nitpiq 0.1.0

package/src/mcp/server.ts

@@ -0,0 +1,210 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { changes, kindSymbol, openRepoAt, readFile, stage, unstage, type Repo } from "../git/repo";
+import { debug, error, initLog } from "../log/log";
+import { relocateThreads } from "../review/anchor";
+import { AuthorModel, ThreadOpen, ThreadResolved } from "../review/types";
+import { Store } from "../store/store";
+
+export function createServer(repo: Repo, store: Store): McpServer {
+  const server = new McpServer({ name: "nitpiq", version: "0.1.0" });
+
+  const activeSession = () => store.activeSession() ?? store.createSession(repo.root);
+
+  server.registerTool(
+    "review_list_changes",
+    {
+      description: "List uncommitted file changes in the repository.",
+    },
+    async () => ({
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            changes(repo).map((change) => ({
+              path: change.path,
+              kind: change.kind,
+              symbol: kindSymbol(change.kind),
+            })),
+            null,
+            2,
+          ),
+        },
+      ],
+    }),
+  );
+
+  server.registerTool(
+    "review_list_threads",
+    {
+      description: "List review threads, optionally filtered by file and status.",
+      inputSchema: {
+        file_path: z.string().optional(),
+        status: z.enum(["open", "resolved", "all"]).optional(),
+      },
+    },
+    async ({ file_path, status = "open" }) => {
+      const session = activeSession();
+      let threads = store.listThreads(session.id, file_path ?? "");
+
+      if (file_path) {
+        const content = readFile(repo, file_path);
+        threads = relocateThreads(threads, content.split("\n"));
+        for (const thread of threads) {
+          store.updateThreadLine(thread.id, thread.currentLine, thread.isOutdated);
+        }
+      }
+
+      const filtered = threads.filter((thread) => status === "all" || thread.status === status);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              filtered.map((thread) => ({
+                id: thread.id,
+                file_path: thread.filePath,
+                line: thread.currentLine,
+                line_end: thread.lineEnd || undefined,
+                status: thread.status,
+                is_outdated: thread.isOutdated || undefined,
+                comment_count: thread.commentCount,
+                first_comment: thread.firstComment,
+              })),
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    },
+  );
+
+  server.registerTool(
+    "review_reply_thread",
+    {
+      description: "Post a reply comment to an existing review thread.",
+      inputSchema: {
+        thread_id: z.string(),
+        body: z.string(),
+      },
+    },
+    async ({ thread_id, body }) => {
+      store.addComment({ threadId: thread_id, author: AuthorModel, body });
+      return textResult(`Reply added to thread ${thread_id}`);
+    },
+  );
+
+  server.registerTool(
+    "review_resolve_thread",
+    {
+      description: "Mark a review thread as resolved.",
+      inputSchema: { thread_id: z.string() },
+    },
+    async ({ thread_id }) => {
+      store.updateThreadStatus(thread_id, ThreadResolved);
+      return textResult(`Thread ${thread_id} resolved`);
+    },
+  );
+
+  server.registerTool(
+    "review_reopen_thread",
+    {
+      description: "Reopen a resolved review thread.",
+      inputSchema: { thread_id: z.string() },
+    },
+    async ({ thread_id }) => {
+      store.updateThreadStatus(thread_id, ThreadOpen);
+      return textResult(`Thread ${thread_id} reopened`);
+    },
+  );
+
+  server.registerTool(
+    "review_apply_edit",
+    {
+      description: "Write new content to a file in the repository.",
+      inputSchema: {
+        file_path: z.string(),
+        content: z.string(),
+      },
+    },
+    async ({ file_path, content }) => {
+      const absolutePath = path.join(repo.root, file_path);
+      mkdirSync(path.dirname(absolutePath), { recursive: true });
+      await Bun.write(absolutePath, content);
+      return textResult(`File ${file_path} updated (${content.length} bytes)`);
+    },
+  );
+
+  server.registerTool(
+    "review_stage_file",
+    {
+      description: "Stage a file with git add.",
+      inputSchema: { file_path: z.string() },
+    },
+    async ({ file_path }) => {
+      stage(repo, file_path);
+      return textResult(`File ${file_path} staged`);
+    },
+  );
+
+  server.registerTool(
+    "review_unstage_file",
+    {
+      description: "Unstage a file.",
+      inputSchema: { file_path: z.string() },
+    },
+    async ({ file_path }) => {
+      unstage(repo, file_path);
+      return textResult(`File ${file_path} unstaged`);
+    },
+  );
+
+  return server;
+}
+
+function textResult(text: string) {
+  return { content: [{ type: "text" as const, text }] };
+}
+
+export async function serveStdio(repoPath?: string): Promise<void> {
+  const repo = openRepoAt(repoPath);
+  const store = Store.open(repo.root);
+  initLog(repo.root);
+  debug("nitpiq-mcp server starting");
+
+  try {
+    const server = createServer(repo, store);
+    const transport = new StdioServerTransport();
+    let cleanedUp = false;
+    const cleanup = async () => {
+      if (cleanedUp) {
+        return;
+      }
+      cleanedUp = true;
+      store.close();
+    };
+    const waitForExit = new Promise<void>((resolve) => {
+      transport.onclose = () => {
+        void cleanup().finally(resolve);
+      };
+      process.once("SIGINT", () => {
+        void cleanup().finally(resolve);
+      });
+      process.once("SIGTERM", () => {
+        void cleanup().finally(resolve);
+      });
+      process.once("beforeExit", () => {
+        void cleanup().finally(resolve);
+      });
+    });
+    await server.connect(transport);
+    await waitForExit;
+  } catch (cause) {
+    error(String(cause));
+    throw cause;
+  }
+}

package/src/review/anchor.ts

@@ -0,0 +1,118 @@
+import type { Thread } from "./types";
+
+const RELOCATE_MAX_DELTA = 50;
+
+export function relocateThreads(threads: Thread[], fileLines: string[]): Thread[] {
+  return threads.map((thread) => relocateThread(thread, fileLines));
+}
+
+function relocateThread(thread: Thread, lines: string[]): Thread {
+  if (thread.currentLine <= 0 || lines.length === 0) {
+    return thread;
+  }
+
+  const next = { ...thread };
+  const anchorLines = next.anchorContent.split("\n");
+  const originalIndex = next.currentLine - 1;
+  const rangeLength = next.lineEnd > next.currentLine ? next.lineEnd - next.currentLine : 0;
+
+  if (anchorMatchesAt(lines, originalIndex, anchorLines)) {
+    next.isOutdated = false;
+    return next;
+  }
+
+  for (let delta = 1; delta <= RELOCATE_MAX_DELTA; delta += 1) {
+    const up = originalIndex - delta;
+    if (up >= 0 && anchorMatchesAt(lines, up, anchorLines)) {
+      next.currentLine = up + 1;
+      next.lineEnd = rangeLength > 0 ? next.currentLine + rangeLength : next.lineEnd;
+      next.isOutdated = false;
+      return next;
+    }
+
+    const down = originalIndex + delta;
+    if (down >= 0 && anchorMatchesAt(lines, down, anchorLines)) {
+      next.currentLine = down + 1;
+      next.lineEnd = rangeLength > 0 ? next.currentLine + rangeLength : next.lineEnd;
+      next.isOutdated = false;
+      return next;
+    }
+  }
+
+  if (next.contextBefore || next.contextAfter) {
+    for (let index = 0; index < lines.length; index += 1) {
+      if (matchesContext(lines, index, next.contextBefore, next.contextAfter)) {
+        next.currentLine = index + 1;
+        next.lineEnd = rangeLength > 0 ? next.currentLine + rangeLength : next.lineEnd;
+        next.isOutdated = true;
+        return next;
+      }
+    }
+  }
+
+  next.isOutdated = true;
+  return next;
+}
+
+function anchorMatchesAt(lines: string[], index: number, anchorLines: string[]): boolean {
+  if (index < 0 || index + anchorLines.length > lines.length) {
+    return false;
+  }
+
+  for (let offset = 0; offset < anchorLines.length; offset += 1) {
+    if (lines[index + offset] !== anchorLines[offset]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function matchesContext(lines: string[], index: number, before: string, after: string): boolean {
+  if (before) {
+    const beforeLines = before.split("\n");
+    for (let offset = 0; offset < beforeLines.length; offset += 1) {
+      const pos = index - beforeLines.length + offset;
+      if (pos < 0 || pos >= lines.length || lines[pos] !== beforeLines[offset]) {
+        return false;
+      }
+    }
+  }
+
+  if (after) {
+    const afterLines = after.split("\n");
+    for (let offset = 0; offset < afterLines.length; offset += 1) {
+      const pos = index + 1 + offset;
+      if (pos >= lines.length || lines[pos] !== afterLines[offset]) {
+        return false;
+      }
+    }
+  }
+
+  return Boolean(before || after);
+}
+
+export function extractContext(fileContent: string, lineNumber: number) {
+  const lines = fileContent.split("\n");
+  const index = lineNumber - 1;
+
+  if (index < 0 || index >= lines.length) {
+    return { anchor: "", before: "", after: "" };
+  }
+
+  const beforeStart = Math.max(0, index - 3);
+  const afterEnd = Math.min(lines.length, index + 4);
+
+  return {
+    anchor: lines[index] ?? "",
+    before: lines.slice(beforeStart, index).join("\n"),
+    after: lines.slice(index + 1, afterEnd).join("\n"),
+  };
+}
+
+export function extractRangeAnchor(fileContent: string, startLine: number, endLine: number): string {
+  const lines = fileContent.split("\n");
+  const start = Math.max(0, startLine - 1);
+  const end = Math.min(lines.length, endLine);
+  return lines.slice(start, end).join("\n");
+}

package/src/review/types.ts

@@ -0,0 +1,64 @@
+export type ThreadStatus = "open" | "resolved";
+
+export const ThreadOpen: ThreadStatus = "open";
+export const ThreadResolved: ThreadStatus = "resolved";
+
+export type Author = "human" | "model";
+
+export const AuthorHuman: Author = "human";
+export const AuthorModel: Author = "model";
+
+export interface ReviewSession {
+  id: string;
+  repoRoot: string;
+  active: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface Thread {
+  id: string;
+  sessionId: string;
+  filePath: string;
+  side: string;
+  originalLine: number;
+  lineEnd: number;
+  currentLine: number;
+  anchorContent: string;
+  contextBefore: string;
+  contextAfter: string;
+  isOutdated: boolean;
+  status: ThreadStatus;
+  createdAt: Date;
+  updatedAt: Date;
+  commentCount: number;
+  firstComment: string;
+}
+
+export interface Comment {
+  id: string;
+  threadId: string;
+  author: Author;
+  body: string;
+  createdAt: Date;
+}
+
+export interface NewThread {
+  sessionId: string;
+  filePath: string;
+  side: string;
+  originalLine: number;
+  lineEnd: number;
+  currentLine: number;
+  anchorContent: string;
+  contextBefore: string;
+  contextAfter: string;
+  isOutdated?: boolean;
+  status?: ThreadStatus;
+}
+
+export interface NewComment {
+  threadId: string;
+  author: Author;
+  body: string;
+}

package/src/store/store.ts

@@ -0,0 +1,315 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { Database } from "bun:sqlite";
+import { AuthorHuman, ThreadOpen, type Author, type Comment, type NewComment, type NewThread, type ReviewSession, type Thread, type ThreadStatus } from "../review/types";
+
+const schema = `
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  repo_root TEXT NOT NULL,
+  active INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS threads (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  file_path TEXT NOT NULL,
+  side TEXT NOT NULL DEFAULT 'new',
+  original_line INTEGER NOT NULL DEFAULT 0,
+  line_end INTEGER NOT NULL DEFAULT 0,
+  current_line INTEGER NOT NULL DEFAULT 0,
+  anchor_content TEXT NOT NULL DEFAULT '',
+  context_before TEXT NOT NULL DEFAULT '',
+  context_after TEXT NOT NULL DEFAULT '',
+  is_outdated INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'open',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS comments (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+  author TEXT NOT NULL,
+  body TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_threads_session ON threads(session_id);
+CREATE INDEX IF NOT EXISTS idx_threads_file ON threads(file_path);
+CREATE INDEX IF NOT EXISTS idx_comments_thread ON comments(thread_id);
+`;
+
+export class Store {
+  readonly db: Database;
+
+  private constructor(db: Database) {
+    this.db = db;
+  }
+
+  static open(repoRoot: string): Store {
+    const dir = path.join(repoRoot, ".git", "nitpiq");
+    mkdirSync(dir, { recursive: true });
+    const dbPath = path.join(dir, "review.db");
+    const db = new Database(dbPath, { create: true, strict: true });
+    db.exec("PRAGMA journal_mode = WAL;");
+    db.exec("PRAGMA foreign_keys = ON;");
+    db.exec(schema);
+    return new Store(db);
+  }
+
+  close(): void {
+    this.db.close();
+  }
+
+  createSession(repoRoot: string): ReviewSession {
+    const now = new Date();
+    const session: ReviewSession = {
+      id: crypto.randomUUID(),
+      repoRoot,
+      active: true,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.db.query("UPDATE sessions SET active = 0 WHERE active = 1").run();
+    this.db
+      .query(
+        "INSERT INTO sessions (id, repo_root, active, created_at, updated_at) VALUES (?, ?, 1, ?, ?)",
+      )
+      .run(session.id, session.repoRoot, now.toISOString(), now.toISOString());
+
+    return session;
+  }
+
+  activeSession(): ReviewSession | null {
+    const row = this.db
+      .query("SELECT id, repo_root, created_at, updated_at FROM sessions WHERE active = 1 ORDER BY created_at DESC LIMIT 1")
+      .get() as
+      | {
+          id: string;
+          repo_root: string;
+          created_at: string;
+          updated_at: string;
+        }
+      | null;
+
+    if (!row) {
+      return null;
+    }
+
+    return {
+      id: row.id,
+      repoRoot: row.repo_root,
+      active: true,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at),
+    };
+  }
+
+  clearSession(id: string): void {
+    this.db.query("DELETE FROM sessions WHERE id = ?").run(id);
+  }
+
+  createThread(input: NewThread): Thread {
+    const now = new Date();
+    const thread: Thread = {
+      id: crypto.randomUUID(),
+      sessionId: input.sessionId,
+      filePath: input.filePath,
+      side: input.side,
+      originalLine: input.originalLine,
+      lineEnd: input.lineEnd,
+      currentLine: input.currentLine,
+      anchorContent: input.anchorContent,
+      contextBefore: input.contextBefore,
+      contextAfter: input.contextAfter,
+      isOutdated: input.isOutdated ?? false,
+      status: input.status ?? ThreadOpen,
+      createdAt: now,
+      updatedAt: now,
+      commentCount: 0,
+      firstComment: "",
+    };
+
+    this.db
+      .query(
+        `INSERT INTO threads (
+          id, session_id, file_path, side, original_line, line_end,
+          current_line, anchor_content, context_before, context_after,
+          is_outdated, status, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        thread.id,
+        thread.sessionId,
+        thread.filePath,
+        thread.side,
+        thread.originalLine,
+        thread.lineEnd,
+        thread.currentLine,
+        thread.anchorContent,
+        thread.contextBefore,
+        thread.contextAfter,
+        thread.isOutdated ? 1 : 0,
+        thread.status,
+        now.toISOString(),
+        now.toISOString(),
+      );
+
+    return thread;
+  }
+
+  listThreads(sessionId: string, filePath = ""): Thread[] {
+    const query = `
+      SELECT t.id, t.session_id, t.file_path, t.side,
+        t.original_line, t.line_end, t.current_line,
+        t.anchor_content, t.context_before, t.context_after,
+        t.is_outdated, t.status, t.created_at, t.updated_at,
+        COALESCE((SELECT COUNT(*) FROM comments WHERE thread_id = t.id), 0) AS comment_count,
+        COALESCE((SELECT body FROM comments WHERE thread_id = t.id ORDER BY created_at LIMIT 1), '') AS first_comment
+      FROM threads t
+      WHERE t.session_id = ? ${filePath ? "AND t.file_path = ?" : ""}
+      ORDER BY t.file_path, t.original_line
+    `;
+
+    const rows = (filePath
+      ? this.db.query(query).all(sessionId, filePath)
+      : this.db.query(query).all(sessionId)) as ThreadRow[];
+
+    return rows.map(mapThread);
+  }
+
+  threadCountsByFile(sessionId: string): Record<string, number> {
+    const rows = this.db
+      .query("SELECT file_path, COUNT(*) AS count FROM threads WHERE session_id = ? AND status = 'open' GROUP BY file_path")
+      .all(sessionId) as Array<{ file_path: string; count: number }>;
+
+    return Object.fromEntries(rows.map((row) => [row.file_path, row.count]));
+  }
+
+  updateThreadLine(id: string, currentLine: number, outdated: boolean): void {
+    this.db
+      .query("UPDATE threads SET current_line = ?, is_outdated = ?, updated_at = ? WHERE id = ?")
+      .run(currentLine, outdated ? 1 : 0, new Date().toISOString(), id);
+  }
+
+  updateThreadStatus(id: string, status: ThreadStatus): void {
+    this.db
+      .query("UPDATE threads SET status = ?, updated_at = ? WHERE id = ?")
+      .run(status, new Date().toISOString(), id);
+  }
+
+  deleteThread(id: string): void {
+    this.db.query("DELETE FROM threads WHERE id = ?").run(id);
+  }
+
+  addComment(input: NewComment): Comment {
+    const comment: Comment = {
+      id: crypto.randomUUID(),
+      threadId: input.threadId,
+      author: input.author ?? AuthorHuman,
+      body: input.body,
+      createdAt: new Date(),
+    };
+
+    this.db
+      .query("INSERT INTO comments (id, thread_id, author, body, created_at) VALUES (?, ?, ?, ?, ?)")
+      .run(comment.id, comment.threadId, comment.author, comment.body, comment.createdAt.toISOString());
+
+    return comment;
+  }
+
+  listComments(threadId: string): Comment[] {
+    const rows = this.db
+      .query("SELECT id, thread_id, author, body, created_at FROM comments WHERE thread_id = ? ORDER BY created_at")
+      .all(threadId) as CommentRow[];
+
+    return rows.map(mapComment);
+  }
+
+  listCommentsForThreads(threadIds: string[]): Record<string, Comment[]> {
+    if (threadIds.length === 0) {
+      return {};
+    }
+
+    const placeholders = threadIds.map(() => "?").join(", ");
+    const rows = this.db
+      .query(
+        `SELECT id, thread_id, author, body, created_at FROM comments WHERE thread_id IN (${placeholders}) ORDER BY created_at`,
+      )
+      .all(...threadIds) as CommentRow[];
+
+    const result: Record<string, Comment[]> = {};
+    for (const row of rows) {
+      const comment = mapComment(row);
+      const existing = result[comment.threadId];
+      if (existing) {
+        existing.push(comment);
+      } else {
+        result[comment.threadId] = [comment];
+      }
+    }
+    return result;
+  }
+}
+
+interface ThreadRow {
+  id: string;
+  session_id: string;
+  file_path: string;
+  side: string;
+  original_line: number;
+  line_end: number;
+  current_line: number;
+  anchor_content: string;
+  context_before: string;
+  context_after: string;
+  is_outdated: number;
+  status: string;
+  created_at: string;
+  updated_at: string;
+  comment_count: number;
+  first_comment: string;
+}
+
+interface CommentRow {
+  id: string;
+  thread_id: string;
+  author: string;
+  body: string;
+  created_at: string;
+}
+
+function mapThread(row: ThreadRow): Thread {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    filePath: row.file_path,
+    side: row.side,
+    originalLine: row.original_line,
+    lineEnd: row.line_end,
+    currentLine: row.current_line,
+    anchorContent: row.anchor_content,
+    contextBefore: row.context_before,
+    contextAfter: row.context_after,
+    isOutdated: row.is_outdated !== 0,
+    status: row.status as ThreadStatus,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+    commentCount: row.comment_count,
+    firstComment: row.first_comment,
+  };
+}
+
+function mapComment(row: CommentRow): Comment {
+  return {
+    id: row.id,
+    threadId: row.thread_id,
+    author: row.author as Author,
+    body: row.body,
+    createdAt: new Date(row.created_at),
+  };
+}