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

package/dist/chunk-DPUYDDQG.js

@@ -0,0 +1,164 @@
+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 {
+  resumedAttempt,
+  stepClassOf
+} from "./chunk-CNUKCS2T.js";
+import {
+  RUN_SCHEMA_VERSION,
+  STEP_CLASSES,
+  changesDirOf,
+  runsDirOf,
+  runsRelOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/runs-view.js
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join, relative, resolve, sep } from "node:path";
+var RUN_ID = /^run-[0-9a-z-]+$/;
+var sha = (s) => createHash("sha256").update(s).digest("hex");
+var dataBlocks = (prompt) => [
+  ...prompt.matchAll(/<atticus-data [^>]*origin="([^"]+)"[^>]*>\n([\s\S]*?)\n<\/atticus-data>/g)
+].map((m) => ({ origin: m[1], text: m[2].trimEnd() }));
+function handedBack(prompt) {
+  const blocks = dataBlocks(prompt);
+  const out = [];
+  for (const b of blocks) {
+    const m = /^checks on attempt (\d+)$/.exec(b.origin);
+    if (!m)
+      continue;
+    const attempt = Number(m[1]);
+    const problems = b.text.split("\n").filter((l) => l.startsWith("- ")).map((l) => l.slice(2).trim());
+    const previous = blocks.find((x) => x.origin === `attempt ${attempt}`)?.text;
+    out.push({
+      attempt,
+      problems,
+      ...previous !== void 0 ? { previousAnswer: previous } : {}
+    });
+  }
+  return out.sort((a, b) => a.attempt - b.attempt);
+}
+async function readStored(root, change, runId) {
+  const dir = join(runsDirOf(root), change, runId);
+  const text = await readFile(join(dir, "run.json"), "utf8").catch(() => void 0);
+  if (!text)
+    return void 0;
+  const run = JSON.parse(text);
+  const prompt = await readFile(join(dir, "prompt.md"), "utf8").catch(() => void 0) ?? run.request.pack?.prompt ?? "";
+  return { run, dir, prompt };
+}
+async function answerOf(root, s) {
+  if (typeof s.run.output === "string")
+    return s.run.output;
+  const out = s.run.request.outputPath;
+  if (!out)
+    return void 0;
+  const inRun = join(s.dir, basename(out));
+  const inChange = resolve(changesDirOf(root), s.run.request.change, out);
+  const candidates = [inRun];
+  if (s.run.request.outputIn !== "run" && !relative(changesDirOf(root), inChange).startsWith(".."))
+    candidates.push(inChange);
+  for (const f of candidates) {
+    const t = await readFile(f, "utf8").catch(() => void 0);
+    if (t !== void 0)
+      return t;
+  }
+  return void 0;
+}
+async function item(root, s) {
+  const r = s.run;
+  const manifest = await readFile(join(s.dir, "context-manifest.json"), "utf8").catch(() => "");
+  const attempt = r.request.pack?.manifest ? resumedAttempt(r).attempt : r.attempt ?? 1;
+  const back = handedBack(s.prompt);
+  const answer = await answerOf(root, s);
+  const agent = r.request.agent;
+  return {
+    schemaVersion: RUN_SCHEMA_VERSION,
+    runId: r.runId,
+    change: r.request.change,
+    agent: typeof agent === "string" ? agent : agent.id,
+    runtime: r.runtime,
+    state: r.state,
+    startedAt: r.startedAt,
+    ...r.finishedAt ? { finishedAt: r.finishedAt } : {},
+    ...r.request.outputPath ? { output: r.request.outputPath } : {},
+    ...r.usage ? { usage: r.usage } : {},
+    contextManifestSha256: sha(manifest),
+    promptPath: `${runsRelOf(root)}/${r.request.change}/${r.runId}/prompt.md`,
+    attempt,
+    answered: answer !== void 0,
+    handedBack: back.reduce((n, b) => n + b.problems.length, 0),
+    ...r.request.pack?.manifest ? { promptTokens: r.request.pack.manifest.totalTokens } : {},
+    ...r.tools ? { toolCalls: r.tools.calls.length } : {},
+    // ADR 0121 addendum: the kind of step and the model that ran it. A run kept before either
+    // was recorded is given its kind from its agent; its model stays unsaid.
+    ...classOf(r) ? { stepClass: classOf(r) } : {},
+    ...r.model ? { model: r.model } : {}
+  };
+}
+function classOf(r) {
+  if (r.stepClass && STEP_CLASSES.includes(r.stepClass))
+    return r.stepClass;
+  const agent = r.request.agent;
+  return agent && typeof agent === "object" && "id" in agent ? stepClassOf(r.request) : void 0;
+}
+async function allRuns(root, change) {
+  const out = [];
+  const changes = change ? [change] : await readdir(runsDirOf(root)).catch(() => []);
+  for (const c of changes) {
+    if (c.includes("/") || c.includes("\\") || c.includes("..") || c.includes(sep))
+      continue;
+    for (const id of await readdir(join(runsDirOf(root), c)).catch(() => [])) {
+      if (!RUN_ID.test(id))
+        continue;
+      const s = await readStored(root, c, id);
+      if (s)
+        out.push(s);
+    }
+  }
+  return out;
+}
+async function listRuns(root, o = {}) {
+  const items = await Promise.all((await allRuns(root, o.change)).map((s) => item(root, s)));
+  items.sort((a, b) => b.startedAt.localeCompare(a.startedAt) || b.runId.localeCompare(a.runId));
+  return items.slice(0, o.limit ?? 200);
+}
+async function runTranscript(root, runId) {
+  if (!RUN_ID.test(runId))
+    return void 0;
+  const all = await allRuns(root);
+  const s = all.find((x) => x.run.runId === runId);
+  if (!s)
+    return void 0;
+  const agentOf = (x) => {
+    const a = x.run.request.agent;
+    return typeof a === "string" ? a : a.id;
+  };
+  const same = all.filter((x) => x.run.request.change === s.run.request.change && agentOf(x) === agentOf(s));
+  const rounds = await Promise.all(same.map((x) => item(root, x)));
+  rounds.sort((a, b) => a.startedAt.localeCompare(b.startedAt) || a.runId.localeCompare(b.runId));
+  const answer = await answerOf(root, s);
+  return {
+    run: await item(root, s),
+    prompt: s.prompt,
+    ...answer !== void 0 ? { answer } : {},
+    ...s.run.tools ? { tools: s.run.tools } : {},
+    ...s.run.request.retrieval ? { retrieval: s.run.request.retrieval } : {},
+    handedBack: handedBack(s.prompt),
+    rounds: rounds.map((x) => ({
+      runId: x.runId,
+      attempt: x.attempt,
+      state: x.state,
+      startedAt: x.startedAt
+    }))
+  };
+}
+
+export {
+  listRuns,
+  runTranscript
+};

package/dist/chunk-DPZHZQKE.js

@@ -0,0 +1,285 @@
+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 {
+  gitUser,
+  loadRepos
+} from "./chunk-EFHQ3TWP.js";
+import {
+  ManifestEditError,
+  REPO_DESCRIPTION_MAX,
+  RecordId,
+  RepoDescription,
+  addManifestRepo,
+  descriptionLine,
+  factsDirOf,
+  manifestFiles,
+  parseFacts,
+  setManifestDescription
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/repo-commands.js
+import { readFile, stat } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+var askOnTerminal = async (prompt) => {
+  if (!stdin.isTTY)
+    return void 0;
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    return (await rl.question(`${prompt} `)).trim() || void 0;
+  } finally {
+    rl.close();
+  }
+};
+var ASK = "What is this repo, in one line? (what it is for, who uses it; Enter to skip and write it later)";
+function idFromUrl(url) {
+  const last = url.replace(/[/\\]+$/, "").split(/[/\\:]/).pop() ?? "";
+  return last.replace(/\.git$/i, "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
+}
+var trimmed = (t) => {
+  const s = t?.trim();
+  return s ? s.slice(0, REPO_DESCRIPTION_MAX) : void 0;
+};
+function written(text, by, now) {
+  return RepoDescription.parse({
+    text,
+    trust: "verified",
+    by,
+    at: now.toISOString().replace(/\.\d{3}Z$/, "Z")
+  });
+}
+async function declaredFrameworks(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return [];
+  const p = parseFacts(text);
+  if (!p.ok)
+    return [];
+  return p.facts.flatMap((f) => f.kind === "framework" ? [{ name: f.name, cite: `${f.cite.file}:${f.cite.line}` }] : []);
+}
+async function typeOf(url, description, frameworks = []) {
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(url) || /^[^/\\]+@/.test(url))
+    return void 0;
+  const dir = resolve(url);
+  if (!await stat(dir).then((s) => s.isDirectory(), () => false))
+    return void 0;
+  const [{ detectRepoType }, { fsRepo }] = await Promise.all([
+    import("./chunk-R77KLRB3.js"),
+    import("./chunk-HFQCFSJR.js")
+  ]);
+  const d = await detectRepoType(fsRepo(basename(dir), dir, "0".repeat(40)), {
+    ...description ? { description } : {},
+    ...frameworks.length ? { frameworks } : {}
+  });
+  return d.type === "unknown" ? void 0 : { type: d.type, signals: d.signals, confidence: d.confidence };
+}
+async function whoFor(root, d) {
+  if (d.by)
+    return d.by;
+  try {
+    return (await gitUser(root)).handle;
+  } catch {
+    return "someone";
+  }
+}
+async function repoAdd(root, url, o, io, deps = {}) {
+  if (!url?.trim()) {
+    io.err('Usage: atticus repo add <clone URL or path> [--id id] [--type repo type] [--owner team] [--description "what it is"].');
+    return 2;
+  }
+  const id = o.id?.trim() || idFromUrl(url.trim());
+  if (!RecordId.safeParse(id).success) {
+    io.err(`${id} isn't a repo id: ids are lowercase slugs (a-z, 0-9, '.', '_' and '-'). Give one with --id.`);
+    return 2;
+  }
+  const files = await manifestFiles(root);
+  const platform = o.platform?.trim() || (files.length === 1 ? files[0].platform : void 0);
+  if (!platform) {
+    io.err(files.length ? `There are ${files.length} platform profiles (${files.map((f) => f.platform).join(", ")}): say which with --platform.` : "The org pack has no platform profile yet (org-pack/profiles/<platform>/repos.manifest.yaml). Run atticus repos discover <folder of clones>, or atticus init first.");
+    return 2;
+  }
+  let text = trimmed(o.description);
+  let asked = false;
+  if (!text && !o.noDescription && !o.json) {
+    text = trimmed(await (deps.ask ?? askOnTerminal)(`${id}: ${ASK}`));
+    asked = true;
+  }
+  const by = await whoFor(root, deps);
+  const description = text ? written(text, by, deps.now ?? /* @__PURE__ */ new Date()) : void 0;
+  const detected = o.type?.trim() ? void 0 : await typeOf(url.trim(), text, await declaredFrameworks(root, id));
+  try {
+    const file = await addManifestRepo(root, platform, {
+      id,
+      url: url.trim(),
+      type: o.type?.trim() || detected?.type || "unknown",
+      owner: o.owner?.trim() || "unassigned",
+      ...o.system?.trim() ? { system: o.system.trim() } : {},
+      ...o.component?.trim() ? { component: o.component.trim() } : {},
+      ...description ? { description } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({ repo: id, platform, file: file.rel, description }, null, 2));
+      return 0;
+    }
+    io.out(`Added ${id} to ${file.rel}: commit it in a pull request.`);
+    if (detected)
+      io.out(`Type: ${detected.type}, from ${detected.signals.join(", ")} (${detected.confidence} confidence). Change it in the manifest if it is wrong.`);
+    if (description)
+      io.out(`What it is: ${description.text}`);
+    else
+      io.out(`${id} has no description yet${asked ? "" : " (--description, or atticus repo describe)"}: atticus repo describe ${id} --description "what it is". Until then its reading prompts, the join's questions and the views have only its id to go on.`);
+    io.out(`Next: atticus workspace sync, then read it: /atticus-map ${id}.`);
+    return 0;
+  } catch (e) {
+    if (e instanceof ManifestEditError) {
+      io.err(e.message);
+      return e.code === "not-found" ? 2 : 1;
+    }
+    throw e;
+  }
+}
+async function undescribedRepos(root) {
+  const repos = await loadRepos(root).catch(() => []);
+  const missing = [];
+  const unconfirmed = [];
+  for (const r of repos) {
+    if (r.archived)
+      continue;
+    if (!r.description)
+      missing.push(r.id);
+    else if (r.description.trust === "suggested")
+      unconfirmed.push({ id: r.id, text: r.description.text });
+  }
+  return { missing, unconfirmed };
+}
+async function repoDescribe(root, repo, o, io, deps = {}) {
+  if (!repo?.trim()) {
+    const { missing, unconfirmed } = await undescribedRepos(root);
+    if (o.json) {
+      io.out(JSON.stringify({ missing, unconfirmed }, null, 2));
+      return 0;
+    }
+    if (!missing.length && !unconfirmed.length) {
+      io.out("Every repo of the manifests says what it is.");
+      return 0;
+    }
+    if (missing.length) {
+      io.out(`${missing.length} repo${missing.length === 1 ? " has" : "s have"} no description:`);
+      for (const id2 of missing)
+        io.out(`  ${id2}: atticus repo describe ${id2} --description "..."`);
+    }
+    if (unconfirmed.length) {
+      io.out(`${unconfirmed.length} description${unconfirmed.length === 1 ? " was" : "s were"} drafted by your assistant and nobody has confirmed ${unconfirmed.length === 1 ? "it" : "them"} yet:`);
+      for (const u of unconfirmed)
+        io.out(`  ${u.id}: "${u.text}" \u2014 atticus repo describe ${u.id} --accept`);
+    }
+    return 0;
+  }
+  const id = repo.trim();
+  const found = (await loadRepos(root).catch(() => [])).find((r) => r.id === id);
+  if (!found) {
+    io.err(`There is no repo ${id} in any repos.manifest.yaml.`);
+    return 2;
+  }
+  const now = deps.now ?? /* @__PURE__ */ new Date();
+  const at = now.toISOString().replace(/\.\d{3}Z$/, "Z");
+  if (o.drafted !== void 0) {
+    const cites = (o.cites ?? "").split(",").map((c) => c.trim()).filter(Boolean).flatMap((c) => {
+      const m = /^(.*):(\d+)$/.exec(c);
+      return m && Number(m[2]) > 0 ? [{ file: m[1], line: Number(m[2]) }] : [];
+    });
+    if (!cites.length) {
+      io.err(`Say where you read it: atticus repo describe ${id} --drafted "..." --cites <file>:<line> (several separated by commas), as a fact cites its line.`);
+      return 2;
+    }
+    const r = await keepDraftedDescription(root, id, { text: o.drafted, cites }, now);
+    if (o.json) {
+      io.out(JSON.stringify({ repo: id, ...r }, null, 2));
+      return r.kept ? 0 : 1;
+    }
+    if (!r.kept) {
+      io.err(`The draft wasn't kept: ${r.why ?? "it wasn't one line"}.`);
+      return 1;
+    }
+    io.out(`${id}: "${o.drafted.trim()}" \u2014 kept as a draft, unconfirmed, with the lines you read it from. A person confirms it (atticus repo describe ${id} --accept), changes it or drops it.`);
+    return 0;
+  }
+  let next;
+  if (o.reject) {
+    if (!found.description) {
+      io.err(`${id} has no description to reject.`);
+      return 2;
+    }
+    next = void 0;
+  } else {
+    let text = trimmed(o.description);
+    if (!text && o.accept) {
+      if (!found.description) {
+        io.err(`${id} has no description to confirm. Write one: atticus repo describe ${id} --description "what it is".`);
+        return 2;
+      }
+      text = found.description.text;
+    }
+    if (!text && !o.json)
+      text = trimmed(await (deps.ask ?? askOnTerminal)(`${id}: ${ASK}`));
+    if (!text) {
+      io.err(`Say what ${id} is: atticus repo describe ${id} --description "what it is" (or --accept to keep the draft, --reject to drop it).`);
+      return 2;
+    }
+    next = written(text, await whoFor(root, deps), now);
+  }
+  try {
+    const file = await setManifestDescription(root, id, next);
+    if (o.json) {
+      io.out(JSON.stringify({ repo: id, file: file.rel, description: next ?? null }, null, 2));
+      return 0;
+    }
+    io.out(next ? `${id}: ${descriptionLine(next)}` : `${id}: the description was dropped; nothing says what it is now.`);
+    io.out(`Written to ${file.rel} at ${at}: commit it in a pull request.`);
+    return 0;
+  } catch (e) {
+    if (e instanceof ManifestEditError) {
+      io.err(e.message);
+      return e.code === "not-found" ? 2 : 1;
+    }
+    throw e;
+  }
+}
+async function keepDraftedDescription(root, repo, draft, now) {
+  const found = (await loadRepos(root).catch(() => [])).find((r) => r.id === repo);
+  if (!found)
+    return { kept: false, why: `${repo} isn't in any repos.manifest.yaml` };
+  if (found.description)
+    return {
+      kept: false,
+      why: found.description.trust === "verified" ? `${repo} already says what it is, in a person's words` : `${repo} already has a drafted description waiting for a person`
+    };
+  const text = trimmed(draft.text);
+  if (!text)
+    return { kept: false, why: "the draft was empty" };
+  const d = RepoDescription.safeParse({
+    text,
+    trust: "suggested",
+    by: draft.by ?? "assistant",
+    at: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+    cites: (draft.cites ?? []).slice(0, 6)
+  });
+  if (!d.success)
+    return { kept: false, why: d.error.issues[0]?.message ?? "the draft wasn't one line" };
+  await setManifestDescription(root, repo, d.data);
+  return { kept: true };
+}
+export {
+  askOnTerminal,
+  idFromUrl,
+  keepDraftedDescription,
+  repoAdd,
+  repoDescribe,
+  undescribedRepos
+};

package/dist/chunk-E36QOJMD.js

@@ -0,0 +1,47 @@
+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 {
+  outcomeList,
+  outcomeRecord,
+  releaseEvidenceCommand,
+  releaseForecastCommand,
+  releaseNotesCommand,
+  releasePlanCommand,
+  releaseSecurityCommand
+} from "./chunk-652QWTLZ.js";
+import "./chunk-BOHJZTEQ.js";
+import "./chunk-MVZVGYXH.js";
+import "./chunk-BWZ77RQT.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 {
+  outcomeList,
+  outcomeRecord,
+  releaseEvidenceCommand,
+  releaseForecastCommand,
+  releaseNotesCommand,
+  releasePlanCommand,
+  releaseSecurityCommand
+};