@ebowwa/coder 0.7.63 → 0.7.64

package/dist/ecosystem/hooks/index.js

@@ -0,0 +1,294 @@
+/**
+ * Hook System - Lifecycle event handlers
+ */
+import { spawn } from "child_process";
+export class HookManager {
+    hooks = new Map();
+    timeout;
+    promptEvaluator;
+    constructor(timeout = 60000, promptEvaluator) {
+        this.timeout = timeout;
+        this.promptEvaluator = promptEvaluator;
+    }
+    /**
+     * Set the prompt evaluator for LLM-based hooks
+     */
+    setPromptEvaluator(evaluator) {
+        this.promptEvaluator = evaluator;
+    }
+    register(event, definition) {
+        if (!this.hooks.has(event)) {
+            this.hooks.set(event, []);
+        }
+        this.hooks.get(event)?.push(definition);
+    }
+    /**
+     * Register an in-process handler for an event
+     */
+    registerHandler(event, handler, options) {
+        this.register(event, {
+            event,
+            command: "", // Not used for in-process handlers
+            handler,
+            timeout: options?.timeout,
+            enabled: options?.enabled ?? true,
+        });
+    }
+    registerAll(hooks) {
+        for (const [event, definitions] of Object.entries(hooks)) {
+            for (const def of definitions) {
+                this.register(event, def);
+            }
+        }
+    }
+    async execute(event, input) {
+        const definitions = this.hooks.get(event);
+        if (!definitions || definitions.length === 0) {
+            return { decision: "allow" };
+        }
+        const fullInput = {
+            ...input,
+            event,
+            timestamp: Date.now(),
+        };
+        for (const def of definitions) {
+            if (def.enabled === false)
+                continue;
+            // Check matcher if present
+            if (def._matcher && input.tool_name) {
+                try {
+                    const regex = new RegExp(def._matcher);
+                    if (!regex.test(input.tool_name)) {
+                        // Matcher doesn't match, skip this hook
+                        continue;
+                    }
+                }
+                catch {
+                    // Invalid regex, skip
+                    continue;
+                }
+            }
+            const result = await this.executeHook(def, fullInput);
+            if (result.decision === "deny" || result.decision === "block") {
+                return result;
+            }
+            // Apply modified input if provided
+            if (result.modified_input) {
+                Object.assign(input, result.modified_input);
+            }
+        }
+        return { decision: "allow" };
+    }
+    async executeHook(def, input) {
+        // If handler function is provided, use it directly
+        if (def.handler) {
+            try {
+                return await def.handler(input);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    decision: "deny",
+                    reason: `Hook handler error: ${errorMessage}`,
+                    errors: [errorMessage],
+                };
+            }
+        }
+        // If prompt is provided, use LLM evaluation
+        if (def.prompt && this.promptEvaluator) {
+            try {
+                return await this.promptEvaluator(def.prompt, input);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    decision: "deny",
+                    reason: `Prompt hook error: ${errorMessage}`,
+                    errors: [errorMessage],
+                };
+            }
+        }
+        // Skip hooks with empty commands (e.g., prompt-type hooks without evaluator)
+        if (!def.command || def.command.trim() === "") {
+            // Allow the operation to proceed if there's no command to execute
+            return { decision: "allow" };
+        }
+        // Shell command execution
+        const timeout = def.timeout || this.timeout;
+        try {
+            const result = await new Promise((resolve, reject) => {
+                const proc = spawn(def.command, [], {
+                    shell: true,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                let stdout = "";
+                let stderr = "";
+                let timedOut = false;
+                const timer = setTimeout(() => {
+                    timedOut = true;
+                    proc.kill();
+                    resolve({
+                        decision: "deny",
+                        reason: "Hook timeout",
+                        errors: ["Hook execution timed out"],
+                    });
+                }, timeout);
+                proc.stdout?.on("data", (data) => {
+                    stdout += data.toString();
+                });
+                proc.stderr?.on("data", (data) => {
+                    stderr += data.toString();
+                });
+                proc.on("close", (code) => {
+                    clearTimeout(timer);
+                    if (timedOut)
+                        return; // Already resolved
+                    // Try to parse JSON from stdout first (works for all exit codes)
+                    let parsedOutput = null;
+                    if (stdout.trim()) {
+                        try {
+                            parsedOutput = JSON.parse(stdout);
+                        }
+                        catch {
+                            // stdout not valid JSON, ignore
+                        }
+                    }
+                    if (code === 0) {
+                        // Success - use parsed output or default to allow
+                        resolve(parsedOutput || { decision: "allow" });
+                    }
+                    else if (code === 1) {
+                        // Deny - use parsed output or fall back to stderr
+                        if (parsedOutput) {
+                            resolve(parsedOutput);
+                        }
+                        else {
+                            resolve({
+                                decision: "deny",
+                                reason: stderr || "Hook denied execution",
+                                errors: stderr ? [stderr] : ["Hook denied execution"],
+                            });
+                        }
+                    }
+                    else if (code === 2) {
+                        // Block - use parsed output or fall back to stderr
+                        if (parsedOutput) {
+                            resolve(parsedOutput);
+                        }
+                        else {
+                            resolve({
+                                decision: "block",
+                                reason: stderr || "Hook blocked execution",
+                                errors: stderr ? [stderr] : ["Hook blocked execution"],
+                            });
+                        }
+                    }
+                    else {
+                        // Other error - default to deny
+                        resolve({
+                            decision: "deny",
+                            reason: `Hook exited with code ${code}`,
+                            errors: [`Hook exited with code ${code}`],
+                        });
+                    }
+                });
+                proc.on("error", (error) => {
+                    clearTimeout(timer);
+                    resolve({
+                        decision: "deny",
+                        reason: `Hook error: ${error.message}`,
+                        errors: [error.message],
+                    });
+                });
+                // Send input via stdin
+                proc.stdin?.write(JSON.stringify(input));
+                proc.stdin?.end();
+            });
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                decision: "deny",
+                reason: `Hook execution failed: ${errorMessage}`,
+                errors: [errorMessage],
+            };
+        }
+    }
+    getHooks(event) {
+        return this.hooks.get(event) || [];
+    }
+    clear(event) {
+        if (event) {
+            this.hooks.delete(event);
+        }
+        else {
+            this.hooks.clear();
+        }
+    }
+}
+// ============================================
+// BUILT-IN HOOKS
+// ============================================
+export const builtInHooks = {
+    /**
+     * Example: Validate file paths before write
+     */
+    validateWrite: {
+        event: "PreToolUse",
+        command: `node -e '
+      const input = JSON.parse(require("fs").readFileSync(0, "utf8"));
+      if (input.tool_name === "Write") {
+        const path = input.tool_input.file_path;
+        if (path.includes("..") || path.startsWith("/etc/")) {
+          console.log(JSON.stringify({ decision: "deny", reason: "Unsafe path" }));
+          process.exit(1);
+        }
+      }
+      console.log(JSON.stringify({ decision: "allow" }));
+    '`,
+        timeout: 5000,
+        enabled: false,
+    },
+    /**
+     * Example: Log all tool uses
+     */
+    logToolUse: {
+        event: "PostToolUse",
+        command: `node -e '
+      const input = JSON.parse(require("fs").readFileSync(0, "utf8"));
+      console.error(\`[LOG] Tool: \${input.tool_name}\`);
+      console.log(JSON.stringify({ decision: "allow" }));
+    '`,
+        timeout: 5000,
+        enabled: false,
+    },
+};
+// ============================================
+// HOOK EVENT DOCUMENTATION
+// ============================================
+export const hookEventDocs = {
+    PreToolUse: "Before a tool is executed. Can modify input or deny execution.",
+    PostToolUse: "After a tool successfully executes. Can process result.",
+    PostToolUseFailure: "After a tool fails. Can handle error or retry.",
+    Stop: "When the agent stops (end_turn, max_tokens, error).",
+    UserPromptSubmit: "When user submits a prompt. Can modify or reject.",
+    SessionStart: "When a new session starts.",
+    SessionEnd: "When a session ends.",
+    Notification: "When a notification is sent.",
+    ConfigChange: "When configuration changes.",
+    WorktreeCreate: "When a git worktree is created.",
+};
+/**
+ * Exit codes for hook commands:
+ * 0 = Success, allow execution
+ * 1 = Show stderr, deny execution
+ * 2 = Block execution silently
+ */
+export const hookExitCodes = {
+    ALLOW: 0,
+    DENY: 1,
+    BLOCK: 2,
+};
+// Re-export prompt evaluator utilities
+export { createPromptEvaluator, createMockPromptEvaluator } from "./prompt-evaluator.js";

package/dist/ecosystem/hooks/prompt-evaluator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Prompt Evaluator - LLM-based hook evaluation
+ *
+ * Evaluates hook prompts by calling the Claude API to make decisions
+ * about tool execution based on natural language rules.
+ */
+import type { PromptEvaluator } from "./index.js";
+/**
+ * Options for creating a prompt evaluator
+ */
+export interface PromptEvaluatorOptions {
+    /** Anthropic API key */
+    apiKey: string;
+    /** Model to use for evaluation (default: claude-haiku-4-5 for speed) */
+    model?: string;
+    /** Max tokens for response (default: 256) */
+    maxTokens?: number;
+    /** System prompt for the evaluator */
+    systemPrompt?: string;
+    /** Base URL for API (default: from ANTHROPIC_BASE_URL env or https://api.anthropic.com) */
+    baseUrl?: string;
+}
+/**
+ * Create a prompt evaluator that uses the Claude API
+ */
+export declare function createPromptEvaluator(options: PromptEvaluatorOptions): PromptEvaluator;
+/**
+ * Create a mock prompt evaluator for testing
+ * Returns canned responses based on patterns in the prompt
+ */
+export declare function createMockPromptEvaluator(): PromptEvaluator;
+//# sourceMappingURL=prompt-evaluator.d.ts.map

package/dist/ecosystem/hooks/prompt-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-evaluator.d.ts","sourceRoot":"","sources":["../../../packages/src/ecosystem/hooks/prompt-evaluator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2FAA2F;IAC3F,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAsMD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,GAAG,eAAe,CAwCtF;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,eAAe,CA4B3D"}

package/dist/ecosystem/hooks/prompt-evaluator.js

@@ -0,0 +1,229 @@
+/**
+ * Prompt Evaluator - LLM-based hook evaluation
+ *
+ * Evaluates hook prompts by calling the Claude API to make decisions
+ * about tool execution based on natural language rules.
+ */
+/**
+ * Default system prompt for hook evaluation
+ */
+const DEFAULT_SYSTEM_PROMPT = `You are a hook evaluator for Coder. Your job is to evaluate tool usage against security and best-practice rules.
+
+You MUST respond with ONLY a valid JSON object in this exact format:
+{
+  "decision": "allow" | "deny" | "block",
+  "reason": "Optional explanation for the decision",
+  "modified_input": { ... } // Optional: modified tool input if you want to change it
+}
+
+Rules:
+- "allow": Let the tool execute normally
+- "deny": Prevent execution and show the user the reason
+- "block": Prevent execution silently (no message shown)
+- Only modify input if absolutely necessary and you're certain of the correct format
+
+Be concise and make quick decisions. Do not explain your reasoning in prose - only use the JSON format.`;
+/**
+ * Interpolate variables in a prompt template
+ */
+function interpolatePrompt(template, input) {
+    let result = template;
+    // Replace $ARGUMENTS with tool input as JSON
+    if (input.tool_input) {
+        result = result.replace(/\$ARGUMENTS/g, JSON.stringify(input.tool_input, null, 2));
+    }
+    // Replace $TOOL_NAME with tool name
+    if (input.tool_name) {
+        result = result.replace(/\$TOOL_NAME/g, input.tool_name);
+    }
+    // Replace $EVENT with event name
+    result = result.replace(/\$EVENT/g, input.event);
+    // Replace $SESSION_ID with session ID
+    if (input.session_id) {
+        result = result.replace(/\$SESSION_ID/g, input.session_id);
+    }
+    // Replace $TIMESTAMP with timestamp
+    result = result.replace(/\$TIMESTAMP/g, String(input.timestamp));
+    // Replace $ERROR with error message if present
+    if (input.error) {
+        result = result.replace(/\$ERROR/g, input.error);
+    }
+    // Replace $TOOL_RESULT with tool result if present
+    if (input.tool_result) {
+        const resultStr = typeof input.tool_result.content === "string"
+            ? input.tool_result.content
+            : JSON.stringify(input.tool_result.content);
+        result = result.replace(/\$TOOL_RESULT/g, resultStr);
+    }
+    return result;
+}
+/**
+ * Parse the LLM response into a HookOutput
+ * Supports multiple JSON formats:
+ * 1. Standard: { "decision": "allow" | "deny" | "block", "reason": "..." }
+ * 2. Standard format: { "continue": true/false, "hookSpecificOutput": {...} }
+ */
+function parseHookOutput(responseText) {
+    // Try to extract JSON from the response
+    // The model might wrap it in markdown code blocks or add extra text
+    let parsed = null;
+    // First, try direct parse
+    try {
+        parsed = JSON.parse(responseText);
+    }
+    catch {
+        // Not valid JSON directly
+    }
+    // Try to extract JSON from markdown code block
+    if (!parsed) {
+        const jsonBlockMatch = responseText.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+        if (jsonBlockMatch?.[1]) {
+            try {
+                parsed = JSON.parse(jsonBlockMatch[1].trim());
+            }
+            catch {
+                // Invalid JSON in code block
+            }
+        }
+    }
+    // Try to find JSON object anywhere in the response
+    if (!parsed) {
+        const jsonMatch = responseText.match(/\{[\s\S]*?\}/);
+        if (jsonMatch) {
+            try {
+                parsed = JSON.parse(jsonMatch[0]);
+            }
+            catch {
+                // Invalid JSON
+            }
+        }
+    }
+    if (!parsed) {
+        // If we can't parse JSON, default to allow with a warning
+        return {
+            decision: "allow",
+            reason: "Hook response could not be parsed as JSON, allowing by default",
+        };
+    }
+    // Format 1: Standard { decision: "allow" | "deny" | "block" }
+    if ("decision" in parsed) {
+        return {
+            decision: parsed.decision || "allow",
+            reason: parsed.reason,
+            modified_input: parsed.modified_input,
+        };
+    }
+    // Format 2: Standard { continue: true/false, hookSpecificOutput: {...} }
+    if ("continue" in parsed) {
+        const shouldContinue = Boolean(parsed.continue);
+        if (shouldContinue) {
+            return { decision: "allow" };
+        }
+        // Extract reason from hookSpecificOutput if present
+        const hookOutput = parsed.hookSpecificOutput;
+        const reason = hookOutput?.permissionDecisionReason;
+        return {
+            decision: "deny",
+            reason: reason || "Hook denied execution",
+        };
+    }
+    // Unknown format, default to allow
+    return {
+        decision: "allow",
+        reason: "Unknown hook response format, allowing by default",
+    };
+}
+/**
+ * Make a non-streaming API call to Claude
+ */
+async function callClaudeAPI(apiKey, model, maxTokens, systemPrompt, userPrompt, baseUrl = "https://api.anthropic.com") {
+    const response = await fetch(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify({
+            model,
+            max_tokens: maxTokens,
+            system: systemPrompt,
+            messages: [
+                {
+                    role: "user",
+                    content: userPrompt,
+                },
+            ],
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`API error: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    // Extract text from response
+    const textContent = data.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text || "")
+        .join("");
+    return textContent;
+}
+/**
+ * Create a prompt evaluator that uses the Claude API
+ */
+export function createPromptEvaluator(options) {
+    const { apiKey, model = "claude-haiku-4-5", // Use Haiku for fast evaluation
+    maxTokens = 256, systemPrompt = DEFAULT_SYSTEM_PROMPT, baseUrl = process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com", } = options;
+    return async (promptTemplate, context) => {
+        // Interpolate variables in the prompt
+        const userPrompt = interpolatePrompt(promptTemplate, context);
+        try {
+            // Call the API
+            const responseText = await callClaudeAPI(apiKey, model, maxTokens, systemPrompt, userPrompt, baseUrl);
+            if (!responseText) {
+                return { decision: "allow" };
+            }
+            // Parse the response
+            return parseHookOutput(responseText);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // On error, allow by default but log the issue
+            console.error(`[PromptEvaluator] Error evaluating hook: ${errorMessage}`);
+            return {
+                decision: "allow",
+                reason: `Hook evaluation failed: ${errorMessage}`,
+            };
+        }
+    };
+}
+/**
+ * Create a mock prompt evaluator for testing
+ * Returns canned responses based on patterns in the prompt
+ */
+export function createMockPromptEvaluator() {
+    return async (promptTemplate, context) => {
+        // Simple mock logic for testing
+        const prompt = promptTemplate.toLowerCase();
+        const toolInput = context.tool_input;
+        // If checking for MCP alternatives and we have a Bash command
+        if (prompt.includes("mcp") && toolInput && "command" in toolInput) {
+            const command = String(toolInput.command);
+            // Check for common patterns that have MCP alternatives
+            if (command.includes("git status")) {
+                return {
+                    decision: "deny",
+                    reason: "Consider using the Git MCP tool instead of running git commands directly",
+                };
+            }
+            if (command.includes("gh ")) {
+                return {
+                    decision: "deny",
+                    reason: "Consider using the GitHub MCP tool instead of gh CLI",
+                };
+            }
+        }
+        // Default allow
+        return { decision: "allow" };
+    };
+}

package/dist/ecosystem/skills/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Skill System - Custom agent behaviors
+ */
+import type { ClaudeModel } from "../../types/index.js";
+export interface SkillFile {
+    path: string;
+    name: string;
+    description: string;
+    prompt: string;
+    tools?: string[];
+    model?: ClaudeModel;
+    color?: string;
+    source: "built-in" | "project" | "user";
+}
+/**
+ * Parse a SKILL.md file with YAML frontmatter
+ */
+export declare function parseSkillFile(path: string, source?: "built-in" | "project" | "user"): SkillFile | null;
+export declare class SkillManager {
+    private skills;
+    /**
+     * Load skills from a directory
+     */
+    loadFromDirectory(dir: string, source?: "built-in" | "project" | "user"): number;
+    /**
+     * Get a skill by name
+     */
+    get(name: string): SkillFile | undefined;
+    /**
+     * Get all skills
+     */
+    getAll(): SkillFile[];
+    /**
+     * Check if skill exists
+     */
+    has(name: string): boolean;
+    /**
+     * Get skill names
+     */
+    getNames(): string[];
+}
+/**
+ * Build the skill prompt that gets injected into system prompt
+ */
+export declare function buildSkillPrompt(skill: SkillFile): string;
+export declare const builtInSkills: SkillFile[];
+/**
+ * Check if a message is a skill invocation
+ */
+export declare function isSkillInvocation(message: string): string | null;
+/**
+ * Get skill invocation arguments
+ */
+export declare function getSkillArgs(message: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/ecosystem/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../packages/src/ecosystem/skills/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAmB,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAIzE,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;CACzC;AAMD;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,UAAU,GAAG,SAAS,GAAG,MAAkB,GAAG,SAAS,GAAG,IAAI,CAoClH;AAkDD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAgC;IAE9C;;OAEG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,UAAU,GAAG,SAAS,GAAG,MAAkB,GAAG,MAAM;IAqB3F;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIxC;;OAEG;IACH,MAAM,IAAI,SAAS,EAAE;IAIrB;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;OAEG;IACH,QAAQ,IAAI,MAAM,EAAE;CAGrB;AAMD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CASzD;AAMD,eAAO,MAAM,aAAa,EAAE,SAAS,EAoFpC,CAAC;AAMF;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGpD"}