alchemylab 1.3.4 → 1.4.0

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

@@ -1,17 +1,9 @@
-"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.tryMarkMessageProcessed = tryMarkMessageProcessed;
-exports.clearProcessedMessages = clearProcessedMessages;
 // Track recent tool calls with timestamps
 const recentCalls = new Map();
 // Default window for considering calls as duplicates (2 seconds)
@@ -24,7 +16,7 @@ const DEFAULT_DEDUP_WINDOW = 2000;
  * @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) {
+export function createToolCallHash(toolName, text) {
     // Simple hash using tool name + first 100 chars of text
     return `${toolName}:${text?.substring(0, 100) || ''}`;
 }
@@ -37,7 +29,7 @@ function createToolCallHash(toolName, text) {
  * @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) {
+export function isDuplicateToolCall(hash, now = Date.now(), dedupWindow = DEFAULT_DEDUP_WINDOW) {
     const lastTime = recentCalls.get(hash);
     if (lastTime && (now - lastTime) < dedupWindow) {
         return true;
@@ -56,13 +48,13 @@ function isDuplicateToolCall(hash, now = Date.now(), dedupWindow = DEFAULT_DEDUP
 /**
  * Clear all tracked calls (useful for testing)
  */
-function clearRecentCalls() {
+export function clearRecentCalls() {
     recentCalls.clear();
 }
 /**
  * Get the number of tracked calls (useful for testing)
  */
-function getRecentCallsCount() {
+export function getRecentCallsCount() {
     return recentCalls.size;
 }
 // Track last processed message ID per session to prevent duplicate triggers
@@ -75,7 +67,7 @@ const lastProcessedMessageId = new Map();
  * This prevents race conditions where two concurrent calls both check
  * hasProcessedMessage() before either calls markMessageProcessed().
  */
-function tryMarkMessageProcessed(sessionId, messageId) {
+export function tryMarkMessageProcessed(sessionId, messageId) {
     if (!messageId)
         return true; // No message ID = proceed (can't dedupe)
     const lastId = lastProcessedMessageId.get(sessionId);
@@ -96,7 +88,7 @@ function tryMarkMessageProcessed(sessionId, messageId) {
 /**
  * Clear processed message tracking (for testing)
  */
-function clearProcessedMessages() {
+export function clearProcessedMessages() {
     lastProcessedMessageId.clear();
 }
 //# sourceMappingURL=dedup-utils.js.map

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

@@ -1,16 +1,9 @@
-"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
@@ -19,7 +12,7 @@ exports.sanitizeTemplateValue = sanitizeTemplateValue;
  * @param variables - Key-value pairs to substitute into the template
  * @returns The interpolated string with all variables replaced
  */
-function interpolatePrompt(template, variables) {
+export function interpolatePrompt(template, variables) {
     let result = template;
     for (const [key, value] of Object.entries(variables)) {
         result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), value);
@@ -33,7 +26,7 @@ function interpolatePrompt(template, variables) {
  * @param text - The tool output text to search
  * @returns The request ID (e.g., "req001234") or null if not found
  */
-function extractRequestId(text) {
+export function extractRequestId(text) {
     const patterns = [
         /Request completed:\s*(req\d+)/i,
         /Request (req\d+) completed/i,
@@ -56,7 +49,7 @@ function extractRequestId(text) {
  * @param text - The tool output text to search
  * @returns The task ID (e.g., "tas002152") or null if not found
  */
-function extractTaskId(text) {
+export function extractTaskId(text) {
     const match = text.match(/Task\s+(tas\d+).*(?:completed|marked as completed)/i);
     return match ? match[1] : null;
 }
@@ -67,7 +60,7 @@ function extractTaskId(text) {
  * @param text - The tool output text to search
  * @returns The file path or null if not found
  */
-function extractFilePath(text) {
+export function extractFilePath(text) {
     // Match "Created file X" or "**Created file X**"
     const createdMatch = text.match(/\*?\*?Created file\s+([^\s*]+)/i);
     if (createdMatch)
@@ -86,7 +79,7 @@ function extractFilePath(text) {
  * @param maxLength - Maximum length before truncation (default: 1000)
  * @returns The sanitized string
  */
-function sanitizeTemplateValue(value, maxLength = 1000) {
+export function sanitizeTemplateValue(value, maxLength = 1000) {
     if (!value)
         return '';
     if (value.length > maxLength) {

package/dist/plugins/hooks/plugin.js

@@ -1,269 +1,69 @@
-"use strict";
 /**
- * OpenCode Event Hooks Plugin — Thin Event Emitter
+ * OpenCode Event Hooks Plugin — Raw Event Emitter
  *
  * Detects events from OpenCode (tool execution, session lifecycle) and POSTs
- * them to the action server's /api/hook-event endpoint. All hook logic
- * (fetching, condition evaluation, template interpolation, execution) lives
- * in the action server.
+ * them to the action server. The plugin itself does no parsing or event-type
+ * derivation: it ships raw envelopes and the action server's hook layer
+ * handles extraction, derivation, condition evaluation, and execution.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const fs_1 = require("fs");
+import { join } from "path";
+import { readFileSync, existsSync } from "fs";
 const ACTION_SERVER_PORT = 3456;
-const ACTION_SERVER_URL = `http://localhost:${ACTION_SERVER_PORT}/api/hook-event`;
+const ACTION_SERVER_BASE = `http://localhost:${ACTION_SERVER_PORT}`;
+const HOOK_EVENT_URL = `${ACTION_SERVER_BASE}/api/hook-event`;
+const TOOL_EVENT_URL = `${ACTION_SERVER_BASE}/api/tool-event`;
 // Singleton guard — OpenCode calls plugin init twice
 let initializedDirectory = null;
 let cachedHandlers = null;
-/**
- * Extract request ID from tool output
- */
-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,
-        /Request (req\d+) merged/i,
-        /merged.*?(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
- */
-function extractTaskId(text) {
-    const match = text.match(/Task\s+(tas\d+).*(?:completed|marked as completed)/i);
-    return match ? match[1] : null;
-}
-/**
- * Fire-and-forget POST to action server. Does not throw.
- */
-function postHookEvent(eventType, sessionId, variables, timing) {
-    fetch(ACTION_SERVER_URL, {
+function postJson(url, body) {
+    fetch(url, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ eventType, sessionId, variables, timing }),
+        body: JSON.stringify(body),
     }).catch(() => { }); // Fire-and-forget
 }
-/**
- * Await POST to action server. Returns silently on failure.
- */
-async function postHookEventAsync(eventType, sessionId, variables, timing) {
+async function postJsonAwaited(url, body) {
     try {
-        await fetch(ACTION_SERVER_URL, {
+        await fetch(url, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ eventType, sessionId, variables, timing }),
+            body: JSON.stringify(body),
         });
     }
-    catch {
-        // Non-fatal
-    }
+    catch { /* non-fatal */ }
 }
 /**
- * Detect tool type and determine event type + variables from tool execution context.
- */
-function extractToolEventInfo(toolName, input, resultText, sessionId) {
-    const events = [];
-    const baseVars = {
-        output: resultText || '',
-        toolName,
-        sessionId: sessionId || '',
-    };
-    const isRequestOps = toolName.includes('request_operations') || toolName.includes('complete_request');
-    const isTaskOps = toolName.includes('task_operations') || toolName.includes('complete_task');
-    const isWriteFile = toolName.includes('write_file');
-    const isReplaceInFiles = toolName.includes('replace_in_files');
-    const isQuickEdit = toolName.includes('quick_write') || toolName.includes('quick_replace') || toolName.includes('quick_manage');
-    const isReadFiles = toolName.includes('read_files');
-    const isSearch = toolName.includes('search');
-    const isManageFiles = toolName.includes('manage_files');
-    const isDocumentOps = toolName.includes('document_operations');
-    const isQueryHistory = toolName.includes('query_history');
-    if (isRequestOps && resultText) {
-        const toolArgs = input?.args || input?.input || {};
-        const operation = toolArgs.operation;
-        const requestId = extractRequestId(resultText);
-        // Debug: log what we see for request ops to diagnose hook firing
-        try {
-            const fs = require('fs'), path = require('path');
-            const debugPath = path.join(process.env.ALCHEMY_PROJECT_PATH || process.cwd(), '.alchemy_lab', 'hook-debug.log');
-            const inputKeys = Object.keys(input || {}).join(',');
-            const inputInputKeys = Object.keys(input?.input || {}).join(',');
-            fs.appendFileSync(debugPath, `[${new Date().toISOString()}] request_ops: tool=${toolName} op=${operation} reqId=${requestId} inputKeys=[${inputKeys}] input.inputKeys=[${inputInputKeys}] input.input.op=${input?.input?.operation} input.operation=${input?.operation} result=${resultText?.substring(0, 80)}\n`);
-        }
-        catch { }
-        if (requestId) {
-            if (operation === 'merge' || operation === 'finalize') {
-                // Actual merge to main
-                events.push({
-                    eventType: 'request_completed',
-                    variables: { ...baseVars, requestId },
-                });
-            }
-            else if (operation === 'complete') {
-                // Phase 1 — work done, ready for merge
-                events.push({
-                    eventType: 'request_ready_for_merge',
-                    variables: { ...baseVars, requestId },
-                });
-            }
-        }
-    }
-    else if (isTaskOps && resultText) {
-        const taskId = extractTaskId(resultText);
-        if (taskId) {
-            events.push({
-                eventType: 'task_completed',
-                variables: { ...baseVars, taskId },
-            });
-        }
-    }
-    else if (isWriteFile) {
-        const pathMatch = resultText?.match(/(?:Created|Updated|Wrote)\s+(?:file\s+)?([^\s\n]+)/i);
-        events.push({
-            eventType: 'write_file',
-            variables: { ...baseVars, path: pathMatch?.[1] || '' },
-        });
-    }
-    else if (isReplaceInFiles) {
-        const replaceArgs = input?.args || input?.input || {};
-        let operations = replaceArgs.operations || [];
-        if (typeof operations === 'string') {
-            try {
-                operations = JSON.parse(operations);
-            }
-            catch {
-                operations = [];
-            }
-        }
-        const paths = operations.map((op) => op.path || op.documentId).filter(Boolean);
-        events.push({
-            eventType: 'replace_in_files',
-            variables: { ...baseVars, paths: paths.join(', '), fileCount: String(paths.length) },
-        });
-    }
-    else if (isQuickEdit) {
-        const vars = {
-            ...baseVars,
-            path: (input?.args || input?.input)?.operationArgs?.path || '',
-            title: (input?.args || input?.input)?.title || '',
-        };
-        const qeRequestMatch = resultText?.match(/\*\*Request:\*\*\s*(req\d+)/i);
-        if (qeRequestMatch)
-            vars.requestId = qeRequestMatch[1];
-        events.push({ eventType: 'quick_edit', variables: vars });
-        // Quick-edit auto-completes requests — also emit request_completed
-        if (vars.requestId) {
-            events.push({
-                eventType: 'request_completed',
-                variables: { ...baseVars, requestId: vars.requestId },
-            });
-        }
-    }
-    else if (isReadFiles) {
-        let pathsInput = (input?.args || input?.input)?.paths || [];
-        if (typeof pathsInput === 'string') {
-            try {
-                pathsInput = JSON.parse(pathsInput);
-            }
-            catch {
-                pathsInput = [];
-            }
-        }
-        const paths = pathsInput.map((p) => p.path || p.documentId).filter(Boolean);
-        events.push({
-            eventType: 'read_files',
-            variables: { ...baseVars, paths: paths.join(', '), fileCount: String(paths.length) },
-        });
-    }
-    else if (isSearch) {
-        events.push({
-            eventType: 'search',
-            variables: {
-                ...baseVars,
-                query: (input?.args || input?.input)?.needle || '',
-                directory: (input?.args || input?.input)?.directory || '',
-                fileExtension: (input?.args || input?.input)?.options?.fileExtension || '*',
-            },
-        });
-    }
-    else if (isManageFiles) {
-        const manageArgs = input?.args || input?.input || {};
-        let manageOps = manageArgs.operations || [];
-        if (typeof manageOps === 'string') {
-            try {
-                manageOps = JSON.parse(manageOps);
-            }
-            catch {
-                manageOps = [];
-            }
-        }
-        const opTypes = manageOps.map((op) => op.operationType).filter(Boolean);
-        events.push({
-            eventType: 'manage_files',
-            variables: { ...baseVars, operationTypes: [...new Set(opTypes)].join(', ') },
-        });
-    }
-    else if (isDocumentOps) {
-        events.push({ eventType: 'document_operations', variables: baseVars });
-    }
-    else if (isQueryHistory) {
-        events.push({ eventType: 'query_history', variables: baseVars });
-    }
-    // Always emit tool_executed for any tool
-    events.push({
-        eventType: 'tool_executed',
-        variables: {
-            tool: toolName,
-            toolName,
-            output: resultText || '',
-            sessionId: sessionId || '',
-        },
-    });
-    return events;
-}
-/**
- * Fetch recent output from a session (for lastOutput variable in session_idle).
+ * Fetch recent assistant output from a session. Used by the session.idle
+ * handler to populate the lastOutput hook variable; OpenCode's local server
+ * is reachable only from the plugin process.
  */
 async function fetchRecentSessionOutput(sessionId, directory) {
     try {
-        const configPath = (0, path_1.join)(directory, '.alchemy_lab', 'opencode.json');
-        if (!(0, fs_1.existsSync)(configPath))
+        const configPath = join(directory, '.alchemy_lab', 'opencode.json');
+        if (!existsSync(configPath))
             return { output: '' };
-        const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf8'));
+        const config = JSON.parse(readFileSync(configPath, 'utf8'));
         const serverUrl = config.port ? `http://127.0.0.1:${config.port}` : null;
         if (!serverUrl)
             return { output: '' };
-        const url = `${serverUrl}/session/${sessionId}/message?limit=5`;
-        const response = await fetch(url);
+        const response = await fetch(`${serverUrl}/session/${sessionId}/message?limit=5`);
         if (!response.ok)
             return { output: '' };
         const messages = await response.json();
         const assistantMessages = messages.filter(m => m.info.role === 'assistant');
-        const lastAssistantMessage = assistantMessages[0];
         const assistantOutput = assistantMessages
             .flatMap(m => m.parts)
             .filter(p => p.type === 'text' && p.text)
             .map(p => p.text)
             .join('\n');
-        return { output: assistantOutput, lastMessageId: lastAssistantMessage?.info?.id };
+        return { output: assistantOutput, lastMessageId: assistantMessages[0]?.info?.id };
     }
     catch {
         return { output: '' };
     }
 }
-exports.default = async ({ directory }) => {
+export default async ({ directory }) => {
     const dir = directory || process.cwd();
-    // Singleton guard
     if (initializedDirectory === dir && cachedHandlers) {
         return cachedHandlers;
     }
@@ -273,48 +73,51 @@ exports.default = async ({ directory }) => {
             const toolName = input?.tool || input?.name;
             if (!toolName)
                 return;
-            const sessionId = input?.sessionID || '';
-            const inputText = JSON.stringify(input?.args || input?.input || {}).substring(0, 1000);
-            postHookEvent('tool_executed', sessionId, {
-                tool: toolName,
+            postJson(TOOL_EVENT_URL, {
                 toolName,
-                input: inputText,
-            }, 'before');
+                sessionId: input?.sessionID || '',
+                input: input?.args || input?.input || {},
+                timing: 'before',
+            });
         },
         "tool.execute.after": async (input, output) => {
             const toolName = input?.tool || input?.name;
             if (!toolName)
                 return;
-            const sessionId = input?.sessionID || '';
             const resultText = output?.content?.[0]?.text;
             if (!resultText)
                 return;
-            const events = extractToolEventInfo(toolName, input, resultText, sessionId);
-            for (const { eventType, variables } of events) {
-                await postHookEventAsync(eventType, sessionId, variables, 'after');
-            }
+            await postJsonAwaited(TOOL_EVENT_URL, {
+                toolName,
+                sessionId: input?.sessionID || '',
+                input: input?.args || input?.input || {},
+                output: resultText,
+                timing: 'after',
+            });
         },
         event: async ({ event }) => {
             switch (event.type) {
                 case 'session.idle': {
                     const sessionId = event.properties.sessionID || '';
                     const { output: lastOutput, lastMessageId } = await fetchRecentSessionOutput(sessionId, dir);
-                    // Fire-and-forget — process is dying
-                    postHookEvent('session_idle', sessionId, {
+                    postJson(HOOK_EVENT_URL, {
+                        eventType: 'session_idle',
                         sessionId,
-                        lastOutput,
-                        lastMessageId: lastMessageId || '',
+                        variables: { sessionId, lastOutput, lastMessageId: lastMessageId || '' },
                     });
                     return;
                 }
                 case 'session.created': {
-                    const sessionInfo = event.properties.info;
-                    const sessionId = sessionInfo?.id || '';
+                    const sessionId = event.properties.info?.id || '';
                     if (!sessionId)
                         return;
-                    // Delay to allow workflow assignment
+                    // Delay so workflow assignment lands before the hook fires.
                     setTimeout(() => {
-                        postHookEvent('session_created', sessionId, { sessionId });
+                        postJson(HOOK_EVENT_URL, {
+                            eventType: 'session_created',
+                            sessionId,
+                            variables: { sessionId },
+                        });
                     }, 500);
                     return;
                 }

package/dist/plugins/inject-session.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * OpenCode Inject Session Plugin
  *
@@ -7,30 +6,29 @@
  *
  * Hooks into tool.execute.before to modify args before the MCP tool executes.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
+import { appendFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 // Log immediately when module is loaded
 try {
-    const logFile = (0, path_1.join)((0, os_1.homedir)(), 'inject-session-plugin.log');
-    (0, fs_1.appendFileSync)(logFile, `[${new Date().toISOString()}] MODULE LOADED - file was imported\n`);
+    const logFile = join(homedir(), 'inject-session-plugin.log');
+    appendFileSync(logFile, `[${new Date().toISOString()}] MODULE LOADED - file was imported\n`);
 }
 catch (e) {
     // ignore
 }
 const debugLog = (msg, data) => {
-    const logFile = (0, path_1.join)((0, os_1.homedir)(), 'inject-session-plugin.log');
+    const logFile = join(homedir(), 'inject-session-plugin.log');
     const line = `[${new Date().toISOString()}] ${msg}${data ? ' ' + JSON.stringify(data) : ''}\n`;
     try {
-        (0, fs_1.appendFileSync)(logFile, line);
+        appendFileSync(logFile, line);
     }
     catch (e) {
         // ignore
     }
     console.log('[inject-session-plugin]', msg, data || '');
 };
-exports.default = async ({ project, directory }) => {
+export default async ({ project, directory }) => {
     debugLog('Plugin loaded', { project: project?.id, directory });
     return {
         "tool.execute.before": async (context, data) => {

package/dist/plugins/system-logger.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * OpenCode System Logger Plugin
  *
@@ -6,15 +5,14 @@
  * to .alchemy_lab/system-prompt.log. Used to diagnose whether entity context
  * (from @ mentions) reaches the LLM via the user.system field.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const path_1 = require("path");
-const getLogFile = (directory) => (0, path_1.join)(directory, '.alchemy_lab', 'system-prompt.log');
+import { appendFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+const getLogFile = (directory) => join(directory, '.alchemy_lab', 'system-prompt.log');
 const debugLog = (logFile, msg, data) => {
     const line = `[${new Date().toISOString()}] ${msg}${data ? ' ' + JSON.stringify(data) : ''}\n`;
     try {
-        (0, fs_1.mkdirSync)((0, path_1.join)(logFile, '..'), { recursive: true });
-        (0, fs_1.appendFileSync)(logFile, line);
+        mkdirSync(join(logFile, '..'), { recursive: true });
+        appendFileSync(logFile, line);
     }
     catch (e) {
         // ignore
@@ -40,7 +38,7 @@ function stripTaskReferences(system) {
         system[i] = s;
     }
 }
-exports.default = async ({ directory }) => {
+export default async ({ directory }) => {
     const logFile = getLogFile(directory);
     debugLog(logFile, 'system-logger plugin loaded', { directory });
     return {
@@ -71,10 +69,10 @@ exports.default = async ({ directory }) => {
                 '',
             ];
             try {
-                (0, fs_1.mkdirSync)((0, path_1.join)(logFile, '..'), { recursive: true });
-                (0, fs_1.appendFileSync)(logFile, lines.join('\n') + '\n');
+                mkdirSync(join(logFile, '..'), { recursive: true });
+                appendFileSync(logFile, lines.join('\n') + '\n');
                 // Also write full untruncated prompt to separate file (overwrite each time)
-                const fullLogFile = (0, path_1.join)(logFile, '..', 'system-prompt-full.log');
+                const fullLogFile = join(logFile, '..', 'system-prompt-full.log');
                 const fullLines = [
                     `Timestamp: ${new Date().toISOString()}`,
                     `Session: ${hookInput.sessionID || 'N/A'}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemylab",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "private": false,
   "description": "AlchemyLab - agentic coding IDEm",
   "author": "Testfire Software",
@@ -49,7 +49,7 @@
     "ws": "^8.14.2",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.3",
-    "alchemylab-opencode": "^1.0.14"
+    "alchemylab-opencode": "^1.0.15"
   },
   "devDependencies": {
     "@types/chai": "^4.3.5",