@dadado/agent-kit-cli 5.15.1 → 5.16.0

package/dist/add-7UMSGVWC.js

@@ -0,0 +1,150 @@
+import {
+  formatSkippedSymlinks,
+  logApplyStats
+} from "./chunk-HS7LVVLO.js";
+import {
+  REGISTRY_CLI_ARGS,
+  resolveRegistryFromCli
+} from "./chunk-XWPO3VYQ.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  allPacks,
+  allSkills,
+  buildManifest,
+  findPack,
+  findSkill,
+  installPack,
+  installSkill,
+  loadAgentKitManifest,
+  loadRegistry,
+  resolveProtectedGlobs,
+  saveManifest,
+  upsertIdList
+} from "./chunk-VS2JD2XC.js";
+import "./chunk-5VCOWTTP.js";
+import {
+  KIT_VERSION
+} from "./chunk-7HDQEK6T.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/add.ts
+import { defineCommand } from "citty";
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Install a skill or L1 pack from the registry."
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "Skill id or pack id from registry"
+    },
+    skill: {
+      type: "boolean",
+      description: "Force treat id as a skill (when pack shares the same id)",
+      default: false
+    },
+    pack: {
+      type: "boolean",
+      description: "Force treat id as a pack (when skill shares the same id)",
+      default: false
+    },
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    ...REGISTRY_CLI_ARGS
+  },
+  async run({ args }) {
+    if (!args.id) throw new Error("Provide an id: agent-kit add <skill|pack>");
+    if (args.skill && args.pack) {
+      throw new Error("Use only one of --skill or --pack");
+    }
+    const existing = await loadAgentKitManifest(args.cwd, { onWarning: logger.warn });
+    const registry = await resolveRegistryFromCli({
+      cwd: args.cwd,
+      registry: args.registry,
+      url: args.url,
+      ref: args.ref,
+      refresh: args.refresh,
+      manifest: existing
+    });
+    try {
+      const protectedGlobs = resolveProtectedGlobs(existing);
+      const index = await loadRegistry(registry.root);
+      const asSkill = allSkills(index).find((s) => s.id === args.id);
+      const asPack = allPacks(index).find((p) => p.id === args.id);
+      const base = existing ? { ...existing } : buildManifest({
+        version: KIT_VERSION,
+        profile: "default",
+        registryUrl: registry.url,
+        registryRef: registry.ref
+      });
+      const skipped = (stats) => {
+        if (stats.skippedSymlink.length === 0) return false;
+        logger.error(formatSkippedSymlinks(stats.skippedSymlink));
+        process.exitCode = 1;
+        return true;
+      };
+      const finish = async (kind, id) => {
+        if (kind === "skill") base.skills = upsertIdList(base.skills, id);
+        else base.packs = upsertIdList(base.packs, id);
+        if (registry.url || registry.ref) {
+          base.registry = {
+            url: registry.url ?? base.registry?.url,
+            ref: registry.ref ?? base.registry?.ref
+          };
+        }
+        base.version = KIT_VERSION;
+        await saveManifest(args.cwd, base);
+      };
+      if (args.skill) {
+        const skill = await findSkill(registry.root, args.id);
+        const stats = await installSkill(registry.root, args.cwd, skill, { protectedGlobs });
+        logApplyStats(stats);
+        if (skipped(stats)) return;
+        await finish("skill", skill.id);
+        logger.success(`Skill '${skill.id}' added.`);
+        return;
+      }
+      if (args.pack) {
+        const pack = await findPack(registry.root, args.id);
+        const stats = await installPack(registry.root, args.cwd, pack.id, { protectedGlobs });
+        logApplyStats(stats);
+        if (skipped(stats)) return;
+        await finish("pack", pack.id);
+        logger.success(`Pack '${pack.id}' added.`);
+        return;
+      }
+      if (asSkill && asPack) {
+        throw new Error(
+          `'${args.id}' is both a skill and a pack. Disambiguate: agent-kit add --skill ${args.id} | agent-kit add --pack ${args.id}`
+        );
+      }
+      if (asSkill) {
+        const stats = await installSkill(registry.root, args.cwd, asSkill, { protectedGlobs });
+        logApplyStats(stats);
+        if (skipped(stats)) return;
+        await finish("skill", asSkill.id);
+        logger.success(`Skill '${asSkill.id}' added.`);
+        return;
+      }
+      if (asPack) {
+        const stats = await installPack(registry.root, args.cwd, asPack.id, { protectedGlobs });
+        logApplyStats(stats);
+        if (skipped(stats)) return;
+        await finish("pack", asPack.id);
+        logger.success(`Pack '${asPack.id}' added.`);
+        return;
+      }
+      throw new Error(`'${args.id}' not found as skill or pack in registry.`);
+    } finally {
+      await registry.unlock?.();
+    }
+  }
+});
+export {
+  addCommand
+};

package/dist/chunk-2IPXQFJE.js

@@ -0,0 +1,253 @@
+import {
+  contextConfigPath,
+  intervalElapsed,
+  loadContextConfig
+} from "./chunk-NQ7IQ5XT.js";
+import {
+  fileExists,
+  writeJson
+} from "./chunk-77V75A7O.js";
+
+// src/lifecycle/public-inbound-radar.ts
+import { execFile } from "child_process";
+import { access } from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var PUBLIC_INBOUND_REPO = "agent-kit-startup/agent-kit";
+var DEFAULT_PREFS = {
+  enabled: false,
+  intervalDays: 7,
+  lastCheckedAt: null
+};
+function emptySummary() {
+  return { issues: 0, humanPullRequests: 0, dependabotPullRequests: 0, total: 0 };
+}
+function summarize(items) {
+  const summary = emptySummary();
+  for (const item of items) {
+    summary.total += 1;
+    if (item.class === "issue") summary.issues += 1;
+    else if (item.class === "dependabot") summary.dependabotPullRequests += 1;
+    else summary.humanPullRequests += 1;
+  }
+  return summary;
+}
+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 isDependabotAuthor(login) {
+  if (!login) return false;
+  const normalized = login.toLowerCase();
+  return normalized === "dependabot" || normalized === "dependabot[bot]" || normalized === "app/dependabot" || normalized.startsWith("dependabot") || normalized === "renovate" || normalized === "renovate[bot]";
+}
+function classifyInbound(kind, authorLogin) {
+  if (kind === "issue") return "issue";
+  return isDependabotAuthor(authorLogin) ? "dependabot" : "human-pr";
+}
+function readPublicInboundCheckPrefs(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return { ...DEFAULT_PREFS };
+  }
+  const raw = config.publicInboundCheck;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ...DEFAULT_PREFS };
+  }
+  const uc = raw;
+  const intervalDays = typeof uc.intervalDays === "number" && Number.isInteger(uc.intervalDays) && uc.intervalDays >= 1 ? uc.intervalDays : DEFAULT_PREFS.intervalDays;
+  return {
+    enabled: uc.enabled === true,
+    intervalDays,
+    lastCheckedAt: typeof uc.lastCheckedAt === "string" ? uc.lastCheckedAt : null
+  };
+}
+async function stampPublicInboundCheck(cwd, checkedAt) {
+  const existing = await loadContextConfig(cwd) ?? {};
+  const prev = existing.publicInboundCheck && typeof existing.publicInboundCheck === "object" ? { ...existing.publicInboundCheck } : {};
+  existing.publicInboundCheck = {
+    ...DEFAULT_PREFS,
+    ...prev,
+    lastCheckedAt: (checkedAt ?? /* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJson(contextConfigPath(cwd), existing);
+}
+function mapRows(kind, rows) {
+  const items = [];
+  for (const row of rows) {
+    const number = typeof row.number === "number" ? row.number : Number(row.number);
+    if (!Number.isFinite(number) || number <= 0) continue;
+    const author = row.author?.login?.trim() || "unknown";
+    const title = typeof row.title === "string" && row.title.trim() ? row.title.trim() : "(no title)";
+    const updatedAt = typeof row.updatedAt === "string" && row.updatedAt.trim() ? row.updatedAt.trim() : "";
+    const url = typeof row.url === "string" && row.url.trim() ? row.url.trim() : `https://github.com/${PUBLIC_INBOUND_REPO}/${kind === "issue" ? "issues" : "pull"}/${number}`;
+    items.push({
+      kind,
+      class: classifyInbound(kind, author),
+      number,
+      title,
+      author,
+      updatedAt,
+      url,
+      labels: labelNames(row.labels),
+      cite: `${PUBLIC_INBOUND_REPO}#${number}`
+    });
+  }
+  return items;
+}
+async function defaultRunGh(args, options) {
+  const { stdout } = await execFileAsync("gh", args, {
+    cwd: options?.cwd,
+    encoding: "utf8",
+    maxBuffer: 4 * 1024 * 1024,
+    timeout: 3e4
+  });
+  return stdout;
+}
+async function ghAvailable(runGh, cwd) {
+  try {
+    await runGh(["--version"], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectFactoryCheckout(cwd) {
+  const root = path.resolve(cwd);
+  try {
+    const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], {
+      cwd: root,
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    if (/agent-kit-dev/i.test(stdout)) return true;
+  } catch {
+  }
+  return fileExists(path.join(root, "dogfood", "README.md"));
+}
+async function listJson(runGh, cwd, resource) {
+  const stdout = await runGh(
+    [
+      resource,
+      "list",
+      "--repo",
+      PUBLIC_INBOUND_REPO,
+      "--state",
+      "open",
+      "--limit",
+      "100",
+      "--json",
+      "number,title,author,updatedAt,labels,url"
+    ],
+    { cwd }
+  );
+  const trimmed = stdout.trim();
+  if (!trimmed) return [];
+  const parsed = JSON.parse(trimmed);
+  return Array.isArray(parsed) ? parsed : [];
+}
+function resultBase(status, message, factory, now, items = []) {
+  return {
+    status,
+    repo: PUBLIC_INBOUND_REPO,
+    checkedAt: now.toISOString(),
+    factory,
+    items,
+    summary: summarize(items),
+    message,
+    mutateRecommended: false
+  };
+}
+async function checkPublicInbound(cwd, options = {}) {
+  const now = options.now?.() ?? /* @__PURE__ */ new Date();
+  const runGh = options.runGh ?? defaultRunGh;
+  const isFactory = options.isFactory ?? detectFactoryCheckout;
+  const root = path.resolve(cwd);
+  try {
+    await access(root);
+  } catch {
+    return resultBase("error", `cwd unreadable: ${root}`, false, now);
+  }
+  const factory = await isFactory(root);
+  if (!factory) {
+    return resultBase(
+      "skipped-non-factory",
+      "Factory-only check. Aborting outside agent-kit-dev / dogfood checkout.",
+      false,
+      now
+    );
+  }
+  if (options.respectPrefs) {
+    const prefs = readPublicInboundCheckPrefs(await loadContextConfig(root));
+    if (!prefs.enabled) {
+      return resultBase(
+        "skipped-disabled",
+        "publicInboundCheck.enabled is false (opt-in). Set true in .cursor/context/config.json to nudge.",
+        true,
+        now
+      );
+    }
+    if (!intervalElapsed(prefs.lastCheckedAt, prefs.intervalDays)) {
+      return resultBase(
+        "skipped-interval",
+        `Within publicInboundCheck.intervalDays (${prefs.intervalDays}); last check ${prefs.lastCheckedAt}.`,
+        true,
+        now
+      );
+    }
+  }
+  if (options.offline) {
+    return resultBase("skipped-offline", "Offline flag set; skipped GitHub fetch.", true, now);
+  }
+  if (!await ghAvailable(runGh, root)) {
+    return resultBase(
+      "skipped-gh-missing",
+      "gh CLI missing or not runnable; fail-open skip.",
+      true,
+      now
+    );
+  }
+  try {
+    const [issueRows, prRows] = await Promise.all([
+      listJson(runGh, root, "issue"),
+      listJson(runGh, root, "pr")
+    ]);
+    const items = [...mapRows("issue", issueRows), ...mapRows("pull_request", prRows)].sort(
+      (a, b) => b.number - a.number
+    );
+    const summary = summarize(items);
+    const message = summary.total === 0 ? `No open issues or pull requests on ${PUBLIC_INBOUND_REPO}.` : `Open inbound on ${PUBLIC_INBOUND_REPO}: ${summary.issues} issue(s), ${summary.humanPullRequests} human PR(s), ${summary.dependabotPullRequests} Dependabot PR(s).`;
+    const result = resultBase("ok", message, true, now, items);
+    if (options.stamp) {
+      await stampPublicInboundCheck(root, now);
+    }
+    return result;
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    if (/ENOTFOUND|ECONNREFUSED|ETIMEDOUT|network|offline|Could not resolve/i.test(detail)) {
+      return resultBase(
+        "skipped-offline",
+        `GitHub unreachable; fail-open skip (${detail}).`,
+        true,
+        now
+      );
+    }
+    return resultBase("error", `Public inbound check failed: ${detail}`, true, now);
+  }
+}
+function shouldEmitPublicInboundNudge(result) {
+  if (!result || result.status !== "ok") return false;
+  if (result.mutateRecommended === true) return false;
+  const summary = result.summary;
+  if (!summary || typeof summary !== "object") return false;
+  const total = summary.total;
+  return typeof total === "number" && total > 0;
+}
+
+export {
+  PUBLIC_INBOUND_REPO,
+  stampPublicInboundCheck,
+  detectFactoryCheckout,
+  checkPublicInbound,
+  shouldEmitPublicInboundNudge
+};

package/dist/chunk-2YU2H7I6.js

@@ -0,0 +1,42 @@
+// src/invariants/handoff-schema.ts
+var MACHINE_LIST_CHECKS = [
+  {
+    heading: "Backlog plans",
+    fieldLabels: ["Backlog plans", "Backlog"],
+    code: "heading-without-field-backlog"
+  },
+  {
+    heading: "Parked plans",
+    fieldLabels: ["Parked plans"],
+    code: "heading-without-field-parked"
+  },
+  {
+    heading: "Run queue",
+    fieldLabels: ["Run queue"],
+    code: "heading-without-field-run-queue"
+  }
+];
+var CITE = "agent-kit validate handoff (see .cursor/context/templates/handoff.md)";
+function validateHandoffText(text) {
+  if (!text.trim()) return [];
+  const warnings = [];
+  for (const check of MACHINE_LIST_CHECKS) {
+    const headingRe = new RegExp(`^##\\s+${check.heading}\\s*$`, "m");
+    if (!headingRe.test(text)) continue;
+    const hasField = check.fieldLabels.some(
+      (label) => new RegExp(`^- \\*\\*${label}:\\*\\*`, "m").test(text)
+    );
+    if (!hasField) {
+      warnings.push({
+        code: check.code,
+        message: `\`## ${check.heading}\` found without \`- **${check.fieldLabels[0]}:**\` (Mission Control will miss this list; rewrite as a field bullet).`,
+        cite: CITE
+      });
+    }
+  }
+  return warnings;
+}
+
+export {
+  validateHandoffText
+};

package/dist/chunk-4IWG5CVE.js

@@ -0,0 +1,214 @@
+// src/readiness/env-checks.ts
+import { constants, access, readFile, realpath, stat } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+var MIN_NODE_MAJOR = 20;
+var CLI_PACKAGE_JSON_REL = path.join(
+  "lib",
+  "node_modules",
+  "@dadado",
+  "agent-kit-cli",
+  "package.json"
+);
+var DIST_INDEX_RE = /(?:\$\{basedir\}|\$basedir)?[^'"\s;]*dist\/index\.js/g;
+function extractDistIndexFromBinScript(contents) {
+  const found = [];
+  DIST_INDEX_RE.lastIndex = 0;
+  for (const match of contents.matchAll(DIST_INDEX_RE)) {
+    const raw = match[0]?.trim();
+    if (raw) found.push(raw.replace(/\\/g, "/"));
+  }
+  return found;
+}
+function expandBinDirVars(raw, binDir) {
+  return raw.replace(/\$\{basedir\}/g, binDir).replace(/\$basedir/g, binDir);
+}
+var SHIM_MAX_BYTES = 4096;
+function packageJsonFromDistIndex(distIndex) {
+  return path.join(path.dirname(distIndex), "..", "package.json");
+}
+function parsePackageVersion(contents) {
+  try {
+    const parsed = JSON.parse(contents);
+    return typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+async function readBinVersion(binPath, options = {}) {
+  const readFileImpl = options.readFileImpl ?? ((filePath) => readFile(filePath, "utf8"));
+  const binDir = path.dirname(binPath);
+  const candidates = [];
+  let realBin = binPath;
+  try {
+    realBin = await realpath(binPath);
+  } catch {
+  }
+  if (path.basename(realBin) === "index.js" && path.basename(path.dirname(realBin)) === "dist") {
+    candidates.push(packageJsonFromDistIndex(realBin));
+  }
+  candidates.push(
+    path.join(binDir, "..", CLI_PACKAGE_JSON_REL),
+    path.join(binDir, "..", "node_modules", "@dadado", "agent-kit-cli", "package.json")
+  );
+  try {
+    if ((await stat(realBin)).size < SHIM_MAX_BYTES) {
+      const contents = await readFileImpl(binPath);
+      for (const raw of extractDistIndexFromBinScript(contents)) {
+        const distIndex = path.resolve(binDir, expandBinDirVars(raw, binDir));
+        candidates.push(packageJsonFromDistIndex(distIndex));
+      }
+    }
+  } catch {
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const resolved = path.resolve(candidate);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    try {
+      const version = parsePackageVersion(await readFileImpl(resolved));
+      if (version) return version;
+    } catch {
+    }
+  }
+  return null;
+}
+async function resolveBinOnPath(binName, env, platform) {
+  const pathVar = env.PATH ?? env.Path ?? "";
+  if (!pathVar) return null;
+  const dirs = pathVar.split(path.delimiter).filter(Boolean);
+  const candidates = platform === "win32" ? [binName, `${binName}.cmd`, `${binName}.exe`, `${binName}.bat`] : [binName];
+  for (const dir of dirs) {
+    for (const candidate of candidates) {
+      const abs = path.join(dir, candidate);
+      try {
+        await access(abs, platform === "win32" ? void 0 : constants.X_OK);
+        return abs;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function isNodeVersionOk(nodeVersion, minMajor = MIN_NODE_MAJOR) {
+  const match = /^v?(\d+)/.exec(nodeVersion);
+  if (!match) return false;
+  const major = Number(match[1]);
+  return Number.isFinite(major) && major >= minMajor;
+}
+function detectShellName(env, platform) {
+  if (platform === "win32") {
+    if (env.PSModulePath) return "powershell";
+    if (env.ComSpec) return "cmd";
+    return null;
+  }
+  const shellPath = env.SHELL;
+  if (!shellPath) return null;
+  const base = path.basename(shellPath).trim();
+  return base || null;
+}
+function detectShellProfile(env, platform, homeDir) {
+  const shellName = detectShellName(env, platform);
+  if (shellName === "zsh") return path.join(homeDir, ".zshrc");
+  if (shellName === "bash") return path.join(homeDir, ".bashrc");
+  return null;
+}
+function parseNpmrcPrefix(content, homeDir) {
+  const match = /^\s*prefix\s*=\s*(.+?)\s*$/m.exec(content);
+  const captured = match?.[1];
+  if (!captured) return null;
+  let value = captured.trim().replace(/^["']|["']$/g, "");
+  if (value.startsWith("~")) {
+    value = path.join(homeDir, value.slice(1));
+  }
+  return value || null;
+}
+function heuristicPrefixFromExecPath(execPath, platform) {
+  const p = platform === "win32" ? path.win32 : path.posix;
+  return platform === "win32" ? p.dirname(execPath) : p.dirname(p.dirname(execPath));
+}
+async function detectNpmPrefix(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const homeDir = options.homeDir ?? homedir();
+  const execPath = options.execPath ?? process.execPath;
+  const readFileImpl = options.readFileImpl ?? ((filePath) => readFile(filePath, "utf8"));
+  const envPrefix = env.npm_config_prefix ?? env.NPM_CONFIG_PREFIX;
+  if (envPrefix?.trim()) {
+    return { prefix: envPrefix.trim(), source: "env" };
+  }
+  const userconfigPath = env.NPM_CONFIG_USERCONFIG ?? path.join(homeDir, ".npmrc");
+  try {
+    const content = await readFileImpl(userconfigPath);
+    const npmrcPrefix = parseNpmrcPrefix(content, homeDir);
+    if (npmrcPrefix) {
+      return { prefix: npmrcPrefix, source: "npmrc" };
+    }
+  } catch {
+  }
+  return { prefix: heuristicPrefixFromExecPath(execPath, platform), source: "heuristic" };
+}
+async function describeUnwritablePrefix(prefix) {
+  try {
+    const info = await stat(prefix);
+    const currentUid = typeof process.getuid === "function" ? process.getuid() : void 0;
+    if (process.platform !== "win32" && currentUid !== void 0 && info.uid === 0 && currentUid !== 0) {
+      return `root-owned prefix (${prefix}); the classic fresh-install PATH/EACCES blocker`;
+    }
+  } catch {
+  }
+  return `npm prefix is not writable: ${prefix}`;
+}
+async function checkNpmPrefixWritable(options = {}) {
+  let detected;
+  try {
+    detected = await detectNpmPrefix(options);
+  } catch {
+    return { prefix: null, writable: false, reason: "npm prefix could not be determined" };
+  }
+  try {
+    await access(detected.prefix, constants.W_OK);
+    return { prefix: detected.prefix, writable: true, source: detected.source };
+  } catch {
+    return {
+      prefix: detected.prefix,
+      writable: false,
+      source: detected.source,
+      reason: await describeUnwritablePrefix(detected.prefix)
+    };
+  }
+}
+async function assessEnvironment(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const nodeVersion = options.nodeVersion ?? process.version;
+  const homeDir = options.homeDir ?? homedir();
+  const binName = options.binName ?? "agent-kit";
+  const [binPath, npmPrefix] = await Promise.all([
+    resolveBinOnPath(binName, env, platform).catch(() => null),
+    checkNpmPrefixWritable(options).catch(
+      () => ({
+        prefix: null,
+        writable: false,
+        reason: "npm prefix check failed unexpectedly"
+      })
+    )
+  ]);
+  const binVersion = binPath ? await readBinVersion(binPath, options).catch(() => null) : null;
+  return {
+    binOnPath: binPath != null,
+    binPath,
+    binVersion,
+    npmPrefixWritable: npmPrefix.writable,
+    npmPrefix,
+    nodeVersionOk: isNodeVersionOk(nodeVersion),
+    nodeVersion,
+    shell: detectShellName(env, platform),
+    shellProfile: detectShellProfile(env, platform, homeDir)
+  };
+}
+
+export {
+  assessEnvironment
+};