salmon-loop 0.2.3

package/dist/core/patch/diff.js

@@ -0,0 +1,298 @@
+import { normalize as pathNormalize, extname } from 'path';
+import { text } from '../../locales/index.js';
+import { LIMITS } from '../config/limits.js';
+import { OpType } from '../grizzco/domain/grizzco-types.js';
+import { DiffValidationError } from '../types/index.js';
+/**
+ * Normalizes a raw diff string by trimming and unwrapping markdown code blocks.
+ */
+const isAbsolutePathLike = (value) => {
+    const normalized = value.replace(/\\/g, '/');
+    return normalized.startsWith('/') || /^[a-zA-Z]:/.test(normalized);
+};
+const cleanPath = (path) => {
+    if (path === '/dev/null' || path === 'dev/null')
+        return path;
+    const rawNormalized = pathNormalize(path).replace(/\\/g, '/');
+    const rawSegments = rawNormalized.split('/');
+    if (rawSegments.some((seg) => seg === '..') || isAbsolutePathLike(rawNormalized)) {
+        throw new DiffValidationError(`Path traversal detected: ${path}`);
+    }
+    const isAbsolute = isAbsolutePathLike(path);
+    let normalized = path.replace(/\\/g, '/').replace(/\/+/g, '/');
+    normalized = normalized.replace(/^[a-zA-Z]:\//, '');
+    if (normalized.startsWith('/'))
+        normalized = normalized.substring(1);
+    normalized = normalized.replace(/^\.\/+/, '');
+    if (!isAbsolute) {
+        const parts = normalized.split('/');
+        if (parts.length > 1) {
+            const repoStripAllowList = new Set([
+                'src',
+                'lib',
+                'app',
+                'tests',
+                'test',
+                'packages',
+                'include',
+                'bin',
+                'docs',
+                'components',
+                'utils',
+                'core',
+            ]);
+            const repoStripFileExtAllowList = new Set([
+                '.js',
+                '.ts',
+                '.jsx',
+                '.tsx',
+                '.json',
+                '.md',
+                '.txt',
+                '.css',
+                '.html',
+                '.vue',
+                '.py',
+                '.rs',
+                '.go',
+                '.java',
+                '.c',
+                '.cpp',
+                '.h',
+            ]);
+            const firstDir = parts[0]?.toLowerCase();
+            const secondDir = parts[1]?.toLowerCase();
+            const secondExt = secondDir ? extname(secondDir) : '';
+            const firstIsCommonDir = firstDir ? repoStripAllowList.has(firstDir) : false;
+            const secondIsAllowedDir = secondDir ? repoStripAllowList.has(secondDir) : false;
+            const secondIsAllowedFile = secondExt ? repoStripFileExtAllowList.has(secondExt) : false;
+            const firstLooksLikeRepo = !!firstDir &&
+                /^[a-z0-9][a-z0-9._-]*$/i.test(firstDir) &&
+                firstDir !== '.' &&
+                firstDir !== '..';
+            if (!firstIsCommonDir && firstLooksLikeRepo && (secondIsAllowedDir || secondIsAllowedFile)) {
+                normalized = parts.slice(1).join('/');
+            }
+        }
+    }
+    const finalNormalized = pathNormalize(normalized).replace(/\\/g, '/');
+    if (finalSegments_check(finalNormalized)) {
+        throw new DiffValidationError(`Path traversal detected after normalization: ${path}`);
+    }
+    return finalNormalized;
+};
+function finalSegments_check(path) {
+    const finalSegments = path.split('/');
+    return finalSegments.some((seg) => seg === '..') || isAbsolutePathLike(path);
+}
+function dedentUnifiedDiff(content) {
+    const lines = content.split('\n');
+    const candidates = [];
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        const trimmed = line.trimStart();
+        // Only consider lines that are expected to be left-aligned in unified diffs.
+        // Avoid context lines that *legitimately* start with a single space.
+        const isDiffLike = trimmed.startsWith('diff --git ') ||
+            trimmed.startsWith('index ') ||
+            trimmed.startsWith('--- ') ||
+            trimmed.startsWith('+++ ') ||
+            trimmed.startsWith('@@ ') ||
+            trimmed.startsWith('new file mode ') ||
+            trimmed.startsWith('deleted file mode ') ||
+            trimmed.startsWith('similarity index ') ||
+            trimmed.startsWith('rename from ') ||
+            trimmed.startsWith('rename to ') ||
+            trimmed.startsWith('old mode ') ||
+            trimmed.startsWith('new mode ') ||
+            trimmed.startsWith('Binary files ') ||
+            trimmed.startsWith('GIT binary patch') ||
+            trimmed.startsWith('\');
+        if (!isDiffLike)
+            continue;
+        const indentMatch = line.match(/^\s+/);
+        if (!indentMatch)
+            continue;
+        candidates.push(indentMatch[0].length);
+    }
+    const minIndent = candidates.length > 0 ? Math.min(...candidates) : 0;
+    if (minIndent <= 0)
+        return content;
+    return lines
+        .map((line) => {
+        if (!line)
+            return line;
+        const indent = line.match(/^\s+/)?.[0]?.length ?? 0;
+        if (indent < minIndent)
+            return line;
+        return line.slice(minIndent);
+    })
+        .join('\n');
+}
+export function normalizeDiff(raw) {
+    const t = raw.trim();
+    let content = t;
+    const match = t.match(/```(?:diff)?\s*\n([\s\S]*?)\n```/i) || t.match(/(diff --git [\s\S]*)$/i);
+    if (match)
+        content = match[1] || match[0];
+    content = dedentUnifiedDiff(content);
+    const diffStart = content.search(/^(diff --git |--- a\/)/m);
+    if (diffStart !== -1)
+        content = content.substring(diffStart);
+    return (content
+        .replace(/^diff --git a\/(.+?) b\/(.+)$/gm, (_, p1, p2) => `diff --git a/${cleanPath(p1)} b/${cleanPath(p2)}`)
+        .replace(/^--- a\/(.+)$/gm, (_, p1) => `--- a/${cleanPath(p1)}`)
+        .replace(/^\+\+\+ b\/(.+)$/gm, (_, p1) => `+++ b/${cleanPath(p1)}`)
+        .trimEnd() + '\n');
+}
+export function isUnifiedDiff(text) {
+    const d = normalizeDiff(text);
+    return d.startsWith('diff --git ') || d.startsWith('--- a/');
+}
+export function validateDiff(rawDiff, limits = LIMITS) {
+    const diff = normalizeDiff(rawDiff);
+    if (!diff.startsWith('diff --git ') && !diff.startsWith('--- a/')) {
+        throw new DiffValidationError(text.diff.notUnifiedFormat);
+    }
+    const changedFiles = new Set();
+    let lineCount = 0;
+    let pos = 0;
+    let nextPos = 0;
+    const processLine = (line) => {
+        if (!line)
+            return;
+        if (line.startsWith('diff --git ')) {
+            const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+            if (match) {
+                const aPath = match[1].replace(/\\/g, '/');
+                const bPath = match[2].replace(/\\/g, '/');
+                if (aPath !== bPath && aPath !== 'dev/null' && bPath !== 'dev/null')
+                    throw new DiffValidationError(text.diff.fileRenameNotAllowed(aPath, bPath));
+                changedFiles.add(bPath);
+            }
+        }
+        else if (line.startsWith('--- a/')) {
+            const match = line.match(/^--- a\/(.+)$/);
+            if (match)
+                changedFiles.add(cleanPath(match[1]));
+        }
+        else if (line.startsWith('rename from ') || line.startsWith('rename to ')) {
+            throw new DiffValidationError(text.diff.fileRenameNotAllowed());
+        }
+        else if ((line.startsWith('+') || line.startsWith('-')) &&
+            !line.startsWith('+++') &&
+            !line.startsWith('---') &&
+            !line.includes('\')) {
+            lineCount++;
+        }
+    };
+    while ((nextPos = diff.indexOf('\n', pos)) !== -1) {
+        processLine(diff.substring(pos, nextPos));
+        pos = nextPos + 1;
+    }
+    processLine(diff.substring(pos));
+    const fileList = Array.from(changedFiles);
+    if (fileList.length === 0)
+        throw new DiffValidationError(text.llm.patchEmpty('File count is 0'));
+    if (fileList.length > limits.maxFilesChanged)
+        throw new DiffValidationError(text.diff.tooManyFiles(fileList.length, limits.maxFilesChanged, fileList));
+    if (lineCount === 0 && !diff.includes('GIT binary patch') && !diff.includes('Binary files '))
+        throw new DiffValidationError(text.llm.patchEmpty('Line count is 0'));
+    if (lineCount > limits.maxDiffLines)
+        throw new DiffValidationError(text.diff.tooManyLines(lineCount, limits.maxDiffLines));
+    return { changedFiles: fileList, fileCount: fileList.length, lineCount };
+}
+/**
+ * Converts a git unified diff into shadow operations.
+ *
+ * 🛡️ CRITICAL ARCHITECTURAL NOTE:
+ * We DO NOT reconstruct full file content from hunks here. Reconstructing content
+ * from a partial diff leads to data loss (the "File Smash" bug).
+ * Instead, we treat the patch as an atomic instruction (OpType.PATCH) and store
+ * the RAW diff text. The actual merge logic is delegated to the native git-apply engine.
+ */
+export async function convertDiffToShadowOperations(diff) {
+    const normalized = normalizeDiff(diff);
+    const operations = [];
+    if (normalized.includes('diff --git ')) {
+        const files = normalized.split('diff --git ');
+        for (const filePart of files) {
+            if (!filePart.trim())
+                continue;
+            // Restore the header for easier parsing
+            const fullPart = 'diff --git ' + filePart;
+            const lines = fullPart.split('\n');
+            const header = lines[0];
+            const match = header.match(/^diff --git a\/(.+?) b\/(.+)$/);
+            if (!match)
+                continue;
+            const path = match[2];
+            const isBinary = fullPart.includes('Binary files') || fullPart.includes('GIT binary patch');
+            let type = OpType.PATCH;
+            if (fullPart.includes('new file mode'))
+                type = OpType.OVERWRITE;
+            if (fullPart.includes('deleted file mode'))
+                type = OpType.DELETE;
+            operations.push({
+                type,
+                path,
+                content: Buffer.from(fullPart, 'utf8'), // Store the actual patch text or full content
+                isBinary,
+                encoding: 'utf8',
+                lineEnding: 'auto',
+            });
+        }
+        return operations;
+    }
+    // Some unified diffs omit the `diff --git` line and start directly with `--- a/...` + `+++ b/...`.
+    // The validator allows this, so the conversion layer must support it; otherwise APPLY becomes 0/0.
+    const lines = normalized.split('\n');
+    let startLineIdx = null;
+    let aPath = null;
+    let bPath = null;
+    const flush = (endExclusive) => {
+        if (startLineIdx === null || !aPath || !bPath)
+            return;
+        const blockLines = lines.slice(startLineIdx, endExclusive);
+        const body = blockLines.join('\n').trimEnd() + '\n';
+        // Add a synthetic `diff --git` header to make downstream parsing and auditing consistent.
+        const fullPart = `diff --git a/${aPath} b/${bPath}\n${body}`;
+        const isBinary = fullPart.includes('Binary files') || fullPart.includes('GIT binary patch');
+        let type = OpType.PATCH;
+        if (fullPart.includes('new file mode'))
+            type = OpType.OVERWRITE;
+        if (fullPart.includes('deleted file mode'))
+            type = OpType.DELETE;
+        operations.push({
+            type,
+            path: bPath,
+            content: Buffer.from(fullPart, 'utf8'),
+            isBinary,
+            encoding: 'utf8',
+            lineEnding: 'auto',
+        });
+        startLineIdx = null;
+        aPath = null;
+        bPath = null;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const aMatch = line.match(/^--- a\/(.+)\s*$/);
+        if (aMatch) {
+            // Start a new block; if a previous block is open, flush it.
+            flush(i);
+            startLineIdx = i;
+            aPath = cleanPath(aMatch[1]);
+            continue;
+        }
+        const bMatch = line.match(/^\+\+\+ b\/(.+)\s*$/);
+        if (bMatch) {
+            bPath = cleanPath(bMatch[1]);
+            continue;
+        }
+    }
+    flush(lines.length);
+    return operations;
+}
+//# sourceMappingURL=diff.js.map

package/dist/core/permission-gate/default-gate.js

@@ -0,0 +1,115 @@
+import { createHash } from 'crypto';
+class DefaultPermissionGate {
+    options;
+    approvedOutsideRootResources = new Set();
+    pendingRequests = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async requestAuthorization(request) {
+        if (request.action === 'context.cache.outside_root' &&
+            this.approvedOutsideRootResources.has(request.resource)) {
+            return { kind: 'allow', source: 'cache', reason: 'authorized_once' };
+        }
+        if (request.action === 'context.cache.outside_root' &&
+            this.options.allowOutsideCacheRoot === true) {
+            return { kind: 'allow', source: 'cli', reason: 'allow-outside-cache-root' };
+        }
+        if (request.action === 'context.cache.outside_root' && this.options.authorizationProvider) {
+            const toolRequest = this.toToolAuthorizationRequest(request);
+            const decision = await this.options.authorizationProvider.requestAuthorization(toolRequest);
+            return this.mapAuthorizationDecision(decision);
+        }
+        return {
+            kind: 'deny',
+            source: 'policy',
+            reason: `Permission denied for action ${request.action}`,
+        };
+    }
+    async requestAuthorizationDeferred(request) {
+        if (request.action === 'context.cache.outside_root' &&
+            this.approvedOutsideRootResources.has(request.resource)) {
+            return {
+                kind: 'decision',
+                decision: { kind: 'allow', source: 'cache', reason: 'authorized_once' },
+            };
+        }
+        if (request.action === 'context.cache.outside_root' &&
+            this.options.allowOutsideCacheRoot === true) {
+            return {
+                kind: 'decision',
+                decision: { kind: 'allow', source: 'cli', reason: 'allow-outside-cache-root' },
+            };
+        }
+        if (request.action === 'context.cache.outside_root' &&
+            this.options.authorizationProvider?.requestAuthorizationDeferred) {
+            const toolRequest = this.toToolAuthorizationRequest(request);
+            const deferred = await this.options.authorizationProvider.requestAuthorizationDeferred(toolRequest);
+            if (deferred.kind === 'pending') {
+                this.pendingRequests.set(toolRequest.id, request);
+                return { ...deferred, requestId: toolRequest.id };
+            }
+            return {
+                kind: 'decision',
+                decision: this.mapAuthorizationDecision(deferred.decision),
+            };
+        }
+        const decision = await this.requestAuthorization(request);
+        return { kind: 'decision', decision };
+    }
+    async waitForAuthorization(requestId, signal) {
+        const provider = this.options.authorizationProvider;
+        if (!provider?.waitForAuthorization)
+            return null;
+        const decision = await provider.waitForAuthorization(requestId, signal);
+        if (!decision)
+            return null;
+        const mapped = this.mapAuthorizationDecision(decision);
+        const pending = this.pendingRequests.get(requestId);
+        if (pending?.action === 'context.cache.outside_root' &&
+            mapped.kind === 'allow' &&
+            pending.resource) {
+            this.approvedOutsideRootResources.add(pending.resource);
+        }
+        this.pendingRequests.delete(requestId);
+        return mapped;
+    }
+    toToolAuthorizationRequest(request) {
+        const raw = `${request.action}|${request.resource}|${Date.now()}`;
+        const id = createHash('sha256').update(raw, 'utf8').digest('hex');
+        return {
+            id,
+            toolName: request.action,
+            source: 'builtin',
+            phase: 'CONTEXT',
+            riskLevel: request.risk === 'critical' ? 'high' : request.risk,
+            sideEffects: ['fs_write'],
+            argsSummary: request.resource,
+            repoRoot: this.options.repoRoot ?? '',
+            worktreeRoot: this.options.worktreeRoot,
+            attemptId: this.options.attemptId ?? 1,
+            model: this.options.model,
+            timestamp: Date.now(),
+        };
+    }
+    mapAuthorizationDecision(decision) {
+        if (decision.outcome === 'deny') {
+            return {
+                kind: 'deny',
+                reason: decision.reason ?? 'denied',
+                source: decision.source === 'auto' || decision.source === 'allowlist'
+                    ? 'policy'
+                    : decision.source,
+            };
+        }
+        return {
+            kind: 'allow',
+            reason: decision.reason,
+            source: decision.source === 'auto' || decision.source === 'allowlist' ? 'policy' : decision.source,
+        };
+    }
+}
+export function createDefaultPermissionGate(options) {
+    return new DefaultPermissionGate(options);
+}
+//# sourceMappingURL=default-gate.js.map

package/dist/core/permission-gate/gate.js

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

package/dist/core/permission-gate/types.js

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

package/dist/core/plan/index.js

@@ -0,0 +1,2 @@
+export { appendPlanNote, initPlan, readPlan, updatePlan } from './manager.js';
+//# sourceMappingURL=index.js.map

package/dist/core/plan/manager.js

@@ -0,0 +1,123 @@
+import { randomBytes } from 'crypto';
+import { applyPlanUpdate, appendPlanConflictOnly, appendPlanNoteOnly, summarizePlan, } from './markdown-editor.js';
+import { ensureSalmonloopIgnored, readPlanFile, resolvePlanFilePath, sha256, writePlanFileAtomic, } from './storage.js';
+const DEFAULT_TEMPLATE = `# 🦑 Mission: {mission}
+
+> **Objective:** {objective}
+
+## 📍 Context & Strategy
+{context}
+
+## 🗺️ Battle Plan (Execution)
+- [ ] Work Items <!-- sl:id=work_root sl:status=active -->
+
+## 📝 Field Notes (Reflections)
+- (empty)
+
+## ⚠️ Conflicts (Auto-generated)
+- (empty)
+`;
+const writeLocks = new Map();
+async function withPlanWriteLock(planFile, fn) {
+    const previous = writeLocks.get(planFile) ?? Promise.resolve();
+    const next = previous.then(fn, fn);
+    writeLocks.set(planFile, next.then(() => undefined, () => undefined));
+    try {
+        return await next;
+    }
+    finally {
+        if (writeLocks.get(planFile) === next) {
+            writeLocks.delete(planFile);
+        }
+    }
+}
+function renderTemplate(params) {
+    const context = params.context?.trim() ? params.context.trim() : '(empty)';
+    return DEFAULT_TEMPLATE.replace('{mission}', params.mission.trim())
+        .replace('{objective}', params.objective.trim())
+        .replace('{context}', context);
+}
+export async function initPlan(params) {
+    await ensureSalmonloopIgnored(params.persistenceRoot);
+    const sessionId = randomBytes(8).toString('hex');
+    const { planDir, planFile, planFileRelHint } = resolvePlanFilePath({
+        persistenceRoot: params.persistenceRoot,
+        sessionId,
+    });
+    const content = renderTemplate(params);
+    await withPlanWriteLock(planFile, async () => {
+        await writePlanFileAtomic(planDir, planFile, content);
+    });
+    return { sessionId, planPathHint: planFileRelHint, baseHash: sha256(content) };
+}
+export async function readPlan(params) {
+    const { planFile } = resolvePlanFilePath(params);
+    const content = await readPlanFile(planFile);
+    const baseHash = sha256(content);
+    const summary = summarizePlan(content);
+    return {
+        sessionId: params.sessionId,
+        baseHash,
+        active: summary.active,
+        pending: summary.pending,
+        recentDone: summary.recentDone,
+        conflicts: summary.conflicts,
+    };
+}
+export async function updatePlan(params) {
+    const { planDir, planFile } = resolvePlanFilePath(params);
+    return withPlanWriteLock(planFile, async () => {
+        const raw = await readPlanFile(planFile);
+        const currentHash = sha256(raw);
+        if (params.baseHash !== currentHash) {
+            const now = params.now ?? new Date();
+            const next = appendPlanConflictOnly(raw, {
+                message: `BASE_HASH_MISMATCH: stepId=${params.stepId}`,
+                note: `Conflict: baseHash mismatch for stepId=${params.stepId}`,
+                now,
+            });
+            await writePlanFileAtomic(planDir, planFile, next);
+            return {
+                ok: false,
+                sessionId: params.sessionId,
+                baseHash: sha256(next),
+                conflict: {
+                    code: 'BASE_HASH_MISMATCH',
+                    message: 'Plan content changed since last read (baseHash mismatch).',
+                },
+            };
+        }
+        const now = params.now ?? new Date();
+        const res = applyPlanUpdate(raw, { stepId: params.stepId, patch: params.patch, now });
+        await writePlanFileAtomic(planDir, planFile, res.content);
+        const nextHash = sha256(res.content);
+        if (!res.ok) {
+            return {
+                ok: false,
+                sessionId: params.sessionId,
+                baseHash: nextHash,
+                conflict: {
+                    code: res.error,
+                    message: `Plan update failed: ${res.error}`,
+                },
+            };
+        }
+        return {
+            ok: true,
+            sessionId: params.sessionId,
+            baseHash: nextHash,
+            updatedStepId: params.stepId,
+        };
+    });
+}
+export async function appendPlanNote(params) {
+    const { planDir, planFile } = resolvePlanFilePath(params);
+    const now = params.now ?? new Date();
+    return withPlanWriteLock(planFile, async () => {
+        const raw = await readPlanFile(planFile);
+        const next = appendPlanNoteOnly(raw, { note: params.note, now });
+        await writePlanFileAtomic(planDir, planFile, next);
+        return { baseHash: sha256(next) };
+    });
+}
+//# sourceMappingURL=manager.js.map