@dadado/agent-kit-cli 5.15.0 → 5.16.0

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