@shipwithai/loopnote 0.0.0-stage → 2.0.0-bootstrap.0

package/dist/bin/loopnote.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+if (process.env.LOOPNOTE_SUPPORT_SERVICE_URL === undefined) process.env.LOOPNOTE_SUPPORT_SERVICE_URL = 'https://boruowxemintmdojkibd.supabase.co';
+const { run } = await import('../cli/run.js');
+
+await run();

package/dist/cli/confirm.js

@@ -0,0 +1,38 @@
+import search from '@inquirer/search';
+import { DIRTY_EXPLANATION, DIRTY_ROW_LABEL, } from '../domain/source.js';
+import { escapeTerminalText } from './picker.js';
+const confirmationChoices = [
+    { name: 'Launch pinned comparison', value: 'launch' },
+    { name: 'Back', value: 'back' },
+];
+async function defaultPrompt(config) {
+    return await search({
+        message: config.message,
+        source: async () => [...config.choices],
+    });
+}
+export async function confirmPinnedComparison(comparison, dependencies = {}) {
+    const output = dependencies.output ?? console.log;
+    const prompt = dependencies.prompt ?? defaultPrompt;
+    output('Confirm pinned comparison');
+    output(`Base: ${escapeTerminalText(comparison.base.label)}\n${comparison.base.oid}`);
+    output(`Head: ${escapeTerminalText(comparison.head.label)}\n${comparison.head.oid}`);
+    output(`Merge base:\n${comparison.mergeBaseOid}`);
+    if (comparison.base.source?.kind === 'worktree') {
+        output(`Base worktree: ${escapeTerminalText(comparison.base.source.path)}`);
+    }
+    if (comparison.head.source?.kind === 'worktree') {
+        output(`Head worktree: ${escapeTerminalText(comparison.head.source.path)}`);
+    }
+    if ((comparison.base.source?.kind === 'worktree' &&
+        comparison.base.source.dirty) ||
+        (comparison.head.source?.kind === 'worktree' &&
+            comparison.head.source.dirty)) {
+        output(`${DIRTY_ROW_LABEL}\n${DIRTY_EXPLANATION}`);
+    }
+    output('This session is pinned to the commits shown below and does not follow moving refs.');
+    return await prompt({
+        message: 'Launch this pinned comparison?',
+        choices: confirmationChoices,
+    });
+}

package/dist/cli/picker.js

@@ -0,0 +1,342 @@
+import search, { Separator } from '@inquirer/search';
+import { RENAME_MAP } from '../domain/product-identity.js';
+import { DIRTY_ROW_LABEL, PENDING_ROW_LABEL, UNAVAILABLE_WORKTREE_REASON, } from '../domain/source.js';
+const BASE_PROMPT = 'Choose base — changes will be compared from its merge base with head';
+const HEAD_PROMPT = 'Choose head — this committed state will be reviewed';
+const BACK_TO_BASE = `${RENAME_MAP.slug}:back-to-base`;
+const UNCOMMITTED_ROW_IDS = {
+    staged: `${RENAME_MAP.slug}:uncommitted:staged`,
+    unstaged: `${RENAME_MAP.slug}:uncommitted:unstaged`,
+    worktree: `${RENAME_MAP.slug}:uncommitted:worktree`,
+};
+const UNCOMMITTED_ROW_KIND_BY_ID = new Map([
+    [UNCOMMITTED_ROW_IDS.staged, 'staged'],
+    [UNCOMMITTED_ROW_IDS.unstaged, 'unstaged'],
+    [UNCOMMITTED_ROW_IDS.worktree, 'worktree'],
+]);
+const UNCOMMITTED_BASE_PROMPT = 'Choose base — changes will be compared from its merge base with HEAD';
+export function escapeTerminalText(value) {
+    let result = '';
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        switch (codePoint) {
+            case 0x09:
+                result += '\\t';
+                break;
+            case 0x0a:
+                result += '\\n';
+                break;
+            case 0x0d:
+                result += '\\r';
+                break;
+            case 0x5c:
+                result += '\\\\';
+                break;
+            default:
+                result +=
+                    codePoint < 0x20 || (codePoint >= 0x7f && codePoint <= 0x9f)
+                        ? `\\x${codePoint.toString(16).toUpperCase().padStart(2, '0')}`
+                        : character;
+        }
+    }
+    return result;
+}
+function worktreeState(candidate) {
+    if (candidate.availability === 'dirty') {
+        return DIRTY_ROW_LABEL;
+    }
+    if (candidate.availability === 'pending') {
+        return PENDING_ROW_LABEL;
+    }
+    if (candidate.availability === 'unavailable') {
+        return 'Unavailable';
+    }
+    return 'Clean';
+}
+function candidateMatches(candidate, query) {
+    if (query.length === 0) {
+        return true;
+    }
+    const identifyingText = candidate.kind === 'branch'
+        ? [
+            'branch',
+            'local branch',
+            candidate.label,
+            candidate.refName,
+            candidate.commitOid,
+            candidate.shortOid,
+        ].join(' ')
+        : [
+            'worktree',
+            candidate.label,
+            candidate.path,
+            candidate.commitOid ?? '',
+            candidate.shortOid ?? '',
+            candidate.detached ? 'detached' : 'attached',
+            worktreeState(candidate),
+            candidate.unavailableReason ?? '',
+        ].join(' ');
+    return identifyingText.toLowerCase().includes(query);
+}
+function candidateItem(candidate, options) {
+    const suggested = options.role === 'head' && candidate.id === options.suggestedHeadId
+        ? ' · Suggested: current checkout'
+        : '';
+    if (candidate.kind === 'branch') {
+        return {
+            kind: 'candidate',
+            value: candidate.id,
+            name: `[Branch] ${escapeTerminalText(candidate.label)} · ${candidate.shortOid}${suggested}`,
+        };
+    }
+    const detached = candidate.detached ? ' · Detached' : '';
+    const shortOid = candidate.shortOid ?? 'no committed HEAD';
+    return {
+        kind: 'candidate',
+        value: candidate.id,
+        name: `[Worktree] ${escapeTerminalText(candidate.label)} · ${shortOid}` +
+            `${detached} · ${worktreeState(candidate)}${suggested}\n` +
+            `    ${escapeTerminalText(candidate.path)}`,
+        disabled: candidate.availability === 'unavailable'
+            ? candidate.unavailableReason ?? UNAVAILABLE_WORKTREE_REASON
+            : undefined,
+    };
+}
+export function buildSourceSearchItems(candidates, term, options) {
+    const query = (term ?? '').toLowerCase();
+    const branchItems = candidates
+        .filter((candidate) => candidate.kind === 'branch' && candidateMatches(candidate, query))
+        .map((candidate) => candidateItem(candidate, options));
+    const worktreeItems = candidates
+        .filter((candidate) => candidate.kind === 'worktree' && candidateMatches(candidate, query))
+        .map((candidate) => candidateItem(candidate, options));
+    const items = [];
+    if (options.role === 'base' && options.includeUncommittedGroup === true) {
+        items.push({ kind: 'separator', label: 'Uncommitted' }, { kind: 'candidate', value: UNCOMMITTED_ROW_IDS.staged, name: 'Staged' }, {
+            kind: 'candidate',
+            value: UNCOMMITTED_ROW_IDS.unstaged,
+            name: 'Unstaged',
+        }, {
+            kind: 'candidate',
+            value: UNCOMMITTED_ROW_IDS.worktree,
+            name: 'Working tree',
+        });
+    }
+    items.push({ kind: 'separator', label: 'Local branches' }, ...branchItems, { kind: 'separator', label: 'Worktrees' }, ...worktreeItems);
+    if (branchItems.length === 0 && worktreeItems.length === 0) {
+        items.push({
+            kind: 'separator',
+            label: 'No branches or worktrees match this search.',
+        });
+    }
+    if (options.role === 'head') {
+        items.push({ kind: 'action', value: BACK_TO_BASE, name: 'Back' });
+    }
+    return items;
+}
+function promptItems(items) {
+    return items.map((item) => item.kind === 'separator'
+        ? new Separator(item.label)
+        : {
+            value: item.value,
+            name: item.name,
+            ...(item.kind === 'candidate' && item.disabled !== undefined
+                ? { disabled: item.disabled }
+                : {}),
+        });
+}
+function mergedCandidates(candidates, branches) {
+    const branchIds = new Set();
+    const mergedBranches = branches.filter((candidate) => {
+        if (branchIds.has(candidate.id)) {
+            return false;
+        }
+        branchIds.add(candidate.id);
+        return true;
+    });
+    return [
+        ...mergedBranches,
+        ...candidates.filter((candidate) => candidate.kind === 'worktree'),
+    ];
+}
+function sourceForPrompt(candidates, searchBranches, candidateById, startCandidateEnrichment, options, initialSearchTerm = '') {
+    let firstRequest = true;
+    return async (term, { signal }) => {
+        signal.throwIfAborted();
+        const startEnrichment = firstRequest;
+        const effectiveTerm = firstRequest && term === undefined ? initialSearchTerm : term;
+        firstRequest = false;
+        if ((effectiveTerm ?? '').length === 0) {
+            const items = promptItems(buildSourceSearchItems(candidates(), effectiveTerm, options));
+            if (startEnrichment) {
+                startCandidateEnrichment?.();
+            }
+            return items;
+        }
+        const branches = await searchBranches(effectiveTerm, signal);
+        signal.throwIfAborted();
+        for (const candidate of branches) {
+            candidateById.set(candidate.id, candidate);
+        }
+        const items = promptItems(buildSourceSearchItems(mergedCandidates(candidates(), branches), undefined, options));
+        if (startEnrichment) {
+            startCandidateEnrichment?.();
+        }
+        return items;
+    };
+}
+export async function pickOrderedSources(options, dependencies = {}) {
+    let currentCandidates = options.candidates;
+    const candidateById = new Map(currentCandidates.map((candidate) => [candidate.id, candidate]));
+    const candidateEnrichment = options.candidateEnrichment?.then((enrichedCandidates) => {
+        currentCandidates = enrichedCandidates;
+        for (const candidate of enrichedCandidates) {
+            candidateById.set(candidate.id, candidate);
+        }
+        return enrichedCandidates;
+    });
+    void candidateEnrichment?.catch(() => undefined);
+    const prompt = dependencies.prompt ??
+        (async (config) => await search({
+            message: config.message,
+            source: config.source,
+            ...(config.default === undefined ? {} : { default: config.default }),
+        }));
+    let base = options.initialBase;
+    let head = options.initialHead;
+    while (true) {
+        if (base === undefined) {
+            const selectedBaseId = await prompt({
+                message: head === undefined
+                    ? BASE_PROMPT
+                    : `${BASE_PROMPT}\nHead retained: ${escapeTerminalText(head.label)} · ${head.shortOid ?? 'unavailable'}`,
+                source: sourceForPrompt(() => currentCandidates, options.searchBranches, candidateById, options.startCandidateEnrichment, { role: 'base' }, options.recovery?.role === 'base'
+                    ? options.recovery.searchTerm
+                    : ''),
+                ...(options.recovery?.role === 'base' &&
+                    options.recovery.focusedCandidateId !== undefined
+                    ? { default: options.recovery.focusedCandidateId }
+                    : {}),
+            });
+            base =
+                selectedBaseId === undefined
+                    ? undefined
+                    : candidateById.get(selectedBaseId);
+            if (base === undefined) {
+                throw new Error('Base selection did not identify an available source');
+            }
+        }
+        if (head === undefined) {
+            const selectedHeadId = await prompt({
+                message: options.recovery?.role === 'head'
+                    ? `${HEAD_PROMPT}\nBase retained: ${escapeTerminalText(base.label)} · ${base.shortOid ?? 'unavailable'}`
+                    : HEAD_PROMPT,
+                source: sourceForPrompt(() => currentCandidates, options.searchBranches, candidateById, options.startCandidateEnrichment, {
+                    role: 'head',
+                    suggestedHeadId: options.suggestedHeadId,
+                }, options.recovery?.role === 'head' ? options.recovery.searchTerm : ''),
+                default: options.recovery?.role === 'head'
+                    ? options.recovery.focusedCandidateId
+                    : options.suggestedHeadId,
+                backValue: BACK_TO_BASE,
+            });
+            if (selectedHeadId === BACK_TO_BASE) {
+                base = undefined;
+                continue;
+            }
+            head =
+                selectedHeadId === undefined
+                    ? undefined
+                    : candidateById.get(selectedHeadId);
+            if (head === undefined) {
+                throw new Error('Head selection did not identify an available source');
+            }
+        }
+        if (candidateEnrichment !== undefined &&
+            (base.kind === 'worktree' || head.kind === 'worktree')) {
+            options.startCandidateEnrichment?.();
+            await candidateEnrichment;
+            base = candidateById.get(base.id);
+            head = candidateById.get(head.id);
+            if (base === undefined) {
+                throw new Error('Base selection did not identify an available source');
+            }
+            if (head === undefined) {
+                throw new Error('Head selection did not identify an available source');
+            }
+        }
+        if (base.kind === 'worktree' && base.availability === 'unavailable') {
+            base = undefined;
+            continue;
+        }
+        if (head.kind === 'worktree' && head.availability === 'unavailable') {
+            head = undefined;
+            continue;
+        }
+        return Object.freeze({ base, head });
+    }
+}
+export async function pickSource(options, dependencies = {}) {
+    if (options.initialBase !== undefined || options.initialHead !== undefined) {
+        const result = await pickOrderedSources(options, dependencies);
+        return Object.freeze({ kind: 'committed', ...result });
+    }
+    let currentCandidates = options.candidates;
+    const candidateById = new Map(currentCandidates.map((candidate) => [candidate.id, candidate]));
+    const candidateEnrichment = options.candidateEnrichment?.then((enrichedCandidates) => {
+        currentCandidates = enrichedCandidates;
+        for (const candidate of enrichedCandidates) {
+            candidateById.set(candidate.id, candidate);
+        }
+        return enrichedCandidates;
+    });
+    void candidateEnrichment?.catch(() => undefined);
+    const prompt = dependencies.prompt ??
+        (async (config) => await search({
+            message: config.message,
+            source: config.source,
+            ...(config.default === undefined ? {} : { default: config.default }),
+        }));
+    const selectedBaseId = await prompt({
+        message: BASE_PROMPT,
+        source: sourceForPrompt(() => currentCandidates, options.searchBranches, candidateById, options.startCandidateEnrichment, { role: 'base', includeUncommittedGroup: true }, options.recovery?.role === 'base' ? options.recovery.searchTerm : ''),
+        ...(options.recovery?.role === 'base' &&
+            options.recovery.focusedCandidateId !== undefined
+            ? { default: options.recovery.focusedCandidateId }
+            : {}),
+    });
+    const uncommittedKind = selectedBaseId === undefined
+        ? undefined
+        : UNCOMMITTED_ROW_KIND_BY_ID.get(selectedBaseId);
+    if (uncommittedKind !== undefined) {
+        if (uncommittedKind === 'unstaged') {
+            return Object.freeze({ kind: 'uncommitted', sourceKind: 'unstaged' });
+        }
+        const selectedSecondBaseId = await prompt({
+            message: UNCOMMITTED_BASE_PROMPT,
+            source: sourceForPrompt(() => currentCandidates, options.searchBranches, candidateById, options.startCandidateEnrichment, { role: 'base' }),
+            ...(options.preselectedBaseId === undefined
+                ? {}
+                : { default: options.preselectedBaseId }),
+        });
+        const resolvedBase = selectedSecondBaseId === undefined
+            ? undefined
+            : candidateById.get(selectedSecondBaseId);
+        if (resolvedBase === undefined) {
+            throw new Error('Base selection did not identify an available source');
+        }
+        return Object.freeze({
+            kind: 'uncommitted',
+            sourceKind: uncommittedKind,
+            base: resolvedBase,
+        });
+    }
+    const initialBase = selectedBaseId === undefined
+        ? undefined
+        : candidateById.get(selectedBaseId);
+    if (initialBase === undefined) {
+        throw new Error('Base selection did not identify an available source');
+    }
+    const result = await pickOrderedSources({ ...options, initialBase }, dependencies);
+    return Object.freeze({ kind: 'committed', ...result });
+}

package/dist/cli/request.js

@@ -0,0 +1,120 @@
+import { Buffer } from 'node:buffer';
+import { AgentReviewRequestSchema, MAX_AGENT_REQUEST_BYTES, } from '../contracts/request.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+const strictUtf8 = new TextDecoder('utf-8', { fatal: true });
+const requestErrorMessages = {
+    'empty-request': `Request input is empty. Pipe one ${RENAME_MAP.kindPrefix}.review-request JSON document.`,
+    'request-too-large': 'Request input exceeds 1048576 bytes. Reduce the request and try again.',
+    'invalid-utf8': 'Request input must be valid UTF-8 JSON.',
+    'malformed-json': 'Request input must contain one JSON document.',
+    'unsupported-version': 'Request schema version is unsupported. Use schemaVersion 1.',
+    'invalid-request': `Request is invalid. Use kind "${RENAME_MAP.kindPrefix}.review-request", schemaVersion 1, and one supported source mode.`,
+    'legacy-kind': `Request kind is outdated. Use kind "${RENAME_MAP.kindPrefix}.review-request" instead.`,
+    'unknown-mode': 'Request mode is not supported. Use revisions, patch, uncommitted, or files.',
+    'base-with-unstaged': '"base" cannot be combined with source "unstaged".',
+    'path-outside-repository': 'Request references a path outside the repository.',
+    'pathspec-no-match': 'Request pathspec does not match any file.',
+    'pathspec-ignored': 'Request pathspec matches only ignored files.',
+};
+export class AgentRequestError extends Error {
+    kind;
+    constructor(kind) {
+        super(requestErrorMessages[kind]);
+        this.name = 'AgentRequestError';
+        this.kind = kind;
+    }
+}
+// The literal old-kind string is an intentional, documented grep-audit exception
+// (17.1-PATTERNS.md Pattern 1): it must match the exact pre-rename kind so requests
+// still carrying it are recognized and rejected with a specific, named error.
+function isLegacyKind(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        'kind' in value &&
+        value.kind === 'cumpa.review-request');
+}
+function isUnsupportedVersion(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        'schemaVersion' in value &&
+        value.schemaVersion !== 1);
+}
+function isUnknownMode(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        'mode' in value &&
+        typeof value.mode === 'string' &&
+        !['revisions', 'patch', 'uncommitted', 'files'].includes(value.mode));
+}
+function isBaseWithUnstaged(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value) || !('uncommitted' in value)) {
+        return false;
+    }
+    const uncommitted = value.uncommitted;
+    return (typeof uncommitted === 'object' &&
+        uncommitted !== null &&
+        !Array.isArray(uncommitted) &&
+        'source' in uncommitted &&
+        uncommitted.source === 'unstaged' &&
+        'base' in uncommitted &&
+        uncommitted.base !== undefined);
+}
+function freezeRequest(request) {
+    if (request.mode === 'revisions') {
+        Object.freeze(request.revisions.pathspecs);
+        Object.freeze(request.revisions);
+    }
+    else if (request.mode === 'patch') {
+        Object.freeze(request.patch.target);
+        Object.freeze(request.patch);
+    }
+    else if (request.mode === 'uncommitted') {
+        Object.freeze(request.uncommitted.pathspecs);
+        Object.freeze(request.uncommitted);
+    }
+    else {
+        Object.freeze(request.files.paths);
+        Object.freeze(request.files);
+    }
+    return Object.freeze(request);
+}
+export async function readAgentReviewRequest(input) {
+    const chunks = [];
+    let byteLength = 0;
+    for await (const chunk of input) {
+        byteLength += chunk.byteLength;
+        if (byteLength > MAX_AGENT_REQUEST_BYTES) {
+            throw new AgentRequestError('request-too-large');
+        }
+        chunks.push(chunk);
+    }
+    if (byteLength === 0) {
+        throw new AgentRequestError('empty-request');
+    }
+    let value;
+    try {
+        value = JSON.parse(strictUtf8.decode(Buffer.concat(chunks, byteLength)));
+    }
+    catch (error) {
+        if (error instanceof TypeError) {
+            throw new AgentRequestError('invalid-utf8');
+        }
+        throw new AgentRequestError('malformed-json');
+    }
+    const parsed = AgentReviewRequestSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new AgentRequestError(isLegacyKind(value)
+            ? 'legacy-kind'
+            : isUnsupportedVersion(value)
+                ? 'unsupported-version'
+                : isUnknownMode(value)
+                    ? 'unknown-mode'
+                    : isBaseWithUnstaged(value)
+                        ? 'base-with-unstaged'
+                        : 'invalid-request');
+    }
+    return freezeRequest(parsed.data);
+}