@persistmemory/cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -342,7 +342,7 @@ var SignalFired = class extends Error {
 };
 function untilAborted(work, signal) {
   work.catch(() => void 0);
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve7, reject) => {
     if (signal.aborted) {
       reject(new SignalFired());
       return;
@@ -352,7 +352,7 @@ function untilAborted(work, signal) {
     work.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve5(value);
+        resolve7(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -362,14 +362,14 @@ function untilAborted(work, signal) {
   });
 }
 function defaultSleep(ms, signal) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve7, reject) => {
     if (signal?.aborted) {
       reject(new AbortError());
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve5();
+      resolve7();
     }, ms);
     function onAbort() {
       clearTimeout(timer);
@@ -556,6 +556,58 @@ var Spaces = class {
   async create(params, options) {
     return this.#http.post("/api/v1/spaces", params, options);
   }
+  /**
+   * Deletes a Space. You must say what happens to what is in it.
+   *
+   * There is no default, here or in the API, and that is deliberate: "delete
+   * this Space" means the label to some people and everything inside it to
+   * others, and a client that guessed would destroy or keep somebody's
+   * material without being asked.
+   *
+   * `delete` never destroys a memory that is filed in another Space as well —
+   * that one is detached and left alone. `deleted` and `kept` come back so you
+   * can say what actually happened.
+   */
+  async delete(id, params, options) {
+    return this.#http.delete(
+      `/api/v1/spaces/${encodeURIComponent(id)}`,
+      params,
+      options
+    );
+  }
+  /**
+   * Merges Spaces into a NEW one, leaving every source exactly as it was.
+   *
+   * Additive, not destructive: a memory ends up in the sources AND the result,
+   * every existing search over a source returns what it did before, and
+   * undoing it is deleting the Space this returns. A memory in two sources is
+   * filed once.
+   */
+  async merge(params, options) {
+    return this.#http.post(
+      "/api/v1/spaces/merge",
+      params,
+      options
+    );
+  }
+  /**
+   * The Space this account files into when a capture names none.
+   *
+   * `{}` — an object with no `space` — means there is no default, which is the
+   * normal state rather than a gap. It is also what comes back after the Space
+   * somebody chose has been deleted.
+   */
+  async getDefault(options) {
+    return this.#http.get("/api/v1/spaces/default", void 0, options);
+  }
+  /** `null` clears it. Not the same as omitting it, which is why the type says so. */
+  async setDefault(spaceId, options) {
+    return this.#http.patch(
+      "/api/v1/spaces/default",
+      { spaceId },
+      options
+    );
+  }
   /** Renaming, retention, and archiving - `archived` is a field, not a verb. */
   async update(id, params, options) {
     return this.#http.patch(`/api/v1/spaces/${encodeURIComponent(id)}`, params, options);
@@ -918,6 +970,42 @@ var Health = class {
     return this.#http.get("/health/ready", void 0, options);
   }
 };
+var Agent = class {
+  #http;
+  constructor(http) {
+    this.#http = http;
+  }
+  /** The row, including whether it finished and how large the result is. */
+  async request(id, options) {
+    return this.#http.get(
+      `/api/v1/agent/request/${encodeURIComponent(id)}`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * A short-lived link to the bytes of a finished request.
+   *
+   * Returns the URL rather than the file, and that is a deliberate limit of
+   * this package rather than an oversight. The transport under every other
+   * method parses JSON, retries, and attaches the API key; none of those is
+   * right for a hundred-megabyte binary body, and building a second request
+   * path inside the SDK to serve one method is how a client ends up with two
+   * retry policies that differ only during an outage. Fetch the URL with
+   * whatever already streams in your runtime - it needs no credential, which
+   * is the whole reason it is signed.
+   *
+   * Treat the URL as the file. It is a bearer credential for exactly one
+   * object, it expires in minutes, and it should not be logged or stored.
+   */
+  async downloadLink(id, options) {
+    return this.#http.get(
+      `/api/v1/agent/request/${encodeURIComponent(id)}/download`,
+      void 0,
+      options
+    );
+  }
+};
 var PersistMemory = class {
   memories;
   search;
@@ -931,6 +1019,7 @@ var PersistMemory = class {
   conversations;
   integrations;
   health;
+  agent;
   #http;
   constructor(options) {
     this.#http = new HttpClient(options);
@@ -946,6 +1035,7 @@ var PersistMemory = class {
     this.conversations = new Conversations(this.#http);
     this.integrations = new Integrations(this.#http);
     this.health = new Health(this.#http);
+    this.agent = new Agent(this.#http);
   }
   /**
    * An escape hatch for an endpoint this package has not caught up with.
@@ -1287,7 +1377,8 @@ function shortDate(iso) {
 }
 
 // src/help.ts
-var VERSION = "0.1.0";
+var VERSION = "0.1.2";
+var PACKAGE = "@persistmemory/cli";
 var HELP = `
   pm \u2014 PersistMemory from your terminal
 
@@ -1295,7 +1386,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
@@ -1313,6 +1406,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
@@ -1324,6 +1424,11 @@ var HELP = `
 
     status                           is the service healthy
     requests                         file requests waiting for you to approve
+    requests get <id>                write a finished one to a file here
+
+    update                           install the newest version
+    uninstall                        remove pm from this machine
+    delete                           delete every file pm has written here
 
   FLAGS
 
@@ -1332,7 +1437,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
@@ -1343,14 +1448,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";
@@ -1381,8 +1568,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((resolve7, reject) => {
+    resolveCallback = resolve7;
     rejectCallback = reject;
   });
   const server = createServer((request, response) => {
@@ -1408,9 +1595,9 @@ async function startLoopback(options = {}) {
     response.end(donePage(callback));
     resolveCallback?.(callback);
   });
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve7, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", resolve5);
+    server.listen(0, "127.0.0.1", resolve7);
   });
   const address = server.address();
   if (address === null || typeof address === "string") {
@@ -1672,7 +1859,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((resolve7, reject) => {
     const child = spawn(command, args, {
       stdio: "ignore",
       // Detached so closing the terminal does not close the browser, and so
@@ -1681,7 +1868,7 @@ async function openBrowser(url) {
     });
     child.once("error", reject);
     child.unref();
-    resolve5();
+    resolve7();
   });
 }
 async function describe(response) {
@@ -1742,19 +1929,29 @@ async function currentCredential(resolved, deps) {
 
 // src/context.ts
 import { createInterface } from "node:readline";
+async function askOnTty(prompt) {
+  return new Promise((resolve7) => {
+    const readline = createInterface({ input: process.stdin, output: process.stdout });
+    readline.question(prompt, (answer3) => {
+      readline.close();
+      resolve7(answer3.trim());
+    });
+    readline.once("close", () => resolve7(""));
+  });
+}
 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((resolve7) => {
       const readline = createInterface({ input });
       readline.once("line", (line) => {
         readline.close();
-        resolve5(line.trim());
+        resolve7(line.trim());
       });
-      readline.once("close", () => resolve5(""));
+      readline.once("close", () => resolve7(""));
     });
   }
   process.stdout.write(prompt);
@@ -1762,21 +1959,21 @@ async function readSecretFromTty(prompt) {
   input.setRawMode?.(true);
   input.resume();
   input.setEncoding("utf8");
-  return new Promise((resolve5) => {
+  return new Promise((resolve7) => {
     let value = "";
-    const finish = () => {
+    const finish2 = () => {
       input.removeListener("data", onData);
       input.setRawMode?.(previouslyRaw);
       input.pause();
       process.stdout.write("\n");
-      resolve5(value.trim());
+      resolve7(value.trim());
     };
     const onData = (chunk) => {
       for (const character of chunk) {
         switch (character) {
           case "\r":
           case "\n":
-            finish();
+            finish2();
             return;
           case ETX:
             input.setRawMode?.(previouslyRaw);
@@ -1806,12 +2003,12 @@ async function readStdin() {
 // src/commands/agent.ts
 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 { join as join4, resolve as resolve3 } from "node:path";
+import { readFileSync as readFileSync4, readdirSync, 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.`);
@@ -1820,22 +2017,24 @@ var OutsideWorkspace = class extends Error {
 };
 var TooLarge = class extends Error {
   constructor(path, bytes, limit) {
-    super(`${path} is ${Math.round(bytes / 1024)} KB, over the ${Math.round(limit / 1024)} KB limit.`);
+    const say = (value) => value >= 1024 * 1024 ? `${(value / (1024 * 1024)).toFixed(1)} MB` : `${Math.round(value / 1024)} KB`;
+    super(`${path} is ${say(bytes)}, over the ${say(limit)} limit.`);
     this.name = "TooLarge";
   }
 };
 var MAX_READ_BYTES = 512 * 1024;
+var MAX_TRANSFER_BYTES = 100 * 1024 * 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;
   }
@@ -1857,7 +2056,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
   };
 }
@@ -1867,7 +2066,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 {
   }
@@ -1877,21 +2076,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]) {
@@ -1908,7 +2107,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");
 }
@@ -1938,19 +2137,41 @@ async function answer(context, apiUrl, token, roots, request) {
     return { ok: false, error: error instanceof Error ? error.message : "refused" };
   }
   let bytes;
+  let filename = request.path.split("/").pop() ?? "file";
+  if (request.kind === "list_dir") {
+    try {
+      const stats = statSync2(located);
+      if (!stats.isDirectory()) return { ok: false, error: `${request.path} is not a folder.` };
+      const entries = readdirSync(located, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).slice(0, MAX_LISTED).map((entry) => {
+        if (entry.isDirectory()) return `${entry.name}/`;
+        try {
+          return `${entry.name}  ${sizeOf(join4(located, entry.name))}`;
+        } catch {
+          return entry.name;
+        }
+      }).sort();
+      const listing = entries.length > 0 ? entries.join("\n") : "(empty)";
+      bytes = Buffer.from(`${request.path}
+
+${listing}
+`, "utf8");
+      filename = `${request.path.split("/").filter(Boolean).pop() ?? "listing"}.txt`;
+      const grant = await upload(apiUrl, token, filename, bytes);
+      return grant;
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : "could not list it" };
+    }
+  }
   try {
     const stats = statSync2(located);
     if (!stats.isFile()) return { ok: false, error: `${request.path} is not a file.` };
-    if (stats.size > MAX_READ_BYTES) {
-      return {
-        ok: false,
-        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" };
   }
+  return upload(apiUrl, token, filename, bytes);
+}
+async function upload(apiUrl, token, filename, bytes) {
   const grant = await fetch(`${apiUrl}/api/v1/agent/upload-url`, {
     method: "POST",
     headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
@@ -1962,13 +2183,17 @@ async function answer(context, apiUrl, token, roots, request) {
       // No content type is sent: this machine has a path, not a declaration.
       // The server resolves it from the name against the one table that knows
       // which types it can read, and tells us below what it decided.
-      filename: request.path.split("/").pop() ?? "file"
+      filename
     })
   });
   if (!grant.ok) {
     return { ok: false, error: await said(grant, "could not get an upload url") };
   }
-  const { uploadUrl, contentType } = await grant.json();
+  const { uploadUrl, contentType, maxBytes } = await grant.json();
+  const limit = maxBytes ?? MAX_TRANSFER_BYTES;
+  if (bytes.length > limit) {
+    return { ok: false, error: new TooLarge(filename, bytes.length, limit).message };
+  }
   const put = await fetch(uploadUrl, {
     method: "PUT",
     // The type the grant was signed for. Anything else is refused.
@@ -1980,6 +2205,13 @@ async function answer(context, apiUrl, token, roots, request) {
   if (!stored.attachToken) return { ok: false, error: "the upload returned no reference" };
   return { ok: true, attachToken: stored.attachToken, bytes: bytes.length };
 }
+var MAX_LISTED = 200;
+function sizeOf(path) {
+  const size = statSync2(path).size;
+  if (size < 1024) return `${size} B`;
+  if (size < 1024 * 1024) return `${Math.round(size / 1024)} KB`;
+  return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
 async function agentCommand(context) {
   const credential = context.resolved.credential;
   if (!credential) {
@@ -2089,7 +2321,10 @@ async function agentCommand(context) {
 }
 
 // src/commands/requests.ts
+import { existsSync as existsSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
 async function requestsCommand(context) {
+  if (context.args.words[1] === "get") return collectCommand(context);
   const credential = context.resolved.credential;
   if (!credential) {
     context.error("Sign in first: pm auth login");
@@ -2127,6 +2362,218 @@ async function requestsCommand(context) {
   context.print("They cannot be approved from here \u2014 see `pm help requests`.");
   return 0;
 }
+async function collectCommand(context) {
+  const credential = context.resolved.credential;
+  if (!credential) {
+    context.error("Sign in first: pm auth login");
+    return 1;
+  }
+  const id = context.args.words[2];
+  if (!id) {
+    context.error("Which request? `pm requests` lists them with their ids.");
+    return 2;
+  }
+  const apiUrl = context.resolved.apiUrl.replace(/\/+$/, "");
+  const link = await fetch(
+    `${apiUrl}/api/v1/agent/request/${encodeURIComponent(id)}/download`,
+    { headers: { authorization: `Bearer ${credential.token}` } }
+  );
+  if (!link.ok) {
+    const body = await link.json().catch(() => void 0);
+    context.error(body?.error?.message ?? `Could not prepare that file (${link.status}).`);
+    return 1;
+  }
+  const { downloadUrl, filename } = await link.json();
+  const file = await fetch(downloadUrl);
+  if (!file.ok) {
+    context.error(`The download refused it (${file.status}). Links expire in minutes \u2014 try again.`);
+    return 1;
+  }
+  const name = stringFlag(context.args, "output", "o") ?? filename;
+  const target = resolve4(name);
+  if (existsSync4(target)) {
+    context.error(`${target} already exists. Pass --output to write somewhere else.`);
+    return 1;
+  }
+  writeFileSync4(target, new Uint8Array(await file.arrayBuffer()));
+  context.print(`Wrote ${target}`);
+  return 0;
+}
+
+// src/workspace.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname3, join as join5, resolve as resolvePath } from "node:path";
+var WORKSPACE_FILE = ".persistmemory.json";
+function findWorkspace(from = process.cwd()) {
+  let dir = resolvePath(from);
+  for (; ; ) {
+    const file = join5(dir, WORKSPACE_FILE);
+    if (existsSync5(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 = join5(dir, WORKSPACE_FILE);
+  writeFileSync5(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) {
@@ -2179,12 +2626,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);
@@ -2239,18 +2699,110 @@ function message(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// src/commands/maintain.ts
+import { existsSync as existsSync6, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname as dirname4, resolve as resolve6 } 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 (!existsSync6(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 = resolve6(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 resolve6(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 existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join6 } 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 = join6(paths.dir, "sessions");
+  mkdirSync3(directory, { recursive: true, mode: 448 });
+  const path = join6(directory, `${id}.jsonl`);
   return {
     id,
     path,
@@ -2262,8 +2814,8 @@ function openSessionLog(paths, id) {
       }
     },
     read() {
-      if (!existsSync3(path)) return [];
-      return readFileSync4(path, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+      if (!existsSync7(path)) return [];
+      return readFileSync6(path, "utf8").split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
         try {
           return [JSON.parse(line)];
         } catch {
@@ -2340,9 +2892,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((resolve7) => {
+    readline.question(prompt, resolve7);
+    readline.once("close", () => resolve7(void 0));
   });
   const root = process.cwd();
   let running = true;
@@ -2442,7 +2994,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.`);
@@ -2493,7 +3045,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.");
@@ -2526,7 +3078,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 },
@@ -2554,7 +3142,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;
@@ -2569,7 +3157,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(
     {
@@ -2613,7 +3201,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 } : {},
@@ -2650,10 +3238,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) {
@@ -2709,6 +3298,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) {
@@ -2760,7 +3379,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)) {
@@ -2770,16 +3391,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":
@@ -2801,6 +3458,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);