@colin4k1024/tsp 2.5.0 → 2.5.2

package/scripts/lib/heartbeat-scheduler.js

@@ -0,0 +1,265 @@
+'use strict';
+
+/**
+ * heartbeat-scheduler.js
+ *
+ * Heartbeat engine for Loop Engineering.
+ * Runs configured discovery scans on a schedule, classifies results,
+ * and routes findings to goals or triage inbox.
+ *
+ * This module provides the logic; scheduling is handled by CronCreate/CronDelete
+ * or ScheduleWakeup in the Claude Code runtime.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const yaml = require ? undefined : undefined; // yaml parsing fallback below
+
+const { createGoal, saveGoal } = require('./completion-oracle');
+
+const DEFAULT_CONFIG = {
+  interval: '30m',
+  scans: [],
+  budget: {
+    maxDollarsPerHour: 2.0,
+    pauseOnExhaust: true,
+  },
+};
+
+const SCAN_ACTIONS = {
+  autoGoal: 'auto-goal',
+  triage: 'triage',
+  notify: 'notify',
+  ignore: 'ignore',
+};
+
+// Simple YAML parser for heartbeat config (avoids external dependency)
+function parseSimpleYaml(content) {
+  try {
+    // Try JSON first (YAML superset)
+    return JSON.parse(content);
+  } catch {
+    // Minimal YAML parsing for heartbeat.yaml structure
+    const lines = content.split('\n');
+    const result = { heartbeat: { scans: [], budget: {} } };
+    let currentScan = null;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      const indentLevel = line.search(/\S/);
+
+      if (trimmed.startsWith('interval:')) {
+        result.heartbeat.interval = trimmed.split(':')[1].trim().replace(/['"]/g, '');
+      } else if (trimmed.startsWith('maxDollarsPerHour:')) {
+        result.heartbeat.budget.maxDollarsPerHour = parseFloat(trimmed.split(':')[1].trim());
+      } else if (trimmed.startsWith('pauseOnExhaust:')) {
+        result.heartbeat.budget.pauseOnExhaust = trimmed.split(':')[1].trim() === 'true';
+      } else if (trimmed.startsWith('- name:')) {
+        if (currentScan) result.heartbeat.scans.push(currentScan);
+        currentScan = { name: trimmed.replace('- name:', '').trim().replace(/['"]/g, '') };
+      } else if (currentScan && indentLevel >= 6) {
+        const [key, ...valueParts] = trimmed.split(':');
+        const value = valueParts.join(':').trim().replace(/['"]/g, '');
+        if (key === 'command') currentScan.command = value;
+        else if (key === 'onFailure') currentScan.onFailure = value;
+        else if (key === 'threshold') currentScan.threshold = parseFloat(value);
+        else if (key === 'description') currentScan.description = value;
+      }
+    }
+    if (currentScan) result.heartbeat.scans.push(currentScan);
+    return result;
+  }
+}
+
+function loadConfig(projectRoot) {
+  const configPath = path.join(projectRoot || process.cwd(), '.claude', 'heartbeat.yaml');
+  if (!fs.existsSync(configPath)) return DEFAULT_CONFIG;
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const parsed = parseSimpleYaml(content);
+    return { ...DEFAULT_CONFIG, ...parsed.heartbeat };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+
+function runScan(scan) {
+  const startTime = Date.now();
+  try {
+    const output = execSync(scan.command, {
+      encoding: 'utf-8',
+      timeout: 60000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    let passed = true;
+
+    if (scan.threshold !== undefined) {
+      const numeric = parseInt(output.match(/\d+/)?.[0] || '0', 10);
+      passed = numeric <= scan.threshold;
+    } else {
+      const exitMatch = output.match(/EXIT:(\d+)$/);
+      passed = exitMatch ? exitMatch[1] === '0' : true;
+    }
+
+    return {
+      name: scan.name,
+      passed,
+      output: output.slice(0, 500),
+      durationMs: Date.now() - startTime,
+      timestamp: new Date().toISOString(),
+    };
+  } catch (error) {
+    return {
+      name: scan.name,
+      passed: false,
+      output: (error.stderr || error.message || 'Unknown error').slice(0, 500),
+      durationMs: Date.now() - startTime,
+      timestamp: new Date().toISOString(),
+    };
+  }
+}
+
+function classifyResult(scan, result) {
+  if (result.passed) return { action: 'pass', scan, result };
+  return {
+    action: scan.onFailure || SCAN_ACTIONS.triage,
+    scan,
+    result,
+  };
+}
+
+function createTriageItem(scan, result) {
+  return {
+    id: `triage-${Date.now().toString(36)}`,
+    source: `heartbeat:${scan.name}`,
+    severity: scan.onFailure === SCAN_ACTIONS.autoGoal ? 'high' : 'medium',
+    summary: `${scan.description || scan.name}: ${result.output.slice(0, 100)}`,
+    detail: result.output,
+    suggestedActions: ['Create goal to fix', 'Ignore for now', 'Defer to next session'],
+    createdAt: new Date().toISOString(),
+    status: 'pending',
+  };
+}
+
+function appendToTriageInbox(item) {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const inboxDir = path.join(home, '.claude', 'triage');
+  if (!fs.existsSync(inboxDir)) {
+    fs.mkdirSync(inboxDir, { recursive: true });
+  }
+  const inboxPath = path.join(inboxDir, 'inbox.jsonl');
+  fs.appendFileSync(inboxPath, JSON.stringify(item) + '\n', 'utf-8');
+  return inboxPath;
+}
+
+function createGoalFromScanFailure(scan, result) {
+  const objective = `Fix ${scan.description || scan.name}: ${result.output.slice(0, 80)}`;
+
+  const stoppingConditions = [{
+    type: 'custom_command',
+    command: scan.command,
+    description: scan.description || scan.name,
+  }];
+
+  if (scan.threshold !== undefined) {
+    stoppingConditions[0].threshold = scan.threshold;
+  }
+
+  const goal = createGoal(objective, { stoppingConditions });
+  saveGoal(goal);
+  return goal;
+}
+
+function runHeartbeat(projectRoot) {
+  const config = loadConfig(projectRoot);
+
+  if (config.scans.length === 0) {
+    return {
+      status: 'no_scans',
+      message: 'No scans configured in .claude/heartbeat.yaml',
+      results: [],
+    };
+  }
+
+  const results = config.scans.map(scan => {
+    const result = runScan(scan);
+    const classified = classifyResult(scan, result);
+
+    if (classified.action === SCAN_ACTIONS.autoGoal) {
+      const goal = createGoalFromScanFailure(scan, result);
+      classified.goalId = goal.goalId;
+    } else if (classified.action === SCAN_ACTIONS.triage) {
+      const item = createTriageItem(scan, result);
+      appendToTriageInbox(item);
+      classified.triageId = item.id;
+    }
+
+    return classified;
+  });
+
+  const passed = results.filter(r => r.action === 'pass').length;
+  const failed = results.length - passed;
+
+  return {
+    status: failed > 0 ? 'issues_found' : 'all_clear',
+    timestamp: new Date().toISOString(),
+    summary: `${passed}/${results.length} scans passed`,
+    results,
+  };
+}
+
+function getHeartbeatStatus(projectRoot) {
+  const config = loadConfig(projectRoot);
+
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const lastRunPath = path.join(home, '.claude', 'heartbeat-last-run.json');
+  let lastRun = null;
+  if (fs.existsSync(lastRunPath)) {
+    try {
+      lastRun = JSON.parse(fs.readFileSync(lastRunPath, 'utf-8'));
+    } catch { /* ignore */ }
+  }
+
+  return {
+    configured: config.scans.length > 0,
+    interval: config.interval,
+    scanCount: config.scans.length,
+    scans: config.scans.map(s => ({ name: s.name, onFailure: s.onFailure, description: s.description })),
+    budget: config.budget,
+    lastRun,
+  };
+}
+
+function saveLastRun(result) {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const lastRunPath = path.join(home, '.claude', 'heartbeat-last-run.json');
+  const dir = path.dirname(lastRunPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(lastRunPath, JSON.stringify(result, null, 2), 'utf-8');
+}
+
+function parseInterval(interval) {
+  const match = (interval || '30m').match(/^(\d+)(m|h)$/);
+  if (!match) return 30 * 60;
+  const value = parseInt(match[1], 10);
+  return match[2] === 'h' ? value * 60 * 60 : value * 60;
+}
+
+module.exports = {
+  SCAN_ACTIONS,
+  loadConfig,
+  runScan,
+  classifyResult,
+  createTriageItem,
+  appendToTriageInbox,
+  createGoalFromScanFailure,
+  runHeartbeat,
+  getHeartbeatStatus,
+  saveLastRun,
+  parseInterval,
+};

package/scripts/lib/opencode/convert-agents.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 角色配置映射
+ */
+const ROLE_CONFIGS = {
+  'tech-lead': {
+    description: 'Tech Lead（技术负责人）- 负责需求 intake、任务拆解、角色分派、冲突决策与最终交付收口',
+    tools: { '*': true },
+    color: '#3B82F6',
+  },
+  'product-manager': {
+    description: 'Product Manager（产品经理）- 负责需求澄清、PRD 编写、用户故事和验收标准定义',
+    tools: { read: true, write: true, grep: true, glob: true, webfetch: true },
+    color: '#10B981',
+  },
+  'project-manager': {
+    description: 'Project Manager（项目管理）- 负责排期、依赖管理、里程碑跟踪和风险推进',
+    tools: { read: true, write: true, grep: true, glob: true },
+    color: '#F59E0B',
+  },
+  'architect': {
+    description: 'Architect（架构师）- 负责 ADR、系统边界、接口与数据契约设计',
+    tools: { read: true, write: true, grep: true, glob: true, webfetch: true },
+    color: '#8B5CF6',
+  },
+  'frontend-engineer': {
+    description: 'Frontend Engineer（前端开发）- 负责前端实现与自测',
+    tools: { edit: true, write: true, bash: true, read: true, grep: true, glob: true },
+    color: '#EC4899',
+  },
+  'backend-engineer': {
+    description: 'Backend Engineer（后端开发）- 负责后端实现与自测',
+    tools: { edit: true, write: true, bash: true, read: true, grep: true, glob: true },
+    color: '#06B6D4',
+  },
+  'qa-engineer': {
+    description: 'QA Engineer（测试工程师）- 负责测试计划、回归验证和放行建议',
+    tools: { read: true, grep: true, glob: true, bash: true },
+    color: '#F97316',
+  },
+  'devops-engineer': {
+    description: 'DevOps Engineer（运维工程师）- 负责发布、监控、回滚与运行保障',
+    tools: { edit: true, write: true, bash: true, read: true, grep: true, glob: true },
+    color: '#6366F1',
+  },
+};
+
+/**
+ * Specialist 配置映射
+ */
+const SPECIALIST_CONFIGS = {
+  'planner': {
+    description: 'Planner - 实现规划专家',
+    tools: { read: true, grep: true, glob: true },
+    hidden: true,
+  },
+  'architect': {
+    description: 'Architect - 系统设计专家',
+    tools: { read: true, grep: true, glob: true },
+    hidden: true,
+  },
+  'tdd-guide': {
+    description: 'TDD Guide - 测试驱动开发专家',
+    tools: { read: true, write: true, edit: true, bash: true, grep: true },
+    hidden: true,
+  },
+  'code-reviewer': {
+    description: 'Code Reviewer - 代码审查专家',
+    tools: { read: true, grep: true, glob: true, bash: true },
+    hidden: true,
+  },
+  'security-reviewer': {
+    description: 'Security Reviewer - 安全审查专家',
+    tools: { read: true, grep: true, glob: true },
+    hidden: true,
+  },
+  'build-error-resolver': {
+    description: 'Build Error Resolver - 构建错误修复专家',
+    tools: { read: true, write: true, edit: true, bash: true, grep: true, glob: true },
+    hidden: true,
+  },
+};
+
+/**
+ * 从 Markdown 内容中提取描述
+ */
+function extractDescription(content, fallback) {
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('# ')) {
+      return trimmed.slice(2).trim();
+    }
+  }
+  return fallback;
+}
+
+/**
+ * 为 Agent 文件添加 YAML front matter
+ */
+function addFrontMatter(filePath, config, isSpecialist = false) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const fileName = path.parse(filePath).name;
+
+  // 检查是否已经有 front matter
+  if (content.startsWith('---')) {
+    console.log(`Skipping ${fileName} - already has front matter`);
+    return content;
+  }
+
+  const description = config.description || extractDescription(content, fileName);
+  const tools = config.tools || { '*': true };
+
+  const frontMatter = [
+    '---',
+    `description: "${description.replace(/"/g, '\\"')}"`,
+    `tools:`,
+  ];
+
+  // Format tools as YAML object
+  for (const [tool, enabled] of Object.entries(tools)) {
+    frontMatter.push(`  ${tool}: ${enabled}`);
+  }
+
+  if (config.color) {
+    frontMatter.push(`color: "${config.color}"`);
+  }
+
+  if (config.hidden) {
+    frontMatter.push(`hidden: true`);
+  }
+
+  frontMatter.push('---', '');
+
+  return `${frontMatter.join('\n')}${content}`;
+}
+
+/**
+ * 转换角色 agents
+ */
+function convertRoleAgents(sourceDir, targetDir) {
+  if (!fs.existsSync(sourceDir)) {
+    console.log(`Source directory not found: ${sourceDir}`);
+    return;
+  }
+
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  const files = fs.readdirSync(sourceDir)
+    .filter(file => file.endsWith('.md'))
+    .sort();
+
+  for (const file of files) {
+    const sourcePath = path.join(sourceDir, file);
+    const targetPath = path.join(targetDir, file);
+    const roleName = path.parse(file).name;
+
+    const config = ROLE_CONFIGS[roleName] || {
+      description: extractDescription(fs.readFileSync(sourcePath, 'utf8'), roleName),
+      tools: { '*': true },
+    };
+
+    const content = addFrontMatter(sourcePath, config, false);
+    fs.writeFileSync(targetPath, content, 'utf8');
+    console.log(`Converted role agent: ${file}`);
+  }
+}
+
+/**
+ * 转换 specialist agents
+ */
+function convertSpecialistAgents(sourceDir, targetDir) {
+  if (!fs.existsSync(sourceDir)) {
+    console.log(`Source directory not found: ${sourceDir}`);
+    return;
+  }
+
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  const files = fs.readdirSync(sourceDir)
+    .filter(file => file.endsWith('.md'))
+    .sort();
+
+  for (const file of files) {
+    const sourcePath = path.join(sourceDir, file);
+    const targetPath = path.join(targetDir, file);
+    const specialistName = path.parse(file).name;
+
+    const config = SPECIALIST_CONFIGS[specialistName] || {
+      description: extractDescription(fs.readFileSync(sourcePath, 'utf8'), specialistName),
+      tools: { '*': true },
+      hidden: true,
+    };
+
+    const content = addFrontMatter(sourcePath, config, true);
+    fs.writeFileSync(targetPath, content, 'utf8');
+    console.log(`Converted specialist agent: ${file}`);
+  }
+}
+
+/**
+ * 主函数
+ */
+function main() {
+  const root = path.join(__dirname, '../../..');
+  const opencodeHome = process.argv[2] || path.join(require('os').homedir(), '.config', 'opencode');
+  const pluginDir = path.join(opencodeHome, 'plugins', 'team-skills-platform');
+
+  console.log('Converting agents for OpenCode...');
+  console.log(`Root: ${root}`);
+  console.log(`Target: ${opencodeHome}`);
+
+  // 转换角色 agents
+  const rolesSourceDir = path.join(root, 'agents', 'roles');
+  const rolesTargetDir = path.join(pluginDir, 'agents', 'roles');
+  convertRoleAgents(rolesSourceDir, rolesTargetDir);
+
+  // 转换 specialist agents
+  const specialistsSourceDir = path.join(root, 'agents', 'specialists');
+  const specialistsTargetDir = path.join(pluginDir, 'agents', 'specialists');
+  convertSpecialistAgents(specialistsSourceDir, specialistsTargetDir);
+
+  // 同时复制到 opencodeHome/agents/ 目录
+  const agentsTargetDir = path.join(opencodeHome, 'agents');
+  fs.mkdirSync(agentsTargetDir, { recursive: true });
+
+  // 复制角色 agents
+  if (fs.existsSync(rolesTargetDir)) {
+    for (const file of fs.readdirSync(rolesTargetDir)) {
+      if (file.endsWith('.md')) {
+        fs.copyFileSync(
+          path.join(rolesTargetDir, file),
+          path.join(agentsTargetDir, file)
+        );
+      }
+    }
+  }
+
+  // 复制 specialist agents
+  if (fs.existsSync(specialistsTargetDir)) {
+    for (const file of fs.readdirSync(specialistsTargetDir)) {
+      if (file.endsWith('.md')) {
+        fs.copyFileSync(
+          path.join(specialistsTargetDir, file),
+          path.join(agentsTargetDir, `specialist-${file}`)
+        );
+      }
+    }
+  }
+
+  console.log('✅ Agent conversion completed');
+}
+
+// 导出函数供其他脚本使用
+module.exports = {
+  addFrontMatter,
+  convertRoleAgents,
+  convertSpecialistAgents,
+  ROLE_CONFIGS,
+  SPECIALIST_CONFIGS,
+};
+
+// 如果直接运行此脚本
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error('Error converting agents:', error.message);
+    process.exitCode = 1;
+  }
+}