@christianmorup/review-intent 0.1.0

package/dist/config.js

@@ -0,0 +1,58 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { z } from "zod";
+export const DEFAULT_CONFIG_PATH = ".review/config.json";
+/** Built-in sensitive-path policy, tuned to the Immeo stack. Each pattern is a
+ *  regex tested against the posix-style changed path (case-insensitive). */
+export const DEFAULT_SENSITIVE_PATHS = [
+    { label: "auth", pattern: "(^|/)auth" },
+    { label: "bicep / infra", pattern: "\\.bicep$|(^|/)bicep/" },
+    { label: "ADO pipeline", pattern: "azure-pipelines|(^|/)\\.azure" },
+    { label: "app config", pattern: "appsettings.*\\.json$|\\.config$" },
+    { label: "secrets / key vault", pattern: "(secret|keyvault|key-vault)" },
+    { label: "container", pattern: "(^|/)dockerfile" },
+    { label: "dependencies", pattern: "\\.csproj$|directory\\.packages\\.props$|package-lock\\.json$|packages\\.lock\\.json$" },
+];
+export const DEFAULT_CONFIG = {
+    sensitivePaths: DEFAULT_SENSITIVE_PATHS,
+    churnFiles: 20,
+    churnLines: 600,
+    complexityThreshold: 15,
+};
+const ConfigFileSchema = z.object({
+    sensitivePaths: z
+        .array(z.object({ label: z.string().min(1), pattern: z.string().min(1) }))
+        .optional(),
+    churnFiles: z.number().int().positive().optional(),
+    churnLines: z.number().int().positive().optional(),
+    complexityThreshold: z.number().int().positive().optional(),
+});
+export class ConfigError extends Error {
+}
+/** Load the optional repo config, falling back to built-in defaults. Validation
+ *  failures throw ConfigError (a malformed policy file should be loud). */
+export function loadConfig(cwd, configPath = DEFAULT_CONFIG_PATH) {
+    const full = resolve(cwd, configPath);
+    if (!existsSync(full))
+        return DEFAULT_CONFIG;
+    let json;
+    try {
+        json = JSON.parse(readFileSync(full, "utf8"));
+    }
+    catch (err) {
+        throw new ConfigError(`${full} is not valid JSON: ${err.message}`);
+    }
+    const parsed = ConfigFileSchema.safeParse(json);
+    if (!parsed.success) {
+        const issues = parsed.error.issues
+            .map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`)
+            .join("\n");
+        throw new ConfigError(`${full} is not a valid config:\n${issues}`);
+    }
+    return {
+        sensitivePaths: parsed.data.sensitivePaths ?? DEFAULT_SENSITIVE_PATHS,
+        churnFiles: parsed.data.churnFiles ?? DEFAULT_CONFIG.churnFiles,
+        churnLines: parsed.data.churnLines ?? DEFAULT_CONFIG.churnLines,
+        complexityThreshold: parsed.data.complexityThreshold ?? DEFAULT_CONFIG.complexityThreshold,
+    };
+}

package/dist/diff-parser.js

@@ -0,0 +1,51 @@
+import parseDiff from "parse-diff";
+/** Parse raw unified diff text into a structured, render-friendly model. */
+export function parseDiffText(raw) {
+    // Normalize CRLF -> LF first: `git diff` on a Windows repo with CRLF files
+    // emits CRLF, which leaves a trailing \r on every content line and breaks
+    // parse-diff's header detection (e.g. "new file mode\r"), mis-classifying an
+    // added file as renamed. Parse against LF regardless of source line endings.
+    const files = parseDiff(raw.replace(/\r\n/g, "\n"));
+    return files.map((f) => {
+        const path = (f.deleted ? f.from : f.to) ?? f.from ?? f.to ?? "(unknown)";
+        const status = f.new
+            ? "added"
+            : f.deleted
+                ? "deleted"
+                : f.from && f.to && f.from !== f.to
+                    ? "renamed"
+                    : "modified";
+        const hunks = (f.chunks ?? []).map((c) => {
+            const newStart = c.newStart ?? 0;
+            const newEnd = newStart + (c.newLines ?? 0) - 1;
+            const lines = (c.changes ?? []).map((ch) => {
+                const content = stripPrefix(ch.content);
+                if (ch.type === "add") {
+                    return { type: "add", content, newNumber: ch.ln };
+                }
+                if (ch.type === "del") {
+                    return { type: "del", content, oldNumber: ch.ln };
+                }
+                const normal = ch;
+                return {
+                    type: "normal",
+                    content,
+                    oldNumber: normal.ln1,
+                    newNumber: normal.ln2,
+                };
+            });
+            return { header: c.content, newStart, newEnd, lines };
+        });
+        return { path, status, hunks };
+    });
+}
+/** parse-diff keeps the leading +/-/space marker on each line's content. */
+function stripPrefix(content) {
+    if (content.length === 0)
+        return content;
+    const first = content[0];
+    if (first === "+" || first === "-" || first === " ") {
+        return content.slice(1);
+    }
+    return content;
+}

package/dist/git.js

@@ -0,0 +1,59 @@
+import { execFileSync } from "node:child_process";
+export class GitError extends Error {
+}
+function git(args, cwd) {
+    try {
+        return execFileSync("git", args, {
+            cwd,
+            encoding: "utf8",
+            maxBuffer: 64 * 1024 * 1024,
+        });
+    }
+    catch (err) {
+        const e = err;
+        throw new GitError((e.stderr || e.message).trim());
+    }
+}
+function branchExists(ref, cwd) {
+    try {
+        execFileSync("git", ["rev-parse", "--verify", "--quiet", ref], {
+            cwd,
+            stdio: "ignore",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Resolve the base branch to diff against: explicit override, else main, else master. */
+export function resolveBase(cwd, override) {
+    if (override) {
+        if (!branchExists(override, cwd)) {
+            throw new GitError(`Base ref "${override}" does not exist in this repo.`);
+        }
+        return override;
+    }
+    for (const candidate of ["main", "master"]) {
+        if (branchExists(candidate, cwd))
+            return candidate;
+    }
+    throw new GitError(`Could not find a base branch (tried "main" and "master"). Pass --base <ref>.`);
+}
+/**
+ * Produce the PR-style diff: changes on the current branch since it diverged
+ * from base (`git diff base...HEAD`). Returns the raw unified diff text.
+ */
+export function getDiff(cwd, base) {
+    // Fails early with a clear message if cwd is not a git work tree.
+    try {
+        execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+            cwd,
+            stdio: "ignore",
+        });
+    }
+    catch {
+        throw new GitError(`Not a git repository: ${cwd}`);
+    }
+    return git(["diff", `${base}...HEAD`], cwd);
+}

package/dist/match.js

@@ -0,0 +1,64 @@
+/**
+ * Pure join: overlay the artifact's intent onto the parsed diff.
+ *
+ * - File-level intent is matched by path.
+ * - Per-hunk intent is matched by anchor: the note attaches to whichever hunk's
+ *   new-line range [newStart, newEnd] contains the anchor line. Notes that match
+ *   no hunk in the file surface in `unmatchedIntents` (never silently dropped).
+ * - Artifact entries for files absent from the diff surface in
+ *   `filesWithoutChanges`.
+ */
+export function buildReviewModel(artifact, diff, base, scorecard, reach, complexity) {
+    const intentByPath = new Map(artifact.files.map((f) => [f.path, f]));
+    const diffPaths = new Set(diff.map((f) => f.path));
+    const files = diff.map((file) => {
+        const fileIntent = intentByPath.get(file.path);
+        const hunkIntents = fileIntent?.hunks ?? [];
+        const matched = new Set();
+        const hunks = file.hunks.map((hunk) => {
+            const intents = [];
+            hunkIntents.forEach((hi, idx) => {
+                if (hi.anchor >= hunk.newStart && hi.anchor <= hunk.newEnd) {
+                    intents.push(hi);
+                    matched.add(idx);
+                }
+            });
+            return { ...hunk, intents };
+        });
+        const unmatchedIntents = hunkIntents.filter((_, idx) => !matched.has(idx));
+        return {
+            path: file.path,
+            status: file.status,
+            what: fileIntent?.what,
+            why: fileIntent?.why,
+            unmatchedIntents,
+            hunks,
+        };
+    });
+    const filesWithoutChanges = artifact.files
+        .filter((f) => !diffPaths.has(f.path))
+        .map((f) => ({ path: f.path, why: f.why }));
+    // Coverage mirrors the completeness contract: a file counts as covered when it
+    // has a what + why, a hunk when at least one intent anchored into it.
+    const intentCoverage = {
+        filesCovered: files.filter((f) => f.what && f.why).length,
+        filesTotal: files.length,
+        hunksCovered: files.reduce((n, f) => n + f.hunks.filter((h) => h.intents.length > 0).length, 0),
+        hunksTotal: files.reduce((n, f) => n + f.hunks.length, 0),
+    };
+    return {
+        title: artifact.title,
+        tldr: artifact.tldr,
+        overall: artifact.overall,
+        base,
+        diagrams: artifact.diagrams,
+        risks: artifact.risks,
+        tests: artifact.tests,
+        scorecard,
+        reach,
+        complexity,
+        intentCoverage,
+        files,
+        filesWithoutChanges,
+    };
+}

package/dist/reach.js

@@ -0,0 +1,138 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+const SKIP_DIRS = new Set([
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    ".git",
+    "bin",
+    "obj",
+    ".vs",
+    ".idea",
+    "coverage",
+    ".next",
+]);
+const CODE_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|vue|svelte)$/i;
+const DEFAULT_MAX_FILES = 2000;
+const DEFAULT_MAX_FILE_BYTES = 300 * 1024;
+const DEFAULT_MAX_EDGES_PER_NODE = 8;
+/** Walk the repo collecting code files (bounded). I/O — not pure. */
+export function scanRepo(cwd, opts = {}) {
+    const maxFiles = opts.maxFiles ?? DEFAULT_MAX_FILES;
+    const maxBytes = opts.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    const files = [];
+    let truncated = false;
+    const walk = (dir) => {
+        if (files.length >= maxFiles) {
+            truncated = true;
+            return;
+        }
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (files.length >= maxFiles) {
+                truncated = true;
+                return;
+            }
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
+                    continue;
+                walk(full);
+            }
+            else if (entry.isFile() && CODE_EXT.test(entry.name)) {
+                try {
+                    if (statSync(full).size > maxBytes)
+                        continue;
+                    const content = readFileSync(full, "utf8");
+                    files.push({ path: toPosix(relative(cwd, full)), content });
+                }
+                catch {
+                    // unreadable file — skip
+                }
+            }
+        }
+    };
+    walk(cwd);
+    return { files, truncated };
+}
+const SPEC_RE = /(?:\bfrom\s+|\bimport\s+|\brequire\s*\(\s*|\bimport\s*\(\s*)['"]([^'"]+)['"]/g;
+/**
+ * Pure: build the file-level reach graph. An edge `from → to` means the
+ * dependent file `from` imports/references the changed file `to`.
+ *
+ * Heuristic: matches import/require/from specifiers against each changed file's
+ * path-without-extension or basename. False positives (shared basenames) and
+ * misses (non-path imports like C# `using`) are possible by design — the
+ * renderer labels the graph as heuristic.
+ */
+export function buildReachGraph(files, changedPaths, opts = {}) {
+    const maxEdges = opts.maxEdgesPerNode ?? DEFAULT_MAX_EDGES_PER_NODE;
+    const changed = changedPaths.map(toPosix);
+    const changedSet = new Set(changed);
+    // Precompute match keys per changed file.
+    const keys = changed.map((p) => ({
+        path: p,
+        noExt: stripExt(p),
+        base: stripExt(p.split("/").pop() ?? p),
+    }));
+    const edges = [];
+    const perNode = new Map();
+    let overflow = 0;
+    for (const file of files) {
+        if (changedSet.has(file.path))
+            continue; // don't link a changed file to itself
+        const specs = extractSpecifiers(file.content);
+        if (specs.length === 0)
+            continue;
+        const specKeys = specs.map((s) => ({ noExt: stripExt(normalize(s)), spec: s }));
+        for (const k of keys) {
+            const hit = specKeys.some((sk) => sk.noExt === k.noExt ||
+                sk.noExt.endsWith("/" + k.base) ||
+                sk.noExt === k.base);
+            if (!hit)
+                continue;
+            const count = perNode.get(k.path) ?? 0;
+            if (count >= maxEdges) {
+                overflow++;
+                continue;
+            }
+            perNode.set(k.path, count + 1);
+            edges.push({ from: file.path, to: k.path });
+        }
+    }
+    const notes = [];
+    if (opts.scanTruncated) {
+        notes.push("repo scan hit the file cap — some dependents may be missing");
+    }
+    if (overflow > 0) {
+        notes.push(`${overflow} additional edge(s) hidden (per-node cap)`);
+    }
+    return {
+        changed,
+        edges,
+        truncatedNote: notes.length ? notes.join("; ") : undefined,
+    };
+}
+function extractSpecifiers(content) {
+    const out = [];
+    for (const m of content.matchAll(SPEC_RE))
+        out.push(m[1]);
+    return out;
+}
+function normalize(spec) {
+    // strip leading ./ and ../ segments
+    return spec.replace(/^(?:\.\.?\/)+/, "");
+}
+function stripExt(p) {
+    return p.replace(/\.(ts|tsx|js|jsx|mjs|cjs|vue|svelte)$/i, "");
+}
+function toPosix(p) {
+    return sep === "\\" ? p.split(sep).join("/") : p;
+}