nitpiq 0.1.0 → 0.3.0

package/src/git/repo.ts

@@ -1,237 +0,0 @@
-import { readFileSync, statSync } from "node:fs";
-import path from "node:path";
-
-export type ChangeKind = "modified" | "added" | "deleted" | "renamed" | "copied" | "untracked";
-
-export interface FileChange {
-  path: string;
-  oldPath: string;
-  kind: ChangeKind;
-  staged: boolean;
-  unstaged: boolean;
-}
-
-export interface Repo {
-  root: string;
-  name: string;
-  hasHead: boolean;
-}
-
-export function kindSymbol(kind: ChangeKind): string {
-  switch (kind) {
-    case "modified":
-      return "M";
-    case "added":
-      return "A";
-    case "deleted":
-      return "D";
-    case "renamed":
-      return "R";
-    case "copied":
-      return "C";
-    case "untracked":
-      return "?";
-  }
-}
-
-export function openRepoAt(dir?: string): Repo {
-  const root = runGit(["rev-parse", "--show-toplevel"], dir || process.cwd()).trim();
-  const hasHead = runGitOptional(["rev-parse", "HEAD"], root).ok;
-
-  return {
-    root,
-    name: path.basename(root),
-    hasHead,
-  };
-}
-
-export function openRepo(): Repo {
-  return openRepoAt();
-}
-
-export function changes(repo: Repo): FileChange[] {
-  const output = runGit(["status", "--porcelain=v1", "-uall"], repo.root);
-  return parsePorcelain(output);
-}
-
-export function files(repo: Repo): string[] {
-  const output = runGit(["ls-files", "--cached", "--others", "--exclude-standard"], repo.root);
-  const seen = new Set<string>();
-  const result: string[] = [];
-
-  for (const line of output.split("\n")) {
-    const candidate = line.trim();
-    if (!candidate || seen.has(candidate)) {
-      continue;
-    }
-    seen.add(candidate);
-    result.push(candidate);
-  }
-
-  return result;
-}
-
-export function diff(repo: Repo, change: FileChange, contextLines = 3): string {
-  if (change.kind === "untracked") {
-    return diffUntracked(repo, change.path);
-  }
-
-  const context = `-U${contextLines}`;
-
-  if (repo.hasHead) {
-    const result = runGitOptional(["diff", context, "HEAD", "--", change.path], repo.root);
-    if (result.ok && result.stdout.trim()) {
-      return result.stdout;
-    }
-  }
-
-  const cached = runGitOptional(["diff", context, "--cached", "--", change.path], repo.root);
-  if (cached.ok && cached.stdout.trim()) {
-    return cached.stdout;
-  }
-
-  const working = runGitOptional(["diff", context, "--", change.path], repo.root);
-  if (working.ok && working.stdout.trim()) {
-    return working.stdout;
-  }
-
-  return "(no diff available)";
-}
-
-function diffUntracked(repo: Repo, relativePath: string): string {
-  const absolutePath = path.join(repo.root, relativePath);
-  const stat = statSync(absolutePath);
-  if (stat.isDirectory()) {
-    return `(directory: ${relativePath})`;
-  }
-
-  const result = Bun.spawnSync(["git", "diff", "--no-index", "--", "/dev/null", absolutePath], {
-    cwd: repo.root,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const text = `${result.stdout ? Buffer.from(result.stdout).toString() : ""}${result.stderr ? Buffer.from(result.stderr).toString() : ""}`;
-  return text || "(empty file)";
-}
-
-export function readFile(repo: Repo, relativePath: string): string {
-  const filePath = path.join(repo.root, relativePath);
-  const stat = statSync(filePath);
-  if (stat.isDirectory()) {
-    throw new Error(`${relativePath} is a directory`);
-  }
-  return readFileSync(filePath, "utf8");
-}
-
-export function stage(repo: Repo, relativePath: string): void {
-  runGit(["add", "--", relativePath], repo.root);
-}
-
-export function unstage(repo: Repo, relativePath: string): void {
-  const restore = runGitOptional(["restore", "--staged", "--", relativePath], repo.root);
-  if (restore.ok) {
-    return;
-  }
-
-  const reset = runGitOptional(["reset", "HEAD", "--", relativePath], repo.root);
-  if (reset.ok) {
-    return;
-  }
-
-  const remove = runGitOptional(["rm", "--cached", "--", relativePath], repo.root);
-  if (!remove.ok) {
-    throw new Error(remove.stderr || `failed to unstage ${relativePath}`);
-  }
-}
-
-function parsePorcelain(output: string): FileChange[] {
-  const result: FileChange[] = [];
-
-  for (const line of output.split("\n")) {
-    if (line.length < 4) {
-      continue;
-    }
-
-    const x = line[0] ?? " ";
-    const y = line[1] ?? " ";
-    let filePath = line.slice(3);
-    let oldPath = "";
-
-    if (filePath.endsWith("/")) {
-      continue;
-    }
-
-    const renameIndex = filePath.indexOf(" -> ");
-    if (renameIndex >= 0) {
-      oldPath = filePath.slice(0, renameIndex);
-      filePath = filePath.slice(renameIndex + 4);
-    }
-
-    const change: FileChange = {
-      path: filePath,
-      oldPath,
-      kind: "modified",
-      staged: false,
-      unstaged: false,
-    };
-
-    if (x === "?" && y === "?") {
-      change.kind = "untracked";
-      change.unstaged = true;
-    } else {
-      if (x !== " " && x !== "?") {
-        change.staged = true;
-        change.kind = charToKind(x);
-      }
-      if (y !== " " && y !== "?") {
-        change.unstaged = true;
-        if (!change.staged) {
-          change.kind = charToKind(y);
-        }
-      }
-    }
-
-    result.push(change);
-  }
-
-  return result;
-}
-
-function charToKind(char: string): ChangeKind {
-  switch (char) {
-    case "A":
-      return "added";
-    case "D":
-      return "deleted";
-    case "R":
-      return "renamed";
-    case "C":
-      return "copied";
-    case "M":
-    default:
-      return "modified";
-  }
-}
-
-function runGit(args: string[], cwd: string): string {
-  const result = runGitOptional(args, cwd);
-  if (!result.ok) {
-    throw new Error(result.stderr || `git ${args.join(" ")} failed`);
-  }
-  return result.stdout;
-}
-
-function runGitOptional(args: string[], cwd: string): { ok: boolean; stdout: string; stderr: string } {
-  const proc = Bun.spawnSync(["git", ...args], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  return {
-    ok: proc.exitCode === 0,
-    stdout: proc.stdout ? Buffer.from(proc.stdout).toString() : "",
-    stderr: proc.stderr ? Buffer.from(proc.stderr).toString().trim() : "",
-  };
-}

package/src/log/log.ts

@@ -1,27 +0,0 @@
-import { mkdirSync, appendFileSync } from "node:fs";
-import path from "node:path";
-
-let logPath: string | null = null;
-
-export function initLog(repoRoot: string): void {
-  const dir = path.join(repoRoot, ".git", "nitpiq");
-  mkdirSync(dir, { recursive: true });
-  logPath = path.join(dir, "debug.log");
-}
-
-function write(level: string, message: string): void {
-  if (!logPath) {
-    return;
-  }
-
-  const line = `[${new Date().toISOString()}] ${level} ${message}\n`;
-  appendFileSync(logPath, line);
-}
-
-export function debug(message: string): void {
-  write("DEBUG", message);
-}
-
-export function error(message: string): void {
-  write("ERROR", message);
-}

package/src/mcp/server.test.ts

@@ -1,37 +0,0 @@
-import { mkdirSync, mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { describe, expect, test } from "bun:test";
-
-describe("nitpiq MCP server", () => {
-  test("keeps the store open after connect", async () => {
-    const repoRoot = mkdtempSync(path.join(tmpdir(), "nitpiq-mcp-"));
-    await Bun.write(path.join(repoRoot, "file.ts"), "export const value = 1;\n");
-
-    Bun.spawnSync(["git", "init"], { cwd: repoRoot, stdout: "ignore", stderr: "ignore" });
-
-    const dbDir = path.join(repoRoot, ".git", "nitpiq");
-    mkdirSync(dbDir, { recursive: true });
-
-    const client = new Client({ name: "nitpiq-test", version: "0.0.0" }, { capabilities: {} });
-    const transport = new StdioClientTransport({
-      command: "bun",
-      args: ["run", path.join(process.cwd(), "src/cli/nitpiq-mcp.ts"), repoRoot],
-      cwd: process.cwd(),
-      stderr: "pipe",
-    });
-
-    await client.connect(transport);
-
-    const result = await client.callTool({
-      name: "review_list_threads",
-      arguments: { status: "open" },
-    });
-
-    expect(result.isError).not.toBeTrue();
-
-    await transport.close();
-  });
-});

package/src/mcp/server.ts

@@ -1,210 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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;
-}