claude-autopm 1.28.0 → 1.30.0

package/lib/query-parser.js

@@ -0,0 +1,322 @@
+/**
+ * QueryParser - Parse command-line filter arguments into structured queries
+ *
+ * Converts CLI-style filter arguments into structured query objects for
+ * filtering PRDs, Epics, and Tasks.
+ *
+ * @example Basic Usage
+ * ```javascript
+ * const QueryParser = require('./lib/query-parser');
+ * const parser = new QueryParser();
+ *
+ * // Parse CLI arguments
+ * const query = parser.parse(['--status', 'active', '--priority', 'high']);
+ * // Returns: { status: 'active', priority: 'high' }
+ *
+ * // Validate query
+ * const validation = parser.validate(query);
+ * // Returns: { valid: true, errors: [] }
+ * ```
+ *
+ * @example Supported Filters
+ * ```javascript
+ * // Status filter
+ * parser.parse(['--status', 'active']);
+ *
+ * // Priority filter
+ * parser.parse(['--priority', 'P0']);
+ *
+ * // Date range filter
+ * parser.parse(['--created-after', '2025-01-01', '--created-before', '2025-12-31']);
+ *
+ * // Full-text search
+ * parser.parse(['--search', 'authentication API']);
+ *
+ * // Combined filters
+ * parser.parse([
+ *   '--status', 'active',
+ *   '--priority', 'high',
+ *   '--created-after', '2025-01-01',
+ *   '--search', 'OAuth2'
+ * ]);
+ * ```
+ *
+ * @module QueryParser
+ * @version 1.0.0
+ * @since v1.28.0
+ */
+
+class QueryParser {
+  constructor() {
+    /**
+     * Supported filter names
+     * @type {string[]}
+     */
+    this.supportedFilters = [
+      'status',
+      'priority',
+      'epic',
+      'author',
+      'assignee',
+      'created-after',
+      'created-before',
+      'updated-after',
+      'updated-before',
+      'search'
+    ];
+
+    /**
+     * Valid status values
+     * @type {string[]}
+     */
+    this.validStatuses = [
+      'draft',
+      'active',
+      'in_progress',
+      'completed',
+      'blocked',
+      'archived'
+    ];
+
+    /**
+     * Valid priority values
+     * @type {string[]}
+     */
+    this.validPriorities = [
+      'P0', 'P1', 'P2', 'P3',
+      'p0', 'p1', 'p2', 'p3',
+      'high', 'medium', 'low',
+      'High', 'Medium', 'Low',
+      'HIGH', 'MEDIUM', 'LOW'
+    ];
+
+    /**
+     * Date filter fields
+     * @type {string[]}
+     */
+    this.dateFilters = [
+      'created-after',
+      'created-before',
+      'updated-after',
+      'updated-before'
+    ];
+  }
+
+  /**
+   * Parse command-line filter arguments into structured query
+   *
+   * @param {string[]} args - Command-line arguments (e.g., ['--status', 'active'])
+   * @returns {Object} - Parsed query object
+   *
+   * @example
+   * const query = parser.parse(['--status', 'active', '--priority', 'high']);
+   * // Returns: { status: 'active', priority: 'high' }
+   */
+  parse(args) {
+    const query = {};
+
+    if (!Array.isArray(args) || args.length === 0) {
+      return query;
+    }
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+
+      // Check if this is a filter flag (starts with --)
+      if (!arg.startsWith('--')) {
+        continue;
+      }
+
+      // Extract filter name (remove -- prefix)
+      const filterName = arg.substring(2);
+
+      // Check if this is a supported filter
+      if (!this.supportedFilters.includes(filterName)) {
+        continue;
+      }
+
+      // Get the next argument as the value
+      const value = args[i + 1];
+
+      // Skip if no value or value is another flag
+      if (!value || value.startsWith('--')) {
+        continue;
+      }
+
+      // Trim whitespace
+      const trimmedValue = value.trim();
+
+      // Skip empty values
+      if (trimmedValue === '') {
+        continue;
+      }
+
+      // Add to query
+      query[filterName] = trimmedValue;
+
+      // Skip the next argument (we just consumed it as a value)
+      i++;
+    }
+
+    return query;
+  }
+
+  /**
+   * Validate query object
+   *
+   * Checks for valid date formats and other constraints.
+   *
+   * @param {Object} query - Query object to validate
+   * @returns {Object} - { valid: boolean, errors: string[] }
+   *
+   * @example
+   * const result = parser.validate({ status: 'active', 'created-after': '2025-01-01' });
+   * // Returns: { valid: true, errors: [] }
+   *
+   * const result2 = parser.validate({ 'created-after': 'invalid-date' });
+   * // Returns: { valid: false, errors: ['Invalid date format...'] }
+   */
+  validate(query) {
+    const errors = [];
+
+    if (!query || typeof query !== 'object') {
+      return { valid: true, errors: [] };
+    }
+
+    // Validate date filters
+    for (const dateFilter of this.dateFilters) {
+      if (query[dateFilter]) {
+        const value = query[dateFilter];
+
+        // Check YYYY-MM-DD format
+        if (!this.isValidDateFormat(value)) {
+          errors.push(`Invalid date format for ${dateFilter}: ${value} (expected YYYY-MM-DD)`);
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Check if a string is a valid date in YYYY-MM-DD format
+   *
+   * @param {string} dateString - Date string to validate
+   * @returns {boolean} - True if valid
+   * @private
+   */
+  isValidDateFormat(dateString) {
+    // Check format: YYYY-MM-DD
+    const regex = /^\d{4}-\d{2}-\d{2}$/;
+    if (!regex.test(dateString)) {
+      return false;
+    }
+
+    // Parse and validate actual date
+    const parts = dateString.split('-');
+    const year = parseInt(parts[0], 10);
+    const month = parseInt(parts[1], 10);
+    const day = parseInt(parts[2], 10);
+
+    // Check ranges
+    if (month < 1 || month > 12) {
+      return false;
+    }
+
+    if (day < 1 || day > 31) {
+      return false;
+    }
+
+    // Create date and verify it matches input
+    // (this catches invalid dates like 2025-02-31)
+    const date = new Date(year, month - 1, day);
+    return (
+      date.getFullYear() === year &&
+      date.getMonth() === month - 1 &&
+      date.getDate() === day
+    );
+  }
+
+  /**
+   * Get list of supported filters
+   *
+   * @returns {string[]} - Array of supported filter names
+   *
+   * @example
+   * const filters = parser.getSupportedFilters();
+   * // Returns: ['status', 'priority', 'epic', ...]
+   */
+  getSupportedFilters() {
+    return [...this.supportedFilters];
+  }
+
+  /**
+   * Get help text for filters
+   *
+   * Returns formatted help text describing all available filters
+   * with examples.
+   *
+   * @returns {string} - Formatted help text
+   *
+   * @example
+   * console.log(parser.getFilterHelp());
+   * // Outputs:
+   * // Available Filters:
+   * //   --status <value>        Filter by status (draft, active, ...)
+   * //   --priority <value>      Filter by priority (P0, P1, high, ...)
+   * //   ...
+   */
+  getFilterHelp() {
+    return `
+Available Filters:
+
+  --status <value>              Filter by status
+                                Values: draft, active, in_progress, completed, blocked, archived
+                                Example: --status active
+
+  --priority <value>            Filter by priority
+                                Values: P0, P1, P2, P3, high, medium, low
+                                Example: --priority high
+
+  --epic <id>                   Filter by epic ID
+                                Example: --epic epic-001
+
+  --author <name>               Filter by author name
+                                Example: --author john
+
+  --assignee <name>             Filter by assignee name
+                                Example: --assignee jane
+
+  --created-after <date>        Created after date (YYYY-MM-DD)
+                                Example: --created-after 2025-01-01
+
+  --created-before <date>       Created before date (YYYY-MM-DD)
+                                Example: --created-before 2025-12-31
+
+  --updated-after <date>        Updated after date (YYYY-MM-DD)
+                                Example: --updated-after 2025-06-01
+
+  --updated-before <date>       Updated before date (YYYY-MM-DD)
+                                Example: --updated-before 2025-06-30
+
+  --search <text>               Full-text search in content and frontmatter
+                                Example: --search "authentication API"
+
+Examples:
+
+  # Filter by status and priority
+  --status active --priority high
+
+  # Filter by date range
+  --created-after 2025-01-01 --created-before 2025-12-31
+
+  # Combine filters
+  --status active --priority P0 --epic epic-001 --search "OAuth2"
+`.trim();
+  }
+}
+
+module.exports = QueryParser;

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-autopm",
-  "version": "1.28.0",
+  "version": "1.30.0",
   "description": "Autonomous Project Management Framework for Claude Code - Advanced AI-powered development automation",
   "main": "bin/autopm.js",
   "bin": {
@@ -114,6 +114,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@octokit/rest": "^22.0.0",
     "azure-devops-node-api": "^15.1.1",
     "chalk": "^5.3.0",
     "dotenv": "^16.6.1",
@@ -128,9 +129,9 @@
     "ora": "^5.4.1",
     "simple-git": "^3.20.0",
     "table": "^6.8.1",
-    "which": "^4.0.0",
+    "which": "^5.0.0",
     "yaml": "^2.8.1",
-    "yargs": "^17.7.2"
+    "yargs": "^18.0.0"
   },
   "devDependencies": {
     "@jest/globals": "^30.1.2",
@@ -151,7 +152,7 @@
     "sinon": "^21.0.0"
   },
   "optionalDependencies": {
-    "@playwright/mcp": "^0.0.40",
+    "@playwright/mcp": "^0.0.41",
     "@upstash/context7-mcp": "^1.0.0"
   },
   "publishConfig": {