@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-HS7LVVLO.js

@@ -0,0 +1,74 @@
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+
+// src/lifecycle/report.ts
+function logApplyStats(stats) {
+  if (stats.written.length > 0) {
+    logger.success(`Wrote ${stats.written.length} file(s)`);
+    for (const p of stats.written) logger.info(`  + ${p}`);
+  }
+  if (stats.unchanged.length > 0) {
+    logger.info(`Unchanged: ${stats.unchanged.length}`);
+  }
+  if (stats.removed.length > 0) {
+    logger.info(`Removed managed legacy files: ${stats.removed.length}`);
+    for (const p of stats.removed) logger.info(`  - ${p}`);
+  }
+  if (stats.collisions.length > 0) {
+    logger.warn("Slash collision preserved because the legacy command is customized:");
+    for (const p of stats.collisions) logger.info(`  ! ${p}`);
+  }
+  if (stats.preservedCustomized.length > 0) {
+    logger.warn(
+      `Preserved customized overlay (agents/skills/commands/hooks/scripts); local body kept, kit body not applied: ${stats.preservedCustomized.length}`
+    );
+    for (const p of stats.preservedCustomized) logger.info(`  ! ${p}`);
+    logger.info(
+      "  Run `agent-kit diff` to see the kit body; send the change upstream (`agent-kit contribute` for agents/skills/commands/hooks, a factory PR for scripts); or add the path to `protected` in .cursor/agent-kit.json to keep it pinned on purpose."
+    );
+  }
+  if (stats.skippedProtected.length > 0) {
+    logger.warn(`Skipped protected (L3): ${stats.skippedProtected.length}`);
+    for (const p of stats.skippedProtected) logger.info(`  ~ ${p}`);
+  }
+  if (stats.skippedSymlink.length > 0) {
+    logger.warn(
+      `Skipped symlinked path (resolves outside the registry/project root, or is a symlink): ${stats.skippedSymlink.length}`
+    );
+    for (const p of stats.skippedSymlink) logger.info(`  ~ ${p}`);
+  }
+  if (stats.missing.length > 0) {
+    logger.warn(`Missing in registry: ${stats.missing.length}`);
+    for (const p of stats.missing) logger.info(`  ? ${p}`);
+  }
+}
+function listSkippedPaths(paths) {
+  const shown = paths.slice(0, 5).join(", ");
+  const more = paths.length > 5 ? ` (+${paths.length - 5} more)` : "";
+  return `${shown}${more}`;
+}
+function formatSkippedSymlinks(paths) {
+  return `${paths.length} kit path(s) were not written because they resolve outside the project (symlink): ${listSkippedPaths(paths)}. Manifest version left unchanged; replace the symlinked directory with a real one inside the project and re-run.`;
+}
+function formatPersonalizationSkippedSymlinks(paths, notRecorded) {
+  const ids = notRecorded.length > 0 ? notRecorded.join(", ") : "none";
+  return `${paths.length} personalization path(s) were not written because they resolve outside the project (symlink): ${listSkippedPaths(paths)}. Manifest saved without: ${ids}; replace the symlinked directory with a real one inside the project and re-run.`;
+}
+var SkippedSymlinkError = class extends Error {
+  constructor(stats, message = formatSkippedSymlinks(stats.skippedSymlink), claudeSessionStartInstructions) {
+    super(message);
+    this.stats = stats;
+    this.claudeSessionStartInstructions = claudeSessionStartInstructions;
+    this.name = "SkippedSymlinkError";
+  }
+  stats;
+  claudeSessionStartInstructions;
+};
+
+export {
+  logApplyStats,
+  formatSkippedSymlinks,
+  formatPersonalizationSkippedSymlinks,
+  SkippedSymlinkError
+};

package/dist/chunk-IHROBTNM.js

@@ -0,0 +1,135 @@
+// src/invariants/handoff-prune.ts
+var HANDOFF_MACHINE_FIELD_LABELS = [
+  "Plan",
+  "Last updated",
+  "Mode",
+  "Phase completed",
+  "Next phase",
+  "Completed to-dos",
+  "Next to-dos",
+  "Parked plans",
+  "Backlog plans",
+  "Run queue",
+  "Queue cursor",
+  "Queue status",
+  "Queue outcomes",
+  "Gaps",
+  "Instruction for the next agent"
+];
+var HANDOFF_FIXED_SECTION_HEADING_PREFIXES = [
+  "## Work Status",
+  "## Session Context",
+  "## Files Touched",
+  "## Decisions Made",
+  "## Issues Found",
+  "## Run queue (multi-plan only)"
+];
+var HANDOFF_MAX_LINES = 200;
+var HANDOFF_MAX_LINE_LENGTH = 2e3;
+var MACHINE_FIELD_RE = new RegExp(
+  `^- \\*\\*(${HANDOFF_MACHINE_FIELD_LABELS.map((l) => l.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")}):\\*\\*`
+);
+function isChunkStart(line) {
+  return /^- \*\*/.test(line) || /^## /.test(line);
+}
+function isFixedSectionHeading(line) {
+  return HANDOFF_FIXED_SECTION_HEADING_PREFIXES.some((p) => line.startsWith(p));
+}
+function splitIntoChunks(lines) {
+  const firstStart = lines.findIndex(isChunkStart);
+  if (firstStart === -1) return { preamble: lines, chunks: [] };
+  const preamble = lines.slice(0, firstStart);
+  const chunks = [];
+  let current = [lines[firstStart]];
+  for (const line of lines.slice(firstStart + 1)) {
+    if (isChunkStart(line)) {
+      chunks.push({ lines: current, isMachineField: MACHINE_FIELD_RE.test(current[0] ?? "") });
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  chunks.push({ lines: current, isMachineField: MACHINE_FIELD_RE.test(current[0] ?? "") });
+  return { preamble, chunks };
+}
+function pruneHandoffText(text, keep) {
+  if (!text.trim()) {
+    return { ok: false, reason: "empty file" };
+  }
+  const lines = text.split("\n");
+  const titleIdx = lines.findIndex((l) => /^# /.test(l));
+  if (titleIdx === -1) {
+    return { ok: false, reason: "no H1 title line found" };
+  }
+  let fixedStartIdx = lines.findIndex((l) => isFixedSectionHeading(l));
+  if (fixedStartIdx === -1) fixedStartIdx = lines.length;
+  const head = lines.slice(0, titleIdx + 1);
+  const narrativeLines = lines.slice(titleIdx + 1, fixedStartIdx);
+  const trailingLines = lines.slice(fixedStartIdx);
+  const { preamble, chunks } = splitIntoChunks(narrativeLines);
+  const machineFieldCount = chunks.filter((c) => c.isMachineField).length;
+  if (machineFieldCount === 0) {
+    return { ok: false, reason: "no machine-field bullets found; refusing to prune" };
+  }
+  if (fixedStartIdx === lines.length) {
+    return { ok: false, reason: "no recognized fixed-section heading found; refusing to prune" };
+  }
+  const narrativeChunks = chunks.filter((c) => !c.isMachineField);
+  if (narrativeChunks.length <= keep) {
+    return { ok: true, text, archived: [], keptCount: narrativeChunks.length };
+  }
+  const keptNarrativeIdx = /* @__PURE__ */ new Set();
+  let seen = 0;
+  const chunkIsNarrative = chunks.map((c) => !c.isMachineField);
+  for (let i = 0; i < chunks.length; i++) {
+    if (chunkIsNarrative[i]) {
+      if (seen < keep) keptNarrativeIdx.add(i);
+      seen++;
+    }
+  }
+  const keptChunks = [];
+  const archivedChunks = [];
+  chunks.forEach((c, i) => {
+    if (c.isMachineField || keptNarrativeIdx.has(i)) keptChunks.push(c);
+    else archivedChunks.push(c);
+  });
+  const newNarrativeLines = [...preamble, ...keptChunks.flatMap((c) => c.lines)];
+  const newLines = [...head, ...newNarrativeLines, ...trailingLines];
+  return {
+    ok: true,
+    text: newLines.join("\n"),
+    archived: archivedChunks.map((c) => c.lines.join("\n")),
+    keptCount: keptNarrativeIdx.size
+  };
+}
+function checkHandoffGrowth(text) {
+  if (!text.trim()) return [];
+  const lines = text.split("\n");
+  const warnings = [];
+  if (lines.length > HANDOFF_MAX_LINES) {
+    warnings.push({
+      code: "file-over-limit",
+      message: `HANDOFF.md is ${lines.length} lines, over the ${HANDOFF_MAX_LINES}-line growth-contract limit. Run \`agent-kit handoff --prune\` to archive older narrative entries.`
+    });
+  }
+  let firstOffendingLine = -1;
+  let overCount = 0;
+  lines.forEach((l, i) => {
+    if (l.length > HANDOFF_MAX_LINE_LENGTH) {
+      overCount++;
+      if (firstOffendingLine === -1) firstOffendingLine = i + 1;
+    }
+  });
+  if (overCount > 0) {
+    warnings.push({
+      code: "line-over-limit",
+      message: `HANDOFF.md has ${overCount} line(s) over the ${HANDOFF_MAX_LINE_LENGTH}-char growth-contract limit (first at line ${firstOffendingLine}). Wrap long paragraphs; do not widen the limit.`
+    });
+  }
+  return warnings;
+}
+
+export {
+  pruneHandoffText,
+  checkHandoffGrowth
+};

package/dist/chunk-KD2MYBB6.js

@@ -0,0 +1,213 @@
+import {
+  HANDOFF_REL
+} from "./chunk-5VCOWTTP.js";
+import {
+  ensureDir
+} from "./chunk-77V75A7O.js";
+
+// src/plan-index/plan-index.ts
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+var PLAN_INDEX_REL = ".cursor/context/plan-index.json";
+var NONE = /^(none|n\/a|empty|nil)$/i;
+var OPEN_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress"]);
+var DONE_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled"]);
+function defaultPlanIndexIo() {
+  return {
+    async readFile(absPath) {
+      try {
+        return await readFile(absPath, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    async writeFile(absPath, body) {
+      await ensureDir(path.dirname(absPath));
+      await writeFile(absPath, body, "utf8");
+    }
+  };
+}
+function extractHandoffNamedPlans(handoffText) {
+  return {
+    active: extractActivePlan(handoffText),
+    backlog: extractPlanBasenames(
+      extractFieldBlock(handoffText, "Backlog plans") ?? extractFieldBlock(handoffText, "Backlog")
+    ),
+    parked: extractPlanBasenames(extractFieldBlock(handoffText, "Parked plans")),
+    runQueue: extractPlanBasenames(extractFieldBlock(handoffText, "Run queue"))
+  };
+}
+function collectNamedPlanBasenames(named) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const file of [named.active, ...named.backlog, ...named.parked, ...named.runQueue]) {
+    if (!file || seen.has(file)) continue;
+    seen.add(file);
+    out.push(file);
+  }
+  return out;
+}
+function namedPlanCandidatePaths(root, basename) {
+  const safe = path.basename(basename);
+  if (!/^[A-Za-z0-9._-]+\.plan\.md$/i.test(safe)) return [];
+  return [
+    path.join(root, ".cursor", "plans", safe),
+    path.join(root, ".cursor", "plans", "archive", safe)
+  ];
+}
+function classifyPlanRole(file, named, openTodos) {
+  if (named.active === file) return "active";
+  if (named.backlog.includes(file)) return "backlog";
+  if (named.parked.includes(file)) return "parked";
+  if (openTodos) return "pending";
+  return null;
+}
+function parsePlanFrontmatter(raw) {
+  const match = raw.replace(/\r\n/g, "\n").match(/^---\n([\s\S]*?)\n---/);
+  if (!match?.[1]) return { todos: [] };
+  const block = match[1];
+  const name = block.match(/^name:\s*(.+)$/m)?.[1]?.trim();
+  const todos = [];
+  let currentId;
+  let currentContent;
+  for (const line of block.split("\n")) {
+    const idMatch = line.match(/^\s*- id:\s*(\S+)/);
+    if (idMatch?.[1]) {
+      currentId = idMatch[1].replace(/^["']|["']$/g, "");
+      currentContent = void 0;
+      continue;
+    }
+    const contentMatch = line.match(/^\s*content:\s*(.+)$/);
+    if (contentMatch?.[1] && currentId) {
+      currentContent = contentMatch[1].trim();
+      continue;
+    }
+    const statusMatch = line.match(/^\s*status:\s*(\S+)/);
+    if (statusMatch?.[1] && currentId) {
+      const todo = { id: currentId, status: statusMatch[1] };
+      if (currentContent !== void 0) todo.content = currentContent;
+      todos.push(todo);
+      currentId = void 0;
+      currentContent = void 0;
+    }
+  }
+  return { name, todos };
+}
+async function buildPlanIndex(root, io = defaultPlanIndexIo(), now = () => /* @__PURE__ */ new Date()) {
+  const handoffPath = path.join(root, HANDOFF_REL);
+  const handoffText = await io.readFile(handoffPath) ?? "";
+  const named = extractHandoffNamedPlans(handoffText);
+  const plans = [];
+  for (const file of collectNamedPlanBasenames(named)) {
+    const text = await readNamedPlanFile(root, file, io);
+    const fm = text ? parsePlanFrontmatter(text) : { todos: [] };
+    const pendingTodoIds = fm.todos.filter((t) => OPEN_STATUSES.has(t.status)).map((t) => t.id);
+    const openTodos = pendingTodoIds.length > 0;
+    const role = classifyPlanRole(file, named, openTodos);
+    if (!role) continue;
+    const exhausted = text !== null && fm.todos.length > 0 && fm.todos.every((t) => DONE_STATUSES.has(t.status));
+    const entry = {
+      file,
+      role,
+      openTodos,
+      pendingTodoIds,
+      exhausted
+    };
+    if (fm.name) entry.name = fm.name;
+    if (!text) entry.missing = true;
+    plans.push(entry);
+  }
+  return {
+    generatedAt: now().toISOString(),
+    source: "handoff-named",
+    plans
+  };
+}
+async function writePlanIndex(root, io = defaultPlanIndexIo(), now = () => /* @__PURE__ */ new Date()) {
+  const index = await buildPlanIndex(root, io, now);
+  const dest = path.join(root, PLAN_INDEX_REL);
+  const write = io.writeFile ?? defaultPlanIndexIo().writeFile;
+  if (write) {
+    await write(dest, `${JSON.stringify(index, null, 2)}
+`);
+  }
+  return index;
+}
+function formatPlanIndexLines(index) {
+  const lines = index.plans.filter((p) => !p.exhausted).map((p) => {
+    const open = p.openTodos ? ` (${p.pendingTodoIds.length} open)` : "";
+    return `- ${p.role}: \`${p.file}\`${open}`;
+  });
+  const exhausted = index.plans.filter((p) => p.exhausted).map((p) => `\`${p.file}\``);
+  if (exhausted.length > 0) lines.push(`- exhausted (retire): ${exhausted.join(", ")}`);
+  return lines;
+}
+function formatPlanIndexSection(index) {
+  if (index.plans.length === 0) return null;
+  return `## Pending plans (index)
+
+${formatPlanIndexLines(index).join("\n")}`;
+}
+async function readNamedPlanFile(root, basename, io) {
+  for (const candidate of namedPlanCandidatePaths(root, basename)) {
+    const text = await io.readFile(candidate);
+    if (text !== null) return text;
+  }
+  return null;
+}
+function extractActivePlan(content) {
+  const match = content.match(/^- \*\*Plan:\*\*\s*(.+)$/m);
+  if (!match?.[1]) return null;
+  let raw = match[1].trim();
+  const tick = raw.match(/^`([^`]+)`/);
+  if (tick?.[1]) raw = tick[1].trim();
+  if (!raw || NONE.test(raw)) return null;
+  return raw.match(/([A-Za-z0-9._-]+\.plan\.md)/i)?.[1] ?? null;
+}
+function extractFieldBlock(content, label) {
+  const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`^- \\*\\*${escaped}:\\*\\*\\s*(.*)$`, "m");
+  const match = content.match(re);
+  if (!match) return null;
+  const chunks = [];
+  const same = (match[1] ?? "").trim();
+  if (same) chunks.push(same);
+  const after = content.slice((match.index ?? 0) + match[0].length);
+  for (const line of after.split("\n")) {
+    if (/^- \*\*[^*:\n]+:\*\*/.test(line)) break;
+    if (!line.trim()) continue;
+    if (/^\s+\S/.test(line)) {
+      chunks.push(line.trim());
+      continue;
+    }
+    break;
+  }
+  return chunks.join("\n").trim() || null;
+}
+function extractPlanBasenames(raw) {
+  if (!raw) return [];
+  const text = raw.trim().replace(/^\[/, "").replace(/\]\s*$/, "");
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ticks = [...text.matchAll(/`([^`]+)`/g)].map((m) => m[1]);
+  const parts = ticks.length > 0 ? ticks : text.split(/[,;\n]/);
+  for (const part of parts) {
+    const cleaned = String(part).replace(/\(.*?\)/g, "").trim().replace(/^-\s*/, "").replace(/^\[/, "").replace(/\]$/, "").replace(/^plans\//, "");
+    if (!cleaned || NONE.test(cleaned)) continue;
+    const base = cleaned.split("/").pop();
+    if (!base || !/\.plan\.md$/i.test(base) || seen.has(base)) continue;
+    seen.add(base);
+    ids.push(base);
+  }
+  return ids;
+}
+
+export {
+  extractHandoffNamedPlans,
+  namedPlanCandidatePaths,
+  parsePlanFrontmatter,
+  writePlanIndex,
+  formatPlanIndexLines,
+  formatPlanIndexSection,
+  extractFieldBlock
+};

package/dist/chunk-MAPOQEA2.js

@@ -0,0 +1,43 @@
+// src/generator/claude-permissions.ts
+var SHARED_DENY_RULES = [
+  "Bash(git push * main)",
+  "Bash(git push * main *)",
+  "Bash(git push *:main*)",
+  "Bash(git push *+main*)",
+  "Bash(git push *refs/heads/main*)",
+  "Bash(git push * master)",
+  "Bash(git push * master *)",
+  "Bash(git push *:master*)",
+  "Bash(git push *+master*)",
+  "Bash(git push *refs/heads/master*)",
+  "Bash(git push * @)",
+  "Bash(git push --force*)",
+  "Bash(git push * --force*)",
+  "Bash(git push -f*)",
+  "Bash(git push * -f*)",
+  "Bash(git push *--no-veri*)",
+  "Bash(git push * +*)",
+  // Any git global option before a push token (-C, -c, -P, --no-pager, --config-env, ...).
+  "Bash(git -* push*)"
+];
+var HEADLESS_ONLY_DENY_RULES = [
+  "Bash(ALLOW_MAIN_PUSH=*)",
+  "Skill(git-prod)",
+  "Skill(kit-prod)",
+  "Edit(.cursor/hooks/**)",
+  "Write(.cursor/hooks/**)",
+  "Edit(.claude/settings.json)",
+  "Write(.claude/settings.json)",
+  "Edit(packages/cli/dist/**)",
+  "Write(packages/cli/dist/**)"
+];
+var HEADLESS_DENY_RULES = [
+  ...SHARED_DENY_RULES,
+  ...HEADLESS_ONLY_DENY_RULES
+];
+var INTERACTIVE_DENY_RULES = [...SHARED_DENY_RULES];
+
+export {
+  HEADLESS_DENY_RULES,
+  INTERACTIVE_DENY_RULES
+};