cortex-editor 0.2.0

package/dist/cli/init-4THVM67R.js

@@ -0,0 +1,904 @@
+#!/usr/bin/env node
+import {
+  version
+} from "./chunk-DDAWRJKB.js";
+
+// src/cli/init.ts
+import { spawn } from "child_process";
+import fs4 from "fs";
+import path3 from "path";
+import { stdin, stdout } from "process";
+import { createInterface } from "readline/promises";
+import {
+  Project,
+  SyntaxKind,
+  ts
+} from "ts-morph";
+
+// src/cli/detect.ts
+import fs from "fs";
+import path from "path";
+var VITE_CONFIG_FILES = [
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mts",
+  "vite.config.mjs",
+  "vite.config.cts",
+  "vite.config.cjs"
+];
+var NEXT_CONFIG_FILES = [
+  "next.config.ts",
+  "next.config.mts",
+  "next.config.mjs",
+  "next.config.js",
+  "next.config.cjs",
+  "next.config.cts"
+];
+var WEBPACK_CONFIG_FILES = [
+  "webpack.config.ts",
+  "webpack.config.js",
+  "webpack.config.mts",
+  "webpack.config.mjs",
+  "webpack.config.cts",
+  "webpack.config.cjs"
+];
+function installedDependencies(pkg) {
+  return {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.optionalDependencies
+  };
+}
+function hasDependency(pkg, name) {
+  return Boolean(installedDependencies(pkg)[name]);
+}
+function detectPackageManager(cwd, pkg = {}) {
+  if (fs.existsSync(path.join(cwd, "package-lock.json"))) return "npm";
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path.join(cwd, "bun.lockb")) || fs.existsSync(path.join(cwd, "bun.lock"))) {
+    return "bun";
+  }
+  if (pkg.packageManager?.startsWith("pnpm@")) return "pnpm";
+  if (pkg.packageManager?.startsWith("yarn@")) return "yarn";
+  if (pkg.packageManager?.startsWith("bun@")) return "bun";
+  if (pkg.packageManager?.startsWith("npm@")) return "npm";
+  return "npm";
+}
+
+// src/adapters/telemetry.ts
+import fs3 from "fs";
+import path2 from "path";
+
+// src/adapters/atomic-write.ts
+import { promises as fs2 } from "fs";
+import { randomBytes } from "crypto";
+import { dirname, basename, join } from "path";
+var ExternalRevertError = class extends Error {
+  filePath;
+  constructor(filePath) {
+    super("Write was reverted by an external process (e.g. editor auto-save)");
+    this.name = "ExternalRevertError";
+    this.filePath = filePath;
+  }
+};
+async function atomicWrite(filePath, content) {
+  const tmpPath = tempSibling(filePath);
+  try {
+    await fs2.writeFile(tmpPath, content, "utf-8");
+    await fs2.rename(tmpPath, filePath);
+  } catch (err) {
+    try {
+      await fs2.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  const afterFirst = await fs2.readFile(filePath, "utf-8");
+  if (afterFirst === content) return;
+  const retryTmp = tempSibling(filePath);
+  try {
+    await fs2.writeFile(retryTmp, content, "utf-8");
+    await fs2.rename(retryTmp, filePath);
+  } catch (err) {
+    try {
+      await fs2.unlink(retryTmp);
+    } catch {
+    }
+    throw err;
+  }
+  const afterRetry = await fs2.readFile(filePath, "utf-8");
+  if (afterRetry === content) return;
+  throw new ExternalRevertError(filePath);
+}
+function tempSibling(filePath) {
+  const nonce = randomBytes(6).toString("hex");
+  return join(dirname(filePath), `.${basename(filePath)}.cortex-${process.pid}-${nonce}.tmp`);
+}
+
+// src/adapters/telemetry.ts
+var NOOP = {
+  async recordInit() {
+  },
+  async recordActivation() {
+  },
+  async recordFirstEdit() {
+  }
+};
+function createTelemetry(options) {
+  if (!options.enabled) return NOOP;
+  const {
+    endpoint,
+    cortexRoot,
+    version: version2,
+    now,
+    fetchImpl = fetch,
+    readFileSync: readFileSyncImpl = (p, enc) => fs3.readFileSync(p, enc),
+    writeFile: writeFileImpl = atomicWrite,
+    mkdirSync: mkdirSyncImpl = (d, opts) => {
+      fs3.mkdirSync(d, opts);
+    }
+  } = options;
+  const usagePath = path2.join(cortexRoot, ".cortex", "usage.json");
+  const cortexDir = path2.join(cortexRoot, ".cortex");
+  function today() {
+    return (now?.() ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  }
+  function readState() {
+    try {
+      const raw = readFileSyncImpl(usagePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async function persistState(state) {
+    try {
+      mkdirSyncImpl(cortexDir, { recursive: true, mode: 448 });
+      await writeFileImpl(usagePath, JSON.stringify(state, null, 2));
+    } catch {
+    }
+  }
+  function emit(event) {
+    if (endpoint) {
+      const payload = {
+        event,
+        ts: (now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+        cortexVersion: version2
+      };
+      void fetchImpl(endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(3e3)
+      }).catch(() => {
+      });
+    }
+  }
+  let tail = Promise.resolve();
+  function serialize(task) {
+    const run = tail.then(task, task);
+    tail = run.catch(() => {
+    });
+    return run;
+  }
+  return {
+    recordInit() {
+      return serialize(async () => {
+        emit("cortex_init");
+        const state = readState() ?? { version: 1 };
+        await persistState(state);
+      });
+    },
+    recordActivation() {
+      return serialize(async () => {
+        const todayStr = today();
+        const state = readState() ?? { version: 1 };
+        const isReturnSession = state.lastActivationDate !== void 0 && state.lastActivationDate !== todayStr;
+        emit("editor_activated");
+        if (isReturnSession) emit("return_session");
+        const updated = {
+          ...state,
+          firstActivationDate: state.firstActivationDate ?? todayStr,
+          lastActivationDate: todayStr
+        };
+        await persistState(updated);
+      });
+    },
+    recordFirstEdit() {
+      return serialize(async () => {
+        const state = readState() ?? { version: 1 };
+        if (state.firstEditRecorded) return;
+        emit("first_edit");
+        const updated = { ...state, firstEditRecorded: true };
+        await persistState(updated);
+      });
+    }
+  };
+}
+
+// src/adapters/telemetry-config.ts
+function resolveTelemetryEnabled(options) {
+  const { env = process.env } = options;
+  return (env.CORTEX_TELEMETRY ?? "").trim().toLowerCase() === "true";
+}
+function resolveTelemetryEndpoint(options) {
+  const { env = process.env } = options;
+  const raw = env.CORTEX_TELEMETRY_ENDPOINT;
+  if (!raw) return void 0;
+  try {
+    const parsed = new URL(raw);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return void 0;
+    }
+    return raw;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cli/init.ts
+var VITE_SETUP_PACKAGES = ["vite", "@vitejs/plugin-react"];
+function resolveObjectLiteralExpression(sourceFile, expr, options = {}, seen = /* @__PURE__ */ new Set()) {
+  if (expr.getKind() === SyntaxKind.ObjectLiteralExpression) {
+    return expr.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+  }
+  if (options.allowCallObjectArg && expr.getKind() === SyntaxKind.CallExpression) {
+    const callExpr = expr.asKindOrThrow(SyntaxKind.CallExpression);
+    const firstArg = callExpr.getArguments()[0];
+    if (firstArg && firstArg.getKind() !== SyntaxKind.SpreadElement) {
+      return resolveObjectLiteralExpression(sourceFile, firstArg, options, seen);
+    }
+  }
+  if (expr.getKind() === SyntaxKind.Identifier) {
+    const name = expr.getText();
+    if (seen.has(name)) return void 0;
+    seen.add(name);
+    const initializer = sourceFile.getVariableDeclaration(name)?.getInitializer();
+    if (initializer) return resolveObjectLiteralExpression(sourceFile, initializer, options, seen);
+  }
+  return void 0;
+}
+function isCommonJsExportTarget(node) {
+  return node.getText().trim() === "module.exports";
+}
+function isCommonJsExportAssignment(binaryExpression) {
+  if (!binaryExpression.isKind(SyntaxKind.BinaryExpression)) return false;
+  if (binaryExpression.getOperatorToken().getKind() !== SyntaxKind.EqualsToken) return false;
+  return isCommonJsExportTarget(binaryExpression.getLeft());
+}
+function findCommonJSExportExpression(sourceFile) {
+  const assignment = sourceFile.getDescendantsOfKind(SyntaxKind.BinaryExpression).find((expr) => isCommonJsExportAssignment(expr));
+  return assignment?.getRight();
+}
+function findConfigObject(sourceFile, moduleConfig) {
+  if (moduleConfig) {
+    const defaultExport = sourceFile.getFirstDescendantByKind(SyntaxKind.ExportAssignment);
+    const expr2 = defaultExport?.getExpression();
+    return expr2 ? resolveObjectLiteralExpression(sourceFile, expr2, { allowCallObjectArg: true }) : void 0;
+  }
+  const expr = findCommonJSExportExpression(sourceFile);
+  return expr ? resolveObjectLiteralExpression(sourceFile, expr, { allowCallObjectArg: true }) : void 0;
+}
+function createConfigSourceFile(fileName, content) {
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: {
+      allowJs: true,
+      noResolve: true,
+      skipLibCheck: true
+    }
+  });
+  return project.createSourceFile(fileName, content);
+}
+function assertParseable(sourceFile, basename2) {
+  const compilerSourceFile = sourceFile.compilerNode;
+  const syntaxDiag = compilerSourceFile.parseDiagnostics ?? [];
+  if (syntaxDiag.length === 0) return;
+  const raw = syntaxDiag[0].messageText;
+  const text = typeof raw === "string" ? raw : ts.flattenDiagnosticMessageText(raw, "\n");
+  throw new Error(`${basename2}: failed to parse - ${text}`);
+}
+function hasNamedCallExpression(node, name) {
+  if (node.isKind(SyntaxKind.CallExpression) && node.getExpression().getText() === name) {
+    return true;
+  }
+  return node.getDescendantsOfKind(SyntaxKind.CallExpression).some((call) => call.getExpression().getText() === name);
+}
+function isRequireCall(expr, moduleSpecifier) {
+  if (!expr || expr.getKind() !== SyntaxKind.CallExpression) return false;
+  const call = expr.asKindOrThrow(SyntaxKind.CallExpression);
+  if (call.getExpression().getText() !== "require") return false;
+  const firstArg = call.getArguments()[0];
+  return firstArg?.getText().replace(/^['"]|['"]$/g, "") === moduleSpecifier;
+}
+function hasNamedImport(sourceFile, functionName, moduleSpecifier) {
+  return sourceFile.getImportDeclarations().some(
+    (declaration) => declaration.getModuleSpecifierValue() === moduleSpecifier && declaration.getNamedImports().some((namedImport) => namedImport.getName() === functionName)
+  );
+}
+function hasNamedRequire(sourceFile, functionName, moduleSpecifier) {
+  return sourceFile.getVariableDeclarations().some((declaration) => {
+    const nameNode = declaration.getNameNode();
+    if (nameNode.getKind() !== SyntaxKind.ObjectBindingPattern) return false;
+    const binding = nameNode.asKindOrThrow(SyntaxKind.ObjectBindingPattern);
+    const hasBinding = binding.getElements().some((element) => element.getName() === functionName);
+    return hasBinding && isRequireCall(declaration.getInitializer(), moduleSpecifier);
+  });
+}
+function getCommonJSHelperInsertIndex(sourceFile) {
+  const statements = sourceFile.getStatements();
+  let insertIndex = 0;
+  while (insertIndex < statements.length) {
+    const statement = statements[insertIndex];
+    if (statement.getKind() !== SyntaxKind.ExpressionStatement) break;
+    const expression = statement.asKindOrThrow(SyntaxKind.ExpressionStatement).getExpression();
+    if (expression.getKind() !== SyntaxKind.StringLiteral && expression.getKind() !== SyntaxKind.NoSubstitutionTemplateLiteral) {
+      break;
+    }
+    insertIndex++;
+  }
+  return insertIndex;
+}
+function ensureHelperBinding(sourceFile, functionName, moduleSpecifier, moduleConfig) {
+  if (hasNamedImport(sourceFile, functionName, moduleSpecifier) || hasNamedRequire(sourceFile, functionName, moduleSpecifier)) {
+    return;
+  }
+  if (moduleConfig) {
+    sourceFile.addImportDeclaration({
+      namedImports: [functionName],
+      moduleSpecifier
+    });
+  } else {
+    sourceFile.insertStatements(
+      getCommonJSHelperInsertIndex(sourceFile),
+      `const { ${functionName} } = require("${moduleSpecifier}")
+`
+    );
+  }
+}
+function configExpressionUsesNamedCall(sourceFile, expression, name) {
+  if (hasNamedCallExpression(expression, name)) return true;
+  const identifier = expression.getText().trim();
+  if (!/^[A-Za-z_$][\w$]*$/.test(identifier)) return false;
+  const declaration = sourceFile.getVariableDeclaration(identifier);
+  const initializer = declaration?.getInitializer();
+  return Boolean(initializer && hasNamedCallExpression(initializer, name));
+}
+function objectPropertyValueUsesNamedCall(sourceFile, property, name) {
+  if (property.isKind(SyntaxKind.PropertyAssignment)) {
+    const initializer = property.getInitializer();
+    return Boolean(initializer && configExpressionUsesNamedCall(sourceFile, initializer, name));
+  }
+  return configExpressionUsesNamedCall(sourceFile, property, name);
+}
+function viteConfigUsesCortexEditor(content, basename2, moduleConfig) {
+  const sourceFile = createConfigSourceFile(basename2, content);
+  assertParseable(sourceFile, basename2);
+  const configObject = findConfigObject(sourceFile, moduleConfig);
+  const pluginsProperty = configObject?.getProperty("plugins");
+  return Boolean(
+    pluginsProperty && objectPropertyValueUsesNamedCall(sourceFile, pluginsProperty, "cortexEditor")
+  );
+}
+function nextConfigUsesWithCortex(content, basename2, moduleConfig) {
+  const sourceFile = createConfigSourceFile(basename2, content);
+  assertParseable(sourceFile, basename2);
+  if (moduleConfig) {
+    const defaultExport = sourceFile.getFirstDescendantByKind(SyntaxKind.ExportAssignment);
+    return Boolean(
+      defaultExport && configExpressionUsesNamedCall(sourceFile, defaultExport.getExpression(), "withCortex")
+    );
+  }
+  return sourceFile.getDescendantsOfKind(SyntaxKind.BinaryExpression).some((binaryExpression) => isCommonJsExportAssignment(binaryExpression) && configExpressionUsesNamedCall(sourceFile, binaryExpression.getRight(), "withCortex"));
+}
+function webpackConfigUsesCortexWebpack(content, basename2, moduleConfig) {
+  const sourceFile = createConfigSourceFile(basename2, content);
+  assertParseable(sourceFile, basename2);
+  const configObject = findConfigObject(sourceFile, moduleConfig);
+  const pluginsProperty = configObject?.getProperty("plugins");
+  return Boolean(
+    pluginsProperty && objectPropertyValueUsesNamedCall(sourceFile, pluginsProperty, "cortexWebpack")
+  );
+}
+function findFirstExisting(cwd, names) {
+  return names.map((file) => path3.join(cwd, file)).find((file) => fs4.existsSync(file)) ?? null;
+}
+function isModuleConfig(filePath, content, pkgType) {
+  const ext = path3.extname(filePath);
+  if (ext === ".mjs" || ext === ".mts") return true;
+  if (ext === ".cjs" || ext === ".cts") return false;
+  const sourceFile = createConfigSourceFile(path3.basename(filePath), content);
+  if (findCommonJSExportExpression(sourceFile)) return false;
+  const exportAssignment = sourceFile.getFirstDescendantByKind(SyntaxKind.ExportAssignment);
+  if (exportAssignment && !exportAssignment.compilerNode.isExportEquals) {
+    return true;
+  }
+  return pkgType === "module";
+}
+function viteConfigCanBeAutoConfigured(content, basename2, moduleConfig) {
+  const sourceFile = createConfigSourceFile(basename2, content);
+  assertParseable(sourceFile, basename2);
+  return Boolean(findConfigObject(sourceFile, moduleConfig));
+}
+function injectVitePlugin(content, basename2, moduleConfig) {
+  const sourceFile = createConfigSourceFile(basename2, content);
+  assertParseable(sourceFile, basename2);
+  const configObject = findConfigObject(sourceFile, moduleConfig);
+  if (!configObject) {
+    throw new Error(
+      `${basename2}: could not find config object - expected defineConfig({...}), export default {...}, or module.exports = {...}`
+    );
+  }
+  const pluginAdded = addPluginToConfigObject(configObject, "cortexEditor()", basename2);
+  if (!pluginAdded) return { content, injected: false };
+  ensureHelperBinding(sourceFile, "cortexEditor", "cortex-editor/vite", moduleConfig);
+  return { content: sourceFile.getFullText(), injected: true };
+}
+function isFunctionConfigExpression(sourceFile, expr) {
+  const kind = expr.getKind();
+  if (kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.FunctionExpression) return true;
+  if (kind !== SyntaxKind.Identifier) return false;
+  const name = expr.getText();
+  const variable = sourceFile.getVariableDeclaration(name);
+  const initializer = variable?.getInitializer();
+  if (initializer) {
+    const initializerKind = initializer.getKind();
+    return initializerKind === SyntaxKind.ArrowFunction || initializerKind === SyntaxKind.FunctionExpression;
+  }
+  return Boolean(sourceFile.getFunction(name));
+}
+function wrapConfigExpression(sourceFile, expr, helperName) {
+  const exprText = expr.getText();
+  if (isFunctionConfigExpression(sourceFile, expr)) {
+    return `async (...args) => ${helperName}(await (${exprText})(...args))`;
+  }
+  return `${helperName}(${exprText})`;
+}
+function injectNextWrapper(content, basename2, moduleConfig) {
+  const sourceFile = createConfigSourceFile(basename2, content);
+  assertParseable(sourceFile, basename2);
+  if (moduleConfig) {
+    const defaultExport = sourceFile.getFirstDescendantByKind(SyntaxKind.ExportAssignment);
+    if (!defaultExport) return { content, injected: false };
+    const expr = defaultExport.getExpression();
+    expr.replaceWithText(wrapConfigExpression(sourceFile, expr, "withCortex"));
+    ensureHelperBinding(sourceFile, "withCortex", "cortex-editor/next", moduleConfig);
+    return { content: sourceFile.getFullText(), injected: true };
+  }
+  const assignment = sourceFile.getDescendantsOfKind(SyntaxKind.BinaryExpression).find((expr) => isCommonJsExportAssignment(expr));
+  if (!assignment) return { content, injected: false };
+  const right = assignment.getRight();
+  right.replaceWithText(wrapConfigExpression(sourceFile, right, "withCortex"));
+  ensureHelperBinding(sourceFile, "withCortex", "cortex-editor/next", moduleConfig);
+  return { content: sourceFile.getFullText(), injected: true };
+}
+function addPluginToConfigObject(configObject, pluginExpression, basename2) {
+  const pluginsProp = configObject.getProperty("plugins");
+  if (pluginsProp) {
+    const initializer = pluginsProp.getChildrenOfKind(SyntaxKind.ArrayLiteralExpression)[0];
+    if (initializer) {
+      initializer.insertElement(0, pluginExpression);
+      return true;
+    }
+    console.warn(`  ${basename2}: plugins is not an array literal - add ${pluginExpression} manually`);
+    return false;
+  }
+  configObject.addPropertyAssignment({
+    name: "plugins",
+    initializer: `[${pluginExpression}]`
+  });
+  return true;
+}
+function injectWebpackPlugin(content, basename2, moduleConfig) {
+  const sourceFile = createConfigSourceFile(basename2, content);
+  assertParseable(sourceFile, basename2);
+  const configObject = findConfigObject(sourceFile, moduleConfig);
+  if (!configObject) {
+    const exportKind = moduleConfig ? "default export object" : "module.exports object";
+    throw new Error(`${basename2}: expected ${exportKind} to configure with cortexWebpack()`);
+  }
+  const pluginAdded = addPluginToConfigObject(configObject, "cortexWebpack()", basename2);
+  if (!pluginAdded) return { content, injected: false };
+  ensureHelperBinding(sourceFile, "cortexWebpack", "cortex-editor/webpack", moduleConfig);
+  return { content: sourceFile.getFullText(), injected: true };
+}
+var CORTEX_SLASH_COMMAND = `---
+description: Activate or manage the Cortex visual editor for this project
+argument-hint: [activate|status|apply|deactivate]
+---
+
+# Cortex
+
+Use the Cortex MCP tools for this project. Interpret \`$ARGUMENTS\` as an optional action:
+
+- No arguments or \`activate\`: call \`cortex_status\`. If the dev server is not connected, tell the user to start the app's normal dev server and open the app in a browser. If connected, call \`cortex_activate\`.
+- \`status\`: call \`cortex_status\` and summarize whether the dev server, browser, and editor are connected.
+- \`deactivate\` or \`close\`: call \`cortex_deactivate\`.
+- \`apply\`: call \`cortex_get_pending_edits\`. If there are staged edits, call \`cortex_apply_edits\` with their intent IDs. For any \`needs-source-edit\` result, inspect the intent/source context as needed, edit the source with normal file-editing tools, then call \`cortex_discard_edits\` for completed intent IDs. Report failed IDs clearly.
+
+If the Cortex MCP server is unavailable, ask the user to restart Claude Code or run \`/mcp\` and approve the project-scoped \`cortex\` server.
+`;
+function createInstallRequest(packageManager, packages, cwd) {
+  if (packageManager === "pnpm") {
+    return {
+      packageManager,
+      command: "pnpm",
+      args: ["add", "-D", ...packages],
+      cwd,
+      packages
+    };
+  }
+  if (packageManager === "yarn") {
+    return {
+      packageManager,
+      command: "yarn",
+      args: ["add", "-D", ...packages],
+      cwd,
+      packages
+    };
+  }
+  if (packageManager === "bun") {
+    return {
+      packageManager,
+      command: "bun",
+      args: ["add", "-d", ...packages],
+      cwd,
+      packages
+    };
+  }
+  return {
+    packageManager,
+    command: "npm",
+    args: ["install", "-D", ...packages],
+    cwd,
+    packages
+  };
+}
+async function defaultInstallPackages(request) {
+  await new Promise((resolve, reject) => {
+    const child = spawn(request.command, request.args, {
+      cwd: request.cwd,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code, signal) => {
+      if (code === 0) {
+        resolve();
+      } else if (signal) {
+        reject(new Error(`${request.command} ${request.args.join(" ")} exited with signal ${signal}`));
+      } else {
+        reject(
+          new Error(
+            `${request.command} ${request.args.join(" ")} exited with ${code ?? "unknown status"}`
+          )
+        );
+      }
+    });
+  });
+}
+async function defaultPromptInstall(request) {
+  if (!stdin.isTTY) return false;
+  const command = createInstallRequest(request.packageManager, request.packages, request.cwd);
+  const promptCwd = path3.resolve(request.cwd);
+  const cwdHint = promptCwd === path3.resolve(process.cwd()) ? "" : ` in ${promptCwd}`;
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await rl.question(
+      `Cortex needs ${request.packages.join(" and ")} to configure source annotations. Run "${command.command} ${command.args.join(" ")}"${cwdHint} now? [Y/n] `
+    );
+    return answer.trim() === "" || /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function ensurePackages(cwd, pkg, packageManager, packages, reason, options) {
+  const missing = packages.filter((name) => !hasDependency(pkg, name));
+  if (missing.length === 0) return true;
+  const promptInstall = options.promptInstall ?? defaultPromptInstall;
+  const approved = await promptInstall({ cwd, packageManager, packages: missing, reason });
+  if (!approved) {
+    const installRequest2 = createInstallRequest(packageManager, missing, cwd);
+    console.warn(
+      `  Cortex setup incomplete: missing ${missing.join(" and ")} required to configure source annotations.`
+    );
+    console.warn(
+      `  Install missing packages with: ${installRequest2.command} ${installRequest2.args.join(" ")}`
+    );
+    console.warn("  Then re-run: npx cortex init");
+    return false;
+  }
+  const installPackages = options.installPackages ?? defaultInstallPackages;
+  const installRequest = createInstallRequest(packageManager, missing, cwd);
+  await installPackages(installRequest);
+  return true;
+}
+function writeViteConfig(cwd) {
+  const viteConfigPath = path3.join(cwd, "vite.config.ts");
+  const content = [
+    "import { defineConfig } from 'vite'",
+    "import react from '@vitejs/plugin-react'",
+    "import { cortexEditor } from 'cortex-editor/vite'",
+    "",
+    "export default defineConfig({",
+    "  plugins: [cortexEditor(), react()],",
+    "})",
+    ""
+  ].join("\n");
+  fs4.writeFileSync(viteConfigPath, content);
+  console.log("  vite.config.ts: created with cortexEditor plugin");
+  return viteConfigPath;
+}
+function writeNextConfig(cwd) {
+  const nextConfigPath = path3.join(cwd, "next.config.mjs");
+  const content = [
+    "import { withCortex } from 'cortex-editor/next'",
+    "",
+    "export default withCortex({})",
+    ""
+  ].join("\n");
+  fs4.writeFileSync(nextConfigPath, content);
+  console.log("  next.config.mjs: created with withCortex()");
+  return nextConfigPath;
+}
+function selectBundler(cwd, pkg, paths) {
+  if (paths.nextConfigPath) return "next";
+  if (paths.viteConfigPath) return "vite";
+  if (paths.webpackConfigPath) return "webpack";
+  if (hasDependency(pkg, "next")) return "next";
+  if (hasDependency(pkg, "vite")) return "vite";
+  if (hasDependency(pkg, "webpack") || hasDependency(pkg, "react-scripts")) return "webpack";
+  void cwd;
+  return "none";
+}
+async function runInit(cwd = process.cwd(), options = {}) {
+  const pkgPath = path3.join(cwd, "package.json");
+  if (!fs4.existsSync(pkgPath)) {
+    throw new Error("No package.json found. Run this from your project root.");
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `package.json: failed to parse - ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const mcpPath = path3.join(cwd, ".mcp.json");
+  let mcpConfig = {};
+  let mcpWritten = false;
+  if (fs4.existsSync(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(fs4.readFileSync(mcpPath, "utf8"));
+    } catch (err) {
+      throw new Error(
+        `.mcp.json: failed to parse - ${err instanceof Error ? err.message : String(err)}
+Fix the JSON syntax and re-run cortex init.`
+      );
+    }
+    if (typeof mcpConfig !== "object" || mcpConfig === null || Array.isArray(mcpConfig)) {
+      throw new Error(".mcp.json: root value must be a JSON object.");
+    }
+  }
+  const rawServers = mcpConfig.mcpServers;
+  if (rawServers !== void 0 && rawServers !== null && (typeof rawServers !== "object" || Array.isArray(rawServers))) {
+    throw new Error('.mcp.json: "mcpServers" must be an object.');
+  }
+  const servers = rawServers ?? {};
+  if (servers.cortex) {
+    console.log("  .mcp.json: cortex already configured");
+  } else {
+    servers.cortex = { command: "npx", args: ["cortex", "mcp"] };
+    mcpConfig.mcpServers = servers;
+    fs4.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+    console.log("  .mcp.json: added cortex MCP server");
+    mcpWritten = true;
+  }
+  const slashCommandPath = path3.join(cwd, ".claude", "commands", "cortex.md");
+  let slashCommandFound = false;
+  let slashCommandWritten = false;
+  if (fs4.existsSync(slashCommandPath)) {
+    slashCommandFound = true;
+    console.log("  .claude/commands/cortex.md: /cortex command already configured");
+  } else {
+    fs4.mkdirSync(path3.dirname(slashCommandPath), { recursive: true });
+    fs4.writeFileSync(slashCommandPath, CORTEX_SLASH_COMMAND);
+    slashCommandFound = true;
+    slashCommandWritten = true;
+    console.log("  .claude/commands/cortex.md: added /cortex slash command");
+  }
+  const viteConfigPath = findFirstExisting(cwd, VITE_CONFIG_FILES);
+  const nextConfigPath = findFirstExisting(cwd, NEXT_CONFIG_FILES);
+  const webpackConfigPath = findFirstExisting(cwd, WEBPACK_CONFIG_FILES);
+  const webpackConfigFound = Boolean(webpackConfigPath);
+  const detectedBundler = selectBundler(cwd, pkg, {
+    viteConfigPath,
+    nextConfigPath,
+    webpackConfigPath
+  });
+  const packageManager = detectPackageManager(cwd, pkg);
+  const depFound = hasDependency(pkg, "cortex-editor");
+  let vitePluginFound = null;
+  let vitePluginInjected = false;
+  let viteConfigCreated = false;
+  let nextConfigFound = null;
+  let nextConfigInjected = false;
+  let nextConfigCreated = false;
+  let webpackConfigInjected = false;
+  let adapterConfigured = false;
+  if (!depFound) {
+    const installRequest = createInstallRequest(packageManager, ["cortex-editor"], cwd);
+    console.warn(
+      "  cortex-editor not in dependencies - add it before configuring source annotations."
+    );
+    console.warn(
+      `  Install cortex-editor with: ${installRequest.command} ${installRequest.args.join(" ")}`
+    );
+  } else if (detectedBundler === "next") {
+    if (viteConfigPath && nextConfigPath) {
+      console.warn(
+        `  ${path3.basename(viteConfigPath)} found alongside ${path3.basename(nextConfigPath)}; skipping Vite setup to avoid configuring auxiliary tooling`
+      );
+    }
+    if (!nextConfigPath) {
+      writeNextConfig(cwd);
+      nextConfigFound = true;
+      nextConfigInjected = true;
+      nextConfigCreated = true;
+      adapterConfigured = true;
+    } else {
+      nextConfigFound = true;
+      const basename2 = path3.basename(nextConfigPath);
+      const content = fs4.readFileSync(nextConfigPath, "utf8");
+      const moduleConfig = isModuleConfig(nextConfigPath, content, pkg.type);
+      if (nextConfigUsesWithCortex(content, basename2, moduleConfig)) {
+        console.log(`  ${basename2}: withCortex config found`);
+        adapterConfigured = true;
+      } else {
+        const result = injectNextWrapper(content, basename2, moduleConfig);
+        if (result.injected) {
+          fs4.writeFileSync(nextConfigPath, result.content);
+          nextConfigInjected = true;
+          adapterConfigured = true;
+          console.log(`  ${basename2}: withCortex config injected`);
+        } else {
+          console.warn(
+            `  ${basename2}: could not auto-configure Next.js - wrap your config with withCortex() from cortex-editor/next`
+          );
+        }
+      }
+    }
+  } else if (detectedBundler === "vite") {
+    if (webpackConfigPath && viteConfigPath) {
+      console.warn(
+        `  ${path3.basename(webpackConfigPath)} found alongside ${path3.basename(viteConfigPath)}; skipping Webpack setup because Vite is the selected app adapter`
+      );
+    }
+    if (!viteConfigPath) {
+      const installed = await ensurePackages(
+        cwd,
+        pkg,
+        packageManager,
+        VITE_SETUP_PACKAGES,
+        "missing-vite-config",
+        options
+      );
+      if (installed) {
+        writeViteConfig(cwd);
+        vitePluginFound = true;
+        vitePluginInjected = true;
+        viteConfigCreated = true;
+        adapterConfigured = true;
+      }
+    } else {
+      const vitePeerInstalled = await ensurePackages(
+        cwd,
+        pkg,
+        packageManager,
+        ["vite"],
+        "missing-vite-peer",
+        options
+      );
+      if (vitePeerInstalled) {
+        const basename2 = path3.basename(viteConfigPath);
+        const content = fs4.readFileSync(viteConfigPath, "utf8");
+        const moduleConfig = isModuleConfig(viteConfigPath, content, pkg.type);
+        if (viteConfigUsesCortexEditor(content, basename2, moduleConfig)) {
+          vitePluginFound = true;
+          adapterConfigured = true;
+          console.log(`  ${basename2}: cortexEditor plugin found`);
+        } else if (!viteConfigCanBeAutoConfigured(content, basename2, moduleConfig)) {
+          vitePluginFound = false;
+          console.warn(
+            `  ${basename2}: Vite config cannot be auto-configured - use export default/module.exports syntax or add cortexEditor() manually.`
+          );
+        } else {
+          const result = injectVitePlugin(content, basename2, moduleConfig);
+          if (result.injected) {
+            fs4.writeFileSync(viteConfigPath, result.content);
+            vitePluginFound = true;
+            vitePluginInjected = true;
+            adapterConfigured = true;
+            console.log(`  ${basename2}: cortexEditor plugin injected`);
+          } else {
+            vitePluginFound = false;
+          }
+        }
+      }
+    }
+  } else if (detectedBundler === "webpack") {
+    if (!webpackConfigPath) {
+      console.warn(
+        "  Webpack detected but no webpack.config.* file was found - add cortexWebpack() manually or create a config file, then re-run cortex init."
+      );
+    } else {
+      const basename2 = path3.basename(webpackConfigPath);
+      const content = fs4.readFileSync(webpackConfigPath, "utf8");
+      const moduleConfig = isModuleConfig(webpackConfigPath, content, pkg.type);
+      if (webpackConfigUsesCortexWebpack(content, basename2, moduleConfig)) {
+        adapterConfigured = true;
+        console.log(`  ${basename2}: cortexWebpack plugin found`);
+      } else {
+        const result = injectWebpackPlugin(content, basename2, moduleConfig);
+        if (result.injected) {
+          fs4.writeFileSync(webpackConfigPath, result.content);
+          webpackConfigInjected = true;
+          adapterConfigured = true;
+          console.log(`  ${basename2}: cortexWebpack plugin injected`);
+        }
+      }
+    }
+  } else {
+    const installed = await ensurePackages(
+      cwd,
+      pkg,
+      packageManager,
+      VITE_SETUP_PACKAGES,
+      "missing-bundler",
+      options
+    );
+    if (installed) {
+      writeViteConfig(cwd);
+      vitePluginFound = true;
+      vitePluginInjected = true;
+      viteConfigCreated = true;
+      adapterConfigured = true;
+    }
+  }
+  const setupComplete = depFound && adapterConfigured;
+  if (setupComplete) {
+    console.log("  Setup complete. Restart your AI agent so it picks up .mcp.json.");
+    try {
+      const telemetry = createTelemetry({
+        enabled: resolveTelemetryEnabled({}),
+        endpoint: resolveTelemetryEndpoint({}),
+        cortexRoot: cwd,
+        version
+      });
+      await telemetry.recordInit();
+    } catch {
+    }
+  } else {
+    console.warn("  Cortex setup incomplete. Resolve the warnings above, then re-run cortex init.");
+  }
+  return {
+    mcpWritten,
+    slashCommandFound,
+    slashCommandWritten,
+    vitePluginFound,
+    vitePluginInjected,
+    viteConfigCreated,
+    nextConfigFound,
+    nextConfigInjected,
+    nextConfigCreated,
+    webpackConfigFound,
+    webpackConfigInjected,
+    depFound,
+    detectedBundler,
+    packageManager,
+    setupComplete
+  };
+}
+export {
+  runInit
+};