alchemylab 1.0.4 → 1.0.5

package/dist/plugins/hooks/plugin.js

@@ -26,6 +26,8 @@ function extractRequestId(text) {
         /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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemylab",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "private": false,
   "description": "AlchemyLab - agentic coding IDEm",
   "author": "Testfire Software",
@@ -30,7 +30,7 @@
     "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 && npm run copy:plugins",
-    "copy:plugins": "cp -r dist-dev/plugins dist/plugins",
+    "copy:plugins": "mkdir -p dist/plugins/hooks/lib && cp dist-dev/plugins/hooks/plugin.js dist/plugins/hooks/ && cp dist-dev/plugins/hooks/lib/*.js dist/plugins/hooks/lib/ && cp dist-dev/plugins/inject-session.js dist/plugins/ && cp dist-dev/plugins/system-logger.js 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",

package/dist/plugins/anthropic-auth.js

@@ -1,399 +0,0 @@
-"use strict";
-/**
- * Alchemy Anthropic Auth Plugin for OpenCode
- *
- * Modified version of opencode-anthropic-auth that uses Title Case for tool names
- * to work around Anthropic's detection of third-party clients.
- *
- * Based on opencode-anthropic-auth@0.0.5
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = AlchemyAnthropicAuthPlugin;
-const fs_1 = require("fs");
-const path_1 = require("path");
-// Debug logging to file
-const LOG_FILE = (0, path_1.join)(process.env.HOME || '/tmp', 'anthropic-auth-plugin.log');
-function log(message, data) {
-    try {
-        const timestamp = new Date().toISOString();
-        const line = data
-            ? `${timestamp} [anthropic-auth] ${message} ${JSON.stringify(data)}\n`
-            : `${timestamp} [anthropic-auth] ${message}\n`;
-        (0, fs_1.appendFileSync)(LOG_FILE, line);
-    }
-    catch (e) {
-        // ignore logging errors
-    }
-}
-// Log immediately when module is loaded
-log('MODULE LOADED - anthropic-auth plugin file imported');
-const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-/**
- * Convert string to Title Case (first letter uppercase, rest lowercase for each word)
- */
-function toTitleCase(str) {
-    return str.replace(/\w\S*/g, text => text.charAt(0).toUpperCase() + text.substring(1).toLowerCase());
-}
-/**
- * Convert Title Case back to original (lowercase with underscores preserved)
- */
-function fromTitleCase(str) {
-    return str.replace(/\w\S*/g, text => text.toLowerCase());
-}
-/**
- * Generate PKCE challenge and verifier
- * Simple implementation that doesn't require external dependencies
- */
-async function generatePKCE() {
-    // Generate random verifier (43-128 characters of unreserved URI characters)
-    const array = new Uint8Array(32);
-    crypto.getRandomValues(array);
-    const verifier = btoa(String.fromCharCode(...array))
-        .replace(/\+/g, '-')
-        .replace(/\//g, '_')
-        .replace(/=/g, '');
-    // Generate challenge from verifier using SHA-256
-    const encoder = new TextEncoder();
-    const data = encoder.encode(verifier);
-    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-    const hashArray = new Uint8Array(hashBuffer);
-    const challenge = btoa(String.fromCharCode(...hashArray))
-        .replace(/\+/g, '-')
-        .replace(/\//g, '_')
-        .replace(/=/g, '');
-    return { verifier, challenge };
-}
-async function authorize(mode) {
-    log('authorize called', { mode });
-    try {
-        const pkce = await generatePKCE();
-        log('PKCE generated', { challenge: pkce.challenge?.substring(0, 20) + '...' });
-        const url = new URL(`https://${mode === "console" ? "console.anthropic.com" : "claude.ai"}/oauth/authorize`);
-        url.searchParams.set("code", "true");
-        url.searchParams.set("client_id", CLIENT_ID);
-        url.searchParams.set("response_type", "code");
-        url.searchParams.set("redirect_uri", "https://console.anthropic.com/oauth/code/callback");
-        url.searchParams.set("scope", "org:create_api_key user:profile user:inference");
-        url.searchParams.set("code_challenge", pkce.challenge);
-        url.searchParams.set("code_challenge_method", "S256");
-        url.searchParams.set("state", pkce.verifier);
-        log('authorize URL created', { url: url.toString() });
-        return {
-            url: url.toString(),
-            verifier: pkce.verifier,
-        };
-    }
-    catch (e) {
-        log('ERROR in authorize', { error: String(e), stack: e?.stack });
-        throw e;
-    }
-}
-async function exchange(code, verifier) {
-    log('exchange called');
-    try {
-        const splits = code.split("#");
-        const result = await fetch("https://console.anthropic.com/v1/oauth/token", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                code: splits[0],
-                state: splits[1],
-                grant_type: "authorization_code",
-                client_id: CLIENT_ID,
-                redirect_uri: "https://console.anthropic.com/oauth/code/callback",
-                code_verifier: verifier,
-            }),
-        });
-        if (!result.ok) {
-            log('exchange failed', { status: result.status });
-            return {
-                type: "failed",
-            };
-        }
-        const json = await result.json();
-        log('exchange successful');
-        return {
-            type: "success",
-            refresh: json.refresh_token,
-            access: json.access_token,
-            expires: Date.now() + json.expires_in * 1000,
-        };
-    }
-    catch (e) {
-        log('ERROR in exchange', { error: String(e), stack: e?.stack });
-        throw e;
-    }
-}
-async function AlchemyAnthropicAuthPlugin({ client }) {
-    log('AlchemyAnthropicAuthPlugin called', { hasClient: !!client });
-    try {
-        return {
-            auth: {
-                provider: "anthropic",
-                async loader(getAuth, provider) {
-                    log('loader called', { hasGetAuth: !!getAuth, hasProvider: !!provider });
-                    try {
-                        const auth = await getAuth();
-                        log('getAuth returned', { type: auth?.type });
-                        if (auth.type === "oauth") {
-                            log('OAuth auth detected, setting up custom fetch');
-                            // Zero out cost for max plan
-                            for (const model of Object.values(provider.models || {})) {
-                                model.cost = {
-                                    input: 0,
-                                    output: 0,
-                                    cache: {
-                                        read: 0,
-                                        write: 0,
-                                    },
-                                };
-                            }
-                            return {
-                                apiKey: "",
-                                async fetch(input, init) {
-                                    log('custom fetch called', {
-                                        inputType: typeof input,
-                                        hasInit: !!init
-                                    });
-                                    try {
-                                        const currentAuth = await getAuth();
-                                        if (currentAuth.type !== "oauth") {
-                                            log('Not OAuth, using default fetch');
-                                            return fetch(input, init);
-                                        }
-                                        let authAccess = currentAuth.access;
-                                        if (!authAccess || (currentAuth.expires && currentAuth.expires < Date.now())) {
-                                            log('Token expired or missing, refreshing');
-                                            const response = await fetch("https://console.anthropic.com/v1/oauth/token", {
-                                                method: "POST",
-                                                headers: {
-                                                    "Content-Type": "application/json",
-                                                },
-                                                body: JSON.stringify({
-                                                    grant_type: "refresh_token",
-                                                    refresh_token: currentAuth.refresh,
-                                                    client_id: CLIENT_ID,
-                                                }),
-                                            });
-                                            if (!response.ok) {
-                                                log('Token refresh failed', { status: response.status });
-                                                throw new Error(`Token refresh failed: ${response.status}`);
-                                            }
-                                            const json = await response.json();
-                                            log('Token refreshed successfully');
-                                            await client.auth.set({
-                                                path: {
-                                                    id: "anthropic",
-                                                },
-                                                body: {
-                                                    type: "oauth",
-                                                    refresh: json.refresh_token,
-                                                    access: json.access_token,
-                                                    expires: Date.now() + json.expires_in * 1000,
-                                                },
-                                            });
-                                            authAccess = json.access_token;
-                                        }
-                                        const requestInit = init ?? {};
-                                        const requestHeaders = new Headers();
-                                        if (input instanceof Request) {
-                                            input.headers.forEach((value, key) => {
-                                                requestHeaders.set(key, value);
-                                            });
-                                        }
-                                        if (requestInit.headers) {
-                                            if (requestInit.headers instanceof Headers) {
-                                                requestInit.headers.forEach((value, key) => {
-                                                    requestHeaders.set(key, value);
-                                                });
-                                            }
-                                            else if (Array.isArray(requestInit.headers)) {
-                                                for (const [key, value] of requestInit.headers) {
-                                                    if (typeof value !== "undefined") {
-                                                        requestHeaders.set(key, String(value));
-                                                    }
-                                                }
-                                            }
-                                            else {
-                                                for (const [key, value] of Object.entries(requestInit.headers)) {
-                                                    if (typeof value !== "undefined") {
-                                                        requestHeaders.set(key, String(value));
-                                                    }
-                                                }
-                                            }
-                                        }
-                                        const incomingBeta = requestHeaders.get("anthropic-beta") || "";
-                                        const incomingBetasList = incomingBeta
-                                            .split(",")
-                                            .map((b) => b.trim())
-                                            .filter(Boolean);
-                                        const includeClaudeCode = incomingBetasList.includes("claude-code-20250219");
-                                        const mergedBetas = [
-                                            "oauth-2025-04-20",
-                                            "interleaved-thinking-2025-05-14",
-                                            ...(includeClaudeCode ? ["claude-code-20250219"] : []),
-                                        ].join(",");
-                                        requestHeaders.set("authorization", `Bearer ${authAccess}`);
-                                        requestHeaders.set("anthropic-beta", mergedBetas);
-                                        requestHeaders.set("user-agent", "claude-cli/2.1.2 (external, cli)");
-                                        requestHeaders.delete("x-api-key");
-                                        // Transform tool names to Title Case
-                                        let body = requestInit.body;
-                                        if (body && typeof body === "string") {
-                                            try {
-                                                const parsed = JSON.parse(body);
-                                                if (parsed.tools && Array.isArray(parsed.tools)) {
-                                                    log('Transforming tool names to Title Case', {
-                                                        count: parsed.tools.length,
-                                                        names: parsed.tools.map((t) => t.name).slice(0, 5)
-                                                    });
-                                                    parsed.tools = parsed.tools.map((tool) => ({
-                                                        ...tool,
-                                                        name: tool.name ? toTitleCase(tool.name) : tool.name,
-                                                    }));
-                                                    body = JSON.stringify(parsed);
-                                                }
-                                            }
-                                            catch (e) {
-                                                log('Error parsing body for tool transformation', { error: String(e) });
-                                            }
-                                        }
-                                        let requestInput = input;
-                                        let requestUrl = null;
-                                        try {
-                                            if (typeof input === "string" || input instanceof URL) {
-                                                requestUrl = new URL(input.toString());
-                                            }
-                                            else if (input instanceof Request) {
-                                                requestUrl = new URL(input.url);
-                                            }
-                                        }
-                                        catch {
-                                            requestUrl = null;
-                                        }
-                                        if (requestUrl &&
-                                            requestUrl.pathname === "/v1/messages" &&
-                                            !requestUrl.searchParams.has("beta")) {
-                                            requestUrl.searchParams.set("beta", "true");
-                                            requestInput =
-                                                input instanceof Request
-                                                    ? new Request(requestUrl.toString(), input)
-                                                    : requestUrl;
-                                        }
-                                        log('Making authenticated request', {
-                                            url: requestUrl?.toString()?.substring(0, 100)
-                                        });
-                                        const response = await fetch(requestInput, {
-                                            ...requestInit,
-                                            body,
-                                            headers: requestHeaders,
-                                        });
-                                        log('Got response', { status: response.status });
-                                        // Transform streaming response to convert Title Case tool names back
-                                        if (response.body) {
-                                            const reader = response.body.getReader();
-                                            const decoder = new TextDecoder();
-                                            const encoder = new TextEncoder();
-                                            const stream = new ReadableStream({
-                                                async pull(controller) {
-                                                    const { done, value } = await reader.read();
-                                                    if (done) {
-                                                        controller.close();
-                                                        return;
-                                                    }
-                                                    let text = decoder.decode(value, { stream: true });
-                                                    // Convert Title Case tool names back to lowercase
-                                                    text = text.replace(/"name"\s*:\s*"([A-Z][^"]+)"/g, (_match, name) => {
-                                                        return `"name": "${fromTitleCase(name)}"`;
-                                                    });
-                                                    controller.enqueue(encoder.encode(text));
-                                                },
-                                            });
-                                            return new Response(stream, {
-                                                status: response.status,
-                                                statusText: response.statusText,
-                                                headers: response.headers,
-                                            });
-                                        }
-                                        return response;
-                                    }
-                                    catch (e) {
-                                        log('ERROR in custom fetch', { error: String(e), stack: e?.stack });
-                                        throw e;
-                                    }
-                                },
-                            };
-                        }
-                        log('Not OAuth auth, returning empty config');
-                        return {};
-                    }
-                    catch (e) {
-                        log('ERROR in loader', { error: String(e), stack: e?.stack });
-                        throw e;
-                    }
-                },
-                methods: [
-                    {
-                        label: "Claude Pro/Max",
-                        type: "oauth",
-                        authorize: async () => {
-                            log('Claude Pro/Max authorize method called');
-                            const { url, verifier } = await authorize("max");
-                            return {
-                                url: url,
-                                instructions: "Paste the authorization code here: ",
-                                method: "code",
-                                callback: async (code) => {
-                                    log('Claude Pro/Max callback called');
-                                    const credentials = await exchange(code, verifier);
-                                    return credentials;
-                                },
-                            };
-                        },
-                    },
-                    {
-                        label: "Create an API Key",
-                        type: "oauth",
-                        authorize: async () => {
-                            log('Create an API Key authorize method called');
-                            const { url, verifier } = await authorize("console");
-                            return {
-                                url: url,
-                                instructions: "Paste the authorization code here: ",
-                                method: "code",
-                                callback: async (code) => {
-                                    log('Create an API Key callback called');
-                                    const credentials = await exchange(code, verifier);
-                                    if (credentials.type === "failed")
-                                        return credentials;
-                                    const result = await fetch(`https://api.anthropic.com/api/oauth/claude_cli/create_api_key`, {
-                                        method: "POST",
-                                        headers: {
-                                            "Content-Type": "application/json",
-                                            authorization: `Bearer ${credentials.access}`,
-                                        },
-                                    }).then((r) => r.json());
-                                    log('API key created');
-                                    return { type: "success", key: result.raw_key };
-                                },
-                            };
-                        },
-                    },
-                    {
-                        provider: "anthropic",
-                        label: "Manually enter API Key",
-                        type: "api",
-                    },
-                ],
-            },
-        };
-    }
-    catch (e) {
-        log('ERROR in AlchemyAnthropicAuthPlugin', { error: String(e), stack: e?.stack });
-        throw e;
-    }
-}
-log('Plugin module fully loaded');
-//# sourceMappingURL=anthropic-auth.js.map

package/dist/plugins/auto-journal.js

@@ -1,83 +0,0 @@
-"use strict";
-/**
- * OpenCode Auto-Journal Plugin
- *
- * Automatically generates journal entries when requests are completed.
- * Hooks into tool.execute.after to detect request-operations complete calls.
- *
- * Checks .alchemy_lab/config.json for autoJournal setting before triggering.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
-const path_1 = require("path");
-const fs_1 = require("fs");
-/**
- * Check if autoJournal is enabled in config
- */
-function isAutoJournalEnabled(directory) {
-    try {
-        const configPath = (0, path_1.join)(directory || process.cwd(), '.alchemy_lab', 'config.json');
-        const configContent = (0, fs_1.readFileSync)(configPath, 'utf8');
-        const config = JSON.parse(configContent);
-        return config.autoJournal === true;
-    }
-    catch {
-        // Config doesn't exist or can't be read - default to false
-        return false;
-    }
-}
-exports.default = async ({ project, directory }) => {
-    return {
-        "tool.execute.after": async (input, output) => {
-            try {
-                // Check if this is request-operations
-                const toolName = input?.tool || input?.name;
-                if (!toolName || !toolName.includes('request-operations')) {
-                    return; // Not the tool we're looking for
-                }
-                // Check if autoJournal is enabled in config
-                if (!isAutoJournalEnabled(directory)) {
-                    return; // Auto-journal is disabled
-                }
-                // 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 - look for any message about completing a request
-                        // Format is "Request completed: req123" or similar
-                        const completionMatch = resultText.match(/Request completed:\s*(req\d+)/i);
-                        if (completionMatch) {
-                            const requestId = completionMatch[1];
-                            // Build the prompt for opencode
-                            const prompt = `Generate a journal entry for request ${requestId}.
-
-Steps:
-1. Use ${toolName.replace(/_request_operations$/, '__generate-request-journal')} tool with requestId: ${requestId}
-2. Write a concise narrative journal entry based on the returned data covering:
-   - What was implemented and why
-   - Key decisions and trade-offs made
-   - Challenges encountered and solutions
-   - Files modified and their purposes
-   - How acceptance criteria were met
-3. Save as JOURNAL-${requestId}.md using ${toolName.replace(/_request_operations$/, '__document-operations')} (operation: create, type: Report)
-
-Keep it story-focused and informative.`;
-                            // Spawn opencode in background (detached) using 'run' command with journal mode
-                            // OpenCode will find opencode.json in cwd automatically
-                            const child = (0, child_process_1.spawn)("opencode", ["run", "--agent", "journal", prompt], {
-                                detached: true,
-                                stdio: "ignore",
-                                cwd: directory || process.cwd()
-                            });
-                            child.unref();
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                // Silently ignore errors to avoid breaking the main session
-            }
-        }
-    };
-};
-//# sourceMappingURL=auto-journal.js.map

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