salmon-loop 0.2.3

package/dist/core/ast/parser.js

@@ -0,0 +1,284 @@
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as TreeSitter from 'web-tree-sitter';
+import { text } from '../../locales/index.js';
+import { syncFs as fs } from '../adapters/fs/node-fs.js';
+import { LIMITS } from '../config/limits.js';
+import { createLanguageSupportOrchestrator } from '../language-support/orchestrator.js';
+import { getLogger } from '../observability/logger.js';
+import { tryGetPluginRegistry } from '../plugin/registry.js';
+const require = createRequire(import.meta.url);
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Initialization states for the AST parser
+ */
+var InitState;
+(function (InitState) {
+    InitState[InitState["Idle"] = 0] = "Idle";
+    InitState[InitState["Initializing"] = 1] = "Initializing";
+    InitState[InitState["Ready"] = 2] = "Ready";
+    InitState[InitState["Error"] = 3] = "Error";
+})(InitState || (InitState = {}));
+export class AstParser {
+    static state = InitState.Idle;
+    static initPromise = null;
+    /**
+     * Get the Parser class from web-tree-sitter, handling different API versions
+     */
+    static getParserClass() {
+        try {
+            return TreeSitter.Parser || TreeSitter.default?.Parser || TreeSitter;
+        }
+        catch (_error) {
+            getLogger().degrade(text.ast.degradedApi);
+            return TreeSitter.default || TreeSitter;
+        }
+    }
+    /**
+     * Get the Language class from web-tree-sitter, handling different API versions
+     */
+    static getLanguageClass() {
+        try {
+            return TreeSitter.Language || TreeSitter.default?.Language;
+        }
+        catch (_error) {
+            getLogger().degrade(text.ast.degradedApi);
+            return TreeSitter.default?.Language;
+        }
+    }
+    /**
+     * Get the Query class from web-tree-sitter, handling different API versions
+     */
+    static getQueryClass() {
+        try {
+            return TreeSitter.Query || TreeSitter.default?.Query;
+        }
+        catch (_error) {
+            getLogger().degrade(text.ast.degradedApi);
+            return TreeSitter.default?.Query;
+        }
+    }
+    static languages = new Map();
+    static languagePromises = new Map();
+    static treeCache = new Map();
+    static CACHE_LIMIT = LIMITS.astCacheSize;
+    /**
+     * Initialize the tree-sitter WASM environment with a state machine and lock
+     */
+    static async init() {
+        if (this.state === InitState.Ready)
+            return;
+        if (this.state === InitState.Initializing)
+            return this.initPromise;
+        this.state = InitState.Initializing;
+        this.initPromise = (async () => {
+            try {
+                const Parser = this.getParserClass();
+                if (typeof Parser.init === 'function') {
+                    await Parser.init();
+                }
+                this.state = InitState.Ready;
+            }
+            catch (e) {
+                this.state = InitState.Error;
+                this.initPromise = null;
+                throw new Error(text.ast.initFailed(e instanceof Error ? e.message : String(e)));
+            }
+        })();
+        return this.initPromise;
+    }
+    /**
+     * Load a language WASM module
+     */
+    static async getLanguage(lang, wasmPath) {
+        await this.init();
+        if (this.languages.has(lang)) {
+            return this.languages.get(lang);
+        }
+        if (this.languagePromises.has(lang)) {
+            return this.languagePromises.get(lang);
+        }
+        const promise = (async () => {
+            try {
+                let finalWasmPath = wasmPath;
+                if (!finalWasmPath) {
+                    // 1. Try to get WASM path from plugin registry first (New Architecture)
+                    const plugin = tryGetPluginRegistry()?.getById(lang);
+                    if (plugin) {
+                        const wasmSource = await plugin.parsing.getTreeSitterWasm();
+                        if (typeof wasmSource === 'string') {
+                            finalWasmPath = wasmSource;
+                        }
+                        else {
+                            // Handle Uint8Array if needed (direct load)
+                            // For now, assume path string primarily, or improve handling logic later
+                        }
+                    }
+                    // 2. Fallback to legacy resolution logic if no plugin or plugin returns nothing
+                    if (!finalWasmPath) {
+                        const searchPaths = [
+                            path.resolve(moduleDir, '../../../bin', `tree-sitter-${lang}.wasm`),
+                        ];
+                        try {
+                            const pkgPath = path.dirname(require.resolve(`tree-sitter-${lang}/package.json`));
+                            searchPaths.push(path.join(pkgPath, `tree-sitter-${lang}.wasm`));
+                        }
+                        catch (__e) {
+                            // Ignore resolution errors
+                        }
+                        for (const p of searchPaths) {
+                            if (fs.existsSync(p)) {
+                                finalWasmPath = p;
+                                break;
+                            }
+                        }
+                        if (!finalWasmPath) {
+                            finalWasmPath = searchPaths[0];
+                        }
+                    }
+                }
+                const Language = this.getLanguageClass();
+                const langObj = await Language.load(finalWasmPath);
+                this.languages.set(lang, langObj);
+                return langObj;
+            }
+            catch (e) {
+                throw new Error(text.ast.loadLanguageFailed(lang, e instanceof Error ? e.message : String(e)));
+            }
+        })();
+        this.languagePromises.set(lang, promise);
+        return promise;
+    }
+    /**
+     * Parse code into an AST tree
+     */
+    static async parse(code, lang, wasmPath) {
+        const cacheKey = `${lang}:${code.length}:${code.substring(0, 100)}`;
+        const cached = this.treeCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < LIMITS.astCacheTTLMs) {
+            return cached.tree;
+        }
+        await this.init();
+        let parser;
+        try {
+            const Parser = this.getParserClass();
+            parser = new Parser();
+            const language = await this.getLanguage(lang, wasmPath);
+            parser.setLanguage(language);
+            const tree = parser.parse(code);
+            // Simple LRU-like cleanup
+            if (this.treeCache.size >= this.CACHE_LIMIT) {
+                const oldestKey = this.treeCache.keys().next().value;
+                if (oldestKey) {
+                    const entry = this.treeCache.get(oldestKey);
+                    if (entry?.tree)
+                        entry.tree.delete();
+                    this.treeCache.delete(oldestKey);
+                }
+            }
+            this.treeCache.set(cacheKey, { tree, timestamp: Date.now() });
+            return tree;
+        }
+        catch (e) {
+            getLogger().error(`AST parse failed: ${e}`);
+            throw e;
+        }
+        finally {
+            if (parser) {
+                parser.delete();
+            }
+        }
+    }
+    /**
+     * Identify definitions in the tree using queries
+     */
+    static async identifyDefinitions(tree, lang) {
+        try {
+            const language = await this.getLanguage(lang);
+            // Get query from plugin via DSL orchestrator (zero hardcoded fallback)
+            const queryStr = await createLanguageSupportOrchestrator().getASTQuery(lang, 'definitions');
+            if (!queryStr || !tree?.rootNode)
+                return [];
+            const Query = this.getQueryClass();
+            const query = new Query(language, queryStr);
+            const captures = query.captures(tree.rootNode);
+            return captures
+                .filter((c) => c.name === 'def')
+                .map((c) => {
+                const nameNode = c.node.childForFieldName('name') || c.node;
+                return {
+                    name: nameNode?.text || 'unknown',
+                    kind: 'definition',
+                    location: {
+                        start: { line: nodeToRow(c.node.startPosition), column: c.node.startPosition.column },
+                        end: { line: nodeToRow(c.node.endPosition), column: c.node.endPosition.column },
+                    },
+                };
+            });
+        }
+        catch (e) {
+            getLogger().error(`AST identifyDefinitions failed: ${e}`);
+            return [];
+        }
+    }
+    /**
+     * Identify references in the tree using queries
+     */
+    static async identifyReferences(tree, lang) {
+        try {
+            const language = await this.getLanguage(lang);
+            // Get query from plugin via DSL orchestrator (zero hardcoded fallback)
+            const queryStr = await createLanguageSupportOrchestrator().getASTQuery(lang, 'references');
+            if (!queryStr || !tree?.rootNode)
+                return [];
+            const Query = this.getQueryClass();
+            const query = new Query(language, queryStr);
+            const captures = query.captures(tree.rootNode);
+            return captures
+                .filter((c) => c.name === 'ref')
+                .map((c) => {
+                const nameNode = c.node.childForFieldName('name') || c.node.childForFieldName('property') || c.node;
+                return {
+                    name: nameNode?.text || 'unknown',
+                    kind: 'reference',
+                    location: {
+                        start: { line: nodeToRow(c.node.startPosition), column: c.node.startPosition.column },
+                        end: { line: nodeToRow(c.node.endPosition), column: c.node.endPosition.column },
+                    },
+                };
+            });
+        }
+        catch (e) {
+            getLogger().error(`AST identifyReferences failed: ${e}`);
+            return [];
+        }
+    }
+    static async queryCapturesFromQuery(tree, lang, queryStr) {
+        try {
+            if (!queryStr || !tree?.rootNode)
+                return [];
+            const language = await this.getLanguage(lang);
+            const Query = this.getQueryClass();
+            const query = new Query(language, queryStr);
+            const captures = query.captures(tree.rootNode);
+            return captures.map((c) => ({
+                name: c.name,
+                text: c.node?.text || '',
+                line: nodeToRow(c.node.startPosition),
+                column: c.node.startPosition.column,
+            }));
+        }
+        catch (e) {
+            getLogger().debug(`AST query capture failed: ${e}`);
+            return [];
+        }
+    }
+}
+/**
+ * Convert 0-based row to 1-based line number
+ */
+function nodeToRow(pos) {
+    return pos.row + 1;
+}
+//# sourceMappingURL=parser.js.map

package/dist/core/ast/validator.js

@@ -0,0 +1,46 @@
+export function checkSyntaxErrors(tree) {
+    if (!tree)
+        return [];
+    const errors = [];
+    let cursor;
+    try {
+        cursor = typeof tree.walk === 'function' ? tree.walk() : null;
+    }
+    catch (_error) {
+        return [];
+    }
+    if (!cursor)
+        return [];
+    let reachedRoot = false;
+    while (!reachedRoot) {
+        const node = cursor.currentNode;
+        // Tree-sitter nodes may expose isMissing as a function or a property.
+        const isMissing = typeof node.isMissing === 'function' ? node.isMissing() : node.isMissing;
+        if (node.type === 'ERROR' || isMissing) {
+            errors.push({
+                line: node.startPosition.row,
+                column: node.startPosition.column,
+                type: node.type === 'ERROR' ? 'ERROR' : 'MISSING',
+                text: node.text,
+            });
+        }
+        if (cursor.gotoFirstChild()) {
+            continue;
+        }
+        if (cursor.gotoNextSibling()) {
+            continue;
+        }
+        let retracing = true;
+        while (retracing) {
+            if (!cursor.gotoParent()) {
+                retracing = false;
+                reachedRoot = true;
+            }
+            else if (cursor.gotoNextSibling()) {
+                retracing = false;
+            }
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=validator.js.map

package/dist/core/backends/salmon-loop/task-executor.js

@@ -0,0 +1,68 @@
+import { mapErrorForDisplay } from '../../observability/error-mapping.js';
+import { createLocalCommandRunner, withCommandRunner, } from '../../runtime/command-runner-context.js';
+function inferFailureCategory(result) {
+    if (result.failurePhase === 'VERIFY' || result.reasonCode === 'VERIFY_FAILED') {
+        return 'verification';
+    }
+    if (result.errorCode === 'AUTH_REQUIRED') {
+        return 'policy';
+    }
+    if (result.failurePhase === 'PREFLIGHT' ||
+        result.reasonCode === 'PREFLIGHT_NOT_GIT' ||
+        result.reasonCode === 'PREFLIGHT_DIRTY' ||
+        result.errorCode === 'PREFLIGHT_NOT_GIT' ||
+        result.errorCode === 'PREFLIGHT_DIRTY') {
+        return 'infrastructure';
+    }
+    return 'runtime';
+}
+export function createSalmonTaskExecutor(deps) {
+    return {
+        async execute(task, options) {
+            const runner = options?.commandRunner ?? createLocalCommandRunner();
+            const result = await withCommandRunner(runner, async () => {
+                return await deps.runLoop({
+                    instruction: task.request.instruction,
+                    checkpointSessionId: task.request.checkpointSessionId,
+                    repoPath: task.request.repoPath,
+                    mode: task.capability,
+                    onEvent: options?.onEvent,
+                    signal: options?.signal,
+                    authorizationProvider: options?.authorizationProvider,
+                    authorizationMode: options?.authorizationMode,
+                    fileSystemOverride: options?.fileSystemOverride,
+                });
+            });
+            if (result.reasonCode === 'AWAITING_INPUT' && result.inputRequired) {
+                return {
+                    ...task,
+                    state: 'awaiting_input',
+                    statusMessage: result.inputRequired.prompt,
+                    inputRequired: result.inputRequired,
+                };
+            }
+            if (!result.success) {
+                const failureCode = result.errorCode ?? result.reasonCode ?? 'LOOP_FAILED';
+                const failureMessage = mapErrorForDisplay({
+                    message: result.reason,
+                    code: failureCode,
+                }).message;
+                return {
+                    ...task,
+                    state: 'failed',
+                    statusMessage: failureMessage,
+                    failure: {
+                        code: failureCode,
+                        message: failureMessage,
+                        category: inferFailureCategory(result),
+                    },
+                };
+            }
+            return {
+                ...task,
+                state: 'completed',
+            };
+        },
+    };
+}
+//# sourceMappingURL=task-executor.js.map