claude-autopm 1.18.0 → 1.20.0

package/lib/performance/benchmarker.js

@@ -1,429 +0,0 @@
-/**
- * Performance Benchmarker
- * Centralized performance benchmarking functionality
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { performance } = require('perf_hooks');
-const v8 = require('v8');
-
-/**
- * Configuration
- */
-const CONFIG = {
-  directories: {
-    benchmarks: '.claude/benchmarks'
-  },
-  defaults: {
-    metrics: ['time', 'memory', 'cpu'],
-    threshold: 20 // 20% regression threshold
-  },
-  filePatterns: {
-    benchmark: 'benchmark-{timestamp}.json',
-    cpuProfile: 'cpu-profile-{timestamp}.cpuprofile',
-    heapSnapshot: 'heap-snapshot-{timestamp}.heapsnapshot'
-  }
-};
-
-class PerformanceBenchmarker {
-  constructor(projectRoot = process.cwd()) {
-    this.projectRoot = projectRoot;
-    this.benchmarkDir = path.join(projectRoot, CONFIG.directories.benchmarks);
-  }
-
-  /**
-   * Measures execution time for a function
-   */
-  async measureExecutionTime(fn) {
-    const start = performance.now();
-    await fn();
-    const end = performance.now();
-    return Math.round((end - start) * 100) / 100;
-  }
-
-  /**
-   * Gets memory usage statistics
-   */
-  getMemoryUsage() {
-    const usage = process.memoryUsage();
-    return {
-      heapUsed: Math.round(usage.heapUsed / 1024 / 1024 * 100) / 100, // MB
-      heapTotal: Math.round(usage.heapTotal / 1024 / 1024 * 100) / 100, // MB
-      external: Math.round(usage.external / 1024 / 1024 * 100) / 100, // MB
-      rss: Math.round(usage.rss / 1024 / 1024 * 100) / 100 // MB
-    };
-  }
-
-  /**
-   * Gets CPU usage statistics
-   */
-  getCPUUsage() {
-    const startUsage = process.cpuUsage();
-
-    // Simulate some work to measure
-    let sum = 0;
-    for (let i = 0; i < 1000000; i++) {
-      sum += Math.sqrt(i);
-    }
-
-    const usage = process.cpuUsage(startUsage);
-    return {
-      user: Math.round(usage.user / 1000), // ms
-      system: Math.round(usage.system / 1000), // ms
-      percent: Math.round((usage.user + usage.system) / 10000) // approximate %
-    };
-  }
-
-  /**
-   * Analyzes a target path (file or directory)
-   */
-  async analyzeTarget(targetPath) {
-    try {
-      const stats = await fs.stat(targetPath);
-
-      if (stats.isDirectory()) {
-        return await this.analyzeDirectory(targetPath);
-      } else {
-        return await this.analyzeFile(targetPath);
-      }
-    } catch (error) {
-      // Return default analysis if path doesn't exist
-      return { type: 'unknown', files: 0, size: 0 };
-    }
-  }
-
-  /**
-   * Analyzes a directory
-   */
-  async analyzeDirectory(dirPath) {
-    const entries = await fs.readdir(dirPath);
-    let fileCount = 0;
-    let totalSize = 0;
-
-    for (const entry of entries) {
-      if (entry.startsWith('.')) continue;
-
-      const fullPath = path.join(dirPath, entry);
-      try {
-        const stats = await fs.stat(fullPath);
-        if (stats.isFile()) {
-          fileCount++;
-          totalSize += stats.size;
-        }
-      } catch (error) {
-        // Skip inaccessible files
-      }
-    }
-
-    return {
-      type: 'directory',
-      files: fileCount,
-      size: totalSize,
-      sizeKB: Math.round(totalSize / 1024)
-    };
-  }
-
-  /**
-   * Analyzes a file
-   */
-  async analyzeFile(filePath) {
-    const stats = await fs.stat(filePath);
-    let lines = 0;
-
-    try {
-      const content = await fs.readFile(filePath, 'utf8');
-      lines = content.split('\n').length;
-    } catch (error) {
-      // Can't read file content
-    }
-
-    return {
-      type: 'file',
-      name: path.basename(filePath),
-      size: stats.size,
-      sizeKB: Math.round(stats.size / 1024),
-      lines
-    };
-  }
-
-  /**
-   * Runs performance benchmark
-   */
-  async runBenchmark(targetPath = '.', options = {}) {
-    const metrics = {};
-    const requestedMetrics = options.metrics ?
-      (typeof options.metrics === 'string' ?
-        options.metrics.split(',').map(m => m.trim()) :
-        options.metrics) :
-      CONFIG.defaults.metrics;
-
-    // Analyze target
-    const analysis = await this.analyzeTarget(targetPath);
-
-    // Measure execution time
-    if (requestedMetrics.includes('time')) {
-      metrics.executionTime = await this.measureExecutionTime(async () => {
-        // Simulate analyzing the codebase
-        await this.analyzeTarget(targetPath);
-        await new Promise(resolve => setTimeout(resolve, 50));
-      });
-    }
-
-    // Measure memory usage
-    if (requestedMetrics.includes('memory')) {
-      const memory = this.getMemoryUsage();
-      metrics.memoryUsage = memory.heapUsed;
-      metrics.memoryDetails = memory;
-    }
-
-    // Measure CPU usage
-    if (requestedMetrics.includes('cpu')) {
-      const cpu = this.getCPUUsage();
-      metrics.cpuUsage = cpu.percent;
-      metrics.cpuDetails = cpu;
-    }
-
-    // Create benchmark data
-    const benchmarkData = {
-      timestamp: new Date().toISOString(),
-      target: targetPath,
-      analysis,
-      metrics,
-      environment: {
-        node: process.version,
-        platform: process.platform,
-        arch: process.arch
-      }
-    };
-
-    // Save if requested
-    if (options.save) {
-      await this.saveBenchmark(benchmarkData);
-    }
-
-    return benchmarkData;
-  }
-
-  /**
-   * Saves benchmark data
-   */
-  async saveBenchmark(benchmarkData) {
-    await fs.mkdir(this.benchmarkDir, { recursive: true });
-
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const filename = CONFIG.filePatterns.benchmark.replace('{timestamp}', timestamp);
-    const benchmarkPath = path.join(this.benchmarkDir, filename);
-
-    await fs.writeFile(benchmarkPath, JSON.stringify(benchmarkData, null, 2));
-
-    return benchmarkPath;
-  }
-
-  /**
-   * Loads previous benchmarks
-   */
-  async loadBenchmarks() {
-    try {
-      const files = await fs.readdir(this.benchmarkDir);
-      const benchmarkFiles = files.filter(f => f.endsWith('.json'));
-
-      const benchmarks = [];
-      for (const file of benchmarkFiles.sort()) {
-        try {
-          const data = JSON.parse(
-            await fs.readFile(path.join(this.benchmarkDir, file), 'utf8')
-          );
-          benchmarks.push({ file, ...data });
-        } catch (error) {
-          // Skip invalid files
-        }
-      }
-
-      return benchmarks;
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Compares current metrics with previous benchmark
-   */
-  compareBenchmarks(currentMetrics, previousMetrics) {
-    const comparison = {};
-
-    if (currentMetrics.executionTime && previousMetrics.executionTime) {
-      const change = ((currentMetrics.executionTime - previousMetrics.executionTime)
-        / previousMetrics.executionTime * 100);
-      comparison.executionTime = {
-        current: currentMetrics.executionTime,
-        previous: previousMetrics.executionTime,
-        change: Math.round(change * 100) / 100,
-        regression: change > 0
-      };
-    }
-
-    if (currentMetrics.memoryUsage && previousMetrics.memoryUsage) {
-      const change = ((currentMetrics.memoryUsage - previousMetrics.memoryUsage)
-        / previousMetrics.memoryUsage * 100);
-      comparison.memoryUsage = {
-        current: currentMetrics.memoryUsage,
-        previous: previousMetrics.memoryUsage,
-        change: Math.round(change * 100) / 100,
-        regression: change > 0
-      };
-    }
-
-    if (currentMetrics.cpuUsage && previousMetrics.cpuUsage) {
-      const change = ((currentMetrics.cpuUsage - previousMetrics.cpuUsage)
-        / previousMetrics.cpuUsage * 100);
-      comparison.cpuUsage = {
-        current: currentMetrics.cpuUsage,
-        previous: previousMetrics.cpuUsage,
-        change: Math.round(change * 100) / 100,
-        regression: change > 0
-      };
-    }
-
-    return comparison;
-  }
-
-  /**
-   * Checks for performance regression
-   */
-  checkThreshold(currentMetrics, baselineMetrics, threshold) {
-    const regressions = [];
-
-    if (currentMetrics.executionTime && baselineMetrics.executionTime) {
-      const change = ((currentMetrics.executionTime - baselineMetrics.executionTime)
-        / baselineMetrics.executionTime * 100);
-
-      if (change > threshold) {
-        regressions.push({
-          metric: 'executionTime',
-          change: Math.round(change * 100) / 100,
-          threshold
-        });
-      }
-    }
-
-    if (currentMetrics.memoryUsage && baselineMetrics.memoryUsage) {
-      const change = ((currentMetrics.memoryUsage - baselineMetrics.memoryUsage)
-        / baselineMetrics.memoryUsage * 100);
-
-      if (change > threshold) {
-        regressions.push({
-          metric: 'memoryUsage',
-          change: Math.round(change * 100) / 100,
-          threshold
-        });
-      }
-    }
-
-    if (currentMetrics.cpuUsage && baselineMetrics.cpuUsage) {
-      const change = ((currentMetrics.cpuUsage - baselineMetrics.cpuUsage)
-        / baselineMetrics.cpuUsage * 100);
-
-      if (change > threshold) {
-        regressions.push({
-          metric: 'cpuUsage',
-          change: Math.round(change * 100) / 100,
-          threshold
-        });
-      }
-    }
-
-    return regressions;
-  }
-
-  /**
-   * Generates CPU profile
-   */
-  async generateCPUProfile() {
-    await fs.mkdir(this.benchmarkDir, { recursive: true });
-
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const filename = CONFIG.filePatterns.cpuProfile.replace('{timestamp}', timestamp);
-    const profilePath = path.join(this.benchmarkDir, filename);
-
-    // Simulate CPU profiling (real implementation would use v8-profiler-next)
-    const profile = {
-      startTime: Date.now(),
-      endTime: Date.now() + 1000,
-      samples: [],
-      timeDeltas: [],
-      nodes: [
-        {
-          id: 1,
-          callFrame: {
-            functionName: '(root)',
-            lineNumber: 0,
-            columnNumber: 0
-          }
-        }
-      ]
-    };
-
-    await fs.writeFile(profilePath, JSON.stringify(profile, null, 2));
-
-    return profilePath;
-  }
-
-  /**
-   * Generates memory heap snapshot
-   */
-  async generateHeapSnapshot() {
-    await fs.mkdir(this.benchmarkDir, { recursive: true });
-
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const filename = CONFIG.filePatterns.heapSnapshot.replace('{timestamp}', timestamp);
-    const snapshotPath = path.join(this.benchmarkDir, filename);
-
-    try {
-      // Write real heap snapshot
-      const stream = v8.writeHeapSnapshot();
-      const chunks = [];
-
-      for await (const chunk of stream) {
-        chunks.push(chunk);
-      }
-
-      await fs.writeFile(snapshotPath, Buffer.concat(chunks));
-    } catch (error) {
-      // Fallback for testing environments
-      const mockSnapshot = {
-        snapshot: {
-          meta: {
-            node_version: process.version,
-            title: 'Heap Snapshot'
-          },
-          node_count: 1000,
-          edge_count: 2000
-        }
-      };
-      await fs.writeFile(snapshotPath, JSON.stringify(mockSnapshot));
-    }
-
-    return snapshotPath;
-  }
-
-  /**
-   * Gets benchmark history
-   */
-  async getHistory(limit = 10) {
-    const benchmarks = await this.loadBenchmarks();
-
-    // Sort by timestamp descending
-    benchmarks.sort((a, b) =>
-      new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
-    );
-
-    // Apply limit
-    return benchmarks.slice(0, limit);
-  }
-}
-
-module.exports = PerformanceBenchmarker;

package/lib/pm/epic-decomposer.js

@@ -1,273 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Epic Decomposer
- * Decomposes PRD into Epic structure based on provider
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-
-class EpicDecomposer {
-  constructor(options = {}) {
-    this.provider = options.provider || this.detectProvider();
-  }
-
-  /**
-   * Detect provider from config
-   */
-  detectProvider() {
-    try {
-      const configPath = path.join(process.cwd(), '.claude', 'config.json');
-      if (fs.existsSync(configPath)) {
-        const config = fs.readJsonSync(configPath);
-        return config.provider || 'github';
-      }
-    } catch (error) {
-      console.error(`Error detecting provider: ${error.message}`);
-    }
-    return 'github';
-  }
-
-  /**
-   * Decompose PRD into Epic structure
-   */
-  async decompose(prdName) {
-    const prdPath = path.join(process.cwd(), '.claude', 'prds', `${prdName}.md`);
-
-    if (!await fs.pathExists(prdPath)) {
-      throw new Error(`PRD not found: ${prdName}`);
-    }
-
-    const prdContent = await fs.readFile(prdPath, 'utf8');
-    const prd = this.parsePRD(prdContent);
-
-    let epic;
-    if (this.provider === 'azure') {
-      epic = await this.decomposeForAzure(prd);
-    } else {
-      epic = await this.decomposeForGitHub(prd);
-    }
-
-    // Save epic to file
-    const epicPath = path.join(process.cwd(), '.claude', 'epics', `${prdName}.md`);
-    await fs.ensureDir(path.dirname(epicPath));
-    await fs.writeFile(epicPath, this.formatEpicMarkdown(epic));
-
-    // Also save as JSON for easier processing
-    const epicJsonPath = path.join(process.cwd(), '.claude', 'epics', `${prdName}.json`);
-    await fs.writeJson(epicJsonPath, epic, { spaces: 2 });
-
-    return epic;
-  }
-
-  /**
-   * Parse PRD from markdown
-   */
-  parsePRD(content) {
-    const lines = content.split('\n');
-    const prd = {
-      title: '',
-      userStories: [],
-      acceptanceCriteria: [],
-      tasks: []
-    };
-
-    let currentSection = '';
-
-    for (const line of lines) {
-      if (line.startsWith('# ')) {
-        prd.title = line.substring(2).trim();
-      } else if (line.toLowerCase().includes('## user stories')) {
-        currentSection = 'userStories';
-      } else if (line.toLowerCase().includes('## acceptance criteria')) {
-        currentSection = 'acceptanceCriteria';
-      } else if (line.toLowerCase().includes('## tasks')) {
-        currentSection = 'tasks';
-      } else if (line.startsWith('- ') && currentSection) {
-        const item = line.substring(2).trim();
-        if (currentSection === 'userStories') {
-          prd.userStories.push(item);
-        } else if (currentSection === 'acceptanceCriteria') {
-          prd.acceptanceCriteria.push(item);
-        } else if (currentSection === 'tasks') {
-          prd.tasks.push(item);
-        }
-      }
-    }
-
-    return prd;
-  }
-
-  /**
-   * Decompose for Azure DevOps (Epic -> User Stories -> Tasks)
-   */
-  async decomposeForAzure(prd) {
-    const epic = {
-      type: 'Epic',
-      title: prd.title,
-      description: `Epic for ${prd.title}`,
-      provider: 'azure',
-      userStories: []
-    };
-
-    // Convert each user story into structured format with tasks
-    for (const storyText of prd.userStories) {
-      const userStory = {
-        title: storyText,
-        acceptanceCriteria: prd.acceptanceCriteria,
-        tasks: this.generateTasksForStory(storyText)
-      };
-      epic.userStories.push(userStory);
-    }
-
-    return epic;
-  }
-
-  /**
-   * Decompose for GitHub (Epic -> Issues)
-   */
-  async decomposeForGitHub(prd) {
-    const epic = {
-      type: 'Epic',
-      title: prd.title,
-      description: `Epic for ${prd.title}`,
-      provider: 'github',
-      issues: []
-    };
-
-    // For GitHub, create flat list of issues
-    if (prd.tasks && prd.tasks.length > 0) {
-      epic.issues = prd.tasks.map(task => ({
-        type: 'Issue',
-        title: task
-      }));
-    } else {
-      // Generate issues from user stories
-      for (const story of prd.userStories) {
-        const tasks = this.generateTasksForStory(story);
-        tasks.forEach(task => {
-          epic.issues.push({
-            type: 'Issue',
-            title: task.title
-          });
-        });
-      }
-    }
-
-    return epic;
-  }
-
-  /**
-   * Generate tasks for a user story
-   */
-  generateTasksForStory(story) {
-    const tasks = [];
-
-    // Extract key action from story
-    const storyLower = story.toLowerCase();
-
-    // Generate common development tasks
-    if (storyLower.includes('register') || storyLower.includes('registration')) {
-      tasks.push(
-        { title: 'Design database schema for user registration', remainingWork: 2 },
-        { title: 'Implement registration API endpoint', remainingWork: 4 },
-        { title: 'Build registration UI form', remainingWork: 3 },
-        { title: 'Add email validation', remainingWork: 2 },
-        { title: 'Write unit tests for registration', remainingWork: 3 }
-      );
-    } else if (storyLower.includes('login')) {
-      tasks.push(
-        { title: 'Implement JWT token generation', remainingWork: 3 },
-        { title: 'Create login API endpoint', remainingWork: 3 },
-        { title: 'Build login UI component', remainingWork: 3 },
-        { title: 'Add session management', remainingWork: 2 },
-        { title: 'Write integration tests for login', remainingWork: 3 }
-      );
-    } else if (storyLower.includes('manage') || storyLower.includes('admin')) {
-      tasks.push(
-        { title: 'Design admin dashboard UI', remainingWork: 4 },
-        { title: 'Implement user management API', remainingWork: 4 },
-        { title: 'Add role-based access control', remainingWork: 3 },
-        { title: 'Create audit logging', remainingWork: 2 },
-        { title: 'Write admin feature tests', remainingWork: 3 }
-      );
-    } else {
-      // Generic tasks for any user story
-      tasks.push(
-        { title: `Design database schema for ${this.extractFeature(story)}`, remainingWork: 2 },
-        { title: `Implement API for ${this.extractFeature(story)}`, remainingWork: 4 },
-        { title: `Build UI for ${this.extractFeature(story)}`, remainingWork: 3 },
-        { title: `Write tests for ${this.extractFeature(story)}`, remainingWork: 3 }
-      );
-    }
-
-    return tasks;
-  }
-
-  /**
-   * Extract feature name from user story
-   */
-  extractFeature(story) {
-    // Try to extract the main action from the user story
-    const match = story.match(/I want to (.+)/i);
-    if (match) {
-      return match[1].trim();
-    }
-    return 'feature';
-  }
-
-  /**
-   * Format epic as markdown
-   */
-  formatEpicMarkdown(epic) {
-    let markdown = `---
-type: ${epic.type}
-title: ${epic.title}
-provider: ${epic.provider}
-created: ${new Date().toISOString()}
----
-
-# ${epic.title}
-
-${epic.description || ''}
-
-`;
-
-    if (epic.userStories && epic.userStories.length > 0) {
-      markdown += '## User Stories\n\n';
-      for (const story of epic.userStories) {
-        markdown += `### ${story.title}\n\n`;
-
-        if (story.acceptanceCriteria && story.acceptanceCriteria.length > 0) {
-          markdown += '**Acceptance Criteria:**\n';
-          story.acceptanceCriteria.forEach(criteria => {
-            markdown += `- ${criteria}\n`;
-          });
-          markdown += '\n';
-        }
-
-        if (story.tasks && story.tasks.length > 0) {
-          markdown += '**Tasks:**\n';
-          story.tasks.forEach(task => {
-            markdown += `- [ ] ${task.title}`;
-            if (task.remainingWork) {
-              markdown += ` (${task.remainingWork}h)`;
-            }
-            markdown += '\n';
-          });
-          markdown += '\n';
-        }
-      }
-    } else if (epic.issues && epic.issues.length > 0) {
-      markdown += '## Issues\n\n';
-      epic.issues.forEach(issue => {
-        markdown += `- [ ] ${issue.title}\n`;
-      });
-    }
-
-    return markdown;
-  }
-}
-
-module.exports = EpicDecomposer;