@mxalbert/context-mode 2.0.0

package/build/adapters/claude-code/index.js

@@ -0,0 +1,569 @@
+/**
+ * adapters/claude-code — Claude Code platform adapter.
+ *
+ * Extends ClaudeCodeBaseAdapter (shared wire-protocol parse/format methods)
+ * with Claude Code-specific configuration, diagnostics, and upgrade logic.
+ *
+ * Claude Code hook specifics:
+ *   - Session ID: transcript_path UUID > session_id > CLAUDE_SESSION_ID > ppid
+ *   - Config root: $CLAUDE_CONFIG_DIR (when set) or ~/.claude
+ *   - Settings: <configDir>/settings.json
+ *   - Session dir: <configDir>/context-mode/sessions/
+ *   - Plugin registry: <configDir>/plugins/installed_plugins.json
+ */
+import { readFileSync, writeFileSync, existsSync, readdirSync, chmodSync, accessSync, mkdirSync, constants, } from "node:fs";
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+import { ClaudeCodeBaseAdapter } from "../claude-code-base.js";
+import { resolveContextModeDataRoot } from "../base.js";
+import { resolveClaudeConfigDir } from "../../util/claude-config.js";
+import { checkPluginCacheIntegritySync } from "../../util/plugin-cache-integrity.js";
+import { buildHookRuntimeCommand, } from "../types.js";
+import { HOOK_TYPES, HOOK_SCRIPTS, REQUIRED_HOOKS, PRE_TOOL_USE_MATCHERS, PRE_TOOL_USE_MATCHER_PATTERN, isContextModeHook, isAnyContextModeHook, extractHookScriptPath, buildHookCommand, } from "./hooks.js";
+// ─────────────────────────────────────────────────────────
+// Adapter implementation
+// ─────────────────────────────────────────────────────────
+export class ClaudeCodeAdapter extends ClaudeCodeBaseAdapter {
+    constructor() {
+        super([".claude"]);
+    }
+    name = "Claude Code";
+    paradigm = "json-stdio";
+    projectDirEnvVar = "CLAUDE_PROJECT_DIR";
+    capabilities = {
+        preToolUse: true,
+        postToolUse: true,
+        preCompact: true,
+        sessionStart: true,
+        canModifyArgs: true,
+        canModifyOutput: true,
+        canInjectSessionContext: true,
+    };
+    // ── Configuration ──────────────────────────────────────
+    /**
+     * Honor `CLAUDE_CONFIG_DIR` (the canonical Claude Code config root) before
+     * falling back to `~/.claude`. Mirrors the contract that
+     * `hooks/session-helpers.mjs::resolveConfigDir` already follows — including
+     * tilde expansion for shells that pass `~/foo` through unchanged — so server
+     * and hooks agree on where session-scoped state lives. See issue #453.
+     *
+     * Tilde regex `/^~[/\\]?/` only handles the current-user form (`~`, `~/`,
+     * `~\`); `~user/` is NOT expanded to a per-user homedir (matches
+     * `resolveConfigDir`). Non-tilde values are run through `resolve()` to
+     * normalize relative paths to absolute against cwd; the hook helper
+     * intentionally leaves them raw, but the adapter contract guarantees an
+     * absolute path (BaseAdapter.getConfigDir docstring).
+     *
+     * Issue #460 round-3: routed through the canonical
+     * `resolveClaudeConfigDir` util so server, CLI, security, and adapter
+     * agree byte-for-byte (incl. empty/whitespace-only env fallback).
+     */
+    getConfigDir(_projectDir) {
+        return resolveClaudeConfigDir();
+    }
+    getSessionDir() {
+        // Issue #649: honor CONTEXT_MODE_DATA_DIR universal storage override
+        // before falling back to the Claude-rooted default. The override moves
+        // ONLY context-mode-owned state; settings.json + CLAUDE_CONFIG_DIR stay
+        // intact below.
+        const override = resolveContextModeDataRoot();
+        const dir = override
+            ? join(override, "context-mode", "sessions")
+            : join(this.getConfigDir(), "context-mode", "sessions");
+        mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    getSettingsPath() {
+        return join(this.getConfigDir(), "settings.json");
+    }
+    generateHookConfig(pluginRoot) {
+        // Algo-D3: every command flows through `buildHookRuntimeCommand`
+        // (defined in src/adapters/types.ts), which:
+        //   - quotes both runtime path and scriptPath (#548 — Windows
+        //     pluginRoots with spaces no longer fall through
+        //     extractHookScriptPath's ambiguous-tail fallback),
+        //   - swaps backslashes for forward slashes (#372 MSYS path mangling),
+        //   - resolves the JS runtime via `resolveHookRuntime`: Bun ≥1.0 when
+        //     available, else `process.execPath` (#369 PATH resolution on Git
+        //     Bash, #738 bun cold-start win).
+        // Pre-D3 we hand-rolled `node "${pluginRoot}/hooks/X.mjs"` for all
+        // six events; bare `node` made claude-code the lone outlier and
+        // dropping the execPath swap re-opened the Windows class. Algo-D3.5
+        // (CI invariant in tests/adapters/claude-code.test.ts) locks this in
+        // for adapter #16.
+        const preToolUseCommand = buildHookRuntimeCommand(`${pluginRoot}/hooks/pretooluse.mjs`);
+        const preToolUseMatchers = [...PRE_TOOL_USE_MATCHERS];
+        return {
+            PreToolUse: preToolUseMatchers.map((matcher) => ({
+                matcher,
+                hooks: [{ type: "command", command: preToolUseCommand }],
+            })),
+            PostToolUse: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookRuntimeCommand(`${pluginRoot}/hooks/posttooluse.mjs`),
+                        },
+                    ],
+                },
+            ],
+            PreCompact: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookRuntimeCommand(`${pluginRoot}/hooks/precompact.mjs`),
+                        },
+                    ],
+                },
+            ],
+            UserPromptSubmit: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookRuntimeCommand(`${pluginRoot}/hooks/userpromptsubmit.mjs`),
+                        },
+                    ],
+                },
+            ],
+            SessionStart: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookRuntimeCommand(`${pluginRoot}/hooks/sessionstart.mjs`),
+                        },
+                    ],
+                },
+            ],
+            Stop: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookRuntimeCommand(`${pluginRoot}/hooks/stop.mjs`),
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    readSettings() {
+        try {
+            const raw = readFileSync(this.getSettingsPath(), "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    writeSettings(settings) {
+        writeFileSync(this.getSettingsPath(), JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    }
+    // ── Diagnostics (doctor) ─────────────────────────────────
+    validateHooks(pluginRoot) {
+        const results = [];
+        const settings = this.readSettings();
+        if (!settings) {
+            results.push({
+                check: "PreToolUse hook",
+                status: "fail",
+                message: `Could not read ${this.getSettingsPath()}`,
+                fix: "context-mode upgrade",
+            });
+            return results;
+        }
+        const hooks = settings.hooks;
+        // Read plugin hooks.json as fallback (Issue #94: plugin installs
+        // register hooks in hooks/hooks.json, not in settings.json)
+        const pluginHooks = this.readPluginHooks(pluginRoot);
+        // Check PreToolUse (settings.json first, then plugin hooks.json fallback)
+        const hasPreToolUse = this.checkHookType(hooks, pluginHooks, HOOK_TYPES.PRE_TOOL_USE);
+        results.push({
+            check: "PreToolUse hook",
+            status: hasPreToolUse ? "pass" : "fail",
+            message: hasPreToolUse
+                ? "PreToolUse hook configured"
+                : "No PreToolUse hooks found",
+            fix: hasPreToolUse ? undefined : "context-mode upgrade",
+        });
+        // Check SessionStart (settings.json first, then plugin hooks.json fallback)
+        const hasSessionStart = this.checkHookType(hooks, pluginHooks, HOOK_TYPES.SESSION_START);
+        results.push({
+            check: "SessionStart hook",
+            status: hasSessionStart ? "pass" : "fail",
+            message: hasSessionStart
+                ? "SessionStart hook configured"
+                : "No SessionStart hooks found",
+            fix: hasSessionStart ? undefined : "context-mode upgrade",
+        });
+        return results;
+    }
+    /**
+     * Adapter-defined health checks (Algo-D1 + Algo-D5).
+     *
+     * For each entry in HOOK_SCRIPTS (the canonical hookType → scriptName
+     * map), emit a HealthCheck that joins `pluginRoot + "hooks" +
+     * scriptName` and probes via `existsSync`. Crucially, this NEVER
+     * parses a hook command — pluginRoot and scriptName are both in our
+     * hand, so the regex round-trip that produced the #548 doubled-path
+     * FAIL is bypassed entirely.
+     *
+     * The hook check derives from HOOK_SCRIPTS (single source of truth in
+     * src/adapters/claude-code/hooks.ts), so adding a new hook event in
+     * that map auto-extends doctor coverage — no parallel hardcoded list
+     * to maintain.
+     *
+     * Algo-D5: appends a single "Plugin cache integrity" check that
+     * delegates to the same helper start.mjs uses at boot
+     * (scripts/plugin-cache-integrity.mjs::assertPluginCacheIntegrity).
+     * Same code, two callsites — boot fail-fast and doctor diagnostic
+     * agree byte-for-byte. Users hitting #550 get the actionable signal
+     * without restarting the MCP server.
+     */
+    getHealthChecks(pluginRoot) {
+        const hookChecks = Object.entries(HOOK_SCRIPTS).map(([hookType, scriptName]) => {
+            const absolutePath = join(pluginRoot, "hooks", scriptName);
+            return {
+                name: `Hook script: ${hookType} (${scriptName})`,
+                check: () => {
+                    // Direct existsSync — no hook-command parsing, no regex.
+                    // pluginRoot is the value the doctor was invoked with;
+                    // scriptName comes from the canonical HOOK_SCRIPTS map.
+                    if (existsSync(absolutePath)) {
+                        return { status: "OK", detail: absolutePath };
+                    }
+                    return {
+                        status: "FAIL",
+                        detail: `not found at ${absolutePath}`,
+                    };
+                },
+            };
+        });
+        const integrityCheck = {
+            name: "Plugin cache integrity",
+            check: () => checkPluginCacheIntegritySync(pluginRoot),
+        };
+        return [...hookChecks, integrityCheck];
+    }
+    /** Read plugin hooks from hooks/hooks.json or .claude-plugin/hooks/hooks.json */
+    readPluginHooks(pluginRoot) {
+        const candidates = [
+            join(pluginRoot, "hooks", "hooks.json"),
+            join(pluginRoot, ".claude-plugin", "hooks", "hooks.json"),
+        ];
+        for (const candidate of candidates) {
+            try {
+                const raw = readFileSync(candidate, "utf-8");
+                const parsed = JSON.parse(raw);
+                if (parsed.hooks)
+                    return parsed.hooks;
+            }
+            catch { /* not available */ }
+        }
+        return undefined;
+    }
+    /** Check if a hook type is configured in either settings.json or plugin hooks */
+    checkHookType(settingsHooks, pluginHooks, hookType) {
+        // Check settings.json
+        const fromSettings = settingsHooks?.[hookType];
+        if (fromSettings && fromSettings.length > 0) {
+            if (fromSettings.some((entry) => isContextModeHook(entry, hookType))) {
+                return true;
+            }
+        }
+        // Fallback: check plugin hooks.json
+        const fromPlugin = pluginHooks?.[hookType];
+        if (fromPlugin && fromPlugin.length > 0) {
+            if (fromPlugin.some((entry) => isContextModeHook(entry, hookType))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    checkPluginRegistration() {
+        const settings = this.readSettings();
+        if (!settings) {
+            return {
+                check: "Plugin registration",
+                status: "warn",
+                message: "Could not read settings.json",
+            };
+        }
+        const enabledPlugins = settings.enabledPlugins;
+        if (!enabledPlugins) {
+            return {
+                check: "Plugin registration",
+                status: "warn",
+                message: "No enabledPlugins section found (might be using standalone MCP mode)",
+            };
+        }
+        const pluginKey = Object.keys(enabledPlugins).find((k) => k.startsWith("context-mode"));
+        if (pluginKey && enabledPlugins[pluginKey]) {
+            return {
+                check: "Plugin registration",
+                status: "pass",
+                message: `Plugin enabled: ${pluginKey}`,
+            };
+        }
+        return {
+            check: "Plugin registration",
+            status: "warn",
+            message: "context-mode not in enabledPlugins (might be using standalone MCP mode)",
+        };
+    }
+    getInstalledVersion() {
+        // Primary: read from installed_plugins.json
+        try {
+            const ipPath = join(this.getConfigDir(), "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: scan common plugin cache locations.
+        // `resolveClaudeConfigDir` honors $CLAUDE_CONFIG_DIR; the literal
+        // `~/.claude` is also retained as a hard floor so environments that
+        // misconfigure the env still find the canonical dir if it exists.
+        const bases = Array.from(new Set([
+            this.getConfigDir(),
+            resolveClaudeConfigDir(),
+            resolve(homedir(), ".claude"),
+            resolve(homedir(), ".config", "claude"),
+        ]));
+        for (const base of bases) {
+            const cacheDir = resolve(base, "plugins", "cache", "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";
+    }
+    // ── Upgrade ────────────────────────────────────────────
+    configureAllHooks(pluginRoot) {
+        const settings = this.readSettings() ?? {};
+        const hooks = (settings.hooks ?? {});
+        const changes = [];
+        // Remove stale context-mode hook entries across ALL hook types (fixes #187).
+        // After a marketplace auto-update or version change, settings.json may contain
+        // hardcoded paths pointing to deleted version directories (e.g., .../0.9.17/hooks/...).
+        // Clean these before registering fresh entries to prevent SessionStart errors.
+        for (const hookType of Object.keys(hooks)) {
+            const entries = hooks[hookType];
+            if (!Array.isArray(entries))
+                continue;
+            const filtered = entries.filter((entry) => {
+                const typedEntry = entry;
+                if (!isAnyContextModeHook(typedEntry))
+                    return true; // preserve non-context-mode hooks
+                // Keep CLI dispatcher entries (path-independent, never stale)
+                const commands = typedEntry.hooks ?? [];
+                const hasOnlyDispatcherCommands = commands.every((h) => !h.command || !extractHookScriptPath(h.command));
+                if (hasOnlyDispatcherCommands)
+                    return true;
+                // For node path commands, check if the referenced script file exists
+                return commands.every((h) => {
+                    const scriptPath = h.command ? extractHookScriptPath(h.command) : null;
+                    if (!scriptPath)
+                        return true; // not a path-based command
+                    return existsSync(scriptPath);
+                });
+            });
+            const removed = entries.length - filtered.length;
+            if (removed > 0) {
+                hooks[hookType] = filtered;
+                changes.push(`Removed ${removed} stale ${hookType} hook(s)`);
+            }
+        }
+        // If plugin hooks.json already covers all required hooks AND context-mode is
+        // actually installed as a Claude Code plugin (present in enabledPlugins), skip
+        // settings.json registration — hooks.json with ${CLAUDE_PLUGIN_ROOT} is the
+        // source of truth for plugin installs (Issue #198).
+        //
+        // Standalone / MacPorts installs are NOT in enabledPlugins. For those, the
+        // hooks/hooks.json shipped in the npm package is never consulted by Claude Code
+        // (it uses ${CLAUDE_PLUGIN_ROOT} which is only set in plugin mode). We must
+        // always write absolute-path hook commands to settings.json in that case.
+        const pluginRegistration = this.checkPluginRegistration();
+        const isPluginInstall = pluginRegistration.status === "pass";
+        const pluginHooks = isPluginInstall ? this.readPluginHooks(pluginRoot) : undefined;
+        if (pluginHooks) {
+            const allCovered = REQUIRED_HOOKS.every((ht) => this.checkHookType(undefined, pluginHooks, ht));
+            if (allCovered) {
+                // Strip ONLY the inner context-mode hook commands from each matcher entry —
+                // hooks.json is the source of truth for ctx-mode. User hooks co-located in
+                // the same matcher entry MUST be preserved (#415: entry-level filter wiped
+                // every co-located user hook). After stripping, prune entries whose `hooks`
+                // array becomes empty.
+                const ctxScriptNames = Object.values(HOOK_SCRIPTS);
+                const isCtxModeCommand = (cmd) => cmd != null &&
+                    (ctxScriptNames.some((s) => cmd.includes(s)) ||
+                        cmd.includes("context-mode hook"));
+                for (const hookType of Object.keys(hooks)) {
+                    const entries = hooks[hookType];
+                    if (!Array.isArray(entries))
+                        continue;
+                    let totalRemoved = 0;
+                    for (const entry of entries) {
+                        const typedEntry = entry;
+                        const innerHooks = typedEntry.hooks ?? [];
+                        const before = innerHooks.length;
+                        typedEntry.hooks = innerHooks.filter((h) => !isCtxModeCommand(h.command));
+                        totalRemoved += before - typedEntry.hooks.length;
+                    }
+                    const pruned = entries.filter((e) => {
+                        const ih = e.hooks;
+                        return Array.isArray(ih) && ih.length > 0;
+                    });
+                    if (totalRemoved > 0 || pruned.length !== entries.length) {
+                        hooks[hookType] = pruned;
+                        if (totalRemoved > 0) {
+                            changes.push(`Removed ${totalRemoved} duplicate ${hookType} hook(s) — covered by plugin hooks.json`);
+                        }
+                    }
+                }
+                settings.hooks = hooks;
+                this.writeSettings(settings);
+                changes.push("Skipped settings.json registration — plugin hooks.json is sufficient");
+                return changes;
+            }
+        }
+        // Register fresh hooks for required hook types
+        const hookTypes = [
+            HOOK_TYPES.PRE_TOOL_USE,
+            HOOK_TYPES.SESSION_START,
+        ];
+        for (const hookType of hookTypes) {
+            const command = buildHookCommand(hookType, pluginRoot);
+            if (hookType === HOOK_TYPES.PRE_TOOL_USE) {
+                const entry = {
+                    matcher: PRE_TOOL_USE_MATCHER_PATTERN,
+                    hooks: [{ type: "command", command }],
+                };
+                const existing = hooks.PreToolUse;
+                if (existing && Array.isArray(existing)) {
+                    const idx = existing.findIndex((e) => isContextModeHook(e, hookType));
+                    if (idx >= 0) {
+                        existing[idx] = entry;
+                        changes.push(`Updated existing ${hookType} hook entry`);
+                    }
+                    else {
+                        existing.push(entry);
+                        changes.push(`Added ${hookType} hook entry`);
+                    }
+                    hooks.PreToolUse = existing;
+                }
+                else {
+                    hooks.PreToolUse = [entry];
+                    changes.push(`Created ${hookType} hooks section`);
+                }
+            }
+            else {
+                const entry = {
+                    matcher: "",
+                    hooks: [{ type: "command", command }],
+                };
+                const existing = hooks[hookType];
+                if (existing && Array.isArray(existing)) {
+                    const idx = existing.findIndex((e) => isContextModeHook(e, hookType));
+                    if (idx >= 0) {
+                        existing[idx] = entry;
+                        changes.push(`Updated existing ${hookType} hook entry`);
+                    }
+                    else {
+                        existing.push(entry);
+                        changes.push(`Added ${hookType} hook entry`);
+                    }
+                    hooks[hookType] = existing;
+                }
+                else {
+                    hooks[hookType] = [entry];
+                    changes.push(`Created ${hookType} hooks section`);
+                }
+            }
+        }
+        settings.hooks = hooks;
+        this.writeSettings(settings);
+        return changes;
+    }
+    setHookPermissions(pluginRoot) {
+        const set = [];
+        for (const [, scriptName] of Object.entries(HOOK_SCRIPTS)) {
+            const scriptPath = resolve(pluginRoot, "hooks", scriptName);
+            try {
+                accessSync(scriptPath, constants.R_OK);
+                chmodSync(scriptPath, 0o755);
+                set.push(scriptPath);
+            }
+            catch {
+                /* skip missing scripts */
+            }
+        }
+        return set;
+    }
+    updatePluginRegistry(pluginRoot, version) {
+        try {
+            const ipPath = join(this.getConfigDir(), "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 = version;
+                    entry.lastUpdated = new Date().toISOString();
+                }
+            }
+            writeFileSync(ipPath, JSON.stringify(ipRaw, null, 2) + "\n", "utf-8");
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    // ── Session ID extraction ───────────────────────────────
+    // Claude Code priority: transcript_path UUID > session_id > CLAUDE_SESSION_ID > ppid
+    extractSessionId(input) {
+        if (input.transcript_path) {
+            const match = input.transcript_path.match(/([a-f0-9-]{36})\.jsonl$/);
+            if (match)
+                return match[1];
+        }
+        if (input.session_id)
+            return input.session_id;
+        if (process.env.CLAUDE_SESSION_ID)
+            return process.env.CLAUDE_SESSION_ID;
+        return `pid-${process.ppid}`;
+    }
+}

package/build/adapters/claude-code-base.d.ts

@@ -0,0 +1,49 @@
+/**
+ * adapters/claude-code-base — Shared base for Claude Code wire-protocol adapters.
+ *
+ * Claude Code and Qwen Code use the identical JSON stdin/stdout hook protocol:
+ *   - Input fields: tool_name, tool_input, tool_output, is_error, session_id,
+ *     transcript_path, source
+ *   - Blocking: `permissionDecision: "deny"` in response
+ *   - Arg modification: `updatedInput` field in response
+ *   - Output modification: `updatedMCPToolOutput` field in response
+ *   - Context injection: `additionalContext` at response root (not wrapped)
+ *   - PreCompact/SessionStart: stdout on exit 0
+ *
+ * This base class implements the 8 shared parse/format methods.
+ * Subclasses provide platform-specific config (env vars, settings path,
+ * session ID priority, hook config, diagnostics, upgrade).
+ */
+import { BaseAdapter } from "./base.js";
+import type { PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse } from "./types.js";
+export interface ClaudeCodeWireInput {
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    tool_output?: string;
+    is_error?: boolean;
+    session_id?: string;
+    transcript_path?: string;
+    source?: string;
+}
+export declare abstract class ClaudeCodeBaseAdapter extends BaseAdapter {
+    /**
+     * Environment variable name for the project directory.
+     * Claude Code: "CLAUDE_PROJECT_DIR", Qwen Code: "QWEN_PROJECT_DIR"
+     */
+    protected abstract readonly projectDirEnvVar: 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;
+    /**
+     * Extract session ID from wire input. Default priority (Claude Code):
+     *   transcript_path UUID > session_id > env var > ppid fallback
+     *
+     * Override in subclasses for different priority (e.g., Qwen: session_id first).
+     */
+    protected abstract extractSessionId(input: ClaudeCodeWireInput): string;
+}