salmon-loop 0.4.1 → 0.5.0

package/dist/core/verification/runner.js

@@ -90,6 +90,82 @@ export function isRetryable(error) {
             return false;
     }
 }
+/**
+ * Extract test summary counts from runner output.
+ * Supports jest/vitest, pytest, bun test, and go test formats.
+ */
+export function parseTestSummary(output) {
+    const lower = output.toLowerCase();
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let found = false;
+    // jest/vitest: "Tests: 2 failed, 5 passed, 7 total"
+    const jestMatch = lower.match(/tests:\s+(?:(\d+)\s+failed,\s*)?(?:(\d+)\s+passed,\s*)?(\d+)\s+total/);
+    if (jestMatch) {
+        failed = parseInt(jestMatch[1] || '0');
+        passed = parseInt(jestMatch[2] || '0');
+        const total = parseInt(jestMatch[3]);
+        skipped = total - passed - failed;
+        found = true;
+    }
+    // jest/vitest: "Test Suites: 1 failed, 3 passed, 4 total"
+    if (!found) {
+        const suiteMatch = lower.match(/test suites:\s+(?:(\d+)\s+failed,\s*)?(?:(\d+)\s+passed,\s*)?(\d+)\s+total/);
+        if (suiteMatch) {
+            failed = parseInt(suiteMatch[1] || '0');
+            passed = parseInt(suiteMatch[2] || '0');
+            const total = parseInt(suiteMatch[3]);
+            skipped = total - passed - failed;
+            found = true;
+        }
+    }
+    // pytest: "2 failed, 5 passed"
+    if (!found) {
+        const pytestMatch = lower.match(/(?:(\d+)\s+failed,?\s*)?(?:(\d+)\s+passed,?\s*)?(?:(\d+)\s+skipped)?/);
+        if (pytestMatch && (pytestMatch[1] || pytestMatch[2])) {
+            failed = parseInt(pytestMatch[1] || '0');
+            passed = parseInt(pytestMatch[2] || '0');
+            skipped = parseInt(pytestMatch[3] || '0');
+            found = true;
+        }
+    }
+    // bun test: "5 pass | 1 fail"
+    if (!found) {
+        const bunMatch = lower.match(/(\d+)\s+pass\s*\|\s*(\d+)\s+fail/);
+        if (bunMatch) {
+            passed = parseInt(bunMatch[1]);
+            failed = parseInt(bunMatch[2]);
+            found = true;
+        }
+    }
+    // go test: "ok" / "FAIL" with counts
+    if (!found) {
+        const goMatch = lower.match(/(\d+)\s+of\s+(\d+)\s+tests?\s+passed/);
+        if (goMatch) {
+            passed = parseInt(goMatch[1]);
+            const total = parseInt(goMatch[2]);
+            failed = total - passed;
+            found = true;
+        }
+    }
+    // Generic: "N passed" / "N failed" / "N skipped"
+    if (!found) {
+        const passMatch = lower.match(/(\d+)\s+pass(?:ed|ing)/);
+        const failMatch = lower.match(/(\d+)\s+fail(?:ed|ing)/);
+        const skipMatch = lower.match(/(\d+)\s+skip(?:ped)/);
+        if (passMatch || failMatch) {
+            passed = passMatch ? parseInt(passMatch[1]) : 0;
+            failed = failMatch ? parseInt(failMatch[1]) : 0;
+            skipped = skipMatch ? parseInt(skipMatch[1]) : 0;
+            found = true;
+        }
+    }
+    if (!found)
+        return undefined;
+    const total = passed + failed + Math.max(skipped, 0);
+    return { total, passed, failed, skipped: Math.max(skipped, 0) };
+}
 export async function runCommand(repoPath, command, timeoutMs, env, signal) {
     const shell = getPlatformShellInvocation(command);
     let output = '';

package/dist/core/version.js

@@ -1,4 +1,5 @@
 import { createRequire } from 'module';
+import { getLogger } from './observability/logger.js';
 const require = createRequire(import.meta.url);
 function readPackageVersion() {
     try {
@@ -7,8 +8,9 @@ function readPackageVersion() {
             return pkg.version;
         }
     }
-    catch {
+    catch (error) {
         // Fall back for non-package runtime embeddings.
+        getLogger().debug(`[Version] Failed to read package.json: ${error instanceof Error ? error.message : String(error)}`);
     }
     return '0.0.0';
 }

package/dist/languages/python/index.js

@@ -0,0 +1,154 @@
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { syncFs as fs } from '../../core/adapters/fs/node-fs.js';
+import { ErrorType } from '../../core/types/index.js';
+const require = createRequire(import.meta.url);
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+const queries = {
+    definitions: `
+    (function_definition name: (identifier) @name) @def
+    (class_definition name: (identifier) @name) @def
+    (decorated_definition
+      definition: (function_definition name: (identifier) @name)) @def
+    (decorated_definition
+      definition: (class_definition name: (identifier) @name)) @def
+  `,
+    references: `
+    (call function: (identifier) @name) @ref
+    (attribute object: (identifier) @name) @ref
+  `,
+};
+export const pythonPlugin = {
+    meta: {
+        id: 'python',
+        name: 'Python',
+        extensions: ['.py', '.pyw', '.pyi'],
+        capabilities: {
+            levels: {
+                l1Parsing: true,
+                l2Symbols: true,
+                l3Flow: true,
+            },
+            ast: {
+                strictValidation: true,
+            },
+        },
+    },
+    detection: {
+        matches: async (repoPath) => {
+            const markers = ['pyproject.toml', 'setup.py', 'requirements.txt', 'Pipfile'];
+            return markers.some((m) => fs.existsSync(path.join(repoPath, m)));
+        },
+    },
+    parsing: {
+        getTreeSitterWasm: async () => {
+            const searchPaths = [path.resolve(moduleDir, '../../../bin', 'tree-sitter-python.wasm')];
+            try {
+                const pkgPath = path.dirname(require.resolve('tree-sitter-python/package.json'));
+                searchPaths.push(path.join(pkgPath, 'tree-sitter-python.wasm'));
+            }
+            catch (_e) {
+                // ignore
+            }
+            for (const p of searchPaths) {
+                if (fs.existsSync(p)) {
+                    return p;
+                }
+            }
+            return searchPaths[0];
+        },
+        queries,
+        queryPack: {
+            version: '1.0.0',
+            symbols: {
+                calls: `
+          (call function: (identifier) @callee)
+          (call function: (attribute attribute: (identifier) @callee))
+        `,
+            },
+            flow: {
+                control: `
+          (if_statement) @branch
+          (elif_clause) @branch
+          (for_statement) @loop
+          (while_statement) @loop
+          (await) @async
+        `,
+                exceptions: `
+          (try_statement) @trycatch
+          (raise_statement) @throw
+          (except_clause) @catch
+        `,
+            },
+        },
+    },
+    dependency: {
+        extractImports: (content) => {
+            const dependencies = [];
+            // from .foo import bar / from ..foo import bar
+            const fromPattern = /from\s+(\.\.+[.\w/]*)\s+import/g;
+            // import .foo (rare but valid in some contexts)
+            const importPattern = /(?:^|\s)import\s+(\.\.+[.\w/]*)/gm;
+            let match;
+            while ((match = fromPattern.exec(content)) !== null) {
+                if (match[1])
+                    dependencies.push(match[1]);
+            }
+            while ((match = importPattern.exec(content)) !== null) {
+                if (match[1])
+                    dependencies.push(match[1]);
+            }
+            return dependencies;
+        },
+        resolvePath: (_basePath, importPath) => {
+            if (!importPath.endsWith('.py') && !importPath.endsWith('.pyi')) {
+                return importPath + '.py';
+            }
+            return importPath;
+        },
+    },
+    diagnostics: {
+        classifyError: (output) => {
+            const lower = output.toLowerCase();
+            // Dependency errors
+            if (lower.includes('modulenotfounderror') ||
+                lower.includes('importerror') ||
+                lower.includes('no module named') ||
+                lower.includes('pip install')) {
+                return ErrorType.DEPENDENCY_ERROR;
+            }
+            // Compilation / syntax errors
+            if (lower.includes('syntaxerror') ||
+                lower.includes('indentationerror') ||
+                lower.includes('taberror') ||
+                lower.includes('failed to compile') ||
+                lower.includes('py_compile')) {
+                return ErrorType.COMPILATION;
+            }
+            // Test errors
+            if (lower.includes('pytest') ||
+                lower.includes('unittest') ||
+                lower.includes('assertionerror') ||
+                lower.includes('assert ') ||
+                lower.includes('test failed') ||
+                lower.includes('tests failed') ||
+                lower.includes('failed tests') ||
+                lower.includes(' ERRORS') ||
+                lower.includes(' FAILURES')) {
+                return ErrorType.TEST;
+            }
+            // Lint errors
+            if (lower.includes('pylint') ||
+                lower.includes('flake8') ||
+                lower.includes('mypy') ||
+                lower.includes('ruff') ||
+                lower.includes('pycodestyle') ||
+                lower.includes('pyflakes')) {
+                return ErrorType.LINT;
+            }
+            return undefined;
+        },
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/locales/en.js

@@ -576,11 +576,17 @@ Please return the patch in PURE unified diff format:`;
         fsListDirectoryDescription: 'List directory entries (files and subdirectories) under a repository path',
         fsListFilesDescription: 'List files (excluding subdirectories) under a repository path',
         fsWriteFileDescription: 'Write a UTF-8 text file atomically (slash-only)',
+        fsEditFileDescription: 'Replace exact occurrences of a string in a file (slash-only). old_string must appear exactly once unless replace_all is set.',
         fsCreateDirectoryDescription: 'Create a directory under the repository root (slash-only)',
         fsDeleteFileDescription: 'Delete a file under the repository root (slash-only)',
         gitStatusDescription: 'Show the working tree status',
         gitCatDescription: 'Read file content from a specific git revision',
+        gitBlameDescription: 'Show line-by-line authorship for a file',
+        gitLogDescription: 'Show structured commit history',
+        gitShowDescription: 'Show commit details and diff',
+        globFindDescription: 'Find files matching a glob pattern (respects .gitignore)',
         codeAstDescription: 'Query AST definitions and references for symbols',
+        codeFindReferencesDescription: 'Find all references to a symbol across the codebase using ripgrep pre-filter + tree-sitter precise matching',
         testRunDescription: 'Run verification command (test/lint/build) and classify errors',
         shellExecDescription: 'Execute a shell command in an isolated workspace (slash-only)',
         artifactReadDescription: 'Read salmonloop (s8p) artifacts by handle',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salmon-loop",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "A chat-first coding agent CLI for safe, reviewable repository changes",
   "type": "module",
   "bin": {
@@ -154,6 +154,7 @@
     "react": "^19.2.4",
     "tiktoken": "^1.0.22",
     "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-python": "^0.25.0",
     "web-tree-sitter": "0.26.3",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",