@tequila99/githuman 0.3.0 → 0.4.1

package/dist/server/services/git.service.js

@@ -211,6 +211,107 @@ function statusCodeToStatus(code) {
             return 'modified';
     }
 }
+/**
+ * Removes the extra record of a merge conflict. During a conflict, `git diff` prints an
+ * `U` record with zero blob ids and also a normal record for the same path. The normal
+ * record has the real blob ids and counts, so it stays.
+ */
+function dedupeUnmerged(records) {
+    const normalPaths = new Set(records
+        .filter(record => record.code !== 'U')
+        .map(record => record.item.newPath));
+    return records
+        .filter(record => record.code !== 'U' || !normalPaths.has(record.item.newPath))
+        .map(record => record.item);
+}
+/**
+ * Parses the output of `git diff --raw --numstat -z`. Git prints all raw records first:
+ * a `:<modes> <old oid> <new oid> <status>` token, then one path, or two for a rename or copy.
+ * The numstat records follow: `<added>\t<removed>\t<path>` in one token. For a rename, the
+ * path part is empty, and two path tokens follow. Paths are read by position, so a path
+ * with `:`, a TAB or a line feed does not break the parse.
+ */
+export function parseRawNumstat(stdout) {
+    const tokens = stdout.split('\0');
+    // With -z, the output ends with NUL, so the last token is empty.
+    if (tokens[tokens.length - 1] === '')
+        tokens.pop();
+    const raw = [];
+    const numstat = [];
+    let i = 0;
+    while (i < tokens.length && tokens[i].startsWith(':')) {
+        const fields = tokens[i++].split(' ');
+        const code = fields[4] ?? 'M';
+        const oldOid = fields[2] ?? '';
+        const newOid = fields[3] ?? '';
+        const status = statusCodeToStatus(code);
+        if (code[0] === 'R' || code[0] === 'C') {
+            const oldPath = tokens[i++];
+            const newPath = tokens[i++];
+            raw.push({ code, oldPath, newPath, status, oldOid, newOid });
+        }
+        else {
+            const path = tokens[i++];
+            raw.push({ code, oldPath: path, newPath: path, status, oldOid, newOid });
+        }
+    }
+    while (i < tokens.length) {
+        const token = tokens[i++];
+        // Only the first two TABs separate fields: a path can hold a TAB too.
+        const firstTab = token.indexOf('\t');
+        const secondTab = token.indexOf('\t', firstTab + 1);
+        const added = token.slice(0, firstTab);
+        const removed = token.slice(firstTab + 1, secondTab);
+        let path = token.slice(secondTab + 1);
+        if (path === '') {
+            i++; // the old path of the rename
+            path = tokens[i++];
+        }
+        const isBinary = added === '-';
+        numstat.push({
+            path,
+            additions: isBinary ? 0 : Number(added),
+            deletions: isBinary ? 0 : Number(removed),
+            isBinary
+        });
+    }
+    return { raw, numstat };
+}
+/**
+ * Joins raw and numstat records. They come from one git run in the same order, so they
+ * line up by position. A path mismatch means the parse went wrong: then the join goes by path.
+ */
+function joinRawNumstat(raw, numstat) {
+    const aligned = raw.length === numstat.length &&
+        raw.every((record, i) => record.newPath === numstat[i].path);
+    if (!aligned) {
+        process.emitWarning(`git diff --raw --numstat: ${raw.length} raw and ${numstat.length} numstat records do not line up; joining by path`);
+    }
+    const byPath = aligned
+        ? undefined
+        : new Map(numstat.map(record => [record.path, record]));
+    return raw.map(({ code, ...record }, i) => {
+        const counts = aligned ? numstat[i] : byPath?.get(record.newPath);
+        return {
+            code,
+            item: {
+                ...record,
+                additions: counts?.additions ?? 0,
+                deletions: counts?.deletions ?? 0,
+                isBinary: counts?.isBinary ?? false
+            }
+        };
+    });
+}
+/**
+ * Lists changed paths with line counts and both blob ids, without reading file contents.
+ * One git run prints both formats, so the records describe one state of the repository.
+ */
+export async function listChangedSummaries(repoPath, diffArgs) {
+    const { stdout } = await execFileAsync('git', ['diff', '--raw', '--numstat', '--no-abbrev', '-M', '-z', ...diffArgs], { cwd: repoPath, encoding: 'utf-8', maxBuffer: 1024 * 1024 * 100 });
+    const { raw, numstat } = parseRawNumstat(stdout);
+    return dedupeUnmerged(joinRawNumstat(raw, numstat));
+}
 /**
  * Lists changed paths for a diff, given the git ref arguments that would
  * normally follow `git diff --name-status -M` (e.g. `['--cached']` for
@@ -233,14 +334,14 @@ export async function listChangedPaths(repoPath, diffArgs) {
         if (code[0] === 'R' || code[0] === 'C') {
             const oldPath = tokens[i++];
             const newPath = tokens[i++];
-            results.push({ oldPath, newPath, status });
+            results.push({ code, item: { oldPath, newPath, status } });
         }
         else {
             const path = tokens[i++];
-            results.push({ oldPath: path, newPath: path, status });
+            results.push({ code, item: { oldPath: path, newPath: path, status } });
         }
     }
-    return results;
+    return dedupeUnmerged(results);
 }
 /** Lists paths that git has never tracked (respects .gitignore). */
 export async function listUntrackedPaths(repoPath) {

package/dist/shared/agents/schemas.js

@@ -1,51 +1,140 @@
 import { Type } from '@sinclair/typebox';
 import { MAX_ATTACHMENT_BYTES, MAX_FILE_SEARCH_LIMIT } from "./constants.js";
-export const SessionParams = Type.Object({ id: Type.String() });
+import { DiffSourceNameSchema } from "../diff/schemas.js";
+import { Nullable } from "../utils/schemas.js";
+export const SessionParams = Type.Object({
+    id: Type.String({ description: 'Chat session id.' })
+});
 export const PermissionParams = Type.Object({
-    id: Type.String(),
-    requestId: Type.String()
+    id: Type.String({ description: 'Chat session id.' }),
+    requestId: Type.String({ description: 'Pending permission request id.' })
 });
 export const CreateSessionBody = Type.Object({
-    presetId: Type.String({ minLength: 1 }),
-    name: Type.Optional(Type.String({ maxLength: 60 })),
-    reviewId: Type.Optional(Type.String())
-});
-export const AutoApproveBody = Type.Object({ enabled: Type.Boolean() });
+    presetId: Type.String({
+        minLength: 1,
+        description: 'Preset from GET /api/agent/presets.'
+    }),
+    name: Type.Optional(Type.String({
+        maxLength: 60,
+        description: 'Chat name. Omitted: the server makes a unique one.'
+    })),
+    reviewId: Type.Optional(Type.String({ description: 'Review that the chat belongs to.' }))
+}, { description: 'A new chat session.' });
+export const AutoApproveBody = Type.Object({
+    enabled: Type.Boolean({
+        description: 'The server answers permission requests itself.'
+    })
+}, { description: 'Auto-approve switch of one session.' });
 export const FileSearchQuery = Type.Object({
-    q: Type.Optional(Type.String({ maxLength: 200 })),
-    limit: Type.Optional(Type.Integer({ minimum: 1, maximum: MAX_FILE_SEARCH_LIMIT }))
+    q: Type.Optional(Type.String({
+        maxLength: 200,
+        description: 'Fuzzy text to find in paths. Empty lists files.'
+    })),
+    limit: Type.Optional(Type.Integer({
+        minimum: 1,
+        maximum: MAX_FILE_SEARCH_LIMIT,
+        description: 'Maximum number of paths.'
+    }))
 });
 export const ContextItem = Type.Union([
     Type.Object({
-        kind: Type.Literal('diff'),
-        source: Type.Union([Type.Literal('staged'), Type.Literal('unstaged')]),
-        path: Type.Optional(Type.String({ minLength: 1 }))
-    }),
+        kind: Type.Literal('diff', { description: 'Live working-tree diff.' }),
+        source: DiffSourceNameSchema,
+        path: Type.Optional(Type.String({
+            minLength: 1,
+            description: 'One file of the diff. Omitted: the whole diff.'
+        }))
+    }, { description: 'The live diff of one side.' }),
     Type.Object({
-        kind: Type.Literal('file'),
-        path: Type.String({ minLength: 1 })
-    }),
-    Type.Object({ kind: Type.Literal('review'), reviewId: Type.String() }),
+        kind: Type.Literal('file', { description: 'A repository file.' }),
+        path: Type.String({
+            minLength: 1,
+            description: 'Repository-relative path. The agent reads the file.'
+        })
+    }, { description: 'A link to a repository file.' }),
     Type.Object({
-        kind: Type.Literal('attachment'),
-        name: Type.String({ minLength: 1, maxLength: 255 }),
-        mimeType: Type.String({ maxLength: 255 }),
+        kind: Type.Literal('review', { description: 'A review.' }),
+        reviewId: Type.String({ description: 'Review id.' })
+    }, { description: 'A review as markdown with its comments.' }),
+    Type.Object({
+        kind: Type.Literal('attachment', {
+            description: 'A file from the user.'
+        }),
+        name: Type.String({
+            minLength: 1,
+            maxLength: 255,
+            description: 'File name.'
+        }),
+        mimeType: Type.String({ maxLength: 255, description: 'MIME type.' }),
         data: Type.String({
-            maxLength: Math.ceil(MAX_ATTACHMENT_BYTES / 3) * 4
+            maxLength: Math.ceil(MAX_ATTACHMENT_BYTES / 3) * 4,
+            description: 'File content in base64.'
         })
-    })
-]);
+    }, { description: 'An uploaded file or a pasted image.' })
+], { description: 'Context of a prompt (docs/agent-context-uris.md).' });
 export const PromptBody = Type.Object({
-    text: Type.String({ minLength: 1 }),
-    context: Type.Optional(Type.Array(ContextItem, { maxItems: 20 }))
-});
+    text: Type.String({ minLength: 1, description: 'Message to the agent.' }),
+    context: Type.Optional(Type.Array(ContextItem, {
+        maxItems: 20,
+        description: 'Context items that go with the message.'
+    }))
+}, { description: 'A user message.' });
 export const PermissionBody = Type.Object({
-    optionId: Type.Optional(Type.String())
-});
+    optionId: Type.Optional(Type.String({
+        description: 'Option from the permission request. Omitted: the request is cancelled.'
+    }))
+}, { description: 'Answer to a permission request.' });
 export const ConfigBody = Type.Object({
-    configId: Type.String({ minLength: 1 }),
+    configId: Type.String({
+        minLength: 1,
+        description: 'Setting id from the config event.'
+    }),
     // No schema type on purpose: a Union/anyOf makes Fastify's Ajv coerce `true`
     // into the string "true", and a `type` array trips Ajv's strictTypes. The
     // session checks the value against the option the agent actually offered.
-    value: Type.Unsafe({})
+    value: Type.Unsafe({
+        description: 'A select value (string) or a boolean.'
+    })
+}, { description: 'A new value of an agent setting.' });
+export const AgentPresetInfoSchema = Type.Object({
+    id: Type.String({ description: 'Preset id.' }),
+    title: Type.String({ description: 'Name in the UI.' }),
+    available: Type.Boolean({
+        description: 'The launcher binary is in PATH. Says nothing about login or auth.'
+    }),
+    autoApprovesEdits: Type.Boolean({
+        description: 'The agent applies edits without permission requests.'
+    })
+}, { description: 'An ACP agent that can start a chat.' });
+export const AgentSessionStatusSchema = Type.Union([
+    Type.Literal('starting'),
+    Type.Literal('ready'),
+    Type.Literal('busy'),
+    Type.Literal('closed')
+], { description: 'Session state.' });
+export const AgentSessionInfoSchema = Type.Object({
+    id: Type.String({ description: 'Chat session id.' }),
+    presetId: Type.String({ description: 'Preset of the agent.' }),
+    name: Type.String({ description: 'Chat name in the UI.' }),
+    status: AgentSessionStatusSchema,
+    reviewId: Nullable(Type.String({ description: 'Review of the chat. Else null.' })),
+    autoApprove: Type.Boolean({
+        description: 'The server answers permission requests itself.'
+    }),
+    error: Nullable(Type.String({
+        description: 'Why the session could not start. Else null.'
+    }))
+}, { description: 'A chat session.' });
+export const AgentFileSearchResponseSchema = Type.Object({
+    files: Type.Array(Type.String(), {
+        description: 'Repository-relative paths, best match first.'
+    })
+}, { description: 'Files for the context picker.' });
+export const AgentEventsHeaders = Type.Object({
+    'last-event-id': Type.Optional(Type.String({
+        description: 'Last event id that the client got. Events after it come again.'
+    }))
+});
+export const AgentStreamSchema = Type.String({
+    description: 'Server-sent events: connected, then agent (AgentStreamEnvelope, SSE id = event id), state (AgentSessionState), gap ({ sessionId }) and sessions (reread the list).'
 });

package/dist/shared/app/schemas.js

@@ -0,0 +1,7 @@
+import { Type } from '@sinclair/typebox';
+export const AppInfoSchema = Type.Object({
+    version: Type.String({ description: 'githuman version from package.json.' })
+}, { description: 'Facts about the running server.' });
+export const HealthSchema = Type.Object({
+    status: Type.Literal('ok', { description: 'Always "ok".' })
+}, { description: 'The server is up.' });

package/dist/shared/comments/schemas.js

@@ -0,0 +1,48 @@
+import { Type } from '@sinclair/typebox';
+import { Nullable } from "../utils/schemas.js";
+import { DiffLineTypeSchema } from "../diff/schemas.js";
+export const CommentSchema = Type.Object({
+    id: Type.String({ description: 'Comment id.' }),
+    reviewId: Type.String({ description: 'Review that holds the comment.' }),
+    filePath: Type.String({ description: 'Repository-relative file path.' }),
+    lineNumber: Nullable(Type.Integer({
+        description: 'First line of the comment. Null for a file comment.'
+    })),
+    lineNumberEnd: Nullable(Type.Integer({
+        description: 'Last line of a selected range. Equals lineNumber for one line.'
+    })),
+    lineType: Nullable(DiffLineTypeSchema),
+    content: Type.String({ description: 'Comment text in markdown.' }),
+    createdAt: Type.String({ description: 'Creation time, ISO 8601.' }),
+    updatedAt: Type.String({ description: 'Last change time, ISO 8601.' }),
+    resolved: Type.Optional(Type.Boolean({ description: 'The comment is resolved.' })),
+    suggestion: Type.Optional(Nullable(Type.String({ description: 'Code that replaces the selected lines.' })))
+}, { description: 'A comment on a file or on lines of a review.' });
+// Null goes first in each union: Fastify's Ajv coerces types, and with
+// Integer (or String) first it turns a JSON null into 0 (or "") before the
+// Null branch is ever tried — a file-level comment would be stored as line 0.
+export const CreateCommentBody = Type.Object({
+    filePath: Type.String({
+        minLength: 1,
+        description: 'Repository-relative file path.'
+    }),
+    lineNumber: Type.Optional(Type.Union([Type.Null(), Type.Integer()], {
+        description: 'First line. Null or omitted for a file comment.'
+    })),
+    lineNumberEnd: Type.Optional(Type.Union([Type.Null(), Type.Integer()], {
+        description: 'Last line of a range. Null or omitted for one line.'
+    })),
+    lineType: Type.Optional(Type.Union([Type.Null(), ...DiffLineTypeSchema.anyOf], {
+        description: 'Line kind of lineNumber. Null for a file comment.'
+    })),
+    content: Type.String({ description: 'Comment text in markdown.' }),
+    suggestion: Type.Optional(Type.Union([Type.Null(), Type.String()], {
+        description: 'Code that replaces the selected lines.'
+    }))
+}, { description: 'A new comment.' });
+export const UpdateCommentBody = Type.Object({
+    content: Type.String({ description: 'New comment text in markdown.' })
+}, { description: 'A comment change.' });
+export const CommentIdParams = Type.Object({
+    id: Type.String({ description: 'Comment id.' })
+});

package/dist/shared/diff/schemas.js

@@ -0,0 +1,77 @@
+import { Type } from '@sinclair/typebox';
+import { Nullable } from "../utils/schemas.js";
+export const DiffSourceNameSchema = Type.Union([Type.Literal('staged'), Type.Literal('unstaged')], { description: 'Side of the working tree: the index or the files on disk.' });
+export const DiffLineTypeSchema = Type.Union([Type.Literal('added'), Type.Literal('removed'), Type.Literal('context')], { description: 'Line kind: added, removed or unchanged context.' });
+export const DiffFileStatusSchema = Type.Union([
+    Type.Literal('added'),
+    Type.Literal('modified'),
+    Type.Literal('deleted'),
+    Type.Literal('renamed')
+], { description: 'What the change does to the file.' });
+export const DiffLineSchema = Type.Object({
+    type: DiffLineTypeSchema,
+    content: Type.String({
+        description: 'Line text without the "+", "-" or " " prefix.'
+    }),
+    oldLineNumber: Nullable(Type.Integer({
+        description: 'Line number in the old file. Null for an added line.'
+    })),
+    newLineNumber: Nullable(Type.Integer({
+        description: 'Line number in the new file. Null for a removed line.'
+    }))
+}, { description: 'One line of a hunk.' });
+export const DiffHunkSchema = Type.Object({
+    oldStart: Type.Integer({ description: 'First line in the old file.' }),
+    oldLines: Type.Integer({ description: 'Line count in the old file.' }),
+    newStart: Type.Integer({ description: 'First line in the new file.' }),
+    newLines: Type.Integer({ description: 'Line count in the new file.' }),
+    lines: Type.Array(DiffLineSchema, {
+        description: 'Lines of the hunk in file order.'
+    })
+}, { description: 'One hunk of a file diff.' });
+const diffFileFields = {
+    oldPath: Type.String({
+        description: 'Path before the change. Equals newPath unless renamed.'
+    }),
+    newPath: Type.String({
+        description: 'Path after the change. Equals oldPath for a deleted file.'
+    }),
+    status: DiffFileStatusSchema,
+    additions: Type.Integer({ description: 'Added line count.' }),
+    deletions: Type.Integer({ description: 'Removed line count.' }),
+    isBinary: Type.Boolean({ description: 'Git sees the file as binary.' })
+};
+export const DiffFileSchema = Type.Object({
+    ...diffFileFields,
+    hunks: Type.Array(DiffHunkSchema, {
+        description: 'Hunks of the file. Empty for a binary file.'
+    })
+}, { description: 'Diff of one file with its hunks.' });
+export const DiffFileSummarySchema = Type.Object({
+    ...diffFileFields,
+    signature: Type.String({
+        description: 'Changes when the file content or its diff changes. Equal signatures mean equal hunks.'
+    })
+}, { description: 'Diff of one file without hunks.' });
+export const SourceParams = Type.Object({ source: DiffSourceNameSchema });
+export const FileQuery = Type.Object({
+    path: Type.String({
+        minLength: 1,
+        description: 'Repository-relative path after the change.'
+    }),
+    oldPath: Type.Optional(Type.String({
+        minLength: 1,
+        description: 'Repository-relative path before a rename.'
+    })),
+    status: DiffFileStatusSchema
+});
+export const BranchQuery = Type.Object({
+    base: Type.String({
+        minLength: 1,
+        description: 'Ref that the diff compares HEAD with.'
+    })
+});
+export const CommitsQuery = Type.Object({
+    from: Type.String({ minLength: 1, description: 'Older ref.' }),
+    to: Type.String({ minLength: 1, description: 'Newer ref.' })
+});

package/dist/shared/diff/types.js

@@ -1,4 +1 @@
-/**
- * Shared types between server and web client
- */
 export {};

package/dist/shared/events/schemas.js

@@ -0,0 +1,4 @@
+import { Type } from '@sinclair/typebox';
+export const EventStreamSchema = Type.String({
+    description: 'Server-sent events. The first event is connected with { instanceId } data. Then come review:created, review:updated, review:deleted, comment:created, comment:updated and comment:deleted with { reviewId } data, and files:changed with {} data.'
+});

package/dist/shared/git/schemas.js

@@ -0,0 +1,59 @@
+import { Type } from '@sinclair/typebox';
+import { Nullable } from "../utils/schemas.js";
+export const RepositoryInfoSchema = Type.Object({
+    name: Type.String({ description: 'Name of the repository directory.' }),
+    branch: Type.String({ description: 'Current branch.' }),
+    remote: Nullable(Type.String({
+        description: 'Fetch URL of the origin remote. Null if none.'
+    })),
+    path: Type.String({ description: 'Absolute path of the repository.' })
+}, { description: 'The repository that the server shows.' });
+export const FileTreeResponseSchema = Type.Object({
+    ref: Type.String({ description: 'Ref from the request.' }),
+    files: Type.Array(Type.String(), {
+        description: 'Repository-relative paths of all files at the ref.'
+    })
+}, { description: 'Files of the repository at a ref.' });
+export const FileContentResponseSchema = Type.Object({
+    path: Type.String({ description: 'Repository-relative path.' }),
+    ref: Type.String({ description: 'Ref from the request.' }),
+    content: Type.String({
+        description: 'Full file text. Empty for a binary file or a file that is not at the ref.'
+    }),
+    lines: Type.Array(Type.String(), {
+        description: 'Lines of the text. Empty for a binary file.'
+    }),
+    lineCount: Type.Integer({ description: 'Length of lines.' }),
+    isBinary: Type.Boolean({ description: 'The file is binary.' })
+}, { description: 'One file at a ref.' });
+export const OkSchema = Type.Object({
+    ok: Type.Literal(true, { description: 'Always true.' })
+}, { description: 'The git command succeeded.' });
+export const TreeParams = Type.Object({
+    ref: Type.String({
+        minLength: 1,
+        description: 'Commit, branch or tag. INDEX lists the index, WORKTREE the files on disk.'
+    })
+});
+export const FileParams = Type.Object({
+    '*': Type.String({
+        description: 'Repository-relative path. Slashes stay literal.'
+    })
+});
+export const FileContentQuery = Type.Object({
+    ref: Type.String({
+        minLength: 1,
+        description: 'Commit, branch or tag. INDEX reads the index, WORKTREE the file on disk.'
+    })
+});
+export const OptionalPathsBody = Type.Object({
+    paths: Type.Optional(Type.Array(Type.String(), {
+        description: 'Repository-relative paths. Omitted or empty means all.'
+    }))
+}, { description: 'Paths for stage or unstage.' });
+export const DiscardBody = Type.Object({
+    paths: Type.Array(Type.String(), {
+        minItems: 1,
+        description: 'Repository-relative paths. Required: there is no "discard all".'
+    })
+}, { description: 'Paths to discard.' });

package/dist/shared/http/schemas.js

@@ -0,0 +1,23 @@
+import { Type } from '@sinclair/typebox';
+/** Fields of the error body that Fastify writes for each error. */
+const API_ERROR_FIELDS = {
+    statusCode: Type.Integer({ description: 'HTTP status code.' }),
+    code: Type.Optional(Type.String({
+        description: 'Stable error code, for example GHT_HTTP_NOT_FOUND.'
+    })),
+    error: Type.String({ description: 'HTTP status text.' }),
+    message: Type.String({ description: 'What went wrong.' })
+};
+/** Error answers that every route can give. */
+export const ERROR_RESPONSES = {
+    '4xx': Type.Object(API_ERROR_FIELDS, {
+        description: 'The request is not valid.'
+    }),
+    '5xx': Type.Object(API_ERROR_FIELDS, { description: 'The server failed.' })
+};
+export const ApiErrorSchema = Type.Object(API_ERROR_FIELDS, {
+    description: 'Error body of every route.'
+});
+export const NoContentSchema = Type.Null({
+    description: 'The request succeeded. The body is empty.'
+});

package/dist/shared/reviews/schemas.js

@@ -0,0 +1,96 @@
+import { Type } from '@sinclair/typebox';
+import { Nullable } from "../utils/schemas.js";
+import { CommentSchema } from "../comments/schemas.js";
+export const ReviewStatusSchema = Type.Union([
+    Type.Literal('in_progress'),
+    Type.Literal('approved'),
+    Type.Literal('changes_requested')
+], { description: 'Review state.' });
+/**
+ * 'local' snapshots staged + unstaged diffs together — the only source type
+ * the "Start review" UI offers, since a review's comments apply to both
+ * regardless of which tab they were left on (see ADR 0018). 'staged'/
+ * 'unstaged' remain valid API inputs (kept for API callers that want one
+ * side only) but have no UI entry point anymore. 'branch'/'commits' are
+ * unrelated future-MVP source types (ADR 0017), unaffected by this.
+ */
+export const ReviewSourceTypeSchema = Type.Union([
+    Type.Literal('local'),
+    Type.Literal('staged'),
+    Type.Literal('unstaged'),
+    Type.Literal('branch'),
+    Type.Literal('commits')
+], {
+    description: 'Diff in the snapshot: local (staged and unstaged), one side, a branch or commits.'
+});
+const reviewSummaryFields = {
+    id: Type.String({ description: 'Review id.' }),
+    repositoryPath: Type.String({
+        description: 'Absolute repository path at creation.'
+    }),
+    baseRef: Nullable(Type.String({
+        description: 'Base ref for branch or commits reviews. Else null.'
+    })),
+    sourceType: ReviewSourceTypeSchema,
+    sourceRef: Nullable(Type.String({
+        description: 'Branch name for branch, the newer ref ("to") for commits. Else null.'
+    })),
+    status: ReviewStatusSchema,
+    name: Nullable(Type.String({
+        description: 'User or generated name ("source + date/time"). Unique within branch.'
+    })),
+    branch: Nullable(Type.String({
+        description: 'Branch at creation. The server does not update it.'
+    })),
+    createdAt: Type.String({ description: 'Creation time, ISO 8601.' }),
+    updatedAt: Type.String({ description: 'Last change time, ISO 8601.' })
+};
+export const ReviewSummarySchema = Type.Object(reviewSummaryFields, {
+    description: 'A review without its snapshot.'
+});
+export const ReviewSchema = Type.Object({
+    ...reviewSummaryFields,
+    snapshotData: Type.String({
+        description: 'JSON array of DiffFile, frozen at creation.'
+    })
+}, { description: 'A review with its diff snapshot.' });
+export const ReviewExportSchema = Type.Object({
+    review: ReviewSchema,
+    comments: Type.Array(CommentSchema, {
+        description: 'All comments of the review.'
+    })
+}, { description: 'A review and its comments as JSON.' });
+export const CreateReviewBody = Type.Object({
+    sourceType: Type.Optional(ReviewSourceTypeSchema),
+    sourceRef: Type.Optional(Type.String({
+        description: 'Branch name for branch, or the newer ref ("to") for commits.'
+    })),
+    baseRef: Type.Optional(Type.String({
+        description: 'Required for branch and commits: the base ref or the older ref ("from").'
+    })),
+    name: Type.Optional(Type.String({
+        description: 'Review name. Omitted or blank: the server makes one.'
+    }))
+}, { description: 'A new review. sourceType defaults to local.' });
+export const ReviewsQuery = Type.Object({
+    branch: Type.Optional(Type.String({ description: 'Branch filter. Default: current branch.' })),
+    search: Type.Optional(Type.String({
+        description: 'Text to find in review names, case-insensitive.'
+    })),
+    createdFrom: Type.Optional(Type.String({ description: 'Earliest creation time, ISO 8601.' })),
+    createdTo: Type.Optional(Type.String({ description: 'Latest creation time, ISO 8601.' })),
+    files: Type.Optional(Type.String({
+        description: 'Comma-separated file paths. A review matches if its snapshot has one of them.'
+    }))
+});
+export const UpdateReviewBody = Type.Object({
+    status: Type.Optional(ReviewStatusSchema)
+}, { description: 'A review change. status is required.' });
+export const ReviewIdParams = Type.Object({
+    id: Type.String({ description: 'Review id.' })
+});
+export const ExportQuery = Type.Object({
+    format: Type.Union([Type.Literal('json'), Type.Literal('markdown')], {
+        description: 'json gives the review and comments, markdown a report.'
+    })
+});

package/dist/shared/reviews/summary.js

@@ -0,0 +1,5 @@
+/** Drops the snapshot, so a list never holds a review's whole diff (#56). */
+export function toReviewSummary(review) {
+    const { snapshotData: _snapshot, ...summary } = review;
+    return summary;
+}

package/dist/shared/utils/schemas.js

@@ -0,0 +1,9 @@
+import { Type } from '@sinclair/typebox';
+/**
+ * A nullable value for a response schema. Request schemas put `Type.Null()`
+ * first instead, because Fastify's Ajv coerces null into the first type.
+ */
+export function Nullable(schema) {
+    const { description } = schema;
+    return Type.Union([schema, Type.Null()], typeof description === 'string' ? { description } : {});
+}

package/dist/web/assets/AppPage-BSvF7ik1.js

@@ -0,0 +1 @@
+import{C as e,I as t,N as n,g as r,it as i,l as a,lt as o,nt as s,q as c,s as l,x as u,y as d}from"./runtime-core.esm-bundler-CUpq88z7.js";import{E as f,O as p,_ as m,j as h,t as g}from"./QBtn-BDbJU6_B.js";import{t as _}from"./create-BkZH2Q0U.js";import{n as v}from"./vue-i18n.runtime-D0pkhc7g.js";import{n as y}from"./pinia-DmTi2T44.js";import{c as b,i as x,l as S,o as C,s as w,t as T}from"./single-flight-r8B7stt1.js";function E(e){if(e.length<2||e[0]!==`"`||e[e.length-1]!==`"`)return e;let t=e.slice(1,-1),n=[];for(let e=0;e<t.length;e++){let r=t[e];r===`\\`&&/^[0-7]{3}$/.test(t.slice(e+1,e+4))?(n.push(parseInt(t.slice(e+1,e+4),8)),e+=3):r===`\\`&&t[e+1]===`"`?(n.push(34),e+=1):r===`\\`&&t[e+1]===`\\`?(n.push(92),e+=1):n.push((r??``).charCodeAt(0))}return new TextDecoder(`utf-8`).decode(new Uint8Array(n))}function D(e){return e.newPath||e.oldPath}function O(e,t){return`${e}:${t}`}function k(e){return{...e,oldPath:E(e.oldPath),newPath:E(e.newPath)}}function A(e){let{signature:t,...n}=e;return{...n,hunks:[]}}function j(e,t,n){let r=new Map(e.map(e=>[D(e),e])),i=new Map;return{files:n.map(e=>{let n=D(e);i.set(n,e.signature);let a=r.get(n);return a&&t.get(n)===e.signature?a:A(e)}),signatures:i}}var M=y(`diff`,()=>{let e=s([]),t=s([]),n=new Map,r=new Map,a=s(!1),o=s(!1),c=s(null),u=l(()=>a.value&&!o.value),d=l(()=>[...e.value,...t.value].map(e=>e.newPath||e.oldPath)),f=i(new Map),p=i(new Map),m=new Map;function h(n){return n===`staged`?e.value:t.value}function g(e,t){return f.value.get(O(e,D(t)))?.file}function _(e,t){return f.value.get(O(e,D(t)))?.for===t}function v(e,t){let n=p.value.get(O(e,D(t)));return n?.for===t?n.message:void 0}function y(e,t){let n=O(e,D(t));if(!p.value.has(n))return;let r=new Map(p.value);r.delete(n),p.value=r}function b(e,t){return y(e,t),S(e,t)}async function S(e,t){let n=O(e,D(t));if(_(e,t)||m.get(n)===t)return;m.set(n,t);let r=new URLSearchParams({path:t.newPath,oldPath:t.oldPath,status:t.status});try{let i=k(await w(`/api/diff/${e}/file?${r}`));if(!h(e).includes(t))return;f.value=new Map(f.value).set(n,{file:i,for:t}),y(e,t)}catch(r){if(!h(e).includes(t))return;p.value=new Map(p.value).set(n,{message:x(r),for:t})}finally{m.get(n)===t&&m.delete(n)}}function C(){let n=new Set([...e.value.map(e=>O(`staged`,D(e))),...t.value.map(e=>O(`unstaged`,D(e)))]),r=new Map([...f.value].filter(([e])=>n.has(e)));r.size!==f.value.size&&(f.value=r);let i=new Map([...p.value].filter(([e])=>n.has(e)));i.size!==p.value.size&&(p.value=i)}let E=T(A);async function A(){a.value=!0;try{let[i,a]=await Promise.all([w(`/api/diff/staged/files`),w(`/api/diff/unstaged/files`)]),o=j(e.value,n,i.map(k)),s=j(t.value,r,a.map(k));e.value=o.files,n=o.signatures,t.value=s.files,r=s.signatures,C(),c.value=null}catch(i){o.value||(e.value=[],t.value=[],n=new Map,r=new Map),c.value=x(i)}finally{a.value=!1,o.value=!0}}return{stagedFiles:e,unstagedFiles:t,loading:a,loaded:o,initialLoading:u,error:c,changedPaths:d,hunksOf:g,hunksFresh:_,hunksError:v,clearHunksError:y,ensureHunks:S,retryHunks:b,fetchDiff:E}});function N(e){let{snapshotData:t,...n}=e;return n}var P=y(`active-review`,()=>{let e=s(null),t=s([]),n=s(!1),r=l(()=>{let e=new Map;for(let n of t.value){let t=e.get(n.filePath);t?t.push(n):e.set(n.filePath,[n])}return e});async function i(){n.value=!0;try{let n=(await w(`/api/reviews`)).filter(e=>e.status===`in_progress`).sort((e,t)=>t.createdAt.localeCompare(e.createdAt));e.value=n[0]??null,t.value=e.value?await w(`/api/reviews/${e.value.id}/comments`):[]}finally{n.value=!1}}function a(n){e.value=N(n),t.value=[]}async function o(t){e.value&&(await b(`/api/reviews/${e.value.id}`,{status:t}),await i())}async function c(n){if(!e.value)throw Error(`No active review`);let r=await S(`/api/reviews/${e.value.id}/comments`,n);return t.value=[...t.value,r],r}async function u(e,n){let r=await b(`/api/comments/${e}`,{content:n});t.value=t.value.map(t=>t.id===e?r:t)}async function d(e){await C(`/api/comments/${e}`),t.value=t.value.filter(t=>t.id!==e)}async function f(e){let n=await b(`/api/comments/${e}/resolve`);t.value=t.value.map(t=>t.id===e?n:t)}async function p(e){let n=await b(`/api/comments/${e}/unresolve`);t.value=t.value.map(t=>t.id===e?n:t)}return{activeReview:e,comments:t,loading:n,commentsByFile:r,refresh:i,setActiveReview:a,setStatus:o,createComment:c,editComment:u,deleteComment:d,resolveComment:f,unresolveComment:p}}),F=r({__name:`CancelButton`,setup(t){let{t:r}=v();return(t,i)=>(n(),a(g,e({padding:`2px 8px`},t.$attrs,{dense:``,flat:``,color:`warning`,label:o(r)(`reviews.comments.cancel`)}),null,16,[`label`]))}}),I=r({__name:`CreateButton`,setup(t){let{t:r}=v();return(t,i)=>(n(),a(g,e({padding:`2px 8px`,label:o(r)(`reviews.create.submit`)},t.$attrs,{unelevated:``,dense:``,color:`accent`}),null,16,[`label`]))}}),L=_({name:`QPage`,props:{padding:Boolean,styleFn:Function},setup(e,{slots:t}){let n=f(),r=u(h,p);if(r===p)return console.error(`QPage needs to be a deep child of QLayout`),p;if(u(`_q_pc_`,p)===p)return console.error(`QPage needs to be child of QPageContainer`),p;let i=l(()=>{let t=(r.header.space?r.header.size:0)+(r.footer.space?r.footer.size:0);if(typeof e.styleFn==`function`){let i=r.isContainer.value?r.containerHeight.value:n.screen.height;return e.styleFn(t,i)}return{minHeight:r.isContainer.value?r.containerHeight.value-t+`px`:n.screen.height===0?t===0?`100vh`:`calc(100vh - ${t}px)`:n.screen.height-t+`px`}}),a=l(()=>`q-page${e.padding?` q-layout-padding`:``}`);return()=>d(`main`,{class:a.value,style:i.value},m(t.default))}}),R=r({__name:`AppPage`,setup(e){function r(e,t){return{height:`${t-e}px`}}return(e,i)=>(n(),a(L,{"style-fn":r},{default:c(()=>[t(e.$slots,`default`)]),_:3}))}});export{N as a,D as c,P as i,E as l,I as n,M as o,F as r,O as s,R as t};