claude-autopm 3.0.2 → 3.1.0

package/autopm/lib/batch-processor-integration.js

@@ -26,7 +26,7 @@ const {
   syncTaskToGitHub,
   loadSyncMap,
   saveSyncMap
-} = require('../autopm/.claude/scripts/pm-sync-upload-local');
+} = require('../.claude/scripts/pm-sync-upload-local');
 
 /**
  * Batch sync PRDs to GitHub

package/lib/batch-processor-integration.js

@@ -26,7 +26,7 @@ const {
   syncTaskToGitHub,
   loadSyncMap,
   saveSyncMap
-} = require('../autopm/.claude/scripts/pm-sync-upload-local');
+} = require('../.claude/scripts/pm-sync-upload-local');
 
 /**
  * Batch sync PRDs to GitHub

package/lib/services/AgentService.js

@@ -38,7 +38,7 @@ class AgentService {
     }
 
     this.aiProvider = aiProvider;
-    this.agentsBaseDir = path.join(process.cwd(), 'autopm/.claude/agents');
+    this.agentsBaseDir = path.join(process.cwd(), '.claude/agents');
     this.conversationHistories = new Map();
 
     // Cache for loaded agents (performance optimization)

package/lib/template-engine.js

@@ -61,8 +61,8 @@ const path = require('path');
 class TemplateEngine {
   constructor(builtInDir, userDir) {
     // For testing, allow custom built-in directory and user directory
-    // In production, use autopm/.claude/templates and .claude/templates
-    this.builtInDir = builtInDir || path.join(__dirname, '..', 'autopm', '.claude', 'templates');
+    // In production, use .claude/templates (framework templates are copied during installation)
+    this.builtInDir = builtInDir || path.join(__dirname, '..', '.claude', 'templates');
     this.userDir = userDir || path.join('.claude', 'templates');
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-autopm",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
   "workspaces": [

package/packages/plugin-pm/providers/azure/issue-start.js

@@ -0,0 +1 @@
+throw new Error("Provider script error");

package/packages/plugin-pm/scripts/pm/epic-sync/create-epic-issue.sh

@@ -67,7 +67,7 @@ epic_number=$(gh issue create \
 - Created: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
 " \
     --label "$labels" \
-    2>&1 | grep -oP '(?<=#)[0-9]+' | head -1)
+    2>&1 | grep -o '#[0-9]\+' | head -1 | sed 's/#//')
 
 if [[ -z "$epic_number" ]]; then
     echo "❌ Error: Failed to create epic issue"

package/packages/plugin-pm/scripts/pm/epic-sync/create-task-issues.sh

@@ -66,7 +66,7 @@ for task_file in $task_files; do
 - Created: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
 " \
         --label "task,epic:$EPIC_NAME" \
-        2>&1 | grep -oP '(?<=#)[0-9]+' | head -1)
+        2>&1 | grep -o '#[0-9]\+' | head -1 | sed 's/#//')
 
     if [[ -n "$issue_number" ]]; then
         echo "#$issue_number ✓"

package/packages/plugin-pm/scripts/pm/issue-start.cjs

@@ -0,0 +1,538 @@
+#!/usr/bin/env node
+/**
+ * Issue Start - Start work on an issue
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+class IssueStarter {
+  constructor() {
+    this.providersDir = path.join(__dirname, '..', '..', 'providers');
+    this.issueDir = path.join('.claude', 'issues');
+    this.activeWorkFile = path.join('.claude', 'active-work.json');
+  }
+
+  detectProvider() {
+    // Check for Azure DevOps
+    if (fs.existsSync('.azure') || process.env.AZURE_DEVOPS_ORG) {
+      return 'azure';
+    }
+
+    // Check for GitHub
+    if (fs.existsSync('.github') || fs.existsSync('.git')) {
+      try {
+        const remoteUrl = execSync('git remote get-url origin 2>/dev/null', { encoding: 'utf8' });
+        if (remoteUrl.includes('github.com')) {
+          return 'github';
+        }
+      } catch {}
+    }
+
+    return 'local';
+  }
+
+  loadActiveWork() {
+    if (!fs.existsSync(this.activeWorkFile)) {
+      return { issues: [], epics: [] };
+    }
+    try {
+      return JSON.parse(fs.readFileSync(this.activeWorkFile, 'utf8'));
+    } catch {
+      return { issues: [], epics: [] };
+    }
+  }
+
+  saveActiveWork(activeWork) {
+    const dir = path.dirname(this.activeWorkFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(this.activeWorkFile, JSON.stringify(activeWork, null, 2));
+  }
+
+  async startIssue(issueId, options = {}) {
+    const provider = options.provider || this.detectProvider();
+    console.log(`🚀 Starting work on issue: ${issueId}`);
+    console.log(`📦 Provider: ${provider}\n`);
+
+    // Update active work tracking
+    const activeWork = this.loadActiveWork();
+    const issueEntry = {
+      id: issueId,
+      provider: provider,
+      startedAt: new Date().toISOString(),
+      status: 'in-progress'
+    };
+
+    // Remove if already exists and add to beginning
+    activeWork.issues = activeWork.issues.filter(i => i.id !== issueId);
+    activeWork.issues.unshift(issueEntry);
+
+    // Keep only last 10 active issues
+    if (activeWork.issues.length > 10) {
+      activeWork.issues = activeWork.issues.slice(0, 10);
+    }
+
+    this.saveActiveWork(activeWork);
+
+    // Try to use provider-specific start command
+    const providerScript = path.join(this.providersDir, provider, 'issue-start.js');
+    if (fs.existsSync(providerScript)) {
+      console.log(`Using ${provider} provider to start issue...`);
+      try {
+        require(providerScript);
+        return;
+      } catch (error) {
+        console.log(`⚠️  Provider script failed, using local tracking`);
+      }
+    }
+
+    // Local tracking fallback
+    console.log('📝 Creating local issue tracking...');
+
+    // Create issue file if it doesn't exist
+    if (!fs.existsSync(this.issueDir)) {
+      fs.mkdirSync(this.issueDir, { recursive: true });
+    }
+
+    const issueFile = path.join(this.issueDir, `${issueId}.md`);
+    if (!fs.existsSync(issueFile)) {
+      const template = `# Issue ${issueId}
+
+## Status
+- **State**: In Progress
+- **Started**: ${new Date().toISOString()}
+- **Assigned**: ${process.env.USER || 'current-user'}
+
+## Description
+[Add issue description here]
+
+## Tasks
+- [ ] Task 1
+- [ ] Task 2
+- [ ] Task 3
+
+## Notes
+- Started work on ${new Date().toLocaleDateString()}
+
+## Updates
+- ${new Date().toISOString()}: Issue started
+`;
+      fs.writeFileSync(issueFile, template);
+      console.log(`✅ Created issue file: ${issueFile}`);
+    }
+
+    // Display status
+    console.log('\n📊 Issue Status:');
+    console.log(`  • ID: ${issueId}`);
+    console.log(`  • Status: In Progress`);
+    console.log(`  • Started: ${new Date().toLocaleString()}`);
+
+    // Show next steps
+    console.log('\n💡 Next steps:');
+    console.log(`  • View issue: pm issue-show ${issueId}`);
+    console.log(`  • Update status: pm issue-edit ${issueId}`);
+    console.log(`  • Close issue: pm issue-close ${issueId}`);
+    console.log(`  • View all active: pm in-progress`);
+  }
+
+  /**
+   * Find task file for an issue by ID
+   * Supports both new naming (123.md) and old naming (feature-name.md with github URL in frontmatter)
+   */
+  findTaskFile(issueId) {
+    const epicsDir = path.join('.claude', 'epics');
+
+    if (!fs.existsSync(epicsDir)) {
+      return null;
+    }
+
+    // Search all epic directories
+    const epicDirs = fs.readdirSync(epicsDir).filter(name => {
+      const epicPath = path.join(epicsDir, name);
+      return fs.statSync(epicPath).isDirectory();
+    });
+
+    for (const epicDir of epicDirs) {
+      const epicPath = path.join(epicsDir, epicDir);
+
+      // Try new naming convention first: {issueId}.md
+      const newStylePath = path.join(epicPath, `${issueId}.md`);
+      if (fs.existsSync(newStylePath)) {
+        return newStylePath;
+      }
+
+      // Try old naming convention: search files for github URL
+      const files = fs.readdirSync(epicPath).filter(f => f.endsWith('.md'));
+      for (const file of files) {
+        const filePath = path.join(epicPath, file);
+        const content = fs.readFileSync(filePath, 'utf8');
+
+        // Check frontmatter for github URL with this issue number
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (frontmatterMatch) {
+          const frontmatter = frontmatterMatch[1];
+          const githubMatch = frontmatter.match(/github:\s*.*\/issues\/(\d+)/);
+          if (githubMatch && githubMatch[1] === issueId) {
+            return filePath;
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract epic name from task file path
+   */
+  getEpicFromTaskFile(taskFilePath) {
+    const parts = taskFilePath.split(path.sep);
+    const epicsIndex = parts.indexOf('epics');
+    if (epicsIndex >= 0 && epicsIndex < parts.length - 1) {
+      return parts[epicsIndex + 1];
+    }
+    return null;
+  }
+
+  /**
+   * Analyze issue to identify parallel work streams
+   */
+  async analyzeIssue(issueId, options = {}) {
+    console.log(`🔍 Analyzing issue #${issueId} for parallel work streams...`);
+
+    // Find task file
+    const taskFile = this.findTaskFile(issueId);
+    if (!taskFile) {
+      throw new Error(`No task file found for issue #${issueId}`);
+    }
+
+    const epicName = this.getEpicFromTaskFile(taskFile);
+    if (!epicName) {
+      throw new Error('Could not determine epic name from task file');
+    }
+
+    // Check if analysis already exists
+    const analysisFile = path.join('.claude', 'epics', epicName, `${issueId}-analysis.md`);
+    if (fs.existsSync(analysisFile) && !options.force) {
+      console.log('⚠️  Analysis already exists. Use --force to overwrite.');
+      return;
+    }
+
+    // Read task file
+    const taskContent = fs.readFileSync(taskFile, 'utf8');
+
+    // Get issue from GitHub if available
+    let issueData = null;
+    try {
+      const result = execSync(`gh issue view ${issueId} --json title,body,labels`, { encoding: 'utf8' });
+      issueData = JSON.parse(result);
+    } catch (error) {
+      console.log('⚠️  Could not fetch issue from GitHub, using local task file only');
+    }
+
+    // Create analysis content
+    const timestamp = new Date().toISOString();
+    const analysisContent = this.generateAnalysisContent(issueId, taskContent, issueData, timestamp);
+
+    // Write analysis file
+    fs.writeFileSync(analysisFile, analysisContent);
+
+    console.log(`✅ Analysis complete: ${analysisFile}`);
+    console.log(`   Next: Run /pm:issue-start ${issueId} to begin parallel work`);
+  }
+
+  /**
+   * Generate analysis file content (simplified version - full analysis done by Claude)
+   */
+  generateAnalysisContent(issueId, taskContent, issueData, timestamp) {
+    const title = issueData?.title || 'Issue #' + issueId;
+
+    // This is a placeholder - in real workflow, Claude would create full analysis
+    return `---
+issue: ${issueId}
+title: ${title}
+analyzed: ${timestamp}
+estimated_hours: 8
+parallelization_factor: 2.0
+---
+
+# Parallel Work Analysis: Issue #${issueId}
+
+## Overview
+${issueData?.body || 'Analysis pending - Claude will provide detailed breakdown'}
+
+## Parallel Streams
+
+### Stream A: Primary Implementation
+**Scope**: Main implementation work
+**Files**:
+- TBD (Claude will analyze)
+**Agent Type**: general-purpose
+**Can Start**: immediately
+**Estimated Hours**: 4
+**Dependencies**: none
+
+### Stream B: Tests
+**Scope**: Test implementation
+**Files**:
+- test/**/*.test.js
+**Agent Type**: test-runner
+**Can Start**: immediately
+**Estimated Hours**: 4
+**Dependencies**: none
+
+## Coordination Points
+
+### Shared Files
+To be determined by Claude during analysis.
+
+### Sequential Requirements
+1. Analysis complete
+2. Implementation and tests can run in parallel
+
+## Conflict Risk Assessment
+- **Low Risk**: Expected - tests and implementation typically work in separate files
+
+## Parallelization Strategy
+
+**Recommended Approach**: parallel
+
+Launch Streams A and B simultaneously for maximum efficiency.
+
+## Expected Timeline
+
+With parallel execution:
+- Wall time: 4 hours
+- Total work: 8 hours
+- Efficiency gain: 50%
+
+## Notes
+This is an automated placeholder. Claude will provide detailed analysis when running this command.
+`;
+  }
+
+  /**
+   * Parse analysis file to extract parallel streams
+   */
+  parseAnalysisStreams(analysisFilePath) {
+    const content = fs.readFileSync(analysisFilePath, 'utf8');
+    const streams = [];
+
+    // Extract stream sections using regex
+    const streamRegex = /### Stream ([A-Z]):\s*(.+?)\n\*\*Scope\*\*:\s*(.+?)\n\*\*Files\*\*:\n((?:- .+\n)+)\*\*Agent Type\*\*:\s*(.+?)\n\*\*Can Start\*\*:\s*(.+?)\n\*\*Estimated Hours\*\*:\s*(\d+)/g;
+
+    let match;
+    while ((match = streamRegex.exec(content)) !== null) {
+      const [, letter, name, scope, filesText, agentType, canStart, hours] = match;
+
+      // Parse files list
+      const files = filesText.trim().split('\n').map(line =>
+        line.replace(/^- /, '').trim()
+      );
+
+      streams.push({
+        letter,
+        name: name.trim(),
+        scope: scope.trim(),
+        files,
+        agentType: agentType.trim(),
+        canStart: canStart.trim(),
+        estimatedHours: parseInt(hours, 10)
+      });
+    }
+
+    return streams;
+  }
+
+  /**
+   * Create workspace structure for issue tracking
+   */
+  async createWorkspace(issueId, epicName) {
+    const workspaceDir = path.join('.claude', 'epics', epicName, 'updates', issueId);
+
+    if (!fs.existsSync(workspaceDir)) {
+      fs.mkdirSync(workspaceDir, { recursive: true });
+    }
+
+    return workspaceDir;
+  }
+
+  /**
+   * Create stream tracking file
+   */
+  async createStreamFile(issueId, epicName, stream, streamNumber) {
+    const workspaceDir = await this.createWorkspace(issueId, epicName);
+    const streamFile = path.join(workspaceDir, `stream-${streamNumber}.md`);
+    const timestamp = new Date().toISOString();
+
+    const content = `---
+issue: ${issueId}
+stream: ${stream.name}
+agent: ${stream.agentType}
+started: ${timestamp}
+status: in_progress
+---
+
+# Stream ${streamNumber}: ${stream.name}
+
+## Scope
+${stream.scope}
+
+## Files
+${stream.files.map(f => `- ${f}`).join('\n')}
+
+## Progress
+- Starting implementation
+`;
+
+    fs.writeFileSync(streamFile, content);
+    return streamFile;
+  }
+
+  /**
+   * Start issue with parallel work streams based on analysis
+   */
+  async startIssueWithAnalysis(issueId, options = {}) {
+    console.log(`🚀 Starting parallel work on issue #${issueId}...\n`);
+
+    // Find task file and epic
+    const taskFile = this.findTaskFile(issueId);
+    if (!taskFile) {
+      throw new Error(`No task file found for issue #${issueId}`);
+    }
+
+    const epicName = this.getEpicFromTaskFile(taskFile);
+    const analysisFile = path.join('.claude', 'epics', epicName, `${issueId}-analysis.md`);
+
+    if (!fs.existsSync(analysisFile)) {
+      throw new Error(`No analysis found for issue #${issueId}. Run with --analyze first.`);
+    }
+
+    // Parse streams from analysis
+    const streams = this.parseAnalysisStreams(analysisFile);
+
+    if (streams.length === 0) {
+      console.log('⚠️  No parallel streams found in analysis. Starting regular workflow.');
+      return this.startIssue(issueId, options);
+    }
+
+    // Create workspace
+    await this.createWorkspace(issueId, epicName);
+
+    // Update active work
+    const activeWork = this.loadActiveWork();
+    const issueEntry = {
+      id: issueId,
+      provider: options.provider || this.detectProvider(),
+      startedAt: new Date().toISOString(),
+      status: 'in-progress',
+      parallelStreams: streams.length
+    };
+
+    activeWork.issues = activeWork.issues.filter(i => i.id !== issueId);
+    activeWork.issues.unshift(issueEntry);
+
+    if (activeWork.issues.length > 10) {
+      activeWork.issues = activeWork.issues.slice(0, 10);
+    }
+
+    this.saveActiveWork(activeWork);
+
+    // Create stream files for immediate streams
+    const immediateStreams = streams.filter(s => s.canStart === 'immediately');
+    let streamNumber = 1;
+
+    console.log(`📋 Epic: ${epicName}`);
+    console.log(`🔀 Launching ${immediateStreams.length} parallel streams:\n`);
+
+    for (const stream of immediateStreams) {
+      await this.createStreamFile(issueId, epicName, stream, streamNumber);
+      console.log(`  ✓ Stream ${streamNumber}: ${stream.name} (${stream.agentType})`);
+      streamNumber++;
+    }
+
+    // List dependent streams
+    const dependentStreams = streams.filter(s => s.canStart !== 'immediately');
+    if (dependentStreams.length > 0) {
+      console.log(`\n⏳ Waiting streams (will start after dependencies):`);
+      dependentStreams.forEach(stream => {
+        console.log(`  ○ ${stream.name} (${stream.canStart})`);
+      });
+    }
+
+    console.log(`\n📁 Progress tracking:`);
+    console.log(`   .claude/epics/${epicName}/updates/${issueId}/\n`);
+
+    console.log(`⚠️  TDD REMINDER - All agents MUST follow:`);
+    console.log(`   1. ❌ RED: Write failing test`);
+    console.log(`   2. ✅ GREEN: Make test pass (minimal code)`);
+    console.log(`   3. 🔄 REFACTOR: Clean up code\n`);
+
+    // Assign issue on GitHub
+    try {
+      execSync(`gh issue edit ${issueId} --add-assignee @me --add-label "in-progress"`, { stdio: 'ignore' });
+      console.log(`✓ Issue assigned on GitHub`);
+    } catch (error) {
+      console.log(`⚠️  Could not assign issue on GitHub (not critical)`);
+    }
+
+    console.log(`\n💡 Next steps:`);
+    console.log(`   • Monitor: /pm:epic-status ${epicName}`);
+    console.log(`   • Sync updates: /pm:issue-sync ${issueId}`);
+  }
+
+  async run(args) {
+    const issueId = args[0];
+
+    if (!issueId) {
+      console.error('❌ Error: Issue ID required');
+      console.error('Usage: pm issue-start <issue-id> [--provider=azure|github] [--analyze]');
+
+      // Show active work if any
+      const activeWork = this.loadActiveWork();
+      if (activeWork.issues.length > 0) {
+        console.log('\n📋 Currently active issues:');
+        activeWork.issues.slice(0, 5).forEach(issue => {
+          const date = new Date(issue.startedAt).toLocaleDateString();
+          console.log(`  • ${issue.id} (${issue.provider}) - started ${date}`);
+        });
+      }
+
+      process.exit(1);
+    }
+
+    const options = {};
+    let shouldAnalyze = false;
+
+    args.slice(1).forEach(arg => {
+      if (arg.startsWith('--provider=')) {
+        options.provider = arg.split('=')[1];
+      } else if (arg === '--analyze') {
+        shouldAnalyze = true;
+      }
+    });
+
+    if (shouldAnalyze) {
+      // Analyze first, then start with analysis
+      await this.analyzeIssue(issueId, options);
+      await this.startIssueWithAnalysis(issueId, options);
+    } else {
+      // Regular start without analysis
+      await this.startIssue(issueId, options);
+    }
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const starter = new IssueStarter();
+  starter.run(process.argv.slice(2)).catch(error => {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = IssueStarter;

package/scripts/benchmarks/azure-issue-list.bench.js

@@ -72,7 +72,7 @@ async function benchmarkIssueList(iterations = 10) {
   };
 
   // Load the actual module (with mocked client)
-  const AzureIssueList = require('../../autopm/.claude/providers/azure/issue-list');
+  const AzureIssueList = require('../../.claude/providers/azure/issue-list');
 
   for (let i = 0; i < iterations; i++) {
     // Create fresh instance

package/scripts/benchmarks/provider-router.bench.js

@@ -45,7 +45,7 @@ async function benchmarkProviderRouting(iterations = 20) {
 
     // Measure module loading time
     const loadStart = performance.now();
-    const ProviderRouter = require('../../autopm/.claude/providers/router');
+    const ProviderRouter = require('../../.claude/providers/router');
     const loadEnd = performance.now();
 
     // Measure routing time

package/scripts/validate-framework-paths.sh

@@ -12,6 +12,15 @@ echo ""
 echo "🔍 Validating Framework Paths"
 echo "=============================="
 echo ""
+echo "Checking directories:"
+echo "  • autopm/.claude/ (framework files)"
+echo "  • lib/ (shared libraries)"
+echo "  • scripts/ (utility scripts)"
+echo "  • bin/ (executables)"
+echo "  • packages/ (plugin packages)"
+echo ""
+echo "Excluding: test/, node_modules/, coverage/"
+echo ""
 
 # Colors for output
 RED='\033[0;31m'
@@ -22,27 +31,65 @@ NC='\033[0m' # No Color
 # Track violations
 violations=0
 
+# Directories to check (production code only, exclude tests)
+SEARCH_DIRS=(
+    "$PROJECT_ROOT/autopm/.claude"
+    "$PROJECT_ROOT/lib"
+    "$PROJECT_ROOT/scripts"
+    "$PROJECT_ROOT/bin"
+    "$PROJECT_ROOT/packages"
+)
+
 # Function to check for violations
 check_violations() {
     local pattern="$1"
     local description="$2"
-    local files
-
-    # Search for pattern, excluding:
-    # - Comments in JS files (lines starting with * or //)
-    # - Comments in shell scripts (lines starting with #)
-    # - "Migrated from" comments
-    # - The framework-path-rules.md file itself (contains examples)
-    files=$(grep -r "$pattern" "$PROJECT_ROOT/autopm/.claude" \
-        --include="*.md" \
-        --include="*.sh" \
-        --include="*.js" \
-        --exclude="framework-path-rules.md" \
-        2>/dev/null | \
-        grep -v "Migrated from" | \
-        grep -v "^\s*\*" | \
-        grep -v "^\s*//" | \
-        grep -v "^\s*#" || true)
+    local files=""
+
+    # Search each directory
+    for search_dir in "${SEARCH_DIRS[@]}"; do
+        if [ -d "$search_dir" ]; then
+            # Search for pattern, excluding:
+            # - Comments in JS files (lines starting with * or //)
+            # - Comments in shell scripts (lines starting with #)
+            # - "Migrated from" comments
+            # - The framework-path-rules.md file itself (contains examples)
+            # - Test files and node_modules
+            local dir_results=$(grep -r "$pattern" "$search_dir" \
+                --include="*.md" \
+                --include="*.sh" \
+                --include="*.js" \
+                --include="*.cjs" \
+                --exclude="framework-path-rules.md" \
+                --exclude="validate-framework-paths.sh" \
+                --exclude="setup-azure-aliases.js" \
+                --exclude="migrate-commands.js" \
+                --exclude="migrate-all-commands.js" \
+                --exclude="add-context7-to-commands.js" \
+                --exclude="fix-command-instructions.js" \
+                --exclude="standardize-framework-agents.js" \
+                --exclude="self-maintenance.js" \
+                --exclude="verify-agents.js" \
+                --exclude-dir="node_modules" \
+                --exclude-dir="test" \
+                --exclude-dir="tests" \
+                --exclude-dir="__tests__" \
+                --exclude-dir="coverage" \
+                --exclude-dir="benchmarks" \
+                2>/dev/null | \
+                grep -v "Migrated from" | \
+                grep -v "^\s*\*" | \
+                grep -v "^\s*//" | \
+                grep -v "^\s*#" || true)
+
+            if [ -n "$dir_results" ]; then
+                files="$files$dir_results"$'\n'
+            fi
+        fi
+    done
+
+    # Remove trailing newline
+    files=$(echo "$files" | sed '/^$/d')
 
     if [ -n "$files" ]; then
         echo -e "${RED}❌ Found violations: $description${NC}"

package/packages/plugin-pm/scripts/pm/issue-start.js

@@ -1,181 +0,0 @@
-#!/usr/bin/env node
-/**
- * Issue Start - Start work on an issue
- */
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-class IssueStarter {
-  constructor() {
-    this.providersDir = path.join(__dirname, '..', '..', 'providers');
-    this.issueDir = path.join('.claude', 'issues');
-    this.activeWorkFile = path.join('.claude', 'active-work.json');
-  }
-
-  detectProvider() {
-    // Check for Azure DevOps
-    if (fs.existsSync('.azure') || process.env.AZURE_DEVOPS_ORG) {
-      return 'azure';
-    }
-
-    // Check for GitHub
-    if (fs.existsSync('.github') || fs.existsSync('.git')) {
-      try {
-        const remoteUrl = execSync('git remote get-url origin 2>/dev/null', { encoding: 'utf8' });
-        if (remoteUrl.includes('github.com')) {
-          return 'github';
-        }
-      } catch {}
-    }
-
-    return 'local';
-  }
-
-  loadActiveWork() {
-    if (!fs.existsSync(this.activeWorkFile)) {
-      return { issues: [], epics: [] };
-    }
-    try {
-      return JSON.parse(fs.readFileSync(this.activeWorkFile, 'utf8'));
-    } catch {
-      return { issues: [], epics: [] };
-    }
-  }
-
-  saveActiveWork(activeWork) {
-    const dir = path.dirname(this.activeWorkFile);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(this.activeWorkFile, JSON.stringify(activeWork, null, 2));
-  }
-
-  async startIssue(issueId, options = {}) {
-    const provider = options.provider || this.detectProvider();
-    console.log(`🚀 Starting work on issue: ${issueId}`);
-    console.log(`📦 Provider: ${provider}\n`);
-
-    // Update active work tracking
-    const activeWork = this.loadActiveWork();
-    const issueEntry = {
-      id: issueId,
-      provider: provider,
-      startedAt: new Date().toISOString(),
-      status: 'in-progress'
-    };
-
-    // Remove if already exists and add to beginning
-    activeWork.issues = activeWork.issues.filter(i => i.id !== issueId);
-    activeWork.issues.unshift(issueEntry);
-
-    // Keep only last 10 active issues
-    if (activeWork.issues.length > 10) {
-      activeWork.issues = activeWork.issues.slice(0, 10);
-    }
-
-    this.saveActiveWork(activeWork);
-
-    // Try to use provider-specific start command
-    const providerScript = path.join(this.providersDir, provider, 'issue-start.js');
-    if (fs.existsSync(providerScript)) {
-      console.log(`Using ${provider} provider to start issue...`);
-      try {
-        require(providerScript);
-        return;
-      } catch (error) {
-        console.log(`⚠️  Provider script failed, using local tracking`);
-      }
-    }
-
-    // Local tracking fallback
-    console.log('📝 Creating local issue tracking...');
-
-    // Create issue file if it doesn't exist
-    if (!fs.existsSync(this.issueDir)) {
-      fs.mkdirSync(this.issueDir, { recursive: true });
-    }
-
-    const issueFile = path.join(this.issueDir, `${issueId}.md`);
-    if (!fs.existsSync(issueFile)) {
-      const template = `# Issue ${issueId}
-
-## Status
-- **State**: In Progress
-- **Started**: ${new Date().toISOString()}
-- **Assigned**: ${process.env.USER || 'current-user'}
-
-## Description
-[Add issue description here]
-
-## Tasks
-- [ ] Task 1
-- [ ] Task 2
-- [ ] Task 3
-
-## Notes
-- Started work on ${new Date().toLocaleDateString()}
-
-## Updates
-- ${new Date().toISOString()}: Issue started
-`;
-      fs.writeFileSync(issueFile, template);
-      console.log(`✅ Created issue file: ${issueFile}`);
-    }
-
-    // Display status
-    console.log('\n📊 Issue Status:');
-    console.log(`  • ID: ${issueId}`);
-    console.log(`  • Status: In Progress`);
-    console.log(`  • Started: ${new Date().toLocaleString()}`);
-
-    // Show next steps
-    console.log('\n💡 Next steps:');
-    console.log(`  • View issue: pm issue-show ${issueId}`);
-    console.log(`  • Update status: pm issue-edit ${issueId}`);
-    console.log(`  • Close issue: pm issue-close ${issueId}`);
-    console.log(`  • View all active: pm in-progress`);
-  }
-
-  async run(args) {
-    const issueId = args[0];
-
-    if (!issueId) {
-      console.error('❌ Error: Issue ID required');
-      console.error('Usage: pm issue-start <issue-id> [--provider=azure|github]');
-
-      // Show active work if any
-      const activeWork = this.loadActiveWork();
-      if (activeWork.issues.length > 0) {
-        console.log('\n📋 Currently active issues:');
-        activeWork.issues.slice(0, 5).forEach(issue => {
-          const date = new Date(issue.startedAt).toLocaleDateString();
-          console.log(`  • ${issue.id} (${issue.provider}) - started ${date}`);
-        });
-      }
-
-      process.exit(1);
-    }
-
-    const options = {};
-    args.slice(1).forEach(arg => {
-      if (arg.startsWith('--provider=')) {
-        options.provider = arg.split('=')[1];
-      }
-    });
-
-    await this.startIssue(issueId, options);
-  }
-}
-
-// Main execution
-if (require.main === module) {
-  const starter = new IssueStarter();
-  starter.run(process.argv.slice(2)).catch(error => {
-    console.error('❌ Error:', error.message);
-    process.exit(1);
-  });
-}
-
-module.exports = IssueStarter;