@mrsf/cli 0.1.0

package/dist/commands/list.js

@@ -0,0 +1,95 @@
+/**
+ * mrsf list — List comments in sidecar files.
+ */
+import chalk from "chalk";
+import { sidecarToDocument } from "../lib/discovery.js";
+import { parseSidecar } from "../lib/parser.js";
+import { resolveSidecarPaths } from "../lib/resolve-files.js";
+import { filterComments, summarize } from "../lib/comments.js";
+export function registerList(program) {
+    program
+        .command("list [files...]")
+        .description("List comments across sidecar files")
+        .option("--open", "Show only open (unresolved) comments")
+        .option("--resolved", "Show only resolved comments")
+        .option("--orphaned", "Show only orphaned comments")
+        .option("--author <name>", "Filter by author")
+        .option("--type <type>", "Filter by type")
+        .option("--severity <level>", "Filter by severity")
+        .option("--summary", "Show a summary instead of individual comments")
+        .option("--json", "Output as JSON")
+        .action(async (files, opts) => {
+        const parentOpts = program.opts();
+        const cwd = parentOpts.cwd ?? process.cwd();
+        const sidecarPaths = await resolveSidecarPaths(files, cwd);
+        if (sidecarPaths.length === 0) {
+            console.log("No sidecar files found.");
+            return;
+        }
+        const filter = {
+            open: opts.open,
+            resolved: opts.resolved,
+            orphaned: opts.orphaned,
+            author: opts.author,
+            type: opts.type,
+            severity: opts.severity,
+        };
+        const allComments = [];
+        for (const sp of sidecarPaths) {
+            try {
+                const doc = await parseSidecar(sp);
+                const filtered = filterComments(doc.comments, filter);
+                const docPath = sidecarToDocument(sp);
+                for (const c of filtered) {
+                    allComments.push({
+                        sidecar: sp,
+                        document: docPath,
+                        comment: c,
+                    });
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(chalk.red(`✗ ${sp}: ${msg}`));
+            }
+        }
+        if (opts.json) {
+            if (opts.summary) {
+                console.log(JSON.stringify(summarize(allComments.map((a) => a.comment)), null, 2));
+            }
+            else {
+                console.log(JSON.stringify(allComments, null, 2));
+            }
+            return;
+        }
+        if (opts.summary) {
+            const s = summarize(allComments.map((a) => a.comment));
+            console.log(`Total: ${s.total}  Open: ${s.open}  Resolved: ${s.resolved}  Orphaned: ${s.orphaned}  Threads: ${s.threads}`);
+            if (Object.keys(s.byType).length > 0) {
+                console.log(`By type: ${Object.entries(s.byType).map(([k, v]) => `${k}(${v})`).join(", ")}`);
+            }
+            if (Object.keys(s.bySeverity).length > 0) {
+                console.log(`By severity: ${Object.entries(s.bySeverity).map(([k, v]) => `${k}(${v})`).join(", ")}`);
+            }
+            return;
+        }
+        if (allComments.length === 0) {
+            console.log("No matching comments.");
+            return;
+        }
+        for (const { document, comment: c } of allComments) {
+            const status = c.resolved
+                ? chalk.dim("[resolved]")
+                : chalk.green("[open]");
+            const loc = c.line ? `:${c.line}` : "";
+            const sev = c.severity ? chalk.yellow(` [${c.severity}]`) : "";
+            const typ = c.type ? chalk.cyan(` (${c.type})`) : "";
+            console.log(`${status} ${chalk.bold(c.id)} ${document}${loc}${sev}${typ}`);
+            console.log(`  ${c.author}: ${c.text}`);
+            if (c.reply_to)
+                console.log(chalk.dim(`  ↳ reply to ${c.reply_to}`));
+        }
+        console.log(`\n${allComments.length} comment(s).`);
+    });
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/reanchor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * mrsf reanchor — Re-anchor comments after document changes.
+ */
+import type { Command } from "commander";
+export declare function registerReanchor(program: Command): void;
+//# sourceMappingURL=reanchor.d.ts.map

package/dist/commands/reanchor.js

@@ -0,0 +1,127 @@
+/**
+ * mrsf reanchor — Re-anchor comments after document changes.
+ */
+import chalk from "chalk";
+import path from "node:path";
+import { parseSidecar } from "../lib/parser.js";
+import { readDocumentLines } from "../lib/parser.js";
+import { sidecarToDocument } from "../lib/discovery.js";
+import { resolveSidecarPaths } from "../lib/resolve-files.js";
+import { writeSidecar } from "../lib/writer.js";
+import { findRepoRoot, getStagedFiles } from "../lib/git.js";
+import { reanchorDocument, applyReanchorResults, } from "../lib/reanchor.js";
+export function registerReanchor(program) {
+    program
+        .command("reanchor [files...]")
+        .description("Re-anchor comments to current document content")
+        .option("-n, --dry-run", "Report without modifying files")
+        .option("-t, --threshold <n>", "Fuzzy threshold 0.0–1.0", "0.6")
+        .option("--staged", "Only process sidecars for staged files")
+        .option("--no-git", "Disable git integration")
+        .option("--from <commit>", "Override from-commit for all comments")
+        .option("--update-text", "Also update selected_text to match current document text")
+        .action(async (files, opts) => {
+        const parentOpts = program.opts();
+        const cwd = parentOpts.cwd ?? process.cwd();
+        const quiet = parentOpts.quiet ?? false;
+        const threshold = parseFloat(opts.threshold);
+        const noGit = !opts.git;
+        let sidecarPaths;
+        if (opts.staged && !noGit) {
+            // Only process sidecars whose documents are staged
+            const repoRoot = await findRepoRoot(cwd);
+            if (!repoRoot) {
+                console.error(chalk.red("Not in a git repository."));
+                process.exit(1);
+            }
+            const staged = await getStagedFiles(repoRoot, "*.md");
+            sidecarPaths = [];
+            for (const md of staged) {
+                const absPath = path.resolve(repoRoot, md + ".review.yaml");
+                try {
+                    await parseSidecar(absPath);
+                    sidecarPaths.push(absPath);
+                }
+                catch {
+                    // No sidecar for this staged file, skip
+                }
+            }
+        }
+        else {
+            sidecarPaths = await resolveSidecarPaths(files, cwd);
+        }
+        if (sidecarPaths.length === 0) {
+            if (!quiet)
+                console.log("No sidecar files found.");
+            return;
+        }
+        let totalChanged = 0;
+        let totalOrphaned = 0;
+        for (const sp of sidecarPaths) {
+            try {
+                const doc = await parseSidecar(sp);
+                const docPath = sidecarToDocument(sp);
+                const lines = await readDocumentLines(docPath);
+                const repoRoot = !noGit ? await findRepoRoot(cwd) : null;
+                const results = await reanchorDocument(doc, lines, {
+                    threshold,
+                    noGit,
+                    fromCommit: opts.from,
+                    documentPath: docPath,
+                    repoRoot: repoRoot ?? undefined,
+                });
+                const orphaned = results.filter((r) => r.status === "orphaned").length;
+                totalOrphaned += orphaned;
+                if (!opts.dryRun) {
+                    const changed = applyReanchorResults(doc, results, {
+                        updateText: opts.updateText,
+                    });
+                    totalChanged += changed;
+                    if (changed > 0) {
+                        await writeSidecar(sp, doc);
+                    }
+                }
+                if (!quiet) {
+                    printResults(sp, results, opts.dryRun);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(chalk.red(`✗ ${sp}: ${msg}`));
+            }
+        }
+        if (!quiet) {
+            console.log();
+            const label = opts.dryRun ? "would change" : "changed";
+            console.log(`${totalChanged} comment(s) ${label}, ${totalOrphaned} orphaned.`);
+        }
+        if (totalOrphaned > 0)
+            process.exit(1);
+    });
+}
+function printResults(sidecarPath, results, dryRun) {
+    const prefix = dryRun ? "[dry-run] " : "";
+    console.log(`${prefix}${sidecarPath}:`);
+    for (const r of results) {
+        const icon = statusIcon(r.status);
+        const line = r.newLine != null ? `:${r.newLine}` : "";
+        console.log(`  ${icon} ${r.commentId}${line} — ${r.reason}`);
+    }
+}
+function statusIcon(status) {
+    switch (status) {
+        case "anchored":
+            return chalk.green("●");
+        case "shifted":
+            return chalk.blue("↕");
+        case "fuzzy":
+            return chalk.yellow("≈");
+        case "ambiguous":
+            return chalk.magenta("?");
+        case "orphaned":
+            return chalk.red("✗");
+        default:
+            return "·";
+    }
+}
+//# sourceMappingURL=reanchor.js.map

package/dist/commands/rename.d.ts

@@ -0,0 +1,6 @@
+/**
+ * mrsf rename — Update sidecar when a document is renamed.
+ */
+import type { Command } from "commander";
+export declare function registerRename(program: Command): void;
+//# sourceMappingURL=rename.d.ts.map

package/dist/commands/rename.js

@@ -0,0 +1,53 @@
+/**
+ * mrsf rename — Update sidecar when a document is renamed.
+ */
+import chalk from "chalk";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { discoverSidecar, findWorkspaceRoot } from "../lib/discovery.js";
+import { parseSidecar } from "../lib/parser.js";
+import { writeSidecar } from "../lib/writer.js";
+export function registerRename(program) {
+    program
+        .command("rename <old-document> <new-document>")
+        .description("Update a sidecar after its document has been renamed or moved")
+        .action(async (oldDoc, newDoc) => {
+        const parentOpts = program.opts();
+        const cwd = parentOpts.cwd ?? process.cwd();
+        const quiet = parentOpts.quiet ?? false;
+        const oldDocPath = path.resolve(cwd, oldDoc);
+        const newDocPath = path.resolve(cwd, newDoc);
+        const root = await findWorkspaceRoot(cwd);
+        // Find old sidecar
+        const oldSidecarPath = await discoverSidecar(oldDocPath, { cwd: root ?? cwd });
+        let doc;
+        try {
+            doc = await parseSidecar(oldSidecarPath);
+        }
+        catch {
+            console.error(chalk.red(`Sidecar not found for ${oldDoc} at ${oldSidecarPath}`));
+            process.exit(1);
+        }
+        // Update document reference
+        doc.document = path.basename(newDocPath);
+        // Compute new sidecar path
+        const newSidecarPath = await discoverSidecar(newDocPath, { cwd: root ?? cwd });
+        // Ensure target directory exists
+        await fs.mkdir(path.dirname(newSidecarPath), { recursive: true });
+        // Write new sidecar
+        await writeSidecar(newSidecarPath, doc);
+        // Remove old sidecar if different location
+        if (oldSidecarPath !== newSidecarPath) {
+            try {
+                await fs.unlink(oldSidecarPath);
+            }
+            catch {
+                // Already gone or inaccessible
+            }
+        }
+        if (!quiet) {
+            console.log(chalk.green(`Renamed: ${oldSidecarPath} → ${newSidecarPath}`));
+        }
+    });
+}
+//# sourceMappingURL=rename.js.map

package/dist/commands/resolve.d.ts

@@ -0,0 +1,6 @@
+/**
+ * mrsf resolve — Resolve (or unresolve) a comment.
+ */
+import type { Command } from "commander";
+export declare function registerResolve(program: Command): void;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/commands/resolve.js

@@ -0,0 +1,35 @@
+/**
+ * mrsf resolve — Resolve (or unresolve) a comment.
+ */
+import chalk from "chalk";
+import path from "node:path";
+import { parseSidecar } from "../lib/parser.js";
+import { writeSidecar } from "../lib/writer.js";
+import { resolveComment, unresolveComment } from "../lib/comments.js";
+export function registerResolve(program) {
+    program
+        .command("resolve <sidecar> <id>")
+        .description("Resolve a comment by ID")
+        .option("--cascade", "Also resolve direct replies")
+        .option("-u, --undo", "Unresolve instead")
+        .action(async (sidecar, id, opts) => {
+        const parentOpts = program.opts();
+        const cwd = parentOpts.cwd ?? process.cwd();
+        const quiet = parentOpts.quiet ?? false;
+        const sp = path.resolve(cwd, sidecar);
+        const doc = await parseSidecar(sp);
+        const ok = opts.undo
+            ? unresolveComment(doc, id)
+            : resolveComment(doc, id, opts.cascade);
+        if (!ok) {
+            console.error(chalk.red(`Comment ${id} not found in ${sidecar}.`));
+            process.exit(1);
+        }
+        await writeSidecar(sp, doc);
+        if (!quiet) {
+            const action = opts.undo ? "Unresolved" : "Resolved";
+            console.log(chalk.green(`${action} ${id} in ${sidecar}.`));
+        }
+    });
+}
+//# sourceMappingURL=resolve.js.map

package/dist/commands/status.d.ts

@@ -0,0 +1,6 @@
+/**
+ * mrsf status — Show anchor health for all comments.
+ */
+import type { Command } from "commander";
+export declare function registerStatus(program: Command): void;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.js

@@ -0,0 +1,156 @@
+/**
+ * mrsf status — Show anchor health for all comments.
+ */
+import chalk from "chalk";
+import { sidecarToDocument } from "../lib/discovery.js";
+import { parseSidecar, readDocumentLines } from "../lib/parser.js";
+import { resolveSidecarPaths } from "../lib/resolve-files.js";
+import { findRepoRoot, isStale as gitIsStale } from "../lib/git.js";
+import { exactMatch } from "../lib/fuzzy.js";
+export function registerStatus(program) {
+    program
+        .command("status [files...]")
+        .description("Show anchor health for comments")
+        .option("--json", "Output as JSON")
+        .action(async (files, opts) => {
+        const parentOpts = program.opts();
+        const cwd = parentOpts.cwd ?? process.cwd();
+        const quiet = parentOpts.quiet ?? false;
+        const sidecarPaths = await resolveSidecarPaths(files, cwd);
+        if (sidecarPaths.length === 0) {
+            if (!quiet)
+                console.log("No sidecar files found.");
+            return;
+        }
+        const repoRoot = await findRepoRoot(cwd);
+        const allResults = [];
+        for (const sp of sidecarPaths) {
+            try {
+                const doc = await parseSidecar(sp);
+                const docPath = sidecarToDocument(sp);
+                let lines;
+                try {
+                    lines = await readDocumentLines(docPath);
+                }
+                catch {
+                    // Document missing
+                    for (const c of doc.comments) {
+                        allResults.push({
+                            commentId: c.id,
+                            health: "unknown",
+                            reason: "Document file not found.",
+                        });
+                    }
+                    continue;
+                }
+                for (const c of doc.comments) {
+                    const result = await assessHealth(c, lines, repoRoot);
+                    allResults.push(result);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(chalk.red(`✗ ${sp}: ${msg}`));
+            }
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(allResults, null, 2));
+            return;
+        }
+        for (const r of allResults) {
+            const icon = healthIcon(r.health);
+            console.log(`${icon} ${r.commentId}: ${r.reason}`);
+        }
+        const fresh = allResults.filter((r) => r.health === "fresh").length;
+        const stale = allResults.filter((r) => r.health === "stale").length;
+        const orphaned = allResults.filter((r) => r.health === "orphaned").length;
+        const unknown = allResults.filter((r) => r.health === "unknown").length;
+        if (!quiet) {
+            console.log(`\n${allResults.length} comment(s): ${fresh} fresh, ${stale} stale, ${orphaned} orphaned, ${unknown} unknown`);
+        }
+    });
+}
+async function assessHealth(comment, lines, repoRoot) {
+    // Already marked orphaned
+    if (comment.x_reanchor_status === "orphaned") {
+        return {
+            commentId: comment.id,
+            health: "orphaned",
+            reason: "Marked orphaned by previous re-anchor.",
+        };
+    }
+    // Check text match
+    if (comment.selected_text) {
+        const matches = exactMatch(lines, comment.selected_text);
+        if (matches.length === 0) {
+            // No exact match — might be stale or orphaned
+            if (comment.commit && repoRoot) {
+                const stale = await gitIsStale(comment.commit, repoRoot);
+                if (stale) {
+                    return {
+                        commentId: comment.id,
+                        health: "stale",
+                        reason: "Commit differs from HEAD and text not found. Run reanchor.",
+                    };
+                }
+            }
+            return {
+                commentId: comment.id,
+                health: "orphaned",
+                reason: "Selected text not found in current document.",
+            };
+        }
+        // Text found — check commit freshness
+        if (comment.commit && repoRoot) {
+            const stale = await gitIsStale(comment.commit, repoRoot);
+            if (stale) {
+                return {
+                    commentId: comment.id,
+                    health: "stale",
+                    reason: "Text still matches but commit is behind HEAD.",
+                };
+            }
+        }
+        return {
+            commentId: comment.id,
+            health: "fresh",
+            reason: "Text matches in current document.",
+        };
+    }
+    // No selected_text
+    if (!comment.commit) {
+        return {
+            commentId: comment.id,
+            health: "unknown",
+            reason: "No selected_text or commit to assess.",
+        };
+    }
+    if (repoRoot) {
+        const stale = await gitIsStale(comment.commit, repoRoot);
+        return {
+            commentId: comment.id,
+            health: stale ? "stale" : "fresh",
+            reason: stale
+                ? "Commit is behind HEAD (no text to verify)."
+                : "Commit matches HEAD.",
+        };
+    }
+    return {
+        commentId: comment.id,
+        health: "unknown",
+        reason: "Git not available for commit check.",
+    };
+}
+function healthIcon(health) {
+    switch (health) {
+        case "fresh":
+            return chalk.green("●");
+        case "stale":
+            return chalk.yellow("◐");
+        case "orphaned":
+            return chalk.red("✗");
+        case "unknown":
+            return chalk.dim("?");
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/validate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * mrsf validate — Validate one or all sidecar files.
+ */
+import type { Command } from "commander";
+export declare function registerValidate(program: Command): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/validate.js

@@ -0,0 +1,55 @@
+/**
+ * mrsf validate — Validate one or all sidecar files.
+ */
+import chalk from "chalk";
+import { validateFile } from "../lib/validator.js";
+import { resolveSidecarPaths } from "../lib/resolve-files.js";
+export function registerValidate(program) {
+    program
+        .command("validate [files...]")
+        .description("Validate MRSF sidecar files against the schema and spec rules")
+        .option("-s, --strict", "Treat warnings as errors")
+        .action(async (files, opts) => {
+        const parentOpts = program.opts();
+        const cwd = parentOpts.cwd ?? process.cwd();
+        const quiet = parentOpts.quiet ?? false;
+        const sidecarPaths = await resolveSidecarPaths(files, cwd);
+        if (sidecarPaths.length === 0) {
+            if (!quiet)
+                console.log("No sidecar files found.");
+            return;
+        }
+        let hasErrors = false;
+        for (const sp of sidecarPaths) {
+            let result;
+            try {
+                result = await validateFile(sp);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(chalk.red(`✗ ${sp}: ${msg}`));
+                hasErrors = true;
+                continue;
+            }
+            const effectiveValid = opts.strict
+                ? result.valid && result.warnings.length === 0
+                : result.valid;
+            if (!effectiveValid)
+                hasErrors = true;
+            if (!quiet || !effectiveValid) {
+                const icon = effectiveValid ? chalk.green("✓") : chalk.red("✗");
+                console.log(`${icon} ${sp}`);
+            }
+            for (const e of result.errors) {
+                console.log(chalk.red(`  error: ${e.message}${e.path ? ` (${e.path})` : ""}`));
+            }
+            for (const w of result.warnings) {
+                const fn = opts.strict ? chalk.red : chalk.yellow;
+                console.log(fn(`  ${opts.strict ? "error" : "warn"}: ${w.message}${w.path ? ` (${w.path})` : ""}`));
+            }
+        }
+        if (hasErrors)
+            process.exit(1);
+    });
+}
+//# sourceMappingURL=validate.js.map

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MRSF — Public API (library surface).
+ *
+ * Usage:
+ *   import { validate, reanchorFile, addComment, ... } from "mrsf";
+ */
+export type { MrsfDocument, Comment, MrsfConfig, DiagnosticSeverity, ValidationDiagnostic, ValidationResult, ReanchorStatus, ReanchorResult, FuzzyCandidate, DiffHunk, AddCommentOptions, CommentFilter, AnchorHealth, StatusResult, BaseOptions, ReanchorOptions, ValidateOptions, } from "./lib/types.js";
+export { findWorkspaceRoot, loadConfig, discoverSidecar, sidecarToDocument, discoverAllSidecars, } from "./lib/discovery.js";
+export { resolveSidecarPaths } from "./lib/resolve-files.js";
+export { parseSidecar, parseSidecarContent, readDocumentLines, } from "./lib/parser.js";
+export { computeHash, syncHash, toYaml, toJson, writeSidecar, } from "./lib/writer.js";
+export { validate, validateFile } from "./lib/validator.js";
+export { exactMatch, normalizedMatch, fuzzySearch, combinedScore, } from "./lib/fuzzy.js";
+export { isGitAvailable, findRepoRoot, getCurrentCommit, isStale, getDiff, getLineShift, getFileAtCommit, getStagedFiles, detectRenames, parseDiffHunks, } from "./lib/git.js";
+export { reanchorComment, reanchorDocument, applyReanchorResults, reanchorFile, } from "./lib/reanchor.js";
+export { addComment, populateSelectedText, resolveComment, unresolveComment, removeComment, filterComments, getThreads, summarize, } from "./lib/comments.js";
+export type { CommentSummary } from "./lib/comments.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,25 @@
+/**
+ * MRSF — Public API (library surface).
+ *
+ * Usage:
+ *   import { validate, reanchorFile, addComment, ... } from "mrsf";
+ */
+// Discovery
+export { findWorkspaceRoot, loadConfig, discoverSidecar, sidecarToDocument, discoverAllSidecars, } from "./lib/discovery.js";
+// File resolution
+export { resolveSidecarPaths } from "./lib/resolve-files.js";
+// Parsing
+export { parseSidecar, parseSidecarContent, readDocumentLines, } from "./lib/parser.js";
+// Writing
+export { computeHash, syncHash, toYaml, toJson, writeSidecar, } from "./lib/writer.js";
+// Validation
+export { validate, validateFile } from "./lib/validator.js";
+// Fuzzy matching
+export { exactMatch, normalizedMatch, fuzzySearch, combinedScore, } from "./lib/fuzzy.js";
+// Git
+export { isGitAvailable, findRepoRoot, getCurrentCommit, isStale, getDiff, getLineShift, getFileAtCommit, getStagedFiles, detectRenames, parseDiffHunks, } from "./lib/git.js";
+// Re-anchoring
+export { reanchorComment, reanchorDocument, applyReanchorResults, reanchorFile, } from "./lib/reanchor.js";
+// Comments
+export { addComment, populateSelectedText, resolveComment, unresolveComment, removeComment, filterComments, getThreads, summarize, } from "./lib/comments.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/comments.d.ts

@@ -0,0 +1,52 @@
+/**
+ * MRSF Comment Operations — CRUD for sidecar comments.
+ */
+import type { AddCommentOptions, Comment, CommentFilter, MrsfDocument } from "./types.js";
+/**
+ * Add a new comment to a document. Mutates doc.comments in place.
+ * Returns the created comment.
+ */
+export declare function addComment(doc: MrsfDocument, opts: AddCommentOptions, repoRoot?: string): Promise<Comment>;
+/**
+ * Populate selected_text from document lines (reads the file content region).
+ * Should be called after addComment if the caller provides line info but not selected_text.
+ */
+export declare function populateSelectedText(comment: Comment, documentLines: string[]): void;
+/**
+ * Resolve a comment by id. Per §9, resolving a parent does NOT
+ * automatically resolve its replies.
+ *
+ * Returns true if the comment was found and updated.
+ */
+export declare function resolveComment(doc: MrsfDocument, commentId: string, cascade?: boolean): boolean;
+/**
+ * Unresolve a comment by id.
+ */
+export declare function unresolveComment(doc: MrsfDocument, commentId: string): boolean;
+/**
+ * Remove a comment by id. Returns true if found and removed.
+ */
+export declare function removeComment(doc: MrsfDocument, commentId: string): boolean;
+/**
+ * Filter comments based on criteria.
+ */
+export declare function filterComments(comments: Comment[], filter: CommentFilter): Comment[];
+/**
+ * Get a list of threads — groups of comments by their root ID via reply_to.
+ * Returns a map of root comment ID → [root, ...replies in order].
+ */
+export declare function getThreads(comments: Comment[]): Map<string, Comment[]>;
+export interface CommentSummary {
+    total: number;
+    open: number;
+    resolved: number;
+    orphaned: number;
+    threads: number;
+    byType: Record<string, number>;
+    bySeverity: Record<string, number>;
+}
+/**
+ * Generate summary statistics for a comment list.
+ */
+export declare function summarize(comments: Comment[]): CommentSummary;
+//# sourceMappingURL=comments.d.ts.map