alchemylab 1.0.2 → 1.0.4

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

@@ -0,0 +1,109 @@
+"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

@@ -0,0 +1,66 @@
+"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

@@ -0,0 +1,85 @@
+"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/hooks/lib/condition-evaluator.js

@@ -0,0 +1,114 @@
+"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
+ */
+// Cache compiled glob→regex patterns to avoid recompilation on every condition check
+const _globCache = new Map();
+function globToRegex(pattern) {
+    const cached = _globCache.get(pattern);
+    if (cached)
+        return cached;
+    let regex = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '{{GLOBSTAR}}')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '.')
+        .replace(/\{\{GLOBSTAR\}\}/g, '.*');
+    const compiled = new RegExp(`^${regex}$`);
+    // Cap cache to prevent unbounded growth
+    if (_globCache.size > 500)
+        _globCache.clear();
+    _globCache.set(pattern, compiled);
+    return compiled;
+}
+/**
+ * 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/lib/dedup-utils.js

@@ -0,0 +1,130 @@
+"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;
+exports.hasProcessedMessage = hasProcessedMessage;
+exports.markMessageProcessed = markMessageProcessed;
+exports.tryMarkMessageProcessed = tryMarkMessageProcessed;
+exports.clearProcessedMessages = clearProcessedMessages;
+// 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;
+}
+// Track last processed message ID per session to prevent duplicate triggers
+const lastProcessedMessageId = new Map();
+/**
+ * Check if we've already processed this message for a session
+ * Returns true if this message was already processed (should skip)
+ * @deprecated Use tryMarkMessageProcessed for atomic check-and-mark
+ */
+function hasProcessedMessage(sessionId, messageId) {
+    if (!messageId)
+        return false;
+    const lastId = lastProcessedMessageId.get(sessionId);
+    return lastId === messageId;
+}
+/**
+ * Mark a message as processed for a session
+ * @deprecated Use tryMarkMessageProcessed for atomic check-and-mark
+ */
+function markMessageProcessed(sessionId, messageId) {
+    if (!messageId)
+        return;
+    lastProcessedMessageId.set(sessionId, messageId);
+    // Clean up old entries (keep max 100 sessions)
+    if (lastProcessedMessageId.size > 100) {
+        const firstKey = lastProcessedMessageId.keys().next().value;
+        if (firstKey)
+            lastProcessedMessageId.delete(firstKey);
+    }
+}
+/**
+ * Atomically check if message was processed and mark it if not.
+ * Returns true if this call should proceed (message was NOT already processed).
+ * Returns false if should skip (message was already processed by another call).
+ *
+ * This prevents race conditions where two concurrent calls both check
+ * hasProcessedMessage() before either calls markMessageProcessed().
+ */
+function tryMarkMessageProcessed(sessionId, messageId) {
+    if (!messageId)
+        return true; // No message ID = proceed (can't dedupe)
+    const lastId = lastProcessedMessageId.get(sessionId);
+    if (lastId === messageId) {
+        // Already processed - skip
+        return false;
+    }
+    // Mark as processed immediately (atomic with check above in single-threaded JS)
+    lastProcessedMessageId.set(sessionId, messageId);
+    // Clean up old entries (keep max 100 sessions)
+    if (lastProcessedMessageId.size > 100) {
+        const firstKey = lastProcessedMessageId.keys().next().value;
+        if (firstKey)
+            lastProcessedMessageId.delete(firstKey);
+    }
+    return true; // Proceed - we claimed this message
+}
+/**
+ * Clear processed message tracking (for testing)
+ */
+function clearProcessedMessages() {
+    lastProcessedMessageId.clear();
+}
+//# sourceMappingURL=dedup-utils.js.map

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

@@ -0,0 +1,97 @@
+"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" or "Request req001234 completed successfully"
+ *
+ * @param text - The tool output text to search
+ * @returns The request ID (e.g., "req001234") or null if not found
+ */
+function extractRequestId(text) {
+    const patterns = [
+        /Request completed:\s*(req\d+)/i,
+        /Request (req\d+) completed/i,
+        /completed.*?(req\d{6})/i,
+        /Request finalized:\s*(req\d+)/i,
+        /Request (req\d+) finalized/i,
+        /finalized.*?(req\d{6})/i,
+    ];
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match)
+            return match[1];
+    }
+    return 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