salmon-loop 0.3.2 → 0.5.0

package/dist/core/verification/detect-runner.js

@@ -0,0 +1,86 @@
+/**
+ * Test runner detection and JSON flag injection.
+ *
+ * Detects which test runner a command invokes and, when the runner
+ * supports structured JSON output, rewrites the command to emit JSON
+ * so downstream parsers can consume machine-readable data instead of
+ * regex-matching human-friendly text.
+ */
+// ── Detection ────────────────────────────────────────────────────────────────
+/** Heuristic detection from the raw command string. */
+export function detectRunner(command) {
+    const cmd = command.toLowerCase();
+    // Order matters: more specific patterns first
+    if (/\bvitest\b/.test(cmd))
+        return 'vitest';
+    if (/\bjest\b/.test(cmd))
+        return 'jest';
+    if (/\bpytest\b/.test(cmd) || /\bpy\.test\b/.test(cmd))
+        return 'pytest';
+    if (/\btsc\b/.test(cmd))
+        return 'tsc';
+    if (/\beslint\b/.test(cmd))
+        return 'eslint';
+    if (/\bbun\s+test\b/.test(cmd))
+        return 'bun';
+    if (/\bgo\s+test\b/.test(cmd))
+        return 'go';
+    // npm/pnpm/yarn script proxies — try to infer from script name
+    if (/\bnpm\s+run\s+/.test(cmd) || /\bpnpm\s+/.test(cmd) || /\byarn\s+/.test(cmd)) {
+        if (/test:unit|test:e2e|test:integration|test:full/.test(cmd))
+            return 'unknown';
+        if (/\btest\b/.test(cmd))
+            return 'unknown'; // could be anything
+    }
+    return 'unknown';
+}
+// ── JSON flag injection ──────────────────────────────────────────────────────
+/** Returns true when the runner supports structured JSON output. */
+export function supportsJsonOutput(runner) {
+    return (runner === 'jest' ||
+        runner === 'vitest' ||
+        runner === 'eslint' ||
+        runner === 'bun' ||
+        runner === 'go');
+}
+/**
+ * Rewrite the command to emit structured output.
+ *
+ * Only modifies commands for runners that support JSON.
+ * Returns the original command unchanged when the runner
+ * has no JSON mode (pytest, tsc) or is unknown.
+ */
+export function injectJsonFlags(command, runner) {
+    switch (runner) {
+        case 'jest':
+            // jest --json --outputFile=/dev/null would suppress file write;
+            // but --json alone prints to stdout which is what we want.
+            // Avoid duplicating --json if already present.
+            if (command.includes('--json'))
+                return command;
+            return `${command} --json`;
+        case 'vitest':
+            // vitest --reporter=json --run  (--run prevents watch mode)
+            if (command.includes('--reporter=json') || command.includes('--reporter json'))
+                return command;
+            return `${command} --reporter=json --run`;
+        case 'eslint':
+            // eslint --format json
+            if (command.includes('--format json') || command.includes('--format=json'))
+                return command;
+            return `${command} --format json`;
+        case 'bun':
+            // bun test --json  (outputs NDJSON to stdout)
+            if (command.includes('--json'))
+                return command;
+            return `${command} --json`;
+        case 'go':
+            // go test -json
+            if (command.includes('-json'))
+                return command;
+            return `${command} -json`;
+        default:
+            return command;
+    }
+}
+//# sourceMappingURL=detect-runner.js.map

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/core/workspace/capabilities.js

@@ -1,6 +1,7 @@
 import { access, constants } from '../adapters/fs/node-fs.js';
 import { GitAdapter } from '../adapters/git/git-adapter.js';
 import { LIMITS } from '../config/limits.js';
+import { errorMessage } from '../utils/error.js';
 const PROBE_LIMITS = { maxStdoutBytes: 4_096, maxStderrChars: 4_096 };
 function gitFailureReason(result) {
     if (result.error?.code === 'ENOENT')
@@ -23,7 +24,7 @@ async function detectFileSystemCapability(workspacePath) {
         return {
             readable: false,
             writable: false,
-            reason: error instanceof Error ? error.message : String(error),
+            reason: errorMessage(error),
         };
     }
     try {
@@ -34,7 +35,7 @@ async function detectFileSystemCapability(workspacePath) {
         return {
             readable: true,
             writable: false,
-            reason: error instanceof Error ? error.message : String(error),
+            reason: errorMessage(error),
         };
     }
 }

package/dist/integrations/langfuse/litellm-langfuse-outcome-reporter.js

@@ -1,6 +1,7 @@
 import { readFile } from '../../core/adapters/fs/node-fs.js';
 import { recordAuditEvent } from '../../core/observability/audit-trail.js';
 import { getLogger } from '../../core/observability/logger.js';
+import { isRecord } from '../../core/utils/serialize.js';
 import { text } from '../../locales/index.js';
 function nowIso() {
     return new Date().toISOString();
@@ -43,7 +44,7 @@ function buildPhaseDurations(traces) {
         return undefined;
     const out = {};
     for (const t of traces) {
-        if (!t || typeof t !== 'object')
+        if (!isRecord(t))
             continue;
         const name = t.name;
         const duration = t.duration;
@@ -69,13 +70,13 @@ async function tryReadAuditJson(auditPath) {
 }
 function extractNetworkErrorCode(error) {
     const allow = (value) => typeof value === 'string' && /^[A-Z0-9_]{2,32}$/.test(value) ? value : undefined;
-    if (error && typeof error === 'object') {
-        const e = error;
-        return (allow(e.code) ||
-            allow(e.cause?.code) ||
-            allow(e.cause?.errno) ||
-            allow(e.errno) ||
-            allow(e.cause?.name));
+    if (isRecord(error)) {
+        const cause = isRecord(error.cause) ? error.cause : undefined;
+        return (allow(error.code) ||
+            allow(cause?.code) ||
+            allow(cause?.errno) ||
+            allow(error.errno) ||
+            allow(cause?.name));
     }
     return undefined;
 }

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',
@@ -770,7 +776,8 @@ Please return the patch in PURE unified diff format:`;
             missionFailedWithReason: (reason) => `Smallfry mission failed: ${reason}`,
         },
         ui: {
-            spawnToolDescription: 'Delegate a concrete sub-task to a specialized sub-agent. This is not a no-argument action: always provide agent_ref and task. Use agent_ref="explorer" for read-only investigation, "reviewer" for audit, "surgeon" for implementation proposals, or "cleaner" for lint/format cleanup. Keep task self-contained with relevant files and the exact deliverable. Omit session_target unless shared context is explicitly required.',
+            spawnToolDescription: 'Delegate a concrete sub-task to a specialized sub-agent. This is not a no-argument action: always provide agent_ref and task. Use agent_ref="explorer" for read-only investigation, "reviewer" for audit, "surgeon" for implementation proposals, or "cleaner" for lint/format cleanup. Keep task self-contained with relevant files and the exact deliverable. Omit session_target unless shared context is explicitly required. Set async=true to get a handle immediately and use agent_await to collect the result later.',
+            awaitToolDescription: 'Wait for an async sub-agent (spawned with agent_dispatch async=true) to complete and return its result. Pass the agentId from the dispatch handle.',
             progressTitle: (id) => `[Smallfry: ${id}]`,
         },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salmon-loop",
-  "version": "0.3.2",
+  "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",