context-mode 0.9.22 → 1.0.1

package/build/cli.js

@@ -3,30 +3,70 @@
  * context-mode CLI
  *
  * Usage:
- *   context-mode          → Start MCP server (stdio)
- *   context-mode setup    → Interactive setup (detect runtimes, install Bun)
- *   context-mode doctor   → Diagnose runtime issues, hooks, FTS5, version
- *   context-mode upgrade  → Fix hooks, permissions, and settings
- *   context-mode stats    → (skill only — /context-mode:ctx-stats)
+ *   context-mode                              → Start MCP server (stdio)
+ *   context-mode doctor                       → Diagnose runtime issues, hooks, FTS5, version
+ *   context-mode upgrade                      → Fix hooks, permissions, and settings
+ *   context-mode hook <platform> <event>      → Dispatch a hook script (used by platform hook configs)
+ *
+ * Platform auto-detection: CLI detects which platform is running
+ * (Claude Code, Gemini CLI, OpenCode, etc.) and uses the appropriate adapter.
  */
 import * as p from "@clack/prompts";
 import color from "picocolors";
 import { execSync } from "node:child_process";
-import { readFileSync, writeFileSync, copyFileSync, cpSync, chmodSync, accessSync, readdirSync, rmSync, constants } from "node:fs";
-import { resolve, dirname } from "node:path";
+import { readFileSync, cpSync, accessSync, readdirSync, rmSync, constants } from "node:fs";
+import { resolve, dirname, join } from "node:path";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { homedir } from "node:os";
 import { detectRuntimes, getRuntimeSummary, hasBunRuntime, getAvailableLanguages, } from "./runtime.js";
-const args = process.argv.slice(2);
-if (args[0] === "setup") {
-    setup();
+// ── Adapter imports ──────────────────────────────────────
+import { detectPlatform, getAdapter } from "./adapters/detect.js";
+/* -------------------------------------------------------
+ * Hook dispatcher — `context-mode hook <platform> <event>`
+ * ------------------------------------------------------- */
+const HOOK_MAP = {
+    "claude-code": {
+        pretooluse: "hooks/pretooluse.mjs",
+        posttooluse: "hooks/posttooluse.mjs",
+        precompact: "hooks/precompact.mjs",
+        sessionstart: "hooks/sessionstart.mjs",
+        userpromptsubmit: "hooks/userpromptsubmit.mjs",
+    },
+    "gemini-cli": {
+        beforetool: "hooks/gemini-cli/beforetool.mjs",
+        aftertool: "hooks/gemini-cli/aftertool.mjs",
+        precompress: "hooks/gemini-cli/precompress.mjs",
+        sessionstart: "hooks/gemini-cli/sessionstart.mjs",
+    },
+    "vscode-copilot": {
+        pretooluse: "hooks/vscode-copilot/pretooluse.mjs",
+        posttooluse: "hooks/vscode-copilot/posttooluse.mjs",
+        precompact: "hooks/vscode-copilot/precompact.mjs",
+        sessionstart: "hooks/vscode-copilot/sessionstart.mjs",
+    },
+};
+async function hookDispatch(platform, event) {
+    const scriptPath = HOOK_MAP[platform]?.[event];
+    if (!scriptPath) {
+        console.error(`Unknown hook: ${platform}/${event}`);
+        process.exit(1);
+    }
+    const pluginRoot = getPluginRoot();
+    await import(join(pluginRoot, scriptPath));
 }
-else if (args[0] === "doctor") {
+/* -------------------------------------------------------
+ * Entry point
+ * ------------------------------------------------------- */
+const args = process.argv.slice(2);
+if (args[0] === "doctor") {
     doctor().then((code) => process.exit(code));
 }
 else if (args[0] === "upgrade") {
     upgrade();
 }
+else if (args[0] === "hook") {
+    hookDispatch(args[1], args[2]);
+}
 else {
     // Default: start MCP server
     import("./server.js");
@@ -43,21 +83,6 @@ function getPluginRoot() {
     const __dirname = dirname(__filename);
     return resolve(__dirname, "..");
 }
-function getSettingsPath() {
-    return resolve(homedir(), ".claude", "settings.json");
-}
-function readSettings() {
-    try {
-        const raw = readFileSync(getSettingsPath(), "utf-8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-function getHookScriptPath() {
-    return resolve(getPluginRoot(), "hooks", "pretooluse.mjs");
-}
 function getLocalVersion() {
     try {
         const pkg = JSON.parse(readFileSync(resolve(getPluginRoot(), "package.json"), "utf-8"));
@@ -79,71 +104,18 @@ async function fetchLatestVersion() {
         return "unknown";
     }
 }
-function getMarketplaceVersion() {
-    // Primary: read from installed_plugins.json (source of truth for Claude Code)
-    try {
-        const ipPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
-        const ipRaw = JSON.parse(readFileSync(ipPath, "utf-8"));
-        const plugins = ipRaw.plugins ?? {};
-        for (const [key, entries] of Object.entries(plugins)) {
-            if (!key.toLowerCase().includes("context-mode"))
-                continue;
-            const arr = entries;
-            if (arr.length > 0 && typeof arr[0].version === "string") {
-                return arr[0].version;
-            }
-        }
-    }
-    catch { /* fallback below */ }
-    // Fallback: read from own package.json
-    const localVer = getLocalVersion();
-    if (localVer !== "unknown")
-        return localVer;
-    // Last resort: scan common plugin cache locations
-    const bases = [
-        resolve(homedir(), ".claude"),
-        resolve(homedir(), ".config", "claude"),
-    ];
-    for (const base of bases) {
-        const cacheDir = resolve(base, "plugins", "cache", "claude-context-mode", "context-mode");
-        try {
-            const entries = readdirSync(cacheDir);
-            const versions = entries
-                .filter((e) => /^\d+\.\d+\.\d+/.test(e))
-                .sort((a, b) => {
-                const pa = a.split(".").map(Number);
-                const pb = b.split(".").map(Number);
-                for (let i = 0; i < 3; i++) {
-                    if ((pa[i] ?? 0) !== (pb[i] ?? 0))
-                        return (pa[i] ?? 0) - (pb[i] ?? 0);
-                }
-                return 0;
-            });
-            if (versions.length > 0)
-                return versions[versions.length - 1];
-        }
-        catch { /* continue */ }
-    }
-    return "not installed";
-}
-function semverGt(a, b) {
-    const pa = a.split(".").map(Number);
-    const pb = b.split(".").map(Number);
-    for (let i = 0; i < 3; i++) {
-        if ((pa[i] ?? 0) > (pb[i] ?? 0))
-            return true;
-        if ((pa[i] ?? 0) < (pb[i] ?? 0))
-            return false;
-    }
-    return false;
-}
 /* -------------------------------------------------------
- * Doctor
+ * Doctor — adapter-aware diagnostics
  * ------------------------------------------------------- */
 async function doctor() {
     if (process.stdout.isTTY)
         console.clear();
+    // Detect platform
+    const detection = detectPlatform();
+    const adapter = await getAdapter(detection.platform);
     p.intro(color.bgMagenta(color.white(" context-mode doctor ")));
+    p.log.info(`Platform: ${color.cyan(adapter.name)}` +
+        color.dim(` (${detection.confidence} confidence — ${detection.reason})`));
     let criticalFails = 0;
     const s = p.spinner();
     s.start("Running diagnostics");
@@ -156,7 +128,7 @@ async function doctor() {
     catch {
         s.stop("Diagnostics partial");
         p.log.warn(color.yellow("Could not detect runtimes") + color.dim(" — module may be missing, restart session after upgrade"));
-        p.outro(color.yellow("Doctor could not fully run — try again after restarting Claude Code"));
+        p.outro(color.yellow("Doctor could not fully run — try again after restarting"));
         return 1;
     }
     s.stop("Diagnostics complete");
@@ -212,55 +184,23 @@ async function doctor() {
             p.log.error(color.red("Server test: FAIL") + ` — ${message}`);
         }
     }
-    // Hooks installed
-    p.log.step("Checking hooks configuration...");
-    const settings = readSettings();
-    const hookScriptPath = getHookScriptPath();
-    if (settings) {
-        const hooks = settings.hooks;
-        const preToolUse = hooks?.PreToolUse;
-        if (preToolUse && preToolUse.length > 0) {
-            const hasCorrectHook = preToolUse.some((entry) => entry.hooks?.some((h) => h.command?.includes("pretooluse.mjs")));
-            if (hasCorrectHook) {
-                p.log.success(color.green("Hooks installed: PASS") + " — PreToolUse hook configured");
-            }
-            else {
-                p.log.error(color.red("Hooks installed: FAIL") +
-                    " — PreToolUse exists but does not point to pretooluse.mjs" +
-                    color.dim("\n  Run: npx context-mode upgrade"));
-            }
+    // Hooks — adapter-aware validation
+    p.log.step(`Checking ${adapter.name} hooks configuration...`);
+    const pluginRoot = getPluginRoot();
+    const hookResults = adapter.validateHooks(pluginRoot);
+    for (const result of hookResults) {
+        if (result.status === "pass") {
+            p.log.success(color.green(`${result.check}: PASS`) + ` — ${result.message}`);
         }
         else {
-            p.log.error(color.red("Hooks installed: FAIL") +
-                " — No PreToolUse hooks found" +
-                color.dim("\n  Run: npx context-mode upgrade"));
-        }
-        // Check SessionStart hook
-        const sessionStart = hooks?.SessionStart;
-        if (sessionStart && sessionStart.length > 0) {
-            const hasSessionHook = sessionStart.some((entry) => entry.hooks?.some((h) => h.command?.includes("sessionstart.mjs")));
-            if (hasSessionHook) {
-                p.log.success(color.green("SessionStart hook: PASS") + " — SessionStart hook configured");
-            }
-            else {
-                p.log.error(color.red("SessionStart hook: FAIL") +
-                    " — SessionStart exists but does not point to sessionstart.mjs" +
-                    color.dim("\n  Run: npx context-mode upgrade"));
-            }
-        }
-        else {
-            p.log.error(color.red("SessionStart hook: FAIL") +
-                " — No SessionStart hooks found" +
-                color.dim("\n  Run: npx context-mode upgrade"));
+            p.log.error(color.red(`${result.check}: FAIL`) +
+                ` — ${result.message}` +
+                (result.fix ? color.dim(`\n  Run: ${result.fix}`) : ""));
         }
     }
-    else {
-        p.log.error(color.red("Hooks installed: FAIL") +
-            " — Could not read ~/.claude/settings.json" +
-            color.dim("\n  Run: npx context-mode upgrade"));
-    }
     // Hook script exists
     p.log.step("Checking hook script...");
+    const hookScriptPath = resolve(pluginRoot, "hooks", "pretooluse.mjs");
     try {
         accessSync(hookScriptPath, constants.R_OK);
         p.log.success(color.green("Hook script exists: PASS") + color.dim(` — ${hookScriptPath}`));
@@ -269,30 +209,15 @@ async function doctor() {
         p.log.error(color.red("Hook script exists: FAIL") +
             color.dim(` — not found at ${hookScriptPath}`));
     }
-    // Plugin enabled
-    p.log.step("Checking plugin registration...");
-    if (settings) {
-        const enabledPlugins = settings.enabledPlugins;
-        if (enabledPlugins) {
-            const pluginKey = Object.keys(enabledPlugins).find((k) => k.startsWith("context-mode"));
-            if (pluginKey && enabledPlugins[pluginKey]) {
-                p.log.success(color.green("Plugin enabled: PASS") + color.dim(` — ${pluginKey}`));
-            }
-            else {
-                p.log.warn(color.yellow("Plugin enabled: WARN") +
-                    " — context-mode not in enabledPlugins" +
-                    color.dim(" (might be using standalone MCP mode)"));
-            }
-        }
-        else {
-            p.log.warn(color.yellow("Plugin enabled: WARN") +
-                " — no enabledPlugins section found" +
-                color.dim(" (might be using standalone MCP mode)"));
-        }
+    // Plugin registration — adapter-aware
+    p.log.step(`Checking ${adapter.name} plugin registration...`);
+    const pluginCheck = adapter.checkPluginRegistration();
+    if (pluginCheck.status === "pass") {
+        p.log.success(color.green("Plugin enabled: PASS") + color.dim(` — ${pluginCheck.message}`));
     }
     else {
         p.log.warn(color.yellow("Plugin enabled: WARN") +
-            " — could not read settings.json");
+            ` — ${pluginCheck.message}`);
     }
     // FTS5 / better-sqlite3
     p.log.step("Checking FTS5 / better-sqlite3...");
@@ -323,12 +248,11 @@ async function doctor() {
                 color.dim("\n  Try: npm rebuild better-sqlite3"));
         }
     }
-    // Version check
+    // Version check — adapter-aware
     p.log.step("Checking versions...");
     const localVersion = getLocalVersion();
     const latestVersion = await fetchLatestVersion();
-    const marketplaceVersion = getMarketplaceVersion();
-    // npm / MCP version
+    const installedVersion = adapter.getInstalledVersion();
     if (latestVersion === "unknown") {
         p.log.warn(color.yellow("npm (MCP): WARN") +
             ` — local v${localVersion}, could not reach npm registry`);
@@ -342,22 +266,21 @@ async function doctor() {
             ` — local v${localVersion}, latest v${latestVersion}` +
             color.dim("\n  Run: /context-mode:ctx-upgrade"));
     }
-    // Marketplace version
-    if (marketplaceVersion === "not installed") {
-        p.log.info(color.dim("Marketplace: not installed") +
+    if (installedVersion === "not installed") {
+        p.log.info(color.dim(`${adapter.name}: not installed`) +
             " — using standalone MCP mode");
     }
-    else if (latestVersion !== "unknown" && marketplaceVersion === latestVersion) {
-        p.log.success(color.green("Marketplace: PASS") +
-            ` — v${marketplaceVersion}`);
+    else if (latestVersion !== "unknown" && installedVersion === latestVersion) {
+        p.log.success(color.green(`${adapter.name}: PASS`) +
+            ` — v${installedVersion}`);
     }
     else if (latestVersion !== "unknown") {
-        p.log.warn(color.yellow("Marketplace: WARN") +
-            ` — v${marketplaceVersion}, latest v${latestVersion}` +
+        p.log.warn(color.yellow(`${adapter.name}: WARN`) +
+            ` — v${installedVersion}, latest v${latestVersion}` +
             color.dim("\n  Run: /context-mode:ctx-upgrade"));
     }
     else {
-        p.log.info(`Marketplace: v${marketplaceVersion}` +
+        p.log.info(`${adapter.name}: v${installedVersion}` +
             color.dim(" — could not verify against npm registry"));
     }
     // Summary
@@ -371,26 +294,29 @@ async function doctor() {
     return 0;
 }
 /* -------------------------------------------------------
- * Upgrade
+ * Upgrade — adapter-aware hook configuration
  * ------------------------------------------------------- */
 async function upgrade() {
     if (process.stdout.isTTY)
         console.clear();
+    // Detect platform
+    const detection = detectPlatform();
+    const adapter = await getAdapter(detection.platform);
     p.intro(color.bgCyan(color.black(" context-mode upgrade ")));
+    p.log.info(`Platform: ${color.cyan(adapter.name)}` +
+        color.dim(` (${detection.confidence} confidence)`));
     let pluginRoot = getPluginRoot();
-    const settingsPath = getSettingsPath();
     const changes = [];
     const s = p.spinner();
-    // Step 1: Pull latest from GitHub (same source as marketplace)
+    // Step 1: Pull latest from GitHub
     p.log.step("Pulling latest from GitHub...");
     const localVersion = getLocalVersion();
-    const tmpDir = `/tmp/context-mode-upgrade-${Date.now()}`;
-    s.start("Cloning mksglu/claude-context-mode");
+    const tmpDir = join(tmpdir(), `context-mode-upgrade-${Date.now()}`);
+    s.start("Cloning mksglu/context-mode");
     try {
-        execSync(`git clone --depth 1 https://github.com/mksglu/claude-context-mode.git "${tmpDir}"`, { stdio: "pipe", timeout: 30000 });
+        execSync(`git clone --depth 1 https://github.com/mksglu/context-mode.git "${tmpDir}"`, { stdio: "pipe", timeout: 30000 });
         s.stop("Downloaded");
         const srcDir = tmpDir;
-        // Read new version
         const newPkg = JSON.parse(readFileSync(resolve(srcDir, "package.json"), "utf-8"));
         const newVersion = newPkg.version ?? "unknown";
         if (newVersion === localVersion) {
@@ -412,9 +338,8 @@ async function upgrade() {
             timeout: 30000,
         });
         s.stop("Built successfully");
-        // Step 3: Update in-place (same directory, no registry changes needed)
+        // Step 3: Update in-place
         s.start("Updating files in-place");
-        // Clean stale version dirs from previous upgrade attempts
         const cacheParentMatch = pluginRoot.match(/^(.*[\\/]plugins[\\/]cache[\\/][^\\/]+[\\/][^\\/]+[\\/])/);
         if (cacheParentMatch) {
             const cacheParent = cacheParentMatch[1];
@@ -433,7 +358,6 @@ async function upgrade() {
             }
             catch { /* parent may not exist */ }
         }
-        // Copy new files over old ones — same path, no registry update needed
         const items = [
             "build", "src", "hooks", "skills", ".claude-plugin",
             "start.mjs", "server.bundle.mjs", "package.json", ".mcp.json",
@@ -446,24 +370,10 @@ async function upgrade() {
             catch { /* some files may not exist in source */ }
         }
         s.stop(color.green(`Updated in-place to v${newVersion}`));
-        // Fix registry to point back to this pluginRoot (self-heal may have changed it)
-        try {
-            const ipPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
-            const ipRaw = JSON.parse(readFileSync(ipPath, "utf-8"));
-            for (const [key, entries] of Object.entries(ipRaw.plugins || {})) {
-                if (!key.toLowerCase().includes("context-mode"))
-                    continue;
-                for (const entry of entries) {
-                    entry.installPath = pluginRoot;
-                    entry.version = newVersion;
-                    entry.lastUpdated = new Date().toISOString();
-                }
-            }
-            writeFileSync(ipPath, JSON.stringify(ipRaw, null, 2) + "\n", "utf-8");
-            p.log.info(color.dim("  Registry synced to " + pluginRoot));
-        }
-        catch { /* best effort */ }
-        // Install production deps (rebuild native modules if needed)
+        // Fix registry — adapter-aware
+        adapter.updatePluginRegistry(pluginRoot, newVersion);
+        p.log.info(color.dim("  Registry synced to " + pluginRoot));
+        // Install production deps
         s.start("Installing production dependencies");
         execSync("npm install --production --no-audit --no-fund", {
             cwd: pluginRoot,
@@ -471,10 +381,10 @@ async function upgrade() {
             timeout: 60000,
         });
         s.stop("Dependencies ready");
-        // Update global npm package from same GitHub source
+        // Update global npm
         s.start("Updating npm global package");
         try {
-            execSync(`npm install -g "${pluginRoot}" --no-audit --no-fund 2>/dev/null`, {
+            execSync(`npm install -g "${pluginRoot}" --no-audit --no-fund`, {
                 stdio: "pipe",
                 timeout: 30000,
             });
@@ -498,120 +408,40 @@ async function upgrade() {
         s.stop(color.red("Update failed"));
         p.log.error(color.red("GitHub pull failed") + ` — ${message}`);
         p.log.info(color.dim("Continuing with hooks/settings fix..."));
-        // Cleanup on failure
         try {
             rmSync(tmpDir, { recursive: true, force: true });
         }
         catch { /* ignore */ }
     }
-    // Step 3: Backup settings.json
-    p.log.step("Backing up settings.json...");
-    try {
-        accessSync(settingsPath, constants.R_OK);
-        const backupPath = settingsPath + ".bak";
-        copyFileSync(settingsPath, backupPath);
+    // Step 3: Backup settings — adapter-aware
+    p.log.step(`Backing up ${adapter.name} settings...`);
+    const backupPath = adapter.backupSettings();
+    if (backupPath) {
         p.log.success(color.green("Backup created") + color.dim(" -> " + backupPath));
-        changes.push("Backed up settings.json");
-    }
-    catch {
-        p.log.warn(color.yellow("No existing settings.json to backup") +
-            " — a new one will be created");
-    }
-    // Step 4: Fix hooks
-    p.log.step("Configuring PreToolUse hooks...");
-    const hookScriptPath = toUnixPath(resolve(pluginRoot, "hooks", "pretooluse.mjs"));
-    const settings = readSettings() ?? {};
-    const desiredHookEntry = {
-        matcher: "Bash|Read|Grep|WebFetch|Task|mcp__plugin_context-mode_context-mode__execute|mcp__plugin_context-mode_context-mode__execute_file|mcp__plugin_context-mode_context-mode__batch_execute",
-        hooks: [
-            {
-                type: "command",
-                command: "node " + hookScriptPath,
-            },
-        ],
-    };
-    const hooks = (settings.hooks ?? {});
-    const existingPreToolUse = hooks.PreToolUse;
-    if (existingPreToolUse && Array.isArray(existingPreToolUse)) {
-        const existingIdx = existingPreToolUse.findIndex((entry) => {
-            const entryHooks = entry.hooks;
-            return entryHooks?.some((h) => h.command?.includes("pretooluse.mjs"));
-        });
-        if (existingIdx >= 0) {
-            existingPreToolUse[existingIdx] = desiredHookEntry;
-            p.log.info(color.dim("Updated existing PreToolUse hook entry"));
-            changes.push("Updated existing PreToolUse hook entry");
-        }
-        else {
-            existingPreToolUse.push(desiredHookEntry);
-            p.log.info(color.dim("Added PreToolUse hook entry"));
-            changes.push("Added PreToolUse hook entry to existing hooks");
-        }
-        hooks.PreToolUse = existingPreToolUse;
+        changes.push("Backed up settings");
     }
     else {
-        hooks.PreToolUse = [desiredHookEntry];
-        p.log.info(color.dim("Created PreToolUse hooks section"));
-        changes.push("Created PreToolUse hooks section");
-    }
-    // --- SessionStart hook ---
-    p.log.step("Configuring SessionStart hook...");
-    const sessionHookScriptPath = resolve(pluginRoot, "hooks", "sessionstart.mjs");
-    const desiredSessionHookEntry = {
-        matcher: "",
-        hooks: [
-            {
-                type: "command",
-                command: "node " + sessionHookScriptPath,
-            },
-        ],
-    };
-    const existingSessionStart = hooks.SessionStart;
-    if (existingSessionStart && Array.isArray(existingSessionStart)) {
-        const existingSessionIdx = existingSessionStart.findIndex((entry) => {
-            const entryHooks = entry.hooks;
-            return entryHooks?.some((h) => h.command?.includes("sessionstart.mjs"));
-        });
-        if (existingSessionIdx >= 0) {
-            existingSessionStart[existingSessionIdx] = desiredSessionHookEntry;
-            p.log.info(color.dim("Updated existing SessionStart hook entry"));
-            changes.push("Updated existing SessionStart hook entry");
-        }
-        else {
-            existingSessionStart.push(desiredSessionHookEntry);
-            p.log.info(color.dim("Added SessionStart hook entry"));
-            changes.push("Added SessionStart hook entry to existing hooks");
-        }
-        hooks.SessionStart = existingSessionStart;
-    }
-    else {
-        hooks.SessionStart = [desiredSessionHookEntry];
-        p.log.info(color.dim("Created SessionStart hooks section"));
-        changes.push("Created SessionStart hooks section");
+        p.log.warn(color.yellow("No existing settings to backup") +
+            " — a new one will be created");
     }
-    settings.hooks = hooks;
-    // Write updated settings
-    try {
-        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-        p.log.success(color.green("Hooks configured") + color.dim(" -> " + settingsPath));
+    // Step 4: Configure hooks — adapter-aware
+    p.log.step(`Configuring ${adapter.name} hooks...`);
+    const hookChanges = adapter.configureAllHooks(pluginRoot);
+    for (const change of hookChanges) {
+        p.log.info(color.dim(`  ${change}`));
+        changes.push(change);
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        p.log.error(color.red("Failed to write settings.json") + " — " + message);
-        p.outro(color.red("Upgrade failed."));
-        process.exit(1);
-    }
-    // Step 5: Set hook script permissions
+    p.log.success(color.green("Hooks configured") + color.dim(` — ${adapter.name}`));
+    // Step 5: Set hook script permissions — adapter-aware
     p.log.step("Setting hook script permissions...");
-    try {
-        accessSync(hookScriptPath, constants.R_OK);
-        chmodSync(hookScriptPath, 0o755);
-        p.log.success(color.green("Permissions set") + color.dim(" — chmod +x " + hookScriptPath));
-        changes.push("Set pretooluse.mjs as executable");
+    const permSet = adapter.setHookPermissions(pluginRoot);
+    if (permSet.length > 0) {
+        p.log.success(color.green("Permissions set") + color.dim(` — ${permSet.length} hook script(s)`));
+        changes.push(`Set ${permSet.length} hook scripts as executable`);
     }
-    catch {
-        p.log.error(color.red("Hook script not found") +
-            color.dim(" — expected at " + hookScriptPath));
+    else {
+        p.log.error(color.red("No hook scripts found") +
+            color.dim(" — expected in " + resolve(pluginRoot, "hooks")));
     }
     // Step 6: Report
     if (changes.length > 0) {
@@ -620,7 +450,7 @@ async function upgrade() {
     else {
         p.log.info(color.dim("No changes were needed."));
     }
-    // Step 7: Run doctor from updated pluginRoot
+    // Step 7: Run doctor
     p.log.step("Running doctor to verify...");
     console.log();
     try {
@@ -632,130 +462,6 @@ async function upgrade() {
     }
     catch {
         p.log.warn(color.yellow("Doctor had warnings") +
-            color.dim(" — restart your Claude Code session to pick up the new version"));
-    }
-}
-/* -------------------------------------------------------
- * Setup
- * ------------------------------------------------------- */
-async function setup() {
-    if (process.stdout.isTTY)
-        console.clear();
-    p.intro(color.bgCyan(color.black(" context-mode setup ")));
-    const s = p.spinner();
-    // Step 1: Detect runtimes
-    s.start("Detecting installed runtimes");
-    const runtimes = detectRuntimes();
-    const available = getAvailableLanguages(runtimes);
-    s.stop("Detected " + available.length + " languages");
-    // Show what's available
-    p.note(getRuntimeSummary(runtimes), "Detected Runtimes");
-    // Step 2: Check Bun
-    if (!hasBunRuntime()) {
-        p.log.warn(color.yellow("Bun is not installed.") +
-            " JS/TS will run with Node.js (3-5x slower).");
-        const installBun = await p.confirm({
-            message: "Would you like to install Bun for faster execution?",
-            initialValue: true,
-        });
-        if (p.isCancel(installBun)) {
-            p.cancel("Setup cancelled.");
-            process.exit(0);
-        }
-        if (installBun) {
-            s.start("Installing Bun");
-            try {
-                execSync("curl -fsSL https://bun.sh/install | bash", {
-                    stdio: "pipe",
-                    timeout: 60000,
-                });
-                s.stop(color.green("Bun installed successfully!"));
-                // Re-detect runtimes
-                const newRuntimes = detectRuntimes();
-                if (hasBunRuntime()) {
-                    p.log.success("JavaScript and TypeScript will now use Bun " +
-                        color.dim("(3-5x faster)"));
-                }
-                p.note(getRuntimeSummary(newRuntimes), "Updated Runtimes");
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                s.stop(color.red("Failed to install Bun"));
-                p.log.error("Installation failed: " +
-                    message +
-                    "\nYou can install manually: curl -fsSL https://bun.sh/install | bash");
-                p.log.info(color.dim("Continuing with Node.js — everything will still work."));
-            }
-        }
-        else {
-            p.log.info(color.dim("No problem! Using Node.js. You can install Bun later: curl -fsSL https://bun.sh/install | bash"));
-        }
-    }
-    else {
-        p.log.success(color.green("Bun detected!") +
-            " JS/TS will run at maximum speed.");
-    }
-    // Step 3: Check optional runtimes
-    const missing = [];
-    if (!runtimes.python)
-        missing.push("Python (python3)");
-    if (!runtimes.ruby)
-        missing.push("Ruby (ruby)");
-    if (!runtimes.go)
-        missing.push("Go (go)");
-    if (!runtimes.php)
-        missing.push("PHP (php)");
-    if (!runtimes.r)
-        missing.push("R (Rscript)");
-    if (missing.length > 0) {
-        p.log.info(color.dim("Optional runtimes not found: " + missing.join(", ")));
-        p.log.info(color.dim("Install them to enable additional language support in context-mode."));
-    }
-    // Step 4: Installation instructions
-    const installMethod = await p.select({
-        message: "How would you like to configure context-mode?",
-        options: [
-            {
-                value: "claude-code",
-                label: "Claude Code (recommended)",
-                hint: "claude mcp add",
-            },
-            {
-                value: "manual",
-                label: "Show manual configuration",
-                hint: ".mcp.json",
-            },
-            { value: "skip", label: "Skip — I'll configure later" },
-        ],
-    });
-    if (p.isCancel(installMethod)) {
-        p.cancel("Setup cancelled.");
-        process.exit(0);
-    }
-    const serverPath = new URL("./server.js", import.meta.url).pathname;
-    if (installMethod === "claude-code") {
-        s.start("Adding to Claude Code");
-        try {
-            execSync(`claude mcp add context-mode -- node ${serverPath}`, { stdio: "pipe", timeout: 10000 });
-            s.stop(color.green("Added to Claude Code!"));
-        }
-        catch {
-            s.stop(color.yellow("Could not add automatically"));
-            p.log.info("Run manually:\n" +
-                color.cyan(`  claude mcp add context-mode -- node ${serverPath}`));
-        }
+            color.dim(` — restart your ${adapter.name} session to pick up the new version`));
     }
-    else if (installMethod === "manual") {
-        p.note(JSON.stringify({
-            mcpServers: {
-                "context-mode": {
-                    command: "node",
-                    args: [serverPath],
-                },
-            },
-        }, null, 2), "Add to your .mcp.json or Claude Code settings");
-    }
-    p.outro(color.green("Setup complete!") +
-        " " +
-        color.dim(available.length + " languages ready."));
 }