salmon-loop 0.2.3

package/dist/core/grizzco/validation/AstValidationService.js

@@ -0,0 +1,133 @@
+import { randomBytes } from 'crypto';
+import { tmpdir } from 'os';
+import path from 'path';
+import { readFile, rm } from '../../adapters/fs/node-fs.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { AstParser } from '../../ast/index.js';
+import { convertDiffToShadowOperations } from '../../patch/diff.js';
+import { tryGetPluginRegistry } from '../../plugin/registry.js';
+import { OpType } from '../domain/grizzco-types.js';
+function looksLikeUnifiedDiff(text) {
+    const trimmed = text.trimStart();
+    return (trimmed.startsWith('diff --git ') ||
+        trimmed.startsWith('--- a/') ||
+        trimmed.startsWith('--- /dev/null'));
+}
+function isAstInfrastructureError(message) {
+    const lower = message.toLowerCase();
+    return (lower.includes('failed to load language') ||
+        lower.includes('failed to initialize ast parser') ||
+        (lower.includes('enoent') && lower.includes('tree-sitter')));
+}
+function defaultResolveLanguage(filePath) {
+    return tryGetPluginRegistry()?.getByExtension(filePath)?.meta.id;
+}
+function defaultSupportsStrictValidation(filePath) {
+    const plugin = tryGetPluginRegistry()?.getByExtension(filePath);
+    return Boolean(plugin?.meta.capabilities?.ast?.strictValidation);
+}
+async function defaultBuildProposedSource(workPath, operation) {
+    if (!operation.content || operation.type === OpType.DELETE)
+        return null;
+    const contentText = operation.content.toString('utf8');
+    const isDiffPayload = looksLikeUnifiedDiff(contentText);
+    // Some callers may provide raw full-file content for OVERWRITE; parse it directly.
+    if (operation.type === OpType.OVERWRITE && !isDiffPayload)
+        return contentText;
+    // PATCH operations are unified diffs and may only contain hunks.
+    // Reconstruct candidate file content by applying the diff to a temporary git index.
+    if (!isDiffPayload)
+        return null;
+    const git = new GitAdapter(workPath);
+    const tempIndex = path.join(tmpdir(), `s8p-ast-${Date.now()}-${randomBytes(4).toString('hex')}`);
+    const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
+    const patchText = contentText;
+    const absoluteTargetPath = path.join(workPath, operation.path);
+    try {
+        const readTreeResult = await git.execMeta(['read-tree', 'HEAD'], { env });
+        if (!readTreeResult.ok) {
+            // Unborn branch or missing HEAD: seed temporary index from working tree when possible.
+            const existingContent = await readFile(absoluteTargetPath).catch(() => null);
+            if (existingContent) {
+                const hashRes = await git.execMeta(['hash-object', '-w', '--stdin'], {
+                    env,
+                    input: existingContent,
+                });
+                if (hashRes.ok) {
+                    const blobHash = hashRes.stdout.toString('utf8').trim();
+                    if (blobHash) {
+                        await git.exec(['update-index', '--add', '--cacheinfo', '100644', blobHash, operation.path], { env });
+                    }
+                }
+            }
+        }
+        await git.exec(['apply', '--cached', '--recount', '--ignore-whitespace', '-'], {
+            env,
+            input: Buffer.from(patchText, 'utf8'),
+        });
+        const showResult = await git.execMeta(['show', `:${operation.path}`], { env });
+        if (!showResult.ok)
+            return null;
+        return showResult.stdout.toString('utf8');
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await rm(tempIndex, { force: true }).catch(() => undefined);
+        await rm(`${tempIndex}.lock`, { force: true }).catch(() => undefined);
+    }
+}
+export class AstValidationService {
+    deps;
+    constructor(deps = {}) {
+        this.deps = {
+            convertDiffToShadowOperations,
+            parse: (code, lang) => AstParser.parse(code, lang),
+            resolveLanguage: defaultResolveLanguage,
+            supportsStrictValidation: defaultSupportsStrictValidation,
+            buildProposedSource: defaultBuildProposedSource,
+            ...deps,
+        };
+    }
+    async validate(args) {
+        const operations = await this.deps.convertDiffToShadowOperations(args.diff);
+        const strictness = args.strictness ?? 'lenient';
+        for (const op of operations) {
+            if (op.type === OpType.DELETE)
+                continue;
+            const lang = this.deps.resolveLanguage(op.path);
+            if (!lang)
+                continue;
+            const enforceStrict = strictness === 'strict' && this.deps.supportsStrictValidation(op.path);
+            try {
+                const proposedSource = await this.deps.buildProposedSource(args.workPath, op);
+                if (typeof proposedSource !== 'string') {
+                    if (enforceStrict) {
+                        return {
+                            ok: false,
+                            filePath: op.path,
+                            error: `AST Validation failed for ${op.path}: unable to reconstruct proposed source`,
+                        };
+                    }
+                    continue;
+                }
+                await this.deps.parse(proposedSource, lang);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                // Best-effort mode: if AST tooling is unavailable, strict-capable plugins may still fail hard.
+                if (isAstInfrastructureError(message) && !enforceStrict) {
+                    continue;
+                }
+                return {
+                    ok: false,
+                    filePath: op.path,
+                    error: `AST Syntax Error in ${op.path}: ${message}`,
+                };
+            }
+        }
+        return { ok: true };
+    }
+}
+//# sourceMappingURL=AstValidationService.js.map

package/dist/core/grizzco/validation/ContextValidator.js

@@ -0,0 +1,17 @@
+export class ContextValidator {
+    /**
+     * Validates the consistency of the exploration phase.
+     * If the model performs searches and has results, but no read actions,
+     * it's identified as a potential hallucination risk.
+     */
+    static validateExploration(audit, capturedCount) {
+        if (capturedCount > 0)
+            return { isValid: true };
+        const hasSuccessfulSearch = audit.some((e) => e.toolIntent === 'SEARCH' && e.toolResultStatus === 'ok');
+        return {
+            isValid: false,
+            errorCode: hasSuccessfulSearch ? 'explorationHallucination' : 'noFilesRead',
+        };
+    }
+}
+//# sourceMappingURL=ContextValidator.js.map

package/dist/core/grizzco/validation/ast-validation-policy.js

@@ -0,0 +1,11 @@
+export function resolveAstValidationStrictness(input) {
+    const configuredStrictness = input.options?.astValidation?.strictness;
+    if (configuredStrictness === 'strict' || configuredStrictness === 'lenient') {
+        return configuredStrictness;
+    }
+    // Default policy:
+    // - debug mode emphasizes containment and safety guarantees
+    // - other modes prefer best-effort compatibility
+    return input.mode === 'debug' ? 'strict' : 'lenient';
+}
+//# sourceMappingURL=ast-validation-policy.js.map

package/dist/core/grizzco/workers/direct-write-worker.js

@@ -0,0 +1,44 @@
+import { OpType } from '../domain/grizzco-types.js';
+/**
+ * Direct Write Worker
+ * Use case: Clean files, Untracked files (New files)
+ */
+export class DirectWriteWorker {
+    id = 'direct-write';
+    async execute(op, state) {
+        const startTime = Date.now();
+        if (!op.content && op.type !== OpType.DELETE) {
+            // Delete operations might not have content, but modify/create must
+            // However, ShadowOperation structure usually has content for create/modify
+            return {
+                path: state.path,
+                success: false,
+                error: 'Operation missing content',
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        // For delete operations, we don't strictly need content, but the merged content is technically empty/null
+        // logic handling is done in AtomicFileWriter, but here we prepare the result.
+        // If it's a delete, mergedContent should be undefined or empty?
+        // The AtomicFileWriter checks op.type.
+        // But TransactionStrategy calls executeMerge first.
+        // If op.type === 'delete', executeMerge might just pass.
+        // Actually, looking at TransactionStrategy in plan:
+        // .writeAtomic() handles delete logic separate from .executeMerge().
+        // But .executeMerge() is expected to produce mergedContent for write.
+        // If delete, maybe we return success with no content?
+        // Let's assume this worker is mainly for Create/Modify on clean files.
+        // If it's delete, it might be handled here too if needed, but let's stick to the plan's DirectWrite logic which returns op.content.
+        return {
+            path: state.path,
+            success: true,
+            mergedContent: op.content,
+            isConflict: false,
+            workerId: this.id,
+            executionTime: Date.now() - startTime,
+        };
+    }
+}
+//# sourceMappingURL=direct-write-worker.js.map

package/dist/core/grizzco/workers/git-apply-worker.js

@@ -0,0 +1,75 @@
+import { randomBytes } from 'crypto';
+import { tmpdir } from 'os';
+import * as path from 'path';
+import { rm } from '../../adapters/fs/node-fs.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { logIgnoredError } from '../../observability/ignored-error.js';
+import { FileStatus } from '../domain/grizzco-types.js';
+/**
+ * Git Apply Worker
+ * 🛡️ DATA INTEGRITY GUARDIAN:
+ * This worker uses the native 'git apply --3way' engine.
+ * It is the ONLY safe way to apply incremental patches to existing files
+ * without risking full-file truncation.
+ */
+export class GitApplyWorker {
+    workPath;
+    id = 'git-apply';
+    constructor(workPath) {
+        this.workPath = workPath;
+    }
+    async execute(op, state) {
+        const startTime = Date.now();
+        const git = new GitAdapter(this.workPath);
+        const tmpIndex = path.join(tmpdir(), `s8p-idx-${Date.now()}-${randomBytes(4).toString('hex')}`);
+        const env = { GIT_INDEX_FILE: tmpIndex };
+        try {
+            if (!op.content) {
+                throw new Error('Patch content is empty');
+            }
+            const diffText = op.content.toString('utf8');
+            // git apply --3way may consult the index for base blobs. In MM state, the index and working tree differ,
+            // which can trigger "does not match index" even for safe patches. We use a temporary index that matches
+            // the current working tree for the target path to keep the real index untouched.
+            const useTempIndex = state.status === FileStatus.MM;
+            if (useTempIndex) {
+                await git.exec(['read-tree', 'HEAD'], { env });
+                await git.exec(['add', '--', state.path], { env });
+            }
+            // applyPatch handles writing a temp patch file and running git apply
+            await git.applyPatch(diffText, {
+                threeWay: true,
+                ignoreWhitespace: true,
+                env: useTempIndex ? env : undefined,
+            });
+            return {
+                path: state.path,
+                success: true,
+                // For git-apply, the changes are applied directly to the filesystem.
+                // We return empty mergedContent because the result is already on disk,
+                // but success is true to indicate the transaction was successful.
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                path: state.path,
+                success: false,
+                error: error instanceof Error
+                    ? error instanceof Error
+                        ? error.message
+                        : String(error)
+                    : String(error),
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        finally {
+            await rm(tmpIndex, { force: true }).catch((error) => logIgnoredError(`[GitApplyWorker] cleanup ${tmpIndex}`, error));
+        }
+    }
+}
+//# sourceMappingURL=git-apply-worker.js.map

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

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

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

@@ -0,0 +1,117 @@
+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';
+import { StrataContentGuardian } from '../../strata/interaction/content-guardian.js';
+import { StrataFileSystemProvider } from '../../strata/interaction/file-system-provider.js';
+/**
+ * MM (Double Dirty) Three-Way Merge Worker
+ * Use case: File has changes in BOTH Index and Worktree.
+ *
+ * Strategy: Optimistic Concurrency Control.
+ *
+ * Base: Snapshot T0 (The state when AI started thinking)
+ * Ours: Current worktree (may have changed since T0)
+ * Theirs: AI Content (V2 - based on T0)
+ *
+ * This allows merging AI changes (T0 -> AI) with the user's latest changes (T0 -> current).
+ */
+export class MMThreeWayWorker {
+    git;
+    id = '3way-mm-advanced';
+    guardian = new StrataContentGuardian();
+    fsProvider;
+    constructor(git) {
+        this.git = git;
+        this.fsProvider = new StrataFileSystemProvider(git);
+    }
+    async gitMergeFile(baseText, oursText, theirsText) {
+        const tempDir = tmpdir();
+        const id = randomBytes(4).toString('hex');
+        const tempBase = path.join(tempDir, `s8p-mm-base-${id}`);
+        const tempOurs = path.join(tempDir, `s8p-mm-ours-${id}`);
+        const tempTheirs = path.join(tempDir, `s8p-mm-theirs-${id}`);
+        try {
+            await fs.writeFile(tempBase, baseText, 'utf8');
+            await fs.writeFile(tempOurs, oursText, 'utf8');
+            await fs.writeFile(tempTheirs, theirsText, 'utf8');
+            return await this.git.mergeFile(tempBase, tempOurs, tempTheirs);
+        }
+        finally {
+            await Promise.all([
+                fs
+                    .unlink(tempBase)
+                    .catch((error) => logIgnoredError(`[MMThreeWayWorker] cleanup ${tempBase}`, error)),
+                fs
+                    .unlink(tempOurs)
+                    .catch((error) => logIgnoredError(`[MMThreeWayWorker] cleanup ${tempOurs}`, error)),
+                fs
+                    .unlink(tempTheirs)
+                    .catch((error) => logIgnoredError(`[MMThreeWayWorker] cleanup ${tempTheirs}`, error)),
+            ]);
+        }
+    }
+    async execute(op, state, context) {
+        const startTime = Date.now();
+        if (!context?.snapshotId) {
+            return {
+                path: state.path,
+                success: false,
+                error: 'MM merge strategy requires snapshotId',
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        try {
+            // 1. Get Base (Snapshot T0)
+            const base = await this.git.show(context.snapshotId, state.path);
+            // 2. Get Theirs (AI Content)
+            const theirs = op.content;
+            // 3. Get Ours (Current Worktree) via Strata Safety Operator
+            // Scenario D: Must read from disk to include unstaged changes
+            const ours = await this.fsProvider.readYours(this.git.repoPath, state.path);
+            if (!ours) {
+                throw new Error(`Failed to read content for ${state.path} from disk`);
+            }
+            // 4. Content Safety Inspection (EOL & Binary)
+            const baseInfo = this.guardian.inspect(base);
+            const theirsInfo = this.guardian.inspect(theirs);
+            const oursInfo = this.guardian.inspect(ours);
+            if (baseInfo.isBinary || theirsInfo.isBinary || oursInfo.isBinary) {
+                return {
+                    path: state.path,
+                    success: false,
+                    error: 'Cannot perform text merge on binary file',
+                    isConflict: false,
+                    workerId: this.id,
+                    executionTime: Date.now() - startTime,
+                };
+            }
+            // 5. Perform Merge (Using Normalized Content)
+            const merged = await this.gitMergeFile(baseInfo.normalized, oursInfo.normalized, theirsInfo.normalized);
+            // 6. Restore EOL (Using User's Disk Preference)
+            const finalContent = this.guardian.restore(merged.content.toString('utf8'), oursInfo.eol);
+            return {
+                path: state.path,
+                success: !merged.hasConflict,
+                mergedContent: Buffer.from(finalContent),
+                isConflict: merged.hasConflict,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                path: state.path,
+                success: false,
+                error: `MM merge failed: ${error instanceof Error ? error.message : String(error)}`,
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+}
+//# sourceMappingURL=mm-three-way-worker.js.map

package/dist/core/grizzco/workers/no-op-worker.js

@@ -0,0 +1,18 @@
+/**
+ * NoOpWorker
+ * Does nothing. Useful for skipping files successfully.
+ */
+export class NoOpWorker {
+    id = 'no-op';
+    async execute(op, _state) {
+        return {
+            path: op.path,
+            success: true,
+            mergedContent: undefined,
+            isConflict: false,
+            workerId: 'no-op',
+            executionTime: 0,
+        };
+    }
+}
+//# sourceMappingURL=no-op-worker.js.map

package/dist/core/grizzco/workers/overwrite-binary-worker.js

@@ -0,0 +1,29 @@
+/**
+ * Overwrite Binary Worker
+ * Use case: Modifying binary files (no merge possible, just overwrite)
+ */
+export class OverwriteBinaryWorker {
+    id = 'overwrite-binary';
+    async execute(op, state) {
+        const startTime = Date.now();
+        if (!op.content) {
+            return {
+                path: state.path,
+                success: false,
+                error: 'Operation missing content for binary overwrite',
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        return {
+            path: state.path,
+            success: true,
+            mergedContent: op.content,
+            isConflict: false,
+            workerId: this.id,
+            executionTime: Date.now() - startTime,
+        };
+    }
+}
+//# sourceMappingURL=overwrite-binary-worker.js.map

package/dist/core/grizzco/workers/strata-sync-worker.js

@@ -0,0 +1,69 @@
+import { promises as fs } from '../../adapters/fs/node-fs.js';
+import { ShadowMergeEngine } from '../../strata/engine/shadow-merge-engine.js';
+/**
+ * StrataSyncWorker
+ * A bridge worker that delegates to the legacy ShadowMergeEngine for complex worktree synchronizations.
+ */
+export class StrataSyncWorker {
+    git;
+    checkpoints;
+    id = 'strata-sync';
+    constructor(git, checkpoints) {
+        this.git = git;
+        this.checkpoints = checkpoints;
+    }
+    async execute(op, state, context) {
+        const startTime = Date.now();
+        // Guard: Ensure we have necessary context for ShadowMergeEngine
+        if (!context?.shadowWorktreePath || !context?.initialRef || !context?.latestRef) {
+            return {
+                path: state.path,
+                success: false,
+                error: 'StrataSyncWorker requires shadowWorktreePath, initialRef, and latestRef in context',
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        try {
+            // 1. Instantiate the legacy engine
+            const engine = new ShadowMergeEngine({
+                mainRepoPath: this.git.repoPath,
+                shadowWorktreePath: context.shadowWorktreePath,
+                initialRef: context.initialRef,
+                latestRef: context.latestRef,
+                // We default to '3way' as Grizzco handles the high-level policy
+                applyBackOnDirty: '3way',
+                // Optional: propagate verbose level if available in context/options (omitted for brevity)
+            }, this.checkpoints);
+            // We need to fetch base content to use mergeFileContents
+            const baseContent = await this.git.show(context.initialRef, state.path);
+            // User content from disk
+            const userContent = await fs.readFile(state.absolutePath || state.path);
+            // AI content from op
+            const aiContent = op.content;
+            // Invoke legacy merge logic
+            // private method: async mergeFileContents(repoPath, base, user, ai, options?)
+            const result = await engine.mergeFileContents(this.git.repoPath, baseContent, userContent, aiContent);
+            return {
+                path: state.path,
+                success: !result.conflict,
+                mergedContent: result.merged,
+                isConflict: result.conflict,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                path: state.path,
+                success: false,
+                error: `Strata sync failed: ${error instanceof Error ? error.message : String(error)}`,
+                isConflict: false,
+                workerId: this.id,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+}
+//# sourceMappingURL=strata-sync-worker.js.map

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

@@ -0,0 +1,84 @@
+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';
+/**
+ * Standard Three-Way Merge Worker
+ * Use case: Unstaged modifications in text files.
+ *
+ * Base: HEAD
+ * Ours: Working Tree (File on disk)
+ * Theirs: AI Content
+ */
+export class ThreeWayMergeWorker {
+    git;
+    normalizer;
+    id = '3way-standard';
+    constructor(git, normalizer) {
+        this.git = git;
+        this.normalizer = normalizer;
+    }
+    async execute(op, state) {
+        const startTime = Date.now();
+        try {
+            // 1. Get Base (HEAD)
+            const base = await this.git.show('HEAD', state.path);
+            // 2. Get Theirs (AI Content)
+            const theirs = op.content;
+            // 3. Get Ours (Working Tree)
+            // We read from disk directly to ensure we have the latest content including unstaged changes
+            const ours = await fs.readFile(state.path);
+            // 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: `Three-way 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);
+            // Use GitAdapter to execute merge-file
+            // Note: GitAdapter.mergeFile implementation takes paths: base, current(ours), incoming(theirs)
+            return await this.git.mergeFile(tempBase, tempOurs, tempTheirs);
+        }
+        finally {
+            // Cleanup
+            await Promise.all([
+                fs
+                    .unlink(tempBase)
+                    .catch((error) => logIgnoredError(`[ThreeWayMergeWorker] cleanup ${tempBase}`, error)),
+                fs
+                    .unlink(tempTheirs)
+                    .catch((error) => logIgnoredError(`[ThreeWayMergeWorker] cleanup ${tempTheirs}`, error)),
+                fs
+                    .unlink(tempOurs)
+                    .catch((error) => logIgnoredError(`[ThreeWayMergeWorker] cleanup ${tempOurs}`, error)),
+            ]);
+        }
+    }
+}
+//# sourceMappingURL=three-way-merge-worker.js.map