avorelo 0.3.8 → 0.4.0-rc.2

package/scripts/cco-userprompt-submit.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const { readStdinJson, ensureCcoDirs, getEffectiveConfig } = require("./lib/fsx");
+const { normalizeHookInput, outAdditional } = require("./lib/hook-contracts");
+const { logMetric } = require("./lib/metrics");
+const { lintPrompt } = require("./lib/prompt-lint");
+const { routeTask } = require("./lib/orchestration");
+
+function isBypassPrompt(prompt) {
+  return typeof prompt === "string" && prompt.trimStart().startsWith("[cco:raw]");
+}
+
+function stripBypass(prompt) {
+  return prompt.replace(/^\s*\[cco:raw\]\s*/i, "");
+}
+
+async function main() {
+  const raw = await readStdinJson();
+  const input = normalizeHookInput(raw);
+  const cwd = input.cwd;
+  const sessionId = input.session_id;
+  const prompt = input.prompt;
+
+  ensureCcoDirs(cwd);
+
+  if (isBypassPrompt(prompt)) {
+    logMetric(cwd, { sessionId, event: "UserPromptSubmit", action: "bypass", reasonCodes: ["PROMPT_BYPASS"], meta: {} });
+    return process.stdout.write(JSON.stringify({}));
+  }
+
+  const { config } = getEffectiveConfig(cwd);
+  if (!config.promptLintEnabled) {
+    logMetric(cwd, { sessionId, event: "UserPromptSubmit", action: "disabled", reasonCodes: ["PROMPT_LINT_DISABLED"], meta: { profile: config.profile } });
+    return process.stdout.write(JSON.stringify({}));
+  }
+
+  const result = lintPrompt({ prompt: stripBypass(prompt), profile: config.profile });
+  let orchestrationContext = null;
+  if (config.orchestration?.enabled !== false && config.orchestration?.mode !== "disabled") {
+    try {
+      const routed = routeTask(cwd, stripBypass(prompt), {
+        surface: "claude_code",
+      });
+      orchestrationContext = [
+        `Avorelo route: ${routed.route.state} ${routed.taskContext.classification.risk}-risk ${routed.taskContext.classification.taskType} task.`,
+        `Preferred worker: ${routed.route.chosenTool || "none"} (${routed.route.chosenModelProfile || "unknown"}).`,
+        `Fallback: ${routed.route.fallbackTool || "none"} (${routed.route.fallbackModelProfile || "unknown"}).`,
+        `Verification: ${(routed.route.expectedVerification || []).join("; ") || "none"}.`,
+        "Current route and proof live under .claude/cco/orchestration/.",
+      ].join(" ");
+      logMetric(cwd, {
+        sessionId,
+        event: "UserPromptSubmit",
+        action: "routePrepared",
+        reasonCodes: ["SMART_ROUTE_CHEAPER_SAFER"],
+        meta: {
+          routeState: routed.route.state,
+          chosenTool: routed.route.chosenTool,
+          chosenModelProfile: routed.route.chosenModelProfile,
+          risk: routed.taskContext.classification.risk,
+          taskType: routed.taskContext.classification.taskType,
+        },
+      });
+    } catch {}
+  }
+
+  if (!result.shouldAddContext && !orchestrationContext) {
+    logMetric(cwd, { sessionId, event: "UserPromptSubmit", action: "noop", reasonCodes: [], meta: { profile: config.profile } });
+    return process.stdout.write(JSON.stringify({}));
+  }
+
+  const additionalContext = [result.additionalContext, orchestrationContext].filter(Boolean).join("\n\n");
+  logMetric(cwd, {
+    sessionId,
+    event: "UserPromptSubmit",
+    action: "injectAdditionalContext",
+    reasonCodes: result.reasonCodes,
+    meta: { profile: config.profile, orchestrationInjected: Boolean(orchestrationContext) },
+  });
+  process.stdout.write(JSON.stringify(outAdditional("UserPromptSubmit", additionalContext)));
+}
+
+main().catch(() => process.stdout.write(JSON.stringify({})));

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

@@ -0,0 +1,37 @@
+"use strict";
+
+const { safeReadJson } = require("../fsx");
+const { USER_STATE_FILE_REL } = require("./connect-account");
+
+const USER_STATE_REL = USER_STATE_FILE_REL;
+
+function defaultAccountState() {
+  return {
+    connected: false,
+    plan: "free",
+    localOnly: true,
+  };
+}
+
+function normalizePlan(plan) {
+  const normalized = String(plan || "").trim().toLowerCase();
+  if (normalized === "free" || normalized === "pro" || normalized === "team") return normalized;
+  return normalized ? "unknown" : "free";
+}
+
+function readAccountState(cwd) {
+  const data = safeReadJson(cwd, USER_STATE_REL, defaultAccountState());
+  const connected = data?.connected === true;
+  const localOnly = typeof data?.localOnly === "boolean" ? data.localOnly : connected !== true;
+  return {
+    connected,
+    plan: normalizePlan(data?.plan),
+    localOnly,
+  };
+}
+
+module.exports = {
+  USER_STATE_REL,
+  defaultAccountState,
+  readAccountState,
+};

package/scripts/lib/activation/activate-command.js

@@ -0,0 +1,114 @@
+"use strict";
+
+// ── Canonical activation command ──────────────────────────────────────────────
+//
+// This is the ONE path behind the default `avorelo activate`.
+// It composes:
+//   1. the real activation runner (runActivationV1) — performs safe local
+//      detection + self-healing repair, writes the canonical
+//      .claude/cco/state/activation.json that status/dashboard/doctor read, and
+//      emits the privacy-safe activation funnel events; and
+//   2. the compact alpha surface — a status/summary readout layered ON TOP of
+//      true activation (it no longer stands in for activation).
+//
+// Safety: default activation writes only local Avorelo state under .claude/cco.
+// It never applies hooks, changes app code, deploys, publishes, or touches
+// secrets. Deeper integrations (e.g. hooks) remain explicit, approval-gated.
+
+const { runActivationV1 } = require("./activation-runner");
+const { PUBLIC_ACTIVATE_COMMAND } = require("./activation-summary");
+const { ACTIVATION_STATE_REL } = require("./activation-state");
+
+function runCanonicalActivation(cwd, options = {}) {
+  const activation = runActivationV1(cwd, {
+    dryRun: false,
+    repair: true,
+    forceRefresh: Boolean(options.forceRefresh),
+    target: options.target || "claude",
+    env: options.env || process.env,
+  });
+
+  // Compact status/summary layer on top of true activation. Best-effort.
+  let surface = null;
+  try {
+    const { buildActivationSurface } = require("../alpha-activation");
+    surface = buildActivationSurface(cwd, { debug: Boolean(options.debug) });
+  } catch {}
+
+  return { activation, surface };
+}
+
+function statusLabel(activation) {
+  if (activation.ready && activation.alreadyActive) return "already active";
+  if (activation.ready) return "ready";
+  if (activation.status === "blocked_hard" || activation.status === "failed_internal") return "needs attention";
+  return activation.status || "unknown";
+}
+
+function formatCanonicalActivationText({ activation, surface }) {
+  const lines = [];
+  lines.push(`Avorelo activation: ${statusLabel(activation)}`);
+  lines.push("");
+
+  if (activation.ready) {
+    const labels = (activation.readiness && Array.isArray(activation.readiness.labels) && activation.readiness.labels.length)
+      ? activation.readiness.labels
+      : ["Workspace connected", "Routing classified", "Registry ready", "Session context ready", "Security checks ready", "Dashboard ready"];
+    lines.push("Activated:");
+    labels.forEach((l) => lines.push(`  + ${l}`));
+    lines.push("");
+
+    if (Array.isArray(activation.safeFixesApplied) && activation.safeFixesApplied.length) {
+      lines.push("Fixed automatically:");
+      activation.safeFixesApplied.forEach((f) => lines.push(`  + ${f}`));
+      lines.push("");
+    }
+
+    lines.push("First value:");
+    lines.push("  + Local Avorelo state and evidence created — no signup required.");
+    lines.push("  + Run `avorelo status` to see Time / Risk / Cost impact and next steps.");
+    lines.push("");
+
+    lines.push("Runtime protection:");
+    lines.push("  Lifecycle hooks are not installed by default.");
+    lines.push("  To enable runtime security and session tracking, run:");
+    lines.push("    avorelo hooks apply --yes");
+    lines.push("");
+
+    lines.push("Where to look:");
+    lines.push(`  State:     ${activation.canonicalStatePath || ACTIVATION_STATE_REL}`);
+    lines.push("  Open:      avorelo open");
+    lines.push("  Status:    avorelo status");
+    lines.push("");
+
+    lines.push("Everything runs locally. No account required.");
+    lines.push("");
+
+    lines.push("Next: avorelo status");
+  } else {
+    if (Array.isArray(activation.safeFixesApplied) && activation.safeFixesApplied.length) {
+      lines.push("Fixed automatically:");
+      activation.safeFixesApplied.forEach((f) => lines.push(`  + ${f}`));
+      lines.push("");
+    }
+    lines.push("Needs attention:");
+    const blockers = (Array.isArray(activation.hardBlockers) && activation.hardBlockers.length)
+      ? activation.hardBlockers
+      : [{ message: "Activation did not complete. Re-run to retry the safe self-healing pass." }];
+    blockers.forEach((b) => lines.push(`  x ${b.message || b.id}`));
+    lines.push("");
+    const firstBlocker = blockers[0] || {};
+    const next = (firstBlocker.requiresUser && firstBlocker.message)
+      ? firstBlocker.message
+      : `Re-run ${PUBLIC_ACTIVATE_COMMAND}`;
+    lines.push(`Next: ${next}`);
+  }
+
+  return lines.join("\n");
+}
+
+module.exports = {
+  runCanonicalActivation,
+  formatCanonicalActivationText,
+  statusLabel,
+};