claude-code-workflow 6.3.37 → 6.3.39

package/ccw/dist/core/routes/issue-routes.js

@@ -203,18 +203,20 @@ function getIssueDetail(issuesDir, issueId) {
 function enrichIssues(issues, issuesDir) {
     return issues.map(issue => {
         const solutions = readSolutionsJsonl(issuesDir, issue.id);
-        let taskCount = 0;
-        // Get task count from bound solution
+        let tasks = [];
+        // Get tasks from bound solution
         if (issue.bound_solution_id) {
             const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
             if (boundSol?.tasks) {
-                taskCount = boundSol.tasks.length;
+                tasks = boundSol.tasks;
             }
         }
         return {
             ...issue,
+            solutions, // Add full solutions array
+            tasks, // Add full tasks array
             solution_count: solutions.length,
-            task_count: taskCount
+            task_count: tasks.length
         };
     });
 }
@@ -310,37 +312,52 @@ export async function handleIssueRoutes(ctx) {
         return true;
     }
     const issuesDir = join(projectPath, '.workflow', 'issues');
-    // ===== Queue Routes (top-level /api/queue) =====
-    // GET /api/queue - Get execution queue
-    if (pathname === '/api/queue' && req.method === 'GET') {
+    // ===== Helper: Normalize queue path (supports both /api/queue/* and /api/issues/queue/*) =====
+    const normalizeQueuePath = (path) => {
+        if (path.startsWith('/api/issues/queue')) {
+            return path.replace('/api/issues/queue', '/api/queue');
+        }
+        if (path.startsWith('/api/queue')) {
+            return path;
+        }
+        return null;
+    };
+    const normalizedPath = normalizeQueuePath(pathname);
+    // ===== Queue Routes (supports both /api/queue/* and /api/issues/queue/*) =====
+    // GET /api/queue or /api/issues/queue - Get execution queue
+    if ((normalizedPath === '/api/queue') && req.method === 'GET') {
         const queue = groupQueueByExecutionGroup(readQueue(issuesDir));
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(queue));
         return true;
     }
-    // GET /api/queue/history - Get queue history (all queues from index)
-    if (pathname === '/api/queue/history' && req.method === 'GET') {
+    // GET /api/queue/history or /api/issues/queue/history - Get queue history (all queues from index)
+    if (normalizedPath === '/api/queue/history' && req.method === 'GET') {
         const queuesDir = join(issuesDir, 'queues');
         const indexPath = join(queuesDir, 'index.json');
         if (!existsSync(indexPath)) {
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ queues: [], active_queue_id: null }));
+            res.end(JSON.stringify({ queues: [], active_queue_id: null, active_queue_ids: [] }));
             return true;
         }
         try {
             const index = JSON.parse(readFileSync(indexPath, 'utf8'));
+            // Ensure active_queue_ids is always returned for multi-queue support
+            if (!index.active_queue_ids) {
+                index.active_queue_ids = index.active_queue_id ? [index.active_queue_id] : [];
+            }
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify(index));
         }
         catch {
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ queues: [], active_queue_id: null }));
+            res.end(JSON.stringify({ queues: [], active_queue_id: null, active_queue_ids: [] }));
         }
         return true;
     }
-    // GET /api/queue/:id - Get specific queue by ID
-    const queueDetailMatch = pathname.match(/^\/api\/queue\/([^/]+)$/);
-    const reservedQueuePaths = ['history', 'reorder', 'switch', 'deactivate', 'merge'];
+    // GET /api/queue/:id or /api/issues/queue/:id - Get specific queue by ID
+    const queueDetailMatch = normalizedPath?.match(/^\/api\/queue\/([^/]+)$/);
+    const reservedQueuePaths = ['history', 'reorder', 'switch', 'deactivate', 'merge', 'activate'];
     if (queueDetailMatch && req.method === 'GET' && !reservedQueuePaths.includes(queueDetailMatch[1])) {
         const queueId = queueDetailMatch[1];
         const queuesDir = join(issuesDir, 'queues');
@@ -361,8 +378,47 @@ export async function handleIssueRoutes(ctx) {
         }
         return true;
     }
-    // POST /api/queue/switch - Switch active queue
-    if (pathname === '/api/queue/switch' && req.method === 'POST') {
+    // POST /api/queue/activate or /api/issues/queue/activate - Activate one or more queues (multi-queue support)
+    if (normalizedPath === '/api/queue/activate' && req.method === 'POST') {
+        handlePostRequest(req, res, async (body) => {
+            const { queueId, queueIds } = body;
+            // Support both single queueId and array queueIds
+            const idsToActivate = queueIds
+                ? (Array.isArray(queueIds) ? queueIds : [queueIds])
+                : (queueId ? [queueId] : []);
+            if (idsToActivate.length === 0) {
+                return { error: 'queueId or queueIds required' };
+            }
+            const queuesDir = join(issuesDir, 'queues');
+            const indexPath = join(queuesDir, 'index.json');
+            // Validate all queue IDs exist
+            for (const id of idsToActivate) {
+                const queueFilePath = join(queuesDir, `${id}.json`);
+                if (!existsSync(queueFilePath)) {
+                    return { error: `Queue ${id} not found` };
+                }
+            }
+            try {
+                const index = existsSync(indexPath)
+                    ? JSON.parse(readFileSync(indexPath, 'utf8'))
+                    : { active_queue_id: null, active_queue_ids: [], queues: [] };
+                index.active_queue_ids = idsToActivate;
+                index.active_queue_id = idsToActivate[0] || null; // Backward compat
+                writeFileSync(indexPath, JSON.stringify(index, null, 2));
+                return {
+                    success: true,
+                    active_queue_ids: idsToActivate,
+                    active_queue_id: idsToActivate[0] || null // Backward compat
+                };
+            }
+            catch (err) {
+                return { error: 'Failed to activate queue(s)' };
+            }
+        });
+        return true;
+    }
+    // POST /api/queue/switch or /api/issues/queue/switch - Switch active queue (legacy, single queue)
+    if (normalizedPath === '/api/queue/switch' && req.method === 'POST') {
         handlePostRequest(req, res, async (body) => {
             const { queueId } = body;
             if (!queueId)
@@ -376,10 +432,15 @@ export async function handleIssueRoutes(ctx) {
             try {
                 const index = existsSync(indexPath)
                     ? JSON.parse(readFileSync(indexPath, 'utf8'))
-                    : { active_queue_id: null, queues: [] };
+                    : { active_queue_id: null, active_queue_ids: [], queues: [] };
                 index.active_queue_id = queueId;
+                index.active_queue_ids = [queueId]; // Also update multi-queue array
                 writeFileSync(indexPath, JSON.stringify(index, null, 2));
-                return { success: true, active_queue_id: queueId };
+                return {
+                    success: true,
+                    active_queue_id: queueId,
+                    active_queue_ids: [queueId]
+                };
             }
             catch (err) {
                 return { error: 'Failed to switch queue' };
@@ -387,19 +448,38 @@ export async function handleIssueRoutes(ctx) {
         });
         return true;
     }
-    // POST /api/queue/deactivate - Deactivate current queue (set active to null)
-    if (pathname === '/api/queue/deactivate' && req.method === 'POST') {
+    // POST /api/queue/deactivate or /api/issues/queue/deactivate - Deactivate queue(s)
+    if (normalizedPath === '/api/queue/deactivate' && req.method === 'POST') {
         handlePostRequest(req, res, async (body) => {
+            const { queueId } = body; // Optional: specific queue to deactivate
             const queuesDir = join(issuesDir, 'queues');
             const indexPath = join(queuesDir, 'index.json');
             try {
                 const index = existsSync(indexPath)
                     ? JSON.parse(readFileSync(indexPath, 'utf8'))
-                    : { active_queue_id: null, queues: [] };
-                const previousActiveId = index.active_queue_id;
-                index.active_queue_id = null;
+                    : { active_queue_id: null, active_queue_ids: [], queues: [] };
+                const currentActiveIds = index.active_queue_ids || (index.active_queue_id ? [index.active_queue_id] : []);
+                let deactivatedIds = [];
+                let remainingIds = [];
+                if (queueId) {
+                    // Deactivate specific queue
+                    deactivatedIds = currentActiveIds.includes(queueId) ? [queueId] : [];
+                    remainingIds = currentActiveIds.filter((id) => id !== queueId);
+                }
+                else {
+                    // Deactivate all
+                    deactivatedIds = [...currentActiveIds];
+                    remainingIds = [];
+                }
+                index.active_queue_ids = remainingIds;
+                index.active_queue_id = remainingIds[0] || null; // Backward compat
                 writeFileSync(indexPath, JSON.stringify(index, null, 2));
-                return { success: true, previous_active_id: previousActiveId };
+                return {
+                    success: true,
+                    deactivated_queue_ids: deactivatedIds,
+                    active_queue_ids: remainingIds,
+                    active_queue_id: remainingIds[0] || null // Backward compat
+                };
             }
             catch (err) {
                 return { error: 'Failed to deactivate queue' };
@@ -407,8 +487,8 @@ export async function handleIssueRoutes(ctx) {
         });
         return true;
     }
-    // POST /api/queue/reorder - Reorder queue items (supports both solutions and tasks)
-    if (pathname === '/api/queue/reorder' && req.method === 'POST') {
+    // POST /api/queue/reorder or /api/issues/queue/reorder - Reorder queue items (supports both solutions and tasks)
+    if (normalizedPath === '/api/queue/reorder' && req.method === 'POST') {
         handlePostRequest(req, res, async (body) => {
             const { groupId, newOrder } = body;
             if (!groupId || !Array.isArray(newOrder)) {
@@ -454,8 +534,8 @@ export async function handleIssueRoutes(ctx) {
         });
         return true;
     }
-    // DELETE /api/queue/:queueId/item/:itemId - Delete item from queue
-    const queueItemDeleteMatch = pathname.match(/^\/api\/queue\/([^/]+)\/item\/([^/]+)$/);
+    // DELETE /api/queue/:queueId/item/:itemId or /api/issues/queue/:queueId/item/:itemId
+    const queueItemDeleteMatch = normalizedPath?.match(/^\/api\/queue\/([^/]+)\/item\/([^/]+)$/);
     if (queueItemDeleteMatch && req.method === 'DELETE') {
         const queueId = queueItemDeleteMatch[1];
         const itemId = decodeURIComponent(queueItemDeleteMatch[2]);
@@ -523,8 +603,8 @@ export async function handleIssueRoutes(ctx) {
         }
         return true;
     }
-    // DELETE /api/queue/:queueId - Delete entire queue
-    const queueDeleteMatch = pathname.match(/^\/api\/queue\/([^/]+)$/);
+    // DELETE /api/queue/:queueId or /api/issues/queue/:queueId - Delete entire queue
+    const queueDeleteMatch = normalizedPath?.match(/^\/api\/queue\/([^/]+)$/);
     if (queueDeleteMatch && req.method === 'DELETE') {
         const queueId = queueDeleteMatch[1];
         const queuesDir = join(issuesDir, 'queues');
@@ -558,8 +638,8 @@ export async function handleIssueRoutes(ctx) {
         }
         return true;
     }
-    // POST /api/queue/merge - Merge source queue into target queue
-    if (pathname === '/api/queue/merge' && req.method === 'POST') {
+    // POST /api/queue/merge or /api/issues/queue/merge - Merge source queue into target queue
+    if (normalizedPath === '/api/queue/merge' && req.method === 'POST') {
         handlePostRequest(req, res, async (body) => {
             const { sourceQueueId, targetQueueId } = body;
             if (!sourceQueueId || !targetQueueId) {
@@ -681,7 +761,7 @@ export async function handleIssueRoutes(ctx) {
         return true;
     }
     // POST /api/queue/split - Split items from source queue into a new queue
-    if (pathname === '/api/queue/split' && req.method === 'POST') {
+    if (normalizedPath === '/api/queue/split' && req.method === 'POST') {
         handlePostRequest(req, res, async (body) => {
             const { sourceQueueId, itemIds } = body;
             if (!sourceQueueId || !itemIds || !Array.isArray(itemIds) || itemIds.length === 0) {
@@ -889,6 +969,173 @@ export async function handleIssueRoutes(ctx) {
         });
         return true;
     }
+    // POST /api/issues/pull - Pull issues from GitHub
+    if (pathname === '/api/issues/pull' && req.method === 'POST') {
+        const state = url.searchParams.get('state') || 'open';
+        const limit = parseInt(url.searchParams.get('limit') || '100');
+        const labels = url.searchParams.get('labels') || '';
+        const downloadImages = url.searchParams.get('downloadImages') === 'true';
+        try {
+            const { execSync } = await import('child_process');
+            const https = await import('https');
+            const http = await import('http');
+            // Check if gh CLI is available
+            try {
+                execSync('gh --version', { stdio: 'ignore', timeout: 5000 });
+            }
+            catch {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'GitHub CLI (gh) is not installed or not in PATH' }));
+                return true;
+            }
+            // Build gh command
+            let ghCommand = `gh issue list --state ${state} --limit ${limit} --json number,title,body,labels,url,state`;
+            if (labels)
+                ghCommand += ` --label "${labels}"`;
+            // Execute gh command from project root
+            const ghOutput = execSync(ghCommand, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: 60000,
+                cwd: issuesDir.replace(/[\\/]\.workflow[\\/]issues$/, '')
+            }).trim();
+            if (!ghOutput) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ imported: 0, updated: 0, skipped: 0, images_downloaded: 0 }));
+                return true;
+            }
+            const ghIssues = JSON.parse(ghOutput);
+            const existingIssues = readIssuesJsonl(issuesDir);
+            let imported = 0;
+            let skipped = 0;
+            let updated = 0;
+            let imagesDownloaded = 0;
+            // Create images directory if needed
+            const imagesDir = join(issuesDir, 'images');
+            if (downloadImages && !existsSync(imagesDir)) {
+                mkdirSync(imagesDir, { recursive: true });
+            }
+            // Helper function to download image
+            const downloadImage = async (imageUrl, issueNumber, imageIndex) => {
+                return new Promise((resolveDownload) => {
+                    try {
+                        const ext = imageUrl.match(/\.(png|jpg|jpeg|gif|webp|svg)/i)?.[1] || 'png';
+                        const filename = `GH-${issueNumber}-${imageIndex}.${ext}`;
+                        const filePath = join(imagesDir, filename);
+                        // Skip if already downloaded
+                        if (existsSync(filePath)) {
+                            resolveDownload(`.workflow/issues/images/${filename}`);
+                            return;
+                        }
+                        const protocol = imageUrl.startsWith('https') ? https : http;
+                        protocol.get(imageUrl, { timeout: 30000 }, (response) => {
+                            // Handle redirect
+                            if (response.statusCode === 301 || response.statusCode === 302) {
+                                const redirectUrl = response.headers.location;
+                                if (redirectUrl) {
+                                    downloadImage(redirectUrl, issueNumber, imageIndex).then(resolveDownload);
+                                    return;
+                                }
+                            }
+                            if (response.statusCode !== 200) {
+                                resolveDownload(null);
+                                return;
+                            }
+                            const chunks = [];
+                            response.on('data', (chunk) => chunks.push(chunk));
+                            response.on('end', () => {
+                                try {
+                                    writeFileSync(filePath, Buffer.concat(chunks));
+                                    resolveDownload(`.workflow/issues/images/${filename}`);
+                                }
+                                catch {
+                                    resolveDownload(null);
+                                }
+                            });
+                            response.on('error', () => resolveDownload(null));
+                        }).on('error', () => resolveDownload(null));
+                    }
+                    catch {
+                        resolveDownload(null);
+                    }
+                });
+            };
+            // Process issues
+            for (const ghIssue of ghIssues) {
+                const issueId = `GH-${ghIssue.number}`;
+                const existingIssue = existingIssues.find((i) => i.id === issueId);
+                let context = ghIssue.body || ghIssue.title;
+                // Extract and download images if enabled
+                if (downloadImages && ghIssue.body) {
+                    // Find all image URLs in the body
+                    const imgPattern = /!\[[^\]]*\]\((https?:\/\/[^)]+)\)|<img[^>]+src=["'](https?:\/\/[^"']+)["']/gi;
+                    const imageUrls = [];
+                    let match;
+                    while ((match = imgPattern.exec(ghIssue.body)) !== null) {
+                        imageUrls.push(match[1] || match[2]);
+                    }
+                    // Download images and build reference list
+                    if (imageUrls.length > 0) {
+                        const downloadedImages = [];
+                        for (let i = 0; i < imageUrls.length; i++) {
+                            const localPath = await downloadImage(imageUrls[i], ghIssue.number, i + 1);
+                            if (localPath) {
+                                downloadedImages.push(localPath);
+                                imagesDownloaded++;
+                            }
+                        }
+                        // Append image references to context
+                        if (downloadedImages.length > 0) {
+                            context += '\n\n---\n**Downloaded Images:**\n';
+                            downloadedImages.forEach((path, idx) => {
+                                context += `- Image ${idx + 1}: \`${path}\`\n`;
+                            });
+                        }
+                    }
+                }
+                // Prepare issue data (truncate context to 2000 chars max)
+                const issueData = {
+                    id: issueId,
+                    title: ghIssue.title,
+                    status: ghIssue.state === 'OPEN' ? 'registered' : 'completed',
+                    priority: 3,
+                    context: context.substring(0, 2000),
+                    source: 'github',
+                    source_url: ghIssue.url,
+                    tags: ghIssue.labels?.map((l) => l.name) || [],
+                    created_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString()
+                };
+                if (existingIssue) {
+                    // Update if changed
+                    const newStatus = ghIssue.state === 'OPEN' ? 'registered' : 'completed';
+                    if (existingIssue.status !== newStatus || existingIssue.title !== ghIssue.title) {
+                        existingIssue.title = ghIssue.title;
+                        existingIssue.status = newStatus;
+                        existingIssue.context = issueData.context;
+                        existingIssue.updated_at = new Date().toISOString();
+                        updated++;
+                    }
+                    else {
+                        skipped++;
+                    }
+                }
+                else {
+                    existingIssues.push(issueData);
+                    imported++;
+                }
+            }
+            // Save all issues
+            writeIssuesJsonl(issuesDir, existingIssues);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ imported, updated, skipped, images_downloaded: imagesDownloaded, total: ghIssues.length }));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message || 'Failed to pull issues from GitHub' }));
+        }
+        return true;
+    }
     // GET /api/issues/:id - Get issue detail
     const detailMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
     if (detailMatch && req.method === 'GET') {