labre-mcp 0.1.0

package/dist/work-on-value-chain/write/component/dual-verification-orchestrator.d.mts

@@ -0,0 +1,99 @@
+import { COMPONENT_TYPE, CONFIDENCE_THRESHOLD } from '../../../lib/component-detection.mjs';
+import { raceWithTimeout, buildSuccessSignal, buildTimeoutSignal, buildErrorSignal, buildSkippedSignal } from './verification-signals.mjs';
+import { reconcileSignalPair } from './verification-reconciliation.mjs';
+/**
+ * Confidence thresholds for each tier transition.
+ *
+ * - NAMING_SKIP: If naming convention confidence >= this, skip LLM tier.
+ *   Reuses the CONFIDENCE_THRESHOLD from solution-capability-router (0.90).
+ * - LLM_SKIP: If combined naming+LLM confidence >= this, skip web search tier.
+ * - MIN_VERIFIED: Minimum confidence to consider the classification "verified".
+ */
+export declare const THRESHOLDS: {
+    NAMING_SKIP: number;
+    LLM_SKIP: number;
+    MIN_VERIFIED: number;
+};
+/**
+ * @typedef {Object} ClassificationContext
+ * @property {string}  [description]    - Business/usage context for the component
+ * @property {string}  [type]           - OWM DSL type hint (component, pipeline, anchor, etc.)
+ * @property {string}  [capability]     - Already-identified underlying capability (if any)
+ * @property {string}  [nature]         - Already-identified capability nature (if any)
+ * @property {function(string): Promise<string>} [llmCall]
+ *   LLM call function for Tier 2 fallback (from llm-call.mjs).
+ *   If not provided, the pipeline stops after Tier 1 naming convention.
+ * @property {function(string): Promise<string>} [webSearchCall]
+ *   Web search call function for Tier 3 evidence (from web-search-verification.mjs).
+ *   If not provided, the pipeline stops after Tier 2 LLM.
+ * @property {boolean} [skipLLM=false]  - Force-skip the LLM tier (e.g. for cost control)
+ * @property {boolean} [skipWebSearch=false] - Force-skip the web search tier
+ */
+/**
+ * @typedef {Object} VerifiedClassificationResult
+ * @property {'solution'|'capability'} classification - Verified component type
+ * @property {number}  confidence      - Final confidence score (0-1)
+ * @property {string}  method          - Detection method chain used:
+ *   'naming' | 'naming+llm' | 'naming+web-search' | 'naming+llm+web-search'
+ * @property {string}  reasoning       - Human-readable explanation of the final classification
+ * @property {boolean} isSolution      - Convenience flag: classification === 'solution'
+ * @property {boolean} verified        - true if at least two tiers agreed or a single tier had >= 90% confidence
+ * @property {string[]} tiersUsed      - Which tiers were actually invoked: ['naming'], ['naming', 'llm'], etc.
+ * @property {import('../routing/solution-capability-router.mjs').ComponentTypeDetection} routingDetection
+ *   - Full detection result from Tier 1 (solution-capability-router), preserved for downstream routing
+ * @property {{ useSolutionStrategies: boolean, useCapabilityStrategies: boolean, mode: string }} routingTargets
+ *   - Pre-computed routing targets based on the verified classification
+ * @property {Object}  [namingResult]  - Raw result from Tier 1 naming convention
+ * @property {Object}  [llmResult]     - Raw result from Tier 2 LLM (if invoked)
+ * @property {Object}  [webSearchResult] - Raw result from Tier 3 web search (if invoked)
+ */
+/**
+ * Dual-verification orchestrator: classify a component as solution or capability
+ * using a multi-tier verification pipeline.
+ *
+ * The pipeline short-circuits at the earliest tier that produces a high-confidence
+ * result, minimizing cost. Each subsequent tier adds evidence to increase
+ * confidence or resolve ambiguity.
+ *
+ * Verification logic:
+ *   - Tier 1 alone at >= 90% confidence → verified = true (dictionary match)
+ *   - Tier 1 + Tier 2 agree → verified = true (boosted confidence)
+ *   - Tier 1 + Tier 2 disagree → Tier 3 invoked as tiebreaker (if available)
+ *   - Any final confidence >= MIN_VERIFIED (0.70) → verified = true
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {ClassificationContext} [context={}] - Partial classification context
+ * @returns {Promise<VerifiedClassificationResult>} Verified classification result
+ */
+export declare function verifyClassification(componentName: string, context?: any): Promise<any>;
+import { verifyConcurrent, verifyConcurrentFull } from './concurrent-verification.mjs';
+export { verifyConcurrent, verifyConcurrentFull };
+/**
+ * Quick classification using only Tier 1 naming convention (no LLM, no web search).
+ *
+ * This is a thin wrapper around detectComponentType() that returns the same
+ * VerifiedClassificationResult shape for API consistency.
+ *
+ * Useful for hot paths where cost must be zero and the caller can tolerate
+ * lower confidence on unknown components.
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {string} [description] - Optional business context
+ * @returns {VerifiedClassificationResult}
+ */
+export declare function classifyNamingOnly(componentName: string, description?: string): any;
+export { COMPONENT_TYPE, CONFIDENCE_THRESHOLD };
+/**
+ * Exported for testing: signal builders and reconciliation.
+ * These are implementation details exposed to enable thorough unit testing.
+ */
+export declare const _internal: {
+    buildSuccessSignal: typeof buildSuccessSignal;
+    buildTimeoutSignal: typeof buildTimeoutSignal;
+    buildErrorSignal: typeof buildErrorSignal;
+    buildSkippedSignal: typeof buildSkippedSignal;
+    reconcileSignalPair: typeof reconcileSignalPair;
+    raceWithTimeout: typeof raceWithTimeout;
+    DEFAULT_SIGNAL_TIMEOUT_MS: number;
+};
+//# sourceMappingURL=dual-verification-orchestrator.d.mts.map

package/dist/work-on-value-chain/write/component/dual-verification-orchestrator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dual-verification-orchestrator.d.mts","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/dual-verification-orchestrator.mts"],"names":[],"mappings":"AAmCA,OAAO,EAEL,cAAc,EACd,oBAAoB,EACrB,MAAM,sCAAsC,CAAC;AAO9C,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAGL,mBAAmB,EAEpB,MAAM,mCAAmC,CAAC;AAM3C;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;;;CAItB,CAAC;AAIF;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAIH;;;;;;;;;;;;;;;;;GAiBG;AAEH,wBAAsB,oBAAoB,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CA2JjG;AAUD,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EAErB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,CAAC;AAIlD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,WAAW,GAAE,MAAW,OAcjF;AAID,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;CAQrB,CAAC"}

package/dist/work-on-value-chain/write/component/dual-verification-orchestrator.mjs

@@ -0,0 +1,288 @@
+// Dual-verification orchestrator for solution vs capability classification
+//
+// Accepts a component name and partial classification context, then runs a
+// multi-tier verification pipeline to determine whether the component is a
+// concrete SOLUTION (Kubernetes, Salesforce...) or an abstract CAPABILITY
+// (container orchestration, CRM...).
+//
+// Pipeline (ordered by cost, short-circuits when confident):
+//   Tier 1: Naming convention heuristics     (free, sub-ms)
+//           → If confidence >= 90%, return immediately
+//   Tier 2: LLM semantic classification      (moderate cost)
+//           → Invoked when naming confidence < 90% and llmCall available
+//   Tier 3: Web search evidence              (higher cost, highest accuracy)
+//           → Invoked when LLM does not resolve above threshold
+//   Tier 4: Reconciliation                   (combine all available signals)
+//
+// The result includes the verified classification plus the raw tier results
+// for traceability. It also carries the ComponentTypeDetection from the
+// existing solution-capability-router so downstream routing can use it
+// without re-computing.
+//
+// This module does NOT modify any existing strategy files or the capability
+// evaluation pipeline. It sits AFTER the classification gate and BEFORE
+// strategy dispatch — called by estimate-evolution.mjs as a replacement for
+// the direct detectComponentType() call when dual verification is desired.
+//
+// Usage:
+//   import { verifyClassification } from './dual-verification-orchestrator.mjs';
+//
+//   const result = await verifyClassification('Kubernetes', {
+//     description: 'Container platform for microservices',
+//     llmCall: myLlmCall,
+//   });
+//   // → { classification: 'solution', confidence: 0.98, verified: true, ... }
+import { detectComponentType, COMPONENT_TYPE, CONFIDENCE_THRESHOLD, } from '../../../lib/component-detection.mjs';
+import { classifySolutionLLM } from '../../../work-on-evolution/write/routing/detect-solution.mjs';
+import { verifyViaWebSearch, combineWithPriorResult } from './web-search-verification.mjs';
+import { logDebug } from '../../../lib/mcp-notifications.mjs';
+import { raceWithTimeout, buildSuccessSignal, buildTimeoutSignal, buildErrorSignal, buildSkippedSignal, } from './verification-signals.mjs';
+import { toIntermediateResult, reconcileTwoTiers, reconcileSignalPair, buildResult, } from './verification-reconciliation.mjs';
+// ─── Constants ────────────────────────────────────────────────────────────────
+const TOOL = 'dual-verification';
+/**
+ * Confidence thresholds for each tier transition.
+ *
+ * - NAMING_SKIP: If naming convention confidence >= this, skip LLM tier.
+ *   Reuses the CONFIDENCE_THRESHOLD from solution-capability-router (0.90).
+ * - LLM_SKIP: If combined naming+LLM confidence >= this, skip web search tier.
+ * - MIN_VERIFIED: Minimum confidence to consider the classification "verified".
+ */
+export const THRESHOLDS = {
+    NAMING_SKIP: CONFIDENCE_THRESHOLD, // 0.90
+    LLM_SKIP: 0.85,
+    MIN_VERIFIED: 0.70,
+};
+// ─── Type Definitions ────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} ClassificationContext
+ * @property {string}  [description]    - Business/usage context for the component
+ * @property {string}  [type]           - OWM DSL type hint (component, pipeline, anchor, etc.)
+ * @property {string}  [capability]     - Already-identified underlying capability (if any)
+ * @property {string}  [nature]         - Already-identified capability nature (if any)
+ * @property {function(string): Promise<string>} [llmCall]
+ *   LLM call function for Tier 2 fallback (from llm-call.mjs).
+ *   If not provided, the pipeline stops after Tier 1 naming convention.
+ * @property {function(string): Promise<string>} [webSearchCall]
+ *   Web search call function for Tier 3 evidence (from web-search-verification.mjs).
+ *   If not provided, the pipeline stops after Tier 2 LLM.
+ * @property {boolean} [skipLLM=false]  - Force-skip the LLM tier (e.g. for cost control)
+ * @property {boolean} [skipWebSearch=false] - Force-skip the web search tier
+ */
+/**
+ * @typedef {Object} VerifiedClassificationResult
+ * @property {'solution'|'capability'} classification - Verified component type
+ * @property {number}  confidence      - Final confidence score (0-1)
+ * @property {string}  method          - Detection method chain used:
+ *   'naming' | 'naming+llm' | 'naming+web-search' | 'naming+llm+web-search'
+ * @property {string}  reasoning       - Human-readable explanation of the final classification
+ * @property {boolean} isSolution      - Convenience flag: classification === 'solution'
+ * @property {boolean} verified        - true if at least two tiers agreed or a single tier had >= 90% confidence
+ * @property {string[]} tiersUsed      - Which tiers were actually invoked: ['naming'], ['naming', 'llm'], etc.
+ * @property {import('../routing/solution-capability-router.mjs').ComponentTypeDetection} routingDetection
+ *   - Full detection result from Tier 1 (solution-capability-router), preserved for downstream routing
+ * @property {{ useSolutionStrategies: boolean, useCapabilityStrategies: boolean, mode: string }} routingTargets
+ *   - Pre-computed routing targets based on the verified classification
+ * @property {Object}  [namingResult]  - Raw result from Tier 1 naming convention
+ * @property {Object}  [llmResult]     - Raw result from Tier 2 LLM (if invoked)
+ * @property {Object}  [webSearchResult] - Raw result from Tier 3 web search (if invoked)
+ */
+// ─── Core Orchestrator ──────────────────────────────────────────────────────
+/**
+ * Dual-verification orchestrator: classify a component as solution or capability
+ * using a multi-tier verification pipeline.
+ *
+ * The pipeline short-circuits at the earliest tier that produces a high-confidence
+ * result, minimizing cost. Each subsequent tier adds evidence to increase
+ * confidence or resolve ambiguity.
+ *
+ * Verification logic:
+ *   - Tier 1 alone at >= 90% confidence → verified = true (dictionary match)
+ *   - Tier 1 + Tier 2 agree → verified = true (boosted confidence)
+ *   - Tier 1 + Tier 2 disagree → Tier 3 invoked as tiebreaker (if available)
+ *   - Any final confidence >= MIN_VERIFIED (0.70) → verified = true
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {ClassificationContext} [context={}] - Partial classification context
+ * @returns {Promise<VerifiedClassificationResult>} Verified classification result
+ */
+// any: context bag (description, llmCall, webSearchCall, timeoutMs, etc.) — heterogeneous result shape
+export async function verifyClassification(componentName, context = {}) {
+    const name = (componentName || '').trim();
+    if (!name) {
+        return buildResult({
+            classification: COMPONENT_TYPE.CAPABILITY,
+            confidence: 0,
+            method: 'error',
+            reasoning: 'Empty or invalid component name',
+            verified: false,
+            tiersUsed: [],
+            routingDetection: detectComponentType('', ''),
+        });
+    }
+    const description = context.description || '';
+    // ── Tier 1: Naming convention heuristics ─────────────────────────────────
+    logDebug(TOOL, `Tier 1 (naming) for "${name}"...`);
+    const namingResult = detectComponentType(name, description);
+    const tiersUsed = ['naming'];
+    logDebug(TOOL, `Tier 1 result: type=${namingResult.type}, confidence=${namingResult.confidence}, ` +
+        `method=${namingResult.method}, needsFallback=${namingResult.needsFallback}`);
+    // Short-circuit: high-confidence naming match → no further verification needed
+    if (namingResult.confidence >= THRESHOLDS.NAMING_SKIP) {
+        logDebug(TOOL, `Tier 1 sufficient (confidence=${namingResult.confidence} >= ${THRESHOLDS.NAMING_SKIP}) — skipping LLM/web`);
+        return buildResult({
+            classification: namingResult.type,
+            confidence: namingResult.confidence,
+            method: 'naming',
+            reasoning: namingResult.reason,
+            verified: true,
+            tiersUsed,
+            routingDetection: namingResult,
+            namingResult,
+        });
+    }
+    // ── Tier 2: LLM semantic classification ──────────────────────────────────
+    let llmResult = null;
+    let currentBest = toIntermediateResult(namingResult);
+    const canUseLLM = !context.skipLLM && typeof context.llmCall === 'function';
+    if (canUseLLM) {
+        logDebug(TOOL, `Tier 2 (LLM) for "${name}" (naming confidence=${namingResult.confidence} < ${THRESHOLDS.NAMING_SKIP})...`);
+        tiersUsed.push('llm');
+        try {
+            llmResult = await classifySolutionLLM(name, context.llmCall, {
+                context: description,
+            });
+            logDebug(TOOL, `Tier 2 result: ${llmResult.classification} (confidence=${llmResult.confidence})`);
+            // Reconcile naming + LLM
+            currentBest = reconcileTwoTiers(currentBest, {
+                classification: llmResult.classification,
+                confidence: llmResult.confidence,
+                method: 'llm',
+                reasoning: llmResult.reasoning,
+            });
+            logDebug(TOOL, `After reconciliation: ${currentBest.classification} (confidence=${currentBest.confidence})`);
+            // Short-circuit: if combined result is above LLM_SKIP threshold, stop
+            if (currentBest.confidence >= THRESHOLDS.LLM_SKIP) {
+                logDebug(TOOL, `Tier 1+2 sufficient (confidence=${currentBest.confidence} >= ${THRESHOLDS.LLM_SKIP}) — skipping web search`);
+                return buildResult({
+                    ...currentBest,
+                    method: 'naming+llm',
+                    verified: currentBest.confidence >= THRESHOLDS.MIN_VERIFIED,
+                    tiersUsed,
+                    routingDetection: namingResult,
+                    namingResult,
+                    llmResult,
+                });
+            }
+        }
+        catch (err) {
+            logDebug(TOOL, `Tier 2 (LLM) failed for "${name}": ${toErrorMessage(err)}`);
+            llmResult = { error: toErrorMessage(err) };
+        }
+    }
+    else {
+        logDebug(TOOL, `Tier 2 (LLM) skipped: ${context.skipLLM ? 'forced skip' : 'no llmCall provided'}`);
+    }
+    // ── Tier 3: Web search evidence ──────────────────────────────────────────
+    let webSearchResult = null;
+    const canUseWebSearch = !context.skipWebSearch &&
+        (typeof context.webSearchCall === 'function' || canUseLLM);
+    if (canUseWebSearch && currentBest.confidence < THRESHOLDS.LLM_SKIP) {
+        logDebug(TOOL, `Tier 3 (web search) for "${name}" (combined confidence=${currentBest.confidence} < ${THRESHOLDS.LLM_SKIP})...`);
+        tiersUsed.push('web-search');
+        try {
+            // any: web search options (Claude Agent SDK loose shape)
+            const webSearchOptions = {};
+            if (typeof context.webSearchCall === 'function') {
+                webSearchOptions.webSearchCall = context.webSearchCall;
+            }
+            if (description) {
+                webSearchOptions.context = description;
+            }
+            webSearchResult = await verifyViaWebSearch(name, webSearchOptions);
+            logDebug(TOOL, `Tier 3 result: ${webSearchResult.classification} (confidence=${webSearchResult.confidence})`);
+            // Combine web search with current best using the existing combiner
+            const combined = combineWithPriorResult(currentBest, webSearchResult);
+            currentBest = {
+                classification: combined.classification,
+                confidence: combined.confidence,
+                method: combined.method,
+                reasoning: combined.reasoning,
+            };
+            logDebug(TOOL, `After web search reconciliation: ${currentBest.classification} (confidence=${currentBest.confidence})`);
+        }
+        catch (err) {
+            logDebug(TOOL, `Tier 3 (web search) failed for "${name}": ${toErrorMessage(err)}`);
+            webSearchResult = { error: toErrorMessage(err) };
+        }
+    }
+    else {
+        logDebug(TOOL, `Tier 3 (web search) skipped: ${context.skipWebSearch ? 'forced skip' : currentBest.confidence >= THRESHOLDS.LLM_SKIP ? 'confidence sufficient' : 'no search backend'}`);
+    }
+    // ── Final result ─────────────────────────────────────────────────────────
+    const methodChain = tiersUsed.join('+');
+    return buildResult({
+        classification: currentBest.classification,
+        confidence: currentBest.confidence,
+        method: methodChain || currentBest.method,
+        reasoning: currentBest.reasoning,
+        verified: currentBest.confidence >= THRESHOLDS.MIN_VERIFIED,
+        tiersUsed,
+        routingDetection: namingResult,
+        namingResult,
+        llmResult,
+        webSearchResult,
+    });
+}
+// ─── Reconciliation Helpers ─────────────────────────────────────────────────
+// toIntermediateResult, reconcileTwoTiers, buildResult — imported from ./verification-reconciliation.mjs
+// ─── Concurrent Dual-Verification ───────────────────────────────────────────
+// Extracted to ./concurrent-verification.mjs for single-responsibility.
+// Re-exported here for backward compatibility.
+import { verifyConcurrent, verifyConcurrentFull, DEFAULT_SIGNAL_TIMEOUT_MS, } from './concurrent-verification.mjs';
+import { toErrorMessage } from '../../../lib/errors.mjs';
+export { verifyConcurrent, verifyConcurrentFull };
+// ─── Convenience: classify without fallback ─────────────────────────────────
+/**
+ * Quick classification using only Tier 1 naming convention (no LLM, no web search).
+ *
+ * This is a thin wrapper around detectComponentType() that returns the same
+ * VerifiedClassificationResult shape for API consistency.
+ *
+ * Useful for hot paths where cost must be zero and the caller can tolerate
+ * lower confidence on unknown components.
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {string} [description] - Optional business context
+ * @returns {VerifiedClassificationResult}
+ */
+export function classifyNamingOnly(componentName, description = '') {
+    const name = (componentName || '').trim();
+    const namingResult = detectComponentType(name, description);
+    return buildResult({
+        classification: namingResult.type,
+        confidence: namingResult.confidence,
+        method: 'naming',
+        reasoning: namingResult.reason,
+        verified: namingResult.confidence >= THRESHOLDS.NAMING_SKIP,
+        tiersUsed: ['naming'],
+        routingDetection: namingResult,
+        namingResult,
+    });
+}
+// ─── Re-exports for consumer convenience ────────────────────────────────────
+export { COMPONENT_TYPE, CONFIDENCE_THRESHOLD };
+/**
+ * Exported for testing: signal builders and reconciliation.
+ * These are implementation details exposed to enable thorough unit testing.
+ */
+export const _internal = {
+    buildSuccessSignal,
+    buildTimeoutSignal,
+    buildErrorSignal,
+    buildSkippedSignal,
+    reconcileSignalPair,
+    raceWithTimeout,
+    DEFAULT_SIGNAL_TIMEOUT_MS,
+};
+//# sourceMappingURL=dual-verification-orchestrator.mjs.map

package/dist/work-on-value-chain/write/component/dual-verification-orchestrator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dual-verification-orchestrator.mjs","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/dual-verification-orchestrator.mts"],"names":[],"mappings":"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"}

package/dist/work-on-value-chain/write/component/identify-capability.d.mts

@@ -0,0 +1,28 @@
+import type { McpToolDefinition } from '../../../types/mcp.mjs';
+import type { ParsedCapabilityResponse } from '../../../schemas/parsed-llm.schema.mjs';
+/**
+ * Parse LLM capability identification response.
+ * Input type (from OWM DSL) always takes priority over LLM-estimated type.
+ * @param {string} text - Raw LLM response
+ * @param {{ name: string, type?: string, context?: string }} component - Input component
+ * @returns {{ type: string, nature: string, capability: string, confidence: number, justification: string, context: string, name: string }}
+ */
+export declare function parseCapabilityResponse(text: string, component: any): ParsedCapabilityResponse;
+/**
+ * Identify the true underlying capability or need behind a component label.
+ *
+ * When type is provided (from OWM DSL):
+ *   - anchor/market/ecosystem → skip immediately, no LLM call
+ *   - component/pipeline → LLM identifies nature/capability, input type is authoritative
+ *
+ * When type is absent:
+ *   - LLM estimates type + nature + capability (no penalty)
+ *
+ * @param {{ name: string, type?: string, description?: string, context?: string }} component
+ * @param {function(string): Promise<string>} llmCall
+ * @returns {Promise<{ type: string, nature: string, capability: string, confidence: number, justification: string }>}
+ */
+export declare function identifyCapability(component: any, llmCall?: any): Promise<any>;
+export declare const IDENTIFY_CAPABILITY_TOOL: McpToolDefinition;
+export declare function handleIdentifyCapability(args: Record<string, unknown>): Promise<unknown>;
+//# sourceMappingURL=identify-capability.d.mts.map

package/dist/work-on-value-chain/write/component/identify-capability.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identify-capability.d.mts","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/identify-capability.mts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAc,MAAM,wBAAwB,CAAC;AAE5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAWvF;;;;;;GAMG;AAEH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,GAAG,wBAAwB,CAqB9F;AAED;;;;;;;;;;;;;GAaG;AAEH,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CA0CpF;AAID,eAAO,MAAM,wBAAwB,EAAE,iBAQtC,CAAC;AAEF,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAoB9F"}

package/dist/work-on-value-chain/write/component/identify-capability.mjs

@@ -0,0 +1,123 @@
+// Identify the true underlying capability or need behind a component label.
+//
+// Reusable module: can be called by any strategy or tool that needs to
+// decode technical solution names (CRM, ERP, Kubernetes…) into the
+// capability they serve, classified by type and nature.
+//
+// Also exposes an MCP tool definition (IDENTIFY_CAPABILITY_TOOL) and
+// handler (handleIdentifyCapability) for direct invocation via MCP clients.
+import { z } from 'zod';
+import { IdentifyCapabilityInputSchema } from '../../../schemas/identify-capability.schema.mjs';
+import { getStrategyLLM } from '../../../lib/llm/registry.mjs';
+import { parseKeyValueBlock } from '../../../lib/prompts/parsers.mjs';
+import { getPrompt } from '../../../lib/prompts/registry.mjs';
+import { tryDegradeAmbient } from '../../../lib/degradation/index.mjs';
+const ELIGIBLE_TYPES = new Set(['component', 'pipeline']);
+// Prompt text lives in prompts/identify-capability.md. Resolved via getPrompt().
+/**
+ * Parse LLM capability identification response.
+ * Input type (from OWM DSL) always takes priority over LLM-estimated type.
+ * @param {string} text - Raw LLM response
+ * @param {{ name: string, type?: string, context?: string }} component - Input component
+ * @returns {{ type: string, nature: string, capability: string, confidence: number, justification: string, context: string, name: string }}
+ */
+// any: component is the loose MCP input (name/type/description/context)
+export function parseCapabilityResponse(text, component) {
+    const raw = parseKeyValueBlock(text, ['type', 'nature', 'capability', 'confidence', 'justification']);
+    if (raw.capability === undefined) {
+        throw new Error(`identifyCapability: could not parse LLM response: ${text.slice(0, 200)}`);
+    }
+    // Original regex for `type` and `nature` captured \S+ (first token).
+    // parseKeyValueBlock captures the full line; reduce to the first token to preserve semantics.
+    const firstToken = (s) => s?.split(/\s+/)[0];
+    const llmType = firstToken(raw.type)?.toLowerCase() ?? 'component';
+    return {
+        type: component.type || llmType,
+        nature: firstToken(raw.nature)?.toLowerCase() ?? 'none',
+        capability: raw.capability,
+        context: component.context || '',
+        name: component.name || '',
+        confidence: raw.confidence !== undefined ? parseFloat(raw.confidence) : 0.5,
+        justification: raw.justification ?? '',
+    };
+}
+/**
+ * Identify the true underlying capability or need behind a component label.
+ *
+ * When type is provided (from OWM DSL):
+ *   - anchor/market/ecosystem → skip immediately, no LLM call
+ *   - component/pipeline → LLM identifies nature/capability, input type is authoritative
+ *
+ * When type is absent:
+ *   - LLM estimates type + nature + capability (no penalty)
+ *
+ * @param {{ name: string, type?: string, description?: string, context?: string }} component
+ * @param {function(string): Promise<string>} llmCall
+ * @returns {Promise<{ type: string, nature: string, capability: string, confidence: number, justification: string }>}
+ */
+// any: component is the loose MCP input; llmCall is a closure with diverse signatures
+export async function identifyCapability(component, llmCall) {
+    // When type is known and non-eligible, skip immediately
+    if (component.type && !ELIGIBLE_TYPES.has(component.type)) {
+        return {
+            type: component.type,
+            nature: 'none',
+            capability: component.name || '',
+            context: component.context || '',
+            name: component.name || '',
+            confidence: 1,
+            justification: `Type "${component.type}" is not eligible for capability identification (only component and pipeline are)`,
+            skipped: true,
+        };
+    }
+    const p = getPrompt('identify-capability');
+    const built = p.build({
+        component: component.name || '',
+        description: component.description ?? '',
+        context: component.context ?? '',
+    });
+    // Wrap the LLM call so a failure (rate limit, auth, network) surfaces
+    // on the ambient degradation collector — the caller still receives a
+    // valid capability shape, but the MCP envelope flips degraded:true.
+    const response = await tryDegradeAmbient('llm:identify-capability', () => llmCall(built.user, undefined, { systemPrompt: built.system }), '');
+    const result = p.parse(response, component);
+    // When type was not provided, check if LLM-estimated type is non-eligible
+    if (!component.type && !ELIGIBLE_TYPES.has(result.type)) {
+        return {
+            ...result,
+            nature: 'none',
+            capability: component.name || '',
+            skipped: true,
+        };
+    }
+    return result;
+}
+// ─── MCP Tool Definition ───────────────────────────────────────────────────
+export const IDENTIFY_CAPABILITY_TOOL = {
+    name: 'identifyCapability',
+    description: 'Identify the true underlying capability or need behind a Wardley Map component label. ' +
+        'Decodes technical solution names (CRM, ERP, Kubernetes...) into the capability they serve, ' +
+        'classified by nature (activity, practice, knowledge, data). ' +
+        'Only works for component and pipeline types — other types (anchor, market, ecosystem) are returned as-is.',
+    inputSchema: z.toJSONSchema(IdentifyCapabilityInputSchema, { io: 'input' }),
+};
+export async function handleIdentifyCapability(args) {
+    const parsed = IdentifyCapabilityInputSchema.parse(args);
+    // Map parsed input onto the legacy local `args` name for minimal downstream diff
+    args = parsed;
+    if (!args?.name || typeof args.name !== 'string' || args.name.trim().length === 0) {
+        throw new Error('Required parameter "name" must be a non-empty string');
+    }
+    const name = args.name;
+    const type = args.type;
+    const description = args.description;
+    const context = args.context;
+    const component = {
+        name: name.trim(),
+        ...(type && { type }),
+        ...(description && { description: description.trim() }),
+        ...(context && { context: context.trim() }),
+    };
+    return identifyCapability(component, getStrategyLLM('identify-capability'));
+}
+//# sourceMappingURL=identify-capability.mjs.map

package/dist/work-on-value-chain/write/component/identify-capability.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"identify-capability.mjs","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/identify-capability.mts"],"names":[],"mappings":"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"}

package/dist/work-on-value-chain/write/component/infer-capability-from-solution.d.mts

@@ -0,0 +1,45 @@
+/**
+ * @typedef {Object} PipelineCapabilityInferenceResult
+ * @property {string}  solutionName    - Original solution name input
+ * @property {string}  capability      - Inferred capability (nature-formatted, e.g. "Orchestrate containers")
+ * @property {string}  capabilityLabel - Clean label for OWM display (e.g. "Container Orchestration")
+ * @property {string}  nature          - Wardley component nature: activity | practice | knowledge | data
+ * @property {string}  wardleyType     - Component type: component | pipeline | anchor | market | ecosystem
+ * @property {number}  confidence      - Confidence in the inference (0–1)
+ * @property {string}  justification   - LLM reasoning for the inference
+ * @property {boolean} inferred        - Always true — marks this as an LLM inference result
+ */
+/**
+ * Convert a nature-formatted capability string into a clean display label
+ * suitable for OWM component names.
+ *
+ * Transformations by nature:
+ *   - activity: "Orchestrate containers" → "Container Orchestration"
+ *     (removes leading verb, nominalizes)
+ *   - practice: "how to manage IT services" → "IT Service Management"
+ *     (removes "how to", nominalizes)
+ *   - knowledge: "technical expertise in welding" → "Welding Expertise"
+ *   - data: kept as-is with title case
+ *
+ * Falls back to title-casing the raw capability if transformation fails.
+ *
+ * @param {string} capability - Nature-formatted capability string
+ * @param {string} nature     - Component nature (activity/practice/knowledge/data)
+ * @returns {string} Clean label for OWM display
+ */
+export declare function capabilityToLabel(capability: string, nature?: string): string;
+/**
+ * Infer the underlying capability from a solution name using the Tier 2 LLM.
+ *
+ * This is the core function for pipeline mode's first step: given a named
+ * solution (product, framework, methodology, standard), determine the generic
+ * capability it addresses.
+ *
+ * @param {string} solutionName - The solution name (e.g. "Kubernetes", "Scrum", "ISO 27001")
+ * @param {Object} options
+ * @param {string}   [options.description] - Additional context about the solution
+ * @param {function} options.llmCall       - LLM call function (from llm-call.mjs)
+ * @returns {Promise<PipelineCapabilityInferenceResult>}
+ */
+export declare function inferCapabilityFromSolution(solutionName: string, options?: any): Promise<any>;
+//# sourceMappingURL=infer-capability-from-solution.d.mts.map

package/dist/work-on-value-chain/write/component/infer-capability-from-solution.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer-capability-from-solution.d.mts","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/infer-capability-from-solution.mts"],"names":[],"mappings":"AA2CA;;;;;;;;;;GAUG;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CA+E7E;AAkBD;;;;;;;;;;;;GAYG;AAEH,wBAAsB,2BAA2B,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CA0CvG"}