context-mode 1.0.15 → 1.0.17

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.15"
+    "version": "1.0.17"
   },
   "plugins": [
     {
       "name": "context-mode",
       "source": "./",
       "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-      "version": "1.0.15",
+      "version": "1.0.17",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/README.md

@@ -103,7 +103,13 @@ npm install -g context-mode
 }
 ```
 
-**Step 4 — Restart Gemini CLI.** On first run, a `GEMINI.md` routing instructions file is auto-created in your project root. This works alongside hooks as a parallel enforcement layer — hooks block dangerous commands programmatically, while `GEMINI.md` teaches the model to prefer sandbox tools from the start.
+**Step 4 — Restart Gemini CLI.** On first session start, the sessionstart hook automatically manages `GEMINI.md` routing instructions in your project root:
+
+- **File does not exist** — the routing instructions file is written.
+- **File exists without context-mode rules** — routing instructions are appended after your existing content.
+- **File already contains context-mode rules** — skipped (idempotent, no duplicate content).
+
+This works alongside hooks as a parallel enforcement layer — hooks block dangerous commands programmatically, while `GEMINI.md` teaches the model to prefer sandbox tools from the start.
 
 > **Why hooks matter:** Without hooks, context-mode relies on `GEMINI.md` instructions alone (~60% compliance). The model sometimes follows them, but regularly runs raw `curl`, reads large files directly, or dumps unprocessed output into context — a single unrouted Playwright snapshot (56 KB) wipes out an entire session's savings. With hooks, every tool call is intercepted before execution — dangerous commands are blocked, and routing guidance is injected in real-time. This is the difference between ~60% and ~98% context savings.
 
@@ -150,7 +156,13 @@ npm install -g context-mode
 }
 ```
 
-**Step 4 — Restart VS Code.** On first run, a `.github/copilot-instructions.md` routing instructions file is auto-created in your project. This works alongside hooks as a parallel enforcement layer — hooks intercept tool calls programmatically, while `copilot-instructions.md` guides the model's tool selection from session start.
+**Step 4 — Restart VS Code.** On first session start, the sessionstart hook automatically manages `.github/copilot-instructions.md` routing instructions in your project:
+
+- **File does not exist** — `.github/` is created and the routing instructions file is written.
+- **File exists without context-mode rules** — routing instructions are appended after your existing content, preserving project-level coding standards.
+- **File already contains context-mode rules** — skipped (idempotent, no duplicate content).
+
+This works alongside hooks as a parallel enforcement layer — hooks intercept tool calls programmatically, while `copilot-instructions.md` guides the model's tool selection from session start.
 
 > **Why hooks matter:** Without hooks, `copilot-instructions.md` guides the model but can't block commands. A single unrouted Playwright snapshot (56 KB) or `gh issue list` (59 KB) wipes out minutes of context savings. With hooks, these calls are intercepted and redirected to the sandbox before they execute.
 
@@ -158,6 +170,61 @@ Full hook config including PreCompact: [`configs/vscode-copilot/hooks.json`](con
 
 </details>
 
+<details>
+<summary><strong>Cursor</strong> <sup>(Beta)</sup></summary>
+
+**Step 1 — Install globally:**
+
+```bash
+npm install -g context-mode
+```
+
+**Step 2 — Register the MCP server.** Create `.cursor/mcp.json` in your project root or `~/.cursor/mcp.json` for a global install:
+
+```json
+{
+  "mcpServers": {
+    "context-mode": {
+      "command": "context-mode"
+    }
+  }
+}
+```
+
+**Step 3 — Add native Cursor hooks.** Cursor v1 support uses native `.cursor/hooks.json` or `~/.cursor/hooks.json` only. Create either path with:
+
+```json
+{
+  "version": 1,
+  "hooks": {
+    "preToolUse": [
+      {
+        "command": "context-mode hook cursor pretooluse",
+        "matcher": "Shell|Read|Grep|WebFetch|Task|MCP:ctx_execute|MCP:ctx_execute_file|MCP:ctx_batch_execute"
+      }
+    ],
+    "postToolUse": [
+      {
+        "command": "context-mode hook cursor posttooluse"
+      }
+    ]
+  }
+}
+```
+
+Note: the `preToolUse` hook matcher is optional. If you don't provide it, the hook will fire on all tools.
+
+**Step 4 — Restart Cursor or open a new agent session.** On first MCP server startup, routing instructions are auto-written to your project (same mechanism as Codex CLI).
+
+> **Native Cursor scope:** `preToolUse` and `postToolUse` are supported. `sessionStart` is documented by Cursor but currently rejected by their validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)), so routing instructions are delivered via MCP server startup instead.
+>
+> **Config precedence:** project `.cursor/hooks.json` overrides `~/.cursor/hooks.json`.
+
+Full native hook config: [`configs/cursor/hooks.json`](configs/cursor/hooks.json)  
+Example MCP registration: [`configs/cursor/mcp.json`](configs/cursor/mcp.json)
+
+</details>
+
 <details>
 <summary><strong>OpenCode</strong> <sup>(Beta)</sup></summary>
 
@@ -184,7 +251,13 @@ npm install -g context-mode
 
 The `mcp` entry gives you the 6 sandbox tools. The `plugin` entry enables hooks — OpenCode calls the plugin's TypeScript functions directly before and after each tool execution, blocking dangerous commands (like raw `curl`) and enforcing sandbox routing.
 
-**Step 3 — Restart OpenCode.** On first run, an `AGENTS.md` routing instructions file is auto-created in your project root. This works alongside the plugin as a parallel enforcement layer — the plugin intercepts tool calls at runtime, while `AGENTS.md` guides the model's tool preferences from session start.
+**Step 3 — Restart OpenCode.** On first plugin init, the plugin automatically manages `AGENTS.md` routing instructions in your project root:
+
+- **File does not exist** — the routing instructions file is written.
+- **File exists without context-mode rules** — routing instructions are appended after your existing content.
+- **File already contains context-mode rules** — skipped (idempotent, no duplicate content).
+
+This works alongside the plugin as a parallel enforcement layer — the plugin intercepts tool calls at runtime, while `AGENTS.md` guides the model's tool preferences from session start.
 
 > **Why the plugin matters:** Without the `plugin` entry, context-mode has no way to intercept tool calls. The model can run raw `curl`, read large files directly, or dump unprocessed output into context — ignoring `AGENTS.md` instructions. With the plugin, `tool.execute.before` fires on every tool call and blocks or redirects data-heavy commands before they execute. The `experimental.session.compacting` hook builds and injects resume snapshots when the conversation compacts, preserving session state.
 >
@@ -278,15 +351,15 @@ Context Mode captures every meaningful event during your session and persists th
 
 Session continuity requires 4 hooks working together:
 
-| Hook | Role | Claude Code | Gemini CLI | VS Code Copilot | OpenCode | Codex CLI |
-|---|---|:---:|:---:|:---:|:---:|:---:|
-| **PostToolUse** | Captures events after each tool call | Yes | Yes | Yes | Plugin | -- |
-| **UserPromptSubmit** | Captures user decisions and corrections | Yes | -- | -- | -- | -- |
-| **PreCompact** | Builds snapshot before compaction | Yes | Yes | Yes | Plugin | -- |
-| **SessionStart** | Restores state after compaction | Yes | Yes | Yes | -- | -- |
-| | **Session completeness** | **Full** | **High** | **High** | **High** | **--** |
+| Hook | Role | Claude Code | Gemini CLI | VS Code Copilot | Cursor | OpenCode | Codex CLI |
+|---|---|:---:|:---:|:---:|:---:|:---:|:---:|
+| **PostToolUse** | Captures events after each tool call | Yes | Yes | Yes | Yes | Plugin | -- |
+| **UserPromptSubmit** | Captures user decisions and corrections | Yes | -- | -- | -- | -- | -- |
+| **PreCompact** | Builds snapshot before compaction | Yes | Yes | Yes | -- | Plugin | -- |
+| **SessionStart** | Restores state after compaction or resume | Yes | Yes | Yes | -- | -- | -- |
+| | **Session completeness** | **Full** | **High** | **High** | **Partial** | **High** | **--** |
 
-> **Note:** Full session continuity (capture + snapshot + restore) works on **Claude Code**, **Gemini CLI**, **VS Code Copilot**, and **OpenCode**. OpenCode uses the `experimental.session.compacting` plugin hook for compaction recovery — SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), so startup/resume is not supported. Codex CLI has no hook support, so session tracking is not available.
+> **Note:** Full session continuity (capture + snapshot + restore) works on **Claude Code**, **Gemini CLI**, **VS Code Copilot**, and **OpenCode**. **Cursor** captures tool events via `preToolUse`/`postToolUse`, but `sessionStart` is currently rejected by Cursor's validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)), so session restore after compaction is not available yet. **OpenCode** uses the `experimental.session.compacting` plugin hook for compaction recovery, but SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), so startup/resume is not supported. Codex CLI has no hook support, so session tracking is not available.
 
 <details>
 <summary><strong>What gets captured</strong></summary>
@@ -361,6 +434,8 @@ Detailed event data is also indexed into FTS5 for on-demand retrieval via `searc
 
 **VS Code Copilot** — High coverage. Same as Gemini CLI — PostToolUse, PreCompact, and SessionStart all fire. User decisions aren't captured but all tool-level events are.
 
+**Cursor** — Partial coverage. Native `preToolUse` and `postToolUse` hooks capture tool events. `sessionStart` is documented by Cursor but currently rejected by their validator, so session restore is not available. Routing instructions are delivered via MCP server startup instead.
+
 **OpenCode** — Partial. The TypeScript plugin captures PostToolUse events via `tool.execute.after`, but SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)). Events are stored but not automatically restored after compaction. The `AGENTS.md` routing instructions file compensates by re-teaching tool preferences at each session start.
 
 **Codex CLI** — No session support. No hooks means no event capture. Each compaction or new session starts fresh. The `AGENTS.md` routing instructions file is the only continuity mechanism.
@@ -369,17 +444,18 @@ Detailed event data is also indexed into FTS5 for on-demand retrieval via `searc
 
 ## Platform Compatibility
 
-| Feature | Claude Code | Gemini CLI <sup>(Beta)</sup> | VS Code Copilot <sup>(Beta)</sup> | OpenCode <sup>(Beta)</sup> | Codex CLI <sup>(Beta)</sup> |
-|---|:---:|:---:|:---:|:---:|:---:|
-| MCP Server | Yes | Yes | Yes | Yes | Yes |
-| PreToolUse Hook | Yes | Yes | Yes | Plugin | -- |
-| PostToolUse Hook | Yes | Yes | Yes | Plugin | -- |
-| SessionStart Hook | Yes | Yes | Yes | -- | -- |
-| Can Modify Args | Yes | Yes | Yes | Plugin | -- |
-| Can Block Tools | Yes | Yes | Yes | Plugin | -- |
-| Utility Commands (ctx) | Yes | Yes | Yes | Yes | Yes |
-| Slash Commands | Yes | -- | -- | -- | -- |
-| Plugin Marketplace | Yes | -- | -- | -- | -- |
+| Feature | Claude Code | Gemini CLI <sup>(Beta)</sup> | VS Code Copilot <sup>(Beta)</sup> | Cursor <sup>(Beta)</sup> | OpenCode <sup>(Beta)</sup> | Codex CLI <sup>(Beta)</sup> |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|
+| MCP Server | Yes | Yes | Yes | Yes | Yes | Yes |
+| PreToolUse Hook | Yes | Yes | Yes | Yes | Plugin | -- |
+| PostToolUse Hook | Yes | Yes | Yes | Yes | Plugin | -- |
+| SessionStart Hook | Yes | Yes | Yes | -- | -- | -- |
+| PreCompact Hook | Yes | Yes | Yes | -- | Plugin | -- |
+| Can Modify Args | Yes | Yes | Yes | Yes | Plugin | -- |
+| Can Block Tools | Yes | Yes | Yes | Yes | Plugin | -- |
+| Utility Commands (ctx) | Yes | Yes | Yes | Yes | Yes | Yes |
+| Slash Commands | Yes | -- | -- | -- | -- | -- |
+| Plugin Marketplace | Yes | -- | -- | -- | -- | -- |
 
 > **OpenCode** uses a TypeScript plugin paradigm — hooks run as in-process functions via `tool.execute.before`, `tool.execute.after`, and `experimental.session.compacting`, providing the same routing enforcement and session continuity as shell-based hooks. SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), but compaction recovery works via the plugin's compacting hook.
 >
@@ -394,6 +470,7 @@ Hooks intercept tool calls programmatically — they can block dangerous command
 | Claude Code | Yes (auto) | [`CLAUDE.md`](configs/claude-code/CLAUDE.md) | **~98% saved** | ~60% saved |
 | Gemini CLI | Yes | [`GEMINI.md`](configs/gemini-cli/GEMINI.md) | **~98% saved** | ~60% saved |
 | VS Code Copilot | Yes | [`copilot-instructions.md`](configs/vscode-copilot/copilot-instructions.md) | **~98% saved** | ~60% saved |
+| Cursor | Yes | -- | **~98% saved** | Manual tool choice |
 | OpenCode | Plugin | [`AGENTS.md`](configs/opencode/AGENTS.md) | **~98% saved** | ~60% saved |
 | Codex CLI | -- | [`AGENTS.md`](configs/codex/AGENTS.md) | -- | ~60% saved |
 

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

@@ -34,6 +34,10 @@ export declare class ClaudeCodeAdapter implements HookAdapter {
     readSettings(): Record<string, unknown> | null;
     writeSettings(settings: Record<string, unknown>): void;
     validateHooks(pluginRoot: string): DiagnosticResult[];
+    /** Read plugin hooks from hooks/hooks.json or .claude-plugin/hooks/hooks.json */
+    private readPluginHooks;
+    /** Check if a hook type is configured in either settings.json or plugin hooks */
+    private checkHookType;
     checkPluginRegistration(): DiagnosticResult;
     getInstalledVersion(): string;
     configureAllHooks(pluginRoot: string): string[];

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

@@ -240,49 +240,65 @@ export class ClaudeCodeAdapter {
             return results;
         }
         const hooks = settings.hooks;
-        // Check PreToolUse
-        const preToolUse = hooks?.PreToolUse;
-        if (preToolUse && preToolUse.length > 0) {
-            const hasHook = preToolUse.some((entry) => isContextModeHook(entry, HOOK_TYPES.PRE_TOOL_USE));
-            results.push({
-                check: "PreToolUse hook",
-                status: hasHook ? "pass" : "fail",
-                message: hasHook
-                    ? "PreToolUse hook configured"
-                    : "PreToolUse exists but does not point to pretooluse.mjs",
-                fix: hasHook ? undefined : "context-mode upgrade",
-            });
-        }
-        else {
-            results.push({
-                check: "PreToolUse hook",
-                status: "fail",
-                message: "No PreToolUse hooks found",
-                fix: "context-mode upgrade",
-            });
+        // 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;
+    }
+    /** 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 */ }
         }
-        // Check SessionStart
-        const sessionStart = hooks?.SessionStart;
-        if (sessionStart && sessionStart.length > 0) {
-            const hasHook = sessionStart.some((entry) => isContextModeHook(entry, HOOK_TYPES.SESSION_START));
-            results.push({
-                check: "SessionStart hook",
-                status: hasHook ? "pass" : "fail",
-                message: hasHook
-                    ? "SessionStart hook configured"
-                    : "SessionStart exists but does not point to sessionstart.mjs",
-                fix: hasHook ? undefined : "context-mode upgrade",
-            });
+        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;
+            }
         }
-        else {
-            results.push({
-                check: "SessionStart hook",
-                status: "fail",
-                message: "No SessionStart hooks found",
-                fix: "context-mode upgrade",
-            });
+        // Fallback: check plugin hooks.json
+        const fromPlugin = pluginHooks?.[hookType];
+        if (fromPlugin && fromPlugin.length > 0) {
+            if (fromPlugin.some((entry) => isContextModeHook(entry, hookType))) {
+                return true;
+            }
         }
-        return results;
+        return false;
     }
     checkPluginRegistration() {
         const settings = this.readSettings();

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

@@ -0,0 +1,4 @@
+/**
+ * adapters/cursor/config — Thin re-exports from CursorAdapter.
+ */
+export { CursorAdapter } from "./index.js";

package/build/adapters/cursor/config.js

@@ -0,0 +1,4 @@
+/**
+ * adapters/cursor/config — Thin re-exports from CursorAdapter.
+ */
+export { CursorAdapter } from "./index.js";

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

@@ -0,0 +1,40 @@
+/**
+ * adapters/cursor/hooks — Cursor hook definitions and config helpers.
+ *
+ * Cursor native hook config lives in `.cursor/hooks.json` or `~/.cursor/hooks.json`.
+ * Unlike Claude/Gemini/VS Code Copilot, each hook entry is a flat object rather
+ * than a `{ matcher, hooks: [...] }` wrapper.
+ */
+/** Cursor hook type names. */
+export declare const HOOK_TYPES: {
+    readonly PRE_TOOL_USE: "preToolUse";
+    readonly POST_TOOL_USE: "postToolUse";
+    readonly SESSION_START: "sessionStart";
+};
+export type HookType = (typeof HOOK_TYPES)[keyof typeof HOOK_TYPES];
+/** Map of hook types to their script file names. */
+export declare const HOOK_SCRIPTS: Record<HookType, string>;
+/** Canonical Cursor-native matchers for tools context-mode routes proactively. */
+export declare const PRE_TOOL_USE_MATCHERS: readonly ["Shell", "Read", "Grep", "WebFetch", "mcp_web_fetch", "mcp_fetch_tool", "Task", "MCP:ctx_execute", "MCP:ctx_execute_file", "MCP:ctx_batch_execute"];
+export declare const PRE_TOOL_USE_MATCHER_PATTERN: string;
+/** Required hooks for native Cursor support. */
+export declare const REQUIRED_HOOKS: HookType[];
+/** Optional hooks that improve behavior but aren't strictly required. */
+export declare const OPTIONAL_HOOKS: HookType[];
+/** Minimal native Cursor hook entry shape. */
+export interface CursorHookCommandEntry {
+    type?: string;
+    command?: string;
+    matcher?: string;
+    timeout?: number;
+    loop_limit?: number | null;
+    failClosed?: boolean;
+}
+/** Check whether a native Cursor hook entry points to context-mode. */
+export declare function isContextModeHook(entry: CursorHookCommandEntry | {
+    hooks?: Array<{
+        command?: string;
+    }>;
+}, hookType: HookType): boolean;
+/** Build the CLI dispatcher command for a Cursor hook type. */
+export declare function buildHookCommand(hookType: HookType): string;

package/build/adapters/cursor/hooks.js

@@ -0,0 +1,53 @@
+/**
+ * adapters/cursor/hooks — Cursor hook definitions and config helpers.
+ *
+ * Cursor native hook config lives in `.cursor/hooks.json` or `~/.cursor/hooks.json`.
+ * Unlike Claude/Gemini/VS Code Copilot, each hook entry is a flat object rather
+ * than a `{ matcher, hooks: [...] }` wrapper.
+ */
+/** Cursor hook type names. */
+export const HOOK_TYPES = {
+    PRE_TOOL_USE: "preToolUse",
+    POST_TOOL_USE: "postToolUse",
+    SESSION_START: "sessionStart",
+};
+/** Map of hook types to their script file names. */
+export const HOOK_SCRIPTS = {
+    [HOOK_TYPES.PRE_TOOL_USE]: "pretooluse.mjs",
+    [HOOK_TYPES.POST_TOOL_USE]: "posttooluse.mjs",
+    [HOOK_TYPES.SESSION_START]: "sessionstart.mjs",
+};
+/** Canonical Cursor-native matchers for tools context-mode routes proactively. */
+export const PRE_TOOL_USE_MATCHERS = [
+    "Shell",
+    "Read",
+    "Grep",
+    "WebFetch",
+    "mcp_web_fetch",
+    "mcp_fetch_tool",
+    "Task",
+    "MCP:ctx_execute",
+    "MCP:ctx_execute_file",
+    "MCP:ctx_batch_execute",
+];
+export const PRE_TOOL_USE_MATCHER_PATTERN = PRE_TOOL_USE_MATCHERS.join("|");
+/** Required hooks for native Cursor support. */
+export const REQUIRED_HOOKS = [
+    HOOK_TYPES.PRE_TOOL_USE,
+];
+/** Optional hooks that improve behavior but aren't strictly required. */
+export const OPTIONAL_HOOKS = [HOOK_TYPES.POST_TOOL_USE];
+/** Check whether a native Cursor hook entry points to context-mode. */
+export function isContextModeHook(entry, hookType) {
+    const scriptName = HOOK_SCRIPTS[hookType];
+    const cliCommand = buildHookCommand(hookType);
+    if ("command" in entry) {
+        return entry.command?.includes(scriptName) || entry.command?.includes(cliCommand) || false;
+    }
+    const wrappedEntry = entry;
+    return (wrappedEntry.hooks?.some((hook) => hook.command?.includes(scriptName) || hook.command?.includes(cliCommand)) ?? false);
+}
+/** Build the CLI dispatcher command for a Cursor hook type. */
+export function buildHookCommand(hookType) {
+    return `context-mode hook cursor ${hookType.toLowerCase()}`;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * adapters/cursor — Cursor platform adapter.
+ *
+ * Native Cursor hooks use lower-camel hook names and flat command entries in
+ * `.cursor/hooks.json` / `~/.cursor/hooks.json`.
+ */
+import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, SessionStartResponse, HookRegistration, RoutingInstructionsConfig } from "../types.js";
+export declare class CursorAdapter implements HookAdapter {
+    readonly name = "Cursor";
+    readonly paradigm: HookParadigm;
+    readonly capabilities: PlatformCapabilities;
+    parsePreToolUseInput(raw: unknown): PreToolUseEvent;
+    parsePostToolUseInput(raw: unknown): PostToolUseEvent;
+    parseSessionStartInput(raw: unknown): SessionStartEvent;
+    formatPreToolUseResponse(response: PreToolUseResponse): unknown;
+    formatPostToolUseResponse(response: PostToolUseResponse): 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;
+    validateHooks(_pluginRoot: string): DiagnosticResult[];
+    checkPluginRegistration(): DiagnosticResult;
+    getInstalledVersion(): string;
+    configureAllHooks(_pluginRoot: string): string[];
+    backupSettings(): string | null;
+    setHookPermissions(pluginRoot: string): string[];
+    updatePluginRegistry(_pluginRoot: string, _version: string): void;
+    getRoutingInstructionsConfig(): RoutingInstructionsConfig;
+    writeRoutingInstructions(_projectDir: string, _pluginRoot: string): string | null;
+    private getCandidateHookConfigPaths;
+    private getProjectDir;
+    private extractSessionId;
+    private loadNativeHookConfig;
+    private hasClaudeCompatibilityHooks;
+    private upsertHookEntry;
+}