modular-studio 1.0.5 → 1.1.0

package/dist-server/src/metaprompt/v2/evaluator.js

@@ -0,0 +1,281 @@
+import { fetchCompletion } from '../../services/llmService.js';
+function parseJSON(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch { /* continue */ }
+    const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch) {
+        try {
+            return JSON.parse(fenceMatch[1].trim());
+        }
+        catch { /* continue */ }
+    }
+    const braceMatch = text.match(/\{[\s\S]*\}/);
+    if (braceMatch) {
+        try {
+            return JSON.parse(braceMatch[0]);
+        }
+        catch { /* continue */ }
+    }
+    return null;
+}
+/**
+ * Check: every named expert and methodology from parsing appears as
+ * an operationalized workflow step (not just in persona text).
+ */
+function checkFrameworkCoverage(_parsed, research, assembled) {
+    const missing = [];
+    const stepText = assembled.workflow_steps.map(s => `${s.name} ${s.process} ${s.output}`).join(' ').toLowerCase();
+    for (const ef of research.expert_frameworks) {
+        const nameInSteps = stepText.includes(ef.expert_name.toLowerCase()) ||
+            stepText.includes(ef.framework_name.toLowerCase());
+        if (!nameInSteps) {
+            missing.push(`${ef.expert_name} (${ef.framework_name})`);
+        }
+    }
+    for (const mf of research.methodology_frameworks) {
+        if (!stepText.includes(mf.name.toLowerCase())) {
+            missing.push(mf.name);
+        }
+    }
+    if (missing.length === 0) {
+        return { passed: true };
+    }
+    return {
+        passed: false,
+        issue: `Missing from workflow steps: ${missing.join(', ')}`,
+        fix_applied: 'Added missing framework steps during assembly post-processing',
+    };
+}
+/**
+ * Check: no step contains vague phrases like "apply best practices",
+ * "use appropriate methods", "leverage expertise".
+ */
+function checkSpecificity(assembled) {
+    const vaguePatterns = [
+        /apply\s+best\s+practices/i,
+        /use\s+appropriate\s+methods/i,
+        /leverage\s+(your\s+)?expertise/i,
+        /utilize\s+(your\s+)?knowledge/i,
+        /as\s+needed/i,
+        /when\s+appropriate/i,
+    ];
+    const vagueSteps = [];
+    for (const step of assembled.workflow_steps) {
+        const combined = `${step.process} ${step.input} ${step.output}`;
+        for (const pattern of vaguePatterns) {
+            if (pattern.test(combined)) {
+                vagueSteps.push(`Step ${step.number} "${step.name}": matches "${pattern.source}"`);
+                break;
+            }
+        }
+    }
+    if (vagueSteps.length === 0)
+        return { passed: true };
+    return {
+        passed: false,
+        issue: `Vague language in steps: ${vagueSteps.join('; ')}`,
+    };
+}
+/**
+ * Check: no sentence in persona repeated in workflow or role.
+ */
+function checkPersonaDuplication(assembled) {
+    const personaSentences = assembled.persona.split(/[.!?]+/).map(s => s.trim().toLowerCase()).filter(s => s.length > 20);
+    const workflowText = assembled.workflow_steps.map(s => s.process).join(' ').toLowerCase();
+    const roleText = assembled.role.toLowerCase();
+    const duplicates = [];
+    for (const sentence of personaSentences) {
+        if (workflowText.includes(sentence) || roleText.includes(sentence)) {
+            duplicates.push(sentence.slice(0, 60) + '...');
+        }
+    }
+    if (duplicates.length === 0)
+        return { passed: true };
+    return {
+        passed: false,
+        issue: `Persona/workflow duplication: ${duplicates.join('; ')}`,
+    };
+}
+/**
+ * Check: total always_loaded tokens < 60% of budget.
+ */
+function checkContextEfficiency(context) {
+    if (context.classified_documents.length === 0)
+        return { passed: true };
+    const ratio = context.total_always_loaded_tokens / context.token_budget;
+    if (ratio <= 0.6)
+        return { passed: true };
+    return {
+        passed: false,
+        issue: `Always-loaded context is ${Math.round(ratio * 100)}% of budget (${context.total_always_loaded_tokens}/${context.token_budget}). Should be ≤60%.`,
+        fix_applied: 'Documents were auto-demoted during context strategy phase',
+    };
+}
+/**
+ * Check: persistence, tool_discipline, and planning are present.
+ */
+function checkAgenticCompleteness(assembled) {
+    const missing = [];
+    if (!assembled.agentic_pillars.persistence)
+        missing.push('persistence');
+    if (!assembled.agentic_pillars.tool_discipline)
+        missing.push('tool_discipline');
+    if (!assembled.agentic_pillars.planning)
+        missing.push('planning');
+    if (missing.length === 0)
+        return { passed: true };
+    return {
+        passed: false,
+        issue: `Missing agentic pillars: ${missing.join(', ')}`,
+    };
+}
+/**
+ * Check: output format has specific fields, not just "markdown".
+ */
+function checkOutputSpecificity(assembled) {
+    const schema = assembled.output_schema;
+    if (schema.primary_artifact?.name &&
+        schema.primary_artifact?.required_fields?.length > 0) {
+        return { passed: true };
+    }
+    return {
+        passed: false,
+        issue: 'Output schema missing specific fields or artifact definition',
+    };
+}
+/**
+ * Convert assembled agent to YAML string.
+ */
+function toYaml(assembled, parsed) {
+    const lines = [];
+    lines.push('---');
+    lines.push(`name: ${parsed.role || 'Generated Agent'}`);
+    lines.push(`description: ${assembled.role}`);
+    lines.push('---');
+    lines.push('');
+    lines.push('## Persona');
+    lines.push(assembled.persona);
+    lines.push('');
+    lines.push('## Agentic Directives');
+    lines.push(`- **Persistence:** ${assembled.agentic_pillars.persistence}`);
+    lines.push(`- **Tool Discipline:** ${assembled.agentic_pillars.tool_discipline}`);
+    lines.push(`- **Planning:** ${assembled.agentic_pillars.planning}`);
+    lines.push('');
+    lines.push('## Workflow');
+    for (const step of assembled.workflow_steps) {
+        lines.push(`### Step ${step.number}: ${step.name}`);
+        lines.push(`**Input:** ${step.input}`);
+        lines.push(`**Process:**`);
+        lines.push(step.process);
+        lines.push(`**Output:** ${step.output}`);
+        if (step.decision_rules.length > 0) {
+            lines.push(`**Decision Rules:**`);
+            for (const rule of step.decision_rules) {
+                lines.push(`- ${rule}`);
+            }
+        }
+        if (step.tools_used.length > 0) {
+            lines.push(`**Tools:** ${step.tools_used.join(', ')}`);
+        }
+        lines.push('');
+    }
+    lines.push('## Output Schema');
+    lines.push(`**Primary:** ${assembled.output_schema.primary_artifact.name} (${assembled.output_schema.primary_artifact.format})`);
+    lines.push(`**Required fields:** ${assembled.output_schema.primary_artifact.required_fields.join(', ')}`);
+    if (assembled.output_schema.secondary_artifacts.length > 0) {
+        lines.push('**Secondary:**');
+        for (const sa of assembled.output_schema.secondary_artifacts) {
+            lines.push(`- ${sa.name} (${sa.format})`);
+        }
+    }
+    lines.push('');
+    if (assembled.context_strategy) {
+        lines.push('## Context Strategy');
+        lines.push(assembled.context_strategy);
+        lines.push('');
+    }
+    lines.push('## Self-Check');
+    for (const q of assembled.self_check.questions) {
+        lines.push(`- ${q}`);
+    }
+    lines.push(`**Action:** ${assembled.self_check.action}`);
+    return lines.join('\n');
+}
+export async function runEvaluator(parsed, research, assembled, context, llmConfig) {
+    // Run all 6 criteria
+    const criteria_results = {
+        framework_coverage: checkFrameworkCoverage(parsed, research, assembled),
+        specificity: checkSpecificity(assembled),
+        persona_duplication: checkPersonaDuplication(assembled),
+        context_efficiency: checkContextEfficiency(context),
+        agentic_completeness: checkAgenticCompleteness(assembled),
+        output_specificity: checkOutputSpecificity(assembled),
+    };
+    const warnings = [];
+    const failedCriteria = Object.entries(criteria_results).filter(([, r]) => !r.passed);
+    // If specificity fails, attempt LLM-based fix (1 retry max)
+    if (criteria_results.specificity && !criteria_results.specificity.passed) {
+        const vagueSteps = assembled.workflow_steps.filter(step => {
+            const combined = `${step.process} ${step.input} ${step.output}`;
+            return /apply\s+best\s+practices|use\s+appropriate|leverage\s+expertise|utilize\s+knowledge|as\s+needed|when\s+appropriate/i.test(combined);
+        });
+        if (vagueSteps.length > 0) {
+            try {
+                const fixText = await fetchCompletion({
+                    providerId: llmConfig.providerId,
+                    model: llmConfig.model,
+                    messages: [
+                        {
+                            role: 'system',
+                            content: 'Rewrite these workflow step processes to be specific and actionable. Replace ALL vague language with concrete procedures, scoring criteria, or decision rules. Return a JSON array of {number, process} objects.',
+                        },
+                        {
+                            role: 'user',
+                            content: JSON.stringify(vagueSteps.map(s => ({ number: s.number, name: s.name, process: s.process }))),
+                        },
+                    ],
+                    temperature: 0.2,
+                    maxTokens: 2048,
+                });
+                const fixes = parseJSON(fixText);
+                if (fixes && Array.isArray(fixes)) {
+                    for (const fix of fixes) {
+                        const step = assembled.workflow_steps.find(s => s.number === fix.number);
+                        if (step && fix.process) {
+                            step.process = fix.process;
+                        }
+                    }
+                    criteria_results.specificity = checkSpecificity(assembled);
+                    if (criteria_results.specificity.passed) {
+                        criteria_results.specificity.fix_applied = 'Vague language replaced via LLM refinement';
+                    }
+                }
+            }
+            catch {
+                warnings.push('Specificity auto-fix failed — vague language remains in some steps');
+            }
+        }
+    }
+    // Collect remaining warnings
+    for (const [name, result] of failedCriteria) {
+        if (!result.passed && !result.fix_applied) {
+            warnings.push(`${name}: ${result.issue}`);
+        }
+    }
+    // Add research confidence warnings
+    for (const ef of research.expert_frameworks) {
+        if (ef.research_confidence === 'low') {
+            warnings.push(`⚠️ Low confidence on ${ef.expert_name}'s framework — verify accuracy`);
+        }
+    }
+    const passed = Object.values(criteria_results).every(r => r.passed);
+    const finalYaml = toYaml(assembled, parsed);
+    return {
+        passed,
+        criteria_results,
+        final_yaml: finalYaml,
+        warnings,
+    };
+}

package/dist-server/src/metaprompt/v2/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Metaprompt V2 Pipeline Orchestrator
+ *
+ * Runs the 6-phase research-augmented agent generation pipeline:
+ * Parse → Research → Pattern Select → Context Strategy → Assemble → Evaluate
+ */
+import type { V2PipelineConfig, V2PipelineResult } from './types.js';
+export type { V2PipelineConfig, V2PipelineResult };
+export interface PipelineOptions {
+    /** Provider ID for LLM calls */
+    providerId: string;
+    /** Model for fast phases (1,2,3,4,6) — typically Sonnet */
+    sonnetModel: string;
+    /** Model for assembly phase (5) — typically Opus */
+    opusModel: string;
+    /** Token budget for context strategy. Default: 4000 */
+    tokenBudget?: number;
+    /** Progress callback — called after each phase completes */
+    onPhaseComplete?: (phase: string, elapsed: number) => void;
+    /** Warning callback — called when a phase fails non-fatally (e.g. tool discovery) */
+    onPhaseWarning?: (phase: string, message: string) => void;
+    /** Already-installed IDs to exclude from suggestions */
+    installed?: {
+        skillIds: string[];
+        mcpIds: string[];
+        connectorIds: string[];
+    };
+}
+/**
+ * Run the full V2 metaprompt pipeline.
+ *
+ * @param userInput - Natural language description of the desired agent
+ * @param options - Pipeline configuration (models, budget, callbacks)
+ * @returns Full pipeline result with timing data
+ */
+export declare function runV2Pipeline(userInput: string, options: PipelineOptions): Promise<V2PipelineResult>;
+/**
+ * Quick convenience: run pipeline and return just the YAML.
+ */
+export declare function generateAgentV2(userInput: string, options: PipelineOptions): Promise<string>;
+//# sourceMappingURL=index.d.ts.map

package/dist-server/src/metaprompt/v2/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/metaprompt/v2/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAiB,MAAM,YAAY,CAAC;AAEpF,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;AAEnD,MAAM,WAAW,eAAe;IAC9B,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,qFAAqF;IACrF,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1D,wDAAwD;IACxD,SAAS,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAC9E;AAUD;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAsE3B;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,MAAM,CAAC,CAGjB"}

package/dist-server/src/metaprompt/v2/index.js

@@ -0,0 +1,90 @@
+/**
+ * Metaprompt V2 Pipeline Orchestrator
+ *
+ * Runs the 6-phase research-augmented agent generation pipeline:
+ * Parse → Research → Pattern Select → Context Strategy → Assemble → Evaluate
+ */
+import { runParser } from './parser.js';
+import { runResearcher } from './researcher.js';
+import { runPatternSelector } from './pattern-selector.js';
+import { runContextStrategist } from './context-strategist.js';
+import { runAssembler } from './assembler.js';
+import { runEvaluator } from './evaluator.js';
+import { discoverTools } from './tool-discovery.js';
+function sonnetConfig(opts) {
+    return { providerId: opts.providerId, model: opts.sonnetModel };
+}
+function opusConfig(opts) {
+    return { providerId: opts.providerId, model: opts.opusModel };
+}
+/**
+ * Run the full V2 metaprompt pipeline.
+ *
+ * @param userInput - Natural language description of the desired agent
+ * @param options - Pipeline configuration (models, budget, callbacks)
+ * @returns Full pipeline result with timing data
+ */
+export async function runV2Pipeline(userInput, options) {
+    if (!userInput.trim())
+        throw new Error('Agent description cannot be empty');
+    const timing = {};
+    const tokenBudget = options.tokenBudget ?? 4000;
+    const notify = options.onPhaseComplete ?? (() => { });
+    const warn = options.onPhaseWarning ?? ((phase, msg) => console.warn(`[V2:${phase}] ${msg}`));
+    // Phase 1: Parse
+    let t = Date.now();
+    const parsed = await runParser(userInput, sonnetConfig(options));
+    timing.parse = Date.now() - t;
+    notify('parse', timing.parse);
+    // Start tool discovery in parallel (best-effort, won't block pipeline)
+    const toolPromise = discoverTools(parsed, options.installed ?? { skillIds: [], mcpIds: [], connectorIds: [] }).catch((err) => {
+        warn('tool_discovery', err instanceof Error ? err.message : String(err));
+        return [];
+    });
+    // Phase 2: Research
+    t = Date.now();
+    const research = await runResearcher(parsed, sonnetConfig(options));
+    timing.research = Date.now() - t;
+    notify('research', timing.research);
+    // Phase 3: Pattern Selection
+    t = Date.now();
+    const pattern = await runPatternSelector(parsed, research, sonnetConfig(options));
+    timing.pattern = Date.now() - t;
+    notify('pattern', timing.pattern);
+    // Phase 4: Context Strategy
+    t = Date.now();
+    const context = await runContextStrategist(parsed, tokenBudget, sonnetConfig(options));
+    timing.context = Date.now() - t;
+    notify('context', timing.context);
+    // Phase 5: Assembly (uses Opus for depth)
+    t = Date.now();
+    const assembled = await runAssembler(parsed, research, pattern, context, opusConfig(options));
+    timing.assemble = Date.now() - t;
+    notify('assemble', timing.assemble);
+    // Phase 6: Evaluate
+    t = Date.now();
+    const evaluation = await runEvaluator(parsed, research, assembled, context, sonnetConfig(options));
+    timing.evaluate = Date.now() - t;
+    notify('evaluate', timing.evaluate);
+    timing.total = Object.values(timing).reduce((a, b) => a + b, 0) - (timing.total ?? 0);
+    // Await tool discovery (started after Phase 1, should be done by now)
+    const discoveredTools = await toolPromise;
+    notify('tool_discovery', 0);
+    return {
+        parsed,
+        research,
+        pattern,
+        context,
+        assembled,
+        evaluation,
+        timing,
+        discoveredTools,
+    };
+}
+/**
+ * Quick convenience: run pipeline and return just the YAML.
+ */
+export async function generateAgentV2(userInput, options) {
+    const result = await runV2Pipeline(userInput, options);
+    return result.evaluation.final_yaml;
+}

package/dist-server/src/metaprompt/v2/parser.d.ts

@@ -0,0 +1,3 @@
+import type { LLMCallConfig, ParsedInput } from './types.js';
+export declare function runParser(userInput: string, llmConfig: LLMCallConfig): Promise<ParsedInput>;
+//# sourceMappingURL=parser.d.ts.map

package/dist-server/src/metaprompt/v2/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/metaprompt/v2/parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAsH7D,wBAAsB,SAAS,CAC7B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,WAAW,CAAC,CAetB"}

package/dist-server/src/metaprompt/v2/parser.js

@@ -0,0 +1,138 @@
+import { fetchCompletion } from '../../services/llmService.js';
+const FEW_SHOT_EXAMPLES = `
+## Example 1: PM Agent (Teresa Torres / RICE)
+Input: "Build a PM agent for SaaS B2B that uses Teresa Torres' continuous discovery approach and RICE prioritization. It will analyze customer interviews and Zoom transcripts to extract feature requests and map opportunities."
+
+Output:
+{
+  "role": "Product Manager",
+  "domain": "SaaS B2B",
+  "named_experts": ["Teresa Torres"],
+  "named_methodologies": ["RICE"],
+  "implied_methodologies": ["opportunity mapping", "customer interview analysis", "JTBD"],
+  "tools_requested": ["Zoom", "Filesystem"],
+  "documents": [
+    { "path": "customer-interviews/", "inferred_type": "signal", "size_estimate": "large" },
+    { "path": "zoom-transcripts/", "inferred_type": "signal", "size_estimate": "large" }
+  ],
+  "success_criteria": ["Features trace to customer evidence", "Opportunities mapped before solutions"],
+  "constraints": ["Do not jump from pain point to solution without opportunity mapping"],
+  "output_expectations": ["Opportunity solution tree", "RICE-scored backlog"]
+}
+
+## Example 2: Legal Agent
+Input: "I need a contract review agent for our legal team. It should apply IRAC analysis methodology to contracts, flag risk clauses, and follow Tina Turner's risk classification framework. Clients include Fortune 500 companies."
+
+Output:
+{
+  "role": "Legal Analyst",
+  "domain": "Contract Review",
+  "named_experts": ["Tina Turner"],
+  "named_methodologies": ["IRAC"],
+  "implied_methodologies": ["risk classification", "clause analysis"],
+  "tools_requested": ["Filesystem"],
+  "documents": [],
+  "success_criteria": ["All risk clauses flagged", "IRAC applied to each clause"],
+  "constraints": ["Do not provide legal advice, only analysis"],
+  "output_expectations": ["Contract risk report", "Flagged clauses list"]
+}
+
+NOTE: "Tina Turner" appears as a risk classification framework author — treat as named expert.
+"Fortune 500 companies" are CLIENTS/STAKEHOLDERS — NOT named experts.
+
+## Example 3: Engineering Agent
+Input: "Create a code review agent that follows Google's engineering practices, applies the DORA metrics framework, and uses Martin Fowler's refactoring catalog. It should review PRs and suggest improvements."
+
+Output:
+{
+  "role": "Senior Software Engineer",
+  "domain": "Code Review",
+  "named_experts": ["Martin Fowler"],
+  "named_methodologies": ["DORA metrics", "Google engineering practices"],
+  "implied_methodologies": ["code smell detection", "refactoring patterns"],
+  "tools_requested": ["GitHub", "Filesystem"],
+  "documents": [],
+  "success_criteria": ["Every suggestion references specific refactoring pattern", "DORA impact assessed"],
+  "constraints": ["Do not approve PRs with critical issues"],
+  "output_expectations": ["PR review with inline comments", "DORA impact assessment"]
+}
+
+## Example 4: Marketing Agent
+Input: "Build a content marketing agent using Seth Godin's permission marketing principles and the AIDA framework. It should create email campaigns and analyze conversion funnels for our e-commerce platform."
+
+Output:
+{
+  "role": "Content Marketing Strategist",
+  "domain": "E-commerce Marketing",
+  "named_experts": ["Seth Godin"],
+  "named_methodologies": ["AIDA", "permission marketing"],
+  "implied_methodologies": ["conversion funnel analysis", "email segmentation"],
+  "tools_requested": ["email platform", "analytics"],
+  "documents": [],
+  "success_criteria": ["Campaigns respect permission principles", "AIDA structure applied"],
+  "constraints": ["No unsolicited contact", "Must track consent"],
+  "output_expectations": ["Email campaign drafts", "Funnel analysis report"]
+}
+`;
+const PARSER_SYSTEM_PROMPT = `You are a precision extractor for AI agent specifications. Given a user's description of an agent they want, extract structured entities as JSON.
+
+CRITICAL RULES:
+1. named_experts: ONLY people referenced as sources of METHODOLOGY, FRAMEWORK, or APPROACH. NOT clients, NOT stakeholders, NOT companies.
+2. named_methodologies: Explicitly named frameworks (RICE, JTBD, IRAC, DORA, AIDA, etc.)
+3. implied_methodologies: Methods SUGGESTED by the task description but not named (e.g., "prioritize features" implies RICE/ICE/MoSCoW)
+4. Return ONLY a valid JSON object — no markdown, no explanation.
+
+${FEW_SHOT_EXAMPLES}
+
+Now extract from the user's input.`;
+function parseJSON(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch { /* continue */ }
+    const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch) {
+        try {
+            return JSON.parse(fenceMatch[1].trim());
+        }
+        catch { /* continue */ }
+    }
+    const braceMatch = text.match(/\{[\s\S]*\}/);
+    if (braceMatch) {
+        try {
+            return JSON.parse(braceMatch[0]);
+        }
+        catch { /* continue */ }
+    }
+    return null;
+}
+function ensureDefaults(parsed) {
+    return {
+        role: parsed.role ?? '',
+        domain: parsed.domain ?? '',
+        named_experts: parsed.named_experts ?? [],
+        named_methodologies: parsed.named_methodologies ?? [],
+        implied_methodologies: parsed.implied_methodologies ?? [],
+        tools_requested: parsed.tools_requested ?? [],
+        documents: parsed.documents ?? [],
+        success_criteria: parsed.success_criteria ?? [],
+        constraints: parsed.constraints ?? [],
+        output_expectations: parsed.output_expectations ?? [],
+    };
+}
+export async function runParser(userInput, llmConfig) {
+    const text = await fetchCompletion({
+        providerId: llmConfig.providerId,
+        model: llmConfig.model,
+        messages: [
+            { role: 'system', content: PARSER_SYSTEM_PROMPT },
+            { role: 'user', content: userInput },
+        ],
+        temperature: 0.1,
+        maxTokens: 2048,
+    });
+    const parsed = parseJSON(text);
+    if (!parsed)
+        throw new Error(`Parser: could not parse LLM response as JSON. Raw: ${text.slice(0, 200)}`);
+    return ensureDefaults(parsed);
+}

package/dist-server/src/metaprompt/v2/pattern-selector.d.ts

@@ -0,0 +1,3 @@
+import type { LLMCallConfig, ParsedInput, ResearchResult, PatternSelection } from './types.js';
+export declare function runPatternSelector(parsed: ParsedInput, research: ResearchResult, llmConfig: LLMCallConfig): Promise<PatternSelection>;
+//# sourceMappingURL=pattern-selector.d.ts.map

package/dist-server/src/metaprompt/v2/pattern-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-selector.d.ts","sourceRoot":"","sources":["../../../../src/metaprompt/v2/pattern-selector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,EAAE,gBAAgB,EAAmB,MAAM,YAAY,CAAC;AAwFhH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,gBAAgB,CAAC,CA2D3B"}