crloop 0.1.0

package/dist/server/server/reviewService.js

@@ -0,0 +1,202 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getChangePath } from "../shared/changePaths.js";
+import { CommentStore, REVIEW_STORAGE_DIRECTORY, getReviewSessionFileName } from "./commentStore.js";
+import { createBinaryUntrackedChange, createUntrackedChange, parseTrackedDiff } from "./diffParser.js";
+import { renderReviewCommentsText } from "../shared/export.js";
+import { runGit } from "./git.js";
+import { ClientError } from "./errors.js";
+const SUMMARY_CONTEXT = "0";
+const FULL_CONTEXT_LINES = 1_000_000;
+export class ReviewService {
+    repoPath;
+    commentStore;
+    constructor(repoPath) {
+        this.repoPath = repoPath;
+        this.commentStore = new CommentStore(repoPath);
+    }
+    async validateRepository() {
+        await this.syncReviewSession();
+    }
+    async getRepoInfo() {
+        await this.syncReviewSession();
+        return {
+            path: this.repoPath,
+            baseRef: "HEAD"
+        };
+    }
+    async getChangeSummaries() {
+        await this.syncReviewSession();
+        const [changes, comments] = await Promise.all([this.getChanges(), this.commentStore.list()]);
+        return changes.map((change) => {
+            const classified = classifyCommentsForChange(comments, change);
+            return {
+                changeId: change.changeId,
+                changeType: change.changeType,
+                oldPath: change.oldPath,
+                newPath: change.newPath,
+                isBinary: change.isBinary,
+                commentCounts: {
+                    current: classified.current.length,
+                    outdated: classified.outdated.length
+                }
+            };
+        });
+    }
+    async getChange(changeId, context = SUMMARY_CONTEXT) {
+        await this.syncReviewSession();
+        const changes = await this.getChanges(context);
+        return changes.find((change) => change.changeId === changeId) ?? null;
+    }
+    async getComments(changeId) {
+        await this.syncReviewSession();
+        const [changes, comments] = await Promise.all([
+            this.getChanges(SUMMARY_CONTEXT),
+            this.commentStore.list()
+        ]);
+        const change = changes.find((c) => c.changeId === changeId);
+        if (!change) {
+            throw new ClientError("Unknown changeId");
+        }
+        return classifyCommentsForChange(comments, change);
+    }
+    async createComment(request) {
+        await this.syncReviewSession();
+        const changes = await this.getChanges("full");
+        const change = changes.find((c) => c.changeId === request.changeId);
+        if (!change) {
+            throw new ClientError("Unknown changeId");
+        }
+        const isValidAnchor = change.hunks.some((hunk) => hunk.lines.some((line) => (line.commentableSide === request.side || (line.kind === "context" && (request.side === "old" || request.side === "new"))) &&
+            getLineNumberForSide(line, request.side) === request.lineNumber));
+        if (!isValidAnchor) {
+            throw new ClientError("Comment anchor is not commentable in the current diff");
+        }
+        return this.commentStore.create({
+            path: getChangePath(change),
+            side: request.side,
+            lineNumber: request.lineNumber,
+            body: request.body.trim(),
+            diffFingerprint: change.diffFingerprint
+        });
+    }
+    async updateComment(commentId, body) {
+        await this.syncReviewSession();
+        return this.commentStore.update(commentId, body.trim());
+    }
+    async deleteComment(commentId) {
+        await this.syncReviewSession();
+        return this.commentStore.delete(commentId);
+    }
+    async exportComments() {
+        await this.syncReviewSession();
+        const [changes, comments] = await Promise.all([this.getChanges(), this.commentStore.list()]);
+        const matchedFileIds = new Set();
+        const files = changes
+            .map((change) => ({
+            path: getChangePath(change),
+            comments: comments
+                .filter((comment) => comment.path === getChangePath(change))
+                .map((comment) => ({
+                comment,
+                status: comment.diffFingerprint === change.diffFingerprint ? "current" : "outdated"
+            }))
+        }))
+            .filter((file) => {
+            const hasComments = file.comments.length > 0;
+            if (hasComments) {
+                matchedFileIds.add(file.path);
+            }
+            return hasComments;
+        });
+        const orphanedFiles = Array.from(groupCommentsByFilePath(comments).entries())
+            .filter(([fileId]) => !matchedFileIds.has(fileId))
+            .map(([fileId, groupedComments]) => ({
+            path: fileId,
+            comments: groupedComments.map((comment) => ({
+                comment,
+                status: "outdated"
+            }))
+        }));
+        return renderReviewCommentsText([...files, ...orphanedFiles], {
+            header: {
+                repoName: path.basename(this.repoPath) || this.repoPath,
+                baseRef: "HEAD",
+                date: new Date().toISOString().slice(0, 10)
+            }
+        });
+    }
+    async syncReviewSession() {
+        const topLevel = (await runGit(this.repoPath, ["rev-parse", "--show-toplevel"])).trim();
+        if (!topLevel) {
+            throw new Error("Invalid Git repository");
+        }
+        const headShortId = (await runGit(topLevel, ["rev-parse", "--short=12", "HEAD"])).trim();
+        if (!headShortId) {
+            throw new Error("Invalid Git repository");
+        }
+        this.repoPath = topLevel;
+        this.commentStore = new CommentStore(topLevel, getReviewSessionFileName(headShortId));
+    }
+    async getChanges(context = SUMMARY_CONTEXT) {
+        const trackedPatch = await runGit(this.repoPath, [
+            "diff",
+            `--unified=${getGitUnifiedContext(context)}`,
+            "HEAD",
+            "--find-renames",
+            "--patch",
+            "--binary",
+            "--no-color"
+        ]);
+        const tracked = parseTrackedDiff(trackedPatch).filter((change) => !isInternalReviewChange(change));
+        const untracked = await this.readUntrackedChanges();
+        return [...tracked, ...untracked].sort((left, right) => getChangePath(left).localeCompare(getChangePath(right)));
+    }
+    async readUntrackedChanges() {
+        const statusOutput = await runGit(this.repoPath, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+        const untrackedPaths = statusOutput
+            .split("\0")
+            .filter((entry) => entry.startsWith("?? "))
+            .map((entry) => entry.slice(3))
+            .filter((relativePath) => !isInternalReviewPath(relativePath));
+        return Promise.all(untrackedPaths.map(async (relativePath) => {
+            const absolutePath = path.join(this.repoPath, relativePath);
+            const content = await fs.readFile(absolutePath);
+            return isBinaryBuffer(content)
+                ? createBinaryUntrackedChange(relativePath, content)
+                : createUntrackedChange(relativePath, content.toString("utf8"));
+        }));
+    }
+}
+function getGitUnifiedContext(context) {
+    return context === "full" ? FULL_CONTEXT_LINES : Number(context);
+}
+function classifyCommentsForChange(comments, change) {
+    const filtered = comments.filter((comment) => comment.path === getChangePath(change));
+    return {
+        current: filtered.filter((comment) => comment.diffFingerprint === change.diffFingerprint),
+        outdated: filtered.filter((comment) => comment.diffFingerprint !== change.diffFingerprint)
+    };
+}
+function groupCommentsByFilePath(comments) {
+    const grouped = new Map();
+    for (const comment of comments) {
+        const list = grouped.get(comment.path) ?? [];
+        list.push(comment);
+        grouped.set(comment.path, list);
+    }
+    return grouped;
+}
+function isInternalReviewChange(change) {
+    return isInternalReviewPath(change.newPath) || isInternalReviewPath(change.oldPath);
+}
+function isInternalReviewPath(filePath) {
+    return typeof filePath === "string" && (filePath === REVIEW_STORAGE_DIRECTORY || filePath.startsWith(`${REVIEW_STORAGE_DIRECTORY}/`));
+}
+function getLineNumberForSide(line, side) {
+    return side === "old" ? line.oldLineNumber : line.newLineNumber;
+}
+function isBinaryBuffer(buffer) {
+    const sample = buffer.subarray(0, Math.min(buffer.length, 8000));
+    return sample.includes(0);
+}

package/dist/server/server/runServer.js

@@ -0,0 +1,15 @@
+import { parseServerOptions } from "./args.js";
+import { startServer } from "./server.js";
+export async function runServer(options = {}) {
+    const parsedOptions = parseServerOptions(options.argv ?? process.argv.slice(2));
+    const { server, port } = await startServer({ repos: parsedOptions.repos, port: parsedOptions.port }, { dev: options.dev });
+    const label = options.dev ? "API" : "Review tool";
+    server.listen(port, "localhost", () => {
+        console.log(`${label} listening on http://localhost:${port}`);
+    });
+}
+export function logFatalError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+}

package/dist/server/server/server.js

@@ -0,0 +1,235 @@
+import http from "node:http";
+import path from "node:path";
+import express from "express";
+import { DIFF_CONTEXT_VALUES } from "../shared/api.js";
+import { deriveRepoId } from "./args.js";
+import { resolveClientDistDirectory } from "./assetPaths.js";
+import { ClientError } from "./errors.js";
+import { ReviewService } from "./reviewService.js";
+function getRepoService(response) {
+    return response.locals.service;
+}
+function getRepoId(response) {
+    return response.locals.repoId;
+}
+export async function startServer({ repos, port }, options = {}) {
+    const services = new Map();
+    for (const repo of repos) {
+        const svc = new ReviewService(repo.path);
+        await svc.validateRepository();
+        services.set(repo.id, svc);
+    }
+    const app = express();
+    app.use(express.json());
+    // ── Flat repo-management endpoints ──────────────────────────
+    app.get("/api/repos", (_request, response) => {
+        const result = [...services.entries()].map(([id, svc]) => ({ id, path: svc.repoPath }));
+        response.json(result);
+    });
+    app.post("/api/repos", async (request, response, next) => {
+        try {
+            const body = request.body;
+            if (typeof body.path !== "string" || body.path.trim().length === 0) {
+                response.status(400).json({ error: "Missing path" });
+                return;
+            }
+            const resolvedPath = path.resolve(body.path);
+            const id = typeof body.id === "string" && body.id.trim().length > 0 ? body.id : deriveRepoId(resolvedPath);
+            if (services.has(id)) {
+                response.status(409).json({ error: `Repo id already in use: ${id}` });
+                return;
+            }
+            const svc = new ReviewService(resolvedPath);
+            try {
+                await svc.validateRepository();
+            }
+            catch {
+                response.status(400).json({ error: "Not a git repository" });
+                return;
+            }
+            services.set(id, svc);
+            response.status(201).json({ id, path: resolvedPath });
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    app.post("/api/server/stop", (_request, response) => {
+        response.status(204).send();
+        setImmediate(() => process.exit(0));
+    });
+    app.delete("/api/repos/:repoId", (request, response) => {
+        const { repoId } = request.params;
+        if (!services.has(repoId)) {
+            response.status(404).json({ error: `Repo not found: ${repoId}` });
+            return;
+        }
+        services.delete(repoId);
+        response.status(204).send();
+    });
+    // ── Per-repo router ──────────────────────────────────────────
+    const repoRouter = express.Router({ mergeParams: true });
+    repoRouter.use((request, response, next) => {
+        const repoId = request.params.repoId;
+        const svc = services.get(repoId);
+        if (!svc) {
+            response.status(404).json({ error: `Repo not found: ${repoId}` });
+            return;
+        }
+        response.locals.repoId = repoId;
+        response.locals.service = svc;
+        next();
+    });
+    repoRouter.get("/repo", async (_request, response, next) => {
+        try {
+            const svc = getRepoService(response);
+            const [info, changes] = await Promise.all([svc.getRepoInfo(), svc.getChangeSummaries()]);
+            response.json({
+                id: getRepoId(response),
+                path: info.path,
+                baseRef: info.baseRef,
+                changeCount: changes.length
+            });
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    repoRouter.get("/changes", async (_request, response, next) => {
+        try {
+            const svc = getRepoService(response);
+            response.json(await svc.getChangeSummaries());
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    repoRouter.get("/changes/:changeId", async (request, response, next) => {
+        try {
+            const svc = getRepoService(response);
+            const change = await svc.getChange(request.params.changeId, parseDiffContext(request.query.context));
+            if (!change) {
+                response.status(404).json({ error: "Change not found" });
+                return;
+            }
+            response.json(change);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    repoRouter.get("/comments", async (request, response, next) => {
+        try {
+            const svc = getRepoService(response);
+            const changeId = request.query.changeId;
+            if (typeof changeId !== "string") {
+                response.status(400).json({ error: "Missing changeId" });
+                return;
+            }
+            response.json(await svc.getComments(changeId));
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    repoRouter.post("/comments", async (request, response, next) => {
+        try {
+            const svc = getRepoService(response);
+            const body = request.body;
+            if (typeof body.changeId !== "string" ||
+                (body.side !== "old" && body.side !== "new") ||
+                typeof body.lineNumber !== "number" ||
+                !Number.isInteger(body.lineNumber) ||
+                body.lineNumber <= 0 ||
+                typeof body.body !== "string" ||
+                body.body.trim().length === 0) {
+                response.status(400).json({ error: "Invalid comment payload" });
+                return;
+            }
+            response.status(201).json(await svc.createComment({
+                changeId: body.changeId,
+                side: body.side,
+                lineNumber: body.lineNumber,
+                body: body.body
+            }));
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    repoRouter.patch("/comments/:commentId", async (request, response, next) => {
+        try {
+            const svc = getRepoService(response);
+            const { commentId } = request.params;
+            const body = request.body;
+            if (typeof commentId !== "string" || typeof body.body !== "string" || body.body.trim().length === 0) {
+                response.status(400).json({ error: "Invalid comment payload" });
+                return;
+            }
+            const updated = await svc.updateComment(commentId, body.body);
+            if (!updated) {
+                response.status(404).json({ error: "Comment not found" });
+                return;
+            }
+            response.json(updated);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    repoRouter.delete("/comments/:commentId", async (request, response, next) => {
+        try {
+            const svc = getRepoService(response);
+            const { commentId } = request.params;
+            if (typeof commentId !== "string") {
+                response.status(400).json({ error: "Missing commentId" });
+                return;
+            }
+            const deleted = await svc.deleteComment(commentId);
+            if (!deleted) {
+                response.status(404).json({ error: "Comment not found" });
+                return;
+            }
+            response.status(204).send();
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    repoRouter.get("/export/comments.txt", async (_request, response, next) => {
+        try {
+            const svc = getRepoService(response);
+            response.type("text/plain").send(await svc.exportComments());
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    app.use("/api/repos/:repoId", repoRouter);
+    app.use((error, _request, response, _next) => {
+        const status = error instanceof ClientError ? 400 : 500;
+        const message = error instanceof Error ? error.message : "Internal server error";
+        response.status(status).json({ error: message });
+    });
+    if (!options.dev) {
+        const clientDir = resolveClientDistDirectory(import.meta.url);
+        app.use(express.static(clientDir));
+        app.get("/{*path}", (_request, response) => {
+            response.sendFile(path.join(clientDir, "index.html"));
+        });
+    }
+    return {
+        app,
+        server: http.createServer(app),
+        port
+    };
+}
+function parseDiffContext(rawValue) {
+    if (rawValue === undefined) {
+        return "full";
+    }
+    if (typeof rawValue !== "string" || !DIFF_CONTEXT_VALUES.includes(rawValue)) {
+        throw new ClientError("Invalid diff context");
+    }
+    return rawValue;
+}

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

@@ -0,0 +1,145 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { startServer } from "./server.js";
+import { createTempGitRepo } from "./testUtils.js";
+let homeDir;
+let repoPath;
+beforeEach(async () => {
+    homeDir = await fs.mkdtemp(path.join(os.tmpdir(), "review-home-"));
+    process.env.HOME = homeDir;
+    process.env.XDG_DATA_HOME = path.join(homeDir, ".local", "share");
+    repoPath = await createTempGitRepo();
+});
+afterEach(async () => {
+    await fs.rm(homeDir, { recursive: true, force: true });
+    await fs.rm(repoPath, { recursive: true, force: true });
+});
+describe("server API", () => {
+    it("lists tracked and untracked changes and persists comments", async () => {
+        const { app } = await startServer({ repoPath, port: 3000 }, { dev: true });
+        const changesResponse = await invokeRoute(app, "get", "/api/changes");
+        expect(changesResponse.statusCode).toBe(200);
+        expect(changesResponse.body.some((change) => change.changeType === "modified")).toBe(true);
+        expect(changesResponse.body.some((change) => change.newPath === "untracked.txt")).toBe(true);
+        const trackedChange = changesResponse.body.find((change) => change.newPath === "tracked.txt");
+        const detailResponse = await invokeRoute(app, "get", "/api/changes/:changeId", {
+            params: { changeId: trackedChange.changeId }
+        });
+        expect(detailResponse.statusCode).toBe(200);
+        const line = detailResponse.body.hunks[0].lines.find((entry) => entry.commentableSide === "new");
+        const createResponse = await invokeRoute(app, "post", "/api/comments", {
+            body: {
+                changeId: trackedChange.changeId,
+                side: "new",
+                oldLineNumber: line.oldLineNumber,
+                newLineNumber: line.newLineNumber,
+                hunkHeader: detailResponse.body.hunks[0].header,
+                body: "Check wording"
+            }
+        });
+        expect(createResponse.statusCode).toBe(201);
+        const commentsResponse = await invokeRoute(app, "get", "/api/comments", {
+            query: { changeId: trackedChange.changeId }
+        });
+        expect(commentsResponse.statusCode).toBe(200);
+        expect(commentsResponse.body.current).toHaveLength(1);
+        expect(commentsResponse.body.outdated).toHaveLength(0);
+    });
+    it("marks comments outdated when the diff fingerprint changes", async () => {
+        const { app } = await startServer({ repoPath, port: 3000 }, { dev: true });
+        const changesResponse = await invokeRoute(app, "get", "/api/changes");
+        const trackedChange = changesResponse.body.find((change) => change.newPath === "tracked.txt");
+        const detailResponse = await invokeRoute(app, "get", "/api/changes/:changeId", {
+            params: { changeId: trackedChange.changeId }
+        });
+        const line = detailResponse.body.hunks[0].lines.find((entry) => entry.commentableSide === "new");
+        const createResponse = await invokeRoute(app, "post", "/api/comments", {
+            body: {
+                changeId: trackedChange.changeId,
+                side: "new",
+                oldLineNumber: line.oldLineNumber,
+                newLineNumber: line.newLineNumber,
+                hunkHeader: detailResponse.body.hunks[0].header,
+                body: "Will go stale"
+            }
+        });
+        expect(createResponse.statusCode).toBe(201);
+        await fs.writeFile(path.join(repoPath, "tracked.txt"), "another\nstay\n", "utf8");
+        const staleResponse = await invokeRoute(app, "get", "/api/comments", {
+            query: { changeId: trackedChange.changeId }
+        });
+        expect(staleResponse.statusCode).toBe(200);
+        expect(staleResponse.body.current).toHaveLength(0);
+        expect(staleResponse.body.outdated).toHaveLength(1);
+    });
+    it("exports orphaned stale comments even after a file leaves the diff", async () => {
+        const { app } = await startServer({ repoPath, port: 3000 }, { dev: true });
+        const changesResponse = await invokeRoute(app, "get", "/api/changes");
+        const trackedChange = changesResponse.body.find((change) => change.newPath === "tracked.txt");
+        const detailResponse = await invokeRoute(app, "get", "/api/changes/:changeId", {
+            params: { changeId: trackedChange.changeId }
+        });
+        const line = detailResponse.body.hunks[0].lines.find((entry) => entry.commentableSide === "new");
+        await invokeRoute(app, "post", "/api/comments", {
+            body: {
+                changeId: trackedChange.changeId,
+                side: "new",
+                oldLineNumber: line.oldLineNumber,
+                newLineNumber: line.newLineNumber,
+                hunkHeader: detailResponse.body.hunks[0].header,
+                body: "Persist in export"
+            }
+        });
+        await fs.writeFile(path.join(repoPath, "tracked.txt"), "before\nstay\n", "utf8");
+        const exportResponse = await invokeRoute(app, "get", "/api/export/comments.md");
+        expect(exportResponse.headers["content-type"]).toBe("text/markdown");
+        expect(exportResponse.body).toContain("## File: tracked.txt");
+        expect(exportResponse.body).toContain("Status: outdated");
+        expect(exportResponse.body).toContain("Persist in export");
+    });
+});
+async function invokeRoute(app, method, pathPattern, options = {}) {
+    const layer = app.router.stack.find((entry) => entry.route?.path === pathPattern && entry.route.methods?.[method]);
+    if (!layer?.route) {
+        throw new Error(`Route not found: ${method.toUpperCase()} ${pathPattern}`);
+    }
+    let statusCode = 200;
+    let body;
+    const headers = {};
+    let nextError;
+    const response = {
+        status(code) {
+            statusCode = code;
+            return this;
+        },
+        json(payload) {
+            body = payload;
+            return this;
+        },
+        send(payload) {
+            body = payload;
+            return this;
+        },
+        type(value) {
+            headers["content-type"] = value;
+            return this;
+        }
+    };
+    await layer.route.stack[0].handle({
+        params: options.params ?? {},
+        query: options.query ?? {},
+        body: options.body ?? {}
+    }, response, (error) => {
+        nextError = error;
+    });
+    if (nextError) {
+        throw nextError;
+    }
+    return {
+        statusCode,
+        body,
+        headers
+    };
+}

package/dist/server/server/testUtils.js

@@ -0,0 +1,25 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+export async function createTempGitRepo() {
+    const repoPath = await fs.mkdtemp(path.join(os.tmpdir(), "review-tool-"));
+    runGit(repoPath, ["init"]);
+    runGit(repoPath, ["config", "user.name", "Test User"]);
+    runGit(repoPath, ["config", "user.email", "test@example.com"]);
+    await fs.writeFile(path.join(repoPath, "tracked.txt"), "before\nstay\n", "utf8");
+    await fs.writeFile(path.join(repoPath, "rename-me.txt"), "rename source\n", "utf8");
+    runGit(repoPath, ["add", "."]);
+    runGit(repoPath, ["commit", "-m", "initial"]);
+    await fs.writeFile(path.join(repoPath, "tracked.txt"), "after\nstay\n", "utf8");
+    await fs.rename(path.join(repoPath, "rename-me.txt"), path.join(repoPath, "renamed.txt"));
+    await fs.writeFile(path.join(repoPath, "untracked.txt"), "brand new\nline two\n", "utf8");
+    await fs.writeFile(path.join(repoPath, "binary.bin"), Buffer.from([0, 1, 2, 3, 4]));
+    return repoPath;
+}
+export function runGit(repoPath, args) {
+    return execFileSync("git", args, {
+        cwd: repoPath,
+        encoding: "utf8"
+    });
+}

package/dist/server/shared/api.js

@@ -0,0 +1 @@
+export const DIFF_CONTEXT_VALUES = ["0", "3", "20", "100", "full"];

package/dist/server/shared/changePaths.js

@@ -0,0 +1,3 @@
+export function getChangePath(change) {
+    return change.newPath ?? change.oldPath ?? "(unknown)";
+}

package/dist/server/shared/export.js

@@ -0,0 +1,26 @@
+export function renderReviewCommentsText(files, options = {}) {
+    const lines = [];
+    if (options.header) {
+        lines.push(`CODE REVIEW  ·  ${options.header.repoName}  ·  branch: ${options.header.baseRef}  ·  ${options.header.date}`, "━".repeat(50), "");
+    }
+    for (const file of [...files].sort((left, right) => left.path.localeCompare(right.path))) {
+        const comments = [...file.comments].sort(compareCommentExportOrder);
+        if (comments.length === 0) {
+            continue;
+        }
+        lines.push(`REVIEW ${file.path}`);
+        lines.push("");
+        for (const { comment, status } of comments) {
+            lines.push(`NOTE ${comment.commentId} SIDE ${comment.side} LINE ${comment.lineNumber} STATUS ${status}`);
+            lines.push(comment.body);
+            lines.push("END NOTE");
+            lines.push("");
+        }
+    }
+    return lines.join("\n").trimEnd() + "\n";
+}
+function compareCommentExportOrder(left, right) {
+    return (left.comment.lineNumber - right.comment.lineNumber ||
+        left.comment.side.localeCompare(right.comment.side) ||
+        left.comment.commentId.localeCompare(right.comment.commentId));
+}

package/dist/server/shared/types.js

@@ -0,0 +1 @@
+export {};