mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-11 02:33:51 +08:00
1548 lines
57 KiB
TypeScript
1548 lines
57 KiB
TypeScript
/**
|
|
* Issue Routes Module (Optimized - Flat JSONL Storage)
|
|
*
|
|
* Storage Structure:
|
|
* .workflow/issues/
|
|
* ├── issues.jsonl # All issues (one per line)
|
|
* ├── queues/ # Queue history directory
|
|
* │ ├── index.json # Queue index (active + history)
|
|
* │ └── {queue-id}.json # Individual queue files
|
|
* └── solutions/
|
|
* ├── {issue-id}.jsonl # Solutions for issue (one per line)
|
|
* └── ...
|
|
*
|
|
* API Endpoints (8 total):
|
|
* - GET /api/issues - List all issues
|
|
* - POST /api/issues - Create new issue
|
|
* - GET /api/issues/:id - Get issue detail
|
|
* - PATCH /api/issues/:id - Update issue (includes binding logic)
|
|
* - DELETE /api/issues/:id - Delete issue
|
|
* - POST /api/issues/:id/solutions - Add solution
|
|
* - PATCH /api/issues/:id/tasks/:taskId - Update task
|
|
* - GET /api/queue - Get execution queue
|
|
* - POST /api/queue/reorder - Reorder queue items
|
|
*/
|
|
import { readFileSync, existsSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
|
|
import { join, resolve, normalize } from 'path';
|
|
import type { RouteContext } from './types.js';
|
|
|
|
// ========== JSONL Helper Functions ==========
|
|
|
|
function readIssuesJsonl(issuesDir: string): any[] {
|
|
const issuesPath = join(issuesDir, 'issues.jsonl');
|
|
if (!existsSync(issuesPath)) return [];
|
|
try {
|
|
const content = readFileSync(issuesPath, 'utf8');
|
|
return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
|
|
} catch {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
function writeIssuesJsonl(issuesDir: string, issues: any[]) {
|
|
if (!existsSync(issuesDir)) mkdirSync(issuesDir, { recursive: true });
|
|
const issuesPath = join(issuesDir, 'issues.jsonl');
|
|
writeFileSync(issuesPath, issues.map(i => JSON.stringify(i)).join('\n'));
|
|
}
|
|
|
|
function readSolutionsJsonl(issuesDir: string, issueId: string): any[] {
|
|
const solutionsPath = join(issuesDir, 'solutions', `${issueId}.jsonl`);
|
|
if (!existsSync(solutionsPath)) return [];
|
|
try {
|
|
const content = readFileSync(solutionsPath, 'utf8');
|
|
return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
|
|
} catch {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
function readIssueHistoryJsonl(issuesDir: string): any[] {
|
|
const historyPath = join(issuesDir, 'issue-history.jsonl');
|
|
if (!existsSync(historyPath)) return [];
|
|
try {
|
|
const content = readFileSync(historyPath, 'utf8');
|
|
return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
|
|
} catch {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
function writeIssueHistoryJsonl(issuesDir: string, issues: any[]) {
|
|
if (!existsSync(issuesDir)) mkdirSync(issuesDir, { recursive: true });
|
|
const historyPath = join(issuesDir, 'issue-history.jsonl');
|
|
writeFileSync(historyPath, issues.map(i => JSON.stringify(i)).join('\n'));
|
|
}
|
|
|
|
function writeSolutionsJsonl(issuesDir: string, issueId: string, solutions: any[]) {
|
|
const solutionsDir = join(issuesDir, 'solutions');
|
|
if (!existsSync(solutionsDir)) mkdirSync(solutionsDir, { recursive: true });
|
|
writeFileSync(join(solutionsDir, `${issueId}.jsonl`), solutions.map(s => JSON.stringify(s)).join('\n'));
|
|
}
|
|
|
|
function generateQueueFileId(): string {
|
|
const now = new Date();
|
|
const ts = now.toISOString().replace(/[-:T]/g, '').slice(0, 14);
|
|
return `QUE-${ts}`;
|
|
}
|
|
|
|
function readQueue(issuesDir: string) {
|
|
// Try new multi-queue structure first
|
|
const queuesDir = join(issuesDir, 'queues');
|
|
const indexPath = join(queuesDir, 'index.json');
|
|
|
|
if (existsSync(indexPath)) {
|
|
try {
|
|
const index = JSON.parse(readFileSync(indexPath, 'utf8'));
|
|
const activeQueueId = index.active_queue_id;
|
|
|
|
if (activeQueueId) {
|
|
const queueFilePath = join(queuesDir, `${activeQueueId}.json`);
|
|
if (existsSync(queueFilePath)) {
|
|
return JSON.parse(readFileSync(queueFilePath, 'utf8'));
|
|
}
|
|
}
|
|
} catch {
|
|
// Fall through to legacy check
|
|
}
|
|
}
|
|
|
|
// Fallback to legacy queue.json
|
|
const legacyQueuePath = join(issuesDir, 'queue.json');
|
|
if (existsSync(legacyQueuePath)) {
|
|
try {
|
|
return JSON.parse(readFileSync(legacyQueuePath, 'utf8'));
|
|
} catch {
|
|
// Return empty queue
|
|
}
|
|
}
|
|
|
|
return { tasks: [], conflicts: [], execution_groups: [], _metadata: { version: '1.0', total_tasks: 0 } };
|
|
}
|
|
|
|
function writeQueue(issuesDir: string, queue: any) {
|
|
if (!existsSync(issuesDir)) mkdirSync(issuesDir, { recursive: true });
|
|
|
|
// Support both solution-based and task-based queues
|
|
const items = queue.solutions || queue.tasks || [];
|
|
const isSolutionBased = Array.isArray(queue.solutions) && queue.solutions.length > 0;
|
|
|
|
queue._metadata = {
|
|
...queue._metadata,
|
|
updated_at: new Date().toISOString(),
|
|
...(isSolutionBased
|
|
? { total_solutions: items.length }
|
|
: { total_tasks: items.length })
|
|
};
|
|
|
|
// Check if using new multi-queue structure
|
|
const queuesDir = join(issuesDir, 'queues');
|
|
const indexPath = join(queuesDir, 'index.json');
|
|
|
|
if (existsSync(indexPath) && queue.id) {
|
|
// Write to new structure
|
|
const queueFilePath = join(queuesDir, `${queue.id}.json`);
|
|
writeFileSync(queueFilePath, JSON.stringify(queue, null, 2));
|
|
|
|
// Update index metadata
|
|
try {
|
|
const index = JSON.parse(readFileSync(indexPath, 'utf8'));
|
|
const queueEntry = index.queues?.find((q: any) => q.id === queue.id);
|
|
if (queueEntry) {
|
|
if (isSolutionBased) {
|
|
queueEntry.total_solutions = items.length;
|
|
queueEntry.completed_solutions = items.filter((i: any) => i.status === 'completed').length;
|
|
} else {
|
|
queueEntry.total_tasks = items.length;
|
|
queueEntry.completed_tasks = items.filter((i: any) => i.status === 'completed').length;
|
|
}
|
|
writeFileSync(indexPath, JSON.stringify(index, null, 2));
|
|
}
|
|
} catch {
|
|
// Ignore index update errors
|
|
}
|
|
} else {
|
|
// Fallback to legacy queue.json
|
|
writeFileSync(join(issuesDir, 'queue.json'), JSON.stringify(queue, null, 2));
|
|
}
|
|
}
|
|
|
|
function getIssueDetail(issuesDir: string, issueId: string) {
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
let issue = issues.find(i => i.id === issueId);
|
|
|
|
// Fix: Check history if not found in active issues
|
|
if (!issue) {
|
|
const historyIssues = readIssueHistoryJsonl(issuesDir);
|
|
issue = historyIssues.find(i => i.id === issueId);
|
|
}
|
|
|
|
// Fallback: Reconstruct issue from solution file if issue not in issues.jsonl or history
|
|
if (!issue) {
|
|
const solutionPath = join(issuesDir, 'solutions', `${issueId}.jsonl`);
|
|
if (existsSync(solutionPath)) {
|
|
const solutions = readSolutionsJsonl(issuesDir, issueId);
|
|
if (solutions.length > 0) {
|
|
const boundSolution = solutions.find(s => s.is_bound) || solutions[0];
|
|
issue = {
|
|
id: issueId,
|
|
title: boundSolution?.description || issueId,
|
|
status: 'completed',
|
|
priority: 3,
|
|
context: boundSolution?.approach || '',
|
|
bound_solution_id: boundSolution?.id || null,
|
|
created_at: boundSolution?.created_at || new Date().toISOString(),
|
|
updated_at: new Date().toISOString(),
|
|
_reconstructed: true
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!issue) return null;
|
|
|
|
const solutions = readSolutionsJsonl(issuesDir, issueId);
|
|
let tasks: any[] = [];
|
|
if (issue.bound_solution_id) {
|
|
const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
|
|
if (boundSol?.tasks) tasks = boundSol.tasks;
|
|
}
|
|
return { ...issue, solutions, tasks };
|
|
}
|
|
|
|
function enrichIssues(issues: any[], issuesDir: string) {
|
|
return issues.map(issue => {
|
|
const solutions = readSolutionsJsonl(issuesDir, issue.id);
|
|
let tasks: any[] = [];
|
|
|
|
// Get tasks from bound solution
|
|
if (issue.bound_solution_id) {
|
|
const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
|
|
if (boundSol?.tasks) {
|
|
tasks = boundSol.tasks;
|
|
}
|
|
}
|
|
|
|
return {
|
|
...issue,
|
|
solutions, // Add full solutions array
|
|
tasks, // Add full tasks array
|
|
solution_count: solutions.length,
|
|
task_count: tasks.length
|
|
};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get queue items (supports both solution-based and task-based queues)
|
|
*/
|
|
function getQueueItems(queue: any): any[] {
|
|
return queue.solutions || queue.tasks || [];
|
|
}
|
|
|
|
/**
|
|
* Check if queue is solution-based
|
|
*/
|
|
function isSolutionBasedQueue(queue: any): boolean {
|
|
return Array.isArray(queue.solutions) && queue.solutions.length > 0;
|
|
}
|
|
|
|
function groupQueueByExecutionGroup(queue: any) {
|
|
const groups: { [key: string]: any[] } = {};
|
|
const items = getQueueItems(queue);
|
|
const isSolutionBased = isSolutionBasedQueue(queue);
|
|
|
|
for (const item of items) {
|
|
const groupId = item.execution_group || 'ungrouped';
|
|
if (!groups[groupId]) groups[groupId] = [];
|
|
groups[groupId].push(item);
|
|
}
|
|
for (const groupId of Object.keys(groups)) {
|
|
groups[groupId].sort((a, b) => (a.execution_order || 0) - (b.execution_order || 0));
|
|
}
|
|
const executionGroups = Object.entries(groups).map(([id, groupItems]) => ({
|
|
id,
|
|
type: id.startsWith('P') ? 'parallel' : id.startsWith('S') ? 'sequential' : 'unknown',
|
|
// Use appropriate count field based on queue type
|
|
...(isSolutionBased
|
|
? { solution_count: groupItems.length, solutions: groupItems.map(i => i.item_id) }
|
|
: { task_count: groupItems.length, tasks: groupItems.map(i => i.item_id) })
|
|
})).sort((a, b) => {
|
|
const aFirst = groups[a.id]?.[0]?.execution_order || 0;
|
|
const bFirst = groups[b.id]?.[0]?.execution_order || 0;
|
|
return aFirst - bFirst;
|
|
});
|
|
return { ...queue, execution_groups: executionGroups, grouped_items: groups };
|
|
}
|
|
|
|
/**
|
|
* Bind solution to issue with proper side effects
|
|
*/
|
|
function bindSolutionToIssue(issuesDir: string, issueId: string, solutionId: string, issues: any[], issueIndex: number) {
|
|
const solutions = readSolutionsJsonl(issuesDir, issueId);
|
|
const solIndex = solutions.findIndex(s => s.id === solutionId);
|
|
|
|
if (solIndex === -1) return { error: `Solution ${solutionId} not found` };
|
|
|
|
// Unbind all, bind new
|
|
solutions.forEach(s => { s.is_bound = false; });
|
|
solutions[solIndex].is_bound = true;
|
|
solutions[solIndex].bound_at = new Date().toISOString();
|
|
writeSolutionsJsonl(issuesDir, issueId, solutions);
|
|
|
|
// Update issue
|
|
issues[issueIndex].bound_solution_id = solutionId;
|
|
issues[issueIndex].status = 'planned';
|
|
issues[issueIndex].planned_at = new Date().toISOString();
|
|
|
|
return { success: true, bound: solutionId };
|
|
}
|
|
|
|
// ========== Path Validation ==========
|
|
|
|
/**
|
|
* Validate that the provided path is safe (no path traversal)
|
|
* Returns the resolved, normalized path or null if invalid
|
|
*/
|
|
function validateProjectPath(requestedPath: string, basePath: string): string | null {
|
|
if (!requestedPath) return basePath;
|
|
|
|
// Resolve to absolute path and normalize
|
|
const resolvedPath = resolve(normalize(requestedPath));
|
|
const resolvedBase = resolve(normalize(basePath));
|
|
|
|
// For local development tool, we allow any absolute path
|
|
// but prevent obvious traversal attempts
|
|
if (requestedPath.includes('..') && !resolvedPath.startsWith(resolvedBase)) {
|
|
// Check if it's trying to escape with ..
|
|
const normalizedRequested = normalize(requestedPath);
|
|
if (normalizedRequested.startsWith('..')) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return resolvedPath;
|
|
}
|
|
|
|
// ========== Route Handler ==========
|
|
|
|
export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
|
|
const { pathname, url, req, res, initialPath, handlePostRequest } = ctx;
|
|
const rawProjectPath = url.searchParams.get('path') || initialPath;
|
|
|
|
// Validate project path to prevent path traversal
|
|
const projectPath = validateProjectPath(rawProjectPath, initialPath);
|
|
if (!projectPath) {
|
|
res.writeHead(400, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: 'Invalid project path' }));
|
|
return true;
|
|
}
|
|
|
|
const issuesDir = join(projectPath, '.workflow', 'issues');
|
|
|
|
// ===== Helper: Normalize queue path (supports both /api/queue/* and /api/issues/queue/*) =====
|
|
const normalizeQueuePath = (path: string): string | null => {
|
|
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 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, 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, active_queue_ids: [] }));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 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');
|
|
const queueFilePath = join(queuesDir, `${queueId}.json`);
|
|
|
|
if (!existsSync(queueFilePath)) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: `Queue ${queueId} not found` }));
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
const queue = JSON.parse(readFileSync(queueFilePath, 'utf8'));
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify(groupQueueByExecutionGroup(queue)));
|
|
} catch {
|
|
res.writeHead(500, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: 'Failed to read queue' }));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 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: any) => {
|
|
const { queueId, queueIds } = body;
|
|
|
|
// Support both single queueId and array queueIds
|
|
const idsToActivate: string[] = 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: any) => {
|
|
const { queueId } = body;
|
|
if (!queueId) return { error: 'queueId required' };
|
|
|
|
const queuesDir = join(issuesDir, 'queues');
|
|
const indexPath = join(queuesDir, 'index.json');
|
|
const queueFilePath = join(queuesDir, `${queueId}.json`);
|
|
|
|
if (!existsSync(queueFilePath)) {
|
|
return { error: `Queue ${queueId} not found` };
|
|
}
|
|
|
|
try {
|
|
const index = existsSync(indexPath)
|
|
? JSON.parse(readFileSync(indexPath, 'utf8'))
|
|
: { 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,
|
|
active_queue_ids: [queueId]
|
|
};
|
|
} catch (err) {
|
|
return { error: 'Failed to switch queue' };
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// 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: any) => {
|
|
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, active_queue_ids: [], queues: [] };
|
|
|
|
const currentActiveIds = index.active_queue_ids || (index.active_queue_id ? [index.active_queue_id] : []);
|
|
let deactivatedIds: string[] = [];
|
|
let remainingIds: string[] = [];
|
|
|
|
if (queueId) {
|
|
// Deactivate specific queue
|
|
deactivatedIds = currentActiveIds.includes(queueId) ? [queueId] : [];
|
|
remainingIds = currentActiveIds.filter((id: string) => 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,
|
|
deactivated_queue_ids: deactivatedIds,
|
|
active_queue_ids: remainingIds,
|
|
active_queue_id: remainingIds[0] || null // Backward compat
|
|
};
|
|
} catch (err) {
|
|
return { error: 'Failed to deactivate queue' };
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// 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: any) => {
|
|
const { groupId, newOrder } = body;
|
|
if (!groupId || !Array.isArray(newOrder)) {
|
|
return { error: 'groupId and newOrder (array) required' };
|
|
}
|
|
|
|
const queue = readQueue(issuesDir);
|
|
const items = getQueueItems(queue);
|
|
const isSolutionBased = isSolutionBasedQueue(queue);
|
|
|
|
const groupItems = items.filter((item: any) => item.execution_group === groupId);
|
|
const otherItems = items.filter((item: any) => item.execution_group !== groupId);
|
|
|
|
if (groupItems.length === 0) return { error: `No items in group ${groupId}` };
|
|
|
|
const groupItemIds = new Set(groupItems.map((i: any) => i.item_id));
|
|
if (groupItemIds.size !== new Set(newOrder).size) {
|
|
return { error: 'newOrder must contain all group items' };
|
|
}
|
|
for (const id of newOrder) {
|
|
if (!groupItemIds.has(id)) return { error: `Invalid item_id: ${id}` };
|
|
}
|
|
|
|
const itemMap = new Map(groupItems.map((i: any) => [i.item_id, i]));
|
|
const reorderedItems = newOrder.map((qid: string, idx: number) => ({ ...itemMap.get(qid), _idx: idx }));
|
|
const newQueueItems = [...otherItems, ...reorderedItems].sort((a, b) => {
|
|
const aGroup = parseInt(a.execution_group?.match(/\d+/)?.[0] || '999');
|
|
const bGroup = parseInt(b.execution_group?.match(/\d+/)?.[0] || '999');
|
|
if (aGroup !== bGroup) return aGroup - bGroup;
|
|
if (a.execution_group === b.execution_group) {
|
|
return (a._idx ?? a.execution_order ?? 999) - (b._idx ?? b.execution_order ?? 999);
|
|
}
|
|
return (a.execution_order || 0) - (b.execution_order || 0);
|
|
});
|
|
|
|
newQueueItems.forEach((item, idx) => { item.execution_order = idx + 1; delete item._idx; });
|
|
|
|
// Write back to appropriate array based on queue type
|
|
if (isSolutionBased) {
|
|
queue.solutions = newQueueItems;
|
|
} else {
|
|
queue.tasks = newQueueItems;
|
|
}
|
|
writeQueue(issuesDir, queue);
|
|
|
|
return { success: true, groupId, reordered: newOrder.length };
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// 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]);
|
|
|
|
const queuesDir = join(issuesDir, 'queues');
|
|
const queueFilePath = join(queuesDir, `${queueId}.json`);
|
|
|
|
if (!existsSync(queueFilePath)) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: `Queue ${queueId} not found` }));
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
const queue = JSON.parse(readFileSync(queueFilePath, 'utf8'));
|
|
const items = queue.solutions || queue.tasks || [];
|
|
const filteredItems = items.filter((item: any) => item.item_id !== itemId);
|
|
|
|
if (filteredItems.length === items.length) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: `Item ${itemId} not found in queue` }));
|
|
return true;
|
|
}
|
|
|
|
// Update queue items
|
|
if (queue.solutions) {
|
|
queue.solutions = filteredItems;
|
|
} else {
|
|
queue.tasks = filteredItems;
|
|
}
|
|
|
|
// Recalculate metadata
|
|
const completedCount = filteredItems.filter((i: any) => i.status === 'completed').length;
|
|
queue._metadata = {
|
|
...queue._metadata,
|
|
updated_at: new Date().toISOString(),
|
|
...(queue.solutions
|
|
? { total_solutions: filteredItems.length, completed_solutions: completedCount }
|
|
: { total_tasks: filteredItems.length, completed_tasks: completedCount })
|
|
};
|
|
|
|
writeFileSync(queueFilePath, JSON.stringify(queue, null, 2));
|
|
|
|
// Update index counts
|
|
const indexPath = join(queuesDir, 'index.json');
|
|
if (existsSync(indexPath)) {
|
|
try {
|
|
const index = JSON.parse(readFileSync(indexPath, 'utf8'));
|
|
const queueEntry = index.queues?.find((q: any) => q.id === queueId);
|
|
if (queueEntry) {
|
|
if (queue.solutions) {
|
|
queueEntry.total_solutions = filteredItems.length;
|
|
queueEntry.completed_solutions = completedCount;
|
|
} else {
|
|
queueEntry.total_tasks = filteredItems.length;
|
|
queueEntry.completed_tasks = completedCount;
|
|
}
|
|
writeFileSync(indexPath, JSON.stringify(index, null, 2));
|
|
}
|
|
} catch (err) {
|
|
console.error('Failed to update queue index:', err);
|
|
}
|
|
}
|
|
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ success: true, queueId, deletedItemId: itemId }));
|
|
} catch (err) {
|
|
res.writeHead(500, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: 'Failed to delete item' }));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 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');
|
|
const queueFilePath = join(queuesDir, `${queueId}.json`);
|
|
const indexPath = join(queuesDir, 'index.json');
|
|
|
|
if (!existsSync(queueFilePath)) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: `Queue ${queueId} not found` }));
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
// Delete queue file
|
|
unlinkSync(queueFilePath);
|
|
|
|
// Update index
|
|
if (existsSync(indexPath)) {
|
|
const index = JSON.parse(readFileSync(indexPath, 'utf8'));
|
|
|
|
// Remove from queues array
|
|
index.queues = (index.queues || []).filter((q: any) => q.id !== queueId);
|
|
|
|
// Clear active if this was the active queue
|
|
if (index.active_queue_id === queueId) {
|
|
index.active_queue_id = null;
|
|
}
|
|
|
|
writeFileSync(indexPath, JSON.stringify(index, null, 2));
|
|
}
|
|
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ success: true, deletedQueueId: queueId }));
|
|
} catch (err) {
|
|
res.writeHead(500, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: 'Failed to delete queue' }));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 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: any) => {
|
|
const { sourceQueueId, targetQueueId } = body;
|
|
if (!sourceQueueId || !targetQueueId) {
|
|
return { error: 'sourceQueueId and targetQueueId required' };
|
|
}
|
|
|
|
if (sourceQueueId === targetQueueId) {
|
|
return { error: 'Cannot merge queue into itself' };
|
|
}
|
|
|
|
const queuesDir = join(issuesDir, 'queues');
|
|
const sourcePath = join(queuesDir, `${sourceQueueId}.json`);
|
|
const targetPath = join(queuesDir, `${targetQueueId}.json`);
|
|
|
|
if (!existsSync(sourcePath)) return { error: `Source queue ${sourceQueueId} not found` };
|
|
if (!existsSync(targetPath)) return { error: `Target queue ${targetQueueId} not found` };
|
|
|
|
try {
|
|
const sourceQueue = JSON.parse(readFileSync(sourcePath, 'utf8'));
|
|
const targetQueue = JSON.parse(readFileSync(targetPath, 'utf8'));
|
|
|
|
const sourceItems = sourceQueue.solutions || sourceQueue.tasks || [];
|
|
const targetItems = targetQueue.solutions || targetQueue.tasks || [];
|
|
const isSolutionBased = !!targetQueue.solutions;
|
|
|
|
if (!isSolutionBased) {
|
|
targetQueue.solutions = [];
|
|
}
|
|
|
|
// Helper to generate next item ID (S-N format)
|
|
const getNextItemId = (): string => {
|
|
const items = targetQueue.solutions || [];
|
|
const maxNum = items.reduce((max: number, i: any) => {
|
|
const match = i.item_id?.match(/^S-(\d+)$/);
|
|
return match ? Math.max(max, parseInt(match[1])) : max;
|
|
}, 0);
|
|
return `S-${maxNum + 1}`;
|
|
};
|
|
|
|
let itemsMerged = 0;
|
|
let skippedDuplicates = 0;
|
|
|
|
for (const sourceItem of sourceItems) {
|
|
// Skip duplicates (same issue_id + solution_id)
|
|
const exists = (targetQueue.solutions || []).some(
|
|
(t: any) => t.issue_id === sourceItem.issue_id && t.solution_id === sourceItem.solution_id
|
|
);
|
|
|
|
if (exists) {
|
|
skippedDuplicates++;
|
|
continue;
|
|
}
|
|
|
|
// Add with new item_id (S-N format)
|
|
const newItem = {
|
|
...sourceItem,
|
|
item_id: getNextItemId(),
|
|
execution_order: (targetQueue.solutions?.length || 0) + 1
|
|
};
|
|
|
|
if (!targetQueue.solutions) targetQueue.solutions = [];
|
|
targetQueue.solutions.push(newItem);
|
|
itemsMerged++;
|
|
}
|
|
|
|
// Merge issue_ids
|
|
const mergedIssueIds = [...new Set([
|
|
...(targetQueue.issue_ids || []),
|
|
...(sourceQueue.issue_ids || [])
|
|
])];
|
|
targetQueue.issue_ids = mergedIssueIds;
|
|
|
|
// Merge conflicts
|
|
if (sourceQueue.conflicts && sourceQueue.conflicts.length > 0) {
|
|
if (!targetQueue.conflicts) targetQueue.conflicts = [];
|
|
targetQueue.conflicts.push(...sourceQueue.conflicts);
|
|
}
|
|
|
|
// Update metadata
|
|
const mergedItems = targetQueue.solutions || [];
|
|
const completedCount = mergedItems.filter((i: any) => i.status === 'completed').length;
|
|
targetQueue._metadata = {
|
|
...targetQueue._metadata,
|
|
updated_at: new Date().toISOString(),
|
|
total_solutions: mergedItems.length,
|
|
completed_solutions: completedCount
|
|
};
|
|
|
|
// Write merged queue
|
|
writeFileSync(targetPath, JSON.stringify(targetQueue, null, 2));
|
|
|
|
// Update source queue status to 'merged'
|
|
sourceQueue.status = 'merged';
|
|
sourceQueue._metadata = {
|
|
...sourceQueue._metadata,
|
|
merged_into: targetQueueId,
|
|
merged_at: new Date().toISOString()
|
|
};
|
|
writeFileSync(sourcePath, JSON.stringify(sourceQueue, null, 2));
|
|
|
|
// Update index
|
|
const indexPath = join(queuesDir, 'index.json');
|
|
if (existsSync(indexPath)) {
|
|
try {
|
|
const index = JSON.parse(readFileSync(indexPath, 'utf8'));
|
|
const sourceEntry = index.queues?.find((q: any) => q.id === sourceQueueId);
|
|
const targetEntry = index.queues?.find((q: any) => q.id === targetQueueId);
|
|
if (sourceEntry) {
|
|
sourceEntry.status = 'merged';
|
|
}
|
|
if (targetEntry) {
|
|
targetEntry.total_solutions = mergedItems.length;
|
|
targetEntry.completed_solutions = completedCount;
|
|
targetEntry.issue_ids = mergedIssueIds;
|
|
}
|
|
writeFileSync(indexPath, JSON.stringify(index, null, 2));
|
|
} catch {
|
|
// Ignore index update errors
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
sourceQueueId,
|
|
targetQueueId,
|
|
mergedItemCount: itemsMerged,
|
|
skippedDuplicates,
|
|
totalItems: mergedItems.length
|
|
};
|
|
} catch (err) {
|
|
return { error: 'Failed to merge queues' };
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// POST /api/queue/split - Split items from source queue into a new queue
|
|
if (normalizedPath === '/api/queue/split' && req.method === 'POST') {
|
|
handlePostRequest(req, res, async (body: any) => {
|
|
const { sourceQueueId, itemIds } = body;
|
|
if (!sourceQueueId || !itemIds || !Array.isArray(itemIds) || itemIds.length === 0) {
|
|
return { error: 'sourceQueueId and itemIds (non-empty array) required' };
|
|
}
|
|
|
|
const queuesDir = join(issuesDir, 'queues');
|
|
const sourcePath = join(queuesDir, `${sourceQueueId}.json`);
|
|
|
|
if (!existsSync(sourcePath)) {
|
|
return { error: `Source queue ${sourceQueueId} not found` };
|
|
}
|
|
|
|
try {
|
|
const sourceQueue = JSON.parse(readFileSync(sourcePath, 'utf8'));
|
|
const sourceItems = sourceQueue.solutions || sourceQueue.tasks || [];
|
|
const isSolutionBased = !!sourceQueue.solutions;
|
|
|
|
// Find items to split
|
|
const itemsToSplit = sourceItems.filter((item: any) =>
|
|
itemIds.includes(item.item_id) ||
|
|
itemIds.includes(item.solution_id) ||
|
|
itemIds.includes(item.task_id)
|
|
);
|
|
|
|
if (itemsToSplit.length === 0) {
|
|
return { error: 'No matching items found to split' };
|
|
}
|
|
|
|
if (itemsToSplit.length === sourceItems.length) {
|
|
return { error: 'Cannot split all items - at least one item must remain in source queue' };
|
|
}
|
|
|
|
// Find remaining items
|
|
const remainingItems = sourceItems.filter((item: any) =>
|
|
!itemIds.includes(item.item_id) &&
|
|
!itemIds.includes(item.solution_id) &&
|
|
!itemIds.includes(item.task_id)
|
|
);
|
|
|
|
// Create new queue with split items
|
|
const newQueueId = generateQueueFileId();
|
|
const newQueuePath = join(queuesDir, `${newQueueId}.json`);
|
|
|
|
// Re-index split items
|
|
const reindexedSplitItems = itemsToSplit.map((item: any, idx: number) => ({
|
|
...item,
|
|
execution_order: idx + 1
|
|
}));
|
|
|
|
// Extract issue IDs from split items
|
|
const splitIssueIds = [...new Set(itemsToSplit.map((item: any) => item.issue_id).filter(Boolean))];
|
|
|
|
// Remaining issue IDs
|
|
const remainingIssueIds = [...new Set(remainingItems.map((item: any) => item.issue_id).filter(Boolean))];
|
|
|
|
// Create new queue
|
|
const newQueue: any = {
|
|
id: newQueueId,
|
|
status: 'active',
|
|
issue_ids: splitIssueIds,
|
|
conflicts: [],
|
|
_metadata: {
|
|
version: '2.1',
|
|
updated_at: new Date().toISOString(),
|
|
split_from: sourceQueueId,
|
|
split_at: new Date().toISOString(),
|
|
...(isSolutionBased
|
|
? {
|
|
total_solutions: reindexedSplitItems.length,
|
|
completed_solutions: reindexedSplitItems.filter((i: any) => i.status === 'completed').length
|
|
}
|
|
: {
|
|
total_tasks: reindexedSplitItems.length,
|
|
completed_tasks: reindexedSplitItems.filter((i: any) => i.status === 'completed').length
|
|
})
|
|
}
|
|
};
|
|
|
|
if (isSolutionBased) {
|
|
newQueue.solutions = reindexedSplitItems;
|
|
} else {
|
|
newQueue.tasks = reindexedSplitItems;
|
|
}
|
|
|
|
// Update source queue with remaining items
|
|
const reindexedRemainingItems = remainingItems.map((item: any, idx: number) => ({
|
|
...item,
|
|
execution_order: idx + 1
|
|
}));
|
|
|
|
if (isSolutionBased) {
|
|
sourceQueue.solutions = reindexedRemainingItems;
|
|
} else {
|
|
sourceQueue.tasks = reindexedRemainingItems;
|
|
}
|
|
|
|
sourceQueue.issue_ids = remainingIssueIds;
|
|
sourceQueue._metadata = {
|
|
...sourceQueue._metadata,
|
|
updated_at: new Date().toISOString(),
|
|
...(isSolutionBased
|
|
? {
|
|
total_solutions: reindexedRemainingItems.length,
|
|
completed_solutions: reindexedRemainingItems.filter((i: any) => i.status === 'completed').length
|
|
}
|
|
: {
|
|
total_tasks: reindexedRemainingItems.length,
|
|
completed_tasks: reindexedRemainingItems.filter((i: any) => i.status === 'completed').length
|
|
})
|
|
};
|
|
|
|
// Write both queues
|
|
writeFileSync(newQueuePath, JSON.stringify(newQueue, null, 2));
|
|
writeFileSync(sourcePath, JSON.stringify(sourceQueue, null, 2));
|
|
|
|
// Update index
|
|
const indexPath = join(queuesDir, 'index.json');
|
|
if (existsSync(indexPath)) {
|
|
try {
|
|
const index = JSON.parse(readFileSync(indexPath, 'utf8'));
|
|
|
|
// Add new queue to index
|
|
const newQueueEntry: any = {
|
|
id: newQueueId,
|
|
status: 'active',
|
|
issue_ids: splitIssueIds,
|
|
created_at: new Date().toISOString(),
|
|
...(isSolutionBased
|
|
? {
|
|
total_solutions: reindexedSplitItems.length,
|
|
completed_solutions: reindexedSplitItems.filter((i: any) => i.status === 'completed').length
|
|
}
|
|
: {
|
|
total_tasks: reindexedSplitItems.length,
|
|
completed_tasks: reindexedSplitItems.filter((i: any) => i.status === 'completed').length
|
|
})
|
|
};
|
|
|
|
index.queues = index.queues || [];
|
|
index.queues.push(newQueueEntry);
|
|
|
|
// Update source queue in index
|
|
const sourceEntry = index.queues.find((q: any) => q.id === sourceQueueId);
|
|
if (sourceEntry) {
|
|
sourceEntry.issue_ids = remainingIssueIds;
|
|
if (isSolutionBased) {
|
|
sourceEntry.total_solutions = reindexedRemainingItems.length;
|
|
sourceEntry.completed_solutions = reindexedRemainingItems.filter((i: any) => i.status === 'completed').length;
|
|
} else {
|
|
sourceEntry.total_tasks = reindexedRemainingItems.length;
|
|
sourceEntry.completed_tasks = reindexedRemainingItems.filter((i: any) => i.status === 'completed').length;
|
|
}
|
|
}
|
|
|
|
writeFileSync(indexPath, JSON.stringify(index, null, 2));
|
|
} catch {
|
|
// Ignore index update errors
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
sourceQueueId,
|
|
newQueueId,
|
|
splitItemCount: itemsToSplit.length,
|
|
remainingItemCount: remainingItems.length
|
|
};
|
|
} catch (err) {
|
|
return { error: 'Failed to split queue' };
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// Legacy: GET /api/issues/queue (backward compat)
|
|
if (pathname === '/api/issues/queue' && req.method === 'GET') {
|
|
const queue = groupQueueByExecutionGroup(readQueue(issuesDir));
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify(queue));
|
|
return true;
|
|
}
|
|
|
|
// ===== Issue Routes =====
|
|
|
|
// GET /api/issues - List all issues
|
|
if (pathname === '/api/issues' && req.method === 'GET') {
|
|
const issues = enrichIssues(readIssuesJsonl(issuesDir), issuesDir);
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({
|
|
issues,
|
|
_metadata: { version: '2.0', storage: 'jsonl', total_issues: issues.length, last_updated: new Date().toISOString() }
|
|
}));
|
|
return true;
|
|
}
|
|
|
|
// GET /api/issues/history - List completed issues from history
|
|
if (pathname === '/api/issues/history' && req.method === 'GET') {
|
|
// Fix: Use enrichIssues to add solution/task counts to historical issues
|
|
const history = enrichIssues(readIssueHistoryJsonl(issuesDir), issuesDir);
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({
|
|
issues: history,
|
|
_metadata: { version: '1.0', storage: 'jsonl', total_issues: history.length, last_updated: new Date().toISOString() }
|
|
}));
|
|
return true;
|
|
}
|
|
|
|
// POST /api/issues - Create issue
|
|
if (pathname === '/api/issues' && req.method === 'POST') {
|
|
handlePostRequest(req, res, async (body: any) => {
|
|
if (!body.id || !body.title) return { error: 'id and title required' };
|
|
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
if (issues.find(i => i.id === body.id)) return { error: `Issue ${body.id} exists` };
|
|
|
|
const newIssue = {
|
|
id: body.id,
|
|
title: body.title,
|
|
status: body.status || 'registered',
|
|
priority: body.priority || 3,
|
|
context: body.context || '',
|
|
source: body.source || 'text',
|
|
source_url: body.source_url || null,
|
|
tags: body.tags || [],
|
|
created_at: new Date().toISOString(),
|
|
updated_at: new Date().toISOString()
|
|
};
|
|
|
|
issues.push(newIssue);
|
|
writeIssuesJsonl(issuesDir, issues);
|
|
return { success: true, issue: newIssue };
|
|
});
|
|
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: string, issueNumber: number, imageIndex: number): Promise<string | null> => {
|
|
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: any) => {
|
|
// 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: Buffer[] = [];
|
|
response.on('data', (chunk: Buffer) => 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: any) => 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: string[] = [];
|
|
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: string[] = [];
|
|
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: any) => 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: any) {
|
|
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') {
|
|
const issueId = decodeURIComponent(detailMatch[1]);
|
|
if (issueId === 'queue') return false;
|
|
|
|
const detail = getIssueDetail(issuesDir, issueId);
|
|
if (!detail) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: 'Issue not found' }));
|
|
return true;
|
|
}
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify(detail));
|
|
return true;
|
|
}
|
|
|
|
// PATCH /api/issues/:id - Update issue (with binding support)
|
|
const updateMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
|
|
if (updateMatch && req.method === 'PATCH') {
|
|
const issueId = decodeURIComponent(updateMatch[1]);
|
|
if (issueId === 'queue') return false;
|
|
|
|
handlePostRequest(req, res, async (body: any) => {
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
const issueIndex = issues.findIndex(i => i.id === issueId);
|
|
if (issueIndex === -1) return { error: 'Issue not found' };
|
|
|
|
const updates: string[] = [];
|
|
|
|
// Handle binding if bound_solution_id provided
|
|
if (body.bound_solution_id !== undefined) {
|
|
if (body.bound_solution_id) {
|
|
const bindResult = bindSolutionToIssue(issuesDir, issueId, body.bound_solution_id, issues, issueIndex);
|
|
if (bindResult.error) return bindResult;
|
|
updates.push('bound_solution_id');
|
|
} else {
|
|
// Unbind
|
|
const solutions = readSolutionsJsonl(issuesDir, issueId);
|
|
solutions.forEach(s => { s.is_bound = false; });
|
|
writeSolutionsJsonl(issuesDir, issueId, solutions);
|
|
issues[issueIndex].bound_solution_id = null;
|
|
updates.push('bound_solution_id (unbound)');
|
|
}
|
|
}
|
|
|
|
// Update other fields
|
|
for (const field of ['title', 'context', 'status', 'priority', 'tags']) {
|
|
if (body[field] !== undefined) {
|
|
issues[issueIndex][field] = body[field];
|
|
updates.push(field);
|
|
}
|
|
}
|
|
|
|
issues[issueIndex].updated_at = new Date().toISOString();
|
|
writeIssuesJsonl(issuesDir, issues);
|
|
return { success: true, issueId, updated: updates };
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// DELETE /api/issues/:id
|
|
const deleteMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
|
|
if (deleteMatch && req.method === 'DELETE') {
|
|
const issueId = decodeURIComponent(deleteMatch[1]);
|
|
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
const filtered = issues.filter(i => i.id !== issueId);
|
|
if (filtered.length === issues.length) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: 'Issue not found' }));
|
|
return true;
|
|
}
|
|
|
|
writeIssuesJsonl(issuesDir, filtered);
|
|
|
|
// Clean up solutions file
|
|
const solPath = join(issuesDir, 'solutions', `${issueId}.jsonl`);
|
|
if (existsSync(solPath)) {
|
|
try { unlinkSync(solPath); } catch {}
|
|
}
|
|
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ success: true, issueId }));
|
|
return true;
|
|
}
|
|
|
|
// POST /api/issues/:id/archive - Archive issue (move to history)
|
|
const archiveMatch = pathname.match(/^\/api\/issues\/([^/]+)\/archive$/);
|
|
if (archiveMatch && req.method === 'POST') {
|
|
const issueId = decodeURIComponent(archiveMatch[1]);
|
|
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
const issueIndex = issues.findIndex(i => i.id === issueId);
|
|
|
|
if (issueIndex === -1) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: 'Issue not found' }));
|
|
return true;
|
|
}
|
|
|
|
// Get the issue and add archive metadata
|
|
const issue = issues[issueIndex];
|
|
issue.archived_at = new Date().toISOString();
|
|
issue.status = 'completed';
|
|
|
|
// Move to history
|
|
const history = readIssueHistoryJsonl(issuesDir);
|
|
history.push(issue);
|
|
writeIssueHistoryJsonl(issuesDir, history);
|
|
|
|
// Remove from active issues
|
|
issues.splice(issueIndex, 1);
|
|
writeIssuesJsonl(issuesDir, issues);
|
|
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ success: true, issueId, archivedAt: issue.archived_at }));
|
|
return true;
|
|
}
|
|
|
|
// POST /api/issues/:id/solutions - Add solution
|
|
const addSolMatch = pathname.match(/^\/api\/issues\/([^/]+)\/solutions$/);
|
|
if (addSolMatch && req.method === 'POST') {
|
|
const issueId = decodeURIComponent(addSolMatch[1]);
|
|
|
|
handlePostRequest(req, res, async (body: any) => {
|
|
if (!body.id || !body.tasks) return { error: 'id and tasks required' };
|
|
|
|
const solutions = readSolutionsJsonl(issuesDir, issueId);
|
|
if (solutions.find(s => s.id === body.id)) return { error: `Solution ${body.id} exists` };
|
|
|
|
const newSolution = {
|
|
id: body.id,
|
|
description: body.description || '',
|
|
tasks: body.tasks,
|
|
exploration_context: body.exploration_context || {},
|
|
analysis: body.analysis || {},
|
|
score: body.score || 0,
|
|
is_bound: false,
|
|
created_at: new Date().toISOString()
|
|
};
|
|
|
|
solutions.push(newSolution);
|
|
writeSolutionsJsonl(issuesDir, issueId, solutions);
|
|
|
|
// Update issue solution_count
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
const idx = issues.findIndex(i => i.id === issueId);
|
|
if (idx !== -1) {
|
|
issues[idx].solution_count = solutions.length;
|
|
issues[idx].updated_at = new Date().toISOString();
|
|
writeIssuesJsonl(issuesDir, issues);
|
|
}
|
|
|
|
return { success: true, solution: newSolution };
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// PATCH /api/issues/:id/tasks/:taskId - Update task
|
|
const taskMatch = pathname.match(/^\/api\/issues\/([^/]+)\/tasks\/([^/]+)$/);
|
|
if (taskMatch && req.method === 'PATCH') {
|
|
const issueId = decodeURIComponent(taskMatch[1]);
|
|
const taskId = decodeURIComponent(taskMatch[2]);
|
|
|
|
handlePostRequest(req, res, async (body: any) => {
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
const issue = issues.find(i => i.id === issueId);
|
|
if (!issue?.bound_solution_id) return { error: 'Issue or bound solution not found' };
|
|
|
|
const solutions = readSolutionsJsonl(issuesDir, issueId);
|
|
const solIdx = solutions.findIndex(s => s.id === issue.bound_solution_id);
|
|
if (solIdx === -1) return { error: 'Bound solution not found' };
|
|
|
|
const taskIdx = solutions[solIdx].tasks?.findIndex((t: any) => t.id === taskId);
|
|
if (taskIdx === -1 || taskIdx === undefined) return { error: 'Task not found' };
|
|
|
|
const updates: string[] = [];
|
|
for (const field of ['status', 'priority', 'result', 'error']) {
|
|
if (body[field] !== undefined) {
|
|
solutions[solIdx].tasks[taskIdx][field] = body[field];
|
|
updates.push(field);
|
|
}
|
|
}
|
|
solutions[solIdx].tasks[taskIdx].updated_at = new Date().toISOString();
|
|
writeSolutionsJsonl(issuesDir, issueId, solutions);
|
|
|
|
return { success: true, issueId, taskId, updated: updates };
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// Legacy: PUT /api/issues/:id/task/:taskId (backward compat)
|
|
const legacyTaskMatch = pathname.match(/^\/api\/issues\/([^/]+)\/task\/([^/]+)$/);
|
|
if (legacyTaskMatch && req.method === 'PUT') {
|
|
const issueId = decodeURIComponent(legacyTaskMatch[1]);
|
|
const taskId = decodeURIComponent(legacyTaskMatch[2]);
|
|
|
|
handlePostRequest(req, res, async (body: any) => {
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
const issue = issues.find(i => i.id === issueId);
|
|
if (!issue?.bound_solution_id) return { error: 'Issue or bound solution not found' };
|
|
|
|
const solutions = readSolutionsJsonl(issuesDir, issueId);
|
|
const solIdx = solutions.findIndex(s => s.id === issue.bound_solution_id);
|
|
if (solIdx === -1) return { error: 'Bound solution not found' };
|
|
|
|
const taskIdx = solutions[solIdx].tasks?.findIndex((t: any) => t.id === taskId);
|
|
if (taskIdx === -1 || taskIdx === undefined) return { error: 'Task not found' };
|
|
|
|
const updates: string[] = [];
|
|
if (body.status !== undefined) { solutions[solIdx].tasks[taskIdx].status = body.status; updates.push('status'); }
|
|
if (body.priority !== undefined) { solutions[solIdx].tasks[taskIdx].priority = body.priority; updates.push('priority'); }
|
|
solutions[solIdx].tasks[taskIdx].updated_at = new Date().toISOString();
|
|
writeSolutionsJsonl(issuesDir, issueId, solutions);
|
|
|
|
return { success: true, issueId, taskId, updated: updates };
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// Legacy: PUT /api/issues/:id/bind/:solutionId (backward compat)
|
|
const legacyBindMatch = pathname.match(/^\/api\/issues\/([^/]+)\/bind\/([^/]+)$/);
|
|
if (legacyBindMatch && req.method === 'PUT') {
|
|
const issueId = decodeURIComponent(legacyBindMatch[1]);
|
|
const solutionId = decodeURIComponent(legacyBindMatch[2]);
|
|
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
const issueIndex = issues.findIndex(i => i.id === issueId);
|
|
if (issueIndex === -1) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ error: 'Issue not found' }));
|
|
return true;
|
|
}
|
|
|
|
const result = bindSolutionToIssue(issuesDir, issueId, solutionId, issues, issueIndex);
|
|
if (result.error) {
|
|
res.writeHead(404, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify(result));
|
|
return true;
|
|
}
|
|
|
|
issues[issueIndex].updated_at = new Date().toISOString();
|
|
writeIssuesJsonl(issuesDir, issues);
|
|
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ success: true, issueId, solutionId }));
|
|
return true;
|
|
}
|
|
|
|
// Legacy: PUT /api/issues/:id (backward compat for PATCH)
|
|
const legacyUpdateMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
|
|
if (legacyUpdateMatch && req.method === 'PUT') {
|
|
const issueId = decodeURIComponent(legacyUpdateMatch[1]);
|
|
if (issueId === 'queue') return false;
|
|
|
|
handlePostRequest(req, res, async (body: any) => {
|
|
const issues = readIssuesJsonl(issuesDir);
|
|
const issueIndex = issues.findIndex(i => i.id === issueId);
|
|
if (issueIndex === -1) return { error: 'Issue not found' };
|
|
|
|
const updates: string[] = [];
|
|
for (const field of ['title', 'context', 'status', 'priority', 'bound_solution_id', 'tags']) {
|
|
if (body[field] !== undefined) {
|
|
issues[issueIndex][field] = body[field];
|
|
updates.push(field);
|
|
}
|
|
}
|
|
|
|
issues[issueIndex].updated_at = new Date().toISOString();
|
|
writeIssuesJsonl(issuesDir, issues);
|
|
return { success: true, issueId, updated: updates };
|
|
});
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|