@tequila99/githuman 0.2.3 → 0.4.0

package/dist/server/services/agent/session-registry.js

@@ -0,0 +1,100 @@
+import { UnknownAgentPresetError, TooManyAgentSessionsError } from "../../errors/agents.js";
+import { MAX_AGENT_SESSIONS } from "../../../shared/agents/constants.js";
+import { uniqueChatName } from "../../../shared/agents/chat-names.js";
+import { AgentSession } from "./agent-session.js";
+import { describePreset } from "../../config/agents.js";
+export function createSessionRegistry(options) {
+    const sessions = new Map();
+    const unsubscribeSession = new Map();
+    const listeners = new Set();
+    let lastEventId = 0;
+    function broadcast(message) {
+        for (const listener of listeners) {
+            listener(message);
+        }
+    }
+    function drop(id) {
+        unsubscribeSession.get(id)?.();
+        unsubscribeSession.delete(id);
+        sessions.delete(id);
+    }
+    function closeAll() {
+        for (const session of sessions.values()) {
+            session.close();
+        }
+        for (const id of sessions.keys()) {
+            drop(id);
+        }
+    }
+    return {
+        listPresets: () => options.presets.map(describePreset),
+        create(presetId, reviewId, name) {
+            const preset = options.presets.find(p => p.id === presetId);
+            if (!preset) {
+                throw new UnknownAgentPresetError(`Unknown agent "${presetId}"`);
+            }
+            if (sessions.size >= MAX_AGENT_SESSIONS) {
+                throw new TooManyAgentSessionsError(`At most ${MAX_AGENT_SESSIONS} chats can be open at once`);
+            }
+            const session = new AgentSession({
+                preset,
+                // Open chats are told apart by name: a taken one gets "(1)", "(2)", …
+                name: uniqueChatName(name?.trim() || preset.title, [...sessions.values()].map(s => s.name)),
+                cwd: options.repositoryPath,
+                reviewId,
+                nextEventId: () => ++lastEventId,
+                ...(options.bufferLimit === undefined
+                    ? {}
+                    : { bufferLimit: options.bufferLimit })
+            });
+            sessions.set(session.id, session);
+            unsubscribeSession.set(session.id, session.onEvent(envelope => {
+                broadcast({
+                    type: 'event',
+                    envelope: { ...envelope, sessionId: session.id }
+                });
+            }));
+            broadcast({ type: 'sessions' });
+            void session.start();
+            return session;
+        },
+        get: id => sessions.get(id),
+        list: () => [...sessions.values()].map(s => s.info()),
+        close(id) {
+            const session = sessions.get(id);
+            if (!session) {
+                return false;
+            }
+            session.close();
+            drop(id);
+            broadcast({ type: 'sessions' });
+            return true;
+        },
+        closeAll,
+        subscribe(listener, afterId = 0) {
+            const replays = [...sessions.values()].map(session => ({
+                sessionId: session.id,
+                ...session.replay(afterId)
+            }));
+            for (const { sessionId, gap } of replays) {
+                if (gap) {
+                    listener({ type: 'gap', sessionId });
+                }
+                // The buffer starts late for a new client or after a gap, so it may
+                // lack the events that set the status, settings and open requests.
+                if (gap || afterId === 0) {
+                    const state = sessions.get(sessionId)?.state();
+                    if (state) {
+                        listener({ type: 'state', state });
+                    }
+                }
+            }
+            replays
+                .flatMap(({ sessionId, envelopes }) => envelopes.map(envelope => ({ ...envelope, sessionId })))
+                .sort((a, b) => a.id - b.id)
+                .forEach(envelope => listener({ type: 'event', envelope }));
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        }
+    };
+}

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

@@ -1,6 +1,5 @@
+import { ValidationError } from "../errors/comments.js";
 import { createComment as insertComment, findCommentById, listCommentsByReview, updateComment as updateCommentRepo, deleteComment as deleteCommentRepo, setCommentResolved } from "../repositories/comment.repo.js";
-export class ValidationError extends Error {
-}
 export function createComment(db, reviewId, input, eventBus) {
     if (!input.content) {
         throw new ValidationError('"content" is required');

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

@@ -1,5 +1,15 @@
 import { diffLines } from 'diff';
-import { assertSafeRef, getFileAtRef, getFilesAtRefBatch, listChangedPaths, listUntrackedPaths } from "./git.service.js";
+import { stat } from 'node:fs/promises';
+import { assertSafeRef, listChangedSummaries, resolveWithinRepo, getFileAtRef, getFilesAtRefBatch, listChangedPaths, listUntrackedPaths } from "./git.service.js";
+/** Unchanged lines kept around each change in a hunk, as in `git diff`. */
+const CONTEXT_LINES = 3;
+/** Stamp of a worktree file that cannot be read. */
+const GONE_STAMP = 'gone';
+/**
+ * Line count and binary flag of untracked files, by repository and path. A refetch runs on
+ * every save, so an untracked file is read again only when its stamp changes.
+ */
+const untrackedCounts = new Map();
 function splitLines(text) {
     if (text === '')
         return [];
@@ -8,7 +18,6 @@ function splitLines(text) {
         lines.pop();
     return lines;
 }
-const CONTEXT_LINES = 3;
 function windowHunks(lines, contextLines = CONTEXT_LINES) {
     if (lines.length === 0)
         return [];
@@ -160,3 +169,113 @@ export async function getCommitsDiff(repoPath, from, to) {
     assertSafeRef(to);
     return buildDiffFiles(repoPath, [from, to], from, to);
 }
+/**
+ * `mtime:ctime:inode:size` of a file in the worktree. It costs no read. The inode catches
+ * a file replaced by rename. Known limit: an edit of the same size within one timestamp
+ * tick of the file system keeps the stamp.
+ */
+async function worktreeStamp(repoPath, path) {
+    try {
+        const info = await stat(resolveWithinRepo(repoPath, path));
+        return `${info.mtimeMs}:${info.ctimeMs}:${info.ino}:${info.size}`;
+    }
+    catch {
+        return GONE_STAMP;
+    }
+}
+function countLines(content) {
+    return splitLines(content).length;
+}
+/**
+ * Builds a signature from both sides of the diff. Equal signatures must mean equal hunks,
+ * so the old side counts too: a change of only HEAD or only the index changes the hunks.
+ */
+function signatureOf(change, oldSide, newSide) {
+    return [
+        change.status,
+        change.oldPath,
+        change.newPath,
+        change.additions,
+        change.deletions,
+        oldSide,
+        newSide
+    ].join('|');
+}
+/** Counts the lines of an untracked file. The file is read only when its stamp changed. */
+async function untrackedSummary(repoPath, path) {
+    const stamp = await worktreeStamp(repoPath, path);
+    const key = `${repoPath}\0${path}`;
+    let counts = untrackedCounts.get(key);
+    if (!counts || counts.stamp !== stamp) {
+        const file = await getFileAtRef(repoPath, 'WORKTREE', path);
+        counts = {
+            stamp,
+            additions: file.isBinary ? 0 : countLines(file.content),
+            isBinary: file.isBinary
+        };
+        if (stamp === GONE_STAMP) {
+            untrackedCounts.delete(key);
+        }
+        else {
+            untrackedCounts.set(key, counts);
+        }
+    }
+    const change = {
+        oldPath: path,
+        newPath: path,
+        status: 'added',
+        additions: counts.additions,
+        deletions: 0,
+        isBinary: counts.isBinary
+    };
+    return { ...change, signature: signatureOf(change, '', stamp) };
+}
+/** Drops the cached counts of files that are no longer untracked in this repository. */
+function pruneUntrackedCounts(repoPath, untrackedPaths) {
+    const prefix = `${repoPath}\0`;
+    const alive = new Set(untrackedPaths.map(path => prefix + path));
+    for (const key of untrackedCounts.keys()) {
+        if (key.startsWith(prefix) && !alive.has(key))
+            untrackedCounts.delete(key);
+    }
+}
+/**
+ * Lists the files of one diff side with counts and a signature, but no hunks (ADR 0033).
+ * Counts come from git, the hunks of `getFileDiff` from `diffLines`: they may differ by a few lines.
+ */
+export async function getDiffSummaries(repoPath, source) {
+    if (source === 'staged') {
+        const changes = await listChangedSummaries(repoPath, ['--cached']);
+        return changes.map(({ oldOid, newOid, ...change }) => ({
+            ...change,
+            signature: signatureOf(change, oldOid, newOid)
+        }));
+    }
+    const [changes, untrackedPaths] = await Promise.all([
+        listChangedSummaries(repoPath, []),
+        listUntrackedPaths(repoPath)
+    ]);
+    // The new side is the worktree: git prints zeros for its blob id, so a stamp stands in.
+    const tracked = await Promise.all(changes.map(async ({ oldOid, newOid: _newOid, ...change }) => ({
+        ...change,
+        signature: signatureOf(change, oldOid, await worktreeStamp(repoPath, change.newPath))
+    })));
+    const untracked = await Promise.all(untrackedPaths.map(path => untrackedSummary(repoPath, path)));
+    pruneUntrackedCounts(repoPath, untrackedPaths);
+    return [...tracked, ...untracked];
+}
+/**
+ * Builds the diff of one file. The caller passes the summary's paths and status, so no
+ * whole-repository listing runs per file. Untracked files have no index entry: their old side is empty.
+ */
+export async function getFileDiff(repoPath, source, meta) {
+    const [oldRef, newRef] = source === 'staged' ? ['HEAD', 'INDEX'] : ['INDEX', 'WORKTREE'];
+    const [oldFile, newFile] = await Promise.all([
+        getFileAtRef(repoPath, oldRef, meta.oldPath),
+        getFileAtRef(repoPath, newRef, meta.newPath)
+    ]);
+    return computeFileDiff(oldFile.content, newFile.content, {
+        ...meta,
+        isBinary: oldFile.isBinary || newFile.isBinary
+    });
+}

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

@@ -1,8 +1,7 @@
+import { ExportNotFoundError } from "../errors/export.js";
 import { findReviewById } from "../repositories/review.repo.js";
 import { listCommentsByReview } from "../repositories/comment.repo.js";
 import { getFileAtRef } from "./git.service.js";
-export class ExportNotFoundError extends Error {
-}
 const STATUS_LABELS = {
     in_progress: 'в процессе',
     approved: 'одобрено',

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

@@ -3,13 +3,14 @@ import { promisify } from 'node:util';
 import { readFile } from 'node:fs/promises';
 import { basename, resolve, sep } from 'node:path';
 import { simpleGit } from 'simple-git';
+import { isBinaryBuffer } from "../utils/text.js";
 const execFileAsync = promisify(execFile);
 /**
  * Resolves `path` against `repoPath` and rejects anything that escapes the
  * repository root (e.g. `../../etc/passwd`), since `path` here is untrusted
  * input coming straight off the HTTP request.
  */
-function resolveWithinRepo(repoPath, path) {
+export function resolveWithinRepo(repoPath, path) {
     const repoRoot = resolve(repoPath);
     const resolved = resolve(repoRoot, path);
     if (resolved !== repoRoot && !resolved.startsWith(repoRoot + sep)) {
@@ -62,10 +63,8 @@ export async function getFileAtRef(repoPath, ref, path) {
         try {
             const absolutePath = resolveWithinRepo(repoPath, path);
             const buffer = await readFile(absolutePath);
-            return {
-                content: buffer.includes(0) ? '' : buffer.toString('utf-8'),
-                isBinary: buffer.includes(0)
-            };
+            const isBinary = isBinaryBuffer(buffer);
+            return { content: isBinary ? '' : buffer.toString('utf-8'), isBinary };
         }
         catch {
             return { content: '', isBinary: false };
@@ -78,7 +77,7 @@ export async function getFileAtRef(repoPath, ref, path) {
             encoding: 'buffer',
             maxBuffer: 1024 * 1024 * 100
         });
-        const isBinary = stdout.includes(0);
+        const isBinary = isBinaryBuffer(stdout);
         return {
             content: isBinary ? '' : stdout.toString('utf-8'),
             isBinary
@@ -119,7 +118,7 @@ function parseCatFileBatchOutput(buffer, count) {
             throw new Error('git cat-file --batch: truncated output (short content)');
         }
         offset += size + 1; // skip content + its trailing LF
-        const isBinary = content.includes(0);
+        const isBinary = isBinaryBuffer(content);
         results.push({
             content: isBinary ? '' : content.toString('utf-8'),
             isBinary
@@ -212,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
@@ -234,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/server/services/review.service.js

@@ -1,10 +1,10 @@
-import { createReview as insertReview, findReviewById, listReviews, updateReviewStatus as updateReviewStatusRepo, deleteReview as deleteReviewRepo, UniqueNameError } from "../repositories/review.repo.js";
+import { ValidationError } from "../errors/reviews.js";
+import { createReview as insertReview, findReviewById, listReviews, updateReviewStatus as updateReviewStatusRepo, deleteReview as deleteReviewRepo } from "../repositories/review.repo.js";
+import { UniqueNameError } from "../errors/reviews.js";
 import { listCommentsByReview, deleteComment } from "../repositories/comment.repo.js";
 import { insertReviewFiles, deleteReviewFiles } from "../repositories/review-file.repo.js";
 import { getStagedDiff, getUnstagedDiff, getBranchDiff, getCommitsDiff } from "./diff.service.js";
 import { getRepositoryInfo } from "./git.service.js";
-export class ValidationError extends Error {
-}
 const REVIEW_NAME_MONTHS_RU = [
     'янв',
     'февр',

package/dist/server/utils/executable.js

@@ -0,0 +1,26 @@
+import { accessSync, constants } from 'node:fs';
+import { delimiter, isAbsolute, join } from 'node:path';
+export function isOnPath(binary, pathEnv = process.env.PATH) {
+    if (isAbsolute(binary)) {
+        try {
+            accessSync(binary, constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    for (const dir of (pathEnv ?? '').split(delimiter)) {
+        if (dir === '') {
+            continue;
+        }
+        try {
+            accessSync(join(dir, binary), constants.X_OK);
+            return true;
+        }
+        catch {
+            // not in this directory
+        }
+    }
+    return false;
+}

package/dist/server/utils/file-name.js

@@ -0,0 +1,6 @@
+import { basename } from 'node:path';
+/** The client-supplied name must not escape the directory it is written into. */
+export function safeFileName(name) {
+    const base = basename(name.replaceAll('\\', '/')).replaceAll('\0', '');
+    return base === '' || base === '.' || base === '..' ? 'attachment' : base;
+}

package/dist/server/utils/sse.js

@@ -0,0 +1,11 @@
+/**
+ * Sends one SSE message and never fails. A client can leave at any time, and
+ * `send` then rejects. Nothing awaits that promise, so Node would end the
+ * process on the unhandled rejection.
+ */
+export function safeSend(sse, message) {
+    if (!sse.isConnected) {
+        return;
+    }
+    sse.send(message).catch(() => { });
+}

package/dist/server/utils/text.js

@@ -0,0 +1,29 @@
+/** Ends a cut text when the caller gives no marker of its own. */
+const DEFAULT_TRUNCATION_MARKER = '\n… (truncated)';
+/**
+ * Cuts `text` to `max` characters. `marker` gets the number of characters
+ * dropped and returns what is appended, so each caller can tell its reader
+ * (browser, agent) what happened.
+ */
+export function truncateText(text, max, marker = () => DEFAULT_TRUNCATION_MARKER) {
+    return text.length > max
+        ? `${text.slice(0, max)}${marker(text.length - max)}`
+        : text;
+}
+/** True when the bytes contain a NUL: the quick test git itself uses to call a file binary. */
+export function isBinaryBuffer(bytes) {
+    return bytes.includes(0);
+}
+/**
+ * The text of `bytes` if they are valid UTF-8 without NUL, else `null`.
+ * Stricter than `Buffer#toString`, which turns bad bytes into U+FFFD.
+ */
+export function decodeText(bytes) {
+    try {
+        const text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        return text.includes('\0') ? null : text;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/shared/agents/chat-names.js

@@ -0,0 +1,17 @@
+const normalize = (name) => name.trim().toLowerCase();
+/**
+ * `base` if no chat has that name yet, else `base (1)`, `base (2)`, … — the
+ * first free one. Names compare without regard to case or surrounding blanks,
+ * so open chats can always be told apart in the tabs and the menu.
+ */
+export function uniqueChatName(base, taken) {
+    const used = new Set(taken.map(normalize));
+    const wanted = base.trim();
+    if (!used.has(normalize(wanted)))
+        return wanted;
+    for (let n = 1;; n++) {
+        const candidate = `${wanted} (${n})`;
+        if (!used.has(normalize(candidate)))
+            return candidate;
+    }
+}

package/dist/shared/agents/constants.js

@@ -0,0 +1,6 @@
+/** Chats open at once (ADR 0024); the server refuses more, the UI hides "add". */
+export const MAX_AGENT_SESSIONS = 5;
+/** Raw bytes per attachment; shared by the upload UI and the server. */
+export const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+export const DEFAULT_FILE_SEARCH_LIMIT = 30;
+export const MAX_FILE_SEARCH_LIMIT = 100;

package/dist/shared/agents/context-format.js

@@ -0,0 +1,17 @@
+export function formatDiffFile(file) {
+    const lines = [
+        `--- ${file.oldPath ? `a/${file.oldPath}` : '/dev/null'}`,
+        `+++ ${file.newPath ? `b/${file.newPath}` : '/dev/null'}`
+    ];
+    if (file.isBinary) {
+        lines.push('(binary file)');
+    }
+    for (const hunk of file.hunks) {
+        lines.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
+        for (const line of hunk.lines) {
+            const prefix = line.type === 'added' ? '+' : line.type === 'removed' ? '-' : ' ';
+            lines.push(prefix + line.content);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/shared/agents/file-search.js

@@ -0,0 +1,48 @@
+function isSubsequence(needle, haystack) {
+    let at = 0;
+    for (const char of haystack) {
+        if (char === needle[at]) {
+            at++;
+        }
+        if (at === needle.length) {
+            return true;
+        }
+    }
+    return needle.length === 0;
+}
+/** Lower is better; undefined = no match. */
+function score(path, query) {
+    const lower = path.toLowerCase();
+    const base = lower.slice(lower.lastIndexOf('/') + 1);
+    if (base === query)
+        return 0;
+    if (base.startsWith(query))
+        return 1;
+    if (base.includes(query))
+        return 2;
+    if (lower.includes(query))
+        return 3;
+    if (isSubsequence(query, lower))
+        return 4;
+    return undefined;
+}
+/**
+ * Orders `files` by how well they match `query`: file name first (exact,
+ * prefix, substring), then anywhere in the path, then as scattered letters.
+ * Ties go to the shorter path. An empty query matches everything.
+ */
+export function rankFiles(files, query) {
+    const needle = query.trim().toLowerCase();
+    const scored = [];
+    for (const path of files) {
+        const rank = needle === '' ? 0 : score(path, needle);
+        if (rank !== undefined) {
+            scored.push({ path, rank });
+        }
+    }
+    return scored
+        .sort((a, b) => a.rank - b.rank ||
+        a.path.length - b.path.length ||
+        a.path.localeCompare(b.path))
+        .map(entry => entry.path);
+}

package/dist/shared/agents/schemas.js

@@ -0,0 +1,51 @@
+import { Type } from '@sinclair/typebox';
+import { MAX_ATTACHMENT_BYTES, MAX_FILE_SEARCH_LIMIT } from "./constants.js";
+export const SessionParams = Type.Object({ id: Type.String() });
+export const PermissionParams = Type.Object({
+    id: Type.String(),
+    requestId: Type.String()
+});
+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() });
+export const FileSearchQuery = Type.Object({
+    q: Type.Optional(Type.String({ maxLength: 200 })),
+    limit: Type.Optional(Type.Integer({ minimum: 1, maximum: MAX_FILE_SEARCH_LIMIT }))
+});
+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 }))
+    }),
+    Type.Object({
+        kind: Type.Literal('file'),
+        path: Type.String({ minLength: 1 })
+    }),
+    Type.Object({ kind: Type.Literal('review'), reviewId: Type.String() }),
+    Type.Object({
+        kind: Type.Literal('attachment'),
+        name: Type.String({ minLength: 1, maxLength: 255 }),
+        mimeType: Type.String({ maxLength: 255 }),
+        data: Type.String({
+            maxLength: Math.ceil(MAX_ATTACHMENT_BYTES / 3) * 4
+        })
+    })
+]);
+export const PromptBody = Type.Object({
+    text: Type.String({ minLength: 1 }),
+    context: Type.Optional(Type.Array(ContextItem, { maxItems: 20 }))
+});
+export const PermissionBody = Type.Object({
+    optionId: Type.Optional(Type.String())
+});
+export const ConfigBody = Type.Object({
+    configId: Type.String({ minLength: 1 }),
+    // 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({})
+});