salmon-loop 0.2.3

package/dist/core/verification/runner.js

@@ -0,0 +1,265 @@
+import { join } from 'path';
+import { text } from '../../locales/index.js';
+import { readFile } from '../adapters/fs/node-fs.js';
+import { GitAdapter } from '../adapters/git/git-adapter.js';
+import { LIMITS } from '../config/limits.js';
+import { getLogger } from '../observability/logger.js';
+import { tryGetPluginRegistry } from '../plugin/registry.js';
+import { isCommandAvailable, spawnCommand } from '../runtime/process-runner.js';
+import { ErrorType } from '../types/index.js';
+import { getPlatformShellInvocation } from '../utils/platform-shell.js';
+/**
+ * Classify the error type based on the output of the verification command
+ */
+export function classifyError(output) {
+    // 1. Common system errors (Language agnostic)
+    const lowerOutput = output.toLowerCase();
+    if (lowerOutput.includes('resource lock error') ||
+        lowerOutput.includes('file lock') ||
+        (lowerOutput.includes('already exists') && lowerOutput.includes('.lock')) ||
+        lowerOutput.includes('ebusy') ||
+        lowerOutput.includes('eperm')) {
+        return ErrorType.RESOURCE_LOCK_ERROR;
+    }
+    if (lowerOutput.includes('ast syntax error') ||
+        lowerOutput.includes('ast structure error') ||
+        lowerOutput.includes('ast scope integrity error') ||
+        lowerOutput.includes('ast validation failed')) {
+        return ErrorType.AST_VALIDATION_ERROR;
+    }
+    // 1.5 Test failure strong signals (language agnostic)
+    if (lowerOutput.includes('bun file tests failed in:') ||
+        lowerOutput.includes('script "test:unit" exited with code') ||
+        lowerOutput.includes('script "test:full" exited with code') ||
+        lowerOutput.startsWith('fail ') ||
+        lowerOutput.includes('\nfail ') ||
+        lowerOutput.includes('test suites') ||
+        lowerOutput.includes('test files') ||
+        lowerOutput.includes('assertionerror')) {
+        return ErrorType.TEST;
+    }
+    // 2. Delegate to plugins
+    for (const plugin of tryGetPluginRegistry()?.getAll() ?? []) {
+        const errorType = plugin.diagnostics.classifyError(output);
+        if (errorType) {
+            return errorType;
+        }
+    }
+    // 3. Heuristics fallback (works even without plugins)
+    if (/TS\d{3,5}/i.test(output) ||
+        lowerOutput.includes('error ts') ||
+        lowerOutput.includes('failed to compile')) {
+        return ErrorType.COMPILATION;
+    }
+    if (lowerOutput.includes('eslint') ||
+        lowerOutput.includes('prettier') ||
+        lowerOutput.includes('prettier/prettier')) {
+        return ErrorType.LINT;
+    }
+    if (lowerOutput.includes('fail ') ||
+        lowerOutput.includes('test suites') ||
+        lowerOutput.includes('test files') ||
+        lowerOutput.includes('assertionerror')) {
+        return ErrorType.TEST;
+    }
+    // 4. Generic logic fallback
+    if (output.trim().length > 0) {
+        return ErrorType.LOGIC;
+    }
+    return ErrorType.UNKNOWN;
+}
+/**
+ * Determine if an error type is retryable
+ */
+export function isRetryable(error) {
+    switch (error) {
+        case ErrorType.COMPILATION:
+        case ErrorType.LINT:
+        case ErrorType.TEST:
+        case ErrorType.LOGIC:
+        case ErrorType.AST_VALIDATION_ERROR:
+            return true;
+        case ErrorType.DEPENDENCY_ERROR:
+        case ErrorType.RESOURCE_LOCK_ERROR:
+        case ErrorType.UNKNOWN:
+        default:
+            return false;
+    }
+}
+export async function runCommand(repoPath, command, timeoutMs, env, signal) {
+    const shell = getPlatformShellInvocation(command);
+    let output = '';
+    const appendOutput = (chunk) => {
+        if (output.length >= 500000)
+            return;
+        const textChunk = Buffer.from(chunk).toString();
+        const remaining = 500000 - output.length;
+        output += textChunk.slice(0, remaining);
+    };
+    const result = await spawnCommand({
+        command: shell.file,
+        args: shell.args,
+        cwd: repoPath,
+        windowsHide: true,
+        detached: process.platform !== 'win32',
+        env: env ? { ...process.env, ...env } : process.env,
+        timeoutMs,
+        killGraceMs: 2000,
+        signal,
+        onStdoutChunk: appendOutput,
+        onStderrChunk: appendOutput,
+    });
+    if (result.error) {
+        return {
+            ok: false,
+            output: text.verify.commandError(command, result.error.message),
+            exitCode: -1,
+        };
+    }
+    if (result.timedOut) {
+        output += text.verify.terminated;
+    }
+    const fullOutput = output.trim();
+    const lines = fullOutput.split('\n');
+    let truncatedOutput = fullOutput;
+    if (lines.length > LIMITS.verifyOutputMaxLines) {
+        const half = Math.floor(LIMITS.verifyOutputMaxLines / 2);
+        const head = lines.slice(0, half).join('\n');
+        const tail = lines.slice(-half).join('\n');
+        truncatedOutput = `${head}${text.verify.outputTruncated(half, half)}${tail}`;
+    }
+    return {
+        ok: !result.timedOut && result.code === 0,
+        output: truncatedOutput,
+        exitCode: result.code,
+    };
+}
+export async function runVerify(repoPath, verifyCommand, env, signal) {
+    const result = await runCommand(repoPath, verifyCommand, LIMITS.verifyTimeoutMs, env, signal);
+    if (!result.ok && result.output.includes('Command timed out')) {
+        result.output = result.output.replace('Command timed out', text.verify.commandTimeout);
+    }
+    if (!result.ok && result.output.includes('Failed to start command')) {
+        result.output = result.output.replace('Failed to start command', text.verify.failedToStartCommand);
+    }
+    return result;
+}
+/**
+ * Verify if a file contains the expected content (string or regex).
+ *
+ * @param repoPath - The root path of the repository
+ * @param filePath - The relative path of the file to check
+ * @param expected - The content string or regex to look for
+ * @returns true if the content is found, false otherwise (including if file is missing)
+ */
+export async function verifyFileContent(repoPath, filePath, expected, onEvent) {
+    try {
+        const fullPath = join(repoPath, filePath);
+        const content = await readFile(fullPath, 'utf-8');
+        if (typeof expected === 'string') {
+            return content.includes(expected);
+        }
+        else {
+            return expected.test(content);
+        }
+    }
+    catch (err) {
+        if ((err && typeof err === 'object' && 'code' in err
+            ? err.code
+            : undefined) === 'ENOENT') {
+            return false;
+        }
+        // Report unexpected errors via event instead of direct getLogger().warn
+        onEvent?.({
+            type: 'resource.status',
+            resource: 'file',
+            status: 'warning',
+            message: text.verify.verifyFileContentError(filePath, err instanceof Error ? err.message : String(err)),
+            timestamp: new Date(),
+        });
+        getLogger().debug(`verifyFileContent failed for ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
+export async function preflight(workspace, onEvent, options) {
+    const now = () => new Date();
+    const git = new GitAdapter(workspace.baseRepoPath);
+    // 1. Check if it's a git repo
+    const gitCheck = await git.execMeta(['rev-parse', '--is-inside-work-tree'], {
+        cwd: workspace.baseRepoPath,
+        limits: { maxStdoutBytes: 4_096, maxStderrChars: 4_096 },
+        timeoutMs: LIMITS.gitTimeoutMs,
+    });
+    if (!gitCheck.ok) {
+        if (gitCheck.error?.code === 'ENOENT') {
+            return { ok: false, reason: text.loop.gitNotFound, reasonCode: 'PREFLIGHT_NOT_GIT' };
+        }
+        if (gitCheck.error?.message) {
+            return {
+                ok: false,
+                reason: text.loop.preflightGitCheckFailed(gitCheck.error.message),
+                reasonCode: 'PREFLIGHT_NOT_GIT',
+            };
+        }
+        return { ok: false, reason: text.loop.preflightFailedNotGit, reasonCode: 'PREFLIGHT_NOT_GIT' };
+    }
+    if (gitCheck.stdoutTruncated) {
+        return {
+            ok: false,
+            reason: text.loop.preflightGitCheckFailed(text.git.outputTruncated(4096)),
+            reasonCode: 'LOOP_FAILED',
+        };
+    }
+    // 2. Check if workspace is dirty (only for direct strategy)
+    // Allow dirty workspace by default for worktree strategy
+    if (workspace.strategy === 'direct' && !options?.ignoreDirty) {
+        const statusCheck = await git.execMeta(['status', '--porcelain'], {
+            cwd: workspace.baseRepoPath,
+            limits: { maxStdoutBytes: 64_000, maxStderrChars: 4_096 },
+            timeoutMs: LIMITS.gitTimeoutMs,
+        });
+        if (!statusCheck.ok) {
+            return {
+                ok: false,
+                reason: text.loop.preflightGitStatusFailed(statusCheck.error?.message ?? statusCheck.stderr.trim() ?? 'Unknown error'),
+                reasonCode: 'LOOP_FAILED',
+            };
+        }
+        if (statusCheck.stdoutTruncated) {
+            return {
+                ok: false,
+                reason: text.loop.preflightGitStatusFailed(text.git.outputTruncated(64_000)),
+                reasonCode: 'LOOP_FAILED',
+            };
+        }
+        const output = statusCheck.stdout.toString('utf8').trim();
+        if (output.length > 0) {
+            return {
+                ok: false,
+                reason: text.loop.preflightFailedDirty(output),
+                reasonCode: 'PREFLIGHT_DIRTY',
+            };
+        }
+        return { ok: true };
+    }
+    // Worktree strategy: ignore dirty state in base repository
+    onEvent?.({
+        type: 'resource.status',
+        resource: 'git',
+        status: 'skipped',
+        message: text.verify.worktreeStrategyActive,
+        timestamp: now(),
+    });
+    // 3. Check if ripgrep is installed (optional but recommended)
+    if (!(await isCommandAvailable('rg'))) {
+        onEvent?.({
+            type: 'resource.status',
+            resource: 'ripgrep',
+            status: 'warning',
+            message: text.verify.ripgrepNotFoundWarning,
+            timestamp: now(),
+        });
+    }
+    return { ok: true };
+}
+//# sourceMappingURL=runner.js.map

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

@@ -0,0 +1,272 @@
+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 { text } from '../../locales/index.js';
+function nowIso() {
+    return new Date().toISOString();
+}
+function trimTrailingSlashes(value) {
+    return value.replace(/\/+$/, '');
+}
+function normalizePathPrefix(value) {
+    const raw = (value || '').trim();
+    if (!raw)
+        return '/langfuse';
+    const withSlash = raw.startsWith('/') ? raw : `/${raw}`;
+    const trimmed = withSlash.replace(/\/+$/, '');
+    return trimmed || '/langfuse';
+}
+function buildBasicAuthHeader(username, password) {
+    // LiteLLM's built-in /langfuse proxy route expects Basic auth in the form "any:<key>".
+    const token = Buffer.from(`${username}:${password}`, 'utf8').toString('base64');
+    return `Basic ${token}`;
+}
+function buildStableId(parts) {
+    return parts
+        .join(':')
+        .replace(/[^a-zA-Z0-9:_-]/g, '_')
+        .slice(0, 128);
+}
+function truncateForAudit(value, max) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, max)}…[truncated]…`;
+}
+function truncateForLangfuse(value, max) {
+    const raw = (value || '').trim();
+    if (!raw)
+        return undefined;
+    return raw.length <= max ? raw : `${raw.slice(0, max)}…[truncated]…`;
+}
+function buildPhaseDurations(traces) {
+    if (!Array.isArray(traces))
+        return undefined;
+    const out = {};
+    for (const t of traces) {
+        if (!t || typeof t !== 'object')
+            continue;
+        const name = t.name;
+        const duration = t.duration;
+        if (typeof name === 'string' && typeof duration === 'number' && Number.isFinite(duration)) {
+            out[name] = duration;
+        }
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+async function tryReadAuditJson(auditPath) {
+    if (!auditPath)
+        return null;
+    try {
+        const raw = await readFile(auditPath, 'utf8');
+        const data = JSON.parse(raw);
+        if (!data || typeof data !== 'object')
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+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));
+    }
+    return undefined;
+}
+function classifyFailureKind(error, aborted) {
+    if (aborted)
+        return 'timeout';
+    if (error instanceof Error && error.name === 'AbortError')
+        return 'timeout';
+    if (extractNetworkErrorCode(error))
+        return 'network';
+    if (error instanceof Error)
+        return 'network';
+    return 'unknown';
+}
+export class LiteLlmLangfuseOutcomeReporter {
+    proxyBaseUrl;
+    proxyPathPrefix;
+    timeoutMs;
+    litellmApiKey;
+    constructor(options) {
+        this.proxyBaseUrl = trimTrailingSlashes(options.proxyBaseUrl);
+        this.proxyPathPrefix = normalizePathPrefix(options.proxyPathPrefix);
+        this.litellmApiKey = options.litellmApiKey;
+        this.timeoutMs = options.timeoutMs ?? 2500;
+    }
+    async report(report, ctx) {
+        const traceId = ctx.runId;
+        if (!traceId)
+            return;
+        const audit = await tryReadAuditJson(ctx.auditPath);
+        const meta = audit?.meta && typeof audit.meta === 'object' ? audit.meta : undefined;
+        const phaseDurations = buildPhaseDurations(audit?.traces);
+        const durationMs = typeof meta?.duration === 'number' && Number.isFinite(meta.duration)
+            ? meta.duration
+            : undefined;
+        const lastStep = typeof meta?.lastStep === 'string' ? meta.lastStep : undefined;
+        const traceMetadata = {
+            salmonloop: {
+                runId: traceId,
+                sessionId: ctx.sessionId,
+                userId: ctx.userId,
+                success: report.success,
+                reasonCode: report.reasonCode,
+                attempts: report.attempts,
+                failurePhase: report.failurePhase,
+                errorCode: report.errorCode,
+                lastStep,
+                durationMs,
+                phaseDurations,
+            },
+        };
+        const scores = [
+            { name: 'run_success', value: report.success ? 1 : 0 },
+            { name: 'first_attempt_success', value: report.success && report.attempts === 1 ? 1 : 0 },
+        ];
+        const tags = [];
+        tags.push('salmonloop');
+        tags.push(report.success ? 'status:success' : 'status:failure');
+        if (ctx.mode)
+            tags.push(`mode:${ctx.mode}`);
+        if (report.failurePhase)
+            tags.push(`failurePhase:${report.failurePhase}`);
+        if (report.errorCode)
+            tags.push(`errorCode:${report.errorCode}`);
+        const timestamp = nowIso();
+        const traceUpsert = {
+            id: buildStableId([traceId, 'trace-create', timestamp]),
+            type: 'trace-create',
+            timestamp,
+            body: {
+                id: traceId,
+                name: 'salmonloop.run',
+                sessionId: ctx.sessionId,
+                userId: ctx.userId,
+                input: {
+                    instruction: truncateForLangfuse(ctx.instruction, 2000),
+                    verify: truncateForLangfuse(ctx.verify, 500),
+                    mode: ctx.mode,
+                    repoPath: ctx.repoPath,
+                },
+                output: {
+                    success: report.success,
+                    reason: truncateForLangfuse(report.reason, 2000),
+                    reasonCode: report.reasonCode,
+                    attempts: report.attempts,
+                    failurePhase: report.failurePhase,
+                    errorCode: report.errorCode,
+                    changedFiles: report.changedFiles,
+                    lastStep,
+                    durationMs,
+                },
+                metadata: traceMetadata,
+                tags,
+            },
+        };
+        const scoreEvents = scores.map((s) => ({
+            id: buildStableId([traceId, 'score', s.name]),
+            type: 'score-create',
+            timestamp,
+            body: {
+                id: buildStableId([traceId, 'score', s.name]),
+                traceId,
+                name: s.name,
+                value: s.value,
+                dataType: 'NUMERIC',
+            },
+        }));
+        const ok = await this.postIngestion([traceUpsert, ...scoreEvents], traceId);
+        if (ok) {
+            recordAuditEvent('langfuse.outcome.reported', { traceId, ok: true, scores: scores.map((s) => s.name) }, { source: 'observability', severity: 'low', scope: 'session' });
+            getLogger().debug(text.grizzco.langfuse.outcomeReported(traceId));
+            return;
+        }
+        getLogger().warn(text.grizzco.langfuse.outcomeReportFailed(traceId));
+    }
+    async postIngestion(events, traceId) {
+        const url = `${this.proxyBaseUrl}${this.proxyPathPrefix}/api/public/ingestion`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const headers = { 'content-type': 'application/json' };
+            if (this.litellmApiKey) {
+                headers.Authorization = buildBasicAuthHeader('any', this.litellmApiKey);
+                // Also send the canonical LiteLLM auth header for deployments that rely on it.
+                headers['x-litellm-api-key'] = this.litellmApiKey;
+            }
+            const resp = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ batch: events }),
+                signal: controller.signal,
+            });
+            if (!resp.ok) {
+                // Capture a small response preview for debugging in audit logs (no secrets).
+                let bodyPreview;
+                try {
+                    bodyPreview = truncateForAudit(await resp.text(), 800);
+                }
+                catch {
+                    // ignore
+                }
+                recordAuditEvent('langfuse.outcome.http_failed', {
+                    traceId,
+                    url,
+                    status: resp.status,
+                    statusText: resp.statusText,
+                    bodyPreview,
+                }, { source: 'observability', severity: 'low', scope: 'session' });
+                return false;
+            }
+            // Langfuse returns 207 with per-event errors; treat any event error as failure.
+            try {
+                const result = (await resp.json());
+                if (Array.isArray(result?.errors) && result.errors.length > 0) {
+                    recordAuditEvent('langfuse.outcome.ingestion_failed', {
+                        traceId,
+                        errors: result.errors.map((e) => ({
+                            id: e.id,
+                            status: e.status,
+                        })),
+                    }, { source: 'observability', severity: 'low', scope: 'session' });
+                    getLogger().debug(`[Langfuse] Ingestion returned errors for ids: ${result.errors
+                        .map((e) => e.id)
+                        .join(',')}`);
+                    return false;
+                }
+            }
+            catch {
+                // If the proxy returns a non-JSON body, fall back to "ok".
+            }
+            return true;
+        }
+        catch (error) {
+            const aborted = controller.signal.aborted;
+            const kind = classifyFailureKind(error, aborted);
+            const errorName = error instanceof Error ? error.name : undefined;
+            const errorCode = extractNetworkErrorCode(error);
+            recordAuditEvent('langfuse.outcome.request_failed', {
+                traceId,
+                url,
+                timeoutMs: this.timeoutMs,
+                aborted,
+                kind,
+                errorName,
+                errorCode,
+            }, { source: 'observability', severity: 'low', scope: 'session' });
+            return false;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+//# sourceMappingURL=litellm-langfuse-outcome-reporter.js.map

package/dist/integrations/langfuse/outcome-proxy.js

@@ -0,0 +1,68 @@
+function trimTrailingSlashes(value) {
+    return value.replace(/\/+$/, '');
+}
+function deriveRootFromOpenAiBaseUrl(baseUrl) {
+    const trimmed = trimTrailingSlashes(baseUrl);
+    return trimmed.replace(/\/v1$/, '');
+}
+function trimTrailingSlashesFromPathname(value) {
+    return value.replace(/\/+$/, '');
+}
+function stripLangfuseApiSuffix(pathname) {
+    // Accept user-provided endpoints like:
+    // - /langfuse
+    // - /langfuse/
+    // - /langfuse/api/public
+    // - /langfuse/api/public/ingestion
+    // Normalize all of them to a stable prefix where we can append "/api/public/ingestion".
+    const p = trimTrailingSlashesFromPathname(pathname || '');
+    return p.replace(/\/api\/public(?:\/.*)?$/, '') || '';
+}
+function hostnameOf(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isKnownPublicProviderHost(hostname) {
+    // Avoid accidentally sending Langfuse ingestion traffic to public LLM provider hosts.
+    // This list is intentionally small and can be extended as needed.
+    return (hostname === 'api.openai.com' ||
+        hostname === 'api.anthropic.com' ||
+        hostname === 'generativelanguage.googleapis.com');
+}
+export function resolveLangfuseOutcomeProxyBaseUrl(input) {
+    const enabled = Boolean(input.enabled);
+    if (!enabled)
+        return { enabled: false, reason: 'DISABLED' };
+    const endpoint = (input.endpoint || '').trim();
+    if (endpoint) {
+        try {
+            const u = new URL(endpoint);
+            const base = trimTrailingSlashes(u.origin);
+            const rawPrefix = stripLangfuseApiSuffix(u.pathname);
+            const prefix = rawPrefix ? trimTrailingSlashesFromPathname(rawPrefix) : '/langfuse';
+            const host = hostnameOf(base);
+            if (host && isKnownPublicProviderHost(host)) {
+                return { enabled: true, reason: 'PUBLIC_PROVIDER_HOST' };
+            }
+            return { enabled: true, proxyBaseUrl: base, proxyPathPrefix: prefix };
+        }
+        catch {
+            // If an invalid URL is provided, treat it as missing so callers can fall back.
+            return { enabled: true, reason: 'MISSING_PROXY_URL' };
+        }
+    }
+    const llmBaseUrl = (input.llmBaseUrl || '').trim();
+    if (!llmBaseUrl)
+        return { enabled: true, reason: 'MISSING_PROXY_URL' };
+    const derived = deriveRootFromOpenAiBaseUrl(llmBaseUrl);
+    const host = hostnameOf(derived);
+    if (host && isKnownPublicProviderHost(host)) {
+        return { enabled: true, reason: 'PUBLIC_PROVIDER_HOST' };
+    }
+    return { enabled: true, proxyBaseUrl: derived, proxyPathPrefix: '/langfuse' };
+}
+//# sourceMappingURL=outcome-proxy.js.map

package/dist/interfaces/cli/task-runner.js

@@ -0,0 +1,11 @@
+export function createCliTaskRunner(deps) {
+    return {
+        async run(input) {
+            return deps.facade.createTask({
+                capability: input.capability,
+                request: { instruction: input.instruction },
+            });
+        },
+    };
+}
+//# sourceMappingURL=task-runner.js.map