@shipwithai/loopnote 0.0.0-stage → 2.0.0

package/dist/git/ignore-status.js

@@ -0,0 +1,23 @@
+import { createGitRunner, GitRunnerError } from './runner.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+const loopnoteIgnoreProbe = `${RENAME_MAP.repoStateDir}.${RENAME_MAP.slug}-ignore-probe`;
+const loopnoteIgnoreArguments = [
+    'check-ignore',
+    '--no-index',
+    '--quiet',
+    '--',
+    loopnoteIgnoreProbe,
+];
+export async function inspectLoopnoteIgnore(options, dependencies = {}) {
+    const runner = dependencies.runner ?? createGitRunner();
+    try {
+        await runner.run(loopnoteIgnoreArguments, { cwd: options.repositoryRoot });
+        return Object.freeze({ kind: 'ignored' });
+    }
+    catch (error) {
+        if (error instanceof GitRunnerError && error.kind === 'exit' && error.exitCode === 1) {
+            return Object.freeze({ kind: 'not-ignored' });
+        }
+        return Object.freeze({ kind: 'unavailable' });
+    }
+}

package/dist/git/inventory.js

@@ -0,0 +1,160 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { ChangedFileSchema } from '../contracts/comparison.js';
+import { decodeBase64url } from '../domain/path-bytes.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+import { classifyAvailability } from './availability.js';
+import { createObjectReader } from './objects.js';
+import { joinDiffStats, parseNumstat } from './numstat.js';
+import { parseRawDiff } from './raw-diff.js';
+import { createGitRunner } from './runner.js';
+const emptyPathspecs = Object.freeze([]);
+const processFileIdNamespace = randomBytes(32);
+const knownModes = Object.freeze({
+    '000000': true,
+    '040000': true,
+    '100644': true,
+    '100755': true,
+    '120000': true,
+    '160000': true,
+});
+const statusKindByCode = Object.freeze({
+    A: 'added',
+    C: 'copied',
+    D: 'deleted',
+    M: 'modified',
+    R: 'renamed',
+    T: 'type-changed',
+});
+const sharedDiffOptions = [
+    '-z',
+    '--find-renames=50%',
+    '--find-copies=50%',
+    '--find-copies-harder',
+    '--no-ext-diff',
+    '--no-textconv',
+];
+const cumpaPath = Buffer.from('.cumpa', 'ascii');
+const cumpaPathPrefix = Buffer.from('.cumpa/', 'ascii');
+const newStateDirPath = Buffer.from(RENAME_MAP.repoStateDir.replace(/\/$/, ''), 'ascii');
+const newStateDirPathPrefix = Buffer.from(RENAME_MAP.repoStateDir, 'ascii');
+export function isLoopnoteInternalPath(path) {
+    if (path === undefined) {
+        return false;
+    }
+    const bytes = decodeBase64url(path.bytesBase64url);
+    if (bytes.byteLength === cumpaPath.byteLength) {
+        if (bytes.every((byte, index) => byte === cumpaPath[index]))
+            return true;
+    }
+    else if (bytes.byteLength >= cumpaPathPrefix.byteLength &&
+        cumpaPathPrefix.every((byte, index) => byte === bytes[index])) {
+        return true;
+    }
+    if (bytes.byteLength === newStateDirPath.byteLength) {
+        return bytes.every((byte, index) => byte === newStateDirPath[index]);
+    }
+    return (bytes.byteLength >= newStateDirPathPrefix.byteLength &&
+        newStateDirPathPrefix.every((byte, index) => byte === bytes[index]));
+}
+export function recordIdentity(record) {
+    return JSON.stringify([
+        record.status,
+        record.similarity,
+        record.oldMode,
+        record.newMode,
+        record.oldBlobOid,
+        record.newBlobOid,
+        ...record.paths.map((path) => path.bytesBase64url),
+    ]);
+}
+export function opaqueFileId(namespace, record) {
+    const digest = createHash('sha256')
+        .update(namespace)
+        .update(Buffer.from([0]))
+        .update(recordIdentity(record), 'ascii')
+        .digest('base64url');
+    return `file_${digest}`;
+}
+export function validateObjectFormat(record, objectFormat) {
+    const expectedLength = objectFormat === 'sha1' ? 40 : 64;
+    if (record.oldBlobOid.length !== expectedLength ||
+        record.newBlobOid.length !== expectedLength) {
+        throw new Error(`Raw diff object ID length does not match repository ${objectFormat} format`);
+    }
+}
+export function inventoryPaths(record) {
+    if (record.paths.length === 2) {
+        return { oldPath: record.paths[0], newPath: record.paths[1] };
+    }
+    const path = record.paths[0];
+    return {
+        ...(record.oldMode === '000000' ? {} : { oldPath: path }),
+        ...(record.newMode === '000000' ? {} : { newPath: path }),
+    };
+}
+export async function createChangedFileInventory(options, dependencies = {}) {
+    const pathspecTail = Object.freeze([
+        '--',
+        ...(options.pathspecs ?? emptyPathspecs),
+    ]);
+    const runner = dependencies.runner ?? createGitRunner();
+    const [rawResult, numstatResult] = await Promise.all([
+        runner.run([
+            'diff',
+            '--raw',
+            sharedDiffOptions[0],
+            '--no-abbrev',
+            ...sharedDiffOptions.slice(1),
+            options.mergeBaseOid,
+            options.headOid,
+            ...pathspecTail,
+        ], { cwd: options.repositoryRoot, signal: options.signal }),
+        runner.run([
+            'diff',
+            '--numstat',
+            ...sharedDiffOptions,
+            options.mergeBaseOid,
+            options.headOid,
+            ...pathspecTail,
+        ], { cwd: options.repositoryRoot, signal: options.signal }),
+    ]);
+    const joined = joinDiffStats(parseRawDiff(rawResult.stdout), parseNumstat(numstatResult.stdout));
+    const reviewable = joined.filter(({ diff }) => {
+        const { oldPath, newPath } = inventoryPaths(diff);
+        return !isLoopnoteInternalPath(oldPath) && !isLoopnoteInternalPath(newPath);
+    });
+    const namespace = options.fileIdNamespace ?? processFileIdNamespace;
+    if (namespace.byteLength === 0) {
+        throw new RangeError('File ID namespace must not be empty');
+    }
+    const objectReader = dependencies.objectReader ??
+        createObjectReader(options.repositoryRoot, { runner });
+    const files = await Promise.all(reviewable.map(async ({ diff, stats }) => {
+        validateObjectFormat(diff, options.objectFormat);
+        const knownStatus = statusKindByCode[diff.status];
+        const hasUnsupportedMetadata = knownStatus === undefined ||
+            knownModes[diff.oldMode] !== true ||
+            knownModes[diff.newMode] !== true;
+        const statusKind = hasUnsupportedMetadata
+            ? 'unsupported'
+            : knownStatus;
+        const file = {
+            id: opaqueFileId(namespace, diff),
+            status: {
+                code: diff.status,
+                kind: statusKind,
+                similarity: diff.similarity,
+            },
+            oldMode: diff.oldMode,
+            newMode: diff.newMode,
+            oldBlobOid: diff.oldBlobOid,
+            newBlobOid: diff.newBlobOid,
+            ...inventoryPaths(diff),
+            additions: stats.additions,
+            deletions: stats.deletions,
+        };
+        const availability = await classifyAvailability(file, objectReader, options.signal);
+        return ChangedFileSchema.parse({ ...file, availability });
+    }));
+    return Object.freeze(files);
+}

package/dist/git/numstat.js

@@ -0,0 +1,111 @@
+import { createExactPath } from '../domain/path-bytes.js';
+function malformedNumstat(message) {
+    return new Error(`Malformed numstat: ${message}`);
+}
+function readNulField(output, offset) {
+    const end = output.indexOf(0, offset);
+    if (end === -1) {
+        throw malformedNumstat('record is not NUL terminated');
+    }
+    return {
+        field: output.subarray(offset, end),
+        nextOffset: end + 1,
+    };
+}
+function parseCount(value) {
+    if (value.length === 1 && value[0] === 0x2d) {
+        return null;
+    }
+    const text = value.toString('ascii');
+    if (!/^(?:0|[1-9][0-9]*)$/.test(text)) {
+        throw malformedNumstat('count is neither a decimal integer nor -');
+    }
+    const count = Number.parseInt(text, 10);
+    if (!Number.isSafeInteger(count)) {
+        throw malformedNumstat('count exceeds the safe integer range');
+    }
+    return count;
+}
+function pathIdentity(paths) {
+    return JSON.stringify(paths.map((path) => path.bytesBase64url));
+}
+export function parseNumstat(output) {
+    if (output.length === 0) {
+        return Object.freeze([]);
+    }
+    if (output[output.length - 1] !== 0) {
+        throw malformedNumstat('output is not NUL terminated');
+    }
+    const records = [];
+    let offset = 0;
+    while (offset < output.length) {
+        const recordField = readNulField(output, offset);
+        offset = recordField.nextOffset;
+        const firstTab = recordField.field.indexOf(0x09);
+        const secondTab = firstTab === -1 ? -1 : recordField.field.indexOf(0x09, firstTab + 1);
+        if (firstTab <= 0 || secondTab <= firstTab + 1) {
+            throw malformedNumstat('record is missing count separators');
+        }
+        const additions = parseCount(recordField.field.subarray(0, firstTab));
+        const deletions = parseCount(recordField.field.subarray(firstTab + 1, secondTab));
+        if ((additions === null) !== (deletions === null)) {
+            throw malformedNumstat('binary counts must both be -');
+        }
+        const pathBytes = recordField.field.subarray(secondTab + 1);
+        let paths;
+        if (pathBytes.length > 0) {
+            paths = Object.freeze([createExactPath(pathBytes)]);
+        }
+        else {
+            if (offset >= output.length) {
+                throw malformedNumstat('rename/copy record is missing its source path');
+            }
+            const oldPathField = readNulField(output, offset);
+            offset = oldPathField.nextOffset;
+            if (offset >= output.length) {
+                throw malformedNumstat('rename/copy record is missing its destination path');
+            }
+            const newPathField = readNulField(output, offset);
+            offset = newPathField.nextOffset;
+            if (oldPathField.field.length === 0 || newPathField.field.length === 0) {
+                throw malformedNumstat('rename/copy path is empty');
+            }
+            paths = Object.freeze([
+                createExactPath(oldPathField.field),
+                createExactPath(newPathField.field),
+            ]);
+        }
+        records.push(Object.freeze({ additions, deletions, paths }));
+    }
+    return Object.freeze(records);
+}
+export function joinDiffStats(diffRecords, statRecords) {
+    const statByIdentity = new Map();
+    for (const stats of statRecords) {
+        const identity = pathIdentity(stats.paths);
+        if (statByIdentity.has(identity)) {
+            throw new Error(`Duplicate numstat identity: ${identity}`);
+        }
+        statByIdentity.set(identity, stats);
+    }
+    const seenDiffIdentities = new Set();
+    const joined = [];
+    for (const diff of diffRecords) {
+        const identity = pathIdentity(diff.paths);
+        if (seenDiffIdentities.has(identity)) {
+            throw new Error(`Duplicate raw diff identity: ${identity}`);
+        }
+        seenDiffIdentities.add(identity);
+        const stats = statByIdentity.get(identity);
+        if (stats === undefined) {
+            throw new Error(`Missing numstat record for raw diff identity: ${identity}`);
+        }
+        joined.push(Object.freeze({ diff, stats }));
+    }
+    for (const identity of statByIdentity.keys()) {
+        if (!seenDiffIdentities.has(identity)) {
+            throw new Error(`Numstat record has no raw diff match: ${identity}`);
+        }
+    }
+    return Object.freeze(joined);
+}

package/dist/git/objects.js

@@ -0,0 +1,95 @@
+import { createGitRunner } from './runner.js';
+const BATCH_HEADER_LIMIT = 256;
+const objectIdPattern = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+function validateObjectId(oid) {
+    if (!objectIdPattern.test(oid)) {
+        throw new TypeError('Git object reads require one full lowercase hexadecimal object ID');
+    }
+}
+function parseBatchHeader(stdout, requestedOid) {
+    const terminator = stdout.indexOf(0);
+    if (terminator < 0 || terminator >= BATCH_HEADER_LIMIT) {
+        throw new Error('Git cat-file returned an invalid or oversized batch header');
+    }
+    const header = stdout.toString('ascii', 0, terminator);
+    if (header === `${requestedOid} missing`) {
+        return Object.freeze({ kind: 'missing', contentOffset: terminator + 1 });
+    }
+    const fields = header.split(' ');
+    if (fields.length !== 3 ||
+        fields[0] !== requestedOid ||
+        fields[1] === undefined ||
+        fields[1].length === 0 ||
+        fields[2] === undefined ||
+        !/^(?:0|[1-9][0-9]*)$/.test(fields[2])) {
+        throw new Error('Git cat-file returned malformed object metadata');
+    }
+    const size = Number(fields[2]);
+    if (!Number.isSafeInteger(size)) {
+        throw new Error('Git cat-file reported an unsafe object size');
+    }
+    return Object.freeze({
+        kind: 'available',
+        contentOffset: terminator + 1,
+        objectType: fields[1],
+        size,
+    });
+}
+export function createObjectReader(repositoryRoot, dependencies = {}) {
+    const runner = dependencies.runner ?? createGitRunner();
+    return Object.freeze({
+        async inspect(oid, signal) {
+            validateObjectId(oid);
+            const result = await runner.run(['cat-file', '--batch-command', '-Z'], {
+                cwd: repositoryRoot,
+                input: Buffer.from(`info ${oid}\0`, 'ascii'),
+                maxStdoutBytes: BATCH_HEADER_LIMIT,
+                signal,
+            });
+            const header = parseBatchHeader(result.stdout, oid);
+            if (header.contentOffset !== result.stdout.byteLength) {
+                throw new Error('Git cat-file returned trailing bytes for object metadata');
+            }
+            return header.kind === 'missing'
+                ? Object.freeze({ kind: 'missing' })
+                : Object.freeze({
+                    kind: 'available',
+                    objectType: header.objectType,
+                    size: header.size,
+                });
+        },
+        async read(oid, options) {
+            validateObjectId(oid);
+            if (!Number.isSafeInteger(options.maxBytes) ||
+                options.maxBytes < 0 ||
+                options.maxBytes > Number.MAX_SAFE_INTEGER - BATCH_HEADER_LIMIT) {
+                throw new RangeError('Object read limit must be a non-negative safe integer');
+            }
+            const result = await runner.run(['cat-file', '--batch-command', '-Z'], {
+                cwd: repositoryRoot,
+                input: Buffer.from(`contents ${oid}\0`, 'ascii'),
+                maxStdoutBytes: options.maxBytes + BATCH_HEADER_LIMIT,
+                signal: options.signal,
+            });
+            const header = parseBatchHeader(result.stdout, oid);
+            if (header.kind === 'missing') {
+                if (header.contentOffset !== result.stdout.byteLength) {
+                    throw new Error('Git cat-file returned trailing bytes for a missing object');
+                }
+                return Object.freeze({ kind: 'missing' });
+            }
+            if (header.size > options.maxBytes) {
+                throw new Error('Git cat-file object exceeds the bounded read limit');
+            }
+            const contentEnd = header.contentOffset + header.size;
+            if (result.stdout.byteLength !== contentEnd + 1 ||
+                result.stdout[contentEnd] !== 0) {
+                throw new Error('Git cat-file returned malformed object content framing');
+            }
+            return Object.freeze({
+                kind: 'available',
+                bytes: result.stdout.subarray(header.contentOffset, contentEnd),
+            });
+        },
+    });
+}

package/dist/git/raw-diff.js

@@ -0,0 +1,84 @@
+import { createExactPath } from '../domain/path-bytes.js';
+function malformedRawDiff(message) {
+    return new Error(`Malformed raw diff: ${message}`);
+}
+function readNulField(output, offset) {
+    const end = output.indexOf(0, offset);
+    if (end === -1) {
+        throw malformedRawDiff('record is not NUL terminated');
+    }
+    return {
+        field: output.subarray(offset, end),
+        nextOffset: end + 1,
+    };
+}
+export function parseRawDiff(output) {
+    if (output.length === 0) {
+        return Object.freeze([]);
+    }
+    if (output[output.length - 1] !== 0) {
+        throw malformedRawDiff('output is not NUL terminated');
+    }
+    const records = [];
+    let offset = 0;
+    while (offset < output.length) {
+        const headerField = readNulField(output, offset);
+        offset = headerField.nextOffset;
+        const header = headerField.field.toString('ascii');
+        const match = /^:([0-7]{6}) ([0-7]{6}) ((?:[0-9a-f]{40}|[0-9a-f]{64})) ((?:[0-9a-f]{40}|[0-9a-f]{64})) ([A-Z])([0-9]{1,3})?$/.exec(header);
+        if (match === null) {
+            throw malformedRawDiff('invalid raw record header');
+        }
+        const [, oldMode, newMode, oldBlobOid, newBlobOid, status, similarityText,] = match;
+        if (oldBlobOid.length !== newBlobOid.length) {
+            throw malformedRawDiff('object IDs use different formats');
+        }
+        const hasPair = status === 'R' || status === 'C';
+        if (hasPair !== (similarityText !== undefined)) {
+            throw malformedRawDiff(hasPair
+                ? 'rename/copy record is missing similarity'
+                : 'non-rename/copy record includes similarity');
+        }
+        const similarity = similarityText === undefined ? null : Number.parseInt(similarityText, 10);
+        if (similarity !== null && similarity > 100) {
+            throw malformedRawDiff('similarity is outside 0-100');
+        }
+        if (offset >= output.length) {
+            throw malformedRawDiff('record is missing its path');
+        }
+        const firstPathField = readNulField(output, offset);
+        offset = firstPathField.nextOffset;
+        if (firstPathField.field.length === 0) {
+            throw malformedRawDiff('path is empty');
+        }
+        const firstPath = createExactPath(firstPathField.field);
+        let paths;
+        if (hasPair) {
+            if (offset >= output.length) {
+                throw malformedRawDiff('rename/copy record is missing its destination path');
+            }
+            const secondPathField = readNulField(output, offset);
+            offset = secondPathField.nextOffset;
+            if (secondPathField.field.length === 0) {
+                throw malformedRawDiff('destination path is empty');
+            }
+            paths = Object.freeze([
+                firstPath,
+                createExactPath(secondPathField.field),
+            ]);
+        }
+        else {
+            paths = Object.freeze([firstPath]);
+        }
+        records.push(Object.freeze({
+            oldMode: oldMode,
+            newMode: newMode,
+            oldBlobOid: oldBlobOid,
+            newBlobOid: newBlobOid,
+            status: status,
+            similarity,
+            paths,
+        }));
+    }
+    return Object.freeze(records);
+}

package/dist/git/repository.js

@@ -0,0 +1,144 @@
+import { realpath } from 'node:fs/promises';
+import { FATAL_LAUNCH_MESSAGES, LaunchError, } from '../domain/errors.js';
+import { GitRunnerError } from './runner.js';
+const MINIMUM_GIT_VERSION = Object.freeze({
+    major: 2,
+    minor: 43,
+    patch: 0,
+});
+function singleLine(buffer, fact) {
+    const value = buffer.toString('utf8').trim();
+    if (value.length === 0 || value.includes('\n') || value.includes('\0')) {
+        throw new Error(`Git returned an invalid ${fact}`);
+    }
+    return value;
+}
+function versionIsSupported(versionOutput) {
+    const match = /^git version (\d+)\.(\d+)\.(\d+)(?:\s|$)/u.exec(singleLine(versionOutput, 'version'));
+    if (match === null) {
+        return false;
+    }
+    const [major, minor, patch] = match.slice(1).map(Number);
+    return (major > MINIMUM_GIT_VERSION.major ||
+        (major === MINIMUM_GIT_VERSION.major &&
+            (minor > MINIMUM_GIT_VERSION.minor ||
+                (minor === MINIMUM_GIT_VERSION.minor &&
+                    patch >= MINIMUM_GIT_VERSION.patch))));
+}
+async function requireSupportedGit(cwd, runner, signal) {
+    try {
+        const version = await runner.run(['--version'], { cwd, signal });
+        if (!versionIsSupported(version.stdout)) {
+            throw new LaunchError('git-unsupported', FATAL_LAUNCH_MESSAGES.gitUnsupported, { recovery: { kind: 'exit' } });
+        }
+    }
+    catch (error) {
+        if (error instanceof LaunchError) {
+            throw error;
+        }
+        if (error instanceof GitRunnerError && error.kind === 'spawn') {
+            throw new LaunchError('git-missing', FATAL_LAUNCH_MESSAGES.gitMissing, {
+                cause: error,
+                recovery: { kind: 'exit' },
+            });
+        }
+        if (signal?.aborted) {
+            throw error;
+        }
+        throw new LaunchError('git-unsupported', FATAL_LAUNCH_MESSAGES.gitUnsupported, { cause: error, recovery: { kind: 'exit' } });
+    }
+}
+async function probeMachineProtocols(repositoryRoot, headOid, runner, signal) {
+    const commands = [
+        ['worktree', 'list', '--porcelain', '-z'],
+        ['for-each-ref', '--count=1', '--format=%(refname)%00', 'refs/heads'],
+        ['merge-base', '--all', headOid, headOid],
+        [
+            'diff',
+            '--raw',
+            '-z',
+            '--no-abbrev',
+            '--no-ext-diff',
+            '--no-textconv',
+            headOid,
+            headOid,
+            '--',
+        ],
+        [
+            'diff',
+            '--numstat',
+            '-z',
+            '--no-ext-diff',
+            '--no-textconv',
+            headOid,
+            headOid,
+            '--',
+        ],
+        ['cat-file', '--batch-command', '-Z'],
+    ];
+    try {
+        for (const arguments_ of commands) {
+            await runner.run(arguments_, { cwd: repositoryRoot, signal });
+        }
+    }
+    catch (error) {
+        if (signal?.aborted) {
+            throw error;
+        }
+        throw new LaunchError('git-unsupported', FATAL_LAUNCH_MESSAGES.gitUnsupported, { cause: error, recovery: { kind: 'exit' } });
+    }
+}
+export async function discoverGitRepository(cwd, runner, signal) {
+    await requireSupportedGit(cwd, runner, signal);
+    let topLevelResult;
+    try {
+        topLevelResult = await runner.run(['rev-parse', '--path-format=absolute', '--show-toplevel'], { cwd, signal });
+    }
+    catch (topLevelError) {
+        if (signal?.aborted) {
+            throw topLevelError;
+        }
+        try {
+            const bare = await runner.run(['rev-parse', '--is-bare-repository'], {
+                cwd,
+                signal,
+            });
+            if (singleLine(bare.stdout, 'bare-repository state') === 'true') {
+                throw new LaunchError('bare-repository', FATAL_LAUNCH_MESSAGES.bareRepository, { cause: topLevelError, recovery: { kind: 'exit' } });
+            }
+        }
+        catch (bareError) {
+            if (bareError instanceof LaunchError || signal?.aborted) {
+                throw bareError;
+            }
+        }
+        throw new LaunchError('not-worktree', FATAL_LAUNCH_MESSAGES.notWorktree, { cause: topLevelError, recovery: { kind: 'exit' } });
+    }
+    let root;
+    try {
+        root = await realpath(singleLine(topLevelResult.stdout, 'worktree root'));
+    }
+    catch (error) {
+        throw new LaunchError('not-worktree', FATAL_LAUNCH_MESSAGES.notWorktree, { cause: error, recovery: { kind: 'exit' } });
+    }
+    const bareResult = await runner.run(['rev-parse', '--is-bare-repository'], {
+        cwd: root,
+        signal,
+    });
+    if (singleLine(bareResult.stdout, 'bare-repository state') !== 'false') {
+        throw new LaunchError('bare-repository', FATAL_LAUNCH_MESSAGES.bareRepository, { recovery: { kind: 'exit' } });
+    }
+    let headOid;
+    try {
+        const head = await runner.run(['rev-parse', '--verify', '--end-of-options', 'HEAD^{commit}'], { cwd: root, signal });
+        headOid = singleLine(head.stdout, 'HEAD commit');
+    }
+    catch (error) {
+        if (signal?.aborted) {
+            throw error;
+        }
+        throw new LaunchError('empty-repository', FATAL_LAUNCH_MESSAGES.emptyRepository, { cause: error, recovery: { kind: 'exit' } });
+    }
+    await probeMachineProtocols(root, headOid, runner, signal);
+    return Object.freeze({ root, headOid });
+}