@sanurb/ringi 0.1.0

package/dist/chunk-3JLVANJR.js

@@ -0,0 +1,1782 @@
+import * as HttpApiSchema from '@effect/platform/HttpApiSchema';
+import * as Schema3 from 'effect/Schema';
+import { randomUUID } from 'node:crypto';
+import * as Effect4 from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { mkdirSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import * as Config from 'effect/Config';
+import * as Exit from 'effect/Exit';
+import { execFile } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import * as Layer from 'effect/Layer';
+import 'effect/ManagedRuntime';
+import { platform } from 'node:os';
+import chokidar from 'chokidar';
+import * as Queue from 'effect/Queue';
+import * as Runtime from 'effect/Runtime';
+import * as Stream from 'effect/Stream';
+
+// src/api/schemas/review.ts
+var ReviewId = Schema3.String.pipe(Schema3.brand("ReviewId"));
+var ReviewStatus = Schema3.Literal(
+  "in_progress",
+  "approved",
+  "changes_requested"
+);
+var ReviewSourceType = Schema3.Literal("staged", "branch", "commits");
+Schema3.Struct({
+  baseRef: Schema3.NullOr(Schema3.String),
+  createdAt: Schema3.String,
+  id: ReviewId,
+  repositoryPath: Schema3.String,
+  snapshotData: Schema3.String,
+  sourceRef: Schema3.NullOr(Schema3.String),
+  sourceType: ReviewSourceType,
+  status: ReviewStatus,
+  updatedAt: Schema3.String
+});
+Schema3.Struct({
+  sourceRef: Schema3.optionalWith(Schema3.NullOr(Schema3.String), {
+    default: () => null
+  }),
+  sourceType: Schema3.optionalWith(ReviewSourceType, {
+    default: () => "staged"
+  })
+});
+Schema3.Struct({
+  status: Schema3.optionalWith(ReviewStatus, { as: "Option" })
+});
+var ReviewNotFound = class extends Schema3.TaggedError()(
+  "ReviewNotFound",
+  { id: ReviewId },
+  HttpApiSchema.annotations({ status: 404 })
+) {
+};
+var TodoId = Schema3.String.pipe(Schema3.brand("TodoId"));
+Schema3.Struct({
+  completed: Schema3.Boolean,
+  content: Schema3.String,
+  createdAt: Schema3.String,
+  id: TodoId,
+  position: Schema3.Number,
+  reviewId: Schema3.NullOr(ReviewId),
+  updatedAt: Schema3.String
+});
+Schema3.Struct({
+  content: Schema3.String.pipe(Schema3.minLength(1)),
+  reviewId: Schema3.optionalWith(Schema3.NullOr(ReviewId), {
+    default: () => null
+  })
+});
+Schema3.Struct({
+  completed: Schema3.optionalWith(Schema3.Boolean, { as: "Option" }),
+  content: Schema3.optionalWith(Schema3.String.pipe(Schema3.minLength(1)), {
+    as: "Option"
+  })
+});
+var TodoNotFound = class extends Schema3.TaggedError()(
+  "TodoNotFound",
+  { id: TodoId },
+  HttpApiSchema.annotations({ status: 404 })
+) {
+};
+var CommentId = Schema3.String.pipe(Schema3.brand("CommentId"));
+var LineType = Schema3.Literal("added", "removed", "context");
+Schema3.Struct({
+  content: Schema3.String,
+  createdAt: Schema3.String,
+  filePath: Schema3.String,
+  id: CommentId,
+  lineNumber: Schema3.NullOr(Schema3.Number),
+  lineType: Schema3.NullOr(LineType),
+  resolved: Schema3.Boolean,
+  reviewId: ReviewId,
+  suggestion: Schema3.NullOr(Schema3.String),
+  updatedAt: Schema3.String
+});
+Schema3.Struct({
+  content: Schema3.String.pipe(Schema3.minLength(1)),
+  filePath: Schema3.String.pipe(Schema3.minLength(1)),
+  lineNumber: Schema3.optionalWith(Schema3.NullOr(Schema3.Number), {
+    default: () => null
+  }),
+  lineType: Schema3.optionalWith(Schema3.NullOr(LineType), {
+    default: () => null
+  }),
+  suggestion: Schema3.optionalWith(Schema3.NullOr(Schema3.String), {
+    default: () => null
+  })
+});
+Schema3.Struct({
+  content: Schema3.optionalWith(Schema3.String.pipe(Schema3.minLength(1)), {
+    as: "Option"
+  }),
+  suggestion: Schema3.optionalWith(Schema3.NullOr(Schema3.String), {
+    as: "Option"
+  })
+});
+var CommentNotFound = class extends Schema3.TaggedError()(
+  "CommentNotFound",
+  { id: CommentId },
+  HttpApiSchema.annotations({ status: 404 })
+) {
+};
+
+// src/core/db/migrations.ts
+var migrations = [
+  // v1: reviews table
+  `CREATE TABLE IF NOT EXISTS reviews (
+    id TEXT PRIMARY KEY,
+    repository_path TEXT NOT NULL,
+    base_ref TEXT,
+    snapshot_data TEXT NOT NULL,
+    status TEXT DEFAULT 'in_progress',
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`,
+  // v2: comments table
+  `CREATE TABLE IF NOT EXISTS comments (
+    id TEXT PRIMARY KEY,
+    review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+    file_path TEXT NOT NULL,
+    line_number INTEGER,
+    line_type TEXT,
+    content TEXT NOT NULL,
+    suggestion TEXT,
+    resolved INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`,
+  // v3: add source_type and source_ref to reviews
+  `ALTER TABLE reviews ADD COLUMN source_type TEXT DEFAULT 'staged';
+   ALTER TABLE reviews ADD COLUMN source_ref TEXT`,
+  // v4: todos table
+  `CREATE TABLE IF NOT EXISTS todos (
+    id TEXT PRIMARY KEY,
+    content TEXT NOT NULL,
+    completed INTEGER DEFAULT 0,
+    review_id TEXT REFERENCES reviews(id) ON DELETE CASCADE,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`,
+  // v5: add position to todos
+  `ALTER TABLE todos ADD COLUMN position INTEGER DEFAULT 0`,
+  // v6: review_files table
+  `CREATE TABLE IF NOT EXISTS review_files (
+    id TEXT PRIMARY KEY,
+    review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+    file_path TEXT NOT NULL,
+    old_path TEXT,
+    status TEXT NOT NULL,
+    additions INTEGER NOT NULL DEFAULT 0,
+    deletions INTEGER NOT NULL DEFAULT 0,
+    hunks_data TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  ) STRICT`
+];
+var runMigrations = (db) => {
+  const currentVersion = db.prepare("PRAGMA user_version").get().user_version;
+  for (let i = currentVersion; i < migrations.length; i++) {
+    const statements = migrations[i].split(";").map((s) => s.trim()).filter(Boolean);
+    for (const sql of statements) {
+      db.exec(sql);
+    }
+    db.exec(`PRAGMA user_version = ${i + 1}`);
+  }
+};
+
+// src/core/db/database.ts
+var withTransaction = (db, body) => Effect4.acquireUseRelease(
+  Effect4.sync(() => db.exec("BEGIN")),
+  () => body,
+  (_, exit) => Effect4.sync(() => {
+    if (Exit.isSuccess(exit)) {
+      db.exec("COMMIT");
+    } else {
+      db.exec("ROLLBACK");
+    }
+  })
+);
+var SqliteService = class extends Effect4.Service()(
+  "@ringi/SqliteService",
+  {
+    effect: Effect4.gen(function* effect() {
+      const dbPath = yield* Config.string("DB_PATH").pipe(
+        Config.withDefault(".ringi/reviews.db")
+      );
+      mkdirSync(dirname(dbPath), { recursive: true });
+      const db = new DatabaseSync(dbPath);
+      db.exec("PRAGMA journal_mode=WAL");
+      db.exec("PRAGMA foreign_keys=ON");
+      runMigrations(db);
+      return { db };
+    })
+  }
+) {
+};
+
+// src/core/repos/comment.repo.ts
+var rowToComment = (row) => ({
+  content: row.content,
+  createdAt: row.created_at,
+  filePath: row.file_path,
+  id: row.id,
+  lineNumber: row.line_number,
+  lineType: row.line_type,
+  resolved: row.resolved === 1,
+  reviewId: row.review_id,
+  suggestion: row.suggestion,
+  updatedAt: row.updated_at
+});
+var CommentRepo = class extends Effect4.Service()(
+  "@ringi/CommentRepo",
+  {
+    dependencies: [SqliteService.Default],
+    effect: Effect4.gen(function* effect() {
+      const { db } = yield* SqliteService;
+      const stmtFindById = db.prepare("SELECT * FROM comments WHERE id = ?");
+      const stmtFindByReview = db.prepare(
+        "SELECT * FROM comments WHERE review_id = ? ORDER BY created_at ASC"
+      );
+      const stmtFindByFile = db.prepare(
+        "SELECT * FROM comments WHERE review_id = ? AND file_path = ? ORDER BY line_number ASC, created_at ASC"
+      );
+      const stmtInsert = db.prepare(
+        `INSERT INTO comments (id, review_id, file_path, line_number, line_type, content, suggestion, resolved, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 0, datetime('now'), datetime('now'))`
+      );
+      const stmtDelete = db.prepare("DELETE FROM comments WHERE id = ?");
+      const stmtDeleteByReview = db.prepare(
+        "DELETE FROM comments WHERE review_id = ?"
+      );
+      const stmtSetResolved = db.prepare(
+        "UPDATE comments SET resolved = ?, updated_at = datetime('now') WHERE id = ?"
+      );
+      const stmtCountByReview = db.prepare(
+        `SELECT
+         COUNT(*) as total,
+         SUM(CASE WHEN resolved = 1 THEN 1 ELSE 0 END) as resolved,
+         SUM(CASE WHEN resolved = 0 THEN 1 ELSE 0 END) as unresolved,
+         SUM(CASE WHEN suggestion IS NOT NULL THEN 1 ELSE 0 END) as with_suggestions
+       FROM comments WHERE review_id = ?`
+      );
+      const findById = (id) => Effect4.sync(() => {
+        const row = stmtFindById.get(id);
+        return row ? rowToComment(row) : null;
+      });
+      const findByReview = (reviewId) => Effect4.sync(() => {
+        const rows = stmtFindByReview.all(
+          reviewId
+        );
+        return rows.map(rowToComment);
+      });
+      const findByFile = (reviewId, filePath) => Effect4.sync(() => {
+        const rows = stmtFindByFile.all(
+          reviewId,
+          filePath
+        );
+        return rows.map(rowToComment);
+      });
+      const create = (input) => Effect4.sync(() => {
+        stmtInsert.run(
+          input.id,
+          input.reviewId,
+          input.filePath,
+          input.lineNumber,
+          input.lineType,
+          input.content,
+          input.suggestion
+        );
+        return rowToComment(
+          stmtFindById.get(input.id)
+        );
+      });
+      const update = (id, updates) => Effect4.sync(() => {
+        const setClauses = [];
+        const params = [];
+        if (updates.content !== void 0) {
+          setClauses.push("content = ?");
+          params.push(updates.content);
+        }
+        if (updates.suggestion !== void 0) {
+          setClauses.push("suggestion = ?");
+          params.push(updates.suggestion);
+        }
+        if (setClauses.length === 0) {
+          const row2 = stmtFindById.get(id);
+          return row2 ? rowToComment(row2) : null;
+        }
+        setClauses.push("updated_at = datetime('now')");
+        params.push(id);
+        db.prepare(
+          `UPDATE comments SET ${setClauses.join(", ")} WHERE id = ?`
+        ).run(...params);
+        const row = stmtFindById.get(id);
+        return row ? rowToComment(row) : null;
+      });
+      const setResolved = (id, resolved) => Effect4.sync(() => {
+        stmtSetResolved.run(resolved ? 1 : 0, id);
+        const row = stmtFindById.get(id);
+        return row ? rowToComment(row) : null;
+      });
+      const remove = (id) => Effect4.sync(() => {
+        const result = stmtDelete.run(id);
+        return Number(result.changes) > 0;
+      });
+      const removeByReview = (reviewId) => Effect4.sync(() => {
+        const result = stmtDeleteByReview.run(reviewId);
+        return Number(result.changes);
+      });
+      const countByReview = (reviewId) => Effect4.sync(() => {
+        const row = stmtCountByReview.get(reviewId);
+        return {
+          resolved: row.resolved,
+          total: row.total,
+          unresolved: row.unresolved,
+          withSuggestions: row.with_suggestions
+        };
+      });
+      return {
+        countByReview,
+        create,
+        findByFile,
+        findById,
+        findByReview,
+        remove,
+        removeByReview,
+        setResolved,
+        update
+      };
+    })
+  }
+) {
+};
+
+// src/core/services/comment.service.ts
+var CommentService = class extends Effect4.Service()(
+  "@ringi/CommentService",
+  {
+    dependencies: [CommentRepo.Default],
+    effect: Effect4.sync(() => {
+      const create = Effect4.fn("CommentService.create")(function* create2(reviewId, input) {
+        const repo = yield* CommentRepo;
+        const id = randomUUID();
+        return yield* repo.create({
+          content: input.content,
+          filePath: input.filePath,
+          id,
+          lineNumber: input.lineNumber,
+          lineType: input.lineType,
+          reviewId,
+          suggestion: input.suggestion
+        });
+      });
+      const getById = Effect4.fn("CommentService.getById")(function* getById2(id) {
+        const repo = yield* CommentRepo;
+        const comment = yield* repo.findById(id);
+        if (!comment) {
+          return yield* new CommentNotFound({ id });
+        }
+        return comment;
+      });
+      const getByReview = Effect4.fn("CommentService.getByReview")(
+        function* getByReview2(reviewId) {
+          const repo = yield* CommentRepo;
+          return yield* repo.findByReview(reviewId);
+        }
+      );
+      const getByFile = Effect4.fn("CommentService.getByFile")(
+        function* getByFile2(reviewId, filePath) {
+          const repo = yield* CommentRepo;
+          return yield* repo.findByFile(reviewId, filePath);
+        }
+      );
+      const update = Effect4.fn("CommentService.update")(function* update2(id, input) {
+        const repo = yield* CommentRepo;
+        const updates = {};
+        if (Option.isSome(input.content)) {
+          updates.content = input.content.value;
+        }
+        if (Option.isSome(input.suggestion)) {
+          updates.suggestion = input.suggestion.value;
+        }
+        const comment = yield* repo.update(id, updates);
+        if (!comment) {
+          return yield* new CommentNotFound({ id });
+        }
+        return comment;
+      });
+      const resolve = Effect4.fn("CommentService.resolve")(function* resolve2(id) {
+        const repo = yield* CommentRepo;
+        const comment = yield* repo.setResolved(id, true);
+        if (!comment) {
+          return yield* new CommentNotFound({ id });
+        }
+        return comment;
+      });
+      const unresolve = Effect4.fn("CommentService.unresolve")(
+        function* unresolve2(id) {
+          const repo = yield* CommentRepo;
+          const comment = yield* repo.setResolved(id, false);
+          if (!comment) {
+            return yield* new CommentNotFound({ id });
+          }
+          return comment;
+        }
+      );
+      const remove = Effect4.fn("CommentService.remove")(function* remove2(id) {
+        const repo = yield* CommentRepo;
+        const existed = yield* repo.remove(id);
+        if (!existed) {
+          return yield* new CommentNotFound({ id });
+        }
+        return { success: true };
+      });
+      const getStats = Effect4.fn("CommentService.getStats")(function* getStats2(reviewId) {
+        const repo = yield* CommentRepo;
+        return yield* repo.countByReview(reviewId);
+      });
+      return {
+        create,
+        getByFile,
+        getById,
+        getByReview,
+        getStats,
+        remove,
+        resolve,
+        unresolve,
+        update
+      };
+    })
+  }
+) {
+};
+
+// src/core/services/diff.service.ts
+var HUNK_HEADER = /@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var splitIntoFiles = (diffText) => {
+  const files = [];
+  const lines2 = diffText.split("\n");
+  let current = [];
+  for (const line of lines2) {
+    if (line.startsWith("diff --git")) {
+      if (current.length > 0) {
+        files.push(current.join("\n"));
+      }
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  if (current.length > 0) {
+    files.push(current.join("\n"));
+  }
+  return files;
+};
+var parseHunks = (lines2) => {
+  const hunks = [];
+  let currentHunk = null;
+  let oldLineNum = 0;
+  let newLineNum = 0;
+  for (const line of lines2) {
+    const match = line.match(HUNK_HEADER);
+    if (match) {
+      if (currentHunk) {
+        hunks.push(currentHunk);
+      }
+      const oldStart = Number.parseInt(match[1], 10);
+      const oldLines = Number.parseInt(match[2] ?? "1", 10);
+      const newStart = Number.parseInt(match[3], 10);
+      const newLines = Number.parseInt(match[4] ?? "1", 10);
+      currentHunk = { lines: [], newLines, newStart, oldLines, oldStart };
+      oldLineNum = oldStart;
+      newLineNum = newStart;
+      continue;
+    }
+    if (!currentHunk) {
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      currentHunk.lines.push({
+        content: line.slice(1),
+        newLineNumber: newLineNum++,
+        oldLineNumber: null,
+        type: "added"
+      });
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      currentHunk.lines.push({
+        content: line.slice(1),
+        newLineNumber: null,
+        oldLineNumber: oldLineNum++,
+        type: "removed"
+      });
+    } else if (line.startsWith(" ")) {
+      currentHunk.lines.push({
+        content: line.slice(1),
+        newLineNumber: newLineNum++,
+        oldLineNumber: oldLineNum++,
+        type: "context"
+      });
+    }
+  }
+  if (currentHunk) {
+    hunks.push(currentHunk);
+  }
+  return hunks;
+};
+var parseFileDiff = (fileDiff) => {
+  const lines2 = fileDiff.split("\n");
+  const diffLine = lines2.find((l) => l.startsWith("diff --git"));
+  if (!diffLine) {
+    return null;
+  }
+  const pathMatch = diffLine.match(/diff --git a\/(.+) b\/(.+)/);
+  if (!pathMatch) {
+    return null;
+  }
+  const oldPath = pathMatch[1];
+  const newPath = pathMatch[2];
+  let status = "modified";
+  if (lines2.some((l) => l.startsWith("deleted file mode"))) {
+    status = "deleted";
+  } else if (lines2.some((l) => l.startsWith("new file mode"))) {
+    status = "added";
+  } else if (lines2.some((l) => l.startsWith("rename from")) || oldPath !== newPath) {
+    status = "renamed";
+  }
+  const hunks = parseHunks(lines2);
+  let additions = 0;
+  let deletions = 0;
+  for (const hunk of hunks) {
+    for (const line of hunk.lines) {
+      if (line.type === "added") {
+        additions++;
+      } else if (line.type === "removed") {
+        deletions++;
+      }
+    }
+  }
+  return { additions, deletions, hunks, newPath, oldPath, status };
+};
+var parseDiff = (diffText) => {
+  if (!diffText.trim()) {
+    return [];
+  }
+  const blocks = splitIntoFiles(diffText);
+  const files = [];
+  for (const block of blocks) {
+    const parsed = parseFileDiff(block);
+    if (parsed) {
+      files.push(parsed);
+    }
+  }
+  return files;
+};
+var getDiffSummary = (files) => {
+  let totalAdditions = 0;
+  let totalDeletions = 0;
+  for (const file of files) {
+    totalAdditions += file.additions;
+    totalDeletions += file.deletions;
+  }
+  return {
+    filesAdded: files.filter((f) => f.status === "added").length,
+    filesDeleted: files.filter((f) => f.status === "deleted").length,
+    filesModified: files.filter((f) => f.status === "modified").length,
+    filesRenamed: files.filter((f) => f.status === "renamed").length,
+    totalAdditions,
+    totalDeletions,
+    totalFiles: files.length
+  };
+};
+var GitError = class extends Schema3.TaggedError()(
+  "GitError",
+  { message: Schema3.String },
+  HttpApiSchema.annotations({ status: 500 })
+) {
+};
+var execGit = (args, repoPath) => Effect4.tryPromise({
+  catch: (error) => new GitError({ message: String(error) }),
+  try: () => new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      [...args],
+      { cwd: repoPath, maxBuffer: 50 * 1024 * 1024 },
+      (err, stdout) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(stdout);
+        }
+      }
+    );
+  })
+});
+var lines = (output) => output.trim().split("\n").filter(Boolean);
+var parseNameStatus = (output) => lines(output).map((line) => {
+  const [status, ...rest] = line.split("	");
+  return { path: rest.join("	"), status };
+});
+var GitService = class extends Effect4.Service()(
+  "@ringi/GitService",
+  {
+    effect: Effect4.gen(function* effect() {
+      const repoPath = yield* Config.string("REPOSITORY_PATH").pipe(
+        Config.withDefault(process.cwd())
+      );
+      const hasCommits = execGit(["rev-parse", "HEAD"], repoPath).pipe(
+        Effect4.as(true),
+        Effect4.catchTag("GitError", () => Effect4.succeed(false)),
+        Effect4.withSpan("GitService.hasCommits")
+      );
+      const getRepositoryInfo = Effect4.gen(function* getRepositoryInfo2() {
+        const name = yield* execGit(
+          ["rev-parse", "--show-toplevel"],
+          repoPath
+        ).pipe(Effect4.map((s) => s.trim().split("/").pop() ?? "unknown"));
+        const branch = yield* execGit(
+          ["rev-parse", "--abbrev-ref", "HEAD"],
+          repoPath
+        ).pipe(Effect4.map((s) => s.trim()));
+        const remote = yield* execGit(
+          ["config", "--get", "remote.origin.url"],
+          repoPath
+        ).pipe(
+          Effect4.map((s) => s.trim() || null),
+          Effect4.catchTag("GitError", () => Effect4.succeed(null))
+        );
+        return { branch, name, path: repoPath, remote };
+      }).pipe(Effect4.withSpan("GitService.getRepositoryInfo"));
+      const getStagedDiff = execGit(
+        ["diff", "--cached", "--no-color", "--unified=3"],
+        repoPath
+      ).pipe(Effect4.withSpan("GitService.getStagedDiff"));
+      const getUncommittedDiff = hasCommits.pipe(
+        Effect4.flatMap(
+          (has) => has ? execGit(["diff", "HEAD", "--no-color", "--unified=3"], repoPath) : Effect4.succeed("")
+        ),
+        Effect4.withSpan("GitService.getUncommittedDiff")
+      );
+      const getUnstagedDiff = execGit(
+        ["diff", "--no-color", "--unified=3"],
+        repoPath
+      ).pipe(Effect4.withSpan("GitService.getUnstagedDiff"));
+      const getLastCommitDiff = hasCommits.pipe(
+        Effect4.flatMap(
+          (has) => has ? execGit(
+            ["show", "HEAD", "--format=", "--no-color", "--unified=3"],
+            repoPath
+          ) : Effect4.succeed("")
+        ),
+        Effect4.withSpan("GitService.getLastCommitDiff")
+      );
+      const getBranchDiff = Effect4.fn("GitService.getBranchDiff")(
+        function* getBranchDiff2(branch) {
+          return yield* execGit(
+            ["diff", `${branch}...HEAD`, "--no-color", "--unified=3"],
+            repoPath
+          );
+        }
+      );
+      const getCommitDiff = Effect4.fn("GitService.getCommitDiff")(
+        function* getCommitDiff2(shas) {
+          if (shas.length === 1) {
+            return yield* execGit(
+              ["show", shas[0], "--format=", "--no-color", "--unified=3"],
+              repoPath
+            );
+          }
+          const first = shas.at(-1);
+          const last = shas[0];
+          return yield* execGit(
+            ["diff", `${first}~1..${last}`, "--no-color", "--unified=3"],
+            repoPath
+          );
+        }
+      );
+      const getStagedFiles = execGit(
+        ["diff", "--cached", "--name-status"],
+        repoPath
+      ).pipe(
+        Effect4.map(parseNameStatus),
+        Effect4.withSpan("GitService.getStagedFiles")
+      );
+      const getUncommittedFiles = hasCommits.pipe(
+        Effect4.flatMap(
+          (has) => has ? execGit(["diff", "HEAD", "--name-status"], repoPath).pipe(
+            Effect4.map(parseNameStatus)
+          ) : Effect4.succeed([])
+        ),
+        Effect4.withSpan("GitService.getUncommittedFiles")
+      );
+      const getUnstagedFiles = execGit(
+        ["diff", "--name-status"],
+        repoPath
+      ).pipe(
+        Effect4.map(parseNameStatus),
+        Effect4.withSpan("GitService.getUnstagedFiles")
+      );
+      const getLastCommitFiles = hasCommits.pipe(
+        Effect4.flatMap(
+          (has) => has ? execGit(
+            ["show", "HEAD", "--format=", "--name-status"],
+            repoPath
+          ).pipe(Effect4.map(parseNameStatus)) : Effect4.succeed([])
+        ),
+        Effect4.withSpan("GitService.getLastCommitFiles")
+      );
+      const getFileContent = Effect4.fn("GitService.getFileContent")(
+        function* getFileContent2(filePath, version) {
+          switch (version) {
+            case "staged": {
+              return yield* execGit(["show", `:${filePath}`], repoPath);
+            }
+            case "head": {
+              return yield* execGit(["show", `HEAD:${filePath}`], repoPath);
+            }
+            case "working":
+            default: {
+              return yield* Effect4.tryPromise({
+                catch: (error) => new GitError({
+                  message: `Failed to read ${filePath}: ${String(error)}`
+                }),
+                try: () => readFile(join(repoPath, filePath), "utf8")
+              });
+            }
+          }
+        }
+      );
+      const getFileTree = Effect4.fn("GitService.getFileTree")(
+        function* getFileTree2(ref) {
+          return yield* execGit(
+            ["ls-tree", "-r", "--name-only", ref],
+            repoPath
+          ).pipe(Effect4.map(lines));
+        }
+      );
+      const getBranches = execGit(
+        ["branch", "--format=%(refname:short)	%(HEAD)"],
+        repoPath
+      ).pipe(
+        Effect4.map(
+          (output) => lines(output).map((line) => {
+            const [name, head] = line.split("	");
+            return { current: head === "*", name };
+          })
+        ),
+        Effect4.withSpan("GitService.getBranches")
+      );
+      const getCommits = Effect4.fn("GitService.getCommits")(
+        function* getCommits2(opts) {
+          const limit = (opts.limit ?? 20) + 1;
+          const args = [
+            "log",
+            `--max-count=${limit}`,
+            `--skip=${opts.offset ?? 0}`,
+            "--format=%H	%s	%an	%aI"
+          ];
+          if (opts.search) {
+            args.push(`--grep=${opts.search}`, "-i");
+          }
+          const output = yield* execGit(args, repoPath);
+          const rows = lines(output);
+          const hasMore = rows.length === limit;
+          const commits = (hasMore ? rows.slice(0, -1) : rows).map((line) => {
+            const [hash, message, author, date] = line.split("	");
+            return {
+              author,
+              date,
+              hash,
+              message
+            };
+          });
+          return { commits, hasMore };
+        }
+      );
+      const stageFiles = Effect4.fn("GitService.stageFiles")(
+        function* stageFiles2(files) {
+          return yield* execGit(["add", "--", ...files], repoPath).pipe(
+            Effect4.as(files)
+          );
+        }
+      );
+      const stageAll = execGit(["add", "-A"], repoPath).pipe(
+        Effect4.flatMap(() => getStagedFiles),
+        Effect4.map((files) => files.map((f) => f.path)),
+        Effect4.withSpan("GitService.stageAll")
+      );
+      const unstageFiles = Effect4.fn("GitService.unstageFiles")(
+        function* unstageFiles2(files) {
+          return yield* execGit(
+            ["reset", "HEAD", "--", ...files],
+            repoPath
+          ).pipe(Effect4.as(files));
+        }
+      );
+      const getRepositoryPath = execGit(
+        ["rev-parse", "--show-toplevel"],
+        repoPath
+      ).pipe(
+        Effect4.map((s) => s.trim()),
+        Effect4.withSpan("GitService.getRepositoryPath")
+      );
+      return {
+        getBranchDiff,
+        getBranches,
+        getCommitDiff,
+        getCommits,
+        getFileContent,
+        getFileTree,
+        getLastCommitDiff,
+        getLastCommitFiles,
+        getRepositoryInfo,
+        getRepositoryPath,
+        getStagedDiff,
+        getStagedFiles,
+        getUncommittedDiff,
+        getUncommittedFiles,
+        getUnstagedDiff,
+        getUnstagedFiles,
+        hasCommits,
+        stageAll,
+        stageFiles,
+        unstageFiles
+      };
+    })
+  }
+) {
+};
+var parseHunks2 = (hunksData) => hunksData == null ? Effect4.succeed([]) : Effect4.try(() => JSON.parse(hunksData)).pipe(
+  Effect4.orElseSucceed(() => [])
+);
+var serializeHunks = (hunks) => JSON.stringify(hunks);
+var ReviewFileRepo = class extends Effect4.Service()(
+  "@ringi/ReviewFileRepo",
+  {
+    dependencies: [SqliteService.Default],
+    effect: Effect4.gen(function* effect() {
+      const { db } = yield* SqliteService;
+      const stmtFindByReview = db.prepare(
+        `SELECT id, review_id, file_path, old_path, status, additions, deletions, created_at
+         FROM review_files WHERE review_id = ? ORDER BY file_path`
+      );
+      const stmtFindByReviewAndPath = db.prepare(
+        "SELECT * FROM review_files WHERE review_id = ? AND file_path = ?"
+      );
+      const stmtInsert = db.prepare(
+        `INSERT INTO review_files (id, review_id, file_path, old_path, status, additions, deletions, hunks_data, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`
+      );
+      const stmtDeleteByReview = db.prepare(
+        "DELETE FROM review_files WHERE review_id = ?"
+      );
+      const stmtCountByReview = db.prepare(
+        "SELECT COUNT(*) as count FROM review_files WHERE review_id = ?"
+      );
+      const findByReview = (reviewId) => Effect4.sync(
+        () => stmtFindByReview.all(reviewId)
+      );
+      const findByReviewAndPath = (reviewId, filePath) => Effect4.sync(() => {
+        const row = stmtFindByReviewAndPath.get(
+          reviewId,
+          filePath
+        );
+        return row ?? null;
+      });
+      const createBulk = (files) => withTransaction(
+        db,
+        Effect4.sync(() => {
+          for (const f of files) {
+            stmtInsert.run(
+              randomUUID(),
+              f.reviewId,
+              f.filePath,
+              f.oldPath,
+              f.status,
+              f.additions,
+              f.deletions,
+              f.hunksData
+            );
+          }
+        })
+      );
+      const deleteByReview = (reviewId) => Effect4.sync(() => {
+        const result = stmtDeleteByReview.run(reviewId);
+        return Number(result.changes);
+      });
+      const countByReview = (reviewId) => Effect4.sync(() => {
+        const row = stmtCountByReview.get(reviewId);
+        return row.count;
+      });
+      return {
+        countByReview,
+        createBulk,
+        deleteByReview,
+        findByReview,
+        findByReviewAndPath
+      };
+    })
+  }
+) {
+};
+var rowToReview = (row) => ({
+  baseRef: row.base_ref,
+  createdAt: row.created_at,
+  id: row.id,
+  repositoryPath: row.repository_path,
+  snapshotData: row.snapshot_data,
+  sourceRef: row.source_ref,
+  sourceType: row.source_type,
+  status: row.status,
+  updatedAt: row.updated_at
+});
+var ReviewRepo = class extends Effect4.Service()(
+  "@ringi/ReviewRepo",
+  {
+    dependencies: [SqliteService.Default],
+    effect: Effect4.gen(function* effect() {
+      const { db } = yield* SqliteService;
+      const stmtFindById = db.prepare("SELECT * FROM reviews WHERE id = ?");
+      const stmtInsert = db.prepare(
+        `INSERT INTO reviews (id, repository_path, base_ref, source_type, source_ref, snapshot_data, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))`
+      );
+      const stmtUpdate = db.prepare(
+        `UPDATE reviews SET status = COALESCE(?, status), updated_at = datetime('now') WHERE id = ?`
+      );
+      const stmtDelete = db.prepare("DELETE FROM reviews WHERE id = ?");
+      const stmtCountAll = db.prepare("SELECT COUNT(*) as count FROM reviews");
+      const stmtCountByStatus = db.prepare(
+        "SELECT COUNT(*) as count FROM reviews WHERE status = ?"
+      );
+      const findById = (id) => Effect4.sync(() => {
+        const row = stmtFindById.get(id);
+        return row ? rowToReview(row) : null;
+      });
+      const findAll = (opts = {}) => Effect4.sync(() => {
+        const conditions = [];
+        const params = [];
+        if (opts.status != null) {
+          conditions.push("status = ?");
+          params.push(opts.status);
+        }
+        if (opts.repositoryPath != null) {
+          conditions.push("repository_path = ?");
+          params.push(opts.repositoryPath);
+        }
+        if (opts.sourceType != null) {
+          conditions.push("source_type = ?");
+          params.push(opts.sourceType);
+        }
+        const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+        const page = opts.page ?? 1;
+        const pageSize = opts.pageSize ?? 20;
+        const offset = (page - 1) * pageSize;
+        const totalRow = db.prepare(`SELECT COUNT(*) as count FROM reviews${where}`).get(
+          ...params
+        );
+        const rows = db.prepare(
+          `SELECT * FROM reviews${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`
+        ).all(
+          ...params,
+          pageSize,
+          offset
+        );
+        return { data: rows.map(rowToReview), total: totalRow.count };
+      });
+      const create = (input) => Effect4.sync(() => {
+        stmtInsert.run(
+          input.id,
+          input.repositoryPath,
+          input.baseRef,
+          input.sourceType,
+          input.sourceRef,
+          input.snapshotData,
+          input.status
+        );
+        return rowToReview(
+          stmtFindById.get(input.id)
+        );
+      });
+      const update = (id, status) => Effect4.sync(() => {
+        stmtUpdate.run(status, id);
+        const row = stmtFindById.get(id);
+        return row ? rowToReview(row) : null;
+      });
+      const remove = (id) => Effect4.sync(() => {
+        const result = stmtDelete.run(id);
+        return Number(result.changes) > 0;
+      });
+      const countAll = () => Effect4.sync(() => {
+        const row = stmtCountAll.get();
+        return row.count;
+      });
+      const countByStatus = (status) => Effect4.sync(() => {
+        const row = stmtCountByStatus.get(status);
+        return row.count;
+      });
+      return {
+        countAll,
+        countByStatus,
+        create,
+        findAll,
+        findById,
+        remove,
+        update
+      };
+    })
+  }
+) {
+};
+
+// src/core/services/review.service.ts
+var ReviewError = class extends Schema3.TaggedError()(
+  "ReviewError",
+  { code: Schema3.String, message: Schema3.String },
+  HttpApiSchema.annotations({ status: 400 })
+) {
+};
+var getHeadSha = (repoPath) => Effect4.tryPromise({
+  catch: () => new ReviewError({ code: "GIT_ERROR", message: "Failed to get HEAD" }),
+  try: () => new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      ["rev-parse", "HEAD"],
+      { cwd: repoPath },
+      (err, stdout) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(stdout.trim());
+        }
+      }
+    );
+  })
+});
+var parseSnapshotData = (s) => Effect4.try(() => JSON.parse(s)).pipe(
+  Effect4.orElseSucceed(() => ({}))
+);
+var ReviewService = class extends Effect4.Service()(
+  "@ringi/ReviewService",
+  {
+    dependencies: [
+      ReviewRepo.Default,
+      ReviewFileRepo.Default,
+      GitService.Default
+    ],
+    effect: Effect4.sync(() => {
+      const create = Effect4.fn("ReviewService.create")(function* create2(input) {
+        const git = yield* GitService;
+        const repo = yield* ReviewRepo;
+        const fileRepo = yield* ReviewFileRepo;
+        const repoPath = yield* git.getRepositoryPath;
+        const hasCommitsResult = yield* git.hasCommits;
+        if (!hasCommitsResult) {
+          return yield* new ReviewError({
+            code: "NO_COMMITS",
+            message: "Repository has no commits"
+          });
+        }
+        let diffText;
+        let baseRef = null;
+        const { sourceType, sourceRef } = input;
+        switch (sourceType) {
+          case "staged": {
+            diffText = yield* git.getStagedDiff;
+            if (!diffText.trim()) {
+              return yield* new ReviewError({
+                code: "NO_STAGED_CHANGES",
+                message: "No staged changes"
+              });
+            }
+            baseRef = yield* getHeadSha(repoPath);
+            break;
+          }
+          case "branch": {
+            if (!sourceRef) {
+              return yield* new ReviewError({
+                code: "INVALID_SOURCE",
+                message: "Branch name required"
+              });
+            }
+            diffText = yield* git.getBranchDiff(sourceRef);
+            baseRef = sourceRef;
+            break;
+          }
+          case "commits": {
+            if (!sourceRef) {
+              return yield* new ReviewError({
+                code: "INVALID_SOURCE",
+                message: "Commit SHAs required"
+              });
+            }
+            const shas = sourceRef.split(",").map((s) => s.trim()).filter(Boolean);
+            if (shas.length === 0) {
+              return yield* new ReviewError({
+                code: "INVALID_SOURCE",
+                message: "No valid commit SHAs"
+              });
+            }
+            diffText = yield* git.getCommitDiff(shas);
+            baseRef = shas.at(-1) ?? null;
+            break;
+          }
+          default: {
+            return yield* new ReviewError({
+              code: "INVALID_SOURCE",
+              message: "Unsupported review source"
+            });
+          }
+        }
+        const files = parseDiff(diffText);
+        if (files.length === 0) {
+          return yield* new ReviewError({
+            code: "NO_CHANGES",
+            message: "No changes found"
+          });
+        }
+        const repoInfo = yield* git.getRepositoryInfo;
+        const reviewId = crypto.randomUUID();
+        const storeHunks = sourceType === "staged";
+        const fileInputs = files.map((f) => ({
+          additions: f.additions,
+          deletions: f.deletions,
+          filePath: f.newPath,
+          hunksData: storeHunks ? serializeHunks(f.hunks) : null,
+          oldPath: f.oldPath !== f.newPath ? f.oldPath : null,
+          reviewId,
+          status: f.status
+        }));
+        const snapshotData = JSON.stringify({
+          repository: repoInfo,
+          version: 2
+        });
+        const review = yield* repo.create({
+          baseRef,
+          id: reviewId,
+          repositoryPath: repoPath,
+          snapshotData,
+          sourceRef: sourceRef ?? null,
+          sourceType,
+          status: "in_progress"
+        });
+        yield* fileRepo.createBulk(fileInputs);
+        return review;
+      });
+      const list = Effect4.fn("ReviewService.list")(function* list2(opts) {
+        const repo = yield* ReviewRepo;
+        const fileRepo = yield* ReviewFileRepo;
+        const page = opts.page ?? 1;
+        const pageSize = opts.pageSize ?? 20;
+        const result = yield* repo.findAll({
+          page,
+          pageSize,
+          repositoryPath: opts.repositoryPath,
+          sourceType: opts.sourceType,
+          status: opts.status
+        });
+        const reviews = [];
+        for (const review of result.data) {
+          const fileCount = yield* fileRepo.countByReview(review.id);
+          const snapshot = yield* parseSnapshotData(review.snapshotData);
+          reviews.push({
+            ...review,
+            fileCount,
+            repository: snapshot.repository ?? null
+          });
+        }
+        return {
+          hasMore: page * pageSize < result.total,
+          page,
+          pageSize,
+          reviews,
+          total: result.total
+        };
+      });
+      const getById = Effect4.fn("ReviewService.getById")(function* getById2(id) {
+        const repo = yield* ReviewRepo;
+        const fileRepo = yield* ReviewFileRepo;
+        const review = yield* repo.findById(id);
+        if (!review) {
+          return yield* new ReviewNotFound({ id });
+        }
+        const fileRows = yield* fileRepo.findByReview(id);
+        const files = fileRows.map((r) => ({
+          additions: r.additions,
+          deletions: r.deletions,
+          filePath: r.file_path,
+          id: r.id,
+          oldPath: r.old_path,
+          status: r.status
+        }));
+        const snapshot = yield* parseSnapshotData(review.snapshotData);
+        const summary = getDiffSummary(
+          files.map((f) => ({
+            additions: f.additions,
+            deletions: f.deletions,
+            hunks: [],
+            newPath: f.filePath,
+            oldPath: f.oldPath ?? f.filePath,
+            status: f.status
+          }))
+        );
+        return {
+          ...review,
+          files,
+          repository: snapshot.repository ?? null,
+          summary
+        };
+      });
+      const getFileHunks = Effect4.fn("ReviewService.getFileHunks")(
+        function* getFileHunks2(reviewId, filePath) {
+          const repo = yield* ReviewRepo;
+          const fileRepo = yield* ReviewFileRepo;
+          const git = yield* GitService;
+          const review = yield* repo.findById(reviewId);
+          if (!review) {
+            return yield* new ReviewNotFound({ id: reviewId });
+          }
+          const fileRecord = yield* fileRepo.findByReviewAndPath(
+            reviewId,
+            filePath
+          );
+          if (fileRecord?.hunks_data) {
+            return yield* parseHunks2(fileRecord.hunks_data);
+          }
+          if (review.sourceType === "branch" && review.sourceRef) {
+            const diff = yield* git.getBranchDiff(review.sourceRef);
+            const diffFiles = parseDiff(diff);
+            const file = diffFiles.find((f) => f.newPath === filePath);
+            return file?.hunks ?? [];
+          }
+          if (review.sourceType === "commits" && review.sourceRef) {
+            const shas = review.sourceRef.split(",").map((s) => s.trim());
+            const diff = yield* git.getCommitDiff(shas);
+            const diffFiles = parseDiff(diff);
+            const file = diffFiles.find((f) => f.newPath === filePath);
+            return file?.hunks ?? [];
+          }
+          const snapshot = yield* parseSnapshotData(review.snapshotData);
+          if (snapshot.files) {
+            const legacyFile = snapshot.files.find(
+              (f) => f.newPath === filePath
+            );
+            return legacyFile?.hunks ?? [];
+          }
+          return [];
+        }
+      );
+      const update = Effect4.fn("ReviewService.update")(function* update2(id, input) {
+        const repo = yield* ReviewRepo;
+        const existing = yield* repo.findById(id);
+        if (!existing) {
+          return yield* new ReviewNotFound({ id });
+        }
+        const status = Option.getOrNull(input.status);
+        const review = yield* repo.update(id, status);
+        if (!review) {
+          return yield* new ReviewNotFound({ id });
+        }
+        return review;
+      });
+      const remove = Effect4.fn("ReviewService.remove")(function* remove2(id) {
+        const repo = yield* ReviewRepo;
+        const fileRepo = yield* ReviewFileRepo;
+        const existing = yield* repo.findById(id);
+        if (!existing) {
+          return yield* new ReviewNotFound({ id });
+        }
+        yield* fileRepo.deleteByReview(id);
+        yield* repo.remove(id);
+        return { success: true };
+      });
+      const getStats = Effect4.fn("ReviewService.getStats")(
+        function* getStats2() {
+          const repo = yield* ReviewRepo;
+          const total = yield* repo.countAll();
+          const inProgress = yield* repo.countByStatus("in_progress");
+          const approved = yield* repo.countByStatus("approved");
+          const changesRequested = yield* repo.countByStatus("changes_requested");
+          return { approved, changesRequested, inProgress, total };
+        }
+      );
+      return {
+        create,
+        getById,
+        getFileHunks,
+        getStats,
+        list,
+        remove,
+        update
+      };
+    })
+  }
+) {
+};
+var rowToTodo = (row) => ({
+  completed: row.completed === 1,
+  content: row.content,
+  createdAt: row.created_at,
+  id: row.id,
+  position: row.position,
+  reviewId: row.review_id,
+  updatedAt: row.updated_at
+});
+var TodoRepo = class extends Effect4.Service()("@ringi/TodoRepo", {
+  dependencies: [SqliteService.Default],
+  effect: Effect4.gen(function* effect() {
+    const { db } = yield* SqliteService;
+    const stmtFindById = db.prepare("SELECT * FROM todos WHERE id = ?");
+    const stmtInsert = db.prepare(
+      `INSERT INTO todos (id, content, completed, review_id, position, created_at, updated_at)
+       VALUES (?, ?, 0, ?, ?, datetime('now'), datetime('now'))`
+    );
+    const stmtDelete = db.prepare("DELETE FROM todos WHERE id = ?");
+    const stmtDeleteCompleted = db.prepare(
+      "DELETE FROM todos WHERE completed = 1"
+    );
+    const stmtNextPosition = db.prepare(
+      "SELECT COALESCE(MAX(position), -1) + 1 AS next_pos FROM todos"
+    );
+    const stmtCountAll = db.prepare("SELECT COUNT(*) as count FROM todos");
+    const stmtCountCompleted = db.prepare(
+      "SELECT COUNT(*) as count FROM todos WHERE completed = 1"
+    );
+    const stmtCountPending = db.prepare(
+      "SELECT COUNT(*) as count FROM todos WHERE completed = 0"
+    );
+    const findById = (id) => Effect4.sync(() => {
+      const row = stmtFindById.get(id);
+      return row ? rowToTodo(row) : null;
+    });
+    const findAll = (opts = {}) => Effect4.sync(() => {
+      const conditions = [];
+      const params = [];
+      if (opts.reviewId != null) {
+        conditions.push("review_id = ?");
+        params.push(opts.reviewId);
+      }
+      if (opts.completed != null) {
+        conditions.push("completed = ?");
+        params.push(opts.completed ? 1 : 0);
+      }
+      const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+      const totalRow = db.prepare(`SELECT COUNT(*) as count FROM todos${where}`).get(
+        ...params
+      );
+      const limitClause = opts.limit != null ? ` LIMIT ? OFFSET ?` : "";
+      const queryParams = opts.limit != null ? [...params, opts.limit, opts.offset ?? 0] : params;
+      const rows = db.prepare(
+        `SELECT * FROM todos${where} ORDER BY position ASC${limitClause}`
+      ).all(
+        ...queryParams
+      );
+      return { data: rows.map(rowToTodo), total: totalRow.count };
+    });
+    const create = (input) => Effect4.sync(() => {
+      const { next_pos } = stmtNextPosition.get();
+      stmtInsert.run(input.id, input.content, input.reviewId, next_pos);
+      return rowToTodo(stmtFindById.get(input.id));
+    });
+    const update = (id, updates) => Effect4.sync(() => {
+      const sets = [];
+      const params = [];
+      if (updates.content != null) {
+        sets.push("content = ?");
+        params.push(updates.content);
+      }
+      if (updates.completed != null) {
+        sets.push("completed = ?");
+        params.push(updates.completed ? 1 : 0);
+      }
+      if (sets.length === 0) {
+        const row2 = stmtFindById.get(id);
+        return row2 ? rowToTodo(row2) : null;
+      }
+      sets.push("updated_at = datetime('now')");
+      params.push(id);
+      db.prepare(`UPDATE todos SET ${sets.join(", ")} WHERE id = ?`).run(
+        ...params
+      );
+      const row = stmtFindById.get(id);
+      return row ? rowToTodo(row) : null;
+    });
+    const toggle = (id) => Effect4.sync(() => {
+      const row = stmtFindById.get(id);
+      if (!row) {
+        return null;
+      }
+      const newCompleted = row.completed === 1 ? 0 : 1;
+      db.prepare(
+        "UPDATE todos SET completed = ?, updated_at = datetime('now') WHERE id = ?"
+      ).run(newCompleted, id);
+      return rowToTodo(stmtFindById.get(id));
+    });
+    const remove = (id) => Effect4.sync(() => {
+      const result = stmtDelete.run(id);
+      return Number(result.changes) > 0;
+    });
+    const removeCompleted = () => Effect4.sync(() => {
+      const result = stmtDeleteCompleted.run();
+      return Number(result.changes);
+    });
+    const reorder = (orderedIds) => withTransaction(
+      db,
+      Effect4.sync(() => {
+        const stmt = db.prepare(
+          "UPDATE todos SET position = ?, updated_at = datetime('now') WHERE id = ?"
+        );
+        let updated = 0;
+        for (let i = 0; i < orderedIds.length; i++) {
+          const result = stmt.run(i, orderedIds[i]);
+          updated += Number(result.changes);
+        }
+        return updated;
+      })
+    );
+    const move = (id, newPosition) => Effect4.gen(function* move2() {
+      const row = stmtFindById.get(id);
+      if (!row) {
+        return null;
+      }
+      const oldPosition = row.position;
+      yield* withTransaction(
+        db,
+        Effect4.sync(() => {
+          if (newPosition < oldPosition) {
+            db.prepare(
+              "UPDATE todos SET position = position + 1, updated_at = datetime('now') WHERE position >= ? AND position < ? AND id != ?"
+            ).run(newPosition, oldPosition, id);
+          } else if (newPosition > oldPosition) {
+            db.prepare(
+              "UPDATE todos SET position = position - 1, updated_at = datetime('now') WHERE position > ? AND position <= ? AND id != ?"
+            ).run(oldPosition, newPosition, id);
+          }
+          db.prepare(
+            "UPDATE todos SET position = ?, updated_at = datetime('now') WHERE id = ?"
+          ).run(newPosition, id);
+        })
+      );
+      return rowToTodo(stmtFindById.get(id));
+    });
+    const countAll = () => Effect4.sync(() => {
+      const row = stmtCountAll.get();
+      return row.count;
+    });
+    const countCompleted = () => Effect4.sync(() => {
+      const row = stmtCountCompleted.get();
+      return row.count;
+    });
+    const countPending = () => Effect4.sync(() => {
+      const row = stmtCountPending.get();
+      return row.count;
+    });
+    return {
+      countAll,
+      countCompleted,
+      countPending,
+      create,
+      findAll,
+      findById,
+      move,
+      remove,
+      removeCompleted,
+      reorder,
+      toggle,
+      update
+    };
+  })
+}) {
+};
+
+// src/core/services/todo.service.ts
+var TodoService = class extends Effect4.Service()(
+  "@ringi/TodoService",
+  {
+    dependencies: [TodoRepo.Default],
+    effect: Effect4.sync(() => {
+      const create = Effect4.fn("TodoService.create")(function* create2(input) {
+        const repo = yield* TodoRepo;
+        const id = randomUUID();
+        return yield* repo.create({
+          content: input.content,
+          id,
+          reviewId: input.reviewId
+        });
+      });
+      const getById = Effect4.fn("TodoService.getById")(function* getById2(id) {
+        const repo = yield* TodoRepo;
+        const todo = yield* repo.findById(id);
+        if (!todo) {
+          return yield* new TodoNotFound({ id });
+        }
+        return todo;
+      });
+      const list = Effect4.fn("TodoService.list")(function* list2(opts = {}) {
+        const repo = yield* TodoRepo;
+        const result = yield* repo.findAll(opts);
+        return {
+          data: result.data,
+          limit: opts.limit ?? null,
+          offset: opts.offset ?? 0,
+          total: result.total
+        };
+      });
+      const update = Effect4.fn("TodoService.update")(function* update2(id, input) {
+        const repo = yield* TodoRepo;
+        const existing = yield* repo.findById(id);
+        if (!existing) {
+          return yield* new TodoNotFound({ id });
+        }
+        const updates = {};
+        if (Option.isSome(input.content)) {
+          updates.content = input.content.value;
+        }
+        if (Option.isSome(input.completed)) {
+          updates.completed = input.completed.value;
+        }
+        const todo = yield* repo.update(id, updates);
+        if (!todo) {
+          return yield* new TodoNotFound({ id });
+        }
+        return todo;
+      });
+      const toggle = Effect4.fn("TodoService.toggle")(function* toggle2(id) {
+        const repo = yield* TodoRepo;
+        const todo = yield* repo.toggle(id);
+        if (!todo) {
+          return yield* new TodoNotFound({ id });
+        }
+        return todo;
+      });
+      const remove = Effect4.fn("TodoService.remove")(function* remove2(id) {
+        const repo = yield* TodoRepo;
+        const existing = yield* repo.findById(id);
+        if (!existing) {
+          return yield* new TodoNotFound({ id });
+        }
+        yield* repo.remove(id);
+        return { success: true };
+      });
+      const removeCompleted = Effect4.fn("TodoService.removeCompleted")(
+        function* removeCompleted2() {
+          const repo = yield* TodoRepo;
+          const deleted = yield* repo.removeCompleted();
+          return { deleted };
+        }
+      );
+      const reorder = Effect4.fn("TodoService.reorder")(function* reorder2(orderedIds) {
+        const repo = yield* TodoRepo;
+        const updated = yield* repo.reorder(orderedIds);
+        return { updated };
+      });
+      const move = Effect4.fn("TodoService.move")(function* move2(id, position) {
+        const repo = yield* TodoRepo;
+        const todo = yield* repo.move(id, position);
+        if (!todo) {
+          return yield* new TodoNotFound({ id });
+        }
+        return todo;
+      });
+      const getStats = Effect4.fn("TodoService.getStats")(function* getStats2() {
+        const repo = yield* TodoRepo;
+        const total = yield* repo.countAll();
+        const completed = yield* repo.countCompleted();
+        const pending = yield* repo.countPending();
+        return { completed, pending, total };
+      });
+      return {
+        create,
+        getById,
+        getStats,
+        list,
+        move,
+        remove,
+        removeCompleted,
+        reorder,
+        toggle,
+        update
+      };
+    })
+  }
+) {
+};
+var ExportService = class extends Effect4.Service()(
+  "@ringi/ExportService",
+  {
+    dependencies: [
+      ReviewService.Default,
+      CommentService.Default,
+      TodoService.Default
+    ],
+    effect: Effect4.sync(() => {
+      const exportReview = Effect4.fn("ExportService.exportReview")(
+        function* exportReview2(reviewId) {
+          const reviewSvc = yield* ReviewService;
+          const commentSvc = yield* CommentService;
+          const todoSvc = yield* TodoService;
+          const review = yield* reviewSvc.getById(reviewId);
+          const repo = review.repository;
+          const repoName = repo?.name ?? "Unknown";
+          const branch = repo?.branch ?? "unknown";
+          const comments = yield* commentSvc.getByReview(reviewId);
+          const commentStats = yield* commentSvc.getStats(reviewId);
+          const todos = yield* todoSvc.list({ reviewId });
+          const lines2 = [];
+          lines2.push(`# Code Review: ${repoName}`);
+          lines2.push("");
+          lines2.push(`**Status:** ${review.status}`);
+          lines2.push(`**Branch:** ${branch}`);
+          lines2.push(`**Created:** ${review.createdAt}`);
+          if (review.files && review.files.length > 0) {
+            lines2.push("");
+            lines2.push("## Files Changed");
+            lines2.push("");
+            lines2.push("| File | Status | Additions | Deletions |");
+            lines2.push("|------|--------|-----------|-----------|");
+            for (const f of review.files) {
+              const statusLabel = f.status === "modified" ? "M" : f.status === "added" ? "A" : f.status === "deleted" ? "D" : f.status;
+              lines2.push(
+                `| ${f.filePath} | ${statusLabel} | +${f.additions} | -${f.deletions} |`
+              );
+            }
+          }
+          if (comments.length > 0) {
+            lines2.push("");
+            lines2.push(
+              `## Comments (${commentStats.total} total, ${commentStats.resolved} resolved)`
+            );
+            const byFile = /* @__PURE__ */ new Map();
+            for (const c of comments) {
+              const key = c.filePath ?? "(general)";
+              const arr = byFile.get(key) ?? [];
+              arr.push(c);
+              byFile.set(key, arr);
+            }
+            for (const [filePath, fileComments] of byFile) {
+              lines2.push("");
+              lines2.push(`### ${filePath}`);
+              for (const c of fileComments) {
+                lines2.push("");
+                lines2.push(
+                  `**Line ${c.lineNumber ?? "\u2013"}** (${c.lineType ?? "context"})`
+                );
+                lines2.push(`> ${c.content}`);
+                if (c.suggestion) {
+                  lines2.push("");
+                  lines2.push("```suggestion");
+                  lines2.push(c.suggestion);
+                  lines2.push("```");
+                }
+              }
+            }
+          }
+          if (todos.data.length > 0) {
+            const completed = todos.data.filter((t) => t.completed).length;
+            lines2.push("");
+            lines2.push("---");
+            lines2.push("");
+            lines2.push(
+              `## Todos (${todos.total} total, ${completed} completed)`
+            );
+            lines2.push("");
+            for (const t of todos.data) {
+              const check = t.completed ? "x" : " ";
+              lines2.push(`- [${check}] ${t.content}`);
+            }
+          }
+          lines2.push("");
+          return lines2.join("\n");
+        }
+      );
+      return { exportReview };
+    })
+  }
+) {
+};
+var EventService = class extends Effect4.Service()(
+  "@ringi/EventService",
+  {
+    effect: Effect4.gen(function* effect() {
+      const rt = yield* Effect4.runtime();
+      const runFork2 = Runtime.runFork(rt);
+      const subscribers = /* @__PURE__ */ new Set();
+      const broadcast = Effect4.fn("EventService.broadcast")(function* broadcast2(type, data) {
+        const event = { data, timestamp: Date.now(), type };
+        for (const queue of subscribers) {
+          yield* Queue.offer(queue, event);
+        }
+      });
+      const subscribe = Effect4.fn("EventService.subscribe")(
+        function* subscribe2() {
+          const queue = yield* Queue.sliding(100);
+          subscribers.add(queue);
+          const stream = Stream.fromQueue(queue);
+          const unsubscribe = Effect4.sync(() => {
+            subscribers.delete(queue);
+          }).pipe(Effect4.andThen(Queue.shutdown(queue)));
+          return { stream, unsubscribe };
+        }
+      );
+      const startFileWatcher = (repoPath) => Effect4.acquireRelease(
+        Effect4.sync(() => {
+          let debounceTimer = null;
+          const watcher = chokidar.watch(repoPath, {
+            ignoreInitial: true,
+            ignored: [
+              "**/node_modules/**",
+              "**/.git/**",
+              "**/.ringi/**",
+              "**/dist/**"
+            ],
+            persistent: true,
+            ...platform() === "darwin" ? { interval: 1e3, usePolling: true } : {}
+          });
+          const debouncedBroadcast = (filePath) => {
+            if (debounceTimer) {
+              clearTimeout(debounceTimer);
+            }
+            debounceTimer = setTimeout(() => {
+              const rel = relative(repoPath, filePath);
+              runFork2(broadcast("files", { path: rel }));
+            }, 300);
+          };
+          watcher.on("add", debouncedBroadcast);
+          watcher.on("change", debouncedBroadcast);
+          watcher.on("unlink", debouncedBroadcast);
+          return watcher;
+        }),
+        (watcher) => Effect4.promise(() => watcher.close())
+      );
+      const getClientCount = () => Effect4.sync(() => subscribers.size);
+      return {
+        broadcast,
+        getClientCount,
+        startFileWatcher,
+        subscribe
+      };
+    })
+  }
+) {
+};
+
+// src/core/runtime.ts
+var CoreLive = Layer.mergeAll(
+  ReviewService.Default,
+  ReviewRepo.Default,
+  ReviewFileRepo.Default,
+  CommentService.Default,
+  CommentRepo.Default,
+  TodoService.Default,
+  TodoRepo.Default,
+  GitService.Default,
+  EventService.Default,
+  ExportService.Default,
+  SqliteService.Default
+);
+
+export { CommentService, CoreLive, ExportService, GitService, ReviewId, ReviewNotFound, ReviewService, ReviewSourceType, TodoId, TodoNotFound, TodoService, getDiffSummary, parseDiff };
+//# sourceMappingURL=chunk-3JLVANJR.js.map
+//# sourceMappingURL=chunk-3JLVANJR.js.map