@su-record/vibe 0.1.3 → 0.1.4

package/mcp/dist/tools/semantic/findSymbol.js

@@ -1,200 +0,0 @@
-// Semantic code analysis tool - Find Symbol (v1.3)
-// With ProjectCache for 25x performance improvement
-import { Node } from 'ts-morph';
-import * as path from 'path';
-import { PythonParser } from '../../lib/PythonParser.js';
-import { ProjectCache } from '../../lib/ProjectCache.js';
-import { readFile } from 'fs/promises';
-export const findSymbolDefinition = {
-    name: 'find_symbol',
-    description: '함수 찾아|클래스 어디|변수 위치|find function|where is|locate - Find symbol definitions',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            symbolName: { type: 'string', description: 'Name of the symbol to find' },
-            projectPath: { type: 'string', description: 'Project directory path' },
-            symbolType: {
-                type: 'string',
-                enum: ['all', 'function', 'class', 'interface', 'variable', 'type'],
-                description: 'Type of symbol to search for'
-            }
-        },
-        required: ['symbolName', 'projectPath']
-    },
-    annotations: {
-        title: 'Find Symbol',
-        audience: ['user', 'assistant']
-    }
-};
-export async function findSymbol(args) {
-    const { symbolName, projectPath, symbolType = 'all' } = args;
-    try {
-        // Use cached project for performance
-        const projectCache = ProjectCache.getInstance();
-        const project = projectCache.getOrCreate(projectPath);
-        const symbols = [];
-        // Check for Python files
-        const glob = await import('glob');
-        const pythonFiles = glob.globSync(path.join(projectPath, '**/*.py'), {
-            ignore: ['**/node_modules/**', '**/.git/**', '**/venv/**', '**/__pycache__/**']
-        });
-        // Parse Python files
-        for (const pyFile of pythonFiles) {
-            try {
-                const content = await readFile(pyFile, 'utf-8');
-                const pythonSymbols = await PythonParser.findSymbols(content);
-                for (const pySymbol of pythonSymbols) {
-                    if (pySymbol.name.includes(symbolName) &&
-                        (symbolType === 'all' || symbolType === pySymbol.kind)) {
-                        symbols.push({
-                            name: pySymbol.name,
-                            kind: pySymbol.kind,
-                            filePath: pyFile,
-                            line: pySymbol.line,
-                            column: pySymbol.column,
-                            preview: pySymbol.docstring?.substring(0, 100) || `${pySymbol.kind} ${pySymbol.name}`
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                // Skip files that can't be parsed
-                console.error(`Error parsing Python file ${pyFile}:`, error);
-            }
-        }
-        // Search through all source files
-        for (const sourceFile of project.getSourceFiles()) {
-            const filePath = sourceFile.getFilePath();
-            // Skip node_modules and other irrelevant paths
-            if (filePath.includes('node_modules') || filePath.includes('.git')) {
-                continue;
-            }
-            // Find matching symbols based on type
-            sourceFile.forEachDescendant((node) => {
-                const nodeSymbol = extractSymbolInfo(node, symbolName, symbolType);
-                if (nodeSymbol) {
-                    const start = node.getStartLinePos();
-                    const pos = sourceFile.getLineAndColumnAtPos(start);
-                    symbols.push({
-                        name: nodeSymbol.name,
-                        kind: nodeSymbol.kind,
-                        filePath: filePath,
-                        line: pos.line,
-                        column: pos.column,
-                        preview: node.getText().substring(0, 100)
-                    });
-                }
-            });
-        }
-        // Sort by relevance (exact matches first)
-        symbols.sort((a, b) => {
-            const aExact = a.name === symbolName ? 0 : 1;
-            const bExact = b.name === symbolName ? 0 : 1;
-            return aExact - bExact;
-        });
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Found ${symbols.length} symbols:\n${symbols.slice(0, 20).map(s => `${s.name} (${s.kind}) - ${s.filePath}:${s.line}`).join('\n')}`
-                }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Error finding symbol: ${error instanceof Error ? error.message : 'Unknown error'}`
-                }]
-        };
-    }
-}
-function extractSymbolInfo(node, symbolName, symbolType) {
-    const kind = node.getKind();
-    // Function declarations and expressions
-    if (symbolType === 'all' || symbolType === 'function') {
-        if (Node.isFunctionDeclaration(node) || Node.isMethodDeclaration(node)) {
-            const name = node.getName();
-            if (name && name.includes(symbolName)) {
-                return { name, kind: 'function' };
-            }
-        }
-        if (Node.isVariableDeclaration(node)) {
-            const name = node.getName();
-            const initializer = node.getInitializer();
-            if (name && name.includes(symbolName) &&
-                (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) {
-                return { name, kind: 'function' };
-            }
-        }
-    }
-    // Class declarations
-    if (symbolType === 'all' || symbolType === 'class') {
-        if (Node.isClassDeclaration(node)) {
-            const name = node.getName();
-            if (name && name.includes(symbolName)) {
-                return { name, kind: 'class' };
-            }
-        }
-    }
-    // Interface declarations
-    if (symbolType === 'all' || symbolType === 'interface') {
-        if (Node.isInterfaceDeclaration(node)) {
-            const name = node.getName();
-            if (name && name.includes(symbolName)) {
-                return { name, kind: 'interface' };
-            }
-        }
-    }
-    // Type aliases
-    if (symbolType === 'all' || symbolType === 'type') {
-        if (Node.isTypeAliasDeclaration(node)) {
-            const name = node.getName();
-            if (name && name.includes(symbolName)) {
-                return { name, kind: 'type' };
-            }
-        }
-    }
-    // Variables
-    if (symbolType === 'all' || symbolType === 'variable') {
-        if (Node.isVariableDeclaration(node)) {
-            const name = node.getName();
-            const initializer = node.getInitializer();
-            if (name && name.includes(symbolName) &&
-                !Node.isArrowFunction(initializer) && !Node.isFunctionExpression(initializer)) {
-                return { name, kind: 'variable' };
-            }
-        }
-    }
-    return null;
-}
-function generateSummary(symbols, query) {
-    if (symbols.length === 0) {
-        return `No symbols found matching "${query}"`;
-    }
-    const byKind = {};
-    symbols.forEach(s => {
-        byKind[s.kind] = (byKind[s.kind] || 0) + 1;
-    });
-    const summary = Object.entries(byKind)
-        .map(([kind, count]) => `${count} ${kind}${count > 1 ? 's' : ''}`)
-        .join(', ');
-    return `Found ${symbols.length} symbols: ${summary}`;
-}
-function formatSymbolResults(result) {
-    let output = `# Symbol Search Results\n\n`;
-    output += `**Query:** ${result.query}\n`;
-    output += `**Type:** ${result.type}\n`;
-    output += `**Results:** ${result.resultsCount} symbols found\n\n`;
-    if (result.symbols.length === 0) {
-        output += `No symbols found matching "${result.query}".\n`;
-        return output;
-    }
-    output += `## Found Symbols\n\n`;
-    result.symbols.forEach((symbol, index) => {
-        output += `### ${index + 1}. ${symbol.name} (${symbol.kind})\n`;
-        output += `**Location:** ${symbol.filePath}:${symbol.line}:${symbol.column}\n`;
-        output += `**Preview:**\n\`\`\`typescript\n${symbol.preview}\n\`\`\`\n\n`;
-    });
-    output += `\n## Summary\n${result.summary}`;
-    return output;
-}

package/mcp/dist/tools/thinking/analyzeProblem.js

@@ -1,50 +0,0 @@
-// Sequential thinking tool - completely independent
-export const analyzeProblemDefinition = {
-    name: 'analyze_problem',
-    description: '문제 분석|어떻게 접근|분석해줘|analyze this|how to approach|break this down - Break down complex problem into structured steps',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            problem: { type: 'string', description: 'Problem to analyze' },
-            domain: { type: 'string', description: 'Problem domain' }
-        },
-        required: ['problem']
-    },
-    annotations: {
-        title: 'Analyze Problem',
-        audience: ['user', 'assistant']
-    }
-};
-export async function analyzeProblem(args) {
-    const { problem, domain = 'general' } = args;
-    const problemAnalysis = {
-        action: 'analyze_problem',
-        problem,
-        domain,
-        analysis: {
-            breakdown: [
-                'Define the problem clearly',
-                'Identify key constraints and requirements',
-                'Break down into smaller sub-problems',
-                'Determine solution approach',
-                'Plan implementation steps'
-            ],
-            considerations: [
-                'What are the inputs and expected outputs?',
-                'Are there any edge cases to consider?',
-                'What are the performance requirements?',
-                'How will this integrate with existing systems?'
-            ],
-            nextSteps: [
-                'Research existing solutions',
-                'Create detailed implementation plan',
-                'Identify potential risks and mitigation strategies',
-                'Define success criteria'
-            ]
-        },
-        status: 'success'
-    };
-    return {
-        content: [{ type: 'text', text: `Problem: ${problem}\nDomain: ${domain}\n\nBreakdown:\n${problemAnalysis.analysis.breakdown.map((b, i) => `${i + 1}. ${b}`).join('\n')}\n\nConsiderations:\n${problemAnalysis.analysis.considerations.map(c => `- ${c}`).join('\n')}\n\nNext Steps:\n${problemAnalysis.analysis.nextSteps.map(n => `- ${n}`).join('\n')}` }]
-    };
-}

package/mcp/dist/tools/thinking/breakDownProblem.js

@@ -1,140 +0,0 @@
-// Sequential thinking tool - completely independent
-import { Project, ScriptKind } from "ts-morph";
-const AST_PROJECT = new Project({
-    useInMemoryFileSystem: true,
-    compilerOptions: { allowJs: true, skipLibCheck: true }
-});
-export const breakDownProblemDefinition = {
-    name: 'break_down_problem',
-    description: '나눠서|단계별로|세분화|break down|divide|split into parts - Break complex problems into sub-problems',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            problem: { type: 'string', description: 'Complex problem to break down' },
-            maxDepth: { type: 'number', description: 'Maximum breakdown depth' },
-            approach: { type: 'string', description: 'Breakdown approach', enum: ['sequential', 'hierarchical', 'dependency-based'] }
-        },
-        required: ['problem']
-    },
-    annotations: {
-        title: 'Break Down Problem',
-        audience: ['user', 'assistant']
-    }
-};
-export async function breakDownProblem(args) {
-    const { problem: breakdownProblem, maxDepth = 3, approach = 'hierarchical' } = args;
-    // 코드로 추정되는 입력이면 AST 기반 구조 분해 시도
-    let codeStructureSubProblems = null;
-    if (breakdownProblem.includes('function') || breakdownProblem.includes('class') || breakdownProblem.includes('=>')) {
-        try {
-            const sourceFile = AST_PROJECT.createSourceFile('temp.ts', breakdownProblem, {
-                overwrite: true,
-                scriptKind: ScriptKind.TS
-            });
-            const funcs = sourceFile.getFunctions();
-            const classes = sourceFile.getClasses();
-            const vars = sourceFile.getVariableDeclarations();
-            codeStructureSubProblems = [];
-            funcs.forEach((f, i) => {
-                codeStructureSubProblems.push({
-                    id: `codeFunc${i + 1}`,
-                    title: `함수 분석: ${f.getName() || '익명함수'}`,
-                    description: f.getText().slice(0, 100) + (f.getText().length > 100 ? '...' : ''),
-                    complexity: 'medium',
-                    priority: 'high',
-                    dependencies: []
-                });
-            });
-            classes.forEach((c, i) => {
-                codeStructureSubProblems.push({
-                    id: `codeClass${i + 1}`,
-                    title: `클래스 분석: ${c.getName() || '익명클래스'}`,
-                    description: c.getText().slice(0, 100) + (c.getText().length > 100 ? '...' : ''),
-                    complexity: 'high',
-                    priority: 'high',
-                    dependencies: []
-                });
-            });
-            vars.forEach((v, i) => {
-                codeStructureSubProblems.push({
-                    id: `codeVar${i + 1}`,
-                    title: `변수 분석: ${v.getName()}`,
-                    description: v.getText().slice(0, 100) + (v.getText().length > 100 ? '...' : ''),
-                    complexity: 'low',
-                    priority: 'medium',
-                    dependencies: []
-                });
-            });
-            if (codeStructureSubProblems.length === 0)
-                codeStructureSubProblems = null;
-        }
-        catch (e) {
-            codeStructureSubProblems = null;
-        }
-    }
-    const generateSubProblems = (parentProblem, depth, maxDepth) => {
-        if (depth >= maxDepth)
-            return null;
-        const subProblems = [
-            {
-                id: `${depth}.1`,
-                title: `Understanding ${parentProblem}`,
-                description: `Analyze and understand the core aspects of ${parentProblem}`,
-                complexity: 'low',
-                priority: 'high',
-                dependencies: []
-            },
-            {
-                id: `${depth}.2`,
-                title: `Planning solution for ${parentProblem}`,
-                description: `Create detailed plan to solve ${parentProblem}`,
-                complexity: 'medium',
-                priority: 'high',
-                dependencies: [`${depth}.1`]
-            },
-            {
-                id: `${depth}.3`,
-                title: `Implementing solution for ${parentProblem}`,
-                description: `Execute the planned solution for ${parentProblem}`,
-                complexity: 'high',
-                priority: 'medium',
-                dependencies: [`${depth}.2`]
-            }
-        ];
-        if (depth < maxDepth - 1) {
-            subProblems.forEach((subProblem) => {
-                subProblem.subProblems = generateSubProblems(subProblem.title, depth + 1, maxDepth);
-            });
-        }
-        return subProblems;
-    };
-    const problemBreakdown = {
-        action: 'break_down_problem',
-        problem: breakdownProblem,
-        approach,
-        maxDepth,
-        breakdown: {
-            rootProblem: {
-                id: '0',
-                title: breakdownProblem,
-                description: `Root problem: ${breakdownProblem}`,
-                complexity: 'high',
-                subProblems: codeStructureSubProblems || generateSubProblems(breakdownProblem, 1, maxDepth)
-            }
-        },
-        executionOrder: approach === 'dependency-based' ?
-            ['Understanding phase', 'Planning phase', 'Implementation phase'] :
-            approach === 'sequential' ?
-                ['Step 1', 'Step 2', 'Step 3', '...'] :
-                ['Top-level analysis', 'Mid-level breakdown', 'Detailed tasks'],
-        status: 'success'
-    };
-    const formatSubProblems = (subs, indent = 0) => {
-        if (!subs)
-            return '';
-        return subs.map(s => `${'  '.repeat(indent)}- ${s.title} (${s.complexity}, ${s.priority})${s.subProblems ? '\n' + formatSubProblems(s.subProblems, indent + 1) : ''}`).join('\n');
-    };
-    return {
-        content: [{ type: 'text', text: `Problem: ${breakdownProblem}\nApproach: ${approach}\nMax Depth: ${maxDepth}\n\nBreakdown:\n${formatSubProblems(problemBreakdown.breakdown.rootProblem.subProblems)}\n\nExecution: ${problemBreakdown.executionOrder.join(' → ')}` }]
-    };
-}

package/mcp/dist/tools/thinking/createThinkingChain.js

@@ -1,39 +0,0 @@
-// Sequential thinking tool - completely independent
-export const createThinkingChainDefinition = {
-    name: 'create_thinking_chain',
-    description: '생각 과정|사고 흐름|연쇄적으로|thinking process|chain of thought|reasoning chain - Create sequential thinking chain',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            topic: { type: 'string', description: 'Topic to think about' },
-            steps: { type: 'number', description: 'Number of thinking steps' }
-        },
-        required: ['topic']
-    },
-    annotations: {
-        title: 'Create Thinking Chain',
-        audience: ['user', 'assistant']
-    }
-};
-export async function createThinkingChain(args) {
-    const { topic, steps = 5 } = args;
-    const thinkingChain = {
-        action: 'create_thinking_chain',
-        topic,
-        steps,
-        chain: Array.from({ length: steps }, (_, i) => ({
-            step: i + 1,
-            title: `Step ${i + 1}: Analyze ${topic}`,
-            content: `Think about ${topic} from perspective ${i + 1}`,
-            questions: [
-                `What are the key aspects of ${topic}?`,
-                `How does this relate to the overall problem?`,
-                `What are the potential implications?`
-            ]
-        })),
-        status: 'success'
-    };
-    return {
-        content: [{ type: 'text', text: `Topic: ${topic}\nSteps: ${steps}\n\n${thinkingChain.chain.map(s => `${s.step}. ${s.title}\n   ${s.content}\n   Q: ${s.questions.join(', ')}`).join('\n\n')}` }]
-    };
-}

package/mcp/dist/tools/thinking/formatAsPlan.js

@@ -1,73 +0,0 @@
-// Sequential thinking tool - completely independent
-export const formatAsPlanDefinition = {
-    name: 'format_as_plan',
-    description: '계획으로|정리해줘|체크리스트|format as plan|make a plan|organize this|checklist - Format content into clear plans',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            content: { type: 'string', description: 'Content to format as a plan' },
-            priority: { type: 'string', description: 'Default priority level', enum: ['high', 'medium', 'low'] },
-            includeTimeEstimates: { type: 'boolean', description: 'Include time estimates for each step' },
-            includeCheckboxes: { type: 'boolean', description: 'Include checkboxes for tracking progress' }
-        },
-        required: ['content']
-    },
-    annotations: {
-        title: 'Format as Plan',
-        audience: ['user', 'assistant']
-    }
-};
-export async function formatAsPlan(args) {
-    const { content: planContent, priority = 'medium', includeTimeEstimates = true, includeCheckboxes = true } = args;
-    // Parse content into actionable steps
-    const sentences = planContent.split(/[.!?]+/).filter(s => s.trim().length > 10);
-    const planSteps = sentences.map((sentence, index) => {
-        const stepNumber = index + 1;
-        const cleanSentence = sentence.trim();
-        // Estimate time based on content complexity
-        let timeEstimate = '5min';
-        if (cleanSentence.length > 100)
-            timeEstimate = '15min';
-        else if (cleanSentence.length > 50)
-            timeEstimate = '10min';
-        // Detect priority keywords
-        let stepPriority = priority;
-        if (cleanSentence.match(/urgent|critical|important|first|must/i))
-            stepPriority = 'high';
-        else if (cleanSentence.match(/later|eventually|nice|optional/i))
-            stepPriority = 'low';
-        // Format step
-        let formattedStep = includeCheckboxes ? `${stepNumber}. □ ` : `${stepNumber}. `;
-        formattedStep += cleanSentence;
-        if (includeTimeEstimates)
-            formattedStep += ` (${stepPriority.toUpperCase()}, ${timeEstimate})`;
-        return {
-            number: stepNumber,
-            content: cleanSentence,
-            priority: stepPriority,
-            timeEstimate,
-            formatted: formattedStep
-        };
-    });
-    // Calculate total time
-    const totalMinutes = planSteps.reduce((total, step) => {
-        const minutes = parseInt(step.timeEstimate.replace('min', ''));
-        return total + minutes;
-    }, 0);
-    const planResult = {
-        action: 'format_as_plan',
-        originalContent: planContent,
-        formattedPlan: planSteps.map((s) => s.formatted).join('\n'),
-        steps: planSteps.length,
-        totalEstimatedTime: `${totalMinutes} minutes`,
-        breakdown: {
-            high: planSteps.filter((s) => s.priority === 'high').length,
-            medium: planSteps.filter((s) => s.priority === 'medium').length,
-            low: planSteps.filter((s) => s.priority === 'low').length
-        },
-        status: 'success'
-    };
-    return {
-        content: [{ type: 'text', text: `${planResult.formattedPlan}\n\nTotal: ${planResult.totalEstimatedTime} | Priority: ${planResult.breakdown.high}H ${planResult.breakdown.medium}M ${planResult.breakdown.low}L` }]
-    };
-}

package/mcp/dist/tools/thinking/stepByStepAnalysis.js

@@ -1,58 +0,0 @@
-// Sequential thinking tool - completely independent
-export const stepByStepAnalysisDefinition = {
-    name: 'step_by_step_analysis',
-    description: '단계별|차근차근|하나씩|step by step|one by one|gradually - Perform detailed step-by-step analysis',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            task: { type: 'string', description: 'Task to analyze step by step' },
-            context: { type: 'string', description: 'Additional context for the task' },
-            detailLevel: { type: 'string', description: 'Level of detail', enum: ['basic', 'detailed', 'comprehensive'] }
-        },
-        required: ['task']
-    },
-    annotations: {
-        title: 'Step-by-Step Analysis',
-        audience: ['user', 'assistant']
-    }
-};
-export async function stepByStepAnalysis(args) {
-    const { task, context = '', detailLevel = 'detailed' } = args;
-    const stepCount = detailLevel === 'basic' ? 3 : detailLevel === 'detailed' ? 5 : 7;
-    const stepAnalysis = {
-        action: 'step_by_step_analysis',
-        task,
-        context,
-        detailLevel,
-        steps: Array.from({ length: stepCount }, (_, i) => {
-            const stepNum = i + 1;
-            return {
-                stepNumber: stepNum,
-                title: `Step ${stepNum}: ${task} - Phase ${stepNum}`,
-                description: `Detailed analysis of ${task} in step ${stepNum}`,
-                actions: [
-                    `Analyze requirements for step ${stepNum}`,
-                    `Identify dependencies and prerequisites`,
-                    `Execute the planned actions`,
-                    `Validate results and check for issues`,
-                    `Prepare for next step`
-                ],
-                checkpoints: [
-                    `Verify step ${stepNum} requirements are met`,
-                    `Confirm outputs are as expected`,
-                    `Check for any blocking issues`
-                ],
-                estimatedTime: detailLevel === 'comprehensive' ? `${stepNum * 10} minutes` : `${stepNum * 5} minutes`
-            };
-        }),
-        summary: {
-            totalSteps: stepCount,
-            estimatedTotalTime: detailLevel === 'comprehensive' ? `${stepCount * 35} minutes` : `${stepCount * 20} minutes`,
-            complexity: detailLevel === 'basic' ? 'low' : detailLevel === 'detailed' ? 'medium' : 'high'
-        },
-        status: 'success'
-    };
-    return {
-        content: [{ type: 'text', text: `Task: ${task}\nDetail: ${detailLevel}\nSteps: ${stepCount}\n\n${stepAnalysis.steps.map(s => `Step ${s.stepNumber}: ${s.title}\n  Time: ${s.estimatedTime}\n  Actions: ${s.actions.join(', ')}\n  Checkpoints: ${s.checkpoints.join(', ')}`).join('\n\n')}\n\nTotal Time: ${stepAnalysis.summary.estimatedTotalTime} | Complexity: ${stepAnalysis.summary.complexity}` }]
-    };
-}

package/mcp/dist/tools/thinking/thinkAloudProcess.js

@@ -1,75 +0,0 @@
-// Sequential thinking tool - completely independent
-export const thinkAloudProcessDefinition = {
-    name: 'think_aloud_process',
-    description: '생각해봐|고민해봐|어떻게 생각해|think about it|let me think|reasoning - Generate think-aloud reasoning process',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            scenario: { type: 'string', description: 'Scenario or problem to think through' },
-            perspective: { type: 'string', description: 'Thinking perspective', enum: ['analytical', 'creative', 'systematic', 'critical'] },
-            verbosity: { type: 'string', description: 'Verbosity level', enum: ['concise', 'moderate', 'verbose'] }
-        },
-        required: ['scenario']
-    },
-    annotations: {
-        title: 'Think Aloud',
-        audience: ['user', 'assistant']
-    }
-};
-export async function thinkAloudProcess(args) {
-    const { scenario, perspective = 'analytical', verbosity = 'moderate' } = args;
-    const thoughtCount = verbosity === 'concise' ? 3 : verbosity === 'moderate' ? 5 : 8;
-    const thinkAloudProcess = {
-        action: 'think_aloud_process',
-        scenario,
-        perspective,
-        verbosity,
-        thoughtProcess: Array.from({ length: thoughtCount }, (_, i) => {
-            const thoughtNum = i + 1;
-            let thoughtStyle = '';
-            switch (perspective) {
-                case 'analytical':
-                    thoughtStyle = `Analyzing: Let me examine ${scenario} systematically...`;
-                    break;
-                case 'creative':
-                    thoughtStyle = `Brainstorming: What if I approach ${scenario} differently...`;
-                    break;
-                case 'systematic':
-                    thoughtStyle = `Step ${thoughtNum}: Following systematic approach to ${scenario}...`;
-                    break;
-                case 'critical':
-                    thoughtStyle = `Questioning: What assumptions am I making about ${scenario}...`;
-                    break;
-            }
-            return {
-                stepNumber: thoughtNum,
-                thought: thoughtStyle,
-                reasoning: `In step ${thoughtNum}, I need to consider the implications of ${scenario} from a ${perspective} perspective`,
-                questions: [
-                    `What do I know about this aspect of ${scenario}?`,
-                    `What don't I know yet?`,
-                    `What should I explore next?`
-                ],
-                conclusions: [
-                    `Based on current analysis...`,
-                    `This leads me to think that...`,
-                    `Next I should focus on...`
-                ],
-                confidence: Math.min(95, 60 + (thoughtNum * 5))
-            };
-        }),
-        metacognition: {
-            thinkingStyle: perspective,
-            processEffectiveness: verbosity === 'verbose' ? 'highly detailed' : verbosity === 'moderate' ? 'balanced' : 'efficient',
-            nextSteps: [
-                'Review thinking process for gaps',
-                'Validate conclusions against evidence',
-                'Plan concrete actions based on analysis'
-            ]
-        },
-        status: 'success'
-    };
-    return {
-        content: [{ type: 'text', text: `Scenario: ${scenario}\nPerspective: ${perspective}\nThoughts: ${thoughtCount}\n${thinkAloudProcess.thoughtProcess.map((t, i) => `${i + 1}. ${t.thought} (confidence: ${t.confidence}%)`).join('\n')}\n\nNext: ${thinkAloudProcess.metacognition.nextSteps.join(', ')}` }]
-    };
-}