spec-agent 1.0.3

package/src/commands/doctor.ts

@@ -0,0 +1,136 @@
+import * as path from 'path';
+import { Command } from 'commander';
+import { Logger } from '../utils/logger';
+import { ensureDir, fileExists } from '../utils/file';
+import { callLLM, getLLMConfig, validateLLMConfig } from '../services/llm';
+
+interface DoctorOptions {
+  workspace: string;
+  checkLlm?: boolean;
+  format: string;
+}
+
+interface CheckResult {
+  name: string;
+  status: 'pass' | 'warn' | 'fail';
+  message: string;
+}
+
+function parseNodeMajorVersion(version: string): number {
+  const raw = version.startsWith('v') ? version.slice(1) : version;
+  const major = parseInt(raw.split('.')[0], 10);
+  return Number.isFinite(major) ? major : 0;
+}
+
+export async function doctorCommand(options: DoctorOptions, command: Command): Promise<void> {
+  const logger = new Logger();
+  const checks: CheckResult[] = [];
+  const workspacePath = path.resolve(options.workspace);
+
+  try {
+    const nodeMajor = parseNodeMajorVersion(process.version);
+    checks.push({
+      name: 'node_version',
+      status: nodeMajor >= 18 ? 'pass' : 'fail',
+      message: `当前 Node 版本: ${process.version}（要求 >= 18）`,
+    });
+
+    try {
+      await ensureDir(workspacePath);
+      checks.push({
+        name: 'workspace_access',
+        status: 'pass',
+        message: `工作目录可访问: ${workspacePath}`,
+      });
+    } catch (error) {
+      checks.push({
+        name: 'workspace_access',
+        status: 'fail',
+        message: `工作目录不可写: ${error instanceof Error ? error.message : String(error)}`,
+      });
+    }
+
+    const llmConfig = getLLMConfig();
+    try {
+      validateLLMConfig(llmConfig);
+      checks.push({
+        name: 'llm_config',
+        status: 'pass',
+        message: `LLM 配置有效: ${llmConfig.model} @ ${llmConfig.baseUrl}`,
+      });
+    } catch (error) {
+      checks.push({
+        name: 'llm_config',
+        status: 'fail',
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+
+    const patternsPath = path.join(workspacePath, '.patterns.json');
+    const hasPatterns = await fileExists(patternsPath);
+    checks.push({
+      name: 'learned_patterns',
+      status: hasPatterns ? 'pass' : 'warn',
+      message: hasPatterns
+        ? `检测到模式文件: ${patternsPath}`
+        : '未检测到 .patterns.json（首次运行可忽略）',
+    });
+
+    if (options.checkLlm) {
+      try {
+        validateLLMConfig(llmConfig);
+        const probeConfig = {
+          ...llmConfig,
+          maxTokens: 32,
+          temperature: 0,
+        };
+        await callLLM(
+          '请返回 JSON：{"ok": true, "purpose": "healthcheck"}',
+          probeConfig,
+          logger
+        );
+        checks.push({
+          name: 'llm_connectivity',
+          status: 'pass',
+          message: 'LLM 连通性检查通过',
+        });
+      } catch (error) {
+        checks.push({
+          name: 'llm_connectivity',
+          status: 'fail',
+          message: `LLM 连通性检查失败: ${error instanceof Error ? error.message : String(error)}`,
+        });
+      }
+    }
+
+    const failCount = checks.filter(c => c.status === 'fail').length;
+    const warnCount = checks.filter(c => c.status === 'warn').length;
+
+    if (options.format === 'json') {
+      logger.json({
+        status: failCount > 0 ? 'fail' : warnCount > 0 ? 'warn' : 'pass',
+        checks,
+      });
+    } else {
+      logger.info(`Doctor workspace: ${workspacePath}`);
+      for (const check of checks) {
+        const prefix = check.status === 'pass' ? 'PASS' : check.status === 'warn' ? 'WARN' : 'FAIL';
+        logger.info(`  [${prefix}] ${check.name}: ${check.message}`);
+      }
+      if (failCount === 0 && warnCount === 0) {
+        logger.success('所有检查通过');
+      } else if (failCount === 0) {
+        logger.warn(`检查完成：${warnCount} 警告`);
+      } else {
+        logger.error(`检查失败：${failCount} 错误, ${warnCount} 警告`);
+      }
+    }
+
+    if (failCount > 0) {
+      process.exit(2);
+    }
+  } catch (error) {
+    logger.error(`Doctor failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}

package/src/commands/learn.ts

@@ -0,0 +1,261 @@
+import * as path from 'path';
+import { Command } from 'commander';
+import { Logger } from '../utils/logger';
+import { 
+  ensureDir, 
+  fileExists, 
+  readJson, 
+  writeJson,
+  findFiles 
+} from '../utils/file';
+import { ChunkSummary, Patterns, LearnedPattern } from '../types';
+
+interface LearnOptions {
+  workspace: string;
+  from?: string;
+  pattern?: string;
+  rule?: string;
+  list?: boolean;
+  export?: string;
+  apply?: boolean;
+}
+
+const PATTERNS_FILE = '.patterns.json';
+
+export async function learnCommand(options: LearnOptions, command: Command): Promise<void> {
+  const logger = new Logger();
+  const workspacePath = path.resolve(options.workspace);
+  const patternsPath = path.join(workspacePath, PATTERNS_FILE);
+  
+  try {
+    // Load existing patterns
+    let patterns: Patterns = {
+      version: '1.0.0',
+      workspace: workspacePath,
+      patterns: [],
+    };
+
+    if (await fileExists(patternsPath)) {
+      patterns = await readJson<Patterns>(patternsPath);
+    }
+
+    // Handle list command
+    if (options.list) {
+      if (patterns.patterns.length === 0) {
+        logger.info('No learned patterns yet.');
+      } else {
+        logger.info(`Learned patterns (${patterns.patterns.length}):`);
+        for (const p of patterns.patterns) {
+          logger.info(`  - ${p.name}: ${p.rule} (confidence: ${(p.confidence * 100).toFixed(0)}%)`);
+        }
+      }
+      return;
+    }
+
+    // Handle export command
+    if (options.export) {
+      const exportPath = path.resolve(options.export);
+      await writeJson(exportPath, patterns);
+      logger.success(`Patterns exported to ${exportPath}`);
+      return;
+    }
+
+    // Handle manual pattern learning
+    if (options.pattern && options.rule) {
+      const newPattern: LearnedPattern = {
+        name: options.pattern,
+        rule: options.rule,
+        context: 'manual',
+        confidence: 1.0,
+        learnedAt: new Date().toISOString(),
+      };
+
+      // Check if pattern already exists
+      const existingIndex = patterns.patterns.findIndex(p => p.name === options.pattern);
+      if (existingIndex >= 0) {
+        patterns.patterns[existingIndex] = newPattern;
+        logger.info(`Updated pattern: ${options.pattern}`);
+      } else {
+        patterns.patterns.push(newPattern);
+        logger.info(`Learned new pattern: ${options.pattern}`);
+      }
+
+      await writeJson(patternsPath, patterns);
+      return;
+    }
+
+    // Handle automatic learning from phase results
+    if (options.from) {
+      const learnedCount = await learnFromPhase(workspacePath, options.from, patterns, logger);
+      
+      if (learnedCount > 0) {
+        await writeJson(patternsPath, patterns);
+        logger.success(`Learned ${learnedCount} new patterns from ${options.from}`);
+      } else {
+        logger.info('No new patterns learned.');
+      }
+      return;
+    }
+
+    // Handle apply command
+    if (options.apply) {
+      if (patterns.patterns.length === 0) {
+        logger.warn('No patterns to apply.');
+        return;
+      }
+      
+      logger.info(`Applied ${patterns.patterns.length} learned patterns to workspace`);
+      logger.json({
+        status: 'success',
+        patternsApplied: patterns.patterns.length,
+        patterns: patterns.patterns.map(p => p.name),
+      });
+      return;
+    }
+
+    // Default: show help
+    logger.info('Usage:');
+    logger.info('  spec-agent learn --workspace ./workspace --from summaries');
+    logger.info('  spec-agent learn --workspace ./workspace --pattern "API规范" --rule "/api/v{version}/{resource}"');
+    logger.info('  spec-agent learn --workspace ./workspace --list');
+    logger.info('  spec-agent learn --workspace ./workspace --export ./patterns.json');
+
+  } catch (error) {
+    logger.error(`Learn failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+async function learnFromPhase(
+  workspacePath: string,
+  phase: string,
+  patterns: Patterns,
+  logger: Logger
+): Promise<number> {
+  let learnedCount = 0;
+
+  switch (phase) {
+    case 'summaries':
+      learnedCount = await learnFromSummaries(workspacePath, patterns, logger);
+      break;
+    case 'plan':
+      learnedCount = await learnFromPlan(workspacePath, patterns, logger);
+      break;
+    case 'dispatch':
+      learnedCount = await learnFromDispatch(workspacePath, patterns, logger);
+      break;
+    default:
+      logger.error(`Unknown phase: ${phase}`);
+      return 0;
+  }
+
+  return learnedCount;
+}
+
+async function learnFromSummaries(
+  workspacePath: string,
+  patterns: Patterns,
+  logger: Logger
+): Promise<number> {
+  const summariesDir = path.join(workspacePath, 'summaries');
+  
+  if (!(await fileExists(summariesDir))) {
+    logger.error('No summaries directory found. Run analyze first.');
+    return 0;
+  }
+
+  const summaryFiles = await findFiles('chunk_*_summary.json', summariesDir);
+  if (summaryFiles.length === 0) {
+    logger.error('No summary files found.');
+    return 0;
+  }
+
+  let learnedCount = 0;
+
+  for (const file of summaryFiles) {
+    const summary = await readJson<ChunkSummary>(file);
+    
+    // Learn naming patterns from features
+    for (const feature of summary.features) {
+      const namingPattern = extractNamingPattern(feature.name);
+      if (namingPattern && !patternExists(patterns, namingPattern.name)) {
+        patterns.patterns.push({
+          ...namingPattern,
+          context: `feature:${feature.id}`,
+          confidence: 0.8,
+          learnedAt: new Date().toISOString(),
+        });
+        learnedCount++;
+      }
+    }
+
+    // Learn API patterns
+    for (const api of summary.apis) {
+      const apiPattern = extractApiPattern(api.path);
+      if (apiPattern && !patternExists(patterns, apiPattern.name)) {
+        patterns.patterns.push({
+          ...apiPattern,
+          context: `api:${api.method}`,
+          confidence: 0.9,
+          learnedAt: new Date().toISOString(),
+        });
+        learnedCount++;
+      }
+    }
+  }
+
+  return learnedCount;
+}
+
+async function learnFromPlan(
+  workspacePath: string,
+  patterns: Patterns,
+  logger: Logger
+): Promise<number> {
+  // Learn from task planning patterns
+  // This would analyze task_plan.json to learn estimation patterns, etc.
+  return 0;
+}
+
+async function learnFromDispatch(
+  workspacePath: string,
+  patterns: Patterns,
+  logger: Logger
+): Promise<number> {
+  // Learn from dispatch patterns
+  // This would analyze dispatch_plan.json to learn agent assignment patterns
+  return 0;
+}
+
+function extractNamingPattern(name: string): { name: string; rule: string } | null {
+  // Detect naming conventions
+  if (/^[A-Z][a-zA-Z0-9]*$/.test(name)) {
+    return { name: '组件命名规范', rule: 'PascalCase' };
+  }
+  if (/^[a-z][a-z0-9-]*$/.test(name)) {
+    return { name: '路由命名规范', rule: 'kebab-case' };
+  }
+  if (/^[a-z][a-zA-Z0-9]*$/.test(name)) {
+    return { name: '变量命名规范', rule: 'camelCase' };
+  }
+  return null;
+}
+
+function extractApiPattern(path: string): { name: string; rule: string } | null {
+  // Detect API patterns
+  const versionMatch = path.match(/\/api\/v(\d+)\//);
+  if (versionMatch) {
+    return { name: 'API版本规范', rule: `/api/v{version}/...` };
+  }
+  
+  const restMatch = path.match(/\/api\/\w+\/(\d+|\w+)/);
+  if (restMatch) {
+    return { name: 'RESTful路径规范', rule: `/api/{resource}/{id}` };
+  }
+  
+  return null;
+}
+
+function patternExists(patterns: Patterns, name: string): boolean {
+  return patterns.patterns.some(p => p.name === name);
+}