@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/init-Q4LBM6KT.js

@@ -0,0 +1,127 @@
+import {
+  nextStepAfterInstall,
+  performInstall,
+  printInstallEpilogue
+} from "./chunk-B73KQ5KX.js";
+import {
+  NON_INTERACTIVE_ROOT_ARGS
+} from "./chunk-DQA434Y4.js";
+import {
+  SkippedSymlinkError,
+  logApplyStats
+} from "./chunk-HS7LVVLO.js";
+import "./chunk-PNG7LO2F.js";
+import "./chunk-STGFBAYT.js";
+import "./chunk-ZXKZBTXE.js";
+import "./chunk-W24CMQ32.js";
+import "./chunk-MAPOQEA2.js";
+import {
+  withCliProgress
+} from "./chunk-QTON2GQX.js";
+import "./chunk-PNFF6OU3.js";
+import "./chunk-ZCTSUQRR.js";
+import "./chunk-F6C3GFKV.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  RootRefusedError,
+  classifyInstallError,
+  confirmProjectRoot,
+  isNonInteractive,
+  syncPathCliToRuntime
+} from "./chunk-F4VMYR7U.js";
+import {
+  assessEnvironment
+} from "./chunk-4IWG5CVE.js";
+import "./chunk-SMGFN3Z4.js";
+import "./chunk-NQ7IQ5XT.js";
+import "./chunk-2RDRMGD3.js";
+import "./chunk-N3HTJVBR.js";
+import "./chunk-AW74INUW.js";
+import "./chunk-5VCOWTTP.js";
+import {
+  KIT_VERSION
+} from "./chunk-7HDQEK6T.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/init.ts
+import { intro, outro } from "@clack/prompts";
+import { defineCommand } from "citty";
+async function runInitCompatibility(cwd, installer = performInstall) {
+  return installer({ cwd });
+}
+var initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "Guided setup entry (compat path to install + readiness)."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      description: "Project root directory",
+      default: process.cwd()
+    },
+    ...NON_INTERACTIVE_ROOT_ARGS
+  },
+  async run({ args }) {
+    const nonInteractive = args.yes || isNonInteractive();
+    if (!nonInteractive) {
+      intro(`agent-kit v${KIT_VERSION}`);
+    } else {
+      logger.info(`agent-kit v${KIT_VERSION} (non-interactive mode)`);
+    }
+    logger.info("init now uses the canonical install and readiness workflow.");
+    let projectRoot;
+    try {
+      projectRoot = await confirmProjectRoot(args.cwd, {
+        nonInteractive,
+        command: "install",
+        forceRoot: args["force-root"]
+      });
+    } catch (err) {
+      if (err instanceof RootRefusedError) {
+        logger.error(err.message);
+        if (err.recovery) console.error(`
+${err.recovery}
+`);
+        process.exitCode = 1;
+        return;
+      }
+      throw err;
+    }
+    try {
+      const result = await withCliProgress("init", () => runInitCompatibility(projectRoot));
+      const pending = result.readiness.pendingActions.length;
+      logger.success(`L0 and readiness prepared in ${result.projectRoot}`);
+      const nextStep = nextStepAfterInstall(pending);
+      const env = await assessEnvironment();
+      const sync = await syncPathCliToRuntime({ runtimeVersion: KIT_VERSION, env });
+      for (const line of sync.lines) console.log(line);
+      printInstallEpilogue(sync.env, { runtimeVersion: KIT_VERSION });
+      if (!nonInteractive) {
+        outro(nextStep);
+      } else {
+        logger.info(nextStep);
+      }
+    } catch (err) {
+      if (err instanceof SkippedSymlinkError) {
+        logApplyStats(err.stats);
+        logger.error(err.message);
+        process.exitCode = 1;
+        return;
+      }
+      const hint = classifyInstallError(err);
+      logger.error(hint.message);
+      console.error(`
+${hint.recovery}
+`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+});
+export {
+  initCommand,
+  runInitCompatibility
+};

package/dist/install-RHOS3OYZ.js

@@ -0,0 +1,34 @@
+import {
+  installCommand,
+  nextStepAfterInstall,
+  performInstall,
+  printInstallEpilogue
+} from "./chunk-B73KQ5KX.js";
+import "./chunk-DQA434Y4.js";
+import "./chunk-HS7LVVLO.js";
+import "./chunk-PNG7LO2F.js";
+import "./chunk-STGFBAYT.js";
+import "./chunk-ZXKZBTXE.js";
+import "./chunk-W24CMQ32.js";
+import "./chunk-MAPOQEA2.js";
+import "./chunk-QTON2GQX.js";
+import "./chunk-PNFF6OU3.js";
+import "./chunk-ZCTSUQRR.js";
+import "./chunk-F6C3GFKV.js";
+import "./chunk-ZB43YMHW.js";
+import "./chunk-F4VMYR7U.js";
+import "./chunk-4IWG5CVE.js";
+import "./chunk-SMGFN3Z4.js";
+import "./chunk-NQ7IQ5XT.js";
+import "./chunk-2RDRMGD3.js";
+import "./chunk-N3HTJVBR.js";
+import "./chunk-AW74INUW.js";
+import "./chunk-5VCOWTTP.js";
+import "./chunk-7HDQEK6T.js";
+import "./chunk-77V75A7O.js";
+export {
+  installCommand,
+  nextStepAfterInstall,
+  performInstall,
+  printInstallEpilogue
+};

package/dist/mission-control-LJACEVVN.js

@@ -0,0 +1,89 @@
+import {
+  buildMcTuiView,
+  findDashboardDataScript,
+  loadDashboardSnapshot,
+  runMcTuiLoop
+} from "./chunk-PCCQUWE5.js";
+import {
+  resolveDashboardSnapshotRoot
+} from "./chunk-HFUH3HVS.js";
+import "./chunk-QTON2GQX.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+
+// src/commands/mission-control.ts
+import { defineCommand } from "citty";
+var missionControlCommand = defineCommand({
+  meta: {
+    name: "mission-control",
+    description: "ASCII Mission Control (mission, flight log, checklist, crew monitor) without a browser."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd(),
+      description: "Workspace to snapshot (nearest .cursor/agent-kit.json, else git root)"
+    },
+    once: {
+      type: "boolean",
+      default: false,
+      description: "Print one frame and exit (Claude Code / non-TTY / CI)"
+    }
+  },
+  async run({ args }) {
+    const snapshotRoot = resolveDashboardSnapshotRoot(args.cwd);
+    const dataScript = await findDashboardDataScript(args.cwd);
+    if (!dataScript) {
+      logger.error("No dashboard/dashboard-data.mjs found.");
+      console.error(
+        [
+          "",
+          "The Mission Control snapshot script is not available in this workspace.",
+          "The TUI reuses the Path C dashboard data collector; it does not start an HTTP server.",
+          "",
+          "Recovery (pick one):",
+          "  1. Upgrade the CLI: npx @dadado/agent-kit-cli@latest mission-control",
+          "  2. Set MISSION_CONTROL_KIT_ROOT or AGENT_KIT_HOME to an agent-kit checkout",
+          "  3. Place an agent-kit sibling: ../agent-kit/dashboard/dashboard-data.mjs",
+          ""
+        ].join("\n")
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const handle = await runMcTuiLoop({
+      once: Boolean(args.once),
+      stdoutIsTTY: Boolean(process.stdout.isTTY),
+      env: process.env,
+      renderOpts: { stdoutIsTTY: Boolean(process.stdout.isTTY) },
+      loadView: async () => {
+        const loaded = await loadDashboardSnapshot({
+          dataScript,
+          snapshotRoot
+        });
+        if (!loaded.ok) return buildMcTuiView(null, loaded.error);
+        return buildMcTuiView(loaded.snapshot);
+      },
+      hooks: {
+        write: (chunk) => {
+          process.stdout.write(chunk);
+        },
+        stdin: process.stdin,
+        exit: (code) => {
+          process.exit(code);
+        }
+      }
+    });
+    if (!handle) return;
+    const onSignal = () => {
+      handle.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+  }
+});
+export {
+  missionControlCommand
+};

package/dist/monitors-QV2IS3MP.js

@@ -0,0 +1,176 @@
+// src/commands/monitors.ts
+import path2 from "path";
+import { defineCommand } from "citty";
+
+// src/invariants/monitors-untriaged.ts
+import { execFile } from "child_process";
+import { readFile, readdir, stat } from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+
+// src/invariants/triage-heading.ts
+var TRIAGE_HEADING_RE = /^#{2,6}\s+(?:Triage note|Follow-?up plan|Residuals plan)\b/im;
+
+// src/invariants/monitors-untriaged.ts
+var execFileAsync = promisify(execFile);
+var CITE = "agent-kit monitors --untriaged (ADR 2026-07-27_plan-review-triage-untriaged-not-mtime; never newest-mtime-wins)";
+function hasOpenGaps(content) {
+  if (/###\s+Still open[^\n]*\n+(?:\s*\n)*(?:None\.|none\.|\*None\*)/i.test(content)) {
+    return false;
+  }
+  if (/###\s+Still open/i.test(content) && !/###\s+Still open[^\n]*\n+(?:\s*\n)*(?:None\.|none\.)/i.test(content)) {
+    const m = content.match(/###\s+Still open[^\n]*\n([\s\S]*?)(?=\n### |\n## |$)/i);
+    if (m?.[1]?.trim() && !/^(none\.?|\*none\*)$/i.test(m[1].trim())) {
+      return true;
+    }
+  }
+  if (/^#{2,6}\s+.*\bResidual items?\b/im.test(content)) return true;
+  return false;
+}
+async function listMonitorFiles(memoryDir) {
+  try {
+    const names = await readdir(memoryDir);
+    return names.filter((n) => n.startsWith("plan-monitor-") && n.endsWith(".md")).sort();
+  } catch {
+    return [];
+  }
+}
+async function gitFreshMonitorNames(rootDir) {
+  const names = /* @__PURE__ */ new Set();
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["status", "--porcelain", "--", ".cursor/memory"],
+      { cwd: rootDir, maxBuffer: 2 * 1024 * 1024 }
+    );
+    for (const line of stdout.split("\n")) {
+      if (!line.trim()) continue;
+      const file = line.slice(3).trim().replace(/^.* -> /, "");
+      const base = path.basename(file);
+      if (base.startsWith("plan-monitor-") && base.endsWith(".md")) {
+        names.add(base);
+      }
+    }
+  } catch {
+  }
+  return names;
+}
+function extractHandoffPlanSlugs(handoff) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const m of handoff.matchAll(/`([a-z0-9][a-z0-9._-]*)\.plan\.md`/gi)) {
+    if (m[1]) slugs.add(m[1].toLowerCase());
+  }
+  for (const m of handoff.matchAll(/plan-monitor-([a-z0-9][a-z0-9._-]*)\.md/gi)) {
+    if (m[1]) slugs.add(m[1].toLowerCase());
+  }
+  return slugs;
+}
+function monitorSlugFromName(fileName) {
+  return fileName.replace(/^plan-monitor-/, "").replace(/\.md$/, "").toLowerCase();
+}
+async function selectUntriagedMonitors(rootDir) {
+  const root = path.resolve(rootDir);
+  const memoryDir = path.join(root, ".cursor", "memory");
+  const allNames = await listMonitorFiles(memoryDir);
+  const selectionOrder = ["git-fresh", "handoff-aligned", "untriaged-scan"];
+  const byName = /* @__PURE__ */ new Map();
+  for (const name of allNames) {
+    const abs = path.join(memoryDir, name);
+    try {
+      const [content, st] = await Promise.all([readFile(abs, "utf8"), stat(abs)]);
+      byName.set(name, { content, mtimeMs: st.mtimeMs });
+    } catch {
+    }
+  }
+  const untriaged = (name) => {
+    const row = byName.get(name);
+    return !!row && !TRIAGE_HEADING_RE.test(row.content);
+  };
+  const gitFresh = await gitFreshMonitorNames(root);
+  const gitFreshSet = [...gitFresh].filter(untriaged).sort();
+  let handoff = "";
+  try {
+    handoff = await readFile(path.join(root, ".cursor", "HANDOFF.md"), "utf8");
+  } catch {
+    handoff = "";
+  }
+  const handoffSlugs = extractHandoffPlanSlugs(handoff);
+  const handoffAligned = allNames.filter((n) => untriaged(n) && handoffSlugs.has(monitorSlugFromName(n))).sort();
+  const scanAll = allNames.filter(untriaged);
+  let chosen;
+  if (gitFreshSet.length > 0) {
+    chosen = { names: gitFreshSet, bucket: "git-fresh" };
+  } else if (handoffAligned.length > 0) {
+    chosen = { names: handoffAligned, bucket: "handoff-aligned" };
+  } else {
+    chosen = { names: scanAll, bucket: "untriaged-scan" };
+  }
+  const entries = [];
+  for (const name of chosen.names) {
+    const row = byName.get(name);
+    if (!row) continue;
+    entries.push({
+      path: path.join(memoryDir, name),
+      relativePath: path.relative(root, path.join(memoryDir, name)).split(path.sep).join("/"),
+      mtimeMs: row.mtimeMs,
+      hasTriageHeading: false,
+      hasOpenGaps: hasOpenGaps(row.content),
+      selectionBucket: chosen.bucket
+    });
+  }
+  entries.sort((a, b) => {
+    if (a.hasOpenGaps !== b.hasOpenGaps) return a.hasOpenGaps ? -1 : 1;
+    return b.mtimeMs - a.mtimeMs;
+  });
+  return {
+    selectionOrder: [...selectionOrder],
+    monitors: entries,
+    cite: CITE
+  };
+}
+
+// src/commands/monitors.ts
+var monitorsCommand = defineCommand({
+  meta: {
+    name: "monitors",
+    description: "Select untriaged plan monitors (--untriaged; SoT for chat triage)."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    untriaged: {
+      type: "boolean",
+      default: false,
+      description: "Select untriaged monitors (never newest-mtime-wins alone)"
+    },
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Machine-readable JSON"
+    }
+  },
+  async run({ args }) {
+    if (!args.untriaged) {
+      console.error("Usage: agent-kit monitors --untriaged [--json] [--cwd <dir>]");
+      process.exitCode = 2;
+      return;
+    }
+    const result = await selectUntriagedMonitors(path2.resolve(args.cwd));
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.monitors.length === 0) {
+      console.log("No untriaged plan-monitor files.");
+      return;
+    }
+    for (const m of result.monitors) {
+      console.log(m.relativePath);
+    }
+  }
+});
+export {
+  monitorsCommand
+};

package/dist/plan-index-JMC7Z4DW.js

@@ -0,0 +1,44 @@
+import {
+  formatPlanIndexLines,
+  writePlanIndex
+} from "./chunk-KD2MYBB6.js";
+import "./chunk-5VCOWTTP.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/plan-index.ts
+import path from "path";
+import { defineCommand } from "citty";
+var planIndexCommand = defineCommand({
+  meta: {
+    name: "plan-index",
+    description: "Write pending-only plan index from HANDOFF-named plans (no directory glob)."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Print the index JSON after writing"
+    }
+  },
+  async run({ args }) {
+    const root = path.resolve(args.cwd);
+    const index = await writePlanIndex(root);
+    if (args.json) {
+      console.log(JSON.stringify(index, null, 2));
+      return;
+    }
+    const lines = formatPlanIndexLines(index);
+    if (lines.length === 0) {
+      console.log("No pending plans in the HANDOFF-named set.");
+      return;
+    }
+    for (const line of lines) console.log(line);
+  }
+});
+export {
+  planIndexCommand
+};

package/dist/public-inbound-radar-WP3XF7GS.js

@@ -0,0 +1,68 @@
+import {
+  checkPublicInbound
+} from "./chunk-2IPXQFJE.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import "./chunk-NQ7IQ5XT.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/public-inbound-radar.ts
+import { defineCommand } from "citty";
+var publicInboundRadarCommand = defineCommand({
+  meta: {
+    name: "public-inbound-radar",
+    description: "Factory-only: list open public issues/PRs on agent-kit-startup/agent-kit (read-only JSON)."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    json: {
+      type: "boolean",
+      description: "Print machine-readable JSON (default true for scripting)",
+      default: true
+    },
+    offline: {
+      type: "boolean",
+      description: "Skip GitHub fetch; fail-open skipped-offline",
+      default: false
+    },
+    "respect-prefs": {
+      type: "boolean",
+      description: "Honor publicInboundCheck.enabled and intervalDays from .cursor/context/config.json",
+      default: false
+    },
+    stamp: {
+      type: "boolean",
+      description: "Persist publicInboundCheck.lastCheckedAt after an ok check",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const result = await checkPublicInbound(args.cwd, {
+      offline: Boolean(args.offline),
+      respectPrefs: Boolean(args["respect-prefs"]),
+      stamp: Boolean(args.stamp)
+    });
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      const line = `[${result.status}] ${result.message}`;
+      if (result.status === "error") logger.error(line);
+      else if (result.status.startsWith("skipped-")) logger.warn(line);
+      else logger.info(line);
+      for (const item of result.items.slice(0, 20)) {
+        logger.info(`- ${item.class} ${item.cite}: ${item.title} (@${item.author})`);
+      }
+      if (result.items.length > 20) {
+        logger.info(`\u2026 and ${result.items.length - 20} more (use --json)`);
+      }
+    }
+    if (result.status === "error") process.exitCode = 2;
+  }
+});
+export {
+  publicInboundRadarCommand
+};

package/dist/remote-issues-SZ4HDQL5.js

@@ -0,0 +1,44 @@
+import {
+  readRemoteIssues
+} from "./chunk-VY7MTPJ2.js";
+import "./chunk-2IPXQFJE.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import "./chunk-NQ7IQ5XT.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/remote-issues.ts
+import { defineCommand } from "citty";
+var remoteIssuesCommand = defineCommand({
+  meta: {
+    name: "remote-issues",
+    description: "Read-only: list remote dogfood issues (provenance label or [Dogfood] title) for the current lane, GitHub or GitLab (JSON)."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    json: {
+      type: "boolean",
+      description: "Print machine-readable JSON (default true for scripting)",
+      default: true
+    }
+  },
+  async run({ args }) {
+    const result = await readRemoteIssues(args.cwd);
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    logger.info(`[${result.lane}] ${result.items.length} remote dogfood issue(s)`);
+    for (const item of result.items) {
+      logger.info(`- ${item.cite}: ${item.title} (${item.url})`);
+    }
+    for (const note of result.notes) logger.warn(note.message);
+  }
+});
+export {
+  remoteIssuesCommand
+};