@dadado/agent-kit-cli 5.15.1 → 5.16.0

package/dist/chunk-CGTE7DHN.js

@@ -0,0 +1,410 @@
+import {
+  INTERACTIVE_DENY_RULES
+} from "./chunk-MAPOQEA2.js";
+import {
+  assertRealContained,
+  assertRealParentContained,
+  isRealWriteTargetContained,
+  resolveContained
+} from "./chunk-VS2JD2XC.js";
+import {
+  ensureDir
+} from "./chunk-77V75A7O.js";
+
+// src/generator/claude-session-start-hook.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+
+// src/generator/claude-settings-ledger.ts
+import { lstat, mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+var CLAUDE_SETTINGS_LEDGER_REL = ".cursor/agent-kit.claude-settings.json";
+var ClaudeSettingsLedgerSymlinkError = class extends Error {
+  constructor(path3, detail) {
+    super(`Refusing to use Claude settings ledger ${path3}: ${detail}`);
+    this.path = path3;
+    this.name = "ClaudeSettingsLedgerSymlinkError";
+  }
+  path;
+};
+var ClaudeSettingsLedgerInvalidError = class extends Error {
+  constructor(path3) {
+    super(
+      `Claude settings ledger ${path3} is malformed or has an unknown schemaVersion; not overwriting without authorization.`
+    );
+    this.path = path3;
+    this.name = "ClaudeSettingsLedgerInvalidError";
+  }
+  path;
+};
+function emptyLedger() {
+  return { schemaVersion: 1, denyRowsWritten: [], hookEntriesWritten: [] };
+}
+function hookKey(r) {
+  return `${r.event}\0${r.marker}`;
+}
+function normalize(denyRows, hooks) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const h of hooks) seen.set(hookKey(h), { event: h.event, marker: h.marker });
+  return {
+    schemaVersion: 1,
+    denyRowsWritten: [...new Set(denyRows)].sort(),
+    hookEntriesWritten: [...seen.values()].sort(
+      (a, b) => a.event.localeCompare(b.event) || a.marker.localeCompare(b.marker)
+    )
+  };
+}
+function parseLedger(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return null;
+  const o = data;
+  if (o.schemaVersion !== 1) return null;
+  if (!Array.isArray(o.denyRowsWritten) || !o.denyRowsWritten.every((r) => typeof r === "string")) {
+    return null;
+  }
+  if (!Array.isArray(o.hookEntriesWritten)) return null;
+  const hooks = [];
+  for (const h of o.hookEntriesWritten) {
+    if (typeof h !== "object" || h === null || typeof h.event !== "string" || typeof h.marker !== "string") {
+      return null;
+    }
+    hooks.push({
+      event: h.event,
+      marker: h.marker
+    });
+  }
+  return normalize(o.denyRowsWritten, hooks);
+}
+async function readState(root) {
+  const abs = resolveContained(root, CLAUDE_SETTINGS_LEDGER_REL);
+  let exists = true;
+  try {
+    await lstat(abs);
+  } catch {
+    exists = false;
+  }
+  try {
+    if (exists) await assertRealContained(root, abs);
+    else await assertRealParentContained(root, abs);
+  } catch (err) {
+    throw new ClaudeSettingsLedgerSymlinkError(
+      abs,
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+  if (!exists) return { abs, state: { kind: "missing" } };
+  const ledger = parseLedger(await readFile(abs, "utf8"));
+  return { abs, state: ledger ? { kind: "ok", ledger } : { kind: "invalid" } };
+}
+async function loadClaudeSettingsLedger(root) {
+  const { state } = await readState(root);
+  return state.kind === "ok" ? state.ledger : null;
+}
+async function saveClaudeSettingsLedger(root, additions, opts = {}) {
+  const { abs, state } = await readState(root);
+  if (state.kind === "invalid" && !opts.overwriteInvalid) {
+    throw new ClaudeSettingsLedgerInvalidError(abs);
+  }
+  const base = state.kind === "ok" ? state.ledger : emptyLedger();
+  const merged = normalize(
+    [...base.denyRowsWritten, ...additions.denyRowsWritten ?? []],
+    [...base.hookEntriesWritten, ...additions.hookEntriesWritten ?? []]
+  );
+  await mkdir(path.dirname(abs), { recursive: true });
+  await writeFile(abs, `${JSON.stringify(merged, null, 2)}
+`, "utf8");
+  return merged;
+}
+
+// src/generator/claude-session-start-hook.ts
+var CLAUDE_SETTINGS_REL = ".claude/settings.json";
+var RESOLVE_AGENT_KIT_REL = ".cursor/hooks/agent/resolve-agent-kit.sh";
+var SESSION_START_HOOK_MARKER = "hook session-start --format claude";
+var SESSION_START_DEGRADED_TEXT = "Agent Kit hooks are running in degraded fail-open mode: the agent-kit CLI could not be resolved (checked AGENT_KIT_HOOK_BIN, node_modules/.bin/agent-kit, PATH), or it resolved to a node script and node is not on PATH. Slash command adapters still work; session-context injection is inactive. Fix: install the CLI (npm i -D @dadado/agent-kit-cli), put node on PATH, or set AGENT_KIT_HOOK_BIN.";
+function buildSessionStartHookCommand() {
+  const run = `{ if command -v run_agent_kit >/dev/null 2>&1; then run_agent_kit ${SESSION_START_HOOK_MARKER}; else exec $AGENT_KIT_RESOLVED ${SESSION_START_HOOK_MARKER}; fi; }`;
+  return `_AGENT_KIT_HOOK_ROOT="\${CLAUDE_PROJECT_DIR}"; . "\${CLAUDE_PROJECT_DIR}/${RESOLVE_AGENT_KIT_REL}" 2>/dev/null && resolve_agent_kit && ${run}; printf '%s' ${shellSingleQuote(SESSION_START_DEGRADED_TEXT)}`;
+}
+var GUARD_SHELL_HOOK_MARKER = "guard shell --format claude";
+function buildGuardShellHookCommand() {
+  const run = `{ if command -v run_agent_kit >/dev/null 2>&1; then run_agent_kit ${GUARD_SHELL_HOOK_MARKER}; else exec $AGENT_KIT_RESOLVED ${GUARD_SHELL_HOOK_MARKER}; fi; }`;
+  return `_AGENT_KIT_HOOK_ROOT="\${CLAUDE_PROJECT_DIR}"; . "\${CLAUDE_PROJECT_DIR}/${RESOLVE_AGENT_KIT_REL}" 2>/dev/null && resolve_agent_kit && ${run}; :`;
+}
+function buildGuardShellHookEntry() {
+  return { type: "command", command: buildGuardShellHookCommand(), timeout: 10 };
+}
+function shellSingleQuote(text) {
+  return `'${text.replace(/'/g, "'\\''")}'`;
+}
+function buildSessionStartHookEntry() {
+  return {
+    type: "command",
+    command: buildSessionStartHookCommand(),
+    timeout: 15,
+    statusMessage: "Loading Agent Kit session context"
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function groupHasMarker(group, marker) {
+  if (!isPlainObject(group) || !Array.isArray(group.hooks)) return false;
+  return group.hooks.some(
+    (h) => isPlainObject(h) && typeof h.command === "string" && h.command.includes(marker)
+  );
+}
+function upsertMarkedGroup(arr, group, marker) {
+  const existingIndex = arr.findIndex((g) => groupHasMarker(g, marker));
+  if (existingIndex === -1) {
+    arr.push(group);
+    return "applied";
+  }
+  if (JSON.stringify(arr[existingIndex]) === JSON.stringify(group)) return "unchanged";
+  arr[existingIndex] = group;
+  return "refreshed";
+}
+var SESSION_START_EVENT = "SessionStart";
+var PRE_TOOL_USE_EVENT = "PreToolUse";
+function mergeSessionStartHookIntoSettings(existingRaw, opts = {}) {
+  const ledger = opts.ledger ?? null;
+  const authorized = opts.authorized ?? true;
+  const entry = buildSessionStartHookEntry();
+  const newGroup = { hooks: [entry] };
+  let root = {};
+  if (existingRaw !== null && existingRaw.trim() !== "") {
+    try {
+      const parsed = JSON.parse(existingRaw);
+      if (!isPlainObject(parsed)) throw new Error("root is not an object");
+      root = parsed;
+    } catch {
+      return {
+        content: null,
+        status: "unavailable",
+        instructions: instructionsBlock(entry)
+      };
+    }
+  }
+  const pending = { denyRows: [], hookEntries: [] };
+  const additions = { denyRowsWritten: [], hookEntriesWritten: [] };
+  const hooks = isPlainObject(root.hooks) ? { ...root.hooks } : {};
+  const sessionStart = Array.isArray(hooks.SessionStart) ? [...hooks.SessionStart] : [];
+  const preToolUse = Array.isArray(hooks.PreToolUse) ? [...hooks.PreToolUse] : [];
+  const upserts = [
+    upsertLedgerAwareGroup({
+      arr: sessionStart,
+      group: newGroup,
+      event: SESSION_START_EVENT,
+      marker: SESSION_START_HOOK_MARKER
+    }),
+    upsertLedgerAwareGroup({
+      arr: preToolUse,
+      group: { matcher: "Bash", hooks: [buildGuardShellHookEntry()] },
+      event: PRE_TOOL_USE_EVENT,
+      marker: GUARD_SHELL_HOOK_MARKER
+    })
+  ];
+  hooks.SessionStart = sessionStart;
+  hooks.PreToolUse = preToolUse;
+  root.hooks = hooks;
+  function upsertLedgerAwareGroup(g) {
+    const record = { event: g.event, marker: g.marker };
+    if (g.arr.some((x) => groupHasMarker(x, g.marker))) {
+      additions.hookEntriesWritten.push(record);
+      return upsertMarkedGroup(g.arr, g.group, g.marker);
+    }
+    if (ledger?.hookEntriesWritten.some((h) => h.event === g.event && h.marker === g.marker)) {
+      return "unchanged";
+    }
+    if (ledger === null && !authorized) {
+      pending.hookEntries.push(record);
+      return "unchanged";
+    }
+    additions.hookEntriesWritten.push(record);
+    return upsertMarkedGroup(g.arr, g.group, g.marker);
+  }
+  const status = upserts.reduce(
+    (acc, next, i) => i === 0 ? next : combineStatus(acc, next),
+    "unchanged"
+  );
+  const denyAdded = mergeKitDenyRules(root, { ledger, authorized }, pending, additions);
+  const finalStatus = denyAdded && status === "unchanged" ? "refreshed" : status;
+  return {
+    content: `${JSON.stringify(root, null, 2)}
+`,
+    status: finalStatus,
+    pending,
+    ledgerAdditions: additions
+  };
+}
+function combineStatus(a, b) {
+  return a === "unchanged" && b !== "unchanged" ? "refreshed" : a;
+}
+function mergeKitDenyRules(root, ctx, pending, additions) {
+  if (root.permissions !== void 0 && !isPlainObject(root.permissions)) return false;
+  const permissions = isPlainObject(root.permissions) ? { ...root.permissions } : {};
+  if (permissions.deny !== void 0 && !Array.isArray(permissions.deny)) return false;
+  const deny = Array.isArray(permissions.deny) ? [...permissions.deny] : [];
+  const written = new Set(ctx.ledger?.denyRowsWritten ?? []);
+  for (const rule of INTERACTIVE_DENY_RULES) {
+    if (deny.includes(rule)) additions.denyRowsWritten.push(rule);
+  }
+  const missing = INTERACTIVE_DENY_RULES.filter(
+    (rule) => !deny.includes(rule) && !written.has(rule)
+  );
+  const toAdd = ctx.ledger === null && !ctx.authorized ? [] : missing;
+  if (ctx.ledger === null && !ctx.authorized) pending.denyRows.push(...missing);
+  if (toAdd.length === 0) return false;
+  additions.denyRowsWritten.push(...toAdd);
+  permissions.deny = [...deny, ...toAdd];
+  root.permissions = permissions;
+  return true;
+}
+function instructionsBlock(entry) {
+  return [
+    `Could not parse the existing ${CLAUDE_SETTINGS_REL} as JSON, so Agent Kit did not touch it.`,
+    "Add these hooks by hand (create the arrays if they do not exist).",
+    "Under hooks.SessionStart:",
+    "",
+    JSON.stringify(entry, null, 2),
+    "",
+    'Under hooks.PreToolUse, in a group with "matcher": "Bash":',
+    "",
+    JSON.stringify(buildGuardShellHookEntry(), null, 2)
+  ].join("\n");
+}
+async function writeClaudeSessionStartHook(rootDir, opts = {}) {
+  const authorized = opts.authorized ?? true;
+  const abs = resolveContained(rootDir, CLAUDE_SETTINGS_REL);
+  if (!await isRealWriteTargetContained(rootDir, abs)) {
+    return { relativePath: CLAUDE_SETTINGS_REL, status: "skipped-symlink" };
+  }
+  let ledger;
+  try {
+    ledger = await loadClaudeSettingsLedger(rootDir);
+  } catch (err) {
+    if (err instanceof ClaudeSettingsLedgerSymlinkError) {
+      return { relativePath: CLAUDE_SETTINGS_REL, status: "skipped-symlink" };
+    }
+    throw err;
+  }
+  let existing = null;
+  try {
+    existing = await readFile2(abs, "utf8");
+  } catch {
+    existing = null;
+  }
+  const merged = mergeSessionStartHookIntoSettings(existing, { ledger, authorized });
+  if (merged.status === "unavailable" || merged.content === null) {
+    return {
+      relativePath: CLAUDE_SETTINGS_REL,
+      status: "unavailable",
+      instructions: merged.instructions
+    };
+  }
+  if (merged.status !== "unchanged") {
+    await ensureDir(path2.dirname(abs));
+    await writeFile2(abs, merged.content, "utf8");
+  }
+  const result = {
+    relativePath: CLAUDE_SETTINGS_REL,
+    status: merged.status
+  };
+  if (merged.pending && (merged.pending.denyRows.length || merged.pending.hookEntries.length)) {
+    result.pending = merged.pending;
+  }
+  if (authorized && merged.ledgerAdditions && ledgerGrows(ledger, merged.ledgerAdditions)) {
+    await saveClaudeSettingsLedger(rootDir, merged.ledgerAdditions, { overwriteInvalid: true });
+    result.ledgerPath = CLAUDE_SETTINGS_LEDGER_REL;
+  }
+  return result;
+}
+function ledgerGrows(ledger, add) {
+  if (ledger === null) return true;
+  const rows = new Set(ledger.denyRowsWritten);
+  const hooks = new Set(ledger.hookEntriesWritten.map((h) => `${h.event}\0${h.marker}`));
+  return add.denyRowsWritten.some((r) => !rows.has(r)) || add.hookEntriesWritten.some((h) => !hooks.has(`${h.event}\0${h.marker}`));
+}
+async function planClaudeSettingsDrift(rootDir) {
+  const abs = resolveContained(rootDir, CLAUDE_SETTINGS_REL);
+  if (!await isRealWriteTargetContained(rootDir, abs)) return null;
+  let raw;
+  try {
+    raw = await readFile2(abs, "utf8");
+  } catch {
+    return null;
+  }
+  let existing;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isPlainObject(parsed)) return null;
+    existing = parsed;
+  } catch {
+    return null;
+  }
+  const hooks = isPlainObject(existing.hooks) ? existing.hooks : {};
+  const groupsOf = (event) => Array.isArray(hooks[event]) ? hooks[event] : [];
+  const kitEntries = [
+    { event: SESSION_START_EVENT, marker: SESSION_START_HOOK_MARKER },
+    { event: PRE_TOOL_USE_EVENT, marker: GUARD_SHELL_HOOK_MARKER }
+  ];
+  const present = kitEntries.filter(
+    (e) => groupsOf(e.event).some((g) => groupHasMarker(g, e.marker))
+  );
+  if (present.length === 0) return null;
+  let ledger;
+  try {
+    ledger = await loadClaudeSettingsLedger(rootDir);
+  } catch (err) {
+    if (err instanceof ClaudeSettingsLedgerSymlinkError) return null;
+    throw err;
+  }
+  const merged = mergeSessionStartHookIntoSettings(raw, { ledger, authorized: false });
+  if (merged.content === null) return null;
+  const next = JSON.parse(merged.content);
+  const deny = (r) => isPlainObject(r.permissions) && Array.isArray(r.permissions.deny) ? r.permissions.deny.filter((x) => typeof x === "string") : [];
+  const had = new Set(deny(existing));
+  const denyRows = deny(next).filter((r) => !had.has(r));
+  const ambiguousDenyRows = merged.pending?.denyRows ?? [];
+  const missingEntries = kitEntries.filter((e) => !present.includes(e));
+  const ledgerHas = (e) => Boolean(ledger?.hookEntriesWritten.some((h) => h.event === e.event && h.marker === e.marker));
+  const hookEntries = missingEntries.filter((e) => !ledgerHas(e));
+  if (denyRows.length === 0 && ambiguousDenyRows.length === 0 && hookEntries.length === 0) {
+    return null;
+  }
+  return { denyRows, ambiguousDenyRows, hookEntries };
+}
+function formatClaudeSettingsDrift(report, opts) {
+  const rows = [...report.denyRows, ...report.ambiguousDenyRows];
+  const lines = [
+    `Claude settings drift in ${CLAUDE_SETTINGS_REL}${opts.protectedPath ? " (protected (skipped))" : ""}: update did not write it.`
+  ];
+  if (rows.length > 0) {
+    lines.push("Add to permissions.deny:", JSON.stringify(rows, null, 2));
+    if (report.ambiguousDenyRows.length > 0) {
+      lines.push(
+        `(${report.ambiguousDenyRows.length} row(s) ambiguous: no ${CLAUDE_SETTINGS_LEDGER_REL} ledger, so a deliberate deletion cannot be told apart.)`
+      );
+    }
+  }
+  if (report.hookEntries.length > 0) {
+    lines.push("Missing hook entries (add by hand or use the command below):");
+    for (const e of report.hookEntries) lines.push(`  ${e.event}: ${e.marker}`);
+  }
+  lines.push("Apply with: agent-kit update --claude");
+  return lines;
+}
+
+export {
+  CLAUDE_SETTINGS_REL,
+  RESOLVE_AGENT_KIT_REL,
+  SESSION_START_HOOK_MARKER,
+  GUARD_SHELL_HOOK_MARKER,
+  writeClaudeSessionStartHook,
+  planClaudeSettingsDrift,
+  formatClaudeSettingsDrift
+};

package/dist/chunk-DE3LQFSJ.js

@@ -0,0 +1,18 @@
+// src/hooks/read-stdin-json.ts
+async function readStdinJson() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export {
+  readStdinJson
+};

package/dist/chunk-F6C3GFKV.js

@@ -0,0 +1,57 @@
+// src/types.ts
+var GIT_PLATFORM_META = {
+  github: {
+    cli: "gh",
+    prTerm: "Pull Request",
+    prCommand: "gh pr create",
+    ciDefault: "github-actions"
+  },
+  gitlab: {
+    cli: "glab",
+    prTerm: "Merge Request",
+    prCommand: "glab mr create",
+    ciDefault: "gitlab-ci"
+  },
+  bitbucket: {
+    cli: "bb",
+    prTerm: "Pull Request",
+    prCommand: "bb pr create",
+    ciDefault: "bitbucket-pipelines"
+  },
+  "azure-devops": {
+    cli: "az repos",
+    prTerm: "Pull Request",
+    prCommand: "az repos pr create",
+    ciDefault: "azure-pipelines"
+  },
+  gitea: { cli: "tea", prTerm: "Pull Request", prCommand: "tea pr create", ciDefault: "none" }
+};
+var CI_PLATFORM_FILES = {
+  "github-actions": ".github/workflows",
+  "gitlab-ci": ".gitlab-ci.yml",
+  "azure-pipelines": "azure-pipelines.yml",
+  "bitbucket-pipelines": "bitbucket-pipelines.yml",
+  jenkins: "Jenkinsfile",
+  circleci: ".circleci/config.yml",
+  travis: ".travis.yml"
+};
+var PM_TOOL_LABELS = {
+  clickup: "ClickUp",
+  jira: "Jira",
+  linear: "Linear",
+  asana: "Asana",
+  "github-issues": "GitHub Issues",
+  "github-projects": "GitHub Projects",
+  "azure-boards": "Azure Boards",
+  trello: "Trello",
+  shortcut: "Shortcut",
+  notion: "Notion",
+  youtrack: "YouTrack",
+  none: "None"
+};
+
+export {
+  GIT_PLATFORM_META,
+  CI_PLATFORM_FILES,
+  PM_TOOL_LABELS
+};