flowmind 1.2.3 → 1.4.0

package/skills/api-sync/index.js

@@ -0,0 +1,130 @@
+/**
+ * API Sync Skill
+ * Sync API definitions, generate documentation, maintain API consistency
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /api.*sync|同步.*api|api.*文档|swagger.*sync|接口.*同步/i.test(input);
+  },
+
+  async execute(input, context) {
+    const params = parseApiSyncParams(input);
+
+    if (params.action === 'generate') {
+      return generateDocs(params, input);
+    }
+
+    if (params.action === 'sync') {
+      return syncToYApi(params, input, context);
+    }
+
+    return {
+      type: 'result',
+      skill: 'api-sync',
+      message: 'API sync. Available actions: generate (from code), sync (to platform)',
+      data: {
+        actions: ['generate - Generate API docs from code', 'sync - Sync to YApi/Swagger Hub'],
+        params
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseApiSyncParams(input) {
+  const params = {};
+  if (/生成|generate|导出/i.test(input)) params.action = 'generate';
+  if (/同步|sync|上传|push/i.test(input)) params.action = 'sync';
+
+  const pathMatch = input.match(/(?:路径|path|目录|dir)\s*[:=]?\s*(\S+)/i);
+  if (pathMatch) params.path = pathMatch[1];
+
+  const platformMatch = input.match(/(?:平台|platform)\s*[:=]?\s*(yapi|swagger|postman)/i);
+  if (platformMatch) params.platform = platformMatch[1].toLowerCase();
+
+  const projectMatch = input.match(/(?:项目|project)\s*[:=]?\s*(\S+)/i);
+  if (projectMatch) params.project = projectMatch[1];
+
+  return params;
+}
+
+async function generateDocs(params, input) {
+  const dirPath = params.path || '.';
+  if (!(await fs.pathExists(dirPath))) {
+    return {
+      type: 'error', skill: 'api-sync',
+      message: `Path not found: ${dirPath}`,
+      input, timestamp: new Date().toISOString()
+    };
+  }
+
+  const apis = [];
+  const files = await findApiFiles(dirPath);
+
+  for (const file of files.slice(0, 20)) {
+    const content = await fs.readFile(file, 'utf-8');
+    const endpoints = extractEndpoints(content);
+    apis.push(...endpoints.map(e => ({ ...e, file: path.relative(dirPath, file) })));
+  }
+
+  return {
+    type: 'result',
+    skill: 'api-sync',
+    message: `Found ${apis.length} API endpoint(s) in ${files.length} file(s)`,
+    data: { apis, totalEndpoints: apis.length, totalFiles: files.length },
+    input,
+    timestamp: new Date().toISOString()
+  };
+}
+
+function syncToYApi(params, input, context) {
+  return {
+    type: 'result',
+    skill: 'api-sync',
+    message: 'API sync to platform (use yapi-sync-interface skill for YApi-specific operations)',
+    data: { platform: params.platform || 'yapi', hint: 'Use yapi-sync-interface skill for direct YApi integration' },
+    input,
+    timestamp: new Date().toISOString()
+  };
+}
+
+async function findApiFiles(dir) {
+  const results = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await findApiFiles(fullPath));
+    } else if (/\.(js|ts|java|py)$/.test(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+function extractEndpoints(content) {
+  const endpoints = [];
+  const patterns = [
+    /@(?:GET|POST|PUT|DELETE|PATCH)Mapping\s*\(\s*["']([^"']+)["']/gi,
+    /(?:app|router)\.(get|post|put|delete|patch)\s*\(\s*["']([^"']+)["']/gi,
+    /@(?:Get|Post|Put|Delete|Patch)\s*\(\s*["']([^"']+)["']/gi,
+  ];
+
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const method = match[1]?.toUpperCase() || 'GET';
+      const urlPath = match[2] || match[1];
+      endpoints.push({ method, path: urlPath });
+    }
+  }
+
+  return endpoints;
+}

package/skills/archive-change/index.js

@@ -0,0 +1,104 @@
+/**
+ * Archive Change Skill
+ * Archive completed changes and maintain project history
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+module.exports = {
+  canHandle(input, context) {
+    if (!input) return false;
+    return /归档|archive|完成.*存档|change.*archive|整理.*完成/i.test(input);
+  },
+
+  async execute(input, context) {
+    const params = parseArchiveParams(input);
+
+    if (params.action === 'check') {
+      const checklist = await checkArchiveReadiness(params.path || '.');
+      return {
+        type: 'result',
+        skill: 'archive-change',
+        message: `Archive readiness: ${checklist.passed}/${checklist.total} checks passed`,
+        data: { checklist },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    if (params.action === 'archive') {
+      const archiveDir = params.archiveDir || '.archive';
+      const changeName = params.name || `change-${Date.now()}`;
+
+      return {
+        type: 'result',
+        skill: 'archive-change',
+        message: `Archiving change: ${changeName}`,
+        data: {
+          changeName,
+          archiveDir: path.join(archiveDir, changeName),
+          structure: ['SUMMARY.md', 'PROPOSAL.md', 'SPECS.md', 'DESIGN.md', 'TASKS.md', 'CHANGELOG.md', 'TESTS.md', 'artifacts/'],
+          preCheck: await checkArchiveReadiness(params.path || '.')
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    return {
+      type: 'result',
+      skill: 'archive-change',
+      message: 'Archive change. Available actions: check, archive',
+      data: {
+        actions: ['check - Check readiness', 'archive - Archive change'],
+        archiveStructure: ['SUMMARY.md', 'PROPOSAL.md', 'SPECS.md', 'DESIGN.md', 'TASKS.md', 'CHANGELOG.md', 'TESTS.md']
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+};
+
+function parseArchiveParams(input) {
+  const params = {};
+  if (/检查|check|就绪|ready/i.test(input)) params.action = 'check';
+  if (/归档|archive|执行/i.test(input)) params.action = 'archive';
+
+  const nameMatch = input.match(/(?:名称|name)\s*[:=]?\s*(\S+)/i);
+  if (nameMatch) params.name = nameMatch[1];
+
+  const pathMatch = input.match(/(?:路径|path|目录|dir)\s*[:=]?\s*(\S+)/i);
+  if (pathMatch) params.path = pathMatch[1];
+
+  return params;
+}
+
+async function checkArchiveReadiness(dir) {
+  const checks = [
+    { name: 'README exists', check: () => fs.pathExists(path.join(dir, 'README.md')) },
+    { name: 'Has git history', check: () => fs.pathExists(path.join(dir, '.git')) },
+    { name: 'Has package.json or similar', check: async () =>
+      await fs.pathExists(path.join(dir, 'package.json')) ||
+      await fs.pathExists(path.join(dir, 'pom.xml')) ||
+      await fs.pathExists(path.join(dir, 'Cargo.toml'))
+    },
+  ];
+
+  const results = [];
+  for (const c of checks) {
+    try {
+      const passed = await c.check();
+      results.push({ name: c.name, passed });
+    } catch {
+      results.push({ name: c.name, passed: false });
+    }
+  }
+
+  return {
+    checks: results,
+    passed: results.filter(r => r.passed).length,
+    total: results.length,
+    ready: results.every(r => r.passed)
+  };
+}

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