@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-ZXKZBTXE.js

@@ -0,0 +1,17 @@
+import {
+  writeJson
+} from "./chunk-77V75A7O.js";
+
+// src/scanner/snapshot.ts
+import path from "path";
+var READINESS_SNAPSHOT_RELATIVE_PATH = ".cursor/context/readiness.json";
+async function writeReadinessSnapshot(rootDir, report) {
+  const snapshotPath = path.join(rootDir, READINESS_SNAPSHOT_RELATIVE_PATH);
+  await writeJson(snapshotPath, report);
+  return snapshotPath;
+}
+
+export {
+  READINESS_SNAPSHOT_RELATIVE_PATH,
+  writeReadinessSnapshot
+};

package/dist/contribute-C6AW2P6J.js

@@ -0,0 +1,367 @@
+import {
+  REGISTRY_CLI_ARGS,
+  resolveRegistryFromCli
+} from "./chunk-PNG7LO2F.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  managedPairs
+} from "./chunk-N3HTJVBR.js";
+import {
+  loadAgentKitManifest,
+  normalizeRelPath,
+  resolveContained
+} from "./chunk-AW74INUW.js";
+import "./chunk-5VCOWTTP.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/contribute.ts
+import { defineCommand } from "citty";
+
+// src/lifecycle/contribute.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+
+// src/lifecycle/contribute-gate.ts
+var SECRET_PATTERNS = [
+  {
+    code: "secret-aws",
+    re: /AKIA[0-9A-Z]{16}/,
+    message: "Looks like an AWS access key id"
+  },
+  {
+    code: "secret-private-key",
+    re: /-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----/,
+    message: "Contains a private key block"
+  },
+  {
+    code: "secret-bearer",
+    re: /(?:api[_-]?key|token|secret|password)\s*[:=]\s*['"][^'"]{12,}['"]/i,
+    message: "Looks like an inline API key / token / password"
+  },
+  {
+    code: "secret-github-pat",
+    re: /\bghp_[A-Za-z0-9]{20,}\b/,
+    message: "Looks like a GitHub personal access token"
+  }
+];
+var HYGIENE_PATTERNS = [
+  {
+    code: "meta-agent",
+    re: /\b(como IA|as an AI|no meu racioc[ií]nio|vou usar a tool|contexto do chat)\b/i,
+    message: "Agent metalinguage \u2014 not allowed in versioned kit artifacts"
+  },
+  {
+    code: "session-transient",
+    re: /\b(conforme falamos|no chat anterior|WIP do agente|hoje eu configurei)\b/i,
+    message: "Session / chat-transient wording \u2014 rewrite in project voice"
+  }
+];
+var BLOCKED_PATH_GLOBS = [
+  /^\.cursor\/HANDOFF\.md$/i,
+  /^\.cursor\/plans\//i,
+  /^\.cursor\/memory\//i,
+  /^\.cursor\/context\//i,
+  /^\.env/i,
+  /(^|\/)credentials?\./i,
+  /(^|\/)secrets?\./i
+];
+var MAX_BYTES = 2e5;
+function gateContributePath(projectRel) {
+  const posix = projectRel.split("\\").join("/");
+  const issues = [];
+  for (const re of BLOCKED_PATH_GLOBS) {
+    if (re.test(posix)) {
+      issues.push({
+        code: "path-blocked",
+        message: `Path is session/L3 or secret-like \u2014 cannot contribute: ${posix}`
+      });
+    }
+  }
+  return issues;
+}
+function gateContributeContent(content, projectRel) {
+  const issues = [...gateContributePath(projectRel)];
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes > MAX_BYTES) {
+    issues.push({
+      code: "too-large",
+      message: `File too large (${bytes} bytes; max ${MAX_BYTES})`
+    });
+  }
+  for (const p of SECRET_PATTERNS) {
+    if (p.re.test(content)) issues.push({ code: p.code, message: p.message });
+  }
+  for (const p of HYGIENE_PATTERNS) {
+    if (p.re.test(content)) issues.push({ code: p.code, message: p.message });
+  }
+  return { ok: issues.length === 0, issues };
+}
+
+// src/lifecycle/contribute.ts
+async function readLocal(projectRoot, rel) {
+  try {
+    return await readFile(resolveContained(projectRoot, rel), "utf8");
+  } catch {
+    return null;
+  }
+}
+async function buildRegistryPathMap(registryRoot, manifest) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { sourceRel, targetRel } of (await managedPairs(registryRoot, manifest)).pairs) {
+    map.set(targetRel, sourceRel);
+  }
+  return map;
+}
+function guessRegistryPath(projectRel) {
+  const p = projectRel.split(path.sep).join("/");
+  if (p.startsWith(".cursor/skills/")) {
+    const rest = p.slice(".cursor/skills/".length);
+    const parts = rest.split("/");
+    if (parts.length >= 3 && (parts[0] === "core" || parts[0] === "community")) {
+      return path.posix.join("registry/skills", rest);
+    }
+    const skillId = parts[0];
+    if (parts.length >= 2 && skillId) {
+      return path.posix.join("registry/skills", "community", rest);
+    }
+  }
+  if (p.startsWith(".cursor/rules/")) {
+    return p;
+  }
+  if (p.startsWith(".cursor/commands/")) {
+    return p;
+  }
+  if (p.startsWith(".cursor/agents/")) {
+    return p;
+  }
+  if (p.startsWith(".cursor/hooks/")) {
+    return p;
+  }
+  if (p.startsWith("autogit/")) {
+    return p;
+  }
+  return null;
+}
+async function planContribute(options) {
+  const includeDrift = options.includeDrift !== false;
+  const pathMap = await buildRegistryPathMap(options.registryRoot, options.manifest);
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = async (kind, projectPath, registryPath) => {
+    const key = projectPath.split(path.sep).join("/");
+    if (seen.has(key)) return;
+    seen.add(key);
+    const content = await readLocal(options.projectRoot, projectPath);
+    if (content === null) {
+      return;
+    }
+    if (kind === "drift") {
+      try {
+        const upstream = await readFile(
+          resolveContained(options.registryRoot, registryPath),
+          "utf8"
+        );
+        if (upstream === content) return;
+      } catch {
+      }
+    }
+    const gate = gateContributeContent(content, key);
+    candidates.push({
+      kind,
+      projectPath: key,
+      registryPath,
+      gateOk: gate.ok,
+      issues: gate.issues
+    });
+  };
+  if (includeDrift) {
+    for (const [projectPath, registryPath] of pathMap) {
+      await push("drift", projectPath, registryPath);
+    }
+  }
+  for (const raw of options.extraPaths ?? []) {
+    const projectPath = path.posix.normalize(normalizeRelPath(raw));
+    const escapes = path.posix.isAbsolute(projectPath) || /^[A-Za-z]:\//.test(projectPath) || projectPath === ".." || projectPath.startsWith("../");
+    const blocked = escapes ? [
+      {
+        code: "path-blocked",
+        message: `Path is absolute or escapes the project root \u2014 cannot contribute: ${projectPath}`
+      }
+    ] : gateContributePath(projectPath);
+    if (blocked.length > 0) {
+      if (!seen.has(projectPath)) {
+        seen.add(projectPath);
+        candidates.push({
+          kind: "path",
+          projectPath,
+          registryPath: "",
+          gateOk: false,
+          issues: blocked
+        });
+      }
+      continue;
+    }
+    const mapped = pathMap.get(projectPath) ?? guessRegistryPath(projectPath);
+    if (!mapped) {
+      candidates.push({
+        kind: "path",
+        projectPath,
+        registryPath: "",
+        gateOk: false,
+        issues: [
+          {
+            code: "unmapped",
+            message: "Cannot map to a registry path \u2014 pass an installed kit artifact or .cursor/{rules,commands,skills,agents,hooks}/*"
+          }
+        ]
+      });
+      continue;
+    }
+    await push("path", projectPath, mapped);
+  }
+  return {
+    candidates,
+    accepted: candidates.filter((c) => c.gateOk),
+    rejected: candidates.filter((c) => !c.gateOk)
+  };
+}
+async function writeContributeToRegistry(projectRoot, registryRoot, accepted) {
+  const written = [];
+  for (const c of accepted) {
+    if (!c.registryPath) continue;
+    const content = await readFile(resolveContained(projectRoot, c.projectPath), "utf8");
+    const dest = resolveContained(registryRoot, c.registryPath);
+    await mkdir(path.dirname(dest), { recursive: true });
+    await writeFile(dest, content, "utf8");
+    written.push(c.registryPath);
+  }
+  return written;
+}
+function formatPrBody(accepted) {
+  const bullets = accepted.map((c) => `- \`${c.projectPath}\` \u2192 \`${c.registryPath}\``).join("\n");
+  return [
+    "## Summary",
+    "Upstream contribution from a consumer project via `agent-kit contribute`.",
+    "",
+    "### Files",
+    bullets || "- (none)",
+    "",
+    "## Checklist",
+    "- [ ] Anti-slop / hygiene gate passed locally",
+    "- [ ] No secrets or session state (HANDOFF/plans/memory)",
+    "- [ ] Docs / registry index updated if this adds a skill or pack member",
+    ""
+  ].join("\n");
+}
+
+// src/commands/contribute.ts
+function parsePaths(raw) {
+  if (!raw?.trim()) return [];
+  return [
+    ...new Set(
+      raw.split(",").map((s) => s.trim()).filter(Boolean)
+    )
+  ];
+}
+var contributeCommand = defineCommand({
+  meta: {
+    name: "contribute",
+    description: "Propose upstream changes: detect local drift/new kit artifacts, run anti-slop gate, optionally write into a kit checkout for a PR."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    path: {
+      type: "string",
+      description: "Comma-separated project-relative paths to contribute (new or edited)"
+    },
+    drift: {
+      type: "boolean",
+      description: "Include drifted installed L0/pack/skill files vs registry (default: true)",
+      default: true
+    },
+    write: {
+      type: "boolean",
+      description: "Copy accepted files into the local kit/registry checkout (--registry required / resolved)",
+      default: false
+    },
+    ...REGISTRY_CLI_ARGS
+  },
+  async run({ args }) {
+    const manifest = await loadAgentKitManifest(args.cwd, { onWarning: logger.warn });
+    if (!manifest) {
+      logger.warn("No .cursor/agent-kit.json \u2014 run agent-kit install first.");
+      return;
+    }
+    const registry = await resolveRegistryFromCli({
+      cwd: args.cwd,
+      registry: args.registry,
+      url: args.url,
+      ref: args.ref,
+      refresh: args.refresh,
+      manifest
+    });
+    try {
+      if (registry.source !== "flag" && args.write) {
+        logger.warn(
+          "contribute --write needs a local kit checkout. Pass --registry /path/to/agent-kit."
+        );
+        return;
+      }
+      logger.info(`Registry: ${registry.root} (${registry.source})`);
+      const plan = await planContribute({
+        registryRoot: registry.root,
+        projectRoot: args.cwd,
+        manifest,
+        extraPaths: parsePaths(args.path),
+        includeDrift: args.drift
+      });
+      console.log(
+        `Contribute plan: accepted=${plan.accepted.length} rejected=${plan.rejected.length} (drift scan=${args.drift})`
+      );
+      if (plan.candidates.length === 0) {
+        logger.success("Nothing to contribute (no drift / no --path).");
+        return;
+      }
+      for (const c of plan.candidates) {
+        const mark = c.gateOk ? "ok" : "FAIL";
+        console.log(
+          `${mark.padEnd(4)} ${c.kind.padEnd(5)} ${c.projectPath} \u2192 ${c.registryPath || "(unmapped)"}`
+        );
+        for (const issue of c.issues) {
+          console.log(`       [${issue.code}] ${issue.message}`);
+        }
+      }
+      if (plan.accepted.length === 0) {
+        logger.warn("No files passed the contribute gate.");
+        return;
+      }
+      console.log("\n--- Suggested PR body ---\n");
+      console.log(formatPrBody(plan.accepted));
+      if (!args.write) {
+        logger.info(
+          "Dry run. Re-run with --write --registry /path/to/agent-kit to copy accepted files into the kit checkout, then open a PR (gh pr create --base main)."
+        );
+        return;
+      }
+      const written = await writeContributeToRegistry(args.cwd, registry.root, plan.accepted);
+      logger.success(`Wrote ${written.length} file(s) into ${registry.root}`);
+      for (const p of written) console.log(`  + ${p}`);
+      console.log("\nNext (HITL \u2014 review before push):");
+      console.log(`  cd ${registry.root}`);
+      console.log("  git checkout -b contribute/<short-topic>");
+      console.log('  git add <files> && git commit -m "feat: contribute <topic> from consumer"');
+      console.log("  git push -u origin HEAD");
+      console.log('  gh pr create --base main --title "feat: contribute <topic>" --body-file -');
+    } finally {
+      await registry.unlock?.();
+    }
+  }
+});
+export {
+  contributeCommand
+};

package/dist/cursor-awareness-KTL2RGKD.js

@@ -0,0 +1,77 @@
+import {
+  checkCursorUpdateAwareness
+} from "./chunk-CBCW5R5J.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import "./chunk-NQ7IQ5XT.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/cursor-awareness.ts
+import { defineCommand } from "citty";
+var cursorAwarenessCommand = defineCommand({
+  meta: {
+    name: "cursor-awareness",
+    description: "Opt-in advisory: Cursor changelog vs native-audit gaps (never apply)."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    check: {
+      type: "boolean",
+      description: "Check-only (default true; apply is never supported)",
+      default: true
+    },
+    json: {
+      type: "boolean",
+      description: "Print machine-readable JSON",
+      default: false
+    },
+    "respect-prefs": {
+      type: "boolean",
+      description: "Honor cursorUpdateCheck.enabled and intervalDays from .cursor/context/config.json",
+      default: false
+    },
+    stamp: {
+      type: "boolean",
+      description: "Persist cursorUpdateCheck.lastCheckedAt / lastSeenCursorVersion",
+      default: false
+    },
+    offline: {
+      type: "boolean",
+      description: "Skip changelog network fetch; inventory-only advisory",
+      default: false
+    }
+  },
+  async run({ args }) {
+    void args.check;
+    const result = await checkCursorUpdateAwareness(args.cwd, {
+      respectPrefs: Boolean(args["respect-prefs"]),
+      stamp: Boolean(args.stamp),
+      offline: Boolean(args.offline)
+    });
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      const line = `[${result.status}] ${result.message}`;
+      if (result.status === "error") logger.error(line);
+      else if (result.status === "gaps-found") logger.warn(line);
+      else if (result.status.startsWith("skipped-")) logger.warn(line);
+      else logger.info(line);
+      if (result.gaps.length > 0 && !args.json) {
+        for (const gap of result.gaps.slice(0, 12)) {
+          logger.info(`- ${gap.id} (${gap.severity}): ${gap.evidence} \u2192 ${gap.suggestedRoute}`);
+        }
+        if (result.gaps.length > 12) {
+          logger.info(`\u2026 and ${result.gaps.length - 12} more (use --json)`);
+        }
+      }
+    }
+    if (result.status === "error") process.exitCode = 2;
+  }
+});
+export {
+  cursorAwarenessCommand
+};

package/dist/dashboard-YSNUGBFY.js

@@ -0,0 +1,21 @@
+import {
+  applyDashboardOpenEnv,
+  bundledDashboardCandidates,
+  dashboardCommand,
+  dashboardProcessTitle,
+  dashboardSpawnEnv,
+  findDashboardStart,
+  readPreferredBrowserFromWorkspace,
+  resolveDashboardSnapshotRoot
+} from "./chunk-HFUH3HVS.js";
+import "./chunk-ZB43YMHW.js";
+export {
+  applyDashboardOpenEnv,
+  bundledDashboardCandidates,
+  dashboardCommand,
+  dashboardProcessTitle,
+  dashboardSpawnEnv,
+  findDashboardStart,
+  readPreferredBrowserFromWorkspace,
+  resolveDashboardSnapshotRoot
+};

package/dist/dashboard-broadcast-M4CMW7RX.js

@@ -0,0 +1,119 @@
+import {
+  bundledDashboardCandidates,
+  dashboardProcessTitle,
+  dashboardSpawnEnv,
+  findDashboardStart,
+  resolveDashboardSnapshotRoot
+} from "./chunk-HFUH3HVS.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+
+// src/commands/dashboard-broadcast.ts
+import { spawn } from "child_process";
+import { access } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+async function findDashboardBroadcastStart(cwd, env = process.env, options = {}) {
+  let dir = path.resolve(cwd);
+  for (; ; ) {
+    const candidate = path.join(dir, "dashboard", "start-broadcast.mjs");
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  for (const key of ["MISSION_CONTROL_KIT_ROOT", "AGENT_KIT_HOME"]) {
+    const base = env[key];
+    if (!base || typeof base !== "string" || !base.trim()) continue;
+    const candidate = path.join(path.resolve(base.trim()), "dashboard", "start-broadcast.mjs");
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  const sibling = path.join(
+    path.resolve(cwd),
+    "..",
+    "agent-kit",
+    "dashboard",
+    "start-broadcast.mjs"
+  );
+  try {
+    await access(sibling);
+    return path.resolve(sibling);
+  } catch {
+  }
+  for (const candidate of bundledDashboardCandidates(
+    "start-broadcast.mjs",
+    options.moduleUrl ?? import.meta.url
+  )) {
+    try {
+      await access(candidate);
+      return path.resolve(candidate);
+    } catch {
+    }
+  }
+  return null;
+}
+function runStartScript(startPath, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [startPath], {
+      cwd: path.dirname(path.dirname(startPath)),
+      env,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+var dashboardBroadcastCommand = defineCommand({
+  meta: {
+    name: "dashboard-broadcast",
+    description: "Opt-in LAN Mission Control (token-gated). Terminal counterpart to /dashboard-broadcast. Does not change loopback /dashboard."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd(),
+      description: "Directory to search upward for dashboard/start-broadcast.mjs"
+    },
+    "no-open": {
+      type: "boolean",
+      default: false,
+      description: "Do not open a browser; only ensure the server is up and print Share URL (when masking is on) plus token / LAN lines"
+    },
+    browser: {
+      type: "string",
+      description: "Preferred browser app/binary for this launch (overrides config missionControl.preferredBrowser)"
+    }
+  },
+  async run({ args }) {
+    const startPath = await findDashboardBroadcastStart(args.cwd);
+    if (!startPath) {
+      const loopback = await findDashboardStart(args.cwd);
+      logger.error(
+        loopback ? "No dashboard/start-broadcast.mjs found beside dashboard/start.mjs. Update the agent-kit tree or reinstall a CLI that ships dashboard/, then retry." : "No dashboard/start-broadcast.mjs found. After a CLI publish that ships dashboard/ (Path C), reinstall @dadado/agent-kit-cli. Or run from an agent-kit tree that includes dashboard/."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const snapshotRoot = resolveDashboardSnapshotRoot(args.cwd);
+    const env = dashboardSpawnEnv({ ...process.env }, snapshotRoot, {
+      noOpen: Boolean(args["no-open"]),
+      browser: args.browser
+    });
+    process.title = dashboardProcessTitle(snapshotRoot);
+    const code = await runStartScript(startPath, env);
+    if (code !== 0) process.exitCode = code;
+  }
+});
+export {
+  dashboardBroadcastCommand,
+  findDashboardBroadcastStart
+};

package/dist/diff-VHNR62SI.js

@@ -0,0 +1,74 @@
+import {
+  REGISTRY_CLI_ARGS,
+  resolveRegistryFromCli
+} from "./chunk-PNG7LO2F.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  diffAgainstRegistry,
+  summarizeDiff
+} from "./chunk-2RDRMGD3.js";
+import "./chunk-N3HTJVBR.js";
+import {
+  loadAgentKitManifest
+} from "./chunk-AW74INUW.js";
+import "./chunk-5VCOWTTP.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/diff.ts
+import { defineCommand } from "citty";
+var diffCommand = defineCommand({
+  meta: {
+    name: "diff",
+    description: "Compare installed kit artifacts to the registry (respects L3 protected)."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    all: {
+      type: "boolean",
+      description: "Include matching files in the report",
+      default: false
+    },
+    ...REGISTRY_CLI_ARGS
+  },
+  async run({ args }) {
+    const manifest = await loadAgentKitManifest(args.cwd, { onWarning: logger.warn });
+    if (!manifest) {
+      logger.warn("No .cursor/agent-kit.json \u2014 run agent-kit install first.");
+      return;
+    }
+    const registry = await resolveRegistryFromCli({
+      cwd: args.cwd,
+      registry: args.registry,
+      url: args.url,
+      ref: args.ref,
+      refresh: args.refresh,
+      manifest
+    });
+    try {
+      logger.info(`Registry: ${registry.root} (${registry.source})`);
+      const entries = await diffAgainstRegistry(registry.root, args.cwd, manifest);
+      const summary = summarizeDiff(entries);
+      console.log(
+        `Summary: match=${summary.match} drift=${summary.drift} missing-local=${summary["missing-local"]} missing-registry=${summary["missing-registry"]} protected=${summary.protected}`
+      );
+      const rows = args.all ? entries : entries.filter((e) => e.status !== "match");
+      if (rows.length === 0) {
+        logger.success("No drift (matches only).");
+        return;
+      }
+      for (const e of rows) {
+        console.log(`${e.status.padEnd(18)} ${e.path}`);
+      }
+    } finally {
+      await registry.unlock?.();
+    }
+  }
+});
+export {
+  diffCommand
+};