@aion0/forge 0.5.48 → 0.5.49

package/lib/migration/runner.ts

@@ -1,219 +0,0 @@
-// HTTP runner — fires the same path against legacy + new and compares.
-// diffMode controls how comparison happens:
-//   exact = fire both, deep-equal JSON
-//   shape = fire only `next`, validate response against OpenAPI schema (legacy not needed)
-//   both  = fire both + schema validation
-
-import type { Endpoint, MigrationConfig, RunResult, SideResult } from './types';
-import { diff, validateAgainstSchema, type SchemaViolation } from './differ';
-
-function compileIgnore(patterns: string[]): RegExp[] {
-  return patterns.map(p => {
-    const body = p.startsWith('$') ? p.slice(1) : p;
-    const escaped = body
-      .replace(/\./g, '\\.')
-      .replace(/\[\*\]/g, '\\[\\d+\\]')
-      .replace(/\[(\d+)\]/g, '\\[$1\\]');
-    return new RegExp(`^\\$${escaped}$`);
-  });
-}
-import { loadOpenApi, lookup, getResponseSchema, type OpenApiDoc } from './openapi';
-
-function substitutePath(path: string, subs: Record<string, string> = {}): string {
-  return path.replace(/\{([^}]+)\}/g, (_, name) => subs[name] ?? subs.id ?? '1');
-}
-
-function buildHeaders(config: MigrationConfig): Record<string, string> {
-  const headers: Record<string, string> = { Accept: 'application/json' };
-  if (config.auth.mode === 'bearer' && config.auth.tokenEnv) {
-    const tok = process.env[config.auth.tokenEnv];
-    if (tok) headers['Authorization'] = `Bearer ${tok}`;
-  } else if (config.auth.mode === 'basic' && config.auth.username && config.auth.passwordEnv) {
-    const pw = process.env[config.auth.passwordEnv];
-    if (pw) {
-      const b64 = Buffer.from(`${config.auth.username}:${pw}`).toString('base64');
-      headers['Authorization'] = `Basic ${b64}`;
-    }
-  }
-  return headers;
-}
-
-async function fetchOne(baseUrl: string, ep: Endpoint, config: MigrationConfig, timeout: number): Promise<SideResult> {
-  const path = substitutePath(ep.path, config.pathSubstitutions);
-  const url = baseUrl.replace(/\/+$/, '') + path;
-  const start = Date.now();
-  const ctrl = new AbortController();
-  const t = setTimeout(() => ctrl.abort(), timeout);
-  try {
-    const resp = await fetch(url, {
-      method: ep.method,
-      headers: buildHeaders(config),
-      signal: ctrl.signal,
-    });
-    const text = await resp.text();
-    let bodyJson: any = undefined;
-    try { bodyJson = text ? JSON.parse(text) : undefined; } catch {}
-    return {
-      url, status: resp.status, ok: resp.ok,
-      bodyExcerpt: text.slice(0, 4096),
-      bodyJson,
-      durationMs: Date.now() - start,
-    };
-  } catch (e: any) {
-    return {
-      url, status: 0, ok: false,
-      error: e?.name === 'AbortError' ? `timeout after ${timeout}ms` : (e?.message || String(e)),
-      durationMs: Date.now() - start,
-    };
-  } finally {
-    clearTimeout(t);
-  }
-}
-
-// Convert SchemaViolation[] → DiffEntry[] so the UI can show them uniformly.
-function violationsToDiffs(vios: SchemaViolation[]): RunResult['diff'] {
-  return vios.slice(0, 50).map(v => ({
-    jsonPath: v.jsonPath,
-    legacy: v.expected,
-    next: v.actual,
-    reason: v.reason === 'missing-required' ? 'missing-in-next' :
-            v.reason === 'type-mismatch' ? 'type-mismatch' : 'value',
-  }));
-}
-
-export async function runEndpoint(ep: Endpoint, config: MigrationConfig, openApi?: OpenApiDoc | null): Promise<RunResult> {
-  const startedAt = new Date().toISOString();
-  const t0 = Date.now();
-  const mode = config.diffMode || 'exact';
-
-  let legacy: SideResult;
-  let next: SideResult;
-
-  if (mode === 'shape') {
-    // Skip legacy entirely — use a synthesized "n/a" SideResult
-    legacy = { url: '(skipped — shape mode)', status: 0, ok: true, durationMs: 0 };
-    next = await fetchOne(config.next.baseUrl, ep, config, config.healthCheck.newTimeout);
-  } else {
-    [legacy, next] = await Promise.all([
-      fetchOne(config.legacy.baseUrl, ep, config, config.healthCheck.legacyTimeout),
-      fetchOne(config.next.baseUrl, ep, config, config.healthCheck.newTimeout),
-    ]);
-  }
-
-  let match: RunResult['match'] = 'pass';
-  let errorType: string | undefined;
-  let errorMessage: string | undefined;
-  let diffEntries: RunResult['diff'];
-
-  // ── Stubbed: only the new side matters; expect 501 ──
-  if (ep.isStubbed) {
-    if (next.error) {
-      match = 'error'; errorType = 'new-unreachable'; errorMessage = next.error;
-    } else if (next.status === 501) {
-      match = 'stub-ok';
-    } else {
-      match = 'fail'; errorType = 'stub-not-501'; errorMessage = `Expected 501, got ${next.status}`;
-    }
-  }
-  // ── Shape mode: validate new against OpenAPI schema ──
-  else if (mode === 'shape') {
-    if (next.error) {
-      match = 'error'; errorType = 'new-unreachable'; errorMessage = next.error;
-    } else if (!(next.status >= 200 && next.status < 300)) {
-      match = 'fail'; errorType = 'http-status'; errorMessage = `HTTP ${next.status}`;
-    } else {
-      const schema = openApi ? getOpResponseSchema(openApi, ep) : null;
-      if (!schema) {
-        // No schema — treat as smoke pass (endpoint responded 2xx with no body check)
-        match = 'pass';
-      } else {
-        const vios = validateAgainstSchema(next.bodyJson, schema, '$', [], compileIgnore(config.ignorePaths));
-        if (vios.length > 0) {
-          match = 'fail';
-          errorType = 'schema-violation';
-          errorMessage = `${vios.length} schema violations`;
-          diffEntries = violationsToDiffs(vios);
-        }
-      }
-    }
-  }
-  // ── Exact / both: deep-equal both sides + optional schema validation ──
-  else {
-    if (legacy.error || next.error) {
-      match = 'error';
-      errorType = legacy.error ? 'legacy-unreachable' : 'new-unreachable';
-      errorMessage = legacy.error || next.error;
-    } else if (legacy.status !== next.status) {
-      match = 'fail';
-      errorType = 'http-status-mismatch';
-      errorMessage = `legacy=${legacy.status} new=${next.status}`;
-    } else {
-      const d = diff(legacy.bodyJson, next.bodyJson, config.ignorePaths, { sortArrays: true });
-      if (d.length > 0) {
-        match = 'fail';
-        errorType = 'json-diff';
-        errorMessage = `${d.length} differences`;
-        diffEntries = d.slice(0, 50);
-      }
-      // In `both` mode also run schema validation on the new side
-      if (mode === 'both' && openApi) {
-        const schema = getOpResponseSchema(openApi, ep);
-        if (schema) {
-          const vios = validateAgainstSchema(next.bodyJson, schema, '$', [], compileIgnore(config.ignorePaths));
-          if (vios.length > 0 && match === 'pass') {
-            match = 'fail';
-            errorType = 'schema-violation';
-            errorMessage = `${vios.length} schema violations`;
-            diffEntries = violationsToDiffs(vios);
-          }
-        }
-      }
-    }
-  }
-
-  return {
-    endpointId: ep.id,
-    startedAt,
-    durationMs: Date.now() - t0,
-    legacy, next, match,
-    diff: diffEntries,
-    errorType,
-    errorMessage,
-  };
-}
-
-function getOpResponseSchema(openApi: OpenApiDoc, ep: Endpoint): any | null {
-  const op = lookup(openApi, ep.method, ep.path);
-  if (!op) return null;
-  return getResponseSchema(op, openApi);
-}
-
-export async function runEndpoints(eps: Endpoint[], config: MigrationConfig, opts: {
-  concurrency?: number;
-  onProgress?: (done: number, total: number, last: RunResult) => void;
-  projectPath?: string;
-} = {}): Promise<RunResult[]> {
-  const concurrency = Math.max(1, opts.concurrency ?? 4);
-  const results: RunResult[] = [];
-  let done = 0;
-  let i = 0;
-
-  // Load OpenAPI once for the whole batch (shape/both modes)
-  let openApi: OpenApiDoc | null = null;
-  if ((config.diffMode === 'shape' || config.diffMode === 'both') && config.endpointSource.openApiSpec && opts.projectPath) {
-    openApi = loadOpenApi(opts.projectPath, config.endpointSource.openApiSpec);
-  }
-
-  async function worker() {
-    while (true) {
-      const idx = i++;
-      if (idx >= eps.length) return;
-      const r = await runEndpoint(eps[idx], config, openApi);
-      results[idx] = r;
-      done++;
-      opts.onProgress?.(done, eps.length, r);
-    }
-  }
-  await Promise.all(Array.from({ length: Math.min(concurrency, eps.length) }, worker));
-  return results;
-}

package/lib/migration/store.ts

@@ -1,89 +0,0 @@
-// Per-project file storage at <project>/.forge/migration/
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import * as YAML from 'yaml';
-import type { Endpoint, MigrationConfig, RunResult, Failure } from './types';
-import { DEFAULT_CONFIG } from './types';
-
-function migrationDir(projectPath: string): string {
-  return join(projectPath, '.forge', 'migration');
-}
-function ensureDir(dir: string) {
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-}
-
-// ── Config ──────────────────────────────────────────────
-export function loadConfig(projectPath: string): MigrationConfig {
-  const file = join(migrationDir(projectPath), 'config.yaml');
-  if (!existsSync(file)) return structuredClone(DEFAULT_CONFIG);
-  try {
-    const parsed = YAML.parse(readFileSync(file, 'utf8')) || {};
-    return { ...DEFAULT_CONFIG, ...parsed,
-      auth: { ...DEFAULT_CONFIG.auth, ...(parsed.auth || {}) },
-      healthCheck: { ...DEFAULT_CONFIG.healthCheck, ...(parsed.healthCheck || {}) },
-      endpointSource: { ...DEFAULT_CONFIG.endpointSource, ...(parsed.endpointSource || {}) },
-      pathSubstitutions: { ...DEFAULT_CONFIG.pathSubstitutions, ...(parsed.pathSubstitutions || {}) },
-    };
-  } catch {
-    return structuredClone(DEFAULT_CONFIG);
-  }
-}
-
-export function saveConfig(projectPath: string, config: MigrationConfig): void {
-  const dir = migrationDir(projectPath);
-  ensureDir(dir);
-  writeFileSync(join(dir, 'config.yaml'), YAML.stringify(config), 'utf8');
-}
-
-// ── Endpoints ───────────────────────────────────────────
-export function loadEndpoints(projectPath: string): Endpoint[] {
-  const file = join(migrationDir(projectPath), 'endpoints.json');
-  if (!existsSync(file)) return [];
-  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return []; }
-}
-
-export function saveEndpoints(projectPath: string, endpoints: Endpoint[]): void {
-  const dir = migrationDir(projectPath);
-  ensureDir(dir);
-  writeFileSync(join(dir, 'endpoints.json'), JSON.stringify(endpoints, null, 2), 'utf8');
-}
-
-// ── Runs ────────────────────────────────────────────────
-export function saveRun(projectPath: string, results: RunResult[]): string {
-  const runsDir = join(migrationDir(projectPath), 'runs');
-  ensureDir(runsDir);
-  const ts = new Date().toISOString().replace(/[:.]/g, '-');
-  const file = join(runsDir, `${ts}.json`);
-  writeFileSync(file, JSON.stringify(results, null, 2), 'utf8');
-  return file;
-}
-
-export function listRuns(projectPath: string): { name: string; path: string; mtime: number }[] {
-  const runsDir = join(migrationDir(projectPath), 'runs');
-  if (!existsSync(runsDir)) return [];
-  return readdirSync(runsDir)
-    .filter(f => f.endsWith('.json'))
-    .map(f => {
-      const path = join(runsDir, f);
-      return { name: f, path, mtime: 0 };
-    });
-}
-
-export function loadRun(file: string): RunResult[] {
-  if (!existsSync(file)) return [];
-  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return []; }
-}
-
-// ── Failures ────────────────────────────────────────────
-export function saveFailures(projectPath: string, failures: Failure[]): void {
-  const dir = join(migrationDir(projectPath), 'failures');
-  ensureDir(dir);
-  writeFileSync(join(dir, 'current.json'), JSON.stringify(failures, null, 2), 'utf8');
-}
-
-export function loadFailures(projectPath: string): Failure[] {
-  const file = join(migrationDir(projectPath), 'failures', 'current.json');
-  if (!existsSync(file)) return [];
-  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return []; }
-}

package/lib/migration/types.ts

@@ -1,115 +0,0 @@
-// Migration Cockpit types — API parity testing for legacy → new module migrations.
-
-export type EndpointStatus = 'pending' | 'in-progress' | 'migrated' | 'tested' | 'skip' | 'defer';
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-
-export interface Endpoint {
-  id: string;                        // stable hash of `${method} ${path}`
-  controller: string;                // tag from OpenAPI or controller name from doc
-  file?: string;                     // legacy or migrated file path
-  method: HttpMethod;
-  path: string;                      // raw path with `{id}` style placeholders
-  status: EndpointStatus;
-  expectedHttpStatus: number;        // 200 normally, 501 for stubbed
-  isStubbed: boolean;
-  source: string;                    // primary source (OpenAPI / doc file)
-  notes?: string;
-  acceptance?: string[];
-  // OpenAPI cross-reference (when OpenAPI is the primary source)
-  operationId?: string;
-  tag?: string;
-  summary?: string;
-  hasResponseSchema?: boolean;
-  // Migration doc cross-reference
-  docFile?: string;                  // docs/migration/<X>.java.md if matched
-}
-
-export interface RunResult {
-  endpointId: string;
-  startedAt: string;
-  durationMs: number;
-  legacy: SideResult;
-  next: SideResult;
-  match: 'pass' | 'fail' | 'stub-ok' | 'error';
-  diff?: DiffEntry[];
-  errorType?: string;
-  errorMessage?: string;
-}
-
-export interface SideResult {
-  url: string;
-  status: number;
-  ok: boolean;
-  bodyExcerpt?: string;
-  bodyJson?: any;
-  error?: string;
-  durationMs: number;
-}
-
-export interface DiffEntry {
-  jsonPath: string;
-  legacy: any;
-  next: any;
-  reason: 'value' | 'missing-in-next' | 'missing-in-legacy' | 'type-mismatch';
-}
-
-export interface Failure {
-  endpointId: string;
-  controller: string;
-  method: HttpMethod;
-  path: string;
-  errorType: string;                 // e.g. "http-status-mismatch", "json-diff", "exception"
-  errorMessage: string;
-  lastSeenAt: string;
-}
-
-export interface FailureCluster {
-  errorType: string;
-  count: number;
-  controllers: { controller: string; failures: Failure[] }[];
-}
-
-export type DiffMode = 'exact' | 'shape' | 'both';
-
-export interface MigrationConfig {
-  legacy: { baseUrl: string };
-  next: { baseUrl: string; sourceDir?: string };
-  auth: {
-    mode: 'skip' | 'bearer' | 'basic';
-    tokenEnv?: string;
-    username?: string;
-    passwordEnv?: string;
-  };
-  ignorePaths: string[];
-  healthCheck: {
-    legacyTimeout: number;
-    newTimeout: number;
-    skipUnhealthy: boolean;
-  };
-  clusterMode: 'simple' | 'ai';
-  diffMode: DiffMode;                // exact = compare both sides; shape = validate new against schema; both = both
-  endpointSource: {
-    type: 'docs' | 'openapi' | 'source-scan' | 'mixed';
-    primary: string;                 // dir for per-controller docs
-    fallback?: string;               // history file
-    openApiSpec?: string;            // path to OpenAPI 3 JSON (preferred when set)
-  };
-  pathSubstitutions?: Record<string, string>; // {id} → "1" etc
-}
-
-export const DEFAULT_CONFIG: MigrationConfig = {
-  legacy: { baseUrl: 'http://localhost:8080' },
-  next: { baseUrl: 'http://localhost:9090' },
-  auth: { mode: 'skip' },
-  ignorePaths: ['$.timestamp', '$.requestId', '$.traceId'],
-  healthCheck: { legacyTimeout: 2000, newTimeout: 2000, skipUnhealthy: true },
-  clusterMode: 'simple',
-  diffMode: 'shape',
-  endpointSource: {
-    type: 'mixed',
-    primary: 'docs/migration',
-    fallback: 'docs/lead/migration-history.md',
-    openApiSpec: 'docs/fnac-rest-schema-7.6.json',
-  },
-  pathSubstitutions: { id: '1', dbid: '1', ip: '127.0.0.1', mac: '00:00:00:00:00:00' },
-};