context-probe 0.1.0

package/dist/src/core/io.js

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { minimatch } from "minimatch";
+import YAML from "yaml";
+const DOCUMENT_EXTENSIONS = new Set([".md", ".adoc", ".txt"]);
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs", ".dart"]);
+const DEFAULT_IGNORES = [
+    "node_modules",
+    "node_modules/**",
+    "**/node_modules",
+    "**/node_modules/**",
+    "dist",
+    "dist/**",
+    "**/dist",
+    "**/dist/**",
+    ".git",
+    ".git/**",
+    "**/.git",
+    "**/.git/**",
+];
+export function toPosixPath(input) {
+    return input.split(path.sep).join("/");
+}
+export function relativePath(root, absolutePath) {
+    return toPosixPath(path.relative(root, absolutePath));
+}
+export function hashText(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+export function isDocumentFile(filePath) {
+    return DOCUMENT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+export function isSourceFile(filePath) {
+    return SOURCE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+export function matchGlobs(filePath, globs) {
+    if (!globs || globs.length === 0) {
+        return false;
+    }
+    return globs.some((pattern) => minimatch(filePath, pattern, { dot: true }));
+}
+export async function listFiles(root) {
+    const results = [];
+    async function visit(directory) {
+        const entries = await fs.readdir(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            const absolutePath = path.join(directory, entry.name);
+            const relative = relativePath(root, absolutePath);
+            if (DEFAULT_IGNORES.some((pattern) => minimatch(relative, pattern, { dot: true }))) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await visit(absolutePath);
+                continue;
+            }
+            if (entry.isFile()) {
+                results.push(absolutePath);
+                continue;
+            }
+            if (entry.isSymbolicLink()) {
+                try {
+                    const stats = await fs.stat(absolutePath);
+                    if (stats.isFile()) {
+                        results.push(absolutePath);
+                    }
+                }
+                catch {
+                    // Ignore broken or inaccessible symlinks during repository scans.
+                }
+            }
+        }
+    }
+    await visit(root);
+    return results.sort();
+}
+export async function readText(filePath) {
+    return fs.readFile(filePath, "utf8");
+}
+export async function readDataFile(filePath) {
+    const content = await readText(filePath);
+    if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+        return YAML.parse(content);
+    }
+    return JSON.parse(content);
+}

package/dist/src/core/measurement-metadata.d.ts

@@ -0,0 +1,13 @@
+import type { CommandResponse, MeasurementQualitySummary, MetricScore, ReviewItem, ReviewItemKind, RuntimeSummary } from "./contracts.js";
+export declare function isApproximationNote(entry: string): boolean;
+export declare function isMissingInputNote(entry: string): boolean;
+export declare function buildMeasurementQualitySummary(input: {
+    metrics: MetricScore[];
+    unknowns: string[];
+    confidence: number;
+}): MeasurementQualitySummary;
+export declare function maybeBuildMeasurementQualitySummary(result: unknown, unknowns: string[], confidence: number): MeasurementQualitySummary | undefined;
+export declare function mergeRuntimeSummary(base: RuntimeSummary | undefined, additions: Partial<RuntimeSummary>): RuntimeSummary;
+export declare function classifyReviewItemKind(summary: string, reason: string): ReviewItemKind;
+export declare function sortReviewItems(items: ReviewItem[]): ReviewItem[];
+export declare function buildSuggestedNextEvidence(response: CommandResponse<unknown>): string[];

package/dist/src/core/measurement-metadata.js

@@ -0,0 +1,142 @@
+const APPROXIMATION_PATTERN = /(proxy|partial|bridge|neutral|unobserved|approx)/iu;
+const MISSING_INPUT_PATTERN = /\b(no |missing|not provided|did not complete|cannot be approximated|cannot be mapped|too few)\b/iu;
+const HISTORY_HOTSPOT_PATTERN = /\b(cross-boundary|co-change|history hotspot|wide review|locality)\b/iu;
+function dedupe(values) {
+    return Array.from(new Set(values));
+}
+export function isApproximationNote(entry) {
+    return APPROXIMATION_PATTERN.test(entry);
+}
+export function isMissingInputNote(entry) {
+    return MISSING_INPUT_PATTERN.test(entry);
+}
+function isHistoryHotspotNote(entry) {
+    return HISTORY_HOTSPOT_PATTERN.test(entry);
+}
+function inferDecisionRisk(input) {
+    const { confidence, unknownsCount, proxyRate } = input;
+    if (confidence < 0.65 || unknownsCount >= 4 || proxyRate >= 0.4) {
+        return "high";
+    }
+    if (confidence < 0.8 || unknownsCount > 0 || proxyRate > 0) {
+        return "medium";
+    }
+    return "low";
+}
+export function buildMeasurementQualitySummary(input) {
+    const metricUnknownCounts = Object.fromEntries(input.metrics.map((metric) => [metric.metricId, metric.unknowns.length]));
+    const proxyMetrics = dedupe(input.metrics.filter((metric) => metric.unknowns.some(isApproximationNote)).map((metric) => metric.metricId));
+    const approximationNotes = dedupe([
+        ...input.unknowns.filter(isApproximationNote),
+        ...input.metrics.flatMap((metric) => metric.unknowns.filter(isApproximationNote)),
+    ]);
+    const proxyRate = input.metrics.length === 0 ? 0 : proxyMetrics.length / input.metrics.length;
+    const unknownsCount = input.unknowns.length + input.metrics.reduce((sum, metric) => sum + metric.unknowns.length, 0);
+    return {
+        unknownsCount,
+        metricUnknownCounts,
+        proxyMetrics,
+        proxyRate,
+        approximationNotes,
+        decisionRisk: inferDecisionRisk({
+            confidence: input.confidence,
+            unknownsCount,
+            proxyRate,
+        }),
+    };
+}
+export function maybeBuildMeasurementQualitySummary(result, unknowns, confidence) {
+    if (typeof result !== "object" || result === null) {
+        return undefined;
+    }
+    const metrics = result.metrics;
+    if (!Array.isArray(metrics)) {
+        return undefined;
+    }
+    return buildMeasurementQualitySummary({
+        metrics: metrics,
+        unknowns,
+        confidence,
+    });
+}
+export function mergeRuntimeSummary(base, additions) {
+    const stages = {
+        ...(base?.stages ?? {}),
+        ...(additions.stages ?? {}),
+    };
+    const totalMs = additions.totalMs ?? base?.totalMs ?? Object.values(stages).reduce((sum, value) => sum + (value ?? 0), 0);
+    return {
+        totalMs,
+        stages,
+    };
+}
+export function classifyReviewItemKind(summary, reason) {
+    if (reason === "low_confidence") {
+        return "low_confidence";
+    }
+    if (reason === "collision") {
+        return "collision";
+    }
+    if (isApproximationNote(summary)) {
+        return "proxy";
+    }
+    if (isMissingInputNote(summary)) {
+        return "missing_input";
+    }
+    if (isHistoryHotspotNote(summary)) {
+        return "history_hotspot";
+    }
+    return "unknown";
+}
+function reviewItemPriority(kind) {
+    switch (kind) {
+        case "missing_input":
+            return 0;
+        case "proxy":
+            return 1;
+        case "low_confidence":
+            return 2;
+        case "collision":
+            return 3;
+        case "history_hotspot":
+            return 4;
+        default:
+            return 5;
+    }
+}
+export function sortReviewItems(items) {
+    return [...items].sort((left, right) => {
+        const leftKind = left.kind ?? classifyReviewItemKind(left.summary, left.reason);
+        const rightKind = right.kind ?? classifyReviewItemKind(right.summary, right.reason);
+        const byKind = reviewItemPriority(leftKind) - reviewItemPriority(rightKind);
+        if (byKind !== 0) {
+            return byKind;
+        }
+        const byConfidence = left.confidence - right.confidence;
+        if (byConfidence !== 0) {
+            return byConfidence;
+        }
+        return left.summary.localeCompare(right.summary);
+    });
+}
+export function buildSuggestedNextEvidence(response) {
+    const suggestions = [];
+    const measurementQuality = response.meta?.measurementQuality;
+    if (measurementQuality?.proxyMetrics.includes("QSF")) {
+        suggestions.push("Add or tighten scenario observations for the highest-priority architecture scenarios.");
+    }
+    if (measurementQuality?.proxyMetrics.includes("OAS")) {
+        suggestions.push("Add telemetry or pattern-runtime observations so OAS stops relying on proxy signals.");
+    }
+    if (response.unknowns.some(isMissingInputNote)) {
+        suggestions.push("Resolve the highest-impact missing input or thin-evidence unknowns first.");
+    }
+    if (typeof response.result === "object" &&
+        response.result !== null &&
+        "domainId" in response.result &&
+        response.result.domainId === "domain_design" &&
+        response.unknowns.some((entry) => entry.includes("aggregate"))) {
+        suggestions.push("Add explicit aggregates or invariant ownership so AFS stops relying on context proxies.");
+    }
+    return dedupe(suggestions).slice(0, 5);
+}

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

@@ -0,0 +1,3 @@
+import type { ArchitectureConstraints, DomainModel } from "./contracts.js";
+export declare function loadDomainModel(modelPath: string): Promise<DomainModel>;
+export declare function loadArchitectureConstraints(constraintsPath: string): Promise<ArchitectureConstraints>;

package/dist/src/core/model.js

@@ -0,0 +1,33 @@
+import { readDataFile } from "./io.js";
+export async function loadDomainModel(modelPath) {
+    const model = await readDataFile(modelPath);
+    if (!Array.isArray(model.contexts) || model.contexts.length === 0) {
+        throw new Error("Domain model must contain at least one context");
+    }
+    if (model.aggregates !== undefined) {
+        if (!Array.isArray(model.aggregates)) {
+            throw new Error("Domain model aggregates must be an array when provided");
+        }
+        const contextNames = new Set(model.contexts.map((context) => context.name));
+        for (const aggregate of model.aggregates) {
+            if (typeof aggregate.name !== "string" || aggregate.name.trim().length === 0) {
+                throw new Error("Domain model aggregates must declare a non-empty name");
+            }
+            if (typeof aggregate.context !== "string" || !contextNames.has(aggregate.context)) {
+                throw new Error(`Aggregate "${aggregate.name}" must reference an existing context`);
+            }
+            if (aggregate.aliases !== undefined &&
+                (!Array.isArray(aggregate.aliases) || aggregate.aliases.some((alias) => typeof alias !== "string"))) {
+                throw new Error(`Aggregate "${aggregate.name}" aliases must be an array of strings`);
+            }
+        }
+    }
+    return model;
+}
+export async function loadArchitectureConstraints(constraintsPath) {
+    const constraints = await readDataFile(constraintsPath);
+    if (!Array.isArray(constraints.layers) || constraints.layers.length === 0) {
+        throw new Error("Architecture constraints must contain at least one layer");
+    }
+    return constraints;
+}

package/dist/src/core/policy-defaults-architecture.d.ts

@@ -0,0 +1,2 @@
+import type { DomainPolicy } from "./contracts.js";
+export declare function createArchitectureDesignPolicy(apsiFormula: string): DomainPolicy;

package/dist/src/core/policy-defaults-architecture.js

@@ -0,0 +1,75 @@
+export function createArchitectureDesignPolicy(apsiFormula) {
+    return {
+        metrics: {
+            QSF: {
+                formula: "QSF",
+                thresholds: {
+                    warn: 0.72,
+                    fail: 0.58,
+                },
+            },
+            DDS: {
+                formula: "0.60*(1-IDR) + 0.25*LRC + 0.15*APM",
+                thresholds: {
+                    warn: 0.72,
+                    fail: 0.58,
+                },
+            },
+            BPS: {
+                formula: "0.45*(1-ALR) + 0.30*FCC + 0.25*(1-SICR)",
+                thresholds: {
+                    warn: 0.72,
+                    fail: 0.58,
+                },
+            },
+            IPS: {
+                formula: "0.50*CBC + 0.25*(1-BCR) + 0.25*SLA",
+                thresholds: {
+                    warn: 0.72,
+                    fail: 0.58,
+                },
+            },
+            TIS: {
+                formula: "0.40*FI + 0.30*RC + 0.30*(1-SDR)",
+                thresholds: {
+                    warn: 0.72,
+                    fail: 0.58,
+                },
+            },
+            OAS: {
+                formula: "0.50*CommonOps + 0.50*PatternRuntime",
+                thresholds: {
+                    warn: 0.72,
+                    fail: 0.58,
+                },
+            },
+            CTI: {
+                formula: "0.20*DeployablesPerTeam + 0.15*PipelinesPerDeployable + 0.15*ContractsOrSchemasPerService + 0.10*DatastoresPerServiceGroup + 0.15*OnCallSurface + 0.10*SyncDepthOverhead + 0.15*RunCostPerBusinessTransaction",
+            },
+            AELS: {
+                formula: "0.40*(1-CrossBoundaryCoChange) + 0.30*(1-WeightedPropagationCost) + 0.30*(1-WeightedClusteringCost)",
+                thresholds: {
+                    warn: 0.68,
+                    fail: 0.5,
+                },
+            },
+            EES: {
+                formula: "0.60*Delivery + 0.40*Locality",
+                thresholds: {
+                    warn: 0.68,
+                    fail: 0.5,
+                },
+            },
+            APSI: {
+                formula: apsiFormula,
+                thresholds: {
+                    warn: 0.68,
+                    fail: 0.52,
+                },
+            },
+        },
+        review: {
+            require_human_if: ["confidence < 0.80", "breaking_change_detected == true"],
+        },
+    };
+}

package/dist/src/core/policy-defaults-domain.d.ts

@@ -0,0 +1,2 @@
+import type { DomainPolicy } from "./contracts.js";
+export declare function createDomainDesignPolicy(): DomainPolicy;

package/dist/src/core/policy-defaults-domain.js

@@ -0,0 +1,51 @@
+export function createDomainDesignPolicy() {
+    return {
+        metrics: {
+            DRF: {
+                formula: "0.30*SC + 0.30*RC + 0.20*(1-IV) + 0.20*RA",
+                thresholds: {
+                    warn: 0.7,
+                    fail: 0.55,
+                },
+            },
+            ULI: {
+                formula: "0.30*GC + 0.20*(1-AE) + 0.25*(1-TC) + 0.25*TL",
+                thresholds: {
+                    warn: 0.7,
+                    fail: 0.55,
+                },
+            },
+            BFS: {
+                formula: "0.50*A + 0.50*R",
+                thresholds: {
+                    warn: 0.7,
+                    fail: 0.55,
+                },
+            },
+            AFS: {
+                formula: "0.60*SIC + 0.40*(1-XTC)",
+                thresholds: {
+                    warn: 0.7,
+                    fail: 0.55,
+                },
+            },
+            MCCS: {
+                formula: "0.50*MRP + 0.25*(1-BLR) + 0.25*CLA",
+                thresholds: {
+                    warn: 0.7,
+                    fail: 0.55,
+                },
+            },
+            ELS: {
+                formula: "0.40*CCL + 0.30*(1-FS) + 0.30*(1-SCR)",
+                thresholds: {
+                    warn: 0.68,
+                    fail: 0.5,
+                },
+            },
+        },
+        review: {
+            require_human_if: ["confidence < 0.75", "unknowns_count > 0"],
+        },
+    };
+}

package/dist/src/core/policy-defaults-profiles.d.ts

@@ -0,0 +1,2 @@
+import type { PolicyConfig } from "./contracts.js";
+export declare function buildDefaultPolicyProfiles(): PolicyConfig["profiles"];

package/dist/src/core/policy-defaults-profiles.js

@@ -0,0 +1,24 @@
+import { createArchitectureDesignPolicy } from "./policy-defaults-architecture.js";
+import { createDomainDesignPolicy } from "./policy-defaults-domain.js";
+import { CQRS_APSI_FORMULA, DEFAULT_APSI_FORMULA, EVENT_DRIVEN_APSI_FORMULA, LAYERED_APSI_FORMULA, SERVICE_BASED_APSI_FORMULA, } from "./policy-formulas.js";
+function createProfile(apsiFormula) {
+    return {
+        domains: {
+            domain_design: createDomainDesignPolicy(),
+            architecture_design: createArchitectureDesignPolicy(apsiFormula),
+        },
+        history_filters: {
+            ignore_commit_patterns: ["^chore: format", "^chore: bump dependencies"],
+            ignore_paths: ["package-lock.json", "pnpm-lock.yaml"],
+        },
+    };
+}
+export function buildDefaultPolicyProfiles() {
+    return {
+        default: createProfile(DEFAULT_APSI_FORMULA),
+        layered: createProfile(LAYERED_APSI_FORMULA),
+        service_based: createProfile(SERVICE_BASED_APSI_FORMULA),
+        cqrs: createProfile(CQRS_APSI_FORMULA),
+        event_driven: createProfile(EVENT_DRIVEN_APSI_FORMULA),
+    };
+}

package/dist/src/core/policy-defaults.d.ts

@@ -0,0 +1,2 @@
+import type { PolicyConfig } from "./contracts.js";
+export declare const DEFAULT_POLICY: PolicyConfig;

package/dist/src/core/policy-defaults.js

@@ -0,0 +1,4 @@
+import { buildDefaultPolicyProfiles } from "./policy-defaults-profiles.js";
+export const DEFAULT_POLICY = {
+    profiles: buildDefaultPolicyProfiles(),
+};

package/dist/src/core/policy-formulas.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_APSI_FORMULA = "0.30*QSF + 0.20*PCS + 0.20*OAS + 0.15*EES + 0.15*(1-CTI)";
+export declare const LAYERED_APSI_FORMULA = "0.35*QSF + 0.30*PCS + 0.15*OAS + 0.10*EES + 0.10*(1-CTI)";
+export declare const SERVICE_BASED_APSI_FORMULA = "0.20*QSF + 0.20*PCS + 0.15*OAS + 0.25*EES + 0.20*(1-CTI)";
+export declare const CQRS_APSI_FORMULA = "0.30*QSF + 0.15*PCS + 0.25*OAS + 0.10*EES + 0.20*(1-CTI)";
+export declare const EVENT_DRIVEN_APSI_FORMULA = "0.20*QSF + 0.15*PCS + 0.30*OAS + 0.10*EES + 0.25*(1-CTI)";

package/dist/src/core/policy-formulas.js

@@ -0,0 +1,5 @@
+export const DEFAULT_APSI_FORMULA = "0.30*QSF + 0.20*PCS + 0.20*OAS + 0.15*EES + 0.15*(1-CTI)";
+export const LAYERED_APSI_FORMULA = "0.35*QSF + 0.30*PCS + 0.15*OAS + 0.10*EES + 0.10*(1-CTI)";
+export const SERVICE_BASED_APSI_FORMULA = "0.20*QSF + 0.20*PCS + 0.15*OAS + 0.25*EES + 0.20*(1-CTI)";
+export const CQRS_APSI_FORMULA = "0.30*QSF + 0.15*PCS + 0.25*OAS + 0.10*EES + 0.20*(1-CTI)";
+export const EVENT_DRIVEN_APSI_FORMULA = "0.20*QSF + 0.15*PCS + 0.30*OAS + 0.10*EES + 0.25*(1-CTI)";

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

@@ -0,0 +1,4 @@
+import type { DomainPolicy, PolicyConfig } from "./contracts.js";
+export { DEFAULT_POLICY } from "./policy-defaults.js";
+export declare function loadPolicyConfig(policyPath?: string): Promise<PolicyConfig>;
+export declare function getDomainPolicy(policyConfig: PolicyConfig, profileName: string, domainId: string): DomainPolicy;

package/dist/src/core/policy.js

@@ -0,0 +1,20 @@
+import { readDataFile } from "./io.js";
+import { DEFAULT_POLICY } from "./policy-defaults.js";
+export { DEFAULT_POLICY } from "./policy-defaults.js";
+export async function loadPolicyConfig(policyPath) {
+    if (!policyPath) {
+        return DEFAULT_POLICY;
+    }
+    return readDataFile(policyPath);
+}
+export function getDomainPolicy(policyConfig, profileName, domainId) {
+    const profile = policyConfig.profiles[profileName];
+    if (!profile) {
+        throw new Error(`Unknown policy profile: ${profileName}`);
+    }
+    const domainPolicy = profile.domains[domainId];
+    if (!domainPolicy) {
+        throw new Error(`Unknown domain policy: ${domainId}`);
+    }
+    return domainPolicy;
+}

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

@@ -0,0 +1,8 @@
+import type { ProgressUpdate } from "./contracts.js";
+export type ProgressReporter = (update: ProgressUpdate) => void;
+export interface ProgressTracker {
+    progress: ProgressUpdate[];
+    reportProgress: ProgressReporter;
+    withProgress<T>(phase: string, message: string, task: () => Promise<T> | T): Promise<T>;
+}
+export declare function createProgressTracker(reporter?: ProgressReporter): ProgressTracker;

package/dist/src/core/progress.js

@@ -0,0 +1,40 @@
+function formatElapsedMs(elapsedMs) {
+    if (elapsedMs < 1000) {
+        return `${elapsedMs}ms`;
+    }
+    return `${Math.round(elapsedMs / 1000)}s`;
+}
+export function createProgressTracker(reporter) {
+    const progress = [];
+    const reportProgress = (update) => {
+        progress.push(update);
+        reporter?.(update);
+    };
+    return {
+        progress,
+        reportProgress,
+        async withProgress(phase, message, task) {
+            const startedAt = Date.now();
+            reportProgress({ phase, message });
+            try {
+                const result = await task();
+                const elapsedMs = Date.now() - startedAt;
+                reportProgress({
+                    phase,
+                    message: `${message} completed in ${formatElapsedMs(elapsedMs)}.`,
+                    elapsedMs,
+                });
+                return result;
+            }
+            catch (error) {
+                const elapsedMs = Date.now() - startedAt;
+                reportProgress({
+                    phase,
+                    message: `${message} failed after ${formatElapsedMs(elapsedMs)}.`,
+                    elapsedMs,
+                });
+                throw error;
+            }
+        },
+    };
+}

package/dist/src/core/providers-normalization.d.ts

@@ -0,0 +1,7 @@
+import type { RawProviderItem } from "./providers-types.js";
+export declare function normalizeProviderPayload(payload: unknown): {
+    items: RawProviderItem[];
+    confidence: number;
+    unknowns: string[];
+    diagnostics: string[];
+};

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

@@ -0,0 +1,27 @@
+export function normalizeProviderPayload(payload) {
+    if (Array.isArray(payload)) {
+        return {
+            items: payload.filter((value) => typeof value === "object" && value !== null),
+            confidence: 0.7,
+            unknowns: [],
+            diagnostics: [],
+        };
+    }
+    if (typeof payload === "object" && payload !== null) {
+        const record = payload;
+        const nested = record.result && typeof record.result === "object" ? record.result : record;
+        return {
+            items: Array.isArray(nested.items)
+                ? nested.items.filter((value) => typeof value === "object" && value !== null)
+                : [],
+            confidence: typeof nested.confidence === "number" ? nested.confidence : 0.7,
+            unknowns: Array.isArray(nested.unknowns)
+                ? nested.unknowns.filter((value) => typeof value === "string")
+                : [],
+            diagnostics: Array.isArray(nested.diagnostics)
+                ? nested.diagnostics.filter((value) => typeof value === "string")
+                : [],
+        };
+    }
+    throw new Error("Provider output was not a JSON object");
+}

package/dist/src/core/providers-prompt.d.ts

@@ -0,0 +1,4 @@
+import type { ExtractionKind, Fragment } from "./contracts.js";
+export declare function defaultProviderCommand(provider: "codex" | "claude"): string;
+export declare function buildPrompt(kind: ExtractionKind, promptProfile: string, fragments: Fragment[]): string;
+export declare function buildSchema(kind: ExtractionKind): Record<string, unknown>;

package/dist/src/core/providers-prompt.js

@@ -0,0 +1,63 @@
+export function defaultProviderCommand(provider) {
+    return provider === "codex" ? "codex" : "claude";
+}
+export function buildPrompt(kind, promptProfile, fragments) {
+    const instructions = {
+        glossary: "Extract canonical domain terms, aliases, collision risk, confidence, unknowns, and supporting fragmentIds.",
+        rules: "Extract business rules with type, statement, confidence, unknowns, relatedTerms, and supporting fragmentIds.",
+        invariants: "Extract invariants with type, statement, confidence, unknowns, relatedTerms, and supporting fragmentIds.",
+    };
+    const fragmentsBlock = fragments
+        .map((fragment) => `- fragmentId=${fragment.fragmentId} path=${fragment.path}\n${fragment.text}`)
+        .join("\n\n");
+    return [
+        "Return JSON only.",
+        instructions[kind],
+        `Prompt profile: ${promptProfile}`,
+        "Use only the provided fragments as evidence.",
+        "If uncertain, keep unknowns non-empty instead of guessing.",
+        "",
+        "Fragments:",
+        fragmentsBlock,
+    ].join("\n");
+}
+export function buildSchema(kind) {
+    const baseItem = kind === "glossary"
+        ? {
+            type: "object",
+            properties: {
+                canonicalTerm: { type: "string" },
+                aliases: { type: "array", items: { type: "string" } },
+                collision: { type: "boolean" },
+                confidence: { type: "number" },
+                unknowns: { type: "array", items: { type: "string" } },
+                fragmentIds: { type: "array", items: { type: "string" } },
+            },
+            required: ["canonicalTerm", "aliases", "collision", "confidence", "unknowns", "fragmentIds"],
+        }
+        : {
+            type: "object",
+            properties: {
+                type: { type: "string" },
+                statement: { type: "string" },
+                confidence: { type: "number" },
+                unknowns: { type: "array", items: { type: "string" } },
+                fragmentIds: { type: "array", items: { type: "string" } },
+                relatedTerms: { type: "array", items: { type: "string" } },
+            },
+            required: ["type", "statement", "confidence", "unknowns", "fragmentIds", "relatedTerms"],
+        };
+    return {
+        type: "object",
+        properties: {
+            items: {
+                type: "array",
+                items: baseItem,
+            },
+            confidence: { type: "number" },
+            unknowns: { type: "array", items: { type: "string" } },
+            diagnostics: { type: "array", items: { type: "string" } },
+        },
+        required: ["items", "confidence", "unknowns", "diagnostics"],
+    };
+}

package/dist/src/core/providers-runner.d.ts

@@ -0,0 +1,3 @@
+import type { CliExtractionOptions } from "./providers-types.js";
+export declare function runCodexCli(options: CliExtractionOptions, schemaPath: string, outputPath: string, prompt: string): Promise<string>;
+export declare function runClaudeCli(options: CliExtractionOptions, schema: Record<string, unknown>, prompt: string): Promise<string>;