@mxalbert/context-mode 2.0.0

package/build/adapters/copilot-base.js

@@ -0,0 +1,297 @@
+/**
+ * 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) ─────────────────────────────
+    /**
+     * Resolve the absolute path to the Copilot-style hook settings file.
+     *
+     * Issue #539 fix: previously this returned `resolve(".github", ...)`
+     * — a CWD-relative path. `doctor` (validateHooks) and `upgrade`
+     * (configureAllHooks) could legitimately run from different working
+     * directories (CLI invoked from a subdir, MCP server cwd=projectDir),
+     * so each saw a DIFFERENT settings path and the diagnose/repair loop
+     * never converged on the same file.
+     *
+     * Now anchors on `projectDir` when supplied (matching the sibling
+     * `getConfigDir(projectDir?: string)` signature in
+     * vscode-copilot/index.ts:93). Falls back to `process.cwd()` to keep
+     * existing callers source-compatible — the slice-5 follow-up will
+     * thread projectDir through `cli.ts doctor`/`upgrade`.
+     */
+    getSettingsPath(projectDir) {
+        return resolve(projectDir ?? process.cwd(), ".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/copilot-cli/hooks.d.ts

@@ -0,0 +1,33 @@
+/**
+ * adapters/copilot-cli/hooks — GitHub Copilot CLI hook definitions.
+ *
+ * GitHub Copilot CLI's native hook events are the camelCase names
+ * preToolUse / postToolUse / sessionStart / userPromptSubmitted / agentStop /
+ * preCompact. Per the copilot-cli changelog, PascalCase event names are ALSO
+ * accepted and fire — the CLI loads hook configs across VS Code, Claude Code,
+ * and the CLI by accepting PascalCase event names alongside camelCase
+ * (copilot-cli changelog.md:1065; see also :811 and :1081). We register the
+ * camelCase KEYS below because they are the CLI's native names, not because
+ * PascalCase would fail. The CLI dispatch token (the `.mjs` script base, e.g.
+ * `pretooluse`) is independent and stays lowercase via buildHookCommand, so
+ * changing the event casing does not change the dispatcher.
+ */
+export declare const HOOK_TYPES: {
+    readonly PRE_TOOL_USE: "preToolUse";
+    readonly POST_TOOL_USE: "postToolUse";
+    readonly PRE_COMPACT: "preCompact";
+    readonly SESSION_START: "sessionStart";
+    readonly USER_PROMPT_SUBMIT: "userPromptSubmitted";
+    readonly STOP: "agentStop";
+};
+export type HookType = (typeof HOOK_TYPES)[keyof typeof HOOK_TYPES];
+export declare const HOOK_SCRIPTS: Record<string, string>;
+export declare const REQUIRED_HOOKS: HookType[];
+export declare const OPTIONAL_HOOKS: HookType[];
+export declare function isContextModeHook(entry: {
+    command?: string;
+    hooks?: Array<{
+        command?: string;
+    }>;
+}, hookType: HookType): boolean;
+export declare function buildHookCommand(hookType: HookType, _pluginRoot?: string): string;

package/build/adapters/copilot-cli/hooks.js

@@ -0,0 +1,64 @@
+/**
+ * adapters/copilot-cli/hooks — GitHub Copilot CLI hook definitions.
+ *
+ * GitHub Copilot CLI's native hook events are the camelCase names
+ * preToolUse / postToolUse / sessionStart / userPromptSubmitted / agentStop /
+ * preCompact. Per the copilot-cli changelog, PascalCase event names are ALSO
+ * accepted and fire — the CLI loads hook configs across VS Code, Claude Code,
+ * and the CLI by accepting PascalCase event names alongside camelCase
+ * (copilot-cli changelog.md:1065; see also :811 and :1081). We register the
+ * camelCase KEYS below because they are the CLI's native names, not because
+ * PascalCase would fail. The CLI dispatch token (the `.mjs` script base, e.g.
+ * `pretooluse`) is independent and stays lowercase via buildHookCommand, so
+ * changing the event casing does not change the dispatcher.
+ */
+export const HOOK_TYPES = {
+    PRE_TOOL_USE: "preToolUse",
+    POST_TOOL_USE: "postToolUse",
+    PRE_COMPACT: "preCompact",
+    SESSION_START: "sessionStart",
+    // Copilot CLI 1.0.60 fires userPromptSubmitted + agentStop (verified against
+    // the @github/copilot binary). Used for user-prompt + session-end capture,
+    // same as the codex/kimi adapters.
+    USER_PROMPT_SUBMIT: "userPromptSubmitted",
+    STOP: "agentStop",
+};
+export const HOOK_SCRIPTS = {
+    [HOOK_TYPES.PRE_TOOL_USE]: "pretooluse.mjs",
+    [HOOK_TYPES.POST_TOOL_USE]: "posttooluse.mjs",
+    [HOOK_TYPES.PRE_COMPACT]: "precompact.mjs",
+    [HOOK_TYPES.SESSION_START]: "sessionstart.mjs",
+    [HOOK_TYPES.USER_PROMPT_SUBMIT]: "userpromptsubmit.mjs",
+    [HOOK_TYPES.STOP]: "stop.mjs",
+};
+export const REQUIRED_HOOKS = [
+    HOOK_TYPES.PRE_TOOL_USE,
+    HOOK_TYPES.SESSION_START,
+];
+export const OPTIONAL_HOOKS = [
+    HOOK_TYPES.POST_TOOL_USE,
+    HOOK_TYPES.PRE_COMPACT,
+    HOOK_TYPES.USER_PROMPT_SUBMIT,
+    HOOK_TYPES.STOP,
+];
+export function isContextModeHook(entry, hookType) {
+    const scriptName = HOOK_SCRIPTS[hookType];
+    if (!scriptName)
+        return false;
+    const cliCommand = buildHookCommand(hookType);
+    if (entry.command?.includes(cliCommand) || entry.command?.includes(scriptName)) {
+        return true;
+    }
+    return (entry.hooks?.some((h) => h.command?.includes(scriptName) || h.command?.includes(cliCommand)) ?? false);
+}
+export function buildHookCommand(hookType, _pluginRoot) {
+    const scriptName = HOOK_SCRIPTS[hookType];
+    if (!scriptName) {
+        throw new Error(`No script defined for hook type: ${hookType}`);
+    }
+    // The CLI dispatch token is the script base (pretooluse, posttooluse, …), NOT
+    // the camelCase host event name — keep them decoupled so the event KEY stays
+    // Copilot's camelCase while the dispatcher token (and the cli.ts hook handler)
+    // remain stable regardless of how the host names its events.
+    return `context-mode hook copilot-cli ${scriptName.replace(/\.mjs$/, "")}`;
+}

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

@@ -0,0 +1,48 @@
+/**
+ * adapters/copilot-cli — GitHub Copilot CLI adapter.
+ *
+ * Native config:
+ *   - MCP:   $COPILOT_HOME/mcp-config.json or ~/.copilot/mcp-config.json
+ *            under root key `mcpServers`.
+ *   - Hooks: $COPILOT_HOME/hooks/context-mode.json or
+ *            ~/.copilot/hooks/context-mode.json.
+ *
+ * Hooks use Copilot CLI's native camelCase event keys (preToolUse /
+ * postToolUse / sessionStart / userPromptSubmitted / agentStop / preCompact)
+ * with flat `{ type, command }` entries. (The CLI also accepts PascalCase
+ * event names alongside camelCase — copilot-cli changelog.md:1065 — so the
+ * casing is not load-bearing; we use camelCase because it is the CLI's native
+ * naming.) Copilot CLI's command output contract is top-level
+ * (`permissionDecision`, `modifiedArgs`, `additionalContext`), so this adapter
+ * overrides the response formatter from CopilotBaseAdapter.
+ */
+import { CopilotBaseAdapter } from "../copilot-base.js";
+import type { CopilotHookInput, CopilotHookModule } from "../copilot-base.js";
+import type { DiagnosticResult, HookRegistration, PostToolUseResponse, PreCompactResponse, PostToolUseEvent, PreToolUseEvent, PreToolUseResponse, SessionStartResponse } from "../types.js";
+export declare function copilotCliHome(): string;
+export declare function copilotCliMcpConfigPath(): string;
+export declare class CopilotCliAdapter extends CopilotBaseAdapter {
+    constructor();
+    readonly name = "GitHub Copilot CLI";
+    protected readonly hookModule: CopilotHookModule;
+    protected readonly hookSubdir = "copilot-cli";
+    protected extractSessionId(input: CopilotHookInput): string;
+    protected getProjectDir(): string;
+    parsePreToolUseInput(raw: unknown): PreToolUseEvent;
+    parsePostToolUseInput(raw: unknown): PostToolUseEvent;
+    getSettingsPath(_projectDir?: string): string;
+    getConfigDir(_projectDir?: string): string;
+    getSessionDir(): string;
+    getInstructionFiles(): string[];
+    generateHookConfig(pluginRoot: string): HookRegistration;
+    writeSettings(settings: Record<string, unknown>): void;
+    configureAllHooks(pluginRoot: string): string[];
+    readSettings(): Record<string, unknown> | null;
+    formatPreToolUseResponse(response: PreToolUseResponse): unknown;
+    formatPostToolUseResponse(response: PostToolUseResponse): unknown;
+    formatPreCompactResponse(response: PreCompactResponse): unknown;
+    formatSessionStartResponse(response: SessionStartResponse): unknown;
+    validateHooks(pluginRoot: string): DiagnosticResult[];
+    checkPluginRegistration(): DiagnosticResult;
+    getInstalledVersion(): string;
+}