@tequila99/githuman 0.2.2 → 0.3.0

package/dist/server/routes/agent.js

@@ -0,0 +1,135 @@
+import { NotFoundError } from "../errors/http.js";
+import { SessionParams, PermissionParams, CreateSessionBody, AutoApproveBody, FileSearchQuery, PromptBody, PermissionBody, ConfigBody } from "../../shared/agents/schemas.js";
+import { buildPromptBlocks } from "../services/agent/context-builder.js";
+import { MAX_ATTACHMENT_BYTES, DEFAULT_FILE_SEARCH_LIMIT } from "../../shared/agents/constants.js";
+import { createFileIndex } from "../services/agent/file-index.js";
+import { safeSend } from "../utils/sse.js";
+import { requireLocalOrigin } from "../hooks/agents/local-origin.js";
+import { findReviewById } from "../repositories/review.repo.js";
+/** Room for a handful of max-size base64 attachments; the schema caps each one. */
+const PROMPT_BODY_LIMIT = 5 * Math.ceil((MAX_ATTACHMENT_BYTES * 4) / 3) + 1024 * 1024;
+export async function agentRoutes(app, opts) {
+    const { registry, db, repositoryPath, eventBus } = opts;
+    const typedApp = app.withTypeProvider();
+    const fileIndex = createFileIndex(repositoryPath, eventBus);
+    app.addHook('onRequest', requireLocalOrigin);
+    app.addHook('onClose', async () => {
+        registry.closeAll();
+        fileIndex.close();
+    });
+    typedApp.get('/api/agent/presets', async () => registry.listPresets());
+    typedApp.get('/api/agent/sessions', async () => registry.list());
+    typedApp.post('/api/agent/sessions', { schema: { body: CreateSessionBody } }, async (request, reply) => {
+        const { presetId, reviewId, name } = request.body;
+        if (reviewId !== undefined && !findReviewById(db, reviewId)) {
+            throw new NotFoundError(`Review ${reviewId} not found`);
+        }
+        // The agent starts in the background; failure shows up as a closed session.
+        const session = registry.create(presetId, reviewId ?? null, name);
+        reply.code(201);
+        return session.info();
+    });
+    typedApp.get('/api/agent/sessions/:id', { schema: { params: SessionParams } }, async (request) => {
+        const session = registry.get(request.params.id);
+        if (!session) {
+            throw new NotFoundError('Session not found');
+        }
+        return session.info();
+    });
+    typedApp.delete('/api/agent/sessions/:id', { schema: { params: SessionParams } }, async (request, reply) => {
+        if (!registry.close(request.params.id)) {
+            throw new NotFoundError('Session not found');
+        }
+        return reply.code(204).send();
+    });
+    typedApp.post('/api/agent/sessions/:id/prompt', {
+        schema: { params: SessionParams, body: PromptBody },
+        bodyLimit: PROMPT_BODY_LIMIT
+    }, async (request, reply) => {
+        const session = registry.get(request.params.id);
+        if (!session) {
+            throw new NotFoundError('Session not found');
+        }
+        session.assertCanPrompt();
+        const blocks = await buildPromptBlocks(request.body, {
+            db,
+            repositoryPath,
+            embeddedContext: session.supportsEmbeddedContext,
+            image: session.supportsImages,
+            attachmentDir: session.attachmentDir
+        });
+        session.prompt(blocks, request.body);
+        return reply.code(202).send();
+    });
+    typedApp.post('/api/agent/sessions/:id/cancel', { schema: { params: SessionParams } }, async (request, reply) => {
+        const session = registry.get(request.params.id);
+        if (!session) {
+            throw new NotFoundError('Session not found');
+        }
+        await session.cancel();
+        return reply.code(204).send();
+    });
+    typedApp.post('/api/agent/sessions/:id/permissions/:requestId', { schema: { params: PermissionParams, body: PermissionBody } }, async (request, reply) => {
+        const session = registry.get(request.params.id);
+        if (!session?.answerPermission(request.params.requestId, request.body.optionId)) {
+            throw new NotFoundError('No such pending permission request');
+        }
+        return reply.code(204).send();
+    });
+    typedApp.post('/api/agent/sessions/:id/config', { schema: { params: SessionParams, body: ConfigBody } }, async (request, reply) => {
+        const session = registry.get(request.params.id);
+        if (!session) {
+            throw new NotFoundError('Session not found');
+        }
+        await session.setConfig(request.body.configId, request.body.value);
+        return reply.code(204).send();
+    });
+    typedApp.post('/api/agent/sessions/:id/auto-approve', { schema: { params: SessionParams, body: AutoApproveBody } }, async (request, reply) => {
+        const session = registry.get(request.params.id);
+        if (!session) {
+            throw new NotFoundError('Session not found');
+        }
+        session.setAutoApprove(request.body.enabled);
+        return reply.code(204).send();
+    });
+    typedApp.get('/api/agent/files', { schema: { querystring: FileSearchQuery } }, async (request) => ({
+        files: await fileIndex.search(request.query.q ?? '', request.query.limit ?? DEFAULT_FILE_SEARCH_LIMIT)
+    }));
+    // One stream for every chat (ADR 0024): browsers allow ~6 connections per
+    // origin over HTTP/1.1, so a stream per session would starve the page's own
+    // requests. Event ids are shared across sessions, so `Last-Event-ID` works.
+    typedApp.get('/api/agent/events', { sse: true }, async (request, reply) => {
+        const lastEventId = Number(request.headers['last-event-id']);
+        reply.sse.keepAlive();
+        // Flushes the headers: with no session yet nothing else would be sent, and
+        // the browser would not consider the stream open.
+        await reply.sse.send({ event: 'connected', data: {} });
+        // The client can leave during the await. `onClose` callbacks run once, so
+        // one added after the close would never run and the listener would leak.
+        if (!reply.sse.isConnected) {
+            return;
+        }
+        const unsubscribe = registry.subscribe(message => {
+            if (message.type === 'event') {
+                safeSend(reply.sse, {
+                    id: String(message.envelope.id),
+                    event: 'agent',
+                    data: message.envelope
+                });
+            }
+            else if (message.type === 'gap') {
+                safeSend(reply.sse, {
+                    event: 'gap',
+                    data: { sessionId: message.sessionId }
+                });
+            }
+            else if (message.type === 'state') {
+                safeSend(reply.sse, { event: 'state', data: message.state });
+            }
+            else {
+                safeSend(reply.sse, { event: 'sessions', data: {} });
+            }
+        }, Number.isInteger(lastEventId) ? lastEventId : 0);
+        reply.sse.onClose(unsubscribe);
+    });
+}

package/dist/server/routes/comments.js

@@ -1,18 +1,22 @@
+import { NotFoundError } from "../errors/http.js";
 import { Type } from '@sinclair/typebox';
 import { getReview } from "../services/review.service.js";
-import { createComment, getComments, editComment, removeComment, resolveComment, unresolveComment, ValidationError } from "../services/comment.service.js";
+import { createComment, getComments, editComment, removeComment, resolveComment, unresolveComment } from "../services/comment.service.js";
+// 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.
 const CreateCommentBody = Type.Object({
     filePath: Type.String({ minLength: 1 }),
-    lineNumber: Type.Optional(Type.Union([Type.Integer(), Type.Null()])),
-    lineNumberEnd: Type.Optional(Type.Union([Type.Integer(), Type.Null()])),
+    lineNumber: Type.Optional(Type.Union([Type.Null(), Type.Integer()])),
+    lineNumberEnd: Type.Optional(Type.Union([Type.Null(), Type.Integer()])),
     lineType: Type.Optional(Type.Union([
+        Type.Null(),
         Type.Literal('added'),
         Type.Literal('removed'),
-        Type.Literal('context'),
-        Type.Null()
+        Type.Literal('context')
     ])),
     content: Type.String(),
-    suggestion: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+    suggestion: Type.Optional(Type.Union([Type.Null(), Type.String()]))
 });
 const UpdateCommentBody = Type.Object({
     content: Type.String()
@@ -24,87 +28,36 @@ export async function commentRoutes(app, opts) {
     const typedApp = app.withTypeProvider();
     typedApp.post('/api/reviews/:id/comments', { schema: { params: ReviewIdParams, body: CreateCommentBody } }, async (request, reply) => {
         if (!getReview(db, request.params.id)) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
-        }
-        try {
-            const comment = createComment(db, request.params.id, request.body, eventBus);
-            reply.code(201);
-            return comment;
-        }
-        catch (error) {
-            if (error instanceof ValidationError) {
-                reply.code(400);
-                return {
-                    error: 'Bad Request',
-                    message: error.message,
-                    statusCode: 400
-                };
-            }
-            throw error;
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
+        const comment = createComment(db, request.params.id, request.body, eventBus);
+        reply.code(201);
+        return comment;
     });
-    typedApp.get('/api/reviews/:id/comments', { schema: { params: ReviewIdParams } }, async (request, reply) => {
+    typedApp.get('/api/reviews/:id/comments', { schema: { params: ReviewIdParams } }, async (request) => {
         if (!getReview(db, request.params.id)) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
         return getComments(db, request.params.id);
     });
-    typedApp.patch('/api/comments/:id', { schema: { params: CommentIdParams, body: UpdateCommentBody } }, async (request, reply) => {
-        try {
-            const updated = editComment(db, request.params.id, request.body.content, eventBus);
-            if (!updated) {
-                reply.code(404);
-                return {
-                    error: 'Not Found',
-                    message: `Comment ${request.params.id} not found`,
-                    statusCode: 404
-                };
-            }
-            return updated;
-        }
-        catch (error) {
-            if (error instanceof ValidationError) {
-                reply.code(400);
-                return {
-                    error: 'Bad Request',
-                    message: error.message,
-                    statusCode: 400
-                };
-            }
-            throw error;
+    typedApp.patch('/api/comments/:id', { schema: { params: CommentIdParams, body: UpdateCommentBody } }, async (request) => {
+        const updated = editComment(db, request.params.id, request.body.content, eventBus);
+        if (!updated) {
+            throw new NotFoundError(`Comment ${request.params.id} not found`);
         }
+        return updated;
     });
-    typedApp.patch('/api/comments/:id/resolve', { schema: { params: CommentIdParams } }, async (request, reply) => {
+    typedApp.patch('/api/comments/:id/resolve', { schema: { params: CommentIdParams } }, async (request) => {
         const updated = resolveComment(db, request.params.id, eventBus);
         if (!updated) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Comment ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Comment ${request.params.id} not found`);
         }
         return updated;
     });
-    typedApp.patch('/api/comments/:id/unresolve', { schema: { params: CommentIdParams } }, async (request, reply) => {
+    typedApp.patch('/api/comments/:id/unresolve', { schema: { params: CommentIdParams } }, async (request) => {
         const updated = unresolveComment(db, request.params.id, eventBus);
         if (!updated) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Comment ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Comment ${request.params.id} not found`);
         }
         return updated;
     });

package/dist/server/routes/diff.js

@@ -1,3 +1,4 @@
+import { BadRequestError } from "../errors/http.js";
 import { Type } from '@sinclair/typebox';
 import { getStagedDiff, getUnstagedDiff, getBranchDiff, getCommitsDiff } from "../services/diff.service.js";
 const BranchQuery = Type.Object({
@@ -16,24 +17,22 @@ export async function diffRoutes(app, opts) {
     typedApp.get('/api/diff/unstaged', async () => {
         return getUnstagedDiff(repositoryPath);
     });
-    typedApp.get('/api/diff/branch', { schema: { querystring: BranchQuery } }, async (request, reply) => {
+    typedApp.get('/api/diff/branch', { schema: { querystring: BranchQuery } }, async (request) => {
         try {
             return await getBranchDiff(repositoryPath, request.query.base);
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Bad ref';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.get('/api/diff/commits', { schema: { querystring: CommitsQuery } }, async (request, reply) => {
+    typedApp.get('/api/diff/commits', { schema: { querystring: CommitsQuery } }, async (request) => {
         try {
             return await getCommitsDiff(repositoryPath, request.query.from, request.query.to);
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Bad ref';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
 }

package/dist/server/routes/events.js

@@ -1,10 +1,16 @@
+import { safeSend } from "../utils/sse.js";
 export async function eventRoutes(app, opts) {
-    const { eventBus } = opts;
+    const { eventBus, instanceId } = opts;
+    const hello = { instanceId };
     app.get('/api/events', { sse: true }, async (request, reply) => {
         reply.sse.keepAlive();
-        await reply.sse.send({ event: 'connected', data: {} });
+        await reply.sse.send({ event: 'connected', data: hello });
+        // The client can leave during the await; a later `onClose` would never run.
+        if (!reply.sse.isConnected) {
+            return;
+        }
         const unsubscribe = eventBus.subscribe(event => {
-            void reply.sse.send({
+            safeSend(reply.sse, {
                 event: event.type,
                 data: { reviewId: event.reviewId }
             });

package/dist/server/routes/export.js

@@ -1,27 +1,18 @@
 import { Type } from '@sinclair/typebox';
-import { exportAsJson, exportAsMarkdown, ExportNotFoundError } from "../services/export.service.js";
+import { exportAsJson, exportAsMarkdown } from "../services/export.service.js";
 const ExportParams = Type.Object({ id: Type.String() });
 const ExportQuery = Type.Object({
     format: Type.Union([Type.Literal('json'), Type.Literal('markdown')])
 });
 export async function exportRoutes(app, opts) {
-    const { db } = opts;
+    const { db, repositoryPath } = opts;
     const typedApp = app.withTypeProvider();
     typedApp.get('/api/reviews/:id/export', { schema: { params: ExportParams, querystring: ExportQuery } }, async (request, reply) => {
-        try {
-            if (request.query.format === 'json') {
-                return exportAsJson(db, request.params.id);
-            }
-            const markdown = exportAsMarkdown(db, request.params.id);
-            reply.type('text/markdown');
-            return markdown;
-        }
-        catch (error) {
-            if (error instanceof ExportNotFoundError) {
-                reply.code(404);
-                return { error: 'Not Found', message: error.message, statusCode: 404 };
-            }
-            throw error;
+        if (request.query.format === 'json') {
+            return exportAsJson(db, request.params.id);
         }
+        const markdown = await exportAsMarkdown(db, request.params.id, repositoryPath);
+        reply.type('text/markdown');
+        return markdown;
     });
 }

package/dist/server/routes/git.js

@@ -1,3 +1,4 @@
+import { BadRequestError } from "../errors/http.js";
 import { Type } from '@sinclair/typebox';
 import { getRepositoryInfo, stagePaths, unstagePaths, discardPaths, getFilesAtRef, getFileAtRef } from "../services/git.service.js";
 const TreeParams = Type.Object({
@@ -20,61 +21,52 @@ export async function gitRoutes(app, opts) {
     app.get('/api/git/info', async () => {
         return getRepositoryInfo(repositoryPath);
     });
-    typedApp.post('/api/git/stage', { schema: { body: OptionalPathsBody } }, async (request, reply) => {
+    typedApp.post('/api/git/stage', { schema: { body: OptionalPathsBody } }, async (request) => {
         try {
             await stagePaths(repositoryPath, request.body.paths ?? []);
             return { ok: true };
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to stage';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.post('/api/git/unstage', { schema: { body: OptionalPathsBody } }, async (request, reply) => {
+    typedApp.post('/api/git/unstage', { schema: { body: OptionalPathsBody } }, async (request) => {
         try {
             await unstagePaths(repositoryPath, request.body.paths ?? []);
             return { ok: true };
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to unstage';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.post('/api/git/discard', { schema: { body: DiscardBody } }, async (request, reply) => {
+    typedApp.post('/api/git/discard', { schema: { body: DiscardBody } }, async (request) => {
         try {
             await discardPaths(repositoryPath, request.body.paths);
             return { ok: true };
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to discard changes';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.get('/api/git/tree/:ref', { schema: { params: TreeParams } }, async (request, reply) => {
+    typedApp.get('/api/git/tree/:ref', { schema: { params: TreeParams } }, async (request) => {
         const { ref } = request.params;
         try {
             const files = await getFilesAtRef(repositoryPath, ref);
             return { ref, files };
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to list files';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
     });
-    typedApp.get('/api/git/file/*', { schema: { querystring: FileContentQuery } }, async (request, reply) => {
+    typedApp.get('/api/git/file/*', { schema: { querystring: FileContentQuery } }, async (request) => {
         const filePath = request.params['*'];
         const { ref } = request.query;
         if (!filePath) {
-            reply.code(400);
-            return {
-                error: 'Bad Request',
-                message: 'File path is required',
-                statusCode: 400
-            };
+            throw new BadRequestError('File path is required');
         }
         let content;
         let isBinary;
@@ -83,9 +75,8 @@ export async function gitRoutes(app, opts) {
             ({ content, isBinary } = await getFileAtRef(repositoryPath, ref, filePath));
         }
         catch (err) {
-            reply.code(400);
             const message = err instanceof Error ? err.message : 'Failed to read file';
-            return { error: 'Bad Request', message, statusCode: 400 };
+            throw new BadRequestError(message, { cause: err });
         }
         const lines = isBinary ? [] : content.split('\n');
         return {

package/dist/server/routes/reviews.js

@@ -1,5 +1,6 @@
+import { NotFoundError, BadRequestError } from "../errors/http.js";
 import { Type } from '@sinclair/typebox';
-import { createReview, getReview, getReviews, setReviewStatus, removeReview, ValidationError } from "../services/review.service.js";
+import { createReview, getReview, getReviews, setReviewStatus, removeReview } from "../services/review.service.js";
 import { getRepositoryInfo } from "../services/git.service.js";
 const CreateReviewBody = Type.Object({
     sourceType: Type.Optional(Type.Union([
@@ -33,22 +34,9 @@ export async function reviewRoutes(app, opts) {
     const { repositoryPath, db, eventBus } = opts;
     const typedApp = app.withTypeProvider();
     typedApp.post('/api/reviews', { schema: { body: CreateReviewBody } }, async (request, reply) => {
-        try {
-            const review = await createReview(db, repositoryPath, request.body, eventBus);
-            reply.code(201);
-            return review;
-        }
-        catch (error) {
-            if (error instanceof ValidationError) {
-                reply.code(400);
-                return {
-                    error: 'Bad Request',
-                    message: error.message,
-                    statusCode: 400
-                };
-            }
-            throw error;
-        }
+        const review = await createReview(db, repositoryPath, request.body, eventBus);
+        reply.code(201);
+        return review;
     });
     typedApp.get('/api/reviews', { schema: { querystring: ReviewsQuery } }, async (request) => {
         const { branch, search, createdFrom, createdTo, files } = request.query;
@@ -63,46 +51,26 @@ export async function reviewRoutes(app, opts) {
                 : undefined
         });
     });
-    typedApp.get('/api/reviews/:id', { schema: { params: ReviewIdParams } }, async (request, reply) => {
+    typedApp.get('/api/reviews/:id', { schema: { params: ReviewIdParams } }, async (request) => {
         const review = getReview(db, request.params.id);
         if (!review) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
         return review;
     });
-    typedApp.patch('/api/reviews/:id', { schema: { params: ReviewIdParams, body: UpdateReviewBody } }, async (request, reply) => {
+    typedApp.patch('/api/reviews/:id', { schema: { params: ReviewIdParams, body: UpdateReviewBody } }, async (request) => {
         if (!request.body.status) {
-            reply.code(400);
-            return {
-                error: 'Bad Request',
-                message: '"status" is required',
-                statusCode: 400
-            };
+            throw new BadRequestError('"status" is required');
         }
         const updated = setReviewStatus(db, request.params.id, request.body.status, eventBus);
         if (!updated) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
         return updated;
     });
     typedApp.delete('/api/reviews/:id', { schema: { params: ReviewIdParams } }, async (request, reply) => {
         if (!getReview(db, request.params.id)) {
-            reply.code(404);
-            return {
-                error: 'Not Found',
-                message: `Review ${request.params.id} not found`,
-                statusCode: 404
-            };
+            throw new NotFoundError(`Review ${request.params.id} not found`);
         }
         removeReview(db, request.params.id, eventBus);
         reply.code(204);