@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/setup-global-M42GEODI.js

@@ -0,0 +1,340 @@
+import {
+  classifyInstallError,
+  isNonInteractive,
+  pathCliStatus
+} from "./chunk-F4VMYR7U.js";
+import {
+  assessEnvironment
+} from "./chunk-4IWG5CVE.js";
+import "./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,
+  pinnedCliSpec
+} from "./chunk-7HDQEK6T.js";
+import "./chunk-77V75A7O.js";
+
+// src/commands/setup-global.ts
+import { spawn } from "child_process";
+import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { confirm, isCancel } from "@clack/prompts";
+import { defineCommand } from "citty";
+import { cyan, green, yellow } from "kolorist";
+var NPM_GLOBAL_DIR_NAME = ".npm-global";
+var SETUP_GLOBAL_MARKER = "# agent-kit setup-global";
+function planSetupGlobalSteps(env, options = {}) {
+  const homeDir = options.homeDir ?? homedir();
+  const packageSpec = options.packageSpec ?? pinnedCliSpec();
+  const npmGlobalDir = path.join(homeDir, NPM_GLOBAL_DIR_NAME);
+  const npmGlobalBin = path.join(npmGlobalDir, "bin");
+  const npmrcPath = path.join(homeDir, ".npmrc");
+  const npmrcPrefixValue = `~/${NPM_GLOBAL_DIR_NAME}`;
+  const pathExportLine = `export PATH="${npmGlobalBin}:$PATH"`;
+  const shellProfile = env.shellProfile;
+  const shellSupported = shellProfile != null;
+  const steps = [
+    {
+      id: "set-prefix",
+      title: "Set npm's global install prefix to a folder you own",
+      detail: [
+        `mkdir -p ${npmGlobalDir}`,
+        `npm config set prefix "${npmrcPrefixValue}"  (writes "prefix = ${npmrcPrefixValue}" to ${npmrcPath})`
+      ]
+    },
+    {
+      id: "append-path",
+      title: shellSupported ? `Put ${npmGlobalBin} on PATH via ${shellProfile}` : "Put npm's global bin on PATH (manual \u2014 shell not auto-detected)",
+      detail: shellSupported ? [`Append to ${shellProfile}:`, `  ${SETUP_GLOBAL_MARKER}`, `  ${pathExportLine}`] : [
+        `Shell could not be auto-detected as zsh or bash (detected: ${env.shell ?? "unknown"}).`,
+        "You'll need to add this line to your shell's startup file yourself:",
+        `  ${pathExportLine}`
+      ]
+    },
+    {
+      id: "npm-install",
+      title: `Reinstall ${packageSpec} globally, now into the new prefix`,
+      detail: [`npm i -g ${packageSpec}`]
+    },
+    {
+      id: "verify",
+      title: "Verify `agent-kit` resolves on PATH",
+      detail: [
+        "Re-check whether a bare `agent-kit` resolves on PATH.",
+        "Needs a new shell session (or `source` the profile) to take effect \u2014 this process's own PATH can't reflect it."
+      ]
+    }
+  ];
+  return {
+    packageSpec,
+    homeDir,
+    npmGlobalDir,
+    npmGlobalBin,
+    npmrcPath,
+    npmrcPrefixValue,
+    pathExportLine,
+    markerComment: SETUP_GLOBAL_MARKER,
+    shellProfile,
+    shellSupported,
+    alreadyWritable: env.npmPrefixWritable,
+    currentPrefix: env.npmPrefix.prefix,
+    steps
+  };
+}
+function upsertNpmrcPrefix(content, prefixValue) {
+  const line = `prefix = ${prefixValue}`;
+  const prefixLineRe = /^\s*prefix\s*=.*$/m;
+  if (prefixLineRe.test(content)) {
+    return content.replace(prefixLineRe, line);
+  }
+  const withTrailingNewline = content.length > 0 && !content.endsWith("\n") ? `${content}
+` : content;
+  return `${withTrailingNewline}${line}
+`;
+}
+var defaultFsImpl = {
+  mkdir: async (dir) => {
+    await mkdir(dir, { recursive: true });
+  },
+  readFile: (filePath) => readFile(filePath, "utf8"),
+  writeFile: (filePath, content) => writeFile(filePath, content, "utf8"),
+  appendFile: (filePath, content) => appendFile(filePath, content, "utf8")
+};
+async function safeReadFile(fs, filePath) {
+  try {
+    return await fs.readFile(filePath);
+  } catch {
+    return "";
+  }
+}
+var defaultNpmInstallImpl = (packageSpec) => new Promise((resolve) => {
+  const child = spawn("npm", ["i", "-g", packageSpec], { stdio: "inherit" });
+  child.on("error", (error) => resolve({ ok: false, error }));
+  child.on("close", (code) => {
+    if (code === 0) resolve({ ok: true });
+    else resolve({ ok: false, error: new Error(`npm exited with code ${code ?? "unknown"}`) });
+  });
+});
+var defaultConfirmImpl = async (message) => {
+  const answer = await confirm({ message, initialValue: true });
+  if (isCancel(answer)) return false;
+  return Boolean(answer);
+};
+function printHeader(env, print) {
+  print(cyan("agent-kit setup-global"));
+  print(
+    `  npm prefix: ${env.npmPrefix.prefix ?? "unknown"} (${env.npmPrefixWritable ? "writable" : "NOT writable"})`
+  );
+  if (!env.npmPrefixWritable && env.npmPrefix.reason) {
+    print(`    ${env.npmPrefix.reason}`);
+  }
+  print(
+    `  shell: ${env.shell ?? "unknown"}${env.shellProfile ? ` (profile: ${env.shellProfile})` : " (profile not auto-detected: zsh/bash only)"}`
+  );
+}
+function printPlanSteps(plan, print) {
+  for (const [index, step] of plan.steps.entries()) {
+    print(`${index + 1}. ${step.title}`);
+    for (const line of step.detail) print(`   ${line}`);
+  }
+}
+function printManualInstructions(plan, print) {
+  print("No changes made. Same fix, as commands you can run yourself:");
+  print(`  mkdir -p ${plan.npmGlobalDir}`);
+  print(`  npm config set prefix "${plan.npmrcPrefixValue}"`);
+  if (plan.shellSupported) {
+    print(`  echo '${plan.markerComment}' >> ${plan.shellProfile}`);
+    print(`  echo '${plan.pathExportLine}' >> ${plan.shellProfile}`);
+    print(`  source ${plan.shellProfile}`);
+  } else {
+    print(`  # add this line to your shell's startup file:`);
+    print(`  ${plan.pathExportLine}`);
+  }
+  print(`  npm i -g ${plan.packageSpec}`);
+  print("  agent-kit --version   # verify, in a new shell session");
+}
+async function runSetupGlobal(options = {}) {
+  const print = options.print ?? ((line) => console.log(line));
+  const assessEnvironmentImpl = options.assessEnvironmentImpl ?? assessEnvironment;
+  const homeDir = options.homeDir ?? homedir();
+  const env = await assessEnvironmentImpl(options);
+  const plan = planSetupGlobalSteps(env, { homeDir, packageSpec: options.packageSpec });
+  if (plan.alreadyWritable && pathCliStatus(env, KIT_VERSION) === "current") {
+    printHeader(env, print);
+    print(green("npm's global prefix is writable and PATH `agent-kit` matches this CLI."));
+    return { exitCode: 0, mutated: false, outcome: "already-ok", env, plan };
+  }
+  if (plan.alreadyWritable) {
+    printHeader(env, print);
+    print(
+      `PATH \`agent-kit\` is ${env.binVersion ? `v${env.binVersion}` : "missing or unreadable"}; this CLI is v${KIT_VERSION}.`
+    );
+    print(`Prefix is writable. Next step is only: npm i -g ${plan.packageSpec}`);
+    if (options.dryRun) {
+      print("Dry run: no changes.");
+      print(`  npm i -g ${plan.packageSpec}`);
+      return { exitCode: 0, mutated: false, outcome: "dry-run", env, plan };
+    }
+    const nonInteractiveWritable = options.nonInteractive ?? isNonInteractive();
+    if (nonInteractiveWritable) {
+      print("No changes made. Run this yourself:");
+      print(`  npm i -g ${plan.packageSpec}`);
+      print("  hash -r");
+      print("  agent-kit --version");
+      return { exitCode: 0, mutated: false, outcome: "manual-instructions", env, plan };
+    }
+    const confirmStep2 = options.confirmImpl ?? defaultConfirmImpl;
+    const npmInstall2 = options.npmInstallImpl ?? defaultNpmInstallImpl;
+    const proceedInstall2 = await confirmStep2(`Run: npm i -g ${plan.packageSpec}?`);
+    if (!proceedInstall2) {
+      print(yellow("Cancelled: no changes made."));
+      return { exitCode: 1, mutated: false, outcome: "cancelled", env, plan };
+    }
+    const installResult2 = await npmInstall2(plan.packageSpec);
+    if (!installResult2.ok) {
+      const hint = classifyInstallError(installResult2.error);
+      print(`  npm install failed: ${hint.message}`);
+      print(hint.recovery);
+      return { exitCode: 1, mutated: false, outcome: "error", env, plan };
+    }
+    print(green(`  done: ${plan.packageSpec} installed globally.`));
+    print("  If this shell still shows the old version: hash -r (or open a new terminal).");
+    return { exitCode: 0, mutated: true, outcome: "completed", env, plan };
+  }
+  if (options.dryRun) {
+    printHeader(env, print);
+    print("Dry run \u2014 no changes will be made. Steps that would run:");
+    printPlanSteps(plan, print);
+    return { exitCode: 0, mutated: false, outcome: "dry-run", env, plan };
+  }
+  const nonInteractive = options.nonInteractive ?? isNonInteractive();
+  if (nonInteractive) {
+    printHeader(env, print);
+    printManualInstructions(plan, print);
+    return { exitCode: 0, mutated: false, outcome: "manual-instructions", env, plan };
+  }
+  printHeader(env, print);
+  print("You just hit the classic 'command not found' / EACCES fresh-install blocker.");
+  print("The following steps need your confirmation, one at a time:");
+  printPlanSteps(plan, print);
+  const fs = options.fsImpl ?? defaultFsImpl;
+  const confirmStep = options.confirmImpl ?? defaultConfirmImpl;
+  const npmInstall = options.npmInstallImpl ?? defaultNpmInstallImpl;
+  let mutated = false;
+  const setPrefixStep = plan.steps[0];
+  print(`
+${setPrefixStep.title}`);
+  for (const line of setPrefixStep.detail) print(`   ${line}`);
+  const proceedPrefix = await confirmStep(`Set npm's global prefix to ${plan.npmGlobalDir}?`);
+  if (!proceedPrefix) {
+    print(yellow("Cancelled \u2014 no changes made."));
+    return { exitCode: 1, mutated, outcome: "cancelled", env, plan };
+  }
+  await fs.mkdir(plan.npmGlobalDir);
+  const npmrcContent = await safeReadFile(fs, plan.npmrcPath);
+  await fs.writeFile(plan.npmrcPath, upsertNpmrcPrefix(npmrcContent, plan.npmrcPrefixValue));
+  mutated = true;
+  print(green(`  done: prefix set (${plan.npmrcPath}).`));
+  const appendPathStep = plan.steps[1];
+  print(`
+${appendPathStep.title}`);
+  for (const line of appendPathStep.detail) print(`   ${line}`);
+  if (!plan.shellSupported) {
+    print(yellow("  shell not auto-detected as zsh/bash \u2014 add the line above yourself."));
+  } else {
+    const profilePath = plan.shellProfile;
+    const profileContent = await safeReadFile(fs, profilePath);
+    if (profileContent.includes(plan.markerComment)) {
+      print(`  already present in ${profilePath} (marker found) \u2014 skipping.`);
+    } else {
+      const proceedPath = await confirmStep(`Append the PATH export to ${profilePath}?`);
+      if (!proceedPath) {
+        print(yellow("Cancelled \u2014 prefix was set, PATH export was not appended."));
+        return { exitCode: 1, mutated, outcome: "cancelled", env, plan };
+      }
+      await fs.appendFile(profilePath, `
+${plan.markerComment}
+${plan.pathExportLine}
+`);
+      mutated = true;
+      print(green(`  done: PATH export appended to ${profilePath}.`));
+    }
+  }
+  const installStep = plan.steps[2];
+  print(`
+${installStep.title}`);
+  for (const line of installStep.detail) print(`   ${line}`);
+  const proceedInstall = await confirmStep(`Run: npm i -g ${plan.packageSpec}?`);
+  if (!proceedInstall) {
+    print(yellow("Cancelled \u2014 prefix/PATH changes above are still in place."));
+    return { exitCode: 1, mutated, outcome: "cancelled", env, plan };
+  }
+  const installResult = await npmInstall(plan.packageSpec);
+  if (!installResult.ok) {
+    const hint = classifyInstallError(installResult.error);
+    print(`  npm install failed: ${hint.message}`);
+    print(hint.recovery);
+    return { exitCode: 1, mutated, outcome: "error", env, plan };
+  }
+  mutated = true;
+  print(green(`  done: ${plan.packageSpec} installed globally.`));
+  const verifyStep = plan.steps[3];
+  print(`
+${verifyStep.title}`);
+  for (const line of verifyStep.detail) print(`   ${line}`);
+  const proceedVerify = await confirmStep("Verify now (re-check PATH in this process)?");
+  if (proceedVerify) {
+    const verifyEnv = await assessEnvironmentImpl(options);
+    if (verifyEnv.binOnPath) {
+      print(green("  verify: `agent-kit` resolves on PATH."));
+    } else {
+      print("  verify: `agent-kit` isn't resolvable in THIS process's PATH yet \u2014 that's expected.");
+      print(
+        `  Open a new terminal (or run: source ${plan.shellProfile ?? "<your shell profile>"}) and re-check with: agent-kit --version`
+      );
+    }
+  } else {
+    print("  skipped verification. Open a new terminal and run: agent-kit --version");
+  }
+  return { exitCode: 0, mutated, outcome: "completed", env, plan };
+}
+var setupGlobalCommand = defineCommand({
+  meta: {
+    name: "setup-global",
+    description: "Self-heal a root-owned npm prefix: relocate to ~/.npm-global, fix PATH, reinstall globally."
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Print the resolved plan; mutate nothing.",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Treat as non-interactive: print the manual steps instead of prompting (never mutates).",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const nonInteractive = args.yes || isNonInteractive();
+    const result = await runSetupGlobal({
+      dryRun: Boolean(args["dry-run"]),
+      nonInteractive
+    });
+    process.exitCode = result.exitCode;
+  }
+});
+export {
+  NPM_GLOBAL_DIR_NAME,
+  SETUP_GLOBAL_MARKER,
+  planSetupGlobalSteps,
+  runSetupGlobal,
+  setupGlobalCommand,
+  upsertNpmrcPrefix
+};

package/dist/status-XPVQVQMX.js

@@ -0,0 +1,150 @@
+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 {
+  npxPinned,
+  pathCliStatus
+} from "./chunk-F4VMYR7U.js";
+import {
+  assessEnvironment
+} from "./chunk-4IWG5CVE.js";
+import "./chunk-SMGFN3Z4.js";
+import "./chunk-NQ7IQ5XT.js";
+import "./chunk-2RDRMGD3.js";
+import "./chunk-N3HTJVBR.js";
+import {
+  MANIFEST_RELATIVE_PATH,
+  loadAgentKitManifest,
+  resolveProtectedGlobs
+} from "./chunk-AW74INUW.js";
+import "./chunk-5VCOWTTP.js";
+import {
+  KIT_VERSION
+} from "./chunk-7HDQEK6T.js";
+import {
+  readJson
+} from "./chunk-77V75A7O.js";
+
+// src/commands/status.ts
+import path from "path";
+import { defineCommand } from "citty";
+function profileStatus(profile) {
+  if (!profile) return { origin: "none", evidence: [], profile: null };
+  if ("detection" in profile && profile.detection && typeof profile.detection === "object") {
+    const detection = profile.detection;
+    return {
+      origin: "readiness-scanner",
+      evidence: detection.providerEvidence ?? [],
+      profile
+    };
+  }
+  return { origin: "legacy-wizard", evidence: [], profile };
+}
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show installed kit version, manifest, and optional profile."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    json: {
+      type: "boolean",
+      description: "Print raw JSON for manifest and profile",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const rootDir = path.resolve(args.cwd);
+    const workspaceParent = await detectWorkspaceParent(rootDir);
+    if (workspaceParent && !args.json) {
+      for (const line of workspaceParentAdvisoryLines(rootDir, workspaceParent, "status")) {
+        console.log(line);
+      }
+      return;
+    }
+    const [manifest, rawProfile, scan, env] = await Promise.all([
+      loadAgentKitManifest(rootDir, args.json ? {} : { onWarning: logger.warn }),
+      readJson(
+        path.join(rootDir, ".cursor", "agent-kit.config.json")
+      ),
+      runScanner(rootDir),
+      assessEnvironment()
+    ]);
+    const readiness = createReadinessReport(scan, { generatorVersion: KIT_VERSION });
+    const profile = profileStatus(rawProfile);
+    const nextAction = readiness.pendingActions[0];
+    if (args.json) {
+      console.log(
+        JSON.stringify(
+          {
+            runtimeVersion: KIT_VERSION,
+            manifest: manifest ?? null,
+            readiness,
+            pendingActions: readiness.pendingActions,
+            profile,
+            ...workspaceParent ? { workspaceParent } : {}
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (!manifest) {
+      logger.warn(`No ${MANIFEST_RELATIVE_PATH}: run agent-kit install.`);
+    } else {
+      const protectedGlobs = resolveProtectedGlobs(manifest);
+      console.log("Agent Kit status");
+      console.log(`  runtime:    ${KIT_VERSION}`);
+      console.log(`  installed:  ${manifest.version}`);
+      console.log(`  profile:    ${manifest.profile ?? "(none)"}`);
+      console.log(`  packs:      ${(manifest.packs ?? []).join(", ") || "(none)"}`);
+      console.log(`  skills:     ${(manifest.skills ?? []).length} listed`);
+      console.log(`  protected:  ${protectedGlobs.length} glob(s) (L3 safe on update)`);
+      console.log(
+        `  registry:   ${manifest.registry?.url ?? "(default)"} @ ${manifest.registry?.ref ?? "(default)"}`
+      );
+      if (manifest.installedAt) console.log(`  installed at: ${manifest.installedAt}`);
+      if (manifest.version !== KIT_VERSION) {
+        console.log(
+          `  overlay:    this CLI is v${KIT_VERSION}; apply with the same binary, not a stale PATH hit:`
+        );
+        console.log(`              ${npxPinned(KIT_VERSION, "update")}`);
+      }
+      const pathStatus = pathCliStatus(env, KIT_VERSION);
+      if (pathStatus === "behind" || pathStatus === "unknown") {
+        console.log(`  PATH bin:   v${env.binVersion ?? "unknown"} at ${env.binPath}`);
+        console.log("              bare `agent-kit update` will re-stamp that older version");
+      }
+    }
+    console.log("Repository readiness");
+    console.log(
+      `  ready: ${readiness.summary.ready}, choices: ${readiness.summary.needs_choice}, manual: ${readiness.summary.manual}, blocked: ${readiness.summary.blocked}`
+    );
+    console.log(`  pending: ${readiness.pendingActions.length}`);
+    console.log(`  profile origin: ${profile.origin}`);
+    console.log(
+      `  profile evidence: ${profile.evidence.map((item) => item.value).join(", ") || "(none)"}`
+    );
+    console.log(
+      nextAction ? `Next: ${nextAction.recommendation}` : "Next: repository readiness checks are complete"
+    );
+  }
+});
+export {
+  statusCommand
+};