@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-4IWG5CVE.js

@@ -0,0 +1,214 @@
+// src/readiness/env-checks.ts
+import { constants, access, readFile, realpath, stat } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+var MIN_NODE_MAJOR = 20;
+var CLI_PACKAGE_JSON_REL = path.join(
+  "lib",
+  "node_modules",
+  "@dadado",
+  "agent-kit-cli",
+  "package.json"
+);
+var DIST_INDEX_RE = /(?:\$\{basedir\}|\$basedir)?[^'"\s;]*dist\/index\.js/g;
+function extractDistIndexFromBinScript(contents) {
+  const found = [];
+  DIST_INDEX_RE.lastIndex = 0;
+  for (const match of contents.matchAll(DIST_INDEX_RE)) {
+    const raw = match[0]?.trim();
+    if (raw) found.push(raw.replace(/\\/g, "/"));
+  }
+  return found;
+}
+function expandBinDirVars(raw, binDir) {
+  return raw.replace(/\$\{basedir\}/g, binDir).replace(/\$basedir/g, binDir);
+}
+var SHIM_MAX_BYTES = 4096;
+function packageJsonFromDistIndex(distIndex) {
+  return path.join(path.dirname(distIndex), "..", "package.json");
+}
+function parsePackageVersion(contents) {
+  try {
+    const parsed = JSON.parse(contents);
+    return typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+async function readBinVersion(binPath, options = {}) {
+  const readFileImpl = options.readFileImpl ?? ((filePath) => readFile(filePath, "utf8"));
+  const binDir = path.dirname(binPath);
+  const candidates = [];
+  let realBin = binPath;
+  try {
+    realBin = await realpath(binPath);
+  } catch {
+  }
+  if (path.basename(realBin) === "index.js" && path.basename(path.dirname(realBin)) === "dist") {
+    candidates.push(packageJsonFromDistIndex(realBin));
+  }
+  candidates.push(
+    path.join(binDir, "..", CLI_PACKAGE_JSON_REL),
+    path.join(binDir, "..", "node_modules", "@dadado", "agent-kit-cli", "package.json")
+  );
+  try {
+    if ((await stat(realBin)).size < SHIM_MAX_BYTES) {
+      const contents = await readFileImpl(binPath);
+      for (const raw of extractDistIndexFromBinScript(contents)) {
+        const distIndex = path.resolve(binDir, expandBinDirVars(raw, binDir));
+        candidates.push(packageJsonFromDistIndex(distIndex));
+      }
+    }
+  } catch {
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const resolved = path.resolve(candidate);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    try {
+      const version = parsePackageVersion(await readFileImpl(resolved));
+      if (version) return version;
+    } catch {
+    }
+  }
+  return null;
+}
+async function resolveBinOnPath(binName, env, platform) {
+  const pathVar = env.PATH ?? env.Path ?? "";
+  if (!pathVar) return null;
+  const dirs = pathVar.split(path.delimiter).filter(Boolean);
+  const candidates = platform === "win32" ? [binName, `${binName}.cmd`, `${binName}.exe`, `${binName}.bat`] : [binName];
+  for (const dir of dirs) {
+    for (const candidate of candidates) {
+      const abs = path.join(dir, candidate);
+      try {
+        await access(abs, platform === "win32" ? void 0 : constants.X_OK);
+        return abs;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function isNodeVersionOk(nodeVersion, minMajor = MIN_NODE_MAJOR) {
+  const match = /^v?(\d+)/.exec(nodeVersion);
+  if (!match) return false;
+  const major = Number(match[1]);
+  return Number.isFinite(major) && major >= minMajor;
+}
+function detectShellName(env, platform) {
+  if (platform === "win32") {
+    if (env.PSModulePath) return "powershell";
+    if (env.ComSpec) return "cmd";
+    return null;
+  }
+  const shellPath = env.SHELL;
+  if (!shellPath) return null;
+  const base = path.basename(shellPath).trim();
+  return base || null;
+}
+function detectShellProfile(env, platform, homeDir) {
+  const shellName = detectShellName(env, platform);
+  if (shellName === "zsh") return path.join(homeDir, ".zshrc");
+  if (shellName === "bash") return path.join(homeDir, ".bashrc");
+  return null;
+}
+function parseNpmrcPrefix(content, homeDir) {
+  const match = /^\s*prefix\s*=\s*(.+?)\s*$/m.exec(content);
+  const captured = match?.[1];
+  if (!captured) return null;
+  let value = captured.trim().replace(/^["']|["']$/g, "");
+  if (value.startsWith("~")) {
+    value = path.join(homeDir, value.slice(1));
+  }
+  return value || null;
+}
+function heuristicPrefixFromExecPath(execPath, platform) {
+  const p = platform === "win32" ? path.win32 : path.posix;
+  return platform === "win32" ? p.dirname(execPath) : p.dirname(p.dirname(execPath));
+}
+async function detectNpmPrefix(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const homeDir = options.homeDir ?? homedir();
+  const execPath = options.execPath ?? process.execPath;
+  const readFileImpl = options.readFileImpl ?? ((filePath) => readFile(filePath, "utf8"));
+  const envPrefix = env.npm_config_prefix ?? env.NPM_CONFIG_PREFIX;
+  if (envPrefix?.trim()) {
+    return { prefix: envPrefix.trim(), source: "env" };
+  }
+  const userconfigPath = env.NPM_CONFIG_USERCONFIG ?? path.join(homeDir, ".npmrc");
+  try {
+    const content = await readFileImpl(userconfigPath);
+    const npmrcPrefix = parseNpmrcPrefix(content, homeDir);
+    if (npmrcPrefix) {
+      return { prefix: npmrcPrefix, source: "npmrc" };
+    }
+  } catch {
+  }
+  return { prefix: heuristicPrefixFromExecPath(execPath, platform), source: "heuristic" };
+}
+async function describeUnwritablePrefix(prefix) {
+  try {
+    const info = await stat(prefix);
+    const currentUid = typeof process.getuid === "function" ? process.getuid() : void 0;
+    if (process.platform !== "win32" && currentUid !== void 0 && info.uid === 0 && currentUid !== 0) {
+      return `root-owned prefix (${prefix}); the classic fresh-install PATH/EACCES blocker`;
+    }
+  } catch {
+  }
+  return `npm prefix is not writable: ${prefix}`;
+}
+async function checkNpmPrefixWritable(options = {}) {
+  let detected;
+  try {
+    detected = await detectNpmPrefix(options);
+  } catch {
+    return { prefix: null, writable: false, reason: "npm prefix could not be determined" };
+  }
+  try {
+    await access(detected.prefix, constants.W_OK);
+    return { prefix: detected.prefix, writable: true, source: detected.source };
+  } catch {
+    return {
+      prefix: detected.prefix,
+      writable: false,
+      source: detected.source,
+      reason: await describeUnwritablePrefix(detected.prefix)
+    };
+  }
+}
+async function assessEnvironment(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const nodeVersion = options.nodeVersion ?? process.version;
+  const homeDir = options.homeDir ?? homedir();
+  const binName = options.binName ?? "agent-kit";
+  const [binPath, npmPrefix] = await Promise.all([
+    resolveBinOnPath(binName, env, platform).catch(() => null),
+    checkNpmPrefixWritable(options).catch(
+      () => ({
+        prefix: null,
+        writable: false,
+        reason: "npm prefix check failed unexpectedly"
+      })
+    )
+  ]);
+  const binVersion = binPath ? await readBinVersion(binPath, options).catch(() => null) : null;
+  return {
+    binOnPath: binPath != null,
+    binPath,
+    binVersion,
+    npmPrefixWritable: npmPrefix.writable,
+    npmPrefix,
+    nodeVersionOk: isNodeVersionOk(nodeVersion),
+    nodeVersion,
+    shell: detectShellName(env, platform),
+    shellProfile: detectShellProfile(env, platform, homeDir)
+  };
+}
+
+export {
+  assessEnvironment
+};

package/dist/chunk-5VCOWTTP.js

@@ -0,0 +1,6 @@
+// src/utils/kit-paths.ts
+var HANDOFF_REL = ".cursor/HANDOFF.md";
+
+export {
+  HANDOFF_REL
+};

package/dist/chunk-77V75A7O.js

@@ -0,0 +1,39 @@
+// src/utils/fs.ts
+import { randomUUID } from "crypto";
+import { constants } from "fs";
+import { access, mkdir, readFile, readdir, rename, writeFile } from "fs/promises";
+import path from "path";
+async function fileExists(target) {
+  try {
+    await access(target, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(target) {
+  if (!await fileExists(target)) return null;
+  const raw = await readFile(target, "utf8");
+  return JSON.parse(raw);
+}
+async function writeJson(target, data) {
+  await ensureDir(path.dirname(target));
+  const tmp = `${target}.${randomUUID()}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  await rename(tmp, target);
+}
+async function ensureDir(target) {
+  await mkdir(target, { recursive: true });
+}
+async function listDirectory(rootDir) {
+  return readdir(rootDir);
+}
+
+export {
+  fileExists,
+  readJson,
+  writeJson,
+  ensureDir,
+  listDirectory
+};

package/dist/chunk-7HDQEK6T.js

@@ -0,0 +1,26 @@
+// src/lifecycle/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function loadPackageVersion() {
+  for (const packagePath of ["../package.json", "../../package.json"]) {
+    try {
+      const metadata = require2(packagePath);
+      if (typeof metadata.version === "string" && metadata.version.length > 0) {
+        return metadata.version;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Unable to resolve the Agent Kit CLI package version");
+}
+var KIT_VERSION = loadPackageVersion();
+var KIT_PACKAGE_SPEC = "@dadado/agent-kit-cli";
+function pinnedCliSpec(version = KIT_VERSION) {
+  return `${KIT_PACKAGE_SPEC}@${version}`;
+}
+
+export {
+  KIT_VERSION,
+  KIT_PACKAGE_SPEC,
+  pinnedCliSpec
+};