@great-arrow/cli 0.6.5 → 0.7.1

package/README.md

@@ -80,6 +80,12 @@ gad memory delete <id>
 cat notes.md | gad memory create --title "Meeting notes"
 ```
 
+`gad memory search` shows a **Source** column for every hit: the original
+document's link (GitHub, Notion, Drive…) when there is one, otherwise the
+memory's page in the web app. `gad ask` prints a numbered **Sources** list of
+the memories its answer was built from, under the answer (`--quiet` hides it;
+`--json` keeps the raw `hits`).
+
 ### Workspace
 
 ```bash

package/dist/index.js

@@ -9483,7 +9483,7 @@ function isNodeError(value) {
 
 // src/lib/version.ts
 var CLI_PACKAGE_NAME = "@great-arrow/cli";
-var CLI_VERSION = "0.6.5";
+var CLI_VERSION = "0.7.1";
 var GAD_INSTALL_VERSION = "2026.08.08";
 var GAD_INSTALL_MIN_VERSION = "2026.06.22";
 var GAD_INSTALL_HEADER = "X-GAD-Install-Version";
@@ -10965,11 +10965,11 @@ var EXIT_SESSION_EXPIRED = 2;
 var EXIT_NOT_OAUTH = 3;
 function authCommand() {
   const cmd = new Command("auth").description("Authentication helpers");
-  cmd.command("token").description("Print a fresh OAuth access token, refreshing it if needed").option("--json", "Output {accessToken, accessExpiresAt, apiUrl} as JSON").action(async (options, actionCommand) => {
+  cmd.command("token").description("Print a fresh OAuth access token, refreshing it if needed").option("--json", "Output {accessToken, accessExpiresAt, apiUrl} as JSON").action(async (options, actionCommand2) => {
     try {
       const t = await getFreshOAuthAccessToken();
       writeCliLocator();
-      const jsonOutput = options.json || actionCommand.optsWithGlobals().json;
+      const jsonOutput = options.json || actionCommand2.optsWithGlobals().json;
       process.stdout.write(
         jsonOutput ? `${JSON.stringify(t)}
 ` : `${t.accessToken}
@@ -12198,11 +12198,56 @@ function readStdin(stream) {
   return readStream(input2);
 }
 
+// src/lib/sources.ts
+function nonEmpty2(value) {
+  if (typeof value !== "string") return null;
+  const clean = stripControlChars(value).trim();
+  return clean === "" ? null : clean;
+}
+function httpUrl(value) {
+  const raw = nonEmpty2(value);
+  if (!raw) return null;
+  try {
+    const parsed = new URL(raw);
+    return parsed.protocol === "https:" || parsed.protocol === "http:" ? parsed.toString() : null;
+  } catch {
+    return null;
+  }
+}
+function sourceOf(hit, apiUrl) {
+  const memoryId = nonEmpty2(hit.memoryId);
+  const link = httpUrl(hit.url) ?? (memoryId ? `${apiUrl.replace(/\/$/, "")}/stuff/memories/${encodeURIComponent(memoryId)}` : null);
+  const label = nonEmpty2(hit.fileName) ?? nonEmpty2(hit.memoryTitle) ?? nonEmpty2(hit.title) ?? memoryId ?? "Untitled";
+  return { label, link };
+}
+function uniqueSources(hits, apiUrl, max = 5) {
+  const seen = /* @__PURE__ */ new Set();
+  const out2 = [];
+  for (const hit of hits) {
+    const source = sourceOf(hit, apiUrl);
+    const key = source.link ?? source.label;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out2.push(source);
+    if (out2.length >= max) break;
+  }
+  return out2;
+}
+function formatSources(sources) {
+  if (sources.length === 0) return "";
+  const lines = sources.map(
+    (s2, i) => `  [${i + 1}] ${s2.label}${s2.link ? ` \u2014 ${s2.link}` : ""}`
+  );
+  return `Sources:
+${lines.join("\n")}`;
+}
+
 // src/commands/memory.ts
 var searchColumns = [
   { key: "title", header: "Title", width: 30 },
   { key: "layer", header: "Layer", width: 12 },
   { key: "freshness", header: "Freshness", width: 10 },
+  { key: "source", header: "Source" },
   {
     key: "preview",
     header: "Preview",
@@ -12298,7 +12343,12 @@ memoryCommand.command("create").description("Create a new memory in the active w
 });
 memoryCommand.command("search <query>").description("Semantic search across memories").option("--json", "Output as JSON").option("-k, --limit <number>", "Max results", "10").option("--layer <layer>", "Filter by layer").action(async (query, opts, command) => {
   const g = globalOutputOpts(command);
-  const client2 = await buildClient();
+  const auth = await resolveAuth();
+  const client2 = new GadClient({
+    token: auth.token,
+    getToken: auth.getToken,
+    apiUrl: auth.apiUrl
+  });
   const args = {
     query,
     k: Number.parseInt(opts.limit, 10)
@@ -12312,6 +12362,7 @@ memoryCommand.command("search <query>").description("Semantic search across memo
   const rows = rawResults.map((item) => ({
     ...item,
     title: item.title ?? item.memoryTitle,
+    source: sourceOf(item, auth.apiUrl).link ?? "",
     preview: extractPreview(item)
   }));
   const fmt = createFormatter({
@@ -18293,6 +18344,17 @@ function askOutcome(data) {
   const answer = extractAnswer(data);
   return answer.trim() === "" ? { kind: "empty" } : { kind: "ok", text: answer };
 }
+function askSources(data, apiUrl) {
+  if (!data || typeof data !== "object") return "";
+  const hits = data.hits;
+  if (!Array.isArray(hits)) return "";
+  return formatSources(
+    uniqueSources(
+      hits.filter((h) => typeof h === "object" && h !== null),
+      apiUrl
+    )
+  );
+}
 function askCommand() {
   const cmd = new Command("ask").description("Ask the orchestrator a question").argument("<question>", "The question to ask").option("--json", "Output raw response as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (question, options, command) => {
     const g = globalOutputOpts(command);
@@ -18329,6 +18391,10 @@ function askCommand() {
     const outcome = askOutcome(result);
     if (outcome.kind === "ok") {
       process.stdout.write(outcome.text + "\n");
+      const sources = g.quiet ? "" : askSources(result, auth.apiUrl);
+      if (sources) process.stdout.write(`
+${sources}
+`);
     } else if (outcome.kind === "error") {
       fmt.warn(`Orchestrator error: ${outcome.message}`);
       process.exitCode = 1;
@@ -20107,7 +20173,7 @@ __export(external_exports, {
   hash: () => hash,
   hex: () => hex2,
   hostname: () => hostname4,
-  httpUrl: () => httpUrl,
+  httpUrl: () => httpUrl2,
   iban: () => iban2,
   includes: () => _includes,
   input: () => input,
@@ -37046,7 +37112,7 @@ __export(schemas_exports2, {
   hash: () => hash,
   hex: () => hex2,
   hostname: () => hostname4,
-  httpUrl: () => httpUrl,
+  httpUrl: () => httpUrl2,
   iban: () => iban2,
   instanceof: () => _instanceof,
   int: () => int,
@@ -37594,7 +37660,7 @@ var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
 function url(params) {
   return _url(ZodURL, params);
 }
-function httpUrl(params) {
+function httpUrl2(params) {
   return _url(ZodURL, {
     protocol: httpProtocol,
     hostname: domain,
@@ -40894,9 +40960,9 @@ var ZodString2 = class _ZodString2 extends ZodType2 {
     }
     return { status: status.value, value: input2.data };
   }
-  _regex(regex2, validation, message) {
+  _regex(regex2, validation2, message) {
     return this.refinement((data) => regex2.test(data), {
-      validation,
+      validation: validation2,
       code: ZodIssueCode2.invalid_string,
       ...errorUtil.errToObj(message)
     });
@@ -50236,6 +50302,248 @@ function callCommand() {
   });
 }
 
+// src/commands/board.ts
+var TOOL = "board_autopilot";
+function asObject4(json3) {
+  if (!json3.startsWith("{")) return null;
+  try {
+    const data = JSON.parse(json3);
+    return data && typeof data === "object" && !Array.isArray(data) ? data : null;
+  } catch (error62) {
+    void error62;
+    return null;
+  }
+}
+function parseToolResult(result) {
+  if (result && typeof result === "object" && !Array.isArray(result)) {
+    return { text: "", data: result };
+  }
+  if (typeof result !== "string") return { text: "", data: null };
+  const cut = result.lastIndexOf("\n");
+  const tail = result.slice(cut + 1).trim();
+  const candidates = [
+    [result.slice(0, Math.max(cut, 0)), tail],
+    ["", result.trim()]
+  ];
+  for (const [text3, json3] of candidates) {
+    const data = asObject4(json3);
+    if (data) return { text: text3, data };
+  }
+  return { text: result, data: null };
+}
+function validation(message, hint) {
+  return new CliError(message, 3 /* VALIDATION_ERROR */, hint);
+}
+function hostedP90(plan) {
+  const q = plan?.quotes?.find((x) => x.executor === "hosted");
+  return typeof q?.p90Usd === "number" ? q.p90Usd : null;
+}
+function buildStartArgs(runId, plan, opts) {
+  if (!opts.healthUrl)
+    throw validation(
+      "--yes needs --health-url <url>.",
+      "The run watches this URL after every merge and rolls back when it fails."
+    );
+  if (!opts.versionUrl)
+    throw validation(
+      "--yes needs --version-url <url>.",
+      "The run reads the serving version here to know a merge reached production."
+    );
+  let cap;
+  if (opts.cap !== void 0) {
+    cap = Number(opts.cap);
+    if (!Number.isFinite(cap) || cap <= 0)
+      throw validation("--cap must be a positive dollar amount.");
+  } else {
+    cap = hostedP90(plan);
+  }
+  if (cap === null)
+    throw validation(
+      "The plan carried no hosted quote to default the cap from.",
+      "Pass --cap <usd>."
+    );
+  if (cap <= 0)
+    throw validation(
+      "The hosted quote is $0, so there is no cap to default to.",
+      "Pass --cap <usd>."
+    );
+  const rejected = new Set(opts.reject ?? []);
+  if (plan?.findings) {
+    const known = new Set(plan.findings.map((f) => f.id));
+    const unknown2 = [...rejected].filter((id) => !known.has(id));
+    if (unknown2.length > 0)
+      throw validation(
+        `--reject: unknown finding id(s): ${unknown2.join(", ")}.`,
+        "Run without --yes to list finding ids."
+      );
+  }
+  const args = {
+    action: "start",
+    run_id: runId,
+    accepted_finding_ids: (plan?.findings ?? []).map((f) => f.id).filter((id) => !rejected.has(id)),
+    cap_usd: cap,
+    notify: { email: opts.email !== false, push: opts.push !== false },
+    health_check_url: opts.healthUrl,
+    version_url: opts.versionUrl
+  };
+  if (opts.types)
+    args.card_types = opts.types.split(",").map((t) => t.trim()).filter(Boolean);
+  return args;
+}
+async function callBoard(client2, args) {
+  let result;
+  try {
+    result = await client2.mcpCall("gad_call", gadCallArgs(TOOL, args));
+  } catch (error62) {
+    if (!(error62 instanceof McpToolError)) throw error62;
+    throw validation(`${TOOL}: ${error62.message}`, error62.hint);
+  }
+  const failure2 = callFailure(result);
+  if (failure2) {
+    throw new CliError(
+      `${TOOL}: ${failure2.message}`,
+      failure2.code === "feature_disabled" || failure2.code === "insufficient_scope" ? 1 /* AUTH_ERROR */ : 3 /* VALIDATION_ERROR */
+    );
+  }
+  return result;
+}
+function printPlan(fmt, plan) {
+  const row = (r) => r;
+  const f = plan.findings ?? [];
+  const c = plan.cards ?? [];
+  const q = plan.quotes ?? [];
+  process.stdout.write(`
+Board cleanups (${f.length})
+`);
+  fmt.table(f.map(row), [
+    { key: "id", header: "Finding" },
+    { key: "kind", header: "Kind" },
+    { key: "todoId", header: "Card" }
+  ]);
+  process.stdout.write(`
+Cards (${c.length})
+`);
+  fmt.table(
+    c.map((x) => row({ ...x, completable: x.completable ? "yes" : "no" })),
+    [
+      { key: "title", header: "Title" },
+      { key: "type", header: "Type" },
+      { key: "completable", header: "Runs alone" },
+      { key: "reason", header: "Why" }
+    ]
+  );
+  process.stdout.write("\nQuotes (USD)\n");
+  fmt.table(
+    q.map(
+      (x) => row({
+        ...x,
+        status: x.available ? "available" : x.comingSoon ? "soon" : "n/a"
+      })
+    ),
+    [
+      { key: "label", header: "Executor" },
+      { key: "status", header: "Status" },
+      { key: "p50Usd", header: "p50" },
+      { key: "p90Usd", header: "p90" }
+    ]
+  );
+}
+function makeFormatter(command) {
+  const g = globalOutputOpts(command);
+  return {
+    g,
+    fmt: createFormatter({
+      json: g.json,
+      quiet: g.quiet,
+      isTTY: isTTY(),
+      noColor: g.noColor
+    })
+  };
+}
+async function makeClient() {
+  const auth = await resolveAuth();
+  return new GadClient({
+    token: auth.token,
+    getToken: auth.getToken,
+    apiUrl: auth.apiUrl
+  });
+}
+function emit(result, json3, quiet = false) {
+  const { text: text3, data } = parseToolResult(result);
+  if (json3) {
+    process.stdout.write(
+      `${typeof result === "string" ? result : JSON.stringify(result)}
+`
+    );
+  } else if (text3 && !quiet) {
+    process.stdout.write(`${text3}
+`);
+  }
+  return data;
+}
+async function runClear(opts, command) {
+  if (opts.yes)
+    buildStartArgs(
+      "pending",
+      { quotes: [{ executor: "hosted", p90Usd: 1 }] },
+      opts
+    );
+  const { g, fmt } = makeFormatter(command);
+  const client2 = await makeClient();
+  const planResult = await callBoard(client2, {
+    action: "plan",
+    ...opts.goal ? { goal_id: opts.goal } : {}
+  });
+  const data = emit(planResult, g.json && !opts.yes, g.quiet);
+  const run4 = data?.run ?? null;
+  if (!g.json && !g.quiet && run4?.plan) printPlan(fmt, run4.plan);
+  if (!opts.yes) {
+    if (!g.json && !g.quiet && run4?.id)
+      process.stdout.write(
+        `
+Nothing has changed. Start with: gad board clear${opts.goal ? ` --goal ${opts.goal}` : ""} --yes --health-url <url> --version-url <url>
+`
+      );
+    return;
+  }
+  if (!run4?.id) throw validation("The plan reply carried no run id.");
+  const startResult = await callBoard(
+    client2,
+    buildStartArgs(run4.id, run4.plan, opts)
+  );
+  emit(startResult, g.json, g.quiet);
+}
+function actionCommand(action) {
+  return new Command(action).description(`${action} a clear-the-board run`).option("--run <id>", "Run id (status defaults to the latest run)").option("--card <id>", "Undo only this card (undo)").action(async (opts, command) => {
+    if (action !== "status" && !opts.run)
+      throw validation(`${action} needs --run <id>.`);
+    if (opts.card && action !== "undo")
+      throw validation("--card only applies to undo.");
+    const { g } = makeFormatter(command);
+    const client2 = await makeClient();
+    const result = await callBoard(client2, {
+      action,
+      ...opts.run ? { run_id: opts.run } : {},
+      ...opts.card ? { card_id: opts.card } : {}
+    });
+    emit(result, g.json, g.quiet);
+  });
+}
+function boardCommand() {
+  const clear = new Command("clear").description("Preview, start, watch, stop or undo a clear-the-board run").option("--goal <id>", "Limit the run to one Goal").option("--yes", "Start the run after planning").option("--health-url <url>", "URL probed after each merge (needs --yes)").option(
+    "--version-url <url>",
+    "URL that reports the serving sha (needs --yes)"
+  ).option("--cap <usd>", "Spend cap in USD (default: hosted p90 quote)").option("--types <list>", "Comma-separated card types, e.g. code").option("--no-email", "Do not email when the run finishes").option("--no-push", "Do not push-notify when the run finishes").option(
+    "--reject <findingId...>",
+    "Finding ids to leave out of the accepted set"
+  ).option("--json", "Output the raw tool result");
+  clear.action(runClear);
+  clear.addCommand(actionCommand("status"));
+  clear.addCommand(actionCommand("stop"));
+  clear.addCommand(actionCommand("undo"));
+  return new Command("board").description("Clear the board: tidy cards and run the safe ones").addCommand(clear);
+}
+
 // src/commands/keys.ts
 import { createInterface as createInterface3 } from "node:readline";
 import { Writable } from "node:stream";
@@ -55061,8 +55369,8 @@ var program2 = new Command().name("gad").description("Great Arrow Digital CLI \u
 );
 program2.hook(
   "preAction",
-  async (_thisCommand, actionCommand) => {
-    const options = actionCommand.optsWithGlobals();
+  async (_thisCommand, actionCommand2) => {
+    const options = actionCommand2.optsWithGlobals();
     const config2 = await loadConfig();
     setCommandWorkspaceTarget(options.workspace, config2.default_workspace);
   }
@@ -55082,6 +55390,7 @@ program2.addCommand(todo_default);
 program2.addCommand(nextCommand());
 program2.addCommand(discoverCommand());
 program2.addCommand(callCommand());
+program2.addCommand(boardCommand());
 program2.addCommand(claim_default);
 program2.addCommand(work_default());
 program2.addCommand(worktree_default);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@great-arrow/cli",
-  "version": "0.6.5",
+  "version": "0.7.1",
   "description": "GreatArrow.ai CLI tool",
   "type": "module",
   "bin": {