context-probe 0.1.0

package/dist/src/core/boundary-fitness-evidence.js

@@ -0,0 +1,27 @@
+import { clamp01 } from "./boundary-fitness-shared.js";
+import { toEvidence } from "./response.js";
+export function buildBoundaryFitnessEvidence(input) {
+    const evidence = [];
+    for (const signal of input.localizedSignals.slice(0, 4)) {
+        evidence.push(toEvidence(`${signal.summary.slice(0, 120)} is localized to ${signal.contexts[0]}`, {
+            kind: signal.kind,
+            contexts: signal.contexts,
+            fragmentIds: signal.fragmentIds ?? [],
+        }, signal.linkedEntities, clamp01(signal.confidence)));
+    }
+    for (const signal of input.ambiguousSignals.slice(0, 4)) {
+        evidence.push(toEvidence(`${signal.summary.slice(0, 120)} spans ${signal.contexts.join(", ")}`, {
+            kind: signal.kind,
+            contexts: signal.contexts,
+            fragmentIds: signal.fragmentIds ?? [],
+        }, signal.linkedEntities, clamp01(Math.min(signal.confidence, 0.82))));
+    }
+    for (const fragment of input.separationFragments.slice(0, 4)) {
+        evidence.push(toEvidence(`${fragment.text.slice(0, 120)} confirms separation`, {
+            fragmentId: fragment.fragmentId,
+            path: fragment.path,
+            contexts: input.fragmentContextMentions.get(fragment.fragmentId) ?? [],
+        }, undefined, 0.84));
+    }
+    return evidence;
+}

package/dist/src/core/boundary-fitness-separation.d.ts

@@ -0,0 +1,13 @@
+export declare function computeCodeBoundaryStrength(input: {
+    applicableReferences: number;
+    adherence: number;
+    leakCount: number;
+    modelCoverageScore: number;
+}): number;
+export declare function computeSeparationScore(input: {
+    attractionSignalCount: number;
+    localizedSignalCount: number;
+    explicitSeparationScore: number;
+    codeBoundaryStrength: number;
+    modelCoverageScore: number;
+}): number;

package/dist/src/core/boundary-fitness-separation.js

@@ -0,0 +1,14 @@
+import { average, clamp01 } from "./boundary-fitness-shared.js";
+export function computeCodeBoundaryStrength(input) {
+    if (input.applicableReferences > 0) {
+        const leakRatio = input.leakCount / input.applicableReferences;
+        return clamp01((input.adherence + (1 - leakRatio)) / 2);
+    }
+    return clamp01(0.55 + input.modelCoverageScore * 0.25);
+}
+export function computeSeparationScore(input) {
+    const documentSeparationScore = input.attractionSignalCount === 0
+        ? 0.5
+        : clamp01(input.localizedSignalCount / Math.max(1, input.attractionSignalCount));
+    return clamp01(average([documentSeparationScore, input.explicitSeparationScore, input.codeBoundaryStrength, input.modelCoverageScore], 0.55));
+}

package/dist/src/core/boundary-fitness-shared.d.ts

@@ -0,0 +1,3 @@
+import { average, clamp01Finite as clamp01, unique } from "./shared-utils.js";
+export { average, clamp01, unique };
+export declare function hasSeparationSignal(text: string): boolean;

package/dist/src/core/boundary-fitness-shared.js

@@ -0,0 +1,17 @@
+import { average, clamp01Finite as clamp01, unique } from "./shared-utils.js";
+const SEPARATION_SIGNALS = [
+    /ownership/u,
+    /security/u,
+    /team境界/u,
+    /セキュリティ/u,
+    /分離/u,
+    /独立/u,
+    /別(?:責務|所有|境界)/u,
+    /\bseparate\b/i,
+    /\bseparation\b/i,
+    /\boundary\b/i,
+];
+export { average, clamp01, unique };
+export function hasSeparationSignal(text) {
+    return SEPARATION_SIGNALS.some((pattern) => pattern.test(text));
+}

package/dist/src/core/boundary-fitness-signals.d.ts

@@ -0,0 +1,21 @@
+import type { DomainModel, Fragment, GlossaryTerm, InvariantCandidate, RuleCandidate } from "./contracts.js";
+import type { ProgressReporter } from "./progress.js";
+export interface BoundarySignal {
+    kind: "term" | "rule" | "invariant" | "use_case";
+    summary: string;
+    contexts: string[];
+    confidence: number;
+    fragmentIds?: string[];
+    linkedEntities?: string[];
+}
+export declare function localizationScore(contexts: string[]): number;
+export declare function buildAttractionSignals(input: {
+    terms: GlossaryTerm[];
+    termContexts: Map<string, string[]>;
+    rules: RuleCandidate[];
+    invariants: InvariantCandidate[];
+    fragments: Fragment[];
+    fragmentContextMentions: Map<string, string[]>;
+    model: DomainModel;
+    reportProgress?: ProgressReporter;
+}): BoundarySignal[];

package/dist/src/core/boundary-fitness-signals.js

@@ -0,0 +1,104 @@
+import { collectStatementContexts } from "./boundary-fitness-contexts.js";
+const USE_CASE_SIGNALS = [
+    /ユースケース/u,
+    /シナリオ/u,
+    /期待(?:される)?結果/u,
+    /受け入れ基準/u,
+    /利用者/u,
+    /\buse case\b/i,
+    /\bscenario\b/i,
+    /\bacceptance\b/i,
+];
+export function localizationScore(contexts) {
+    if (contexts.length === 0) {
+        return 0;
+    }
+    return 1 / contexts.length;
+}
+function hasUseCaseSignal(text) {
+    return USE_CASE_SIGNALS.some((pattern) => pattern.test(text));
+}
+export function buildAttractionSignals(input) {
+    input.reportProgress?.({
+        phase: "docs",
+        message: "BFS: collecting localized glossary term signals.",
+    });
+    const mappedTerms = input.terms
+        .map((term) => ({
+        term,
+        contexts: input.termContexts.get(term.termId) ?? [],
+    }))
+        .filter((entry) => entry.contexts.length > 0);
+    const termSummaries = mappedTerms.map((entry) => ({
+        labels: [entry.term.canonicalTerm, ...(entry.term.aliases ?? [])],
+        contexts: entry.contexts,
+    }));
+    const signals = [];
+    for (const entry of mappedTerms) {
+        signals.push({
+            kind: "term",
+            summary: entry.term.canonicalTerm,
+            contexts: entry.contexts,
+            confidence: entry.term.confidence,
+            fragmentIds: entry.term.fragmentIds,
+            linkedEntities: [entry.term.termId],
+        });
+    }
+    input.reportProgress?.({
+        phase: "docs",
+        message: "BFS: mapping rule statements to domain contexts.",
+    });
+    for (const rule of input.rules) {
+        const contexts = collectStatementContexts(rule.statement, rule.fragmentIds, input.fragmentContextMentions, termSummaries, input.model);
+        if (contexts.length === 0) {
+            continue;
+        }
+        signals.push({
+            kind: "rule",
+            summary: rule.statement,
+            contexts,
+            confidence: rule.confidence,
+            fragmentIds: rule.fragmentIds,
+            linkedEntities: [rule.ruleId],
+        });
+    }
+    input.reportProgress?.({
+        phase: "docs",
+        message: "BFS: mapping invariants to domain contexts.",
+    });
+    for (const invariant of input.invariants) {
+        const contexts = collectStatementContexts(invariant.statement, invariant.fragmentIds, input.fragmentContextMentions, termSummaries, input.model);
+        if (contexts.length === 0) {
+            continue;
+        }
+        signals.push({
+            kind: "invariant",
+            summary: invariant.statement,
+            contexts,
+            confidence: invariant.confidence,
+            fragmentIds: invariant.fragmentIds,
+            linkedEntities: [invariant.invariantId],
+        });
+    }
+    input.reportProgress?.({
+        phase: "docs",
+        message: "BFS: scanning use-case fragments for context signals.",
+    });
+    for (const fragment of input.fragments) {
+        if (!hasUseCaseSignal(fragment.text)) {
+            continue;
+        }
+        const contexts = input.fragmentContextMentions.get(fragment.fragmentId) ?? [];
+        if (contexts.length === 0) {
+            continue;
+        }
+        signals.push({
+            kind: "use_case",
+            summary: fragment.text,
+            contexts,
+            confidence: 0.72,
+            fragmentIds: [fragment.fragmentId],
+        });
+    }
+    return signals;
+}

package/dist/src/core/boundary-fitness.d.ts

@@ -0,0 +1,3 @@
+export { buildFragmentContextMentions, collectStatementContexts, collectTermContexts, } from "./boundary-fitness-contexts.js";
+export type { BoundaryFitnessResult } from "./boundary-fitness-core.js";
+export { computeBoundaryFitness } from "./boundary-fitness-core.js";

package/dist/src/core/boundary-fitness.js

@@ -0,0 +1,2 @@
+export { buildFragmentContextMentions, collectStatementContexts, collectTermContexts, } from "./boundary-fitness-contexts.js";
+export { computeBoundaryFitness } from "./boundary-fitness-core.js";

package/dist/src/core/command-analytics.d.ts

@@ -0,0 +1,32 @@
+import type { CommandResponse } from "./contracts.js";
+export interface CommandEventLogEntry {
+    timestamp: string;
+    sessionId: string;
+    command: string;
+    domain?: string;
+    status: string;
+    durationMs: number;
+    confidence: number;
+    unknownsCount: number;
+    proxyRate: number;
+    repoBasename?: string;
+    repoPathHash?: string;
+}
+export interface CommandEventLogSummary {
+    entries: number;
+    commandMix: Record<string, number>;
+    averageDurationByCommandDomain: Record<string, number>;
+    averageProxyRate: number;
+    averageUnknownsCount: number;
+    followUpRate: number;
+}
+export declare function resolveCommandSessionId(env: NodeJS.ProcessEnv): string;
+export declare function appendCommandEventLog(input: {
+    env: NodeJS.ProcessEnv;
+    command: string;
+    repoPath?: string;
+    durationMs: number;
+    response: CommandResponse<unknown>;
+    sessionId: string;
+}): Promise<void>;
+export declare function readAndSummarizeCommandEventLog(inputPath: string): Promise<CommandEventLogSummary>;

package/dist/src/core/command-analytics.js

@@ -0,0 +1,80 @@
+import { createHash, randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+function normalizeEventLogPath(env) {
+    const value = env.CONTEXT_PROBE_EVENT_LOG;
+    return value && path.isAbsolute(value) ? value : undefined;
+}
+function hashPath(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+export function resolveCommandSessionId(env) {
+    return env.CONTEXT_PROBE_SESSION_ID || randomUUID();
+}
+export async function appendCommandEventLog(input) {
+    const logPath = normalizeEventLogPath(input.env);
+    if (!logPath) {
+        return;
+    }
+    const measurementQuality = input.response.meta?.measurementQuality;
+    const entry = {
+        timestamp: new Date().toISOString(),
+        sessionId: input.sessionId,
+        command: input.command,
+        ...(typeof input.response.result === "object" &&
+            input.response.result !== null &&
+            "domainId" in input.response.result
+            ? { domain: input.response.result.domainId }
+            : {}),
+        status: input.response.status,
+        durationMs: input.durationMs,
+        confidence: input.response.confidence,
+        unknownsCount: measurementQuality?.unknownsCount ?? input.response.unknowns.length,
+        proxyRate: measurementQuality?.proxyRate ?? 0,
+        ...(input.repoPath ? { repoBasename: path.basename(input.repoPath), repoPathHash: hashPath(input.repoPath) } : {}),
+    };
+    await fs.mkdir(path.dirname(logPath), { recursive: true });
+    await fs.appendFile(logPath, `${JSON.stringify(entry)}\n`, "utf8");
+}
+function summarizeCommandEventEntries(entries) {
+    const commandCounts = new Map();
+    const domainDurations = new Map();
+    let proxyRateTotal = 0;
+    let unknownsCountTotal = 0;
+    const sessions = new Map();
+    for (const entry of entries) {
+        commandCounts.set(entry.command, (commandCounts.get(entry.command) ?? 0) + 1);
+        const durationKey = `${entry.command}:${entry.domain ?? "none"}`;
+        const durations = domainDurations.get(durationKey) ?? [];
+        durations.push(entry.durationMs);
+        domainDurations.set(durationKey, durations);
+        proxyRateTotal += entry.proxyRate;
+        unknownsCountTotal += entry.unknownsCount;
+        const sessionEntries = sessions.get(entry.sessionId) ?? [];
+        sessionEntries.push(entry);
+        sessions.set(entry.sessionId, sessionEntries);
+    }
+    const followUpSessions = Array.from(sessions.values()).filter((sessionEntries) => {
+        const commands = new Set(sessionEntries.map((entry) => entry.command));
+        return commands.has("report.generate") || commands.has("review.list_unknowns");
+    }).length;
+    return {
+        entries: entries.length,
+        commandMix: Object.fromEntries(Array.from(commandCounts.entries()).sort(([left], [right]) => left.localeCompare(right))),
+        averageDurationByCommandDomain: Object.fromEntries(Array.from(domainDurations.entries())
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, durations]) => [key, durations.reduce((sum, value) => sum + value, 0) / durations.length])),
+        averageProxyRate: entries.length === 0 ? 0 : proxyRateTotal / entries.length,
+        averageUnknownsCount: entries.length === 0 ? 0 : unknownsCountTotal / entries.length,
+        followUpRate: sessions.size === 0 ? 0 : followUpSessions / sessions.size,
+    };
+}
+export async function readAndSummarizeCommandEventLog(inputPath) {
+    const raw = await fs.readFile(path.resolve(inputPath), "utf8");
+    const entries = raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+    return summarizeCommandEventEntries(entries);
+}

package/dist/src/core/contracts/analysis.d.ts

@@ -0,0 +1,105 @@
+export interface FileDependency {
+    source: string;
+    target: string;
+    specifier: string;
+    targetKind: "file" | "external" | "missing";
+    kind: "import" | "export" | "part";
+}
+export interface ParsedSourceFile {
+    path: string;
+    imports: FileDependency[];
+    language: "typescript" | "javascript" | "dart";
+    generated: boolean;
+    libraryRole?: "library" | "part";
+}
+export interface CodebaseAnalysis {
+    files: ParsedSourceFile[];
+    dependencies: FileDependency[];
+    sourceFiles: string[];
+    scorableSourceFiles: string[];
+}
+export interface ContractUsageReport {
+    adherence: number;
+    applicableReferences: number;
+    compliantReferences: number;
+    findings: Array<{
+        source: string;
+        target: string;
+        sourceContext: string;
+        targetContext: string;
+        targetClassification: "contract" | "internal" | "unclassified";
+    }>;
+}
+export interface BoundaryLeakFinding {
+    findingId: string;
+    severity: "low" | "medium" | "high";
+    sourceContext: string;
+    targetContext: string;
+    violationType: string;
+    sourceSymbol: string;
+    targetSymbol: string;
+    path: string;
+    line?: number;
+}
+export interface CochangeCommit {
+    hash: string;
+    subject: string;
+    files: string[];
+}
+export interface CochangeAnalysis {
+    commits: CochangeCommit[];
+    crossContextCommits: number;
+    localCommits: number;
+    averageContextsPerCommit: number;
+    surpriseCouplingRatio: number;
+    crossContextChangeLocality: number;
+    featureScatter: number;
+    contextsSeen: string[];
+}
+export interface CochangePairWeight {
+    left: string;
+    right: string;
+    rawCount: number;
+    jaccard: number;
+}
+export interface LocalityWatchlistItem {
+    boundaries: string[];
+    count: number;
+    sampleCommitHashes: string[];
+}
+export interface CochangeStabilityCluster {
+    contexts: string[];
+    birth: number;
+    death: number;
+    stability: number;
+}
+export interface CochangePersistenceAnalysis {
+    relevantCommitCount: number;
+    contextsSeen: string[];
+    pairWeights: CochangePairWeight[];
+    stableChangeClusters: CochangeStabilityCluster[];
+    naturalSplitLevels: number[];
+    noiseRatio: number;
+}
+export interface CochangePersistenceCandidateScore {
+    localityScore: number;
+    persistentCouplingPenalty: number;
+    strongestPair: CochangePairWeight | null;
+    strongestCluster: CochangeStabilityCluster | null;
+    clusterPenalty: number;
+    pairPenalty: number;
+    coherencePenalty: number;
+}
+export interface EvolutionLocalityModelComparison {
+    els: {
+        score: number;
+        components: {
+            CCL: number;
+            FS: number;
+            SCR: number;
+        };
+    };
+    persistenceCandidate: CochangePersistenceCandidateScore;
+    persistenceAnalysis: CochangePersistenceAnalysis;
+    delta: number;
+}

package/dist/src/core/contracts/analysis.js

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

package/dist/src/core/contracts/architecture-complexity.d.ts

@@ -0,0 +1,20 @@
+import type { ArchitectureCanonicalSourceConfig } from "./architecture-scenarios.js";
+export interface ArchitectureComplexityExportBundle {
+    version: string;
+    sourceSystem?: string;
+    metrics: {
+        teamCount?: number;
+        deployableCount?: number;
+        pipelineCount?: number;
+        contractOrSchemaCount?: number;
+        serviceCount?: number;
+        serviceGroupCount?: number;
+        datastoreCount?: number;
+        onCallSurface?: number;
+        syncDepthP95?: number;
+        runCostPerBusinessTransaction?: number;
+    };
+    note?: string;
+}
+export interface ArchitectureComplexitySourceConfig extends ArchitectureCanonicalSourceConfig {
+}

package/dist/src/core/contracts/architecture-complexity.js

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

package/dist/src/core/contracts/architecture-constraints.d.ts

@@ -0,0 +1,62 @@
+import type { ArchitectureScenarioCatalog, ArchitectureScenarioObservationTemplate } from "./architecture-scenarios.js";
+import type { ArchitectureBoundaryMap, ArchitectureTopologyModel } from "./architecture-topology.js";
+import type { Evidence } from "./common.js";
+export interface LayerDefinition {
+    name: string;
+    rank: number;
+    globs: string[];
+}
+export type ComplexityTaxComponentName = "DeployablesPerTeam" | "PipelinesPerDeployable" | "ContractsOrSchemasPerService" | "DatastoresPerServiceGroup" | "OnCallSurface" | "SyncDepthOverhead" | "RunCostPerBusinessTransaction";
+export interface ComplexityTaxBaseline {
+    target?: number;
+    worst?: number;
+}
+export interface ArchitectureComplexityMetadata {
+    teamCount?: number;
+    deployableCount?: number;
+    pipelineCount?: number;
+    contractOrSchemaCount?: number;
+    serviceCount?: number;
+    serviceGroupCount?: number;
+    datastoreCount?: number;
+    onCallSurface?: number;
+    syncDepthP95?: number;
+    runCostPerBusinessTransaction?: number;
+    normalization?: Partial<Record<ComplexityTaxComponentName, ComplexityTaxBaseline>>;
+}
+export interface ArchitectureConstraints {
+    version: string;
+    direction?: "inward";
+    layers: LayerDefinition[];
+    complexity?: ArchitectureComplexityMetadata;
+}
+export interface ArchitectureLayerCandidate {
+    definition: LayerDefinition;
+    confidence: number;
+    evidence: Evidence[];
+    unknowns: string[];
+}
+export interface ArchitectureConstraintsScaffoldResult {
+    constraints: ArchitectureConstraints;
+    yaml: string;
+    layers: ArchitectureLayerCandidate[];
+    complexityCandidate?: ArchitectureComplexityMetadata;
+    drafts?: {
+        scenarioObservationsTemplate: {
+            value: ArchitectureScenarioObservationTemplate;
+            yaml: string;
+        };
+        scenarioCatalog: {
+            value: ArchitectureScenarioCatalog;
+            yaml: string;
+        };
+        topologyModel: {
+            value: ArchitectureTopologyModel;
+            yaml: string;
+        };
+        boundaryMap: {
+            value: ArchitectureBoundaryMap;
+            yaml: string;
+        };
+    };
+}

package/dist/src/core/contracts/architecture-constraints.js

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

package/dist/src/core/contracts/architecture-contract-baseline.d.ts

@@ -0,0 +1,33 @@
+import type { ArchitectureCanonicalSourceConfig } from "./architecture-scenarios.js";
+export interface ArchitectureContractBaselineSnapshot {
+    sourceKind?: string;
+    capturedAt?: string;
+    note?: string;
+}
+export type ArchitectureContractBaselineSymbolKind = "interface" | "type_alias" | "enum" | "class" | "function" | "value" | "default_export" | "unknown";
+export type ArchitectureContractBaselineSymbolStability = "stable" | "risky";
+export type ArchitectureContractBaselineSymbolLooseness = "strict" | "loose";
+export interface ArchitectureContractBaselineSymbol {
+    name: string;
+    kind: ArchitectureContractBaselineSymbolKind;
+    stability: ArchitectureContractBaselineSymbolStability;
+    looseness: ArchitectureContractBaselineSymbolLooseness;
+}
+export interface ArchitectureContractBaselineImportStats {
+    total: number;
+    nonContract: number;
+    internal: number;
+}
+export interface ArchitectureContractBaselineEntry {
+    path: string;
+    symbols: ArchitectureContractBaselineSymbol[];
+    imports?: ArchitectureContractBaselineImportStats;
+}
+export interface ArchitectureContractBaseline {
+    version: string;
+    snapshot?: ArchitectureContractBaselineSnapshot;
+    contracts: ArchitectureContractBaselineEntry[];
+    note?: string;
+}
+export interface ArchitectureContractBaselineSourceConfig extends ArchitectureCanonicalSourceConfig {
+}

package/dist/src/core/contracts/architecture-contract-baseline.js

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

package/dist/src/core/contracts/architecture-delivery.d.ts

@@ -0,0 +1,42 @@
+import type { TelemetryNormalizationRule } from "./architecture-normalization.js";
+import type { ArchitectureCanonicalSourceConfig } from "./architecture-scenarios.js";
+export interface ArchitectureDeliveryObservationSet {
+    version: string;
+    scores: {
+        LeadTimeScore?: number;
+        DeployFreqScore?: number;
+        RecoveryScore?: number;
+        ChangeFailScore?: number;
+        ReworkScore?: number;
+    };
+}
+export interface ArchitectureDeliveryRawObservationSet {
+    version: string;
+    values: {
+        LeadTime?: number;
+        DeployFrequency?: number;
+        RecoveryTime?: number;
+        ChangeFailRate?: number;
+        ReworkRate?: number;
+    };
+    source?: string;
+    note?: string;
+}
+export interface ArchitectureDeliveryExportBundle {
+    version: string;
+    sourceSystem?: string;
+    measurements: {
+        leadTime?: number;
+        deployFrequency?: number;
+        recoveryTime?: number;
+        changeFailRate?: number;
+        reworkRate?: number;
+    };
+    note?: string;
+}
+export interface ArchitectureDeliverySourceConfig extends ArchitectureCanonicalSourceConfig {
+}
+export interface ArchitectureDeliveryNormalizationProfile {
+    version: string;
+    signals: Partial<Record<"LeadTime" | "DeployFrequency" | "RecoveryTime" | "ChangeFailRate" | "ReworkRate", TelemetryNormalizationRule>>;
+}

package/dist/src/core/contracts/architecture-delivery.js

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

package/dist/src/core/contracts/architecture-normalization.d.ts

@@ -0,0 +1,6 @@
+import type { ScenarioDirection } from "./architecture-scenarios.js";
+export interface TelemetryNormalizationRule {
+    direction: ScenarioDirection;
+    target: number;
+    worstAcceptable: number;
+}

package/dist/src/core/contracts/architecture-normalization.js

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