claude-autopm 1.30.0 → 1.31.0

package/autopm/lib/visual-diff.js

@@ -0,0 +1,297 @@
+/**
+ * Visual Diff Renderer
+ *
+ * Renders ASCII side-by-side comparisons of text differences.
+ * Highlights conflicting sections and provides context lines.
+ *
+ * @example
+ * const VisualDiff = require('./lib/visual-diff');
+ *
+ * const diff = new VisualDiff({
+ *   columnWidth: 80
+ * });
+ *
+ * // Render side-by-side comparison
+ * const rendered = diff.sideBySide(localContent, remoteContent);
+ * console.log(rendered);
+ *
+ * // Highlight conflicts
+ * const highlighted = diff.highlightConflicts(text, conflicts);
+ *
+ * // Render with context
+ * const context = diff.renderContext(text, [5, 10], 3);
+ */
+
+class VisualDiff {
+  /**
+   * Create a new VisualDiff instance
+   *
+   * @param {Object} options - Configuration options
+   * @param {number} options.columnWidth - Width of each column in side-by-side view (default: 60)
+   * @param {boolean} options.showLineNumbers - Show line numbers (default: true)
+   * @param {string} options.separator - Column separator (default: ' | ')
+   */
+  constructor(options = {}) {
+    // Validate configuration
+    if (options.columnWidth !== undefined) {
+      if (typeof options.columnWidth !== 'number' || options.columnWidth <= 0) {
+        throw new Error('columnWidth must be a positive number');
+      }
+    }
+
+    this.options = {
+      columnWidth: options.columnWidth || 60,
+      showLineNumbers: options.showLineNumbers !== false,
+      separator: options.separator || ' | '
+    };
+  }
+
+  /**
+   * Render side-by-side comparison of two text versions
+   *
+   * @param {string} left - Left side content (local)
+   * @param {string} right - Right side content (remote)
+   * @param {Object} options - Rendering options
+   * @returns {string} ASCII side-by-side comparison
+   */
+  sideBySide(left, right, options = {}) {
+    const leftLines = left.split('\n');
+    const rightLines = right.split('\n');
+
+    const maxLines = Math.max(leftLines.length, rightLines.length);
+
+    const output = [];
+
+    // Header
+    const colWidth = this.options.columnWidth;
+    const header = this._padRight('LOCAL', colWidth) +
+                   this.options.separator +
+                   this._padRight('REMOTE', colWidth);
+    output.push(header);
+    output.push('='.repeat(header.length));
+
+    // Content lines
+    for (let i = 0; i < maxLines; i++) {
+      const leftLine = leftLines[i] || '';
+      const rightLine = rightLines[i] || '';
+
+      const lineNum = this.options.showLineNumbers ? `${(i + 1).toString().padStart(4)} ` : '';
+
+      const leftContent = this._truncate(leftLine, colWidth - lineNum.length);
+      const rightContent = this._truncate(rightLine, colWidth - lineNum.length);
+
+      // Mark differences
+      const marker = leftLine !== rightLine ? '*' : ' ';
+
+      const line = marker + lineNum + this._padRight(leftContent, colWidth - lineNum.length - 1) +
+                   this.options.separator +
+                   marker + lineNum + this._padRight(rightContent, colWidth - lineNum.length - 1);
+
+      output.push(line);
+    }
+
+    return output.join('\n');
+  }
+
+  /**
+   * Highlight conflicts in text with conflict markers
+   *
+   * @param {string} text - Original text
+   * @param {Array<Object>} conflicts - Array of conflict objects
+   * @returns {string} Text with conflict markers inserted
+   */
+  highlightConflicts(text, conflicts) {
+    const lines = text.split('\n');
+
+    // Sort conflicts by line number (ascending)
+    const sortedConflicts = [...conflicts].sort((a, b) => a.line - b.line);
+
+    // Build result in a single pass
+    const result = [];
+    let conflictIdx = 0;
+    for (let i = 0; i < lines.length; i++) {
+      // Check if current line matches the next conflict
+      if (
+        conflictIdx < sortedConflicts.length &&
+        sortedConflicts[conflictIdx].line - 1 === i
+      ) {
+        const conflict = sortedConflicts[conflictIdx];
+        result.push('<<<<<<< LOCAL');
+        result.push(conflict.localContent);
+        result.push('=======');
+        result.push(conflict.remoteContent);
+        result.push('>>>>>>> REMOTE');
+        conflictIdx++;
+      } else {
+        result.push(lines[i]);
+      }
+    }
+
+    return result.join('\n');
+  }
+
+  /**
+   * Render context lines around specified line numbers
+   *
+   * @param {string} text - Full text content
+   * @param {Array<number>} lineNumbers - Line numbers to show context for
+   * @param {number} contextLines - Number of context lines before and after (default: 3)
+   * @returns {string} Text with only context lines
+   */
+  renderContext(text, lineNumbers, contextLines = 3) {
+    const lines = text.split('\n');
+    const lineSet = new Set();
+
+    // Add context lines for each specified line number
+    for (const lineNum of lineNumbers) {
+      const lineIndex = lineNum - 1; // Convert to 0-based
+
+      // Add lines in context range
+      const start = Math.max(0, lineIndex - contextLines);
+      const end = Math.min(lines.length - 1, lineIndex + contextLines);
+
+      for (let i = start; i <= end; i++) {
+        lineSet.add(i);
+      }
+    }
+
+    // Convert to sorted array
+    const includedLines = Array.from(lineSet).sort((a, b) => a - b);
+
+    // Build output with ellipsis for gaps
+    const output = [];
+    let lastLine = -2;
+
+    for (const lineIndex of includedLines) {
+      // Add ellipsis if there's a gap
+      if (lineIndex > lastLine + 1) {
+        output.push('...');
+      }
+
+      // Add the line with line number
+      const lineNum = (lineIndex + 1).toString().padStart(4);
+      output.push(`${lineNum} | ${lines[lineIndex]}`);
+
+      lastLine = lineIndex;
+    }
+
+    return output.join('\n');
+  }
+
+  /**
+   * Calculate diff statistics
+   *
+   * @param {string} left - Left side content
+   * @param {string} right - Right side content
+   * @returns {Object} Diff statistics
+   */
+  getStats(left, right) {
+    const leftLines = left.split('\n');
+    const rightLines = right.split('\n');
+
+    let added = 0;
+    let removed = 0;
+    let modified = 0;
+    let unchanged = 0;
+
+    const maxLines = Math.max(leftLines.length, rightLines.length);
+
+    for (let i = 0; i < maxLines; i++) {
+      const leftLine = leftLines[i];
+      const rightLine = rightLines[i];
+
+      if (leftLine === undefined && rightLine !== undefined) {
+        added++;
+      } else if (leftLine !== undefined && rightLine === undefined) {
+        removed++;
+      } else if (leftLine !== rightLine) {
+        modified++;
+      } else {
+        unchanged++;
+      }
+    }
+
+    return {
+      added,
+      removed,
+      modified,
+      unchanged,
+      total: maxLines
+    };
+  }
+
+  /**
+   * Truncate text to fit within column width
+   *
+   * @private
+   * @param {string} text - Text to truncate
+   * @param {number} maxWidth - Maximum width
+   * @returns {string} Truncated text
+   */
+  _truncate(text, maxWidth) {
+    if (text.length <= maxWidth) {
+      return text;
+    }
+    // If maxWidth is less than 3, we can't fit the ellipsis, so just truncate to maxWidth
+    if (maxWidth < 3) {
+      return text.substring(0, maxWidth);
+    }
+    return text.substring(0, maxWidth - 3) + '...';
+  }
+
+  /**
+   * Pad text to the right with spaces
+   *
+   * @private
+   * @param {string} text - Text to pad
+   * @param {number} width - Target width
+   * @returns {string} Padded text
+   */
+  _padRight(text, width) {
+    if (text.length >= width) {
+      return text.substring(0, width);
+    }
+
+    return text + ' '.repeat(width - text.length);
+  }
+
+  /**
+   * Render unified diff format (similar to git diff)
+   *
+   * @param {string} left - Left side content
+   * @param {string} right - Right side content
+   * @param {Object} options - Rendering options
+   * @returns {string} Unified diff output
+   */
+  unified(left, right, options = {}) {
+    const leftLines = left.split('\n');
+    const rightLines = right.split('\n');
+
+    const output = [];
+    output.push('--- LOCAL');
+    output.push('+++ REMOTE');
+    output.push(`@@ -1,${leftLines.length} +1,${rightLines.length} @@`);
+
+    const maxLines = Math.max(leftLines.length, rightLines.length);
+
+    for (let i = 0; i < maxLines; i++) {
+      const leftLine = leftLines[i];
+      const rightLine = rightLines[i];
+
+      if (leftLine === rightLine) {
+        output.push(` ${leftLine || ''}`);
+      } else if (leftLine === undefined) {
+        output.push(`+${rightLine}`);
+      } else if (rightLine === undefined) {
+        output.push(`-${leftLine}`);
+      } else {
+        output.push(`-${leftLine}`);
+        output.push(`+${rightLine}`);
+      }
+    }
+
+    return output.join('\n');
+  }
+}
+
+module.exports = VisualDiff;

package/bin/autopm-poc.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+/**
+ * AutoPM POC - CLI for testing Claude API integration
+ *
+ * Usage:
+ *   autopm-poc parse <prd-file>       - Parse PRD with streaming output
+ *   autopm-poc parse <prd-file> --json - Parse PRD and output JSON
+ *   autopm-poc summarize <prd-file>   - Get one-paragraph summary
+ *   autopm-poc test                   - Test API connection
+ *
+ * Environment:
+ *   ANTHROPIC_API_KEY - Required for all operations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const ClaudeProvider = require('../lib/ai-providers/ClaudeProvider');
+const PRDService = require('../lib/services/PRDService');
+
+/**
+ * Print usage information
+ */
+function printUsage() {
+  console.log(`
+AutoPM POC - Claude API Integration Demo
+=========================================
+
+Usage:
+  autopm-poc parse <prd-file>          Parse PRD with streaming output
+  autopm-poc parse <prd-file> --json   Parse PRD and extract epics as JSON
+  autopm-poc summarize <prd-file>      Get one-paragraph summary
+  autopm-poc test                      Test API connection
+  autopm-poc help                      Show this help message
+
+Environment Variables:
+  ANTHROPIC_API_KEY                    Required - Your Anthropic API key
+
+Examples:
+  export ANTHROPIC_API_KEY="sk-ant-..."
+  autopm-poc parse examples/sample-prd.md
+  autopm-poc summarize examples/sample-prd.md
+  autopm-poc parse examples/sample-prd.md --json
+`);
+}
+
+/**
+ * Test API connection
+ */
+async function testConnection(provider) {
+  console.log('🔍 Testing API connection...\n');
+
+  try {
+    const result = await provider.complete('Say "Connection successful!"', {
+      maxTokens: 50
+    });
+
+    console.log('✅ API Connection Test: SUCCESS');
+    console.log(`📝 Response: ${result}\n`);
+    return true;
+  } catch (error) {
+    console.error('❌ API Connection Test: FAILED');
+    console.error(`   Error: ${error.message}\n`);
+    return false;
+  }
+}
+
+/**
+ * Parse PRD with streaming output
+ */
+async function parsePRDStream(service, content) {
+  console.log('🔍 Analyzing PRD with Claude AI...\n');
+  console.log('📝 Streaming response:\n');
+  console.log('─'.repeat(60));
+
+  let fullResponse = '';
+  try {
+    for await (const chunk of service.parseStream(content)) {
+      process.stdout.write(chunk);
+      fullResponse += chunk;
+    }
+
+    console.log('\n' + '─'.repeat(60));
+    console.log('\n✅ Analysis complete!');
+    console.log(`📊 Total response length: ${fullResponse.length} characters\n`);
+  } catch (error) {
+    console.error('\n❌ Error during parsing:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Parse PRD and extract epics as JSON
+ */
+async function parsePRDJson(service, content) {
+  console.log('🔍 Extracting epics from PRD...\n');
+
+  try {
+    const epics = await service.extractEpics(content);
+
+    console.log('✅ Extraction complete!\n');
+    console.log('📋 Extracted Epics:\n');
+    console.log(JSON.stringify(epics, null, 2));
+    console.log(`\n📊 Found ${Array.isArray(epics) ? epics.length : 0} epic(s)\n`);
+  } catch (error) {
+    console.error('❌ Error during JSON extraction:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Summarize PRD
+ */
+async function summarizePRD(service, content) {
+  console.log('🔍 Summarizing PRD...\n');
+
+  try {
+    const summary = await service.summarize(content);
+
+    console.log('✅ Summary complete!\n');
+    console.log('📝 Summary:\n');
+    console.log(summary);
+    console.log();
+  } catch (error) {
+    console.error('❌ Error during summarization:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  // Handle help
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    printUsage();
+    process.exit(0);
+  }
+
+  // Check for API key
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    console.error('❌ Error: ANTHROPIC_API_KEY environment variable required\n');
+    console.error('Set it with:');
+    console.error('  export ANTHROPIC_API_KEY="sk-ant-..."\n');
+    process.exit(1);
+  }
+
+  // Initialize provider and service
+  const provider = new ClaudeProvider(apiKey);
+  const service = new PRDService(provider);
+
+  // Handle test command
+  if (command === 'test') {
+    const success = await testConnection(provider);
+    process.exit(success ? 0 : 1);
+  }
+
+  // Handle parse and summarize commands
+  if (command === 'parse' || command === 'summarize') {
+    const file = args[1];
+
+    if (!file) {
+      console.error(`❌ Error: PRD file required for '${command}' command\n`);
+      console.error(`Usage: autopm-poc ${command} <prd-file>\n`);
+      process.exit(1);
+    }
+
+    // Check if file exists
+    if (!fs.existsSync(file)) {
+      console.error(`❌ Error: File not found: ${file}\n`);
+      process.exit(1);
+    }
+
+    // Read file content
+    const content = fs.readFileSync(file, 'utf8');
+
+    if (!content.trim()) {
+      console.error('❌ Error: PRD file is empty\n');
+      process.exit(1);
+    }
+
+    console.log(`📄 Reading PRD from: ${file}`);
+    console.log(`📏 File size: ${content.length} characters\n`);
+
+    // Execute command
+    if (command === 'parse') {
+      const jsonFlag = args[2] === '--json';
+
+      if (jsonFlag) {
+        await parsePRDJson(service, content);
+      } else {
+        await parsePRDStream(service, content);
+      }
+    } else if (command === 'summarize') {
+      await summarizePRD(service, content);
+    }
+
+    process.exit(0);
+  }
+
+  // Unknown command
+  console.error(`❌ Error: Unknown command: ${command}\n`);
+  printUsage();
+  process.exit(1);
+}
+
+// Run main with error handling
+main().catch(err => {
+  console.error('❌ Fatal error:', err.message);
+  console.error('\nStack trace:');
+  console.error(err.stack);
+  process.exit(1);
+});

package/install/install.js

@@ -46,7 +46,8 @@ class Installer {
       '.claude/mcp-servers.json',
       '.claude/.env.example',
       '.claude/teams.json',
-      '.claude-code'
+      '.claude-code',
+      'lib'  // Template engine and other utilities
     ];
 
     // Parse command line arguments

package/lib/ai-providers/ClaudeProvider.js

@@ -0,0 +1,112 @@
+/**
+ * ClaudeProvider - Anthropic Claude API integration
+ *
+ * Provides both synchronous completion and streaming capabilities
+ * for Claude AI interactions.
+ *
+ * Documentation Queries:
+ * - mcp://context7/anthropic/sdk - Anthropic SDK patterns
+ * - mcp://context7/anthropic/streaming - Streaming best practices
+ * - mcp://context7/nodejs/async-generators - Async generator patterns
+ */
+
+const Anthropic = require('@anthropic-ai/sdk');
+
+/**
+ * ClaudeProvider class for Anthropic Claude API integration
+ */
+class ClaudeProvider {
+  /**
+   * Create a new ClaudeProvider instance
+   * @param {string} apiKey - Anthropic API key
+   * @throws {Error} If API key is not provided
+   */
+  constructor(apiKey) {
+    if (!apiKey) {
+      throw new Error('API key is required for ClaudeProvider');
+    }
+
+    this.apiKey = apiKey;
+    this.client = new Anthropic({ apiKey });
+  }
+
+  /**
+   * Complete a prompt synchronously (wait for full response)
+   * @param {string} prompt - The prompt to complete
+   * @param {Object} options - Optional configuration
+   * @param {string} options.model - Model to use (default: claude-sonnet-4-20250514)
+   * @param {number} options.maxTokens - Maximum tokens to generate (default: 4096)
+   * @returns {Promise<string>} The completed text
+   */
+  async complete(prompt, options = {}) {
+    try {
+      const response = await this.client.messages.create({
+        model: options.model || 'claude-sonnet-4-20250514',
+        max_tokens: options.maxTokens || 4096,
+        messages: [{ role: 'user', content: prompt }]
+      });
+
+      // Extract text from response
+      if (response.content && response.content.length > 0) {
+        return response.content[0].text;
+      }
+
+      return '';
+    } catch (error) {
+      throw new Error(`Claude API error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Stream a prompt response (async generator for real-time feedback)
+   * @param {string} prompt - The prompt to complete
+   * @param {Object} options - Optional configuration
+   * @param {string} options.model - Model to use (default: claude-sonnet-4-20250514)
+   * @param {number} options.maxTokens - Maximum tokens to generate (default: 4096)
+   * @yields {string} Text chunks as they arrive
+   */
+  async *stream(prompt, options = {}) {
+    try {
+      const stream = await this.client.messages.create({
+        model: options.model || 'claude-sonnet-4-20250514',
+        max_tokens: options.maxTokens || 4096,
+        stream: true,
+        messages: [{ role: 'user', content: prompt }]
+      });
+
+      // Yield text deltas as they arrive
+      for await (const event of stream) {
+        if (event.type === 'content_block_delta' &&
+            event.delta &&
+            event.delta.type === 'text_delta') {
+          yield event.delta.text;
+        }
+      }
+    } catch (error) {
+      throw new Error(`Claude API streaming error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get the current model being used
+   * @returns {string} The default model name
+   */
+  getModel() {
+    return 'claude-sonnet-4-20250514';
+  }
+
+  /**
+   * Test the API connection
+   * @returns {Promise<boolean>} True if connection is successful
+   */
+  async testConnection() {
+    try {
+      await this.complete('Hello');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+module.exports = ClaudeProvider;