avorelo 0.1.0

package/scripts/lib/activation/activation-self-healing.js

@@ -0,0 +1,480 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { ensureCcoDirs, nowIso } = require("../fsx");
+
+// Avorelo runtime artifact patterns to keep out of git
+const GITIGNORE_PATTERNS = Object.freeze([
+  ".claude/cco/orchestration/",
+  ".claude/cco/security/",
+  ".claude/cco/events/",
+  ".claude/cco/memory/",
+  ".claude/cco/metrics/",
+  ".claude/cco/reports/",
+  ".claude/cco/context/",
+  ".claude/cco/state/activation.json",
+  ".claude/cco/state/onboarding.json",
+  ".claude/cco/state/context-pack.json",
+  ".claude/cco/state/reentry-carry-forward.json",
+]);
+
+const GITIGNORE_BLOCK_HEADER = "# Avorelo runtime artifacts";
+const GITIGNORE_BLOCK_FOOTER = "# end Avorelo runtime artifacts";
+
+// Readiness keys and their descriptions
+const READINESS_CHECKS = Object.freeze([
+  { id: "workspace_detected",          label: "Workspace connected",         required: true },
+  { id: "runtime_dirs",                label: "Runtime directories",          required: true },
+  { id: "local_config",                label: "Local config",                 required: true },
+  { id: "gitignore_ready",             label: "Runtime artifacts ignored",    required: false },
+  { id: "workspace_registry",          label: "Workspace registry",           required: true },
+  { id: "brain_pack",                  label: "Brain pack",                   required: true },
+  { id: "session_context",             label: "Session context ready",        required: true },
+  { id: "operating_value",             label: "Value tracking baseline",      required: true },
+  { id: "dashboard_preview",           label: "Dashboard ready",              required: false },
+  { id: "proof_summary",               label: "Proof summary",                required: false },
+  { id: "security_baseline",           label: "Security checks ready",        required: false },
+  { id: "model_routing",               label: "Routing detected",             required: false },
+]);
+
+function safeExists(cwd, relPath) {
+  try {
+    return fs.existsSync(path.join(cwd, relPath));
+  } catch {
+    return false;
+  }
+}
+
+// --- .gitignore management ---
+
+function readGitignore(cwd) {
+  const abs = path.join(cwd, ".gitignore");
+  try {
+    return fs.existsSync(abs) ? fs.readFileSync(abs, "utf8") : "";
+  } catch {
+    return "";
+  }
+}
+
+function hasGitignoreBlock(content) {
+  return content.includes(GITIGNORE_BLOCK_HEADER);
+}
+
+function buildGitignoreBlock() {
+  return [
+    GITIGNORE_BLOCK_HEADER,
+    ...GITIGNORE_PATTERNS,
+    GITIGNORE_BLOCK_FOOTER,
+    "",
+  ].join("\n");
+}
+
+function ensureGitignorePatterns(cwd, options = {}) {
+  if (options.dryRun) {
+    const current = readGitignore(cwd);
+    if (!hasGitignoreBlock(current)) {
+      return { applied: true, dryRun: true, action: "would_append_block" };
+    }
+    return { applied: false, dryRun: true, action: "already_present" };
+  }
+
+  const abs = path.join(cwd, ".gitignore");
+  let current = readGitignore(cwd);
+
+  if (hasGitignoreBlock(current)) {
+    return { applied: false, action: "already_present" };
+  }
+
+  const block = buildGitignoreBlock();
+  const separator = current && !current.endsWith("\n") ? "\n" : "";
+  const updated = current + separator + "\n" + block;
+
+  try {
+    fs.writeFileSync(abs, updated, "utf8");
+    return { applied: true, action: "appended_block" };
+  } catch (err) {
+    return { applied: false, action: "write_failed", error: err.message };
+  }
+}
+
+// --- Corrupted state detection and repair ---
+
+function detectCorruptedJson(cwd, relPath) {
+  const abs = path.join(cwd, relPath);
+  if (!fs.existsSync(abs)) return { exists: false, corrupted: false };
+  try {
+    const raw = fs.readFileSync(abs, "utf8");
+    JSON.parse(raw);
+    return { exists: true, corrupted: false };
+  } catch {
+    return { exists: true, corrupted: true };
+  }
+}
+
+function moveCorruptedAside(cwd, relPath) {
+  const abs = path.join(cwd, relPath);
+  const backupAbs = abs + ".corrupted-" + Date.now();
+  try {
+    fs.renameSync(abs, backupAbs);
+    return { moved: true, backup: backupAbs };
+  } catch (err) {
+    try {
+      fs.unlinkSync(abs);
+      return { moved: true, deleted: true };
+    } catch {
+      return { moved: false, error: err.message };
+    }
+  }
+}
+
+// --- Readiness surface generation ---
+
+function generateWorkspaceRegistry(cwd, options = {}) {
+  if (options.dryRun) return { planned: true };
+  try {
+    const { buildWorkspaceRegistry, writeWorkspaceRegistry } = require("../workspace-registry");
+    const registry = buildWorkspaceRegistry(cwd);
+    writeWorkspaceRegistry(cwd, registry);
+    return { generated: true, id: registry.registryId || "unknown" };
+  } catch (err) {
+    return { generated: false, error: err.message };
+  }
+}
+
+function generateBrainPack(cwd, options = {}) {
+  if (options.dryRun) return { planned: true };
+  try {
+    const { buildBrainPack, writeBrainPack } = require("../brain-pack");
+    const bp = buildBrainPack(cwd);
+    writeBrainPack(cwd, bp);
+    return { generated: true };
+  } catch (err) {
+    return { generated: false, error: err.message };
+  }
+}
+
+function generateSessionContext(cwd, options = {}) {
+  if (options.dryRun) return { planned: true };
+  try {
+    const { buildSessionContext, writeSessionContext } = require("../session-context-optimizer");
+    const ctx = buildSessionContext(cwd, { target: options.target || "claude" });
+    writeSessionContext(cwd, ctx);
+    return { generated: true };
+  } catch (err) {
+    return { generated: false, error: err.message };
+  }
+}
+
+function generateOperatingValueBaseline(cwd, options = {}) {
+  if (options.dryRun) return { planned: true };
+  try {
+    const { buildOperatingValue, writeOperatingValue } = require("../operating-value");
+    const value = buildOperatingValue(cwd);
+    writeOperatingValue(cwd, value);
+    // Explicitly: do NOT surface any time/token savings in activation
+    return {
+      generated: true,
+      dashboardPath: value.dashboardReady && value.dashboardReady.localDashboardPath
+        ? value.dashboardReady.localDashboardPath
+        : null,
+      valueClaimsShown: false,
+    };
+  } catch (err) {
+    return { generated: false, error: err.message, valueClaimsShown: false };
+  }
+}
+
+// --- Readiness verification ---
+
+function checkReadiness(cwd, context) {
+  const checks = {};
+
+  // workspace_detected
+  checks.workspace_detected = Boolean(cwd && cwd.length > 0 && fs.existsSync(cwd));
+
+  // runtime_dirs
+  checks.runtime_dirs = (
+    safeExists(cwd, ".claude/cco/state") &&
+    safeExists(cwd, ".claude/cco/orchestration") &&
+    safeExists(cwd, ".claude/cco/config.json")
+  );
+
+  // local_config
+  checks.local_config = safeExists(cwd, ".claude/cco/config.json");
+
+  // gitignore_ready
+  const gitignoreContent = readGitignore(cwd);
+  checks.gitignore_ready = hasGitignoreBlock(gitignoreContent);
+
+  // workspace_registry
+  checks.workspace_registry = safeExists(cwd, ".claude/cco/orchestration/workspace-registry/latest-registry.json");
+
+  // brain_pack
+  checks.brain_pack = safeExists(cwd, ".claude/cco/context/brain-pack/latest.json");
+
+  // session_context
+  checks.session_context = safeExists(cwd, ".claude/cco/orchestration/session-context/latest-context.json");
+
+  // operating_value
+  checks.operating_value = safeExists(cwd, ".claude/cco/orchestration/operating-value/latest-value.json");
+
+  // dashboard_preview (non-required, nice-to-have)
+  checks.dashboard_preview = safeExists(cwd, ".claude/cco/orchestration/operating-value/dashboard-preview.md");
+
+  // proof_summary
+  checks.proof_summary = (
+    safeExists(cwd, ".claude/cco/orchestration/current-proof.md") ||
+    safeExists(cwd, ".claude/cco/orchestration/current-proof.json")
+  );
+
+  // security_baseline (non-blocking — intake may not have run yet)
+  checks.security_baseline = safeExists(cwd, ".claude/cco/security");
+
+  // model_routing (from context, non-blocking)
+  checks.model_routing = Boolean(context && context.detectedModelRouting && context.detectedModelRouting.status);
+
+  // Required checks
+  const requiredChecks = READINESS_CHECKS.filter((c) => c.required).map((c) => c.id);
+  const failingRequired = requiredChecks.filter((id) => !checks[id]);
+  const ready = failingRequired.length === 0;
+
+  const hardBlockers = context && Array.isArray(context.hardBlockers) ? context.hardBlockers : [];
+
+  return {
+    checks,
+    ready: ready && hardBlockers.length === 0,
+    failingRequired,
+    hardBlockers,
+  };
+}
+
+// --- Planned repairs (dry-run) ---
+
+function planRepairs(cwd, readinessResult) {
+  const plans = [];
+
+  if (!readinessResult.checks.runtime_dirs || !readinessResult.checks.local_config) {
+    plans.push({
+      id: "ensure_runtime_dirs",
+      label: "Create Avorelo runtime directories",
+      safeToAutoFix: true,
+      domainOwned: true,
+    });
+  }
+
+  if (!readinessResult.checks.gitignore_ready) {
+    plans.push({
+      id: "ensure_gitignore",
+      label: "Add Avorelo patterns to .gitignore",
+      safeToAutoFix: true,
+      domainOwned: true,
+    });
+  }
+
+  if (!readinessResult.checks.workspace_registry) {
+    plans.push({
+      id: "generate_workspace_registry",
+      label: "Generate workspace registry",
+      safeToAutoFix: true,
+      domainOwned: true,
+    });
+  }
+
+  if (!readinessResult.checks.brain_pack) {
+    plans.push({
+      id: "generate_brain_pack",
+      label: "Initialize brain pack",
+      safeToAutoFix: true,
+      domainOwned: true,
+    });
+  }
+
+  if (!readinessResult.checks.session_context) {
+    plans.push({
+      id: "generate_session_context",
+      label: "Generate session context baseline",
+      safeToAutoFix: true,
+      domainOwned: true,
+    });
+  }
+
+  if (!readinessResult.checks.operating_value) {
+    plans.push({
+      id: "generate_operating_value",
+      label: "Generate value tracking baseline",
+      safeToAutoFix: true,
+      domainOwned: true,
+    });
+  }
+
+  return plans;
+}
+
+// --- Full self-healing repair pass ---
+
+function runSelfHealingPass(cwd, context, options = {}) {
+  const repairs = [];
+  const hardBlockers = [];
+  const refreshedSurfaces = [];
+  const refreshSkipped = [];
+  const refreshErrors = [];
+  const forceRefresh = Boolean(options.forceRefresh);
+
+  // 1. Ensure runtime dirs
+  if (!safeExists(cwd, ".claude/cco/state") || !safeExists(cwd, ".claude/cco/config.json")) {
+    if (options.dryRun) {
+      repairs.push({ id: "ensure_runtime_dirs", status: "planned", label: "Create Avorelo runtime directories" });
+    } else {
+      try {
+        ensureCcoDirs(cwd);
+        const { ensureProjectConfig } = require("../fsx");
+        ensureProjectConfig(cwd);
+        repairs.push({ id: "ensure_runtime_dirs", status: "applied", label: "Created Avorelo runtime directories" });
+      } catch (err) {
+        hardBlockers.push({
+          id: "runtime_dirs_failed",
+          message: `Cannot create local runtime directories: ${err.message}`,
+          requiresUser: true,
+        });
+      }
+    }
+  }
+
+  if (hardBlockers.length > 0) return { repairs, hardBlockers, refreshedSurfaces, refreshSkipped, refreshErrors };
+
+  // 2. Gitignore
+  const gitignoreResult = ensureGitignorePatterns(cwd, options);
+  if (gitignoreResult.applied) {
+    repairs.push({ id: "ensure_gitignore", status: options.dryRun ? "planned" : "applied", label: "Added Avorelo patterns to .gitignore" });
+  }
+
+  // 3. Workspace registry
+  const registryRel = ".claude/cco/orchestration/workspace-registry/latest-registry.json";
+  const registryState = detectCorruptedJson(cwd, registryRel);
+  if (registryState.corrupted) {
+    if (!options.dryRun) {
+      const moved = moveCorruptedAside(cwd, registryRel);
+      repairs.push({ id: "repair_corrupted_registry", status: moved.moved ? "applied" : "failed", label: "Moved corrupted registry aside for regeneration" });
+    } else {
+      repairs.push({ id: "repair_corrupted_registry", status: "planned", label: "Would move corrupted registry aside" });
+    }
+  }
+
+  if (forceRefresh && safeExists(cwd, registryRel) && !options.dryRun) {
+    // Force-refresh: regenerate even if present
+    const result = generateWorkspaceRegistry(cwd, options);
+    if (result.generated) {
+      repairs.push({ id: "force_refresh_workspace_registry", status: "applied", label: "Force-refreshed workspace registry", detail: result });
+      refreshedSurfaces.push("workspace_registry");
+    } else {
+      refreshErrors.push({ surface: "workspace_registry", error: result.error || "unknown" });
+    }
+  } else if (!safeExists(cwd, registryRel)) {
+    const result = generateWorkspaceRegistry(cwd, options);
+    repairs.push({ id: "generate_workspace_registry", status: result.planned ? "planned" : (result.generated ? "applied" : "failed"), label: "Generated workspace registry", detail: result });
+  } else if (forceRefresh && options.dryRun) {
+    refreshSkipped.push({ surface: "workspace_registry", reason: "dry-run" });
+  }
+
+  // 4. Brain pack
+  const brainPackRel = ".claude/cco/context/brain-pack/latest.json";
+  const brainPackState = detectCorruptedJson(cwd, brainPackRel);
+  if (brainPackState.corrupted) {
+    if (!options.dryRun) moveCorruptedAside(cwd, brainPackRel);
+    repairs.push({ id: "repair_corrupted_brain_pack", status: options.dryRun ? "planned" : "applied", label: "Moved corrupted brain pack aside" });
+  }
+
+  if (forceRefresh && safeExists(cwd, brainPackRel) && !options.dryRun) {
+    const result = generateBrainPack(cwd, options);
+    if (result.generated) {
+      repairs.push({ id: "force_refresh_brain_pack", status: "applied", label: "Force-refreshed brain pack", detail: result });
+      refreshedSurfaces.push("brain_pack");
+    } else {
+      refreshErrors.push({ surface: "brain_pack", error: result.error || "unknown" });
+    }
+  } else if (!safeExists(cwd, brainPackRel)) {
+    const result = generateBrainPack(cwd, options);
+    repairs.push({ id: "generate_brain_pack", status: result.planned ? "planned" : (result.generated ? "applied" : "failed"), label: "Initialized brain pack", detail: result });
+  } else if (forceRefresh && options.dryRun) {
+    refreshSkipped.push({ surface: "brain_pack", reason: "dry-run" });
+  }
+
+  // 5. Session context
+  const sessionContextRel = ".claude/cco/orchestration/session-context/latest-context.json";
+  const scState = detectCorruptedJson(cwd, sessionContextRel);
+  if (scState.corrupted) {
+    if (!options.dryRun) moveCorruptedAside(cwd, sessionContextRel);
+    repairs.push({ id: "repair_corrupted_session_context", status: options.dryRun ? "planned" : "applied", label: "Moved corrupted session context aside" });
+  }
+
+  if (forceRefresh && safeExists(cwd, sessionContextRel) && !options.dryRun) {
+    const result = generateSessionContext(cwd, { ...options, target: context.target });
+    if (result.generated) {
+      repairs.push({ id: "force_refresh_session_context", status: "applied", label: "Force-refreshed session context", detail: result });
+      refreshedSurfaces.push("session_context");
+    } else {
+      refreshErrors.push({ surface: "session_context", error: result.error || "unknown" });
+    }
+  } else if (!safeExists(cwd, sessionContextRel)) {
+    const result = generateSessionContext(cwd, { ...options, target: context.target });
+    repairs.push({ id: "generate_session_context", status: result.planned ? "planned" : (result.generated ? "applied" : "failed"), label: "Generated session context baseline", detail: result });
+  } else if (forceRefresh && options.dryRun) {
+    refreshSkipped.push({ surface: "session_context", reason: "dry-run" });
+  }
+
+  // 6. Operating value baseline (readiness only, no savings claim)
+  const operatingValueRel = ".claude/cco/orchestration/operating-value/latest-value.json";
+  const ovState = detectCorruptedJson(cwd, operatingValueRel);
+  if (ovState.corrupted) {
+    if (!options.dryRun) moveCorruptedAside(cwd, operatingValueRel);
+    repairs.push({ id: "repair_corrupted_operating_value", status: options.dryRun ? "planned" : "applied", label: "Moved corrupted value baseline aside" });
+  }
+
+  if (forceRefresh && safeExists(cwd, operatingValueRel) && !options.dryRun) {
+    const result = generateOperatingValueBaseline(cwd, options);
+    if (result.generated) {
+      repairs.push({
+        id: "force_refresh_operating_value",
+        status: "applied",
+        label: "Force-refreshed value tracking baseline",
+        dashboardPath: result.dashboardPath || null,
+        valueClaimsShown: false,
+      });
+      refreshedSurfaces.push("operating_value");
+    } else {
+      refreshErrors.push({ surface: "operating_value", error: result.error || "unknown" });
+    }
+  } else if (!safeExists(cwd, operatingValueRel)) {
+    const result = generateOperatingValueBaseline(cwd, options);
+    repairs.push({
+      id: "generate_operating_value",
+      status: result.planned ? "planned" : (result.generated ? "applied" : "failed"),
+      label: "Generated value tracking baseline",
+      dashboardPath: result.dashboardPath || null,
+      valueClaimsShown: false,
+    });
+  } else if (forceRefresh && options.dryRun) {
+    refreshSkipped.push({ surface: "operating_value", reason: "dry-run" });
+  }
+
+  return { repairs, hardBlockers, refreshedSurfaces, refreshSkipped, refreshErrors };
+}
+
+module.exports = {
+  GITIGNORE_PATTERNS,
+  READINESS_CHECKS,
+  readGitignore,
+  hasGitignoreBlock,
+  buildGitignoreBlock,
+  ensureGitignorePatterns,
+  detectCorruptedJson,
+  moveCorruptedAside,
+  generateWorkspaceRegistry,
+  generateBrainPack,
+  generateSessionContext,
+  generateOperatingValueBaseline,
+  checkReadiness,
+  planRepairs,
+  runSelfHealingPass,
+};

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

@@ -0,0 +1,83 @@
+"use strict";
+
+const { safeReadJson, safeWriteJson, nowIso } = require("../fsx");
+
+const ACTIVATION_STATE_REL = ".claude/cco/state/activation.json";
+
+function defaultActivationState(cwd) {
+  return {
+    version: 1,
+    status: "not_started",
+    createdAt: nowIso(),
+    updatedAt: nowIso(),
+    project: {
+      cwd,
+      gitDetected: false,
+      repoRoot: null,
+      packageJsonDetected: false,
+    },
+    environment: {
+      platform: process.platform,
+      nodeDetected: Boolean(process.execPath),
+      npmDetected: false,
+      gitDetected: false,
+      internetLikelyAvailable: true,
+    },
+    account: {
+      connected: false,
+      plan: "free",
+      features: {},
+    },
+    detectedHosts: [],
+    enabledIntegrations: [],
+    repairsAttempted: [],
+    manualFixesRequired: [],
+    nextAction: {
+      label: "Check setup",
+      command: "npx avorelo@latest activate",
+      reason: "Activation has not run yet.",
+      blocking: false,
+    },
+    firstValue: {
+      available: false,
+      summary: null,
+    },
+  };
+}
+
+function readActivationState(cwd) {
+  return safeReadJson(cwd, ACTIVATION_STATE_REL, defaultActivationState(cwd));
+}
+
+function buildActivationState(input) {
+  const existing = input.existingState || defaultActivationState(input.project?.cwd || process.cwd());
+  const createdAt = existing.createdAt || nowIso();
+  return {
+    version: 1,
+    status: input.status || existing.status || "not_started",
+    createdAt,
+    updatedAt: nowIso(),
+    project: input.project || existing.project,
+    environment: input.environment || existing.environment,
+    account: input.account || existing.account,
+    detectedHosts: Array.isArray(input.detectedHosts) ? input.detectedHosts : existing.detectedHosts,
+    enabledIntegrations: Array.isArray(input.enabledIntegrations) ? input.enabledIntegrations : existing.enabledIntegrations,
+    repairsAttempted: Array.isArray(input.repairsAttempted) ? input.repairsAttempted : existing.repairsAttempted,
+    manualFixesRequired: Array.isArray(input.manualFixesRequired) ? input.manualFixesRequired : existing.manualFixesRequired,
+    nextAction: input.nextAction || existing.nextAction,
+    firstValue: input.firstValue || existing.firstValue,
+  };
+}
+
+function writeActivationState(cwd, state) {
+  safeWriteJson(cwd, ACTIVATION_STATE_REL, state);
+  return state;
+}
+
+module.exports = {
+  ACTIVATION_STATE_REL,
+  defaultActivationState,
+  readActivationState,
+  buildActivationState,
+  writeActivationState,
+};