@mrsf/cli 0.4.2 → 0.5.0

package/dist/lib/reanchor.d.ts

@@ -12,7 +12,7 @@
  *   Step 4  – orphan
  */
 import type { MrsfDocument, ReanchorOptions, ReanchorResult } from "./types.js";
-export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, toReanchorLines, } from "./reanchor-core.js";
+export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, resolveAnchor, toReanchorLines, } from "./reanchor-core.js";
 /**
  * Re-anchor all comments in an MRSF document.
  */

package/dist/lib/reanchor.js

@@ -18,7 +18,7 @@ import { sidecarToDocument } from "./discovery.js";
 import { parseSidecar } from "./parser.js";
 import { writeSidecar } from "./writer.js";
 import path from "node:path";
-export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, toReanchorLines, } from "./reanchor-core.js";
+export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, resolveAnchor, toReanchorLines, } from "./reanchor-core.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------

package/dist/lib/schema.d.ts

@@ -0,0 +1,106 @@
+export declare const mrsfSchema: {
+    $schema: string;
+    $id: string;
+    title: string;
+    description: string;
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        mrsf_version: {
+            type: string;
+            pattern: string;
+            description: string;
+        };
+        document: {
+            type: string;
+            description: string;
+        };
+        comments: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                additionalProperties: boolean;
+                properties: {
+                    id: {
+                        type: string;
+                        description: string;
+                    };
+                    author: {
+                        type: string;
+                        description: string;
+                    };
+                    timestamp: {
+                        type: string;
+                        format: string;
+                        description: string;
+                    };
+                    text: {
+                        type: string;
+                        maxLength: number;
+                        description: string;
+                    };
+                    resolved: {
+                        type: string;
+                        description: string;
+                    };
+                    commit: {
+                        type: string;
+                        description: string;
+                    };
+                    type: {
+                        type: string;
+                        description: string;
+                        examples: string[];
+                    };
+                    severity: {
+                        type: string;
+                        description: string;
+                        enum: string[];
+                    };
+                    reply_to: {
+                        type: string;
+                        description: string;
+                    };
+                    line: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    end_line: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    start_column: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    end_column: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    selected_text: {
+                        type: string;
+                        maxLength: number;
+                        description: string;
+                    };
+                    anchored_text: {
+                        type: string;
+                        maxLength: number;
+                        description: string;
+                    };
+                    selected_text_hash: {
+                        type: string;
+                        pattern: string;
+                        description: string;
+                    };
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/lib/schema.js

@@ -0,0 +1,3 @@
+import mrsfSchemaJson from "../../mrsf.schema.json" with { type: "json" };
+export const mrsfSchema = mrsfSchemaJson;
+//# sourceMappingURL=schema.js.map

package/dist/lib/types.d.ts

@@ -40,6 +40,7 @@ export interface MrsfConfig {
 export type DiagnosticSeverity = "error" | "warning";
 export interface ValidationDiagnostic {
     severity: DiagnosticSeverity;
+    code: string;
     message: string;
     /** Path within the document, e.g. "/comments/0/end_line". */
     path?: string;
@@ -69,6 +70,23 @@ export interface ReanchorResult {
     /** Human-readable explanation of the resolution. */
     reason: string;
 }
+export interface AnchorPosition {
+    status: ReanchorStatus;
+    score: number;
+    /** Absolute 0-based character offset in normalized document text (start). */
+    from?: number;
+    /** Absolute 0-based character offset in normalized document text (end, exclusive). */
+    to?: number;
+    /** 1-based start line. */
+    line?: number;
+    /** 1-based end line. */
+    endLine?: number;
+    /** 0-based start column. */
+    startColumn?: number;
+    /** 0-based end column. */
+    endColumn?: number;
+    reason: string;
+}
 export interface FuzzyCandidate {
     /** Matched text in the document. */
     text: string;

package/dist/lib/validate-core.d.ts

@@ -0,0 +1,6 @@
+import type { MrsfDocument, ValidationDiagnostic, ValidationResult } from "./types.js";
+export type HashFunction = (text: string) => string;
+export declare function validateDocument(doc: MrsfDocument, schema?: object): ValidationResult;
+export declare function validateSchema(doc: MrsfDocument, rawSchema: object, errors: ValidationDiagnostic[]): void;
+export declare function validateCrossFields(doc: MrsfDocument, errors: ValidationDiagnostic[], warnings: ValidationDiagnostic[], hash?: HashFunction): void;
+//# sourceMappingURL=validate-core.d.ts.map

package/dist/lib/validate-core.js

@@ -0,0 +1,128 @@
+import AjvModule from "ajv";
+import addFormatsModule from "ajv-formats";
+import { mrsfSchema } from "./schema.js";
+const Ajv = AjvModule.default ?? AjvModule;
+const addFormats = addFormatsModule.default ?? addFormatsModule;
+export function validateDocument(doc, schema = mrsfSchema) {
+    const errors = [];
+    const warnings = [];
+    validateSchema(doc, schema, errors);
+    validateCrossFields(doc, errors, warnings);
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+export function validateSchema(doc, rawSchema, errors) {
+    const { $schema, ...schema } = rawSchema;
+    void $schema;
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const ajvValidate = ajv.compile(schema);
+    const schemaValid = ajvValidate(doc);
+    if (!schemaValid && ajvValidate.errors) {
+        for (const err of ajvValidate.errors) {
+            errors.push({
+                severity: "error",
+                code: "schema-violation",
+                message: `${err.instancePath || "/"}: ${err.message ?? "schema error"}`,
+                path: err.instancePath || "/",
+            });
+        }
+    }
+}
+export function validateCrossFields(doc, errors, warnings, hash) {
+    if (!Array.isArray(doc.comments))
+        return;
+    const ids = new Set();
+    const allIds = doc.comments.map((x) => x.id);
+    for (let i = 0; i < doc.comments.length; i++) {
+        const c = doc.comments[i];
+        const prefix = `/comments/${i}`;
+        if (c.id) {
+            if (ids.has(c.id)) {
+                errors.push({
+                    severity: "error",
+                    code: "duplicate-id",
+                    message: `Duplicate comment id "${c.id}"`,
+                    path: `${prefix}/id`,
+                    commentId: c.id,
+                });
+            }
+            ids.add(c.id);
+        }
+        if (c.line != null && c.end_line != null && c.end_line < c.line) {
+            errors.push({
+                severity: "error",
+                code: "end-line-before-line",
+                message: `end_line (${c.end_line}) must be ≥ line (${c.line})`,
+                path: `${prefix}/end_line`,
+                commentId: c.id,
+            });
+        }
+        if (c.start_column != null &&
+            c.end_column != null &&
+            (c.line == null || c.end_line == null || c.line === c.end_line) &&
+            c.end_column < c.start_column) {
+            errors.push({
+                severity: "error",
+                code: "end-column-before-start-column",
+                message: `end_column (${c.end_column}) must be ≥ start_column (${c.start_column}) on the same line`,
+                path: `${prefix}/end_column`,
+                commentId: c.id,
+            });
+        }
+        if (c.selected_text && c.selected_text.length > 4096) {
+            errors.push({
+                severity: "error",
+                code: "selected-text-too-long",
+                message: `selected_text exceeds 4096 characters (${c.selected_text.length})`,
+                path: `${prefix}/selected_text`,
+                commentId: c.id,
+            });
+        }
+        if (c.text && c.text.length > 16384) {
+            warnings.push({
+                severity: "warning",
+                code: "text-too-long",
+                message: `text exceeds recommended 16384 characters (${c.text.length})`,
+                path: `${prefix}/text`,
+                commentId: c.id,
+            });
+        }
+        // Browser-safe callers do not get the Node SHA-256 implementation.
+        // The hash check runs only when a hash function is injected by the Node validator.
+        if (hash && c.selected_text && c.selected_text_hash) {
+            const expected = hash(c.selected_text);
+            if (c.selected_text_hash !== expected) {
+                warnings.push({
+                    severity: "warning",
+                    code: "hash-mismatch",
+                    message: `selected_text_hash mismatch (expected ${expected.slice(0, 12)}…, got ${c.selected_text_hash.slice(0, 12)}…)`,
+                    path: `${prefix}/selected_text_hash`,
+                    commentId: c.id,
+                });
+            }
+        }
+        if (c.reply_to && !ids.has(c.reply_to) && !allIds.includes(c.reply_to)) {
+            warnings.push({
+                severity: "warning",
+                code: "unresolved-reply-to",
+                message: `reply_to "${c.reply_to}" does not resolve to any comment id in this file`,
+                path: `${prefix}/reply_to`,
+                commentId: c.id,
+            });
+        }
+        if (c.line != null && !c.selected_text) {
+            warnings.push({
+                severity: "warning",
+                code: "missing-selected-text",
+                message: "Comment has line anchors but no selected_text — anchoring will be fragile across edits",
+                path: `${prefix}/selected_text`,
+                commentId: c.id,
+            });
+        }
+    }
+}
+//# sourceMappingURL=validate-core.js.map

package/dist/lib/validator.js

@@ -1,15 +1,11 @@
 /**
  * MRSF Validator — JSON Schema + cross-field validation per §10.
  */
-import AjvModule from "ajv";
-import addFormatsModule from "ajv-formats";
-// ESM interop: handle both default and namespace imports
-const Ajv = AjvModule.default ?? AjvModule;
-const addFormats = addFormatsModule.default ?? addFormatsModule;
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { computeHash } from "./writer.js";
+import { validateCrossFields, validateSchema } from "./validate-core.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 let _schemaCache = null;
 async function loadSchema() {
@@ -44,114 +40,9 @@ export async function validate(doc, options = {}) {
     const warnings = [];
     // ── JSON Schema validation ──
     const rawSchema = await loadSchema();
-    // Ajv 8 doesn't natively support 2020-12; strip $schema to use draft-07 mode
-    const { $schema, ...schema } = rawSchema;
-    const ajv = new Ajv({ allErrors: true, strict: false });
-    addFormats(ajv);
-    const ajvValidate = ajv.compile(schema);
-    const schemaValid = ajvValidate(doc);
-    if (!schemaValid && ajvValidate.errors) {
-        for (const err of ajvValidate.errors) {
-            errors.push({
-                severity: "error",
-                message: `${err.instancePath || "/"}: ${err.message ?? "schema error"}`,
-                path: err.instancePath || "/",
-            });
-        }
-    }
+    validateSchema(doc, rawSchema, errors);
     // ── Cross-field validation (§10) ──
-    if (Array.isArray(doc.comments)) {
-        const ids = new Set();
-        for (let i = 0; i < doc.comments.length; i++) {
-            const c = doc.comments[i];
-            const prefix = `/comments/${i}`;
-            // Unique id check
-            if (c.id) {
-                if (ids.has(c.id)) {
-                    errors.push({
-                        severity: "error",
-                        message: `Duplicate comment id "${c.id}"`,
-                        path: `${prefix}/id`,
-                        commentId: c.id,
-                    });
-                }
-                ids.add(c.id);
-            }
-            // end_line ≥ line
-            if (c.line != null && c.end_line != null && c.end_line < c.line) {
-                errors.push({
-                    severity: "error",
-                    message: `end_line (${c.end_line}) must be ≥ line (${c.line})`,
-                    path: `${prefix}/end_line`,
-                    commentId: c.id,
-                });
-            }
-            // end_column ≥ start_column when same line
-            if (c.start_column != null &&
-                c.end_column != null &&
-                (c.line == null || c.end_line == null || c.line === c.end_line) &&
-                c.end_column < c.start_column) {
-                errors.push({
-                    severity: "error",
-                    message: `end_column (${c.end_column}) must be ≥ start_column (${c.start_column}) on the same line`,
-                    path: `${prefix}/end_column`,
-                    commentId: c.id,
-                });
-            }
-            // selected_text length
-            if (c.selected_text && c.selected_text.length > 4096) {
-                errors.push({
-                    severity: "error",
-                    message: `selected_text exceeds 4096 characters (${c.selected_text.length})`,
-                    path: `${prefix}/selected_text`,
-                    commentId: c.id,
-                });
-            }
-            // text length
-            if (c.text && c.text.length > 16384) {
-                warnings.push({
-                    severity: "warning",
-                    message: `text exceeds recommended 16384 characters (${c.text.length})`,
-                    path: `${prefix}/text`,
-                    commentId: c.id,
-                });
-            }
-            // selected_text_hash consistency
-            if (c.selected_text && c.selected_text_hash) {
-                const expected = computeHash(c.selected_text);
-                if (c.selected_text_hash !== expected) {
-                    warnings.push({
-                        severity: "warning",
-                        message: `selected_text_hash mismatch (expected ${expected.slice(0, 12)}…, got ${c.selected_text_hash.slice(0, 12)}…)`,
-                        path: `${prefix}/selected_text_hash`,
-                        commentId: c.id,
-                    });
-                }
-            }
-            // reply_to resolution
-            if (c.reply_to && !ids.has(c.reply_to)) {
-                // Check forward references too
-                const allIds = doc.comments.map((x) => x.id);
-                if (!allIds.includes(c.reply_to)) {
-                    warnings.push({
-                        severity: "warning",
-                        message: `reply_to "${c.reply_to}" does not resolve to any comment id in this file`,
-                        path: `${prefix}/reply_to`,
-                        commentId: c.id,
-                    });
-                }
-            }
-            // Missing selected_text warning
-            if (c.line != null && !c.selected_text) {
-                warnings.push({
-                    severity: "warning",
-                    message: `Comment has line anchors but no selected_text — anchoring will be fragile across edits`,
-                    path: `${prefix}/selected_text`,
-                    commentId: c.id,
-                });
-            }
-        }
-    }
+    validateCrossFields(doc, errors, warnings, computeHash);
     const valid = errors.length === 0 && (!options.strict || warnings.length === 0);
     return { valid, errors, warnings };
 }
@@ -170,6 +61,7 @@ export async function validateFile(filePath, options = {}) {
             errors: [
                 {
                     severity: "error",
+                    code: "parse-error",
                     message: `Failed to parse: ${e.message}`,
                 },
             ],

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@mrsf/cli",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "CLI and library for the Markdown Review Sidecar Format (MRSF)",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.cjs"
     },
     "./browser": {
+      "types": "./dist/browser.d.ts",
+      "browser": "./dist/browser.js",
       "import": "./dist/browser.js",
-      "types": "./dist/browser.d.ts"
+      "require": "./dist/browser.cjs"
     }
   },
   "bin": {
@@ -22,7 +25,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node esbuild.config.mjs",
     "dev": "tsc --watch",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -57,6 +60,8 @@
   "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts",
+    "dist/**/*.cjs",
+    "dist/**/*.cjs.map",
     "mrsf.schema.json",
     "README.md",
     "LICENSE"
@@ -78,6 +83,9 @@
     "@types/uuid": "^10.0.0",
     "@vitest/coverage-v8": "^4.0.18",
     "typescript": "^5.8.2",
-    "vitest": "^4.0.18"
-  }
+    "vitest": "^4.0.18",
+    "esbuild": "^0.27.3"
+  },
+  "module": "./dist/index.js",
+  "sideEffects": false
 }