flowmind 1.2.2 → 1.3.0

package/skills/auto-flow/index.js

@@ -0,0 +1,124 @@
+/**
+ * Auto Flow Skill
+ * Define, execute, and manage complex multi-step workflows
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const BUILTIN_WORKFLOWS = {
+  'dev-workflow': {
+    name: 'Development Workflow',
+    steps: [
+      { id: 'review', skill: 'code-review', name: 'Code Review' },
+      { id: 'test', action: 'run-command', command: 'npm test', depends_on: ['review'] },
+      { id: 'docs', action: 'run-command', command: 'npm run docs', depends_on: ['test'] },
+      { id: 'archive', skill: 'archive-change', name: 'Archive', depends_on: ['docs'] }
+    ]
+  },
+  'deploy-workflow': {
+    name: 'Deploy Workflow',
+    steps: [
+      { id: 'validate', action: 'run-command', command: 'npm run validate' },
+      { id: 'build', action: 'run-command', command: 'npm run build', depends_on: ['validate'] },
+      { id: 'deploy', action: 'deploy', depends_on: ['build'] },
+      { id: 'verify', action: 'run-command', command: 'npm run verify', depends_on: ['deploy'] },
+      { id: 'notify', action: 'notify', depends_on: ['verify'] }
+    ]
+  }
+};
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /自动流程|auto.*flow|工作流|workflow|执行流程|run.*flow/i.test(input);
+  },
+
+  async execute(input, context) {
+    const params = parseFlowParams(input);
+
+    if (params.action === 'list') {
+      return {
+        type: 'result',
+        skill: 'auto-flow',
+        message: `Available workflows: ${Object.keys(BUILTIN_WORKFLOWS).join(', ')}`,
+        data: { workflows: Object.entries(BUILTIN_WORKFLOWS).map(([k, v]) => ({ id: k, name: v.name, steps: v.steps.length })) },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    if (params.action === 'run') {
+      const workflow = BUILTIN_WORKFLOWS[params.workflow];
+      if (!workflow) {
+        return {
+          type: 'error', skill: 'auto-flow',
+          message: `Workflow not found: ${params.workflow}. Available: ${Object.keys(BUILTIN_WORKFLOWS).join(', ')}`,
+          input, timestamp: new Date().toISOString()
+        };
+      }
+
+      return {
+        type: 'result',
+        skill: 'auto-flow',
+        message: `Starting workflow: ${workflow.name} (${workflow.steps.length} steps)`,
+        data: {
+          workflow: params.workflow,
+          steps: workflow.steps.map(s => ({
+            id: s.id,
+            name: s.name || s.action || s.skill,
+            depends_on: s.depends_on || [],
+            status: 'pending'
+          })),
+          status: 'started'
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    if (params.action === 'define') {
+      return {
+        type: 'result',
+        skill: 'auto-flow',
+        message: 'Define a workflow in YAML format',
+        data: {
+          format: 'YAML workflow definition',
+          example: {
+            name: 'My Workflow',
+            steps: [
+              { id: 'step1', action: 'run-command', command: 'echo hello' },
+              { id: 'step2', skill: 'code-review', depends_on: ['step1'] }
+            ]
+          }
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'auto-flow',
+      message: 'Auto Flow. Available actions: list, run, define',
+      data: {
+        actions: ['list - List workflows', 'run <name> - Run workflow', 'define - Define new workflow'],
+        builtinWorkflows: Object.keys(BUILTIN_WORKFLOWS)
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseFlowParams(input) {
+  const params = {};
+  if (/列表|list/i.test(input)) params.action = 'list';
+  if (/执行|run|start|运行/i.test(input)) params.action = 'run';
+  if (/定义|define|创建|create/i.test(input)) params.action = 'define';
+
+  const workflowMatch = input.match(/(?:workflow|流程|工作流)\s*[:=]?\s*(\S+)/i);
+  if (workflowMatch) params.workflow = workflowMatch[1];
+
+  return params;
+}

package/skills/code-review/index.js

@@ -0,0 +1,79 @@
+/**
+ * Code Review Skill
+ * Analyzes code for security vulnerabilities, style violations, and best practices
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const SECURITY_PATTERNS = [
+  { pattern: /(\bselect\b.*\bfrom\b.*\bwhere\b.*['"]\s*\+\s*)/i, name: 'SQL Injection', severity: 'HIGH' },
+  { pattern: /eval\s*\(/, name: 'Code Injection (eval)', severity: 'HIGH' },
+  { pattern: /innerHTML\s*=/, name: 'XSS (innerHTML)', severity: 'MEDIUM' },
+  { pattern: /password\s*=\s*['"][^'"]+['"]/i, name: 'Hardcoded Password', severity: 'HIGH' },
+  { pattern: /api[_-]?key\s*=\s*['"][^'"]+['"]/i, name: 'Hardcoded API Key', severity: 'HIGH' },
+  { pattern: /secret\s*=\s*['"][^'"]+['"]/i, name: 'Hardcoded Secret', severity: 'HIGH' },
+  { pattern: /md5\s*\(/i, name: 'Weak Crypto (MD5)', severity: 'MEDIUM' },
+  { pattern: /exec\s*\(\s*['"`]/, name: 'Command Injection', severity: 'HIGH' },
+];
+
+const QUALITY_PATTERNS = [
+  { pattern: /console\.(log|debug|info)\s*\(/, name: 'Console statement', severity: 'LOW' },
+  { pattern: /\/\/\s*TODO/i, name: 'TODO comment', severity: 'LOW' },
+  { pattern: /\/\/\s*FIXME/i, name: 'FIXME comment', severity: 'MEDIUM' },
+  { pattern: /\/\/\s*HACK/i, name: 'HACK comment', severity: 'MEDIUM' },
+  { pattern: /catch\s*\(\s*\w*\s*\)\s*\{\s*\}/, name: 'Empty catch block', severity: 'MEDIUM' },
+];
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    const lower = input.toLowerCase();
+    return /代码审查|code review|review code|检查代码|分析代码/.test(lower);
+  },
+
+  async execute(input, context) {
+    const issues = [];
+    const filePath = extractFilePath(input);
+
+    if (filePath && await fs.pathExists(filePath)) {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+      const relPath = path.basename(filePath);
+
+      lines.forEach((line, idx) => {
+        SECURITY_PATTERNS.forEach(({ pattern, name, severity }) => {
+          if (pattern.test(line)) {
+            issues.push({ file: relPath, line: idx + 1, type: 'security', name, severity, code: line.trim() });
+          }
+        });
+        QUALITY_PATTERNS.forEach(({ pattern, name, severity }) => {
+          if (pattern.test(line)) {
+            issues.push({ file: relPath, line: idx + 1, type: 'quality', name, severity, code: line.trim() });
+          }
+        });
+      });
+    }
+
+    const high = issues.filter(i => i.severity === 'HIGH').length;
+    const medium = issues.filter(i => i.severity === 'MEDIUM').length;
+    const low = issues.filter(i => i.severity === 'LOW').length;
+
+    return {
+      type: 'result',
+      skill: 'code-review',
+      message: issues.length > 0
+        ? `Found ${issues.length} issue(s): ${high} HIGH, ${medium} MEDIUM, ${low} LOW`
+        : 'No issues found',
+      data: { issues, summary: { total: issues.length, high, medium, low } },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function extractFilePath(input) {
+  const match = input.match(/(?:review|审查|检查|分析)\s+(.+?\.[a-zA-Z]+)$/i)
+    || input.match(/([^\s]+\.(js|ts|jsx|tsx|py|java|go|rs|c|cpp|rb))$/i);
+  return match ? match[1].trim() : null;
+}

package/skills/code-review-audit/index.js

@@ -0,0 +1,77 @@
+/**
+ * Code Review Audit Skill
+ * Three-dimensional review: security audit, design compliance, mandatory constraints
+ */
+
+const fs = require('fs-extra');
+
+const SECURITY_CHECKS = [
+  { pattern: /(\bselect\b.*\bfrom\b.*\bwhere\b.*['"]\s*\+\s*)/i, name: 'SQL Injection', severity: 'HIGH' },
+  { pattern: /eval\s*\(/, name: 'Code Injection', severity: 'HIGH' },
+  { pattern: /innerHTML\s*=/, name: 'XSS Risk', severity: 'MEDIUM' },
+  { pattern: /password|secret|apikey|token/i, name: 'Potential Sensitive Data', severity: 'MEDIUM' },
+];
+
+const CONSTRAINT_CHECKS = [
+  { pattern: /class\s+[a-z]/, name: 'Class naming (should be PascalCase)', severity: 'LOW' },
+  { pattern: /function\s+[A-Z]/, name: 'Function naming (should be camelCase)', severity: 'LOW' },
+  { pattern: /catch\s*\(\s*\w*\s*\)\s*\{\s*\}/, name: 'Empty catch block', severity: 'MEDIUM' },
+  { pattern: /\/\/\s*TODO/i, name: 'TODO comment', severity: 'LOW' },
+];
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /安全审计|security audit|design compliance|设计合规|code review audit|审查审计/i.test(input);
+  },
+
+  async execute(input, context) {
+    const findings = [];
+    const filePath = extractFilePath(input);
+
+    if (filePath && await fs.pathExists(filePath)) {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+
+      lines.forEach((line, idx) => {
+        SECURITY_CHECKS.forEach(({ pattern, name, severity }) => {
+          if (pattern.test(line)) {
+            findings.push({ dimension: 'security', line: idx + 1, name, severity, code: line.trim() });
+          }
+        });
+        CONSTRAINT_CHECKS.forEach(({ pattern, name, severity }) => {
+          if (pattern.test(line)) {
+            findings.push({ dimension: 'constraint', line: idx + 1, name, severity, code: line.trim() });
+          }
+        });
+      });
+    }
+
+    const high = findings.filter(f => f.severity === 'HIGH').length;
+    const medium = findings.filter(f => f.severity === 'MEDIUM').length;
+    const verdict = high > 0 ? 'FAIL' : medium > 0 ? 'CONDITIONAL' : 'PASS';
+
+    return {
+      type: 'result',
+      skill: 'code-review-audit',
+      message: `Audit verdict: ${verdict} (${findings.length} findings)`,
+      data: {
+        verdict,
+        findings,
+        summary: { total: findings.length, high, medium, low: findings.filter(f => f.severity === 'LOW').length },
+        dimensions: {
+          security: findings.filter(f => f.dimension === 'security').length,
+          constraint: findings.filter(f => f.dimension === 'constraint').length
+        }
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function extractFilePath(input) {
+  const match = input.match(/(?:audit|审计|审查)\s+(.+?\.[a-zA-Z]+)$/i)
+    || input.match(/([^\s]+\.(js|ts|jsx|tsx|py|java|go))$/i);
+  return match ? match[1].trim() : null;
+}

package/skills/data-logic-validation/index.js

@@ -0,0 +1,108 @@
+/**
+ * Data Logic Validation Skill
+ * Verify SQL queries, Redis operations, and data processing logic against real data via MCP
+ */
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /数据逻辑|data.*logic.*valid|sql.*验证|redis.*验证|数据.*校验.*逻辑/i.test(input);
+  },
+
+  async execute(input, context) {
+    const registry = context.componentRegistry;
+    const params = parseValidationParams(input);
+
+    // Check MCP component availability
+    const dbManager = registry?.getAdapter('databaseManager');
+    const dbQuery = registry?.getAdapter('databaseQuery');
+    const redisMonitor = registry?.getAdapter('redisMonitor');
+
+    const availableComponents = {
+      databaseManager: !!dbManager,
+      databaseQuery: !!dbQuery,
+      redisMonitor: !!redisMonitor
+    };
+
+    if (params.action === 'sql') {
+      if (!dbQuery) {
+        return {
+          type: 'result',
+          skill: 'data-logic-validation',
+          message: 'Database query service not configured (need friday-rds-redis-query MCP)',
+          data: { availableComponents, hint: 'Configure database query MCP server first' },
+          input,
+          timestamp: new Date().toISOString()
+        };
+      }
+
+      return {
+        type: 'result',
+        skill: 'data-logic-validation',
+        message: `SQL validation ready for: ${params.query || 'provided query'}`,
+        data: {
+          action: 'validate_sql',
+          query: params.query,
+          mcpTool: 'mcpQueryExec',
+          availableComponents
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    if (params.action === 'redis') {
+      if (!redisMonitor) {
+        return {
+          type: 'result',
+          skill: 'data-logic-validation',
+          message: 'Redis monitor not configured (need friday-aliyun-sz-rds-redis MCP)',
+          data: { availableComponents, hint: 'Configure Redis monitor MCP server first' },
+          input,
+          timestamp: new Date().toISOString()
+        };
+      }
+
+      return {
+        type: 'result',
+        skill: 'data-logic-validation',
+        message: `Redis validation ready for key: ${params.key || 'provided key'}`,
+        data: {
+          action: 'validate_redis',
+          key: params.key,
+          mcpTools: ['mcpRedisKeyGet', 'mcpRedisKeyInfo', 'mcpRedisKeys'],
+          availableComponents
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'data-logic-validation',
+      message: 'Data logic validation. Available: sql, redis',
+      data: {
+        actions: ['sql - Validate SQL queries', 'redis - Validate Redis operations'],
+        availableComponents,
+        requiredMCP: ['databaseManager', 'databaseQuery', 'redisMonitor']
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseValidationParams(input) {
+  const params = {};
+  if (/sql|查询|query|select|insert|update|delete/i.test(input)) params.action = 'sql';
+  if (/redis|缓存|cache|key/i.test(input)) params.action = 'redis';
+
+  const sqlMatch = input.match(/(?:sql|查询)\s*[:=]?\s*(select\s+.+?)(?:\s*$)/i);
+  if (sqlMatch) params.query = sqlMatch[1].trim();
+
+  const keyMatch = input.match(/(?:key|键)\s*[:=]?\s*(\S+)/i);
+  if (keyMatch) params.key = keyMatch[1];
+
+  return params;
+}

package/skills/data-validation/index.js

@@ -0,0 +1,72 @@
+/**
+ * Data Validation Skill
+ * Validates data against schema rules and business logic
+ */
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /数据校验|数据验证|data valid|validate data|校验数据|检查数据/i.test(input);
+  },
+
+  async execute(input, context) {
+    const data = extractData(input);
+
+    if (!data) {
+      return {
+        type: 'result',
+        skill: 'data-validation',
+        message: 'No data found to validate. Provide JSON data or a file path.',
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    const issues = [];
+
+    // Schema validation
+    if (data.rules && data.values) {
+      for (const [field, rule] of Object.entries(data.rules)) {
+        const value = data.values[field];
+
+        if (rule.required && (value === undefined || value === null || value === '')) {
+          issues.push({ field, rule: 'required', message: `${field} is required but missing`, severity: 'ERROR' });
+        }
+        if (value !== undefined && rule.type && typeof value !== rule.type) {
+          issues.push({ field, rule: 'type', message: `${field} should be ${rule.type}, got ${typeof value}`, severity: 'ERROR' });
+        }
+        if (value !== undefined && rule.min !== undefined && value < rule.min) {
+          issues.push({ field, rule: 'min', message: `${field} (${value}) below minimum (${rule.min})`, severity: 'WARNING' });
+        }
+        if (value !== undefined && rule.max !== undefined && value > rule.max) {
+          issues.push({ field, rule: 'max', message: `${field} (${value}) above maximum (${rule.max})`, severity: 'WARNING' });
+        }
+        if (value !== undefined && rule.pattern && !new RegExp(rule.pattern).test(String(value))) {
+          issues.push({ field, rule: 'pattern', message: `${field} doesn't match pattern`, severity: 'WARNING' });
+        }
+      }
+    }
+
+    const errors = issues.filter(i => i.severity === 'ERROR').length;
+    const warnings = issues.filter(i => i.severity === 'WARNING').length;
+
+    return {
+      type: 'result',
+      skill: 'data-validation',
+      message: issues.length > 0
+        ? `Validation: ${errors} errors, ${warnings} warnings`
+        : 'All validations passed',
+      data: { issues, summary: { errors, warnings, passed: issues.length === 0 } },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function extractData(input) {
+  const jsonMatch = input.match(/\{[\s\S]*\}/);
+  if (jsonMatch) {
+    try { return JSON.parse(jsonMatch[0]); } catch {}
+  }
+  return null;
+}

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()
+    };
+  }
+};