rea-agents 6.3.0 → 6.5.0

package/dist/application/ReconstructionCoverageService.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import { reconstructionCoverageEvaluationInputSchema } from "../domain/reconstructionCoverageInput.js";
 import { AnalysisInputError } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
 import { evaluateReconstructionClosure } from "../domain/reconstructionCoverage.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";

package/dist/application/ReconstructionObligationCandidates.js

@@ -2,9 +2,9 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { parseEvidenceBundle, } from "../domain/evidenceBundle.js";
 import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
-import { resolveJavaScriptSemanticEvidence } from "../domain/javascript/javascriptSemanticGraph.js";
 import { parseApplicationGraphEvidence } from "./javascript/JavaScriptApplicationEvidenceGraph.js";
 import { applicationObligationPolicy, semanticObligationPolicy, } from "./ReconstructionObligationPolicies.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 /** Derive conservative candidates from graph, process, and reviewed inputs. */
 export const deriveReconstructionObligationCandidates = (bundleInput, reviewed) => {
     const bundle = parseEvidenceBundle(bundleInput);
@@ -18,7 +18,7 @@ export const deriveReconstructionObligationCandidates = (bundleInput, reviewed)
     for (const obligation of reviewed)
         addCandidate(candidates, reviewedCandidate(obligation, records));
     return {
-        candidates: [...candidates.values()].sort((left, right) => left.obligation_id.localeCompare(right.obligation_id)),
+        candidates: [...candidates.values()].sort((left, right) => compareUnicodeCodePoints(left.obligation_id, right.obligation_id)),
         limitations: [...limitations].sort(),
     };
 };
@@ -55,12 +55,18 @@ const deriveApplicationCandidates = (evidence, records, candidates, limitations)
                 authorityReferences: reference,
             }));
         }
-        if (source.semanticGraph !== null)
+        if (source.semanticGraph !== null) {
+            const evidenceContexts = new Map(source.semanticGraph.evidence_contexts.map((context) => [
+                context.context_id,
+                context,
+            ]));
             for (const node of source.semanticGraph.nodes) {
                 const candidatePolicy = semanticObligationPolicy(node.kind);
                 if (candidatePolicy === undefined)
                     continue;
-                const evidenceContext = resolveJavaScriptSemanticEvidence(source.semanticGraph, node.evidence);
+                const evidenceContext = evidenceContexts.get(node.evidence.context_id);
+                if (evidenceContext === undefined)
+                    throw new TypeError("Semantic evidence reference names an absent context");
                 addCandidate(candidates, generatedCandidate({
                     key: `semantic:${node.node_id}:${candidatePolicy.family}`,
                     title: node.label ?? `${node.kind} semantic boundary`,
@@ -74,6 +80,7 @@ const deriveApplicationCandidates = (evidence, records, candidates, limitations)
                     ],
                 }));
             }
+        }
         if (source.graph.coverage.status !== "complete")
             limitations.add(`Application graph ${source.graph.graph_id} coverage is ${source.graph.coverage.status}; omitted candidates remain unknown.`);
     }
@@ -268,7 +275,7 @@ const sourceState = (references) => {
         return "reviewed";
     return "unknown";
 };
-const uniqueBy = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => key(left).localeCompare(key(right)));
+const uniqueBy = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => compareUnicodeCodePoints(key(left), key(right)));
 const obligationId = (key) => `obl_${digest({ schema: "ReconstructionObligation", key })}`;
 const digest = (value) => {
     const encoded = canonicalize(value);

package/dist/application/ReconstructionObligationLedgerDiagnostics.js

@@ -1,3 +1,4 @@
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 export const groupManifestBindings = (manifest) => {
     const grouped = new Map();
     for (const binding of manifest.bindings)
@@ -24,8 +25,7 @@ export const uniqueObligationDiagnostics = (diagnostics) => [
         `${diagnostic.code}:${diagnostic.detail}`,
         diagnostic,
     ])).values(),
-].sort((left, right) => `${left.code}:${left.detail}`.localeCompare(`${right.code}:${right.detail}`));
-export const hasObligationDiagnostic = (diagnostics, code) => diagnostics.some((diagnostic) => diagnostic.code === code);
+].sort((left, right) => compareUnicodeCodePoints(`${left.code}:${left.detail}`, `${right.code}:${right.detail}`));
 export const contradictionDiagnostics = (obligationId, contradictions, evidenceById) => {
     const evidenceIds = contradictions.get(obligationId) ?? [];
     if (evidenceIds.length === 0)

package/dist/application/ReconstructionObligationLedgerEvaluation.js

@@ -1,65 +1,47 @@
 import { parseEvidenceBundle, } from "../domain/evidenceBundle.js";
 import { reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
+import { digestCanonicalValue } from "../domain/canonicalDigest.js";
+import { reconstructionObligationCoverage, reconstructionObligationDependencyGraph, reconstructionObligationLedgerClosureDigest, reconstructionObligationLedgerStatus, hasReconstructionObligationDiagnostic as hasDiagnostic, reconstructionObligationOwnershipGraph, reconstructionObligationReports, summarizeReconstructionObligations, } from "../domain/reconstructionObligationLedgerIntegrity.js";
 import { evidenceAuthoritySupportsProof, evidenceSupportsOriginalAuthority, proofAuthoritySatisfies, } from "./ReconstructionObligationAuthority.js";
-import { addObligationDiagnostic as addDiagnostic, contradictionDiagnostics, groupManifestBindings, groupManifestContradictions, hasObligationDiagnostic as hasDiagnostic, uniqueObligationDiagnostics as uniqueDiagnostics, } from "./ReconstructionObligationLedgerDiagnostics.js";
+import { addObligationDiagnostic as addDiagnostic, contradictionDiagnostics, groupManifestBindings, groupManifestContradictions, uniqueObligationDiagnostics as uniqueDiagnostics, } from "./ReconstructionObligationLedgerDiagnostics.js";
 import { originalCaseDiagnostics, originalCasesFor, } from "./ReconstructionObligationOriginalCases.js";
-import { digestObligationLedgerValue, obligationLedgerCoverage, obligationEdgeOrder, obligationLedgerEvidenceLinks, obligationLedgerStatus, obligationReports, summarizeObligations, } from "./ReconstructionObligationLedgerProjection.js";
+import { obligationLedgerEvidenceLinks } from "./ReconstructionObligationLedgerProjection.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 export const evaluateReconstructionObligationLedger = ({ candidates: candidatesInput, bundle: bundleInput, manifest, generationLimitations, }) => {
     const bundle = parseEvidenceBundle(bundleInput);
-    const allCandidates = [...candidatesInput].sort((left, right) => left.obligation_id.localeCompare(right.obligation_id));
+    const allCandidates = [...candidatesInput].sort((left, right) => compareUnicodeCodePoints(left.obligation_id, right.obligation_id));
     const orphanManifestIds = findOrphanManifestIds(allCandidates, manifest);
     const candidates = allCandidates;
     const context = createEvaluationContext(candidates, bundle, manifest);
     const obligations = applyDependencyDiagnostics(candidates.map((candidate) => evaluateObligation(candidate, context)), context);
-    const ownershipGraph = obligations
-        .flatMap((obligation) => obligation.binding === null
-        ? []
-        : [
-            {
-                obligation_id: obligation.obligation_id,
-                module_path: obligation.binding.owner.module_path,
-                symbol: obligation.binding.owner.symbol,
-            },
-        ])
-        .sort(obligationEdgeOrder);
-    const dependencyGraph = obligations
-        .flatMap((obligation) => obligation.dependency_obligation_ids.map((dependencyId) => ({
-        obligation_id: obligation.obligation_id,
-        depends_on_obligation_id: dependencyId,
-    })))
-        .sort(obligationEdgeOrder);
+    const ownershipGraph = reconstructionObligationOwnershipGraph(obligations);
+    const dependencyGraph = reconstructionObligationDependencyGraph(obligations);
     const evidenceLinks = obligationLedgerEvidenceLinks(obligations, manifest);
     const limitations = ledgerLimitations(generationLimitations, allCandidates.length, orphanManifestIds);
-    const coverage = obligationLedgerCoverage(limitations.length > 0);
+    const coverage = reconstructionObligationCoverage(limitations);
     const semantic = {
         coverage,
-        summary: summarizeObligations(obligations),
-        reports: obligationReports(obligations),
+        summary: summarizeReconstructionObligations(obligations),
+        reports: reconstructionObligationReports(obligations),
         ownership_graph: ownershipGraph,
         dependency_graph: dependencyGraph,
         obligations,
         evidence_links: evidenceLinks,
         limitations,
     };
-    const evaluatedStatus = obligationLedgerStatus(obligations);
-    const status = evaluatedStatus === "failed"
-        ? evaluatedStatus
-        : limitations.length > 0
-            ? "unknown"
-            : evaluatedStatus;
-    const closureDigest = digestObligationLedgerValue({
-        schema: "ReconstructionObligationClosure",
+    const status = reconstructionObligationLedgerStatus(obligations, limitations);
+    const closureDigest = reconstructionObligationLedgerClosureDigest({
         status,
         ...semantic,
     });
     return reconstructionObligationLedgerSchema.parse({
         schema: "ReconstructionObligationLedger",
-        ledger_id: `rol_${digestObligationLedgerValue({
+        ledger_id: `rol_${digestCanonicalValue({
             schema: "ReconstructionObligationLedger",
             evidence_ids: bundle.records.map(({ evidence_id: id }) => id),
             obligation_ids: obligations.map(({ obligation_id: id }) => id),
             closure_digest: closureDigest,
-        })}`,
+        }, "Reconstruction obligation ledger")}`,
         closure_digest: closureDigest,
         status,
         ...semantic,

package/dist/application/ReconstructionObligationLedgerProjection.js

@@ -1,50 +1,8 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
-import { canonicalJson } from "../domain/comparisonSemantics.js";
+import { reconstructionObligationEvidenceIds } from "../domain/reconstructionObligationLedgerIntegrity.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
-export const obligationLedgerCoverage = (incomplete) => ({
-    status: incomplete ? "partial" : "complete",
-});
-export const summarizeObligations = (obligations) => ({
-    total: obligations.length,
-    required: obligations.filter(({ required }) => required).length,
-    verified: obligations.filter(({ status }) => status === "verified").length,
-    required_open: obligations.filter(({ required, status }) => required && status !== "verified").length,
-    by_status: countBy(obligations, [
-        "unowned",
-        "characterized",
-        "implemented",
-        "verified",
-        "contradicted",
-        "blocked",
-        "out-of-scope",
-        "unknown",
-    ], ({ status }) => status),
-    by_application_layer: countBy(obligations, [
-        "cli",
-        "protocol",
-        "electron",
-        "persistence",
-        "process",
-        "runtime",
-        "packaging",
-        "native-abi",
-        "application",
-        "other",
-    ], ({ application_layer: layer }) => layer),
-    by_evidence_authority: countBy(obligations, ["candidate", "observed", "reviewed", "unknown"], ({ source_state: state }) => state),
-});
-export const obligationReports = (obligations) => ({
-    missing_owner_obligation_ids: obligationIdsWith(obligations, "missing-owner"),
-    missing_verifier_obligation_ids: obligationIdsWith(obligations, "missing-verifier"),
-    contradicted_obligation_ids: obligationIdsWith(obligations, "contradiction"),
-    residual_unknown_ids: [
-        ...new Set(obligations.flatMap(({ residual_unknown_ids: ids }) => ids)),
-    ].sort(),
-});
 export const obligationLedgerEvidenceLinks = (obligations, manifest) => [
     ...new Set([
-        ...obligations.flatMap(({ authority_references: references }) => references.map(({ evidence_id: id }) => id)),
+        ...reconstructionObligationEvidenceIds(obligations),
         ...manifest.bindings.flatMap((binding) => [
             ...binding.original_cases.map(({ evidence_id: id }) => id),
             ...binding.fixtures.flatMap(({ evidence_ids: ids }) => ids),
@@ -54,31 +12,4 @@ export const obligationLedgerEvidenceLinks = (obligations, manifest) => [
         ]),
         ...manifest.contradictions.flatMap(({ evidence_ids: ids }) => ids),
     ]),
-].sort();
-export const obligationLedgerStatus = (obligations) => {
-    if (obligations.length === 0)
-        return "unknown";
-    const requiredOpen = obligations.filter(({ required, status }) => required && status !== "verified");
-    if (requiredOpen.some(({ status, diagnostics }) => status === "contradicted" ||
-        hasDiagnostic(diagnostics, "verifier-failed")))
-        return "failed";
-    if (requiredOpen.some(({ status }) => status === "unknown"))
-        return "unknown";
-    return requiredOpen.length === 0 ? "ready" : "open";
-};
-export const obligationEdgeOrder = (left, right) => compareUnicodeCodePoints(canonicalJson(left), canonicalJson(right));
-export const digestObligationLedgerValue = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Reconstruction obligation ledger is not canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};
-const countBy = (items, values, valueFor) => values.map((value) => ({
-    key: value,
-    count: items.filter((item) => valueFor(item) === value).length,
-}));
-const obligationIdsWith = (obligations, code) => obligations
-    .filter(({ diagnostics }) => hasDiagnostic(diagnostics, code))
-    .map(({ obligation_id: id }) => id)
-    .sort();
-const hasDiagnostic = (diagnostics, code) => diagnostics.some((diagnostic) => diagnostic.code === code);
+].sort(compareUnicodeCodePoints);

package/dist/application/ReconstructionObligationLedgerService.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AnalysisProtocolError } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
+import { NonCanonicalEvidenceBundleError } from "../domain/evidenceBundle.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
 import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
@@ -30,6 +30,8 @@ export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
         return ok(createLedgerEvidence(input, ledger));
     }
     catch (cause) {
+        if (cause instanceof NonCanonicalEvidenceBundleError)
+            return err(workflowInputError(OPERATION, cause));
         if (cause instanceof z.ZodError)
             return err(workflowInputError(OPERATION, cause));
         return err(new AnalysisProtocolError("Reconstruction obligation ledger generation failed", { cause }));

package/dist/application/ReconstructionObligationOriginalCases.js

@@ -1,11 +1,12 @@
 import { evidenceSupportsOriginalAuthority } from "./ReconstructionObligationAuthority.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 /** Merge generated and manifest-supplied original observations canonically. */
 export const originalCasesFor = (candidate, binding) => [
     ...new Map([...candidate.observed_cases, ...(binding?.original_cases ?? [])].map((observed) => [
         `${observed.kind}:${observed.evidence_id}:${observed.location}`,
         observed,
     ])).values(),
-].sort((left, right) => `${left.kind}:${left.evidence_id}:${left.location}`.localeCompare(`${right.kind}:${right.evidence_id}:${right.location}`));
+].sort((left, right) => compareUnicodeCodePoints(`${left.kind}:${left.evidence_id}:${left.location}`, `${right.kind}:${right.evidence_id}:${right.location}`));
 /** Report original cases that are absent or lack comparable Evidence authority. */
 export const originalCaseDiagnostics = (candidate, binding, evidenceById) => {
     const diagnostics = [];

package/dist/application/ReferenceSourceImport.js

@@ -4,14 +4,16 @@ import { err, ok } from "../domain/result.js";
 import { readReferenceSource } from "../reference/ReferenceSourceReader.js";
 import { parseReferenceSourceEntries } from "./ReferenceSourceImportEntries.js";
 import { readReferenceSourceVcs } from "./ReferenceSourceVcsAdapter.js";
-import {} from "./ReferenceSourceImportTypes.js";
-import { prepareReferenceSourceImport } from "./ReferenceSourceImportPolicy.js";
+import { prepareReferenceSourceImport, } from "./ReferenceSourceImportPolicy.js";
 const failure = (code, message) => ({
     tag: "reference-source-import",
     code,
     message,
 });
-const cancelled = () => failure("cancelled", "Reference source import cancelled");
+const cancelled = (partial) => ({
+    ...failure("cancelled", "Reference source import cancelled"),
+    ...(partial === undefined ? {} : { partial }),
+});
 const isAborted = (signal) => signal?.aborted === true;
 const relationshipKey = (relationship) => `${relationship.from_path}\u0000${relationship.to}\u0000${relationship.kind}\u0000${relationship.resolution}\u0000${relationship.parse_state}`;
 const deduplicateRelationships = (relationships) => {
@@ -52,7 +54,8 @@ const deriveInventoryState = (input) => {
     const partialEntry = input.entries.some((entry) => entry.limitations.length > 0 ||
         (entry.kind === "file" && entry.content_state !== "hashed") ||
         (entry.kind === "directory" && entry.tree_state !== "enumerated") ||
-        (entry.kind === "symlink" && entry.target_state !== "internal"));
+        (entry.kind === "symlink" && entry.target_state !== "internal") ||
+        entry.kind === "unknown");
     if (partialEntry)
         return "partial";
     const partialRelationship = input.relationships.some(({ parse_state, resolution }) => parse_state !== "parsed" ||
@@ -65,8 +68,53 @@ const sortExclusions = (exclusions) => [...exclusions].sort((left, right) => {
     const byPath = compareUnicodeCodePoints(left.path, right.path);
     if (byPath !== 0)
         return byPath;
-    return compareUnicodeCodePoints(left.reason, right.reason);
+    const byReason = compareUnicodeCodePoints(left.reason, right.reason);
+    if (byReason !== 0)
+        return byReason;
+    return compareUnicodeCodePoints("pattern" in left ? left.pattern : "", "pattern" in right ? right.pattern : "");
 });
+const createShouldExclude = (exclusions, secrets, ignored) => (path, kind) => {
+    // An entry of unknown kind may be a directory, so directory-only rules
+    // must still exclude it; this fails closed for caller-marked secrets.
+    const patternPaths = kind === "directory"
+        ? [`${path}/`]
+        : kind === "unknown"
+            ? [path, `${path}/`]
+            : [path];
+    const firstMatch = (matcher) => {
+        const results = patternPaths.map((patternPath) => matcher.test(patternPath));
+        return results.find(({ ignored }) => ignored) ?? results[0];
+    };
+    const secretMatch = firstMatch(secrets);
+    if (secretMatch?.ignored === true) {
+        if (!secretMatch.rule)
+            throw new Error(`Ignored secret path has no matching rule: ${path}`);
+        exclusions.push({
+            path,
+            entry_kind: kind,
+            reason: "configured-secret",
+            pattern: secretMatch.rule.pattern,
+        });
+        return true;
+    }
+    const match = firstMatch(ignored);
+    if (match?.ignored !== true)
+        return false;
+    if (!match.rule)
+        throw new Error(`Ignored path has no matching rule: ${path}`);
+    const reason = match.rule.mark;
+    if (reason !== "project-ignored" &&
+        reason !== "default-ignored" &&
+        reason !== "caller-excluded")
+        throw new Error(`Ignored path has unknown rule origin: ${path}`);
+    exclusions.push({
+        path,
+        entry_kind: kind,
+        reason,
+        pattern: match.rule.pattern,
+    });
+    return true;
+};
 /**
  * Import a reference source directory into a committed historical source graph.
  *
@@ -74,51 +122,38 @@ const sortExclusions = (exclusions) => [...exclusions].sort((left, right) => {
  * git subprocesses, or network requests. Paths explicitly excluded by the
  * caller's reference-source policy are omitted from the graph.
  */
-export const importReferenceSource = async (options) => {
+export const importReferenceSource = async (options, resources) => {
     if (isAborted(options.signal))
         return err(cancelled());
-    const prepared = await prepareReferenceSourceImport(options);
+    const prepared = await prepareReferenceSourceImport(options, resources);
     if (!prepared.ok)
         return prepared;
     const { ignored, root, secrets } = prepared.value;
     if (isAborted(options.signal))
         return err(cancelled());
     const exclusions = [];
-    const shouldExclude = (path) => {
-        if (secrets.ignores(path)) {
-            exclusions.push({ path, reason: "configured-secret" });
-            return true;
-        }
-        if (ignored.ignores(path)) {
-            exclusions.push({ path, reason: "caller-excluded" });
-            return true;
-        }
-        return false;
-    };
-    const [readResult, vcs] = await Promise.all([
-        readReferenceSource(root, {
+    const shouldExclude = createShouldExclude(exclusions, secrets, ignored);
+    const [readResult, vcsResult] = await Promise.all([
+        readReferenceSource(root, resources, {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
             shouldExclude,
         }),
-        readReferenceSourceVcs(root, options.signal),
+        readReferenceSourceVcs(root, resources, options.signal),
     ]);
-    if (!readResult.ok) {
-        const error = readResult.error;
-        if (error.code === "cancelled")
-            return err(cancelled());
-        if (error.code === "unsupported")
-            return err(failure("unsupported", error.message));
-        return err(failure("io", error.message));
-    }
+    if (!readResult.ok)
+        return err(combineReadFailures(readResult.error, vcsResult.ok ? undefined : vcsResult.error, readResult.error.partial));
+    if (!vcsResult.ok)
+        return err(combineReadFailures(vcsResult.error, undefined, readResult.value));
+    const vcs = vcsResult.value;
     if (isAborted(options.signal))
-        return err(cancelled());
+        return err(cancelled(readResult.value));
     const read = readResult.value;
     const filePaths = new Set(read.entries
         .filter((entry) => entry.status === "read" && entry.kind === "file")
         .map((entry) => entry.path));
     const { entries, relationships, parseFailures, limitations } = parseReferenceSourceEntries(read, filePaths, options.signal);
     if (isAborted(options.signal))
-        return err(cancelled());
+        return err(cancelled(read));
     const uniqueRelationships = deduplicateRelationships(relationships);
     const uniqueFailures = normalizeHistoricalSourceParseFailures(parseFailures);
     const sortedEntries = [...entries].sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
@@ -152,3 +187,31 @@ export const importReferenceSource = async (options) => {
         return err(failure("parse", cause instanceof Error ? cause.message : "Graph failed validation"));
     }
 };
+const combineReadFailures = (primary, other, partial) => {
+    const code = primary.code === "cancelled" || other?.code === "cancelled"
+        ? "cancelled"
+        : primary.code;
+    const cleanup = mergeCleanup(primary.cleanup, other?.cleanup);
+    const message = other === undefined
+        ? primary.message
+        : `${primary.message}; additional reference metadata failure: ${other.message}`;
+    const cause = other === undefined
+        ? primary.cause
+        : new AggregateError([primary, other], "Reference source inventory and metadata both failed", { cause: primary });
+    return {
+        ...failure(code, message),
+        ...(cleanup === undefined ? {} : { cleanup }),
+        ...(partial === undefined ? {} : { partial }),
+        ...(cause === undefined ? {} : { cause }),
+    };
+};
+const mergeCleanup = (first, second) => {
+    if (first === undefined)
+        return second;
+    if (second === undefined)
+        return first;
+    return {
+        reason: `${first.reason}; ${second.reason}`,
+        resources: [...new Set([...first.resources, ...second.resources])],
+    };
+};

package/dist/application/ReferenceSourceImportEntries.js

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import { posix } from "node:path";
+import { logicalPathEscapesRoot } from "../domain/artifactIdentity.js";
+import { createReferenceSourcePathLookup, isPortableAbsoluteReferenceTarget, } from "../domain/referenceSourcePathIdentity.js";
 import { classifyReferenceSourcePath, detectReferenceSourceLanguage, } from "../domain/referenceSourceClassification.js";
-import { parseReferenceSourceImports } from "../domain/referenceSourceImportParsing.js";
-import { PARSEABLE_REFERENCE_SOURCE_LANGUAGES } from "./ReferenceSourceImportTypes.js";
+import { parseReferenceSourceImports, PARSEABLE_REFERENCE_SOURCE_LANGUAGES, } from "../domain/referenceSourceImportParsing.js";
+import { typescriptEmittedSourceCandidates } from "./TypeScriptEmittedSourceCandidates.js";
 /** Preserve the observed reader failure and add entry-specific recovery guidance. */
 export const projectReferenceSourceEntryFailure = (entry) => `${entry.message} ${entryRecoveryGuidance(entry)}`;
 const entryRecoveryGuidance = (entry) => {
@@ -14,6 +16,8 @@ const entryRecoveryGuidance = (entry) => {
         return "This directory could not be read. Check its permissions, then try again.";
     if (entry.kind === "symlink")
         return "This symbolic link could not be read safely. Check the link and its permissions, then try again.";
+    if (entry.kind === "unknown")
+        return "This entry's type could not be determined. Check the parent directory and try again.";
     return "This file could not be read. Check its permissions, then try again.";
 };
 const hashBytes = (bytes) => createHash("sha256").update(bytes).digest("hex");
@@ -37,6 +41,13 @@ const failedEntry = (entry) => {
             classifications,
             limitations: [limitation],
         };
+    if (entry.kind === "unknown" || entry.kind === "other")
+        return {
+            path: entry.path,
+            kind: "unknown",
+            classifications: ["unknown"],
+            limitations: [limitation],
+        };
     return {
         path: entry.path,
         kind: "file",
@@ -48,40 +59,33 @@ const failedEntry = (entry) => {
         limitations: [limitation],
     };
 };
-const resolveInternalSpecifier = (fromPath, specifier, filePaths) => {
+const resolveInternalSpecifier = (fromPath, specifier, lookupPath) => {
     if (posix.isAbsolute(specifier))
         return { to: specifier, resolution: "unresolved" };
     const normalized = posix.normalize(posix.join(posix.dirname(fromPath), specifier));
-    if (normalized.startsWith("../") || normalized === "..")
+    if (logicalPathEscapesRoot(normalized))
         return { to: normalized, resolution: "unresolved" };
+    // Preserve directory intent before normalization removes terminal dot segments.
+    const directoryReference = specifier.endsWith("/") || [".", ".."].includes(posix.basename(specifier));
     const suffixes = ["", ".ts", ".js", ".mjs", ".cjs", ".tsx", ".jsx"];
     const candidates = suffixes.flatMap((suffix) => [
-        `${normalized}${suffix}`,
-        `${normalized}/index${suffix}`,
+        ...(directoryReference ? [] : [`${normalized}${suffix}`]),
+        posix.join(normalized, `index${suffix}`),
     ]);
-    // TypeScript source commonly names the extension emitted for NodeNext.
     // Retain present runtime files first; substitute only a missing counterpart.
     // Counterparts cover explicit filenames, not directory/index resolution.
-    if (/\.(?:ts|tsx|mts|cts)$/u.test(fromPath)) {
-        const sourceSuffixes = normalized.endsWith(".js")
-            ? [".ts", ".tsx", ".d.ts"]
-            : normalized.endsWith(".mjs")
-                ? [".mts", ".d.mts"]
-                : normalized.endsWith(".cjs")
-                    ? [".cts", ".d.cts"]
-                    : normalized.endsWith(".jsx")
-                        ? [".tsx", ".d.ts"]
-                        : [];
-        const stem = normalized.slice(0, -posix.extname(normalized).length);
-        candidates.push(...sourceSuffixes.map((suffix) => `${stem}${suffix}`));
-    }
-    const match = candidates.find((candidate) => filePaths.has(candidate));
+    if (!directoryReference)
+        candidates.push(...typescriptEmittedSourceCandidates(fromPath, normalized).map(({ path }) => path));
+    const match = lookupPath.resolveCandidates(candidates);
     return match === undefined
         ? { to: normalized, resolution: "unresolved" }
         : { to: match, resolution: "internal" };
 };
-const appendFile = (entry, filePaths, output) => {
+const appendFile = (entry, lookupPath, output) => {
     const language = detectReferenceSourceLanguage(entry.path);
+    const parsed = language === null || !PARSEABLE_REFERENCE_SOURCE_LANGUAGES.has(language)
+        ? undefined
+        : parseReferenceSourceImports(entry.path, entry.bytes, language);
     output.entries.push({
         path: entry.path,
         kind: "file",
@@ -90,17 +94,16 @@ const appendFile = (entry, filePaths, output) => {
         language,
         classifications: classifyReferenceSourcePath(entry.path),
         content_state: "hashed",
-        limitations: [],
+        limitations: [...(parsed?.limitations ?? [])],
     });
-    if (language === null || !PARSEABLE_REFERENCE_SOURCE_LANGUAGES.has(language))
+    if (parsed === undefined)
         return;
-    const parsed = parseReferenceSourceImports(entry.path, entry.bytes, language);
     for (const relationship of parsed.relationships) {
         if (relationship.resolution !== "internal") {
             output.relationships.push(relationship);
             continue;
         }
-        const resolved = resolveInternalSpecifier(relationship.from_path, relationship.to, filePaths);
+        const resolved = resolveInternalSpecifier(relationship.from_path, relationship.to, lookupPath);
         output.relationships.push({
             ...relationship,
             to: resolved.to,
@@ -109,9 +112,9 @@ const appendFile = (entry, filePaths, output) => {
     }
     output.parseFailures.push(...parsed.parse_failures);
 };
-const appendReadEntry = (entry, filePaths, output) => {
+const appendReadEntry = (entry, lookupPath, output) => {
     if (entry.kind === "file") {
-        appendFile(entry, filePaths, output);
+        appendFile(entry, lookupPath, output);
         return;
     }
     const classifications = classifyReferenceSourcePath(entry.path);
@@ -128,7 +131,13 @@ const appendReadEntry = (entry, filePaths, output) => {
     output.entries.push({
         path: entry.path,
         kind: "symlink",
-        target: entry.target,
+        // The reader resolves inventory identities from its root; the persisted
+        // graph represents relative symlink targets from the link's directory.
+        target: entry.targetState === "internal" ||
+            (entry.targetState === "missing" &&
+                !isPortableAbsoluteReferenceTarget(entry.target))
+            ? posix.relative(posix.dirname(entry.path), entry.target) || "."
+            : entry.target,
         target_state: entry.targetState,
         classifications,
         limitations: [],
@@ -142,13 +151,14 @@ export const parseReferenceSourceEntries = (read, filePaths, signal) => {
         parseFailures: [],
         limitations: [...read.limitations],
     };
+    const lookupPath = createReferenceSourcePathLookup(filePaths);
     for (const entry of read.entries) {
         if (signal?.aborted === true)
             break;
         if (entry.status === "failed")
             output.entries.push(failedEntry(entry));
         else
-            appendReadEntry(entry, filePaths, output);
+            appendReadEntry(entry, lookupPath, output);
     }
     return output;
 };