@aion0/forge 0.6.0 → 0.6.3

package/.forge/worktrees/pipeline-4dd8dc2d/app/api/delivery/[id]/route.ts

@@ -1,62 +0,0 @@
-import { NextResponse } from 'next/server';
-import {
-  getDelivery, cancelDelivery, deleteDelivery,
-  approveDeliveryPhase, rejectDeliveryPhase,
-  sendToAgent, retryPhase,
-} from '@/lib/delivery';
-import { listArtifacts, getArtifact } from '@/lib/artifacts';
-import type { PhaseName } from '@/lib/delivery';
-
-// GET /api/delivery/:id — get delivery state + artifacts
-export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params;
-  const delivery = getDelivery(id);
-  if (!delivery) return NextResponse.json({ error: 'Not found' }, { status: 404 });
-
-  const artifacts = listArtifacts(id);
-  return NextResponse.json({ ...delivery, artifacts });
-}
-
-// POST /api/delivery/:id — actions
-export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params;
-  const body = await req.json();
-  const { action } = body;
-
-  if (action === 'cancel') {
-    return NextResponse.json({ ok: cancelDelivery(id) });
-  }
-
-  if (action === 'delete') {
-    return NextResponse.json({ ok: deleteDelivery(id) });
-  }
-
-  if (action === 'approve') {
-    return NextResponse.json({ ok: approveDeliveryPhase(id, body.feedback) });
-  }
-
-  if (action === 'reject') {
-    if (!body.feedback) return NextResponse.json({ error: 'feedback required' }, { status: 400 });
-    return NextResponse.json({ ok: rejectDeliveryPhase(id, body.feedback) });
-  }
-
-  if (action === 'send') {
-    const { phase, message } = body;
-    if (!phase || !message) return NextResponse.json({ error: 'phase and message required' }, { status: 400 });
-    return NextResponse.json({ ok: sendToAgent(id, phase as PhaseName, message) });
-  }
-
-  if (action === 'retry') {
-    const { phase } = body;
-    if (!phase) return NextResponse.json({ error: 'phase required' }, { status: 400 });
-    return NextResponse.json({ ok: retryPhase(id, phase as PhaseName) });
-  }
-
-  return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
-}
-
-// DELETE /api/delivery/:id
-export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params;
-  return NextResponse.json({ ok: deleteDelivery(id) });
-}

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

@@ -1,40 +0,0 @@
-import { NextResponse } from 'next/server';
-import { createDelivery, listDeliveries, ROLE_PRESETS } from '@/lib/delivery';
-
-// GET /api/delivery — list deliveries, or get role presets
-export async function GET(req: Request) {
-  const { searchParams } = new URL(req.url);
-
-  if (searchParams.get('type') === 'presets') {
-    return NextResponse.json(ROLE_PRESETS);
-  }
-
-  const deliveries = listDeliveries();
-  return NextResponse.json(deliveries);
-}
-
-// POST /api/delivery — create new delivery
-export async function POST(req: Request) {
-  const body = await req.json();
-  const { title, project, projectPath, prUrl, description, agentId, phases } = body;
-
-  if (!project || !projectPath) {
-    return NextResponse.json({ error: 'project and projectPath required' }, { status: 400 });
-  }
-
-  try {
-    const delivery = createDelivery({
-      title: title || description?.slice(0, 50) || 'Delivery',
-      project,
-      projectPath,
-      prUrl,
-      description,
-      agentId,
-      customPhases: phases,  // user-defined phases
-    });
-
-    return NextResponse.json(delivery);
-  } catch (e: any) {
-    return NextResponse.json({ error: e.message }, { status: 500 });
-  }
-}

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

@@ -1,46 +0,0 @@
-import { NextResponse } from 'next/server';
-import { execSync } from 'node:child_process';
-import { platform } from 'node:os';
-
-interface CliInfo {
-  name: string;
-  path: string;
-  version: string;
-  installHint: string;
-}
-
-function detect(name: string, installHint: string): CliInfo {
-  try {
-    const path = execSync(`which ${name}`, { encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-    let version = '';
-    try {
-      const out = execSync(`${path} --version`, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-      // Extract version number from output (e.g. "@anthropic-ai/claude-code v1.2.3" or "codex 0.1.0")
-      const match = out.match(/v?(\d+\.\d+\.\d+)/);
-      version = match ? match[1] : out.slice(0, 50);
-    } catch {}
-    return { name, path, version, installHint };
-  } catch {
-    return { name, path: '', version: '', installHint };
-  }
-}
-
-export async function GET() {
-  const os = platform();
-  const isLinux = os === 'linux';
-  const isMac = os === 'darwin';
-
-  const results = [
-    detect('claude', isMac
-      ? 'npm install -g @anthropic-ai/claude-code'
-      : isLinux
-        ? 'npm install -g @anthropic-ai/claude-code'
-        : 'npm install -g @anthropic-ai/claude-code'),
-    detect('codex', 'npm install -g @openai/codex'),
-    detect('aider', isMac
-      ? 'brew install aider  or  pip install aider-chat'
-      : 'pip install aider-chat'),
-  ];
-
-  return NextResponse.json({ os, tools: results });
-}

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

@@ -1,176 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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 });
-}