avorelo 0.1.0

package/scripts/lib/activation/connect-account.js

@@ -0,0 +1,145 @@
+"use strict";
+
+const { safeWriteJson, nowIso } = require("../fsx");
+
+const USER_STATE_FILE_REL = ".claude/cco/state/account.json";
+
+function planFromToken(token) {
+  const normalized = String(token || "").trim().toLowerCase();
+  if (normalized.startsWith("team")) return "team";
+  if (normalized.startsWith("pro")) return "pro";
+  if (normalized.startsWith("free")) return "free";
+  return "free";
+}
+
+function claimActivationToken(token) {
+  if (!token) {
+    return {
+      ok: false,
+      reason: "missing_token",
+    };
+  }
+
+  const normalized = String(token).trim();
+  if (/expired/i.test(normalized)) {
+    return {
+      ok: false,
+      reason: "token_expired",
+      expired: true,
+    };
+  }
+
+  if (/invalid|fail|reject/i.test(normalized)) {
+    return {
+      ok: false,
+      reason: "token_rejected",
+    };
+  }
+
+  return {
+    ok: true,
+    claimedAt: nowIso(),
+    tokenHint: normalized.slice(0, 8),
+    plan: planFromToken(normalized),
+  };
+}
+
+function fetchAccountEntitlements(claimResult) {
+  const plan = claimResult?.plan || "free";
+  const featuresByPlan = {
+    free: {
+      localActivation: true,
+      contextBudgetGuard: true,
+      basicAgentSecurity: true,
+    },
+    pro: {
+      localActivation: true,
+      contextBudgetGuard: true,
+      basicAgentSecurity: true,
+      advancedRecommendations: true,
+      voiceAlpha: true,
+    },
+    team: {
+      localActivation: true,
+      contextBudgetGuard: true,
+      basicAgentSecurity: true,
+      advancedRecommendations: true,
+      voiceAlpha: true,
+      teamDefaults: true,
+      cloudSync: true,
+    },
+  };
+
+  return {
+    connected: true,
+    plan,
+    features: featuresByPlan[plan] || featuresByPlan.free,
+  };
+}
+
+function writeAccountState(cwd, accountState) {
+  safeWriteJson(cwd, USER_STATE_FILE_REL, {
+    version: 1,
+    updatedAt: nowIso(),
+    source: "activation-router-local-stub",
+    ...accountState,
+  });
+}
+
+function handleTokenExpired(token) {
+  return {
+    connected: false,
+    plan: "free",
+    features: {},
+    reason: "token_expired",
+    reconnectCommand: `npx avorelo@latest activate --connect ${token}`,
+  };
+}
+
+function connectAccount(cwd, options = {}) {
+  if (options.localOnly || options.noConnect) {
+    const account = {
+      connected: false,
+      plan: "free",
+      features: {},
+    };
+    writeAccountState(cwd, account);
+    return account;
+  }
+
+  const token = options.connectToken || null;
+  if (!token) {
+    const account = {
+      connected: false,
+      plan: "free",
+      features: {},
+    };
+    writeAccountState(cwd, account);
+    return account;
+  }
+
+  const claimResult = claimActivationToken(token);
+  if (!claimResult.ok) {
+    const expired = claimResult.expired ? handleTokenExpired(token) : {
+      connected: false,
+      plan: "free",
+      features: {},
+      reason: claimResult.reason || "token_rejected",
+    };
+    writeAccountState(cwd, expired);
+    return expired;
+  }
+
+  const account = fetchAccountEntitlements(claimResult);
+  writeAccountState(cwd, account);
+  return account;
+}
+
+module.exports = {
+  USER_STATE_FILE_REL,
+  claimActivationToken,
+  fetchAccountEntitlements,
+  writeAccountState,
+  handleTokenExpired,
+  connectAccount,
+};

package/scripts/lib/activation/detect-environment.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+function parseBoolean(value, fallback) {
+  if (value === undefined || value === null || value === "") return fallback;
+  if (typeof value === "boolean") return value;
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "n", "off"].includes(normalized)) return false;
+  return fallback;
+}
+
+function commandExists(command, env = process.env) {
+  if (!command) return false;
+  try {
+    if (process.platform === "win32") {
+      execSync(`where ${command}`, { stdio: "ignore", env });
+    } else {
+      execSync(`command -v ${command}`, { stdio: "ignore", env, shell: "/bin/sh" });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function findRepoRoot(cwd, env = process.env) {
+  try {
+    const out = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      env,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return out || null;
+  } catch {
+    const gitPath = path.join(cwd, ".git");
+    if (fs.existsSync(gitPath)) return path.resolve(cwd);
+    return null;
+  }
+}
+
+function detectProject(cwd, options = {}) {
+  const env = options.env || process.env;
+  const resolvedCwd = path.resolve(cwd);
+  const repoRoot = findRepoRoot(resolvedCwd, env);
+  return {
+    cwd: resolvedCwd,
+    gitDetected: Boolean(repoRoot),
+    repoRoot: repoRoot || null,
+    packageJsonDetected: fs.existsSync(path.join(resolvedCwd, "package.json")),
+  };
+}
+
+function detectEnvironment(cwd, options = {}) {
+  const env = options.env || process.env;
+  return {
+    platform: process.platform,
+    nodeDetected: Boolean(process.execPath) || commandExists("node", env),
+    npmDetected: commandExists("npm", env),
+    gitDetected: commandExists("git", env),
+    internetLikelyAvailable: parseBoolean(env.Avorelo_INTERNET_AVAILABLE, true),
+  };
+}
+
+module.exports = {
+  parseBoolean,
+  commandExists,
+  findRepoRoot,
+  detectProject,
+  detectEnvironment,
+};

package/scripts/lib/activation/detect-hosts.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const claudeCode = require("./adapters/claude-code");
+const vscode = require("./adapters/vscode");
+const cursor = require("./adapters/cursor");
+const windsurf = require("./adapters/windsurf");
+const codexCli = require("./adapters/codex-cli");
+const terminal = require("./adapters/terminal");
+const githubAgent = require("./adapters/github-agent");
+
+const ADAPTERS = [
+  claudeCode,
+  vscode,
+  cursor,
+  windsurf,
+  codexCli,
+  terminal,
+  githubAgent,
+];
+
+function safeCall(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+
+function detectHosts(cwd, options = {}) {
+  return ADAPTERS.map((adapter) => {
+    const detected = safeCall(() => Boolean(adapter.detect(cwd, options)), false);
+    const installState = safeCall(
+      () => String(adapter.getInstallState(cwd, options) || (detected ? "available" : "unknown")),
+      detected ? "available" : "unknown"
+    );
+    const limitations = safeCall(() => adapter.getLimitations(cwd, options) || [], []);
+    const recommendedActions = safeCall(() => adapter.getRecommendedActions(cwd, options) || [], []);
+    return {
+      id: adapter.id,
+      label: adapter.label,
+      depth: adapter.depth,
+      detected,
+      installState,
+      recommendedActions,
+      limitations,
+      canAutoConfigure: adapter.canAutoConfigure === true,
+      configureIfSafe: adapter.configureIfSafe,
+    };
+  });
+}
+
+function buildEnabledIntegrations(hosts) {
+  return hosts
+    .filter((host) => host.detected && ["configured", "active"].includes(host.installState))
+    .map((host) => host.id);
+}
+
+module.exports = {
+  ADAPTERS,
+  detectHosts,
+  buildEnabledIntegrations,
+};

package/scripts/lib/activation/format-activation-output.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const SUPPORT_CONTACT_LINE = "Need help? Contact support@avorelo.com.";
+
+function formatHostLine(host) {
+  return `OK ${host.label}`;
+}
+
+function buildFirstValueCard(statusDashboard) {
+  const fixes = Array.isArray(statusDashboard.topRecommendedFixes) ? statusDashboard.topRecommendedFixes : [];
+  const weekly = statusDashboard.weeklySummary || {};
+  const trust = statusDashboard.trustSummary || {};
+  const contextSignals = Number(weekly.largeOutputsStored || 0) + Number(weekly.compactPressureEvents || 0);
+  const trustSignals = Number(trust.unknownFiles || 0) + Number(trust.untrustedFiles || 0);
+  return [
+    `Found ${contextSignals} context-pressure signals, ${trustSignals} trust surfaces, and ${fixes.length} optimization opportunities.`,
+    `Next best action: ${statusDashboard.nextBestAction || "Continue working."}`,
+  ].join(" ");
+}
+
+function formatActivationText(report) {
+  const state = report.activation;
+  const detectedHosts = state.detectedHosts.filter((host) => host.detected);
+  const optionalHosts = state.detectedHosts.filter((host) => !host.detected);
+  const lines = [];
+  lines.push(state.status === "active" ? "Avorelo is active." : "Avorelo Activation");
+  lines.push("");
+  lines.push("Project:");
+  lines.push("OK Project detected");
+  lines.push(state.project.gitDetected ? "OK Git detected" : "-- Git repo not detected");
+  lines.push(state.project.packageJsonDetected ? "OK package.json detected" : "-- package.json not detected");
+  lines.push("");
+  lines.push("Avorelo detected your tools:");
+  detectedHosts.forEach((host) => {
+    lines.push(formatHostLine(host));
+  });
+  if (!detectedHosts.length) {
+    lines.push("-- No host-specific tools detected yet");
+  }
+
+  if (optionalHosts.length) {
+    lines.push("");
+    lines.push("Other tools not detected in this project yet (optional):");
+    optionalHosts.forEach((host) => {
+      lines.push(`- ${host.label}`);
+    });
+  }
+
+  lines.push("");
+  lines.push("Avorelo setup:");
+  lines.push("OK Local Avorelo state ready");
+  lines.push(state.firstValue.available ? "OK First value ready" : "-- First value not ready yet");
+  if (state.account.connected) {
+    lines.push(`OK Account connected (${state.account.plan} plan)`);
+  } else {
+    lines.push("OK Running in local/free mode");
+    lines.push("   Connect later to sync plan, billing, saved settings, and paid modes.");
+  }
+
+  if (state.repairsAttempted.length) {
+    lines.push("");
+    lines.push("Safe setup fixes applied:");
+    state.repairsAttempted.forEach((repair) => {
+      lines.push(`- ${repair.reason}`);
+    });
+  }
+
+  lines.push("");
+  lines.push("Next action:");
+  if (state.nextAction.command) {
+    lines.push(`${state.nextAction.label}:`);
+    lines.push(`  ${state.nextAction.command}`);
+  } else {
+    lines.push(state.nextAction.label);
+  }
+  lines.push(state.nextAction.reason);
+  if (state.status === "blocked" || state.nextAction.blocking) {
+    lines.push("");
+    lines.push(SUPPORT_CONTACT_LINE);
+  }
+
+  if (state.firstValue.available && report.firstValueCard) {
+    lines.push("");
+    lines.push("First value:");
+    lines.push(report.firstValueCard.summary);
+  }
+
+  if (report.workspaceRegistration?.ok) {
+    lines.push("");
+    lines.push("Workspace registered for global use:");
+    lines.push(report.workspaceRegistration.workspace);
+    lines.push('For global use, run "npm link" once, then use "avorelo ..." from any terminal.');
+  } else if (report.workspaceRegistration?.message) {
+    lines.push("");
+    lines.push(`Workspace registration note: ${report.workspaceRegistration.message}`);
+  }
+
+  return lines.join("\n");
+}
+
+function formatActivationJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+
+module.exports = {
+  buildFirstValueCard,
+  formatActivationText,
+  formatActivationJson,
+};

package/scripts/lib/activation/next-action.js

@@ -0,0 +1,43 @@
+"use strict";
+
+function pickNextAction(context) {
+  const blockingFix = (context.manualFixesRequired || []).find((fix) => fix.blocking);
+  if (blockingFix) {
+    return {
+      label: blockingFix.label,
+      command: blockingFix.command || null,
+      reason: blockingFix.reason,
+      blocking: true,
+    };
+  }
+
+  const claudeHost = (context.detectedHosts || []).find((host) => host.id === "claude-code" && host.detected);
+  if (claudeHost && ["available", "configured", "unknown"].includes(claudeHost.installState)) {
+    return {
+      label: "Install the Claude Code plugin",
+      command: "/plugin install avorelo@avorelo-marketplace",
+      reason: "Claude Code was detected, but the plugin is not active there yet.",
+      blocking: false,
+    };
+  }
+
+  if (!context.firstValue || context.firstValue.available !== true) {
+    return {
+      label: "Check Avorelo status",
+      command: "avorelo status --text",
+      reason: "Generate the first compact Avorelo status card.",
+      blocking: false,
+    };
+  }
+
+  return {
+    label: "Continue working",
+    command: null,
+    reason: "Avorelo is active locally and will stay quiet unless it can help.",
+    blocking: false,
+  };
+}
+
+module.exports = {
+  pickNextAction,
+};

package/scripts/lib/activation/repair-engine.js

@@ -0,0 +1,219 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const {
+  ensureCcoDirs,
+  ensureProjectConfig,
+  safeReadJson,
+  safeWriteJson,
+  nowIso,
+} = require("../fsx");
+const { attemptAutoRecovery } = require("../upgrade-interruption-recovery");
+
+const CONTEXT_PACK_REL = ".claude/cco/state/context-pack.json";
+const ONBOARDING_REL = ".claude/cco/state/onboarding.json";
+
+function buildDefaultOnboardingState() {
+  return {
+    status: "completed",
+    createdAt: nowIso(),
+    completedAt: nowIso(),
+    stepsCompleted: ["activation"],
+    hasSeenDashboard: false,
+    hasSeenStatus: true,
+    hasCompletedSession: false,
+  };
+}
+
+function buildContextPack(cwd, context) {
+  return {
+    version: 1,
+    generatedAt: nowIso(),
+    project: {
+      cwd: context.project.cwd,
+      gitDetected: context.project.gitDetected,
+      repoRoot: context.project.repoRoot,
+      packageJsonDetected: context.project.packageJsonDetected,
+    },
+    commands: {
+      status: "avorelo status --text",
+      audit: "avorelo audit",
+      activate: "npx avorelo@latest activate",
+    },
+    hosts: (context.detectedHosts || [])
+      .filter((host) => host.detected)
+      .map((host) => ({
+        id: host.id,
+        label: host.label,
+        depth: host.depth,
+      })),
+  };
+}
+
+function localFilesReady(cwd) {
+  return (
+    fs.existsSync(path.join(cwd, ".claude", "cco", "config.json")) &&
+    fs.existsSync(path.join(cwd, ".claude", "cco", "state", "onboarding.json")) &&
+    fs.existsSync(path.join(cwd, ".claude", "cco", "state", "context-pack.json"))
+  );
+}
+
+function runRepairEngine(cwd, context, options = {}) {
+  const repairEnabled = options.repair !== false;
+  const repairsAttempted = [];
+  const manualFixesRequired = [];
+  const issues = [];
+  let localSetupReady = false;
+
+  if (!context.environment.nodeDetected) {
+    issues.push({ id: "node_missing", classification: "blocking", reason: "Node.js is required to run Avorelo." });
+    manualFixesRequired.push({
+      id: "install_node",
+      label: "Install Node.js",
+      command: "https://nodejs.org/",
+      reason: "Avorelo activation requires Node.js in PATH.",
+      blocking: true,
+    });
+  }
+
+  if (!context.environment.npmDetected) {
+    issues.push({ id: "npm_missing", classification: "blocking", reason: "npm is required for the activation entrypoint." });
+    manualFixesRequired.push({
+      id: "install_npm",
+      label: "Restore npm in PATH",
+      command: null,
+      reason: "Avorelo activation uses npm/npx for the primary install and verification path.",
+      blocking: true,
+    });
+  }
+
+  if (repairEnabled && manualFixesRequired.every((fix) => !fix.blocking)) {
+    try {
+      ensureCcoDirs(cwd);
+      repairsAttempted.push({
+        id: "ensure_cco_dirs",
+        status: "applied",
+        reason: "Prepared local Avorelo directories.",
+      });
+    } catch (error) {
+      manualFixesRequired.push({
+        id: "fix_local_write_access",
+        label: "Restore local write access",
+        command: null,
+        reason: `Avorelo could not create project-local state: ${error.message}`,
+        blocking: true,
+      });
+      issues.push({ id: "write_access", classification: "blocking", reason: error.message });
+    }
+  }
+
+  if (repairEnabled && manualFixesRequired.every((fix) => !fix.blocking)) {
+    ensureProjectConfig(cwd);
+    repairsAttempted.push({
+      id: "ensure_project_config",
+      status: "applied",
+      reason: "Normalized project-local Avorelo config.",
+    });
+
+    const originalConsoleError = console.error;
+    let recovery;
+    try {
+      console.error = () => {};
+      recovery = attemptAutoRecovery(cwd);
+    } finally {
+      console.error = originalConsoleError;
+    }
+    if (recovery.success) {
+      repairsAttempted.push({
+        id: "upgrade_marker_repair",
+        status: "applied",
+        reason: recovery.recoveryType,
+      });
+    }
+
+    if (!safeReadJson(cwd, ONBOARDING_REL, null)) {
+      safeWriteJson(cwd, ONBOARDING_REL, buildDefaultOnboardingState());
+      repairsAttempted.push({
+        id: "create_onboarding_state",
+        status: "applied",
+        reason: "Created onboarding state for activation.",
+      });
+    }
+  } else if (!repairEnabled && !safeReadJson(cwd, ONBOARDING_REL, null)) {
+    issues.push({ id: "missing_onboarding_state", classification: "recoverable", reason: "Onboarding state is missing." });
+    manualFixesRequired.push({
+      id: "run_activation_with_repair",
+      label: "Run activation with repair enabled",
+      command: "npx avorelo@latest activate --repair",
+      reason: "Avorelo can recreate missing local state automatically when repair is enabled.",
+      blocking: false,
+    });
+  }
+
+  if (repairEnabled && manualFixesRequired.every((fix) => !fix.blocking)) {
+    const contextPack = buildContextPack(cwd, context);
+    safeWriteJson(cwd, CONTEXT_PACK_REL, contextPack);
+    repairsAttempted.push({
+      id: "generate_context_pack",
+      status: "applied",
+      reason: "Generated a reusable local context pack.",
+    });
+  }
+
+  const hostConfiguration = [];
+  if (repairEnabled && Array.isArray(context.detectedHosts)) {
+    context.detectedHosts
+      .filter((host) => host.detected && host.canAutoConfigure && typeof host.configureIfSafe === "function")
+      .forEach((host) => {
+        try {
+          const result = host.configureIfSafe(cwd, { contextPackRel: CONTEXT_PACK_REL });
+          hostConfiguration.push({
+            id: host.id,
+            applied: result?.applied === true,
+            integrationId: result?.integrationId || null,
+          });
+          if (result?.applied) {
+            repairsAttempted.push({
+              id: `configure_${host.id}`,
+              status: "applied",
+              reason: `Prepared ${host.label} project-local artifacts.`,
+            });
+          }
+        } catch (error) {
+          issues.push({
+            id: `${host.id}_configure_failed`,
+            classification: "optional",
+            reason: error.message,
+          });
+        }
+      });
+  }
+
+  localSetupReady = manualFixesRequired.every((fix) => !fix.blocking) && localFilesReady(cwd);
+
+  if (!context.project.gitDetected) {
+    issues.push({
+      id: "git_repo_not_detected",
+      classification: "optional",
+      reason: "Git repo not detected. Avorelo still runs in local mode.",
+    });
+  }
+
+  return {
+    repairEnabled,
+    localSetupReady,
+    issues,
+    repairsAttempted,
+    manualFixesRequired,
+    hostConfiguration,
+    contextPackRel: CONTEXT_PACK_REL,
+  };
+}
+
+module.exports = {
+  CONTEXT_PACK_REL,
+  buildDefaultOnboardingState,
+  buildContextPack,
+  runRepairEngine,
+};