salmon-loop 0.2.3

package/dist/core/failure/diagnostics.js

@@ -0,0 +1,221 @@
+import { builtinModules } from 'module';
+function extractMissingModule(output) {
+    const patterns = [
+        /TS2307:\s+Cannot find module ['"]([^'"]+)['"]/i,
+        /Cannot find module ['"]([^'"]+)['"]/i,
+    ];
+    for (const pattern of patterns) {
+        const match = output.match(pattern);
+        if (match?.[1])
+            return match[1];
+    }
+    return undefined;
+}
+const BUILTIN_MODULES = new Set(builtinModules.map((name) => name.replace(/^node:/, '')));
+const SAFE_PACKAGE_NAME_PATTERN = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+function isBarePackageSpecifier(specifier) {
+    const trimmed = specifier.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed.startsWith('.') || trimmed.startsWith('/') || trimmed.startsWith('\\'))
+        return false;
+    if (trimmed.startsWith('node:') || trimmed.startsWith('#'))
+        return false;
+    if (trimmed.startsWith('~/') || trimmed.startsWith('@/'))
+        return false;
+    if (/^[a-zA-Z]:[\\/]/.test(trimmed))
+        return false;
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed))
+        return false;
+    if (BUILTIN_MODULES.has(trimmed))
+        return false;
+    return true;
+}
+function extractPackageName(specifier) {
+    if (!isBarePackageSpecifier(specifier))
+        return undefined;
+    if (specifier.startsWith('@')) {
+        const [scope, name] = specifier.split('/');
+        if (!scope || !name)
+            return undefined;
+        return `${scope}/${name}`;
+    }
+    return specifier.split('/')[0] || undefined;
+}
+function isSafePackageName(packageName) {
+    return SAFE_PACKAGE_NAME_PATTERN.test(packageName);
+}
+function inferInstallCommand(output, pkg) {
+    const lower = output.toLowerCase();
+    if (lower.includes('pnpm'))
+        return `pnpm add ${pkg}`;
+    if (lower.includes('yarn'))
+        return `yarn add ${pkg}`;
+    if (lower.includes('npm'))
+        return `npm install ${pkg}`;
+    return `bun add ${pkg}`;
+}
+function buildGenericDependencyGuidance() {
+    return {
+        diagnosticCode: 'VERIFY_DEPENDENCY_ERROR',
+        safeHint: 'Verification failed because dependency setup is incomplete in the execution environment.',
+        remediationSteps: [
+            'Install project dependencies in the repository root and retry.',
+            'If this keeps failing, ensure all imported packages are declared in package.json.',
+        ],
+    };
+}
+function buildDependencyGuidance(input) {
+    if (input.reasonCode !== 'VERIFY_FAILED')
+        return undefined;
+    const output = input.verifyOutput || '';
+    const missingSpecifier = extractMissingModule(output);
+    if (!missingSpecifier) {
+        if (input.errorCode !== 'dependency_error')
+            return undefined;
+        return buildGenericDependencyGuidance();
+    }
+    const packageName = extractPackageName(missingSpecifier);
+    if (!packageName || !isSafePackageName(packageName)) {
+        if (input.errorCode !== 'dependency_error')
+            return undefined;
+        return buildGenericDependencyGuidance();
+    }
+    const installCommand = inferInstallCommand(output, packageName);
+    const modeHint = input.environmentMode === 'strict'
+        ? 'strict mode uses an isolated worktree and does not inherit parent-level node_modules.'
+        : 'isolated execution may not reuse parent-level node_modules.';
+    return {
+        diagnosticCode: 'UNDECLARED_DEPENDENCY',
+        safeHint: `Missing declared dependency '${packageName}' in verification environment.`,
+        remediationSteps: [
+            `Declare and install it in this project (for example: \`${installCommand}\`).`,
+            'Commit the updated lockfile so isolated environments can reproduce dependencies.',
+            `Why this happens: ${modeHint}`,
+        ],
+    };
+}
+function buildErrorCodeGuidance(input) {
+    switch (input.errorCode) {
+        case 'LLM_HTTP_REQUEST_FAILED':
+            return {
+                diagnosticCode: 'LLM_HTTP_REQUEST_FAILED',
+                safeHint: 'LLM request failed. Please retry in a moment.',
+                remediationSteps: [
+                    'Retry the command after a short delay.',
+                    'If it persists, check provider status or credentials.',
+                ],
+            };
+        case 'LLM_HTTP_ABORTED':
+            return {
+                diagnosticCode: 'LLM_HTTP_ABORTED',
+                safeHint: 'LLM request was aborted. Please retry.',
+                remediationSteps: [
+                    'Retry the command.',
+                    'If it persists, check network connectivity or timeouts.',
+                ],
+            };
+        case 'noFilesRead':
+            return {
+                diagnosticCode: 'NO_FILES_READ',
+                safeHint: 'Exploration did not read any files. Your instruction may be too vague (for example, "review my code"). Please specify the exact file(s) or scope you want to work with.',
+                remediationSteps: [
+                    'Explicitly open the target file(s) in your editor, or reference them in your instruction (for example: "review src/main.ts").',
+                    'If you want to review recent changes, try "review the last committed files" or "review git diff".',
+                    'Retry the command after opening or referencing the specific files.',
+                ],
+            };
+        case 'explorationHallucination':
+            return {
+                diagnosticCode: 'EXPLORATION_HALLUCINATION',
+                safeHint: 'Exploration found candidate files via search but did not read them. This usually happens when the instruction is ambiguous (e.g., "review my code" without specifying which files).',
+                remediationSteps: [
+                    'Open the specific file(s) you want to work with in your editor, or reference them explicitly in your instruction.',
+                    'If you saw file names in search results, try: "review <file-path>" or "analyze <file-path>".',
+                    'For ambiguous instructions like "review my code", the agent needs you to clarify which files or scope to focus on.',
+                ],
+            };
+        case 'PATCH_NOT_APPLICABLE':
+            return {
+                diagnosticCode: 'PATCH_NOT_APPLICABLE',
+                safeHint: 'Patch could not be applied cleanly. Please retry.',
+                remediationSteps: [
+                    'Re-run after syncing with the latest file contents.',
+                    'If it keeps failing, rerun with a smaller, more targeted change.',
+                ],
+            };
+        case 'LLM_PATCH_EMPTY':
+            return {
+                diagnosticCode: 'LLM_PATCH_EMPTY',
+                safeHint: 'LLM returned an empty patch. Please retry.',
+                remediationSteps: ['Retry the command.'],
+            };
+        case 'LLM_PATCH_NOT_UNIFIED_DIFF':
+            return {
+                diagnosticCode: 'LLM_PATCH_NOT_UNIFIED_DIFF',
+                safeHint: 'LLM returned a patch in an unsupported format. Please retry.',
+                remediationSteps: ['Ensure the patch is in unified diff format.'],
+            };
+        case 'lint':
+            return {
+                diagnosticCode: 'LINT_FAILED',
+                safeHint: 'Linting failed. Fix lint issues and retry.',
+                remediationSteps: ['Run the lint command locally to see details.'],
+            };
+        case 'test':
+            return {
+                diagnosticCode: 'TEST_FAILED',
+                safeHint: 'Tests failed. Fix test failures and retry.',
+                remediationSteps: ['Run the test command locally to see details.'],
+            };
+        case 'Error':
+            return {
+                diagnosticCode: 'UNEXPECTED_ERROR',
+                safeHint: 'An unexpected error occurred. Check the audit log for details and retry.',
+                remediationSteps: [
+                    'Retry the command; if it persists, inspect the audit log for specifics.',
+                ],
+            };
+        default:
+            return undefined;
+    }
+}
+export function buildFailureGuidance(input) {
+    const dependencyGuidance = buildDependencyGuidance(input);
+    if (dependencyGuidance)
+        return dependencyGuidance;
+    const errorCodeGuidance = buildErrorCodeGuidance(input);
+    if (errorCodeGuidance)
+        return errorCodeGuidance;
+    if (input.reasonCode === 'PREFLIGHT_NOT_GIT') {
+        return {
+            diagnosticCode: 'PREFLIGHT_NOT_GIT',
+            safeHint: 'Run failed because the target directory is not a Git repository.',
+            remediationSteps: [
+                'Run the command from a Git repository root, or initialize one with `git init`.',
+            ],
+        };
+    }
+    if (input.reasonCode === 'PREFLIGHT_DIRTY') {
+        return {
+            diagnosticCode: 'PREFLIGHT_DIRTY',
+            safeHint: 'Run failed because the workspace has local changes that must be handled first.',
+            remediationSteps: ['Commit/stash local changes, or switch to worktree strategy and retry.'],
+        };
+    }
+    if (input.reasonCode === 'APPLY_BACK_FAILED') {
+        return {
+            diagnosticCode: 'APPLY_BACK_FAILED',
+            safeHint: input.fallbackReason,
+            remediationSteps: ['Resolve conflicting local changes, then retry.'],
+        };
+    }
+    return {
+        diagnosticCode: input.reasonCode,
+        safeHint: input.fallbackReason,
+        remediationSteps: [
+            'Check the audit log for phase-level details and retry after fixing the issue.',
+        ],
+    };
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/core/feedback/index.js

@@ -0,0 +1,28 @@
+import { parseGenericOutput } from './parsers.js';
+import { applyPatterns } from './patterns.js';
+export * from './types.js';
+export * from './parsers.js';
+export * from './patterns.js';
+export function generateFeedbackPrompt(diagnostics) {
+    if (diagnostics.length === 0)
+        return '';
+    let prompt = 'Critical Errors found during verification:\n';
+    diagnostics.forEach((d, i) => {
+        const location = d.line ? `${d.file}:${d.line}` : d.file;
+        prompt += `${i + 1}. ${location} - [${d.source}] ${d.message}\n`;
+        const suggestion = d.suggestion || applyPatterns(d.message);
+        if (suggestion) {
+            prompt += `   Suggestion: ${suggestion}\n`;
+        }
+    });
+    return prompt;
+}
+export function refineFeedback(output) {
+    const diagnostics = parseGenericOutput(output);
+    if (diagnostics.length > 0) {
+        return generateFeedbackPrompt(diagnostics);
+    }
+    // Fallback: last 2000 chars
+    return output.length > 2000 ? `...${output.slice(-2000)}` : output;
+}
+//# sourceMappingURL=index.js.map

package/dist/core/feedback/parsers.js

@@ -0,0 +1,59 @@
+export function parseTscOutput(output) {
+    const diagnostics = [];
+    const lines = output.split('\n');
+    // Example: src/app.ts(10,5): error TS2322: Type 'string' is not assignable to type 'number'.
+    const regex = /^(.+)\((\d+),(\d+)\): (error|warning) (TS\d+): (.+)$/;
+    for (const line of lines) {
+        const match = line.trim().match(regex);
+        if (match) {
+            diagnostics.push({
+                file: match[1],
+                line: parseInt(match[2]),
+                column: parseInt(match[3]),
+                severity: match[4],
+                message: `${match[5]}: ${match[6]}`,
+                source: 'tsc',
+            });
+        }
+    }
+    return diagnostics;
+}
+export function parsePythonError(output) {
+    const diagnostics = [];
+    const lines = output.split('\n');
+    // Example: File "app.py", line 10, in <module>
+    const fileRegex = /File "(.+)", line (\d+)/;
+    let currentFile = null;
+    let currentLine = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        const fileMatch = line.match(fileRegex);
+        if (fileMatch) {
+            currentFile = fileMatch[1];
+            currentLine = parseInt(fileMatch[2]);
+        }
+        else if (currentFile && (line.includes('Error:') || line.includes('Exception:'))) {
+            diagnostics.push({
+                file: currentFile,
+                line: currentLine || undefined,
+                severity: 'error',
+                message: line,
+                source: 'python',
+            });
+            currentFile = null;
+            currentLine = null;
+        }
+    }
+    return diagnostics;
+}
+export function parseGenericOutput(output) {
+    // Fallback or combined parser
+    const tsc = parseTscOutput(output);
+    if (tsc.length > 0)
+        return tsc;
+    const py = parsePythonError(output);
+    if (py.length > 0)
+        return py;
+    return [];
+}
+//# sourceMappingURL=parsers.js.map

package/dist/core/feedback/patterns.js

@@ -0,0 +1,26 @@
+export const ERROR_PATTERNS = [
+    {
+        id: 'module-not-found',
+        regex: /Cannot find module '(.+)'/,
+        suggestion: 'Check if the package is installed or if the import path matches the file structure.',
+    },
+    {
+        id: 'react-hook-rule',
+        regex: /React Hook ".*" is called conditionally/,
+        suggestion: 'Move the Hook call to the top level of the component.',
+    },
+    {
+        id: 'ts-type-mismatch',
+        regex: /Type '(.+)' is not assignable to type '(.+)'/,
+        suggestion: 'Ensure the types match or use a type assertion if appropriate.',
+    },
+];
+export function applyPatterns(message) {
+    for (const pattern of ERROR_PATTERNS) {
+        if (pattern.regex.test(message)) {
+            return pattern.suggestion;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=patterns.js.map

package/dist/core/feedback/types.js

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

package/dist/core/grizzco/domain/grizzco-types.js

@@ -0,0 +1,41 @@
+/**
+ * File status enumeration strictly following git status --porcelain=v2 format.
+ *
+ * - CLEAN: No changes
+ * - UNTRACKED: Untracked file (??)
+ * - STAGED_MODIFIED: Modified in index (M.)
+ * - STAGED_ADDED: Added to index (A.)
+ * - STAGED_DELETED: Deleted from index (D.)
+ * - UNSTAGED_MODIFIED: Modified in worktree but not index (.M)
+ * - UNSTAGED_DELETED: Deleted from worktree but not index (.D)
+ * - MM: Modified in both index and worktree (Double Dirty)
+ * - CONFLICT: Merge conflict (UU/AA/DD)
+ */
+export var FileStatus;
+(function (FileStatus) {
+    // Clean state
+    FileStatus["CLEAN"] = "CLEAN";
+    FileStatus["UNTRACKED"] = "UNTRACKED";
+    // Staged states
+    FileStatus["STAGED_MODIFIED"] = "STAGED_MODIFIED";
+    FileStatus["STAGED_ADDED"] = "STAGED_ADDED";
+    FileStatus["STAGED_DELETED"] = "STAGED_DELETED";
+    // Worktree states
+    FileStatus["UNSTAGED_MODIFIED"] = "UNSTAGED_MODIFIED";
+    FileStatus["UNSTAGED_DELETED"] = "UNSTAGED_DELETED";
+    // Double Dirty state
+    FileStatus["MM"] = "MM";
+    // Conflict state
+    FileStatus["CONFLICT"] = "CONFLICT";
+})(FileStatus || (FileStatus = {}));
+/**
+ * Operation semantic types.
+ * Defines whether the content should be treated as a full file or a patch.
+ */
+export var OpType;
+(function (OpType) {
+    OpType["PATCH"] = "PATCH";
+    OpType["OVERWRITE"] = "OVERWRITE";
+    OpType["DELETE"] = "DELETE";
+})(OpType || (OpType = {}));
+//# sourceMappingURL=grizzco-types.js.map

package/dist/core/grizzco/dsl/DecisionEngine.js

@@ -0,0 +1,149 @@
+export class PlanBuilder {
+    plan = {
+        shouldAbort: false,
+        actions: [],
+        decisionTree: [],
+    };
+    _ctx;
+    bindContext(ctx) {
+        this._ctx = ctx;
+        return this;
+    }
+    abort(reason) {
+        this.plan.shouldAbort = true;
+        this.plan.abortReason = reason;
+        return this;
+    }
+    reject(reason) {
+        return this.abort(reason);
+    }
+    setWorker(workerId) {
+        this.plan.workerId = workerId;
+        return this;
+    }
+    hasWorker() {
+        return Boolean(this.plan.workerId);
+    }
+    addAction(type, params) {
+        this.plan.actions.push({ type, params });
+        return this;
+    }
+    build() {
+        return this.plan;
+    }
+    _setDecisionTree(tree) {
+        this.plan.decisionTree = tree;
+    }
+    get ctx() {
+        if (!this._ctx)
+            throw new Error('PlanBuilder: context not bound');
+        return this._ctx;
+    }
+}
+export class DecisionEngine {
+    ctx;
+    planBuilder;
+    history = [];
+    currentPhase = 'initialization';
+    missingDataKeys = new Set();
+    recordCounter = 0;
+    constructor(ctx, planBuilder) {
+        this.ctx = ctx;
+        this.planBuilder = planBuilder;
+        this.planBuilder.bindContext(ctx);
+    }
+    phase(name) {
+        this.currentPhase = name;
+        return this;
+    }
+    /**
+     * Declare data dependency. Supports single key or array of keys.
+     * COMPLIANCE: DSL-Spec-V3 - Explicitly tracks missing keys for the Ping-Pong protocol.
+     */
+    requireData(keyOrKeys, reason) {
+        const keys = Array.isArray(keyOrKeys) ? keyOrKeys : [keyOrKeys];
+        for (const key of keys) {
+            if (!this.ctx.data || this.ctx.data[key] === undefined) {
+                this.missingDataKeys.add(key);
+                this.recordDecision(false, `requireData('${key}')`, { reason });
+            }
+            else {
+                this.recordDecision(true, `requireData('${key}')`, { val: this.ctx.data[key] });
+            }
+        }
+        return this;
+    }
+    require(predicate, msg) {
+        if (this.missingDataKeys.size > 0)
+            return this;
+        const matched = predicate(this.ctx);
+        this.recordDecision(matched, predicate, { type: 'require', msg });
+        if (!matched) {
+            this.planBuilder.abort(msg);
+        }
+        return this;
+    }
+    when(predicate, action) {
+        if (this.missingDataKeys.size > 0)
+            return this;
+        const matched = predicate(this.ctx);
+        this.recordDecision(matched, predicate, { type: 'when' });
+        if (matched) {
+            action(this.planBuilder);
+        }
+        return this;
+    }
+    unless(predicate, action) {
+        return this.when((c) => !predicate(c), action);
+    }
+    setWorker(workerId) {
+        if (this.missingDataKeys.size > 0)
+            return this;
+        if (!this.planBuilder.hasWorker()) {
+            this.planBuilder.setWorker(workerId);
+        }
+        return this;
+    }
+    apply(fragment) {
+        if (this.missingDataKeys.size > 0)
+            return this;
+        fragment(this);
+        return this;
+    }
+    build() {
+        if (this.missingDataKeys.size > 0) {
+            const keys = Array.from(this.missingDataKeys);
+            return {
+                type: 'NEED_DATA',
+                key: keys[0] || 'unknown',
+                keys,
+            };
+        }
+        this.planBuilder._setDecisionTree(this.exportDecisionTree());
+        return {
+            type: 'PLAN',
+            plan: this.planBuilder.build(),
+        };
+    }
+    getStructuredDecisions() {
+        return [...this.history];
+    }
+    recordDecision(matched, predicateOrRule, metadata) {
+        const rule = typeof predicateOrRule === 'string'
+            ? predicateOrRule
+            : predicateOrRule.toString().slice(0, 100);
+        this.history.push({
+            index: this.recordCounter++,
+            phase: this.currentPhase,
+            rule,
+            matched,
+            metadata,
+        });
+    }
+    exportDecisionTree() {
+        return this.history
+            .map((r) => `${r.matched ? '[match]' : '[skip]'} [${r.phase}] ${r.rule}`)
+            .filter(Boolean);
+    }
+}
+//# sourceMappingURL=DecisionEngine.js.map

package/dist/core/grizzco/dsl/MicroTaskRunner.js

@@ -0,0 +1,39 @@
+import { text } from '../../../locales/index.js';
+import { DecisionEngine, PlanBuilder, } from './DecisionEngine.js';
+export class MicroTaskRunner {
+    params;
+    maxRounds;
+    constructor(params) {
+        this.params = params;
+        this.maxRounds = params.maxRounds ?? 10;
+    }
+    async decide(context) {
+        let rounds = 0;
+        let finalEngine;
+        while (true) {
+            if (rounds++ > this.maxRounds) {
+                throw new Error(text.grizzco.microOrchestratorLoopStuck(this.params.debugLabel || 'unknown'));
+            }
+            const planBuilder = new PlanBuilder();
+            const engine = new DecisionEngine(context, planBuilder);
+            finalEngine = engine;
+            this.params.strategy(engine);
+            const result = engine.build();
+            if (result.type === 'PLAN') {
+                return {
+                    plan: result.plan,
+                    decisions: finalEngine.getStructuredDecisions(),
+                    context,
+                };
+            }
+            if (!context.data) {
+                context.data = {};
+            }
+            const requiredKeys = result.keys ?? [result.key];
+            await Promise.all(requiredKeys.map(async (key) => {
+                context.data[key] = await this.params.resolveData(context, key);
+            }));
+        }
+    }
+}
+//# sourceMappingURL=MicroTaskRunner.js.map

package/dist/core/grizzco/dsl/llm-strategy.js

@@ -0,0 +1,80 @@
+import { Phase } from '../../types/runtime.js';
+import { DecisionEngine, PlanBuilder } from './DecisionEngine.js';
+function defaultMaxRoundsForPhase(phase) {
+    // Explore needs more rounds to navigate the codebase
+    if (phase === Phase.EXPLORE)
+        return 8;
+    if (phase === Phase.RESEARCH)
+        return 8;
+    if (phase === Phase.PLAN)
+        return 4;
+    if (phase === Phase.PATCH)
+        return 4;
+    return 4;
+}
+export function resolveLlmToolCallingPolicy(phase, llm) {
+    const caps = llm.getCapabilities?.();
+    const maxRounds = defaultMaxRoundsForPhase(phase);
+    // Grizzco DSL engine is transaction-shaped; for LLM policies we inject a minimal context and keep all
+    // decisions inside ctx.data to avoid coupling to file/operation semantics.
+    const ctx = {
+        repoRoot: '',
+        file: {
+            path: '',
+            status: 0,
+            isBinary: false,
+            isSymlink: false,
+            isIgnored: false,
+            hasConflict: false,
+            size: 0,
+        },
+        operation: {
+            type: 0,
+            path: '',
+        },
+        options: {
+            force: false,
+            allowMM: false,
+            safeMode: true,
+            rejectDir: '',
+            dryRun: true,
+            maxFileSize: 0,
+        },
+        snapshot: {
+            exists: true,
+            id: 'llm-policy',
+            timestamp: 0,
+            path: '',
+        },
+        runtime: {
+            needsRollback: false,
+        },
+        data: {
+            llm_tool_calling_capable: Boolean(caps?.toolCalling),
+            llm_tool_calling_max_rounds: maxRounds,
+            phase,
+        },
+    };
+    const planBuilder = new PlanBuilder();
+    const engine = new DecisionEngine(ctx, planBuilder);
+    const result = engine
+        .phase('LLM Tool Calling Policy')
+        .requireData('llm_tool_calling_capable')
+        .requireData('llm_tool_calling_max_rounds')
+        .when((c) => Boolean(c.data?.llm_tool_calling_capable), (p) => p.addAction('SET_TOOL_CALLING_POLICY', {
+        enabled: true,
+        maxRounds,
+    }))
+        .unless((c) => Boolean(c.data?.llm_tool_calling_capable), (p) => p.addAction('SET_TOOL_CALLING_POLICY', {
+        enabled: false,
+        maxRounds,
+    }))
+        .build();
+    if (result.type !== 'PLAN') {
+        return { enabled: false, maxRounds };
+    }
+    const actions = result.plan.actions;
+    const lastPolicy = [...actions].reverse().find((a) => a.type === 'SET_TOOL_CALLING_POLICY');
+    return lastPolicy?.params || { enabled: false, maxRounds };
+}
+//# sourceMappingURL=llm-strategy.js.map