salmon-loop 0.2.3

package/dist/core/grizzco/workers/three-way-staged-worker.js

@@ -0,0 +1,93 @@
+import { randomBytes } from 'crypto';
+import { tmpdir } from 'os';
+import * as path from 'path';
+import { promises as fs } from '../../adapters/fs/node-fs.js';
+import { logIgnoredError } from '../../observability/ignored-error.js';
+/**
+ * Staged Aware Three-Way Merge Worker
+ * Use case: File has changes in Index (Staged).
+ *
+ * Base: HEAD
+ * Ours: Index (Staged content)
+ * Theirs: AI Content
+ *
+ * Result matches Zero Index Access: We read from Index, but the result will be written to Worktree (Unstaged).
+ */
+export class ThreeWayStagedAwareWorker {
+    git;
+    normalizer;
+    id = '3way-staged-aware';
+    constructor(git, normalizer) {
+        this.git = git;
+        this.normalizer = normalizer;
+    }
+    async execute(op, state) {
+        const startTime = Date.now();
+        // Binary check (Safety)
+        if (state.isBinary) {
+            return {
+                path: state.path,
+                success: false,
+                error: 'Binary files do not support staged auto-merge',
+                isConflict: true,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        try {
+            // 1. Get Base (HEAD)
+            const base = await this.git.show('HEAD', state.path);
+            // 2. Get Ours (Index / Staged)
+            const ours = await this.git.show(':0', state.path);
+            // 3. Get Theirs (AI Content)
+            const theirs = op.content;
+            // 4. Perform Merge
+            const merged = await this.gitMergeFile(base, theirs, ours);
+            return {
+                path: state.path,
+                success: !merged.hasConflict,
+                mergedContent: merged.content,
+                isConflict: merged.hasConflict,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                path: state.path,
+                success: false,
+                error: `Staged merge failed: ${error instanceof Error ? error.message : String(error)}`,
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async gitMergeFile(base, theirs, ours) {
+        const tempDir = tmpdir();
+        const id = randomBytes(4).toString('hex');
+        const tempBase = path.join(tempDir, `s8p-base-${id}`);
+        const tempTheirs = path.join(tempDir, `s8p-theirs-${id}`);
+        const tempOurs = path.join(tempDir, `s8p-ours-${id}`);
+        try {
+            await fs.writeFile(tempBase, base);
+            await fs.writeFile(tempTheirs, theirs);
+            await fs.writeFile(tempOurs, ours);
+            return await this.git.mergeFile(tempBase, tempOurs, tempTheirs);
+        }
+        finally {
+            await Promise.all([
+                fs
+                    .unlink(tempBase)
+                    .catch((error) => logIgnoredError(`[ThreeWayStagedAwareWorker] cleanup ${tempBase}`, error)),
+                fs
+                    .unlink(tempTheirs)
+                    .catch((error) => logIgnoredError(`[ThreeWayStagedAwareWorker] cleanup ${tempTheirs}`, error)),
+                fs
+                    .unlink(tempOurs)
+                    .catch((error) => logIgnoredError(`[ThreeWayStagedAwareWorker] cleanup ${tempOurs}`, error)),
+            ]);
+        }
+    }
+}
+//# sourceMappingURL=three-way-staged-worker.js.map

package/dist/core/grizzco/workers/union-merge-worker.js

@@ -0,0 +1,71 @@
+import { Buffer } from 'node:buffer';
+import * as path from 'path';
+import * as fs from '../../adapters/fs/node-fs.js';
+/**
+ * Union Merge Worker
+ * Use case: Force append mode for safe file types.
+ * Strategy:
+ * 1. For safe types (.md, .txt, .log): Append content with a separator.
+ * 2. For code files: Reject (return conflict) to force .rej generation.
+ */
+export class UnionMergeWorker {
+    id = 'union-merge-safe';
+    // Safe extension whitelist
+    SAFE_EXTENSIONS = new Set(['.md', '.txt', '.log', '.csv']);
+    async execute(op, state, context) {
+        const startTime = Date.now();
+        const ext = path.extname(state.path).toLowerCase();
+        // 1. Check if extension is safe for union merge
+        if (!this.SAFE_EXTENSIONS.has(ext)) {
+            return {
+                path: state.path,
+                success: false,
+                error: 'Code files do not support forced append. Please resolve conflicts manually via .rej files.',
+                isConflict: true, // Treat as conflict to trigger .rej generation
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        // 2. Perform append
+        try {
+            let current;
+            if (state.workingContent) {
+                current = state.workingContent;
+            }
+            else {
+                const repoRoot = context?.repoRoot;
+                if (!repoRoot) {
+                    throw new Error('repoRoot context is required for union-merge reading');
+                }
+                const fullPath = path.join(repoRoot, state.path);
+                // 🛡️ REFACTOR: Join with repoRoot to ensure sandboxed reading
+                current = await fs.readFile(fullPath);
+            }
+            const incoming = op.content;
+            const merged = Buffer.concat([
+                current,
+                Buffer.from('\n\n<!-- === AI Generated Content === -->\n'),
+                incoming,
+            ]);
+            return {
+                path: state.path,
+                success: true,
+                mergedContent: merged,
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                path: state.path,
+                success: false,
+                error: `Union merge failed: ${error instanceof Error ? error.message : String(error)}`,
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+}
+//# sourceMappingURL=union-merge-worker.js.map

package/dist/core/history/input-history.js

@@ -0,0 +1,55 @@
+import { join } from 'path';
+import { FileAdapter } from '../adapters/fs/index.js';
+/**
+ * Manages persistence of user input history isolated by Session.
+ * Storage path: .salmonloop/ui-history/{sessionId}.json
+ */
+export class InputHistoryManager {
+    storageDir;
+    fileAdapter = new FileAdapter();
+    maxHistory = 500;
+    constructor(repoPath) {
+        this.storageDir = join(repoPath, '.salmonloop', 'ui-history');
+    }
+    /**
+     * Initialize the storage directory
+     */
+    async init() {
+        await this.fileAdapter.mkdir(this.storageDir);
+    }
+    /**
+     * Load input history for a specific Session
+     */
+    async load(sessionId) {
+        const filePath = join(this.storageDir, `${sessionId}.json`);
+        try {
+            const data = await this.fileAdapter.readFile(filePath);
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Append and persist new input
+     */
+    async append(sessionId, input) {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return;
+        // Rule: Exclude slash commands from history (AGENTS.md line 36)
+        if (trimmed.startsWith('/')) {
+            return;
+        }
+        const history = await this.load(sessionId);
+        // Deduplication: Don't record if identical to the last entry
+        if (history.length > 0 && history[history.length - 1] === trimmed) {
+            return;
+        }
+        history.push(trimmed);
+        const updatedHistory = history.slice(-this.maxHistory);
+        const filePath = join(this.storageDir, `${sessionId}.json`);
+        await this.fileAdapter.writeFile(filePath, JSON.stringify(updatedHistory, null, 2));
+    }
+}
+//# sourceMappingURL=input-history.js.map

package/dist/core/intent/chat-intent.js

@@ -0,0 +1,250 @@
+import { z } from 'zod';
+const LlmDecisionSchema = z
+    .object({
+    intent: z.enum(['answer', 'review', 'patch', 'debug', 'research']),
+    confidence: z.number().min(0).max(1),
+    reason: z.string().min(1).max(300),
+})
+    .strict();
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.min(1, Math.max(0, value));
+}
+function normalize(input) {
+    return String(input ?? '').trim();
+}
+function routeHeuristic(input) {
+    const text = normalize(input);
+    const lower = text.toLowerCase();
+    // Strong signals: explicit diffs
+    if (lower.includes('diff --git') || lower.includes('@@') || lower.includes('+++ b/')) {
+        return {
+            intent: 'patch',
+            confidence: 0.98,
+            classifier: 'heuristic',
+            reason: 'diff_markers_detected',
+        };
+    }
+    // Strong signals: errors / stack traces / failing checks
+    const errorSignals = [
+        'traceback (most recent call last)',
+        'exception',
+        'error:',
+        'panic:',
+        'segmentation fault',
+        'assertionerror',
+        'typeerror',
+        'referenceerror',
+        'syntaxerror',
+        'cannot find module',
+        'module not found',
+        'failed',
+        'fail:',
+        'bun test',
+        'test:unit',
+        'test:full',
+        'vitest',
+        'jest',
+        'eslint',
+        'ts',
+    ];
+    const hasErrorSignal = errorSignals.some((s) => lower.includes(s)) || /\bat\s+\S+:\d+:\d+\b/.test(lower);
+    if (hasErrorSignal) {
+        return {
+            intent: 'debug',
+            confidence: 0.9,
+            classifier: 'heuristic',
+            reason: 'error_signal_detected',
+        };
+    }
+    // Review-like requests
+    const researchSignals = [
+        'deep research',
+        'research',
+        'investigate',
+        'investigation',
+        '调研',
+        '研究',
+        '资料搜集',
+        '资料收集',
+    ];
+    if (researchSignals.some((s) => lower.includes(s))) {
+        return {
+            intent: 'research',
+            confidence: 0.86,
+            classifier: 'heuristic',
+            reason: 'research_signal_detected',
+        };
+    }
+    // Review-like requests
+    const reviewSignals = [
+        'review',
+        'code review',
+        'audit',
+        'security',
+        'performance',
+        'lint',
+        'best practice',
+    ];
+    if (reviewSignals.some((s) => lower.includes(s))) {
+        return {
+            intent: 'review',
+            confidence: 0.82,
+            classifier: 'heuristic',
+            reason: 'review_signal_detected',
+        };
+    }
+    // Edit-like verbs (moderate confidence)
+    const editSignals = [
+        'fix',
+        'implement',
+        'add',
+        'remove',
+        'refactor',
+        'rename',
+        'update',
+        'change',
+        'create',
+        'delete',
+        'optimize',
+        'support',
+        'migrate',
+    ];
+    if (editSignals.some((s) => lower.includes(s))) {
+        return {
+            intent: 'patch',
+            confidence: 0.72,
+            classifier: 'heuristic',
+            reason: 'edit_signal_detected',
+        };
+    }
+    // Default heuristic: answer
+    return {
+        intent: 'answer',
+        confidence: 0.55,
+        classifier: 'heuristic',
+        reason: 'default_answer',
+    };
+}
+function shouldCallLlmHeuristic(decision, input) {
+    if (decision.confidence >= 0.8)
+        return false;
+    // Prefer LLM classification for non-trivial or non-ASCII inputs where English heuristics are weak.
+    const hasNonAscii = (() => {
+        for (let i = 0; i < input.length; i++) {
+            if (input.charCodeAt(i) > 127)
+                return true;
+        }
+        return false;
+    })();
+    // Note: this improves classification quality for multilingual inputs, but it adds one extra LLM roundtrip
+    // before emitting the first "intent routed" log in chat mode.
+    if (hasNonAscii)
+        return true;
+    if (decision.intent === 'answer' && decision.confidence < 0.7)
+        return true;
+    return false;
+}
+async function routeByLlm(input, options) {
+    const extractJsonObject = (raw) => {
+        const trimmed = String(raw ?? '').trim();
+        if (!trimmed) {
+            throw new Error('Empty LLM response');
+        }
+        const stripCodeFence = (value) => {
+            const v = value.trim();
+            if (!v.startsWith('```'))
+                return v;
+            const firstNewline = v.indexOf('\n');
+            if (firstNewline < 0)
+                return v.replace(/```/g, '').trim();
+            const withoutHeader = v.slice(firstNewline + 1);
+            const closing = withoutHeader.lastIndexOf('```');
+            if (closing >= 0)
+                return withoutHeader.slice(0, closing).trim();
+            return withoutHeader.trim();
+        };
+        const candidate = stripCodeFence(trimmed);
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            // Best-effort: extract the first JSON object from mixed output.
+            const start = candidate.indexOf('{');
+            const end = candidate.lastIndexOf('}');
+            if (start >= 0 && end > start) {
+                return JSON.parse(candidate.slice(start, end + 1));
+            }
+            throw new Error(`Invalid JSON: ${candidate.slice(0, 80)}`);
+        }
+    };
+    const system = [
+        'You are an intent router for a coding assistant.',
+        'Classify the user message into exactly one intent:',
+        '- answer: explain, answer questions, or give guidance; no repository mutation.',
+        '- review: analyze existing code and provide suggestions; no repository mutation.',
+        '- patch: user is requesting code changes, new features, or refactors.',
+        '- debug: user is reporting an error/failing tests/logs and wants it fixed.',
+        'Return a JSON object with keys: intent, confidence (0..1), reason.',
+        'Return JSON only (no Markdown, no code fences, no backticks).',
+    ].join('\n');
+    const messages = [
+        { role: 'system', content: system },
+        { role: 'user', content: input },
+    ];
+    const res = await options.llm.chat(messages, {
+        temperature: 0,
+        responseFormat: 'json_object',
+        signal: options.signal,
+        tools: [],
+        toolChoice: 'none',
+    });
+    const raw = String(res?.content ?? '').trim();
+    const parsed = extractJsonObject(raw);
+    const value = LlmDecisionSchema.parse(parsed);
+    const intent = value.intent;
+    const confidence = clamp01(value.confidence);
+    // Safety gating: default to non-mutating intent if confidence is low.
+    const mutating = intent === 'patch' || intent === 'debug';
+    if (mutating && confidence < 0.6) {
+        return {
+            intent: 'answer',
+            confidence: 1 - confidence,
+            classifier: 'llm',
+            reason: `downgraded_low_confidence:${value.reason}`,
+        };
+    }
+    return {
+        intent,
+        confidence,
+        classifier: 'llm',
+        reason: value.reason,
+    };
+}
+export async function routeChatIntent(input, options) {
+    const normalized = normalize(input);
+    if (!normalized) {
+        return {
+            intent: 'answer',
+            confidence: 1,
+            classifier: 'fallback',
+            reason: 'empty_input',
+        };
+    }
+    const heuristic = routeHeuristic(normalized);
+    if (!shouldCallLlmHeuristic(heuristic, normalized))
+        return heuristic;
+    try {
+        return await routeByLlm(normalized, options);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return {
+            ...heuristic,
+            classifier: 'fallback',
+            reason: `llm_classification_failed:${msg}`,
+        };
+    }
+}
+//# sourceMappingURL=chat-intent.js.map

package/dist/core/interaction/events/bus.js

@@ -0,0 +1,52 @@
+export function createTaskEventBus() {
+    const listeners = new Set();
+    const events = [];
+    let nextId = 1;
+    return {
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        publish(event) {
+            let resolvedId = event.id;
+            if (resolvedId) {
+                const numericId = Number(resolvedId);
+                if (Number.isFinite(numericId) && numericId >= nextId) {
+                    nextId = numericId + 1;
+                }
+                else {
+                    resolvedId = String(nextId++);
+                }
+            }
+            else {
+                resolvedId = String(nextId++);
+            }
+            const persistedEvent = {
+                ...event,
+                id: resolvedId,
+            };
+            events.push(persistedEvent);
+            for (const listener of listeners) {
+                listener(persistedEvent);
+            }
+        },
+        list(taskId, options) {
+            const afterId = options?.afterId ?? null;
+            const filtered = events.filter((event) => {
+                if (event.taskId !== taskId)
+                    return false;
+                if (!afterId)
+                    return true;
+                return Number(event.id) > Number(afterId);
+            });
+            const limit = options?.limit;
+            if (typeof limit === 'number') {
+                return filtered.slice(0, Math.max(0, limit));
+            }
+            return filtered;
+        },
+    };
+}
+//# sourceMappingURL=bus.js.map

package/dist/core/interaction/model/events.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=events.js.map

package/dist/core/interaction/model/index.js

@@ -0,0 +1,3 @@
+export { canTransitionTaskState, isTerminalTaskState } from './task-state.js';
+export { createTaskTransitionPolicy } from './transition-policy.js';
+//# sourceMappingURL=index.js.map

package/dist/core/interaction/model/task-state.js

@@ -0,0 +1,9 @@
+import { createTaskTransitionPolicy } from './transition-policy.js';
+export function isTerminalTaskState(state) {
+    return state === 'completed' || state === 'failed' || state === 'cancelled';
+}
+const transitionPolicy = createTaskTransitionPolicy();
+export function canTransitionTaskState(from, to) {
+    return transitionPolicy.allows(from, to);
+}
+//# sourceMappingURL=task-state.js.map

package/dist/core/interaction/model/transition-policy.js

@@ -0,0 +1,50 @@
+const TASK_TRANSITIONS = {
+    accepted: ['running', 'cancelled'],
+    running: ['streaming', 'awaiting_input', 'completed', 'failed', 'cancelled'],
+    awaiting_input: ['running', 'cancelled'],
+    streaming: ['running', 'awaiting_input', 'completed', 'failed', 'cancelled'],
+    completed: ['awaiting_input', 'cancelled'],
+    failed: ['accepted', 'awaiting_input'],
+    cancelled: ['accepted', 'awaiting_input'],
+};
+const RETRYABLE_FAILURE_CATEGORIES = new Set(['verification', 'runtime', 'infrastructure']);
+export function createTaskTransitionPolicy() {
+    return {
+        allows(from, to) {
+            return TASK_TRANSITIONS[from].includes(to);
+        },
+        allowedTargets(from) {
+            return [...TASK_TRANSITIONS[from]];
+        },
+        isResumable(state) {
+            return state === 'streaming' || state === 'awaiting_input';
+        },
+        isRetryable(state) {
+            return state === 'failed' || state === 'cancelled';
+        },
+        isReopenable(state) {
+            return state === 'completed' || state === 'failed' || state === 'cancelled';
+        },
+        canRetry(task) {
+            if (!this.isRetryable(task.state))
+                return false;
+            if (!task.failure)
+                return false;
+            if (!task.failure.retryable)
+                return false;
+            if (!task.failure.category)
+                return false;
+            return RETRYABLE_FAILURE_CATEGORIES.has(task.failure.category);
+        },
+        canReopen(task) {
+            if (!this.isReopenable(task.state))
+                return false;
+            if (task.state === 'completed')
+                return true;
+            if (!task.failure?.category)
+                return false;
+            return RETRYABLE_FAILURE_CATEGORIES.has(task.failure.category);
+        },
+    };
+}
+//# sourceMappingURL=transition-policy.js.map

package/dist/core/interaction/model/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map