context-probe 0.1.0

package/dist/src/core/document-extractor-text-signals.js

@@ -0,0 +1,115 @@
+export const RULE_SIGNALS = [
+    /なければならない/u,
+    /べき/u,
+    /\bmust\b/i,
+    /\bmust not\b/i,
+    /\bshould not\b/i,
+    /禁止/u,
+    /行わない/u,
+    /残さない/u,
+];
+export const INVARIANT_SIGNALS = [
+    /常に/u,
+    /一致/u,
+    /不変/u,
+    /\balways\b/i,
+    /一意/u,
+    /整合/u,
+    /返(?:る|される)/u,
+    /欠落しない/u,
+    /再現可能/u,
+    /安定(?:する|している)/u,
+    /辿れる/u,
+    /反映(?:される|されている)/u,
+    /付与(?:される|されている)/u,
+    /表示(?:される|されている)/u,
+];
+export const RULE_PREDICATE_PATTERNS = [
+    /なければならない[。.]?$/u,
+    /べき[。.]?$/u,
+    /\bmust\b/i,
+    /\bmust not\b/i,
+    /\bshould not\b/i,
+    /選択できる[。.]?$/u,
+    /行わない[。.]?$/u,
+    /残さない[。.]?$/u,
+    /持つ[。.]?$/u,
+    /従う[。.]?$/u,
+    /守る[。.]?$/u,
+];
+export const INVARIANT_PREDICATE_PATTERNS = [
+    /である[。.]?$/u,
+    /不変である[。.]?$/u,
+    /一致(?:して(?:いる|いなければならない)|する)[。.]?$/u,
+    /返(?:る|される)[。.]?$/u,
+    /一意である[。.]?$/u,
+    /整合(?:して(?:いる|いなければならない)|する)[。.]?$/u,
+    /欠落しない[。.]?$/u,
+    /再現可能である/u,
+    /安定(?:する|している)[。.]?$/u,
+    /辿れる[。.]?$/u,
+    /反映(?:される|されている)[。.]?$/u,
+    /付与(?:される|されている)[。.]?$/u,
+    /表示(?:される|されている)[。.]?$/u,
+    /保た(?:れる|れている)[。.]?$/u,
+    /維持(?:される|している|する)?[。.]?$/u,
+    /成立(?:する|している)?[。.]?$/u,
+    /閉じ(?:ている|る)[。.]?$/u,
+    /\balways\b.+\b(is|are|returns?|holds?)\b/i,
+];
+export const RULE_INVARIANT_AMBIGUITY = "The boundary between a rule and an invariant is ambiguous.";
+export const INVARIANT_REVIEW_SIGNALS = [
+    /返(?:る|される)/u,
+    /表示(?:される|されている)/u,
+    /反映(?:される|されている)/u,
+    /付与(?:される|されている)/u,
+    /欠落しない/u,
+];
+const STRUCTURAL_GLOSSARY_FLAG_PATTERN = /^--[a-z0-9][a-z0-9-]*$/;
+const STRUCTURAL_GLOSSARY_FILE_SUFFIX_PATTERN = /\.(?:ts|tsx|js|mjs|md|yaml|yml|json)$/i;
+const STRUCTURAL_GLOSSARY_ID_PATTERN = /^(?:ART|FRG|TERM|RULE|INV|EV|RUN|RV)-[A-Za-z0-9._-]+$/;
+const STRUCTURAL_GLOSSARY_RESPONSE_PATH_PATTERN = /^(?:result|response)\.[A-Za-z0-9_*.-]+$/;
+const STRUCTURAL_GLOSSARY_SNAKE_CASE_PATTERN = /^[a-z0-9]+(?:_[a-z0-9]+)+$/;
+export function isStructuredNoiseFragment(fragment) {
+    const trimmed = fragment.text.trim();
+    if (trimmed.startsWith("```") || trimmed.includes("\n```")) {
+        return true;
+    }
+    return trimmed
+        .split("\n")
+        .filter(Boolean)
+        .every((line) => line.trim().startsWith("|"));
+}
+function isStructuralGlossaryNoise(term) {
+    return (STRUCTURAL_GLOSSARY_FLAG_PATTERN.test(term) ||
+        term.includes("/") ||
+        STRUCTURAL_GLOSSARY_FILE_SUFFIX_PATTERN.test(term) ||
+        STRUCTURAL_GLOSSARY_ID_PATTERN.test(term) ||
+        STRUCTURAL_GLOSSARY_RESPONSE_PATH_PATTERN.test(term) ||
+        STRUCTURAL_GLOSSARY_SNAKE_CASE_PATTERN.test(term));
+}
+export function hasAnySignal(text, patterns) {
+    return patterns.some((pattern) => pattern.test(text));
+}
+export function hasPredicateShape(text, patterns) {
+    return patterns.some((pattern) => pattern.test(text));
+}
+export function normalizeInlineTerm(term) {
+    const normalized = term.trim();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized.includes("\n")) {
+        return undefined;
+    }
+    if (normalized.length > 80) {
+        return undefined;
+    }
+    if (normalized.split(/\s+/).length > 4) {
+        return undefined;
+    }
+    if (isStructuralGlossaryNoise(normalized)) {
+        return undefined;
+    }
+    return normalized;
+}

package/dist/src/core/document-extractor-text.d.ts

@@ -0,0 +1,3 @@
+export { isListItemLine, isQuestionLikeStatement, normalizeStatement, splitIntoSentences, stripListMarker, } from "./document-extractor-text-normalization.js";
+export { buildInvariantReviewState } from "./document-extractor-text-review.js";
+export { hasAnySignal, hasPredicateShape, INVARIANT_PREDICATE_PATTERNS, INVARIANT_SIGNALS, isStructuredNoiseFragment, normalizeInlineTerm, RULE_INVARIANT_AMBIGUITY, RULE_PREDICATE_PATTERNS, RULE_SIGNALS, } from "./document-extractor-text-signals.js";

package/dist/src/core/document-extractor-text.js

@@ -0,0 +1,3 @@
+export { isListItemLine, isQuestionLikeStatement, normalizeStatement, splitIntoSentences, stripListMarker, } from "./document-extractor-text-normalization.js";
+export { buildInvariantReviewState } from "./document-extractor-text-review.js";
+export { hasAnySignal, hasPredicateShape, INVARIANT_PREDICATE_PATTERNS, INVARIANT_SIGNALS, isStructuredNoiseFragment, normalizeInlineTerm, RULE_INVARIANT_AMBIGUITY, RULE_PREDICATE_PATTERNS, RULE_SIGNALS, } from "./document-extractor-text-signals.js";

package/dist/src/core/document-extractor-types.d.ts

@@ -0,0 +1,30 @@
+import type { ExtractionBackend, ExtractionProviderName, Fragment, GlossaryTerm, ReviewResolutionLog } from "./contracts.js";
+export interface ExtractionOptions {
+    root: string;
+    cwd: string;
+    extractor?: ExtractionBackend;
+    provider?: ExtractionProviderName;
+    providerCommand?: string;
+    promptProfile?: string;
+    fallback?: "heuristic" | "none";
+    reviewLog?: ReviewResolutionLog;
+    applyReviewLog?: boolean;
+}
+export interface HeuristicTermCandidate {
+    canonicalTerm: string;
+    aliases: string[];
+    count: number;
+    evidence: GlossaryTerm["evidence"];
+    fragmentIds: string[];
+}
+export interface HeuristicStatementCandidate {
+    statement: string;
+    fragment: Fragment;
+    confidence: number;
+    unknowns: string[];
+    sourceKind: "sentence" | "bullet";
+}
+export interface StatementSegment {
+    text: string;
+    sourceKind: "sentence" | "bullet";
+}

package/dist/src/core/document-extractor-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/document-extractors-review.d.ts

@@ -0,0 +1,4 @@
+import type { GlossaryTerm, InvariantCandidate, ReviewResolutionLog, RuleCandidate } from "./contracts.js";
+export declare function applyGlossaryReview(items: GlossaryTerm[], applyReviewLog: boolean | undefined, reviewLog?: ReviewResolutionLog): GlossaryTerm[];
+export declare function applyRulesReview(items: RuleCandidate[], applyReviewLog: boolean | undefined, reviewLog?: ReviewResolutionLog): RuleCandidate[];
+export declare function applyInvariantsReview(items: InvariantCandidate[], applyReviewLog: boolean | undefined, reviewLog?: ReviewResolutionLog): InvariantCandidate[];

package/dist/src/core/document-extractors-review.js

@@ -0,0 +1,10 @@
+import { applyReviewOverrides } from "./review.js";
+export function applyGlossaryReview(items, applyReviewLog, reviewLog) {
+    return applyReviewLog ? applyReviewOverrides(items, reviewLog, "termId") : items;
+}
+export function applyRulesReview(items, applyReviewLog, reviewLog) {
+    return applyReviewLog ? applyReviewOverrides(items, reviewLog, "ruleId") : items;
+}
+export function applyInvariantsReview(items, applyReviewLog, reviewLog) {
+    return applyReviewLog ? applyReviewOverrides(items, reviewLog, "invariantId") : items;
+}

package/dist/src/core/document-extractors-runner.d.ts

@@ -0,0 +1,15 @@
+import type { ExtractionKind, Fragment } from "./contracts.js";
+import type { ExtractionOptions } from "./document-extractor-types.js";
+export declare function extractWithProvider<T>(kind: ExtractionKind, fragments: Fragment[], options: ExtractionOptions, normalize: (rawItems: Record<string, unknown>[], fragments: Fragment[]) => T[]): Promise<{
+    fragments: Fragment[];
+    items: T[];
+    confidence: number;
+    unknowns: string[];
+    diagnostics: string[];
+    provider: import("./contracts.js").ExtractionProviderName;
+}>;
+export declare function normalizeExtractionOptions(options: ExtractionOptions): Promise<{
+    metadata: import("./contracts.js").ExtractionMetadata;
+    fragments: Fragment[];
+    fallback: "heuristic" | "none";
+}>;

package/dist/src/core/document-extractors-runner.js

@@ -0,0 +1,31 @@
+import { normalizeDocuments } from "./artifacts.js";
+import { buildMetadata } from "./document-extractor-shared.js";
+import { runCliExtraction } from "./providers.js";
+export async function extractWithProvider(kind, fragments, options, normalize) {
+    if (!options.provider) {
+        throw new Error("CLI extractor requires `provider`");
+    }
+    const providerResult = await runCliExtraction({
+        cwd: options.cwd,
+        provider: options.provider,
+        kind,
+        promptProfile: options.promptProfile ?? "default",
+        fragments,
+        ...(options.providerCommand ? { providerCommand: options.providerCommand } : {}),
+    });
+    return {
+        fragments,
+        items: normalize(providerResult.items, fragments),
+        confidence: providerResult.confidence,
+        unknowns: providerResult.unknowns,
+        diagnostics: providerResult.diagnostics,
+        provider: providerResult.provider,
+    };
+}
+export async function normalizeExtractionOptions(options) {
+    return {
+        metadata: buildMetadata(options),
+        fragments: await normalizeDocuments(options.root),
+        fallback: options.fallback ?? "heuristic",
+    };
+}

package/dist/src/core/document-extractors.d.ts

@@ -0,0 +1,24 @@
+export declare function extractGlossary(options: import("./document-extractor-types.js").ExtractionOptions): Promise<{
+    fragments: import("./contracts.js").Fragment[];
+    terms: import("./contracts.js").GlossaryTerm[];
+    metadata: import("./contracts.js").ExtractionMetadata;
+    confidence: number;
+    unknowns: string[];
+    diagnostics: string[];
+}>;
+export declare function extractRules(options: import("./document-extractor-types.js").ExtractionOptions): Promise<{
+    rules: import("./contracts.js").RuleCandidate[];
+    fragments: import("./contracts.js").Fragment[];
+    metadata: import("./contracts.js").ExtractionMetadata;
+    confidence: number;
+    unknowns: string[];
+    diagnostics: string[];
+}>;
+export declare function extractInvariants(options: import("./document-extractor-types.js").ExtractionOptions): Promise<{
+    invariants: import("./contracts.js").InvariantCandidate[];
+    fragments: import("./contracts.js").Fragment[];
+    metadata: import("./contracts.js").ExtractionMetadata;
+    confidence: number;
+    unknowns: string[];
+    diagnostics: string[];
+}>;

package/dist/src/core/document-extractors.js

@@ -0,0 +1,130 @@
+import { normalizeGlossaryFromCli, normalizeGlossaryFromHeuristic } from "./document-extractor-glossary.js";
+import { normalizeInvariantsFromCli, normalizeInvariantsFromHeuristic, normalizeRulesFromCli, normalizeRulesFromHeuristic, } from "./document-extractor-statements.js";
+import { applyGlossaryReview, applyInvariantsReview, applyRulesReview } from "./document-extractors-review.js";
+import { extractWithProvider, normalizeExtractionOptions } from "./document-extractors-runner.js";
+export async function extractGlossary(options) {
+    const { metadata, fragments, fallback } = await normalizeExtractionOptions(options);
+    if (metadata.extractor === "cli") {
+        try {
+            const extracted = await extractWithProvider("glossary", fragments, options, normalizeGlossaryFromCli);
+            return {
+                fragments: extracted.fragments,
+                terms: applyGlossaryReview(extracted.items, options.applyReviewLog, options.reviewLog),
+                metadata: {
+                    ...metadata,
+                    provider: extracted.provider,
+                },
+                confidence: extracted.confidence,
+                unknowns: extracted.unknowns,
+                diagnostics: extracted.diagnostics,
+            };
+        }
+        catch (error) {
+            if (fallback === "none") {
+                throw error;
+            }
+            const terms = normalizeGlossaryFromHeuristic(fragments);
+            return {
+                fragments,
+                terms: applyGlossaryReview(terms, options.applyReviewLog, options.reviewLog),
+                metadata,
+                confidence: 0.55,
+                unknowns: ["The CLI extractor failed, so a heuristic fallback was used."],
+                diagnostics: [error instanceof Error ? error.message : "CLI extractor failed"],
+            };
+        }
+    }
+    const terms = normalizeGlossaryFromHeuristic(fragments);
+    return {
+        fragments,
+        terms: applyGlossaryReview(terms, options.applyReviewLog, options.reviewLog),
+        metadata,
+        confidence: 0.7,
+        unknowns: [],
+        diagnostics: [],
+    };
+}
+export async function extractRules(options) {
+    const { metadata, fragments, fallback } = await normalizeExtractionOptions(options);
+    if (metadata.extractor === "cli") {
+        try {
+            const extracted = await extractWithProvider("rules", fragments, options, normalizeRulesFromCli);
+            return {
+                rules: applyRulesReview(extracted.items, options.applyReviewLog, options.reviewLog),
+                fragments: extracted.fragments,
+                metadata: {
+                    ...metadata,
+                    provider: extracted.provider,
+                },
+                confidence: extracted.confidence,
+                unknowns: extracted.unknowns,
+                diagnostics: extracted.diagnostics,
+            };
+        }
+        catch (error) {
+            if (fallback === "none") {
+                throw error;
+            }
+            const rules = normalizeRulesFromHeuristic(fragments);
+            return {
+                rules: applyRulesReview(rules, options.applyReviewLog, options.reviewLog),
+                fragments,
+                metadata,
+                confidence: 0.55,
+                unknowns: ["The CLI extractor failed, so a heuristic fallback was used."],
+                diagnostics: [error instanceof Error ? error.message : "CLI extractor failed"],
+            };
+        }
+    }
+    const rules = normalizeRulesFromHeuristic(fragments);
+    return {
+        rules: applyRulesReview(rules, options.applyReviewLog, options.reviewLog),
+        fragments,
+        metadata,
+        confidence: 0.7,
+        unknowns: [],
+        diagnostics: [],
+    };
+}
+export async function extractInvariants(options) {
+    const { metadata, fragments, fallback } = await normalizeExtractionOptions(options);
+    if (metadata.extractor === "cli") {
+        try {
+            const extracted = await extractWithProvider("invariants", fragments, options, normalizeInvariantsFromCli);
+            return {
+                invariants: applyInvariantsReview(extracted.items, options.applyReviewLog, options.reviewLog),
+                fragments: extracted.fragments,
+                metadata: {
+                    ...metadata,
+                    provider: extracted.provider,
+                },
+                confidence: extracted.confidence,
+                unknowns: extracted.unknowns,
+                diagnostics: extracted.diagnostics,
+            };
+        }
+        catch (error) {
+            if (fallback === "none") {
+                throw error;
+            }
+            const invariants = normalizeInvariantsFromHeuristic(fragments);
+            return {
+                invariants: applyInvariantsReview(invariants, options.applyReviewLog, options.reviewLog),
+                fragments,
+                metadata,
+                confidence: 0.55,
+                unknowns: ["The CLI extractor failed, so a heuristic fallback was used."],
+                diagnostics: [error instanceof Error ? error.message : "CLI extractor failed"],
+            };
+        }
+    }
+    const invariants = normalizeInvariantsFromHeuristic(fragments);
+    return {
+        invariants: applyInvariantsReview(invariants, options.applyReviewLog, options.reviewLog),
+        fragments,
+        metadata,
+        confidence: 0.68,
+        unknowns: [],
+        diagnostics: [],
+    };
+}

package/dist/src/core/domain-design-matching.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeDomainDesignLabel(value: string): string;
+export declare function scoreTextAgainstLabel(text: string, label: string): number;

package/dist/src/core/domain-design-matching.js

@@ -0,0 +1,85 @@
+function splitCamelCase(value) {
+    return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2");
+}
+function collapseWhitespace(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function deriveTokenForms(token) {
+    const forms = new Set([token]);
+    if (token.endsWith("ies") && token.length > 4) {
+        forms.add(`${token.slice(0, -3)}y`);
+    }
+    if (token.endsWith("es") && token.length > 4) {
+        forms.add(token.slice(0, -2));
+    }
+    if (token.endsWith("s") && token.length > 3) {
+        forms.add(token.slice(0, -1));
+    }
+    if (token.endsWith("ing") && token.length > 5) {
+        forms.add(token.slice(0, -3));
+    }
+    if (token.endsWith("ed") && token.length > 4) {
+        forms.add(token.slice(0, -2));
+    }
+    if (token.endsWith("ship") && token.length > 7) {
+        forms.add(token.slice(0, -4));
+    }
+    if (token.endsWith("ment") && token.length > 7) {
+        forms.add(token.slice(0, -4));
+    }
+    return Array.from(forms);
+}
+export function normalizeDomainDesignLabel(value) {
+    return collapseWhitespace(splitCamelCase(value)
+        .normalize("NFKC")
+        .replace(/[_/.-]+/g, " ")
+        .replace(/[^\p{L}\p{N}\s]+/gu, " ")
+        .toLowerCase());
+}
+function tokenizeDomainDesignLabel(value) {
+    return normalizeDomainDesignLabel(value)
+        .split(" ")
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+}
+function toComparableTokenForms(value) {
+    return new Set(tokenizeDomainDesignLabel(value).flatMap((token) => deriveTokenForms(token)));
+}
+function textContainsNormalizedLabel(text, label) {
+    const normalizedText = normalizeDomainDesignLabel(text);
+    const normalizedLabel = normalizeDomainDesignLabel(label);
+    if (normalizedText.length === 0 || normalizedLabel.length === 0) {
+        return false;
+    }
+    return ` ${normalizedText} `.includes(` ${normalizedLabel} `);
+}
+function countMatchingTokens(source, label) {
+    const sourceForms = toComparableTokenForms(source);
+    const labelTokens = tokenizeDomainDesignLabel(label).filter((token) => token.length >= 3);
+    if (labelTokens.length === 0) {
+        return { matched: 0, total: 0 };
+    }
+    let matched = 0;
+    for (const token of labelTokens) {
+        if (deriveTokenForms(token).some((form) => sourceForms.has(form))) {
+            matched += 1;
+        }
+    }
+    return { matched, total: labelTokens.length };
+}
+export function scoreTextAgainstLabel(text, label) {
+    if (textContainsNormalizedLabel(text, label)) {
+        return 3;
+    }
+    const { matched, total } = countMatchingTokens(text, label);
+    if (total === 0 || matched === 0) {
+        return 0;
+    }
+    if (matched === total) {
+        return 2;
+    }
+    if (total >= 2 && matched / total >= 0.5) {
+        return 1;
+    }
+    return 0;
+}

package/dist/src/core/domain-design-scoring-context.d.ts

@@ -0,0 +1,25 @@
+import type { CodebaseAnalysis, ExtractionBackend, ExtractionProviderName, ReviewResolutionLog } from "./contracts.js";
+import { extractGlossary, extractInvariants, extractRules } from "./document-extractors.js";
+import type { ProgressReporter } from "./progress.js";
+import { buildTermTraceLinks } from "./trace.js";
+export interface DomainDesignDocsLoaders {
+    getGlossaryResult: () => Promise<Awaited<ReturnType<typeof extractGlossary>>>;
+    getRulesResult: () => Promise<Awaited<ReturnType<typeof extractRules>>>;
+    getInvariantsResult: () => Promise<Awaited<ReturnType<typeof extractInvariants>>>;
+    getTermTraceLinks: () => Promise<Awaited<ReturnType<typeof buildTermTraceLinks>>>;
+}
+export declare function createDomainDesignDocsLoaders(options: {
+    repoPath: string;
+    docsRoot: string | undefined;
+    reportProgress?: ProgressReporter;
+    extraction: {
+        extractor: ExtractionBackend;
+        provider?: ExtractionProviderName;
+        providerCommand?: string;
+        promptProfile?: string;
+        fallback?: "heuristic" | "none";
+        reviewLog?: ReviewResolutionLog;
+        applyReviewLog?: boolean;
+    } | undefined;
+    codebase: CodebaseAnalysis;
+}): DomainDesignDocsLoaders | null;

package/dist/src/core/domain-design-scoring-context.js

@@ -0,0 +1,66 @@
+import { extractGlossary, extractInvariants, extractRules } from "./document-extractors.js";
+import { buildTermTraceLinks } from "./trace.js";
+export function createDomainDesignDocsLoaders(options) {
+    const docsRoot = options.docsRoot;
+    if (!docsRoot) {
+        return null;
+    }
+    const docsExtractionOptions = {
+        root: docsRoot,
+        cwd: options.repoPath,
+        extractor: options.extraction?.extractor ?? "heuristic",
+        ...(options.extraction?.provider ? { provider: options.extraction.provider } : {}),
+        ...(options.extraction?.providerCommand ? { providerCommand: options.extraction.providerCommand } : {}),
+        promptProfile: options.extraction?.promptProfile ?? "default",
+        fallback: options.extraction?.fallback ?? "heuristic",
+        ...(options.extraction?.reviewLog ? { reviewLog: options.extraction.reviewLog } : {}),
+        applyReviewLog: options.extraction?.applyReviewLog ?? false,
+    };
+    let glossaryResultCache;
+    let rulesResultCache;
+    let invariantsResultCache;
+    let termTraceLinksCache;
+    const getGlossaryResult = async () => {
+        if (!glossaryResultCache) {
+            glossaryResultCache = await extractGlossary(docsExtractionOptions);
+        }
+        return glossaryResultCache;
+    };
+    const getRulesResult = async () => {
+        if (!rulesResultCache) {
+            rulesResultCache = await extractRules(docsExtractionOptions);
+        }
+        return rulesResultCache;
+    };
+    const getInvariantsResult = async () => {
+        if (!invariantsResultCache) {
+            invariantsResultCache = await extractInvariants(docsExtractionOptions);
+        }
+        return invariantsResultCache;
+    };
+    const getTermTraceLinks = async () => {
+        if (!termTraceLinksCache) {
+            const glossary = await getGlossaryResult();
+            termTraceLinksCache = await buildTermTraceLinks({
+                docsRoot,
+                repoRoot: options.repoPath,
+                terms: glossary.terms,
+                codeFiles: options.codebase.scorableSourceFiles,
+                onProgress: (update) => {
+                    options.reportProgress?.({
+                        phase: "docs",
+                        message: update.message,
+                        ...(update.elapsedMs !== undefined ? { elapsedMs: update.elapsedMs } : {}),
+                    });
+                },
+            });
+        }
+        return termTraceLinksCache;
+    };
+    return {
+        getGlossaryResult,
+        getRulesResult,
+        getInvariantsResult,
+        getTermTraceLinks,
+    };
+}

package/dist/src/core/domain-design-scoring-core-docs.d.ts

@@ -0,0 +1,5 @@
+export declare function buildDomainDocsMetricFormulas(policy: {
+    metrics: Record<string, {
+        formula: string;
+    } | undefined>;
+}): Partial<Record<"DRF" | "ULI" | "BFS" | "AFS", string>>;

package/dist/src/core/domain-design-scoring-core-docs.js

@@ -0,0 +1,8 @@
+export function buildDomainDocsMetricFormulas(policy) {
+    return {
+        ...(policy.metrics.DRF ? { DRF: policy.metrics.DRF.formula } : {}),
+        ...(policy.metrics.ULI ? { ULI: policy.metrics.ULI.formula } : {}),
+        ...(policy.metrics.BFS ? { BFS: policy.metrics.BFS.formula } : {}),
+        ...(policy.metrics.AFS ? { AFS: policy.metrics.AFS.formula } : {}),
+    };
+}

package/dist/src/core/domain-design-scoring-core.d.ts

@@ -0,0 +1,24 @@
+import type { CommandResponse, DomainDesignScoreResult, DomainDesignShadowRolloutGateEvaluation, DomainModel, ExtractionBackend, ExtractionProviderName, PolicyConfig, ReviewResolutionLog } from "./contracts.js";
+export declare function computeDomainDesignScores(options: {
+    repoPath: string;
+    model: DomainModel;
+    policyConfig: PolicyConfig;
+    profileName: string;
+    progressReporter?: (update: {
+        phase: string;
+        message: string;
+    }) => void;
+    shadowPersistence?: boolean;
+    pilotPersistenceCategory?: string;
+    pilotGateEvaluation?: DomainDesignShadowRolloutGateEvaluation;
+    docsRoot?: string;
+    extraction?: {
+        extractor: ExtractionBackend;
+        provider?: ExtractionProviderName;
+        providerCommand?: string;
+        promptProfile?: string;
+        fallback?: "heuristic" | "none";
+        reviewLog?: ReviewResolutionLog;
+        applyReviewLog?: boolean;
+    };
+}): Promise<CommandResponse<DomainDesignScoreResult>>;