avorelo 0.3.8 → 0.4.0-rc.2

package/scripts/lib/activation/activation-runner.js

@@ -0,0 +1,607 @@
+"use strict";
+
+const crypto = require("crypto");
+const path = require("path");
+const { nowIso, safeWriteJson } = require("../fsx");
+const { detectProject, detectEnvironment } = require("./detect-environment");
+const { detectAiSurfaces, detectModelRouting } = require("./ai-surface-detector");
+const { runRepairEngine } = require("./repair-engine");
+const {
+  checkReadiness,
+  planRepairs,
+  runSelfHealingPass,
+} = require("./activation-self-healing");
+const { appendProductLearningEvent } = require("../product-learning-events");
+const { PUBLIC_ACTIVATE_COMMAND } = require("./activation-summary");
+
+const ACTIVATION_CONTRACT = "avorelo.activation.v1";
+const ACTIVATION_SCHEMA_VERSION = 1;
+const MAX_REPAIR_ATTEMPTS = 3;
+
+function createActivationId() {
+  return `act-${Date.now()}-${crypto.randomBytes(3).toString("hex")}`;
+}
+
+function defaultResult(cwd) {
+  return {
+    schemaVersion: ACTIVATION_SCHEMA_VERSION,
+    contract: ACTIVATION_CONTRACT,
+    activationId: createActivationId(),
+    startedAt: nowIso(),
+    completedAt: null,
+    cwd: cwd || process.cwd(),
+    workspaceRoot: null,
+    status: "not_started",
+    ready: false,
+    attempts: 0,
+    maxAttempts: MAX_REPAIR_ATTEMPTS,
+    detectedEnvironment: {},
+    detectedAiSurfaces: [],
+    detectedModelRouting: { status: "unknown" },
+    safeFixesPlanned: [],
+    safeFixesApplied: [],
+    unsafeBlockers: [],
+    hardBlockers: [],
+    verificationChecks: {},
+    readiness: {},
+    generatedReceipts: [],
+    dashboardPath: null,
+    valueTrackingReady: false,
+    valueClaimsShown: false,
+    nextAction: null,
+    agentRepairInstructions: null,
+    firstValueReadiness: null,
+    forceRefresh: false,
+    refreshedSurfaces: [],
+    refreshSkipped: [],
+    refreshErrors: [],
+    errors: [],
+    redacted: true,
+  };
+}
+
+function buildReadinessLabels(checks) {
+  const labels = [];
+  if (checks.workspace_detected) labels.push("Workspace connected");
+  if (checks.model_routing) labels.push("Routing classified");
+  if (checks.workspace_registry) labels.push("Registry ready");
+  if (checks.session_context) labels.push("Session context ready");
+  if (checks.security_baseline) labels.push("Security checks ready");
+  if (checks.dashboard_preview || checks.operating_value) labels.push("Dashboard ready");
+  return labels;
+}
+
+function buildNextAction(target, readinessChecks) {
+  const t = target || "claude";
+  const handoffCommand = `node bin/avorelo session-context --handoff --target ${t}`;
+  const dashboardCommand = "node bin/avorelo open";
+
+  if (t === "codex") {
+    return {
+      handoff: "node bin/avorelo session-context --handoff --target codex",
+      dashboard: dashboardCommand,
+      note: "Paste handoff output into your Codex prompt for session continuity.",
+    };
+  }
+  if (t === "local-model") {
+    return {
+      handoff: "node bin/avorelo session-context --handoff --target local-model",
+      dashboard: dashboardCommand,
+      note: "Local model target prepared with compact session context.",
+    };
+  }
+  return {
+    handoff: handoffCommand,
+    dashboard: dashboardCommand,
+    note: "Paste handoff output at the start of your next Claude Code session.",
+  };
+}
+
+function buildFirstValueReadiness(checks, nextAction) {
+  const missing = [];
+  if (!checks.session_context) missing.push("session_context");
+  if (!checks.workspace_registry) missing.push("workspace_registry");
+  if (!checks.brain_pack) missing.push("brain_pack");
+  if (!checks.operating_value) missing.push("operating_value");
+  if (!checks.dashboard_preview) missing.push("dashboard_preview");
+  if (!checks.proof_summary) missing.push("proof_summary");
+  if (!checks.security_baseline) missing.push("security_baseline");
+
+  const ready = missing.filter((k) => ["session_context", "workspace_registry", "brain_pack", "operating_value"].includes(k)).length === 0;
+
+  return {
+    ready,
+    sessionContextReady: Boolean(checks.session_context),
+    targetHandoffReady: Boolean(checks.session_context),
+    dashboardValueReady: Boolean(checks.dashboard_preview || checks.operating_value),
+    operatingValueReady: Boolean(checks.operating_value),
+    workspaceRegistryReady: Boolean(checks.workspace_registry),
+    brainPackReady: Boolean(checks.brain_pack),
+    proofReady: Boolean(checks.proof_summary),
+    capabilityRecommendationReady: Boolean(checks.workspace_registry && checks.brain_pack),
+    securityBaselineReady: Boolean(checks.security_baseline),
+    nextAction: nextAction && nextAction.handoff ? nextAction.handoff : "node bin/avorelo session-context --handoff --target claude",
+    missing,
+  };
+}
+
+function emitActivationEvent(cwd, eventName, payload, dryRun) {
+  if (dryRun) return;
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName,
+      category: "activation",
+      surface: "local",
+      status: "observed",
+      payload: payload || {},
+    });
+  } catch {
+    // event emission is best-effort; never fail activation
+  }
+}
+
+function buildAgentRepairInstructions(result) {
+  // Use only required-check failures so optional checks don't pollute the repair plan
+  const remainingFailing = result.readiness && Array.isArray(result.readiness.failing)
+    ? result.readiness.failing
+    : Object.entries(result.verificationChecks || {}).filter(([, v]) => !v).map(([k]) => k);
+
+  return {
+    schemaVersion: 1,
+    contract: "avorelo.activation.agent-repair.v1",
+    activationId: result.activationId,
+    status: result.status,
+    ready: result.ready,
+    attemptsUsed: result.attempts,
+    maxAttempts: result.maxAttempts,
+    failingChecks: remainingFailing,
+    hardBlockers: result.hardBlockers,
+    safeFixesApplied: result.safeFixesApplied,
+    unsafeBlockers: result.unsafeBlockers,
+    nextRepairCommand: "node bin/avorelo activate --repair",
+    instructions: [
+      "Run `node bin/avorelo activate --repair` to retry the self-healing pass.",
+      "If a hard blocker is listed, address it and rerun activation.",
+      "If failingChecks remain after repair, inspect each path manually.",
+      "All safe/domain-owned fixes have already been attempted automatically.",
+      "Only proceed with changes listed in this repair plan.",
+      "Do not delete user source files, modify business logic, or change CI behavior.",
+    ],
+  };
+}
+
+function runActivationV1(cwd, options = {}) {
+  const result = defaultResult(cwd);
+  result.workspaceRoot = cwd;
+  result.forceRefresh = Boolean(options.forceRefresh);
+
+  // Detect prior canonical state so we can distinguish a fresh activation from a
+  // re-run (idempotency / "already active" funnel signal). Best-effort, never throws.
+  let wasAlreadyActive = false;
+  try {
+    const { readActivationState } = require("./activation-state");
+    const prior = readActivationState(cwd);
+    wasAlreadyActive = Boolean(prior && prior.present !== false && prior.status === "first_value_ready");
+  } catch {}
+  result.alreadyActive = wasAlreadyActive;
+
+  // Status: scanning
+  result.status = "scanning";
+
+  // Emit activation_started (activationSessionId is anonymous: act-<ts>-<rand>, no PII)
+  emitActivationEvent(cwd, "activation_started", {
+    activationSessionId: result.activationId,
+    forceRefresh: result.forceRefresh,
+    dryRun: Boolean(options.dryRun),
+    target: options.target || "claude",
+    alreadyActive: wasAlreadyActive,
+  }, options.dryRun);
+
+  try {
+    // Phase: environment detection
+    result.detectedEnvironment = detectEnvironment(cwd, { env: options.env });
+    result.detectedAiSurfaces = detectAiSurfaces(cwd, { env: options.env });
+    result.detectedModelRouting = detectModelRouting(cwd, { env: options.env });
+
+    // Emit scan completed
+    emitActivationEvent(cwd, "activation_scan_completed", {
+      aiSurfaceCount: result.detectedAiSurfaces.length,
+      routingStatus: result.detectedModelRouting.status,
+      nodeDetected: result.detectedEnvironment.nodeDetected,
+    }, options.dryRun);
+
+    if (result.detectedModelRouting.status && result.detectedModelRouting.status !== "unknown") {
+      emitActivationEvent(cwd, "activation_model_routing_detected", {
+        routingStatus: result.detectedModelRouting.status,
+        envProviderCount: (result.detectedModelRouting.envProviders || []).length,
+      }, options.dryRun);
+    }
+
+    // Hard blocker: Node missing
+    if (!result.detectedEnvironment.nodeDetected) {
+      result.hardBlockers.push({
+        id: "node_missing",
+        message: "Node.js is required but not detected. Install Node.js and rerun activation.",
+        requiresUser: true,
+      });
+    }
+
+    // Early exit if hard blockers at scan phase
+    if (result.hardBlockers.length > 0) {
+      result.status = "blocked_hard";
+      result.ready = false;
+      result.completedAt = nowIso();
+      result.agentRepairInstructions = buildAgentRepairInstructions(result);
+      emitActivationEvent(cwd, "activation_hard_blocker_detected", {
+        blockerCount: result.hardBlockers.length,
+        firstBlockerId: result.hardBlockers[0] && result.hardBlockers[0].id,
+      }, options.dryRun);
+      return result;
+    }
+
+    // Phase: repair + verify loop
+    for (let attempt = 0; attempt < MAX_REPAIR_ATTEMPTS; attempt++) {
+      result.attempts = attempt + 1;
+      result.status = "repairing";
+
+      // Run existing repair engine (dirs, config, context-pack, host configuration)
+      const repairEngineResult = runRepairEngine(cwd, {
+        environment: result.detectedEnvironment,
+        project: detectProject(cwd, { env: options.env }),
+        detectedHosts: [],
+        existingState: null,
+        doctor: null,
+      }, { repair: !options.dryRun });
+
+      const engineRepairs = repairEngineResult.repairsAttempted || [];
+
+      // Run self-healing pass (gitignore, registry, brain-pack, session-context, operating-value)
+      const healingContext = {
+        target: options.target,
+        detectedModelRouting: result.detectedModelRouting,
+        hardBlockers: repairEngineResult.manualFixesRequired
+          .filter((f) => f.blocking)
+          .map((f) => ({ id: f.id, message: f.reason, requiresUser: true })),
+      };
+
+      const selfHealResult = runSelfHealingPass(cwd, healingContext, {
+        dryRun: options.dryRun,
+        target: options.target,
+        forceRefresh: options.forceRefresh,
+      });
+
+      // Propagate force-refresh results
+      if (selfHealResult.refreshedSurfaces && selfHealResult.refreshedSurfaces.length > 0) {
+        result.refreshedSurfaces = selfHealResult.refreshedSurfaces;
+      }
+      if (selfHealResult.refreshSkipped && selfHealResult.refreshSkipped.length > 0) {
+        result.refreshSkipped = selfHealResult.refreshSkipped;
+      }
+      if (selfHealResult.refreshErrors && selfHealResult.refreshErrors.length > 0) {
+        result.refreshErrors = selfHealResult.refreshErrors;
+      }
+
+      // Collect all hard blockers
+      const allHardBlockers = [
+        ...healingContext.hardBlockers,
+        ...selfHealResult.hardBlockers,
+      ];
+
+      const allRepairs = [
+        ...engineRepairs.map((r) => ({ ...r, source: "repair-engine" })),
+        ...selfHealResult.repairs.map((r) => ({ ...r, source: "self-healing" })),
+      ];
+
+      // Split into planned vs applied
+      const planned = allRepairs.filter((r) => r.status === "planned");
+      const applied = allRepairs.filter((r) => r.status === "applied");
+
+      result.safeFixesPlanned = planned.map((r) => r.label || r.id);
+      result.safeFixesApplied = applied.map((r) => r.label || r.id);
+
+      // Emit per-repair events (aggregate, not per-item)
+      if (applied.length > 0) {
+        emitActivationEvent(cwd, "activation_safe_fix_applied", {
+          fixCount: applied.length,
+          attempt: result.attempts,
+        }, options.dryRun);
+      }
+
+      if (allHardBlockers.length > 0) {
+        result.hardBlockers = allHardBlockers;
+        result.status = "blocked_hard";
+        emitActivationEvent(cwd, "activation_hard_blocker_detected", {
+          blockerCount: allHardBlockers.length,
+          firstBlockerId: allHardBlockers[0] && allHardBlockers[0].id,
+        }, options.dryRun);
+        break;
+      }
+
+      // Phase: verify
+      result.status = "verifying";
+      const readinessResult = checkReadiness(cwd, healingContext);
+      result.verificationChecks = readinessResult.checks;
+      result.readiness = {
+        labels: buildReadinessLabels(readinessResult.checks),
+        failing: readinessResult.failingRequired,
+        ready: readinessResult.ready,
+      };
+
+      emitActivationEvent(cwd, "activation_verification_completed", {
+        attempt: result.attempts,
+        failingRequiredCount: readinessResult.failingRequired.length,
+        readinessReady: readinessResult.ready,
+      }, options.dryRun);
+
+      // Extract dashboard path from repairs
+      const dashboardRepair = selfHealResult.repairs.find((r) => r.dashboardPath);
+      if (dashboardRepair) {
+        result.dashboardPath = dashboardRepair.dashboardPath;
+        emitActivationEvent(cwd, "activation_dashboard_ready", {
+          hasDashboardPath: true,
+        }, options.dryRun);
+      }
+
+      // Value tracking ready (without savings claims)
+      result.valueTrackingReady = readinessResult.checks.operating_value === true;
+      result.valueClaimsShown = false;
+
+      if (readinessResult.ready) {
+        result.status = "ready";
+        result.ready = true;
+        break;
+      }
+
+      // If still failing required checks and last attempt, mark blocked
+      if (attempt === MAX_REPAIR_ATTEMPTS - 1) {
+        result.status = "blocked_hard";
+        result.hardBlockers.push({
+          id: "max_attempts_exceeded",
+          message: `Activation could not complete after ${MAX_REPAIR_ATTEMPTS} repair attempts. Failing required checks: ${readinessResult.failingRequired.join(", ")}`,
+          requiresUser: false,
+          failingChecks: readinessResult.failingRequired,
+        });
+      }
+    }
+
+  } catch (err) {
+    result.status = "failed_internal";
+    result.errors.push({ message: err.message });
+    result.hardBlockers.push({
+      id: "internal_error",
+      message: `Activation failed internally: ${err.message}`,
+      requiresUser: false,
+    });
+  }
+
+  // Build next action
+  result.nextAction = buildNextAction(options.target, result.verificationChecks);
+
+  // Build first value readiness
+  result.firstValueReadiness = buildFirstValueReadiness(result.verificationChecks || {}, result.nextAction);
+
+  // Build agent repair instructions
+  result.agentRepairInstructions = buildAgentRepairInstructions(result);
+
+  // Emit final ready/blocked event
+  if (result.ready) {
+    emitActivationEvent(cwd, "activation_ready", {
+      attemptsUsed: result.attempts,
+      surfacesRefreshed: result.refreshedSurfaces.length,
+      firstValueReady: result.firstValueReadiness && result.firstValueReadiness.ready,
+    }, options.dryRun);
+  }
+  emitActivationEvent(cwd, "activation_agent_repair_plan_generated", {
+    ready: result.ready,
+    failingChecksCount: (result.agentRepairInstructions && result.agentRepairInstructions.failingChecks && result.agentRepairInstructions.failingChecks.length) || 0,
+  }, options.dryRun);
+
+  result.completedAt = nowIso();
+
+  // Write the canonical activation.json that status / dashboard / doctor read.
+  // This is the single source of truth for "is this project activated".
+  let canonicalStateWritten = false;
+  if (!options.dryRun) {
+    try {
+      const { buildActivationState, writeActivationState, ACTIVATION_STATE_REL } = require("./activation-state");
+      const compatStatus = result.ready ? "first_value_ready" : (result.status === "blocked_hard" ? "blocked" : result.status);
+      writeActivationState(cwd, buildActivationState({
+        status: compatStatus,
+        activationSessionId: result.activationId,
+        project: detectProject(cwd, { env: options.env }),
+        environment: result.detectedEnvironment,
+        account: { connected: false, plan: "free", features: {} },
+        detectedHosts: result.detectedAiSurfaces.map((s) => ({
+          id: s.id,
+          label: s.label,
+          detected: true,
+          installState: "detected",
+          depth: "shallow",
+          limitations: [],
+        })),
+        enabledIntegrations: result.detectedAiSurfaces.map((s) => s.id),
+        repairsAttempted: result.safeFixesApplied.map((label) => ({ id: label, status: "applied", reason: label })),
+        manualFixesRequired: result.hardBlockers.map((b) => ({ id: b.id, label: b.message, blocking: true, command: null, reason: b.message })),
+        nextAction: result.nextAction
+          ? { label: "Start working", command: result.nextAction.handoff || null, reason: "Avorelo is ready.", blocking: false }
+          : { label: "Check setup", command: PUBLIC_ACTIVATE_COMMAND, reason: "Activation incomplete.", blocking: false },
+        firstValue: { available: result.ready, summary: null },
+      }));
+      canonicalStateWritten = true;
+      result.canonicalStatePath = ACTIVATION_STATE_REL;
+    } catch {
+      // canonical state write is best-effort; do not fail activation
+    }
+
+    // Install/repair the durable run-entry contract (idempotent, local-first).
+    try {
+      const { installRunEntry } = require("./run-entry");
+      result.runEntry = installRunEntry(cwd, { activationSource: "cli" });
+    } catch (error) {
+      result.runEntry = { error: error.message };
+    }
+  }
+
+  // ── Activation funnel completion events (privacy-safe, local-first, fail-open) ──
+  if (canonicalStateWritten) {
+    emitActivationEvent(cwd, "first_receipt_created", {
+      activationSessionId: result.activationId,
+      receipt: "activation.json",
+    }, options.dryRun);
+  }
+  if (result.ready) {
+    emitActivationEvent(cwd, "activation_completed", {
+      activationSessionId: result.activationId,
+      attemptsUsed: result.attempts,
+      safeFixCount: result.safeFixesApplied.length,
+      alreadyActive: wasAlreadyActive,
+    }, options.dryRun);
+    if (wasAlreadyActive) {
+      emitActivationEvent(cwd, "activation_already_active", {
+        activationSessionId: result.activationId,
+      }, options.dryRun);
+    }
+    if (result.safeFixesApplied.length > 0) {
+      emitActivationEvent(cwd, "activation_repaired", {
+        activationSessionId: result.activationId,
+        fixCount: result.safeFixesApplied.length,
+      }, options.dryRun);
+    }
+  } else {
+    emitActivationEvent(cwd, "activation_failed", {
+      activationSessionId: result.activationId,
+      status: result.status,
+      blockerCount: result.hardBlockers.length,
+      firstBlockerId: result.hardBlockers[0] && result.hardBlockers[0].id,
+    }, options.dryRun);
+  }
+
+  return result;
+}
+
+function parseActivationArgs(argv) {
+  const args = {
+    json: false,
+    dryRun: false,
+    repair: true,
+    target: "claude",
+    open: false,
+    agentRepair: false,
+    forceRefresh: false,
+    help: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--json") args.json = true;
+    if (token === "--dry-run") args.dryRun = true;
+    if (token === "--repair") args.repair = true;
+    if (token === "--open") args.open = true;
+    if (token === "--agent-repair") args.agentRepair = true;
+    if (token === "--force-refresh") args.forceRefresh = true;
+    if (token === "--help" || token === "-h") args.help = true;
+    if (token === "--target" && argv[i + 1]) {
+      args.target = argv[i + 1];
+      i += 1;
+    }
+    if (token.startsWith("--target=")) {
+      args.target = token.split("=")[1] || "claude";
+    }
+  }
+
+  return args;
+}
+
+function formatActivationSuccess(result) {
+  const lines = [];
+  lines.push("Avorelo is ready.");
+  lines.push("");
+  lines.push("Ready:");
+
+  const readyLabels = result.readiness && Array.isArray(result.readiness.labels)
+    ? result.readiness.labels
+    : ["Workspace connected", "Routing classified", "Registry ready", "Session context ready", "Security checks ready", "Dashboard ready"];
+
+  for (const label of readyLabels) {
+    lines.push(`- ${label}`);
+  }
+
+  lines.push("");
+  lines.push("Next:");
+  if (result.nextAction && result.nextAction.handoff) {
+    lines.push(result.nextAction.handoff);
+  }
+
+  lines.push("");
+  lines.push("Dashboard:");
+  if (result.nextAction && result.nextAction.dashboard) {
+    lines.push(result.nextAction.dashboard);
+  }
+
+  return lines.join("\n");
+}
+
+function formatActivationBlocked(result) {
+  const lines = [];
+  lines.push("Avorelo could not finish activation automatically.");
+  lines.push("");
+
+  if (result.safeFixesApplied.length > 0) {
+    lines.push("Fixed:");
+    for (const fix of result.safeFixesApplied) {
+      lines.push(`- ${fix}`);
+    }
+    lines.push("");
+  }
+
+  lines.push("Blocked:");
+  const blockers = result.hardBlockers.length > 0
+    ? result.hardBlockers
+    : [{ message: "Unknown hard blocker — rerun activation for details." }];
+  for (const b of blockers) {
+    lines.push(`- ${b.message || b.id}`);
+  }
+
+  if (result.safeFixesApplied.length > 0) {
+    lines.push("");
+    lines.push("I already tried:");
+    for (const fix of result.safeFixesApplied) {
+      lines.push(`- ${fix}`);
+    }
+  }
+
+  lines.push("");
+  lines.push("Next:");
+  if (result.hardBlockers.length > 0 && result.hardBlockers[0].requiresUser) {
+    lines.push(result.hardBlockers[0].message || "Address the blocker above and rerun activation.");
+  } else {
+    lines.push("node bin/avorelo activate --repair");
+  }
+
+  lines.push("");
+  lines.push("Agent repair:");
+  lines.push("node bin/avorelo activate --agent-repair");
+
+  return lines.join("\n");
+}
+
+function formatActivationText(result) {
+  if (result.ready) return formatActivationSuccess(result);
+  return formatActivationBlocked(result);
+}
+
+function formatActivationJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+module.exports = {
+  ACTIVATION_CONTRACT,
+  ACTIVATION_SCHEMA_VERSION,
+  MAX_REPAIR_ATTEMPTS,
+  runActivationV1,
+  parseActivationArgs,
+  formatActivationSuccess,
+  formatActivationBlocked,
+  formatActivationText,
+  formatActivationJson,
+};