@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-PNFF6OU3.js

@@ -0,0 +1,273 @@
+// src/scanner/readiness.ts
+import { createHash } from "crypto";
+function action(id, status, recommendation, owner) {
+  return { id, status, recommendation, owner };
+}
+function check(id, title, status, essential, evidence, actions = []) {
+  return { id, title, status, essential, evidence, actions };
+}
+function pillar(pillarName, checks) {
+  return { pillar: pillarName, checks };
+}
+function repositoryFingerprint(scan) {
+  const fingerprintInput = {
+    purpose: scan.purpose,
+    stack: {
+      language: scan.stack.language,
+      framework: scan.stack.framework,
+      packageManager: scan.stack.packageManager,
+      workspaces: scan.stack.workspaces
+    },
+    git: {
+      mode: scan.git.mode,
+      remoteUrl: scan.git.remoteUrl,
+      currentBranch: scan.git.currentBranch,
+      defaultBranch: scan.git.defaultBranch
+    },
+    context: scan.context.sources,
+    agentKitVersion: scan.agentKit.version
+  };
+  return createHash("sha256").update(JSON.stringify(fingerprintInput)).digest("hex");
+}
+function buildPillars(scan) {
+  const agentKitStatus = scan.agentKit.installed ? "ready" : "auto_fix";
+  const purposeStatus = scan.purpose.value === "unknown" ? "needs_choice" : "ready";
+  const gitStatus = scan.git.mode === "none" ? "needs_choice" : "ready";
+  const secretsStatus = scan.safety.trackedSensitiveFiles.length > 0 ? "blocked" : scan.safety.trackedFilesUnknown ? "manual" : scan.safety.missingSecretPatterns.length > 0 ? "auto_fix" : "ready";
+  const contextStatus = scan.context.sources.length > 0 ? "ready" : "needs_choice";
+  const providerStatus = scan.git.mode === "none" ? "needs_choice" : scan.git.mode === "local-only" ? "ready" : scan.git.providerKind === "unknown" || scan.git.providerKind === "custom" && scan.git.providerConfidence === "low" ? "needs_choice" : "ready";
+  return [
+    pillar("workspace", [
+      check(
+        "workspace.agent-kit",
+        "Agent Kit installation",
+        agentKitStatus,
+        true,
+        scan.agentKit.manifestPath ? [{ source: "file", value: scan.agentKit.manifestPath }] : [],
+        agentKitStatus === "ready" ? [] : [action("install-agent-kit", "auto_fix", "Install the managed L0 inventory", "system")]
+      )
+    ]),
+    pillar("purpose-context", [
+      check(
+        "purpose.classification",
+        "Repository purpose",
+        purposeStatus,
+        true,
+        scan.purpose.evidence,
+        purposeStatus === "ready" ? [] : [
+          action(
+            "confirm-repository-purpose",
+            "needs_choice",
+            "Confirm the stable repository purpose",
+            "user"
+          )
+        ]
+      ),
+      check(
+        "context.sources",
+        "Project context sources",
+        contextStatus,
+        true,
+        scan.context.sources,
+        contextStatus === "ready" ? [] : [
+          action(
+            "identify-context-source",
+            "needs_choice",
+            "Identify the repository source of truth",
+            "user"
+          )
+        ]
+      )
+    ]),
+    pillar("source-control", [
+      check(
+        "git.repository",
+        "Git repository",
+        gitStatus,
+        true,
+        scan.git.currentBranch ? [{ source: "git", value: `branch:${scan.git.currentBranch}` }] : [],
+        gitStatus === "ready" ? [] : [
+          action(
+            "choose-source-control",
+            "needs_choice",
+            "Choose whether to initialize Git",
+            "user"
+          )
+        ]
+      ),
+      check(
+        "git.staging-branch",
+        "Staging branch",
+        scan.git.hasLocalStaging || scan.git.hasRemoteStaging ? "ready" : "needs_choice",
+        false,
+        [
+          ...scan.git.hasLocalStaging ? [{ source: "git", value: "local branch:staging" }] : [],
+          ...scan.git.hasRemoteStaging ? [{ source: "git", value: "remote branch:staging" }] : []
+        ],
+        scan.git.hasLocalStaging || scan.git.hasRemoteStaging ? [] : [
+          action(
+            "choose-branch-strategy",
+            "needs_choice",
+            "Confirm the repository promotion strategy",
+            "user"
+          )
+        ]
+      )
+    ]),
+    pillar("safety", [
+      check(
+        "safety.secrets",
+        "Secrets hygiene",
+        secretsStatus,
+        true,
+        [
+          ...scan.safety.ignoredSecretPatterns.map((value) => ({
+            source: "file",
+            value: `.gitignore:${value}`
+          })),
+          ...scan.safety.trackedSensitiveFiles.map((value) => ({
+            source: "git",
+            value: `tracked:${value}`
+          }))
+        ],
+        secretsStatus === "ready" ? [] : secretsStatus === "blocked" ? [
+          action(
+            "remove-tracked-secrets",
+            "blocked",
+            "Remove tracked sensitive files and rotate exposed values",
+            "user"
+          )
+        ] : secretsStatus === "manual" ? [
+          action(
+            "verify-tracked-secrets",
+            "manual",
+            "Tracked files could not be listed (git ls-files failed); check for tracked secrets manually",
+            "user"
+          ),
+          ...scan.safety.missingSecretPatterns.length > 0 ? [
+            action(
+              "merge-secret-ignores",
+              "auto_fix",
+              "Merge required secret patterns into .gitignore",
+              "system"
+            )
+          ] : []
+        ] : [
+          action(
+            "merge-secret-ignores",
+            "auto_fix",
+            "Merge required secret patterns into .gitignore",
+            "system"
+          )
+        ]
+      )
+    ]),
+    pillar("stack-tooling", [
+      check(
+        "stack.detected",
+        "Stack and package manager",
+        scan.stack.language !== "unknown" || scan.stack.hasProjectFiles ? "ready" : "needs_choice",
+        true,
+        scan.stack.packageManagerEvidence ?? []
+      )
+    ]),
+    pillar("quality-ci", [
+      (() => {
+        const hasValidation = scan.quality.hasTests || scan.quality.validationCommands.length > 0 || scan.quality.ciRunCommands.length > 0;
+        return check(
+          "quality.validation",
+          "Tests and validation",
+          hasValidation ? "ready" : "manual",
+          false,
+          [
+            ...scan.infra.ciFiles.map((value) => ({ source: "file", value })),
+            ...scan.quality.ciRunCommands.map((value) => ({
+              source: "file",
+              value: `ci:${value}`
+            }))
+          ],
+          hasValidation ? [] : [
+            action(
+              "document-validation",
+              "manual",
+              "Document a repeatable repository validation command",
+              "user"
+            )
+          ]
+        );
+      })()
+    ]),
+    pillar("deploy-infrastructure", [
+      check(
+        "infrastructure.detected",
+        "Deployment and infrastructure evidence",
+        "ready",
+        false,
+        [...scan.infra.infrastructureFiles, ...scan.infra.deploymentFiles].map((value) => ({
+          source: "file",
+          value
+        }))
+      )
+    ]),
+    pillar("collaboration", [
+      check(
+        "collaboration.provider",
+        "Repository provider",
+        providerStatus,
+        false,
+        scan.git.providerEvidence,
+        providerStatus === "ready" ? [] : [
+          action(
+            "confirm-provider",
+            "needs_choice",
+            "Confirm the remote provider or local-only model",
+            "user"
+          )
+        ]
+      )
+    ]),
+    pillar("agent-kit-personalization", [
+      check(
+        "agent-kit.context",
+        "Agent guidance",
+        scan.context.hasAgentGuidance ? "ready" : "auto_fix",
+        false,
+        scan.context.sources.filter((item) => item.value.includes("guidance")),
+        scan.context.hasAgentGuidance ? [] : [
+          action(
+            "prepare-agent-context",
+            "auto_fix",
+            "Prepare Agent Kit-owned context from detected evidence",
+            "system"
+          )
+        ]
+      )
+    ])
+  ];
+}
+function createReadinessReport(scan, options) {
+  const pillars = buildPillars(scan);
+  const checks = pillars.flatMap((item) => item.checks);
+  const statuses = ["ready", "auto_fix", "needs_choice", "manual", "blocked"];
+  const summary = Object.fromEntries(
+    statuses.map((status) => [status, checks.filter((item) => item.status === status).length])
+  );
+  const pendingActions = checks.flatMap((item) => item.actions).filter((item) => item.status !== "ready");
+  const { rootDir: _rootDir, ...portableScan } = scan;
+  return {
+    schemaVersion: 1,
+    generatorVersion: options.generatorVersion,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    repositoryFingerprint: repositoryFingerprint(scan),
+    summary,
+    scan: portableScan,
+    pillars,
+    appliedSafeFixes: [],
+    pendingActions,
+    deferredChecks: []
+  };
+}
+
+export {
+  createReadinessReport
+};

package/dist/chunk-PNG7LO2F.js

@@ -0,0 +1,53 @@
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  DEFAULT_REGISTRY_REF,
+  DEFAULT_REGISTRY_URL,
+  resolveRegistryRoot
+} from "./chunk-AW74INUW.js";
+
+// src/lifecycle/resolve-cli.ts
+async function resolveRegistryFromCli(options) {
+  const fromManifest = options.manifest?.registry;
+  if (!options.registry && !options.url && fromManifest?.url) {
+    const ref = options.ref ?? fromManifest.ref ?? DEFAULT_REGISTRY_REF;
+    logger.info(`registry: ${fromManifest.url}@${ref} (from manifest)`);
+    if (fromManifest.url !== DEFAULT_REGISTRY_URL) {
+      logger.warn(
+        `registry url from .cursor/agent-kit.json is not the default ${DEFAULT_REGISTRY_URL}; verify you trust ${fromManifest.url}`
+      );
+    }
+  }
+  return resolveRegistryRoot({
+    cwd: options.cwd,
+    registryPath: options.registry,
+    registryUrl: options.url ?? fromManifest?.url,
+    registryRef: options.ref ?? fromManifest?.ref,
+    refresh: options.refresh
+  });
+}
+var REGISTRY_CLI_ARGS = {
+  registry: {
+    type: "string",
+    description: "Local path to a kit checkout that contains registry/"
+  },
+  url: {
+    type: "string",
+    description: "Remote registry git URL (default: public agent-kit)"
+  },
+  ref: {
+    type: "string",
+    description: "Git ref for remote registry (branch or tag)"
+  },
+  refresh: {
+    type: "boolean",
+    description: "Refresh cached remote registry",
+    default: false
+  }
+};
+
+export {
+  resolveRegistryFromCli,
+  REGISTRY_CLI_ARGS
+};

package/dist/chunk-QTON2GQX.js

@@ -0,0 +1,203 @@
+// src/welcome/visual-kit.ts
+import { cyan, gray, options as koloristOptions } from "kolorist";
+var KOLORIST_TRUECOLOR = 3;
+var HELMET_OUTLINE = "#e2e8f0";
+var HELMET_FILL = "#0C8DEB";
+var HELMET_ACCENT = "#00D0E7";
+var LABEL_MUTED = "#8899aa";
+var STATUS_OK = "#22c55e";
+var STATUS_WARN = "#eab308";
+var STATUS_ERR = "#ef4444";
+var STATUS_INFO = "#06b6d4";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPACE_MARKS = {
+  star: "\u2726",
+  tick: "\xB7",
+  diamond: "\u2727",
+  visor: "( )"
+};
+var KIT_TIPS = [
+  "Try agent-kit doctor for repository readiness.",
+  "HITL Ask UI is Cursor-only; agent-kit run uses a numbered list.",
+  "/run-plan never promotes to production.",
+  "Mission Control is the dashboard, not the CLI name.",
+  "NO_COLOR and CI keep this output static.",
+  "agent-kit --help groups SETUP, MISSION, DASHBOARD, INTEGRITY."
+];
+function shouldUseWelcomeColor(opts = {}) {
+  const env = opts.env ?? process.env;
+  if (opts.color === false) return false;
+  if (env.NO_COLOR) return false;
+  if (env.NODE_DISABLE_COLORS) return false;
+  if (env.FORCE_COLOR === "0") return false;
+  if (opts.color === true) return true;
+  if (env.CI != null && env.CI !== "" && env.CI !== "false" && env.CI !== "0") return false;
+  const tty = opts.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
+  return tty;
+}
+function withKoloristColor(fn) {
+  const prevEnabled = koloristOptions.enabled;
+  const prevLevel = koloristOptions.supportLevel;
+  koloristOptions.enabled = true;
+  koloristOptions.supportLevel = KOLORIST_TRUECOLOR;
+  try {
+    return fn();
+  } finally {
+    koloristOptions.enabled = prevEnabled;
+    koloristOptions.supportLevel = prevLevel;
+  }
+}
+function shouldUseVisualMotion(opts = {}) {
+  if (process.env.AGENT_KIT_REDUCED_MOTION === "1") return false;
+  return shouldUseWelcomeColor(opts);
+}
+function spinnerFrame(index) {
+  const n = SPINNER_FRAMES.length;
+  return SPINNER_FRAMES[(index % n + n) % n] ?? SPINNER_FRAMES[0];
+}
+function tipAt(index) {
+  const n = KIT_TIPS.length;
+  return KIT_TIPS[(index % n + n) % n] ?? KIT_TIPS[0];
+}
+function wrapNarrow(text, columns) {
+  const width = Math.max(8, Number.isFinite(columns) ? Math.floor(columns) : 80);
+  const words = text.trim().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return "";
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (word.length > width) {
+      if (current) {
+        lines.push(current);
+        current = "";
+      }
+      for (let i = 0; i < word.length; i += width) {
+        const chunk = word.slice(i, i + width);
+        if (i + width >= word.length) current = chunk;
+        else lines.push(chunk);
+      }
+      continue;
+    }
+    const next = current ? `${current} ${word}` : word;
+    if (next.length > width) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = next;
+    }
+  }
+  if (current) lines.push(current);
+  return lines.join("\n");
+}
+function renderProgressLine(opts) {
+  const motion = opts.motion ?? shouldUseVisualMotion();
+  const color = opts.color ?? shouldUseWelcomeColor();
+  const mark = motion ? spinnerFrame(opts.frameIndex) : SPACE_MARKS.tick;
+  const tip = tipAt(opts.tipIndex);
+  const label = opts.label?.trim() ?? "";
+  const raw = label ? `${mark} ${label} ${SPACE_MARKS.star} ${tip}` : `${mark} ${tip}`;
+  const cols = opts.columns ?? process.stdout.columns ?? 80;
+  const wrapped = wrapNarrow(raw, cols);
+  if (!color) return wrapped;
+  const prevEnabled = koloristOptions.enabled;
+  koloristOptions.enabled = true;
+  try {
+    return wrapped.split("\n").map((line, i) => i === 0 ? cyan(line) : gray(line)).join("\n");
+  } finally {
+    koloristOptions.enabled = prevEnabled;
+  }
+}
+var TtySpinner = class {
+  timer = null;
+  frame = 0;
+  startedAt = 0;
+  label = "";
+  write;
+  columns;
+  motion;
+  color;
+  intervalMs;
+  now;
+  constructor(opts = {}) {
+    this.write = opts.write ?? ((chunk) => process.stdout.write(chunk));
+    this.columns = opts.columns ?? (() => process.stdout.columns ?? 80);
+    this.motion = opts.motion ?? shouldUseVisualMotion();
+    this.color = opts.color ?? shouldUseWelcomeColor();
+    this.intervalMs = opts.intervalMs ?? 80;
+    this.now = opts.now ?? (() => Date.now());
+  }
+  start(label = "") {
+    this.stop();
+    this.label = label;
+    this.frame = 0;
+    this.startedAt = this.now();
+    this.paint(false);
+    if (!this.motion) return;
+    this.timer = setInterval(() => {
+      this.frame += 1;
+      this.paint(true);
+    }, this.intervalMs);
+    this.timer.unref?.();
+  }
+  stop(finalLine) {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.motion) this.write("\r\x1B[K");
+    if (finalLine) this.write(`${finalLine}
+`);
+  }
+  paint(overwrite) {
+    const elapsed = this.now() - this.startedAt;
+    const tipIndex = Math.floor(elapsed / 4e3);
+    const line = renderProgressLine({
+      frameIndex: this.frame,
+      tipIndex,
+      columns: this.columns(),
+      label: this.label,
+      motion: this.motion,
+      color: this.color
+    }).split("\n")[0] ?? "";
+    if (overwrite && this.motion) this.write(`\r\x1B[K${line}`);
+    else if (this.motion) this.write(line);
+    else this.write(`${line}
+`);
+  }
+};
+async function withCliProgress(label, fn, opts) {
+  const motion = opts?.motion ?? shouldUseVisualMotion();
+  if (!motion) {
+    return fn();
+  }
+  const spinner = new TtySpinner({ ...opts, motion: true });
+  spinner.start(label);
+  try {
+    const result = await fn();
+    spinner.stop();
+    return result;
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+}
+
+export {
+  HELMET_OUTLINE,
+  HELMET_FILL,
+  HELMET_ACCENT,
+  LABEL_MUTED,
+  STATUS_OK,
+  STATUS_WARN,
+  STATUS_ERR,
+  STATUS_INFO,
+  SPACE_MARKS,
+  shouldUseWelcomeColor,
+  withKoloristColor,
+  shouldUseVisualMotion,
+  spinnerFrame,
+  tipAt,
+  wrapNarrow,
+  TtySpinner,
+  withCliProgress
+};

package/dist/chunk-S6GMFDKV.js

@@ -0,0 +1,50 @@
+import {
+  MANIFEST_RELATIVE_PATH
+} from "./chunk-AW74INUW.js";
+import {
+  fileExists
+} from "./chunk-77V75A7O.js";
+
+// src/scanner/workspace-parent.ts
+import { readdir } from "fs/promises";
+import path from "path";
+var MAX_CHILDREN_INSPECTED = 200;
+var MAX_KIT_PROJECTS_REPORTED = 10;
+async function detectWorkspaceParent(rootDir) {
+  try {
+    if (await fileExists(path.join(rootDir, MANIFEST_RELATIVE_PATH))) return null;
+    const entries = await readdir(rootDir, { withFileTypes: true });
+    const children = entries.filter(
+      (entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules"
+    ).map((entry) => entry.name).sort().slice(0, MAX_CHILDREN_INSPECTED);
+    const hits = await Promise.all(
+      children.map(
+        async (name) => await fileExists(path.join(rootDir, name, MANIFEST_RELATIVE_PATH)) ? name : null
+      )
+    );
+    const kitProjects = hits.filter((name) => name !== null).slice(0, MAX_KIT_PROJECTS_REPORTED);
+    return kitProjects.length > 0 ? { kitProjects } : null;
+  } catch {
+    return null;
+  }
+}
+function shellArg(value) {
+  return /^[\w@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+function workspaceParentNextStep(detection, command) {
+  return `cd ${shellArg(detection.kitProjects[0] ?? "<project>")} && agent-kit ${command}`;
+}
+function workspaceParentAdvisoryLines(rootDir, detection, command) {
+  return [
+    `No Agent Kit here: ${rootDir} is a workspace folder, not a kit project.`,
+    "Kit projects in its direct subfolders:",
+    ...detection.kitProjects.map((name) => `  - ${name}`),
+    `Run \`agent-kit ${command}\` from inside one of them.`,
+    `Next: ${workspaceParentNextStep(detection, command)}`
+  ];
+}
+
+export {
+  detectWorkspaceParent,
+  workspaceParentAdvisoryLines
+};