crloop 0.1.0

package/dist/server/server/commentStore.js

@@ -0,0 +1,190 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+export const REVIEW_STORAGE_DIRECTORY = ".local-code-review";
+export function getReviewSessionFileName(reviewBaseShortId) {
+    return `${reviewBaseShortId}.json`;
+}
+export class CommentStore {
+    sessionFileName;
+    storageDir;
+    constructor(repoPath, sessionFileName = getReviewSessionFileName("HEAD"), storageDir = path.join(repoPath, REVIEW_STORAGE_DIRECTORY)) {
+        this.sessionFileName = sessionFileName;
+        this.storageDir = storageDir;
+    }
+    async list() {
+        const storedComments = await this.read();
+        return flattenStoredComments(storedComments).map(toReviewComment);
+    }
+    async create(input) {
+        const storedComments = await this.read();
+        const commentsForPath = storedComments[input.path] ?? [];
+        const storedComment = {
+            id: createCommentId(),
+            side: input.side,
+            line: input.lineNumber,
+            body: input.body,
+            diffFingerprint: input.diffFingerprint
+        };
+        commentsForPath.push(storedComment);
+        storedComments[input.path] = commentsForPath;
+        await this.write(storedComments);
+        return toReviewComment({
+            path: input.path,
+            comment: storedComment
+        });
+    }
+    async update(commentId, body) {
+        const storedComments = await this.read();
+        const record = findStoredComment(storedComments, commentId);
+        if (!record) {
+            return null;
+        }
+        const updated = {
+            ...record.comment,
+            body
+        };
+        storedComments[record.path][record.index] = updated;
+        await this.write(storedComments);
+        return toReviewComment({
+            path: record.path,
+            comment: updated
+        });
+    }
+    async delete(commentId) {
+        const storedComments = await this.read();
+        const record = findStoredComment(storedComments, commentId);
+        if (!record) {
+            return false;
+        }
+        const nextComments = storedComments[record.path].filter((_comment, index) => index !== record.index);
+        if (nextComments.length === 0) {
+            delete storedComments[record.path];
+        }
+        else {
+            storedComments[record.path] = nextComments;
+        }
+        await this.write(storedComments);
+        return true;
+    }
+    async getSessionFilePath() {
+        await fs.mkdir(this.storageDir, { recursive: true });
+        return path.join(this.storageDir, this.sessionFileName);
+    }
+    async read() {
+        const sessionPath = await this.getSessionFilePath();
+        try {
+            const content = await fs.readFile(sessionPath, "utf8");
+            const normalized = normalizeStoredComments(JSON.parse(content));
+            if (normalized.didUpgrade) {
+                await this.write(normalized.comments);
+            }
+            return normalized.comments;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return {};
+            }
+            throw error;
+        }
+    }
+    async write(storedComments) {
+        const sessionPath = await this.getSessionFilePath();
+        const sortedEntries = Object.entries(storedComments).sort(([left], [right]) => left.localeCompare(right));
+        const normalizedComments = Object.fromEntries(sortedEntries);
+        await fs.writeFile(sessionPath, `${JSON.stringify(normalizedComments, null, 2)}\n`, "utf8");
+    }
+}
+function flattenStoredComments(storedComments) {
+    return Object.entries(storedComments).flatMap(([path, comments]) => comments.map((comment) => ({
+        path,
+        comment
+    })));
+}
+function toReviewComment(entry) {
+    return {
+        commentId: entry.comment.id,
+        path: entry.path,
+        side: entry.comment.side,
+        lineNumber: entry.comment.line,
+        body: entry.comment.body,
+        diffFingerprint: entry.comment.diffFingerprint
+    };
+}
+function createCommentId() {
+    return randomUUID().replace(/-/g, "").slice(0, 12);
+}
+function findStoredComment(storedComments, commentId) {
+    for (const [filePath, comments] of Object.entries(storedComments)) {
+        for (const [index, comment] of comments.entries()) {
+            if (comment.id === commentId) {
+                return {
+                    path: filePath,
+                    index,
+                    comment
+                };
+            }
+        }
+    }
+    return null;
+}
+function normalizeStoredComments(value) {
+    if (isLegacySessionFile(value)) {
+        return {
+            comments: value.comments.reduce((accumulator, comment) => {
+                const lineNumber = comment.side === "old" ? comment.oldLineNumber : comment.newLineNumber;
+                if (typeof lineNumber !== "number") {
+                    return accumulator;
+                }
+                const commentsForPath = accumulator[comment.fileId] ?? [];
+                commentsForPath.push({
+                    id: createCommentId(),
+                    side: comment.side,
+                    line: lineNumber,
+                    body: comment.body,
+                    diffFingerprint: comment.diffFingerprint
+                });
+                accumulator[comment.fileId] = commentsForPath;
+                return accumulator;
+            }, {}),
+            didUpgrade: true
+        };
+    }
+    if (!isStoredCommentsFile(value)) {
+        throw new Error("Invalid comments file");
+    }
+    let didUpgrade = false;
+    const comments = {};
+    for (const [filePath, storedComments] of Object.entries(value)) {
+        comments[filePath] = storedComments.map((comment) => {
+            const id = typeof comment.id === "string" && comment.id.length > 0 ? comment.id : createCommentId();
+            if (id !== comment.id) {
+                didUpgrade = true;
+            }
+            return {
+                ...comment,
+                id
+            };
+        });
+    }
+    return {
+        comments,
+        didUpgrade
+    };
+}
+function isLegacySessionFile(value) {
+    return typeof value === "object" && value !== null && Array.isArray(value.comments);
+}
+function isStoredCommentsFile(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    return Object.values(value).every((comments) => Array.isArray(comments) &&
+        comments.every((comment) => typeof comment === "object" &&
+            comment !== null &&
+            (typeof comment.id === "string" || comment.id === undefined) &&
+            (comment.side === "old" || comment.side === "new") &&
+            typeof comment.line === "number" &&
+            typeof comment.body === "string" &&
+            typeof comment.diffFingerprint === "string"));
+}

package/dist/server/server/commentStore.test.js

@@ -0,0 +1,34 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { CommentStore } from "./commentStore.js";
+const createdDirectories = [];
+afterEach(async () => {
+    await Promise.all(createdDirectories.splice(0).map((directory) => fs.rm(directory, { recursive: true, force: true })));
+});
+describe("CommentStore", () => {
+    it("persists comments in a deterministic session file", async () => {
+        const storageDir = await fs.mkdtemp(path.join(os.tmpdir(), "comment-store-"));
+        createdDirectories.push(storageDir);
+        const store = new CommentStore("/tmp/repo", storageDir);
+        const created = await store.create({
+            fileId: "change-1",
+            side: "new",
+            oldLineNumber: null,
+            newLineNumber: 4,
+            hunkHeader: "@@ -1,1 +1,2 @@",
+            body: "Looks good",
+            diffFingerprint: "fingerprint-1"
+        });
+        const comments = await store.list();
+        const sessionFiles = await fs.readdir(storageDir);
+        expect(sessionFiles).toHaveLength(1);
+        expect(comments).toHaveLength(1);
+        expect(comments[0]).toMatchObject({
+            commentId: created.commentId,
+            body: "Looks good",
+            createdAt: created.createdAt
+        });
+    });
+});

package/dist/server/server/devServer.js

@@ -0,0 +1,2 @@
+import { logFatalError, runServer } from "./runServer.js";
+runServer({ dev: true }).catch(logFatalError);

package/dist/server/server/diffParser.js

@@ -0,0 +1,234 @@
+import { getChangePath } from "../shared/changePaths.js";
+import { sha256 } from "./hash.js";
+const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
+export function parseTrackedDiff(patch) {
+    const state = {
+        current: null,
+        currentHunk: null,
+        files: []
+    };
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("diff --git ")) {
+            finalizeHunk(state);
+            finalizeFile(state);
+            state.current = createFileFromHeader(line);
+            continue;
+        }
+        if (!state.current) {
+            continue;
+        }
+        if (line.startsWith("old mode ") || line.startsWith("new mode ") || line.startsWith("similarity index ")) {
+            appendFingerprintLine(state.current, line);
+            continue;
+        }
+        if (line.startsWith("rename from ")) {
+            state.current.changeType = "renamed";
+            state.current.oldPath = line.slice("rename from ".length);
+            appendFingerprintLine(state.current, line);
+            continue;
+        }
+        if (line.startsWith("rename to ")) {
+            state.current.changeType = "renamed";
+            state.current.newPath = line.slice("rename to ".length);
+            appendFingerprintLine(state.current, line);
+            continue;
+        }
+        if (line.startsWith("new file mode ")) {
+            state.current.changeType = "added";
+            appendFingerprintLine(state.current, line);
+            continue;
+        }
+        if (line.startsWith("deleted file mode ")) {
+            state.current.changeType = "deleted";
+            appendFingerprintLine(state.current, line);
+            continue;
+        }
+        if (line.startsWith("Binary files ") || line === "GIT binary patch") {
+            state.current.isBinary = true;
+            appendFingerprintLine(state.current, line);
+            continue;
+        }
+        if (line.startsWith("index ") || line.startsWith("--- ") || line.startsWith("+++ ")) {
+            updatePathsFromPatchLine(state.current, line);
+            appendFingerprintLine(state.current, line);
+            continue;
+        }
+        if (line.startsWith("@@ ")) {
+            finalizeHunk(state);
+            state.currentHunk = createHunk(line);
+            continue;
+        }
+        if (state.currentHunk && isDiffBodyLine(line)) {
+            const diffLine = parseDiffLine(line, state.currentHunk);
+            state.currentHunk.lines.push(diffLine);
+            if (diffLine.kind !== "context") {
+                appendFingerprintLine(state.current, normalizeDiffLine(diffLine));
+            }
+            continue;
+        }
+        if (line === "\") {
+            appendFingerprintLine(state.current, line);
+        }
+    }
+    finalizeHunk(state);
+    finalizeFile(state);
+    return state.files
+        .map(({ rawFingerprintLines, ...file }) => ({
+        ...file,
+        diffFingerprint: sha256(rawFingerprintLines.join("\n"))
+    }))
+        .sort((left, right) => getChangePath(left).localeCompare(getChangePath(right)));
+}
+export function createUntrackedChange(filePath, content) {
+    const lines = content.split(/\r?\n/);
+    const visibleLines = lines.at(-1) === "" ? lines.slice(0, -1) : lines;
+    const hunkHeader = `@@ -0,0 +1,${Math.max(visibleLines.length, 0)} @@`;
+    const diffLines = visibleLines.map((text, index) => ({
+        kind: "added",
+        oldLineNumber: null,
+        newLineNumber: index + 1,
+        text,
+        commentableSide: "new"
+    }));
+    const fingerprintSource = [`untracked:${filePath}`, hunkHeader, ...diffLines.map(normalizeDiffLine)].join("\n");
+    const changeId = sha256(`untracked:${filePath}`);
+    return {
+        changeId,
+        changeType: "untracked",
+        oldPath: null,
+        newPath: filePath,
+        isBinary: false,
+        diffFingerprint: sha256(fingerprintSource),
+        hunks: [
+            {
+                header: hunkHeader,
+                lines: diffLines
+            }
+        ]
+    };
+}
+export function createBinaryUntrackedChange(filePath, content) {
+    return {
+        changeId: sha256(`untracked:${filePath}`),
+        changeType: "untracked",
+        oldPath: null,
+        newPath: filePath,
+        isBinary: true,
+        diffFingerprint: sha256(`untracked-binary:${filePath}:${content.toString("base64")}`),
+        hunks: []
+    };
+}
+function createFileFromHeader(line) {
+    const match = /^diff --git a\/(.*) b\/(.*)$/.exec(line);
+    const oldPath = match?.[1] ?? null;
+    const newPath = match?.[2] ?? null;
+    return {
+        changeId: sha256(`tracked:${oldPath ?? ""}:${newPath ?? ""}`),
+        changeType: inferInitialChangeType(oldPath, newPath),
+        oldPath,
+        newPath,
+        isBinary: false,
+        hunks: [],
+        rawFingerprintLines: [line]
+    };
+}
+function inferInitialChangeType(oldPath, newPath) {
+    if (!oldPath && newPath) {
+        return "added";
+    }
+    if (oldPath && !newPath) {
+        return "deleted";
+    }
+    return "modified";
+}
+function finalizeHunk(state) {
+    if (!state.current || !state.currentHunk || state.current.isBinary) {
+        state.currentHunk = null;
+        return;
+    }
+    state.current.hunks.push({
+        header: state.currentHunk.header,
+        lines: state.currentHunk.lines
+    });
+    state.currentHunk = null;
+}
+function finalizeFile(state) {
+    if (!state.current) {
+        return;
+    }
+    state.current.changeId = sha256(`${state.current.changeType}:${state.current.oldPath ?? ""}:${state.current.newPath ?? ""}`);
+    state.files.push(state.current);
+    state.current = null;
+}
+function appendFingerprintLine(file, line) {
+    file.rawFingerprintLines.push(line);
+}
+function updatePathsFromPatchLine(file, line) {
+    if (!line.startsWith("--- ") && !line.startsWith("+++ ")) {
+        return;
+    }
+    const rawPath = line.slice(4).trim();
+    const parsed = rawPath === "/dev/null" ? null : stripPatchPrefix(rawPath);
+    if (line.startsWith("--- ")) {
+        file.oldPath = parsed;
+    }
+    else {
+        file.newPath = parsed;
+    }
+}
+function stripPatchPrefix(value) {
+    return value.replace(/^[ab]\//, "");
+}
+function createHunk(headerLine) {
+    const match = HUNK_RE.exec(headerLine);
+    if (!match) {
+        throw new Error(`Invalid hunk header: ${headerLine}`);
+    }
+    return {
+        header: `@@ -${match[1]}${match[2] ? `,${match[2]}` : ""} +${match[3]}${match[4] ? `,${match[4]}` : ""} @@${match[5]}`,
+        lines: [],
+        oldLineNumber: Number(match[1]),
+        newLineNumber: Number(match[3])
+    };
+}
+function isDiffBodyLine(line) {
+    return line.startsWith(" ") || line.startsWith("+") || line.startsWith("-");
+}
+function parseDiffLine(line, hunk) {
+    const text = line.slice(1);
+    if (line.startsWith(" ")) {
+        const diffLine = {
+            kind: "context",
+            oldLineNumber: hunk.oldLineNumber,
+            newLineNumber: hunk.newLineNumber,
+            text,
+            commentableSide: null
+        };
+        hunk.oldLineNumber += 1;
+        hunk.newLineNumber += 1;
+        return diffLine;
+    }
+    if (line.startsWith("+")) {
+        const diffLine = {
+            kind: "added",
+            oldLineNumber: null,
+            newLineNumber: hunk.newLineNumber,
+            text,
+            commentableSide: "new"
+        };
+        hunk.newLineNumber += 1;
+        return diffLine;
+    }
+    const diffLine = {
+        kind: "removed",
+        oldLineNumber: hunk.oldLineNumber,
+        newLineNumber: null,
+        text,
+        commentableSide: "old"
+    };
+    hunk.oldLineNumber += 1;
+    return diffLine;
+}
+function normalizeDiffLine(line) {
+    return [line.kind, line.oldLineNumber ?? "-", line.newLineNumber ?? "-", line.text].join("|");
+}

package/dist/server/server/diffParser.test.js

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { createBinaryUntrackedChange, createUntrackedChange, parseTrackedDiff } from "./diffParser.js";
+describe("parseTrackedDiff", () => {
+    it("parses tracked text diffs with stable line numbers and commentable sides", () => {
+        const patch = [
+            "diff --git a/tracked.txt b/tracked.txt",
+            "index 83db48f..bf8a6f4 100644",
+            "--- a/tracked.txt",
+            "+++ b/tracked.txt",
+            "@@ -1,2 +1,2 @@",
+            "-before",
+            "+after",
+            " stay"
+        ].join("\n");
+        const [change] = parseTrackedDiff(patch);
+        expect(change.changeType).toBe("modified");
+        expect(change.hunks).toHaveLength(1);
+        expect(change.hunks[0].lines).toEqual([
+            {
+                kind: "removed",
+                oldLineNumber: 1,
+                newLineNumber: null,
+                text: "before",
+                commentableSide: "old"
+            },
+            {
+                kind: "added",
+                oldLineNumber: null,
+                newLineNumber: 1,
+                text: "after",
+                commentableSide: "new"
+            },
+            {
+                kind: "context",
+                oldLineNumber: 2,
+                newLineNumber: 2,
+                text: "stay",
+                commentableSide: null
+            }
+        ]);
+    });
+    it("marks binary tracked diffs as non-commentable", () => {
+        const patch = [
+            "diff --git a/image.png b/image.png",
+            "index 1111111..2222222 100644",
+            "Binary files a/image.png and b/image.png differ"
+        ].join("\n");
+        const [change] = parseTrackedDiff(patch);
+        expect(change.isBinary).toBe(true);
+        expect(change.hunks).toEqual([]);
+    });
+});
+describe("untracked changes", () => {
+    it("creates text hunks for untracked files", () => {
+        const change = createUntrackedChange("notes.txt", "first\nsecond\n");
+        expect(change.changeType).toBe("untracked");
+        expect(change.hunks[0].header).toBe("@@ -0,0 +1,2 @@");
+        expect(change.hunks[0].lines[1]).toEqual({
+            kind: "added",
+            oldLineNumber: null,
+            newLineNumber: 2,
+            text: "second",
+            commentableSide: "new"
+        });
+    });
+    it("creates non-commentable binary untracked changes", () => {
+        const change = createBinaryUntrackedChange("blob.bin", Buffer.from([0, 1, 2]));
+        expect(change.isBinary).toBe(true);
+        expect(change.hunks).toEqual([]);
+    });
+});

package/dist/server/server/errors.js

@@ -0,0 +1,6 @@
+export class ClientError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ClientError";
+    }
+}

package/dist/server/server/exporter.js

@@ -0,0 +1,4 @@
+import { renderReviewCommentsText } from "../shared/export.js";
+export function renderCommentsMarkdown(files) {
+    return renderReviewCommentsText(files);
+}

package/dist/server/server/exporter.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { renderCommentsMarkdown } from "./exporter.js";
+describe("renderCommentsMarkdown", () => {
+    it("renders comments in stable file and line order", () => {
+        const markdown = renderCommentsMarkdown("/repo", [
+            {
+                change: null,
+                path: "b.ts",
+                current: [
+                    {
+                        commentId: "2",
+                        fileId: "b",
+                        side: "new",
+                        oldLineNumber: null,
+                        newLineNumber: 10,
+                        hunkHeader: "@@ -1,1 +1,1 @@",
+                        body: "Second",
+                        createdAt: "2026-03-10T10:00:00.000Z",
+                        diffFingerprint: "fp"
+                    }
+                ],
+                outdated: []
+            },
+            {
+                change: null,
+                path: "a.ts",
+                current: [
+                    {
+                        commentId: "1",
+                        fileId: "a",
+                        side: "old",
+                        oldLineNumber: 3,
+                        newLineNumber: null,
+                        hunkHeader: "@@ -3,1 +3,0 @@",
+                        body: "First",
+                        createdAt: "2026-03-10T09:00:00.000Z",
+                        diffFingerprint: "fp"
+                    }
+                ],
+                outdated: []
+            }
+        ]);
+        expect(markdown.indexOf("## File: a.ts")).toBeLessThan(markdown.indexOf("## File: b.ts"));
+        expect(markdown).toContain("Status: current");
+        expect(markdown).toContain("Body:\nFirst");
+    });
+});

package/dist/server/server/git.js

@@ -0,0 +1,11 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function runGit(repoPath, args) {
+    const { stdout } = await execFileAsync("git", args, {
+        cwd: repoPath,
+        encoding: "utf8",
+        maxBuffer: 20 * 1024 * 1024
+    });
+    return stdout;
+}

package/dist/server/server/hash.js

@@ -0,0 +1,4 @@
+import crypto from "node:crypto";
+export function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}

package/dist/server/server/index.js

@@ -0,0 +1,2 @@
+import { logFatalError, runServer } from "./runServer.js";
+runServer().catch(logFatalError);

package/dist/server/server/platformPaths.js

@@ -0,0 +1,12 @@
+import os from "node:os";
+import path from "node:path";
+export function getAppDataDirectory() {
+    const home = os.homedir();
+    if (process.platform === "darwin") {
+        return path.join(home, "Library", "Application Support", "local-review-tool");
+    }
+    if (process.platform === "win32") {
+        return path.join(process.env.APPDATA ?? path.join(home, "AppData", "Roaming"), "local-review-tool");
+    }
+    return path.join(process.env.XDG_DATA_HOME ?? path.join(home, ".local", "share"), "local-review-tool");
+}