salmon-loop 0.2.3

package/dist/core/grizzco/steps/display-report.js

@@ -0,0 +1,158 @@
+import { text } from '../../../locales/index.js';
+import { SalmonError } from '../../types/errors.js';
+export class ReportContextMissingError extends SalmonError {
+    constructor(message) {
+        super(message, 'REPORT_CONTEXT_MISSING');
+    }
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function removeLeadingSpaces(content) {
+    const lines = content.split('\n');
+    const minIndent = lines
+        .filter((line) => line.trim().length > 0)
+        .reduce((min, line) => {
+        const match = line.match(/^(\s*)/);
+        const indent = match ? match[1].length : 0;
+        return Math.min(min, indent);
+    }, Infinity);
+    if (minIndent > 0 && minIndent !== Infinity) {
+        return lines.map((line) => line.substring(minIndent)).join('\n');
+    }
+    return content;
+}
+function isReviewSuggestion(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeSuggestions(input) {
+    if (!input)
+        return [];
+    if (Array.isArray(input)) {
+        return input.map((item) => {
+            if (typeof item === 'string') {
+                return { type: 'note', content: item };
+            }
+            if (isReviewSuggestion(item)) {
+                const type = typeof item.type === 'string' ? item.type : 'note';
+                const content = typeof item.content === 'string' ? item.content : safeStringify(item);
+                return { type, content };
+            }
+            return { type: 'note', content: String(item) };
+        });
+    }
+    if (typeof input === 'string') {
+        return [{ type: 'note', content: input }];
+    }
+    if (isReviewSuggestion(input)) {
+        const type = typeof input.type === 'string' ? input.type : 'note';
+        const content = typeof input.content === 'string' ? input.content : safeStringify(input);
+        return [{ type, content }];
+    }
+    return [{ type: 'note', content: safeStringify(input) }];
+}
+export async function displayReport(ctx) {
+    if (!ctx.report || !ctx.report.kind) {
+        throw new ReportContextMissingError('Report context missing: expected report.kind to be set before REPORT step.');
+    }
+    const outputKinds = ctx.options?.llmOutput?.kinds ?? [];
+    if (outputKinds.includes(ctx.report.kind) ||
+        (ctx.report.kind === 'answer' && outputKinds.includes('assistant_message'))) {
+        return ctx;
+    }
+    if (ctx.report.kind === 'research') {
+        ctx.emit({
+            type: 'log',
+            level: 'info',
+            message: text.grizzco.research.header,
+            timestamp: new Date(),
+        });
+        const findings = ctx.report.findings ?? [];
+        if (findings.length === 0) {
+            const summary = ctx.report.summary?.trim();
+            if (!summary) {
+                ctx.emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.grizzco.research.empty,
+                    timestamp: new Date(),
+                });
+                return ctx;
+            }
+            ctx.emit({
+                type: 'log',
+                level: 'info',
+                message: text.grizzco.research.summary(summary),
+                timestamp: new Date(),
+            });
+            return ctx;
+        }
+        findings.forEach((finding, index) => {
+            const summary = removeLeadingSpaces(finding.summary || '');
+            ctx.emit({
+                type: 'log',
+                level: 'info',
+                message: text.grizzco.research.findingItem(index + 1, summary, finding.confidence, finding.uncertainty),
+                timestamp: new Date(),
+            });
+        });
+        return ctx;
+    }
+    if (ctx.report.kind === 'answer') {
+        ctx.emit({
+            type: 'log',
+            level: 'info',
+            message: text.grizzco.answer.header,
+            timestamp: new Date(),
+        });
+        const summary = ctx.report.summary?.trim();
+        if (!summary) {
+            ctx.emit({
+                type: 'log',
+                level: 'info',
+                message: text.grizzco.answer.empty,
+                timestamp: new Date(),
+            });
+            return ctx;
+        }
+        ctx.emit({
+            type: 'log',
+            level: 'info',
+            message: summary,
+            timestamp: new Date(),
+        });
+        return ctx;
+    }
+    ctx.emit({
+        type: 'log',
+        level: 'info',
+        message: text.grizzco.review.header,
+        timestamp: new Date(),
+    });
+    const suggestions = normalizeSuggestions(ctx.report.suggestions ?? null);
+    if (suggestions.length === 0) {
+        ctx.emit({
+            type: 'log',
+            level: 'info',
+            message: text.grizzco.review.empty,
+            timestamp: new Date(),
+        });
+        return ctx;
+    }
+    suggestions.forEach((suggestion, index) => {
+        const cleanContent = removeLeadingSpaces(suggestion.content);
+        ctx.emit({
+            type: 'log',
+            level: 'info',
+            message: text.grizzco.review.suggestionItem(index + 1, suggestion.type, cleanContent),
+            timestamp: new Date(),
+        });
+    });
+    return ctx;
+}
+//# sourceMappingURL=display-report.js.map

package/dist/core/grizzco/steps/display-research.js

@@ -0,0 +1,6 @@
+import { displayReport } from './display-report.js';
+export async function displayResearch(ctx) {
+    await displayReport(ctx);
+    return ctx;
+}
+//# sourceMappingURL=display-research.js.map

package/dist/core/grizzco/steps/displayReview.js

@@ -0,0 +1,6 @@
+import { displayReport } from './display-report.js';
+export async function displayReview(ctx) {
+    await displayReport(ctx);
+    return ctx;
+}
+//# sourceMappingURL=displayReview.js.map

package/dist/core/grizzco/steps/explore.js

@@ -0,0 +1,245 @@
+import path from 'path';
+import { text } from '../../../locales/index.js';
+import { composeChatMessages } from '../../llm/message-composition.js';
+import { formatContextForPrompt } from '../../llm/utils.js';
+import { getExplorePrompt, getExploreSystemPrompt } from '../../prompts/runtime.js';
+import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
+import { SalmonError } from '../../types/errors.js';
+import { Phase } from '../../types/runtime.js';
+import { ensureInSandbox, isSafeRelativePath, normalizePath } from '../../utils/path.js';
+import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
+import { ContextValidator } from '../validation/ContextValidator.js';
+const SAFE_INFERRED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.json',
+    '.md',
+    '.txt',
+    '.css',
+    '.html',
+    '.vue',
+    '.py',
+    '.rs',
+    '.go',
+    '.java',
+    '.c',
+    '.cpp',
+    '.h',
+]);
+function inferHighConfidenceFiles(instruction) {
+    const candidates = [];
+    const normalized = instruction || '';
+    if (/README\b/i.test(normalized)) {
+        candidates.push('README.md');
+    }
+    const pathLike = /(?:^|\s)([a-zA-Z0-9][a-zA-Z0-9._/-]*\.[a-zA-Z0-9]{1,8})(?:\s|$)/g;
+    let match = null;
+    while ((match = pathLike.exec(normalized)) !== null) {
+        const raw = match[1];
+        if (!raw)
+            continue;
+        const rel = normalizePath(raw).replace(/^(\.\/|\/)+/, '');
+        if (!rel)
+            continue;
+        if (!isSafeRelativePath(rel))
+            continue;
+        const lower = rel.toLowerCase();
+        if (lower.startsWith('.'))
+            continue;
+        if (lower.includes('/.'))
+            continue;
+        if (lower.startsWith('.git/') || lower.startsWith('.salmonloop/'))
+            continue;
+        if (lower.includes('node_modules/'))
+            continue;
+        const ext = path.extname(rel).toLowerCase();
+        if (!SAFE_INFERRED_EXTENSIONS.has(ext))
+            continue;
+        candidates.push(rel);
+        if (candidates.length >= 3)
+            break;
+    }
+    return Array.from(new Set(candidates));
+}
+export const exploreCodebase = async (ctx) => {
+    const toolstack = ctx.toolstack;
+    const toolPolicy = resolveLlmToolCallingPolicy(Phase.EXPLORE, ctx.options.llm);
+    // If tools are not available or disabled, skip exploration
+    if (!toolstack || !toolPolicy.enabled) {
+        ctx.emit({
+            type: 'log',
+            level: 'debug',
+            message: text.grizzco.validation.explorationSkipped,
+            timestamp: new Date(),
+        });
+        return { ...ctx };
+    }
+    const prompt = await getExplorePrompt(formatContextForPrompt(ctx.context), ctx.options.instruction, ctx.lastError);
+    const systemPrompt = await getExploreSystemPrompt(toolstack.registry, { plan: ctx.planRuntime });
+    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const llmOutput = {
+        policy: ctx.options.llmOutput,
+        kind: 'explore',
+        step: 'EXPLORE',
+    };
+    // We need to capture files read during exploration to pass them to the Plan phase.
+    // We use the tool intent metadata to identify read operations.
+    const capturedFiles = new Map();
+    const proxiedRouter = new Proxy(toolstack.router, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+            if (prop === 'call' && typeof value === 'function') {
+                return async (envelope) => {
+                    const result = await value.apply(target, [envelope]);
+                    if (!result || typeof result !== 'object')
+                        return result;
+                    // Find the corresponding spec to check intent
+                    const spec = toolstack.registry.listAll().find((s) => s.name === result.toolName);
+                    const intent = spec?.intent;
+                    // Intercept tools with READ intent
+                    if (intent === 'READ' && result.status === 'ok') {
+                        const output = result.output;
+                        const content = typeof output === 'string' ? output : output?.content;
+                        if (typeof content === 'string') {
+                            try {
+                                // Attempt to parse arguments to get the file path
+                                // Support multiple common parameter names: file, file_path, filePath, path
+                                const args = envelope.args || envelope.input;
+                                const filePath = args?.file || args?.file_path || args?.filePath || args?.path;
+                                if (typeof filePath === 'string') {
+                                    capturedFiles.set(filePath, content);
+                                }
+                            }
+                            catch {
+                                // Ignore parsing errors, just don't capture
+                            }
+                        }
+                    }
+                    return result;
+                };
+            }
+            return value;
+        },
+    });
+    const proxiedToolstack = {
+        ...toolstack,
+        router: proxiedRouter,
+    };
+    const localAudit = [];
+    const baseMessages = composeChatMessages({
+        system: systemPrompt,
+        user: prompt,
+        conversationContext: ctx.options.conversationContext,
+    });
+    await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, {
+        signal: ctx.options.signal,
+    }, {
+        phase: Phase.EXPLORE,
+        llm: ctx.options.llm,
+        runtime: {
+            repoRoot: ctx.workspace.workPath,
+            persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            attemptId: ctx.attempt ?? 1,
+            dryRun: Boolean(ctx.options?.dryRun),
+            llm: ctx.options.llm,
+            model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
+            userInputProvider: ctx.options.userInputProvider,
+            agentKind: ctx.options.agentKind ?? 'primary',
+            languagePlugins: ctx.options.languagePlugins,
+            subAgentController: ctx.options.subAgentController,
+        },
+        toolstack: proxiedToolstack,
+        eventPayload: ctx.options.eventPayload,
+        toolCallingAudit: {
+            event: (entry) => {
+                localAudit.push(entry);
+                const list = ctx.toolCallingAudit ?? [];
+                list.push(entry);
+                ctx.toolCallingAudit = list;
+            },
+        },
+        maxRounds: toolPolicy.maxRounds,
+        llmOutput,
+        emit: (event) => ctx.emit({ ...event, timestamp: event.timestamp ?? new Date() }),
+    });
+    if (capturedFiles.size === 0 && !ctx.context.primaryText) {
+        const inferred = inferHighConfidenceFiles(ctx.options.instruction);
+        for (const rel of inferred) {
+            try {
+                const fullPath = ensureInSandbox(ctx.workspace.workPath, path.join(ctx.workspace.workPath, rel));
+                const content = await ctx.fs.readFile(fullPath, 'utf-8');
+                if (typeof content === 'string' && content.trim()) {
+                    capturedFiles.set(rel, content);
+                }
+            }
+            catch {
+                // Best-effort; failure here should not abort exploration.
+            }
+        }
+    }
+    // Validation: Check for exploration consistency using ContextValidator on LOCAL audit
+    const validation = ContextValidator.validateExploration(localAudit, capturedFiles.size);
+    if (!validation.isValid) {
+        const msg = text.grizzco.validation[validation.errorCode] || validation.errorCode;
+        ctx.emit({
+            type: 'log',
+            level: 'error',
+            message: msg,
+            timestamp: new Date(),
+        });
+        throw new SalmonError(msg, validation.errorCode);
+    }
+    // Update context with captured files
+    const updatedContext = { ...ctx.context };
+    const newRelatedFiles = updatedContext.relatedFiles
+        ? [...updatedContext.relatedFiles]
+        : [];
+    // Track existing files to update them or add new ones
+    const fileMap = new Map();
+    newRelatedFiles.forEach((f) => fileMap.set(f.path, f));
+    for (const [path, content] of capturedFiles) {
+        if (path === updatedContext.primaryFile)
+            continue;
+        if (fileMap.has(path)) {
+            // Update content for existing file
+            const existing = fileMap.get(path);
+            existing.content = content;
+            existing.mode = 'full';
+        }
+        else {
+            // Add as new dependency
+            newRelatedFiles.push({
+                path,
+                content,
+                kind: 'dependency',
+                mode: 'full',
+            });
+        }
+    }
+    updatedContext.relatedFiles = newRelatedFiles;
+    // Report the end of the explore phase
+    ctx.emit({
+        type: 'phase.end',
+        phase: Phase.EXPLORE,
+        success: true,
+        timestamp: new Date(),
+    });
+    ctx.emit({
+        type: 'log',
+        level: 'info',
+        message: text.grizzco.validation.explorationFinished(capturedFiles.size),
+        timestamp: new Date(),
+    });
+    return {
+        ...ctx,
+        context: updatedContext,
+        explorationSummary: {
+            filesFound: capturedFiles.size,
+            toolCallCount: localAudit.length,
+        },
+    };
+};
+//# sourceMappingURL=explore.js.map

package/dist/core/grizzco/steps/extractIssues.js

@@ -0,0 +1,27 @@
+import { text } from '../../../locales/index.js';
+function isReviewSuggestion(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function collectIssues(suggestions) {
+    if (!Array.isArray(suggestions))
+        return [];
+    return suggestions.filter((item) => {
+        if (!isReviewSuggestion(item))
+            return false;
+        const type = typeof item.type === 'string' ? item.type.toLowerCase() : '';
+        return type === 'bug' || type === 'security' || type === 'vulnerability';
+    });
+}
+export async function extractIssues(ctx) {
+    const issues = collectIssues(ctx.review?.suggestions);
+    if (issues.length > 0) {
+        ctx.emit({
+            type: 'log',
+            level: 'info',
+            message: text.grizzco.review.issuesExtracted(issues.length),
+            timestamp: new Date(),
+        });
+    }
+    return ctx;
+}
+//# sourceMappingURL=extractIssues.js.map

package/dist/core/grizzco/steps/generateFixPlan.js

@@ -0,0 +1,13 @@
+import { text } from '../../../locales/index.js';
+import { generatePlan } from './plan.js';
+export async function generateFixPlan(ctx) {
+    const planCtx = await generatePlan(ctx);
+    ctx.emit({
+        type: 'log',
+        level: 'info',
+        message: text.grizzco.review.fixPlanGenerated,
+        timestamp: new Date(),
+    });
+    return planCtx;
+}
+//# sourceMappingURL=generateFixPlan.js.map

package/dist/core/grizzco/steps/generateReview.js

@@ -0,0 +1,71 @@
+import { text } from '../../../locales/index.js';
+import { emitLlmOutput } from '../../llm/output-policy.js';
+function buildReviewPrompt(context) {
+    const summary = JSON.stringify(context, null, 2);
+    return `Please review the following context and provide suggestions for improvement:\n\n${summary}`;
+}
+function normalizeReviewSuggestions(value) {
+    if (value == null)
+        return null;
+    if (Array.isArray(value)) {
+        return value.map((item) => {
+            if (typeof item === 'string')
+                return item;
+            if (item && typeof item === 'object')
+                return item;
+            return String(item);
+        });
+    }
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object')
+        return value;
+    return String(value);
+}
+function parseReviewResponse(content) {
+    try {
+        return normalizeReviewSuggestions(JSON.parse(content));
+    }
+    catch {
+        return normalizeReviewSuggestions(content);
+    }
+}
+export async function generateReview(ctx) {
+    const reviewPrompt = buildReviewPrompt(ctx.context);
+    const llmClient = ctx.options.llm;
+    const response = await llmClient.chat([{ role: 'user', content: reviewPrompt }], {
+        tools: [],
+        signal: ctx.options.signal,
+    });
+    if (!response?.content) {
+        throw new Error(text.llm.reviewEmpty);
+    }
+    emitLlmOutput({
+        emit: ctx.emit,
+        policy: ctx.options.llmOutput,
+        kind: 'review',
+        step: 'REVIEW',
+        content: response.content,
+    });
+    ctx.emit({
+        type: 'log',
+        level: 'info',
+        message: text.grizzco.review.generated,
+        timestamp: new Date(),
+    });
+    const suggestions = parseReviewResponse(response.content);
+    const timestamp = Date.now();
+    return {
+        ...ctx,
+        review: {
+            suggestions,
+            timestamp,
+        },
+        report: {
+            kind: 'review',
+            suggestions,
+            timestamp,
+        },
+    };
+}
+//# sourceMappingURL=generateReview.js.map