comprehende 0.6.0 → 0.7.0

package/dist/git/repo.js

@@ -1,5 +1,8 @@
-import { basename, dirname, isAbsolute, resolve } from "node:path";
+import { basename as nodeBasename, dirname, isAbsolute, resolve } from "node:path";
+import { assertSafePath, isSafePath } from "../api/paths.js";
+import { basename as posixBasename } from "../schema/types.js";
 import { git, gitOk } from "./exec.js";
+export { assertSafePath, isSafePath };
 export async function assertWorkTree(cwd) {
     const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], { allowFail: true });
     if (inside.trim() !== "true") {
@@ -27,8 +30,8 @@ export function nameFromRemoteUrl(url) {
         : value.includes(":")
             ? value.slice(value.lastIndexOf(":") + 1)
             : value;
-    const last = pathPart.split("/").filter(Boolean).at(-1);
-    return last === undefined || last === "" ? null : last;
+    const last = posixBasename(pathPart);
+    return last === "" ? null : last;
 }
 export async function gitCommonDir(cwd) {
     const raw = (await git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"])).trim();
@@ -41,7 +44,7 @@ export async function readRepoIdentity(cwd) {
     if (fromOrigin !== null) {
         return { name: fromOrigin, origin };
     }
-    return { name: basename(dirname(await gitCommonDir(cwd))), origin };
+    return { name: nodeBasename(dirname(await gitCommonDir(cwd))), origin };
 }
 /** Drop userinfo from an http(s) remote so a copied prompt never carries a token. */
 export function stripRemoteCredentials(url) {
@@ -93,8 +96,12 @@ export function assertSafeRef(ref) {
         throw new Error(`invalid git ref: ${ref}`);
     }
 }
-export function assertSafePath(path) {
-    if (path.trim() === "" || path.startsWith("/") || path.includes("\0") || path.split("/").includes("..")) {
-        throw new Error(`invalid path: ${path}`);
+export function resolveInsideRoot(root, relative) {
+    assertSafePath(relative);
+    const rootAbs = resolve(root);
+    const abs = resolve(root, relative);
+    if (abs !== rootAbs && !abs.startsWith(`${rootAbs}/`)) {
+        throw new Error(`invalid path: ${relative}`);
     }
+    return abs;
 }

package/dist/git/show.js

@@ -1,6 +1,6 @@
 import { readBlob } from "./blob.js";
 import { assertSafePath, assertSafeRef } from "./repo.js";
-import { git } from "./exec.js";
+import { gitOk } from "./exec.js";
 export async function showFile(cwd, ref, path) {
     const bytes = await readBlob(cwd, ref, path);
     return bytes.toString("utf8");
@@ -8,11 +8,5 @@ export async function showFile(cwd, ref, path) {
 export async function fileExistsAt(cwd, ref, path) {
     assertSafeRef(ref);
     assertSafePath(path);
-    try {
-        await git(cwd, ["cat-file", "-e", `${ref}:${path}`]);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return gitOk(cwd, ["cat-file", "-e", `${ref}:${path}`]);
 }

package/dist/package-root.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 export function findPackageRoot(from = import.meta.url) {
@@ -7,7 +8,7 @@ export function findPackageRoot(from = import.meta.url) {
         const pkgPath = join(dir, "package.json");
         if (existsSync(pkgPath)) {
             const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-            if (pkg.name === "comprehende") {
+            if (isRecord(pkg) && pkg.name === "comprehende") {
                 return dir;
             }
         }
@@ -20,6 +21,22 @@ export function findPackageRoot(from = import.meta.url) {
 }
 export function readPackageVersion() {
     const pkgPath = join(findPackageRoot(), "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-    return pkg.version;
+    return parsePackageVersion(readFileSync(pkgPath, "utf8"));
+}
+export function parsePackageVersion(text) {
+    const parsed = JSON.parse(text);
+    if (!isRecord(parsed)) {
+        throw new Error("package.json version must be a non-empty string");
+    }
+    const version = parsed.version;
+    if (typeof version !== "string" || version === "") {
+        throw new Error("package.json version must be a non-empty string");
+    }
+    return version;
+}
+export async function readPackageVersionFromDir(root) {
+    return parsePackageVersion(await readFile(join(root, "package.json"), "utf8"));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/review/coverage.js

@@ -1,6 +1,6 @@
 import { flattenHunks, readDiff, toHunkRef } from "../git/diff.js";
 import { pinRange } from "../git/repo.js";
-import { hunkKey } from "../schema/identity.js";
+import { formatHunkRef, hunkKey } from "../schema/identity.js";
 import { isLockfilePath } from "../schema/lockfile.js";
 export async function coverReview(cwd, document, pin) {
     const range = pin ?? (await pinRange(cwd, document.source.baseRef, document.source.headRef));
@@ -11,7 +11,8 @@ export async function coverReview(cwd, document, pin) {
 export function joinCoverage(document, live) {
     const liveByKey = new Map();
     for (const hunk of live) {
-        liveByKey.set(hunkKey(hunk), hunk);
+        const key = hunkKey(hunk);
+        liveByKey.set(key, hunk);
     }
     const assignedKeys = new Set();
     const allStale = [];
@@ -22,18 +23,22 @@ export function joinCoverage(document, live) {
             if (isLockfilePath(ref.path)) {
                 continue;
             }
-            const match = liveByKey.get(hunkKey(ref));
+            const key = hunkKey(ref);
+            const match = liveByKey.get(key);
             if (match === undefined) {
                 stale.push(ref);
                 allStale.push(ref);
                 continue;
             }
             hunks.push(match);
-            assignedKeys.add(hunkKey(match));
+            assignedKeys.add(key);
         }
         return { group, hunks, stale };
     });
-    const unassigned = live.filter((hunk) => !assignedKeys.has(hunkKey(hunk)));
+    const unassigned = live.filter((hunk) => {
+        const key = hunkKey(hunk);
+        return !assignedKeys.has(key);
+    });
     return {
         groups,
         unassigned,
@@ -53,10 +58,5 @@ export function coverageErrors(coverage) {
     return errors;
 }
 function formatRefs(refs) {
-    return refs
-        .map((ref) => {
-        const rename = ref.oldPath !== undefined ? `${ref.oldPath} -> ` : "";
-        return `  ${rename}${ref.path} @@ -${ref.oldStart},${ref.oldLines} +${ref.newStart},${ref.newLines} @@`;
-    })
-        .join("\n");
+    return refs.map((ref) => `  ${formatHunkRef(ref)}`).join("\n");
 }

package/dist/review/load.js

@@ -0,0 +1,20 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { parseReviewJson } from "../schema/parse.js";
+export async function loadDocument(dataPath) {
+    const text = await readFile(dataPath, "utf8");
+    const parsed = parseReviewJson(text);
+    if (!parsed.ok) {
+        throw new Error(`invalid review document:\n${parsed.errors.map((error) => `  - ${error}`).join("\n")}`);
+    }
+    return parsed.document;
+}
+export function resolveDataPath(data, cwd) {
+    return resolveCliPath(data, cwd, "--data <review.json>");
+}
+export function resolveCliPath(value, cwd, flag) {
+    if (value === undefined) {
+        throw new Error(`missing ${flag}`);
+    }
+    return isAbsolute(value) ? value : resolve(cwd, value);
+}

package/dist/review/pins.js

@@ -1,4 +1,4 @@
-import { fileExistsAt, showFile } from "../git/show.js";
+import { showFile } from "../git/show.js";
 import { isLinePinned, textLineCount } from "../schema/source.js";
 export async function staleCommentPins(cwd, document, range) {
     const stale = [];
@@ -21,10 +21,13 @@ export function commentPinErrors(pins) {
 }
 async function commentPinMatches(cwd, source, range) {
     const sha = source.side === "old" ? range.baseSha : range.headSha;
-    if (!(await fileExistsAt(cwd, sha, source.path))) {
+    let content;
+    try {
+        content = await showFile(cwd, sha, source.path);
+    }
+    catch {
         return false;
     }
-    const content = await showFile(cwd, sha, source.path);
     const count = textLineCount(content);
     return source.line >= 1 && source.line <= count;
 }

package/dist/schema/hunk-meta.js

@@ -2,28 +2,6 @@ export function hunkRangeLabel(header) {
     const match = /^(@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@)/.exec(header);
     return match?.[1] ?? header;
 }
-export function hunkContext(header) {
-    const match = /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@\s*(.*)$/.exec(header);
-    const ctx = match?.[1]?.trim();
-    if (ctx === undefined || ctx === "") {
-        return undefined;
-    }
-    return looksLikeCodeAnchor(ctx) ? ctx : undefined;
-}
-function looksLikeCodeAnchor(line) {
-    if (line.startsWith("#")) {
-        return false;
-    }
-    const hasCodeToken = /[(){};=<>]|=>/.test(line) || /[a-zA-Z_][\w]*\(/.test(line);
-    const hasKeyword = /\b(function|class|const|let|var|type|interface|enum|export|import|def|fn|async|return|struct|impl|pub)\b/.test(line);
-    if (/^[A-Z]/.test(line) && line.includes(": ") && !hasCodeToken && !hasKeyword) {
-        return false;
-    }
-    if (/[.!?]$/.test(line) && !hasCodeToken) {
-        return false;
-    }
-    return hasCodeToken || hasKeyword || /^[A-Za-z_][\w.]*$/.test(line);
-}
 export function addedSymbols(addedLines) {
     const names = [];
     const pattern = /^(?:export\s+)?(?:async\s+)?(?:function|class|type|interface|enum)\s+([A-Za-z_][\w]*)/;
@@ -49,59 +27,3 @@ export function lineDelta(lines) {
     }
     return { added, removed };
 }
-export function splitDiffRows(lines) {
-    const rows = [];
-    let index = 0;
-    while (index < lines.length) {
-        const line = lines[index];
-        if (line === undefined) {
-            break;
-        }
-        if (line.kind === "ctx") {
-            rows.push({
-                left: { kind: "ctx", number: line.oldNumber, text: line.text },
-                right: { kind: "ctx", number: line.newNumber, text: line.text },
-            });
-            index += 1;
-            continue;
-        }
-        if (line.kind === "del") {
-            const removed = [];
-            while (index < lines.length && lines[index]?.kind === "del") {
-                const next = lines[index];
-                if (next !== undefined) {
-                    removed.push(next);
-                }
-                index += 1;
-            }
-            const added = [];
-            while (index < lines.length && lines[index]?.kind === "add") {
-                const next = lines[index];
-                if (next !== undefined) {
-                    added.push(next);
-                }
-                index += 1;
-            }
-            const count = Math.max(removed.length, added.length);
-            for (let offset = 0; offset < count; offset += 1) {
-                const leftLine = removed[offset];
-                const rightLine = added[offset];
-                rows.push({
-                    left: leftLine === undefined
-                        ? null
-                        : { kind: leftLine.kind, number: leftLine.oldNumber, text: leftLine.text },
-                    right: rightLine === undefined
-                        ? null
-                        : { kind: rightLine.kind, number: rightLine.newNumber, text: rightLine.text },
-                });
-            }
-            continue;
-        }
-        rows.push({
-            left: null,
-            right: { kind: "add", number: line.newNumber, text: line.text },
-        });
-        index += 1;
-    }
-    return rows;
-}

package/dist/schema/identity.js

@@ -2,6 +2,7 @@ export function hunkKey(ref) {
     const oldPath = ref.oldPath ?? "";
     return `${oldPath}\0${ref.path}\0${ref.oldStart}\0${ref.newStart}`;
 }
-export function sameHunk(a, b) {
-    return hunkKey(a) === hunkKey(b);
+export function formatHunkRef(ref) {
+    const rename = ref.oldPath !== undefined ? `${ref.oldPath} -> ` : "";
+    return `${rename}${ref.path} @@ -${ref.oldStart},${ref.oldLines} +${ref.newStart},${ref.newLines} @@`;
 }

package/dist/schema/image.js

@@ -1,3 +1,4 @@
+import { basename } from "./types.js";
 export const IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "avif", "ico"];
 const IMAGE_EXT = new Set(IMAGE_EXTENSIONS);
 export const LFS_POINTER_VERSION = "version https://git-lfs.github.com/spec/v1";
@@ -12,7 +13,7 @@ const MEDIA = {
     ico: "image/x-icon",
 };
 export function imageExtension(path) {
-    const base = path.split("/").pop() ?? path;
+    const base = basename(path);
     const dot = base.lastIndexOf(".");
     if (dot <= 0) {
         return undefined;
@@ -27,9 +28,3 @@ export function imageMediaType(path) {
     const ext = imageExtension(path);
     return ext === undefined ? "application/octet-stream" : MEDIA[ext];
 }
-export function isLfsPointerText(text) {
-    return text.includes(LFS_POINTER_VERSION) && /oid sha256:[a-f0-9]{64}/.test(text);
-}
-export function isImageHunkRef(ref) {
-    return ref.oldStart === 0 && ref.oldLines === 0 && ref.newStart === 0 && ref.newLines === 0;
-}

package/dist/schema/lockfile.js

@@ -1,3 +1,4 @@
+import { basename } from "./types.js";
 const LOCKFILE_NAMES = new Set([
     ".terraform.lock.hcl",
     "bun.lock",
@@ -33,6 +34,6 @@ const LOCKFILE_NAMES = new Set([
     "yarn.lock",
 ]);
 export function isLockfilePath(path) {
-    const base = path.split("/").pop() ?? path;
+    const base = basename(path);
     return LOCKFILE_NAMES.has(base) || base.endsWith(".gradle.lockfile");
 }