sequential-thinking-engine-custom
Version:
Sequential Thinking Engine v3.0 - 完全実装5軸思考品質評価システム with Claude Code サブエージェント統合
398 lines • 14.5 kB
JavaScript
/**
* SubAgent Manager - サブエージェント統合管理システム
* GitHub MCP Auto Git Systemのものをベースに、Sequential Thinking専用に最適化
*/
import { promises as fs } from 'fs';
import { join, basename } from 'path';
export class SubAgentManager {
agentsPath;
projectPath;
loadedAgents = new Map();
constructor(agentsPath, projectPath) {
this.agentsPath = agentsPath;
this.projectPath = projectPath;
}
/**
* エージェントの初期化と読み込み
*/
async initialize() {
console.log('🤖 サブエージェントを初期化中...');
try {
const agentFiles = await this.findAgentFiles();
for (const file of agentFiles) {
try {
const agent = await this.loadAgentDefinition(file);
this.loadedAgents.set(agent.name, agent);
console.log(`✅ エージェント読み込み完了: ${agent.name}`);
}
catch (error) {
console.warn(`⚠️ エージェント読み込み失敗: ${file}`, error);
}
}
console.log(`🚀 ${this.loadedAgents.size}個のサブエージェントが利用可能`);
}
catch (error) {
console.error('❌ サブエージェント初期化に失敗:', error);
throw error;
}
}
/**
* エージェントファイルの検索
*/
async findAgentFiles() {
try {
const files = await fs.readdir(this.agentsPath);
return files
.filter(file => file.endsWith('.md'))
.map(file => join(this.agentsPath, file));
}
catch (error) {
console.warn(`⚠️ エージェントディレクトリが見つかりません: ${this.agentsPath}`);
return [];
}
}
/**
* エージェント定義の読み込み
*/
async loadAgentDefinition(filePath) {
const content = await fs.readFile(filePath, 'utf-8');
const { frontmatter, body } = this.parseFrontmatter(content);
return {
name: frontmatter.name || basename(filePath, '.md'),
description: frontmatter.description || '',
version: frontmatter.version || '1.0.0',
author: frontmatter.author || 'Unknown',
type: frontmatter.type || 'general',
content: body,
metadata: frontmatter
};
}
/**
* Frontmatterの解析
*/
parseFrontmatter(content) {
const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
const match = content.match(frontmatterRegex);
if (!match) {
return {
frontmatter: {},
body: content
};
}
const [, frontmatterText, body] = match;
const frontmatter = {};
// 簡単なYAML解析（productionでは適切なYAMLパーサーを使用）
if (frontmatterText) {
frontmatterText.split('\n').forEach(line => {
const colonIndex = line.indexOf(':');
if (colonIndex > 0) {
const key = line.substring(0, colonIndex).trim();
const value = line.substring(colonIndex + 1).trim();
frontmatter[key] = value;
}
});
}
return { frontmatter, body: body || content };
}
/**
* エージェントの実行
*/
async executeAgent(agentName, input) {
const startTime = Date.now();
try {
const agent = this.loadedAgents.get(agentName);
if (!agent) {
throw new Error(`エージェント '${agentName}' が見つかりません`);
}
console.log(`🔄 エージェント実行中: ${agentName}`);
// エージェントタイプに応じた実行
const result = await this.executeAgentByType(agent, input);
const executionTime = Date.now() - startTime;
console.log(`✅ エージェント実行完了: ${agentName} (${executionTime}ms)`);
return {
success: true,
result,
executionTime,
errors: [],
warnings: [],
confidence: result.confidence || 85
};
}
catch (error) {
const executionTime = Date.now() - startTime;
console.error(`❌ エージェント実行エラー: ${agentName}`, error);
return {
success: false,
result: null,
executionTime,
errors: [error instanceof Error ? error.message : String(error)],
warnings: [],
confidence: 0
};
}
}
/**
* エージェントタイプ別の実行ロジック
*/
async executeAgentByType(agent, input) {
switch (agent.type) {
case 'evaluator':
return this.executeEvaluatorAgent(agent, input);
case 'advisor':
return this.executeAdvisorAgent(agent, input);
case 'optimizer':
return this.executeOptimizerAgent(agent, input);
default:
return this.executeGeneralAgent(agent, input);
}
}
/**
* 評価系エージェントの実行
*/
async executeEvaluatorAgent(agent, input) {
// thinking-quality-evaluator の実行ロジック
if (agent.name === 'thinking-quality-evaluator') {
return this.executeQualityEvaluator(input);
}
return { type: 'evaluation', result: 'Generic evaluation result' };
}
/**
* アドバイス系エージェントの実行
*/
async executeAdvisorAgent(agent, input) {
// thinking-strategy-advisor の実行ロジック
if (agent.name === 'thinking-strategy-advisor') {
return this.executeStrategyAdvisor(input);
}
return { type: 'advice', result: 'Generic advice result' };
}
/**
* 最適化系エージェントの実行
*/
async executeOptimizerAgent(agent, input) {
// thinking-process-optimizer の実行ロジック
if (agent.name === 'thinking-process-optimizer') {
return this.executeProcessOptimizer(input);
}
return { type: 'optimization', result: 'Generic optimization result' };
}
/**
* 汎用エージェントの実行
*/
async executeGeneralAgent(agent, input) {
return { type: 'general', result: 'Generic agent result' };
}
/**
* Quality Evaluator の具体的な実行ロジック
*/
async executeQualityEvaluator(input) {
const { steps } = input;
// 簡単な品質評価実装（実際はより高度なロジック）
const quality = {
clarity: this.evaluateClarity(steps),
depth: this.evaluateDepth(steps),
logic: this.evaluateLogic(steps),
creativity: this.evaluateCreativity(steps),
practicality: this.evaluatePracticality(steps),
overall: 0
};
quality.overall = Math.round((quality.clarity + quality.depth + quality.logic +
quality.creativity + quality.practicality) / 5);
return {
quality,
strengths: this.identifyStrengths(quality),
weaknesses: this.identifyWeaknesses(quality),
recommendations: this.generateRecommendations(quality),
nextStepSuggestions: this.suggestNextSteps(quality),
confidence: 87
};
}
/**
* Strategy Advisor の具体的な実行ロジック
*/
async executeStrategyAdvisor(input) {
const { initialThought, context, personalHistory } = input;
// 思考内容の分析
const analysis = this.analyzeThinkingContext(initialThought, context);
// 最適戦略の決定
const recommendedStrategy = this.determineOptimalStrategy(analysis, personalHistory);
return {
recommendedStrategy: {
type: recommendedStrategy.type,
confidence: recommendedStrategy.confidence,
reasoning: recommendedStrategy.reasoning,
expectedOutcomes: recommendedStrategy.expectedOutcomes
},
adaptations: this.generateAdaptations(analysis),
personalOptimization: this.personalOptimization(personalHistory),
confidence: 82
};
}
/**
* Process Optimizer の具体的な実行ロジック
*/
async executeProcessOptimizer(input) {
const { steps, strategy } = input;
// プロセス効率の分析
const efficiency = this.analyzeProcessEfficiency(steps);
// 最適化提案の生成
const optimizations = this.generateOptimizations(steps, strategy, efficiency);
return {
optimizations,
personalInsights: this.generatePersonalInsights(steps),
recommendations: this.generateProcessRecommendations(efficiency),
confidence: 79
};
}
/**
* エージェント状態の取得
*/
async getAgentStatus() {
if (this.loadedAgents.size === 0) {
await this.initialize();
}
return {
available: Array.from(this.loadedAgents.keys()),
errors: [], // エラー履歴があれば追加
total: this.loadedAgents.size
};
}
/**
* 並列エージェント実行
*/
async executeMultipleAgents(agents) {
const executions = agents.map(({ name, input }) => this.executeAgent(name, input));
try {
return await Promise.all(executions);
}
catch (error) {
console.error('❌ 並列エージェント実行でエラー:', error);
return [];
}
}
// ユーティリティメソッド群
evaluateClarity(steps) {
// 明確性の評価ロジック
const baseScore = 75;
const lengthBonus = Math.min(10, steps.length * 2);
return Math.min(100, baseScore + lengthBonus);
}
evaluateDepth(steps) {
// 深度の評価ロジック
return Math.min(100, 70 + steps.length * 3);
}
evaluateLogic(steps) {
// 論理性の評価ロジック
return Math.min(100, 80 + steps.length * 2);
}
evaluateCreativity(steps) {
// 創造性の評価ロジック
return Math.min(100, 65 + Math.random() * 20);
}
evaluatePracticality(steps) {
// 実用性の評価ロジック
return Math.min(100, 75 + steps.length * 1.5);
}
identifyStrengths(quality) {
const strengths = [];
if (quality.clarity > 80)
strengths.push('明確な表現');
if (quality.logic > 80)
strengths.push('論理的構造');
if (quality.practicality > 80)
strengths.push('実用性重視');
return strengths;
}
identifyWeaknesses(quality) {
const weaknesses = [];
if (quality.creativity < 70)
weaknesses.push('創造性の向上余地');
if (quality.depth < 70)
weaknesses.push('より深い分析が可能');
return weaknesses;
}
generateRecommendations(quality) {
const recommendations = [];
if (quality.creativity < 70) {
recommendations.push('異なる視点からのアプローチを検討');
}
if (quality.depth < 70) {
recommendations.push('より詳細な分析を追加');
}
return recommendations;
}
suggestNextSteps(quality) {
return ['具体的な実装例を検討', 'リスク分析の実施'];
}
analyzeThinkingContext(thought, context) {
return {
complexity: thought.length > 100 ? 'high' : 'medium',
domain: context || 'general',
urgency: 'medium'
};
}
determineOptimalStrategy(analysis, history) {
return {
type: 'analytical',
confidence: 0.85,
reasoning: '複雑な問題に対して段階的分析が効果的',
expectedOutcomes: ['論理的な問題分解', '体系的な解決策']
};
}
generateAdaptations(analysis) {
return [
{
trigger: '思考が停滞した場合',
action: '創造的アプローチに切り替え',
implementation: 'ブレインストーミング技法の導入'
}
];
}
personalOptimization(history) {
return {
strengthsToLeverage: ['論理性', '体系性'],
areasToImprove: ['創造性', '速度'],
customizedApproach: '分析的ベースに創造的要素を段階的に導入'
};
}
analyzeProcessEfficiency(steps) {
return {
timeEfficiency: 0.8,
qualityConsistency: 0.85,
bottlenecks: ['分析フェーズで時間超過傾向']
};
}
generateOptimizations(steps, strategy, efficiency) {
return [
{
type: 'efficiency',
priority: 'high',
recommendation: '並列思考プロセスの導入',
expectedBenefit: {
timeReduction: '20%',
qualityImprovement: '5%'
}
}
];
}
generatePersonalInsights(steps) {
return {
strengths: ['体系的アプローチ', '論理的構造'],
improvementAreas: ['創造性', '効率性'],
learningProgress: {
recentImprovements: ['分析速度 +10%'],
nextFocusAreas: ['創造性向上']
}
};
}
generateProcessRecommendations(efficiency) {
return [
{
immediate: '次回セッションで時間配分を調整',
shortTerm: '効率的な思考パターンの練習',
longTerm: '個人最適化フレームワークの構築'
}
];
}
}
//# sourceMappingURL=subagent-manager.js.map