flowmind 1.2.3 → 1.4.0

package/skills/git-review/index.js

@@ -0,0 +1,73 @@
+/**
+ * Git Review Skill
+ * Reviews commit history, analyzes changes, ensures code quality
+ */
+
+const { execSync } = require('child_process');
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /git\s*review|commit.*review|代码提交|提交审查|review.*commit|检查提交/i.test(input);
+  },
+
+  async execute(input, context) {
+    const count = extractCount(input) || 5;
+
+    try {
+      const logRaw = execSync(
+        `git log --oneline -${count} --format="%H|%s|%an|%ai"`,
+        { encoding: 'utf-8', timeout: 10000 }
+      ).trim();
+
+      if (!logRaw) {
+        return { type: 'result', skill: 'git-review', message: 'No commits found', input, timestamp: new Date().toISOString() };
+      }
+
+      const commits = logRaw.split('\n').map(line => {
+        const [hash, subject, author, date] = line.split('|');
+        return { hash: hash?.slice(0, 8), subject, author, date };
+      });
+
+      const issues = [];
+      const good = [];
+
+      commits.forEach(c => {
+        // Check conventional commit format
+        const conventional = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|build)(\(.+\))?: .+/;
+        if (!conventional.test(c.subject)) {
+          issues.push({ hash: c.hash, type: 'format', message: `Non-conventional commit message: "${c.subject}"` });
+        } else {
+          good.push({ hash: c.hash, message: c.subject });
+        }
+
+        // Check length
+        if (c.subject && c.subject.length > 72) {
+          issues.push({ hash: c.hash, type: 'length', message: `Subject too long (${c.subject.length} chars)` });
+        }
+      });
+
+      return {
+        type: 'result',
+        skill: 'git-review',
+        message: `Reviewed ${commits.length} commits: ${good.length} good, ${issues.length} issues`,
+        data: { commits, issues, good, summary: { total: commits.length, good: good.length, issues: issues.length } },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    } catch (e) {
+      return {
+        type: 'error',
+        skill: 'git-review',
+        message: `Git review failed: ${e.message}`,
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+};
+
+function extractCount(input) {
+  const match = input.match(/(\d+)\s*(?:个|条|commits?|次)/i) || input.match(/-(\d+)/);
+  return match ? parseInt(match[1]) : null;
+}

package/skills/learning-engine/index.js

@@ -0,0 +1,50 @@
+/**
+ * Learning Engine Skill
+ * Delegates to core LearningEngine for detecting and recording learning patterns
+ */
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    const lower = input.toLowerCase();
+    const patterns = [
+      /不[对是]/, /错[了误]/, /应该[是用]/, /改[成为]/, /优化/, /改进/,
+      /记住/, /学习/, /纠正/, /prefer/, /learn/, /correct/, /remember/
+    ];
+    return patterns.some(p => p.test(lower));
+  },
+
+  async execute(input, context) {
+    const learning = context.flowmind?.learning;
+    if (!learning) {
+      return {
+        type: 'error',
+        skill: 'learning-engine',
+        message: 'Learning engine not available',
+        input
+      };
+    }
+
+    const result = await learning.detectLearning(input, context);
+
+    if (result) {
+      return {
+        type: 'learning',
+        skill: 'learning-engine',
+        learningType: result.type,
+        message: result.message || `Detected ${result.type} learning pattern`,
+        data: result,
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'learning-engine',
+      message: 'No learning pattern detected in input',
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};

package/skills/learning-feedback/index.js

@@ -0,0 +1,83 @@
+/**
+ * Learning Feedback Skill
+ * Captures user corrections, feedback, and refinement suggestions.
+ * Overlaps with learning-engine but focuses on feedback capture and binding.
+ */
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    const lower = input.toLowerCase();
+    const feedbackPatterns = [
+      /不对/, /错了/, /应该是/, /不要/, /别这样/,
+      /下次/, /以后/, /记得/, /别再/, /改成/,
+      /wrong/, /should be/, /don't/, /next time/, /change to/
+    ];
+    return feedbackPatterns.some(p => p.test(lower));
+  },
+
+  async execute(input, context) {
+    const learning = context.flowmind?.learning;
+    if (!learning) {
+      return {
+        type: 'error',
+        skill: 'learning-feedback',
+        message: 'Learning engine not available',
+        input
+      };
+    }
+
+    // Detect correction patterns
+    const correction = learning.detectCorrection(input);
+    if (correction) {
+      const record = await learning.recordCorrection(correction, context);
+      return {
+        type: 'learning',
+        skill: 'learning-feedback',
+        learningType: 'correction',
+        message: `Recorded correction: ${correction.summary || 'user feedback captured'}`,
+        data: record,
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    // Detect preference patterns
+    const preference = learning.detectPreference(input);
+    if (preference) {
+      const record = await learning.recordPreference(preference, context);
+      return {
+        type: 'learning',
+        skill: 'learning-feedback',
+        learningType: 'preference',
+        message: `Recorded preference: ${preference.type} = ${preference.value}`,
+        data: record,
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    // Detect scene mapping
+    const scene = learning.detectSceneMapping(input);
+    if (scene) {
+      const record = await learning.recordSceneMapping(scene, context);
+      return {
+        type: 'learning',
+        skill: 'learning-feedback',
+        learningType: 'scene_mapping',
+        message: `Recorded scene mapping for skill: ${scene.skill}`,
+        data: record,
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'learning-feedback',
+      message: 'No feedback pattern detected',
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};

package/skills/log-audit/index.js

@@ -0,0 +1,88 @@
+/**
+ * Log Audit Skill
+ * Analyzes application logs, traces requests, debugs performance issues
+ */
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /日志分析|log.*audit|日志查询|查日志|log.*analy|trace.*id|调用链/i.test(input);
+  },
+
+  async execute(input, context) {
+    const logService = context.componentRegistry?.getAdapter('logService');
+    const params = parseLogParams(input);
+
+    if (!logService && !params.mock) {
+      return {
+        type: 'result',
+        skill: 'log-audit',
+        message: 'Log service not configured. Connect an SLS/ELK log service first.',
+        data: { params, hint: 'Use `flowmind resource` to configure log service connections' },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    // If we have a log service, format the query for MCP tools
+    if (params.traceId) {
+      return {
+        type: 'result',
+        skill: 'log-audit',
+        message: `Trace query for: ${params.traceId}`,
+        data: {
+          action: 'trace',
+          traceId: params.traceId,
+          query: `* and "${params.traceId}"`,
+          timeRange: params.timeRange || 'last 1 hour',
+          endpoint: params.endpoint || 'cn-shenzhen.log.aliyuncs.com'
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'log-audit',
+      message: `Log query: ${params.service || 'all services'}, ${params.level || 'all levels'}, ${params.timeRange || 'last 1 hour'}`,
+      data: {
+        action: 'query',
+        query: buildSLSQuery(params),
+        timeRange: params.timeRange || 'last 1 hour',
+        endpoint: params.endpoint || 'cn-shenzhen.log.aliyuncs.com',
+        limit: params.limit || 100
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseLogParams(input) {
+  const params = {};
+  const traceMatch = input.match(/(?:trace[_-]?id|调用链)\s*[:=]?\s*(\S+)/i);
+  if (traceMatch) params.traceId = traceMatch[1];
+
+  const serviceMatch = input.match(/(?:服务|service)\s*[:=]?\s*(\S+)/i);
+  if (serviceMatch) params.service = serviceMatch[1];
+
+  const levelMatch = input.match(/(?:级别|level)\s*[:=]?\s*(ERROR|WARN|INFO|DEBUG)/i);
+  if (levelMatch) params.level = levelMatch[1].toUpperCase();
+
+  const timeMatch = input.match(/(?:最近|last)\s*(\d+)\s*(分钟|小时|分钟|min|hour)/i);
+  if (timeMatch) params.timeRange = `last ${timeMatch[1]} ${timeMatch[2]}`;
+
+  const keywordMatch = input.match(/(?:关键词|keyword|搜索|search)\s*[:=]?\s*(.+?)(?:\s*$)/i);
+  if (keywordMatch) params.keyword = keywordMatch[1].trim();
+
+  return params;
+}
+
+function buildSLSQuery(params) {
+  const parts = [];
+  if (params.service) parts.push(`service: ${params.service}`);
+  if (params.level) parts.push(`level: ${params.level}`);
+  if (params.keyword) parts.push(`"${params.keyword}"`);
+  return parts.length > 0 ? parts.join(' and ') : '*';
+}

package/skills/project-review/index.js

@@ -0,0 +1,105 @@
+/**
+ * Project Review Skill
+ * Analyzes project health, dependencies, and overall quality
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /项目审查|project review|项目健康|health check|依赖检查|dependency/i.test(input);
+  },
+
+  async execute(input, context) {
+    const projectDir = extractProjectDir(input) || process.cwd();
+    const checks = [];
+    let score = 100;
+
+    // Check package.json
+    const pkgPath = path.join(projectDir, 'package.json');
+    if (await fs.pathExists(pkgPath)) {
+      const pkg = await fs.readJson(pkgPath);
+
+      // Check for missing description
+      if (!pkg.description) {
+        checks.push({ type: 'warning', name: 'Missing description', impact: -5 });
+        score -= 5;
+      }
+
+      // Check for missing license
+      if (!pkg.license) {
+        checks.push({ type: 'warning', name: 'Missing license', impact: -5 });
+        score -= 5;
+      }
+
+      // Check for missing test script
+      if (!pkg.scripts?.test || pkg.scripts.test === 'echo "Error: no test specified"') {
+        checks.push({ type: 'warning', name: 'No test script configured', impact: -10 });
+        score -= 10;
+      }
+
+      // Check for missing lint script
+      if (!pkg.scripts?.lint) {
+        checks.push({ type: 'info', name: 'No lint script configured', impact: -5 });
+        score -= 5;
+      }
+
+      // Check dependency count
+      const deps = Object.keys(pkg.dependencies || {});
+      const devDeps = Object.keys(pkg.devDependencies || {});
+      checks.push({ type: 'info', name: `Dependencies: ${deps.length} prod, ${devDeps.length} dev` });
+
+      // Check for outdated (if npm is available)
+      try {
+        const outdated = execSync('npm outdated --json 2>/dev/null || echo "{}"', {
+          encoding: 'utf-8', cwd: projectDir, timeout: 30000
+        });
+        const outdatedPkgs = JSON.parse(outdated);
+        const count = Object.keys(outdatedPkgs).length;
+        if (count > 0) {
+          checks.push({ type: 'warning', name: `${count} outdated package(s)`, impact: -5 });
+          score -= 5;
+        }
+      } catch {}
+    } else {
+      checks.push({ type: 'error', name: 'No package.json found', impact: -20 });
+      score -= 20;
+    }
+
+    // Check for README
+    if (!(await fs.pathExists(path.join(projectDir, 'README.md')))) {
+      checks.push({ type: 'warning', name: 'No README.md', impact: -10 });
+      score -= 10;
+    }
+
+    // Check for .git
+    if (!(await fs.pathExists(path.join(projectDir, '.git')))) {
+      checks.push({ type: 'info', name: 'Not a git repository' });
+    }
+
+    // Check for .gitignore
+    if (!(await fs.pathExists(path.join(projectDir, '.gitignore')))) {
+      checks.push({ type: 'warning', name: 'No .gitignore', impact: -5 });
+      score -= 5;
+    }
+
+    score = Math.max(0, score);
+
+    return {
+      type: 'result',
+      skill: 'project-review',
+      message: `Project health score: ${score}/100 (${checks.filter(c => c.type === 'warning' || c.type === 'error').length} issues)`,
+      data: { score, checks, summary: { score, issues: checks.filter(c => c.type !== 'info').length } },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function extractProjectDir(input) {
+  const match = input.match(/(?:项目|project|目录|dir)\s+(.+?)(?:\s|$)/i);
+  return match ? match[1].trim() : null;
+}

package/skills/requirement-analyst/index.js

@@ -0,0 +1,88 @@
+/**
+ * Requirement Analyst Skill
+ * Six-dimensional analysis of requirements, design, and code alignment
+ */
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /需求分析|requirement.*analy|六维分析|需求.*审查|分析需求/i.test(input);
+  },
+
+  async execute(input, context) {
+    const dimensions = [
+      { name: '历史设计原则', weight: 0.15, description: '评估历史设计意图、依据、当前有效性' },
+      { name: '迭代合理性', weight: 0.15, description: '评估迭代驱动力、演进路径、迭代质量' },
+      { name: '可扩展性', weight: 0.20, description: '评估开发扩展性、需求升级扩展性、用户增长扩展性' },
+      { name: '市场路线图', weight: 0.15, description: '评估功能覆盖度、需求趋势、竞争定位' },
+      { name: '需求代码偏差', weight: 0.20, description: '评估功能缺失、过度实现、理解偏差' },
+      { name: '升级脆弱性', weight: 0.15, description: '评估数据模型脆弱性、API不兼容、硬编码陷阱' }
+    ];
+
+    const requirementText = extractRequirement(input);
+
+    if (!requirementText) {
+      return {
+        type: 'result',
+        skill: 'requirement-analyst',
+        message: 'Please provide requirement text or a requirement document path for analysis',
+        data: { dimensions: dimensions.map(d => ({ ...d, score: null })) },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    // Basic analysis based on text content
+    const analysis = dimensions.map(dim => {
+      const keywords = getDimensionKeywords(dim.name);
+      const matches = keywords.filter(k => requirementText.toLowerCase().includes(k));
+      const coverage = Math.min(1, matches.length / Math.max(1, keywords.length * 0.3));
+      const score = Math.round(50 + coverage * 50);
+
+      return {
+        name: dim.name,
+        weight: dim.weight,
+        score,
+        description: dim.description,
+        findings: matches.length > 0 ? [`Found ${matches.length} relevant keywords`] : ['Insufficient data for analysis']
+      };
+    });
+
+    const overallScore = Math.round(
+      analysis.reduce((sum, d) => sum + d.score * d.weight, 0)
+    );
+
+    const priorityActions = [];
+    analysis.filter(d => d.score < 60).forEach(d => {
+      priorityActions.push({ priority: d.score < 40 ? 'P0' : 'P1', dimension: d.name, action: `Improve ${d.name}` });
+    });
+
+    return {
+      type: 'result',
+      skill: 'requirement-analyst',
+      message: `Six-dimensional analysis complete. Overall score: ${overallScore}/100`,
+      data: { overallScore, dimensions: analysis, priorityActions },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function extractRequirement(input) {
+  const jsonMatch = input.match(/\{[\s\S]*\}/);
+  if (jsonMatch) return jsonMatch[0];
+  const textMatch = input.replace(/需求分析|requirement.*analy|分析/gi, '').trim();
+  return textMatch.length > 10 ? textMatch : null;
+}
+
+function getDimensionKeywords(dimName) {
+  const map = {
+    '历史设计原则': ['设计', '架构', '历史', '原理', '依据', 'design', 'architecture'],
+    '迭代合理性': ['迭代', '版本', '功能', '需求', 'iteration', 'feature', 'release'],
+    '可扩展性': ['扩展', '模块', '接口', '性能', 'scalable', 'extensible', 'modular'],
+    '市场路线图': ['市场', '竞争', '路线', '规划', 'market', 'roadmap', 'competitive'],
+    '需求代码偏差': ['偏差', '缺失', '过度', '偏差', 'gap', 'deviation', 'mismatch'],
+    '升级脆弱性': ['脆弱', '兼容', '硬编码', '升级', 'fragile', 'breaking', 'migration']
+  };
+  return map[dimName] || [];
+}

package/skills/resource-bind/index.js

@@ -0,0 +1,60 @@
+/**
+ * Resource Bind Skill
+ * Manage database, Redis, API, and other external resource connections
+ */
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /资源绑定|resource.*bind|数据库.*连接|redis.*连接|连接.*管理|connection.*manage/i.test(input);
+  },
+
+  async execute(input, context) {
+    const registry = context.componentRegistry;
+    const params = parseResourceParams(input);
+
+    if (params.action === 'list') {
+      const components = registry ? registry.getAll() : [];
+      return {
+        type: 'result',
+        skill: 'resource-bind',
+        message: `Found ${components.length} configured component(s)`,
+        data: { components: components.map(c => ({ name: c.name, type: c.type, active: c.active })) },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    if (params.action === 'status') {
+      const status = registry ? registry.getStatus() : {};
+      return {
+        type: 'result',
+        skill: 'resource-bind',
+        message: 'Resource connection status',
+        data: { status },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'resource-bind',
+      message: 'Resource binding. Available actions: list, status',
+      data: {
+        actions: ['list - List all resources', 'status - Show connection status'],
+        supportedTypes: ['MySQL', 'PostgreSQL', 'Redis', 'REST API']
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseResourceParams(input) {
+  const params = {};
+  if (/列表|list|查看|show/i.test(input)) params.action = 'list';
+  if (/状态|status|连接/i.test(input)) params.action = 'status';
+  if (/绑定|bind|添加|add/i.test(input)) params.action = 'bind';
+  return params;
+}

package/skills/sls-log-audit/index.js

@@ -0,0 +1,120 @@
+/**
+ * SLS Log Audit Skill
+ * Query Alibaba Cloud SLS logs, trace ID chain analysis, performance analysis
+ */
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /sls.*日志|sls.*log|阿里云.*日志|trace.*分析|feign.*链|调用链.*分析/i.test(input);
+  },
+
+  async execute(input, context) {
+    const params = parseSLSParams(input);
+
+    // Determine default endpoint based on environment
+    const env = params.env || 'test';
+    const endpointMap = {
+      test: 'cn-shenzhen.log.aliyuncs.com',
+      uat: 'cn-shenzhen.log.aliyuncs.com',
+      gray: 'cn-hongkong.log.aliyuncs.com',
+      prod: 'cn-hongkong.log.aliyuncs.com'
+    };
+    const endpoint = endpointMap[env] || endpointMap.test;
+
+    if (params.traceId) {
+      return {
+        type: 'result',
+        skill: 'sls-log-audit',
+        message: `SLS TraceID chain analysis: ${params.traceId}`,
+        data: {
+          action: 'trace_chain',
+          traceId: params.traceId,
+          query: `* and "${params.traceId}"`,
+          endpoint,
+          project: params.project,
+          logstore: params.logstore,
+          timeRange: params.timeRange || 'last 1 hour'
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    if (params.keyword?.includes('feign') || /feign/i.test(input)) {
+      return {
+        type: 'result',
+        skill: 'sls-log-audit',
+        message: 'Feign call chain extraction',
+        data: {
+          action: 'feign_chain',
+          query: buildFeignQuery(params),
+          endpoint,
+          project: params.project,
+          logstore: params.logstore,
+          timeRange: params.timeRange || 'last 1 hour'
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'sls-log-audit',
+      message: `SLS query: ${params.service || 'all'}, ${params.level || 'all'}, ${params.timeRange || 'last 1 hour'}`,
+      data: {
+        action: 'query',
+        query: buildSLSQuery(params),
+        endpoint,
+        project: params.project,
+        logstore: params.logstore,
+        timeRange: params.timeRange || 'last 1 hour',
+        limit: params.limit || 100
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseSLSParams(input) {
+  const params = {};
+  const traceMatch = input.match(/trace[_-]?id\s*[:=]?\s*(\S+)/i);
+  if (traceMatch) params.traceId = traceMatch[1];
+
+  const serviceMatch = input.match(/(?:服务|service)\s*[:=]?\s*(\S+)/i);
+  if (serviceMatch) params.service = serviceMatch[1];
+
+  const levelMatch = input.match(/(?:级别|level)\s*[:=]?\s*(ERROR|WARN|INFO|DEBUG)/i);
+  if (levelMatch) params.level = levelMatch[1].toUpperCase();
+
+  const projectMatch = input.match(/(?:项目|project)\s*[:=]?\s*(\S+)/i);
+  if (projectMatch) params.project = projectMatch[1];
+
+  const logstoreMatch = input.match(/(?:logstore|日志库)\s*[:=]?\s*(\S+)/i);
+  if (logstoreMatch) params.logstore = logstoreMatch[1];
+
+  const envMatch = input.match(/(?:环境|env)\s*[:=]?\s*(test|uat|gray|prod)/i);
+  if (envMatch) params.env = envMatch[1].toLowerCase();
+
+  const timeMatch = input.match(/(?:最近|last)\s*(\d+)\s*(分钟|小时|min|hour)/i);
+  if (timeMatch) params.timeRange = `last ${timeMatch[1]} ${timeMatch[2]}`;
+
+  const keywordMatch = input.match(/(?:关键词|keyword|搜索)\s*[:=]?\s*(.+?)(?:\s*$)/i);
+  if (keywordMatch) params.keyword = keywordMatch[1].trim();
+
+  return params;
+}
+
+function buildSLSQuery(params) {
+  const parts = [];
+  if (params.service) parts.push(`service: ${params.service}`);
+  if (params.level) parts.push(`level: ${params.level}`);
+  if (params.keyword) parts.push(`"${params.keyword}"`);
+  return parts.length > 0 ? parts.join(' and ') : '*';
+}
+
+function buildFeignQuery(params) {
+  return `* and "feign" ${params.service ? `and service: ${params.service}` : ''}`;
+}