modular-studio 1.0.6 → 1.1.0

package/dist-server/src/metaprompt/v2/pattern-selector.js

@@ -0,0 +1,154 @@
+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;
+}
+/**
+ * Signal-based heuristic scoring for workflow patterns.
+ * Returns a pre-scored suggestion that the LLM can refine.
+ */
+function scorePatterns(parsed, research) {
+    const input = [
+        parsed.role,
+        parsed.domain,
+        ...parsed.success_criteria,
+        ...parsed.output_expectations,
+        ...parsed.constraints,
+    ].join(' ').toLowerCase();
+    const scores = {
+        prompt_chaining: 0,
+        routing: 0,
+        parallelization: 0,
+        orchestrator_workers: 0,
+        evaluator_optimizer: 0,
+        hybrid: 0,
+    };
+    // Prompt chaining signals
+    if (input.match(/step.?by.?step|first.*then.*finally|sequential|pipeline|extract.*then.*prioritize/))
+        scores.prompt_chaining += 3;
+    if (research.expert_frameworks.length >= 2)
+        scores.prompt_chaining += 2; // multiple frameworks → chain them
+    if (parsed.output_expectations.length >= 2)
+        scores.prompt_chaining += 1;
+    // Routing signals
+    if (input.match(/different types? of|depending on|classify|categorize|triage/))
+        scores.routing += 3;
+    if (input.match(/route|dispatch|handle.*(differently|separately)/))
+        scores.routing += 2;
+    // Parallelization signals
+    if (input.match(/multiple (perspectives|angles|criteria)|cross.?reference|simultaneously/))
+        scores.parallelization += 3;
+    if (input.match(/evaluate.*from.*angles|compare.*frameworks/))
+        scores.parallelization += 2;
+    if (research.methodology_frameworks.length >= 3)
+        scores.parallelization += 1;
+    // Orchestrator-workers signals
+    if (input.match(/dynamic|figure out|whatever.?is.?needed|unpredictable|complex.*multi/))
+        scores.orchestrator_workers += 3;
+    if (input.match(/break.*down|delegate|coordinate/))
+        scores.orchestrator_workers += 2;
+    // Evaluator-optimizer signals
+    if (input.match(/iterate|refine|polish|high.?quality|draft.*review|critique/))
+        scores.evaluator_optimizer += 3;
+    if (input.match(/improve|feedback.?loop|revise/))
+        scores.evaluator_optimizer += 2;
+    // Hybrid: if multiple patterns score high
+    const topScores = Object.values(scores).sort((a, b) => b - a);
+    if (topScores[0] > 0 && topScores[1] > 0 && topScores[1] >= topScores[0] * 0.6) {
+        scores.hybrid = topScores[0] + 1;
+    }
+    // Default to prompt_chaining if nothing stands out (safest pattern)
+    if (Object.values(scores).every(s => s === 0)) {
+        scores.prompt_chaining = 1;
+    }
+    return scores;
+}
+const PATTERN_SYSTEM_PROMPT = `You select the optimal agentic workflow pattern for an AI agent based on Anthropic's taxonomy.
+
+Patterns:
+- prompt_chaining: Fixed sequential steps, each output feeds next. Quality gates between steps.
+- routing: Input classification → specialized handling. Different input types need different processes.
+- parallelization: Independent subtasks run simultaneously, or multiple perspectives aggregated.
+- orchestrator_workers: Central LLM dynamically breaks down tasks and delegates to workers.
+- evaluator_optimizer: Generate → critique → refine loop. Iterative quality improvement.
+- hybrid: Combination of patterns (specify which).
+
+Return ONLY a JSON object:
+{
+  "pattern": "<pattern_name>",
+  "justification": "<one sentence explaining why>",
+  "suggested_steps": ["<high-level step 1>", "<step 2>", ...]
+}
+
+Base your selection on the task shape, not on what sounds impressive. Most tasks are prompt_chaining. Only use complex patterns when the task genuinely requires them.`;
+export async function runPatternSelector(parsed, research, llmConfig) {
+    const scores = scorePatterns(parsed, research);
+    const topPattern = Object.entries(scores).sort(([, a], [, b]) => b - a)[0][0];
+    const frameworksList = [
+        ...research.expert_frameworks.map(f => `${f.expert_name}: ${f.framework_name} (${f.steps.length} steps)`),
+        ...research.methodology_frameworks.map(f => `${f.name}: ${f.purpose}`),
+    ].join('\n');
+    const text = await fetchCompletion({
+        providerId: llmConfig.providerId,
+        model: llmConfig.model,
+        messages: [
+            { role: 'system', content: PATTERN_SYSTEM_PROMPT },
+            {
+                role: 'user',
+                content: `Role: ${parsed.role}
+Domain: ${parsed.domain}
+Success criteria: ${parsed.success_criteria.join(', ')}
+Output expectations: ${parsed.output_expectations.join(', ')}
+Constraints: ${parsed.constraints.join(', ')}
+
+Frameworks to incorporate:
+${frameworksList}
+
+Heuristic suggestion: ${topPattern} (score: ${scores[topPattern]})
+All scores: ${JSON.stringify(scores)}
+
+Select the best pattern and explain why.`,
+            },
+        ],
+        temperature: 0.2,
+        maxTokens: 1024,
+    });
+    const result = parseJSON(text);
+    if (!result || !result.pattern) {
+        // Fallback to heuristic
+        return {
+            pattern: topPattern,
+            justification: `Selected based on heuristic scoring. Top signal: ${topPattern} (score ${scores[topPattern]}).`,
+            suggested_steps: [
+                'Extract and classify input data',
+                ...research.expert_frameworks.map(f => `Apply ${f.framework_name}`),
+                ...research.methodology_frameworks.slice(0, 3).map(f => `Apply ${f.name}`),
+                'Self-check and validate output',
+            ],
+        };
+    }
+    const validPatterns = ['prompt_chaining', 'routing', 'parallelization', 'orchestrator_workers', 'evaluator_optimizer', 'hybrid'];
+    const pattern = validPatterns.includes(result.pattern) ? result.pattern : topPattern;
+    return {
+        pattern,
+        justification: result.justification ?? `Selected ${pattern} based on task analysis.`,
+        suggested_steps: result.suggested_steps ?? [],
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"researcher.d.ts","sourceRoot":"","sources":["../../../../src/metaprompt/v2/researcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,EAA6D,MAAM,YAAY,CAAC;AAmLxI,wBAAsB,aAAa,CACjC,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,cAAc,CAAC,CAkCzB"}

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

@@ -0,0 +1,194 @@
+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;
+}
+/**
+ * Search the web using the Agent SDK's built-in WebSearch tool.
+ * Falls back to null if the server isn't available.
+ */
+async function searchWeb(query) {
+    try {
+        const { fetchAgentSdkCompletion } = await import('../../services/llmService.js');
+        const result = await fetchAgentSdkCompletion({
+            prompt: `Search the web for: "${query}". Return ONLY the key findings as a concise summary (max 500 words). Focus on framework steps, methodology mechanics, scoring criteria.`,
+            maxTurns: 3,
+        });
+        return result && result.length > 20 ? result : null;
+    }
+    catch {
+        return null;
+    }
+}
+const EXPERT_SYSTEM_PROMPT = `You are a research analyst. Given a person's name and domain context, decompose their framework into executable steps.
+
+Return ONLY a JSON object with this structure:
+{
+  "expert_name": "...",
+  "framework_name": "...",
+  "core_concept": "...",
+  "steps": [
+    {
+      "step": "Step name",
+      "input": "What data goes in",
+      "process": "Exact procedure with specific criteria",
+      "output": "Named artifact with defined format"
+    }
+  ],
+  "decision_rules": ["If X then Y", "Override: when Z..."],
+  "artifacts": ["Artifact 1", "Artifact 2"],
+  "research_confidence": "high|medium|low",
+  "research_note": "Optional note if confidence < high"
+}
+
+CRITICAL:
+- Steps must have SPECIFIC inputs/outputs/procedures — not "apply best practices"
+- If you cannot find a canonical framework for this person, set confidence to "low" and explain in research_note
+- Do NOT invent frameworks. If unknown, say so.`;
+const METHODOLOGY_SYSTEM_PROMPT = `You are a research analyst. Given a methodology/framework name, decompose it into executable mechanics.
+
+Return ONLY a JSON object with this structure:
+{
+  "name": "...",
+  "purpose": "...",
+  "mechanics": {
+    "inputs": ["input1", "input2"],
+    "formula": "optional formula string",
+    "scoring": {
+      "dimension": { "description": "...", "scale": "..." }
+    },
+    "output": "Specific artifact",
+    "decision_rules": ["Rule 1", "Rule 2"]
+  },
+  "research_confidence": "high|medium|low",
+  "research_note": "Optional"
+}
+
+CRITICAL: Include exact scoring scales, formulas, and decision thresholds where they exist.`;
+async function resolveExpert(expertName, domain, llmConfig, searchContext) {
+    const contextSection = searchContext ? `\n\nSearch context found:\n${searchContext}` : '\n\n(No web search available — use training knowledge, flag confidence accordingly)';
+    const text = await fetchCompletion({
+        providerId: llmConfig.providerId,
+        model: llmConfig.model,
+        messages: [
+            { role: 'system', content: EXPERT_SYSTEM_PROMPT },
+            { role: 'user', content: `Expert: ${expertName}\nDomain context: ${domain}${contextSection}` },
+        ],
+        temperature: 0.2,
+        maxTokens: 2048,
+    });
+    const parsed = parseJSON(text);
+    if (!parsed) {
+        return {
+            expert_name: expertName,
+            framework_name: `${expertName} (unresolved)`,
+            core_concept: '',
+            steps: [],
+            decision_rules: [],
+            artifacts: [],
+            research_confidence: 'low',
+            research_note: `\u26a0\ufe0f Could not parse research result for ${expertName}. Included as expertise reference only.`,
+        };
+    }
+    return {
+        expert_name: parsed.expert_name ?? expertName,
+        framework_name: parsed.framework_name ?? `${expertName} framework`,
+        core_concept: parsed.core_concept ?? '',
+        steps: parsed.steps ?? [],
+        decision_rules: parsed.decision_rules ?? [],
+        artifacts: parsed.artifacts ?? [],
+        research_confidence: parsed.research_confidence ?? 'medium',
+        research_note: parsed.research_note,
+    };
+}
+async function resolveMethodology(methodologyName, llmConfig, searchContext) {
+    const contextSection = searchContext ? `\n\nSearch context found:\n${searchContext}` : '\n\n(No web search available — use training knowledge, flag confidence accordingly)';
+    const text = await fetchCompletion({
+        providerId: llmConfig.providerId,
+        model: llmConfig.model,
+        messages: [
+            { role: 'system', content: METHODOLOGY_SYSTEM_PROMPT },
+            { role: 'user', content: `Methodology: ${methodologyName}${contextSection}` },
+        ],
+        temperature: 0.2,
+        maxTokens: 2048,
+    });
+    const parsed = parseJSON(text);
+    if (!parsed) {
+        return {
+            name: methodologyName,
+            purpose: '',
+            mechanics: { inputs: [], output: '', decision_rules: [] },
+            research_confidence: 'low',
+            research_note: `\u26a0\ufe0f Could not parse research result for ${methodologyName}.`,
+        };
+    }
+    return {
+        name: parsed.name ?? methodologyName,
+        purpose: parsed.purpose ?? '',
+        mechanics: parsed.mechanics ?? { inputs: [], output: '', decision_rules: [] },
+        research_confidence: parsed.research_confidence ?? 'medium',
+        research_note: parsed.research_note,
+    };
+}
+function detectConflicts(methodologies) {
+    const conflicts = [];
+    // Simple heuristic: check for overlapping purposes
+    const prioritizationFrameworks = methodologies.filter(m => m.purpose.toLowerCase().includes('prioriti') || m.name.match(/RICE|ICE|MoSCoW|Kano/i));
+    if (prioritizationFrameworks.length > 1) {
+        conflicts.push({
+            concern: 'feature prioritization',
+            frameworks: prioritizationFrameworks.map(f => f.name),
+            resolution: `Use ${prioritizationFrameworks[0].name} as primary. Others can serve as cross-checks or quick validation.`,
+        });
+    }
+    return conflicts;
+}
+export async function runResearcher(parsed, llmConfig) {
+    const research_notes = [];
+    // Try web search for each reference (graceful fallback if unavailable)
+    const expertFrameworks = [];
+    for (const expert of parsed.named_experts) {
+        const searchContext = await searchWeb(`${expert} framework methodology core steps`);
+        if (!searchContext) {
+            research_notes.push(`\u26a0\ufe0f Web search unavailable for ${expert}. Using training knowledge. Verify framework accuracy.`);
+        }
+        const framework = await resolveExpert(expert, parsed.domain, llmConfig, searchContext);
+        expertFrameworks.push(framework);
+    }
+    const methodologyFrameworks = [];
+    const allMethodologies = [...parsed.named_methodologies, ...parsed.implied_methodologies];
+    for (const methodology of allMethodologies) {
+        const searchContext = await searchWeb(`${methodology} framework scoring criteria steps`);
+        const framework = await resolveMethodology(methodology, llmConfig, searchContext);
+        if (parsed.implied_methodologies.includes(methodology) && !parsed.named_methodologies.includes(methodology)) {
+            framework.research_note = (framework.research_note ? framework.research_note + ' ' : '') +
+                `(inferred — confirm with user if critical)`;
+        }
+        methodologyFrameworks.push(framework);
+    }
+    const conflicts = detectConflicts(methodologyFrameworks);
+    return {
+        expert_frameworks: expertFrameworks,
+        methodology_frameworks: methodologyFrameworks,
+        conflicts,
+        research_notes,
+    };
+}

package/dist-server/src/metaprompt/v2/tool-discovery.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Tool Discovery — suggests MCP servers, connectors, and skills
+ * based on the parsed metaprompt V2 input.
+ *
+ * MCP + connector matching is synchronous (in-memory).
+ * Skills discovery is async best-effort via skills.sh.
+ *
+ * Discovery strategy (in priority order):
+ *   1. Semantic table lookup — 26 curated intent→MCP mappings (score 1.0).
+ *   2. Fuzzy registry scan — ALL MCP_REGISTRY entries matched by name/description/tags.
+ *      New entries added to the registry are discovered automatically here (score 0.5–0.9).
+ *   3. Native connectors — preferred over MCP when the same service has both.
+ *   4. Skills catalog — async fetch from skills.sh, best-effort, 10s timeout.
+ *
+ * Results are capped: 3 MCP + 2 connectors + 3 skills, sorted by relevance.
+ */
+import type { ParsedInput } from './types.js';
+export type ToolSource = 'skill' | 'mcp' | 'connector';
+export interface DiscoveredTool {
+    id: string;
+    name: string;
+    description: string;
+    source: ToolSource;
+    matchReason: string;
+    matchTerm: string;
+    relevanceScore: number;
+    npmPackage?: string;
+    tags?: string[];
+    category?: string;
+    configFields?: Array<{
+        key: string;
+        label: string;
+        type: string;
+        required?: boolean;
+    }>;
+    owner?: string;
+    repo?: string;
+    url?: string;
+    installCmd?: string;
+    installs?: string;
+    service?: string;
+    authMethod?: string;
+}
+/**
+ * Discover MCP servers relevant to the parsed agent input.
+ * Runs semantic table lookup first, then fuzzy-matches all registry entries.
+ * @param parsed - Parsed metaprompt V2 input with tools, domain, and role.
+ * @param enabledMcpIds - Already-enabled MCP server IDs (excluded from suggestions).
+ * @returns Suggested MCP tools sorted by relevance, descending.
+ */
+export declare function discoverMcpServers(parsed: ParsedInput, enabledMcpIds: string[]): DiscoveredTool[];
+/**
+ * Discover native connectors (Notion, HubSpot, Slack, …) relevant to the parsed input.
+ * Prefers connectors over MCP when both cover the same service.
+ * @param parsed - Parsed metaprompt V2 input.
+ * @param enabledConnectorIds - Already-enabled connector IDs (excluded from suggestions).
+ * @returns Suggested connector tools at relevance 1.0.
+ */
+export declare function discoverConnectors(parsed: ParsedInput, enabledConnectorIds: string[]): DiscoveredTool[];
+export declare function discoverSkills(parsed: ParsedInput, installedSkillIds: string[], signal?: AbortSignal): Promise<DiscoveredTool[]>;
+/**
+ * Discover all relevant tools (MCP + connectors + skills) for the parsed agent input.
+ * MCP and connector discovery is synchronous; skills discovery is async best-effort.
+ * @param parsed - Parsed metaprompt V2 input.
+ * @param installed - IDs of already-installed tools (excluded from suggestions).
+ * @param signal - Optional abort signal for the skills.sh network request.
+ * @returns Up to 8 tool suggestions (3 MCP + 2 connectors + 3 skills), sorted by relevance.
+ */
+export declare function discoverTools(parsed: ParsedInput, installed: {
+    skillIds: string[];
+    mcpIds: string[];
+    connectorIds: string[];
+}, signal?: AbortSignal): Promise<DiscoveredTool[]>;
+//# sourceMappingURL=tool-discovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-discovery.d.ts","sourceRoot":"","sources":["../../../../src/metaprompt/v2/tool-discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,KAAK,GAAG,WAAW,CAAC;AAEvD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IAEvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAEvF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA+FD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,MAAM,EAAE,GACtB,cAAc,EAAE,CA0BlB;AAID;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,mBAAmB,EAAE,MAAM,EAAE,GAC5B,cAAc,EAAE,CAwBlB;AA6CD,wBAAsB,cAAc,CAClC,MAAM,EAAE,WAAW,EACnB,iBAAiB,EAAE,MAAM,EAAE,EAC3B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,EAAE,CAAC,CA0D3B;AAID;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,EAC3E,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,EAAE,CAAC,CA4B3B"}