@shipwithai/loopnote 0.0.0-stage → 2.0.0

package/dist/server/draft-loader.js

@@ -0,0 +1,134 @@
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import { join } from 'node:path';
+import { CURRENT_DRAFT_SCHEMA_VERSION, DraftVersionEnvelopeSchema, ReviewDraftV1Schema, } from '../contracts/draft.js';
+import { comparisonKey } from '../domain/comparison-key.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+const draftsDirectory = `${RENAME_MAP.repoStateDir}drafts`;
+const strictUtf8 = new TextDecoder('utf-8', { fatal: true });
+export function assertAttachedStorageScope(storageScope) {
+    if (!/^agent-[0-9a-f]{32}$/u.test(storageScope)) {
+        throw new Error('Attached storage scope is invalid.');
+    }
+    return storageScope;
+}
+function isMissing(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+function bounded(value) {
+    if (value.length <= 160) {
+        return value;
+    }
+    return `${value.slice(0, 157)}...`;
+}
+function fingerprint(raw) {
+    return createHash('sha256').update(raw).digest('hex');
+}
+function sameComparison(left, right) {
+    if (('kind' in left && left.kind === 'exact-patch') || ('kind' in right && right.kind === 'exact-patch')) {
+        return ('kind' in left &&
+            'kind' in right &&
+            left.kind === 'exact-patch' &&
+            right.kind === 'exact-patch' &&
+            left.digest === right.digest &&
+            left.validationTarget.kind === right.validationTarget.kind &&
+            left.reviewKey === right.reviewKey);
+    }
+    if (('kind' in left && left.kind === 'uncommitted') || ('kind' in right && right.kind === 'uncommitted')) {
+        return ('kind' in left &&
+            'kind' in right &&
+            left.kind === 'uncommitted' &&
+            right.kind === 'uncommitted' &&
+            left.sourceKind === right.sourceKind &&
+            left.baseCommitOid === right.baseCommitOid &&
+            left.reviewKey === right.reviewKey);
+    }
+    if (left.baseCommitOid !== right.baseCommitOid ||
+        left.headCommitOid !== right.headCommitOid ||
+        left.mergeBaseOid !== right.mergeBaseOid) {
+        return false;
+    }
+    if (left.range === undefined || right.range === undefined) {
+        return left.range === right.range;
+    }
+    return (left.range.requestedBase === right.range.requestedBase &&
+        left.range.requestedHead === right.range.requestedHead &&
+        left.range.baseOid === right.range.baseOid &&
+        left.range.headOid === right.range.headOid &&
+        left.range.reviewKey === right.range.reviewKey &&
+        left.range.pathspecs.length === right.range.pathspecs.length &&
+        left.range.pathspecs.every((pathspec, index) => pathspec === right.range?.pathspecs[index]));
+}
+function invalidState(path, raw, details) {
+    return Object.freeze({
+        kind: 'schemaInvalid',
+        path,
+        raw,
+        fingerprint: fingerprint(raw),
+        details: Object.freeze(details.slice(0, 8)),
+    });
+}
+export function draftPaths(repositoryRoot, comparison, storageScope) {
+    const key = storageScope === undefined
+        ? ('kind' in comparison
+            ? comparison.reviewKey
+            : comparison.range?.reviewKey ?? comparisonKey(comparison.baseCommitOid, comparison.headCommitOid))
+        : assertAttachedStorageScope(storageScope);
+    const relativePath = `${draftsDirectory}/${key}.json`;
+    const directory = join(repositoryRoot, draftsDirectory);
+    return Object.freeze({ key, directory, canonicalPath: join(repositoryRoot, relativePath), relativePath });
+}
+export function classifyDraft(raw, path, comparison) {
+    let value;
+    try {
+        value = JSON.parse(strictUtf8.decode(raw));
+    }
+    catch {
+        return Object.freeze({
+            kind: 'malformed',
+            path,
+            raw,
+            fingerprint: fingerprint(raw),
+            detail: Object.freeze({ message: 'Draft is not valid UTF-8 JSON.' }),
+        });
+    }
+    const envelope = DraftVersionEnvelopeSchema.safeParse(value);
+    if (!envelope.success) {
+        return invalidState(path, raw, envelope.error.issues.map((issue) => Object.freeze({ path: bounded(issue.path.join('.')), message: bounded(issue.message) })));
+    }
+    if (envelope.data.schemaVersion > CURRENT_DRAFT_SCHEMA_VERSION) {
+        return Object.freeze({
+            kind: 'newerUnsupported',
+            path,
+            raw,
+            foundVersion: envelope.data.schemaVersion,
+            supportedVersion: CURRENT_DRAFT_SCHEMA_VERSION,
+        });
+    }
+    const parsed = ReviewDraftV1Schema.safeParse(value);
+    if (!parsed.success) {
+        return invalidState(path, raw, parsed.error.issues.map((issue) => Object.freeze({ path: bounded(issue.path.join('.')), message: bounded(issue.message) })));
+    }
+    if (!sameComparison(parsed.data.comparison, comparison)) {
+        return invalidState(path, raw, [Object.freeze({ path: 'comparison', message: 'Draft comparison does not match this session.' })]);
+    }
+    return Object.freeze({ kind: 'current', path, raw, draft: parsed.data });
+}
+export function createDraftLoader(options) {
+    const paths = draftPaths(options.repositoryRoot, options.comparison, options.storageScope);
+    const fileSystem = options.fileSystem ?? { readFile: async (path) => fs.readFile(path) };
+    return Object.freeze({
+        paths,
+        async load() {
+            try {
+                return classifyDraft(await fileSystem.readFile(paths.canonicalPath), paths.relativePath, options.comparison);
+            }
+            catch (error) {
+                if (isMissing(error)) {
+                    return Object.freeze({ kind: 'missing', path: paths.relativePath });
+                }
+                throw error;
+            }
+        },
+    });
+}

package/dist/server/draft-recovery.js

@@ -0,0 +1,5 @@
+export function createDraftRecovery(draftStore) {
+    return Object.freeze({
+        recover: async (input) => draftStore.recover(input),
+    });
+}

package/dist/server/draft-store.js

@@ -0,0 +1,380 @@
+import { randomUUID } from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { CURRENT_DRAFT_SCHEMA_VERSION, DraftMutationSchema, ReviewDraftV1Schema, RevisionSchema, } from '../contracts/draft.js';
+import { applyDraftMutation } from '../draft/mutate-draft.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+import { createDraftLoader } from './draft-loader.js';
+export class DraftStoreError extends Error {
+}
+const queues = new Map();
+const nodeFileSystem = {
+    readFile: async (path) => fs.readFile(path),
+    mkdir: async (path) => {
+        await fs.mkdir(path, { recursive: true });
+    },
+    open: async (path, flags, mode) => {
+        const handle = await fs.open(path, flags, mode);
+        return {
+            writeFile: async (bytes) => handle.writeFile(bytes),
+            sync: async () => handle.sync(),
+            close: async () => handle.close(),
+        };
+    },
+    rename: async (from, to) => fs.rename(from, to),
+    unlink: async (path) => fs.unlink(path),
+    syncDirectory: async (path) => {
+        const handle = await fs.open(path, 'r');
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    },
+};
+function hasCode(error, code) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
+}
+function isUnsupportedDirectorySync(error) {
+    return hasCode(error, 'EINVAL') || hasCode(error, 'ENOTSUP') || hasCode(error, 'EISDIR');
+}
+function initialDraft(comparison) {
+    return ReviewDraftV1Schema.parse({
+        schemaVersion: CURRENT_DRAFT_SCHEMA_VERSION,
+        comparison,
+        revision: 0,
+        summary: '',
+        comments: [],
+    });
+}
+async function runSerialized(key, operation) {
+    const prior = queues.get(key) ?? Promise.resolve();
+    const current = prior.catch(() => undefined).then(operation);
+    queues.set(key, current);
+    try {
+        return await current;
+    }
+    finally {
+        if (queues.get(key) === current) {
+            queues.delete(key);
+        }
+    }
+}
+export function createDraftStore(options) {
+    const fileSystem = options.fileSystem ?? nodeFileSystem;
+    const loader = createDraftLoader({
+        repositoryRoot: options.repositoryRoot,
+        comparison: options.comparison,
+        ...(options.storageScope === undefined ? {} : { storageScope: options.storageScope }),
+        fileSystem,
+    });
+    const { canonicalPath, directory, key, relativePath } = loader.paths;
+    const queueKey = `${options.repositoryRoot}\u0000${key}`;
+    const commit = async (draft) => {
+        const bytes = Buffer.from(`${JSON.stringify(ReviewDraftV1Schema.parse(draft))}\n`, 'utf8');
+        const temporaryPath = join(directory, `.${key}.${randomUUID()}.tmp`);
+        let handle;
+        let renamed = false;
+        try {
+            await fileSystem.mkdir(directory);
+            handle = await fileSystem.open(temporaryPath, 'wx', 0o600);
+            await handle.writeFile(bytes);
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await fileSystem.rename(temporaryPath, canonicalPath);
+            renamed = true;
+            try {
+                await fileSystem.syncDirectory(dirname(canonicalPath));
+            }
+            catch (error) {
+                if (!isUnsupportedDirectorySync(error)) {
+                    throw error;
+                }
+            }
+        }
+        catch {
+            if (handle !== undefined) {
+                try {
+                    await handle.close();
+                }
+                catch {
+                    // Canonical bytes are untouched until rename succeeds.
+                }
+            }
+            if (!renamed) {
+                try {
+                    await fileSystem.unlink(temporaryPath);
+                }
+                catch {
+                    // A cleanup failure cannot justify touching canonical bytes.
+                }
+            }
+            throw new DraftStoreError('Draft persistence failed.');
+        }
+    };
+    const backupRaw = async (raw, expectedFingerprint) => {
+        await fileSystem.mkdir(directory);
+        for (let suffix = 0;; suffix += 1) {
+            const name = suffix === 0
+                ? `${key}.corrupt.${expectedFingerprint}.bak`
+                : `${key}.corrupt.${expectedFingerprint}.${suffix}.bak`;
+            const absolutePath = join(directory, name);
+            let handle;
+            let created = false;
+            try {
+                handle = await fileSystem.open(absolutePath, 'wx', 0o600);
+                created = true;
+                await handle.writeFile(raw);
+                await handle.sync();
+                await handle.close();
+                handle = undefined;
+                try {
+                    await fileSystem.syncDirectory(directory);
+                }
+                catch (error) {
+                    if (!isUnsupportedDirectorySync(error)) {
+                        throw error;
+                    }
+                }
+                const verified = await fileSystem.readFile(absolutePath);
+                if (verified.length !== raw.length || !verified.equals(raw)) {
+                    throw new DraftStoreError('Draft backup verification failed.');
+                }
+                return `${relativePath.slice(0, -'.json'.length)}.corrupt.${expectedFingerprint}${suffix === 0 ? '' : `.${suffix}`}.bak`;
+            }
+            catch (error) {
+                if (handle !== undefined) {
+                    try {
+                        await handle.close();
+                    }
+                    catch {
+                        // The exclusively-created candidate must not be treated as a backup after an incomplete close.
+                    }
+                }
+                if (hasCode(error, 'EEXIST')) {
+                    try {
+                        const existing = await fileSystem.readFile(absolutePath);
+                        if (existing.length === raw.length && existing.equals(raw)) {
+                            return `${relativePath.slice(0, -'.json'.length)}.corrupt.${expectedFingerprint}${suffix === 0 ? '' : `.${suffix}`}.bak`;
+                        }
+                    }
+                    catch {
+                        // Never overwrite an existing backup whose bytes cannot be proven identical.
+                    }
+                    continue;
+                }
+                if (created) {
+                    try {
+                        await fileSystem.unlink(absolutePath);
+                    }
+                    catch {
+                        // Failed candidate cleanup does not affect the canonical draft.
+                    }
+                }
+                throw error;
+            }
+        }
+    };
+    return Object.freeze({
+        canonicalPath,
+        async load() {
+            const load = await loader.load();
+            if (load.kind === 'missing') {
+                return initialDraft(options.comparison);
+            }
+            if (load.kind === 'current') {
+                return load.draft;
+            }
+            throw new DraftStoreError('Existing draft cannot be used for this comparison.');
+        },
+        loadState: async () => loader.load(),
+        async settle(expectedRevision, operation) {
+            return runSerialized(queueKey, async () => {
+                const expected = RevisionSchema.parse(expectedRevision);
+                let initial;
+                try {
+                    initial = await loader.load();
+                }
+                catch {
+                    return Object.freeze({ kind: 'persistenceFailure' });
+                }
+                if (initial.kind === 'malformed' || initial.kind === 'schemaInvalid' || initial.kind === 'newerUnsupported') {
+                    return Object.freeze({ kind: 'readOnly', load: initial });
+                }
+                const draft = initial.kind === 'missing' ? initialDraft(options.comparison) : initial.draft;
+                if (draft.revision !== expected) {
+                    return Object.freeze({ kind: 'revisionConflict', expectedRevision: expected, actualRevision: draft.revision });
+                }
+                let prepared;
+                try {
+                    prepared = await operation.prepare(structuredClone(draft));
+                }
+                catch {
+                    return Object.freeze({ kind: 'persistenceFailure' });
+                }
+                let final;
+                try {
+                    final = await loader.load();
+                }
+                catch {
+                    return Object.freeze({ kind: 'persistenceFailure' });
+                }
+                if (final.kind !== initial.kind
+                    || (final.kind === 'current' && initial.kind === 'current' && !final.raw.equals(initial.raw))) {
+                    return Object.freeze({ kind: 'draftChanged', actualRevision: final.kind === 'current' ? final.draft.revision : 0 });
+                }
+                if (final.kind !== 'missing' && final.kind !== 'current') {
+                    return Object.freeze({ kind: 'readOnly', load: final });
+                }
+                try {
+                    return Object.freeze({
+                        kind: 'accepted',
+                        value: await operation.finalize({ draft: structuredClone(draft), prepared }),
+                    });
+                }
+                catch {
+                    return Object.freeze({ kind: 'persistenceFailure' });
+                }
+            });
+        },
+        async mutate(input) {
+            return runSerialized(queueKey, async () => {
+                const expectedRevision = RevisionSchema.parse(input.expectedRevision);
+                const load = await loader.load();
+                if (load.kind === 'malformed' || load.kind === 'schemaInvalid' || load.kind === 'newerUnsupported') {
+                    return Object.freeze({ kind: 'readOnly', load });
+                }
+                const current = load.kind === 'missing' ? initialDraft(options.comparison) : load.draft;
+                if (expectedRevision !== current.revision) {
+                    return Object.freeze({
+                        kind: 'revisionConflict',
+                        expectedRevision,
+                        actualRevision: current.revision,
+                        latest: current,
+                    });
+                }
+                const mutation = DraftMutationSchema.parse(input.mutation.type === 'addComment'
+                    ? { ...input.mutation, commentId: `comment_${randomUUID()}` }
+                    : input.mutation);
+                const applied = applyDraftMutation(current, mutation, new Date().toISOString());
+                if (applied.kind !== 'applied') {
+                    return applied;
+                }
+                const next = ReviewDraftV1Schema.parse({ ...applied.draft, revision: current.revision + 1 });
+                try {
+                    await commit(next);
+                }
+                catch {
+                    return Object.freeze({ kind: 'persistenceFailure' });
+                }
+                return Object.freeze({ kind: 'accepted', draft: next });
+            });
+        },
+        async recover(input) {
+            return runSerialized(queueKey, async () => {
+                let load;
+                try {
+                    load = await loader.load();
+                }
+                catch {
+                    return Object.freeze({ kind: 'persistenceFailure' });
+                }
+                if (load.kind !== 'malformed' && load.kind !== 'schemaInvalid') {
+                    return Object.freeze({ kind: 'recoveryUnavailable', load });
+                }
+                if (load.fingerprint !== input.expectedFingerprint) {
+                    return Object.freeze({ kind: 'fingerprintChanged' });
+                }
+                let backupPath;
+                try {
+                    backupPath = await backupRaw(load.raw, load.fingerprint);
+                }
+                catch {
+                    return Object.freeze({ kind: 'persistenceFailure' });
+                }
+                const draft = initialDraft(options.comparison);
+                try {
+                    await commit(draft);
+                }
+                catch {
+                    // A post-rename directory sync can report failure after the replacement is visible.
+                    // Do not claim a failed recovery while leaving callers to retry against new canonical bytes.
+                    let visible;
+                    try {
+                        visible = await loader.load();
+                    }
+                    catch {
+                        return Object.freeze({ kind: 'persistenceFailure' });
+                    }
+                    if (visible.kind !== 'current') {
+                        return Object.freeze({ kind: 'persistenceFailure' });
+                    }
+                }
+                return Object.freeze({ kind: 'recovered', backupPath, draft });
+            });
+        },
+    });
+}
+export async function findUncommittedDraftCandidate(repositoryRoot, sourceKind, baseCommitOid) {
+    const directory = join(repositoryRoot, RENAME_MAP.repoStateDir.replace(/\/$/, ''), 'drafts');
+    let entries;
+    try {
+        entries = await fs.readdir(directory);
+    }
+    catch {
+        return undefined;
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const candidatePath = join(directory, entry);
+        try {
+            const parsed = JSON.parse(await fs.readFile(candidatePath, 'utf8'));
+            if (typeof parsed !== 'object' || parsed === null || !('comparison' in parsed))
+                continue;
+            const comparison = parsed.comparison;
+            if (typeof comparison !== 'object' || comparison === null)
+                continue;
+            if (!('kind' in comparison) || comparison.kind !== 'uncommitted')
+                continue;
+            if (!('sourceKind' in comparison) || comparison.sourceKind !== sourceKind)
+                continue;
+            const storedBaseCommitOid = 'baseCommitOid' in comparison ? comparison.baseCommitOid : undefined;
+            if (storedBaseCommitOid !== baseCommitOid)
+                continue;
+            if (!('reviewKey' in comparison) || typeof comparison.reviewKey !== 'string')
+                continue;
+            return Object.freeze({ reviewKey: comparison.reviewKey, path: candidatePath });
+        }
+        catch {
+            continue;
+        }
+    }
+    return undefined;
+}
+export async function loadUncommittedDraftCandidateComments(path) {
+    let raw;
+    try {
+        raw = await fs.readFile(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    const result = ReviewDraftV1Schema.safeParse(parsed);
+    if (!result.success)
+        return undefined;
+    return result.data.comments.map((comment) => ({
+        body: comment.body,
+        state: comment.state,
+        anchor: comment.anchor,
+    }));
+}