alchemylab 1.0.3 → 1.0.4

package/dist/plugins/hooks/plugin.js

@@ -0,0 +1,278 @@
+"use strict";
+/**
+ * OpenCode Event Hooks Plugin — Thin 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const ACTION_SERVER_PORT = 3456;
+const ACTION_SERVER_URL = `http://localhost:${ACTION_SERVER_PORT}/api/hook-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,
+    ];
+    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, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ eventType, sessionId, variables, timing }),
+    }).catch(() => { }); // Fire-and-forget
+}
+/**
+ * Await POST to action server. Returns silently on failure.
+ */
+async function postHookEventAsync(eventType, sessionId, variables, timing) {
+    try {
+        await fetch(ACTION_SERVER_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ eventType, sessionId, variables, timing }),
+        });
+    }
+    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 requestId = extractRequestId(resultText);
+        if (requestId) {
+            events.push({
+                eventType: 'request_completed',
+                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 operations = input?.input?.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?.input?.operationArgs?.path || '',
+            title: 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) {
+        const pathsInput = input?.input?.paths || [];
+        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?.input?.needle || '',
+                directory: input?.input?.directory || '',
+                fileExtension: input?.input?.options?.fileExtension || '*',
+            },
+        });
+    }
+    else if (isManageFiles) {
+        const operations = input?.input?.operations || [];
+        const opTypes = operations.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).
+ */
+async function fetchRecentSessionOutput(sessionId, directory) {
+    try {
+        const configPath = (0, path_1.join)(directory, '.alchemy_lab', 'opencode.json');
+        if (!(0, fs_1.existsSync)(configPath))
+            return { output: '' };
+        const config = JSON.parse((0, fs_1.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);
+        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 };
+    }
+    catch {
+        return { output: '' };
+    }
+}
+exports.default = async ({ directory }) => {
+    const dir = directory || process.cwd();
+    // Singleton guard
+    if (initializedDirectory === dir && cachedHandlers) {
+        return cachedHandlers;
+    }
+    initializedDirectory = dir;
+    const handlers = {
+        "tool.execute.before": async (input) => {
+            const toolName = input?.tool || input?.name;
+            if (!toolName)
+                return;
+            const sessionId = input?.sessionID || '';
+            const inputText = JSON.stringify(input?.input || {}).substring(0, 1000);
+            postHookEvent('tool_executed', sessionId, {
+                tool: toolName,
+                toolName,
+                input: inputText,
+            }, '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');
+            }
+        },
+        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, {
+                        sessionId,
+                        lastOutput,
+                        lastMessageId: lastMessageId || '',
+                    });
+                    return;
+                }
+                case 'session.created': {
+                    const sessionInfo = event.properties.info;
+                    const sessionId = sessionInfo?.id || '';
+                    if (!sessionId)
+                        return;
+                    // Delay to allow workflow assignment
+                    setTimeout(() => {
+                        postHookEvent('session_created', sessionId, { sessionId });
+                    }, 500);
+                    return;
+                }
+            }
+        },
+    };
+    cachedHandlers = handlers;
+    return handlers;
+};
+//# sourceMappingURL=plugin.js.map

package/dist/plugins/inject-session.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * OpenCode Inject Session Plugin
+ *
+ * Injects the current session ID into spawn-background-work tool calls
+ * so that spawned background sessions can be linked as children of the parent.
+ *
+ * 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 path_1 = require("path");
+// Log immediately when module is loaded
+try {
+    const logFile = (0, path_1.join)(process.env.HOME || '/tmp', 'inject-session-plugin.log');
+    (0, fs_1.appendFileSync)(logFile, `[${new Date().toISOString()}] MODULE LOADED - file was imported\n`);
+}
+catch (e) {
+    // ignore
+}
+const debugLog = (msg, data) => {
+    const logFile = (0, path_1.join)(process.env.HOME || '/tmp', 'inject-session-plugin.log');
+    const line = `[${new Date().toISOString()}] ${msg}${data ? ' ' + JSON.stringify(data) : ''}\n`;
+    try {
+        (0, fs_1.appendFileSync)(logFile, line);
+    }
+    catch (e) {
+        // ignore
+    }
+    console.log('[inject-session-plugin]', msg, data || '');
+};
+exports.default = async ({ project, directory }) => {
+    debugLog('Plugin loaded', { project: project?.id, directory });
+    return {
+        "tool.execute.before": async (context, data) => {
+            debugLog('tool.execute.before called', {
+                tool: context.tool,
+                sessionID: context.sessionID,
+                hasArgs: !!data?.args
+            });
+            try {
+                // Check if this is a spawn-background-work tool
+                // MCP tool names can use dashes or underscores depending on how they're registered
+                const toolName = context.tool;
+                if (!toolName || (!toolName.includes('spawn_background_work') && !toolName.includes('spawn-background-work'))) {
+                    return; // Not logging every non-matching tool to avoid spam
+                }
+                debugLog('Matched spawn-background-work tool!');
+                // Inject parentSessionId into args if not already set
+                if (!data.args.parentSessionId && context.sessionID) {
+                    data.args.parentSessionId = context.sessionID;
+                    debugLog('Injected parentSessionId', context.sessionID);
+                }
+                else {
+                    debugLog('parentSessionId already set or no sessionID', {
+                        existing: data.args.parentSessionId,
+                        sessionID: context.sessionID
+                    });
+                }
+            }
+            catch (error) {
+                debugLog('Error', { error: String(error) });
+            }
+        }
+    };
+};
+//# sourceMappingURL=inject-session.js.map

package/dist/plugins/notify-parent.js

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

package/dist/plugins/system-logger.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * OpenCode System Logger Plugin
+ *
+ * Hooks into experimental.chat.system.transform to log the full system prompt
+ * 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');
+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);
+    }
+    catch (e) {
+        // ignore
+    }
+};
+/**
+ * Strip Task tool references from system prompt for alchemist sessions.
+ * The OpenCode base prompt heavily promotes using the Task tool, which causes
+ * the alchemist to hallucinate the tool even when it's disabled in tool config.
+ */
+function stripTaskReferences(system) {
+    for (let i = 0; i < system.length; i++) {
+        let s = system[i];
+        // Remove lines that promote the Task tool
+        s = s.replace(/^- When doing file search, prefer to use the Task tool.*$/gm, '');
+        s = s.replace(/^- You should proactively use the Task tool.*$/gm, '');
+        s = s.replace(/^- VERY IMPORTANT:.*use the Task tool instead of running search commands directly\.$/gm, '');
+        s = s.replace(/^- If the user specifies that they want you to run tools "in parallel".*multiple Task tool calls\.$/gm, '');
+        // Remove Task tool examples
+        s = s.replace(/<example>\n.*?\[Uses the Task tool.*?<\/example>/gs, '');
+        // Clean up excessive blank lines left behind
+        s = s.replace(/\n{3,}/g, '\n\n');
+        system[i] = s;
+    }
+}
+exports.default = async ({ directory }) => {
+    const logFile = getLogFile(directory);
+    debugLog(logFile, 'system-logger plugin loaded', { directory });
+    return {
+        "experimental.chat.system.transform": async (hookInput, output) => {
+            // Strip Task tool references for alchemist sessions
+            const isAlchemist = output.system.some((s) => s.includes('head of engineering'));
+            debugLog(logFile, 'Alchemist detection', { isAlchemist, sessionID: hookInput.sessionID, systemParts: output.system.length, partLengths: output.system.map((s) => s.length), hasSpecialist: output.system.map((s) => s.includes('specialist_ops')) });
+            if (isAlchemist) {
+                stripTaskReferences(output.system);
+                debugLog(logFile, 'Stripped Task tool references for alchemist session', { sessionID: hookInput.sessionID });
+            }
+            const hasEntityContext = output.system.some((s) => s.includes('referenced the following') || s.includes('entity'));
+            const lines = [
+                '='.repeat(80),
+                `Timestamp: ${new Date().toISOString()}`,
+                `Session: ${hookInput.sessionID || 'N/A'}`,
+                `Model: ${hookInput.model?.providerID || '?'}/${hookInput.model?.modelID || '?'}`,
+                `System parts: ${output.system.length}`,
+                `Has entity context: ${hasEntityContext}`,
+                '-'.repeat(80),
+                ...output.system.map((s, i) => {
+                    const preview = s.length > 500
+                        ? s.slice(0, 250) + '\n...[truncated]...\n' + s.slice(-250)
+                        : s;
+                    return `--- Part ${i} (${s.length} chars) ---\n${preview}`;
+                }),
+                '='.repeat(80),
+                '',
+            ];
+            try {
+                (0, fs_1.mkdirSync)((0, path_1.join)(logFile, '..'), { recursive: true });
+                (0, fs_1.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 fullLines = [
+                    `Timestamp: ${new Date().toISOString()}`,
+                    `Session: ${hookInput.sessionID || 'N/A'}`,
+                    `IsAlchemist: ${isAlchemist}`,
+                    `System parts: ${output.system.length}`,
+                    ...output.system.map((s, i) => `--- Part ${i} (${s.length} chars) ---\n${s}`),
+                    '='.repeat(80),
+                ];
+                const { writeFileSync } = require('fs');
+                writeFileSync(fullLogFile, fullLines.join('\n') + '\n');
+            }
+            catch (e) {
+                // ignore
+            }
+        },
+    };
+};
+//# sourceMappingURL=system-logger.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemylab",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "private": false,
   "description": "AlchemyLab - agentic coding IDEm",
   "author": "Testfire Software",
@@ -22,13 +22,15 @@
   },
   "files": [
     "dist/**/*.js",
+    "dist/plugins/**/*.js",
     "package.json",
     "README.md"
   ],
   "scripts": {
     "build": "npm run build:dev",
     "build:dev": "tsc -p tsconfig.json && chmod +x dist-dev/*.js",
-    "build:prod": "webpack --mode=production && chmod +x dist/*.js",
+    "build:prod": "webpack --mode=production && chmod +x dist/*.js && npm run copy:plugins",
+    "copy:plugins": "cp -r dist-dev/plugins dist/plugins",
     "build:analyze": "ANALYZE=true webpack --mode=production",
     "test": "npm run build:dev && mocha --require ts-node/register test/**/*.test.ts",
     "test:watch": "mocha --require ts-node/register test/**/*.test.ts --watch --watch-files src/**/*.ts,test/**/*.ts",