@gurulu/cli 0.1.0 → 0.1.2

package/scripts/gurulu-agentic-install.mjs

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+// gurulu-agentic-install.mjs — Phase 14 B3 CLI wrapper.
+//
+// Reads a `gurulu-scan` JSON output and produces the 10 `.gurulu/` artifacts
+// that the runtime loader (Phase 13 B1) consumes. Pairs with:
+//   scripts/gurulu-scan.mjs       (Phase 13 B2 — scanner)
+//   scripts/gurulu-agentic-install.lib.cjs  (generator logic)
+//
+// Usage:
+//   node scripts/gurulu-agentic-install.mjs <scan-output.json> \
+//     --site-id <id> --tenant-id <id> [--output .gurulu/] [--dry-run] [--quiet]
+//
+// Pass `-` as the scan path to read JSON from stdin.
+
+import { createRequire } from 'node:module';
+import { readFileSync, statSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const lib = require('./gurulu-agentic-install.lib.cjs');
+const patches = require('./patches/index.cjs');
+
+export const {
+  INSTALL_AGENT_VERSION,
+  generateArtifacts,
+  generateInstallPlan,
+  generateCoreConfig,
+  generateWebConfig,
+  generateAppConfig,
+  generateServerMap,
+  generateDbMap,
+  generateFlowSeeds,
+  generateMilestoneRules,
+  generateCorrelationMap,
+  generateConnectors,
+  deriveBusinessSurfaces,
+  deriveMilestones,
+  inferEventName,
+  validateArtifacts,
+  writeArtifacts,
+} = lib;
+
+// ---------------------------------------------------------------------------
+// CLI entry
+// ---------------------------------------------------------------------------
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--help' || a === '-h') {
+      args.help = true;
+    } else if (a === '--quiet' || a === '-q') {
+      args.quiet = true;
+    } else if (a === '--dry-run') {
+      args.dryRun = true;
+    } else if (a === '--apply') {
+      args.apply = true;
+    } else if (a === '--rollback') {
+      args.rollback = true;
+    } else if (a === '--auto-instrument') {
+      args.autoInstrument = true;
+    } else if (a.startsWith('--')) {
+      const key = a.slice(2);
+      args[key] = argv[++i];
+    } else {
+      args._.push(a);
+    }
+  }
+  return args;
+}
+
+function printHelp(out = process.stdout) {
+  out.write(
+    [
+      'Usage: node scripts/gurulu-agentic-install.mjs <scan-output.json> \\',
+      '         --site-id <id> --tenant-id <id> [--output .gurulu/] [--dry-run] [--quiet]',
+      '',
+      'Reads a gurulu-scan JSON document (pass `-` for stdin) and generates the',
+      '10 .gurulu/ artifacts ingested by the Phase 13 B1 runtime loader.',
+      '',
+      'Options:',
+      '  --site-id <id>     Stable site identifier (required)',
+      '  --tenant-id <id>   Tenant identifier (required)',
+      '  --publishable-key <key>  Stripe-style gpk_live_/gpk_test_ key (optional)',
+      '  --output <path>    Output directory (default: .gurulu)',
+      '  --domains <list>   Comma-separated host list for install-plan.domains',
+      '  --dry-run          Validate + report without writing files (default for patch mode)',
+      '  --apply            (patch mode) write patches + create backup',
+      '  --rollback         (patch mode) restore most recent backup',
+      '  --framework <f>    auto|nextjs-app|nextjs-pages|vite-react|express',
+      '  --auto-instrument  (Phase 18.7) Also write gurulu.track() calls into route handlers',
+      '  --intent-result <path>  JSON file with InstallIntent output (feeds --auto-instrument)',
+      '  --quiet            Suppress non-error output',
+      '  -h, --help         Show this help',
+      '',
+    ].join('\n'),
+  );
+}
+
+async function readScanInput(scanFile) {
+  if (scanFile === '-') {
+    // stdin
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+  }
+  return JSON.parse(readFileSync(scanFile, 'utf8'));
+}
+
+async function runPatchMode(repoRoot, args) {
+  const log = args.quiet ? () => {} : (m) => process.stdout.write(m + '\n');
+  if (args.rollback) {
+    const res = patches.rollback(repoRoot);
+    if (!res.rolledBack) {
+      process.stderr.write(`Rollback failed: ${res.reason}\n`);
+      process.exit(3);
+    }
+    log(`Rolled back ${res.files.length} files`);
+    return;
+  }
+  if (!args['site-id'] || !args['tenant-id']) {
+    process.stderr.write('Error: --site-id and --tenant-id are required for patch mode\n');
+    process.exit(1);
+  }
+  const framework = args.framework || 'auto';
+  const { patcher, detection, error } = patches.resolvePatcher(repoRoot, framework);
+  if (error) {
+    process.stderr.write(`Error: ${error}\n`);
+    process.exit(1);
+  }
+  if (!patcher) {
+    process.stderr.write('No supported framework detected in ' + repoRoot + '\n');
+    process.exit(4);
+  }
+  const injection = patches.buildInjection({
+    siteId: args['site-id'],
+    tenantId: args['tenant-id'],
+    publishableKey: args['publishable-key'] || '',
+    scriptSrc: args['script-src'] || '/gurulu-tracker.js',
+  });
+  const plan = patcher.plan({ repoRoot, injection });
+  log(`Framework: ${patcher.name}`);
+  log(`Detected files: ${(detection?.files || []).join(', ') || '(none)'}`);
+  if (plan.changes.length === 0) {
+    log('No changes to apply (already installed or nothing to patch)');
+    return;
+  }
+  // Default behavior is dry-run unless --apply is passed.
+  const shouldApply = !!args.apply;
+  if (!shouldApply) {
+    for (const change of plan.changes) {
+      process.stdout.write(patches.unifiedDiff(change.relPath, change.before, change.after));
+    }
+    // Phase 18.7 B6 — include auto-instrument diff in dry-run output so
+    // users can eyeball what will be written before --apply.
+    if (args.autoInstrument && args['intent-result']) {
+      try {
+        const intent = JSON.parse(readFileSync(args['intent-result'], 'utf8'));
+        const acceptedEvents = (intent && intent.accepted && intent.accepted.events) || [];
+        const frameworkName = (patcher && patcher.name) || framework;
+        const aiResult = patches.autoInstrumentDispatch(
+          frameworkName,
+          { repoRoot },
+          acceptedEvents,
+        );
+        for (const change of aiResult.changes || []) {
+          process.stdout.write(
+            patches.unifiedDiff(change.relPath, change.before, change.after),
+          );
+        }
+        log(
+          `Auto-instrument dry-run: ${aiResult.filesModified} file(s) would change, ` +
+            `${aiResult.eventsInstrumented} event(s), ${aiResult.eventsSkipped} skipped.`,
+        );
+      } catch (err) {
+        process.stderr.write(
+          `Auto-instrument dry-run failed: ${err.message || err}\n`,
+        );
+      }
+    }
+    log(`Dry-run: ${plan.changes.length} file(s) would change. Re-run with --apply to write.`);
+    return;
+  }
+  const result = await patches.applyPlan(repoRoot, patcher, plan);
+  log(`Applied ${result.files.length} file change(s). Patch log: .gurulu/patch-log.json`);
+
+  // -------------------------------------------------------------------
+  // Phase 18.7 B6 — Auto-instrumentation (opt-in).
+  // When --auto-instrument is set AND --intent-result is provided, load
+  // the accepted events from the Phase 18.6 intent proposal, dispatch
+  // to the matching auto-instrument module, and append the resulting
+  // route-handler changes to the existing patch-log. Failures here are
+  // reported but do NOT unwind the script-tag patch (separate concerns).
+  // -------------------------------------------------------------------
+  if (args.autoInstrument) {
+    const intentPath = args['intent-result'];
+    if (!intentPath) {
+      log('Auto-instrument: skipped (no --intent-result provided)');
+      return;
+    }
+    let intent;
+    try {
+      intent = JSON.parse(readFileSync(intentPath, 'utf8'));
+    } catch (err) {
+      process.stderr.write(`Auto-instrument: failed to read ${intentPath}: ${err.message}\n`);
+      return;
+    }
+    const acceptedEvents = (intent && intent.accepted && intent.accepted.events) || [];
+    if (acceptedEvents.length === 0) {
+      log('Auto-instrument: no accepted events to instrument');
+      return;
+    }
+    const frameworkName = (patcher && patcher.name) || framework;
+    const aiResult = patches.autoInstrumentDispatch(
+      frameworkName,
+      { repoRoot },
+      acceptedEvents,
+    );
+    if (aiResult.collision) {
+      process.stderr.write(
+        `Auto-instrument: singleton helper collision; aborting without changes.\n`,
+      );
+      return;
+    }
+    if (!aiResult.changes || aiResult.changes.length === 0) {
+      log(`Auto-instrument: 0 file(s) changed (${aiResult.eventsSkipped} event(s) skipped)`);
+      for (const note of aiResult.notes || []) log(`  note: ${note}`);
+      return;
+    }
+    try {
+      const aiApply = await patches.applyAutoInstrumentPlan(repoRoot, {
+        framework: frameworkName,
+        changes: aiResult.changes,
+      });
+      log(
+        `Auto-instrument: ${aiResult.filesModified} file(s) instrumented, ` +
+          `${aiResult.eventsInstrumented} event(s), ${aiResult.eventsSkipped} skipped`,
+      );
+      log(`Auto-instrument: wrote ${aiApply.files.length} change(s) to patch-log`);
+      // Emit a machine-readable summary on stdout so the CLI can capture it.
+      process.stdout.write(
+        'AUTO_INSTRUMENT_RESULT ' +
+          JSON.stringify({
+            filesModified: aiResult.filesModified,
+            eventsInstrumented: aiResult.eventsInstrumented,
+            eventsSkipped: aiResult.eventsSkipped,
+            notes: aiResult.notes || [],
+          }) +
+          '\n',
+      );
+    } catch (err) {
+      process.stderr.write(`Auto-instrument: apply failed: ${err.stack || err.message || err}\n`);
+    }
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+  const input = args._[0];
+  if (!input) {
+    process.stderr.write('Error: input path is required (scan json or repo root)\n');
+    printHelp(process.stderr);
+    process.exit(1);
+  }
+
+  // Patch-mode: when input is a directory we run the code editor pipeline.
+  const isDirectory = input !== '-' && existsSync(input) && statSync(input).isDirectory();
+  if (isDirectory) {
+    await runPatchMode(input, args);
+    return;
+  }
+
+  const scanFile = input;
+  if (!args['site-id'] || !args['tenant-id']) {
+    process.stderr.write('Error: --site-id and --tenant-id are required\n');
+    process.exit(1);
+  }
+
+  const outputPath = args.output || '.gurulu';
+  const log = args.quiet ? () => {} : (m) => process.stderr.write(m + '\n');
+
+  let scanOutput;
+  try {
+    scanOutput = await readScanInput(scanFile);
+  } catch (err) {
+    process.stderr.write(`Error: failed to read scan input: ${err.message}\n`);
+    process.exit(1);
+  }
+
+  const domains = typeof args.domains === 'string'
+    ? args.domains.split(',').map((d) => d.trim()).filter(Boolean)
+    : undefined;
+
+  const result = generateArtifacts(scanOutput, {
+    siteId: args['site-id'],
+    tenantId: args['tenant-id'],
+    outputPath,
+    ...(domains ? { domains } : {}),
+  });
+
+  const validation = validateArtifacts(result.artifacts);
+  if (!validation.ok) {
+    process.stderr.write('Validation failed — not writing any files:\n');
+    for (const err of validation.errors) {
+      process.stderr.write(`  ${err.file}: ${err.message}\n`);
+    }
+    process.exit(2);
+  }
+
+  const filenames = Object.keys(result.artifacts);
+  if (args.dryRun) {
+    log(`Dry-run — would write ${filenames.length} files to ${outputPath}/:`);
+    for (const f of filenames) log(`  ${outputPath}/${f}`);
+    return;
+  }
+
+  await writeArtifacts(result.artifacts, outputPath);
+  log(`Wrote ${filenames.length} artifacts to ${outputPath}/`);
+}
+
+const invokedDirectly =
+  typeof process !== 'undefined' &&
+  process.argv[1] &&
+  (() => {
+    try {
+      return fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+    } catch {
+      return false;
+    }
+  })();
+
+if (invokedDirectly) {
+  main().catch((err) => {
+    process.stderr.write(`[agentic-install] ERROR: ${err.stack || err.message || err}\n`);
+    process.exit(1);
+  });
+}