salmon-loop 0.2.3

package/dist/core/strata/layers/shadow-driver/shadow-driver.js

@@ -0,0 +1,234 @@
+/**
+ * ShadowDriver - Main Implementation
+ *
+ * Core implementation of Layer 2 ShadowDriver following v2.0 specification.
+ */
+import { join } from 'path';
+import { existsSync } from '../../../adapters/fs/node-fs.js';
+import { rm, mkdir, symlink } from '../../../adapters/fs/node-fs.js';
+import { getLogger } from '../../../observability/logger.js';
+import { spawnCommand } from '../../../runtime/process-runner.js';
+import { normalizePath } from '../../../utils/path.js';
+import { getPlatformShellInvocation } from '../../../utils/platform-shell.js';
+import { copyDir, linkDirLinux } from './copy-backend.js';
+import { getEnvInjection } from './env.js';
+import { isEnvironmentError } from './error-classifier.js';
+import { enforceReadOnly, restoreWrite, acquireLock, releaseLock } from './readonly-lock.js';
+import { determineStrategy, planDependencyPaths, detectDependencyPaths } from './strategy.js';
+/**
+ * ShadowDriver Class
+ */
+export class ShadowDriver {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Hydrate a target directory with dependencies from a source repository.
+     * This projects the environment (node_modules, venv, etc.) into the target
+     * using cross-platform symlinks (junctions).
+     *
+     * Used by: Worktree Strategy (L1) to prepare the execution environment (L2).
+     */
+    static async hydrate(repoRoot, targetRoot) {
+        const depPaths = await detectDependencyPaths(repoRoot);
+        if (depPaths.length === 0) {
+            getLogger().debug('No dependencies detected to hydrate.');
+            return;
+        }
+        getLogger().debug(`Hydrating environment: ${depPaths.join(', ')} -> ${targetRoot}`);
+        for (const depPath of depPaths) {
+            const sourcePath = join(repoRoot, depPath);
+            const targetDepPath = join(targetRoot, depPath);
+            if (!existsSync(sourcePath)) {
+                continue;
+            }
+            try {
+                // Use 'junction' for Windows compatibility (no admin rights needed usually)
+                await symlink(sourcePath, targetDepPath, 'junction');
+                getLogger().debug(`Linked dependency: ${depPath}`);
+            }
+            catch (err) {
+                if ((err && typeof err === 'object' && 'code' in err
+                    ? err.code
+                    : undefined) !== 'EEXIST') {
+                    getLogger().warn(`Failed to link ${depPath}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                else {
+                    getLogger().debug(`Dependency link already exists: ${depPath}`);
+                }
+            }
+        }
+    }
+    /**
+     * Setup dependency environment for task execution
+     */
+    async setup(task) {
+        // Acquire concurrency lock
+        await acquireLock(this.config.shadowRoot);
+        const strategy = determineStrategy(task, this.config.whitelist);
+        const depPaths = await planDependencyPaths(this.config);
+        getLogger().debug(`ShadowDriver setup: strategy=${strategy}, depPaths=${depPaths.join(',')}`);
+        // Prepare dependency directories
+        await this.prepareDependencyDirs(depPaths);
+        if (strategy === 'ISOLATED') {
+            if (existsSync(join(this.config.repoRoot, 'bun.lock')) ||
+                existsSync(join(this.config.repoRoot, 'bun.lockb'))) {
+                getLogger().debug('bun project detected');
+            }
+            await this.copyDependencies(depPaths);
+        }
+        else if (strategy === 'AGGRESSIVE') {
+            await this.linkDependencies(depPaths);
+            if (this.config.readonly)
+                await enforceReadOnly(this.config.shadowRoot, depPaths);
+        }
+        // OPTIMIZED strategy doesn't require copying/linking
+        return {
+            shadowPath: this.config.shadowRoot,
+            strategy,
+            fallbackApplied: false,
+            readonlyLocked: strategy === 'AGGRESSIVE' && this.config.readonly,
+            dependencyPaths: depPaths,
+        };
+    }
+    /**
+     * Run task with driver environment
+     */
+    async run(task) {
+        return runWithDriver(task, this.config);
+    }
+    /**
+     * Cleanup shadow environment
+     */
+    async cleanup(depPaths) {
+        await cleanup(this.config.shadowRoot, depPaths);
+    }
+    /**
+     * Prepare dependency directories in shadow root
+     */
+    async prepareDependencyDirs(depPaths) {
+        for (const dep of depPaths) {
+            const depPath = join(this.config.shadowRoot, dep);
+            try {
+                // Create the directory itself to ensure copy contents works correctly (paired with cp src/. dest)
+                await mkdir(depPath, { recursive: true });
+            }
+            catch (error) {
+                getLogger().warn(`Failed to create dependency directory ${depPath}: ${error}`);
+            }
+        }
+    }
+    /**
+     * Copy dependencies for ISOLATED strategy
+     */
+    async copyDependencies(depPaths) {
+        for (const dep of depPaths) {
+            const srcPath = join(this.config.repoRoot, dep);
+            const destPath = join(this.config.shadowRoot, dep);
+            try {
+                await copyDir(srcPath, destPath, this.config.platform);
+                getLogger().debug(`Copied dependency: ${dep}`);
+            }
+            catch (error) {
+                getLogger().error(`Failed to copy dependency ${dep}: ${error}`);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Link dependencies for AGGRESSIVE strategy
+     */
+    async linkDependencies(depPaths) {
+        if (this.config.platform !== 'linux') {
+            throw new Error('AGGRESSIVE strategy only supported on Linux');
+        }
+        for (const dep of depPaths) {
+            const srcPath = join(this.config.repoRoot, dep);
+            const destPath = join(this.config.shadowRoot, dep);
+            try {
+                await linkDirLinux(srcPath, destPath);
+                getLogger().debug(`Linked dependency: ${dep}`);
+            }
+            catch (error) {
+                getLogger().error(`Failed to link dependency ${dep}: ${error}`);
+                throw error;
+            }
+        }
+    }
+}
+/**
+ * Run task with driver environment (with fallback support)
+ */
+async function runWithDriver(task, ctx, isFallback = false) {
+    const driver = new ShadowDriver(ctx);
+    let depPaths;
+    try {
+        const result = await driver.setup(task);
+        depPaths = result.dependencyPaths;
+        // Execute command with injected environment
+        const env = getEnvInjection(ctx.repoRoot);
+        await executeCommand(task.command, ctx.shadowRoot, env);
+        getLogger().debug(`Command executed successfully: ${task.command}`);
+    }
+    catch (error) {
+        if (isFallback)
+            throw error;
+        if (isEnvironmentError(error)) {
+            getLogger().debug(`Environment error detected, triggering fallback: ${error}`);
+            await cleanup(ctx.shadowRoot, depPaths);
+            return runWithDriver({ ...task, forceIsolation: true }, ctx, true);
+        }
+        throw error;
+    }
+}
+/**
+ * Execute command in shadow environment
+ */
+async function executeCommand(command, cwd, env) {
+    const shell = getPlatformShellInvocation(command);
+    let stderr = '';
+    const result = await spawnCommand({
+        command: shell.file,
+        args: shell.args,
+        cwd,
+        env,
+        onStderrChunk: (chunk) => {
+            stderr += Buffer.from(chunk).toString();
+        },
+    });
+    if (result.error) {
+        throw new Error(result.error.message);
+    }
+    if (!result.timedOut && result.code === 0) {
+        return;
+    }
+    if (result.timedOut) {
+        throw new Error('command timed out');
+    }
+    const message = stderr.trim() || `command failed with exit code ${String(result.code)}`;
+    throw new Error(message);
+}
+/**
+ * Cleanup shadow environment
+ */
+async function cleanup(root, depPaths) {
+    const normalizedRoot = normalizePath(root);
+    getLogger().debug(`Cleaning up shadow environment: ${normalizedRoot}`);
+    // Restore write permissions if needed
+    if (process.platform === 'linux' && depPaths?.length) {
+        await restoreWrite(root, depPaths);
+    }
+    // Release concurrency lock
+    await releaseLock(root);
+    // Remove shadow directory
+    try {
+        await rm(root, { recursive: true, force: true, maxRetries: 3, retryDelay: 200 });
+        getLogger().debug(`Successfully cleaned up shadow environment: ${normalizedRoot}`);
+    }
+    catch (error) {
+        getLogger().error(`Failed to cleanup shadow environment ${normalizedRoot}: ${error}`);
+        throw error;
+    }
+}
+//# sourceMappingURL=shadow-driver.js.map

package/dist/core/strata/layers/shadow-driver/strategy.js

@@ -0,0 +1,86 @@
+/**
+ * Strategy Selector for ShadowDriver
+ *
+ * Implements the strategy determination logic:
+ * - Default: ISOLATED (safe by default)
+ * - Whitelist: OPTIMIZED (fast if possible)
+ * - Blacklist: ISOLATED (fallback on failure)
+ */
+import { join } from 'path';
+import { existsSync } from '../../../adapters/fs/node-fs.js';
+import { WRITE_OP_BLACKLIST } from '../../types.js';
+/**
+ * Normalize command for consistent matching
+ */
+function normalizeCommand(cmd) {
+    return cmd.trim().replace(/\\/g, '/').toLowerCase();
+}
+/**
+ * Determine the appropriate strategy for a given task
+ */
+export function determineStrategy(task, whitelist) {
+    // Force isolation takes precedence
+    if (task.forceIsolation || task.requiresWrite)
+        return 'ISOLATED';
+    const normalizedCmd = normalizeCommand(task.command);
+    // Whitelist check
+    if (whitelist && whitelist.length > 0) {
+        const inWhitelist = whitelist.some((safeCmd) => normalizedCmd.startsWith(normalizeCommand(safeCmd)));
+        if (!inWhitelist)
+            return 'ISOLATED';
+    }
+    // Blacklist check
+    if (WRITE_OP_BLACKLIST.some((op) => normalizedCmd.includes(op)))
+        return 'ISOLATED';
+    // Mode-based optimization
+    if (task.mode === 'analysis' || task.mode === 'test_readonly')
+        return 'OPTIMIZED';
+    // Default to isolation
+    return 'ISOLATED';
+}
+/**
+ * Plan dependency paths based on repository configuration
+ */
+export async function planDependencyPaths(config) {
+    if (config.dependencyPaths?.length) {
+        return config.dependencyPaths.filter((p) => validateDependencyPath(config.repoRoot, p));
+    }
+    return detectDependencyPaths(config.repoRoot);
+}
+/**
+ * Validate dependency path for security
+ */
+export function validateDependencyPath(repoRoot, depPath) {
+    if (depPath.startsWith('/') || /^[a-zA-Z]:/.test(depPath))
+        return false;
+    if (depPath.includes('..'))
+        return false;
+    return true;
+}
+/**
+ * Detect dependency paths based on repository files
+ */
+export async function detectDependencyPaths(repoRoot) {
+    const paths = [];
+    // Node.js
+    if (existsSync(join(repoRoot, 'package.json'))) {
+        paths.push('node_modules');
+    }
+    // Python
+    if (existsSync(join(repoRoot, 'requirements.txt')) ||
+        existsSync(join(repoRoot, 'pyproject.toml'))) {
+        paths.push('venv');
+        paths.push('.venv');
+        paths.push('__pycache__');
+    }
+    // Rust
+    if (existsSync(join(repoRoot, 'Cargo.toml'))) {
+        paths.push('target');
+    }
+    // Go
+    if (existsSync(join(repoRoot, 'go.mod'))) {
+        paths.push('vendor');
+    }
+    return paths.filter((p) => existsSync(join(repoRoot, p)));
+}
+//# sourceMappingURL=strategy.js.map

package/dist/core/strata/layers/sidecar-layer.js

@@ -0,0 +1,96 @@
+/**
+ * SyntheticSidecarLayer - Layer 3 Ignored/Untracked File Handling
+ *
+ * Manages ignored and untracked files for ShadowMergeEngine
+ * Provides base content for ignored files that are modified during execution.
+ */
+import { dirname } from 'path';
+import { existsSync } from '../../adapters/fs/node-fs.js';
+import { mkdir, readFile, writeFile as writeFileToDisk } from '../../adapters/fs/node-fs.js';
+import { getLogger } from '../../observability/logger.js';
+import { isSafeRelativePath, normalizePath, safeJoin } from '../../utils/path.js';
+/**
+ * SyntheticSidecarLayer Implementation
+ */
+export class SyntheticSidecarLayerImpl {
+    repoRoot;
+    capturedFiles = new Map();
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+    }
+    /**
+     * Capture ignored/untracked files
+     */
+    async capture(paths) {
+        getLogger().debug(`Capturing ${paths.length} ignored/untracked files`);
+        for (const filePath of paths) {
+            const normalized = normalizePath(filePath);
+            if (!isSafeRelativePath(normalized)) {
+                getLogger().warn(`Skipping unsafe path capture: ${filePath}`);
+                continue;
+            }
+            try {
+                const absolutePath = this.repoRoot ? safeJoin(this.repoRoot, normalized) : normalized;
+                if (existsSync(absolutePath)) {
+                    const content = await readFile(absolutePath);
+                    this.capturedFiles.set(normalized, content);
+                    getLogger().debug(`Captured file: ${normalized}`);
+                }
+            }
+            catch (error) {
+                getLogger().warn(`Failed to capture file ${filePath}: ${error}`);
+            }
+        }
+    }
+    /**
+     * Inject captured files to shadow worktree
+     */
+    async inject(shadowPath) {
+        getLogger().debug(`Injecting ${this.capturedFiles.size} files to shadow worktree`);
+        for (const [filePath, content] of this.capturedFiles) {
+            const shadowFilePath = safeJoin(shadowPath, filePath);
+            try {
+                await writeSidecarFile(shadowFilePath, content);
+                getLogger().debug(`Injected file: ${filePath}`);
+            }
+            catch (error) {
+                getLogger().warn(`Failed to inject file ${filePath}: ${error}`);
+            }
+        }
+    }
+    /**
+     * Check if file is captured
+     */
+    has(path) {
+        const normalized = normalizePath(path);
+        if (!isSafeRelativePath(normalized))
+            return false;
+        return this.capturedFiles.has(normalized);
+    }
+    /**
+     * Get captured file content
+     */
+    async get(path) {
+        const normalized = normalizePath(path);
+        if (!isSafeRelativePath(normalized))
+            return null;
+        return this.capturedFiles.get(normalized) || null;
+    }
+    /**
+     * Clear captured files
+     */
+    async clear() {
+        this.capturedFiles.clear();
+        getLogger().debug('Cleared all captured files');
+    }
+}
+/**
+ * Write file helper
+ */
+async function writeSidecarFile(filePath, content) {
+    // Ensure directory exists
+    await mkdir(dirname(filePath), { recursive: true });
+    // Write file
+    await writeFileToDisk(filePath, content);
+}
+//# sourceMappingURL=sidecar-layer.js.map

package/dist/core/strata/layers/worktree.js

@@ -0,0 +1,240 @@
+import { randomBytes } from 'crypto';
+import { tmpdir } from 'os';
+import path from 'path';
+import { text } from '../../../locales/index.js';
+import { access, realpath, rm } from '../../adapters/fs/node-fs.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { getLogger } from '../../observability/logger.js';
+import { isPathWithinDirectory, normalizePath } from '../../utils/path.js';
+function resolveEnvironmentMode(options) {
+    return options.environmentMode === 'parity' ? 'parity' : 'strict';
+}
+function isWindowsAbsolutePath(p) {
+    return /^[a-zA-Z]:[\\/]/.test(p) || p.startsWith('\\\\');
+}
+function selectPathImpl(p) {
+    const normalized = normalizePath(p);
+    if (!normalized)
+        return path;
+    if (isWindowsAbsolutePath(normalized))
+        return path.win32;
+    if (normalized.startsWith('/'))
+        return path.posix;
+    return path;
+}
+function resolveParityWorktreeRoot(repoPath) {
+    const impl = selectPathImpl(repoPath);
+    const normalizedRepoPath = normalizePath(repoPath);
+    return normalizePath(impl.join(impl.dirname(impl.resolve(normalizedRepoPath)), '.salmonloop', 'worktrees'));
+}
+function isManagedWorktreePath(baseRepoPath, workPath) {
+    if (isPathWithinDirectory(tmpdir(), workPath, { allowEqual: false }))
+        return true;
+    const parityRoot = resolveParityWorktreeRoot(baseRepoPath);
+    if (isPathWithinDirectory(parityRoot, workPath, { allowEqual: false }))
+        return true;
+    return false;
+}
+function normalizePathForCompare(value) {
+    const normalized = path.normalize(value).replace(/\\/g, '/');
+    if (process.platform === 'darwin' && normalized.startsWith('/private/')) {
+        return normalized.slice('/private'.length);
+    }
+    return normalized;
+}
+async function tryRealpath(value) {
+    try {
+        return await realpath(value);
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveWorktreeMatchPath(worktreePaths, targetPath) {
+    const targetNorm = normalizePathForCompare(targetPath);
+    const exactMatch = worktreePaths.find((p) => p === targetPath) ||
+        worktreePaths.find((p) => normalizePathForCompare(p) === targetNorm);
+    if (exactMatch)
+        return exactMatch;
+    const targetReal = await tryRealpath(targetPath);
+    if (!targetReal)
+        return null;
+    for (const candidate of worktreePaths) {
+        const candidateReal = await tryRealpath(candidate);
+        if (candidateReal && candidateReal === targetReal) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * WorkspaceManager - Manages execution workspace for different checkpoint strategies
+ *
+ * Supports two strategies:
+ * - 'direct': Operates directly on the repository
+ * - 'worktree': Creates a temporary git worktree for isolated execution
+ */
+export class WorkspaceManager {
+    /**
+     * Setup execution workspace based on strategy
+     * @param options RunOptions with optional strategy
+     * @param initialCommit Optional commit hash to base the worktree on (defaults to HEAD)
+     * @param onEvent Optional event callback for reporting progress
+     * @returns ExecutionWorkspace configuration
+     */
+    static async setup(options, initialCommit, onEvent) {
+        const strategy = options.strategy || 'direct';
+        const git = new GitAdapter(options.repoPath);
+        if (strategy === 'worktree') {
+            const baseRef = initialCommit || (await git.query(['rev-parse', 'HEAD']));
+            const repoPathImpl = selectPathImpl(options.repoPath);
+            const repoName = repoPathImpl.basename(normalizePath(options.repoPath));
+            const timestamp = Date.now();
+            const random = randomBytes(4).toString('hex');
+            const environmentMode = resolveEnvironmentMode(options);
+            const worktreeRootImpl = environmentMode === 'parity' ? selectPathImpl(options.repoPath) : selectPathImpl(tmpdir());
+            const rootDir = environmentMode === 'parity'
+                ? worktreeRootImpl.join(resolveParityWorktreeRoot(options.repoPath), repoName)
+                : worktreeRootImpl.join(tmpdir(), `s8p-wt/${repoName}`);
+            const worktreePath = worktreeRootImpl.join(rootDir, `${timestamp}-${random}`);
+            const normalizedWorktreePath = worktreeRootImpl.normalize(worktreePath);
+            if (environmentMode === 'parity') {
+                const parityRoot = worktreeRootImpl.normalize(resolveParityWorktreeRoot(options.repoPath));
+                if (!isPathWithinDirectory(parityRoot, normalizedWorktreePath, { allowEqual: false })) {
+                    throw new Error('Worktree path must be under parity worktree root');
+                }
+            }
+            else {
+                const tmpDir = worktreeRootImpl.normalize(tmpdir());
+                if (!isPathWithinDirectory(tmpDir, normalizedWorktreePath, { allowEqual: false })) {
+                    throw new Error('Worktree path must be in system temp directory');
+                }
+            }
+            if (isPathWithinDirectory(options.repoPath, worktreePath, { allowEqual: true })) {
+                throw new Error('Worktree path must not be inside repo path');
+            }
+            // Use GitAdapter for worktree creation
+            await git.query(['worktree', 'add', '--quiet', '--detach', worktreePath, baseRef.trim()]);
+            onEvent?.({
+                type: 'workspace.ready',
+                strategy: 'worktree',
+                path: worktreePath,
+                timestamp: new Date(),
+            });
+            getLogger().debug(`Created worktree at: ${worktreePath}`);
+            return {
+                baseRepoPath: options.repoPath,
+                workPath: worktreePath,
+                strategy: 'worktree',
+                environmentMode,
+            };
+        }
+        // Default direct strategy
+        onEvent?.({
+            type: 'workspace.ready',
+            strategy: 'direct',
+            path: options.repoPath,
+            timestamp: new Date(),
+        });
+        return {
+            baseRepoPath: options.repoPath,
+            workPath: options.repoPath,
+            strategy: 'direct',
+            environmentMode: resolveEnvironmentMode(options),
+        };
+    }
+    /**
+     * Teardown execution workspace and clean up resources
+     * @param workspace ExecutionWorkspace to teardown
+     * @param onEvent Optional event callback
+     */
+    static async teardown(workspace, onEvent) {
+        if (workspace.strategy !== 'worktree') {
+            getLogger().debug(`Teardown workspace (strategy: ${workspace.strategy}) - no action needed`);
+            return;
+        }
+        if (workspace.workPath === workspace.baseRepoPath) {
+            onEvent?.({
+                type: 'resource.status',
+                resource: 'worktree',
+                status: 'skipped',
+                message: text.resource.worktreeSkipCleanup,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const git = new GitAdapter(workspace.baseRepoPath);
+        let removed = false;
+        try {
+            const list = await git.query(['worktree', 'list', '--porcelain']);
+            const worktreePaths = list
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.startsWith('worktree '))
+                .map((line) => line.slice('worktree '.length).trim())
+                .filter(Boolean);
+            const matchPath = await resolveWorktreeMatchPath(worktreePaths, workspace.workPath);
+            if (matchPath) {
+                await git.query(['worktree', 'remove', '--force', matchPath]);
+                removed = true;
+                const directoryStillExists = await (async () => {
+                    try {
+                        await access(workspace.workPath);
+                        return true;
+                    }
+                    catch (error) {
+                        if (error && typeof error === 'object' && error.code === 'ENOENT') {
+                            return false;
+                        }
+                        return true;
+                    }
+                })();
+                if (directoryStillExists) {
+                    removed = false;
+                    getLogger().debug(`git worktree remove reported success but directory still exists; falling back to fs.rm: ${workspace.workPath}`);
+                }
+                else {
+                    getLogger().debug(`Removed worktree: ${matchPath}`);
+                }
+            }
+            else {
+                onEvent?.({
+                    type: 'resource.status',
+                    resource: 'worktree',
+                    status: 'warning',
+                    message: text.resource.worktreeNotFoundInList(workspace.workPath),
+                    timestamp: new Date(),
+                });
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error
+                ? error instanceof Error
+                    ? error.message
+                    : String(error)
+                : String(error);
+            onEvent?.({
+                type: 'action.fallback',
+                tool: 'git',
+                method: 'worktree remove',
+                reason: msg,
+                severity: 'low',
+                timestamp: new Date(),
+            });
+            getLogger().debug(`git worktree remove failed, falling back to filesystem removal: ${msg}`);
+        }
+        if (!removed) {
+            if (!isManagedWorktreePath(workspace.baseRepoPath, workspace.workPath)) {
+                throw new Error('Worktree path not in managed roots, refusing to delete');
+            }
+            await rm(workspace.workPath, {
+                recursive: true,
+                force: true,
+                maxRetries: 3,
+                retryDelay: 100,
+            });
+            getLogger().debug(`Successfully cleaned up worktree directory via fs.rm: ${workspace.workPath}`);
+        }
+    }
+}
+//# sourceMappingURL=worktree.js.map