context-probe 0.1.0

package/dist/src/core/history-normalization.js

@@ -0,0 +1,105 @@
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { consumeGitHistoryLine, createGitHistoryParseState, flushParsedCommit, toGitHistoryPathspecs, } from "./history-shared.js";
+async function runGitLog(repoPath, onLine, options) {
+    const args = [
+        "-C",
+        repoPath,
+        "log",
+        "--no-merges",
+        "--find-renames",
+        "--name-status",
+        "--pretty=format:__COMMIT__%n%H%n%s",
+    ];
+    const pathspecs = toGitHistoryPathspecs(options?.includePathGlobs ?? []);
+    if (pathspecs.length > 0) {
+        args.push("--", ...pathspecs);
+    }
+    const child = spawn("git", args, {
+        cwd: repoPath,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stderr = "";
+    let stdoutBuffer = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        stdoutBuffer += chunk;
+        const lines = stdoutBuffer.split("\n");
+        stdoutBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            onLine(line);
+        }
+    });
+    child.stderr.on("data", (chunk) => {
+        stderr += chunk;
+    });
+    const closePromise = once(child, "close");
+    const errorPromise = once(child, "error").then(([error]) => {
+        throw error;
+    });
+    const [code, signal] = await Promise.race([closePromise, errorPromise]);
+    if (code !== 0) {
+        const details = stderr.trim() || `git log exited with code ${code ?? "unknown"}${signal ? ` signal ${signal}` : ""}.`;
+        throw new Error(details);
+    }
+    if (stdoutBuffer.length > 0) {
+        onLine(stdoutBuffer);
+    }
+}
+export async function normalizeHistory(repoPath, policyConfig, profileName, options) {
+    const profile = policyConfig.profiles[profileName];
+    const ignoreCommitPatterns = (profile?.history_filters?.ignore_commit_patterns ?? []).map((pattern) => new RegExp(pattern));
+    const ignorePaths = profile?.history_filters?.ignore_paths ?? [];
+    const commits = [];
+    const parseState = createGitHistoryParseState();
+    const startTime = Date.now();
+    const includePathGlobCount = toGitHistoryPathspecs(options?.includePathGlobs ?? []).length;
+    const progressIntervalMs = options?.progressIntervalMs ?? 5000;
+    let observedCommitCount = 0;
+    let lastProgressAt = startTime;
+    options?.onProgress?.({
+        phase: "start",
+        elapsedMs: 0,
+        observedCommitCount,
+        emittedCommitCount: commits.length,
+        includePathGlobCount,
+    });
+    try {
+        await runGitLog(repoPath, (line) => {
+            if (line === "__COMMIT__") {
+                observedCommitCount += 1;
+            }
+            consumeGitHistoryLine(line, parseState, commits, ignoreCommitPatterns, ignorePaths);
+            if (options?.onProgress && Date.now() - lastProgressAt >= progressIntervalMs) {
+                lastProgressAt = Date.now();
+                options.onProgress({
+                    phase: "heartbeat",
+                    elapsedMs: lastProgressAt - startTime,
+                    observedCommitCount,
+                    emittedCommitCount: commits.length,
+                    includePathGlobCount,
+                });
+            }
+        }, options);
+        flushParsedCommit(parseState, commits, ignoreCommitPatterns, ignorePaths);
+    }
+    catch (error) {
+        options?.onProgress?.({
+            phase: "error",
+            elapsedMs: Date.now() - startTime,
+            observedCommitCount,
+            emittedCommitCount: commits.length,
+            includePathGlobCount,
+        });
+        throw error;
+    }
+    options?.onProgress?.({
+        phase: "complete",
+        elapsedMs: Date.now() - startTime,
+        observedCommitCount,
+        emittedCommitCount: commits.length,
+        includePathGlobCount,
+    });
+    return commits;
+}

package/dist/src/core/history-persistence-analysis.d.ts

@@ -0,0 +1,6 @@
+import type { CochangeCommit, CochangePersistenceAnalysis, DomainModel } from "./contracts.js";
+export declare function analyzeCochangePersistence(commits: CochangeCommit[], model: DomainModel): {
+    analysis: CochangePersistenceAnalysis;
+    confidence: number;
+    unknowns: string[];
+};

package/dist/src/core/history-persistence-analysis.js

@@ -0,0 +1,26 @@
+import { buildPairWeights, deriveStableClusters } from "./history-persistence-clusters.js";
+import { buildHistoryObservationQuality, contextualizeCommits, unique } from "./history-shared.js";
+export function analyzeCochangePersistence(commits, model) {
+    const relevant = contextualizeCommits(commits, model);
+    const contextsSeen = unique(relevant.flatMap((commit) => commit.contexts)).sort();
+    const pairWeights = buildPairWeights(relevant);
+    const { stableChangeClusters, naturalSplitLevels, noiseRatio, hasWeightRange } = deriveStableClusters(contextsSeen, pairWeights);
+    const quality = buildHistoryObservationQuality({
+        relevantCommitCount: relevant.length,
+        contextsSeen,
+        pairWeightCount: pairWeights.length,
+        hasWeightRange,
+    });
+    return {
+        analysis: {
+            relevantCommitCount: relevant.length,
+            contextsSeen,
+            pairWeights,
+            stableChangeClusters,
+            naturalSplitLevels,
+            noiseRatio,
+        },
+        confidence: quality.confidence,
+        unknowns: quality.unknowns,
+    };
+}

package/dist/src/core/history-persistence-clusters.d.ts

@@ -0,0 +1,6 @@
+import type { CochangePairWeight } from "./contracts.js";
+import { buildPairWeights } from "./history-persistence-components.js";
+import { computeClusterPenalty as computeClusterPenaltyImpl, deriveStableClusters as deriveStableClustersImpl } from "./history-persistence-stability.js";
+export declare function deriveStableClusters(contextsSeen: string[], pairWeights: CochangePairWeight[]): ReturnType<typeof deriveStableClustersImpl>;
+export declare function computeClusterPenalty(strongestCluster: Parameters<typeof computeClusterPenaltyImpl>[0], contextCount: number): number;
+export { buildPairWeights };

package/dist/src/core/history-persistence-clusters.js

@@ -0,0 +1,9 @@
+import { buildPairWeights } from "./history-persistence-components.js";
+import { computeClusterPenalty as computeClusterPenaltyImpl, deriveStableClusters as deriveStableClustersImpl, } from "./history-persistence-stability.js";
+export function deriveStableClusters(contextsSeen, pairWeights) {
+    return deriveStableClustersImpl(contextsSeen, pairWeights);
+}
+export function computeClusterPenalty(strongestCluster, contextCount) {
+    return computeClusterPenaltyImpl(strongestCluster, contextCount);
+}
+export { buildPairWeights };

package/dist/src/core/history-persistence-comparison.d.ts

@@ -0,0 +1,6 @@
+import type { CochangeCommit, DomainModel, EvolutionLocalityModelComparison } from "./contracts.js";
+export declare function compareEvolutionLocalityModels(commits: CochangeCommit[], model: DomainModel): {
+    comparison: EvolutionLocalityModelComparison;
+    confidence: number;
+    unknowns: string[];
+};

package/dist/src/core/history-persistence-comparison.js

@@ -0,0 +1,66 @@
+import { computeEvolutionLocalityScore, scoreEvolutionLocality } from "./history-locality.js";
+import { analyzeCochangePersistence } from "./history-persistence-analysis.js";
+import { computeClusterPenalty } from "./history-persistence-clusters.js";
+import { clamp01 } from "./history-shared.js";
+function scorePersistenceLocalityCandidate(commits, model) {
+    const result = analyzeCochangePersistence(commits, model);
+    if (result.analysis.relevantCommitCount === 0 || result.analysis.contextsSeen.length === 0) {
+        const fallbackElsScore = computeEvolutionLocalityScore(scoreEvolutionLocality(commits, model));
+        return {
+            analysis: result.analysis,
+            candidate: {
+                localityScore: fallbackElsScore,
+                persistentCouplingPenalty: clamp01(1 - fallbackElsScore),
+                strongestPair: null,
+                strongestCluster: null,
+                clusterPenalty: 0,
+                pairPenalty: 0,
+                coherencePenalty: 0,
+            },
+            confidence: result.confidence,
+            unknowns: result.unknowns,
+        };
+    }
+    const strongestPair = result.analysis.pairWeights[0] ?? null;
+    const strongestCluster = result.analysis.stableChangeClusters[0] ?? null;
+    const clusterPenalty = computeClusterPenalty(strongestCluster, result.analysis.contextsSeen.length);
+    const pairPenalty = strongestPair?.jaccard ?? 0;
+    const coherencePenalty = strongestPair ? clamp01((1 - result.analysis.noiseRatio) * pairPenalty) : 0;
+    const persistentCouplingPenalty = clamp01(0.6 * clusterPenalty + 0.3 * pairPenalty + 0.1 * coherencePenalty);
+    return {
+        analysis: result.analysis,
+        candidate: {
+            localityScore: clamp01(1 - persistentCouplingPenalty),
+            persistentCouplingPenalty,
+            strongestPair,
+            strongestCluster,
+            clusterPenalty,
+            pairPenalty,
+            coherencePenalty,
+        },
+        confidence: result.confidence,
+        unknowns: result.unknowns,
+    };
+}
+export function compareEvolutionLocalityModels(commits, model) {
+    const elsAnalysis = scoreEvolutionLocality(commits, model);
+    const persistence = scorePersistenceLocalityCandidate(commits, model);
+    const elsScore = computeEvolutionLocalityScore(elsAnalysis);
+    return {
+        comparison: {
+            els: {
+                score: elsScore,
+                components: {
+                    CCL: elsAnalysis.crossContextChangeLocality,
+                    FS: elsAnalysis.featureScatter,
+                    SCR: elsAnalysis.surpriseCouplingRatio,
+                },
+            },
+            persistenceCandidate: persistence.candidate,
+            persistenceAnalysis: persistence.analysis,
+            delta: persistence.candidate.localityScore - elsScore,
+        },
+        confidence: persistence.confidence,
+        unknowns: persistence.unknowns,
+    };
+}

package/dist/src/core/history-persistence-components.d.ts

@@ -0,0 +1,8 @@
+import type { CochangePairWeight } from "./contracts.js";
+type ContextualizedCommit = {
+    contexts: string[];
+};
+export declare function componentKey(contexts: string[]): string;
+export declare function buildConnectedComponents(contextsSeen: string[], pairWeights: CochangePairWeight[], threshold: number): string[][];
+export declare function buildPairWeights(relevant: ContextualizedCommit[]): CochangePairWeight[];
+export {};

package/dist/src/core/history-persistence-components.js

@@ -0,0 +1,99 @@
+export function componentKey(contexts) {
+    return contexts.join("::");
+}
+export function buildConnectedComponents(contextsSeen, pairWeights, threshold) {
+    if (contextsSeen.length === 0) {
+        return [];
+    }
+    const parent = new Map(contextsSeen.map((context) => [context, context]));
+    const size = new Map(contextsSeen.map((context) => [context, 1]));
+    const find = (value) => {
+        let current = value;
+        while (true) {
+            const parentValue = parent.get(current);
+            if (!parentValue || parentValue === current) {
+                break;
+            }
+            current = parentValue;
+        }
+        let compress = value;
+        while (true) {
+            const parentValue = parent.get(compress);
+            if (!parentValue || parentValue === current) {
+                break;
+            }
+            const next = parentValue;
+            parent.set(compress, current);
+            compress = next;
+        }
+        return current;
+    };
+    const union = (left, right) => {
+        let leftRoot = find(left);
+        let rightRoot = find(right);
+        if (leftRoot === rightRoot) {
+            return;
+        }
+        const leftSize = size.get(leftRoot) ?? 1;
+        const rightSize = size.get(rightRoot) ?? 1;
+        if (leftSize < rightSize || (leftSize === rightSize && leftRoot.localeCompare(rightRoot) > 0)) {
+            [leftRoot, rightRoot] = [rightRoot, leftRoot];
+        }
+        parent.set(rightRoot, leftRoot);
+        size.set(leftRoot, leftSize + rightSize);
+    };
+    for (const pair of pairWeights) {
+        if (pair.jaccard < threshold) {
+            continue;
+        }
+        union(pair.left, pair.right);
+    }
+    const groups = new Map();
+    for (const context of contextsSeen) {
+        const root = find(context);
+        const members = groups.get(root) ?? [];
+        members.push(context);
+        groups.set(root, members);
+    }
+    return Array.from(groups.values())
+        .map((members) => members.sort())
+        .filter((members) => members.length > 1)
+        .sort((left, right) => right.length - left.length || componentKey(left).localeCompare(componentKey(right)));
+}
+export function buildPairWeights(relevant) {
+    const contextTouchCount = new Map();
+    const pairCount = new Map();
+    for (const commit of relevant) {
+        for (const context of commit.contexts) {
+            contextTouchCount.set(context, (contextTouchCount.get(context) ?? 0) + 1);
+        }
+        for (let index = 0; index < commit.contexts.length; index += 1) {
+            for (let next = index + 1; next < commit.contexts.length; next += 1) {
+                const left = commit.contexts[index];
+                const right = commit.contexts[next];
+                if (!left || !right) {
+                    continue;
+                }
+                const key = `${left}::${right}`;
+                pairCount.set(key, (pairCount.get(key) ?? 0) + 1);
+            }
+        }
+    }
+    return Array.from(pairCount.entries())
+        .map(([key, rawCount]) => {
+        const [left = "", right = ""] = key.split("::");
+        const leftTouches = contextTouchCount.get(left) ?? 0;
+        const rightTouches = contextTouchCount.get(right) ?? 0;
+        const denominator = leftTouches + rightTouches - rawCount;
+        return {
+            left,
+            right,
+            rawCount,
+            jaccard: denominator === 0 ? 0 : Math.max(0, Math.min(1, rawCount / denominator)),
+        };
+    })
+        .sort((left, right) => right.jaccard - left.jaccard ||
+        right.rawCount - left.rawCount ||
+        left.left.localeCompare(right.left) ||
+        left.right.localeCompare(right.right));
+}

package/dist/src/core/history-persistence-stability.d.ts

@@ -0,0 +1,8 @@
+import type { CochangePairWeight, CochangeStabilityCluster } from "./contracts.js";
+export declare function deriveStableClusters(contextsSeen: string[], pairWeights: CochangePairWeight[]): {
+    stableChangeClusters: CochangeStabilityCluster[];
+    naturalSplitLevels: number[];
+    noiseRatio: number;
+    hasWeightRange: boolean;
+};
+export declare function computeClusterPenalty(strongestCluster: CochangeStabilityCluster | null, contextCount: number): number;

package/dist/src/core/history-persistence-stability.js

@@ -0,0 +1,79 @@
+import { buildConnectedComponents, componentKey } from "./history-persistence-components.js";
+import { clamp01, unique } from "./history-shared.js";
+function computeNoiseRatio(stableChangeClusters) {
+    const stabilityMass = stableChangeClusters.reduce((sum, cluster) => sum + cluster.stability, 0);
+    if (stabilityMass === 0) {
+        return 0;
+    }
+    const topMass = stableChangeClusters
+        .slice()
+        .sort((left, right) => right.stability - left.stability)
+        .slice(0, 3)
+        .reduce((sum, cluster) => sum + cluster.stability, 0);
+    return clamp01(1 - topMass / stabilityMass);
+}
+export function deriveStableClusters(contextsSeen, pairWeights) {
+    if (contextsSeen.length < 2 || pairWeights.length === 0) {
+        return {
+            stableChangeClusters: [],
+            naturalSplitLevels: [],
+            noiseRatio: 0,
+            hasWeightRange: true,
+        };
+    }
+    const thresholds = unique(pairWeights.map((pair) => pair.jaccard)).sort((left, right) => right - left);
+    const active = new Map();
+    const completed = [];
+    for (const threshold of thresholds) {
+        const components = buildConnectedComponents(contextsSeen, pairWeights, threshold);
+        const currentKeys = new Set(components.map((members) => componentKey(members)));
+        for (const members of components) {
+            const key = componentKey(members);
+            if (!active.has(key)) {
+                active.set(key, {
+                    contexts: members,
+                    birth: threshold,
+                });
+            }
+        }
+        for (const [key, entry] of Array.from(active.entries())) {
+            if (currentKeys.has(key)) {
+                continue;
+            }
+            completed.push({
+                contexts: entry.contexts,
+                birth: entry.birth,
+                death: threshold,
+                stability: clamp01(entry.birth - threshold),
+            });
+            active.delete(key);
+        }
+    }
+    for (const entry of active.values()) {
+        completed.push({
+            contexts: entry.contexts,
+            birth: entry.birth,
+            death: 0,
+            stability: clamp01(entry.birth),
+        });
+    }
+    const stableChangeClusters = completed
+        .sort((left, right) => right.stability - left.stability ||
+        right.contexts.length - left.contexts.length ||
+        componentKey(left.contexts).localeCompare(componentKey(right.contexts)))
+        .slice(0, 5);
+    const naturalSplitLevels = unique(stableChangeClusters.map((cluster) => cluster.birth)).sort((left, right) => right - left);
+    return {
+        stableChangeClusters,
+        naturalSplitLevels,
+        noiseRatio: computeNoiseRatio(completed),
+        hasWeightRange: thresholds.length > 1,
+    };
+}
+export function computeClusterPenalty(strongestCluster, contextCount) {
+    if (!strongestCluster || contextCount < 2) {
+        return 0;
+    }
+    const spanFactor = clamp01((strongestCluster.contexts.length - 1) / (contextCount - 1));
+    return clamp01(strongestCluster.stability * spanFactor);
+}

package/dist/src/core/history-persistence.d.ts

@@ -0,0 +1,2 @@
+export { analyzeCochangePersistence } from "./history-persistence-analysis.js";
+export { compareEvolutionLocalityModels } from "./history-persistence-comparison.js";

package/dist/src/core/history-persistence.js

@@ -0,0 +1,2 @@
+export { analyzeCochangePersistence } from "./history-persistence-analysis.js";
+export { compareEvolutionLocalityModels } from "./history-persistence-comparison.js";

package/dist/src/core/history-shared.d.ts

@@ -0,0 +1,27 @@
+import type { CochangeCommit, DomainModel } from "./contracts.js";
+import { clamp01Finite as clamp01, unique } from "./shared-utils.js";
+export interface ContextualizedCommit extends CochangeCommit {
+    contexts: string[];
+}
+export interface HistoryObservationQuality {
+    confidence: number;
+    unknowns: string[];
+}
+export { clamp01, unique };
+export declare function toGitHistoryPathspecs(globs: string[]): string[];
+export interface GitHistoryParseState {
+    currentHash: string | undefined;
+    currentSubject: string | undefined;
+    currentFiles: string[];
+    expect: "sentinel" | "hash" | "subject" | "files";
+}
+export declare function createGitHistoryParseState(): GitHistoryParseState;
+export declare function flushParsedCommit(state: GitHistoryParseState, commits: CochangeCommit[], ignoreCommitPatterns: RegExp[], ignorePaths: string[]): void;
+export declare function consumeGitHistoryLine(line: string, state: GitHistoryParseState, commits: CochangeCommit[], ignoreCommitPatterns: RegExp[], ignorePaths: string[]): void;
+export declare function contextualizeCommits(commits: CochangeCommit[], model: DomainModel): ContextualizedCommit[];
+export declare function buildHistoryObservationQuality(input: {
+    relevantCommitCount: number;
+    contextsSeen: string[];
+    pairWeightCount?: number;
+    hasWeightRange?: boolean;
+}): HistoryObservationQuality;

package/dist/src/core/history-shared.js

@@ -0,0 +1,145 @@
+import { matchGlobs, toPosixPath } from "./io.js";
+import { average, clamp01Finite as clamp01, unique } from "./shared-utils.js";
+function classifyContext(filePath, model) {
+    return model.contexts.find((context) => matchGlobs(filePath, context.pathGlobs))?.name;
+}
+export { clamp01, unique };
+export function toGitHistoryPathspecs(globs) {
+    return unique(globs
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0 && !entry.startsWith("!"))
+        .map((entry) => (entry.startsWith("./") ? entry.slice(2) : entry))
+        .map((entry) => `:(glob)${entry}`));
+}
+function parseChangedPath(entry) {
+    const normalized = entry.trim();
+    if (!normalized) {
+        return null;
+    }
+    const parts = normalized
+        .split("\t")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        return null;
+    }
+    if (parts.length === 1) {
+        const onlyPath = parts[0];
+        return onlyPath ? toPosixPath(onlyPath) : null;
+    }
+    const status = parts[0];
+    if (!status) {
+        return null;
+    }
+    if (status.startsWith("R") || status.startsWith("C")) {
+        const renamedPath = parts.at(-1);
+        return renamedPath ? toPosixPath(renamedPath) : null;
+    }
+    const nextPath = parts[1];
+    return nextPath ? toPosixPath(nextPath) : null;
+}
+export function createGitHistoryParseState() {
+    return {
+        currentHash: undefined,
+        currentSubject: undefined,
+        currentFiles: [],
+        expect: "sentinel",
+    };
+}
+export function flushParsedCommit(state, commits, ignoreCommitPatterns, ignorePaths) {
+    if (!state.currentHash) {
+        return;
+    }
+    const subject = state.currentSubject ?? "";
+    if (ignoreCommitPatterns.some((pattern) => pattern.test(subject))) {
+        state.currentHash = undefined;
+        state.currentSubject = undefined;
+        state.currentFiles = [];
+        state.expect = "sentinel";
+        return;
+    }
+    const normalizedFiles = state.currentFiles
+        .map((entry) => parseChangedPath(entry))
+        .filter((value) => Boolean(value))
+        .filter((entry) => !ignorePaths.includes(entry));
+    const uniqueFiles = unique(normalizedFiles);
+    if (uniqueFiles.length > 0) {
+        commits.push({
+            hash: state.currentHash,
+            subject,
+            files: uniqueFiles,
+        });
+    }
+    state.currentHash = undefined;
+    state.currentSubject = undefined;
+    state.currentFiles = [];
+    state.expect = "sentinel";
+}
+export function consumeGitHistoryLine(line, state, commits, ignoreCommitPatterns, ignorePaths) {
+    if (line === "__COMMIT__") {
+        flushParsedCommit(state, commits, ignoreCommitPatterns, ignorePaths);
+        state.expect = "hash";
+        return;
+    }
+    if (state.expect === "sentinel") {
+        return;
+    }
+    if (state.expect === "hash") {
+        state.currentHash = line.trim() || undefined;
+        state.expect = "subject";
+        return;
+    }
+    if (state.expect === "subject") {
+        state.currentSubject = line;
+        state.expect = "files";
+        return;
+    }
+    if (line.trim().length === 0) {
+        return;
+    }
+    state.currentFiles.push(line);
+}
+export function contextualizeCommits(commits, model) {
+    return commits
+        .map((commit) => ({
+        ...commit,
+        contexts: unique(commit.files
+            .map((filePath) => classifyContext(filePath, model))
+            .filter((value) => Boolean(value))).sort(),
+    }))
+        .filter((entry) => entry.contexts.length > 0);
+}
+export function buildHistoryObservationQuality(input) {
+    const unknowns = [];
+    if (input.relevantCommitCount === 0) {
+        unknowns.push("No Git commits suitable for evaluation were found.");
+    }
+    else if (input.relevantCommitCount < 3) {
+        unknowns.push("Git history is still thin, so ELS is provisional.");
+    }
+    if (input.contextsSeen.length < 2) {
+        unknowns.push("Fewer than two contexts were observed in history, so locality evidence is limited.");
+    }
+    if (input.pairWeightCount !== undefined && input.pairWeightCount === 0) {
+        unknowns.push("No cross-context co-change pairs were observed, so topology signals are limited.");
+    }
+    if (input.pairWeightCount !== undefined && input.pairWeightCount > 0 && input.hasWeightRange === false) {
+        unknowns.push("All normalized co-change weights are identical, so natural split levels are limited.");
+    }
+    const confidenceSignals = [
+        input.relevantCommitCount === 0 ? 0.25 : input.relevantCommitCount < 3 ? 0.6 : 0.85,
+        input.contextsSeen.length < 2 ? 0.35 : 0.85,
+    ];
+    if (input.pairWeightCount !== undefined) {
+        if (input.relevantCommitCount > 0) {
+            confidenceSignals.push(input.pairWeightCount === 0 ? 0.55 : 0.8);
+        }
+        if (input.pairWeightCount > 0) {
+            confidenceSignals.push(input.hasWeightRange === false ? 0.55 : 0.78);
+        }
+    }
+    return {
+        confidence: clamp01(average(confidenceSignals, 0.45)),
+        unknowns: unique(unknowns),
+    };
+}

package/dist/src/core/history.d.ts

@@ -0,0 +1,3 @@
+export { evaluateEvolutionLocalityObservationQuality, scoreEvolutionLocality, } from "./history-locality.js";
+export { normalizeHistory } from "./history-normalization.js";
+export { analyzeCochangePersistence, compareEvolutionLocalityModels } from "./history-persistence.js";

package/dist/src/core/history.js

@@ -0,0 +1,3 @@
+export { evaluateEvolutionLocalityObservationQuality, scoreEvolutionLocality, } from "./history-locality.js";
+export { normalizeHistory } from "./history-normalization.js";
+export { analyzeCochangePersistence, compareEvolutionLocalityModels } from "./history-persistence.js";

package/dist/src/core/io.d.ts

@@ -0,0 +1,9 @@
+export declare function toPosixPath(input: string): string;
+export declare function relativePath(root: string, absolutePath: string): string;
+export declare function hashText(text: string): string;
+export declare function isDocumentFile(filePath: string): boolean;
+export declare function isSourceFile(filePath: string): boolean;
+export declare function matchGlobs(filePath: string, globs: string[] | undefined): boolean;
+export declare function listFiles(root: string): Promise<string[]>;
+export declare function readText(filePath: string): Promise<string>;
+export declare function readDataFile<T>(filePath: string): Promise<T>;