@hegel-dev/companion 1.0.8 → 1.0.10

package/dist/setup.js

@@ -1,89 +1,39 @@
 #!/usr/bin/env node
-import { resolve, join, dirname, parse, posix as posixPath, win32 as win32Path } from "node:path";
-import { mkdir, writeFile, readdir, readFile, access, rm } from "node:fs/promises";
-import { execFileSync } from "node:child_process";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { loadConfig } from "./config.js";
-import { writeHooksFile, configHash } from "./hooks-generator.js";
-export const COMPANION_RULE = `# Hegel Companion Rule
-
-You are working in a project that uses Hegel, a dialectical companion for AI-assisted development.
-Hegel monitors your prompts and responses for quality, context drift, and session health.
-
-## MCP Tools Available
-
-You have access to the \`hegel-mcp\` server which provides two tools:
-1. \`hegel-status\`: Fetch the real-time health status of the current session.
-2. \`hegel-review\`: Fetch a comprehensive retrospective of the session.
-
-## When to use these tools
-
-- **Proactive Self-Correction**: If the user seems frustrated, repeats the same prompt, or if you feel the conversation is losing focus, call \`hegel-status\` to check if Hegel has flagged \`context-drift\` or \`prompt-degradation\`. Adjust your behavior accordingly.
-- **End-of-Task Summaries**: When completing a significant multi-step task, call \`hegel-review\` and append a brief session health summary to your final response.
-- **Transparency**: If Hegel blocks a prompt or flags a critical concern, acknowledge it and help the user formulate a better prompt.
-`;
-const defaultDeps = {
-    loadConfig,
-    writeHooksFile,
-    mkdir,
-    writeFile,
-    readdir,
-    readFile,
-    access,
-    rm,
-    execFileSync,
-    log: console.log,
-    error: console.error,
-    resolveHegelRoot: () => resolve(join(dirname(fileURLToPath(import.meta.url)), "..")),
-    platform: process.platform,
-    env: process.env,
-};
-/**
- * Walks up from `startDir` (exclusive) looking for an ancestor that already
- * contains a Hegel install (hegel.config.json + .cursor/hooks.json).
- * Returns the ancestor path if found, or null. Stops at the filesystem root.
- */
-export async function findAncestorHegelInstall(startDir, accessFn = access) {
-    const root = parse(startDir).root;
-    let current = dirname(startDir);
-    while (current && current !== root) {
-        try {
-            await accessFn(join(current, "hegel.config.json"));
-            await accessFn(join(current, ".cursor", "hooks.json"));
-            return current;
-        }
-        catch {
-            // keep walking up
-        }
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return null;
-}
+import { pathToFileURL } from "node:url";
+import { configHash } from "./hooks-generator.js";
+// Re-export shared types/utils for tests and downstream usage
+export * from "./commands/types.js";
+export * from "./utils/workspace.js";
+export * from "./utils/install.js";
+export * from "./utils/package-manager.js";
+export * from "./utils/path.js";
+// Import commands
+import { runInit } from "./commands/init.js";
+import { runUpdate } from "./commands/update.js";
+import { runCleanup } from "./commands/cleanup.js";
+import { defaultDeps } from "./commands/types.js";
+export { runUpdate, runCleanup };
 export async function runSetup(argv = process.argv, deps = defaultDeps) {
     const rest = argv.slice(2);
-    const forceFlag = rest.includes("--force");
     const positional = rest.filter((a) => !a.startsWith("--"));
-    // Subcommand dispatch. `update` is the 1.0.4 single-command refresh path
-    // for downstream projects (npm i @latest + init --force + prune orphans).
-    if (positional[0] === "update") {
+    const command = positional[0];
+    if (command === "update") {
         return runUpdate(argv, deps);
     }
-    if (positional[0] === "init" && positional[1] === "update") {
+    if (command === "cleanup") {
+        return runCleanup(argv, deps);
+    }
+    if (command === "init" && positional[1] === "update") {
         deps.error("Error: 'update' is a command, not a project path.");
         deps.error("       If your installed Hegel version does not know `update`, upgrade first:");
         deps.error("         npm install @hegel-dev/companion@latest");
         deps.error("         npx hegel-companion update .");
         return 1;
     }
-    let targetDir = positional[0];
+    let targetDir = command;
     if (targetDir === "init" && positional[1]) {
         targetDir = positional[1];
     }
-    // Catch the common typo `npx hegel-companion init init` — argv[3]==="init"
-    // was being treated as the target path, scaffolding into ./init/.
     if (targetDir === "init") {
         deps.error("Error: 'init' is not a valid project path.");
         deps.error("       Did you mean: npx hegel-companion init .");
@@ -96,6 +46,7 @@ export async function runSetup(argv = process.argv, deps = defaultDeps) {
         deps.log("  init <project-path>   Scaffold .cursor/hooks.json + register MCP + install VSIX");
         deps.log("  update [project-path] Reinstall @hegel-dev/companion@latest, refresh config,");
         deps.log("                        prune orphan dirs (default path: .)");
+        deps.log("  cleanup [project-path] Prune stale concerns and recompute session states");
         deps.log("");
         deps.log("Use '.' for the current directory. Pass --force on init to bypass safety checks.");
         deps.log("Pass --skip-npm on update to skip the dependency upgrade step.");
@@ -106,485 +57,10 @@ export async function runSetup(argv = process.argv, deps = defaultDeps) {
         deps.log(`  enableLlmAnalysis: ${config.enableLlmAnalysis}`);
         deps.log(`  timeoutSeconds:  ${config.timeoutSeconds}s`);
         deps.log(`  strictness:  ${config.strictness}`);
-        deps.log(`  observeOnly:   ${config.observeOnly}`);
         deps.log(`  configHash:  ${configHash(config)}`);
         return 1;
     }
-    const projectPath = resolve(targetDir);
-    // Refuse to nest a Hegel install inside another one. This catches e.g.
-    // `init hegel-mcp` being run from a workspace that already has Hegel set up,
-    // which would silently create an orphan .cursor/ and hegel.config.json that
-    // Cursor never reads.
-    const ancestor = await findAncestorHegelInstall(projectPath, deps.access);
-    if (ancestor && !forceFlag) {
-        deps.error(`Error: ${ancestor} already has a Hegel install.`);
-        deps.error(`       Refusing to scaffold a nested install at ${projectPath}.`);
-        deps.error(`       If this is intentional, rerun with --force.`);
-        return 1;
-    }
-    const config = await deps.loadConfig(projectPath);
-    const hooksFile = join(projectPath, ".cursor", "hooks.json");
-    const hegelRoot = deps.resolveHegelRoot();
-    // Source-repo mode: when `init` targets the Hegel repo itself, Cursor's
-    // MCP server lives at `<hegelRoot>/dist/mcp.js`, not at
-    // `node_modules/@hegel-dev/companion/dist/mcp.js`. Detect this and emit an
-    // absolute local path so running the CLI inside the source repo doesn't
-    // silently break the MCP config.
-    const isSourceRepo = resolve(projectPath) === resolve(hegelRoot);
-    // Pre-flight report: if an existing install is present, tell the user what
-    // we're about to touch before doing it. Without --force, a matching config
-    // hash makes hooks.json a no-op (see writeHooksFile); this prevents
-    // accidental rewrites that change `generatedAt` for no functional reason.
-    const existingHooks = await deps.readFile(hooksFile, "utf-8").catch(() => null);
-    if (existingHooks) {
-        deps.log(`Existing Hegel install detected at ${projectPath}.`);
-        if (isSourceRepo) {
-            deps.log("  (running against the Hegel source repo — will use local dist/ paths)");
-        }
-        if (!forceFlag) {
-            deps.log("  hooks.json will be rewritten only if the config hash differs.");
-            deps.log("  Pass --force to rewrite unconditionally.");
-        }
-    }
-    const hooksWritten = await deps.writeHooksFile(projectPath, config, forceFlag);
-    if (!hooksWritten && existingHooks) {
-        deps.log(`hooks.json is already up to date (config hash ${configHash(config)})`);
-    }
-    // Write the Hegel Companion rule
-    const rulesDir = join(projectPath, ".cursor", "rules");
-    await deps.mkdir(rulesDir, { recursive: true });
-    await deps.writeFile(join(rulesDir, "hegel-companion.mdc"), COMPANION_RULE, "utf-8");
-    // Scaffold hegel.config.json if it doesn't exist
-    const configPath = join(projectPath, "hegel.config.json");
-    try {
-        const existingConfig = await deps.readFile(configPath, "utf-8").catch(() => null);
-        if (!existingConfig) {
-            const defaultConfig = {
-                "$schema": isSourceRepo
-                    ? "./hegel.config.schema.json"
-                    : "./node_modules/@hegel-dev/companion/hegel.config.schema.json",
-                "model": "auto",
-                "enableLlmAnalysis": true,
-                "timeoutSeconds": 15,
-                "strictness": "balanced",
-                "observeOnly": true
-            };
-            await deps.writeFile(configPath, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
-            deps.log(`✅ Default hegel.config.json created`);
-        }
-    }
-    catch {
-        // Ignore
-    }
-    // Register MCP server in .cursor/mcp.json
-    const mcpConfigPath = join(projectPath, ".cursor", "mcp.json");
-    try {
-        let mcpConfig = { mcpServers: {} };
-        const existingMcp = await deps.readFile(mcpConfigPath, "utf-8").catch(() => null);
-        if (existingMcp) {
-            mcpConfig = JSON.parse(existingMcp);
-            if (!mcpConfig.mcpServers)
-                mcpConfig.mcpServers = {};
-        }
-        // We use a direct node command rather than npx because Cursor's internal
-        // MCP spawner on Windows often fails to pass environment variables or
-        // trailing arguments correctly through npx. In source-repo mode we point
-        // at the local build; in consumer mode, at the node_modules install.
-        const mcpArgs = isSourceRepo
-            ? [join(hegelRoot, "dist", "mcp.js").replace(/\\/g, "/")]
-            : ["node_modules/@hegel-dev/companion/dist/mcp.js"];
-        mcpConfig.mcpServers["hegel-mcp"] = {
-            command: "node",
-            args: mcpArgs,
-            env: {
-                "HEGEL_WORKSPACE_ROOT": projectPath
-            }
-        };
-        await deps.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
-        deps.log(`✅ MCP server registered in .cursor/mcp.json`);
-    }
-    catch {
-        deps.log("Failed to register MCP server in .cursor/mcp.json");
-    }
-    // Install the VS Code extension (or report failure loudly at the end).
-    const vscodeDir = join(hegelRoot, "hegel-vscode");
-    const extensionResult = await installVsCodeExtension(vscodeDir, deps);
-    const model = config.model === "auto" ? "Cursor default" : config.model;
-    const mode = config.observeOnly ? "observe-only (silent — full analysis, no chat intervention)" : "active (will block on concerns)";
-    deps.log("");
-    deps.log(`✅ Hegel hooks written to ${hooksFile}`);
-    deps.log(`✅ Hegel Companion Rule written to ${join(rulesDir, "hegel-companion.mdc")}`);
-    deps.log(`   Config hash: ${configHash(config)}`);
-    deps.log("");
-    deps.log(`Mode: ${mode}`);
-    deps.log("");
-    deps.log("Layers:");
-    deps.log(`  Layer 1: Rule-based analysis (command hooks) — ${config.observeOnly ? "full analysis, no chat intervention" : "blocks on warning+"}`);
-    if (config.enableLlmAnalysis) {
-        deps.log(`  Layer 2: LLM deep analysis (prompt hooks) — model: ${model} — ${config.observeOnly ? "full analysis, no chat intervention" : "blocks on concern"}`);
-    }
-    else {
-        deps.log("  Layer 2: LLM deep analysis — disabled (enableLlmAnalysis=false)");
-    }
-    if (config.observeOnly) {
-        deps.log("");
-        deps.log("  observeOnly is ON — both layers run full analysis and collect stats,");
-        deps.log("     but the user never sees intervention in the chat.");
-        deps.log("     Set observeOnly=false in hegel.config.json to enable blocking.");
-    }
-    deps.log("");
-    deps.log("Hot-reload: config changes are auto-detected on the next prompt.");
-    deps.log("            Change hegel.config.json → hooks.json is regenerated on the next");
-    deps.log("            beforeSubmitPrompt hook. Model changes on Layer 2 prompt hooks");
-    deps.log("            usually require a full Cursor restart to take effect.");
-    // Extension-install status goes at the very end of output so it is the last
-    // thing the user sees. Silent mid-flow failure (fixed in 1.0.3) had been
-    // biting users who missed the one-liner buried in init's other output.
-    if (extensionResult.status !== "installed") {
-        deps.log("");
-        deps.log("⚠️  VS Code extension was NOT installed automatically.");
-        if (extensionResult.status === "vsix-not-found") {
-            deps.log(`    Reason: ${extensionResult.reason}`);
-            deps.log("    The Hegel sidebar won't appear until a VSIX is built/installed.");
-        }
-        else if (extensionResult.status === "cursor-cli-missing") {
-            deps.log(`    Reason: ${extensionResult.reason ?? "'cursor' CLI not found on PATH"}`);
-            deps.log("    Run this from a shell where the 'cursor' command is available");
-            deps.log("    (e.g. Cursor's built-in terminal, or with Cursor on your PATH):");
-            deps.log(`      cursor --install-extension "${extensionResult.vsixPath}"`);
-            deps.log("    Then fully quit and reopen Cursor (not just Reload Window — the");
-            deps.log("    extension manifest is cached in the extension-host process).");
-        }
-        else {
-            deps.log(`    Reason: ${extensionResult.reason ?? "unknown"}`);
-            deps.log("    You can retry manually:");
-            deps.log(`      cursor --install-extension "${extensionResult.vsixPath}"`);
-            deps.log("    Then fully quit and reopen Cursor (not just Reload Window).");
-        }
-    }
-    return 0;
-}
-/**
- * Well-known absolute paths where Cursor installs the `cursor` CLI shim.
- * Returned in priority order — first existing candidate wins. We intentionally
- * probe only well-documented install locations: user-scoped first (most
- * common), then system-scoped.
- *
- * Windows candidates end in .cmd because Node's execFileSync needs the shim,
- * not the Electron binary (Cursor.exe) which would try to launch a second IDE
- * window rather than run the CLI.
- */
-export function getCursorCliCandidates(platform = process.platform, env = process.env) {
-    const candidates = [];
-    // Use platform-specific path joiners so candidate paths are correct even
-    // when the host OS differs (e.g. when Node is run under WSL, or in tests).
-    const pj = platform === "win32" ? win32Path.join : posixPath.join;
-    if (platform === "win32") {
-        const local = env.LOCALAPPDATA;
-        if (local) {
-            candidates.push(pj(local, "Programs", "cursor", "resources", "app", "bin", "cursor.cmd"));
-            candidates.push(pj(local, "Programs", "Cursor", "resources", "app", "bin", "cursor.cmd"));
-        }
-        const programFiles = env["ProgramFiles"];
-        if (programFiles) {
-            candidates.push(pj(programFiles, "Cursor", "resources", "app", "bin", "cursor.cmd"));
-        }
-    }
-    else if (platform === "darwin") {
-        candidates.push("/Applications/Cursor.app/Contents/Resources/app/bin/cursor");
-        const home = env.HOME;
-        if (home) {
-            candidates.push(pj(home, "Applications", "Cursor.app", "Contents", "Resources", "app", "bin", "cursor"));
-        }
-    }
-    else {
-        candidates.push("/usr/local/bin/cursor");
-        candidates.push("/usr/bin/cursor");
-        const home = env.HOME;
-        if (home) {
-            candidates.push(pj(home, ".local", "share", "cursor", "bin", "cursor"));
-            candidates.push(pj(home, ".cursor", "bin", "cursor"));
-        }
-    }
-    return candidates;
-}
-/**
- * Quote one argument for cmd.exe. The current call sites pass command names,
- * static flags, package names, and filesystem paths; still, centralizing the
- * quoting keeps spaces in VSIX paths and Program Files installs safe.
- */
-function quoteWindowsCmdArg(arg) {
-    return `"${arg.replace(/"/g, '\\"')}"`;
-}
-function isBareWindowsCommand(command) {
-    return !/[\\/\s]/.test(command);
-}
-/**
- * Run a command synchronously, using cmd.exe explicitly on Windows.
- *
- * Node deprecated `execFileSync(command, args, { shell: true })` because args
- * are concatenated without escaping (DEP0190). We still need cmd.exe on
- * Windows so PATHEXT resolves `npm`/`cursor` to their `.cmd` shims, but we
- * invoke it directly with one quoted command string instead of shell:true.
- */
-function execCommandSync(command, args, deps, extra = {}) {
-    const platform = deps.platform ?? process.platform;
-    if (platform !== "win32") {
-        deps.execFileSync(command, args, extra);
-        return;
-    }
-    const quotedArgs = args.map(quoteWindowsCmdArg).join(" ");
-    const commandLine = isBareWindowsCommand(command)
-        ? [command, quotedArgs].filter(Boolean).join(" ")
-        : `"${[quoteWindowsCmdArg(command), quotedArgs].filter(Boolean).join(" ")}"`;
-    const windowsOptions = {
-        ...extra,
-        windowsVerbatimArguments: true,
-    };
-    deps.execFileSync("cmd.exe", ["/d", "/s", "/c", commandLine], windowsOptions);
-}
-/**
- * Walk the candidate list and return the first one that exists on disk.
- * Used as a fallback when `execFileSync("cursor", ...)` throws ENOENT — the
- * most common failure mode for users running `npx hegel-companion init` from
- * a non-Cursor terminal (e.g. stock PowerShell/cmd without Cursor on PATH).
- */
-async function findInstalledCursorCli(candidates, accessFn) {
-    for (const candidate of candidates) {
-        try {
-            await accessFn(candidate);
-            return candidate;
-        }
-        catch {
-            // try next
-        }
-    }
-    return null;
-}
-export async function installVsCodeExtension(vscodeDir, deps) {
-    let files;
-    try {
-        files = await deps.readdir(vscodeDir);
-    }
-    catch {
-        return { status: "vsix-not-found", reason: `${vscodeDir} not readable` };
-    }
-    const vsixFile = files.find((f) => f.endsWith(".vsix"));
-    if (!vsixFile) {
-        return { status: "vsix-not-found", reason: `no .vsix file found in ${vscodeDir}` };
-    }
-    const vsixPath = join(vscodeDir, vsixFile);
-    deps.log(`Installing VS Code extension: ${vsixFile}...`);
-    // First attempt: `cursor` on PATH. This is the common case when the user
-    // runs `init` from Cursor's built-in terminal or from any shell that has
-    // Cursor's bin directory on PATH. On Windows this goes through cmd.exe so
-    // PATHEXT can resolve `cursor` to cursor.cmd.
-    try {
-        execCommandSync("cursor", ["--install-extension", vsixPath], deps, { stdio: "inherit" });
-        return { status: "installed", vsixPath };
-    }
-    catch (err) {
-        const errno = err?.code;
-        if (errno !== "ENOENT") {
-            // Non-ENOENT means `cursor` was found but rejected the install — no
-            // point retrying with an absolute path, the error is genuine.
-            const message = err instanceof Error ? err.message : String(err);
-            return { status: "install-failed", vsixPath, reason: message };
-        }
-    }
-    // Second attempt: auto-discovered absolute path. Eliminates the manual
-    // "please run from Cursor's built-in terminal" workaround for users whose
-    // shell simply doesn't have Cursor on PATH.
-    const candidates = getCursorCliCandidates(deps.platform, deps.env);
-    const discovered = await findInstalledCursorCli(candidates, deps.access);
-    if (!discovered) {
-        return {
-            status: "cursor-cli-missing",
-            vsixPath,
-            reason: `'cursor' CLI not found on PATH and no install detected at known locations (${candidates.length} path${candidates.length === 1 ? "" : "s"} checked)`,
-        };
-    }
-    deps.log(`  'cursor' not on PATH — found install at ${discovered}, retrying...`);
-    try {
-        execCommandSync(discovered, ["--install-extension", vsixPath], deps, { stdio: "inherit" });
-        return { status: "installed", vsixPath, usedCursorPath: discovered };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { status: "install-failed", vsixPath, reason: `retry via ${discovered} failed: ${message}` };
-    }
-}
-/**
- * Marker filenames inside an orphan dir that indicate it was once a Hegel
- * install (created by a CLI mistake like `init hegel-mcp` or `init init`).
- * Pruning is gated on at least one of these existing — never blindly removes
- * a directory that happens to be named `init` or `hegel-mcp`.
- */
-const ORPHAN_DIR_NAMES = ["hegel-mcp", "init"];
-const ORPHAN_MARKER_PATHS = ["hegel.config.json", join(".cursor", "hooks.json")];
-/**
- * Removes orphan Hegel installs left behind by past CLI mistakes
- * (`init hegel-mcp`, `init init`). Only removes a candidate dir if it
- * contains a Hegel marker file — never deletes user code directories that
- * happen to share the name.
- */
-export async function pruneOrphanInstalls(projectPath, deps) {
-    const result = { pruned: [], skipped: [] };
-    for (const name of ORPHAN_DIR_NAMES) {
-        const dir = join(projectPath, name);
-        try {
-            await deps.access(dir);
-        }
-        catch {
-            continue;
-        }
-        let hasMarker = false;
-        for (const marker of ORPHAN_MARKER_PATHS) {
-            try {
-                await deps.access(join(dir, marker));
-                hasMarker = true;
-                break;
-            }
-            catch {
-                // try next marker
-            }
-        }
-        if (!hasMarker) {
-            result.skipped.push({ path: dir, reason: "no Hegel marker file detected (kept)" });
-            continue;
-        }
-        try {
-            await deps.rm(dir, { recursive: true, force: true });
-            result.pruned.push(dir);
-            deps.log(`  Pruned orphan install at ${dir}`);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            result.skipped.push({ path: dir, reason: `rm failed: ${message}` });
-            deps.log(`  Could not prune ${dir}: ${message}`);
-        }
-    }
-    return result;
-}
-/**
- * Reads the version of @hegel-dev/companion from the consumer's
- * node_modules/, returning null if not installed (e.g. source-repo mode).
- */
-export async function readInstalledCompanionVersion(projectPath, readFileFn = readFile) {
-    try {
-        const pkgPath = join(projectPath, "node_modules", "@hegel-dev", "companion", "package.json");
-        const contents = await readFileFn(pkgPath, "utf-8");
-        const parsed = JSON.parse(contents);
-        return typeof parsed.version === "string" ? parsed.version : null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * `update` subcommand. Single-step refresh path for downstream projects:
- *   1. Refuses if no Hegel install present (hint to use `init`).
- *   2. Detects source-repo mode and skips npm install in that case.
- *   3. Runs `npm install @hegel-dev/companion@latest` (skippable via --skip-npm).
- *   4. Re-runs setup with --force so hooks.json regenerates, MCP re-registers,
- *      and the bundled VSIX is reinstalled (with 1.0.4 auto-discovery).
- *   5. Prunes orphan `hegel-mcp/` and `init/` directories left over from past
- *      CLI mistakes (only when those dirs contain a Hegel marker file).
- *   6. Prints the new installed version + the Cursor full-quit reminder.
- */
-export async function runUpdate(argv = process.argv, deps = defaultDeps) {
-    const rest = argv.slice(2);
-    const positional = rest.filter((a) => !a.startsWith("--"));
-    // positional[0] === "update"; positional[1] is the optional path
-    const targetDir = positional[1] ?? ".";
-    const skipNpm = rest.includes("--skip-npm");
-    const projectPath = resolve(targetDir);
-    // Step 1: sanity check — must be an existing Hegel install.
-    const hasConfig = await deps.access(join(projectPath, "hegel.config.json")).then(() => true).catch(() => false);
-    const hasHooks = await deps.access(join(projectPath, ".cursor", "hooks.json")).then(() => true).catch(() => false);
-    if (!hasConfig && !hasHooks) {
-        deps.error(`Error: no Hegel install detected at ${projectPath}.`);
-        deps.error(`       Run 'npx hegel-companion init ${targetDir}' first.`);
-        return 1;
-    }
-    deps.log(`Updating Hegel install at ${projectPath}`);
-    deps.log("");
-    // Step 2: source-repo detection. Running `update` against the Hegel source
-    // repo itself must NOT npm-install the package (would clobber the live
-    // dev tree); just refresh hooks via init --force.
-    const hegelRoot = deps.resolveHegelRoot();
-    const isSourceRepo = resolve(projectPath) === resolve(hegelRoot);
-    const beforeVersion = await readInstalledCompanionVersion(projectPath, deps.readFile);
-    // Step 3: npm install @hegel-dev/companion@latest
-    if (isSourceRepo) {
-        deps.log("Source-repo mode detected — skipping `npm install @hegel-dev/companion@latest`.");
-        deps.log("");
-    }
-    else if (skipNpm) {
-        deps.log("--skip-npm passed — skipping dependency upgrade.");
-        deps.log("");
-    }
-    else {
-        deps.log("Running: npm install @hegel-dev/companion@latest");
-        try {
-            // Windows ships npm as npm.cmd/npm.ps1; execFileSync won't launch those
-            // directly. execCommandSync uses cmd.exe on Windows so PATHEXT resolution
-            // matches the user's interactive shell without relying on shell:true.
-            execCommandSync("npm", ["install", "@hegel-dev/companion@latest"], deps, { stdio: "inherit", cwd: projectPath });
-        }
-        catch (err) {
-            const errno = err?.code;
-            if (errno === "ENOENT") {
-                deps.error("Error: 'npm' not found on PATH.");
-                deps.error("       Install Node.js (which bundles npm) and rerun, or pass --skip-npm");
-                deps.error("       to refresh hooks/VSIX without touching dependencies.");
-                return 1;
-            }
-            const message = err instanceof Error ? err.message : String(err);
-            deps.error(`Error: npm install failed: ${message}`);
-            return 1;
-        }
-        deps.log("");
-    }
-    // Step 4: re-run setup with --force in the same process. Logs are
-    // re-emitted by runSetup itself, so the user sees a continuous stream.
-    const setupArgv = ["node", argv[1] ?? "setup.js", projectPath, "--force"];
-    const setupExit = await runSetup(setupArgv, deps);
-    if (setupExit !== 0) {
-        deps.error(`Error: setup re-run failed with exit code ${setupExit}.`);
-        return setupExit;
-    }
-    // Step 5: prune orphan installs.
-    deps.log("");
-    deps.log("Checking for orphan Hegel directories...");
-    const prune = await pruneOrphanInstalls(projectPath, deps);
-    if (prune.pruned.length === 0 && prune.skipped.length === 0) {
-        deps.log("  No orphans found.");
-    }
-    // Step 6: report the final installed version.
-    deps.log("");
-    const afterVersion = await readInstalledCompanionVersion(projectPath, deps.readFile);
-    if (afterVersion) {
-        if (beforeVersion && beforeVersion !== afterVersion) {
-            deps.log(`✅ Updated @hegel-dev/companion: ${beforeVersion} → ${afterVersion}`);
-        }
-        else if (beforeVersion === afterVersion) {
-            deps.log(`✅ @hegel-dev/companion ${afterVersion} (already at latest — refreshed hooks + VSIX)`);
-        }
-        else {
-            deps.log(`✅ @hegel-dev/companion ${afterVersion} installed.`);
-        }
-    }
-    else if (isSourceRepo) {
-        deps.log("✅ Source-repo update complete (no node_modules version to report).");
-    }
-    else {
-        deps.log("✅ Update complete (could not read installed version from node_modules).");
-    }
-    deps.log("");
-    deps.log("Reminder: fully quit and reopen Cursor (not just Reload Window) so the");
-    deps.log("          updated VSIX manifest is picked up by the extension host.");
-    return 0;
+    return runInit(argv, deps);
 }
 function isEntrypoint() {
     return !process.env.VITEST &&
@@ -592,7 +68,7 @@ function isEntrypoint() {
         import.meta.url === pathToFileURL(process.argv[1]).href;
 }
 if (isEntrypoint()) {
-    runSetup().then((exitCode) => {
+    runSetup(process.argv, defaultDeps).then((exitCode) => {
         if (exitCode !== 0)
             process.exit(exitCode);
     }).catch((err) => {