@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/run-I3BFGULT.js

@@ -0,0 +1,243 @@
+import {
+  detectAgentBackend,
+  listDetectBackendIds,
+  runPlanLoop,
+  shouldUseLiveTui,
+  withLiveTui
+} from "./chunk-TFZ2JUXH.js";
+import "./chunk-PCCQUWE5.js";
+import "./chunk-HFUH3HVS.js";
+import "./chunk-KD2MYBB6.js";
+import {
+  buildDispatchPrompt,
+  classifySlash,
+  ensureDispatchLogPath,
+  normalizeSlashName,
+  promoteBlockedMessage,
+  readCommandFile,
+  runHeadlessDispatch,
+  unknownSlashMessage
+} from "./chunk-WW3YZKHW.js";
+import {
+  HITL_UNANSWERED_EXIT_CODE,
+  formatHitlSummary,
+  getBackend,
+  hitlExitCode
+} from "./chunk-OUQZC744.js";
+import "./chunk-MAPOQEA2.js";
+import "./chunk-QTON2GQX.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import "./chunk-5VCOWTTP.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/run.ts
+import { homedir } from "os";
+import path from "path";
+import { defineCommand } from "citty";
+function displayPath(target, home = homedir()) {
+  const resolvedHome = path.resolve(home);
+  if (target === resolvedHome) return "~";
+  const prefix = resolvedHome.endsWith(path.sep) ? resolvedHome : `${resolvedHome}${path.sep}`;
+  return target.startsWith(prefix) ? `~${path.sep}${target.slice(prefix.length)}` : target;
+}
+async function executeRun(input) {
+  const root = path.resolve(input.cwd);
+  const slash = normalizeSlashName(input.slash);
+  if (!slash) {
+    return { exitCode: 1, error: "Provide a slash: agent-kit run <slash>" };
+  }
+  const kind = classifySlash(slash);
+  if (kind === "promote-blocked") {
+    return { exitCode: 1, error: promoteBlockedMessage(slash) };
+  }
+  if (kind === "unknown") {
+    return { exitCode: 1, error: unknownSlashMessage(slash) };
+  }
+  const detected = await detectAgentBackend(input.backend, input.whichFn);
+  if (!detected.ok) {
+    return { exitCode: 1, error: detected.message };
+  }
+  if (kind === "run-plan") {
+    let backend;
+    try {
+      backend = getBackend(detected.id);
+    } catch (err) {
+      return { exitCode: 1, error: String(err) };
+    }
+    if (input.dryRun) {
+      const preview = [
+        `--dry-run: alias agent-kit run-plan (backend ${detected.id} at ${displayPath(detected.bin)})`,
+        "No agent will be started. Tick prompt is the existing run-plan loop prompt."
+      ].join("\n");
+      return { exitCode: 0, stdout: preview };
+    }
+    const code = await runPlanLoop({
+      root,
+      maxTicks: input.maxTicks,
+      sleepSeconds: input.sleepSeconds,
+      model: input.model,
+      dryRun: false,
+      backend,
+      noHitl: input.noHitl === true,
+      plain: input.plain === true
+    });
+    return { exitCode: code };
+  }
+  const file = await readCommandFile(root, slash);
+  if (!file.ok) {
+    return { exitCode: 1, error: file.message };
+  }
+  const prompt = buildDispatchPrompt(file.body);
+  if (input.dryRun) {
+    const stdout = [
+      "--dry-run: no agent will be started.",
+      `Slash: ${slash}`,
+      `Command file: ${path.relative(root, file.path)}`,
+      `Backend: ${detected.id} (${displayPath(detected.bin)})`,
+      "Prompt:",
+      prompt
+    ].join("\n");
+    return { exitCode: 0, stdout };
+  }
+  const logPath = await ensureDispatchLogPath(root);
+  console.log(`Dispatch: ${slash} via ${detected.id}`);
+  console.log(`Command file: ${path.relative(root, file.path)}`);
+  console.log(`Log: ${path.relative(root, logPath)}`);
+  try {
+    const dispatch = {
+      backendId: detected.id,
+      bin: detected.bin,
+      workspace: root,
+      prompt,
+      model: input.model,
+      logPath
+    };
+    const result = shouldUseLiveTui({ plain: input.plain }) ? await withLiveTui(
+      { root, backend: detected.id, logPath, noHitl: input.noHitl === true },
+      (seams) => runHeadlessDispatch({
+        ...dispatch,
+        hitl: seams.hitl,
+        render: seams.render,
+        onSpawn: seams.onSpawn,
+        log: seams.log
+      })
+    ) : await runHeadlessDispatch({
+      ...dispatch,
+      hitl: { policy: input.noHitl ? "off" : "prompt" }
+    });
+    for (const line of formatHitlSummary(result.hitl)) console.log(line);
+    return { exitCode: hitlExitCode(result.exitCode, result.hitl) };
+  } catch (err) {
+    return { exitCode: 1, error: String(err) };
+  }
+}
+var runDispatchArgs = {
+  cwd: {
+    type: "string",
+    description: "Project root (default: current directory)",
+    default: process.cwd()
+  },
+  backend: {
+    type: "string",
+    description: `Agent CLI (${listDetectBackendIds().join(" | ")}; default: auto)`,
+    default: "auto"
+  },
+  model: {
+    type: "string",
+    description: "Optional model id passed to the agent CLI",
+    default: ""
+  },
+  "dry-run": {
+    type: "boolean",
+    description: "Print the resolved backend and prompt, then exit without starting an agent",
+    default: false
+  },
+  "max-ticks": {
+    type: "string",
+    description: "For run-plan alias only: maximum ticks (default: 10)",
+    default: "10"
+  },
+  sleep: {
+    type: "string",
+    description: "For run-plan alias only: seconds between ticks (default: 5)",
+    default: "5"
+  },
+  "no-hitl": {
+    type: "boolean",
+    description: `CI: never prompt; a HITL gate stops the run with exit ${HITL_UNANSWERED_EXIT_CODE} (no default answer)`,
+    default: false
+  },
+  plain: {
+    type: "boolean",
+    description: "Status lines instead of the Mission Control live view (the default on a TTY; non-TTY, NO_COLOR and CI are always plain)",
+    default: false
+  }
+};
+async function runSlashCli(slash, args) {
+  const maxTicks = Number.parseInt(String(args["max-ticks"]), 10);
+  const sleepSeconds = Number.parseFloat(String(args.sleep));
+  if (!Number.isFinite(maxTicks) || maxTicks < 1) {
+    logger.error("--max-ticks must be a positive integer");
+    process.exitCode = 1;
+    return;
+  }
+  if (!Number.isFinite(sleepSeconds) || sleepSeconds < 0) {
+    logger.error("--sleep must be a non-negative number");
+    process.exitCode = 1;
+    return;
+  }
+  const result = await executeRun({
+    slash,
+    cwd: String(args.cwd),
+    backend: String(args.backend),
+    model: args.model ? String(args.model) : void 0,
+    dryRun: Boolean(args["dry-run"]),
+    maxTicks,
+    sleepSeconds,
+    noHitl: Boolean(args["no-hitl"]),
+    plain: Boolean(args.plain)
+  });
+  if (result.stdout) {
+    console.log(result.stdout);
+  }
+  if (result.error) {
+    logger.error(result.error);
+  }
+  process.exitCode = result.exitCode;
+}
+var runCommand = defineCommand({
+  meta: {
+    name: "run",
+    description: "Start one headless session from an L0 slash file. Numbered-list HITL answered from the terminal (claude backend). Never git-prod."
+  },
+  args: {
+    slash: {
+      type: "positional",
+      description: "Slash name (e.g. run-plan-all, backlog-add, continue-plan)",
+      required: true
+    },
+    ...runDispatchArgs
+  },
+  async run({ args }) {
+    await runSlashCli(String(args.slash ?? ""), args);
+  }
+});
+var runPlanAllCommand = defineCommand({
+  meta: {
+    name: "run-plan-all",
+    description: "Headless /run-plan-all queue from the L0 file. Numbered-list HITL answered from the terminal (claude backend). Never git-prod."
+  },
+  args: runDispatchArgs,
+  async run({ args }) {
+    await runSlashCli("run-plan-all", args);
+  }
+});
+export {
+  displayPath,
+  executeRun,
+  runCommand,
+  runPlanAllCommand,
+  runSlashCli
+};

package/dist/run-plan-FO7CL4M3.js

@@ -0,0 +1,118 @@
+import {
+  detectAgentBackend,
+  listDetectBackendIds,
+  runPlanLoop
+} from "./chunk-TFZ2JUXH.js";
+import "./chunk-PCCQUWE5.js";
+import "./chunk-HFUH3HVS.js";
+import "./chunk-KD2MYBB6.js";
+import {
+  HITL_UNANSWERED_EXIT_CODE,
+  getBackend
+} from "./chunk-OUQZC744.js";
+import "./chunk-MAPOQEA2.js";
+import "./chunk-QTON2GQX.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import "./chunk-5VCOWTTP.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/run-plan.ts
+import path from "path";
+import { defineCommand } from "citty";
+var runPlanCommand = defineCommand({
+  meta: {
+    name: "run-plan",
+    description: "Headless continuous plan runner (one fresh agent per tick). Never git-prod."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      description: "Project root (default: current directory)",
+      default: process.cwd()
+    },
+    "max-ticks": {
+      type: "string",
+      description: "Maximum ticks before stopping (default: 10)",
+      default: "10"
+    },
+    model: {
+      type: "string",
+      description: "Optional model id passed to the agent backend",
+      default: ""
+    },
+    sleep: {
+      type: "string",
+      description: "Seconds to sleep between ticks (default: 5)",
+      default: "5"
+    },
+    backend: {
+      type: "string",
+      description: `Agent backend (${listDetectBackendIds().join(" | ")}; default: cursor-agent)`,
+      default: "cursor-agent"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Print the tick prompt and exit without starting an agent",
+      default: false
+    },
+    "no-hitl": {
+      type: "boolean",
+      description: `CI: never prompt; a HITL gate stops the run with exit ${HITL_UNANSWERED_EXIT_CODE} (no default answer)`,
+      default: false
+    },
+    plain: {
+      type: "boolean",
+      description: "Status lines instead of the Mission Control live view (the default on a TTY; non-TTY, NO_COLOR and CI are always plain)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const maxTicks = Number.parseInt(String(args["max-ticks"]), 10);
+    const sleepSeconds = Number.parseFloat(String(args.sleep));
+    if (!Number.isFinite(maxTicks) || maxTicks < 1) {
+      logger.error("--max-ticks must be a positive integer");
+      process.exitCode = 1;
+      return;
+    }
+    if (!Number.isFinite(sleepSeconds) || sleepSeconds < 0) {
+      logger.error("--sleep must be a non-negative number");
+      process.exitCode = 1;
+      return;
+    }
+    let backend;
+    try {
+      const requested = String(args.backend);
+      if (requested === "auto") {
+        const detected = await detectAgentBackend("auto");
+        if (!detected.ok) {
+          logger.error(detected.message);
+          process.exitCode = 1;
+          return;
+        }
+        backend = getBackend(detected.id);
+      } else {
+        backend = getBackend(requested);
+      }
+    } catch (err) {
+      logger.error(String(err));
+      process.exitCode = 1;
+      return;
+    }
+    const code = await runPlanLoop({
+      root: path.resolve(args.cwd),
+      maxTicks,
+      sleepSeconds,
+      model: args.model ? String(args.model) : void 0,
+      dryRun: Boolean(args["dry-run"]),
+      backend,
+      noHitl: Boolean(args["no-hitl"]),
+      plain: Boolean(args.plain)
+    });
+    process.exitCode = code;
+  }
+});
+export {
+  runPlanCommand
+};

package/dist/scan-NI2SWJ2E.js

@@ -0,0 +1,33 @@
+import {
+  runScanner
+} from "./chunk-ZCTSUQRR.js";
+import "./chunk-F6C3GFKV.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/scan.ts
+import { defineCommand } from "citty";
+var scanCommand = defineCommand({
+  meta: {
+    name: "scan",
+    description: "Scan the repository and print the detected profile."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      description: "Project root directory",
+      default: process.cwd()
+    }
+  },
+  async run({ args }) {
+    const result = await runScanner(args.cwd);
+    logger.info(`Scan completed for ${result.rootDir}`);
+    logger.info(`Path: ${result.isGreenfield ? "greenfield" : "existing project"}`);
+    console.log(JSON.stringify(result, null, 2));
+  }
+});
+export {
+  scanCommand
+};