claude-autopm 1.17.0 → 1.20.0

package/lib/helpers/azure-cache-manager.js

@@ -1,287 +0,0 @@
-#!/usr/bin/env node
-/**
- * Azure DevOps Intelligent Cache Manager
- * Implements smart caching with preloading and predictive fetching
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const crypto = require('crypto');
-
-class CacheManager {
-    constructor(options = {}) {
-        this.cacheDir = options.cacheDir || path.join(process.cwd(), '.claude', 'azure', 'cache');
-        this.maxAge = options.maxAge || 3600000; // 1 hour default
-        this.maxSize = options.maxSize || 100 * 1024 * 1024; // 100MB default
-        this.preloadPatterns = new Map();
-        this.accessLog = new Map();
-    }
-
-    /**
-     * Initialize cache directory
-     */
-    async init() {
-        await fs.mkdir(this.cacheDir, { recursive: true });
-        await fs.mkdir(path.join(this.cacheDir, 'workitems'), { recursive: true });
-        await fs.mkdir(path.join(this.cacheDir, 'queries'), { recursive: true });
-        await fs.mkdir(path.join(this.cacheDir, 'metadata'), { recursive: true });
-        await this.loadAccessLog();
-    }
-
-    /**
-     * Get cached item with intelligent preloading
-     */
-    async get(key, category = 'general') {
-        const filePath = this.getCachePath(key, category);
-
-        try {
-            const stats = await fs.stat(filePath);
-            const age = Date.now() - stats.mtime.getTime();
-
-            if (age > this.maxAge) {
-                await fs.unlink(filePath).catch(() => {});
-                return null;
-            }
-
-            const data = await fs.readFile(filePath, 'utf8');
-
-            // Track access for intelligent preloading
-            this.trackAccess(key, category);
-
-            // Trigger preloading if patterns detected
-            this.triggerPreload(key, category);
-
-            return JSON.parse(data);
-        } catch {
-            return null;
-        }
-    }
-
-    /**
-     * Set cache item
-     */
-    async set(key, value, category = 'general', ttl = null) {
-        const filePath = this.getCachePath(key, category);
-
-        await fs.mkdir(path.dirname(filePath), { recursive: true });
-        await fs.writeFile(filePath, JSON.stringify(value, null, 2));
-
-        if (ttl) {
-            // Store TTL metadata
-            const metaPath = path.join(this.cacheDir, 'metadata', `${key}.meta`);
-            await fs.writeFile(metaPath, JSON.stringify({ ttl, created: Date.now() }));
-        }
-
-        // Cleanup if cache size exceeded
-        await this.enforceSize();
-    }
-
-    /**
-     * Intelligent preloading based on access patterns
-     */
-    async preload(items, fetcher, category = 'workitems') {
-        const uncached = [];
-        const cached = [];
-
-        // Check what's already cached
-        for (const item of items) {
-            const key = typeof item === 'object' ? item.id : item;
-            const cachedItem = await this.get(key, category);
-
-            if (cachedItem) {
-                cached.push(cachedItem);
-            } else {
-                uncached.push(item);
-            }
-        }
-
-        // Fetch uncached items in parallel
-        if (uncached.length > 0 && fetcher) {
-            const freshData = await fetcher(uncached);
-
-            // Cache the fresh data
-            for (let i = 0; i < freshData.length; i++) {
-                if (freshData[i]) {
-                    const key = typeof uncached[i] === 'object' ? uncached[i].id : uncached[i];
-                    await this.set(key, freshData[i], category);
-                    cached.push(freshData[i]);
-                }
-            }
-        }
-
-        return cached;
-    }
-
-    /**
-     * Track access patterns for intelligent preloading
-     * @private
-     */
-    trackAccess(key, category) {
-        const accessKey = `${category}:${key}`;
-        const accesses = this.accessLog.get(accessKey) || [];
-        accesses.push(Date.now());
-
-        // Keep only recent accesses (last 24 hours)
-        const cutoff = Date.now() - 86400000;
-        const recentAccesses = accesses.filter(time => time > cutoff);
-
-        this.accessLog.set(accessKey, recentAccesses);
-    }
-
-    /**
-     * Trigger preloading based on patterns
-     * @private
-     */
-    async triggerPreload(key, category) {
-        // Detect sequential access patterns
-        if (category === 'workitems' && /^\d+$/.test(key)) {
-            const id = parseInt(key);
-            const related = [];
-
-            // Preload adjacent items
-            for (let i = id - 2; i <= id + 2; i++) {
-                if (i !== id && i > 0) {
-                    related.push(i.toString());
-                }
-            }
-
-            // Preload in background
-            setImmediate(async () => {
-                for (const relatedId of related) {
-                    const cached = await this.get(relatedId, category);
-                    if (!cached) {
-                        // Mark for background fetch
-                        this.preloadPatterns.set(relatedId, Date.now());
-                    }
-                }
-            });
-        }
-    }
-
-    /**
-     * Get cache path for key
-     * @private
-     */
-    getCachePath(key, category) {
-        const hashedKey = crypto.createHash('md5').update(key).digest('hex');
-        return path.join(this.cacheDir, category, `${hashedKey}.json`);
-    }
-
-    /**
-     * Enforce cache size limit
-     * @private
-     */
-    async enforceSize() {
-        try {
-            const files = await this.getAllCacheFiles();
-            let totalSize = 0;
-            const fileStats = [];
-
-            for (const file of files) {
-                const stats = await fs.stat(file);
-                totalSize += stats.size;
-                fileStats.push({ path: file, size: stats.size, mtime: stats.mtime });
-            }
-
-            if (totalSize > this.maxSize) {
-                // Sort by modification time (oldest first)
-                fileStats.sort((a, b) => a.mtime - b.mtime);
-
-                // Remove oldest files until under limit
-                for (const file of fileStats) {
-                    if (totalSize <= this.maxSize) break;
-
-                    await fs.unlink(file.path).catch(() => {});
-                    totalSize -= file.size;
-                }
-            }
-        } catch (error) {
-            console.error('Cache cleanup error:', error.message);
-        }
-    }
-
-    /**
-     * Get all cache files
-     * @private
-     */
-    async getAllCacheFiles() {
-        const files = [];
-        const categories = ['workitems', 'queries', 'general'];
-
-        for (const category of categories) {
-            const dir = path.join(this.cacheDir, category);
-            try {
-                const entries = await fs.readdir(dir);
-                files.push(...entries.map(f => path.join(dir, f)));
-            } catch {}
-        }
-
-        return files;
-    }
-
-    /**
-     * Load access log from disk
-     * @private
-     */
-    async loadAccessLog() {
-        const logPath = path.join(this.cacheDir, 'metadata', 'access.log');
-        try {
-            const data = await fs.readFile(logPath, 'utf8');
-            this.accessLog = new Map(JSON.parse(data));
-        } catch {}
-    }
-
-    /**
-     * Save access log to disk
-     */
-    async saveAccessLog() {
-        const logPath = path.join(this.cacheDir, 'metadata', 'access.log');
-        await fs.mkdir(path.dirname(logPath), { recursive: true });
-        await fs.writeFile(logPath, JSON.stringify([...this.accessLog]));
-    }
-
-    /**
-     * Clear all cache
-     */
-    async clear() {
-        await fs.rm(this.cacheDir, { recursive: true, force: true });
-        await this.init();
-    }
-
-    /**
-     * Get cache statistics
-     */
-    async getStats() {
-        const files = await this.getAllCacheFiles();
-        let totalSize = 0;
-        let totalFiles = files.length;
-        let oldestFile = null;
-        let newestFile = null;
-
-        for (const file of files) {
-            try {
-                const stats = await fs.stat(file);
-                totalSize += stats.size;
-
-                if (!oldestFile || stats.mtime < oldestFile.mtime) {
-                    oldestFile = { path: file, mtime: stats.mtime };
-                }
-
-                if (!newestFile || stats.mtime > newestFile.mtime) {
-                    newestFile = { path: file, mtime: stats.mtime };
-                }
-            } catch {}
-        }
-
-        return {
-            totalFiles,
-            totalSize,
-            totalSizeMB: (totalSize / (1024 * 1024)).toFixed(2),
-            oldestFile,
-            newestFile,
-            utilizationPercent: Math.round((totalSize / this.maxSize) * 100)
-        };
-    }
-}
-
-module.exports = CacheManager;

package/lib/helpers/azure-parallel-processor.js

@@ -1,158 +0,0 @@
-#!/usr/bin/env node
-/**
- * Azure DevOps Parallel Processor
- * Enables parallel processing of work items and API calls
- */
-
-const { Worker } = require('worker_threads');
-const os = require('os');
-
-class ParallelProcessor {
-    constructor(options = {}) {
-        this.maxWorkers = options.maxWorkers || os.cpus().length;
-        this.taskQueue = [];
-        this.activeWorkers = 0;
-    }
-
-    /**
-     * Process items in parallel
-     * @param {Array} items - Items to process
-     * @param {Function} processor - Processing function
-     * @param {Object} options - Processing options
-     * @returns {Promise<Array>} Processed results
-     */
-    async processParallel(items, processor, options = {}) {
-        const chunkSize = Math.ceil(items.length / this.maxWorkers);
-        const chunks = this.chunkArray(items, chunkSize);
-
-        const promises = chunks.map(chunk =>
-            this.processChunk(chunk, processor, options)
-        );
-
-        const results = await Promise.all(promises);
-        return results.flat();
-    }
-
-    /**
-     * Process a chunk of items
-     * @private
-     */
-    async processChunk(chunk, processor, options) {
-        const results = [];
-
-        // Use Promise.all for concurrent processing within chunk
-        const promises = chunk.map(item =>
-            this.wrapWithTimeout(
-                processor(item, options),
-                options.timeout || 30000
-            )
-        );
-
-        try {
-            const chunkResults = await Promise.allSettled(promises);
-
-            for (const result of chunkResults) {
-                if (result.status === 'fulfilled') {
-                    results.push(result.value);
-                } else {
-                    console.error(`Processing failed: ${result.reason}`);
-                    results.push(null);
-                }
-            }
-        } catch (error) {
-            console.error(`Chunk processing error: ${error.message}`);
-        }
-
-        return results;
-    }
-
-    /**
-     * Wrap promise with timeout
-     * @private
-     */
-    wrapWithTimeout(promise, timeout) {
-        return Promise.race([
-            promise,
-            new Promise((_, reject) =>
-                setTimeout(() => reject(new Error('Operation timed out')), timeout)
-            )
-        ]);
-    }
-
-    /**
-     * Chunk array into smaller arrays
-     * @private
-     */
-    chunkArray(array, size) {
-        const chunks = [];
-        for (let i = 0; i < array.length; i += size) {
-            chunks.push(array.slice(i, i + size));
-        }
-        return chunks;
-    }
-
-    /**
-     * Process WIQL queries in parallel
-     */
-    async parallelWiqlQueries(queries, apiClient) {
-        return this.processParallel(
-            queries,
-            async (query) => {
-                try {
-                    return await apiClient.queryByWiql(query);
-                } catch (error) {
-                    console.error(`Query failed: ${error.message}`);
-                    return null;
-                }
-            },
-            { timeout: 10000 }
-        );
-    }
-
-    /**
-     * Fetch work items in parallel
-     */
-    async parallelFetchWorkItems(ids, apiClient, options = {}) {
-        const showProgress = options.showProgress !== false;
-        let processed = 0;
-
-        return this.processParallel(
-            ids,
-            async (id) => {
-                try {
-                    const result = await apiClient.getWorkItem(id);
-
-                    if (showProgress) {
-                        processed++;
-                        this.updateProgress(processed, ids.length);
-                    }
-
-                    return result;
-                } catch (error) {
-                    console.error(`Failed to fetch work item ${id}: ${error.message}`);
-                    return null;
-                }
-            },
-            { timeout: 5000 }
-        );
-    }
-
-    /**
-     * Update progress indicator
-     * @private
-     */
-    updateProgress(current, total) {
-        const percent = Math.round((current / total) * 100);
-        const barLength = 30;
-        const filled = Math.round((percent / 100) * barLength);
-        const bar = '█'.repeat(filled) + '░'.repeat(barLength - filled);
-
-        process.stdout.write(`\rProgress: ${bar} ${percent}% (${current}/${total})`);
-
-        if (current === total) {
-            process.stdout.write('\n');
-        }
-    }
-}
-
-module.exports = ParallelProcessor;

package/lib/helpers/azure-work-item-create.js

@@ -1,278 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Azure DevOps Work Item Creation Helper
- * Provides methods to create work items with JSON responses
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-
-class AzureWorkItemCreator {
-  constructor() {
-    this.client = null;
-  }
-
-  /**
-   * Set Azure DevOps client
-   */
-  _setClient(client) {
-    this.client = client;
-  }
-
-  /**
-   * Validate that client is configured
-   */
-  _validateClient() {
-    if (!this.client) {
-      throw new Error('Azure DevOps client not configured. Call _setClient() first.');
-    }
-  }
-
-  /**
-   * Validate required options
-   */
-  _validateOptions(options, requiredFields = ['title']) {
-    for (const field of requiredFields) {
-      if (!options[field]) {
-        throw new Error(`${field} is required`);
-      }
-    }
-  }
-
-  /**
-   * Build work item fields from options
-   */
-  async _buildFields(options) {
-    const fields = {};
-
-    // Title
-    if (options.title) {
-      fields['System.Title'] = options.title;
-    }
-
-    // Description
-    if (options.description) {
-      fields['System.Description'] = options.description;
-    } else if (options.descriptionFile) {
-      fields['System.Description'] = await fs.readFile(options.descriptionFile, 'utf8');
-    }
-
-    // Tags
-    if (options.tags && options.tags.length > 0) {
-      fields['System.Tags'] = options.tags.join('; ');
-    }
-
-    // Priority
-    if (options.priority !== undefined) {
-      fields['Microsoft.VSTS.Common.Priority'] = options.priority;
-    }
-
-    // Severity (for bugs)
-    if (options.severity) {
-      fields['Microsoft.VSTS.Common.Severity'] = options.severity;
-    }
-
-    // Iteration Path
-    if (options.iterationPath) {
-      fields['System.IterationPath'] = options.iterationPath;
-    }
-
-    // Area Path
-    if (options.areaPath) {
-      fields['System.AreaPath'] = options.areaPath;
-    }
-
-    // Assigned To
-    if (options.assignedTo) {
-      fields['System.AssignedTo'] = options.assignedTo;
-    }
-
-    // Acceptance Criteria (for stories)
-    if (options.acceptanceCriteria) {
-      if (typeof options.acceptanceCriteria === 'string') {
-        fields['Microsoft.VSTS.Common.AcceptanceCriteria'] = options.acceptanceCriteria;
-      } else if (Array.isArray(options.acceptanceCriteria)) {
-        fields['Microsoft.VSTS.Common.AcceptanceCriteria'] =
-          options.acceptanceCriteria.map(c => `- ${c}`).join('\n');
-      }
-    }
-
-    // Story Points (for stories)
-    if (options.storyPoints !== undefined) {
-      fields['Microsoft.VSTS.Scheduling.StoryPoints'] = options.storyPoints;
-    }
-
-    // Remaining Work (for tasks)
-    if (options.remainingWork !== undefined) {
-      fields['Microsoft.VSTS.Scheduling.RemainingWork'] = options.remainingWork;
-    }
-
-    // Parent link
-    if (options.parentId) {
-      fields['System.Parent'] = options.parentId;
-    }
-
-    return fields;
-  }
-
-  /**
-   * Format work item response
-   */
-  _formatResponse(workItem) {
-    return {
-      id: workItem.id,
-      type: workItem.fields['System.WorkItemType'],
-      title: workItem.fields['System.Title'],
-      state: workItem.fields['System.State'],
-      url: workItem._links?.html?.href || `https://dev.azure.com/_workitems/edit/${workItem.id}`,
-      fields: workItem.fields
-    };
-  }
-
-  /**
-   * Create a work item
-   */
-  async createWorkItem(options) {
-    this._validateClient();
-    this._validateOptions(options, ['title']);
-
-    try {
-      const fields = await this._buildFields(options);
-      const workItem = await this.client.createWorkItem(options.type, fields);
-
-      return this._formatResponse(workItem);
-    } catch (error) {
-      if (error.message && error.message.includes('Unauthorized')) {
-        throw new Error('Azure DevOps API Error: Unauthorized. Check your PAT token.');
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Create an Epic
-   */
-  async createEpic(options) {
-    const epicName = options.epicName || options.title?.replace(/^Epic:\s*/, '');
-
-    if (!epicName && !options.title) {
-      throw new Error('epicName or title is required for epic creation');
-    }
-
-    // Prepare epic options
-    const epicOptions = {
-      type: 'Epic',
-      title: options.title || `Epic: ${epicName}`,
-      description: options.description || this._generateEpicDescription(options),
-      tags: ['epic', `epic:${epicName}`],
-      priority: options.priority
-    };
-
-    // Add additional fields
-    if (options.acceptanceCriteria) {
-      epicOptions.acceptanceCriteria = options.acceptanceCriteria;
-    }
-
-    return await this.createWorkItem(epicOptions);
-  }
-
-  /**
-   * Generate epic description from options
-   */
-  _generateEpicDescription(options) {
-    let description = '## Epic Description\n\n';
-
-    if (options.description) {
-      description += `${options.description}\n\n`;
-    }
-
-    if (options.acceptanceCriteria && options.acceptanceCriteria.length > 0) {
-      description += '## Acceptance Criteria\n\n';
-      options.acceptanceCriteria.forEach(criteria => {
-        description += `- ${criteria}\n`;
-      });
-      description += '\n';
-    }
-
-    if (options.tasks && options.tasks.length > 0) {
-      description += '## Tasks\n\n';
-      options.tasks.forEach(task => {
-        description += `- ${task}\n`;
-      });
-    }
-
-    return description;
-  }
-
-  /**
-   * Create a User Story
-   */
-  async createUserStory(options) {
-    this._validateOptions(options, ['title']);
-
-    const storyOptions = {
-      type: 'User Story',
-      ...options
-    };
-
-    return await this.createWorkItem(storyOptions);
-  }
-
-  /**
-   * Create a Task
-   */
-  async createTask(options) {
-    this._validateOptions(options, ['title']);
-
-    const taskOptions = {
-      type: 'Task',
-      ...options
-    };
-
-    return await this.createWorkItem(taskOptions);
-  }
-
-  /**
-   * Create multiple work items in batch
-   */
-  async createBatch(items) {
-    const results = [];
-
-    for (const item of items) {
-      try {
-        const result = await this.createWorkItem(item);
-        results.push(result);
-      } catch (error) {
-        results.push({
-          error: error.message,
-          item
-        });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Helper method for PM commands - create epic and return just the ID
-   */
-  async createEpicAndGetId(options) {
-    const result = await this.createEpic(options);
-    return result.id;
-  }
-}
-
-// Create singleton instance
-const creator = new AzureWorkItemCreator();
-
-// Export methods bound to instance
-module.exports = {
-  createWorkItem: creator.createWorkItem.bind(creator),
-  createEpic: creator.createEpic.bind(creator),
-  createUserStory: creator.createUserStory.bind(creator),
-  createTask: creator.createTask.bind(creator),
-  createBatch: creator.createBatch.bind(creator),
-  createEpicAndGetId: creator.createEpicAndGetId.bind(creator),
-  _setClient: creator._setClient.bind(creator)
-};