agemon 0.1.0 → 6.0.0

package/dist/fake-subprocess-2BETWZVZ.js

@@ -0,0 +1,666 @@
+import {
+  AGNIX_VERSION,
+  CANONICAL_SKILLS_DIRECTORY,
+  CLAUDE_SKILLS_DIRECTORY,
+  CODE_REVIEW_GRAPH_PACKAGE_SPEC,
+  CODE_REVIEW_GRAPH_VERSION,
+  ESSENTIALS_SKILLS_COMMIT,
+  FAKE_PINNED_SKILL_MANIFEST_FILE,
+  SKILLS_CLI_PATH_IN_TOOLS_DIR,
+  SKILLS_LOCK_FILE,
+  SKILL_GROUPS,
+  fakePinnedSkillManifest,
+  isLeftOutBySkillsCli,
+  isPlainSkillName,
+  resolveHomeDirectory,
+  resolveStateRoot,
+  sha256Hex,
+  skillPathInRepository
+} from "./chunk-5LATHJYU.js";
+
+// src/core/fake-subprocess.ts
+import {
+  closeSync,
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, isAbsolute, join, relative } from "path";
+var FAKE_CRG_ON_PATH = "/fake/bin/code-review-graph";
+var PINNED_SKILLS_CLI_SUFFIX = `/${SKILLS_CLI_PATH_IN_TOOLS_DIR}`;
+var FAKE_LOCK_VERSION = 1;
+function formatCommand(command, args) {
+  return [command, ...args].join(" ");
+}
+var fakeCrgInstalledState = null;
+var fakeInstalledGlobalNpmPackageNames = null;
+var fakeVersionedAgentBinaryNames = null;
+var fakeUsableAgentBinaryNames = null;
+var fakeStateSignature = null;
+var fakeVerifiedBinaryInstallRequests = [];
+function buildFakeStateSignature() {
+  return [
+    process.env.AGEMON_FAKE_PREINSTALLED_CRG ?? "",
+    process.env.AGEMON_FAKE_PREINSTALLED_NPM_PACKAGES ?? "",
+    process.env.AGEMON_FAKE_INSTALLED_AGENTS ?? "",
+    process.env.AGEMON_FAKE_USABLE_AGENTS ?? ""
+  ].join("||");
+}
+function fakeGlobalNpmStatePath() {
+  return join(resolveStateRoot(), "agemon-fake", "npm-global.json");
+}
+function saveFakeGlobalNpmPackages() {
+  if (fakeInstalledGlobalNpmPackageNames?.size === 0) {
+    rmSync(fakeGlobalNpmStatePath(), { force: true });
+    return;
+  }
+  mkdirSync(dirname(fakeGlobalNpmStatePath()), { recursive: true });
+  writeFileSync(
+    fakeGlobalNpmStatePath(),
+    JSON.stringify([...fakeInstalledGlobalNpmPackageNames ?? []])
+  );
+}
+function loadSavedFakeGlobalNpmPackages() {
+  if (!existsSync(fakeGlobalNpmStatePath())) {
+    return null;
+  }
+  return JSON.parse(readFileSync(fakeGlobalNpmStatePath(), "utf8"));
+}
+function resetFakeSubprocessState() {
+  rmSync(fakeGlobalNpmStatePath(), { force: true });
+  fakeCrgInstalledState = null;
+  fakeInstalledGlobalNpmPackageNames = null;
+  fakeVersionedAgentBinaryNames = null;
+  fakeUsableAgentBinaryNames = null;
+  fakeStateSignature = null;
+  fakeVerifiedBinaryInstallRequests = [];
+}
+function createFakeVerifiedBinaryInstaller() {
+  return {
+    async install(request) {
+      initializeFakeStateIfNeeded();
+      fakeVerifiedBinaryInstallRequests.push(request);
+      fakeInstalledGlobalNpmPackageNames?.add(request.packageName);
+      saveFakeGlobalNpmPackages();
+    },
+    async inspect(request) {
+      initializeFakeStateIfNeeded();
+      return fakeInstalledGlobalNpmPackageNames?.has(request.packageName) ? { kind: "installed", version: AGNIX_VERSION, differences: [] } : { kind: "absent" };
+    }
+  };
+}
+function takeFakeVerifiedBinaryInstallRequests() {
+  return fakeVerifiedBinaryInstallRequests.splice(0);
+}
+function initializeFakeStateIfNeeded() {
+  const currentStateSignature = buildFakeStateSignature();
+  if (fakeCrgInstalledState !== null && fakeStateSignature === currentStateSignature) {
+    return;
+  }
+  fakeStateSignature = currentStateSignature;
+  fakeCrgInstalledState = process.env.AGEMON_FAKE_PREINSTALLED_CRG === "1";
+  const preinstalledGlobalNpmPackages = process.env.AGEMON_FAKE_PREINSTALLED_NPM_PACKAGES?.split(",").map((packageName) => packageName.trim()).filter((packageName) => packageName.length > 0);
+  fakeInstalledGlobalNpmPackageNames = new Set(
+    loadSavedFakeGlobalNpmPackages() ?? preinstalledGlobalNpmPackages ?? []
+  );
+  const versionedAgentBinaryNames = process.env.AGEMON_FAKE_INSTALLED_AGENTS?.split(",").map((binaryName) => binaryName.trim()).filter((binaryName) => binaryName.length > 0);
+  fakeVersionedAgentBinaryNames = new Set(versionedAgentBinaryNames ?? []);
+  const usableAgentBinaryNames = process.env.AGEMON_FAKE_USABLE_AGENTS?.split(
+    ","
+  ).map((binaryName) => binaryName.trim()).filter((binaryName) => binaryName.length > 0);
+  fakeUsableAgentBinaryNames = new Set(usableAgentBinaryNames ?? []);
+}
+function readOptionValue(args, optionName) {
+  const optionIndex = args.indexOf(optionName);
+  if (optionIndex < 0) {
+    return void 0;
+  }
+  return args[optionIndex + 1];
+}
+function declaredSkillName(manifestPath, directoryName) {
+  const nameLine = readFileSync(manifestPath, "utf8").split("\n").find((line) => line.startsWith("name:"));
+  return nameLine?.slice("name:".length).trim() || directoryName;
+}
+function installedSkillNamesIn(skillsDirectory) {
+  if (!existsSync(skillsDirectory)) {
+    return [];
+  }
+  return readdirSync(skillsDirectory).flatMap((directoryName) => {
+    const manifestPath = join(skillsDirectory, directoryName, "SKILL.md");
+    return existsSync(manifestPath) ? [declaredSkillName(manifestPath, directoryName)] : [];
+  });
+}
+function buildFakeSkillsList(cwd) {
+  const names = /* @__PURE__ */ new Set([
+    ...installedSkillNamesIn(join(cwd, CANONICAL_SKILLS_DIRECTORY)),
+    ...installedSkillNamesIn(join(cwd, CLAUDE_SKILLS_DIRECTORY))
+  ]);
+  const skills = [...names].sort().map((name) => ({
+    name,
+    path: join(cwd, CLAUDE_SKILLS_DIRECTORY, name),
+    scope: "project",
+    agents: ["Claude Code"]
+  }));
+  return {
+    code: 0,
+    stdout: `${JSON.stringify(skills, null, 2)}
+`,
+    stderr: ""
+  };
+}
+function removeInstalledCopy(copyPath) {
+  const stats = lstatSync(copyPath, { throwIfNoEntry: false });
+  if (stats?.isSymbolicLink()) {
+    unlinkSync(copyPath);
+  } else if (stats !== void 0) {
+    rmSync(copyPath, { recursive: true, force: true });
+  }
+}
+function copyLikeSkillsCli(source, destination) {
+  cpSync(source, destination, {
+    recursive: true,
+    dereference: true,
+    filter: (path) => path === source || !isLeftOutBySkillsCli(basename(path), statSync(path))
+  });
+}
+function readFakeLockSkills(cwd) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync(join(cwd, SKILLS_LOCK_FILE), "utf8")
+    );
+    return parsed.version === FAKE_LOCK_VERSION && parsed.skills ? parsed.skills : {};
+  } catch {
+    return {};
+  }
+}
+function writeFakeLockLikeSkillsCli(cwd, skills) {
+  const sortedSkills = Object.fromEntries(
+    Object.keys(skills).sort().map((name) => [name, skills[name]])
+  );
+  writeFileSync(
+    join(cwd, SKILLS_LOCK_FILE),
+    `${JSON.stringify({ version: FAKE_LOCK_VERSION, skills: sortedSkills }, null, 2)}
+`
+  );
+}
+function fakeLockEntry(packageSource, cwd) {
+  const isLocal = existsSync(packageSource);
+  const source = isLocal ? relative(cwd, packageSource) : packageSource;
+  return {
+    source,
+    sourceType: isLocal ? "local" : "github",
+    computedHash: sha256Hex(source)
+  };
+}
+function refusedSkillName(skillName) {
+  return {
+    code: 1,
+    stdout: "",
+    stderr: `the fake skills CLI refuses the skill name ${JSON.stringify(skillName)}`
+  };
+}
+function buildFakeSkillsAdd(args, cwd) {
+  const packageSource = args[1];
+  if (!packageSource) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: "skills add requires a package source"
+    };
+  }
+  const skillName = readOptionValue(args, "--skill") ?? packageSource;
+  if (!isPlainSkillName(skillName)) {
+    return refusedSkillName(skillName);
+  }
+  const copyPath = join(cwd, CLAUDE_SKILLS_DIRECTORY, skillName);
+  removeInstalledCopy(copyPath);
+  mkdirSync(dirname(copyPath), { recursive: true });
+  if (existsSync(packageSource)) {
+    copyLikeSkillsCli(packageSource, copyPath);
+  } else {
+    mkdirSync(copyPath);
+    writeFileSync(
+      join(copyPath, "SKILL.md"),
+      `---
+name: ${skillName}
+---
+`,
+      "utf8"
+    );
+  }
+  writeFakeLockLikeSkillsCli(cwd, {
+    ...readFakeLockSkills(cwd),
+    [skillName]: fakeLockEntry(packageSource, cwd)
+  });
+  return {
+    code: 0,
+    stdout: `installed skill ${skillName} from ${packageSource}
+`,
+    stderr: ""
+  };
+}
+function buildFakeSkillsRemove(args, cwd) {
+  const agentName = readOptionValue(args, "--agent");
+  const skillNames = args.slice(1).filter(
+    (arg) => arg.length > 0 && !arg.startsWith("-") && arg !== agentName
+  );
+  const unsafeName = skillNames.find(
+    (skillName) => !isPlainSkillName(skillName)
+  );
+  if (unsafeName !== void 0) {
+    return refusedSkillName(unsafeName);
+  }
+  for (const skillName of skillNames) {
+    removeInstalledCopy(join(cwd, CLAUDE_SKILLS_DIRECTORY, skillName));
+    rmSync(join(cwd, CANONICAL_SKILLS_DIRECTORY, skillName), {
+      recursive: true,
+      force: true
+    });
+    const lockSkills = readFakeLockSkills(cwd);
+    if (Object.hasOwn(lockSkills, skillName)) {
+      delete lockSkills[skillName];
+      writeFakeLockLikeSkillsCli(cwd, lockSkills);
+    }
+  }
+  return {
+    code: 0,
+    stdout: `removed ${skillNames.length} skill(s)
+`,
+    stderr: ""
+  };
+}
+function buildFakeSkillsCliResponse(args, cwd) {
+  const subcommand = args[0];
+  const needsRepository = ["list", "ls", "add", "remove", "rm"].includes(
+    subcommand ?? ""
+  );
+  if (needsRepository && cwd === void 0) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: "the fake skills CLI needs the repository as its cwd"
+    };
+  }
+  if (cwd !== void 0 && (subcommand === "list" || subcommand === "ls")) {
+    return buildFakeSkillsList(cwd);
+  }
+  if (cwd !== void 0 && subcommand === "add") {
+    return buildFakeSkillsAdd(args, cwd);
+  }
+  if (cwd !== void 0 && (subcommand === "remove" || subcommand === "rm")) {
+    return buildFakeSkillsRemove(args, cwd);
+  }
+  return {
+    code: 0,
+    stdout: `[fake subprocess] skills ${args.join(" ")}
+`,
+    stderr: ""
+  };
+}
+function writeFakePinnedSkills(sourceDirectory) {
+  const commit = basename(sourceDirectory);
+  for (const entry of SKILL_GROUPS.flatMap((group) => group.skills)) {
+    if (entry.pinnedRepository?.commit !== commit) {
+      continue;
+    }
+    const skillDirectory = join(
+      sourceDirectory,
+      skillPathInRepository(entry.skillName)
+    );
+    mkdirSync(skillDirectory, { recursive: true });
+    writeFileSync(
+      join(skillDirectory, FAKE_PINNED_SKILL_MANIFEST_FILE),
+      fakePinnedSkillManifest(entry.skillName),
+      "utf8"
+    );
+  }
+}
+function fakePipxHome() {
+  return join(resolveHomeDirectory(), ".agemon", "fake-pipx");
+}
+function fakeCrgVenvPath() {
+  return join(fakePipxHome(), "venvs", "code-review-graph");
+}
+function fakeCrgStubPath() {
+  return join(fakeCrgVenvPath(), "bin", "code-review-graph");
+}
+function fakeCodeReviewGraphOnPath() {
+  initializeFakeStateIfNeeded();
+  if (existsSync(fakeCrgStubPath())) {
+    return fakeCrgStubPath();
+  }
+  return fakeCrgInstalledState ? FAKE_CRG_ON_PATH : void 0;
+}
+function splitPipArgs(args) {
+  const pipArgsFlag = args.find((arg) => arg.startsWith("--pip-args="));
+  if (pipArgsFlag === void 0) {
+    return [];
+  }
+  return [
+    ...pipArgsFlag.slice("--pip-args=".length).matchAll(/'([^']*)'|(\S+)/g)
+  ].map((match) => match[1] ?? match[2]);
+}
+function writeFakeCrgVenv(pipArgs) {
+  const metadataPath = join(fakeCrgVenvPath(), "pipx_metadata.json");
+  if (existsSync(metadataPath)) {
+    return;
+  }
+  mkdirSync(dirname(fakeCrgStubPath()), { recursive: true });
+  writeFileSync(fakeCrgStubPath(), "#!/bin/sh\n", { flag: "wx", mode: 493 });
+  writeFileSync(join(fakeCrgVenvPath(), "bin", "python"), "#!/bin/sh\n", {
+    flag: "wx",
+    mode: 493
+  });
+  const metadata = {
+    main_package: {
+      package: "code-review-graph",
+      package_version: CODE_REVIEW_GRAPH_VERSION,
+      app_paths: [{ __Path__: fakeCrgStubPath(), __type__: "Path" }],
+      pip_args: pipArgs
+    },
+    pipx_metadata_version: "0.3"
+  };
+  writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}
+`, {
+    flag: "wx"
+  });
+}
+function findProjectRootLikeCrg(cwd, repoRootOverride) {
+  if (repoRootOverride && existsSync(repoRootOverride)) {
+    return repoRootOverride;
+  }
+  for (let directory = cwd; ; directory = dirname(directory)) {
+    if (existsSync(join(directory, ".git"))) {
+      return directory;
+    }
+    if (directory === dirname(directory)) {
+      return cwd;
+    }
+  }
+}
+function fakeGraphDatabasePath(projectRoot) {
+  const graphDirectory = join(projectRoot, ".code-review-graph");
+  mkdirSync(graphDirectory, { recursive: true });
+  return join(graphDirectory, "graph.db");
+}
+function buildFakeGraph(projectRoot) {
+  if (projectRoot !== void 0) {
+    writeFileSync(fakeGraphDatabasePath(projectRoot), "fake graph\n", "utf8");
+  }
+}
+function openFakeGraph(projectRoot) {
+  if (projectRoot !== void 0) {
+    closeSync(openSync(fakeGraphDatabasePath(projectRoot), "a"));
+  }
+}
+function buildFakeCrgResponse(command, args, projectRoot) {
+  const installed = fakeCrgInstalledState || isAbsolute(command) && existsSync(command);
+  if (!installed) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: "code-review-graph: command not found"
+    };
+  }
+  if (args[0] === "status") {
+    openFakeGraph(projectRoot);
+    return {
+      code: 0,
+      stdout: "Files: 1\nNodes: 1\nEdges: 1\n",
+      stderr: ""
+    };
+  }
+  if (args[0] === "build") {
+    buildFakeGraph(projectRoot);
+    return {
+      code: 0,
+      stdout: "Graph build complete\n",
+      stderr: ""
+    };
+  }
+  return {
+    code: 0,
+    stdout: "code-review-graph 0.0.0-fake\n",
+    stderr: ""
+  };
+}
+function buildFakePipxResponse(args) {
+  const [operation, packageName] = args;
+  if (operation === "install" && packageName === CODE_REVIEW_GRAPH_PACKAGE_SPEC) {
+    writeFakeCrgVenv(splitPipArgs(args));
+    fakeCrgInstalledState = true;
+    return {
+      code: 0,
+      stdout: "installed package code-review-graph\n",
+      stderr: ""
+    };
+  }
+  if (operation === "uninstall" && packageName === "code-review-graph") {
+    rmSync(fakeCrgVenvPath(), { recursive: true, force: true });
+    fakeCrgInstalledState = false;
+    return {
+      code: 0,
+      stdout: "uninstalled package code-review-graph\n",
+      stderr: ""
+    };
+  }
+  return void 0;
+}
+function parseGlobalNpmPackageNames(args) {
+  const packageNames = [];
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg || arg.startsWith("-")) {
+      continue;
+    }
+    packageNames.push(arg);
+  }
+  return packageNames;
+}
+function buildFakeNpmCi(args) {
+  const prefix = readOptionValue(args, "--prefix");
+  if (prefix) {
+    const cliPath = join(prefix, SKILLS_CLI_PATH_IN_TOOLS_DIR);
+    mkdirSync(dirname(cliPath), { recursive: true });
+    writeFileSync(cliPath, "", "utf8");
+  }
+  return {
+    code: 0,
+    stdout: `[fake subprocess] npm ${args.join(" ")}
+`,
+    stderr: ""
+  };
+}
+function assertNpmIgnoresProjectConfig(args) {
+  const ignoresProjectConfig = args.some(
+    (arg) => arg === "--global" || arg === "--prefix" || arg.startsWith("--prefix=")
+  );
+  if (!ignoresProjectConfig) {
+    throw new Error(
+      `npm ${args.join(" ")} must pass --global or --prefix, so npm never reads a .npmrc from the repository it runs in.`
+    );
+  }
+}
+function buildFakeNpmResponse(args) {
+  const operation = args[0];
+  if (!operation) {
+    return void 0;
+  }
+  if (operation === "ci") {
+    return buildFakeNpmCi(args);
+  }
+  const hasGlobalFlag = args.includes("-g") || args.includes("--global");
+  if (operation === "root" && hasGlobalFlag) {
+    const fakeNpmRoot = join(resolveStateRoot(), "agemon-fake", "npm-root");
+    mkdirSync(fakeNpmRoot, { recursive: true });
+    return { code: 0, stdout: `${fakeNpmRoot}
+`, stderr: "" };
+  }
+  if (!hasGlobalFlag) {
+    return {
+      code: 0,
+      stdout: `[fake subprocess] npm ${args.join(" ")}
+`,
+      stderr: ""
+    };
+  }
+  const packageNames = parseGlobalNpmPackageNames(args);
+  if (operation === "install") {
+    throw new Error(
+      `npm install --global ${packageNames.join(" ")} installs by name; agemon installs global npm packages only from a verified tarball (ctx.verifiedBinaryInstaller).`
+    );
+  }
+  if (operation === "uninstall") {
+    for (const packageName of packageNames) {
+      fakeInstalledGlobalNpmPackageNames?.delete(packageName);
+    }
+    saveFakeGlobalNpmPackages();
+    return {
+      code: 0,
+      stdout: `removed ${packageNames.length} package(s) globally
+`,
+      stderr: ""
+    };
+  }
+  return {
+    code: 0,
+    stdout: `[fake subprocess] npm ${args.join(" ")}
+`,
+    stderr: ""
+  };
+}
+function buildFakeAgnixResponse(args) {
+  if (!fakeInstalledGlobalNpmPackageNames?.has("agnix")) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: "agnix: command not found"
+    };
+  }
+  if (args[0] === "--version") {
+    return {
+      code: 0,
+      stdout: "agnix 0.0.0-fake\n",
+      stderr: ""
+    };
+  }
+  if (args[0] === "lint") {
+    return {
+      code: 0,
+      stdout: "agnix lint passed\n",
+      stderr: ""
+    };
+  }
+  return {
+    code: 0,
+    stdout: `[fake subprocess] agnix ${args.join(" ")}
+`,
+    stderr: ""
+  };
+}
+var FAKE_AGENT_BINARY_NAMES = /* @__PURE__ */ new Set([
+  "claude",
+  "gemini"
+]);
+function buildFakeAgentVersionResponse(binaryName) {
+  if (fakeVersionedAgentBinaryNames?.has(binaryName)) {
+    return {
+      code: 0,
+      stdout: `${binaryName} 1.0.0-fake
+`,
+      stderr: ""
+    };
+  }
+  return {
+    code: 0,
+    stdout: "unrecognized output\n",
+    stderr: ""
+  };
+}
+function buildFakeAgentUsabilityResponse(binaryName, args) {
+  if (fakeUsableAgentBinaryNames?.has(binaryName)) {
+    return {
+      code: 0,
+      stdout: `[fake subprocess] ${binaryName} ${args.join(" ")} ok
+`,
+      stderr: ""
+    };
+  }
+  return {
+    code: 1,
+    stdout: "",
+    stderr: `${binaryName} ${args.join(" ")}: command failed
+`
+  };
+}
+function buildFakeAgentResponse(binaryName, args) {
+  if (args[0] === "--version") {
+    return buildFakeAgentVersionResponse(binaryName);
+  }
+  return buildFakeAgentUsabilityResponse(binaryName, args);
+}
+function runFakeSubprocess(command, args, options = {}) {
+  initializeFakeStateIfNeeded();
+  if (command === "pipx") {
+    const pipxResponse = buildFakePipxResponse(args);
+    if (pipxResponse) {
+      return pipxResponse;
+    }
+  }
+  if (args[0]?.endsWith(PINNED_SKILLS_CLI_SUFFIX)) {
+    return buildFakeSkillsCliResponse(args.slice(1), options.cwd);
+  }
+  if (command === "git" && args.at(-2) === "rev-parse" && args.at(-1) === "HEAD") {
+    return { code: 0, stdout: `${ESSENTIALS_SKILLS_COMMIT}
+`, stderr: "" };
+  }
+  if (command === "git" && args.slice(-3).join(" ") === "checkout -q FETCH_HEAD" && options.cwd !== void 0) {
+    writeFakePinnedSkills(options.cwd);
+  }
+  if (basename(command) === "npm") {
+    assertNpmIgnoresProjectConfig(args);
+  }
+  if (command === "npm") {
+    const npmResponse = buildFakeNpmResponse(args);
+    if (npmResponse) {
+      return npmResponse;
+    }
+  }
+  if (command === "agnix") {
+    return buildFakeAgnixResponse(args);
+  }
+  const commandBinaryName = basename(command);
+  if (commandBinaryName === "code-review-graph") {
+    return buildFakeCrgResponse(
+      command,
+      args,
+      options.cwd && findProjectRootLikeCrg(options.cwd, options.env?.CRG_REPO_ROOT)
+    );
+  }
+  if (FAKE_AGENT_BINARY_NAMES.has(commandBinaryName)) {
+    return buildFakeAgentResponse(commandBinaryName, args);
+  }
+  return {
+    code: 0,
+    stdout: `[fake subprocess] ${formatCommand(command, args)}
+`,
+    stderr: ""
+  };
+}
+export {
+  createFakeVerifiedBinaryInstaller,
+  fakeCodeReviewGraphOnPath,
+  fakePipxHome,
+  resetFakeSubprocessState,
+  runFakeSubprocess,
+  takeFakeVerifiedBinaryInstallRequests
+};
+//# sourceMappingURL=fake-subprocess-2BETWZVZ.js.map