@aion0/forge 0.5.48 → 0.5.49

package/app/api/migration/config/route.ts

@@ -1,19 +0,0 @@
-import { NextResponse } from 'next/server';
-import { loadConfig, saveConfig } from '@/lib/migration/store';
-import type { MigrationConfig } from '@/lib/migration/types';
-
-// GET /api/migration/config?projectPath=...
-export async function GET(req: Request) {
-  const url = new URL(req.url);
-  const projectPath = url.searchParams.get('projectPath');
-  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
-  return NextResponse.json(loadConfig(projectPath));
-}
-
-// POST /api/migration/config — body: { projectPath, config }
-export async function POST(req: Request) {
-  const { projectPath, config } = await req.json() as { projectPath: string; config: MigrationConfig };
-  if (!projectPath || !config) return NextResponse.json({ error: 'projectPath + config required' }, { status: 400 });
-  saveConfig(projectPath, config);
-  return NextResponse.json({ ok: true });
-}

package/app/api/migration/discover/route.ts

@@ -1,26 +0,0 @@
-import { NextResponse } from 'next/server';
-import { discoverEndpoints } from '@/lib/migration/discoverer';
-import { loadConfig, saveEndpoints, loadEndpoints } from '@/lib/migration/store';
-
-// GET /api/migration/discover?projectPath=...  → return cached endpoints
-export async function GET(req: Request) {
-  const url = new URL(req.url);
-  const projectPath = url.searchParams.get('projectPath');
-  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
-  return NextResponse.json({ endpoints: loadEndpoints(projectPath) });
-}
-
-// POST /api/migration/discover — body: { projectPath } → re-scan docs
-export async function POST(req: Request) {
-  const { projectPath } = await req.json() as { projectPath: string };
-  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
-  const config = loadConfig(projectPath);
-  const result = discoverEndpoints(projectPath, config);
-  saveEndpoints(projectPath, result.endpoints);
-  return NextResponse.json({
-    endpoints: result.endpoints,
-    warnings: result.warnings,
-    sources: result.sources,
-    total: result.endpoints.length,
-  });
-}

package/app/api/migration/failures/route.ts

@@ -1,35 +0,0 @@
-import { NextResponse } from 'next/server';
-import { loadFailures } from '@/lib/migration/store';
-import type { Failure, FailureCluster } from '@/lib/migration/types';
-
-function cluster(failures: Failure[]): FailureCluster[] {
-  const byType = new Map<string, Map<string, Failure[]>>();
-  for (const f of failures) {
-    let m = byType.get(f.errorType);
-    if (!m) { m = new Map(); byType.set(f.errorType, m); }
-    let arr = m.get(f.controller);
-    if (!arr) { arr = []; m.set(f.controller, arr); }
-    arr.push(f);
-  }
-  const out: FailureCluster[] = [];
-  for (const [errorType, ctrlMap] of byType) {
-    const controllers = [...ctrlMap.entries()].map(([controller, failures]) => ({ controller, failures }));
-    controllers.sort((a, b) => b.failures.length - a.failures.length);
-    out.push({
-      errorType,
-      count: controllers.reduce((sum, c) => sum + c.failures.length, 0),
-      controllers,
-    });
-  }
-  out.sort((a, b) => b.count - a.count);
-  return out;
-}
-
-// GET /api/migration/failures?projectPath=...
-export async function GET(req: Request) {
-  const url = new URL(req.url);
-  const projectPath = url.searchParams.get('projectPath');
-  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
-  const failures = loadFailures(projectPath);
-  return NextResponse.json({ failures, clusters: cluster(failures) });
-}

package/app/api/migration/fix/route.ts

@@ -1,82 +0,0 @@
-import { NextResponse } from 'next/server';
-import { execSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { writeFileSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { loadEndpoints } from '@/lib/migration/store';
-import { createTask } from '@/lib/task-manager';
-import type { Failure } from '@/lib/migration/types';
-
-interface FixRequest {
-  projectPath: string;
-  projectName?: string;
-  mode: 'inject' | 'task';
-  endpointIds?: string[];           // single or batch
-  failures?: Failure[];             // optional pre-clustered failures
-  sessionName?: string;             // tmux session for inject mode
-  customPrompt?: string;
-}
-
-function buildPrompt(eps: any[], failures?: Failure[], custom?: string): string {
-  const lines: string[] = [];
-  lines.push('# API parity fix request');
-  lines.push('');
-  lines.push('The following endpoints in the new web-server module produce results that differ from the legacy module. The legacy code MUST NOT be changed — fix the new module so its output matches.');
-  lines.push('');
-  if (failures && failures.length > 0) {
-    lines.push('## Failures');
-    for (const f of failures) {
-      lines.push(`- \`${f.method} ${f.path}\` (${f.controller}) — ${f.errorType}: ${f.errorMessage}`);
-    }
-  } else if (eps.length > 0) {
-    lines.push('## Endpoints');
-    for (const e of eps) {
-      lines.push(`- \`${e.method} ${e.path}\` — controller: ${e.controller}, status: ${e.status}${e.notes ? `, notes: ${e.notes}` : ''}`);
-    }
-  }
-  lines.push('');
-  lines.push('## Approach');
-  lines.push('1. Read .forge/migration/runs/*.json for the latest run output and diffs.');
-  lines.push('2. Identify the controller class in the new web-server module.');
-  lines.push('3. Compare to the legacy implementation — focus on response shape, status codes, field names.');
-  lines.push('4. Apply minimal fix; do not change unrelated code.');
-  lines.push('5. Re-run the migration cockpit batch test for these endpoints.');
-  if (custom) {
-    lines.push('');
-    lines.push('## Additional context');
-    lines.push(custom);
-  }
-  return lines.join('\n');
-}
-
-export async function POST(req: Request) {
-  const body = await req.json() as FixRequest;
-  const { projectPath, projectName, mode, endpointIds, failures, sessionName, customPrompt } = body;
-  if (!projectPath || !mode) return NextResponse.json({ error: 'projectPath + mode required' }, { status: 400 });
-
-  const all = loadEndpoints(projectPath);
-  const ids = new Set(endpointIds || []);
-  const eps = ids.size > 0 ? all.filter(e => ids.has(e.id)) : [];
-  const prompt = buildPrompt(eps, failures, customPrompt);
-
-  if (mode === 'task') {
-    const name = projectName || projectPath.split('/').filter(Boolean).pop() || 'project';
-    const task = createTask({ projectName: name, projectPath, prompt });
-    return NextResponse.json({ ok: true, mode: 'task', taskId: task.id });
-  }
-
-  if (mode === 'inject') {
-    if (!sessionName) return NextResponse.json({ error: 'sessionName required for inject mode' }, { status: 400 });
-    try {
-      const buf = join(tmpdir(), `forge-migration-fix-${Date.now()}.txt`);
-      writeFileSync(buf, prompt);
-      execSync(`tmux load-buffer -t "${sessionName}" "${buf}" && tmux paste-buffer -t "${sessionName}" && sleep 0.2 && tmux send-keys -t "${sessionName}" Enter`, { timeout: 5000 });
-      try { unlinkSync(buf); } catch {}
-      return NextResponse.json({ ok: true, mode: 'inject', sessionName });
-    } catch (e: any) {
-      return NextResponse.json({ error: e?.message || String(e) }, { status: 500 });
-    }
-  }
-
-  return NextResponse.json({ error: 'invalid mode' }, { status: 400 });
-}

package/app/api/migration/run/route.ts

@@ -1,22 +0,0 @@
-import { NextResponse } from 'next/server';
-import { loadConfig, loadEndpoints, saveRun } from '@/lib/migration/store';
-import { runEndpoint } from '@/lib/migration/runner';
-import { loadOpenApi } from '@/lib/migration/openapi';
-
-// POST /api/migration/run — body: { projectPath, endpointId }
-export async function POST(req: Request) {
-  const { projectPath, endpointId } = await req.json() as { projectPath: string; endpointId: string };
-  if (!projectPath || !endpointId) return NextResponse.json({ error: 'projectPath + endpointId required' }, { status: 400 });
-
-  const eps = loadEndpoints(projectPath);
-  const ep = eps.find(e => e.id === endpointId);
-  if (!ep) return NextResponse.json({ error: 'endpoint not found' }, { status: 404 });
-
-  const config = loadConfig(projectPath);
-  const openApi = config.endpointSource.openApiSpec
-    ? loadOpenApi(projectPath, config.endpointSource.openApiSpec)
-    : null;
-  const result = await runEndpoint(ep, config, openApi);
-  saveRun(projectPath, [result]);
-  return NextResponse.json(result);
-}

package/app/api/migration/run-batch/route.ts

@@ -1,86 +0,0 @@
-import { loadConfig, loadEndpoints, saveRun, saveFailures } from '@/lib/migration/store';
-import { runEndpoints } from '@/lib/migration/runner';
-import type { Endpoint, RunResult, Failure } from '@/lib/migration/types';
-
-export const dynamic = 'force-dynamic';
-
-// POST /api/migration/run-batch — body: { projectPath, endpointIds?, onlyStatus?, concurrency? }
-// Returns SSE stream with progress and final result.
-export async function POST(req: Request) {
-  const { projectPath, endpointIds, onlyStatus, concurrency } = await req.json() as {
-    projectPath: string;
-    endpointIds?: string[];
-    onlyStatus?: string[];
-    concurrency?: number;
-  };
-  if (!projectPath) return new Response(JSON.stringify({ error: 'projectPath required' }), { status: 400 });
-
-  const config = loadConfig(projectPath);
-  const all = loadEndpoints(projectPath);
-  let toRun: Endpoint[] = all;
-  if (endpointIds && endpointIds.length > 0) {
-    const ids = new Set(endpointIds);
-    toRun = all.filter(e => ids.has(e.id));
-  } else if (onlyStatus && onlyStatus.length > 0) {
-    const s = new Set(onlyStatus);
-    toRun = all.filter(e => s.has(e.status));
-  }
-
-  const encoder = new TextEncoder();
-  const stream = new ReadableStream({
-    async start(controller) {
-      const send = (event: string, data: any) => {
-        controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
-      };
-      send('start', { total: toRun.length });
-
-      try {
-        const results = await runEndpoints(toRun, config, {
-          concurrency: concurrency ?? 4,
-          projectPath,
-          onProgress: (done, total, last) => {
-            send('progress', { done, total, result: last });
-          },
-        });
-        saveRun(projectPath, results);
-
-        const failures: Failure[] = results
-          .filter(r => r.match === 'fail' || r.match === 'error')
-          .map(r => {
-            const ep = toRun.find(e => e.id === r.endpointId)!;
-            return {
-              endpointId: r.endpointId,
-              controller: ep.controller,
-              method: ep.method,
-              path: ep.path,
-              errorType: r.errorType || 'unknown',
-              errorMessage: r.errorMessage || '',
-              lastSeenAt: r.startedAt,
-            };
-          });
-        saveFailures(projectPath, failures);
-
-        send('done', {
-          total: results.length,
-          pass: results.filter(r => r.match === 'pass').length,
-          fail: results.filter(r => r.match === 'fail').length,
-          stubOk: results.filter(r => r.match === 'stub-ok').length,
-          error: results.filter(r => r.match === 'error').length,
-          failures: failures.length,
-        });
-      } catch (e: any) {
-        send('error', { message: e?.message || String(e) });
-      } finally {
-        controller.close();
-      }
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
-    },
-  });
-}