@persistmemory/cli 0.1.0 → 0.1.1

package/dist/bin.js

@@ -344,7 +344,7 @@ var SignalFired = class extends Error {
 };
 function untilAborted(work, signal) {
   work.catch(() => void 0);
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     if (signal.aborted) {
       reject(new SignalFired());
       return;
@@ -354,7 +354,7 @@ function untilAborted(work, signal) {
     work.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve5(value);
+        resolve6(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -364,14 +364,14 @@ function untilAborted(work, signal) {
   });
 }
 function defaultSleep(ms, signal) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     if (signal?.aborted) {
       reject(new AbortError());
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve5();
+      resolve6();
     }, ms);
     function onAbort() {
       clearTimeout(timer);
@@ -1289,7 +1289,8 @@ function shortDate(iso) {
 }
 
 // src/help.ts
-var VERSION = "0.1.0";
+var VERSION = "0.1.1";
+var PACKAGE = "@persistmemory/cli";
 var HELP = `
   pm \u2014 PersistMemory from your terminal
 
@@ -1297,7 +1298,9 @@ var HELP = `
 
   GETTING STARTED
 
+    pm setup                         sign in, then pick a Space for this folder
     pm auth login                    sign in with your browser
+    pm auth logout                   sign out on this machine
     pm                               start a session and just ask
     pm remember "we chose Postgres"  capture something
     pm search "what did we choose"   ask for it back
@@ -1315,6 +1318,13 @@ var HELP = `
     chat                             start an interactive session
     chat --resume <id>               pick up an earlier session
 
+    setup                            sign in and choose this folder's Space
+    setup --space "Acme"             choose one without being asked
+    setup --new-space "Acme"         create one and use it
+
+    spaces list                      your Spaces
+    spaces create <name>             make a new one
+
     remember <text>                  capture text
     remember -                       capture whatever is piped in
     remember --file <path>           capture a file's contents
@@ -1327,6 +1337,10 @@ var HELP = `
     status                           is the service healthy
     requests                         file requests waiting for you to approve
 
+    update                           install the newest version
+    uninstall                        remove pm from this machine
+    delete                           delete every file pm has written here
+
   FLAGS
 
     --output table|json|yaml|csv|tsv  how to print (default: table on a
@@ -1334,7 +1348,7 @@ var HELP = `
     --profile <name>                  use a named account
     --api-url <url>                   talk to a different server
     --limit <n>                       how many results
-    --space <a,b>                     restrict to Spaces
+    --space <a,b>                     restrict to Spaces, by name or id
     --quiet                           suppress notices
     --version                         print the version
     --help                            print this
@@ -1345,14 +1359,96 @@ var HELP = `
                                      login. This is what CI should set.
     PERSISTMEMORY_API_URL            the server to talk to
     PERSISTMEMORY_PROFILE            which stored profile to use
+    PERSISTMEMORY_SPACE              Spaces to use when --space is not given
     PERSISTMEMORY_HOME               where config, credentials and session
                                      transcripts live (default: ~/.persistmemory)
     PERSISTMEMORY_CLIENT_ID          override the OAuth client id, for a
                                      self-hosted deployment
+    PERSISTMEMORY_AUTO_UPDATE        update without asking when a newer
+                                     version is published
+    PERSISTMEMORY_NO_UPDATE          never check for updates
 
   Docs: https://persistmemory.com/docs/cli
 `;
 
+// src/update.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+var REGISTRY = "https://registry.npmjs.org/@persistmemory/cli/latest";
+var EVERY_MS = 24 * 60 * 60 * 1e3;
+function updateNotice(deps) {
+  if (!wanted(deps)) return void 0;
+  const cached = read(deps.file);
+  if (!cached) return void 0;
+  if (!isNewer(cached.latest, deps.current)) return void 0;
+  return [
+    `A newer PersistMemory CLI is available: ${deps.current} \u2192 ${cached.latest}`,
+    `Run \`pm update\` to install it.`
+  ].join("\n");
+}
+async function refreshUpdateCache(deps) {
+  if (!wanted(deps)) return;
+  const now = (deps.now ?? Date.now)();
+  const cached = read(deps.file);
+  if (cached && now - cached.checkedAt < EVERY_MS) return;
+  const call = deps.fetch ?? globalThis.fetch;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1500);
+    const response = await call(REGISTRY, {
+      signal: controller.signal,
+      headers: { accept: "application/vnd.npm.install-v1+json" }
+    }).finally(() => clearTimeout(timer));
+    if (!response.ok) return;
+    const body = await response.json();
+    if (typeof body.version !== "string") return;
+    write(deps.file, { checkedAt: now, latest: body.version });
+  } catch {
+  }
+}
+function wanted(deps) {
+  const env = deps.env ?? process.env;
+  if (deps.quiet === true) return false;
+  if (deps.isTty === false) return false;
+  if (env["PERSISTMEMORY_NO_UPDATE"]) return false;
+  if (env["CI"]) return false;
+  return true;
+}
+function read(file) {
+  try {
+    if (!existsSync2(file)) return void 0;
+    const parsed = JSON.parse(readFileSync2(file, "utf8"));
+    if (typeof parsed.checkedAt !== "number" || typeof parsed.latest !== "string") {
+      return void 0;
+    }
+    return { checkedAt: parsed.checkedAt, latest: parsed.latest };
+  } catch {
+    return void 0;
+  }
+}
+function write(file, value) {
+  try {
+    mkdirSync2(dirname(file), { recursive: true });
+    writeFileSync2(file, JSON.stringify(value), "utf8");
+  } catch {
+  }
+}
+function isNewer(candidate, current) {
+  if (candidate.includes("-") || current.includes("-")) return false;
+  const a = candidate.split(".").map(Number);
+  const b = current.split(".").map(Number);
+  if (a.some(Number.isNaN) || b.some(Number.isNaN)) return false;
+  for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+    const left = a[index] ?? 0;
+    const right = b[index] ?? 0;
+    if (left !== right) return left > right;
+  }
+  return false;
+}
+function updateCacheFile(home) {
+  return join2(home, "update-check.json");
+}
+
 // src/auth/oauth.ts
 import { spawn } from "node:child_process";
 import { timingSafeEqual } from "node:crypto";
@@ -1383,8 +1479,8 @@ async function startLoopback(options = {}) {
   const timeoutMs = options.timeoutMs ?? 5 * 60 * 1e3;
   let resolveCallback;
   let rejectCallback;
-  const received = new Promise((resolve5, reject) => {
-    resolveCallback = resolve5;
+  const received = new Promise((resolve6, reject) => {
+    resolveCallback = resolve6;
     rejectCallback = reject;
   });
   const server = createServer((request, response) => {
@@ -1410,9 +1506,9 @@ async function startLoopback(options = {}) {
     response.end(donePage(callback));
     resolveCallback?.(callback);
   });
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", resolve5);
+    server.listen(0, "127.0.0.1", resolve6);
   });
   const address = server.address();
   if (address === null || typeof address === "string") {
@@ -1674,7 +1770,7 @@ function safeEqual(a, b) {
 }
 async function openBrowser(url) {
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     const child = spawn(command, args, {
       stdio: "ignore",
       // Detached so closing the terminal does not close the browser, and so
@@ -1683,7 +1779,7 @@ async function openBrowser(url) {
     });
     child.once("error", reject);
     child.unref();
-    resolve5();
+    resolve6();
   });
 }
 async function describe(response) {
@@ -1744,19 +1840,29 @@ async function currentCredential(resolved, deps) {
 
 // src/context.ts
 import { createInterface } from "node:readline";
+async function askOnTty(prompt) {
+  return new Promise((resolve6) => {
+    const readline = createInterface({ input: process.stdin, output: process.stdout });
+    readline.question(prompt, (answer3) => {
+      readline.close();
+      resolve6(answer3.trim());
+    });
+    readline.once("close", () => resolve6(""));
+  });
+}
 var ETX = "";
 var DELETE = "\x7F";
 var BACKSPACE = "\b";
 async function readSecretFromTty(prompt) {
   const input = process.stdin;
   if (!input.isTTY) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const readline = createInterface({ input });
       readline.once("line", (line) => {
         readline.close();
-        resolve5(line.trim());
+        resolve6(line.trim());
       });
-      readline.once("close", () => resolve5(""));
+      readline.once("close", () => resolve6(""));
     });
   }
   process.stdout.write(prompt);
@@ -1764,21 +1870,21 @@ async function readSecretFromTty(prompt) {
   input.setRawMode?.(true);
   input.resume();
   input.setEncoding("utf8");
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let value = "";
-    const finish = () => {
+    const finish2 = () => {
       input.removeListener("data", onData);
       input.setRawMode?.(previouslyRaw);
       input.pause();
       process.stdout.write("\n");
-      resolve5(value.trim());
+      resolve6(value.trim());
     };
     const onData = (chunk) => {
       for (const character of chunk) {
         switch (character) {
           case "\r":
           case "\n":
-            finish();
+            finish2();
             return;
           case ETX:
             input.setRawMode?.(previouslyRaw);
@@ -1809,11 +1915,11 @@ async function readStdin() {
 import { hostname } from "node:os";
 import { homedir as homedir2 } from "node:os";
 import { resolve as resolve3 } from "node:path";
-import { readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
 
 // src/files.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync, statSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname, isAbsolute, join as join2, relative, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync, statSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, isAbsolute, join as join3, relative, resolve as resolve2 } from "node:path";
 var OutsideWorkspace = class extends Error {
   constructor(path) {
     super(`${path} is outside the directory this session was started in.`);
@@ -1830,14 +1936,14 @@ var MAX_READ_BYTES = 512 * 1024;
 function realLocation(absolute) {
   let existing = absolute;
   const trailing = [];
-  while (!existsSync2(existing)) {
-    const parent = dirname(existing);
+  while (!existsSync3(existing)) {
+    const parent = dirname2(existing);
     if (parent === existing) return absolute;
     trailing.unshift(existing.slice(parent.length + 1));
     existing = parent;
   }
   try {
-    return join2(realpathSync(existing), ...trailing);
+    return join3(realpathSync(existing), ...trailing);
   } catch {
     return absolute;
   }
@@ -1859,7 +1965,7 @@ function readWithin(root, path) {
   if (stats.size > MAX_READ_BYTES) throw new TooLarge(path, stats.size, MAX_READ_BYTES);
   return {
     path: absolute,
-    text: readFileSync2(absolute, "utf8"),
+    text: readFileSync3(absolute, "utf8"),
     bytes: stats.size
   };
 }
@@ -1869,7 +1975,7 @@ function proposeWrite(root, path, contents) {
   try {
     const stats = statSync(absolute);
     if (stats.isFile() && stats.size <= MAX_READ_BYTES) {
-      existing = readFileSync2(absolute, "utf8");
+      existing = readFileSync3(absolute, "utf8");
     }
   } catch {
   }
@@ -1879,21 +1985,21 @@ function proposeWrite(root, path, contents) {
     ...existing !== void 0 ? { existing } : {}
   };
 }
-function commitWrite(write2, confirmed) {
+function commitWrite(write3, confirmed) {
   if (!confirmed) throw new Error("refusing to write without confirmation");
-  writeFileSync2(write2.path, write2.contents, "utf8");
+  writeFileSync3(write3.path, write3.contents, "utf8");
 }
-function summarise(write2, maxLines = 40) {
-  if (write2.existing === void 0) {
-    const lines = write2.contents.split("\n");
+function summarise(write3, maxLines = 40) {
+  if (write3.existing === void 0) {
+    const lines = write3.contents.split("\n");
     const head = lines.slice(0, maxLines).map((line) => `+ ${line}`);
     if (lines.length > maxLines) head.push(`  \u2026 ${lines.length - maxLines} more lines`);
-    return `create ${write2.path} (${lines.length} lines)
+    return `create ${write3.path} (${lines.length} lines)
 ${head.join("\n")}`;
   }
-  if (write2.existing === write2.contents) return `${write2.path} is already exactly this.`;
-  const before = write2.existing.split("\n");
-  const after = write2.contents.split("\n");
+  if (write3.existing === write3.contents) return `${write3.path} is already exactly this.`;
+  const before = write3.existing.split("\n");
+  const after = write3.contents.split("\n");
   const changes = [];
   let start = 0;
   while (start < before.length && start < after.length && before[start] === after[start]) {
@@ -1910,7 +2016,7 @@ ${head.join("\n")}`;
   for (const line of added.slice(0, maxLines)) changes.push(`+ ${line}`);
   if (added.length > maxLines) changes.push(`  \u2026 ${added.length - maxLines} more added`);
   return [
-    `edit ${write2.path} (line ${start + 1}: -${removed.length} +${added.length})`,
+    `edit ${write3.path} (line ${start + 1}: -${removed.length} +${added.length})`,
     ...changes
   ].join("\n");
 }
@@ -1949,7 +2055,7 @@ async function answer(context, apiUrl, token, roots, request) {
         error: new TooLarge(request.path, stats.size, MAX_READ_BYTES).message
       };
     }
-    bytes = readFileSync3(located);
+    bytes = readFileSync4(located);
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : "could not read it" };
   }
@@ -2130,6 +2236,181 @@ async function requestsCommand(context) {
   return 0;
 }
 
+// src/workspace.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname3, join as join4, resolve as resolvePath } from "node:path";
+var WORKSPACE_FILE = ".persistmemory.json";
+function findWorkspace(from = process.cwd()) {
+  let dir = resolvePath(from);
+  for (; ; ) {
+    const file = join4(dir, WORKSPACE_FILE);
+    if (existsSync4(file)) {
+      const config = readWorkspace(file);
+      if (config) return { file, dir, config };
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function readWorkspace(file) {
+  try {
+    const parsed = JSON.parse(readFileSync5(file, "utf8"));
+    const space = parsed.space;
+    if (space && typeof space === "object" && typeof space.id === "string" && space.id !== "" && typeof space.name === "string") {
+      return { space: { id: space.id, name: space.name } };
+    }
+    return {};
+  } catch {
+    return void 0;
+  }
+}
+function writeWorkspace(dir, config) {
+  const file = join4(dir, WORKSPACE_FILE);
+  writeFileSync4(file, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return file;
+}
+
+// src/commands/setup.ts
+async function setupCommand(context) {
+  const { print, error } = context;
+  print("");
+  print("  PersistMemory setup");
+  print("");
+  if (!context.resolved.credential) {
+    print("  You are not signed in yet. Opening your browser.");
+    print("");
+    const code = await login(context);
+    if (code !== 0) {
+      error("Setup stopped: signing in did not finish.");
+      return code;
+    }
+  } else {
+    const how = context.resolved.credential.kind === "api-key" ? "an API key" : "your browser sign-in";
+    print(`  Already signed in to ${context.resolved.apiUrl} with ${how}.`);
+  }
+  let client;
+  let spaces;
+  try {
+    client = await context.client();
+    const page = await client.spaces.list({ limit: 200 }).first();
+    spaces = page.data;
+  } catch (caught) {
+    error(
+      `Signed in, but the server would not answer: ${caught instanceof Error ? caught.message : String(caught)}`
+    );
+    error("Run `pm auth login` to sign in again.");
+    return 1;
+  }
+  print("  Signed in and the server answered. \u2713");
+  print("");
+  return chooseSpace(context, client, spaces);
+}
+async function chooseSpace(context, client, spaces) {
+  const { print, error } = context;
+  const found = findWorkspace();
+  const current = found?.config.space;
+  const named = stringFlag(context.args, "space");
+  const creating = stringFlag(context.args, "new-space");
+  if (creating !== void 0) {
+    const space = await create(client, creating);
+    return finish(context, space, current);
+  }
+  if (named !== void 0) {
+    const match = byName(spaces, named);
+    if (!match) {
+      error(`No Space called "${named}". Use --new-space to create it.`);
+      return 1;
+    }
+    return finish(context, match, current);
+  }
+  const interactive = context.args.flags["yes"] !== true && context.isTty;
+  if (!interactive) {
+    print("  No Space chosen. Memories will go to your account's default.");
+    print(`  Pass --space "<name>" or --new-space "<name>" to pick one.`);
+    return 0;
+  }
+  if (current) {
+    print(`  This folder currently uses the Space "${current.name}".`);
+    print("");
+  }
+  print("  Which Space should this folder use?");
+  print("");
+  spaces.forEach((space, index) => {
+    const mark = current?.id === space.id ? " (current)" : "";
+    const count = space.memoryCount === void 0 ? "" : `, ${space.memoryCount} memories`;
+    print(`    ${index + 1}. ${space.name}${mark}  ${space.kind}${count}`);
+  });
+  const createIndex = spaces.length + 1;
+  const noneIndex = spaces.length + 2;
+  print(`    ${createIndex}. Create a new Space`);
+  print(`    ${noneIndex}. No Space \u2014 use everything in my account`);
+  print("");
+  const fallback = current ? "keep the current one" : String(createIndex);
+  const answer3 = await context.ask(`  Choose 1-${noneIndex} [${fallback}]: `);
+  if (answer3 === "") {
+    if (current) {
+      print("");
+      print(`  Keeping "${current.name}".`);
+      return 0;
+    }
+    return finish(context, await askForNewSpace(context, client), current);
+  }
+  const choice = Number(answer3);
+  if (!Number.isInteger(choice) || choice < 1 || choice > noneIndex) {
+    error(`"${answer3}" is not one of the choices. Nothing was changed.`);
+    return 2;
+  }
+  if (choice === noneIndex) {
+    if (found) {
+      writeWorkspace(found.dir, {});
+      print("");
+      print(`  Cleared the Space in ${WORKSPACE_FILE}. This folder now uses everything.`);
+    } else {
+      print("");
+      print("  No Space. This folder uses everything in your account.");
+    }
+    return 0;
+  }
+  if (choice === createIndex) {
+    return finish(context, await askForNewSpace(context, client), current);
+  }
+  return finish(context, spaces[choice - 1], current);
+}
+async function askForNewSpace(context, client) {
+  for (; ; ) {
+    const name = await context.ask("  Name for the new Space: ");
+    if (name !== "") return create(client, name);
+    context.print("  A Space needs a name.");
+  }
+}
+async function create(client, name) {
+  return client.spaces.create({ name, kind: "project" });
+}
+function byName(spaces, name) {
+  const wanted2 = name.trim().toLowerCase();
+  return spaces.find((one) => one.name.trim().toLowerCase() === wanted2) ?? spaces.find((one) => one.id === name);
+}
+function finish(context, space, previous) {
+  const file = writeWorkspace(process.cwd(), {
+    space: { id: space.id, name: space.name }
+  });
+  context.print("");
+  context.print(`  This folder now uses the Space "${space.name}".`);
+  if (previous && previous.id !== space.id) {
+    context.print(`  It used to use "${previous.name}". Existing memories were not moved.`);
+  }
+  context.print(`  Saved to ${file}`);
+  context.print("");
+  context.print("  Try it:");
+  context.print("");
+  context.print('    pm remember "we chose Postgres for the ledger"');
+  context.print('    pm search "what did we choose"');
+  context.print("");
+  return 0;
+}
+
 // src/commands/auth.ts
 async function authCommand(context) {
   const action = context.args.words[1] ?? "status";
@@ -2181,12 +2462,25 @@ async function login(context) {
     });
     context.print(`
 Signed in to ${apiUrl} as profile "${profile}".`);
-    return 0;
+    if (context.args.flags["no-setup"] === true || !context.isTty) return 0;
+    return continueToSpace(context);
   } catch (error) {
     context.error(message(error));
     return 1;
   }
 }
+async function continueToSpace(context) {
+  try {
+    const client = await context.client();
+    const { data } = await client.spaces.list({ limit: 200 }).first();
+    return await chooseSpace(context, client, data);
+  } catch (caught) {
+    context.print("");
+    context.print(`Could not load your Spaces: ${message(caught)}`);
+    context.print("You are signed in. Run `pm setup` to choose a Space.");
+    return 0;
+  }
+}
 function logout(context) {
   const profile = context.flags.profile ?? context.resolved.profile;
   const forgotten = clearLogin(context.paths, profile);
@@ -2241,18 +2535,110 @@ function message(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// src/commands/maintain.ts
+import { existsSync as existsSync5, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname as dirname4, resolve as resolve5 } from "node:path";
+import { fileURLToPath } from "node:url";
+async function updateCommand(context) {
+  const manager = installer();
+  if (!manager) {
+    context.error(
+      "This copy was not installed by npm, so `pm update` cannot replace it.\nRe-run the installer: curl -fsSL https://persistmemory.com/install.sh | sh"
+    );
+    return 1;
+  }
+  context.print(`Installing the newest ${PACKAGE}\u2026`);
+  const result = spawnSync(manager, ["install", "-g", `${PACKAGE}@latest`], {
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    context.error(
+      "That did not work. If it failed on permissions, do NOT re-run it with sudo \u2014\npoint npm at a directory you own instead:\n  npm config set prefix ~/.npm-global\n  export PATH=$HOME/.npm-global/bin:$PATH"
+    );
+    return result.status ?? 1;
+  }
+  context.print("Done. `pm --version` will show the new one.");
+  return 0;
+}
+async function uninstallCommand(context) {
+  const manager = installer();
+  if (!manager) {
+    context.error(
+      `This copy was not installed by npm, so it cannot uninstall itself.
+Delete the file it runs from: ${processPath()}`
+    );
+    return 1;
+  }
+  const alsoData = context.args.flags["purge"] === true || (context.isTty ? /^y(es)?$/i.test(
+    await context.ask(`Also delete your credentials and settings in ${context.paths.dir}? [y/N] `)
+  ) : false);
+  const result = spawnSync(manager, ["uninstall", "-g", PACKAGE], { stdio: "inherit" });
+  if (result.status !== 0) return result.status ?? 1;
+  if (alsoData) removeEverything(context);
+  context.print("Removed. Your memories are untouched \u2014 this only removed the program.");
+  return 0;
+}
+async function deleteCommand(context) {
+  if (!existsSync5(context.paths.dir)) {
+    context.print(`Nothing to delete: ${context.paths.dir} does not exist.`);
+    return 0;
+  }
+  if (context.args.flags["yes"] !== true) {
+    if (!context.isTty) {
+      context.error("Refusing to delete without confirmation. Pass --yes.");
+      return 2;
+    }
+    context.print("");
+    context.print(`This deletes everything in ${context.paths.dir}:`);
+    context.print("  \u2022 the credential you signed in with");
+    context.print("  \u2022 your profiles and settings");
+    context.print("  \u2022 transcripts of your `pm` sessions");
+    context.print("");
+    context.print("Your account and your memories are NOT touched. To delete those,");
+    context.print("go to https://persistmemory.com/settings.");
+    context.print("");
+    const answer3 = await context.ask("Type 'delete' to confirm: ");
+    if (answer3.trim().toLowerCase() !== "delete") {
+      context.print("Nothing was deleted.");
+      return 1;
+    }
+  }
+  removeEverything(context);
+  context.print(`Deleted ${context.paths.dir}.`);
+  return 0;
+}
+function removeEverything(context) {
+  const dir = resolve5(context.paths.dir);
+  if (dir === "/" || dir.split("/").filter(Boolean).length < 2) {
+    context.error(`Refusing to delete ${dir}: that does not look like a data directory.`);
+    return;
+  }
+  rmSync(dir, { recursive: true, force: true });
+}
+function installer() {
+  return processPath().includes(`node_modules`) ? "npm" : void 0;
+}
+function processPath() {
+  try {
+    return resolve5(dirname4(fileURLToPath(import.meta.url)));
+  } catch {
+    return process.argv[1] ?? "";
+  }
+}
+
 // src/commands/session.ts
 import { createInterface as createInterface2 } from "node:readline";
 import { randomUUID } from "node:crypto";
 import { relative as relative2 } from "node:path";
 
 // src/events.ts
-import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "node:fs";
-import { join as join3 } from "node:path";
+import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join5 } from "node:path";
 function openSessionLog(paths, id) {
-  const directory = join3(paths.dir, "sessions");
-  mkdirSync2(directory, { recursive: true, mode: 448 });
-  const path = join3(directory, `${id}.jsonl`);
+  const directory = join5(paths.dir, "sessions");
+  mkdirSync3(directory, { recursive: true, mode: 448 });
+  const path = join5(directory, `${id}.jsonl`);
   return {
     id,
     path,
@@ -2264,8 +2650,8 @@ function openSessionLog(paths, id) {
       }
     },
     read() {
-      if (!existsSync3(path)) return [];
-      return readFileSync4(path, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+      if (!existsSync6(path)) return [];
+      return readFileSync6(path, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
         try {
           return [JSON.parse(line)];
         } catch {
@@ -2342,9 +2728,9 @@ async function sessionCommand(context) {
   context.print(`  Ask anything. /help for commands, /exit to leave.
 `);
   const readline = createInterface2({ input: process.stdin, output: process.stdout });
-  const ask = (prompt) => new Promise((resolve5) => {
-    readline.question(prompt, resolve5);
-    readline.once("close", () => resolve5(void 0));
+  const ask = (prompt) => new Promise((resolve6) => {
+    readline.question(prompt, resolve6);
+    readline.once("close", () => resolve6(void 0));
   });
   const root = process.cwd();
   let running = true;
@@ -2444,7 +2830,7 @@ async function handleInput(args) {
       return true;
     }
     case "write":
-      await write({ ...args, path: argument });
+      await write2({ ...args, path: argument });
       return true;
     default:
       context.error(`  Unknown command /${command ?? ""}. Try /help.`);
@@ -2495,7 +2881,7 @@ ${reply}
     context.error("  Note: answered without the semantic index, so this may be narrower than usual.");
   }
 }
-async function write(args) {
+async function write2(args) {
   const { context, state, log, root } = args;
   if (!args.path) {
     context.error("  /write needs a path.");
@@ -2528,7 +2914,43 @@ async function write(args) {
 }
 
 // src/commands/memory.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
+
+// src/spaces.ts
+async function spacesFor(context, client, env = process.env) {
+  const asked = listFlag(context.args, "space", "spaces") ?? splitList(env["PERSISTMEMORY_SPACE"]) ?? workspaceSpace();
+  if (!asked || asked.length === 0) return void 0;
+  if (asked.every(looksLikeId)) return asked;
+  const { data } = await client.spaces.list({ limit: 200 }).first();
+  return asked.map((one) => looksLikeId(one) ? one : resolveName(one, data));
+}
+function workspaceSpace() {
+  const found = findWorkspace();
+  return found?.config.space ? [found.config.space.id] : void 0;
+}
+function splitList(raw) {
+  if (!raw) return void 0;
+  const items = raw.split(",").map((one) => one.trim()).filter((one) => one.length > 0);
+  return items.length > 0 ? items : void 0;
+}
+function looksLikeId(value) {
+  return value.startsWith("space_");
+}
+function resolveName(name, spaces) {
+  const wanted2 = name.trim().toLowerCase();
+  const matches = spaces.filter((one) => one.name.trim().toLowerCase() === wanted2);
+  if (matches.length === 1) return matches[0].id;
+  if (matches.length === 0) {
+    throw new Error(
+      `No Space called "${name}". Run \`pm list spaces\` to see yours, or \`pm spaces create "${name}"\` to make it.`
+    );
+  }
+  throw new Error(
+    `More than one Space is called "${name}": ${matches.map((one) => one.id).join(", ")}. Name it by id.`
+  );
+}
+
+// src/commands/memory.ts
 var memoryColumns = [
   { header: "id", value: (m) => m.id },
   { header: "type", value: (m) => m.type },
@@ -2556,7 +2978,7 @@ async function rememberCommand(context) {
   let text;
   if (file) {
     try {
-      text = readFileSync5(file, "utf8");
+      text = readFileSync7(file, "utf8");
     } catch {
       context.error(`Could not read ${file}.`);
       return 1;
@@ -2571,7 +2993,7 @@ async function rememberCommand(context) {
     return 2;
   }
   const client = await context.client();
-  const spaceIds = listFlag(context.args, "space", "spaces");
+  const spaceIds = await spacesFor(context, client);
   const title = stringFlag(context.args, "title");
   const result = await client.memories.remember(
     {
@@ -2615,7 +3037,7 @@ async function searchCommand(context) {
     return 2;
   }
   const client = await context.client();
-  const spaceIds = listFlag(context.args, "space", "spaces");
+  const spaceIds = await spacesFor(context, client);
   const response = await client.search.query({
     query,
     ...limit !== void 0 ? { limit } : {},
@@ -2652,10 +3074,11 @@ async function listMemoriesCommand(context) {
     return 2;
   }
   const client = await context.client();
+  const spaceIds = await spacesFor(context, client);
   const page = client.memories.list({
     ...limit !== void 0 ? { limit } : {},
     ...listFlag(context.args, "type") ? { type: listFlag(context.args, "type") } : {},
-    ...listFlag(context.args, "space", "spaces") ? { spaceIds: listFlag(context.args, "space", "spaces") } : {}
+    ...spaceIds ? { spaceIds: [...spaceIds] } : {}
   });
   const rows = context.args.flags["all"] ? await page.all(limit ?? 1e3) : (await page.first()).data;
   if (rows.length === 0) {
@@ -2711,6 +3134,36 @@ function hash(text) {
   }
   return value.toString(16).padStart(8, "0");
 }
+async function createSpaceCommand(context) {
+  const name = context.args.words.slice(2).join(" ").trim();
+  if (name === "") {
+    context.error('A Space needs a name. Try `pm spaces create "Acme"`.');
+    return 2;
+  }
+  const kind = stringFlag(context.args, "kind") ?? "project";
+  const description = stringFlag(context.args, "description");
+  const client = await context.client();
+  const space = await client.spaces.create({
+    name,
+    kind,
+    ...description ? { description } : {}
+  });
+  if (context.flags.output !== "table") {
+    context.print(renderOne(space, spaceFields, { format: context.flags.output }));
+    return 0;
+  }
+  context.print(`Created "${space.name}".`);
+  context.print(`  id    ${space.id}`);
+  context.print(`  kind  ${space.kind}`);
+  context.print("");
+  context.print(`Use it here with:  pm setup --space "${space.name}"`);
+  return 0;
+}
+var spaceFields = [
+  { header: "id", value: (s) => s.id },
+  { header: "name", value: (s) => s.name },
+  { header: "kind", value: (s) => s.kind }
+];
 
 // src/index.ts
 async function run(deps) {
@@ -2762,7 +3215,9 @@ async function run(deps) {
     client: () => clientFor(resolved, session),
     print,
     error,
-    readSecret: deps.readSecret ?? readSecretFromTty
+    readSecret: deps.readSecret ?? readSecretFromTty,
+    ask: deps.ask ?? askOnTty,
+    isTty: deps.isTty ?? process.stdin.isTTY ?? false
   };
   if (args.words.length === 0) {
     if (!(deps.isTty ?? process.stdin.isTTY ?? false)) {
@@ -2772,16 +3227,52 @@ async function run(deps) {
     return sessionCommand(context);
   }
   try {
-    return await dispatch(context);
+    await offerUpdate(context, deps);
+    const code = await dispatch(context);
+    void refreshUpdateCache(updateDeps(context, deps));
+    return code;
   } catch (caught) {
     return report(caught, error);
   }
 }
+async function offerUpdate(context, deps) {
+  const verb = context.args.words[0];
+  if (verb === "update" || verb === "upgrade" || verb === "uninstall") return;
+  const notice = updateNotice(updateDeps(context, deps));
+  if (!notice) return;
+  const env = deps.env ?? process.env;
+  if (env["PERSISTMEMORY_AUTO_UPDATE"]) {
+    context.print(notice.split("\n")[0] ?? "");
+    await updateCommand(context);
+    return;
+  }
+  context.error(notice);
+}
+function updateDeps(context, deps) {
+  return {
+    file: updateCacheFile(context.paths.dir),
+    current: VERSION,
+    ...deps.fetch ? { fetch: deps.fetch } : {},
+    ...deps.env ? { env: deps.env } : {},
+    isTty: context.isTty,
+    quiet: context.flags.quiet
+  };
+}
 async function dispatch(context) {
   const [verb, noun] = context.args.words;
   switch (verb) {
     case "auth":
       return authCommand(context);
+    case "setup":
+    case "init":
+      return setupCommand(context);
+    case "update":
+    case "upgrade":
+      return updateCommand(context);
+    case "uninstall":
+      return uninstallCommand(context);
+    case "delete":
+      return deleteCommand(context);
     case "agent":
       return agentCommand(context);
     case "chat":
@@ -2803,6 +3294,12 @@ async function dispatch(context) {
      * a consistent grammar is what lets a tool grow past the handful of
      * commands anybody can memorise.
      */
+    case "spaces":
+    case "space":
+      if (noun === "create" || noun === "new") return createSpaceCommand(context);
+      if (noun === void 0 || noun === "list") return listSpacesCommand(context);
+      context.error(`Cannot "pm spaces ${noun}". Try list or create.`);
+      return 2;
     case "list":
       if (noun === "memories" || noun === "memory") return listMemoriesCommand(context);
       if (noun === "spaces" || noun === "space") return listSpacesCommand(context);