alchemylab 1.0.4 → 1.0.6

package/dist/plugins/hooks/condition-evaluator.js

@@ -1,109 +0,0 @@
-"use strict";
-/**
- * Hook Condition Evaluator
- *
- * Evaluates hook conditions against event variables to determine
- * if a hook should be triggered.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateSingleCondition = evaluateSingleCondition;
-exports.evaluatePathsCondition = evaluatePathsCondition;
-exports.evaluateCondition = evaluateCondition;
-/**
- * Simple glob-to-regex converter for pattern matching
- * Handles common glob patterns without external dependencies
- */
-function globToRegex(pattern) {
-    // Escape regex special chars except * and ?
-    let regex = pattern
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        // Replace ** with a placeholder
-        .replace(/\*\*/g, '{{GLOBSTAR}}')
-        // Replace * with [^/]* (anything except path separator)
-        .replace(/\*/g, '[^/]*')
-        // Replace ? with single char
-        .replace(/\?/g, '.')
-        // Replace globstar placeholder with .* (anything including /)
-        .replace(/\{\{GLOBSTAR\}\}/g, '.*');
-    return new RegExp(`^${regex}$`);
-}
-/**
- * Check if a string matches a glob pattern
- */
-function isMatch(str, pattern) {
-    try {
-        return globToRegex(pattern).test(str);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Evaluate a single condition against the field value
- */
-function evaluateSingleCondition(fieldValue, operator, value) {
-    switch (operator) {
-        case 'matches':
-            return isMatch(fieldValue, value);
-        case 'not_matches':
-            return !isMatch(fieldValue, value);
-        case 'contains':
-            return fieldValue.includes(value);
-        case 'not_contains':
-            return !fieldValue.includes(value);
-        case 'equals':
-            return fieldValue === value;
-        case 'not_equals':
-            return fieldValue !== value;
-        default:
-            return true;
-    }
-}
-/**
- * Evaluate a condition against a paths array (comma-separated)
- * For 'matches'/'contains' - returns true if ANY path matches
- * For 'not_matches'/'not_contains' - returns true if ALL paths don't match
- */
-function evaluatePathsCondition(paths, operator, value) {
-    switch (operator) {
-        case 'matches':
-            return paths.some(p => isMatch(p, value));
-        case 'not_matches':
-            return paths.every(p => !isMatch(p, value));
-        case 'contains':
-            return paths.some(p => p.includes(value));
-        case 'not_contains':
-            return paths.every(p => !p.includes(value));
-        case 'equals':
-            return paths.some(p => p === value);
-        case 'not_equals':
-            return paths.every(p => p !== value);
-        default:
-            return true;
-    }
-}
-/**
- * Evaluate hook conditions against current variables
- * Returns true if hook should be triggered, false to skip
- */
-function evaluateCondition(condition, variables) {
-    // No conditions or empty conditions = always match
-    if (!condition || !condition.conditions || condition.conditions.length === 0) {
-        return true;
-    }
-    const results = condition.conditions.map((c) => {
-        const fieldValue = variables[c.field] || '';
-        // For 'paths' field, check if any path matches
-        if (c.field === 'paths' && fieldValue.includes(', ')) {
-            const paths = fieldValue.split(', ');
-            return evaluatePathsCondition(paths, c.operator, c.value);
-        }
-        // Single value evaluation
-        return evaluateSingleCondition(fieldValue, c.operator, c.value);
-    });
-    // Combine results based on logic (default: AND)
-    return condition.logic === 'OR'
-        ? results.some((r) => r)
-        : results.every((r) => r);
-}
-//# sourceMappingURL=condition-evaluator.js.map

package/dist/plugins/hooks/dedup-utils.js

@@ -1,66 +0,0 @@
-"use strict";
-/**
- * Deduplication Utilities
- *
- * Functions to prevent duplicate hook triggers when OpenCode fires
- * the same event multiple times in quick succession.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createToolCallHash = createToolCallHash;
-exports.isDuplicateToolCall = isDuplicateToolCall;
-exports.clearRecentCalls = clearRecentCalls;
-exports.getRecentCallsCount = getRecentCallsCount;
-// Track recent tool calls with timestamps
-const recentCalls = new Map();
-// Default window for considering calls as duplicates (2 seconds)
-const DEFAULT_DEDUP_WINDOW = 2000;
-/**
- * Create a hash for a tool call based on tool name and output/input
- * Used to identify potentially duplicate calls
- *
- * @param toolName - The name of the tool being called
- * @param text - The output or input text to include in hash (truncated to 100 chars)
- * @returns A string hash identifying this specific call
- */
-function createToolCallHash(toolName, text) {
-    // Simple hash using tool name + first 100 chars of text
-    return `${toolName}:${text?.substring(0, 100) || ''}`;
-}
-/**
- * Check if a tool call is a duplicate of a recent call
- * Also cleans up old entries from the tracking map
- *
- * @param hash - The hash created by createToolCallHash
- * @param now - Current timestamp (allows injection for testing)
- * @param dedupWindow - Time window in ms to consider calls as duplicates (default: 2000ms)
- * @returns true if this appears to be a duplicate call, false otherwise
- */
-function isDuplicateToolCall(hash, now = Date.now(), dedupWindow = DEFAULT_DEDUP_WINDOW) {
-    const lastTime = recentCalls.get(hash);
-    if (lastTime && (now - lastTime) < dedupWindow) {
-        return true;
-    }
-    // Clean up old entries (older than 2x the dedup window)
-    const cleanupThreshold = dedupWindow * 2;
-    for (const [key, time] of recentCalls.entries()) {
-        if (now - time > cleanupThreshold) {
-            recentCalls.delete(key);
-        }
-    }
-    // Record this call
-    recentCalls.set(hash, now);
-    return false;
-}
-/**
- * Clear all tracked calls (useful for testing)
- */
-function clearRecentCalls() {
-    recentCalls.clear();
-}
-/**
- * Get the number of tracked calls (useful for testing)
- */
-function getRecentCallsCount() {
-    return recentCalls.size;
-}
-//# sourceMappingURL=dedup-utils.js.map

package/dist/plugins/hooks/hook-utils.js

@@ -1,85 +0,0 @@
-"use strict";
-/**
- * Hook Utility Functions
- *
- * Shared utilities for hook processing including template interpolation
- * and ID extraction from tool outputs.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interpolatePrompt = interpolatePrompt;
-exports.extractRequestId = extractRequestId;
-exports.extractTaskId = extractTaskId;
-exports.extractFilePath = extractFilePath;
-exports.sanitizeTemplateValue = sanitizeTemplateValue;
-/**
- * Interpolate template variables in prompt
- * Replaces {{variableName}} patterns with corresponding values from variables object
- *
- * @param template - The template string with {{variable}} placeholders
- * @param variables - Key-value pairs to substitute into the template
- * @returns The interpolated string with all variables replaced
- */
-function interpolatePrompt(template, variables) {
-    let result = template;
-    for (const [key, value] of Object.entries(variables)) {
-        result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), value);
-    }
-    return result;
-}
-/**
- * Extract request ID from tool output
- * Matches patterns like "Request completed: req001234"
- *
- * @param text - The tool output text to search
- * @returns The request ID (e.g., "req001234") or null if not found
- */
-function extractRequestId(text) {
-    const match = text.match(/Request completed:\s*(req\d+)/i);
-    return match ? match[1] : null;
-}
-/**
- * Extract task ID from tool output
- * Matches patterns like "Task tas002152 has been marked as completed"
- *
- * @param text - The tool output text to search
- * @returns The task ID (e.g., "tas002152") or null if not found
- */
-function extractTaskId(text) {
-    const match = text.match(/Task\s+(tas\d+).*(?:completed|marked as completed)/i);
-    return match ? match[1] : null;
-}
-/**
- * Extract file path from write_file tool output
- * Matches patterns like "Created file path/to/file.ts"
- *
- * @param text - The tool output text to search
- * @returns The file path or null if not found
- */
-function extractFilePath(text) {
-    // Match "Created file X" or "**Created file X**"
-    const createdMatch = text.match(/\*?\*?Created file\s+([^\s*]+)/i);
-    if (createdMatch)
-        return createdMatch[1];
-    // Match "File Modified: Yes" with path context
-    const modifiedMatch = text.match(/File \d+:\s*([^\n]+)\n.*File Modified:\s*Yes/i);
-    if (modifiedMatch)
-        return modifiedMatch[1];
-    return null;
-}
-/**
- * Sanitize a value for use in template interpolation
- * Truncates long values and escapes special characters
- *
- * @param value - The value to sanitize
- * @param maxLength - Maximum length before truncation (default: 1000)
- * @returns The sanitized string
- */
-function sanitizeTemplateValue(value, maxLength = 1000) {
-    if (!value)
-        return '';
-    if (value.length > maxLength) {
-        return value.substring(0, maxLength) + '... (truncated)';
-    }
-    return value;
-}
-//# sourceMappingURL=hook-utils.js.map

package/dist/plugins/notify-parent.js

@@ -1,95 +0,0 @@
-"use strict";
-/**
- * OpenCode Notify Parent Plugin
- *
- * Sends a toast notification to the parent session when a request is completed.
- * Only active when OPENCODE_PARENT_SERVER env var is set (indicating this is
- * a background subagent spawned by another session).
- *
- * Hooks into tool.execute.after to detect request-operations complete calls.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-// Deduplication: track recent tool calls to prevent double-triggering
-// OpenCode sometimes fires tool.execute.after twice for the same call
-const recentToolCalls = new Map();
-const DEDUP_WINDOW = 2000; // 2 second window
-function createToolCallHash(toolName, outputText) {
-    return `${toolName}:${outputText?.substring(0, 100) || ''}`;
-}
-function isDuplicateToolCall(hash, now) {
-    const lastTime = recentToolCalls.get(hash);
-    if (lastTime && (now - lastTime) < DEDUP_WINDOW) {
-        return true;
-    }
-    // Clean up old entries
-    for (const [key, time] of recentToolCalls.entries()) {
-        if (now - time > DEDUP_WINDOW * 2) {
-            recentToolCalls.delete(key);
-        }
-    }
-    recentToolCalls.set(hash, now);
-    return false;
-}
-exports.default = async ({ project, directory }) => {
-    // Only activate if we have a parent server to notify
-    const parentServerUrl = process.env.OPENCODE_PARENT_SERVER;
-    if (!parentServerUrl) {
-        return {}; // No hooks if no parent to notify
-    }
-    return {
-        "tool.execute.after": async (input, output) => {
-            try {
-                // Check if this is request-operations (with underscores)
-                const toolName = input?.tool || input?.name;
-                if (!toolName || !toolName.includes('request_operations')) {
-                    return; // Not the tool we're looking for
-                }
-                // Deduplication check - OpenCode fires hooks twice
-                const outputText = output?.content?.[0]?.text || '';
-                const callHash = createToolCallHash(toolName, outputText);
-                if (isDuplicateToolCall(callHash, Date.now())) {
-                    return; // Skip duplicate
-                }
-                // Check the output content for the operation result
-                if (output?.content && Array.isArray(output.content)) {
-                    if (output.content[0]?.text) {
-                        const resultText = output.content[0].text;
-                        // Check if this was a complete operation
-                        const completionMatch = resultText.match(/(?:Request|request)\s+(req\d+)\s+(?:completed|complete)/i);
-                        if (completionMatch) {
-                            const requestId = completionMatch[1];
-                            // Send toast notification to parent
-                            await sendToastToParent(parentServerUrl, {
-                                title: "Background Work Complete",
-                                message: `Request ${requestId} has been completed`,
-                                variant: "success",
-                                duration: 8000
-                            });
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                // Silently ignore errors to avoid breaking the main session
-                // Could log to file if debugging is needed
-            }
-        }
-    };
-};
-/**
- * Send a toast notification to the parent OpenCode session
- */
-async function sendToastToParent(parentServerUrl, toast) {
-    const toastUrl = `${parentServerUrl.replace(/\/$/, '')}/tui/toast`;
-    const response = await fetch(toastUrl, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(toast)
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to send toast: ${response.status} ${response.statusText}`);
-    }
-}
-//# sourceMappingURL=notify-parent.js.map