@aion0/forge 0.5.26 → 0.5.28

package/.forge/worktrees/pipeline-4dd8dc2d/app/api/docs/route.ts

@@ -0,0 +1,176 @@
+import { NextResponse } from 'next/server';
+import { readdirSync, statSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, relative, extname } from 'node:path';
+import { homedir } from 'node:os';
+import { loadSettings } from '@/lib/settings';
+
+interface FileNode {
+  name: string;
+  path: string;      // relative to docRoot
+  type: 'file' | 'dir';
+  fileType?: 'md' | 'image' | 'other';
+  children?: FileNode[];
+}
+
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.bmp', '.ico', '.avif']);
+
+function scanDir(dir: string, base: string, depth: number = 0): FileNode[] {
+  if (depth > 6) return [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    const nodes: FileNode[] = [];
+
+    // Sort: dirs first, then files, alphabetical
+    const sorted = entries
+      .filter(e => !e.name.startsWith('.') && e.name !== 'node_modules')
+      .sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory()) return -1;
+        if (!a.isDirectory() && b.isDirectory()) return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+    for (const entry of sorted) {
+      const fullPath = join(dir, entry.name);
+      const relPath = relative(base, fullPath);
+
+      if (entry.isDirectory()) {
+        const children = scanDir(fullPath, base, depth + 1);
+        if (children.length > 0) {
+          nodes.push({ name: entry.name, path: relPath, type: 'dir', children });
+        }
+      } else {
+        const ext = extname(entry.name).toLowerCase();
+        if (ext === '.md') {
+          nodes.push({ name: entry.name, path: relPath, type: 'file', fileType: 'md' });
+        } else if (IMAGE_EXTS.has(ext)) {
+          nodes.push({ name: entry.name, path: relPath, type: 'file', fileType: 'image' });
+        } else if (!entry.name.startsWith('.')) {
+          nodes.push({ name: entry.name, path: relPath, type: 'file', fileType: 'other' });
+        }
+      }
+    }
+    return nodes;
+  } catch {
+    return [];
+  }
+}
+
+// GET /api/docs — list doc roots and their file trees
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const filePath = searchParams.get('file');
+  const rootIdx = parseInt(searchParams.get('root') || '0');
+
+  const settings = loadSettings();
+  const docRoots = (settings.docRoots || []).map(r => r.replace(/^~/, homedir()));
+
+  if (docRoots.length === 0) {
+    return NextResponse.json({ roots: [], tree: [], content: null });
+  }
+
+  const rootNames = docRoots.map(r => r.split('/').pop() || r);
+
+  // Serve image
+  const imagePath = searchParams.get('image');
+  if (imagePath && rootIdx < docRoots.length) {
+    const root = docRoots[rootIdx];
+    const fullPath = join(root, imagePath);
+    if (!fullPath.startsWith(root)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+    }
+    try {
+      const { readFileSync: readBin } = require('node:fs');
+      const data = readBin(fullPath);
+      const ext = extname(fullPath).toLowerCase();
+      const mimeMap: Record<string, string> = {
+        '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif', '.svg': 'image/svg+xml', '.webp': 'image/webp',
+        '.bmp': 'image/bmp', '.ico': 'image/x-icon', '.avif': 'image/avif',
+      };
+      return new Response(data, {
+        headers: { 'Content-Type': mimeMap[ext] || 'application/octet-stream', 'Cache-Control': 'public, max-age=3600' },
+      });
+    } catch {
+      return NextResponse.json({ error: 'Image not found' }, { status: 404 });
+    }
+  }
+
+  // Read file content
+  if (filePath && rootIdx < docRoots.length) {
+    const root = docRoots[rootIdx];
+    const fullPath = join(root, filePath);
+    if (!fullPath.startsWith(root)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+    }
+    try {
+      const stat = statSync(fullPath);
+      const size = stat.size;
+      const ext = extname(fullPath).replace('.', '').toLowerCase();
+      const sizeKB = Math.round(size / 1024);
+      const sizeMB = (size / (1024 * 1024)).toFixed(1);
+
+      // Binary file types
+      const BINARY_EXTS = new Set([
+        'png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'webp', 'avif',
+        'mp3', 'mp4', 'wav', 'ogg', 'webm', 'mov', 'avi',
+        'zip', 'gz', 'tar', 'bz2', 'xz', '7z', 'rar',
+        'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx',
+        'exe', 'dll', 'so', 'dylib', 'bin', 'o', 'a',
+        'woff', 'woff2', 'ttf', 'eot', 'otf',
+        'sqlite', 'db', 'sqlite3', 'class', 'jar', 'pyc', 'wasm',
+      ]);
+      if (BINARY_EXTS.has(ext)) {
+        return NextResponse.json({ binary: true, fileType: ext, size, sizeLabel: sizeKB > 1024 ? `${sizeMB} MB` : `${sizeKB} KB` });
+      }
+
+      if (size > 2_000_000) {
+        return NextResponse.json({ tooLarge: true, size, sizeLabel: `${sizeMB} MB`, message: 'File exceeds 2 MB limit' });
+      }
+      if (size > 200_000) {
+        return NextResponse.json({ large: true, size, sizeLabel: `${sizeKB} KB` });
+      }
+      const content = readFileSync(fullPath, 'utf-8');
+      return NextResponse.json({ content, language: ext });
+    } catch {
+      return NextResponse.json({ error: 'File not found' }, { status: 404 });
+    }
+  }
+
+  // Return tree for selected root
+  const idx = Math.min(rootIdx, docRoots.length - 1);
+  const root = docRoots[idx];
+  const tree = scanDir(root, root);
+
+  return NextResponse.json({ roots: rootNames, rootPaths: docRoots, tree });
+}
+
+// PUT /api/docs — save file content
+export async function PUT(req: Request) {
+  const { root: rootIdx, file: filePath, content } = await req.json() as {
+    root: number;
+    file: string;
+    content: string;
+  };
+
+  const settings = loadSettings();
+  const docRoots = (settings.docRoots || []).map(r => r.replace(/^~/, homedir()));
+
+  if (rootIdx >= docRoots.length || !filePath) {
+    return NextResponse.json({ error: 'Invalid request' }, { status: 400 });
+  }
+
+  const root = docRoots[rootIdx];
+  const fullPath = join(root, filePath);
+
+  // Security: ensure path is within root
+  if (!fullPath.startsWith(root)) {
+    return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+  }
+
+  try {
+    writeFileSync(fullPath, content, 'utf-8');
+    return NextResponse.json({ ok: true });
+  } catch (e) {
+    return NextResponse.json({ error: 'Failed to save' }, { status: 500 });
+  }
+}

package/.forge/worktrees/pipeline-4dd8dc2d/app/api/docs/sessions/route.ts

@@ -0,0 +1,54 @@
+import { NextResponse } from 'next/server';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { getClaudeDir } from '@/lib/dirs';
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const dir = searchParams.get('dir');
+  if (!dir) return NextResponse.json({ sessions: [] });
+
+  // Claude stores sessions at <claudeDir>/projects/<path-with-dashes>/
+  const hash = dir.replace(/\//g, '-');
+  const claudeDir = join(getClaudeDir(), 'projects', hash);
+
+  if (!existsSync(claudeDir)) {
+    return NextResponse.json({ sessions: [] });
+  }
+
+  try {
+    const files = readdirSync(claudeDir).filter(f => f.endsWith('.jsonl'));
+    const sessions = files.map(f => {
+      const sessionId = f.replace('.jsonl', '');
+      const filePath = join(claudeDir, f);
+      const stat = statSync(filePath);
+
+      // Read first line to get first prompt
+      let firstPrompt = '';
+      try {
+        const content = readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            if (entry.type === 'human' || entry.role === 'user') {
+              const text = typeof entry.message === 'string' ? entry.message
+                : entry.message?.content?.[0]?.text || '';
+              if (text) { firstPrompt = text.slice(0, 80); break; }
+            }
+          } catch {}
+        }
+      } catch {}
+
+      return {
+        sessionId,
+        firstPrompt,
+        modified: stat.mtime.toISOString(),
+      };
+    }).sort((a, b) => b.modified.localeCompare(a.modified));
+
+    return NextResponse.json({ sessions });
+  } catch {
+    return NextResponse.json({ sessions: [] });
+  }
+}

package/.forge/worktrees/pipeline-4dd8dc2d/app/api/favorites/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+
+function db() { return getDb(getDbPath()); }
+
+// GET /api/favorites — list all favorites
+export async function GET() {
+  const rows = db().prepare('SELECT project_path FROM project_favorites ORDER BY created_at ASC').all() as any[];
+  return NextResponse.json(rows.map(r => r.project_path));
+}
+
+// POST /api/favorites — add or remove
+export async function POST(req: Request) {
+  const { action, projectPath } = await req.json();
+  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
+
+  if (action === 'add') {
+    db().prepare('INSERT OR IGNORE INTO project_favorites (project_path) VALUES (?)').run(projectPath);
+  } else if (action === 'remove') {
+    db().prepare('DELETE FROM project_favorites WHERE project_path = ?').run(projectPath);
+  }
+
+  const rows = db().prepare('SELECT project_path FROM project_favorites ORDER BY created_at ASC').all() as any[];
+  return NextResponse.json(rows.map(r => r.project_path));
+}

package/.forge/worktrees/pipeline-4dd8dc2d/app/api/flows/route.ts

@@ -0,0 +1,6 @@
+import { NextResponse } from 'next/server';
+import { listFlows } from '@/lib/flows';
+
+export async function GET() {
+  return NextResponse.json(listFlows());
+}

package/.forge/worktrees/pipeline-4dd8dc2d/app/api/flows/run/route.ts

@@ -0,0 +1,19 @@
+import { NextResponse } from 'next/server';
+import { runFlow } from '@/lib/flows';
+
+export async function POST(req: Request) {
+  const { name } = await req.json();
+  if (!name) {
+    return NextResponse.json({ error: 'Flow name required' }, { status: 400 });
+  }
+
+  try {
+    const result = runFlow(name);
+    return NextResponse.json({
+      flow: result.flow.name,
+      tasks: result.tasks.map(t => ({ id: t.id, projectName: t.projectName, prompt: t.prompt })),
+    });
+  } catch (err: any) {
+    return NextResponse.json({ error: err.message }, { status: 400 });
+  }
+}

package/.forge/worktrees/pipeline-4dd8dc2d/app/api/git/route.ts

@@ -0,0 +1,149 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { execSync, exec } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { promisify } from 'node:util';
+import { loadSettings } from '@/lib/settings';
+
+function isUnderProjectRoot(dir: string): boolean {
+  const settings = loadSettings();
+  const roots = (settings.projectRoots || []).map(r => r.replace(/^~/, homedir()));
+  return roots.some(root => dir.startsWith(root) || dir === root);
+}
+
+const execAsync = promisify(exec);
+
+function gitSync(cmd: string, cwd: string): string {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'] }).toString().trim();
+}
+
+async function gitAsync(cmd: string, cwd: string): Promise<string> {
+  try {
+    const { stdout } = await execAsync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 });
+    return stdout.trim();
+  } catch { return ''; }
+}
+
+// GET /api/git?dir=<path> — git status for a project
+export async function GET(req: NextRequest) {
+  const dir = req.nextUrl.searchParams.get('dir');
+  if (!dir || !isUnderProjectRoot(dir)) {
+    return NextResponse.json({ error: 'Invalid directory' }, { status: 400 });
+  }
+
+  try {
+    // Run all git commands in parallel
+    const [branchOut, statusOut, remoteOut, lastCommitOut, logOut, branchListOut] = await Promise.all([
+      gitAsync('rev-parse --abbrev-ref HEAD', dir),
+      gitAsync('status --porcelain -u', dir),
+      gitAsync('remote get-url origin', dir),
+      gitAsync('log -1 --format="%h %s"', dir),
+      gitAsync('log --format="%h||%s||%an||%ar" -20', dir),
+      gitAsync('branch --format="%(refname:short)||%(upstream:short)||%(objectname:short)"', dir),
+    ]);
+
+    const branch = branchOut;
+    const changes = statusOut ? statusOut.split('\n').filter(Boolean).map(line => ({
+      status: line.substring(0, 2).trim() || 'M',
+      path: line.substring(3).replace(/\/$/, ''),
+    })) : [];
+
+    let ahead = 0, behind = 0;
+    try {
+      const counts = await gitAsync(`rev-list --left-right --count HEAD...origin/${branch}`, dir);
+      if (counts) { const [a, b] = counts.split('\t'); ahead = parseInt(a) || 0; behind = parseInt(b) || 0; }
+    } catch {}
+
+    const log = logOut ? logOut.split('\n').filter(Boolean).map(line => {
+      const [hash, message, author, date] = line.split('||');
+      return { hash, message, author, date };
+    }) : [];
+
+    const branches = branchListOut ? branchListOut.split('\n').filter(Boolean).map(line => {
+      const [name, upstream, hash] = line.split('||');
+      return { name, upstream: upstream || '', hash: hash || '', current: name === branch };
+    }) : [];
+
+    return NextResponse.json({ branch, branches, changes, remote: remoteOut, ahead, behind, lastCommit: lastCommitOut, log });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}
+
+// POST /api/git — git operations (commit, push, pull, clone)
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const { action, dir, message, files, repoUrl, targetDir } = body;
+
+  if (action === 'clone') {
+    // Clone a repo into a project root
+    if (!repoUrl) return NextResponse.json({ error: 'repoUrl required' }, { status: 400 });
+    const settings = loadSettings();
+    const roots = (settings.projectRoots || []).map(r => r.replace(/^~/, homedir()));
+    const cloneTarget = targetDir || roots[0];
+    if (!cloneTarget) return NextResponse.json({ error: 'No project root configured' }, { status: 400 });
+
+    try {
+      const output = execSync(`git clone "${repoUrl}"`, {
+        cwd: cloneTarget,
+        encoding: 'utf-8',
+        timeout: 60000,
+      });
+      // Extract cloned dir name from URL
+      const repoName = repoUrl.split('/').pop()?.replace(/\.git$/, '') || 'repo';
+      return NextResponse.json({ ok: true, path: join(cloneTarget, repoName), output });
+    } catch (e: any) {
+      return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+  }
+
+  if (!dir || !isUnderProjectRoot(dir)) {
+    return NextResponse.json({ error: 'Invalid directory' }, { status: 400 });
+  }
+
+  try {
+    if (action === 'commit') {
+      if (!message) return NextResponse.json({ error: 'message required' }, { status: 400 });
+      if (files && files.length > 0) {
+        for (const f of files) {
+          gitSync(`add "${f}"`, dir);
+        }
+      } else {
+        gitSync('add -A', dir);
+      }
+      gitSync(`commit -m "${message.replace(/"/g, '\\"')}"`, dir);
+      return NextResponse.json({ ok: true });
+    }
+
+    if (action === 'push') {
+      const output = gitSync('push', dir);
+      return NextResponse.json({ ok: true, output });
+    }
+
+    if (action === 'pull') {
+      const output = gitSync('pull', dir);
+      return NextResponse.json({ ok: true, output });
+    }
+
+    if (action === 'checkout') {
+      const branch = body.branch;
+      if (!branch) return NextResponse.json({ error: 'branch required' }, { status: 400 });
+      const out = gitSync(`checkout ${branch}`, dir);
+      return NextResponse.json({ ok: true, output: out });
+    }
+
+    if (action === 'stage') {
+      if (files && files.length > 0) {
+        for (const f of files) gitSync(`add "${f}"`, dir);
+      } else {
+        gitSync('add -A', dir);
+      }
+      return NextResponse.json({ ok: true });
+    }
+
+    return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/.forge/worktrees/pipeline-4dd8dc2d/app/api/help/route.ts

@@ -0,0 +1,84 @@
+import { NextResponse } from 'next/server';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getConfigDir, getDataDir } from '@/lib/dirs';
+import { loadSettings } from '@/lib/settings';
+import { execSync } from 'node:child_process';
+
+const HELP_DIR = join(getConfigDir(), 'help');
+const SOURCE_HELP_DIR = join(process.cwd(), 'lib', 'help-docs');
+
+/** Ensure help docs are copied to ~/.forge/help/ and CLAUDE.md to ~/.forge/data/ */
+function ensureHelpDocs() {
+  if (!existsSync(HELP_DIR)) mkdirSync(HELP_DIR, { recursive: true });
+  if (existsSync(SOURCE_HELP_DIR)) {
+    for (const file of readdirSync(SOURCE_HELP_DIR)) {
+      if (!file.endsWith('.md')) continue;
+      const src = join(SOURCE_HELP_DIR, file);
+      const dest = join(HELP_DIR, file);
+      writeFileSync(dest, readFileSync(src));
+    }
+  }
+  // Copy CLAUDE.md to data dir so Help AI (working in ~/.forge/data/) picks it up
+  const dataDir = getDataDir();
+  const claudeMdSrc = join(HELP_DIR, 'CLAUDE.md');
+  const claudeMdDest = join(dataDir, 'CLAUDE.md');
+  if (existsSync(claudeMdSrc)) {
+    writeFileSync(claudeMdDest, readFileSync(claudeMdSrc));
+  }
+}
+
+/** Check if any agent CLI is available */
+function detectAgent(): { name: string; path: string } | null {
+  const settings = loadSettings();
+  if (settings.claudePath) {
+    try {
+      execSync(`"${settings.claudePath}" --version`, { timeout: 5000, stdio: 'pipe' });
+      return { name: 'claude', path: settings.claudePath };
+    } catch {}
+  }
+  for (const agent of ['claude', 'codex', 'aider']) {
+    try {
+      const path = execSync(`which ${agent}`, { encoding: 'utf-8', timeout: 3000, stdio: 'pipe' }).trim();
+      if (path) return { name: agent, path };
+    } catch {}
+  }
+  return null;
+}
+
+// GET /api/help
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const action = searchParams.get('action') || 'status';
+
+  if (action === 'status') {
+    const agent = detectAgent();
+    ensureHelpDocs();
+    const docs = existsSync(HELP_DIR)
+      ? readdirSync(HELP_DIR).filter(f => f.endsWith('.md')).sort()
+      : [];
+    return NextResponse.json({ agent, docsCount: docs.length, helpDir: HELP_DIR, dataDir: getDataDir() });
+  }
+
+  if (action === 'docs') {
+    ensureHelpDocs();
+    const docs = existsSync(HELP_DIR)
+      ? readdirSync(HELP_DIR).filter(f => f.endsWith('.md')).sort().map(f => ({
+          name: f,
+          title: f.replace(/^\d+-/, '').replace(/\.md$/, '').replace(/-/g, ' '),
+        }))
+      : [];
+    return NextResponse.json({ docs });
+  }
+
+  if (action === 'doc') {
+    const name = searchParams.get('name');
+    if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+    ensureHelpDocs();
+    const file = join(HELP_DIR, name);
+    if (!existsSync(file)) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    return NextResponse.json({ content: readFileSync(file, 'utf-8') });
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}

package/.forge/worktrees/pipeline-4dd8dc2d/app/api/issue-scanner/route.ts

@@ -0,0 +1,116 @@
+import { NextResponse } from 'next/server';
+import {
+  getConfig,
+  saveConfig,
+  listConfigs,
+  scanAndTrigger,
+  restartScanner,
+  getProcessedIssues,
+  resetProcessedIssue,
+  getNextScanTime,
+  type IssueAutofixConfig,
+} from '@/lib/issue-scanner';
+
+// GET /api/issue-scanner?project=PATH — get config + processed issues
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const projectPath = searchParams.get('project');
+
+  if (projectPath) {
+    const config = getConfig(projectPath);
+    const processed = getProcessedIssues(projectPath);
+    const scanTime = getNextScanTime(projectPath);
+    return NextResponse.json({ config, processed, ...scanTime });
+  }
+
+  // List all enabled configs
+  const configs = listConfigs();
+  return NextResponse.json({ configs });
+}
+
+// POST /api/issue-scanner
+export async function POST(req: Request) {
+  const body = await req.json();
+
+  // Save config
+  if (body.action === 'save-config') {
+    const config: IssueAutofixConfig = {
+      projectPath: body.projectPath,
+      projectName: body.projectName,
+      enabled: !!body.enabled,
+      interval: body.interval || 30,
+      labels: body.labels || [],
+      baseBranch: body.baseBranch || '',
+    };
+    saveConfig(config);
+    restartScanner();
+    return NextResponse.json({ ok: true });
+  }
+
+  // Manual scan & trigger
+  if (body.action === 'scan') {
+    const config = getConfig(body.projectPath);
+    if (!config) return NextResponse.json({ error: 'Not configured' }, { status: 400 });
+    const result = scanAndTrigger(config);
+    return NextResponse.json(result);
+  }
+
+  // Manual trigger for a specific issue
+  if (body.action === 'trigger') {
+    const { startPipeline } = require('@/lib/pipeline');
+    const config = getConfig(body.projectPath);
+    const projectName = config?.projectName || body.projectName;
+    try {
+      const pipeline = startPipeline('issue-fix-and-review', {
+        issue_id: String(body.issueId),
+        project: projectName,
+        base_branch: config?.baseBranch || body.baseBranch || 'auto-detect',
+      });
+      // Track in processed issues
+      const { getDb } = require('@/src/core/db/database');
+      const { getDbPath } = require('@/src/config');
+      getDb(getDbPath()).prepare(`
+        INSERT OR REPLACE INTO issue_autofix_processed (project_path, issue_number, pipeline_id, status)
+        VALUES (?, ?, ?, 'processing')
+      `).run(body.projectPath, body.issueId, pipeline.id);
+      return NextResponse.json({ ok: true, pipelineId: pipeline.id });
+    } catch (e) {
+      return NextResponse.json({ ok: false, error: String(e) }, { status: 500 });
+    }
+  }
+
+  // Reset a processed issue (allow re-scan)
+  if (body.action === 'reset') {
+    resetProcessedIssue(body.projectPath, body.issueId);
+    return NextResponse.json({ ok: true });
+  }
+
+  // Retry with additional context/instructions
+  if (body.action === 'retry') {
+    const { startPipeline } = require('@/lib/pipeline');
+    const config = getConfig(body.projectPath);
+    const projectName = config?.projectName || body.projectName;
+    // Reset the processed record first, then re-create with new pipeline
+    resetProcessedIssue(body.projectPath, body.issueId);
+    try {
+      const pipeline = startPipeline('issue-fix-and-review', {
+        issue_id: String(body.issueId),
+        project: projectName,
+        base_branch: config?.baseBranch || 'auto-detect',
+        extra_context: body.context || '',
+      });
+      // Re-mark as processed with new pipeline ID
+      const { getDb } = require('@/src/core/db/database');
+      const { getDbPath } = require('@/src/config');
+      getDb(getDbPath()).prepare(`
+        INSERT OR REPLACE INTO issue_autofix_processed (project_path, issue_number, pipeline_id, status)
+        VALUES (?, ?, ?, 'processing')
+      `).run(body.projectPath, body.issueId, pipeline.id);
+      return NextResponse.json({ ok: true, pipelineId: pipeline.id });
+    } catch (e) {
+      return NextResponse.json({ ok: false, error: String(e) }, { status: 500 });
+    }
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}