@shipwithai/loopnote 0.0.0-stage → 2.0.0

package/dist/git/runner.js

@@ -0,0 +1,145 @@
+import { spawn } from 'node:child_process';
+const DEFAULT_TIMEOUT_MS = 10_000;
+const DEFAULT_STDOUT_LIMIT = 1024 * 1024;
+const DEFAULT_STDERR_LIMIT = 64 * 1024;
+const safeGitArguments = [
+    '--no-optional-locks',
+    '-c',
+    'core.hooksPath=',
+    '-c',
+    'core.fsmonitor=false',
+    '-c',
+    'diff.external=',
+    '-c',
+    'protocol.file.allow=never',
+];
+export class GitRunnerError extends Error {
+    kind;
+    exitCode;
+    stderr;
+    constructor(kind, message, options = {}) {
+        super(message, { cause: options.cause });
+        this.name = 'GitRunnerError';
+        this.kind = kind;
+        this.exitCode = options.exitCode ?? null;
+        this.stderr = options.stderr ?? Buffer.alloc(0);
+    }
+}
+function positiveLimit(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new RangeError('Git runner byte limits and timeouts must be positive integers');
+    }
+    return value;
+}
+export function createGitRunner(defaults = {}) {
+    const defaultTimeoutMs = positiveLimit(defaults.timeoutMs, DEFAULT_TIMEOUT_MS);
+    const defaultMaxStdoutBytes = positiveLimit(defaults.maxStdoutBytes, DEFAULT_STDOUT_LIMIT);
+    const defaultMaxStderrBytes = positiveLimit(defaults.maxStderrBytes, DEFAULT_STDERR_LIMIT);
+    return Object.freeze({
+        async run(arguments_, options) {
+            const timeoutMs = positiveLimit(options.timeoutMs, defaultTimeoutMs);
+            const maxStdoutBytes = positiveLimit(options.maxStdoutBytes, defaultMaxStdoutBytes);
+            const maxStderrBytes = positiveLimit(options.maxStderrBytes, defaultMaxStderrBytes);
+            if (options.signal?.aborted) {
+                throw new GitRunnerError('aborted', 'Git command was cancelled', {
+                    cause: options.signal.reason,
+                });
+            }
+            return await new Promise((resolve, reject) => {
+                const controller = new AbortController();
+                let abortKind;
+                let terminalFailure;
+                let spawnFailure;
+                let stdoutBytes = 0;
+                let stderrBytes = 0;
+                const stdoutChunks = [];
+                const stderrChunks = [];
+                const abortFromCaller = () => {
+                    abortKind = 'aborted';
+                    controller.abort(options.signal?.reason);
+                };
+                options.signal?.addEventListener('abort', abortFromCaller, {
+                    once: true,
+                });
+                const timeout = setTimeout(() => {
+                    abortKind = 'timeout';
+                    controller.abort(new Error(`Git command timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+                timeout.unref();
+                const environment = { ...process.env };
+                delete environment.GIT_LITERAL_PATHSPECS;
+                delete environment.GIT_GLOB_PATHSPECS;
+                delete environment.GIT_NOGLOB_PATHSPECS;
+                delete environment.GIT_ICASE_PATHSPECS;
+                const child = spawn('git', [...safeGitArguments, ...arguments_], {
+                    cwd: options.cwd,
+                    env: {
+                        ...environment,
+                        GIT_CONFIG_NOSYSTEM: '1',
+                        GIT_EXTERNAL_DIFF: '',
+                        GIT_OPTIONAL_LOCKS: '0',
+                        GIT_TERMINAL_PROMPT: '0',
+                    },
+                    shell: false,
+                    signal: controller.signal,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                child.stdin.end(options.input);
+                child.stdout.on('data', (chunk) => {
+                    stdoutBytes += chunk.length;
+                    if (stdoutBytes > maxStdoutBytes) {
+                        terminalFailure ??= new GitRunnerError('stdout-limit', `Git stdout exceeded ${maxStdoutBytes} bytes`);
+                        child.kill('SIGKILL');
+                        return;
+                    }
+                    stdoutChunks.push(chunk);
+                });
+                child.stderr.on('data', (chunk) => {
+                    stderrBytes += chunk.length;
+                    if (stderrBytes > maxStderrBytes) {
+                        terminalFailure ??= new GitRunnerError('stderr-limit', `Git stderr exceeded ${maxStderrBytes} bytes`);
+                        child.kill('SIGKILL');
+                        return;
+                    }
+                    stderrChunks.push(chunk);
+                });
+                child.once('error', (error) => {
+                    spawnFailure = error;
+                });
+                child.once('close', (exitCode) => {
+                    clearTimeout(timeout);
+                    options.signal?.removeEventListener('abort', abortFromCaller);
+                    const stderr = Buffer.concat(stderrChunks);
+                    if (terminalFailure !== undefined) {
+                        reject(terminalFailure);
+                        return;
+                    }
+                    if (abortKind !== undefined) {
+                        reject(new GitRunnerError(abortKind, abortKind === 'timeout'
+                            ? `Git command timed out after ${timeoutMs}ms`
+                            : 'Git command was cancelled', { cause: controller.signal.reason, stderr }));
+                        return;
+                    }
+                    if (spawnFailure !== undefined) {
+                        reject(new GitRunnerError('spawn', 'Unable to start the Git executable', {
+                            cause: spawnFailure,
+                            stderr,
+                        }));
+                        return;
+                    }
+                    if (exitCode !== 0) {
+                        reject(new GitRunnerError('exit', `Git command exited with status ${exitCode ?? 'unknown'}`, { exitCode, stderr }));
+                        return;
+                    }
+                    resolve({
+                        stdout: Buffer.concat(stdoutChunks),
+                        stderr,
+                    });
+                });
+            });
+        },
+    });
+}

package/dist/git/selector-drift.js

@@ -0,0 +1,169 @@
+import { GitObjectIdSchema, } from '../contracts/comparison.js';
+import { SelectorDriftResponseSchema, } from '../contracts/api.js';
+import { createGitRunner } from './runner.js';
+const UNAVAILABLE_REASON = 'source-unavailable';
+function splitNul(buffer) {
+    const fields = [];
+    let start = 0;
+    for (let index = 0; index < buffer.length; index += 1) {
+        if (buffer[index] === 0) {
+            fields.push(buffer.subarray(start, index));
+            start = index + 1;
+        }
+    }
+    if (start < buffer.length) {
+        fields.push(buffer.subarray(start));
+    }
+    return fields;
+}
+function parseWorktreeRecords(buffer) {
+    const records = [];
+    let current = {
+        prunable: false,
+        bare: false,
+    };
+    for (const field of splitNul(buffer)) {
+        if (field.length === 0) {
+            if (current.path !== undefined) {
+                records.push(Object.freeze(current));
+            }
+            current = { prunable: false, bare: false };
+            continue;
+        }
+        const separator = field.indexOf(0x20);
+        const key = (separator === -1 ? field : field.subarray(0, separator)).toString('ascii');
+        const value = separator === -1 ? undefined : field.subarray(separator + 1).toString('utf8');
+        if (key === 'worktree') {
+            if (current.path !== undefined) {
+                records.push(Object.freeze(current));
+            }
+            current = { path: value, prunable: false, bare: false };
+        }
+        else if (key === 'HEAD') {
+            current.headOid = value;
+        }
+        else if (key === 'prunable') {
+            current.prunable = true;
+        }
+        else if (key === 'bare') {
+            current.bare = true;
+        }
+    }
+    if (current.path !== undefined) {
+        records.push(Object.freeze(current));
+    }
+    return Object.freeze(records);
+}
+function retainDescriptor(role, endpoint) {
+    if (endpoint.source?.kind === 'branch') {
+        return Object.freeze({
+            kind: 'branch',
+            role,
+            label: endpoint.label,
+            selectorType: 'branch',
+            oldOid: endpoint.oid,
+            refName: endpoint.source.refName,
+        });
+    }
+    if (endpoint.source?.kind === 'worktree') {
+        return Object.freeze({
+            kind: 'worktree',
+            role,
+            label: endpoint.label,
+            selectorType: 'worktree',
+            oldOid: endpoint.oid,
+            path: endpoint.source.path,
+        });
+    }
+    return undefined;
+}
+function unchanged(role) {
+    return { kind: 'unchanged', role };
+}
+function unavailable(descriptor) {
+    return {
+        kind: 'unavailable',
+        role: descriptor.role,
+        label: descriptor.label,
+        selectorType: descriptor.selectorType,
+        oldOid: descriptor.oldOid,
+        reason: UNAVAILABLE_REASON,
+    };
+}
+function statusForCurrentOid(descriptor, currentOid) {
+    return currentOid === descriptor.oldOid
+        ? unchanged(descriptor.role)
+        : {
+            kind: 'moved',
+            role: descriptor.role,
+            label: descriptor.label,
+            selectorType: descriptor.selectorType,
+            oldOid: descriptor.oldOid,
+            newOid: currentOid,
+        };
+}
+function parseCommitOid(output) {
+    const lines = output
+        .toString('ascii')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length !== 1) {
+        return undefined;
+    }
+    const parsed = GitObjectIdSchema.safeParse(lines[0]);
+    return parsed.success ? parsed.data : undefined;
+}
+export function createSelectorDriftObserver(comparison, options = {}) {
+    const runner = options.runner ?? createGitRunner();
+    const repositoryRoot = comparison.repositoryRoot;
+    const descriptors = Object.freeze({
+        base: retainDescriptor('base', comparison.base),
+        head: retainDescriptor('head', comparison.head),
+    });
+    const listWorktrees = async () => {
+        try {
+            const result = await runner.run(['worktree', 'list', '--porcelain', '-z'], { cwd: repositoryRoot });
+            return parseWorktreeRecords(result.stdout);
+        }
+        catch {
+            return [];
+        }
+    };
+    const observeBranch = async (descriptor) => {
+        try {
+            const result = await runner.run(['rev-parse', '--verify', '--end-of-options', `${descriptor.refName}^{commit}`], { cwd: repositoryRoot });
+            const currentOid = parseCommitOid(result.stdout);
+            return currentOid === undefined ? unavailable(descriptor) : statusForCurrentOid(descriptor, currentOid);
+        }
+        catch {
+            return unavailable(descriptor);
+        }
+    };
+    const observeWorktree = async (descriptor, records) => {
+        const record = records.find((candidate) => candidate.path === descriptor.path && !candidate.prunable && !candidate.bare);
+        if (record === undefined || record.headOid === undefined) {
+            return unavailable(descriptor);
+        }
+        const currentOid = GitObjectIdSchema.safeParse(record.headOid);
+        return currentOid.success ? statusForCurrentOid(descriptor, currentOid.data) : unavailable(descriptor);
+    };
+    const observe = async (descriptor, role, worktreeRecords) => {
+        if (descriptor === undefined) {
+            return unchanged(role);
+        }
+        return descriptor.kind === 'branch'
+            ? await observeBranch(descriptor)
+            : await observeWorktree(descriptor, worktreeRecords ?? []);
+    };
+    return Object.freeze({
+        async observe() {
+            const hasWorktreeDescriptor = descriptors.base?.kind === 'worktree' || descriptors.head?.kind === 'worktree';
+            const worktreeRecords = hasWorktreeDescriptor ? await listWorktrees() : undefined;
+            return SelectorDriftResponseSchema.parse({
+                base: await observe(descriptors.base, 'base', worktreeRecords),
+                head: await observe(descriptors.head, 'head', worktreeRecords),
+            });
+        },
+    });
+}

package/dist/git/standalone-resolution.js

@@ -0,0 +1,174 @@
+import { randomBytes } from 'node:crypto';
+import { createExactPath, decodeBase64url } from '../domain/path-bytes.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+import { createObjectReader } from './objects.js';
+import { createGitRunner, GitRunnerError } from './runner.js';
+import { buildUntrackedChangedFile } from './worktree-inventory.js';
+const newStateDirSegment = RENAME_MAP.repoStateDir.replace(/\/$/, '');
+export class StandaloneResolutionError extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.name = 'StandaloneResolutionError';
+        this.kind = kind;
+    }
+}
+/**
+ * Mirrors `MAX_PATHSPEC_COUNT` (`src/contracts/request.ts:7`), duplicated as
+ * a local literal because this phase is the first caller applying that bound
+ * to CLI argv rather than the agent-protocol JSON contract.
+ */
+const MAX_RAW_STANDALONE_ARGUMENTS = 256;
+/**
+ * Mirrors `MAX_SNAPSHOT_FILES` (`src/server/worktree-snapshot.ts`),
+ * duplicated as a local literal because `src/git/` never depends on
+ * `src/server/`.
+ */
+const MAX_RESOLVED_STANDALONE_FILES = 10_000;
+const standaloneFileIdNamespace = randomBytes(32);
+function parseNulDelimitedPaths(output) {
+    const paths = [];
+    let offset = 0;
+    while (offset < output.length) {
+        const end = output.indexOf(0, offset);
+        if (end === -1) {
+            break;
+        }
+        if (end > offset) {
+            paths.push(createExactPath(output.subarray(offset, end)));
+        }
+        offset = end + 1;
+    }
+    return Object.freeze(paths);
+}
+function parsePorcelainRecords(output) {
+    const records = new Map();
+    let offset = 0;
+    while (offset < output.length) {
+        const end = output.indexOf(0, offset);
+        const segmentEnd = end === -1 ? output.length : end;
+        if (segmentEnd > offset) {
+            const record = output.subarray(offset, segmentEnd).toString('utf8');
+            records.set(record.slice(3), record);
+        }
+        offset = segmentEnd + 1;
+    }
+    return records;
+}
+async function resolveOneArgument(repositoryRoot, argument, runner) {
+    let stdout;
+    try {
+        ({ stdout } = await runner.run(['ls-files', '--cached', '--others', '--exclude-standard', '-z', '--', argument], { cwd: repositoryRoot }));
+    }
+    catch (error) {
+        if (error instanceof GitRunnerError && error.kind === 'exit' && error.exitCode === 128) {
+            throw new StandaloneResolutionError('path-outside-repository', `Argument "${argument}" resolves outside the repository.`);
+        }
+        throw error;
+    }
+    const matches = parseNulDelimitedPaths(stdout);
+    if (matches.length > 0) {
+        return matches;
+    }
+    let ignored;
+    try {
+        await runner.run(['check-ignore', '--quiet', '--', argument], { cwd: repositoryRoot });
+        ignored = true;
+    }
+    catch (error) {
+        // Exit 0 is the only "ignored" signal `check-ignore` gives. Any other
+        // outcome — exit 1 ("not ignored"), or Git's own fatal "pathspec is
+        // beyond a symbolic link" rejection (exit 128) when the argument walks
+        // through a symlinked directory the ls-files probe above already
+        // declined to traverse — all collapse to "not ignored" here.
+        if (error instanceof GitRunnerError && error.kind === 'exit') {
+            ignored = false;
+        }
+        else {
+            throw error;
+        }
+    }
+    if (ignored) {
+        throw new StandaloneResolutionError('pathspec-ignored', `Argument "${argument}" matched only a path excluded via .gitignore; it was not opened.`);
+    }
+    throw new StandaloneResolutionError('pathspec-no-match', `Argument "${argument}" did not match any file.`);
+}
+function rejectReservedSegments(path) {
+    const segments = Buffer.from(decodeBase64url(path.bytesBase64url))
+        .toString('latin1')
+        .split('/');
+    for (const segment of segments) {
+        if (segment === '.git' || segment === '.cumpa' || segment === newStateDirSegment) {
+            throw new Error(`Resolved path "${path.display}" contains a reserved ".git"/".cumpa"/"${newStateDirSegment}" segment and was rejected.`);
+        }
+    }
+}
+export async function resolveStandaloneArguments(repositoryRoot, rawArguments, dependencies = {}, options = {}) {
+    if (rawArguments.length > MAX_RAW_STANDALONE_ARGUMENTS) {
+        throw new Error(`Too many arguments: ${rawArguments.length} exceeds the ${MAX_RAW_STANDALONE_ARGUMENTS}-argument limit.`);
+    }
+    const runner = dependencies.runner ?? createGitRunner();
+    const resolved = new Map();
+    for (const argument of rawArguments) {
+        let matches;
+        try {
+            matches = await resolveOneArgument(repositoryRoot, argument, runner);
+        }
+        catch (error) {
+            // Opt-in drift tolerance for the refresh path (CR-01): a single-file
+            // standalone argument whose only match has since been deleted/moved
+            // should surface as a clean "removed" delta on refresh, matching
+            // every other sourceKind's diff-based enumeration, rather than
+            // crashing the refresh request. The initial CLI launch in
+            // `src/cli/run.ts` never passes `toleratesNoMatch`, so it keeps
+            // rejecting typos/missing files at startup.
+            if (options.toleratesNoMatch === true &&
+                error instanceof Error &&
+                /did not match any file/.test(error.message)) {
+                continue;
+            }
+            throw error;
+        }
+        for (const match of matches) {
+            rejectReservedSegments(match);
+            resolved.set(match.bytesBase64url, match);
+        }
+    }
+    if (resolved.size > MAX_RESOLVED_STANDALONE_FILES) {
+        throw new Error(`Resolved file count ${resolved.size} exceeds the ${MAX_RESOLVED_STANDALONE_FILES}-file limit.`);
+    }
+    return Object.freeze([...resolved.values()]);
+}
+export async function classifyStandaloneGitState(repositoryRoot, resolvedPaths, dependencies = {}) {
+    const states = new Map();
+    if (resolvedPaths.length === 0) {
+        return states;
+    }
+    const runner = dependencies.runner ?? createGitRunner();
+    const pathArguments = resolvedPaths.map((path) => path.utf8 ?? path.display);
+    const { stdout } = await runner.run(['status', '--porcelain=v1', '-z', '--untracked-files=normal', '--', ...pathArguments], { cwd: repositoryRoot });
+    const records = parsePorcelainRecords(stdout);
+    for (const path of resolvedPaths) {
+        const record = records.get(path.utf8 ?? path.display);
+        const state = record === undefined
+            ? 'unchanged'
+            : record.startsWith('??')
+                ? 'untracked'
+                : 'modified-uncommitted';
+        states.set(path.bytesBase64url, state);
+    }
+    return states;
+}
+export async function createStandaloneChangedFileInventory(repositoryRoot, resolvedPaths, gitStates, objectFormat, dependencies = {}) {
+    const runner = dependencies.runner ?? createGitRunner();
+    const objectReader = dependencies.objectReader ?? createObjectReader(repositoryRoot, { runner });
+    const files = await Promise.all(resolvedPaths.map(async (path) => {
+        const file = await buildUntrackedChangedFile(path, objectFormat, standaloneFileIdNamespace, objectReader, repositoryRoot, dependencies.signal);
+        const standaloneGitState = gitStates.get(path.bytesBase64url);
+        if (standaloneGitState === undefined) {
+            throw new RangeError(`Missing Git-state classification for resolved path "${path.display}".`);
+        }
+        return { ...file, standaloneGitState };
+    }));
+    return Object.freeze(files);
+}

package/dist/git/worktree-content.js

@@ -0,0 +1,97 @@
+import { blobOid } from './exact-patch.js';
+import { createGitRunner } from './runner.js';
+const hunkHeaderPattern = /^@@ -(0|[1-9][0-9]*)(?:,(0|[1-9][0-9]*))? \+(0|[1-9][0-9]*)(?:,(0|[1-9][0-9]*))? @@(?: .*)?$/u;
+function fail(path, reason) {
+    throw new Error(`resolveWorktreeSideContent: ${reason} for "${path}"`);
+}
+/**
+ * Walks the single full-context hunk produced by `git diff -U1000000` for one
+ * path and rebuilds the postimage (the side after the invoked comparison —
+ * the worktree file itself for `scope: 'worktree'`) from its context (' ')
+ * and added ('+') lines, exactly mirroring the line-prefix classification in
+ * `exact-patch.ts`'s `applyText` (modeled on it, not calling it: this reads
+ * git's own already-normalized hunk output directly, it does not replay a
+ * submitted patch against a known preimage).
+ *
+ * `-U1000000` always collapses every edited region of a file into exactly
+ * one hunk, so a second `@@` header is a malformed-input signal, not a
+ * second hunk to merge.
+ */
+function reconstructPostimage(stdout, path) {
+    const text = stdout.toString('utf8');
+    const lines = text.length === 0 ? [] : text.split('\n');
+    if (lines.length > 0 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    const output = [];
+    let newCount = 0;
+    let newConsumed = 0;
+    let hunkFound = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const header = hunkHeaderPattern.exec(line);
+        if (header !== null) {
+            if (hunkFound)
+                fail(path, 'a -U1000000 diff produced more than one hunk');
+            hunkFound = true;
+            newCount = Number(header[4] ?? 1);
+            newConsumed = 0;
+            continue;
+        }
+        if (!hunkFound)
+            continue;
+        const prefix = line[0];
+        if (prefix !== ' ' && prefix !== '+' && prefix !== '-') {
+            fail(path, `unrecognized diff hunk line "${line}"`);
+        }
+        const noNewline = lines[index + 1] === '\';
+        if (noNewline)
+            index += 1;
+        if (prefix === ' ' || prefix === '+') {
+            if (newConsumed >= newCount)
+                fail(path, 'hunk reported more postimage lines than its header declared');
+            newConsumed += 1;
+            output.push(`${line.slice(1)}${noNewline ? '' : '\n'}`);
+        }
+    }
+    if (!hunkFound) {
+        fail(path, 'git diff reported no change (resolveWorktreeSideContent must only be called for already-changed files)');
+    }
+    if (newConsumed !== newCount)
+        fail(path, 'hunk postimage line count did not match its header');
+    return Buffer.from(output.join(''), 'utf8');
+}
+/**
+ * Reconstructs the full text of a diff side that crosses the worktree
+ * boundary (Unstaged's worktree side, Working-tree's worktree side for
+ * tracked files) by reading `git diff`'s own full-context patch output
+ * rather than independently `fs.readFile`-ing the worktree file and
+ * comparing it against a differently-normalized object-backed side. Git
+ * already applies `core.autocrlf`/`.gitattributes` text normalization
+ * consistently when it decides what changed and what the patch text looks
+ * like; re-deriving that here would risk silently diverging from `git
+ * diff`'s own notion of "changed".
+ *
+ * Precondition: callers must only invoke this for a path already reported
+ * as changed by the corresponding `git diff --raw`/`--numstat` inventory
+ * call (`createWorktreeChangedFileInventory`). Calling it for a path with no
+ * actual diff is a contract violation, not a case this function recovers
+ * from — it throws, mirroring how `exact-patch.ts`'s `applyText` assumes a
+ * well-formed patch rather than defensively handling a no-op one.
+ */
+export async function resolveWorktreeSideContent(options, dependencies = {}) {
+    const runner = dependencies.runner ?? createGitRunner();
+    const result = await runner.run([
+        'diff',
+        ...(options.scope === 'cached' ? ['--cached'] : []),
+        '-U1000000',
+        '--no-color',
+        '--no-ext-diff',
+        '--no-textconv',
+        ...(options.endpoint === undefined ? [] : [options.endpoint]),
+        '--',
+        options.path,
+    ], { cwd: options.repositoryRoot, signal: options.signal });
+    const bytes = reconstructPostimage(result.stdout, options.path);
+    return Object.freeze({ bytes, blobOid: blobOid(bytes, options.objectFormat) });
+}