@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/doctor-PET2HRRJ.js

@@ -0,0 +1,236 @@
+import {
+  assessHooksHealth,
+  executeSafeReadinessFixes,
+  refreshRepositoryProfile
+} from "./chunk-STGFBAYT.js";
+import {
+  writeReadinessSnapshot
+} from "./chunk-ZXKZBTXE.js";
+import "./chunk-W24CMQ32.js";
+import "./chunk-MAPOQEA2.js";
+import {
+  withCliProgress
+} from "./chunk-QTON2GQX.js";
+import {
+  detectWorkspaceParent,
+  workspaceParentAdvisoryLines
+} from "./chunk-S6GMFDKV.js";
+import {
+  createReadinessReport
+} from "./chunk-PNFF6OU3.js";
+import {
+  runScanner
+} from "./chunk-ZCTSUQRR.js";
+import "./chunk-F6C3GFKV.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  assessEnvironment
+} from "./chunk-4IWG5CVE.js";
+import {
+  warnIfRunningCliBehindNpm
+} from "./chunk-SMGFN3Z4.js";
+import "./chunk-NQ7IQ5XT.js";
+import "./chunk-2RDRMGD3.js";
+import "./chunk-N3HTJVBR.js";
+import "./chunk-AW74INUW.js";
+import "./chunk-5VCOWTTP.js";
+import {
+  KIT_VERSION
+} from "./chunk-7HDQEK6T.js";
+import {
+  readJson
+} from "./chunk-77V75A7O.js";
+
+// src/commands/doctor.ts
+import path from "path";
+import { defineCommand } from "citty";
+async function readDeferredEssentials(rootDir, report) {
+  const config = await readJson(
+    path.join(rootDir, ".cursor", "context", "config.json")
+  );
+  const deferredItems = config?.onboarding?.deferredItems;
+  if (!Array.isArray(deferredItems)) return [];
+  const essentialIds = new Set(
+    report.pillars.flatMap((pillar) => pillar.checks).filter((check) => check.essential).map((check) => check.id)
+  );
+  return deferredItems.filter(
+    (item) => typeof item?.checkId === "string" && typeof item?.reason === "string" && essentialIds.has(item.checkId)
+  ).map((item) => ({ checkId: item.checkId, reason: item.reason }));
+}
+async function runDoctor(cwd, options = {}) {
+  const rootDir = path.resolve(cwd);
+  const hooks = await assessHooksHealth(rootDir);
+  const workspaceParent = await detectWorkspaceParent(rootDir);
+  if (workspaceParent) {
+    const scan2 = await runScanner(rootDir);
+    const report2 = createReadinessReport(scan2, {
+      generatorVersion: KIT_VERSION,
+      generatedAt: options.generatedAt
+    });
+    return {
+      report: report2,
+      safeChanges: [],
+      hooks,
+      env: await assessEnvironment(),
+      deferredEssentials: [],
+      workspaceParent
+    };
+  }
+  const env = await assessEnvironment();
+  if (options.fixSafe) {
+    const execution = await executeSafeReadinessFixes(rootDir, {
+      generatorVersion: KIT_VERSION,
+      generatedAt: options.generatedAt
+    });
+    await writeReadinessSnapshot(rootDir, execution.after);
+    return {
+      report: execution.after,
+      safeChanges: execution.changes,
+      hooks,
+      env,
+      deferredEssentials: await readDeferredEssentials(rootDir, execution.after)
+    };
+  }
+  if (options.refreshProfile) {
+    const refresh = await refreshRepositoryProfile(rootDir, {
+      generatorVersion: KIT_VERSION,
+      generatedAt: options.generatedAt
+    });
+    const scan2 = await runScanner(rootDir);
+    const report2 = createReadinessReport(scan2, {
+      generatorVersion: KIT_VERSION,
+      generatedAt: options.generatedAt
+    });
+    await writeReadinessSnapshot(rootDir, report2);
+    return {
+      report: report2,
+      safeChanges: [],
+      hooks,
+      env,
+      profileRefreshed: refresh.changed,
+      deferredEssentials: await readDeferredEssentials(rootDir, report2)
+    };
+  }
+  const scan = await runScanner(rootDir);
+  const report = createReadinessReport(scan, {
+    generatorVersion: KIT_VERSION,
+    generatedAt: options.generatedAt
+  });
+  await writeReadinessSnapshot(rootDir, report);
+  return {
+    report,
+    safeChanges: [],
+    hooks,
+    env,
+    deferredEssentials: await readDeferredEssentials(rootDir, report)
+  };
+}
+function printDoctorSummary(result, rootDir) {
+  if (result.workspaceParent) {
+    for (const line of workspaceParentAdvisoryLines(rootDir, result.workspaceParent, "doctor")) {
+      console.log(line);
+    }
+    return;
+  }
+  const { summary, pendingActions } = result.report;
+  const fixed = result.safeChanges.filter((change) => change.status === "applied").length;
+  const nextAction = pendingActions[0];
+  console.log("Repository readiness");
+  console.log(
+    `  ready: ${summary.ready}, choices: ${summary.needs_choice}, manual: ${summary.manual}, blocked: ${summary.blocked}`
+  );
+  console.log(`  safe fixes applied: ${fixed}`);
+  console.log(`  pending actions: ${pendingActions.length}`);
+  if (result.profileRefreshed !== void 0) {
+    console.log(
+      `  profile refreshed: ${result.profileRefreshed ? "yes (facts changed)" : "no (already current)"}`
+    );
+  }
+  for (const item of result.deferredEssentials) {
+    console.log(`  Deferred essential: ${item.checkId} \u2014 ${item.reason}`);
+  }
+  console.log(`hooks: ${result.hooks.status}`);
+  if (result.hooks.reasons.length > 0) {
+    for (const reason of result.hooks.reasons.slice(0, 5)) {
+      console.log(`  - ${reason}`);
+    }
+  }
+  if (result.hooks.advisories.length > 0) {
+    console.log("hooks advisories (soft; install via cp, see git-hooks/README.md):");
+    for (const tip of result.hooks.advisories.slice(0, 5)) {
+      console.log(`  - ${tip}`);
+    }
+  }
+  console.log("environment:");
+  const pathLabel = result.env.binOnPath ? `ok (v${result.env.binVersion ?? "unknown"} at ${result.env.binPath})` : "MISSING";
+  console.log(`  - bin on PATH (agent-kit): ${pathLabel}`);
+  console.log(
+    `  - npm prefix writable: ${result.env.npmPrefixWritable ? "ok" : "BLOCKED"}${result.env.npmPrefix.prefix ? ` (${result.env.npmPrefix.prefix})` : ""}`
+  );
+  if (!result.env.npmPrefixWritable && result.env.npmPrefix.reason) {
+    console.log(`    - ${result.env.npmPrefix.reason}`);
+  }
+  console.log(
+    `  - node version >= 20: ${result.env.nodeVersionOk ? "ok" : "TOO OLD"} (${result.env.nodeVersion})`
+  );
+  console.log(
+    `  - shell profile: ${result.env.shellProfile ?? "not detected (zsh/bash only)"}${result.env.shell ? ` (shell: ${result.env.shell})` : ""}`
+  );
+  if (process.env.ALLOW_MAIN_PUSH === "1") {
+    console.log("\u26A0\uFE0F  WARNING: ALLOW_MAIN_PUSH=1 is set in environment");
+    console.log("   This disables main-push protection for agent Shell commands.");
+    console.log("   Consider unsetting it: unset ALLOW_MAIN_PUSH");
+  }
+  console.log(
+    nextAction ? `Next: ${nextAction.recommendation}` : "Next: repository readiness checks are complete"
+  );
+}
+var doctorCommand = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Diagnose repository readiness; optional --fix-safe local repairs."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    json: {
+      type: "boolean",
+      description: "Print deterministic machine-readable JSON without status messages",
+      default: false
+    },
+    "fix-safe": {
+      type: "boolean",
+      description: "Apply only local, reversible, merge-safe readiness fixes",
+      default: false
+    },
+    "refresh-profile": {
+      type: "boolean",
+      description: "Reconcile .cursor/agent-kit.config.json with current scanner facts: fresh values win on shared keys, unrecognized existing keys are preserved",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!args.json) {
+      await warnIfRunningCliBehindNpm(args.cwd, { warn: (message) => logger.warn(message) });
+    }
+    const run = () => runDoctor(args.cwd, {
+      fixSafe: args["fix-safe"],
+      refreshProfile: args["refresh-profile"]
+    });
+    const result = args.json ? await run() : await withCliProgress("doctor", run);
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printDoctorSummary(result, path.resolve(args.cwd));
+  }
+});
+export {
+  doctorCommand,
+  printDoctorSummary,
+  runDoctor
+};

package/dist/dogfood-KKFVRWT6.js

@@ -0,0 +1,366 @@
+import {
+  REMOTE_ISSUE_TITLE_PREFIX,
+  parseRemoteUrl
+} from "./chunk-VY7MTPJ2.js";
+import {
+  PUBLIC_INBOUND_REPO
+} from "./chunk-2IPXQFJE.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import "./chunk-NQ7IQ5XT.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/dogfood.ts
+import { defineCommand } from "citty";
+
+// src/lifecycle/dogfood-file.ts
+import { execFile } from "child_process";
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var TRANSIENT_PHRASES = [/\bas I mentioned\b/gi, /\bdear user\b/gi, /\bconforme falamos\b/gi];
+function hygieneStrip(input) {
+  const redacted = /* @__PURE__ */ new Set();
+  let text = input;
+  const apply = (name, pattern, replacement) => {
+    text = text.replace(pattern, () => {
+      redacted.add(name);
+      return replacement;
+    });
+  };
+  apply(
+    "secret",
+    /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|glpat-[A-Za-z0-9_-]{16,}|sk-[A-Za-z0-9_-]{20,}|AKIA[0-9A-Z]{16}|xox[baprs]-[A-Za-z0-9-]{10,})\b/g,
+    "[redacted-secret]"
+  );
+  apply(
+    "secret",
+    /\b(?:api[_-]?key|token|secret|password|passwd)\s*[:=]\s*\S+/gi,
+    "[redacted-secret]"
+  );
+  apply("secret", /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/g, "[redacted-secret]");
+  apply("email", /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, "[redacted-email]");
+  apply("path", /(?:\/Users|\/home)\/[^\s/]+(?:\/[^\s`'")]*)?/g, "[redacted-path]");
+  for (const phrase of TRANSIENT_PHRASES) apply("transient", phrase, "");
+  text = text.replace(/[ \t]{2,}/g, " ");
+  const needsAnonymization = ["secret", "email", "path"].some((kind) => redacted.has(kind));
+  return { text: text.trim(), redacted: [...redacted], needsAnonymization };
+}
+function normalizeTopic(topic) {
+  const normalized = topic.toLowerCase().replace(/\d{4}[-_]?\d{2}[-_]?\d{2}\s*$/, "").replace(/[\s_-]+/g, "_").replace(/[^a-z0-9_]/g, "").replace(/^_+|_+$/g, "").slice(0, 40).replace(/_+$/g, "");
+  return normalized || "note";
+}
+function dogfoodFilename(topic, date) {
+  const stamp = date.toISOString().slice(0, 10).replaceAll("-", "_");
+  return `cursor_${normalizeTopic(topic)}_${stamp}.md`;
+}
+function renderDogfoodNote(input) {
+  const tags = (input.tags ?? []).map((tag) => tag.trim().toLowerCase()).filter(Boolean);
+  const lines = [
+    `# Dogfood: ${input.topic}`,
+    "",
+    `- **Date:** ${input.date.toISOString().slice(0, 10)}`,
+    `- **Lane:** ${input.lane}`,
+    `- **Source:** ${input.source ?? "explicit dogfood args"}`
+  ];
+  if (input.needsAnonymization) lines.push("- **Flag:** needs-anonymization");
+  lines.push(
+    "",
+    "## Observation",
+    "",
+    input.observation || "(no description)",
+    "",
+    "## Impact",
+    "",
+    input.impact || "(to be assessed at triage)",
+    "",
+    "## Triage (initial)",
+    "",
+    "- Fix now / Park / Ignore",
+    `- **Tags:** ${tags.join(", ")}`,
+    ""
+  );
+  return lines.join("\n");
+}
+async function exists(target) {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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;
+  }
+}
+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 detectDogfoodLane(root, deps = {}) {
+  const getRemoteUrl = deps.getRemoteUrl ?? defaultGetRemoteUrl;
+  const origin = await getRemoteUrl(root, "origin");
+  if (origin && /agent-kit-dev/i.test(origin)) return "factory";
+  if (await exists(path.join(root, "dogfood", "README.md"))) return "factory";
+  if (await exists(path.join(root, ".cursor", "agent-kit.json"))) return "consumer";
+  return null;
+}
+function inboxDir(root, lane) {
+  return lane === "factory" ? path.join(root, "dogfood") : path.join(root, ".cursor", "dogfood");
+}
+var UNPROCESSED_HEADING = /^(#{2,3})\s+Unprocessed Files\s*$/m;
+var NEW_INDEX = "# Dogfood inbox\n\n### Unprocessed Files\n\n### Processed Files\n";
+function appendUnprocessedEntry(readme, entry) {
+  const match = UNPROCESSED_HEADING.exec(readme);
+  if (!match) {
+    const base = readme.trimEnd();
+    return `${base}${base ? "\n\n" : ""}### Unprocessed Files
+
+${entry}
+`;
+  }
+  const level = (match[1] ?? "###").length;
+  const start = match.index + match[0].length;
+  const rest = readme.slice(start);
+  const next = new RegExp(`^#{1,${level}}\\s`, "m").exec(rest);
+  const sectionEnd = next ? start + next.index : readme.length;
+  const section = readme.slice(start, sectionEnd).replace(/\s+$/, "");
+  const tail = readme.slice(sectionEnd);
+  return `${readme.slice(0, start)}${section}
+${entry}
+${tail ? `
+${tail}` : ""}`;
+}
+async function addDogfoodNote(root, input, deps = {}) {
+  const lane = await detectDogfoodLane(root, deps);
+  if (!lane) return { status: "unknown-lane" };
+  const now = deps.now?.() ?? /* @__PURE__ */ new Date();
+  const topic = hygieneStrip(input.topic);
+  const observation = hygieneStrip(input.summary ?? input.topic);
+  const impact = hygieneStrip(input.impact ?? "");
+  const redacted = [.../* @__PURE__ */ new Set([...topic.redacted, ...observation.redacted, ...impact.redacted])];
+  const needsAnonymization = topic.needsAnonymization || observation.needsAnonymization || impact.needsAnonymization;
+  const dir = inboxDir(root, lane);
+  const filename = dogfoodFilename(topic.text || input.topic, now);
+  const file = path.join(dir, filename);
+  if (await exists(file)) return { status: "exists", lane, file };
+  await mkdir(dir, { recursive: true });
+  await writeFile(
+    file,
+    renderDogfoodNote({
+      topic: topic.text || input.topic,
+      lane,
+      observation: observation.text,
+      impact: impact.text || void 0,
+      tags: input.tags,
+      source: input.source,
+      date: now,
+      needsAnonymization
+    }),
+    "utf8"
+  );
+  const indexFile = path.join(dir, "README.md");
+  const oneLine = observation.text.split(/\r?\n/)[0]?.slice(0, 200) ?? "";
+  const entry = `- \`${filename}\` - ${oneLine || topic.text} (captured ${now.toISOString().slice(0, 10)})${needsAnonymization ? " [needs-anonymization]" : ""}`;
+  const current = await exists(indexFile) ? await readFile(indexFile, "utf8") : NEW_INDEX;
+  await writeFile(indexFile, appendUnprocessedEntry(current, entry), "utf8");
+  return {
+    status: "filed",
+    lane,
+    file,
+    relativeFile: path.relative(root, file),
+    indexFile,
+    needsAnonymization,
+    redacted
+  };
+}
+function withMarker(title) {
+  const trimmed = title.trim();
+  return trimmed.toLowerCase().startsWith(REMOTE_ISSUE_TITLE_PREFIX.toLowerCase()) ? trimmed : `${REMOTE_ISSUE_TITLE_PREFIX} ${trimmed}`;
+}
+function classifyCliFailure(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";
+  return "skipped-error";
+}
+function extractUrl(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    const url = parsed.web_url ?? parsed.url;
+    if (typeof url === "string" && url) return url;
+  } catch {
+  }
+  return /https?:\/\/\S+/.exec(trimmed)?.[0] ?? null;
+}
+async function fileDogfoodIssue(root, input, deps = {}) {
+  const getRemoteUrl = deps.getRemoteUrl ?? defaultGetRemoteUrl;
+  const runCli = deps.runCli ?? defaultRunCli;
+  const title = hygieneStrip(withMarker(input.title));
+  const body = hygieneStrip(input.body);
+  const redacted = [.../* @__PURE__ */ new Set([...title.redacted, ...body.redacted])];
+  const base = {
+    visibility: input.visibility,
+    provider: null,
+    repo: null,
+    title: title.text,
+    confidential: false,
+    url: null,
+    redacted
+  };
+  const stop = (status, message, extra = {}) => ({ ...base, status, message, ...extra });
+  const lane = await detectDogfoodLane(root, deps);
+  if (!lane)
+    return stop("refused-unknown-lane", "Lane unknown: not the factory nor a kit install.");
+  let target;
+  if (input.visibility === "public") {
+    if (lane !== "factory") {
+      return stop("refused-consumer-public", "Consumers never file upstream; use a private issue.");
+    }
+    if (!input.approvedPublic) {
+      return stop(
+        "refused-not-approved",
+        "Public issues need explicit operator approval (--approve-public)."
+      );
+    }
+    if (title.needsAnonymization || body.needsAnonymization) {
+      return stop(
+        "refused-hygiene",
+        `Hygiene strip removed ${redacted.join(", ")}; anonymize the text and retry.`
+      );
+    }
+    target = `https://github.com/${PUBLIC_INBOUND_REPO}.git`;
+  } else {
+    target = await getRemoteUrl(root, "origin");
+  }
+  const remote = target ? parseRemoteUrl(target) : null;
+  if (!remote)
+    return stop("skipped-no-remote", `No ${input.visibility} remote to file the issue in.`);
+  const found = { provider: remote.provider, repo: remote.repo };
+  const finalTitle = title.text;
+  const finalBody = input.visibility === "public" ? body.text : input.body.trim();
+  try {
+    if (remote.provider === "gitlab") {
+      const args = ["api", "--method", "POST"];
+      if (remote.host !== "gitlab.com") args.push("--hostname", remote.host);
+      args.push(
+        `projects/${encodeURIComponent(remote.repo)}/issues`,
+        "-f",
+        `title=${finalTitle}`,
+        "-f",
+        `description=${finalBody}`,
+        "-f",
+        `confidential=${input.visibility === "private" ? "true" : "false"}`
+      );
+      const url2 = extractUrl(await runCli("glab", args, { cwd: root }));
+      return stop("filed", `Filed ${input.visibility} GitLab issue in ${remote.repo}.`, {
+        ...found,
+        confidential: input.visibility === "private",
+        url: url2
+      });
+    }
+    const url = extractUrl(
+      await runCli(
+        "gh",
+        ["issue", "create", "--repo", remote.repo, "--title", finalTitle, "--body", finalBody],
+        { cwd: root }
+      )
+    );
+    return stop("filed", `Filed ${input.visibility} GitHub issue in ${remote.repo}.`, {
+      ...found,
+      url
+    });
+  } catch (error) {
+    const status = classifyCliFailure(error);
+    return stop(status, `Issue not filed (${status}); the local note stays the record.`, found);
+  }
+}
+
+// src/commands/dogfood.ts
+var dogfoodCommand = defineCommand({
+  meta: {
+    name: "dogfood",
+    description: "File dogfood findings headlessly: `add` writes the note + Unprocessed index; `file-issue` opens a private or public issue (GitHub/GitLab)."
+  },
+  subCommands: {
+    add: defineCommand({
+      meta: {
+        name: "add",
+        description: "Write the dogfood template file and append the Unprocessed index for the detected lane (factory dogfood/, consumer .cursor/dogfood/)."
+      },
+      args: {
+        topic: { type: "positional", description: "Short topic", required: true },
+        summary: { type: "string", description: "Observation (hygiene-stripped)" },
+        impact: { type: "string", description: "Impact on the kit or operator" },
+        tags: { type: "string", description: "Comma-separated lowercase tags" },
+        cwd: { type: "string", default: process.cwd() }
+      },
+      async run({ args }) {
+        const result = await addDogfoodNote(String(args.cwd), {
+          topic: String(args.topic),
+          summary: args.summary,
+          impact: args.impact,
+          tags: args.tags?.split(",").map((tag) => tag.trim()),
+          source: "agent-kit dogfood add"
+        });
+        console.log(JSON.stringify(result, null, 2));
+        if (result.status !== "filed") process.exitCode = 1;
+      }
+    }),
+    "file-issue": defineCommand({
+      meta: {
+        name: "file-issue",
+        description: "File an issue with the [Dogfood] marker. private: own origin (GitLab confidential). public: factory only, needs --approve-public and a clean hygiene strip."
+      },
+      args: {
+        visibility: { type: "string", description: "private | public", required: true },
+        title: { type: "string", required: true },
+        body: { type: "string", required: true },
+        "approve-public": {
+          type: "boolean",
+          description: "Operator approved this public issue (Ask provenance recorded in HANDOFF)",
+          default: false
+        },
+        cwd: { type: "string", default: process.cwd() }
+      },
+      async run({ args }) {
+        if (args.visibility !== "private" && args.visibility !== "public") {
+          logger.error("--visibility must be private or public");
+          process.exitCode = 1;
+          return;
+        }
+        const result = await fileDogfoodIssue(String(args.cwd), {
+          visibility: args.visibility,
+          title: String(args.title),
+          body: String(args.body),
+          approvedPublic: args["approve-public"] === true
+        });
+        console.log(JSON.stringify(result, null, 2));
+        if (result.status !== "filed") process.exitCode = 1;
+      }
+    })
+  }
+});
+export {
+  dogfoodCommand
+};