@dadado/agent-kit-cli 5.15.0 → 5.16.0

package/dist/chunk-VY7MTPJ2.js

@@ -0,0 +1,205 @@
+import {
+  PUBLIC_INBOUND_REPO,
+  detectFactoryCheckout
+} from "./chunk-2IPXQFJE.js";
+
+// src/lifecycle/remote-issues.ts
+import { execFile } from "child_process";
+import { access } from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var REMOTE_ISSUE_LABEL = "dogfood";
+var REMOTE_ISSUE_TITLE_PREFIX = "[Dogfood]";
+function parseRemoteUrl(url) {
+  const trimmed = url.trim();
+  const match = /^(?:[a-z+]+:\/\/)?(?:[^@/]+@)?([^:/\s]+)(?::\d+)?[:/](.+?)(?:\.git)?\/?$/i.exec(
+    trimmed
+  );
+  if (!match) return null;
+  const host = (match[1] ?? "").toLowerCase();
+  const repo = (match[2] ?? "").replace(/^\/+/, "");
+  if (!repo.includes("/")) return null;
+  const provider = /gitlab|(^|\.)git\.[^.]+\./i.test(host) ? "gitlab" : "github";
+  return { provider, host, repo };
+}
+function matchesProvenance(title, labels, env = process.env) {
+  const wanted = /* @__PURE__ */ new Set([
+    REMOTE_ISSUE_LABEL,
+    ...(env.AGENT_KIT_REMOTE_ISSUE_LABELS ?? "").split(",").map((l) => l.trim().toLowerCase()).filter(Boolean)
+  ]);
+  if (labels.some((label) => wanted.has(label.toLowerCase()))) return true;
+  return title.trim().toLowerCase().startsWith(REMOTE_ISSUE_TITLE_PREFIX.toLowerCase());
+}
+async function defaultRunCli(bin, args, options) {
+  const { stdout } = await execFileAsync(bin, args, {
+    cwd: options?.cwd,
+    encoding: "utf8",
+    maxBuffer: 4 * 1024 * 1024,
+    timeout: 3e4
+  });
+  return stdout;
+}
+async function defaultGetRemoteUrl(cwd, name) {
+  try {
+    const { stdout } = await execFileAsync("git", ["remote", "get-url", name], {
+      cwd,
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function classifyFailure(error) {
+  const err = error;
+  const text = `${String(err?.message ?? "")} ${String(err?.stderr ?? "")}`;
+  if (err?.code === "ENOENT" || /ENOENT|command not found/i.test(text))
+    return "skipped-cli-missing";
+  if (/auth|login|401|403|token|credential/i.test(text)) return "skipped-auth";
+  if (/ENOTFOUND|EAI_AGAIN|ECONNREFUSED|network|resolve host|timed? ?out|offline/i.test(text)) {
+    return "skipped-offline";
+  }
+  return "skipped-error";
+}
+function labelNames(labels) {
+  if (!Array.isArray(labels)) return [];
+  return labels.map((entry) => typeof entry === "string" ? entry : entry?.name).filter((name) => typeof name === "string" && name.length > 0);
+}
+function parseRows(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return [];
+  const parsed = JSON.parse(trimmed);
+  return Array.isArray(parsed) ? parsed : [];
+}
+async function listGithub(runCli, cwd, remote, role) {
+  const stdout = await runCli(
+    "gh",
+    [
+      "issue",
+      "list",
+      "--repo",
+      remote.repo,
+      "--state",
+      "open",
+      "--limit",
+      "100",
+      "--json",
+      "number,title,updatedAt,labels,url"
+    ],
+    { cwd }
+  );
+  return parseRows(stdout).flatMap(
+    (row) => toItem(role, remote, row.number, row.title, row.url, row.updatedAt, row.labels)
+  );
+}
+async function listGitlab(runCli, cwd, remote, role) {
+  const project = encodeURIComponent(remote.repo);
+  const args = ["api"];
+  if (remote.host !== "gitlab.com") args.push("--hostname", remote.host);
+  args.push(`projects/${project}/issues?state=opened&per_page=100`);
+  const stdout = await runCli("glab", args, { cwd });
+  return parseRows(stdout).flatMap(
+    (row) => toItem(role, remote, row.iid, row.title, row.web_url, row.updated_at, row.labels)
+  );
+}
+function toItem(role, remote, rawNumber, rawTitle, rawUrl, rawUpdated, rawLabels) {
+  const number = typeof rawNumber === "number" ? rawNumber : Number(rawNumber);
+  if (!Number.isFinite(number) || number <= 0) return [];
+  const title = typeof rawTitle === "string" && rawTitle.trim() ? rawTitle.trim() : "(no title)";
+  const labels = labelNames(rawLabels);
+  if (!matchesProvenance(title, labels)) return [];
+  return [
+    {
+      role,
+      provider: remote.provider,
+      repo: remote.repo,
+      number,
+      title,
+      url: typeof rawUrl === "string" && rawUrl.trim() ? rawUrl.trim() : `https://${remote.host}/${remote.repo}/issues/${number}`,
+      labels,
+      updatedAt: typeof rawUpdated === "string" ? rawUpdated.trim() : "",
+      cite: `${remote.repo}#${number}`
+    }
+  ];
+}
+async function readTarget(runCli, cwd, role, url) {
+  const remote = url ? parseRemoteUrl(url) : null;
+  if (!remote) {
+    return { role, provider: null, host: null, repo: null, status: "skipped-no-remote", items: [] };
+  }
+  const base = { role, provider: remote.provider, host: remote.host, repo: remote.repo };
+  try {
+    const items = remote.provider === "gitlab" ? await listGitlab(runCli, cwd, remote, role) : await listGithub(runCli, cwd, remote, role);
+    return { ...base, status: "ok", items };
+  } catch (error) {
+    return { ...base, status: classifyFailure(error), items: [] };
+  }
+}
+function noteFor(target) {
+  if (target.status === "ok") return null;
+  const where = target.repo ? `${target.role} ${target.repo}` : `${target.role} remote`;
+  const bin = target.provider === "gitlab" ? "glab" : "gh";
+  const reason = {
+    "skipped-no-remote": "no remote configured",
+    "skipped-cli-missing": `${bin} not installed`,
+    "skipped-auth": `${bin} not authenticated`,
+    "skipped-offline": "offline or host unreachable",
+    "skipped-error": "remote read failed"
+  };
+  return {
+    label: "note",
+    message: `Remote issues skipped for ${where}: ${reason[target.status]}. Local inbox only.`
+  };
+}
+async function readRemoteIssues(cwd, options = {}) {
+  const now = options.now?.() ?? /* @__PURE__ */ new Date();
+  const runCli = options.runCli ?? defaultRunCli;
+  const getRemoteUrl = options.getRemoteUrl ?? defaultGetRemoteUrl;
+  const isFactory = options.isFactory ?? detectFactoryCheckout;
+  const root = path.resolve(cwd);
+  let readable = true;
+  try {
+    await access(root);
+  } catch {
+    readable = false;
+  }
+  const factory = readable ? await isFactory(root) : false;
+  const lane = factory ? "factory" : "consumer";
+  const targets = [];
+  if (readable) {
+    targets.push(await readTarget(runCli, root, "origin", await getRemoteUrl(root, "origin")));
+    if (factory) {
+      const publicUrl = await getRemoteUrl(root, "public") ?? `https://github.com/${PUBLIC_INBOUND_REPO}.git`;
+      targets.push(await readTarget(runCli, root, "public", publicUrl));
+    }
+  } else {
+    targets.push({
+      role: "origin",
+      provider: null,
+      host: null,
+      repo: null,
+      status: "skipped-error",
+      items: []
+    });
+  }
+  const notes = targets.flatMap((target) => {
+    const note = noteFor(target);
+    return note ? [note] : [];
+  });
+  return {
+    lane,
+    checkedAt: now.toISOString(),
+    targets,
+    items: targets.flatMap((target) => target.items),
+    notes,
+    mutateRecommended: false
+  };
+}
+
+export {
+  REMOTE_ISSUE_TITLE_PREFIX,
+  parseRemoteUrl,
+  readRemoteIssues
+};

package/dist/chunk-WW3YZKHW.js

@@ -0,0 +1,165 @@
+import {
+  RESERVED_GATE_IDS,
+  checkClaudeVersion,
+  claudeChildEnv,
+  claudeHeadlessArgs,
+  claudeRedactions,
+  claudeRunCaps,
+  cursorAgentHeadlessArgs,
+  redactSecrets,
+  resolveHitlRunOptions,
+  spawnLogged
+} from "./chunk-OUQZC744.js";
+import {
+  fileExists
+} from "./chunk-77V75A7O.js";
+
+// src/plan-loop/dispatch.ts
+import { mkdir, readFile } from "fs/promises";
+import path from "path";
+var RUN_CATALOG = [
+  "run-plan",
+  "run-plan-all",
+  "continue-plan",
+  "start-project",
+  "backlog-add",
+  "backlog-edit",
+  "backlog-delete",
+  "backlog-cancel",
+  "git-staging"
+];
+var FIRST_CLASS_SLASH_COMMANDS = ["run-plan", "run-plan-all"];
+var RUN_PROMOTE_BLOCKED = RESERVED_GATE_IDS;
+function normalizeSlashName(raw) {
+  return raw.replace(/^\//, "").replace(/\.md$/i, "").trim();
+}
+function classifySlash(name) {
+  const n = normalizeSlashName(name);
+  if (RUN_PROMOTE_BLOCKED.includes(n)) return "promote-blocked";
+  if (n === "run-plan") return "run-plan";
+  if (RUN_CATALOG.includes(n)) return "catalog";
+  return "unknown";
+}
+function rewriteRootArgvToRun(argv) {
+  const idx = argv.findIndex((arg) => arg.length > 0 && !arg.startsWith("-"));
+  if (idx < 0) return argv;
+  const token = argv[idx];
+  if (!token || token === "run") return argv;
+  const kind = classifySlash(token);
+  if (kind === "unknown") return argv;
+  const slash = normalizeSlashName(token);
+  if (FIRST_CLASS_SLASH_COMMANDS.includes(slash)) {
+    if (token === slash) return argv;
+    const next2 = [...argv];
+    next2[idx] = slash;
+    return next2;
+  }
+  const next = [...argv];
+  next.splice(idx, 1, "run", slash);
+  return next;
+}
+function commandMarkdownPath(root, name) {
+  return path.join(root, ".cursor", "commands", `${normalizeSlashName(name)}.md`);
+}
+function buildDispatchPrompt(commandBody) {
+  return [
+    "Follow the Agent Kit command below. This session is headless: use numbered-list HITL (Ask questions is Cursor-only). Before each numbered list print one line `HITL_GATE: <ask-id> | <label 1> | <label 2> | ...` (ask-id and labels from the hitl-gates skill), then wait; the operator's answer arrives as `HITL_REPLY: <ask-id> | operator reply <n> | <label>`. Never /git-prod. No CLI --force promote.",
+    "",
+    commandBody.trimEnd(),
+    ""
+  ].join("\n");
+}
+function promoteBlockedMessage(name) {
+  const n = normalizeSlashName(name);
+  return `${n} is operator-gated and omitted from agent-kit run. Use the Cursor slash /${n} (explicit yes). Never auto /git-prod.`;
+}
+function unknownSlashMessage(name) {
+  return `Unknown or unsupported slash '${name}'. Catalog: ${RUN_CATALOG.join(", ")}. git-prod and kit-prod are omitted (operator-gated).`;
+}
+async function readCommandFile(root, name) {
+  const filePath = commandMarkdownPath(root, name);
+  if (!await fileExists(filePath)) {
+    return {
+      ok: false,
+      message: `Command file not found: ${filePath}. Install or refresh Agent Kit L0 so .cursor/commands/${normalizeSlashName(name)}.md exists.`
+    };
+  }
+  const body = await readFile(filePath, "utf8");
+  return { ok: true, path: filePath, body };
+}
+function stamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}${p(d.getMilliseconds(), 3)}`;
+}
+function cursorAgentDispatchArgs(opts) {
+  return cursorAgentHeadlessArgs(opts);
+}
+function claudeDispatchArgs(opts = {}) {
+  return claudeHeadlessArgs(opts);
+}
+async function runHeadlessDispatch(opts) {
+  if (opts.backendId === "claude") {
+    const log = opts.log ?? ((line) => console.log(line));
+    const env = claudeChildEnv();
+    const redact = claudeRedactions(env);
+    const version = checkClaudeVersion(opts.bin, opts.versionFn);
+    if (!version.ok) throw new Error(`claude dispatch: ${version.message}`);
+    if (version.warning) log(version.warning);
+    const { caps, invalid } = claudeRunCaps(env);
+    for (const problem of invalid)
+      log(`claude dispatch: ignoring invalid ${problem}; running uncapped.`);
+    try {
+      return await spawnLogged(
+        opts.bin,
+        claudeDispatchArgs({ model: opts.model, ...caps }),
+        opts.logPath,
+        {
+          cwd: opts.workspace,
+          env,
+          redact,
+          spawnFn: opts.spawnFn,
+          hitl: resolveHitlRunOptions(opts.hitl, {
+            kind: "stdin-stream-json",
+            firstPrompt: opts.prompt
+          }),
+          render: opts.render,
+          onSpawn: opts.onSpawn,
+          backendId: "claude"
+        }
+      );
+    } catch (err) {
+      throw new Error(`claude dispatch failed to start: ${redactSecrets(String(err), redact)}`);
+    }
+  }
+  const args = cursorAgentDispatchArgs({
+    workspace: opts.workspace,
+    prompt: opts.prompt,
+    model: opts.model
+  });
+  return spawnLogged(opts.bin, args, opts.logPath, {
+    spawnFn: opts.spawnFn,
+    redact: claudeRedactions(process.env),
+    hitl: resolveHitlRunOptions(opts.hitl, { kind: "none", backend: "cursor-agent" }),
+    render: opts.render,
+    onSpawn: opts.onSpawn,
+    backendId: "cursor-agent"
+  });
+}
+async function ensureDispatchLogPath(root) {
+  const logDir = path.join(root, ".cursor", "loop-logs");
+  await mkdir(logDir, { recursive: true });
+  return path.join(logDir, `run-${stamp()}.log`);
+}
+
+export {
+  normalizeSlashName,
+  classifySlash,
+  rewriteRootArgvToRun,
+  buildDispatchPrompt,
+  promoteBlockedMessage,
+  unknownSlashMessage,
+  readCommandFile,
+  runHeadlessDispatch,
+  ensureDispatchLogPath
+};

package/dist/chunk-XWPO3VYQ.js

@@ -0,0 +1,53 @@
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  DEFAULT_REGISTRY_REF,
+  DEFAULT_REGISTRY_URL,
+  resolveRegistryRoot
+} from "./chunk-VS2JD2XC.js";
+
+// src/lifecycle/resolve-cli.ts
+async function resolveRegistryFromCli(options) {
+  const fromManifest = options.manifest?.registry;
+  if (!options.registry && !options.url && fromManifest?.url) {
+    const ref = options.ref ?? fromManifest.ref ?? DEFAULT_REGISTRY_REF;
+    logger.info(`registry: ${fromManifest.url}@${ref} (from manifest)`);
+    if (fromManifest.url !== DEFAULT_REGISTRY_URL) {
+      logger.warn(
+        `registry url from .cursor/agent-kit.json is not the default ${DEFAULT_REGISTRY_URL}; verify you trust ${fromManifest.url}`
+      );
+    }
+  }
+  return resolveRegistryRoot({
+    cwd: options.cwd,
+    registryPath: options.registry,
+    registryUrl: options.url ?? fromManifest?.url,
+    registryRef: options.ref ?? fromManifest?.ref,
+    refresh: options.refresh
+  });
+}
+var REGISTRY_CLI_ARGS = {
+  registry: {
+    type: "string",
+    description: "Local path to a kit checkout that contains registry/"
+  },
+  url: {
+    type: "string",
+    description: "Remote registry git URL (default: public agent-kit)"
+  },
+  ref: {
+    type: "string",
+    description: "Git ref for remote registry (branch or tag)"
+  },
+  refresh: {
+    type: "boolean",
+    description: "Refresh cached remote registry",
+    default: false
+  }
+};
+
+export {
+  resolveRegistryFromCli,
+  REGISTRY_CLI_ARGS
+};