avorelo 0.1.0 → 0.3.0

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

@@ -1,546 +0,0 @@
-"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 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 detected");
-  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 dashboard --value";
-
-  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);
-
-  // Status: scanning
-  result.status = "scanning";
-
-  // Emit activation_started
-  emitActivationEvent(cwd, "activation_started", {
-    forceRefresh: result.forceRefresh,
-    dryRun: Boolean(options.dryRun),
-    target: options.target || "claude",
-  }, 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 backward-compat activation.json so cco-status / cco-dashboard still work
-  if (!options.dryRun) {
-    try {
-      const { buildActivationState, writeActivationState } = require("./activation-state");
-      const compatStatus = result.ready ? "first_value_ready" : (result.status === "blocked_hard" ? "blocked" : result.status);
-      writeActivationState(cwd, buildActivationState({
-        status: compatStatus,
-        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: "node bin/avorelo activate", reason: "Activation incomplete.", blocking: false },
-        firstValue: { available: result.ready, summary: null },
-      }));
-    } catch {
-      // backward-compat write is best-effort; do not fail activation
-    }
-  }
-  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 detected", "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,
-};