@tequila99/githuman 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivan Milovanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,152 @@
+# GitHuman
+
+Локальный CLI + веб-интерфейс для просмотра изменений в git-репозитории —
+staged/unstaged diff, сравнение веток и коммитов, браузер файлов с
+подсветкой синтаксиса — до коммита. Данные никуда не уходят: всё работает
+локально, поверх обычного `git`.
+
+Идея и часть архитектуры унаследованы от оригинального
+[mcollina/githuman](https://github.com/mcollina/githuman) (MIT) — эта версия
+переосмысливает стек (Fastify + `node:sqlite` на бэкенде, Vue 3 + Quasar на
+фронтенде вместо React) и интерфейс.
+
+## Что уже работает
+
+- Просмотр diff: staged, unstaged, между ветками, между произвольными
+  коммитами.
+- Браузер файлов репозитория (не только изменённых) с подсветкой
+  синтаксиса (shiki).
+- Live-обновления через SSE: интерфейс сам обновляется при изменении
+  файлов в репозитории — удобно смотреть, как редактирует код AI-агент.
+- Ручной/авто выбор тёмной-светлой темы.
+- CLI: `serve` (поднять сервер), `list`/`export` (быстрый доступ к
+  сохранённым ревью без веб-интерфейса).
+
+## Известное ограничение (WIP)
+
+Бэкенд полностью поддерживает модель "ревью" — создание ревью
+(staged/branch/commits), инлайн-комментарии, статусы
+(`in_progress`/`approved`/`changes_requested`), экспорт в Markdown/JSON — всё
+это покрыто тестами (`src/server/routes/reviews.ts`, `comments.ts`,
+`export.ts`). **Соответствующий экран во фронтенде пока не реализован** —
+`ReviewsPage.vue` сейчас заглушка. Работает только просмотр diff/файлов;
+создание ревью и комментирование через UI недоступно. Это следующий
+логический кусок работы, не забытая функциональность — трекается в
+`.claude/docs/adr/0014-quasar-frontend-migration.md` (не публикуется, файл
+только для локальной разработки).
+
+## Установка и запуск
+
+Требуется Node.js ≥ 24 (используется нативный `node:sqlite`).
+
+### Быстрый старт (npx)
+
+Без клонирования и локальной установки — пакет опубликован на npm как
+[`@tequila99/githuman`](https://www.npmjs.com/package/@tequila99/githuman):
+
+```bash
+npx @tequila99/githuman serve
+```
+
+Запускать из корня того `git`-репозитория, изменения в котором нужно
+просматривать (определяется как `git rev-parse --show-toplevel` от текущей
+директории).
+
+### Из исходников
+
+Требуется pnpm.
+
+```bash
+git clone <url-этого-репозитория>
+cd githuman
+pnpm install
+pnpm run build
+node dist/cli/index.js serve
+```
+
+По умолчанию сервер слушает `http://localhost:3847` и открывает браузер
+автоматически (отключить: `--no-open`). Репозиторий, который анализируется —
+это `git`-репозиторий, из корня которого запущена команда (определяется как
+`git rev-parse --show-toplevel` от текущей директории).
+
+```bash
+node dist/cli/index.js serve --port 4000 --host 0.0.0.0   # LAN-доступ, см. предупреждение ниже
+node dist/cli/index.js list --status in_progress            # список ревью без веб-интерфейса
+node dist/cli/index.js export last --format markdown -o review.md
+```
+
+> **Осторожно с `--host 0.0.0.0`**: сервер по умолчанию не требует
+> аутентификации. Открывая его в локальной сети, любой в этой сети сможет
+> просматривать содержимое репозитория.
+
+### Данные и совместимость с оригинальным mcollina/githuman
+
+Ревью хранятся в `.githuman/ght-reviews.db` (SQLite) в корне анализируемого
+репозитория. Префикс `ght-` — сознательный выбор: оригинальный
+[mcollina/githuman](https://github.com/mcollina/githuman) хранит свои данные
+в том же `.githuman/reviews.db` с несовместимой схемой — без префикса оба
+инструмента затирали бы файлы друг друга при использовании в одном
+репозитории.
+
+Префикс настраивается флагом `--db-prefix` (доступен у `serve`, `list`,
+`export` — указывайте один и тот же для всех трёх) или переменной окружения
+`GITHUMAN_DB_PREFIX`; флаг имеет приоритет над переменной. Пустое значение
+(`--db-prefix ""`) — осознанный режим совместимости: работать с
+`.githuman/reviews.db` оригинального инструмента напрямую (миграция схем на
+вашей ответственности).
+
+```bash
+node dist/cli/index.js serve --db-prefix myteam-   # .githuman/myteam-reviews.db
+node dist/cli/index.js list --db-prefix ""         # .githuman/reviews.db (оригинальный githuman)
+```
+
+## Разработка
+
+Два процесса нужны одновременно — backend (Fastify, автоперезапуск при
+правках) и frontend (Quasar dev-сервер с HMR):
+
+```bash
+# терминал 1 — backend
+pnpm run dev:server
+
+# терминал 2 — frontend, из этого же репозитория
+pnpm run dev
+```
+
+Если backend должен анализировать _другой_ репозиторий, а не сам
+githuman — запустите `dev:server` из cwd того репозитория, указав
+абсолютный путь к скрипту:
+
+```bash
+cd /path/to/other/repo
+node --watch-path=/path/to/githuman/src \
+  /path/to/githuman/src/cli/index.ts serve --no-open
+```
+
+Прочие команды:
+
+```bash
+pnpm test           # server (node:test) + CLI
+pnpm run typecheck   # tsc (server) + vue-tsc (web)
+pnpm run lint:check  # oxfmt --check + oxlint (read-only)
+pnpm run lint        # то же самое, но с автофиксом
+pnpm run build       # server (tsc) + web (quasar build) → dist/
+```
+
+Нет отдельного набора тестов для Vue-компонентов и e2e-спеков в
+`tests/e2e/` пока не существует (несмотря на `playwright.config.ts` и
+`test:e2e`-скрипт) — покрытие сейчас только на уровне backend/CLI (175
+тестов, `node:test`).
+
+## Стек
+
+- **Backend**: Fastify 5, `node:sqlite` (нативный, синхронный), TypeBox
+  (валидация + OpenAPI), SSE для live-обновлений.
+- **Frontend**: Vue 3 + Quasar (Composition API, `<script setup>`), Pinia,
+  vue-i18n, shiki.
+- **Тесты**: `node:test` (backend/CLI).
+- **Пакетный менеджер**: pnpm.
+
+## Лицензия
+
+MIT, см. [LICENSE](LICENSE).

package/dist/cli/commands/export.js

@@ -0,0 +1,55 @@
+import { parseArgs } from 'node:util';
+import { exportAsJson, exportAsMarkdown, ExportNotFoundError } from "../../server/services/export.service.js";
+import { getReviews } from "../../server/services/review.service.js";
+import { resolveDbPrefix } from "../config.js";
+export class ExportCliError extends Error {
+}
+export function parseExportArgs(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            format: { type: 'string', default: 'markdown' },
+            output: { type: 'string', short: 'o' },
+            'db-prefix': { type: 'string' }
+        },
+        strict: false,
+        allowPositionals: true
+    });
+    const [id] = positionals;
+    if (!id) {
+        throw new ExportCliError('Usage: githuman export <id|last> [--format json|markdown] [-o <file>]');
+    }
+    if (values.format !== 'json' && values.format !== 'markdown') {
+        throw new ExportCliError(`Invalid --format value "${String(values.format)}": expected "json" or "markdown"`);
+    }
+    return {
+        id,
+        format: values.format,
+        output: typeof values.output === 'string' ? values.output : undefined,
+        dbPrefix: resolveDbPrefix(typeof values['db-prefix'] === 'string' ? values['db-prefix'] : undefined)
+    };
+}
+function resolveReviewId(db, id) {
+    if (id !== 'last') {
+        return id;
+    }
+    const [latest] = getReviews(db);
+    if (!latest) {
+        throw new ExportCliError('No reviews found in this repository');
+    }
+    return latest.id;
+}
+export function runExport(db, id, format = 'markdown') {
+    const reviewId = resolveReviewId(db, id);
+    try {
+        return format === 'json'
+            ? JSON.stringify(exportAsJson(db, reviewId), null, 2)
+            : exportAsMarkdown(db, reviewId);
+    }
+    catch (error) {
+        if (error instanceof ExportNotFoundError) {
+            throw new ExportCliError(error.message);
+        }
+        throw error;
+    }
+}

package/dist/cli/commands/list.js

@@ -0,0 +1,39 @@
+import { parseArgs } from 'node:util';
+import { getReviews } from "../../server/services/review.service.js";
+import { resolveDbPrefix } from "../config.js";
+export function parseListArgs(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            json: { type: 'boolean', default: false },
+            status: { type: 'string' },
+            'db-prefix': { type: 'string' }
+        },
+        strict: false
+    });
+    return {
+        json: values.json === true,
+        status: isReviewStatus(values.status) ? values.status : undefined,
+        dbPrefix: resolveDbPrefix(typeof values['db-prefix'] === 'string' ? values['db-prefix'] : undefined)
+    };
+}
+function isReviewStatus(value) {
+    return (value === 'in_progress' ||
+        value === 'approved' ||
+        value === 'changes_requested');
+}
+export function runList(db, options = {}) {
+    let reviews = getReviews(db);
+    if (options.status) {
+        reviews = reviews.filter(review => review.status === options.status);
+    }
+    if (options.json) {
+        return JSON.stringify(reviews);
+    }
+    if (reviews.length === 0) {
+        return 'Ревью не найдены.';
+    }
+    return reviews
+        .map(review => `${review.id}\t${review.status}\t${review.createdAt}`)
+        .join('\n');
+}

package/dist/cli/config.js

@@ -0,0 +1,65 @@
+import { parseArgs } from 'node:util';
+const DEFAULT_PORT = 3847;
+const DEFAULT_HOST = 'localhost';
+/**
+ * Default prefix for filenames written under `.githuman/` (e.g.
+ * `ght-reviews.db`). The original mcollina/githuman CLI reads and writes
+ * `.githuman/reviews.db` in the same repo root with an incompatible schema —
+ * without a prefix, running both tools against the same repository would
+ * silently corrupt or crash on the other tool's database file.
+ */
+export const DEFAULT_DB_PREFIX = 'ght-';
+/**
+ * `GITHUMAN_DB_PREFIX` is intentionally not one of the env vars the original
+ * mcollina/githuman CLI reads (`GITHUMAN_DB_PATH`, `GITHUMAN_TOKEN`), so
+ * setting it can't be mistaken for configuring the original tool.
+ */
+const DB_PREFIX_ENV_VAR = 'GITHUMAN_DB_PREFIX';
+/**
+ * Resolves the `.githuman/`-internal filename prefix: an explicit value (CLI
+ * flag) wins, then the env var, then the default — each checked with `!==
+ * undefined` rather than truthiness, so an explicitly empty string ("") is a
+ * valid override that means "use the original mcollina/githuman filenames
+ * unprefixed" (e.g. for a deliberate interop/migration attempt), not "unset".
+ */
+export function resolveDbPrefix(explicit) {
+    if (explicit !== undefined) {
+        return explicit;
+    }
+    const fromEnv = process.env[DB_PREFIX_ENV_VAR];
+    if (fromEnv !== undefined) {
+        return fromEnv;
+    }
+    return DEFAULT_DB_PREFIX;
+}
+function resolvePort(explicit) {
+    if (explicit === undefined) {
+        return DEFAULT_PORT;
+    }
+    const parsed = Number(explicit);
+    if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+        throw new Error(`Invalid --port value "${explicit}": must be an integer between 1 and 65535`);
+    }
+    return parsed;
+}
+function resolveHost(explicit) {
+    return explicit !== undefined && explicit.length > 0 ? explicit : DEFAULT_HOST;
+}
+export function parseServeArgs(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            port: { type: 'string' },
+            host: { type: 'string' },
+            open: { type: 'boolean', default: true },
+            'no-open': { type: 'boolean', default: false },
+            'db-prefix': { type: 'string' }
+        },
+        strict: false
+    });
+    const port = resolvePort(typeof values.port === 'string' ? values.port : undefined);
+    const host = resolveHost(typeof values.host === 'string' ? values.host : undefined);
+    const open = values['no-open'] === true ? false : values.open !== false;
+    const dbPrefix = resolveDbPrefix(typeof values['db-prefix'] === 'string' ? values['db-prefix'] : undefined);
+    return { port, host, open, dbPrefix };
+}

package/dist/cli/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { writeFileSync } from 'node:fs';
+import { parseServeArgs } from "./config.js";
+import { startServer, resolveRepositoryPath, resolveReviewsDbPath } from "./server-runtime.js";
+import { formatStartupMessage } from "./startup-message.js";
+import { parseListArgs, runList } from "./commands/list.js";
+import { parseExportArgs, runExport } from "./commands/export.js";
+import { createFileDatabase } from "../server/db/index.js";
+/** Opens the reviews DB for the repo at cwd, shared by `list` and `export`. */
+async function openReviewsDb(dbPrefix) {
+    const repositoryPath = await resolveRepositoryPath(process.cwd());
+    return createFileDatabase(resolveReviewsDbPath(repositoryPath, dbPrefix));
+}
+async function main(argv) {
+    const [command, ...rest] = argv;
+    switch (command) {
+        case 'serve': {
+            const options = parseServeArgs(rest);
+            const { url } = await startServer(options);
+            console.log(formatStartupMessage(url, options.host));
+            return;
+        }
+        case 'list': {
+            const options = parseListArgs(rest);
+            const db = await openReviewsDb(options.dbPrefix);
+            console.log(runList(db, options));
+            return;
+        }
+        case 'export': {
+            const options = parseExportArgs(rest);
+            const db = await openReviewsDb(options.dbPrefix);
+            const output = runExport(db, options.id, options.format);
+            if (options.output) {
+                writeFileSync(options.output, output);
+            }
+            else {
+                console.log(output);
+            }
+            return;
+        }
+        default:
+            console.error(`Unknown command: ${command ?? '(none)'}`);
+            console.error('Usage: githuman serve|list|export [options]');
+            process.exitCode = 1;
+    }
+}
+main(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});

package/dist/cli/server-runtime.js

@@ -0,0 +1,66 @@
+import { existsSync } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildApp } from "../server/app.js";
+import { createFileDatabase } from "../server/db/index.js";
+import { resolveDbPrefix } from "./config.js";
+const execFileAsync = promisify(execFile);
+function resolveStaticRoot() {
+    // Compiled layout: dist/cli/server-runtime.js sits next to dist/web/.
+    // fileURLToPath (not URL.pathname) is required so this survives a percent-
+    // encoded install path or a Windows drive letter (`file:///C:/...`).
+    const candidatePath = fileURLToPath(new URL('../web', import.meta.url));
+    return existsSync(join(candidatePath, 'index.html'))
+        ? candidatePath
+        : undefined;
+}
+/** Best-effort opens `url` in the OS default browser — never throws or blocks startup. */
+function openBrowser(url) {
+    const [command, args] = process.platform === 'darwin'
+        ? ['open', [url]]
+        : process.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '""', url]]
+            : ['xdg-open', [url]];
+    execFile(command, args, () => {
+        // Ignore failures (no GUI/browser available, headless CI, etc.) — the
+        // startup message already printed the URL for the user to open by hand.
+    });
+}
+/** Resolves the repository root from cwd, falling back to cwd itself outside a git repo. */
+export async function resolveRepositoryPath(cwd) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf-8' });
+        return stdout.trim();
+    }
+    catch {
+        return cwd;
+    }
+}
+/**
+ * Path to the reviews SQLite file for a given repository, shared by `serve`,
+ * `list` and `export`. `dbPrefix` defaults (via `resolveDbPrefix`) the same
+ * way `parseServeArgs` does, so callers that don't care about it — like
+ * `serve`/`list`/`export` reading each other's file, or tests — land on the
+ * same path without having to thread the prefix through explicitly.
+ */
+export function resolveReviewsDbPath(repositoryPath, dbPrefix) {
+    const prefix = resolveDbPrefix(dbPrefix);
+    return join(repositoryPath, '.githuman', `${prefix}reviews.db`);
+}
+export async function startServer(options) {
+    const repositoryPath = await resolveRepositoryPath(process.cwd());
+    const db = createFileDatabase(resolveReviewsDbPath(repositoryPath, options.dbPrefix));
+    const app = buildApp({
+        staticRoot: resolveStaticRoot(),
+        repositoryPath,
+        db,
+        watchFiles: true
+    });
+    const address = await app.listen({ port: options.port, host: options.host });
+    if (options.open) {
+        openBrowser(address);
+    }
+    return { app, url: address };
+}

package/dist/cli/startup-message.js

@@ -0,0 +1,7 @@
+export function formatStartupMessage(url, host) {
+    const lines = [`githuman listening on ${url}`];
+    if (host !== 'localhost' && host !== '127.0.0.1') {
+        lines.push('Warning: server is reachable from your local network without authentication.');
+    }
+    return lines.join('\n');
+}

package/dist/server/app.js

@@ -0,0 +1,62 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Fastify from 'fastify';
+import fastifyStatic from '@fastify/static';
+// @fastify/sse's published types declare an ESM default export that doesn't match
+// its actual CJS runtime shape, so the default import resolves to the whole module
+// namespace under NodeNext — cast it back to the plugin function type.
+import fastifySseImport from '@fastify/sse';
+import { healthRoutes } from "./routes/health.js";
+import { diffRoutes } from "./routes/diff.js";
+import { gitRoutes } from "./routes/git.js";
+import { reviewRoutes } from "./routes/reviews.js";
+import { commentRoutes } from "./routes/comments.js";
+import { exportRoutes } from "./routes/export.js";
+import { eventRoutes } from "./routes/events.js";
+import { createTestDatabase } from "./db/index.js";
+import { createEventBus } from "./event-bus.js";
+import { watchRepository } from "./services/file-watcher.service.js";
+// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- documented workaround above
+const fastifySse = fastifySseImport;
+export function buildApp(options = {}) {
+    const app = Fastify({ logger: false, forceCloseConnections: true });
+    const repositoryPath = options.repositoryPath ?? process.cwd();
+    const db = options.db ?? createTestDatabase();
+    const eventBus = options.eventBus ?? createEventBus();
+    app.register(fastifySse);
+    app.register(healthRoutes);
+    app.register(diffRoutes, { repositoryPath });
+    app.register(gitRoutes, { repositoryPath });
+    app.register(reviewRoutes, { repositoryPath, db, eventBus });
+    app.register(commentRoutes, { db, eventBus });
+    app.register(exportRoutes, { db });
+    app.register(eventRoutes, { eventBus });
+    if (options.watchFiles) {
+        const watcher = watchRepository(repositoryPath, () => {
+            eventBus.publish({ type: 'files:changed' });
+        });
+        app.addHook('onClose', async () => {
+            watcher.close();
+        });
+    }
+    if (options.staticRoot) {
+        const staticRoot = options.staticRoot;
+        app.register(fastifyStatic, {
+            root: staticRoot,
+            wildcard: false
+        });
+        app.setNotFoundHandler((request, reply) => {
+            if (request.url.startsWith('/api/')) {
+                reply.code(404).send({
+                    error: 'Not Found',
+                    message: `Route ${request.url} not found`,
+                    statusCode: 404
+                });
+                return;
+            }
+            const indexHtml = readFileSync(join(staticRoot, 'index.html'), 'utf-8');
+            reply.code(200).type('text/html').send(indexHtml);
+        });
+    }
+    return app;
+}

package/dist/server/db/index.js

@@ -0,0 +1,17 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { applyMigrations } from "./migrations.js";
+export function createTestDatabase() {
+    const db = new DatabaseSync(':memory:');
+    applyMigrations(db);
+    return db;
+}
+export function createFileDatabase(path) {
+    mkdirSync(dirname(path), { recursive: true });
+    const db = new DatabaseSync(path);
+    // WAL allows a concurrent reader (`list`/`export`) while `serve` holds the file open.
+    db.exec('PRAGMA journal_mode = WAL;');
+    applyMigrations(db);
+    return db;
+}

package/dist/server/db/migrations.js

@@ -0,0 +1,34 @@
+export function applyMigrations(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS reviews (
+      id TEXT PRIMARY KEY,
+      repository_path TEXT NOT NULL,
+      base_ref TEXT,
+      source_type TEXT NOT NULL,
+      source_ref TEXT,
+      snapshot_data TEXT NOT NULL,
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS comments (
+      id TEXT PRIMARY KEY,
+      review_id TEXT NOT NULL REFERENCES reviews(id),
+      file_path TEXT NOT NULL,
+      line_number INTEGER,
+      line_type TEXT,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+  `);
+    const columns = db.prepare('PRAGMA table_info(comments)').all();
+    const columnNames = new Set(columns.map(c => c.name));
+    if (!columnNames.has('resolved')) {
+        db.exec('ALTER TABLE comments ADD COLUMN resolved INTEGER NOT NULL DEFAULT 0');
+    }
+    if (!columnNames.has('suggestion')) {
+        db.exec('ALTER TABLE comments ADD COLUMN suggestion TEXT');
+    }
+}

package/dist/server/event-bus.js

@@ -0,0 +1,14 @@
+export function createEventBus() {
+    const listeners = new Set();
+    return {
+        publish(event) {
+            for (const listener of listeners) {
+                listener(event);
+            }
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        }
+    };
+}

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

@@ -0,0 +1,52 @@
+function rowToComment(row) {
+    return {
+        id: row.id,
+        reviewId: row.review_id,
+        filePath: row.file_path,
+        lineNumber: row.line_number,
+        lineType: row.line_type,
+        content: row.content,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        resolved: Boolean(row.resolved),
+        suggestion: row.suggestion
+    };
+}
+export function findCommentById(db, id) {
+    const row = db.prepare('SELECT * FROM comments WHERE id = ?').get(id);
+    return row ? rowToComment(row) : null;
+}
+export function createComment(db, comment) {
+    db.prepare(`INSERT INTO comments (id, review_id, file_path, line_number, line_type, content, created_at, updated_at, suggestion)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(comment.id, comment.reviewId, comment.filePath, comment.lineNumber, comment.lineType, comment.content, comment.createdAt, comment.updatedAt, comment.suggestion ?? null);
+    return findCommentById(db, comment.id);
+}
+export function listCommentsByReview(db, reviewId) {
+    const rows = db
+        .prepare('SELECT * FROM comments WHERE review_id = ? ORDER BY created_at ASC')
+        .all(reviewId);
+    return rows.map(rowToComment);
+}
+export function updateComment(db, id, content) {
+    const updatedAt = new Date().toISOString();
+    const result = db
+        .prepare('UPDATE comments SET content = ?, updated_at = ? WHERE id = ?')
+        .run(content, updatedAt, id);
+    if (result.changes === 0) {
+        return null;
+    }
+    return findCommentById(db, id);
+}
+export function deleteComment(db, id) {
+    db.prepare('DELETE FROM comments WHERE id = ?').run(id);
+}
+export function setCommentResolved(db, id, resolved) {
+    const updatedAt = new Date().toISOString();
+    const result = db
+        .prepare('UPDATE comments SET resolved = ?, updated_at = ? WHERE id = ?')
+        .run(resolved ? 1 : 0, updatedAt, id);
+    if (result.changes === 0) {
+        return null;
+    }
+    return findCommentById(db, id);
+}