@gurulu/cli 0.4.7 → 1.0.0

package/scripts/gurulu-agentic-install.lib.cjs

@@ -1,762 +0,0 @@
-// gurulu-agentic-install.lib.cjs — Phase 14 B3 agentic install alpha.
-//
-// Takes a scanner output document (from scripts/gurulu-scan.mjs / .lib.cjs)
-// and produces the 10 `.gurulu/` artifacts that the runtime loader (Phase 13
-// B1) ingests. Every artifact is validated against schemas/gurulu/*.schema.json
-// before being written. No source code edits. No SDK injection. Config only.
-//
-// Exposed as CommonJS so ts-jest can require() it directly and the ESM CLI
-// wrapper can import it via createRequire.
-
-'use strict';
-
-const INSTALL_AGENT_VERSION = '0.1.0';
-const DEFAULT_INGEST_ENDPOINT = 'https://ingest.gurulu.io/v1/events';
-const DEFAULT_SDK_VERSION = '0.1.0';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Map framework name from scanner to install-plan framework label. */
-function mapFrameworkName(name) {
-  if (!name || name === 'unknown') return 'unknown';
-  if (name === 'nextjs') return 'next';
-  return name;
-}
-
-/** Map ORM name to dialect list (best-effort). */
-function ormDialects(ormName) {
-  switch (ormName) {
-    case 'prisma':
-    case 'drizzle':
-    case 'typeorm':
-    case 'sequelize':
-    case 'kysely':
-      return ['postgresql'];
-    case 'mongoose':
-      return ['mongodb'];
-    default:
-      return [];
-  }
-}
-
-/** Map auth name to install-plan auth strategy. */
-function authStrategy(authName) {
-  switch (authName) {
-    case 'nextauth':
-    case 'lucia':
-    case 'passport':
-      return 'session';
-    case 'clerk':
-    case 'supabase':
-    case 'firebase':
-      return 'oauth';
-    case 'custom-jwt':
-      return 'jwt';
-    default:
-      return 'custom';
-  }
-}
-
-/** Map op verb to past-tense event name fragment. */
-function opVerb(op) {
-  if (!op) return 'changed';
-  const lower = String(op).toLowerCase();
-  if (lower.startsWith('create') || lower === 'insert' || lower === 'insertmany') return 'created';
-  if (
-    lower.startsWith('update') ||
-    lower.startsWith('upsert') ||
-    lower === 'findoneandupdate'
-  )
-    return 'updated';
-  if (lower.startsWith('delete') || lower.startsWith('remove') || lower === 'findoneanddelete')
-    return 'deleted';
-  return lower;
-}
-
-/** Infer canonical event name from model + operation. */
-function inferEventName(model, op) {
-  const safeModel = String(model || 'entity')
-    .replace(/[^A-Za-z0-9_]/g, '')
-    .toLowerCase();
-  return `${safeModel || 'entity'}_${opVerb(op)}`;
-}
-
-/** Normalise CDC op name to schema enum (insert|update|delete). */
-function cdcOp(op) {
-  const verb = opVerb(op);
-  if (verb === 'created') return 'insert';
-  if (verb === 'updated') return 'update';
-  if (verb === 'deleted') return 'delete';
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// Business surface derivation
-// ---------------------------------------------------------------------------
-
-const SURFACE_KEYWORDS = [
-  { kind: 'signup', patterns: ['signup', 'register', 'sign-up', 'join', 'onboard'] },
-  { kind: 'login', patterns: ['login', 'signin', 'sign-in', 'auth/callback'] },
-  { kind: 'checkout', patterns: ['checkout', 'payment', 'cart', 'billing', 'order'] },
-  { kind: 'subscription', patterns: ['subscribe', 'subscription', 'plan', 'pricing'] },
-  { kind: 'lead', patterns: ['lead', 'contact', 'demo', 'newsletter'] },
-  { kind: 'onboarding', patterns: ['welcome', 'onboarding', 'getting-started'] },
-];
-
-const MODEL_SURFACE = new Map([
-  ['user', 'signup'],
-  ['users', 'signup'],
-  ['account', 'signup'],
-  ['accounts', 'signup'],
-  ['profile', 'signup'],
-  ['order', 'checkout'],
-  ['orders', 'checkout'],
-  ['payment', 'checkout'],
-  ['payments', 'checkout'],
-  ['cart', 'checkout'],
-  ['invoice', 'checkout'],
-  ['subscription', 'subscription'],
-  ['subscriptions', 'subscription'],
-  ['plan', 'subscription'],
-  ['lead', 'lead'],
-  ['leads', 'lead'],
-  ['contact', 'lead'],
-  ['contacts', 'lead'],
-]);
-
-/** Scan routes + mutations to produce install-plan surfaces (with evidence). */
-function deriveBusinessSurfaces(scan) {
-  const surfaces = new Map();
-  const addEvidence = (kind, entry, evidence) => {
-    if (!surfaces.has(kind)) {
-      surfaces.set(kind, { kind, entry, confidence: 0.5, evidence: [] });
-    }
-    const s = surfaces.get(kind);
-    if (!s.entry || s.entry === '/') s.entry = entry || s.entry;
-    if (evidence && !s.evidence.includes(evidence)) s.evidence.push(evidence);
-    s.confidence = Math.min(0.95, s.confidence + 0.1);
-  };
-
-  for (const route of scan.routes || []) {
-    const p = (route.path || '').toLowerCase();
-    for (const { kind, patterns } of SURFACE_KEYWORDS) {
-      if (patterns.some((pat) => p.includes(pat))) {
-        const method = (route.methods || []).includes('POST') ? 'POST' : (route.methods || ['*'])[0];
-        addEvidence(kind, route.path, `${method} ${route.path}`);
-        break;
-      }
-    }
-  }
-
-  for (const m of scan.mutations || []) {
-    const key = String(m.model || '').toLowerCase();
-    const kind = MODEL_SURFACE.get(key);
-    if (kind) {
-      addEvidence(
-        kind,
-        null,
-        `${m.file}:${m.line} ${m.model}.${m.operation}`,
-      );
-    }
-  }
-
-  return Array.from(surfaces.values()).map((s) => ({
-    ...s,
-    entry: s.entry || '/',
-    confidence: Number(s.confidence.toFixed(2)),
-  }));
-}
-
-/** Build a suggested_milestones array from the derived surfaces. */
-function deriveMilestones(surfaces) {
-  const out = [];
-  for (const s of surfaces) {
-    const type = ['signup', 'checkout', 'lead', 'onboarding'].includes(s.kind) ? s.kind : null;
-    if (!type) continue;
-    out.push({
-      id: `ms_${type}`,
-      type,
-      description: `Auto-detected ${type} milestone`,
-    });
-  }
-  // Always at least one milestone so downstream tooling has a seed.
-  if (out.length === 0) {
-    out.push({ id: 'ms_activation', type: 'activation', description: 'Default activation milestone' });
-  }
-  return out;
-}
-
-// ---------------------------------------------------------------------------
-// Artifact generators
-// ---------------------------------------------------------------------------
-
-/** install-plan.json — top-level discovery summary. */
-function generateInstallPlan(scan, opts) {
-  const framework = scan.framework || { name: 'unknown' };
-  const orm = scan.orm || { name: 'unknown' };
-  const auth = scan.auth || { name: 'unknown' };
-
-  const domains = Array.isArray(opts && opts.domains) && opts.domains.length > 0
-    ? opts.domains.slice()
-    : ['localhost'];
-
-  const stack = {
-    framework: {
-      name: mapFrameworkName(framework.name),
-      ...(framework.version ? { version: String(framework.version) } : {}),
-      confidence: 0.9,
-    },
-    runtime: 'node:20',
-  };
-  if (orm.name && orm.name !== 'unknown') {
-    stack.orm = { name: orm.name, dialects: ormDialects(orm.name) };
-  }
-  if (auth.name && auth.name !== 'unknown') {
-    stack.auth = { provider: auth.name, strategy: authStrategy(auth.name) };
-  }
-
-  const surfaces = deriveBusinessSurfaces(scan);
-  const suggested_milestones = deriveMilestones(surfaces);
-
-  return {
-    site_id: opts.siteId,
-    generated_at: new Date().toISOString(),
-    agent_version: INSTALL_AGENT_VERSION,
-    domains,
-    install_mode: 'observe',
-    stack,
-    surfaces,
-    suggested_milestones,
-  };
-}
-
-/** core-config.json — shared SDK runtime config. */
-function generateCoreConfig(scan, opts) {
-  return {
-    sdk_version: DEFAULT_SDK_VERSION,
-    config_version: 1,
-    ingest: {
-      endpoint: DEFAULT_INGEST_ENDPOINT,
-      region: 'eu',
-      batch_size: 50,
-      flush_interval_ms: 2000,
-    },
-    project: { id: opts.siteId },
-    tenant: { id: opts.tenantId, mode: 'single' },
-    identity: {
-      anonymous_id_cookie: '_gurulu_aid',
-      user_id_field: 'user.id',
-      correlation_field: 'correlation_id',
-    },
-    consent_defaults: {
-      analytics: true,
-      marketing: false,
-      strict_mode: true,
-    },
-    feature_flags: {},
-  };
-}
-
-/** web.config.json — browser SDK config + route→flow heuristic. */
-function generateWebConfig(scan /*, opts*/) {
-  const routes = [];
-  const seen = new Set();
-  for (const route of scan.routes || []) {
-    const p = (route.path || '').toLowerCase();
-    let flow = null;
-    let milestone = null;
-    for (const { kind, patterns } of SURFACE_KEYWORDS) {
-      if (patterns.some((pat) => p.includes(pat))) {
-        flow = `flow_${kind}`;
-        if (['signup', 'checkout', 'lead', 'onboarding'].includes(kind)) {
-          milestone = `ms_${kind}`;
-        }
-        break;
-      }
-    }
-    if (!flow) continue;
-    const entry = { pattern: route.path, flow };
-    if (milestone) entry.milestone = milestone;
-    const key = `${entry.pattern}::${entry.flow}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    routes.push(entry);
-  }
-  if (routes.length === 0) {
-    routes.push({ pattern: '/', flow: 'flow_default' });
-  }
-
-  return {
-    auto_track: {
-      page_views: true,
-      clicks: true,
-      form_submits: true,
-      web_vitals: true,
-      errors: true,
-    },
-    routes,
-    selectors: [],
-    drift: {
-      capture_scroll: true,
-      capture_viewport: true,
-      capture_referrer: true,
-      capture_user_agent: true,
-    },
-    no_capture: ['input[type=password]', '[data-sensitive]'],
-    inspector: { enabled: true, endpoint: 'https://inspector.gurulu.io' },
-    playground: { enabled: false, endpoint: 'https://playground.gurulu.io' },
-  };
-}
-
-/** app.config.json — mobile SDK skeleton (alpha doesn't auto-detect mobile). */
-function generateAppConfig(/* scan, opts */) {
-  return {
-    platform: 'ios',
-    auto_screen_tracking: {
-      enabled: true,
-      screen_name_source: 'view_controller',
-      ignore_patterns: [],
-    },
-    lifecycle: {
-      track_install: true,
-      track_update: true,
-      track_foreground: true,
-      track_background: false,
-    },
-    deep_links: [],
-    push: { provider: 'none', track_opens: false },
-    offline_queue: {
-      max_events: 1000,
-      max_bytes: 1048576,
-      flush_on_network: true,
-    },
-  };
-}
-
-/** server-map.json — server endpoint → business event. */
-function generateServerMap(scan /*, opts*/) {
-  const endpoints = [];
-  for (const route of scan.routes || []) {
-    const p = (route.path || '').toLowerCase();
-    const methods = route.methods && route.methods.length > 0 ? route.methods : ['*'];
-    let event = null;
-    if (p.includes('checkout') || p.includes('order') || p.includes('payment')) {
-      event = 'order_placed';
-    } else if (p.includes('signup') || p.includes('register')) {
-      event = 'user_registered';
-    } else if (p.includes('subscribe') || p.includes('subscription')) {
-      event = 'subscription_started';
-    } else if (p.includes('lead') || p.includes('contact')) {
-      event = 'lead_captured';
-    }
-    if (!event) continue;
-    for (const method of methods) {
-      if (method === '*' || method === 'GET' || method === 'HEAD' || method === 'OPTIONS') continue;
-      endpoints.push({
-        method,
-        path: route.path,
-        handler: route.file ? `${route.file}:${method}` : undefined,
-        event,
-        emit_on: 'success',
-      });
-    }
-  }
-  // server-map schema doesn't require minItems on endpoints, but an empty
-  // map isn't useful — include a placeholder only when we have zero routes.
-  return {
-    identity: {
-      header: 'x-gurulu-aid',
-      cookie: '_gurulu_aid',
-      trace_header: 'traceparent',
-    },
-    endpoints: endpoints.map((e) => {
-      const out = { method: e.method, path: e.path, event: e.event, emit_on: e.emit_on };
-      if (e.handler) out.handler = e.handler;
-      return out;
-    }),
-    ignore: ['/api/health'],
-  };
-}
-
-/**
- * Sprint E1.3b — singularize plural table/model names to canonical singular.
- * The scan layer normalises mutations as `{ op: '<model>.<operation>' }` so we
- * derive the operation from `m.op` when `m.operation` isn't present, and
- * collapse common irregular plurals to their singular form so e.g. raw-SQL
- * `INSERT INTO orders` and a Drizzle `pgTable('orders', ...)` both fold into
- * the same `order` row in db-map.
- */
-const SINGULARIZE_IRREGULARS = {
-  users: 'user',
-  orders: 'order',
-  items: 'item',
-};
-function singularizeModelName(raw) {
-  const lower = String(raw || '').toLowerCase();
-  if (!lower) return lower;
-  if (Object.prototype.hasOwnProperty.call(SINGULARIZE_IRREGULARS, lower)) {
-    return SINGULARIZE_IRREGULARS[lower];
-  }
-  return lower;
-}
-
-/** db-map.json — table → event emitter mapping from detected mutations. */
-function generateDbMap(scan, opts) {
-  const byModel = new Map();
-  for (const m of scan.mutations || []) {
-    const rawName = String(m.model || '').trim();
-    if (!rawName) continue;
-    const name = singularizeModelName(rawName);
-    // Sprint E1.3b — `scan.mutations` from gurulu-scan.lib.cjs normalises the
-    // operation as `m.op = "<model>.<operation>"` and drops `m.operation`.
-    // Derive the operation verb from whichever field is populated.
-    const operation =
-      m.operation || (typeof m.op === 'string' ? m.op.split('.').pop() : null);
-    const op = cdcOp(operation);
-    if (!op) continue;
-    if (!byModel.has(name)) byModel.set(name, new Set());
-    const key = `${op}::${inferEventName(name, operation)}`;
-    byModel.get(name).add(key);
-  }
-
-  const tables = [];
-  for (const [name, opsSet] of byModel.entries()) {
-    const emits = [];
-    const seen = new Set();
-    for (const entry of opsSet) {
-      const [op, event] = entry.split('::');
-      if (seen.has(event)) continue;
-      seen.add(event);
-      emits.push({ event, on: op });
-    }
-    if (emits.length === 0) continue;
-    tables.push({ name, primary_key: 'id', emits });
-  }
-
-  // Schema requires tables.minItems === 1. Seed a placeholder so downstream
-  // tooling has something to edit.
-  if (tables.length === 0) {
-    tables.push({
-      name: 'users',
-      primary_key: 'id',
-      emits: [{ event: 'user_created', on: 'insert' }],
-    });
-  }
-
-  return {
-    connector: `conn_${(opts && opts.tenantId) || 'primary'}_db`,
-    allowed_operations: ['insert', 'update', 'delete'],
-    tables,
-    truth_commit: { reconcile_interval_s: 300, strict: false },
-  };
-}
-
-/** flow-seeds.json — pre-seeded flows from derived business surfaces. */
-function generateFlowSeeds(scan /*, opts*/) {
-  const surfaces = deriveBusinessSurfaces(scan);
-  const flows = [];
-  for (const s of surfaces) {
-    const flowName = `flow_${s.kind}`;
-    const entryRef = s.entry || '/';
-    const successEvent =
-      s.kind === 'signup'
-        ? 'user_registered'
-        : s.kind === 'checkout'
-          ? 'order_placed'
-          : s.kind === 'subscription'
-            ? 'subscription_started'
-            : s.kind === 'lead'
-              ? 'lead_captured'
-              : `${s.kind}_complete`;
-
-    flows.push({
-      flowName,
-      surface: 'hybrid',
-      nodes: [
-        { id: 'n1', kind: 'entry', ref: entryRef, next: ['n2'] },
-        { id: 'n2', kind: 'page', ref: entryRef, next: ['n3'] },
-        { id: 'n3', kind: 'event', ref: `${s.kind}_form_submitted`, next: ['n4'] },
-        { id: 'n4', kind: 'server_event', ref: successEvent, next: ['n5'] },
-        { id: 'n5', kind: 'success', ref: `${s.kind}_complete` },
-      ],
-      expectedOutcome: { event: successEvent, within_ms: 300000 },
-      confidence: s.confidence,
-      source: 'route_scan',
-    });
-  }
-
-  // Schema requires flows.minItems === 1.
-  if (flows.length === 0) {
-    flows.push({
-      flowName: 'flow_default',
-      surface: 'web',
-      nodes: [
-        { id: 'n1', kind: 'entry', ref: '/', next: ['n2'] },
-        { id: 'n2', kind: 'success', ref: 'page_viewed' },
-      ],
-      expectedOutcome: { event: 'page_viewed', within_ms: 60000 },
-      confidence: 0.5,
-      source: 'heuristic',
-    });
-  }
-
-  return { generated_at: new Date().toISOString(), flows };
-}
-
-/** milestone-rules.json — milestone engine rules. */
-function generateMilestoneRules(scan /*, opts*/) {
-  const surfaces = deriveBusinessSurfaces(scan);
-  const kinds = new Set(surfaces.map((s) => s.kind));
-  const rules = [];
-
-  if (kinds.has('signup') || kinds.size === 0) {
-    rules.push({
-      id: 'rule_signup',
-      milestone: 'signup',
-      match: { event: 'signup_form_submitted' },
-      success_signals: ['user_registered'],
-      abandon_signals: ['page_leave'],
-      error_signals: ['signup_error'],
-      window: { max_duration_ms: 600000, idle_timeout_ms: 120000 },
-      priority: 10,
-    });
-  }
-  if (kinds.has('checkout')) {
-    rules.push({
-      id: 'rule_checkout',
-      milestone: 'checkout',
-      match: { event: 'checkout_started' },
-      success_signals: ['order_placed'],
-      abandon_signals: ['checkout_cancelled', 'page_leave'],
-      error_signals: ['payment_failed'],
-      window: { max_duration_ms: 900000, idle_timeout_ms: 180000 },
-      priority: 20,
-    });
-  }
-  if (kinds.has('lead')) {
-    rules.push({
-      id: 'rule_lead',
-      milestone: 'lead',
-      match: { event: 'lead_form_submitted' },
-      success_signals: ['lead_captured'],
-      abandon_signals: ['page_leave'],
-      window: { max_duration_ms: 300000, idle_timeout_ms: 60000 },
-      priority: 30,
-    });
-  }
-  if (rules.length === 0) {
-    // Guarantee minItems === 1 even when we somehow removed the signup rule.
-    rules.push({
-      id: 'rule_activation',
-      milestone: 'activation',
-      match: { event: 'page_viewed' },
-      success_signals: ['session_active'],
-      window: { max_duration_ms: 600000, idle_timeout_ms: 120000 },
-      priority: 100,
-    });
-  }
-  return { rules };
-}
-
-/** correlation-map.json — client ↔ server ↔ db event linking. */
-function generateCorrelationMap(scan /*, opts*/) {
-  const surfaces = deriveBusinessSurfaces(scan);
-  const kinds = new Set(surfaces.map((s) => s.kind));
-  const links = [];
-
-  if (kinds.has('signup') || kinds.size === 0) {
-    links.push({
-      from: { tier: 'client', event: 'signup_form_submitted' },
-      to: { tier: 'server', event: 'user_registered' },
-      via: 'correlation_id',
-      window_ms: 60000,
-    });
-  }
-  if (kinds.has('checkout')) {
-    links.push({
-      from: { tier: 'client', event: 'checkout_started' },
-      to: { tier: 'server', event: 'order_placed' },
-      via: 'correlation_id',
-      window_ms: 60000,
-    });
-    links.push({
-      from: { tier: 'server', event: 'order_placed' },
-      to: { tier: 'db', event: 'order_created' },
-      via: 'order_id',
-      window_ms: 600000,
-    });
-  }
-  if (links.length === 0) {
-    // Belt-and-braces minItems guarantee.
-    links.push({
-      from: { tier: 'client', event: 'page_viewed' },
-      to: { tier: 'server', event: 'page_viewed' },
-      via: 'correlation_id',
-      window_ms: 60000,
-    });
-  }
-
-  return {
-    correlation_field: 'correlation_id',
-    ttl_ms: 300000,
-    identity_propagation: {
-      anonymous_to_user: true,
-      carry_header: 'x-gurulu-aid',
-    },
-    links,
-  };
-}
-
-/** connectors.json — external destinations placeholder (empty in alpha). */
-function generateConnectors(/* scan, opts */) {
-  return { connectors: [] };
-}
-
-// ---------------------------------------------------------------------------
-// Top-level entry
-// ---------------------------------------------------------------------------
-
-/**
- * Generate all 10 artifacts from a scanner output and install options.
- *
- * @param {object} scanOutput — result of scripts/gurulu-scan.lib.cjs scanRepo()
- * @param {{ siteId: string, tenantId: string, outputPath?: string, domains?: string[] }} opts
- * @returns {{ artifacts: Record<string, object>, errors: Array<{file:string,message:string}> }}
- */
-function generateArtifacts(scanOutput, opts) {
-  if (!opts || !opts.siteId || !opts.tenantId) {
-    throw new Error('generateArtifacts: opts.siteId and opts.tenantId are required');
-  }
-  const scan = scanOutput || {};
-  return {
-    artifacts: {
-      'install-plan.json': generateInstallPlan(scan, opts),
-      'core-config.json': generateCoreConfig(scan, opts),
-      'web.config.json': generateWebConfig(scan, opts),
-      'app.config.json': generateAppConfig(scan, opts),
-      'server-map.json': generateServerMap(scan, opts),
-      'db-map.json': generateDbMap(scan, opts),
-      'flow-seeds.json': generateFlowSeeds(scan, opts),
-      'milestone-rules.json': generateMilestoneRules(scan, opts),
-      'correlation-map.json': generateCorrelationMap(scan, opts),
-      'connectors.json': generateConnectors(scan, opts),
-    },
-    errors: [],
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Validation
-// ---------------------------------------------------------------------------
-
-let _ajvInstance = null;
-function getAjv() {
-  if (_ajvInstance) return _ajvInstance;
-  // eslint-disable-next-line global-require
-  const Ajv = require('ajv');
-  _ajvInstance = new Ajv({ allErrors: true, format: 'full' });
-  return _ajvInstance;
-}
-
-/**
- * Validate every artifact against its matching schema.
- *
- * @param {Record<string, object>} artifacts
- * @returns {{ ok: true } | { ok: false, errors: Array<{file:string,message:string}> }}
- */
-function validateArtifacts(artifacts) {
-  // eslint-disable-next-line global-require
-  const path = require('path');
-  // eslint-disable-next-line global-require
-  const fs = require('fs');
-  const ajv = getAjv();
-
-  const schemaDir = path.join(__dirname, '..', 'schemas', 'gurulu');
-  const errors = [];
-
-  for (const [filename, artifact] of Object.entries(artifacts)) {
-    const schemaName = filename.replace(/\.json$/, '.schema.json');
-    const schemaPath = path.join(schemaDir, schemaName);
-    if (!fs.existsSync(schemaPath)) {
-      errors.push({ file: filename, message: `schema not found: ${schemaName}` });
-      continue;
-    }
-    let schema;
-    try {
-      schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
-    } catch (err) {
-      errors.push({ file: filename, message: `schema parse error: ${err.message}` });
-      continue;
-    }
-    let validate;
-    try {
-      // Compile fresh each call to avoid ajv caching conflicts across runs.
-      const freshAjv = new (require('ajv'))({ allErrors: true, format: 'full' });
-      validate = freshAjv.compile(schema);
-    } catch (err) {
-      errors.push({ file: filename, message: `schema compile error: ${err.message}` });
-      continue;
-    }
-    const valid = validate(artifact);
-    if (!valid) {
-      for (const e of validate.errors || []) {
-        errors.push({
-          file: filename,
-          message: `${e.dataPath || '(root)'} ${e.message}`,
-        });
-      }
-    }
-  }
-
-  return errors.length === 0 ? { ok: true } : { ok: false, errors };
-}
-
-// ---------------------------------------------------------------------------
-// Atomic writer
-// ---------------------------------------------------------------------------
-
-/**
- * Write artifacts to disk. Ensures the output directory exists and writes
- * each file with a trailing newline. Designed to be re-runnable.
- *
- * @param {Record<string, object>} artifacts
- * @param {string} outputPath
- */
-async function writeArtifacts(artifacts, outputPath) {
-  // eslint-disable-next-line global-require
-  const fs = require('fs/promises');
-  // eslint-disable-next-line global-require
-  const path = require('path');
-  await fs.mkdir(outputPath, { recursive: true });
-  for (const [filename, artifact] of Object.entries(artifacts)) {
-    const filePath = path.join(outputPath, filename);
-    await fs.writeFile(filePath, JSON.stringify(artifact, null, 2) + '\n', 'utf8');
-  }
-}
-
-module.exports = {
-  INSTALL_AGENT_VERSION,
-  DEFAULT_INGEST_ENDPOINT,
-  DEFAULT_SDK_VERSION,
-  generateArtifacts,
-  generateInstallPlan,
-  generateCoreConfig,
-  generateWebConfig,
-  generateAppConfig,
-  generateServerMap,
-  generateDbMap,
-  generateFlowSeeds,
-  generateMilestoneRules,
-  generateCorrelationMap,
-  generateConnectors,
-  deriveBusinessSurfaces,
-  deriveMilestones,
-  inferEventName,
-  validateArtifacts,
-  writeArtifacts,
-  mapFrameworkName,
-  ormDialects,
-  authStrategy,
-};