@promptci/core 0.2.1 → 0.3.0

package/dist/dead-references.js

@@ -26,13 +26,13 @@
  *
  * Findings are heuristic — wording is intentionally cautious.
  */
-import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as crypto from 'node:crypto';
 import fg from 'fast-glob';
 import { fencedBlocks, scanFencedLines } from './markdown-fences.js';
 import { createGitIgnoreChecker } from './gitignore.js';
-import { isWithinRoot, realPath } from './path-containment.js';
+import { isWithinRoot } from './path-containment.js';
+import { RepoTree, errorCode, incompleteCheckIssue, isAbsoluteAnywhere } from './repo-tree.js';
 // ── Patterns ──────────────────────────────────────────────────────────────────
 /** Matches markdown inline links: [label](target) — captures target (may include a title). */
 const MD_LINK_RE = /\[(?:[^\]]*)\]\(([^)]+)\)/g;
@@ -494,14 +494,19 @@ function collectRefs(content, opts = {}) {
         const before = content.slice(lineOffsets[line - 1] ?? 0, index);
         return (before.match(/`/g)?.length ?? 0) % 2 === 1;
     };
-    const pushLink = (ref, evidence, index) => {
+    const pushLink = (ref, evidence, index, linkRaw) => {
         if (!ref || isExternalRef(ref))
             return;
         const line = lineForOffset(lineOffsets, index);
+        // pcic-oonz: a link written inside a fence or a code span is sample text.
+        // It is still CHECKED (a stale example is worth reporting), but the
+        // mechanical fix must leave it alone.
+        const inCodeContext = fenceLines[line - 1]?.inFence === true || inCode(index);
         if (hasCheckableExtension(ref))
-            found.push({ ref, evidence, line, kind: 'file' });
-        else if (isExtensionlessPathRef(ref) && !inCode(index))
-            found.push({ ref, evidence, line, kind: 'linkPath' });
+            found.push({ ref, evidence, line, kind: 'file', linkRaw, inCodeContext });
+        else if (isExtensionlessPathRef(ref) && !inCode(index)) {
+            found.push({ ref, evidence, line, kind: 'linkPath', linkRaw, inCodeContext });
+        }
     };
     // Markdown links: [label](target) or [label](target "Title")
     let m;
@@ -510,7 +515,7 @@ function collectRefs(content, opts = {}) {
         if (m.index >= 2 && content[m.index - 2] === '[' && content[m.index - 1] === '!')
             continue;
         const raw = m[1] ?? '';
-        pushLink(stripFragment(stripLinkTitle(raw)), `[...](${raw})`, m.index);
+        pushLink(stripFragment(stripLinkTitle(raw)), `[...](${raw})`, m.index, raw);
     }
     const nestedLinkRe = new RegExp(NESTED_MD_LINK_RE.source, NESTED_MD_LINK_RE.flags);
     while ((m = nestedLinkRe.exec(content)) !== null) {
@@ -518,7 +523,7 @@ function collectRefs(content, opts = {}) {
         if (!labelPart.includes(']('))
             continue;
         const raw = m[1] ?? '';
-        pushLink(stripFragment(stripLinkTitle(raw)), `[...](${raw})`, m.index);
+        pushLink(stripFragment(stripLinkTitle(raw)), `[...](${raw})`, m.index, raw);
     }
     // Reference-style link definitions: [ref]: docs/missing.md "Title"
     const linkDefRe = new RegExp(LINK_REF_DEF_RE.source, LINK_REF_DEF_RE.flags);
@@ -621,182 +626,6 @@ function segmentsOf(ref) {
 function underOutputDir(ref) {
     return segmentsOf(ref).some((s) => OUTPUT_DIRS.has(s.toLowerCase()));
 }
-/** The `code` of a filesystem error (`EACCES`, `ENOENT`, …), when it has one. */
-function errorCode(err) {
-    const code = err?.code;
-    return typeof code === 'string' ? code : undefined;
-}
-/** Links followed for one lookup before it gives up (a cycle, or a chain no real tree has). */
-const MAX_LINK_HOPS = 40;
-/**
- * pcic-xhzb: the only way the detector asks the filesystem about a reference.
- *
- * - Contained. A path is looked up by listing the directories from the scan
- *   root down to it, so nothing outside the root is ever listed, stat'ed or
- *   opened. A committed link is read (`readlink`, a property of the link,
- *   which lives in the tree) and followed only while its target stays inside
- *   the root; a link out of the tree makes the lookup `outside` without
- *   touching what it points at. A hosted scan runs against a server temp
- *   directory, and an existence check outside it would tell whoever wrote the
- *   scanned repository whether a server path exists.
- * - Exact case. A segment matches a directory entry of exactly that name, so
- *   `Deploy_PR.yml` does not resolve to `deploy_pr.yml` on a case-insensitive
- *   filesystem (Windows, macOS). The result is the same on every platform, and
- *   the same as on Linux and GitHub, where the reference is broken.
- * - Honest about failure. A directory that cannot be listed makes the lookup
- *   `unreadable`, never `missing`, and is recorded so the scan can say so.
- *
- * Listings are cached for the scan, so each directory is read at most once.
- */
-class RepoTree {
-    root;
-    /** The root's real path, when it differs (a root under a symlink, like macOS `/var`). */
-    realRoot;
-    listings = new Map();
-    /** What could not be read, as shown in the report (`dir/` or a link's path) → why. */
-    unreadable = new Map();
-    constructor(repoRoot) {
-        this.root = path.resolve(repoRoot);
-        const real = realPath(this.root);
-        this.realRoot = real !== null && real !== this.root ? real : undefined;
-    }
-    /** Forward-slash path relative to the root (`.` for the root itself); never absolute. */
-    relative(abs) {
-        return path.relative(this.root, abs).split(path.sep).join('/') || '.';
-    }
-    /** Record what could not be read: a directory (shown as `dir/`) or a link (shown as its path). */
-    noteUnreadable(p, reason, kind = 'dir') {
-        const abs = path.resolve(this.root, p);
-        // Only in-root names are ever recorded: the report must not carry a server path.
-        if (!isWithinRoot(this.root, abs))
-            return;
-        const rel = this.relative(abs);
-        const shown = kind === 'link' ? rel : rel === '.' ? './' : `${rel}/`;
-        if (!this.unreadable.has(shown))
-            this.unreadable.set(shown, reason);
-    }
-    /** The entries of an in-root directory, by exact name. */
-    list(dir) {
-        let listing = this.listings.get(dir);
-        if (listing === undefined) {
-            try {
-                listing = new Map(fs.readdirSync(dir, { withFileTypes: true }).map((d) => [d.name, d]));
-            }
-            catch (err) {
-                const code = errorCode(err);
-                if (code === 'ENOENT' || code === 'ENOTDIR') {
-                    listing = 'missing';
-                }
-                else {
-                    listing = 'unreadable';
-                    this.noteUnreadable(dir, code ?? 'error');
-                }
-            }
-            this.listings.set(dir, listing);
-        }
-        return listing;
-    }
-    /** In-root equivalent of a link target written against the root's real path. */
-    fromRealRoot(p) {
-        if (this.realRoot === undefined || isWithinRoot(this.root, p) || !isWithinRoot(this.realRoot, p))
-            return p;
-        return path.join(this.root, path.relative(this.realRoot, p));
-    }
-    lookup(candidate) {
-        let target = path.resolve(this.root, candidate);
-        let lastLink = '';
-        for (let hop = 0; hop <= MAX_LINK_HOPS; hop++) {
-            // Lexical containment first: `..`, absolute, other-drive and UNC paths stop here.
-            if (!isWithinRoot(this.root, target))
-                return { state: 'outside' };
-            const parts = path.relative(this.root, target).split(path.sep).filter(Boolean);
-            let dir = this.root;
-            let isDir = true;
-            let next;
-            for (let i = 0; i < parts.length; i++) {
-                if (!isDir)
-                    return { state: 'missing' }; // a file in the middle of a path
-                const listing = this.list(dir);
-                if (listing === 'missing')
-                    return { state: 'missing' };
-                if (listing === 'unreadable')
-                    return { state: 'unreadable' };
-                const name = parts[i];
-                const entry = listing.get(name);
-                if (!entry)
-                    return { state: 'missing' };
-                const entryPath = path.join(dir, name);
-                if (entry.isSymbolicLink()) {
-                    let link;
-                    try {
-                        link = fs.readlinkSync(entryPath);
-                    }
-                    catch (err) {
-                        this.noteUnreadable(entryPath, errorCode(err) ?? 'unreadable link', 'link');
-                        return { state: 'unreadable' };
-                    }
-                    lastLink = entryPath;
-                    // Resolved lexically against the link's own directory, then re-walked
-                    // from the root: the containment check above runs before anything
-                    // under the target is touched.
-                    next = path.join(this.fromRealRoot(path.resolve(dir, link)), ...parts.slice(i + 1));
-                    break;
-                }
-                isDir = entry.isDirectory();
-                dir = entryPath;
-            }
-            if (next === undefined)
-                return { state: 'found', path: dir, isDir };
-            target = next;
-        }
-        // More links than the kernel itself follows (Linux MAXSYMLINKS): a cycle.
-        this.noteUnreadable(lastLink, 'symlink loop', 'link');
-        return { state: 'unreadable' };
-    }
-    isDir(candidate) {
-        const found = this.lookup(candidate);
-        return found.state === 'found' && found.isDir;
-    }
-    /**
-     * An extension-less module path names the file that carries the extension:
-     * `src/lib/db` is `src/lib/db.ts`. True when the directory holds `<name>.*`.
-     */
-    hasStemSibling(candidate) {
-        const dir = this.lookup(path.dirname(candidate));
-        if (dir.state !== 'found' || !dir.isDir)
-            return false;
-        const listing = this.list(dir.path);
-        if (typeof listing === 'string')
-            return false;
-        const prefix = `${path.basename(candidate)}.`;
-        for (const name of listing.keys())
-            if (name.startsWith(prefix))
-                return true;
-        return false;
-    }
-    /**
-     * fast-glob's directory reads, routed through node:fs here so a directory the
-     * walk cannot list is recorded instead of silently dropping out of the result.
-     * The walk itself (`cwd` = root, links not followed) never leaves the root.
-     */
-    walkFs(onError) {
-        const readdirSync = (dir, options) => {
-            try {
-                return options ? fs.readdirSync(dir, options) : fs.readdirSync(dir);
-            }
-            catch (err) {
-                const code = errorCode(err);
-                // A directory deleted mid-walk has nothing left to miss.
-                if (code !== 'ENOENT') {
-                    this.noteUnreadable(dir, code ?? 'error');
-                    onError();
-                }
-                throw err;
-            }
-        };
-        return { readdirSync: readdirSync };
-    }
-}
 /** Trees never searched for an abbreviated path (dependencies, VCS, worktrees, engine caches). */
 const SUFFIX_SEARCH_IGNORE = [
     ...[
@@ -904,7 +733,7 @@ function judgeReference(ref, kind, codeSpan, fileDir, ctx) {
     // Windows scan never opens an SMB connection for `\\host\…`.
     // A drive-relative `C:notes.md` is skipped too: Windows resolves it against
     // that drive's working directory, Linux reads it as a file name.
-    if (path.posix.isAbsolute(target) || path.win32.isAbsolute(target) || /^[A-Za-z]:/.test(target))
+    if (isAbsoluteAnywhere(target))
         return null;
     const lookups = [];
     for (const abs of new Set([path.resolve(fileDir, target), path.resolve(tree.root, target)])) {
@@ -917,14 +746,26 @@ function judgeReference(ref, kind, codeSpan, fileDir, ctx) {
     if (lookups.length === 0)
         return null;
     // The repository's own ignore rules say the path is local state (pcic-2b6.8,
-    // same matcher the skills detector uses).
+    // same matcher the skills detector uses). When those rules are not available
+    // the reference may well BE ignored local state, so it is never reported
+    // broken on the strength of rules nobody read: a `.gitignore` a caller's
+    // inventory listed without fetching (pcic-csf) is silent, and one the scan
+    // genuinely could not read is left unjudged and named in the notice below,
+    // the same way an unlistable directory is.
+    let ignoreRulesUnreadable = false;
     for (const { abs } of lookups) {
         const rel = path.relative(tree.root, abs).replace(/\\/g, '/');
         if (!rel)
             continue;
-        if (isIgnored(rel) || (pathLike && isIgnored(`${rel}/${DIR_PROBE}`)))
-            return null;
+        for (const verdict of [isIgnored(rel), ...(pathLike ? [isIgnored(`${rel}/${DIR_PROBE}`)] : [])]) {
+            if (verdict === true || verdict === 'unfetched')
+                return null;
+            if (verdict === 'unreadable')
+                ignoreRulesUnreadable = true;
+        }
     }
+    if (ignoreRulesUnreadable)
+        return UNJUDGED;
     const moduleStyle = pathLike && !target.endsWith('/');
     if (lookups.some(({ abs, found }) => found.state === 'found' || (moduleStyle && tree.hasStemSibling(abs)))) {
         return null;
@@ -944,7 +785,7 @@ function judgeReference(ref, kind, codeSpan, fileDir, ctx) {
         // skipped by isPlaceholderRef.
         if (codeSpan && !/[/\\]/.test(target)) {
             const index = ctx.nameIndex();
-            if (index.paths.get(target)?.some((rel) => !isIgnored(rel)))
+            if (index.paths.get(target)?.some((rel) => isIgnored(rel) !== true))
                 return null;
             // pcic-xhzb: a walk that could not list everything is no evidence of absence.
             if (!index.complete)
@@ -998,6 +839,94 @@ function judgeReference(ref, kind, codeSpan, fileDir, ctx) {
         return UNJUDGED;
     return 0.6;
 }
+// ── Mechanical fix: a link whose target moved (pcic-oonz) ────────────────────
+/**
+ * pcic-oonz: the substitution that re-points a broken inline markdown link at
+ * the file it names, or `undefined` when the move is not unambiguous.
+ *
+ * Every condition below has to hold, and each one is there to keep the rewrite
+ * a fact rather than a guess:
+ *
+ *  - The reference is an INLINE markdown link, outside any fence or code span,
+ *    naming a FILE (a checkable extension, no trailing slash), whose raw target
+ *    is a plain path (no angle brackets, no link title, no surrounding
+ *    whitespace). The other forms are rewritable in principle, but each needs
+ *    its own reassembly rule, and a recipe that is only sometimes right is worse
+ *    than none.
+ *  - The path it would be rewritten TO needs no escaping, and does not point at
+ *    the linking file itself.
+ *  - The repository holds EXACTLY ONE non-ignored file with that basename,
+ *    found in the name index the detector already builds — one walk, inside the
+ *    scan root, dependency and output trees excluded (see
+ *    {@link SUFFIX_SEARCH_IGNORE}). Two candidates, or none, stay advisory:
+ *    only the author knows which `README.md` was meant.
+ *  - That walk was COMPLETE. A tree the scan could not list fully is no
+ *    evidence that a basename is unique in it.
+ *  - The `](target)` span occurs exactly once on the line, so the edit cannot
+ *    land on a second link that happens to share the target text.
+ *
+ * The new target is the path from the linking file's own directory, with
+ * forward slashes and an explicit `./` when it does not already start with a
+ * `.` — the form the repository's own links use. A `#fragment` is carried over
+ * verbatim.
+ */
+function movedLinkEdit(filePath, line, lineText, linkRaw, kind, ctx) {
+    // Only a link to a FILE — one with a checkable extension and no trailing
+    // slash. A directory link resolves to a tree, not to a name the file index
+    // can identify, and an extension-less target could match a same-named file
+    // that is not what the link meant.
+    if (kind !== 'file' || linkRaw.endsWith('/'))
+        return undefined;
+    if (linkRaw !== linkRaw.trim() || linkRaw.startsWith('<'))
+        return undefined;
+    if (stripLinkTitle(linkRaw) !== linkRaw)
+        return undefined; // carries a title
+    // Plain path characters only. The nested-link pattern can capture a target
+    // that still carries the shape of the link around it — seen live as
+    // `([detail](docs/agents/ci-and-deploys.md` — and splicing a replacement
+    // into the `](` of a DIFFERENT link would corrupt both. Brackets,
+    // parentheses, whitespace and backticks are rejected outright, and a target
+    // that needs them stays advisory.
+    if (/[()[\]\s`]/.test(linkRaw))
+        return undefined;
+    const hash = linkRaw.indexOf('#');
+    const targetPath = hash === -1 ? linkRaw : linkRaw.slice(0, hash);
+    const fragment = hash === -1 ? '' : linkRaw.slice(hash);
+    const base = path.basename(targetPath.replace(/\\/g, '/').replace(/\/+$/, ''));
+    if (!base)
+        return undefined;
+    const index = ctx.nameIndex();
+    if (!index.complete)
+        return undefined;
+    const candidates = (index.paths.get(base) ?? []).filter((rel) => ctx.isIgnored(rel) !== true);
+    if (candidates.length !== 1)
+        return undefined;
+    const absCandidate = path.resolve(ctx.tree.root, candidates[0]);
+    // A file cannot be the fix for a link inside itself.
+    if (absCandidate === path.resolve(filePath))
+        return undefined;
+    const relative = path.relative(path.dirname(filePath), absCandidate).split(path.sep).join('/');
+    if (!relative)
+        return undefined;
+    // The new target is written into `](…)` as-is, so it must need no escaping.
+    // A repository file whose path holds a space, a bracket, a parenthesis, `#`,
+    // `%`, `<`, `>`, `?` or a backtick would produce a link that renders as
+    // literal text or points somewhere else entirely — `](my docs/notes.md)` is
+    // not a link to `my docs/notes.md`. Percent-encoding it would be a second
+    // guess about the author's markdown flavour, so such a move stays advisory.
+    if (/[()[\]\s`#%<>?]/.test(relative))
+        return undefined;
+    const newTarget = `${relative.startsWith('.') ? relative : `./${relative}`}${fragment}`;
+    if (newTarget === linkRaw)
+        return undefined;
+    const find = `](${linkRaw})`;
+    let occurrences = 0;
+    for (let at = lineText.indexOf(find); at !== -1; at = lineText.indexOf(find, at + find.length))
+        occurrences++;
+    if (occurrences !== 1)
+        return undefined;
+    return { filePath, line, find, replace: `](${newTarget})` };
+}
 // ── Detector ─────────────────────────────────────────────────────────────────
 /**
  * Detect broken file references across all instruction files.
@@ -1014,10 +943,16 @@ function judgeReference(ref, kind, codeSpan, fileDir, ctx) {
  * referenced in both CLAUDE.md and AGENTS.md would fire twice, inflating issue counts
  * and health-score penalties.
  */
-export function detectDeadReferences(files, repoRoot) {
+export function detectDeadReferences(files, repoRoot, 
+/**
+ * The scan's view of the repository. Pass `context.tree` so the listings and
+ * any caller-supplied file inventory (pcic-csf) are shared with every other
+ * detector; omitted, a plain filesystem-backed tree over `repoRoot` is used.
+ */
+sharedTree) {
     // normRef → { displayRef, filePaths, fileLines, evidenceLines, minConfidence }
     const byRef = new Map();
-    const tree = new RepoTree(repoRoot);
+    const tree = sharedTree ?? new RepoTree(repoRoot);
     let ctx;
     let nameIndexCache;
     const nameIndex = () => (nameIndexCache ??= buildNameIndex(tree));
@@ -1028,7 +963,10 @@ export function detectDeadReferences(files, repoRoot) {
         const refs = collectRefs(file.content, {
             skipSourceBackticks: SKIP_SOURCE_BACKTICK_FILE_TYPES.has(file.fileType),
         });
-        for (const { ref, evidence, line, kind, codeSpan } of refs) {
+        // pcic-oonz: the file's own lines, so a rewrite can be confirmed
+        // unambiguous on the line it would edit.
+        const fileLineTexts = file.content.split(/\r?\n/);
+        for (const { ref, evidence, line, kind, codeSpan, linkRaw, inCodeContext } of refs) {
             // BUG-009: Skip obvious placeholder/example filenames (foo.ts, bar.go, etc.)
             if (isPlaceholderRef(ref))
                 continue;
@@ -1039,7 +977,7 @@ export function detectDeadReferences(files, repoRoot) {
             if (isHomeRooted(ref))
                 continue;
             // Resolve relative to the instruction file first, then repo root.
-            ctx ??= { tree, isIgnored: createGitIgnoreChecker(repoRoot), suffixCache: new Map(), nameIndex };
+            ctx ??= { tree, isIgnored: createGitIgnoreChecker(tree), suffixCache: new Map(), nameIndex };
             const confidence = judgeReference(ref, kind, codeSpan ?? false, fileDir, ctx);
             if (confidence === null)
                 continue;
@@ -1069,9 +1007,20 @@ export function detectDeadReferences(files, repoRoot) {
                     fileLines: new Map(),
                     evidenceLines: [],
                     minConfidence: confidence,
+                    edits: [],
+                    allRewritable: true,
                 });
             }
             const entry = byRef.get(normRef);
+            // pcic-oonz: can THIS occurrence be re-pointed at the file it names?
+            const edit = linkRaw === undefined || inCodeContext === true
+                ? undefined
+                : movedLinkEdit(file.path, line, fileLineTexts[line - 1] ?? '', linkRaw, kind, ctx);
+            if (edit === undefined)
+                entry.allRewritable = false;
+            else if (!entry.edits.some((e) => e.filePath === edit.filePath && e.line === edit.line && e.find === edit.find)) {
+                entry.edits.push(edit);
+            }
             entry.filePaths.add(file.path);
             const existingLine = entry.fileLines.get(file.path);
             if (existingLine === undefined || line < existingLine) {
@@ -1085,7 +1034,7 @@ export function detectDeadReferences(files, repoRoot) {
     }
     const issues = [];
     const MIN_CONFIDENCE_THRESHOLD = MIN_CONFIDENCE;
-    for (const [normRef, { displayRef, kind, filePaths, fileLines, evidenceLines, minConfidence }] of byRef) {
+    for (const [normRef, { displayRef, kind, filePaths, fileLines, evidenceLines, minConfidence, edits, allRewritable }] of byRef) {
         // BUG-002: Skip findings below the minimum confidence threshold.
         // Low-confidence source-code path references are almost certainly architecture docs.
         if (minConfidence < MIN_CONFIDENCE_THRESHOLD)
@@ -1110,58 +1059,28 @@ export function detectDeadReferences(files, repoRoot) {
             evidence: evidenceLines,
             recommendation: 'Verify the path is correct relative to the instruction file location, ' +
                 'or remove the reference if the file no longer exists.',
+            ...(allRewritable && edits.length > 0
+                ? {
+                    fixRecipe: `Re-point the link${edits.length > 1 ? 's' : ''} at the one file of that name in the ` +
+                        `repository: ${[...new Set(edits.map((e) => `\`${e.find}\` -> \`${e.replace}\``))].join(', ')}.`,
+                    // `applyFixRecipe` rewrites exactly those `](target)` spans.
+                    autoApplySafe: true,
+                    fixEdits: edits,
+                }
+                : {}),
             confidence: minConfidence,
         });
     }
-    if (unjudged.size > 0)
-        issues.push(incompleteCheckIssue(tree, [...unjudged.values()]));
-    return issues;
-}
-/** Evidence lines listed per kind before the rest is summarised. */
-const MAX_INCOMPLETE_EVIDENCE = 10;
-/**
- * pcic-xhzb: a directory the scan could not list is named, never turned into
- * findings. Without this, an unreadable directory emptied the name index (or
- * part of it) and every bare name filed there was reported as broken, with no
- * sign the scan had failed. The gap is a `warning`, the severity of the
- * findings it stands in for, so a `--fail-on warning` gate that a broken
- * reference would have tripped is not passed silently by a scan that could
- * not look (the supply-chain scan's `unscanned-files` likewise warns about
- * content it could not read). Paths are repo-relative, so a hosted scan never
- * shows its temp dir.
- */
-function incompleteCheckIssue(tree, refs) {
-    const capped = (lines, noun) => lines.length > MAX_INCOMPLETE_EVIDENCE
-        ? [...lines.slice(0, MAX_INCOMPLETE_EVIDENCE), `…and ${lines.length - MAX_INCOMPLETE_EVIDENCE} more ${noun}`]
-        : lines;
-    const dirs = [...tree.unreadable].sort(([a], [b]) => a.localeCompare(b));
-    const dirLines = dirs.map(([shown, reason]) => `Could not read: ${shown} (${reason})`);
-    const filePaths = [...new Set(refs.flatMap((r) => [...r.filePaths]))];
-    const firstLine = new Map();
-    for (const r of refs) {
-        for (const [fp, line] of r.fileLines) {
-            const seen = firstLine.get(fp);
-            if (seen === undefined || line < seen)
-                firstLine.set(fp, line);
-        }
+    if (unjudged.size > 0) {
+        issues.push(incompleteCheckIssue(tree, [...unjudged.values()], {
+            id: issueId('(dead-reference check incomplete)'),
+            category: 'structure',
+            title: 'Dead-reference check incomplete: part of the repository could not be read',
+            unit: 'reference',
+            unknown: 'They may or may not exist',
+            finding: 'broken-reference',
+        }));
     }
-    return {
-        id: issueId('(dead-reference check incomplete)'),
-        severity: 'warning',
-        category: 'structure',
-        title: 'Dead-reference check incomplete: part of the repository could not be read',
-        summary: `${refs.length} reference(s) were not checked because part of the repository could not be read ` +
-            `(${dirs.length} location${dirs.length === 1 ? '' : 's'}). They may or may not exist; ` +
-            'no broken-reference finding was reported for them.',
-        filePaths,
-        locations: filePaths.map((fp) => {
-            const startLine = firstLine.get(fp);
-            return startLine !== undefined ? { filePath: fp, startLine } : { filePath: fp };
-        }),
-        evidence: [...capped(dirLines, 'locations'), ...capped(refs.map((r) => r.evidence), 'references')],
-        recommendation: 'Make the listed locations readable by the user running the scan (or fix the symlink), then scan again to ' +
-            'check these references.',
-        confidence: 0.8,
-    };
+    return issues;
 }
 //# sourceMappingURL=dead-references.js.map