Three things worth building in an afternoon.

#!/usr/bin/env -S node --experimental-strip-types
// did.ts - file a note, or ask what you did.
//
//   ./did.ts "moved the retry queue off Redis, Priya reviewed it"
//   ./did.ts --recall "retry queue"
//   ./did.ts --since 2026-08-01

import { PersistMemory, RateLimitError } from "@persistmemory/sdk";

const client = new PersistMemory({
  apiKey: process.env.PERSISTMEMORY_API_KEY!,
  timeoutMs: 15_000
});

const SPACE = process.env.PM_SPACE_ID ?? "sp_work";

async function file(text: string): Promise<void> {
  const day = new Date().toISOString().slice(0, 10);

  const result = await client.memories.remember(
    { text, spaceIds: [SPACE] },
    // Meaningful, not random. A retry of THIS note must not become a second
    // note, and a different note on the same day must not be swallowed.
    { idempotencyKey: `did:${day}:${text.slice(0, 60)}` }
  );

  // Deliberately not "saved". Extraction, entity resolution and conflict
  // detection all run after this returns, and may produce one memory,
  // several, or none.
  console.log(`queued ${result.jobId}`);
}

async function recall(query: string): Promise<void> {
  const found = await client.search.query({
    query,
    limit: 10,
    spaceIds: [SPACE],
    scope: "space"
  });

  if (found.diagnostics.degraded) {
    // Search answers even with the semantic index stopped. Saying so is the
    // difference between "nothing found" and "found less than usual".
    console.error(found.diagnostics.notice ?? "Searching without the semantic index.");
  }

  for (const { memory, score } of found.results) {
    console.log(`${score.toFixed(2)}  ${memory.title}`);
  }
}

async function since(date: string): Promise<void> {
  // `all` takes a bound on purpose: an unbounded walk on a busy account is
  // minutes of requests.
  const memories = await client.memories
    .list({ spaceIds: [SPACE], scope: "space", createdAfter: `${date}T00:00:00Z` })
    .all(200);

  for (const memory of memories) {
    console.log(`${memory.createdAt.slice(0, 10)}  ${memory.type.padEnd(11)}  ${memory.title}`);
  }
}

const [flag, ...rest] = process.argv.slice(2);
const argument = rest.join(" ");

try {
  if (flag === "--recall") await recall(argument);
  else if (flag === "--since") await since(argument);
  else if (flag) await file([flag, ...rest].join(" "));
  else console.error('usage: did.ts "what you did" | --recall <query> | --since <date>');
} catch (error) {
  if (error instanceof RateLimitError) {
    console.error(`rate limited, retry in ${error.retryAfterSeconds ?? 60}s`);
    process.exit(1);
  }
  throw error;
}

#!/usr/bin/env -S node --experimental-strip-types
// file-notes.ts - put a directory of meeting notes into Spaces.
//
//   ./file-notes.ts ./notes/platform Platform
//
// Files are named YYYY-MM-DD-<topic>.md, which is where the idempotency key
// comes from: re-running the script never files the same meeting twice.

import { readdir, readFile } from "node:fs/promises";
import { basename, join } from "node:path";
import { PersistMemory, NotFoundError } from "@persistmemory/sdk";

const client = new PersistMemory({ apiKey: process.env.PERSISTMEMORY_API_KEY! });

async function spaceNamed(name: string): Promise<string> {
  // Look before creating. Two Spaces called Platform is a state nothing
  // downstream can repair, because neither is wrong.
  for await (const space of client.spaces.list()) {
    if (space.name.toLowerCase() === name.toLowerCase()) return space.id;
  }

  const created = await client.spaces.create(
    { name, kind: "project", description: `Meeting notes for ${name}` },
    // A double-clicked create is the same request twice, and this is the one
    // call where that leaves permanent damage.
    { idempotencyKey: `space:${name.toLowerCase()}` }
  );
  return created.id;
}

async function waitFor(jobId: string): Promise<string> {
  for (let attempt = 0; attempt < 30; attempt += 1) {
    try {
      const job = await client.jobs.get(jobId);
      // `completed` is the terminal success state. Waiting for `succeeded`
      // waits forever.
      if (job.status === "completed" || job.status === "failed") return job.status;
    } catch (error) {
      if (!(error instanceof NotFoundError)) throw error;
      // A job id can be handed back a moment before the row is visible.
    }
    await new Promise((resolve) => setTimeout(resolve, 2_000));
  }
  return "pending";
}

const [directory, projectName] = process.argv.slice(2);
if (!directory || !projectName) {
  console.error("usage: file-notes.ts <directory> <project name>");
  process.exit(1);
}

const spaceId = await spaceNamed(projectName);
const files = (await readdir(directory)).filter((name) => name.endsWith(".md")).sort();

for (const file of files) {
  const text = await readFile(join(directory, file), "utf8");
  const meeting = basename(file, ".md");

  const { jobId } = await client.memories.remember(
    { text, title: `Meeting notes: ${meeting}`, spaceIds: [spaceId] },
    { idempotencyKey: `notes:${projectName}:${meeting}` }
  );

  const status = await waitFor(jobId);
  console.log(`${file.padEnd(34)} ${status}`);
}

// What the pipeline actually made of them, which is the only real receipt.
const decisions = await client.memories
  .list({ spaceIds: [spaceId], scope: "space", type: "decision" })
  .all(100);

console.log(`\n${decisions.length} decisions in ${projectName}:`);
for (const decision of decisions) console.log(`  ${decision.title}`);