@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.2

package/dist/chunk-NE2W3OO7.js

@@ -0,0 +1,230 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  renderTaskContext,
+  taskContext
+} from "./chunk-CKSITVS4.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-3HI6Z55Y.js";
+import {
+  changeFolder,
+  changeStore
+} from "./chunk-XY3P7JW7.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import {
+  attachToChange
+} from "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  changesRelOf,
+  inputsDirOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/attach-commands.js
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join, relative, resolve, sep } from "node:path";
+var sha256 = (b) => createHash("sha256").update(b).digest("hex");
+async function filesUnder(dir) {
+  const out = [];
+  const walk = async (d) => {
+    for (const e of await readdir(d, { withFileTypes: true }).catch(() => []))
+      if (e.isDirectory())
+        await walk(join(d, e.name));
+      else if (e.isFile())
+        out.push(join(d, e.name));
+  };
+  await walk(dir);
+  return out;
+}
+async function metarepoInputs(root) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of await filesUnder(inputsDirOf(root)))
+    out.set(sha256(new Uint8Array(await readFile(f))), relative(root, f).split(sep).join("/"));
+  return out;
+}
+var AttachError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AttachError";
+  }
+};
+async function attachFiles(root, change, files, by, now = /* @__PURE__ */ new Date(), replaces) {
+  const c = await changeStore(root).read(change).catch(() => {
+    throw new AttachError("not-found", `There is no change ${change}: atticus change list shows them.`);
+  });
+  const known = await metarepoInputs(root);
+  return attachToChange(changeFolder(root, c.id), files, {
+    by,
+    at: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+    elsewhere: (h) => known.get(h),
+    ...replaces ? { replaces } : {}
+  });
+}
+async function promoteChangeInput(root, change, file) {
+  const c = await changeStore(root).read(change).catch(() => {
+    throw new AttachError("not-found", `There is no change ${change}: atticus change list shows them.`);
+  });
+  const name = file.replace(/^inputs\//, "");
+  if (!name || /[\\/]/.test(name) || name === "." || name === "..")
+    throw new AttachError("invalid", `Name one attached file, such as inputs/${basename(file) || "rules.pdf"}.`);
+  let bytes;
+  try {
+    bytes = new Uint8Array(await readFile(join(changeFolder(root, c.id), "inputs", name)));
+  } catch {
+    throw new AttachError("not-found", `inputs/${name} isn't attached to ${c.id}: atticus change attach ${c.id} adds it.`);
+  }
+  const { addToInbox } = await import("./chunk-W3BQAZ3Q.js");
+  const r = await addToInbox(root, [{ name, bytes }]);
+  const added = r.added[0];
+  if (!added)
+    throw new AttachError("invalid", `inputs/${name}: ${r.refused[0]?.why ?? "refused"}`);
+  return {
+    path: added.path,
+    note: `Copied to ${added.path}: general knowledge, read at the next atticus sources sync. ${c.id} keeps its copy. Commit both through a pull request.`
+  };
+}
+function attachedLine(rel, a) {
+  const what = a.read === "text" ? `${a.kind}, ${a.format}; read, cited by ${a.citeBy}` : a.kind === "image" ? "a picture: your assistant looks at it in the chat; Atticus doesn't read pictures" : `${a.format}: no reader takes it, so the steps name it without its text`;
+  return `Attached ${rel}/${a.path} (${what})${a.supersedes ? `, a newer version of ${a.supersedes}` : ""}${a.defences ? `; the defences found ${a.defences.risk} risk` : ""}.`;
+}
+async function changeAttachCli(root, change, paths, o, io) {
+  if (change && o.prototype) {
+    if (paths.length) {
+      const { PROTOTYPE_CLI_WORDS } = await import("./chunk-Q4D5X7QB.js");
+      io.err(PROTOTYPE_CLI_WORDS.usage(change, o.prototype));
+      return 2;
+    }
+    const { attachPrototype } = await import("./chunk-Q4D5X7QB.js");
+    return attachPrototype(root, change, o.prototype, { by: o.by, ...o.json ? { json: true } : {}, ...o.now ? { now: o.now } : {} }, io);
+  }
+  if (change && o.like) {
+    if (paths.length) {
+      io.err("--like names an archived change, attached on its own: atticus change attach add-refund-window --like raise-transfer-limit");
+      return 2;
+    }
+    const { attachPastChange, findPastChange } = await import("./chunk-HVUPKCGJ.js");
+    const folder = await findPastChange(root, o.like);
+    if (!folder) {
+      io.err(`There is no archived change ${o.like}: atticus change similar "<what it is about>" lists them.`);
+      return 1;
+    }
+    try {
+      const name = await attachPastChange(root, change, folder, o.by, o.now);
+      io.out(`Attached ${folder} as inputs/${name}: the change's steps read it as an example.`);
+      return 0;
+    } catch (e) {
+      if (e instanceof AttachError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+  }
+  if (change && o.promote) {
+    if (paths.length) {
+      io.err("--promote names one file already attached; attach new files without it, for example: atticus change attach add-refund-window --promote inputs/refund-rules.pdf");
+      return 2;
+    }
+    try {
+      const r2 = await promoteChangeInput(root, change, o.promote);
+      if (o.json)
+        io.out(JSON.stringify(r2, null, 2));
+      else
+        io.out(r2.note);
+      return 0;
+    } catch (e) {
+      if (e instanceof AttachError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+  }
+  if (!change || paths.length === 0) {
+    io.err("Usage: atticus change attach <change> <files...>, for example: atticus change attach add-refund-window refund-rules.pdf");
+    return 2;
+  }
+  if (o.replaces && paths.length !== 1) {
+    io.err("--replaces names the one attached file that the file given replaces: attach one file with it, for example: atticus change attach add-refund-window refund-rules-v2.pdf --replaces inputs/refund-rules-v1.pdf");
+    return 2;
+  }
+  const files = [];
+  let problems = false;
+  for (const p of paths) {
+    try {
+      files.push({ name: basename(p), bytes: new Uint8Array(await readFile(resolve(p))) });
+    } catch {
+      io.err(`Can't read ${p}.`);
+      problems = true;
+    }
+  }
+  let r;
+  try {
+    r = await attachFiles(root, change, files, o.by, o.now, o.replaces);
+  } catch (e) {
+    if (e instanceof AttachError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(r, null, 2));
+    return r.refused.length || problems ? 1 : 0;
+  }
+  const rel = `${changesRelOf(root)}/${change}`;
+  for (const a of r.added)
+    io.out(attachedLine(rel, a));
+  for (const x of r.refused)
+    io.err(`${x.name}: not attached. ${x.why}`);
+  for (const n of r.notes)
+    io.out(n);
+  if (r.added.length)
+    io.out(`The change's steps read them as data, citing each by file and line or page: atticus next says which step is next. Commit ${rel}/inputs/ with the change.`);
+  return r.refused.length || problems ? 1 : 0;
+}
+async function taskContextCli(root, change, task, o, io) {
+  if (!change || !task) {
+    io.err("Usage: atticus task context <change> <task> [--json|--markdown], for example: atticus task context add-refund-window 1.2");
+    return 2;
+  }
+  try {
+    const command = `atticus task context ${change} ${task}`;
+    const c = await taskContext(root, change, task, {
+      ask: { command, rerun: command, at: (o.now ?? /* @__PURE__ */ new Date()).toISOString() }
+    });
+    io.out(o.json && !o.markdown ? JSON.stringify(c, null, 2) : renderTaskContext(c).trimEnd());
+    return 0;
+  } catch (e) {
+    if (e instanceof Error && ["PlannerError", "ChangeError", "ChangeFileError"].includes(e.name)) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+}
+export {
+  AttachError,
+  attachFiles,
+  attachedLine,
+  changeAttachCli,
+  promoteChangeInput,
+  taskContextCli
+};

package/dist/chunk-NN2ZQEB4.js

@@ -0,0 +1,38 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  changeEstimateCommand,
+  estimateOf
+} from "./chunk-FHH4I4ZV.js";
+import "./chunk-TDD55CJH.js";
+import "./chunk-BOHJZTEQ.js";
+import "./chunk-MVZVGYXH.js";
+import "./chunk-FITWGOJ2.js";
+import "./chunk-2ANOROX3.js";
+import "./chunk-65NYPGRC.js";
+import "./chunk-CKSITVS4.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-3HI6Z55Y.js";
+import "./chunk-XY3P7JW7.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  changeEstimateCommand,
+  estimateOf
+};

package/dist/chunk-NXFPS2LR.js

@@ -0,0 +1,182 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  runPluginTests
+} from "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-EFHQ3TWP.js";
+import {
+  pluginEntryHash,
+  runTranslator
+} from "./chunk-GQ4N4WKF.js";
+import {
+  SHIPPED_MODEL_PROVIDER_PLUGINS
+} from "./chunk-YEDDOYSC.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  ModelProviderPlugin,
+  ScannerPlugin,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/plugin-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var MODEL_PROVIDERS = "model-providers";
+async function folders(dir) {
+  return (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function load(root, id, io) {
+  const plugins = join(orgPackDirOf(root), "plugins");
+  const asModel = join(plugins, MODEL_PROVIDERS, id);
+  const kind = id !== MODEL_PROVIDERS && existsSync(join(plugins, id, "plugin.yaml")) ? "scanner" : existsSync(join(asModel, "plugin.yaml")) ? "model-provider" : void 0;
+  if (!kind) {
+    const known = [
+      ...(await folders(plugins)).filter((n) => n !== MODEL_PROVIDERS),
+      ...await folders(join(plugins, MODEL_PROVIDERS))
+    ].sort();
+    io.err(`No plugin ${id} in org-pack/plugins/ or org-pack/plugins/${MODEL_PROVIDERS}/. ${known.length ? `Plugins here: ${known.join(", ")}` : "This org pack has no plugins yet."}`);
+    return void 0;
+  }
+  const dir = kind === "scanner" ? join(plugins, id) : asModel;
+  const rel = kind === "scanner" ? `plugins/${id}` : `plugins/${MODEL_PROVIDERS}/${id}`;
+  const file = join(dir, "plugin.yaml");
+  let data;
+  try {
+    data = (0, import_yaml.parse)(await readFile(file, "utf8"));
+  } catch (e) {
+    io.err(`org-pack/${rel}/plugin.yaml isn't valid YAML: ${e.message}`);
+    return void 0;
+  }
+  const r = kind === "scanner" ? ScannerPlugin.safeParse(data) : ModelProviderPlugin.safeParse(data);
+  if (!r.success) {
+    io.err(`org-pack/${rel}/plugin.yaml isn't a valid plugin manifest (contract C6):`);
+    for (const i of r.error.issues)
+      io.err(`  ${i.path.length ? `${i.path.map(String).join(".")}: ` : ""}${i.message}`);
+    return void 0;
+  }
+  if (r.data.id !== id) {
+    io.err(`org-pack/${rel}/plugin.yaml is for ${r.data.id}; keep it in a folder of that name`);
+    return void 0;
+  }
+  let source;
+  try {
+    source = await readFile(join(dir, ...r.data.entry.split("/")), "utf8");
+  } catch {
+    io.err(`Can't read the entry file org-pack/${rel}/${r.data.entry}.`);
+    return void 0;
+  }
+  return kind === "scanner" ? { kind, dir, file, rel, source, manifest: r.data } : { kind, dir, file, rel, source, manifest: r.data };
+}
+async function modelProviderTests(p) {
+  const code = {
+    id: p.manifest.id,
+    version: p.manifest.version,
+    source: p.source,
+    entry: p.manifest.entry,
+    limits: p.manifest.limits
+  };
+  const out = [];
+  for (const name of (await folders(join(p.dir, "test"))).sort()) {
+    const at = join(p.dir, "test", name);
+    const failures = [];
+    for (const [fn, given, wanted] of [
+      ["request", "request.json", "expected-request.json"],
+      ["response", "answer.json", "expected-answer.json"]
+    ]) {
+      if (!existsSync(join(at, given)))
+        continue;
+      try {
+        const arg = JSON.parse(await readFile(join(at, given), "utf8"));
+        const expected = JSON.parse(await readFile(join(at, wanted), "utf8"));
+        const got = await runTranslator(code, fn, arg);
+        if (!isDeepStrictEqual(got, expected))
+          failures.push(`${fn} gave ${JSON.stringify(got)}, but ${wanted} says ${JSON.stringify(expected)}`);
+      } catch (e) {
+        failures.push(`${fn}: ${e.message}`);
+      }
+    }
+    out.push({ name, failures });
+  }
+  return out;
+}
+async function pluginTest(root, id, io) {
+  const p = await load(root, id, io);
+  if (!p)
+    return 1;
+  const results = p.kind === "scanner" ? await runPluginTests(p.dir, p.manifest, p.source) : await modelProviderTests(p);
+  io.out(`Testing plugin ${p.manifest.id} ${p.manifest.version}: ${plural(results.length, "test")}`);
+  if (results.length === 0) {
+    io.out(p.kind === "scanner" ? `No tests. Add test/<case>/repo/ and test/<case>/expected.yaml under org-pack/${p.rel}/; the scan won't use a plugin without them.` : `No tests. Add test/<case>/request.json with expected-request.json, and answer.json with expected-answer.json, under org-pack/${p.rel}/.`);
+    return 1;
+  }
+  for (const r of results) {
+    io.out(`  ${r.failures.length === 0 ? "pass" : "FAIL"}  ${r.name}`);
+    for (const f of r.failures)
+      io.out(`          ${f}`);
+  }
+  const hash = pluginEntryHash(p.source);
+  const user = p.kind === "scanner" ? "the scan" : "model mode";
+  const pin = !p.manifest.sha256 ? `It isn't pinned: once it is reviewed, run atticus plugin pin ${id}.` : p.manifest.sha256 === hash ? `The pin matches ${p.manifest.entry}.` : `${p.manifest.entry} changed since it was pinned: ${user} won't use it until it is reviewed and pinned again.`;
+  const failed = results.filter((r) => r.failures.length > 0).length;
+  if (failed === 0) {
+    io.out(`${plural(results.length, "test")} passed. ${pin}`);
+    return 0;
+  }
+  io.out(`${failed} of ${plural(results.length, "test")} failed. ${pin}`);
+  return 1;
+}
+async function pluginPin(root, id, io) {
+  const p = await load(root, id, io);
+  if (!p)
+    return 1;
+  const hash = pluginEntryHash(p.source);
+  const doc = (0, import_yaml.parseDocument)(await readFile(p.file, "utf8"));
+  doc.set("sha256", hash);
+  await writeFile(p.file, doc.toString({ flowCollectionPadding: false }), "utf8");
+  io.out(`Pinned ${p.manifest.id} ${p.manifest.version}: ${p.manifest.entry} has sha256 ${hash}.`);
+  io.out("Commit plugin.yaml with the code, in the same reviewed change.");
+  return 0;
+}
+async function pluginAdd(root, id, io) {
+  const files = SHIPPED_MODEL_PROVIDER_PLUGINS[id];
+  if (!files) {
+    io.err(`Atticus ships no plugin called ${id}. It ships: ${Object.keys(SHIPPED_MODEL_PROVIDER_PLUGINS).sort().join(", ")}.`);
+    return 2;
+  }
+  const dir = join(orgPackDirOf(root), "plugins", MODEL_PROVIDERS, id);
+  if (existsSync(dir)) {
+    io.err(`org-pack/plugins/${MODEL_PROVIDERS}/${id}/ is already there; Atticus leaves it as it is.`);
+    return 1;
+  }
+  for (const [path, text] of Object.entries(files)) {
+    const to = join(dir, ...path.split("/"));
+    await mkdir(dirname(to), { recursive: true });
+    await writeFile(to, text, "utf8");
+  }
+  io.out(`Added the ${id} model-provider plugin in org-pack/plugins/${MODEL_PROVIDERS}/${id}/.`);
+  io.out(`Review index.js: it only builds each request and reads each answer; Atticus makes the call, to the hosts plugin.yaml names, and adds the key itself.`);
+  io.out(`Then run atticus plugin test ${id}, atticus plugin pin ${id}, and commit the folder through a pull request. Choose it as the model provider on Set up \u203A AI (adapters.model.type: ${id}).`);
+  return 0;
+}
+export {
+  pluginAdd,
+  pluginPin,
+  pluginTest
+};

package/dist/chunk-O3WI5KWW.js

@@ -0,0 +1,31 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  baseClonePath
+} from "./chunk-EFHQ3TWP.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/repo-for.js
+import { stat } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+var isDir = async (p) => !!(await stat(p).catch(() => void 0))?.isDirectory();
+async function repoFor(root, target) {
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const known = op.profiles.flatMap((p) => p.repos?.repos ?? []).find((r) => r.id === target);
+  if (known) {
+    const dir2 = baseClonePath(root, known.id);
+    return await isDir(dir2) ? { id: known.id, dir: dir2 } : void 0;
+  }
+  const dir = resolve(target);
+  return await isDir(dir) ? { id: basename(dir), dir } : void 0;
+}
+
+export {
+  repoFor
+};

package/dist/chunk-OLQJTJJU.js

@@ -0,0 +1,76 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  GitError,
+  IGNORED,
+  WORKSPACE_DIR,
+  WorkspaceFileError,
+  baseClonePath,
+  branchCheckoutPath,
+  branchSlug,
+  changeDir,
+  changeReposPath,
+  changeWorktreesDir,
+  changedFiles,
+  changesSince,
+  checkoutState,
+  createGit,
+  createWorkspace,
+  ensureGitignore,
+  gitUser,
+  intellijProject,
+  intellijProjectPath,
+  isInPlace,
+  loadManifest,
+  loadRepos,
+  readChangeRepos,
+  remoteDefaultBranch,
+  removeEditorWorkspaces,
+  toHandle,
+  toRepoRelative,
+  vscodeWorkspace,
+  vscodeWorkspacePath,
+  worktreePath,
+  writeChangeRepos,
+  writeEditorWorkspaces
+} from "./chunk-EFHQ3TWP.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  GitError,
+  IGNORED,
+  WORKSPACE_DIR,
+  WorkspaceFileError,
+  baseClonePath,
+  branchCheckoutPath,
+  branchSlug,
+  changeDir,
+  changeReposPath,
+  changeWorktreesDir,
+  changedFiles,
+  changesSince,
+  checkoutState,
+  createGit,
+  createWorkspace,
+  ensureGitignore,
+  gitUser,
+  intellijProject,
+  intellijProjectPath,
+  isInPlace,
+  loadManifest,
+  loadRepos,
+  readChangeRepos,
+  remoteDefaultBranch,
+  removeEditorWorkspaces,
+  toHandle,
+  toRepoRelative,
+  vscodeWorkspace,
+  vscodeWorkspacePath,
+  worktreePath,
+  writeChangeRepos,
+  writeEditorWorkspaces
+};

package/dist/chunk-ONLS5QA5.js

@@ -0,0 +1,102 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  INPUTS_SOURCE_ID
+} from "./chunk-ABWHYWNI.js";
+import {
+  readCatalog
+} from "./chunk-27NKUS3X.js";
+import {
+  readKnowledge,
+  readSnapshot
+} from "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import {
+  scanInputs
+} from "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  catalogDirOf,
+  inputsDirOf,
+  knowledgeRelOf,
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/documents.js
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+var titleOf = (r) => "title" in r && typeof r.title === "string" && r.title || "name" in r && typeof r.name === "string" && r.name || r.id;
+async function listDocuments(root) {
+  const dir = inputsDirOf(root);
+  const commands = [
+    `atticus sources sync --source ${INPUTS_SOURCE_ID}`,
+    `atticus knowledge scan --source ${INPUTS_SOURCE_ID}`
+  ];
+  const there = await stat(dir).then((s) => s.isDirectory(), () => false);
+  if (!there)
+    return { documents: [], snapshot: null, commands };
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const records = [];
+  for (const part of ["generated", "curated"])
+    records.push(...await readCatalog(join(catalogDirOf(root), part), { cacheRoot: root }).then((c) => c.records, () => []));
+  const intake = await scanInputs({
+    root,
+    orgPack: op,
+    inputsDir: dir,
+    records,
+    scannedAt: "1970-01-01T00:00:00Z"
+  });
+  const byId = new Map(intake.documents.filter((d) => d.id).map((d) => [d.id, d.path]));
+  const snap = await readSnapshot(root, INPUTS_SOURCE_ID).catch(() => void 0);
+  const read = new Set(snap?.manifest.pages.map((p) => `inputs/${p.page}`) ?? []);
+  const skipped = new Map(snap?.manifest.skipped.map((s) => [s.page, s.reason]) ?? []);
+  const fileOf = new Map(snap?.manifest.pages.map((p) => [p.file, `inputs/${p.page}`]) ?? []);
+  const copy = new RegExp(`^${knowledgeRelOf(root).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/snapshots/${INPUTS_SOURCE_ID}/[^/]+/(.+)$`);
+  const k = await readKnowledge(root, { cacheRoot: root }).catch(() => void 0);
+  const itemsOf = /* @__PURE__ */ new Map();
+  for (const item of k?.items ?? []) {
+    const files = new Set(item.evidence.map((e) => e.path ? copy.exec(e.path)?.[1] : void 0).filter((f) => !!f).map((f) => fileOf.get(f)).filter((p) => !!p));
+    const review = k.reviews[item.id];
+    for (const f of files)
+      itemsOf.set(f, [
+        ...itemsOf.get(f) ?? [],
+        {
+          id: item.id,
+          title: titleOf(item),
+          verified: review?.state === "verified" || review?.state === "corrected"
+        }
+      ]);
+  }
+  const documents = [];
+  for (const d of [...intake.documents].sort((a, b) => a.path < b.path ? -1 : 1)) {
+    const at = await stat(join(dir, ...d.path.replace(/^inputs\//, "").split("/"))).catch(() => void 0);
+    const reason = skipped.get(d.path);
+    documents.push({
+      path: d.path,
+      kind: d.classification,
+      ...d.title ? { title: d.title } : {},
+      systems: d.systems,
+      state: read.has(d.path) ? "read" : reason ? "skipped" : "not-synced",
+      ...reason ? { reason } : {},
+      ...d.duplicateOf ? { duplicateOf: d.duplicateOf } : {},
+      ...d.supersededBy ? { supersededBy: byId.get(d.supersededBy) ?? d.supersededBy } : {},
+      inbox: d.path.startsWith("inputs/inbox/"),
+      ...at ? { modifiedAt: at.mtime.toISOString() } : {},
+      items: itemsOf.get(d.path) ?? []
+    });
+  }
+  return { documents, snapshot: snap ? { date: snap.manifest.date } : null, commands };
+}
+export {
+  listDocuments
+};