labre-mcp 0.1.0

package/dist/work-on-evolution/routing/eval-mode-dispatcher.mjs

@@ -0,0 +1,287 @@
+// Eval Mode Dispatcher: routes component evaluation to the correct strategy set(s)
+// based on WARDLEY_EVAL_MODE environment variable.
+//
+// This module is the integration layer between the solution-capability router
+// (which DETECTS component type) and the strategy registries (which EVALUATE).
+//
+// Routing modes (controlled by WARDLEY_EVAL_MODE env var):
+//   - "exclusive" (default): routes to ONE strategy set based on detection
+//       * solution detected  -> solution-strategies/ only
+//       * capability detected -> strategies/ only
+//   - "parallel": routes to BOTH strategy sets regardless of detection
+//       * results are merged under namespaced keys (solution:* and capability:*)
+//
+// This module does NOT modify any existing strategy files.
+// It sits between the orchestrator and the registries, providing a unified
+// dispatch interface.
+//
+// Usage:
+//   import { dispatchEvaluation, getEffectiveEvalMode } from './eval-mode-dispatcher.mjs';
+//
+//   const result = await dispatchEvaluation(component, detection, {
+//     createCapabilityInstance,
+//     createSolutionInstance,
+//   });
+import { detectComponentType, COMPONENT_TYPE, } from '../../lib/component-detection.mjs';
+import { determineRoutingTargets, getEvalMode, EVAL_MODES, } from './solution-dispatch.mjs';
+import { loadStrategies } from '../strategies/capacity/registry.mjs';
+import { loadSolutionStrategies } from '../strategies/solution/registry.mjs';
+import { logDebug } from '../../lib/mcp-notifications.mjs';
+import { toErrorMessage } from '../../lib/errors.mjs';
+const TOOL = 'evalModeDispatcher';
+// ─── Types ────────────────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} DispatchOptions
+ * @property {function} [createCapabilityInstance] - Factory to create capability strategy instances (with LLM injection)
+ * @property {function} [createSolutionInstance]   - Factory to create solution strategy instances (with LLM injection)
+ * @property {string}   [strategy]                 - Specific strategy to run (default: 'all')
+ * @property {boolean}  [skipPhaseB]               - Skip Phase B enrichment (for testing)
+ */
+/**
+ * @typedef {Object} DispatchResult
+ * @property {Object<string, import('../strategies/capacity/base-strategy.mjs').EvolutionResult>} evaluations
+ *   - Keyed by strategy method name. In parallel mode, solution strategy keys are
+ *     prefixed with "solution:" (e.g. "solution:solution-properties")
+ * @property {import('./solution-capability-router.mjs').ComponentTypeDetection} detection
+ * @property {string}  evalMode    - 'exclusive' or 'parallel'
+ * @property {boolean} usedSolutionStrategies  - Whether solution strategies were executed
+ * @property {boolean} usedCapabilityStrategies - Whether capability strategies were executed
+ * @property {Object}  [enrichedComponent]      - Component with Phase B enrichments (if applicable)
+ */
+// ─── Strategy Execution Helpers ──────────────────────────────────────────────
+/**
+ * Run all capability strategies on a component.
+ * Follows the existing Phase A/B/C pipeline pattern from estimate-evolution.mjs.
+ *
+ * @param {Object} component - Component input
+ * @param {function} createInstance - Factory for capability strategy instances
+ * @returns {Promise<Object<string, import('../strategies/capacity/base-strategy.mjs').EvolutionResult>>}
+ */
+// any: createInstance is a strategy-class factory closure with diverse callbacks
+// any: component is a ComponentInput superset; response shape varies
+async function runCapabilityStrategies(component, createInstance) {
+    const strategies = await loadStrategies();
+    const evaluations = {};
+    // Phase A: Run all non-s-curve strategies first
+    for (const [method, StrategyCls] of strategies) {
+        if (method === 's-curve')
+            continue;
+        try {
+            logDebug(TOOL, `Running capability strategy "${method}" on "${component.name}"...`);
+            const instance = createInstance(StrategyCls);
+            const result = await Promise.resolve(instance.evaluate(component));
+            evaluations[method] = result;
+            logDebug(TOOL, `Capability strategy "${method}": evolution=${result.evolution}, confidence=${result.confidence}`);
+        }
+        catch (err) {
+            evaluations[method] = { error: err.message };
+            logDebug(TOOL, `Capability strategy "${method}" failed: ${err.message}`);
+        }
+    }
+    // Phase B: Enrich component with certitude/ubiquity from LLM results
+    // any: ComponentInput + derived LLM averages (certitude, ubiquity)
+    const enrichedComponent = { ...component };
+    if (enrichedComponent.certitude == null || enrichedComponent.ubiquity == null) {
+        const llmResults = // any: evaluations values are heterogeneous strategy results
+         Object.values(evaluations).filter(e => !e.error && e.certitude != null && e.ubiquity != null);
+        if (llmResults.length > 0) {
+            enrichedComponent.certitude = Math.round(llmResults.reduce((s, r) => s + r.certitude, 0) / llmResults.length * 1000) / 1000;
+            enrichedComponent.ubiquity = Math.round(llmResults.reduce((s, r) => s + r.ubiquity, 0) / llmResults.length * 1000) / 1000;
+            logDebug(TOOL, `Enriched "${component.name}": certitude=${enrichedComponent.certitude}, ubiquity=${enrichedComponent.ubiquity}`);
+        }
+    }
+    // Phase C: Run s-curve with enriched component
+    const scurveCls = strategies.get('s-curve');
+    if (scurveCls) {
+        try {
+            logDebug(TOOL, `Running capability strategy "s-curve" on "${component.name}"...`);
+            const instance = createInstance(scurveCls);
+            const result = await Promise.resolve(instance.evaluate(enrichedComponent));
+            evaluations['s-curve'] = result;
+            logDebug(TOOL, `Capability strategy "s-curve": evolution=${result.evolution}, confidence=${result.confidence}`);
+        }
+        catch (err) {
+            evaluations['s-curve'] = { error: toErrorMessage(err) };
+            logDebug(TOOL, `Capability strategy "s-curve" failed: ${toErrorMessage(err)}`);
+        }
+    }
+    return evaluations;
+}
+/**
+ * Run all solution strategies on a component.
+ *
+ * @param {Object} component - Component input (with isSolution flag)
+ * @param {function} createInstance - Factory for solution strategy instances
+ * @returns {Promise<Object<string, import('../strategies/capacity/base-strategy.mjs').EvolutionResult>>}
+ */
+// any: component is a SolutionInput superset; createInstance is a DI closure
+async function runSolutionStrategies(component, createInstance) {
+    const strategies = await loadSolutionStrategies();
+    const evaluations = {};
+    for (const [method, StrategyCls] of strategies) {
+        try {
+            logDebug(TOOL, `Running solution strategy "${method}" on "${component.name}"...`);
+            const instance = createInstance(StrategyCls);
+            const result = await Promise.resolve(instance.evaluate(component));
+            evaluations[method] = result;
+            logDebug(TOOL, `Solution strategy "${method}": evolution=${result.evolution}, confidence=${result.confidence}`);
+        }
+        catch (err) {
+            evaluations[method] = { error: err.message };
+            logDebug(TOOL, `Solution strategy "${method}" failed: ${err.message}`);
+        }
+    }
+    return evaluations;
+}
+// ─── Namespace Helpers ───────────────────────────────────────────────────────
+/**
+ * Prefix strategy keys for parallel mode to avoid collisions.
+ * In parallel mode, solution strategy keys get "solution:" prefix
+ * and capability strategy keys get "capability:" prefix.
+ *
+ * @param {Object} evaluations - Strategy results
+ * @param {string} namespace   - 'solution' or 'capability'
+ * @returns {Object} Namespaced evaluations
+ */
+function namespaceResults(evaluations, namespace) {
+    const namespaced = {};
+    for (const [key, value] of Object.entries(evaluations)) {
+        namespaced[`${namespace}:${key}`] = value;
+    }
+    return namespaced;
+}
+// ─── Main Dispatch Function ──────────────────────────────────────────────────
+/**
+ * Dispatch component evaluation to the correct strategy set(s) based on
+ * detection result and WARDLEY_EVAL_MODE.
+ *
+ * In exclusive mode (default):
+ *   - solution detected -> runs solution-strategies/ only
+ *   - capability detected -> runs strategies/ only
+ *   - Strategy keys are NOT namespaced (backward compatible)
+ *
+ * In parallel mode:
+ *   - Always runs BOTH strategy sets
+ *   - Solution strategy keys are prefixed "solution:"
+ *   - Capability strategy keys are prefixed "capability:"
+ *
+ * @param {Object} component - Component input (name, description, etc.)
+ * @param {import('./solution-capability-router.mjs').ComponentTypeDetection} detection
+ *   - Result from detectComponentType(). If null, detection is performed internally.
+ * @param {DispatchOptions} [options={}]
+ * @returns {Promise<DispatchResult>}
+ */
+// any: options bag includes createInstance, createSolutionInstance, strategy, etc.; response shape varies
+export async function dispatchEvaluation(component, detection = null, options = {}) {
+    const { createCapabilityInstance = defaultInstanceFactory, createSolutionInstance = defaultInstanceFactory, strategy = 'all', } = options;
+    // Step 1: Detect component type if not provided.
+    // `description` is the label we classify on (not `context`, which is the
+    // business environment and can be noisy for detection).
+    const effectiveDetection = detection || detectComponentType(component.name, component.description ?? '');
+    // Step 2: Determine routing targets
+    const targets = determineRoutingTargets(effectiveDetection);
+    const evalMode = targets.mode;
+    logDebug(TOOL, `Dispatching "${component.name}": type=${effectiveDetection.type}, mode=${evalMode}, ` +
+        `solution=${targets.useSolutionStrategies}, capability=${targets.useCapabilityStrategies}`);
+    // Step 3: Prepare enriched component — `kind` carries the discriminant,
+    // `routing` carries the confidence/method of the classification.
+    // any: effectiveDetection has loose extension fields (canonical, vendor, category) typed as unknown
+    const det = effectiveDetection;
+    const isSolutionKind = det.type === COMPONENT_TYPE.SOLUTION;
+    const enrichedComponent = {
+        ...component,
+        kind: isSolutionKind ? 'solution' : 'capability',
+        ...(det.canonical ? { canonicalName: det.canonical } : {}),
+        ...(det.vendor ? { vendor: det.vendor } : {}),
+        ...(det.category ? { solutionCategory: det.category } : {}),
+    };
+    // Step 4: Execute strategy set(s)
+    let evaluations = {};
+    if (evalMode === EVAL_MODES.PARALLEL) {
+        // Parallel mode: run both sets concurrently, namespace the keys
+        const [solutionEvals, capabilityEvals] = await Promise.all([
+            targets.useSolutionStrategies
+                ? runSolutionStrategies(enrichedComponent, createSolutionInstance)
+                : Promise.resolve({}),
+            targets.useCapabilityStrategies
+                ? runCapabilityStrategies(enrichedComponent, createCapabilityInstance)
+                : Promise.resolve({}),
+        ]);
+        // Namespace results to avoid key collisions
+        evaluations = {
+            ...namespaceResults(solutionEvals, 'solution'),
+            ...namespaceResults(capabilityEvals, 'capability'),
+        };
+        logDebug(TOOL, `Parallel mode: ${Object.keys(solutionEvals).length} solution + ` +
+            `${Object.keys(capabilityEvals).length} capability strategies executed`);
+    }
+    else {
+        // Exclusive mode: run only the target set, no namespacing
+        if (targets.useSolutionStrategies) {
+            evaluations = await runSolutionStrategies(enrichedComponent, createSolutionInstance);
+            logDebug(TOOL, `Exclusive mode (solution): ${Object.keys(evaluations).length} strategies executed`);
+        }
+        else if (targets.useCapabilityStrategies) {
+            evaluations = await runCapabilityStrategies(enrichedComponent, createCapabilityInstance);
+            logDebug(TOOL, `Exclusive mode (capability): ${Object.keys(evaluations).length} strategies executed`);
+        }
+    }
+    return {
+        evaluations,
+        detection: effectiveDetection,
+        evalMode,
+        usedSolutionStrategies: targets.useSolutionStrategies,
+        usedCapabilityStrategies: targets.useCapabilityStrategies,
+        enrichedComponent: enrichedComponent,
+    };
+}
+// ─── Convenience Functions ──────────────────────────────────────────────────
+/**
+ * Get the effective eval mode, resolving the env var.
+ * Re-exported for consumers that need to check the mode without dispatching.
+ *
+ * @returns {string} 'exclusive' or 'parallel'
+ */
+export function getEffectiveEvalMode() {
+    return getEvalMode();
+}
+/**
+ * Check if the dispatcher will run in parallel mode.
+ * Convenience for conditional logic in orchestrators.
+ *
+ * @returns {boolean} true if WARDLEY_EVAL_MODE=parallel
+ */
+export function isParallelMode() {
+    return getEvalMode() === EVAL_MODES.PARALLEL;
+}
+/**
+ * Build a summary of what the dispatcher would do for a given component,
+ * without actually running any strategies. Useful for dry-run/preview.
+ *
+ * @param {string} name - Component name
+ * @param {string} [description] - Description
+ * @returns {{ detection: Object, targets: Object, evalMode: string }}
+ */
+export function previewDispatch(name, description = '') {
+    const detection = detectComponentType(name, description);
+    const targets = determineRoutingTargets(detection);
+    return {
+        detection,
+        targets,
+        evalMode: targets.mode,
+    };
+}
+// ─── Default Instance Factory ───────────────────────────────────────────────
+/**
+ * Default strategy instance factory (no LLM injection).
+ * Used when the caller doesn't provide custom factories.
+ *
+ * @param {function} StrategyCls - Strategy class constructor
+ * @returns {Object} Strategy instance
+ */
+function defaultInstanceFactory(StrategyCls) {
+    return new StrategyCls();
+}
+// ─── Re-exports ─────────────────────────────────────────────────────────────
+export { EVAL_MODES, COMPONENT_TYPE };
+//# sourceMappingURL=eval-mode-dispatcher.mjs.map

package/dist/work-on-evolution/routing/eval-mode-dispatcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"eval-mode-dispatcher.mjs","sourceRoot":"","sources":["../../../src/work-on-evolution/routing/eval-mode-dispatcher.mts"],"names":[],"mappings":"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"}

package/dist/work-on-evolution/routing/mode-router.d.mts

@@ -0,0 +1,49 @@
+import type { EstimateEvolutionResponse } from '../../types/routing.mjs';
+/** Supported execution modes */
+export declare const MODES: {
+    ONESHOT: string;
+    GUIDED: string;
+};
+/**
+ * Detect the execution mode from the input signals.
+ *
+ * Decision tree:
+ *   1. Explicit mode parameter → use it (resolved through aliases)
+ *   2. sessionState present → guided (continuing a conversation)
+ *   3. space explicitly provided → oneshot (user knows the classification)
+ *   4. Sufficient evaluation params → oneshot (enough data for strategies)
+ *   5. Otherwise → guided (need to gather more context)
+ *
+ * @param {Object} input - Raw request input
+ * @returns {{ mode: string, reason: string }} Detected mode and reason for the choice
+ */
+export declare function detectMode(input: any): {
+    mode: string;
+    reason: string;
+};
+/**
+ * @typedef {Object} RoutedResponse
+ * @property {string}  mode             - 'oneshot' or 'guided'
+ * @property {string}  modeReason       - Why this mode was selected
+ * @property {Object}  classification   - Classification gate result
+ * @property {string[]|null} reQuestions - Re-questioning prompts for non-economic
+ * @property {Object|null}   evaluations - Strategy evaluation results
+ * @property {string}  message          - Human-readable summary
+ * @property {string}  formatted        - Markdown-formatted output (shared formatter)
+ * @property {string|null} sessionState - Session state for guided mode continuation
+ * @property {Object|null}  nextQuestion - Next question in guided mode
+ * @property {string|null}  phase        - Current phase in guided mode
+ * @property {Object|null}  routing      - Solution/capability routing metadata (type, confidence, method, evalMode)
+ */
+/**
+ * Route an estimateEvolution request to the appropriate mode handler
+ * and return a consistently shaped response.
+ *
+ * This is the single entry point for all estimateEvolution requests,
+ * whether from MCP tool calls, skill invocations, or direct API use.
+ *
+ * @param {Object} input - Request input with optional mode parameter
+ * @returns {Promise<RoutedResponse>} Unified response with mode, results, and formatting
+ */
+export declare function routeEstimateEvolution(input?: any): Promise<EstimateEvolutionResponse>;
+//# sourceMappingURL=mode-router.d.mts.map

package/dist/work-on-evolution/routing/mode-router.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-router.d.mts","sourceRoot":"","sources":["../../../src/work-on-evolution/routing/mode-router.mts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAkB,yBAAyB,EAAsB,MAAM,yBAAyB,CAAC;AAI7G,gCAAgC;AAChC,eAAO,MAAM,KAAK;;;CAGjB,CAAC;AA4CF;;;;;;;;;;;;GAYG;AAEH,wBAAgB,UAAU,CAAC,KAAK,EAAE,GAAG,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAmCvE;AAID;;;;;;;;;;;;;GAaG;AAIH;;;;;;;;;GASG;AAEH,wBAAsB,sBAAsB,CAAC,KAAK,GAAE,GAAQ,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAQhG"}