@tequila99/githuman 0.4.0 → 0.4.2

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/preamble.js

@@ -0,0 +1,77 @@
+// The farthest line, above a hunk, that its preamble may reach (ADR 0036). The reach is a
+// limit, not the size: the preamble starts at a safe line within it. A reach of 60 gave the
+// fewest wrong lines in a test on the history of this repository.
+export const PREAMBLE_REACH = 60;
+// A budget for one preamble, in characters. A minified file has lines of many kilobytes.
+const PREAMBLE_MAX_CHARS = 4000;
+// A line that closes a tag. At the start of a preamble it has no opening tag, and a markup
+// grammar then loses its state.
+const CLOSER = /^\s*(<\/|\/>|>)/;
+// A top-level block of a Vue file: the tag stands alone on its line, at column 0.
+const VUE_BLOCK_OPEN = /^<(template|script|style)\b[^>]*>\s*$/;
+/**
+ * For each line index, the opening tag of the Vue block that is open before that line.
+ * The list has one more entry than there are lines, so the end of the file has an entry too.
+ */
+function vueOpenTags(lines) {
+    const tags = [undefined];
+    let open;
+    for (const text of lines) {
+        const match = VUE_BLOCK_OPEN.exec(text);
+        if (match) {
+            open = { tag: match[1], text };
+        }
+        else if (open && text.startsWith(`</${open.tag}>`)) {
+            open = undefined;
+        }
+        tags.push(open?.text);
+    }
+    return tags;
+}
+/**
+ * Makes a reader of preambles for one side of a file. Use one reader for all hunks of the
+ * file: it scans the Vue blocks once, and only when a hunk needs them.
+ *
+ * The preamble starts at the farthest safe line within {@link PREAMBLE_REACH} lines above
+ * the hunk. A line is safe when it is indented no deeper than every line after it, up to the
+ * hunk, and does not close a tag. Then the preamble holds no line that closes a block
+ * opened above it, and the grammar keeps a sound state. In a Vue file the opening tag of the
+ * enclosing block comes first, so the parser knows the language. `sideLines` are all lines
+ * of the file on the side of the hunk.
+ */
+export function createPreambleReader(path, sideLines) {
+    const isVue = path.toLowerCase().endsWith('.vue');
+    let openTags;
+    return firstLine => {
+        const end = Math.min(firstLine - 1, sideLines.length);
+        if (end <= 0)
+            return [];
+        let start = end;
+        let chars = 0;
+        let shallowest = Infinity;
+        for (let i = end - 1; i >= Math.max(0, end - PREAMBLE_REACH); i--) {
+            const line = sideLines[i];
+            chars += line.length;
+            if (chars > PREAMBLE_MAX_CHARS)
+                break;
+            if (line.trim() === '')
+                continue;
+            const indent = line.length - line.trimStart().length;
+            if (indent <= shallowest && !CLOSER.test(line))
+                start = i;
+            shallowest = Math.min(shallowest, indent);
+        }
+        const lines = sideLines.slice(start, end);
+        if (isVue) {
+            openTags ??= vueOpenTags(sideLines);
+            const tag = openTags[start];
+            if (tag !== undefined)
+                lines.unshift(tag);
+        }
+        return lines;
+    };
+}
+/** The preamble of one hunk. For many hunks of one file, use {@link createPreambleReader}. */
+export function hunkPreamble(path, sideLines, firstLine) {
+    return createPreambleReader(path, sideLines)(firstLine);
+}

package/dist/shared/diff/schemas.js

@@ -0,0 +1,80 @@
+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.'
+    }),
+    preamble: Type.Optional(Type.Array(Type.String(), {
+        description: 'Unchanged lines above the hunk, for syntax highlighting only. Bounded in count and size. In a Vue file the opening tag of the enclosing block comes first. Absent when there are none.'
+    }))
+}, { 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 } : {});
+}