context-mode 1.0.89 → 1.0.90

package/build/adapters/copilot-base.d.ts

@@ -0,0 +1,78 @@
+/**
+ * CopilotBaseAdapter — shared implementation for VS Code Copilot and JetBrains Copilot.
+ *
+ * Both platforms share the SAME Copilot agent runtime:
+ *   - hookSpecificOutput wrapper with hookEventName
+ *   - Same hook events (PreToolUse, PostToolUse, PreCompact, SessionStart)
+ *   - Same .github/hooks/ config location
+ *   - Same configureHooks logic
+ *   - Same generateHookConfig format
+ *   - Same parse/format methods
+ *
+ * Platform-specific differences handled by subclasses:
+ *   - extractSessionId() — different env var fallbacks
+ *   - getProjectDir() — different env vars for project root
+ *   - getSessionDir() — different default session directories
+ *   - checkPluginRegistration() — VS Code reads .vscode/mcp.json, JetBrains uses IDE UI
+ *   - getInstalledVersion() — VS Code checks extensions dir, JetBrains checks hook config
+ *   - validateHooks() — different warning messages
+ */
+import { BaseAdapter } from "./base.js";
+import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration } from "./types.js";
+export interface CopilotHookInput {
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    tool_output?: string;
+    is_error?: boolean;
+    /** Copilot uses camelCase sessionId (NOT session_id). */
+    sessionId?: string;
+    source?: string;
+}
+export interface CopilotHookModule {
+    HOOK_TYPES: {
+        readonly PRE_TOOL_USE: string;
+        readonly POST_TOOL_USE: string;
+        readonly PRE_COMPACT: string;
+        readonly SESSION_START: string;
+        readonly STOP: string;
+        readonly SUBAGENT_START: string;
+        readonly SUBAGENT_STOP: string;
+    };
+    HOOK_SCRIPTS: Record<string, string>;
+    buildHookCommand: (hookType: any, pluginRoot?: string) => string;
+}
+export declare abstract class CopilotBaseAdapter extends BaseAdapter implements HookAdapter {
+    readonly paradigm: HookParadigm;
+    readonly capabilities: PlatformCapabilities;
+    /** Subclasses must provide their platform name. */
+    abstract readonly name: string;
+    /** Subclasses must provide their hook module (HOOK_TYPES, HOOK_SCRIPTS, buildHookCommand). */
+    protected abstract readonly hookModule: CopilotHookModule;
+    /** Subclasses must provide the hook scripts subdirectory name (e.g., "vscode-copilot"). */
+    protected abstract readonly hookSubdir: string;
+    /** Extract session ID from Copilot hook input — env var fallbacks differ per platform. */
+    protected abstract extractSessionId(input: CopilotHookInput): string;
+    /** Get the project directory — env vars differ per platform. */
+    protected abstract getProjectDir(): string;
+    /** Validate that hooks are properly configured for this platform. */
+    abstract validateHooks(pluginRoot: string): DiagnosticResult[];
+    /** Check if the plugin is registered/enabled on this platform. */
+    abstract checkPluginRegistration(): DiagnosticResult;
+    /** Get the installed version from this platform's registry/marketplace. */
+    abstract getInstalledVersion(): string;
+    parsePreToolUseInput(raw: unknown): PreToolUseEvent;
+    parsePostToolUseInput(raw: unknown): PostToolUseEvent;
+    parsePreCompactInput(raw: unknown): PreCompactEvent;
+    parseSessionStartInput(raw: unknown): SessionStartEvent;
+    formatPreToolUseResponse(response: PreToolUseResponse): unknown;
+    formatPostToolUseResponse(response: PostToolUseResponse): unknown;
+    formatPreCompactResponse(response: PreCompactResponse): unknown;
+    formatSessionStartResponse(response: SessionStartResponse): unknown;
+    getSettingsPath(): string;
+    generateHookConfig(pluginRoot: string): HookRegistration;
+    readSettings(): Record<string, unknown> | null;
+    writeSettings(settings: Record<string, unknown>): void;
+    configureAllHooks(pluginRoot: string): string[];
+    setHookPermissions(pluginRoot: string): string[];
+    updatePluginRegistry(_pluginRoot: string, _version: string): void;
+}

package/build/adapters/copilot-base.js

@@ -0,0 +1,281 @@
+/**
+ * CopilotBaseAdapter — shared implementation for VS Code Copilot and JetBrains Copilot.
+ *
+ * Both platforms share the SAME Copilot agent runtime:
+ *   - hookSpecificOutput wrapper with hookEventName
+ *   - Same hook events (PreToolUse, PostToolUse, PreCompact, SessionStart)
+ *   - Same .github/hooks/ config location
+ *   - Same configureHooks logic
+ *   - Same generateHookConfig format
+ *   - Same parse/format methods
+ *
+ * Platform-specific differences handled by subclasses:
+ *   - extractSessionId() — different env var fallbacks
+ *   - getProjectDir() — different env vars for project root
+ *   - getSessionDir() — different default session directories
+ *   - checkPluginRegistration() — VS Code reads .vscode/mcp.json, JetBrains uses IDE UI
+ *   - getInstalledVersion() — VS Code checks extensions dir, JetBrains checks hook config
+ *   - validateHooks() — different warning messages
+ */
+import { readFileSync, writeFileSync, mkdirSync, accessSync, chmodSync, constants, } from "node:fs";
+import { resolve, join } from "node:path";
+import { BaseAdapter } from "./base.js";
+// ─────────────────────────────────────────────────────────
+// Abstract base adapter for Copilot platforms
+// ─────────────────────────────────────────────────────────
+export class CopilotBaseAdapter extends BaseAdapter {
+    paradigm = "json-stdio";
+    capabilities = {
+        preToolUse: true,
+        postToolUse: true,
+        preCompact: true,
+        sessionStart: true,
+        canModifyArgs: true,
+        canModifyOutput: true,
+        canInjectSessionContext: true,
+    };
+    // ── Input parsing (shared) ─────────────────────────────
+    parsePreToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            sessionId: this.extractSessionId(input),
+            projectDir: this.getProjectDir(),
+            raw,
+        };
+    }
+    parsePostToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            toolOutput: input.tool_output,
+            isError: input.is_error,
+            sessionId: this.extractSessionId(input),
+            projectDir: this.getProjectDir(),
+            raw,
+        };
+    }
+    parsePreCompactInput(raw) {
+        const input = raw;
+        return {
+            sessionId: this.extractSessionId(input),
+            projectDir: this.getProjectDir(),
+            raw,
+        };
+    }
+    parseSessionStartInput(raw) {
+        const input = raw;
+        const rawSource = input.source ?? "startup";
+        let source;
+        switch (rawSource) {
+            case "compact":
+                source = "compact";
+                break;
+            case "resume":
+                source = "resume";
+                break;
+            case "clear":
+                source = "clear";
+                break;
+            default:
+                source = "startup";
+        }
+        return {
+            sessionId: this.extractSessionId(input),
+            source,
+            projectDir: this.getProjectDir(),
+            raw,
+        };
+    }
+    // ── Response formatting (shared) ───────────────────────
+    formatPreToolUseResponse(response) {
+        if (response.decision === "deny") {
+            return {
+                permissionDecision: "deny",
+                reason: response.reason ?? "Blocked by context-mode hook",
+            };
+        }
+        if (response.decision === "modify" && response.updatedInput) {
+            return {
+                hookSpecificOutput: {
+                    hookEventName: this.hookModule.HOOK_TYPES.PRE_TOOL_USE,
+                    updatedInput: response.updatedInput,
+                },
+            };
+        }
+        if (response.decision === "context" && response.additionalContext) {
+            return {
+                hookSpecificOutput: {
+                    hookEventName: this.hookModule.HOOK_TYPES.PRE_TOOL_USE,
+                    additionalContext: response.additionalContext,
+                },
+            };
+        }
+        if (response.decision === "ask") {
+            return {
+                permissionDecision: "deny",
+                reason: response.reason ?? "Action requires user confirmation (security policy)",
+            };
+        }
+        // "allow" — return undefined for passthrough
+        return undefined;
+    }
+    formatPostToolUseResponse(response) {
+        if (response.updatedOutput) {
+            return {
+                hookSpecificOutput: {
+                    hookEventName: this.hookModule.HOOK_TYPES.POST_TOOL_USE,
+                    decision: "block",
+                    reason: response.updatedOutput,
+                },
+            };
+        }
+        if (response.additionalContext) {
+            return {
+                hookSpecificOutput: {
+                    hookEventName: this.hookModule.HOOK_TYPES.POST_TOOL_USE,
+                    additionalContext: response.additionalContext,
+                },
+            };
+        }
+        return undefined;
+    }
+    formatPreCompactResponse(response) {
+        return response.context ?? "";
+    }
+    formatSessionStartResponse(response) {
+        return response.context ?? "";
+    }
+    // ── Configuration (shared) ─────────────────────────────
+    getSettingsPath() {
+        return resolve(".github", "hooks", "context-mode.json");
+    }
+    generateHookConfig(pluginRoot) {
+        const { HOOK_TYPES, buildHookCommand } = this.hookModule;
+        return {
+            [HOOK_TYPES.PRE_TOOL_USE]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(HOOK_TYPES.PRE_TOOL_USE, pluginRoot),
+                        },
+                    ],
+                },
+            ],
+            [HOOK_TYPES.POST_TOOL_USE]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(HOOK_TYPES.POST_TOOL_USE, pluginRoot),
+                        },
+                    ],
+                },
+            ],
+            [HOOK_TYPES.PRE_COMPACT]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(HOOK_TYPES.PRE_COMPACT, pluginRoot),
+                        },
+                    ],
+                },
+            ],
+            [HOOK_TYPES.SESSION_START]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(HOOK_TYPES.SESSION_START, pluginRoot),
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    readSettings() {
+        // Primary: .github/hooks/context-mode.json
+        try {
+            const raw = readFileSync(this.getSettingsPath(), "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            /* fall through */
+        }
+        // Fallback: .claude/settings.json
+        try {
+            const raw = readFileSync(resolve(".claude", "settings.json"), "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    writeSettings(settings) {
+        const configPath = this.getSettingsPath();
+        mkdirSync(resolve(".github", "hooks"), { recursive: true });
+        writeFileSync(configPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    }
+    // ── Upgrade (shared) ──────────────────────────────────
+    configureAllHooks(pluginRoot) {
+        const changes = [];
+        const settings = this.readSettings() ?? {};
+        const hooks = settings.hooks ?? {};
+        const { HOOK_TYPES, HOOK_SCRIPTS, buildHookCommand } = this.hookModule;
+        const hookTypes = [
+            HOOK_TYPES.PRE_TOOL_USE,
+            HOOK_TYPES.POST_TOOL_USE,
+            HOOK_TYPES.PRE_COMPACT,
+            HOOK_TYPES.SESSION_START,
+        ];
+        for (const hookType of hookTypes) {
+            const script = HOOK_SCRIPTS[hookType];
+            if (!script)
+                continue;
+            hooks[hookType] = [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand(hookType, pluginRoot),
+                        },
+                    ],
+                },
+            ];
+            changes.push(`Configured ${hookType} hook`);
+        }
+        settings.hooks = hooks;
+        this.writeSettings(settings);
+        changes.push(`Wrote hook config to ${this.getSettingsPath()}`);
+        return changes;
+    }
+    setHookPermissions(pluginRoot) {
+        const set = [];
+        const hooksDir = join(pluginRoot, "hooks", this.hookSubdir);
+        for (const scriptName of Object.values(this.hookModule.HOOK_SCRIPTS)) {
+            const scriptPath = resolve(hooksDir, scriptName);
+            try {
+                accessSync(scriptPath, constants.R_OK);
+                chmodSync(scriptPath, 0o755);
+                set.push(scriptPath);
+            }
+            catch {
+                /* skip missing scripts */
+            }
+        }
+        return set;
+    }
+    updatePluginRegistry(_pluginRoot, _version) {
+        // Copilot platforms manage plugins through their own marketplaces.
+        // No manual registry update needed.
+    }
+}

package/build/adapters/cursor/index.d.ts

@@ -4,6 +4,7 @@
  * Native Cursor hooks use lower-camel hook names and flat command entries in
  * `.cursor/hooks.json` / `~/.cursor/hooks.json`.
  */
+import { BaseAdapter } from "../base.js";
 import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, SessionStartResponse, HookRegistration } from "../types.js";
 interface StopEvent {
     sessionId: string;
@@ -12,7 +13,8 @@ interface StopEvent {
     generationId?: string;
     transcriptPath?: string;
 }
-export declare class CursorAdapter implements HookAdapter {
+export declare class CursorAdapter extends BaseAdapter implements HookAdapter {
+    constructor();
     readonly name = "Cursor";
     readonly paradigm: HookParadigm;
     readonly capabilities: PlatformCapabilities;
@@ -30,9 +32,6 @@ export declare class CursorAdapter implements HookAdapter {
         text: string;
     };
     getSettingsPath(): string;
-    getSessionDir(): string;
-    getSessionDBPath(projectDir: string): string;
-    getSessionEventsPath(projectDir: string): string;
     generateHookConfig(_pluginRoot: string): HookRegistration;
     readSettings(): Record<string, unknown> | null;
     writeSettings(settings: Record<string, unknown>): void;
@@ -40,7 +39,6 @@ export declare class CursorAdapter implements HookAdapter {
     checkPluginRegistration(): DiagnosticResult;
     getInstalledVersion(): string;
     configureAllHooks(_pluginRoot: string): string[];
-    backupSettings(): string | null;
     setHookPermissions(pluginRoot: string): string[];
     updatePluginRegistry(_pluginRoot: string, _version: string): void;
     private getCandidateHookConfigPaths;

package/build/adapters/cursor/index.js

@@ -4,14 +4,17 @@
  * Native Cursor hooks use lower-camel hook names and flat command entries in
  * `.cursor/hooks.json` / `~/.cursor/hooks.json`.
  */
-import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync, mkdirSync, copyFileSync, accessSync, chmodSync, constants, existsSync, } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, accessSync, chmodSync, constants, existsSync, } from "node:fs";
 import { execSync } from "node:child_process";
 import { resolve, join } from "node:path";
 import { homedir } from "node:os";
+import { BaseAdapter } from "../base.js";
 import { HOOK_TYPES as CURSOR_HOOK_NAMES, HOOK_SCRIPTS as CURSOR_HOOK_SCRIPTS, PRE_TOOL_USE_MATCHER_PATTERN, REQUIRED_HOOKS, OPTIONAL_HOOKS, isContextModeHook, buildHookCommand, } from "./hooks.js";
 const CURSOR_ENTERPRISE_HOOKS_PATH = "/Library/Application Support/Cursor/hooks.json";
-export class CursorAdapter {
+export class CursorAdapter extends BaseAdapter {
+    constructor() {
+        super([".cursor"]);
+    }
     name = "Cursor";
     paradigm = "json-stdio";
     capabilities = {
@@ -125,25 +128,6 @@ export class CursorAdapter {
     getSettingsPath() {
         return resolve(".cursor", "hooks.json");
     }
-    getSessionDir() {
-        const dir = join(homedir(), ".cursor", "context-mode", "sessions");
-        mkdirSync(dir, { recursive: true });
-        return dir;
-    }
-    getSessionDBPath(projectDir) {
-        const hash = createHash("sha256")
-            .update(projectDir)
-            .digest("hex")
-            .slice(0, 16);
-        return join(this.getSessionDir(), `${hash}.db`);
-    }
-    getSessionEventsPath(projectDir) {
-        const hash = createHash("sha256")
-            .update(projectDir)
-            .digest("hex")
-            .slice(0, 16);
-        return join(this.getSessionDir(), `${hash}-events.md`);
-    }
     generateHookConfig(_pluginRoot) {
         const hooks = {
             [CURSOR_HOOK_NAMES.PRE_TOOL_USE]: [
@@ -355,18 +339,6 @@ export class CursorAdapter {
         changes.push(`Wrote native Cursor hooks to ${this.getSettingsPath()}`);
         return changes;
     }
-    backupSettings() {
-        const settingsPath = this.getSettingsPath();
-        try {
-            accessSync(settingsPath, constants.R_OK);
-            const backupPath = settingsPath + ".bak";
-            copyFileSync(settingsPath, backupPath);
-            return backupPath;
-        }
-        catch {
-            return null;
-        }
-    }
     setHookPermissions(pluginRoot) {
         const set = [];
         const hooksDir = join(pluginRoot, "hooks", "cursor");

package/build/adapters/detect.d.ts

@@ -15,8 +15,15 @@
  *   - Codex CLI:      CODEX_CI, CODEX_THREAD_ID | ~/.codex/
  *   - Cursor:         CURSOR_TRACE_ID (MCP), CURSOR_CLI (terminal) | ~/.cursor/
  *   - VS Code Copilot: VSCODE_PID, VSCODE_CWD | ~/.vscode/
+ *   - JetBrains Copilot: IDEA_INITIAL_DIRECTORY, IDEA_HOME, JETBRAINS_CLIENT_ID | ~/.config/JetBrains/
  */
 import type { PlatformId, DetectionSignal, HookAdapter } from "./types.js";
+/**
+ * High-confidence env vars per platform, checked in priority order.
+ * Single source of truth — consumed by detectPlatform() below and by
+ * tests that need to clear platform-related env vars deterministically.
+ */
+export declare const PLATFORM_ENV_VARS: readonly [readonly ["claude-code", readonly ["CLAUDE_PROJECT_DIR", "CLAUDE_SESSION_ID"]], readonly ["gemini-cli", readonly ["GEMINI_PROJECT_DIR", "GEMINI_CLI"]], readonly ["openclaw", readonly ["OPENCLAW_HOME", "OPENCLAW_CLI"]], readonly ["kilo", readonly ["KILO", "KILO_PID"]], readonly ["opencode", readonly ["OPENCODE", "OPENCODE_PID"]], readonly ["codex", readonly ["CODEX_CI", "CODEX_THREAD_ID"]], readonly ["cursor", readonly ["CURSOR_TRACE_ID", "CURSOR_CLI"]], readonly ["vscode-copilot", readonly ["VSCODE_PID", "VSCODE_CWD"]], readonly ["jetbrains-copilot", readonly ["IDEA_INITIAL_DIRECTORY", "IDEA_HOME", "JETBRAINS_CLIENT_ID"]], readonly ["qwen-code", readonly ["QWEN_PROJECT_DIR", "QWEN_SESSION_ID"]]];
 /**
  * Detect the current platform by checking env vars and config dirs.
  *

package/build/adapters/detect.js

@@ -15,11 +15,29 @@
  *   - Codex CLI:      CODEX_CI, CODEX_THREAD_ID | ~/.codex/
  *   - Cursor:         CURSOR_TRACE_ID (MCP), CURSOR_CLI (terminal) | ~/.cursor/
  *   - VS Code Copilot: VSCODE_PID, VSCODE_CWD | ~/.vscode/
+ *   - JetBrains Copilot: IDEA_INITIAL_DIRECTORY, IDEA_HOME, JETBRAINS_CLIENT_ID | ~/.config/JetBrains/
  */
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { homedir } from "node:os";
 import { CLIENT_NAME_TO_PLATFORM } from "./client-map.js";
+/**
+ * High-confidence env vars per platform, checked in priority order.
+ * Single source of truth — consumed by detectPlatform() below and by
+ * tests that need to clear platform-related env vars deterministically.
+ */
+export const PLATFORM_ENV_VARS = [
+    ["claude-code", ["CLAUDE_PROJECT_DIR", "CLAUDE_SESSION_ID"]],
+    ["gemini-cli", ["GEMINI_PROJECT_DIR", "GEMINI_CLI"]],
+    ["openclaw", ["OPENCLAW_HOME", "OPENCLAW_CLI"]],
+    ["kilo", ["KILO", "KILO_PID"]],
+    ["opencode", ["OPENCODE", "OPENCODE_PID"]],
+    ["codex", ["CODEX_CI", "CODEX_THREAD_ID"]],
+    ["cursor", ["CURSOR_TRACE_ID", "CURSOR_CLI"]],
+    ["vscode-copilot", ["VSCODE_PID", "VSCODE_CWD"]],
+    ["jetbrains-copilot", ["IDEA_INITIAL_DIRECTORY", "IDEA_HOME", "JETBRAINS_CLIENT_ID"]],
+    ["qwen-code", ["QWEN_PROJECT_DIR", "QWEN_SESSION_ID"]],
+];
 /**
  * Detect the current platform by checking env vars and config dirs.
  *
@@ -37,13 +55,21 @@ export function detectPlatform(clientInfo) {
                 reason: `MCP clientInfo.name="${clientInfo.name}"`,
             };
         }
+        // Qwen Code uses dynamic client names: qwen-cli-mcp-client-<serverName>
+        if (clientInfo.name.startsWith("qwen-cli-mcp-client")) {
+            return {
+                platform: "qwen-code",
+                confidence: "high",
+                reason: `MCP clientInfo.name="${clientInfo.name}" (qwen-cli pattern)`,
+            };
+        }
     }
     // ── Explicit platform override ────────────────────────
     const platformOverride = process.env.CONTEXT_MODE_PLATFORM;
     if (platformOverride) {
         const validPlatforms = [
             "claude-code", "gemini-cli", "kilo", "opencode", "codex",
-            "vscode-copilot", "cursor", "antigravity", "kiro", "pi", "zed",
+            "vscode-copilot", "jetbrains-copilot", "cursor", "antigravity", "kiro", "pi", "zed", "qwen-code",
         ];
         if (validPlatforms.includes(platformOverride)) {
             return {
@@ -54,61 +80,14 @@ export function detectPlatform(clientInfo) {
         }
     }
     // ── High confidence: environment variables ─────────────
-    if (process.env.CLAUDE_PROJECT_DIR || process.env.CLAUDE_SESSION_ID) {
-        return {
-            platform: "claude-code",
-            confidence: "high",
-            reason: "CLAUDE_PROJECT_DIR or CLAUDE_SESSION_ID env var set",
-        };
-    }
-    if (process.env.GEMINI_PROJECT_DIR || process.env.GEMINI_CLI) {
-        return {
-            platform: "gemini-cli",
-            confidence: "high",
-            reason: "GEMINI_PROJECT_DIR or GEMINI_CLI env var set",
-        };
-    }
-    if (process.env.OPENCLAW_HOME || process.env.OPENCLAW_CLI) {
-        return {
-            platform: "openclaw",
-            confidence: "high",
-            reason: "OPENCLAW_HOME or OPENCLAW_CLI env var set",
-        };
-    }
-    if (process.env.KILO || process.env.KILO_PID) {
-        return {
-            platform: "kilo",
-            confidence: "high",
-            reason: "KILO or KILO_PID env var set",
-        };
-    }
-    if (process.env.OPENCODE || process.env.OPENCODE_PID) {
-        return {
-            platform: "opencode",
-            confidence: "high",
-            reason: "OPENCODE or OPENCODE_PID env var set",
-        };
-    }
-    if (process.env.CODEX_CI || process.env.CODEX_THREAD_ID) {
-        return {
-            platform: "codex",
-            confidence: "high",
-            reason: "CODEX_CI or CODEX_THREAD_ID env var set",
-        };
-    }
-    if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CLI) {
-        return {
-            platform: "cursor",
-            confidence: "high",
-            reason: "CURSOR_TRACE_ID or CURSOR_CLI env var set",
-        };
-    }
-    if (process.env.VSCODE_PID || process.env.VSCODE_CWD) {
-        return {
-            platform: "vscode-copilot",
-            confidence: "high",
-            reason: "VSCODE_PID or VSCODE_CWD env var set",
-        };
+    for (const [platform, vars] of PLATFORM_ENV_VARS) {
+        if (vars.some((v) => process.env[v])) {
+            return {
+                platform,
+                confidence: "high",
+                reason: `${vars.join(" or ")} env var set`,
+            };
+        }
     }
     // ── Medium confidence: config directory existence ──────
     const home = homedir();
@@ -154,6 +133,13 @@ export function detectPlatform(clientInfo) {
             reason: "~/.pi/ directory exists",
         };
     }
+    if (existsSync(resolve(home, ".qwen"))) {
+        return {
+            platform: "qwen-code",
+            confidence: "medium",
+            reason: "~/.qwen/ directory exists",
+        };
+    }
     if (existsSync(resolve(home, ".openclaw"))) {
         return {
             platform: "openclaw",
@@ -168,6 +154,13 @@ export function detectPlatform(clientInfo) {
             reason: "~/.config/kilo/ directory exists",
         };
     }
+    if (existsSync(resolve(home, ".config", "JetBrains"))) {
+        return {
+            platform: "jetbrains-copilot",
+            confidence: "medium",
+            reason: "~/.config/JetBrains/ directory exists",
+        };
+    }
     if (existsSync(resolve(home, ".config", "opencode"))) {
         return {
             platform: "opencode",
@@ -221,6 +214,10 @@ export async function getAdapter(platform) {
             const { VSCodeCopilotAdapter } = await import("./vscode-copilot/index.js");
             return new VSCodeCopilotAdapter();
         }
+        case "jetbrains-copilot": {
+            const { JetBrainsCopilotAdapter } = await import("./jetbrains-copilot/index.js");
+            return new JetBrainsCopilotAdapter();
+        }
         case "cursor": {
             const { CursorAdapter } = await import("./cursor/index.js");
             return new CursorAdapter();
@@ -237,6 +234,10 @@ export async function getAdapter(platform) {
             const { ZedAdapter } = await import("./zed/index.js");
             return new ZedAdapter();
         }
+        case "qwen-code": {
+            const { QwenCodeAdapter } = await import("./qwen-code/index.js");
+            return new QwenCodeAdapter();
+        }
         default: {
             // Unsupported platform — fall back to Claude Code adapter
             // (MCP server works everywhere, hooks may not)

package/build/adapters/gemini-cli/index.d.ts

@@ -18,8 +18,10 @@
  *   - Project dir env: GEMINI_PROJECT_DIR (also CLAUDE_PROJECT_DIR alias)
  *   - Session dir: ~/.gemini/context-mode/sessions/
  */
+import { BaseAdapter } from "../base.js";
 import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration } from "../types.js";
-export declare class GeminiCLIAdapter implements HookAdapter {
+export declare class GeminiCLIAdapter extends BaseAdapter implements HookAdapter {
+    constructor();
     readonly name = "Gemini CLI";
     readonly paradigm: HookParadigm;
     readonly capabilities: PlatformCapabilities;
@@ -32,9 +34,6 @@ export declare class GeminiCLIAdapter implements HookAdapter {
     formatPreCompactResponse(response: PreCompactResponse): unknown;
     formatSessionStartResponse(response: SessionStartResponse): unknown;
     getSettingsPath(): string;
-    getSessionDir(): string;
-    getSessionDBPath(projectDir: string): string;
-    getSessionEventsPath(projectDir: string): string;
     generateHookConfig(pluginRoot: string): HookRegistration;
     readSettings(): Record<string, unknown> | null;
     writeSettings(settings: Record<string, unknown>): void;
@@ -42,7 +41,6 @@ export declare class GeminiCLIAdapter implements HookAdapter {
     checkPluginRegistration(): DiagnosticResult;
     getInstalledVersion(): string;
     configureAllHooks(pluginRoot: string): string[];
-    backupSettings(): string | null;
     setHookPermissions(pluginRoot: string): string[];
     updatePluginRegistry(pluginRoot: string, version: string): void;
     /** Get the project directory from environment variables. */