@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/add-HTYIFKMN.js

@@ -0,0 +1,150 @@
+import {
+  formatSkippedSymlinks,
+  logApplyStats
+} from "./chunk-HS7LVVLO.js";
+import {
+  REGISTRY_CLI_ARGS,
+  resolveRegistryFromCli
+} from "./chunk-PNG7LO2F.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  allPacks,
+  allSkills,
+  buildManifest,
+  findPack,
+  findSkill,
+  installPack,
+  installSkill,
+  loadAgentKitManifest,
+  loadRegistry,
+  resolveProtectedGlobs,
+  saveManifest,
+  upsertIdList
+} from "./chunk-AW74INUW.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-2RDRMGD3.js

@@ -0,0 +1,82 @@
+import {
+  managedPairs
+} from "./chunk-N3HTJVBR.js";
+import {
+  isProtectedPath,
+  resolveContained,
+  resolveProtectedGlobs
+} from "./chunk-AW74INUW.js";
+
+// src/lifecycle/diff.ts
+import { readFile } from "fs/promises";
+import path from "path";
+async function readIfExists(abs) {
+  try {
+    return await readFile(abs, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function comparePair(registryRoot, projectRoot, sourceRel, targetRel, protectedGlobs) {
+  const posixTarget = targetRel.split(path.sep).join("/");
+  if (isProtectedPath(posixTarget, protectedGlobs)) {
+    return { path: posixTarget, status: "protected" };
+  }
+  let sourceAbs;
+  try {
+    sourceAbs = resolveContained(registryRoot, sourceRel);
+  } catch {
+    return { path: posixTarget, status: "missing-registry" };
+  }
+  const registryContent = await readIfExists(sourceAbs);
+  if (registryContent === null) {
+    return { path: posixTarget, status: "missing-registry" };
+  }
+  let targetAbs;
+  try {
+    targetAbs = resolveContained(projectRoot, targetRel);
+  } catch {
+    return { path: posixTarget, status: "missing-local" };
+  }
+  const localContent = await readIfExists(targetAbs);
+  if (localContent === null) return { path: posixTarget, status: "missing-local" };
+  if (localContent === registryContent) return { path: posixTarget, status: "match" };
+  return { path: posixTarget, status: "drift" };
+}
+async function diffAgainstRegistry(registryRoot, projectRoot, manifest) {
+  const protectedGlobs = resolveProtectedGlobs(manifest);
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushUnique = async (sourceRel, targetRel) => {
+    const key = targetRel.split(path.sep).join("/");
+    if (seen.has(key)) return;
+    seen.add(key);
+    entries.push(
+      await comparePair(registryRoot, projectRoot, sourceRel, targetRel, protectedGlobs)
+    );
+  };
+  const { pairs, missingSkills } = await managedPairs(registryRoot, manifest);
+  for (const { sourceRel, targetRel } of pairs) {
+    await pushUnique(sourceRel, targetRel);
+  }
+  for (const id of missingSkills) {
+    entries.push({ path: `skill:${id}`, status: "missing-registry" });
+  }
+  return entries;
+}
+function summarizeDiff(entries) {
+  const summary = {
+    match: 0,
+    drift: 0,
+    "missing-local": 0,
+    "missing-registry": 0,
+    protected: 0
+  };
+  for (const e of entries) summary[e.status] += 1;
+  return summary;
+}
+
+export {
+  diffAgainstRegistry,
+  summarizeDiff
+};

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
+};