labre-mcp 0.1.0

package/dist/work-on-evolution/write/strategies/solution/assemble-result.mjs

@@ -0,0 +1,236 @@
+// Solution result assembler: enriches raw solution strategy outputs
+// with structured metadata from SolutionEvolutionResult.
+//
+// This module sits between the strategy evaluation (PropertiesStrategy.evaluate())
+// and the evaluations map returned by dispatchSolutionStrategies().
+// It transforms raw EvolutionResult-compatible outputs into rich
+// SolutionEvolutionResult objects with:
+//   - Phase distribution breakdown (how many properties at each phase)
+//   - Mean phase across all properties
+//   - Confidence metadata (coverage, evaluation mode, aggregation method)
+//   - Wardley stage label (Genesis/Custom/Product/Commodity)
+//   - Full interoperability with the capability EvolutionResult contract
+//
+// The assembler is extensible: any solution strategy that returns
+// { evolution, confidence, method, properties? } will be enriched.
+// Strategies that don't produce properties (e.g. a future market-data
+// strategy) pass through unchanged.
+//
+// Usage:
+//   import { assembleSolutionResult } from './assemble-result.mjs';
+//   const enriched = assembleSolutionResult(rawResult, { mode: 'auto' });
+import { SolutionEvolutionResult, PropertyScore, PROPERTY_COUNT, PROPERTY_NAME_TO_ID, } from './solution-evolution-result.mjs';
+import { PHASE_LABELS } from './solution-base-strategy.mjs';
+// ─── Phase Distribution Helper ──────────────────────────────────────────────
+/**
+ * Compute phase distribution from an array of property evaluations.
+ *
+ * @param {Array<{ phase: number }>} properties
+ * @returns {{ 1: number, 2: number, 3: number, 4: number }}
+ */
+function computePhaseDistribution(properties) {
+    const dist = { 1: 0, 2: 0, 3: 0, 4: 0 };
+    for (const prop of properties) {
+        const p = Math.round(prop.phase);
+        if (p >= 1 && p <= 4)
+            dist[p]++;
+    }
+    return dist;
+}
+/**
+ * Compute the dominant phase (mode) from a distribution.
+ *
+ * @param {{ 1: number, 2: number, 3: number, 4: number }} distribution
+ * @returns {{ phase: number, count: number, label: string }}
+ */
+function dominantPhase(distribution) {
+    let maxPhase = 1;
+    let maxCount = 0;
+    for (const [phase, count] of Object.entries(distribution)) {
+        if (count > maxCount) {
+            maxCount = count;
+            maxPhase = parseInt(phase, 10);
+        }
+    }
+    return {
+        phase: maxPhase,
+        count: maxCount,
+        label: PHASE_LABELS[maxPhase] || 'Unknown',
+    };
+}
+/**
+ * Compute mean phase across evaluated properties.
+ *
+ * @param {Array<{ phase: number }>} properties
+ * @returns {number} Mean phase (1–4), rounded to 2 decimals
+ */
+function computeMeanPhase(properties) {
+    if (properties.length === 0)
+        return 0;
+    const sum = properties.reduce((s, p) => s + (p.phase || 0), 0);
+    return Math.round((sum / properties.length) * 100) / 100;
+}
+// ─── Assembler ──────────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} AssemblyOptions
+ * @property {string}  [mode='auto']    - Evaluation mode ('auto' | 'conversational')
+ * @property {boolean} [enrichMetadata=true] - Whether to add phase distribution and confidence metadata
+ */
+/**
+ * Assemble a solution strategy result into a rich, structured format.
+ *
+ * Takes a raw EvolutionResult (as returned by a solution strategy's evaluate())
+ * and enriches it with:
+ *   - `stage`: Wardley stage label (Genesis/Custom/Product/Commodity)
+ *   - `meanPhase`: average phase across properties
+ *   - `phaseDistribution`: count per phase { 1: n, 2: n, 3: n, 4: n }
+ *   - `dominantPhase`: the most common phase
+ *   - `confidenceMetadata`: structured metadata about confidence computation
+ *
+ * If the result already has rich metadata (e.g. it's a SolutionEvolutionResult),
+ * the assembler preserves existing metadata and only fills gaps.
+ *
+ * If the result has no properties array (e.g. a non-property-based strategy),
+ * it passes through with only the stage label added.
+ *
+ * @param {Object} rawResult - Raw strategy evaluation result
+ *   Must conform to EvolutionResult: { evolution, confidence, method, trace?, properties? }
+ * @param {AssemblyOptions} [options={}]
+ * @returns {Object} Enriched result with all original fields plus metadata
+ */
+// any: rawResult is a SolutionEvolutionResult-like bag with assembler-added extension fields
+export function assembleSolutionResult(rawResult, options = {}) {
+    if (!rawResult || rawResult.error) {
+        // Error results pass through unchanged
+        return rawResult;
+    }
+    const { mode = 'auto', enrichMetadata = true } = options;
+    // Start with a copy of the raw result (preserve all original fields)
+    const enriched = { ...rawResult };
+    // Add Wardley stage label
+    enriched.stage = resolveStage(rawResult.evolution);
+    // If no properties, return with just the stage
+    if (!Array.isArray(rawResult.properties) || rawResult.properties.length === 0) {
+        return enriched;
+    }
+    if (!enrichMetadata) {
+        return enriched;
+    }
+    // Compute phase distribution
+    const distribution = computePhaseDistribution(rawResult.properties);
+    enriched.phaseDistribution = distribution;
+    // Compute mean phase
+    enriched.meanPhase = computeMeanPhase(rawResult.properties);
+    // Compute dominant phase
+    enriched.dominantPhase = dominantPhase(distribution);
+    // Build confidence metadata if not already present
+    if (!enriched.confidenceMetadata) {
+        const evaluatedProperties = rawResult.properties.filter((p) => !p.reason?.startsWith('Not evaluated'));
+        const evaluatedCount = evaluatedProperties.length || rawResult.properties.length;
+        const coverage = evaluatedCount / PROPERTY_COUNT;
+        enriched.confidenceMetadata = {
+            coverage: Math.round(coverage * 1000) / 1000,
+            evaluatedCount,
+            totalCount: PROPERTY_COUNT,
+            mode,
+            aggregationMethod: 'weighted_average',
+        };
+    }
+    // Ensure each property has a label
+    enriched.properties = rawResult.properties.map((prop) => {
+        if (prop.label)
+            return prop;
+        return {
+            ...prop,
+            label: PHASE_LABELS[Math.round(prop.phase)] || `Phase ${prop.phase}`,
+        };
+    });
+    return enriched;
+}
+/**
+ * Assemble multiple solution strategy results into a unified evaluations map.
+ *
+ * This is the batch version of assembleSolutionResult, designed to be called
+ * after all solution strategies have evaluated. It enriches each result
+ * individually and returns the enriched evaluations map.
+ *
+ * @param {Object<string, Object>} evaluations - Map of method → raw result
+ * @param {AssemblyOptions} [options={}]
+ * @returns {Object<string, Object>} Map of method → enriched result
+ */
+export function assembleSolutionEvaluations(evaluations, options = {}) {
+    const assembled = {};
+    for (const [method, result] of Object.entries(evaluations)) {
+        assembled[method] = assembleSolutionResult(result, options);
+    }
+    return assembled;
+}
+/**
+ * Build a structured SolutionEvolutionResult instance from a raw result.
+ *
+ * This is the full-model version that creates a proper SolutionEvolutionResult
+ * with PropertyScore instances and ConfidenceMetadata. Use this when you need
+ * the full structured API (e.g. for validation, serialization, or rich display).
+ *
+ * For lighter-weight enrichment that keeps plain objects, use assembleSolutionResult.
+ *
+ * @param {Object} rawResult - Raw strategy evaluation result with properties
+ * @param {Object} [options={}]
+ * @param {string} [options.mode='auto'] - Evaluation mode
+ * @returns {SolutionEvolutionResult}
+ * @throws {Error} If rawResult doesn't have required fields or properties
+ */
+// any: rawResult/options shapes mirror assembleSolutionResult — loose assembler contract
+export function buildStructuredResult(rawResult, options = {}) {
+    if (!rawResult || rawResult.error) {
+        throw new Error('Cannot build structured result from error or null result');
+    }
+    const { mode = 'auto' } = options;
+    // Convert properties to PropertyScore instances
+    const scores = (rawResult.properties || []).map((prop) => {
+        const id = PROPERTY_NAME_TO_ID.get(prop.property?.toLowerCase())
+            || prop.id
+            || prop.property?.toLowerCase().replace(/[\s/]+/g, '_')
+            || 'unknown';
+        return PropertyScore.create(id, prop.property || id, prop.phase, prop.reason, {
+            confidence: prop.confidence,
+            phaseDescription: prop.phaseDescription,
+            weight: prop.weight,
+        });
+    });
+    // Build structured result using the factory
+    if (scores.length > 0) {
+        return SolutionEvolutionResult.fromPropertyScores(scores, {
+            method: rawResult.method,
+            mode,
+            trace: rawResult.trace || [],
+        });
+    }
+    // No properties: direct construction
+    return new SolutionEvolutionResult({
+        evolution: rawResult.evolution,
+        confidence: rawResult.confidence,
+        method: rawResult.method,
+        trace: rawResult.trace || [],
+    });
+}
+// ─── Stage Resolution ──────────────────────────────────────────────────────
+/**
+ * Resolve the Wardley stage label from an evolution value.
+ *
+ * @param {number} evolution - Evolution value (0–1)
+ * @returns {string} Stage label: 'Genesis' | 'Custom' | 'Product' | 'Commodity'
+ */
+function resolveStage(evolution) {
+    if (typeof evolution !== 'number' || Number.isNaN(evolution))
+        return 'Unknown';
+    if (evolution < 0.18)
+        return 'Genesis';
+    if (evolution < 0.40)
+        return 'Custom';
+    if (evolution < 0.70)
+        return 'Product';
+    return 'Commodity';
+}
+export { resolveStage, computePhaseDistribution, computeMeanPhase, dominantPhase };
+//# sourceMappingURL=assemble-result.mjs.map

package/dist/work-on-evolution/write/strategies/solution/assemble-result.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble-result.mjs","sourceRoot":"","sources":["../../../../../src/work-on-evolution/write/strategies/solution/assemble-result.mts"],"names":[],"mappings":"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"}

package/dist/work-on-evolution/write/strategies/solution/phase-classifier.d.mts

@@ -0,0 +1,211 @@
+declare const GENERAL_PHASE_SIGNALS: {
+    1: string[];
+    2: string[];
+    3: string[];
+    4: string[];
+};
+/**
+ * Normalize text for comparison: lowercase, remove punctuation, collapse whitespace.
+ * @param {string} text
+ * @returns {string}
+ */
+declare function normalizeText(text: string): string;
+/**
+ * Extract meaningful unigram tokens from text (words, excluding stop words).
+ * @param {string} text - Normalized text
+ * @returns {string[]}
+ */
+declare function extractTokens(text: string): string[];
+/**
+ * Extract bigram phrases from text (consecutive word pairs).
+ * @param {string} text - Normalized text
+ * @returns {string[]}
+ */
+declare function extractBigrams(text: string): string[];
+/**
+ * @typedef {Object} SignalEntry
+ * @property {string} term       - The signal term (unigram or phrase)
+ * @property {number} weight     - Discriminative weight (higher = more indicative of this phase)
+ * @property {string} source     - Where the signal came from: 'description' or 'general'
+ */
+/**
+ * @typedef {Object} PropertySignals
+ * @property {string} propertyName
+ * @property {string} propertyId
+ * @property {Map<number, SignalEntry[]>} phases  - Map of phase (1–4) → signal entries
+ */
+/**
+ * Build the signal bank for a single property from its phase descriptions.
+ *
+ * Terms that appear in only one phase get weight 1.0 (highly discriminative).
+ * Terms that appear in two phases get weight 0.5, etc.
+ * General phase indicators are added with a moderate weight (0.6).
+ *
+ * @param {object} property - Property definition with name and phases
+ * @returns {PropertySignals}
+ */
+interface PropertyDef {
+    name: string;
+    id?: string;
+    phases?: Record<string, string>;
+}
+interface SignalEntry {
+    term: string;
+    weight: number;
+    source: string;
+}
+interface PropertySignalBank {
+    propertyName: string;
+    propertyId: string;
+    phases: Map<number, SignalEntry[]>;
+}
+declare function buildPropertySignals(property: PropertyDef): PropertySignalBank;
+/**
+ * @typedef {Object} PropertyClassification
+ * @property {string}  property    - Property name (e.g. "Market")
+ * @property {number}  phase       - Assigned phase (1–4)
+ * @property {string}  label       - Phase label (Genesis, Custom, Product, Commodity)
+ * @property {number}  confidence  - Classification confidence (0–1)
+ * @property {Object}  scores      - Raw scores per phase { 1: n, 2: n, 3: n, 4: n }
+ * @property {string}  reason      - Brief explanation of classification
+ */
+declare const PHASE_LABELS: {
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+};
+/**
+ * Per-property phase classifier for Wardley evolution evaluation.
+ *
+ * Evaluates input text against the 12-property phase reference using
+ * keyword-based scoring with TF-IDF-like discrimination weighting.
+ *
+ * @example
+ *   const classifier = await PhaseClassifier.fromReference();
+ *   const results = classifier.classifyAll('Kubernetes is a mature container orchestration platform...');
+ *   // → [{ property: 'Market', phase: 3, confidence: 0.72, ... }, ...]
+ *
+ * @example
+ *   const result = classifier.classifyProperty('Market', 'Highly commoditized market...');
+ *   // → { property: 'Market', phase: 4, confidence: 0.85, ... }
+ */
+export declare class PhaseClassifier {
+    _properties: PropertyDef[];
+    _signalBank: PropertySignalBank[];
+    constructor(propertiesRef: PropertyDef[]);
+    /**
+     * Create a PhaseClassifier from the evolution-properties.json reference file.
+     * Factory method that handles async file loading.
+     *
+     * @returns {Promise<PhaseClassifier>}
+     */
+    static fromReference(): Promise<PhaseClassifier>;
+    /**
+     * Get the number of properties in the reference.
+     * @returns {number}
+     */
+    get propertyCount(): number;
+    /**
+     * Get the list of property names.
+     * @returns {string[]}
+     */
+    get propertyNames(): any[];
+    /**
+     * Classify input text for a single property, returning the best-matching phase.
+     *
+     * Scoring algorithm:
+     *   1. Normalize and tokenize the input text
+     *   2. For each phase (1–4), scan the signal bank for term matches
+     *   3. Sum matched signal weights → raw phase score
+     *   4. Select the phase with highest score
+     *   5. Compute confidence from score margin between top two phases
+     *
+     * @param {string} propertyName - Name of the property to classify (e.g. "Market")
+     * @param {string} inputText    - Text to evaluate (solution description, evidence, etc.)
+     * @returns {PropertyClassification}
+     * @throws {Error} If propertyName is not found in the reference
+     */
+    classifyProperty(propertyName: string, inputText: string): any;
+    /**
+     * Classify input text against all 12 properties, returning per-property phases.
+     *
+     * @param {string} inputText - Text to evaluate against all properties
+     * @returns {PropertyClassification[]} Array of 12 classifications (one per property)
+     */
+    classifyAll(inputText: string): any[];
+    /**
+     * Classify input text against a subset of properties.
+     *
+     * @param {string} inputText      - Text to evaluate
+     * @param {string[]} propertyNames - Names of properties to evaluate
+     * @returns {PropertyClassification[]}
+     */
+    classifySubset(inputText: string, propertyNames: string[]): any[];
+    /**
+     * Validate an existing phase classification against the classifier's judgment.
+     * Returns the degree of agreement (0 = complete disagreement, 1 = exact match).
+     *
+     * @param {string} propertyName  - Property name
+     * @param {number} assignedPhase - Phase assigned by another method (e.g. LLM)
+     * @param {string} inputText     - The text that was classified
+     * @returns {{ agreement: number, classifierPhase: number, assignedPhase: number, delta: number }}
+     */
+    validateClassification(propertyName: string, assignedPhase: number, inputText: string): any;
+    /**
+     * Find the signal bank entry for a given property name.
+     * Uses fuzzy matching (case-insensitive, substring).
+     *
+     * @param {string} propertyName
+     * @returns {PropertySignals}
+     * @private
+     */
+    _findPropertySignals(propertyName: string): any;
+    /**
+     * Score input text against a property's signal bank and select the best phase.
+     *
+     * @param {PropertySignals} signals - Property signal bank
+     * @param {string} inputText        - Text to score
+     * @returns {PropertyClassification}
+     * @private
+     */
+    _scoreAndClassify(signals: any, inputText: string): any;
+    /**
+     * Select the winning phase from scores and compute confidence.
+     *
+     * Confidence is based on:
+     *   - Score margin: how much the top phase exceeds the runner-up
+     *   - Total score: whether there's enough signal to be meaningful
+     *
+     * When all scores are zero (no signal found), defaults to phase 2
+     * with very low confidence.
+     *
+     * @param {Object} scores   - Phase scores { 1: n, 2: n, 3: n, 4: n }
+     * @param {string} propName - Property name for reason text
+     * @returns {{ phase: number, confidence: number, reason: string }}
+     * @private
+     */
+    _selectPhase(scores: any, propName: string): {
+        phase: number;
+        confidence: number;
+        reason: string;
+    };
+}
+/**
+ * Classify all 12 properties for a given input text in one call.
+ * Creates a classifier from the default reference file.
+ *
+ * @param {string} inputText - Solution description or evidence text
+ * @returns {Promise<PropertyClassification[]>}
+ */
+export declare function classifyAllProperties(inputText: string): Promise<any[]>;
+/**
+ * Classify a single property for a given input text.
+ *
+ * @param {string} propertyName - Property name (e.g. "Market")
+ * @param {string} inputText    - Text to evaluate
+ * @returns {Promise<PropertyClassification>}
+ */
+export declare function classifySingleProperty(propertyName: string, inputText: string): Promise<any>;
+export { normalizeText, extractTokens, extractBigrams, buildPropertySignals, GENERAL_PHASE_SIGNALS, PHASE_LABELS, };
+//# sourceMappingURL=phase-classifier.d.mts.map

package/dist/work-on-evolution/write/strategies/solution/phase-classifier.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-classifier.d.mts","sourceRoot":"","sources":["../../../../../src/work-on-evolution/write/strategies/solution/phase-classifier.mts"],"names":[],"mappings":"AAqDA,QAAA,MAAM,qBAAqB;;;;;CAmC1B,CAAC;AAIF;;;;GAIG;AACH,iBAAS,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO3C;AAED;;;;GAIG;AACH,iBAAS,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAI7C;AAED;;;;GAIG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAO9C;AAID;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;;;;;GASG;AACH,UAAU,WAAW;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE;AACpF,UAAU,WAAW;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACtE,UAAU,kBAAkB;IAAG,YAAY,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAA;CAAE;AAE7G,iBAAS,oBAAoB,CAAC,QAAQ,EAAE,WAAW,GAAG,kBAAkB,CAqEvE;AAKD;;;;;;;;GAQG;AAEH,QAAA,MAAM,YAAY;;;;;CAA8D,CAAC;AAEjF;;;;;;;;;;;;;;GAcG;AACH,qBAAa,eAAe;IAC1B,WAAW,EAAE,WAAW,EAAE,CAAC;IAC3B,WAAW,EAAE,kBAAkB,EAAE,CAAC;gBAEtB,aAAa,EAAE,WAAW,EAAE;IAQxC;;;;;OAKG;WACU,aAAa;IAQ1B;;;OAGG;IACH,IAAI,aAAa,WAEhB;IAED;;;OAGG;IACH,IAAI,aAAa,UAEhB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG;IAK9D;;;;;OAKG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,EAAE;IAIrC;;;;;;OAMG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,GAAG,EAAE;IAOjE;;;;;;;;OAQG;IACH,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG;IAkB3F;;;;;;;OAOG;IACH,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG;IAsB/C;;;;;;;OAOG;IACH,iBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG;IAiDvD;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM;;;;;CAyC3C;AAID;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAG7E;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAGlG;AAID,OAAO,EACL,aAAa,EACb,aAAa,EACb,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,YAAY,GACb,CAAC"}