salmon-loop 0.2.3

package/dist/core/strata/layers/file-state-resolver.js

@@ -0,0 +1,157 @@
+import { Buffer } from 'node:buffer';
+import * as path from 'path';
+import * as fs from '../../adapters/fs/node-fs.js';
+import { LIMITS } from '../../config/limits.js';
+import { FileStatus } from '../../grizzco/domain/grizzco-types.js';
+/**
+ * FileStateResolver
+ * Responsibilities: Accurately scan workspace and index state, implementing the data foundation for Zero Index Access.
+ */
+export class FileStateResolver {
+    git;
+    workspaceRoot;
+    constructor(git, workspaceRoot) {
+        this.git = git;
+        this.workspaceRoot = workspaceRoot;
+    }
+    /**
+     * Resolve the state of a single file.
+     * Strictly follows git status --porcelain=v2 specification.
+     */
+    async resolve(filePath) {
+        // Normalize path to forward slashes for Git
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        // Get status using GitAdapter
+        const output = await this.git.getStatus([normalizedPath]);
+        const line = output.trim().split('\n')[0] || '';
+        const status = this.parseStatus(line);
+        const absolutePath = path.join(this.workspaceRoot, normalizedPath);
+        const state = {
+            path: normalizedPath,
+            absolutePath: absolutePath,
+            status: status,
+            isBinary: await this.detectBinary(absolutePath),
+            isSymlink: await this.detectSymlink(absolutePath),
+            isIgnored: await this.git.checkIgnore(normalizedPath), // [Added] Physical check for safety guard
+            size: await this.getFileSize(absolutePath),
+        };
+        // For MM state, we need snapshots of both versions
+        // stagedContent comes from Index (:0)
+        // workingContent comes from Disk
+        if (status === FileStatus.MM) {
+            try {
+                state.stagedContent = await this.git.show(':0', normalizedPath);
+                state.workingContent = await fs.readFile(absolutePath);
+            }
+            catch {
+                // Fallback: If we can't capture content, we might be in a race condition.
+                // But proceed with what we have; strategy layer will handle missing content if needed.
+            }
+        }
+        return state;
+    }
+    /**
+     * Batch resolution
+     */
+    async getWorkspaceMap(paths) {
+        const resultMap = new Map();
+        if (paths.length === 0)
+            return resultMap;
+        // Simple parallel processing
+        await Promise.all(paths.map(async (p) => {
+            const state = await this.resolve(p);
+            resultMap.set(p, state);
+        }));
+        return resultMap;
+    }
+    /**
+     * Parse Git Porcelain V2 status line.
+     * Format examples:
+     * 1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>  (Tracked)
+     * ? <path>                                      (Untracked)
+     * u <XY> <sub> <m1> <m2> <m3> <mW> <h1> <h2> <h3> <path> (Conflict)
+     */
+    parseStatus(line) {
+        if (!line)
+            return FileStatus.CLEAN;
+        const parts = line.split(' ');
+        const type = parts[0];
+        // 1. Untracked
+        if (type === '?')
+            return FileStatus.UNTRACKED;
+        // 2. Conflict (Unmerged)
+        if (type === 'u')
+            return FileStatus.CONFLICT;
+        // 3. Tracked (Normal or Rename)
+        if (type === '1' || type === '2') {
+            const xy = parts[1]; // XY flags
+            const x = xy[0];
+            const y = xy[1];
+            // Double Dirty (MM)
+            // X (Index status) != Unmodified (.) AND Y (Worktree status) != Unmodified (.)
+            if (x !== '.' && y !== '.')
+                return FileStatus.MM;
+            // Staged (X != '.', Y == '.')
+            if (x !== '.' && y === '.') {
+                if (x === 'A')
+                    return FileStatus.STAGED_ADDED;
+                if (x === 'D')
+                    return FileStatus.STAGED_DELETED;
+                return FileStatus.STAGED_MODIFIED;
+            }
+            // Unstaged (X == '.', Y != '.')
+            if (x === '.' && y !== '.') {
+                if (y === 'D')
+                    return FileStatus.UNSTAGED_DELETED;
+                return FileStatus.UNSTAGED_MODIFIED;
+            }
+        }
+        return FileStatus.CLEAN;
+    }
+    /**
+     * Detect if a file is binary by checking for null bytes in the first 8KB.
+     */
+    async detectBinary(filePath) {
+        try {
+            const buffer = Buffer.alloc(LIMITS.binaryCheckBufferSize);
+            const fd = await fs.open(filePath, 'r');
+            try {
+                const { bytesRead } = await fd.read(buffer, 0, LIMITS.binaryCheckBufferSize, 0);
+                const sample = buffer.subarray(0, bytesRead);
+                return sample.includes(0x00);
+            }
+            finally {
+                await fd.close();
+            }
+        }
+        catch {
+            // If file doesn't exist or can't be read, assume non-binary (safe default for new files)
+            return false;
+        }
+    }
+    /**
+     * Detect if path is a symlink.
+     */
+    async detectSymlink(filePath) {
+        try {
+            const stats = await fs.lstat(filePath);
+            return stats.isSymbolicLink();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get file size in bytes.
+     */
+    async getFileSize(filePath) {
+        try {
+            const stats = await fs.stat(filePath);
+            return stats.size;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+//# sourceMappingURL=file-state-resolver.js.map

package/dist/core/strata/layers/immutable-git-layer.js

@@ -0,0 +1,42 @@
+/**
+ * ImmutableGitLayer - Layer 1 Git Snapshot Management
+ *
+ * Wraps existing CheckpointManager to provide StrataSystem interface
+ * for L1 Git snapshot and worktree operations.
+ */
+import { CheckpointManager } from '../checkpoint/manager.js';
+/**
+ * ImmutableGitLayer Implementation
+ */
+export class ImmutableGitLayerImpl {
+    checkpointManager;
+    constructor() {
+        this.checkpointManager = new CheckpointManager();
+    }
+    /**
+     * Create a snapshot of the current repository state
+     */
+    async snapshot() {
+        const result = await this.checkpointManager.createSafeSnapshot(process.cwd());
+        return result.commitHash;
+    }
+    /**
+     * Checkout snapshot to shadow worktree
+     */
+    async checkout(shadowPath, commitHash) {
+        await this.checkpointManager.restoreToShadow(process.cwd(), shadowPath, commitHash);
+    }
+    /**
+     * Get file content from snapshot
+     */
+    async getFile(path) {
+        try {
+            const content = await this.checkpointManager.getSnapshotFileContent(process.cwd(), 'HEAD', path);
+            return Buffer.from(content);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=immutable-git-layer.js.map

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

@@ -0,0 +1,114 @@
+/**
+ * Copy Backend for ShadowDriver
+ *
+ * Platform-specific copy implementations:
+ * - macOS: cp -Rc (APFS CoW)
+ * - Linux: cp -r (safe) or cp -al (hardlink with readonly lock)
+ * - Windows: robocopy /MIR
+ */
+import { getLogger } from '../../../observability/logger.js';
+import { spawnCommand } from '../../../runtime/process-runner.js';
+import { normalizePath } from '../../../utils/path.js';
+/**
+ * Copy directory with platform-specific implementation
+ */
+export async function copyDir(src, dest, platform) {
+    const normalizedSrc = normalizePath(src);
+    const normalizedDest = normalizePath(dest);
+    getLogger().debug(`Copying ${normalizedSrc} to ${normalizedDest} on ${platform}`);
+    if (platform === 'darwin') {
+        try {
+            await exec(['cp', '-Rc', `${normalizedSrc}/.`, normalizedDest], {
+                allowExitCodes: new Set([0]),
+            });
+        }
+        catch (err) {
+            getLogger().warn(`macOS CoW copy failed, falling back to standard copy: ${err}`);
+            await exec(['cp', '-R', `${normalizedSrc}/.`, normalizedDest], {
+                allowExitCodes: new Set([0]),
+            });
+        }
+        return;
+    }
+    if (platform === 'linux') {
+        await exec(['cp', '-r', `${normalizedSrc}/.`, normalizedDest], {
+            allowExitCodes: new Set([0]),
+        });
+        return;
+    }
+    if (platform === 'win32') {
+        const robocopyArgs = [
+            'robocopy',
+            normalizedSrc,
+            normalizedDest,
+            '/MIR',
+            '/MT:8',
+            '/R:3',
+            '/W:1',
+            '/XD',
+            '.git',
+        ];
+        // Robocopy exit codes 0-7 are considered success (e.g. 1 means files copied).
+        // https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/robocopy
+        await exec(robocopyArgs, {
+            allowExitCodes: new Set([0, 1, 2, 3, 4, 5, 6, 7]),
+        });
+        return;
+    }
+}
+/**
+ * Hardlink directory (Linux only)
+ */
+export async function linkDirLinux(src, dest) {
+    const normalizedSrc = normalizePath(src);
+    const normalizedDest = normalizePath(dest);
+    try {
+        await exec(['cp', '-al', `${normalizedSrc}/.`, normalizedDest], {
+            allowExitCodes: new Set([0]),
+        });
+    }
+    catch (err) {
+        if (String((err instanceof Error ? err.message : String(err)) || '').includes('EXDEV')) {
+            getLogger().debug('Cross-device hardlink failed, falling back to copy');
+            await exec(['cp', '-r', `${normalizedSrc}/.`, normalizedDest], {
+                allowExitCodes: new Set([0]),
+            });
+            return;
+        }
+        throw err;
+    }
+}
+/**
+ * Execute command with timeout and error handling
+ */
+async function exec(command, options = {}) {
+    const commandArray = Array.isArray(command) ? command : [command];
+    const allowExitCodes = options.allowExitCodes ?? new Set([0]);
+    const timeout = options.timeout || 300000;
+    let stdout = '';
+    let stderr = '';
+    const result = await spawnCommand({
+        command: commandArray[0],
+        args: commandArray.slice(1),
+        cwd: options.cwd,
+        timeoutMs: timeout,
+        onStdoutChunk: (data) => {
+            stdout += Buffer.from(data).toString();
+        },
+        onStderrChunk: (data) => {
+            stderr += Buffer.from(data).toString();
+        },
+    });
+    if (result.error) {
+        throw new Error(`Command failed: ${result.error.message}`);
+    }
+    if (result.timedOut) {
+        throw new Error(`Command timed out after ${timeout}ms`);
+    }
+    const exitCode = result.code ?? 0;
+    if (allowExitCodes.has(exitCode)) {
+        return { code: exitCode, stdout, stderr };
+    }
+    throw new Error(`Command failed with code ${exitCode}: ${stderr}`);
+}
+//# sourceMappingURL=copy-backend.js.map

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

@@ -0,0 +1,29 @@
+/**
+ * Environment Variable Injection for ShadowDriver
+ *
+ * Provides optimized environment variables for dependency caching
+ * and performance optimization.
+ */
+import os from 'os';
+import path from 'path';
+/**
+ * Get environment variable injection for optimized execution
+ */
+export function getEnvInjection(repoRoot) {
+    const delimiter = path.delimiter;
+    const env = { ...process.env };
+    // Node.js: fallback dependency paths
+    const nodePaths = [env.NODE_PATH || '', '/usr/lib/s8p/global_modules'];
+    if (repoRoot) {
+        nodePaths.push(path.join(repoRoot, 'node_modules'));
+    }
+    env.NODE_PATH = nodePaths.filter(Boolean).join(delimiter);
+    // Rust
+    env.RUSTC_WRAPPER = env.RUSTC_WRAPPER || 'sccache';
+    // C/C++
+    env.CCACHE_DIR = env.CCACHE_DIR || path.join(os.homedir(), '.ccache');
+    // Go
+    env.GOCACHE = env.GOCACHE || path.join(os.homedir(), '.cache', 'go-build');
+    return env;
+}
+//# sourceMappingURL=env.js.map

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

@@ -0,0 +1,41 @@
+/**
+ * Error Classifier for ShadowDriver
+ *
+ * Classifies errors to determine if they are environment-related
+ * and should trigger fallback to ISOLATED strategy.
+ */
+/**
+ * Check if an error is environment-related
+ */
+export function isEnvironmentError(error) {
+    const msg = String(error?.message || error?.stderr || '');
+    // Module not found errors
+    if (msg.includes('MODULE_NOT_FOUND') || msg.includes('Cannot find module'))
+        return true;
+    // File not found errors for critical dependency paths
+    if (msg.includes('ENOENT') || msg.includes('no such file or directory')) {
+        const critical = [
+            'node_modules',
+            'bun.lock',
+            'bun.lockb',
+            'target/',
+            'build/',
+            '.cache',
+            'toolchain',
+        ];
+        return critical.some((p) => msg.includes(p));
+    }
+    // Permission errors
+    if (/EACCES|EPERM|Permission denied/.test(msg))
+        return true;
+    // Architecture mismatch errors
+    if (/wrong ELF class|mach-o, but wrong architecture/.test(msg))
+        return true;
+    // Windows-specific environment errors
+    if (msg.includes('The system cannot find the path specified'))
+        return true;
+    if (msg.includes('is not recognized as an internal or external command'))
+        return true;
+    return false;
+}
+//# sourceMappingURL=error-classifier.js.map

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

@@ -0,0 +1,17 @@
+/**
+ * ShadowDriver - Layer 2 Dependency Environment Manager
+ *
+ * Responsibilities:
+ * - Prepare dependency environments for ShadowMergeEngine
+ * - Manage dependency lifecycle (build, readonly lock, cleanup, fallback)
+ * - Implement Safe by Default -> Fast if Possible -> Fallback on Failure strategy
+ *
+ * @packageDocumentation
+ */
+export * from './strategy.js';
+export * from './error-classifier.js';
+export * from './copy-backend.js';
+export * from './readonly-lock.js';
+export * from './env.js';
+export * from './shadow-driver.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,221 @@
+/**
+ * Readonly Lock Manager for ShadowDriver
+ *
+ * Implements readonly locking for AGGRESSIVE strategy on Linux
+ * to prevent hardlink pollution.
+ *
+ * Also implements concurrent file lock mechanism for shadowRoot.
+ */
+import { randomBytes } from 'crypto';
+import path from 'path';
+import { mkdir, writeFile, unlink, readFile, rename } from '../../../adapters/fs/node-fs.js';
+import { getLogger } from '../../../observability/logger.js';
+import { getShadowLockPath } from '../../../runtime/paths.js';
+import { spawnCommand } from '../../../runtime/process-runner.js';
+import { normalizePath } from '../../../utils/path.js';
+const ownedLockTokens = new Map();
+/**
+ * Acquire a file lock for shadowRoot
+ */
+export async function acquireLock(shadowRoot) {
+    const lockPath = getShadowLockPath(shadowRoot);
+    const pid = process.pid;
+    const timestamp = Date.now();
+    try {
+        await mkdir(path.dirname(lockPath), { recursive: true });
+        const lockPayload = `${pid}:${timestamp}:${randomBytes(4).toString('hex')}`;
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            try {
+                await writeFile(lockPath, lockPayload, { flag: 'wx' });
+                ownedLockTokens.set(lockPath, lockPayload);
+                getLogger().debug(`Lock acquired for shadowRoot: ${shadowRoot}`);
+                return;
+            }
+            catch (error) {
+                const err = error;
+                if ((err && typeof err === 'object' && 'code' in err
+                    ? err.code
+                    : undefined) !== 'EEXIST') {
+                    throw error;
+                }
+                const existingLock = await readFile(lockPath, 'utf8').catch(() => null);
+                if (!existingLock) {
+                    continue;
+                }
+                const [oldPid, oldTs] = existingLock.split(':').map(Number);
+                if (!Number.isFinite(oldPid) || oldPid <= 0) {
+                    await removeLockByToken(lockPath, existingLock);
+                    continue;
+                }
+                const isAlive = await isProcessAlive(oldPid);
+                if (isAlive && oldPid !== pid) {
+                    const lockSince = formatLockTimestamp(oldTs);
+                    throw new Error(`ShadowRoot is locked by process ${oldPid} since ${lockSince}`);
+                }
+                if (isAlive && oldPid === pid) {
+                    ownedLockTokens.set(lockPath, existingLock);
+                    getLogger().debug(`Lock already held by current process ${pid}`);
+                    return;
+                }
+                getLogger().warn(`Stale lock found for process ${oldPid}, removing...`);
+                await removeLockByToken(lockPath, existingLock);
+            }
+        }
+        throw new Error('Failed to acquire lock due to concurrent lock updates');
+    }
+    catch (error) {
+        getLogger().error(`Failed to acquire lock: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Release the file lock
+ */
+export async function releaseLock(shadowRoot) {
+    const lockPath = getShadowLockPath(shadowRoot);
+    const ownedToken = ownedLockTokens.get(lockPath);
+    if (!ownedToken) {
+        getLogger().warn(`Skip releasing unowned lock: ${shadowRoot}`);
+        return;
+    }
+    try {
+        const removed = await removeLockByToken(lockPath, ownedToken);
+        if (!removed) {
+            getLogger().warn(`Skip releasing lock due to ownership mismatch: ${shadowRoot}`);
+            ownedLockTokens.delete(lockPath);
+            return;
+        }
+        ownedLockTokens.delete(lockPath);
+        getLogger().debug(`Lock released for shadowRoot: ${shadowRoot}`);
+    }
+    catch (error) {
+        getLogger().warn(`Failed to release lock: ${error}`);
+    }
+}
+/**
+ * Check if a process is alive
+ */
+async function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        const message = err?.message || '';
+        if ((err && typeof err === 'object' && 'code' in err
+            ? err.code
+            : undefined) === 'ESRCH' ||
+            message.includes('ESRCH'))
+            return false;
+        if ((err && typeof err === 'object' && 'code' in err
+            ? err.code
+            : undefined) === 'EPERM' ||
+            message.includes('EPERM'))
+            return true;
+        return true;
+    }
+}
+function formatLockTimestamp(value) {
+    if (!Number.isFinite(value))
+        return 'unknown-time';
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return 'unknown-time';
+    return date.toISOString();
+}
+async function removeLockByToken(lockPath, expectedToken) {
+    const swapPath = `${lockPath}.swap-${process.pid}-${randomBytes(4).toString('hex')}`;
+    try {
+        await rename(lockPath, swapPath);
+    }
+    catch {
+        return false;
+    }
+    try {
+        const movedToken = await readFile(swapPath, 'utf8');
+        if (movedToken === expectedToken) {
+            await unlink(swapPath);
+            return true;
+        }
+        try {
+            await rename(swapPath, lockPath);
+        }
+        catch {
+            // Best-effort rollback when concurrent updates happen.
+            await unlink(swapPath).catch(() => null);
+        }
+        return false;
+    }
+    catch {
+        try {
+            await rename(swapPath, lockPath);
+        }
+        catch {
+            // Best-effort rollback when concurrent updates happen.
+            await unlink(swapPath).catch(() => null);
+        }
+        return false;
+    }
+}
+/**
+ * Enforce readonly permissions on dependency paths
+ */
+export async function enforceReadOnly(root, depPaths) {
+    if (process.platform !== 'linux')
+        return;
+    getLogger().debug(`Enforcing readonly lock on ${depPaths.length} paths`);
+    for (const dep of depPaths) {
+        const depPath = normalizePath(`${root}/${dep}`);
+        try {
+            await execChmod('a-w', depPath);
+            getLogger().debug(`Readonly lock applied to ${depPath}`);
+        }
+        catch (error) {
+            getLogger().warn(`Failed to apply readonly lock to ${depPath}: ${error}`);
+        }
+    }
+}
+/**
+ * Restore write permissions for cleanup
+ */
+export async function restoreWrite(root, depPaths) {
+    if (process.platform !== 'linux')
+        return;
+    getLogger().debug(`Restoring write permissions on ${depPaths.length} paths`);
+    for (const dep of depPaths) {
+        const depPath = normalizePath(`${root}/${dep}`);
+        try {
+            await execChmod('u+w', depPath);
+            getLogger().debug(`Write permissions restored to ${depPath}`);
+        }
+        catch (error) {
+            getLogger().warn(`Failed to restore write permissions to ${depPath}: ${error}`);
+        }
+    }
+}
+/**
+ * Execute command helper
+ */
+async function execChmod(mode, targetPath) {
+    let stderr = '';
+    const result = await spawnCommand({
+        command: 'chmod',
+        args: ['-R', mode, targetPath],
+        timeoutMs: 10000,
+        onStderrChunk: (chunk) => {
+            stderr += Buffer.from(chunk).toString();
+        },
+    });
+    if (result.error) {
+        throw new Error(`Command failed: ${result.error.message}`);
+    }
+    if (result.timedOut) {
+        throw new Error('Command timed out');
+    }
+    if (result.code === 0) {
+        return;
+    }
+    throw new Error(`Command failed with code ${result.code}: ${stderr}`);
+}
+//# sourceMappingURL=readonly-lock.js.map