@clearlydev/nx-archweave 0.3.1 → 0.3.3

package/dist/generators/record-integration/generator.js

@@ -1,3 +1,15 @@
+import {
+  runRecordPipeline
+} from "../_chunks/chunk-URV6FLUH.js";
+import "../_chunks/chunk-U6LAFHSF.js";
+import {
+  PLUGIN_IDS,
+  createIntegrationsCompositionRoot,
+  getCatalogEntry,
+  recordMetadataFor
+} from "../_chunks/chunk-AQHV7DJS.js";
+import "../_chunks/chunk-34V6HAJT.js";
+
 // src/generators/record-integration/render.ts
 function renderRecordIntegrationView(view) {
   const lines = [
@@ -35,784 +47,6 @@ function renderRecordIntegrationView(view) {
   return lines.join("\n");
 }
 
-// ../integrations/dist/registry/integration-registry.js
-function createIntegrationRegistry(integrations) {
-  const seenIds = /* @__PURE__ */ new Set();
-  for (const integration of integrations) {
-    if (seenIds.has(integration.id)) {
-      throw new Error(`Duplicate integration id: "${integration.id}"`);
-    }
-    seenIds.add(integration.id);
-  }
-  return integrations;
-}
-function listIntegrations(registry) {
-  return registry;
-}
-function getIntegration(registry, id) {
-  return registry.find((integration) => integration.id === id);
-}
-
-// ../integrations/dist/manifest/manifest.js
-import { existsSync, lstatSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { randomBytes } from "node:crypto";
-var MANIFEST_FILENAME = "archweave-integrations.json";
-function createEmptyManifest() {
-  return { integrations: {} };
-}
-function loadManifest(root) {
-  const manifestPath = join(root, MANIFEST_FILENAME);
-  if (!existsSync(manifestPath)) {
-    return createEmptyManifest();
-  }
-  try {
-    const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
-    if (parsed && typeof parsed === "object" && typeof parsed.integrations === "object") {
-      return { integrations: parsed.integrations ?? {} };
-    }
-    return createEmptyManifest();
-  } catch {
-    return createEmptyManifest();
-  }
-}
-function serializeManifest(manifest) {
-  return `${JSON.stringify(manifest, null, 2)}
-`;
-}
-function writeManifestAtomic(root, manifest) {
-  const finalPath = join(root, MANIFEST_FILENAME);
-  if (existsSync(finalPath) && lstatSync(finalPath).isSymbolicLink()) {
-    throw new Error(`Refusing to write ${MANIFEST_FILENAME}: the path is a symlink. Remove or replace it with a regular file first.`);
-  }
-  const suffix = randomBytes(6).toString("hex");
-  const tempPath = join(root, `.${MANIFEST_FILENAME}.tmp-${suffix}`);
-  try {
-    writeFileSync(tempPath, serializeManifest(manifest));
-    renameSync(tempPath, finalPath);
-  } catch (error) {
-    if (existsSync(tempPath)) {
-      unlinkSync(tempPath);
-    }
-    throw error;
-  }
-}
-
-// ../integrations/dist/manifest/record-plan.js
-function entriesEqual(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-function buildRecordPlan(input) {
-  const isRecordable = input.verification.verified && input.verificationSource === "claude-cli";
-  const proposedEntry = isRecordable ? {
-    source: input.metadata.source,
-    repository: input.metadata.repository,
-    version: input.verification.resolvedVersion,
-    method: input.metadata.method,
-    managedBy: "nx-archweave",
-    verification: "passed",
-    target: input.target,
-    evidenceKind: "claude-cli"
-  } : void 0;
-  const hasConflict = input.existingEntry !== void 0 && proposedEntry !== void 0 && !entriesEqual(input.existingEntry, proposedEntry);
-  return {
-    id: input.id,
-    target: input.target,
-    verificationSource: input.verificationSource,
-    currentVerification: input.verification,
-    existingEntry: input.existingEntry,
-    proposedEntry,
-    hasConflict
-  };
-}
-
-// ../shared/dist/lib/spawnable-command.js
-import { statSync } from "node:fs";
-import { win32 } from "node:path";
-function isFile(path) {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
-}
-var DEFAULT_ENV = { platform: process.platform, env: process.env, isFile };
-function envValue(env, name) {
-  const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
-  return key === void 0 ? void 0 : env[key];
-}
-function resolveWindowsCommand(command, environment) {
-  const exts = (envValue(environment.env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
-  const candidates = (base) => win32.extname(base) !== "" ? [base] : exts.map((ext) => base + ext);
-  if (win32.isAbsolute(command) || /[\\/]/.test(command)) {
-    return candidates(command).find(environment.isFile);
-  }
-  const dirs = (envValue(environment.env, "PATH") ?? "").split(";").filter(Boolean);
-  for (const dir of dirs) {
-    const found = candidates(win32.join(dir, command)).find(environment.isFile);
-    if (found !== void 0)
-      return found;
-  }
-  return void 0;
-}
-var META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
-var BIN_SHIM = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
-function escapeCmdArgument(arg, doubleEscape = false) {
-  let quoted = arg.replace(/(\\*)"/g, '$1$1\\"');
-  quoted = quoted.replace(/(\\*)$/, "$1$1");
-  const escaped = `"${quoted}"`.replace(META_CHARS, "^$1");
-  return doubleEscape ? escaped.replace(META_CHARS, "^$1") : escaped;
-}
-function spawnableCommand(command, args, environment = DEFAULT_ENV) {
-  if (environment.platform !== "win32")
-    return { command, args: [...args] };
-  const resolved = resolveWindowsCommand(command, environment);
-  if (resolved === void 0 || !/\.(cmd|bat)$/i.test(resolved))
-    return { command, args: [...args] };
-  const doubleEscape = BIN_SHIM.test(resolved);
-  const line = [resolved.replace(META_CHARS, "^$1"), ...args.map((arg) => escapeCmdArgument(arg, doubleEscape))].join(" ");
-  return {
-    command: envValue(environment.env, "COMSPEC") ?? "cmd.exe",
-    args: ["/d", "/s", "/c", `"${line}"`],
-    windowsVerbatimArguments: true
-  };
-}
-
-// ../integrations/dist/process/read-only-command-runner.js
-var CLAUDE_CLI_TIMEOUT_MS = 5e3;
-var CLAUDE_CLI_STDOUT_LIMIT_BYTES = 1048576;
-var CLAUDE_CLI_STDERR_LIMIT_BYTES = 65536;
-
-// ../integrations/dist/catalog/plugin-catalog.js
-var PLUGIN_HOSTS = ["claude-code"];
-var PLUGIN_CATALOG = [
-  {
-    // Researched 2026-07-15. The claude-code values are the ones the manifest and verifier
-    // were measured with. ponytail documents official installs for ~20 hosts; only claude-code
-    // has an adapter.
-    id: "ponytail",
-    displayName: "ponytail",
-    // The project's own tagline.
-    description: 'over-engineering review rules and skills \u2014 "makes your AI agent think like the laziest senior dev in the room"',
-    homepage: "https://ponytail.dev",
-    repository: "https://github.com/DietrichGebert/ponytail",
-    license: "MIT",
-    npmPackage: "@dietrichgebert/ponytail",
-    installDocs: "https://github.com/DietrichGebert/ponytail#install",
-    uninstallSteps: [
-      "Run this from a clone of https://github.com/DietrichGebert/ponytail (or before removing the plugin below \u2014 the script is itself a plugin file, so removing the plugin first deletes it): node scripts/uninstall.js",
-      "Then remove the plugin via your host's own command, e.g. in Claude Code: /plugin uninstall ponytail@ponytail (or use the Claude Code Desktop app: Customize > manage marketplaces > remove plugin).",
-      "See https://github.com/DietrichGebert/ponytail#uninstall for the full, current official instructions."
-    ],
-    hosts: {
-      "claude-code": { name: "ponytail", marketplace: "DietrichGebert/ponytail", pluginId: "ponytail@ponytail" }
-    }
-  }
-];
-var PLUGIN_IDS = PLUGIN_CATALOG.map((entry) => entry.id);
-function getCatalogEntry(id) {
-  return PLUGIN_CATALOG.find((entry) => entry.id === id);
-}
-var CLAUDE_MARKETPLACE_METHOD = "claude-code-plugin-marketplace";
-function recordMetadataFor(entry) {
-  const claude = entry.hosts["claude-code"];
-  if (!claude)
-    return void 0;
-  return { source: claude.marketplace, repository: entry.repository, method: CLAUDE_MARKETPLACE_METHOD };
-}
-
-// ../integrations/dist/hosts/claude-code/detect.js
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
-async function detectWorkspacePackage(entry, context) {
-  const npmPackage = entry.npmPackage;
-  if (npmPackage === void 0) {
-    return { installed: false, managedBy: "unknown", evidence: [] };
-  }
-  const packageJsonPath = join2(context.workspaceRoot, "package.json");
-  if (!existsSync2(packageJsonPath)) {
-    return { installed: false, managedBy: "unknown", evidence: [] };
-  }
-  let pkg;
-  try {
-    pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-  } catch {
-    return { installed: false, managedBy: "unknown", evidence: [] };
-  }
-  const deps = pkg["dependencies"] ?? {};
-  const devDeps = pkg["devDependencies"] ?? {};
-  const version = deps[npmPackage] ?? devDeps[npmPackage];
-  if (!version) {
-    return { installed: false, managedBy: "unknown", evidence: [] };
-  }
-  return {
-    installed: true,
-    installedVersion: version,
-    managedBy: "external-tool",
-    evidence: [`package.json: ${npmPackage}@${version}`]
-  };
-}
-
-// ../integrations/dist/hosts/claude-code/plan.js
-var VERSION_DECIDED_BY_MARKETPLACE = "latest (decided by the marketplace)";
-var WORKSPACE_FILES_BY_SCOPE = {
-  user: [],
-  project: [".claude/settings.json"],
-  local: [".claude/settings.local.json"]
-};
-var DEFAULT_PLUGIN_SCOPE = "project";
-function createClaudeMarketplacePlan(entry) {
-  return async (options) => {
-    const distribution = entry.hosts["claude-code"];
-    if (options.targetEnvironment !== "claude-code" || distribution === void 0) {
-      const supported = Object.entries(entry.hosts).filter(([, value]) => value !== void 0).map(([host]) => host).join(", ");
-      throw new Error(`Target environment "${options.targetEnvironment}" is not supported by this integration. Supported: ${supported}.`);
-    }
-    const resolvedVersion = options.versionRange ?? VERSION_DECIDED_BY_MARKETPLACE;
-    const scope = options.scope ?? DEFAULT_PLUGIN_SCOPE;
-    return {
-      officialCommand: {
-        executable: "claude",
-        args: [
-          "plugin",
-          "install",
-          distribution.name,
-          "--marketplace",
-          distribution.marketplace,
-          "--scope",
-          scope,
-          "--json"
-        ]
-      },
-      resolvedVersion,
-      filesCreated: [],
-      // project/local scope: Claude Code records the plugin in the workspace's own
-      // .claude settings — shown before approval as the files that will change.
-      filesModified: [...WORKSPACE_FILES_BY_SCOPE[scope]],
-      conflicts: [],
-      sourceRepository: entry.repository,
-      officialHomepage: entry.homepage,
-      license: entry.license,
-      requiresManualExecution: false
-    };
-  };
-}
-
-// ../integrations/dist/hosts/claude-code/install.js
-import { homedir } from "node:os";
-function manualInstallSteps(entry) {
-  const distribution = entry.hosts["claude-code"];
-  if (distribution === void 0)
-    return [`See ${entry.installDocs} for the official instructions.`];
-  return [
-    `In Claude Code, send this as its own prompt: /plugin marketplace add ${distribution.marketplace}`,
-    `Then, as a second separate prompt: /plugin install ${distribution.pluginId}`,
-    `See ${entry.installDocs} for the official instructions.`
-  ];
-}
-var CLAUDE_CLI_INSTALL_TIMEOUT_MS = 12e4;
-var CLAUDE_CLI_INSTALL_STDOUT_LIMIT_BYTES = 1048576;
-var CLAUDE_CLI_INSTALL_STDERR_LIMIT_BYTES = 262144;
-function defaultRerunCommand(entry, runNx = "pnpm nx") {
-  return `${runNx} g @clearlydev/nx-archweave:install-integration --tool=${entry.id} --apply`;
-}
-function chatAlternative(entry) {
-  return ["Alternatively, inside a Claude Code session (the chat path):", ...manualInstallSteps(entry)];
-}
-var MARKETPLACE_NOTE = "If the marketplace was registered before the failure, it stays in your user settings \u2014 see `claude plugin marketplace list`.";
-function claudeCliNotFoundSteps(entry, rerunCommand) {
-  return [
-    "The claude CLI was not found on PATH. Install the Claude Code CLI from your terminal: npm install -g @anthropic-ai/claude-code (setup guide: https://code.claude.com/docs/en/setup)",
-    `Then rerun: ${rerunCommand}`,
-    ...chatAlternative(entry)
-  ];
-}
-function claudeCliUnsupportedSteps(entry, rerunCommand, cliSaid) {
-  return [
-    `Your claude CLI does not know this command (it said: ${cliSaid}). Scriptable plugin install needs Claude Code 2.1.285 or newer: run \`claude update\`, or reinstall it with npm install -g @anthropic-ai/claude-code@latest`,
-    `Then rerun: ${rerunCommand}`,
-    ...chatAlternative(entry)
-  ];
-}
-var TAIL_CHARS = 500;
-var UNSUPPORTED_CLI_PATTERN = /error: unknown (command|option) '(plugin|install|marketplace|--json|--marketplace|--scope)'/;
-function tail(text) {
-  const trimmed = text.trim();
-  return trimmed.length > TAIL_CHARS ? trimmed.slice(-TAIL_CHARS) : trimmed;
-}
-var ESCAPED_HOME = homedir().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var HOME_PATTERN = new RegExp(`${ESCAPED_HOME}(?=[/\\\\\\s'"\`]|$)`, "g");
-function redactHomePaths(text) {
-  let out = ESCAPED_HOME.length > 1 ? text.replace(HOME_PATTERN, "~") : text;
-  out = out.replace(/\/(?:Users|home)\/[^/\s'"`]+/g, "~");
-  out = out.replace(/[A-Za-z]:\\Users\\[^\\\s'"`]+/g, "~");
-  out = out.replace(/\/root(?=[/\s'"`]|$)/g, "~");
-  return out;
-}
-function parseLastJsonObject(stdout) {
-  const lines = stdout.split("\n");
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i].trim();
-    if (!line.startsWith("{"))
-      continue;
-    try {
-      const parsed = JSON.parse(line);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed))
-        return parsed;
-    } catch {
-    }
-  }
-  return null;
-}
-function renderUserCommand(command) {
-  return [command.executable, ...command.args.filter((arg) => arg !== "--json")].join(" ");
-}
-async function classifyRun(runner, command, cwd) {
-  let raw;
-  try {
-    raw = await runner.run({
-      executable: command.executable,
-      argv: command.args,
-      ...cwd === void 0 ? {} : { cwd },
-      timeoutMs: CLAUDE_CLI_INSTALL_TIMEOUT_MS,
-      stdoutLimitBytes: CLAUDE_CLI_INSTALL_STDOUT_LIMIT_BYTES,
-      stderrLimitBytes: CLAUDE_CLI_INSTALL_STDERR_LIMIT_BYTES
-    });
-  } catch (error) {
-    const code = typeof error?.code === "string" ? error.code : "unknown";
-    return code === "ENOENT" ? { kind: "cli-not-found" } : { kind: "failed-to-start", code };
-  }
-  if (raw.timedOut)
-    return { kind: "timeout" };
-  if (raw.outputExceeded)
-    return { kind: "output-too-large" };
-  const json = parseLastJsonObject(raw.stdout);
-  const jsonSaysFailed = json !== null && json["outcome"] === "failed";
-  if (raw.exitCode === 0 && !jsonSaysFailed)
-    return { kind: "executed" };
-  if (json !== null) {
-    const message = redactHomePaths(typeof json["message"] === "string" ? json["message"] : `the claude CLI exited with code ${raw.exitCode}`);
-    const failureCode = typeof json["failureCode"] === "string" ? json["failureCode"] : void 0;
-    const shown = json["shownCommand"];
-    if (typeof shown === "object" && shown !== null)
-      return { kind: "confirmation-required", message };
-    return failureCode === void 0 ? { kind: "failed", message } : { kind: "failed", failureCode, message };
-  }
-  if (UNSUPPORTED_CLI_PATTERN.test(raw.stderr)) {
-    const line = raw.stderr.split("\n").find((l) => UNSUPPORTED_CLI_PATTERN.test(l)) ?? "";
-    return { kind: "cli-unsupported", stderrTail: redactHomePaths(line.trim()) };
-  }
-  const said = redactHomePaths(tail(raw.stderr.length > 0 ? raw.stderr : raw.stdout));
-  return { kind: "failed", message: said.length > 0 ? said : `the claude CLI exited with code ${raw.exitCode}` };
-}
-function manualStepsFor(entry, detail, command, rerunCommand) {
-  const chat = chatAlternative(entry);
-  const userCommand = command === null ? "" : renderUserCommand(command);
-  const rerun = `Once resolved, rerun to install, verify and record it: ${rerunCommand}`;
-  switch (detail.kind) {
-    case "executed":
-      return [];
-    case "manual-only":
-      return manualInstallSteps(entry);
-    case "cli-not-found":
-      return claudeCliNotFoundSteps(entry, rerunCommand);
-    case "failed-to-start":
-      return [
-        `The claude CLI was found but could not be started (${detail.code}) \u2014 check its permissions and your system limits.`,
-        rerun,
-        ...chat
-      ];
-    case "cli-unsupported":
-      return claudeCliUnsupportedSteps(entry, rerunCommand, detail.stderrTail);
-    case "confirmation-required":
-      return [
-        `The marketplace declares a command that must be confirmed by a person; nx-archweave never accepts it for you (${detail.message})`,
-        `Review it and run the install yourself: ${userCommand}`,
-        rerun,
-        ...chat
-      ];
-    case "failed":
-      return [`The install command did not succeed: ${detail.message}`, MARKETPLACE_NOTE, rerun, ...chat];
-    case "timeout":
-      return [
-        `The install command did not finish within ${CLAUDE_CLI_INSTALL_TIMEOUT_MS / 1e3} s and was stopped.`,
-        MARKETPLACE_NOTE,
-        rerun,
-        ...chat
-      ];
-    case "output-too-large":
-      return [
-        "The install command produced more output than nx-archweave is willing to buffer and was stopped.",
-        `Run it yourself to see the full output: ${userCommand}`,
-        rerun,
-        ...chat
-      ];
-  }
-}
-async function installClaudeMarketplacePlugin(entry, deps, plan, options = {}) {
-  const rerunCommand = options.rerunCommand ?? defaultRerunCommand(entry);
-  const detail = plan.officialCommand === null ? { kind: "manual-only" } : await classifyRun(deps.runner, plan.officialCommand, options.cwd);
-  const executed = detail.kind === "executed";
-  const result = {
-    executed,
-    // One command: it either reached exit 0 or it did not. What a failed run may
-    // have left behind is re-checked live by install-integration, not guessed here.
-    partialFailure: false,
-    filesCreated: [],
-    // The workspace files the plan said the host would change (project/local scope);
-    // Claude's own plugin store is outside the workspace and never listed.
-    filesModified: executed ? [...plan.filesModified] : [],
-    manualStepsRemaining: manualStepsFor(entry, detail, plan.officialCommand, rerunCommand)
-  };
-  return { result, detail };
-}
-function createClaudeMarketplaceInstall(entry, deps) {
-  return async (plan) => (await installClaudeMarketplacePlugin(entry, deps, plan)).result;
-}
-
-// ../integrations/dist/hosts/claude-code/verify-via-claude-cli.js
-import { realpathSync } from "node:fs";
-import { resolve } from "node:path";
-
-// ../integrations/dist/hosts/claude-code/parse-claude-plugin-list.js
-var KNOWN_SCOPES = /* @__PURE__ */ new Set(["user", "project", "local", "managed"]);
-function isKnownScope(scope) {
-  return KNOWN_SCOPES.has(scope);
-}
-function isValidEntry(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const record = value;
-  if (typeof record["id"] !== "string") {
-    return false;
-  }
-  if (typeof record["enabled"] !== "boolean") {
-    return false;
-  }
-  if (typeof record["scope"] !== "string" || record["scope"].length === 0) {
-    return false;
-  }
-  if (record["version"] !== void 0 && typeof record["version"] !== "string") {
-    return false;
-  }
-  return true;
-}
-function parseClaudePluginList(rawStdout, options = {}) {
-  let parsed;
-  try {
-    parsed = JSON.parse(rawStdout);
-  } catch {
-    return { ok: false, reason: "invalid-json" };
-  }
-  if (!Array.isArray(parsed)) {
-    return { ok: false, reason: "non-array" };
-  }
-  const entries = [];
-  const otherScopeIds = [];
-  for (const item of parsed) {
-    if (!isValidEntry(item)) {
-      return { ok: false, reason: "missing-fields" };
-    }
-    if (typeof item.projectPath === "string" && options.isThisWorkspace && !options.isThisWorkspace(item.projectPath)) {
-      continue;
-    }
-    const scope = item.scope;
-    if (!isKnownScope(scope)) {
-      otherScopeIds.push(item.id);
-      continue;
-    }
-    entries.push({
-      id: item.id,
-      version: item.version,
-      scope,
-      enabled: item.enabled
-    });
-  }
-  return { ok: true, entries, otherScopeIds };
-}
-
-// ../integrations/dist/hosts/claude-code/match-claude-plugin.js
-function matchClaudePlugin(entries, pluginId) {
-  const matches = entries.filter((candidate) => candidate.id === pluginId);
-  if (matches.length === 0) {
-    return { kind: "absent" };
-  }
-  if (matches.length > 1) {
-    return { kind: "ambiguous", entries: matches };
-  }
-  return { kind: "matched", entry: matches[0] };
-}
-
-// ../integrations/dist/hosts/claude-code/claude-cli-verification-result.js
-function evaluateClaudeCliMatch(match) {
-  switch (match.kind) {
-    case "matched":
-      return match.entry.enabled ? { status: "verified", version: match.entry.version, scope: match.entry.scope } : { status: "installed-but-disabled", scope: match.entry.scope };
-    case "absent":
-      return { status: "absent" };
-    case "ambiguous":
-      return { status: "ambiguous" };
-  }
-}
-
-// ../integrations/dist/hosts/claude-code/verify-via-claude-cli.js
-async function verifyViaClaudeCli(runner, pluginId, cwd) {
-  let raw;
-  try {
-    raw = await runner.run({
-      executable: "claude",
-      argv: ["plugin", "list", "--json"],
-      ...cwd === void 0 ? {} : { cwd },
-      timeoutMs: CLAUDE_CLI_TIMEOUT_MS,
-      stdoutLimitBytes: CLAUDE_CLI_STDOUT_LIMIT_BYTES,
-      stderrLimitBytes: CLAUDE_CLI_STDERR_LIMIT_BYTES
-    });
-  } catch {
-    return { source: "claude-cli-unavailable", reason: "not-found" };
-  }
-  if (raw.timedOut) {
-    return { source: "claude-cli-unavailable", reason: "timeout" };
-  }
-  if (raw.outputExceeded) {
-    return { source: "claude-cli-unavailable", reason: "output-too-large" };
-  }
-  if (raw.exitCode !== 0) {
-    return { source: "claude-cli-unavailable", reason: "non-zero-exit" };
-  }
-  const parsed = parseClaudePluginList(raw.stdout, cwd === void 0 ? {} : { isThisWorkspace: samePathAs(cwd) });
-  if (!parsed.ok) {
-    return {
-      source: "claude-cli-unavailable",
-      reason: parsed.reason === "invalid-json" ? "invalid-json" : "unexpected-schema"
-    };
-  }
-  const match = matchClaudePlugin(parsed.entries, pluginId);
-  if (parsed.otherScopeIds.includes(pluginId)) {
-    return match.kind === "absent" ? { source: "claude-cli-unavailable", reason: "unexpected-schema" } : { source: "claude-cli", outcome: { status: "ambiguous" } };
-  }
-  return { source: "claude-cli", outcome: evaluateClaudeCliMatch(match) };
-}
-function canonical(path) {
-  try {
-    return realpathSync(path);
-  } catch {
-    return resolve(path);
-  }
-}
-function samePathAs(workspaceRoot) {
-  const root = canonical(workspaceRoot);
-  return (projectPath) => canonical(projectPath) === root;
-}
-
-// ../integrations/dist/hosts/claude-code/verify.js
-async function verifyClaudeMarketplacePlugin(entry, deps, context) {
-  const detect = deps.detect ?? detectWorkspacePackage;
-  const pluginId = entry.hosts["claude-code"]?.pluginId;
-  if (pluginId === void 0) {
-    throw new Error(`${entry.displayName} has no Claude Code distribution \u2014 it cannot be verified through the claude CLI.`);
-  }
-  const cliResult = await verifyViaClaudeCli(deps.runner, pluginId, context.workspaceRoot);
-  if (cliResult.source === "claude-cli") {
-    switch (cliResult.outcome.status) {
-      case "verified":
-        return {
-          source: "claude-cli",
-          result: { verified: true, resolvedVersion: cliResult.outcome.version, problems: [] }
-        };
-      case "installed-but-disabled":
-        return {
-          source: "claude-cli",
-          result: {
-            verified: false,
-            problems: [
-              `${entry.displayName} is installed (scope: ${cliResult.outcome.scope}) but currently disabled in Claude Code.`,
-              "Enable it before recording this integration \u2014 a disabled plugin is never recorded as verified."
-            ]
-          }
-        };
-      case "absent":
-        return {
-          source: "claude-cli",
-          result: {
-            verified: false,
-            problems: [
-              `${pluginId} was not found in the installed Claude Code plugin list.`,
-              `Install it (${defaultRerunCommand(entry)}) or complete the manual Claude Code steps, then try again.`
-            ]
-          }
-        };
-      case "ambiguous":
-        return {
-          source: "claude-cli",
-          result: {
-            verified: false,
-            problems: [
-              `Verification error: more than one installed plugin matches ${pluginId} exactly. This is ambiguous and cannot be safely resolved automatically.`
-            ]
-          }
-        };
-    }
-  }
-  if (cliResult.reason === "not-found") {
-    const detected = await detect(entry, context);
-    if (detected.installed) {
-      return {
-        source: "package-json",
-        result: { verified: true, resolvedVersion: detected.installedVersion, problems: [] }
-      };
-    }
-    return {
-      source: "package-json",
-      result: {
-        verified: false,
-        problems: [
-          `The claude CLI was not found, and ${entry.displayName} was not found as a workspace dependency either.`,
-          `Install the Claude Code CLI to use the authoritative verification signal, or add ${entry.displayName} as a workspace dependency for the weaker fallback signal.`
-        ]
-      }
-    };
-  }
-  return {
-    source: "claude-cli",
-    result: {
-      verified: false,
-      problems: [`Verification error: the claude CLI returned an unexpected result (${cliResult.reason}).`]
-    }
-  };
-}
-function createClaudeMarketplaceVerifier(entry, deps) {
-  return async (context) => (await verifyClaudeMarketplacePlugin(entry, deps, context)).result;
-}
-
-// ../integrations/dist/catalog/create-catalog-integration.js
-function createCatalogIntegration(entry, deps) {
-  return {
-    id: entry.id,
-    displayName: entry.displayName,
-    homepage: entry.homepage,
-    repository: entry.repository,
-    license: entry.license,
-    supportedEnvironments: PLUGIN_HOSTS.filter((host) => entry.hosts[host] !== void 0),
-    detect: (context) => detectWorkspacePackage(entry, context),
-    plan: createClaudeMarketplacePlan(entry),
-    install: createClaudeMarketplaceInstall(entry, { runner: deps.runner }),
-    verify: createClaudeMarketplaceVerifier(entry, { runner: deps.runner }),
-    uninstallInstructions: async () => [...entry.uninstallSteps]
-  };
-}
-function createCatalogIntegrations(deps) {
-  return PLUGIN_CATALOG.map((entry) => createCatalogIntegration(entry, deps));
-}
-
-// src/runtime/node-command-runner.ts
-import { spawn } from "node:child_process";
-var KILL_GRACE_MS = 500;
-var NodeCommandRunner = class {
-  run(input) {
-    return new Promise((resolve2, reject) => {
-      let stdout = "";
-      let stderr = "";
-      let timedOut = false;
-      let outputExceeded = false;
-      let settled = false;
-      let killTimer;
-      const spawnable = spawnableCommand(input.executable, input.argv);
-      const child = spawn(spawnable.command, spawnable.args, {
-        cwd: input.cwd,
-        shell: false,
-        windowsVerbatimArguments: spawnable.windowsVerbatimArguments,
-        windowsHide: true,
-        // No stdin: nothing here ever answers a prompt (a command that wants
-        // confirmation must fail fast instead of waiting on an open pipe).
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-      const terminate = () => {
-        child.kill("SIGTERM");
-        killTimer = setTimeout(() => {
-          child.kill("SIGKILL");
-        }, KILL_GRACE_MS);
-      };
-      const timer = setTimeout(() => {
-        timedOut = true;
-        terminate();
-      }, input.timeoutMs);
-      child.stdout.on("data", (chunk) => {
-        stdout += chunk.toString("utf8");
-        if (Buffer.byteLength(stdout, "utf8") > input.stdoutLimitBytes) {
-          outputExceeded = true;
-          terminate();
-        }
-      });
-      child.stderr.on("data", (chunk) => {
-        stderr += chunk.toString("utf8");
-        if (Buffer.byteLength(stderr, "utf8") > input.stderrLimitBytes) {
-          outputExceeded = true;
-          terminate();
-        }
-      });
-      child.on("error", (error) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        clearTimeout(killTimer);
-        reject(error);
-      });
-      child.on("close", (code) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        clearTimeout(killTimer);
-        resolve2({ stdout, stderr, exitCode: code, timedOut, outputExceeded });
-      });
-    });
-  }
-};
-
-// src/runtime/integrations-composition-root.ts
-function createIntegrationsCompositionRoot(deps = {}) {
-  const runner = deps.runner ?? new NodeCommandRunner();
-  const registry = createIntegrationRegistry(createCatalogIntegrations({ runner }));
-  return {
-    registry,
-    runner,
-    getIntegration: (id) => getIntegration(registry, id),
-    listIntegrations: () => listIntegrations(registry)
-  };
-}
-
-// src/generators/shared/record-pipeline.ts
-async function runRecordPipeline(input) {
-  const entry = getCatalogEntry(input.id);
-  const metadata = entry === void 0 ? void 0 : recordMetadataFor(entry);
-  if (!entry || !metadata) {
-    throw new Error(`No manifest metadata is defined for "${input.id}".`);
-  }
-  const { result: verification, source: verificationSource } = await verifyClaudeMarketplacePlugin(
-    entry,
-    { runner: input.runner },
-    { workspaceRoot: input.workspaceRoot, targetEnvironment: input.target }
-  );
-  const manifest = loadManifest(input.workspaceRoot);
-  const existingEntry = manifest.integrations[input.id];
-  const plan = buildRecordPlan({ id: input.id, target: input.target, verificationSource, verification, existingEntry, metadata });
-  let wasWritten = false;
-  if (input.write && plan.proposedEntry) {
-    writeManifestAtomic(input.workspaceRoot, {
-      integrations: { ...manifest.integrations, [input.id]: plan.proposedEntry }
-    });
-    wasWritten = true;
-  }
-  return {
-    verificationSource,
-    verification,
-    existingEntry,
-    proposedEntry: plan.proposedEntry,
-    hasConflict: plan.hasConflict,
-    wasWritten
-  };
-}
-
 // src/generators/record-integration/generator.ts
 async function recordIntegrationGenerator(tree, options, deps = {}) {
   const root = deps.integrationsRoot ?? createIntegrationsCompositionRoot();