@tequila99/githuman 0.1.0

package/dist/server/repositories/review.repo.js

@@ -0,0 +1,41 @@
+function rowToReview(row) {
+    return {
+        id: row.id,
+        repositoryPath: row.repository_path,
+        baseRef: row.base_ref,
+        sourceType: row.source_type,
+        sourceRef: row.source_ref,
+        snapshotData: row.snapshot_data,
+        status: row.status,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+    };
+}
+export function createReview(db, review) {
+    db.prepare(`INSERT INTO reviews (id, repository_path, base_ref, source_type, source_ref, snapshot_data, status, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(review.id, review.repositoryPath, review.baseRef, review.sourceType, review.sourceRef, review.snapshotData, review.status, review.createdAt, review.updatedAt);
+    return review;
+}
+export function findReviewById(db, id) {
+    const row = db.prepare('SELECT * FROM reviews WHERE id = ?').get(id);
+    return row ? rowToReview(row) : null;
+}
+export function listReviews(db) {
+    const rows = db
+        .prepare('SELECT * FROM reviews ORDER BY created_at DESC')
+        .all();
+    return rows.map(rowToReview);
+}
+export function deleteReview(db, id) {
+    db.prepare('DELETE FROM reviews WHERE id = ?').run(id);
+}
+export function updateReviewStatus(db, id, status) {
+    const updatedAt = new Date().toISOString();
+    const result = db
+        .prepare('UPDATE reviews SET status = ?, updated_at = ? WHERE id = ?')
+        .run(status, updatedAt, id);
+    if (result.changes === 0) {
+        return null;
+    }
+    return findReviewById(db, id);
+}

package/dist/server/routes/comments.js

@@ -0,0 +1,114 @@
+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";
+const CreateCommentBody = Type.Object({
+    filePath: Type.String({ minLength: 1 }),
+    lineNumber: Type.Optional(Type.Union([Type.Integer(), Type.Null()])),
+    lineType: Type.Optional(Type.Union([
+        Type.Literal('added'),
+        Type.Literal('removed'),
+        Type.Literal('context'),
+        Type.Null()
+    ])),
+    content: Type.String(),
+    suggestion: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+});
+const UpdateCommentBody = Type.Object({
+    content: Type.String()
+});
+const ReviewIdParams = Type.Object({ id: Type.String() });
+const CommentIdParams = Type.Object({ id: Type.String() });
+export async function commentRoutes(app, opts) {
+    const { db, eventBus } = 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;
+        }
+    });
+    typedApp.get('/api/reviews/:id/comments', { 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
+            };
+        }
+        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/resolve', { schema: { params: CommentIdParams } }, async (request, reply) => {
+        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
+            };
+        }
+        return updated;
+    });
+    typedApp.patch('/api/comments/:id/unresolve', { schema: { params: CommentIdParams } }, async (request, reply) => {
+        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
+            };
+        }
+        return updated;
+    });
+    typedApp.delete('/api/comments/:id', { schema: { params: CommentIdParams } }, async (request, reply) => {
+        removeComment(db, request.params.id, eventBus);
+        reply.code(204);
+    });
+}

package/dist/server/routes/diff.js

@@ -0,0 +1,39 @@
+import { Type } from '@sinclair/typebox';
+import { getStagedDiff, getUnstagedDiff, getBranchDiff, getCommitsDiff } from "../services/diff.service.js";
+const BranchQuery = Type.Object({
+    base: Type.String({ minLength: 1 })
+});
+const CommitsQuery = Type.Object({
+    from: Type.String({ minLength: 1 }),
+    to: Type.String({ minLength: 1 })
+});
+export async function diffRoutes(app, opts) {
+    const { repositoryPath } = opts;
+    const typedApp = app.withTypeProvider();
+    typedApp.get('/api/diff/staged', async () => {
+        return getStagedDiff(repositoryPath);
+    });
+    typedApp.get('/api/diff/unstaged', async () => {
+        return getUnstagedDiff(repositoryPath);
+    });
+    typedApp.get('/api/diff/branch', { schema: { querystring: BranchQuery } }, async (request, reply) => {
+        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 };
+        }
+    });
+    typedApp.get('/api/diff/commits', { schema: { querystring: CommitsQuery } }, async (request, reply) => {
+        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 };
+        }
+    });
+}

package/dist/server/routes/events.js

@@ -0,0 +1,16 @@
+export async function eventRoutes(app, opts) {
+    const { eventBus } = opts;
+    app.get('/api/events', { sse: true }, async (request, reply) => {
+        reply.sse.keepAlive();
+        await reply.sse.send({ event: 'connected', data: {} });
+        const unsubscribe = eventBus.subscribe(event => {
+            void reply.sse.send({
+                event: event.type,
+                data: { reviewId: event.reviewId }
+            });
+        });
+        reply.sse.onClose(() => {
+            unsubscribe();
+        });
+    });
+}

package/dist/server/routes/export.js

@@ -0,0 +1,27 @@
+import { Type } from '@sinclair/typebox';
+import { exportAsJson, exportAsMarkdown, ExportNotFoundError } 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 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;
+        }
+    });
+}

package/dist/server/routes/git.js

@@ -0,0 +1,100 @@
+import { Type } from '@sinclair/typebox';
+import { getRepositoryInfo, stagePaths, unstagePaths, discardPaths, getFilesAtRef, getFileAtRef } from "../services/git.service.js";
+const TreeParams = Type.Object({
+    ref: Type.String({ minLength: 1 })
+});
+const FileContentQuery = Type.Object({
+    ref: Type.String({ minLength: 1 })
+});
+/** Body for `/stage` and `/unstage`: an omitted/empty `paths` means "all". */
+const OptionalPathsBody = Type.Object({
+    paths: Type.Optional(Type.Array(Type.String()))
+});
+/** Body for `/discard`: `paths` is required — no "discard everything". */
+const DiscardBody = Type.Object({
+    paths: Type.Array(Type.String(), { minItems: 1 })
+});
+export async function gitRoutes(app, opts) {
+    const { repositoryPath } = opts;
+    const typedApp = app.withTypeProvider();
+    app.get('/api/git/info', async () => {
+        return getRepositoryInfo(repositoryPath);
+    });
+    typedApp.post('/api/git/stage', { schema: { body: OptionalPathsBody } }, async (request, reply) => {
+        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 };
+        }
+    });
+    typedApp.post('/api/git/unstage', { schema: { body: OptionalPathsBody } }, async (request, reply) => {
+        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 };
+        }
+    });
+    typedApp.post('/api/git/discard', { schema: { body: DiscardBody } }, async (request, reply) => {
+        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 };
+        }
+    });
+    typedApp.get('/api/git/tree/:ref', { schema: { params: TreeParams } }, async (request, reply) => {
+        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 };
+        }
+    });
+    typedApp.get('/api/git/file/*', { schema: { querystring: FileContentQuery } }, async (request, reply) => {
+        const filePath = request.params['*'];
+        const { ref } = request.query;
+        if (!filePath) {
+            reply.code(400);
+            return {
+                error: 'Bad Request',
+                message: 'File path is required',
+                statusCode: 400
+            };
+        }
+        let content;
+        let isBinary;
+        try {
+            ;
+            ({ 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 };
+        }
+        const lines = isBinary ? [] : content.split('\n');
+        return {
+            path: filePath,
+            ref,
+            content,
+            lines,
+            lineCount: lines.length,
+            isBinary
+        };
+    });
+}

package/dist/server/routes/health.js

@@ -0,0 +1,5 @@
+export async function healthRoutes(app) {
+    app.get('/health', async () => {
+        return { status: 'ok' };
+    });
+}

package/dist/server/routes/reviews.js

@@ -0,0 +1,90 @@
+import { Type } from '@sinclair/typebox';
+import { createReview, getReview, getReviews, setReviewStatus, removeReview, ValidationError } from "../services/review.service.js";
+const CreateReviewBody = Type.Object({
+    sourceType: Type.Optional(Type.Union([
+        Type.Literal('staged'),
+        Type.Literal('unstaged'),
+        Type.Literal('branch'),
+        Type.Literal('commits')
+    ])),
+    sourceRef: Type.Optional(Type.String()),
+    baseRef: Type.Optional(Type.String())
+});
+const UpdateReviewBody = Type.Object({
+    status: Type.Optional(Type.Union([
+        Type.Literal('in_progress'),
+        Type.Literal('approved'),
+        Type.Literal('changes_requested')
+    ]))
+});
+const ReviewIdParams = Type.Object({ id: Type.String() });
+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;
+        }
+    });
+    typedApp.get('/api/reviews', async () => {
+        return getReviews(db);
+    });
+    typedApp.get('/api/reviews/:id', { schema: { params: ReviewIdParams } }, async (request, reply) => {
+        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
+            };
+        }
+        return review;
+    });
+    typedApp.patch('/api/reviews/:id', { schema: { params: ReviewIdParams, body: UpdateReviewBody } }, async (request, reply) => {
+        if (!request.body.status) {
+            reply.code(400);
+            return {
+                error: 'Bad Request',
+                message: '"status" is required',
+                statusCode: 400
+            };
+        }
+        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
+            };
+        }
+        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
+            };
+        }
+        removeReview(db, request.params.id, eventBus);
+        reply.code(204);
+        return null;
+    });
+}

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

@@ -0,0 +1,57 @@
+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');
+    }
+    const now = new Date().toISOString();
+    const comment = {
+        id: crypto.randomUUID(),
+        reviewId,
+        filePath: input.filePath,
+        lineNumber: input.lineNumber ?? null,
+        lineType: input.lineType ?? null,
+        content: input.content,
+        createdAt: now,
+        updatedAt: now,
+        suggestion: input.suggestion ?? null
+    };
+    const created = insertComment(db, comment);
+    eventBus?.publish({ type: 'comment:created', reviewId });
+    return created;
+}
+export function getComments(db, reviewId) {
+    return listCommentsByReview(db, reviewId);
+}
+export function editComment(db, id, content, eventBus) {
+    if (!content) {
+        throw new ValidationError('"content" is required');
+    }
+    const updated = updateCommentRepo(db, id, content);
+    if (updated) {
+        eventBus?.publish({ type: 'comment:updated', reviewId: updated.reviewId });
+    }
+    return updated;
+}
+export function resolveComment(db, id, eventBus) {
+    const updated = setCommentResolved(db, id, true);
+    if (updated) {
+        eventBus?.publish({ type: 'comment:updated', reviewId: updated.reviewId });
+    }
+    return updated;
+}
+export function unresolveComment(db, id, eventBus) {
+    const updated = setCommentResolved(db, id, false);
+    if (updated) {
+        eventBus?.publish({ type: 'comment:updated', reviewId: updated.reviewId });
+    }
+    return updated;
+}
+export function removeComment(db, id, eventBus) {
+    const comment = findCommentById(db, id);
+    deleteCommentRepo(db, id);
+    if (comment) {
+        eventBus?.publish({ type: 'comment:deleted', reviewId: comment.reviewId });
+    }
+}

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

@@ -0,0 +1,144 @@
+import { diffLines } from 'diff';
+import { assertSafeRef, getFileAtRef, listChangedPaths, listUntrackedPaths } from "./git.service.js";
+function splitLines(text) {
+    if (text === '')
+        return [];
+    const lines = text.split('\n');
+    if (lines[lines.length - 1] === '')
+        lines.pop();
+    return lines;
+}
+const CONTEXT_LINES = 3;
+function windowHunks(lines, contextLines = CONTEXT_LINES) {
+    if (lines.length === 0)
+        return [];
+    const keep = Array.from({ length: lines.length }).fill(false);
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].type === 'context')
+            continue;
+        for (let j = Math.max(0, i - contextLines); j <= Math.min(lines.length - 1, i + contextLines); j++) {
+            keep[j] = true;
+        }
+    }
+    const hunks = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (!keep[i]) {
+            i += 1;
+            continue;
+        }
+        let j = i;
+        while (j < lines.length && keep[j])
+            j += 1;
+        const segment = lines.slice(i, j);
+        const oldNumbers = segment
+            .map(l => l.oldLineNumber)
+            .filter((n) => n !== null);
+        const newNumbers = segment
+            .map(l => l.newLineNumber)
+            .filter((n) => n !== null);
+        hunks.push({
+            oldStart: oldNumbers.length > 0 ? oldNumbers[0] : 0,
+            oldLines: oldNumbers.length,
+            newStart: newNumbers.length > 0 ? newNumbers[0] : 0,
+            newLines: newNumbers.length,
+            lines: segment
+        });
+        i = j;
+    }
+    return hunks;
+}
+export function computeFileDiff(oldContent, newContent, meta) {
+    const base = {
+        oldPath: meta.oldPath,
+        newPath: meta.newPath,
+        status: meta.status,
+        isBinary: meta.isBinary
+    };
+    if (meta.isBinary) {
+        return { ...base, additions: 0, deletions: 0, hunks: [] };
+    }
+    if (oldContent === newContent) {
+        return { ...base, additions: 0, deletions: 0, hunks: [] };
+    }
+    const parts = diffLines(oldContent, newContent);
+    let oldLineNumber = 1;
+    let newLineNumber = 1;
+    let additions = 0;
+    let deletions = 0;
+    const lines = [];
+    for (const part of parts) {
+        for (const content of splitLines(part.value)) {
+            if (part.added) {
+                lines.push({
+                    type: 'added',
+                    content,
+                    oldLineNumber: null,
+                    newLineNumber
+                });
+                newLineNumber += 1;
+                additions += 1;
+            }
+            else if (part.removed) {
+                lines.push({
+                    type: 'removed',
+                    content,
+                    oldLineNumber,
+                    newLineNumber: null
+                });
+                oldLineNumber += 1;
+                deletions += 1;
+            }
+            else {
+                lines.push({ type: 'context', content, oldLineNumber, newLineNumber });
+                oldLineNumber += 1;
+                newLineNumber += 1;
+            }
+        }
+    }
+    const hunks = windowHunks(lines);
+    return { ...base, additions, deletions, hunks };
+}
+async function buildDiffFiles(repoPath, diffArgs, oldRef, newRef) {
+    const changes = await listChangedPaths(repoPath, diffArgs);
+    return Promise.all(changes.map(async (change) => {
+        const [oldFile, newFile] = await Promise.all([
+            getFileAtRef(repoPath, oldRef, change.oldPath),
+            getFileAtRef(repoPath, newRef, change.newPath)
+        ]);
+        return computeFileDiff(oldFile.content, newFile.content, {
+            oldPath: change.oldPath,
+            newPath: change.newPath,
+            status: change.status,
+            isBinary: oldFile.isBinary || newFile.isBinary
+        });
+    }));
+}
+export async function getStagedDiff(repoPath) {
+    return buildDiffFiles(repoPath, ['--cached'], 'HEAD', 'INDEX');
+}
+export async function getUnstagedDiff(repoPath) {
+    const [trackedFiles, untrackedPaths] = await Promise.all([
+        buildDiffFiles(repoPath, [], 'INDEX', 'WORKTREE'),
+        listUntrackedPaths(repoPath)
+    ]);
+    const untrackedFiles = await Promise.all(untrackedPaths.map(async (path) => {
+        const worktreeFile = await getFileAtRef(repoPath, 'WORKTREE', path);
+        return computeFileDiff('', worktreeFile.content, {
+            oldPath: path,
+            newPath: path,
+            status: 'added',
+            isBinary: worktreeFile.isBinary
+        });
+    }));
+    return [...trackedFiles, ...untrackedFiles];
+}
+export async function getBranchDiff(repoPath, base) {
+    assertSafeRef(base);
+    return buildDiffFiles(repoPath, [base, 'HEAD'], base, 'HEAD');
+}
+export async function getCommitsDiff(repoPath, from, to) {
+    assertSafeRef(from);
+    assertSafeRef(to);
+    return buildDiffFiles(repoPath, [from, to], from, to);
+}