avorelo 0.1.0

package/scripts/lib/pricing-experiment.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { safeReadJson, safeWriteJson, nowIso } = require("./fsx");
+
+const EXPERIMENT_REL = ".claude/cco/pricing/experiment.json";
+const METER_REL = ".claude/cco/pricing/meter.jsonl";
+
+function defaultExperiment() {
+  return {
+    version: 1,
+    enabled: true,
+    selectedModel: "pending",
+    cohorts: {
+      seat_plus_outcome: 0.5,
+      outcome_forward: 0.5,
+    },
+    createdAt: nowIso(),
+  };
+}
+
+function hashFloat(seed) {
+  const h = crypto.createHash("sha256").update(String(seed)).digest("hex");
+  const n = parseInt(h.slice(0, 8), 16);
+  return (n % 10000) / 10000;
+}
+
+function assignCohort(projectId, experiment) {
+  const r = hashFloat(projectId || "unknown");
+  const p = Number(experiment?.cohorts?.seat_plus_outcome || 0.5);
+  return r < p ? "seat_plus_outcome" : "outcome_forward";
+}
+
+function loadPricingExperiment(cwd) {
+  return safeReadJson(cwd, EXPERIMENT_REL, defaultExperiment());
+}
+
+function ensurePricingExperiment(cwd, projectId) {
+  const exp = loadPricingExperiment(cwd);
+  const cohort = assignCohort(projectId, exp);
+  const out = { ...exp, projectId, cohort };
+  safeWriteJson(cwd, EXPERIMENT_REL, out);
+  return out;
+}
+
+function buildPricingMeter(params) {
+  const outcomeAggregation = params?.outcomeAggregation || null;
+  const weekly = params?.weekly || {};
+  const config = params?.config || {};
+  const cohort = params?.cohort || "seat_plus_outcome";
+  const savings = weekly.savingsFirstSummary || {};
+
+  const seatUsage = Number(weekly.sessions || 0) > 0 ? 1 : 0;
+  const activeProjects = 1;
+  const outcomeDelta = {
+    minutesSavedEstimate: Number(savings.estimatedMinutesSaved || 0),
+    riskEventsPrevented: Number(weekly.riskyIntercepts || 0),
+    contextPressureReduction: Number(savings.outputsTrimmed || weekly.largeOutputsStored || 0),
+  };
+
+  const intelInfluencedRecommendations = Array.isArray(weekly.recommendationTraces)
+    ? weekly.recommendationTraces.filter((x) => String(x.recommendationId || x.id || "").startsWith("intel-")).length
+    : 0;
+
+  const acceptedIntelRecommendations = Number(weekly.intelAccepted || 0);
+
+  let billableUnits = seatUsage;
+  if (cohort === "outcome_forward") {
+    billableUnits = Math.max(0, outcomeDelta.minutesSavedEstimate) + Math.max(0, outcomeDelta.riskEventsPrevented * 2);
+  }
+
+  const billingConfidence =
+    Number(weekly.sessions || 0) >= 10 ? "high" : Number(weekly.sessions || 0) >= 4 ? "medium" : "low";
+
+  const attributionCoverage = outcomeAggregation
+    ? Number(outcomeAggregation.weeklyRepoSummary?.events || 0)
+    : Number(weekly.sessions || 0);
+  const attributionQuality = attributionCoverage >= 25 ? "high" : attributionCoverage >= 10 ? "medium" : "low";
+
+  return {
+    version: 3,
+    ts: nowIso(),
+    cohort,
+    tier: config.tier || "free",
+    seatUsage,
+    activeProjects,
+    outcomeDelta,
+    billableUnits,
+    billingConfidence,
+    auditRefs: [
+      ".claude/cco/metrics/metrics.jsonl",
+      ".claude/cco/reports/",
+    ],
+    intelInfluencedRecommendations,
+    acceptedIntelRecommendations,
+    attributionQuality,
+    attributionCoverage,
+  };
+}
+
+function appendPricingMeter(cwd, meter) {
+  const abs = path.join(cwd, METER_REL);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.appendFileSync(abs, JSON.stringify(meter) + "\n", "utf8");
+}
+
+module.exports = {
+  EXPERIMENT_REL,
+  METER_REL,
+  defaultExperiment,
+  loadPricingExperiment,
+  ensurePricingExperiment,
+  assignCohort,
+  buildPricingMeter,
+  appendPricingMeter,
+};

package/scripts/lib/pro-moment-events.js

@@ -0,0 +1,77 @@
+"use strict";
+
+const { nowIso } = require("./fsx");
+const { appendProductLearningEvent } = require("./product-learning-events");
+
+const PRO_MOMENT_EVENT_CATEGORIES = Object.freeze({
+  pro_moment_candidate_detected: "pro_moments",
+  pro_moment_eligible: "pro_moments",
+  pro_moment_suppressed: "pro_moments",
+  pro_nudge_shown: "pro_moments",
+  pro_nudge_clicked: "pro_moments",
+  pro_nudge_dismissed: "pro_moments",
+  pro_nudge_cooldown_started: "pro_moments",
+  pro_feature_requested: "pro_moments",
+  pro_limit_reached: "pro_moments",
+  upgrade_page_viewed: "pro_moments",
+  checkout_started: "pro_moments",
+  checkout_abandoned: "pro_moments",
+  upgrade_completed: "pro_moments",
+  pro_nudge_not_now_clicked: "annoyance_trust",
+  pro_nudge_dont_show_again_clicked: "annoyance_trust",
+  pro_nudge_multiple_dismissals: "annoyance_trust",
+  pro_nudge_hidden_due_to_cooldown: "annoyance_trust",
+  disable_avorelo_started: "annoyance_trust",
+  feedback_negative_submitted: "annoyance_trust",
+});
+
+function stringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => String(item || "").trim())
+    .filter(Boolean)
+    .slice(0, 12);
+}
+
+function finiteNumber(value, fallback = 0) {
+  return Number.isFinite(Number(value)) ? Number(value) : fallback;
+}
+
+function buildProMomentEventPayload(payload = {}) {
+  return {
+    momentId: payload.momentId ? String(payload.momentId) : null,
+    surface: payload.surface ? String(payload.surface) : null,
+    displayLevel: payload.displayLevel ? String(payload.displayLevel) : null,
+    reasonCodes: stringArray(payload.reasonCodes),
+    blockedReasonCodes: stringArray(payload.blockedReasonCodes),
+    plan: payload.plan ? String(payload.plan) : "free",
+    sessionCount: finiteNumber(payload.sessionCount),
+    valueEventsCount: finiteNumber(payload.valueEventsCount),
+    dismissCount: finiteNumber(payload.dismissCount),
+    cooldownActive: Boolean(payload.cooldownActive),
+    nextEligibleAt: payload.nextEligibleAt ? String(payload.nextEligibleAt) : null,
+    timestamp: payload.timestamp ? String(payload.timestamp) : nowIso(),
+  };
+}
+
+function appendProMomentEvent(cwd, eventName, payload = {}) {
+  const category = PRO_MOMENT_EVENT_CATEGORIES[eventName];
+  if (!category) {
+    return {
+      ok: false,
+      errors: [`Unknown Pro moment event: ${eventName}`],
+      event: null,
+    };
+  }
+  return appendProductLearningEvent(cwd, {
+    eventName,
+    category,
+    payload: buildProMomentEventPayload(payload),
+  });
+}
+
+module.exports = {
+  PRO_MOMENT_EVENT_CATEGORIES,
+  appendProMomentEvent,
+  buildProMomentEventPayload,
+};

package/scripts/lib/pro-moment-state.js

@@ -0,0 +1,227 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const { ensureCcoDirs, safeWriteJson } = require("./fsx");
+
+const PRO_MOMENT_STATE_REL = ".claude/cco/state/pro-moments.json";
+const RECENTLY_SHOWN_SUPPRESSION_HOURS = 12;
+
+function buildDefaultMomentStateEntry() {
+  return {
+    lastShownAt: null,
+    dismissCount: 0,
+    suppressedUntil: null,
+    shownCount: 0,
+    clickedCount: 0,
+    lastDismissedAt: null,
+    lastClickedAt: null,
+  };
+}
+
+function buildDefaultProMomentState() {
+  return {
+    version: 1,
+    global: {
+      lastShownAt: null,
+      dismissCount: 0,
+      suppressedUntil: null,
+      strongModalCount: 0,
+    },
+    moments: {},
+  };
+}
+
+function isIsoDateString(value) {
+  if (typeof value !== "string" || !value.trim()) return false;
+  return Number.isFinite(Date.parse(value));
+}
+
+function normalizeGlobalState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return {
+    lastShownAt: isIsoDateString(value.lastShownAt) ? value.lastShownAt : null,
+    dismissCount: Number.isFinite(Number(value.dismissCount)) ? Math.max(0, Number(value.dismissCount)) : 0,
+    suppressedUntil: isIsoDateString(value.suppressedUntil) ? value.suppressedUntil : null,
+    strongModalCount: Number.isFinite(Number(value.strongModalCount))
+      ? Math.max(0, Number(value.strongModalCount))
+      : 0,
+  };
+}
+
+function normalizeMomentStateEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return buildDefaultMomentStateEntry();
+  const base = buildDefaultMomentStateEntry();
+  return {
+    ...base,
+    lastShownAt: isIsoDateString(value.lastShownAt) ? value.lastShownAt : null,
+    dismissCount: Number.isFinite(Number(value.dismissCount)) ? Math.max(0, Number(value.dismissCount)) : 0,
+    suppressedUntil: isIsoDateString(value.suppressedUntil) ? value.suppressedUntil : null,
+    shownCount: Number.isFinite(Number(value.shownCount)) ? Math.max(0, Number(value.shownCount)) : 0,
+    clickedCount: Number.isFinite(Number(value.clickedCount)) ? Math.max(0, Number(value.clickedCount)) : 0,
+    lastDismissedAt: isIsoDateString(value.lastDismissedAt) ? value.lastDismissedAt : null,
+    lastClickedAt: isIsoDateString(value.lastClickedAt) ? value.lastClickedAt : null,
+  };
+}
+
+function normalizeProMomentState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const global = normalizeGlobalState(value.global);
+  if (!global) return null;
+
+  const rawMoments =
+    value.moments && typeof value.moments === "object" && !Array.isArray(value.moments)
+      ? value.moments
+      : {};
+  const moments = Object.fromEntries(
+    Object.entries(rawMoments).map(([momentId, momentState]) => [
+      String(momentId),
+      normalizeMomentStateEntry(momentState),
+    ]),
+  );
+
+  return {
+    version: 1,
+    global,
+    moments,
+  };
+}
+
+function getStatePath(cwd) {
+  return path.join(cwd, PRO_MOMENT_STATE_REL);
+}
+
+function readProMomentState(cwd) {
+  const filePath = getStatePath(cwd);
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const normalized = normalizeProMomentState(parsed);
+    if (!normalized) {
+      return {
+        state: buildDefaultProMomentState(),
+        integrity: "invalid",
+        warning: "Pro moment state was invalid and has been ignored.",
+        path: PRO_MOMENT_STATE_REL,
+      };
+    }
+    return {
+      state: normalized,
+      integrity: "valid",
+      warning: null,
+      path: PRO_MOMENT_STATE_REL,
+    };
+  } catch (error) {
+    const exists = fs.existsSync(filePath);
+    if (exists) {
+      return {
+        state: buildDefaultProMomentState(),
+        integrity: "invalid",
+        warning: "Pro moment state could not be parsed and has been ignored.",
+        path: PRO_MOMENT_STATE_REL,
+      };
+    }
+    return {
+      state: buildDefaultProMomentState(),
+      integrity: "missing",
+      warning: null,
+      path: PRO_MOMENT_STATE_REL,
+    };
+  }
+}
+
+function writeProMomentState(cwd, state) {
+  ensureCcoDirs(cwd);
+  const normalized = normalizeProMomentState(state) || buildDefaultProMomentState();
+  safeWriteJson(cwd, PRO_MOMENT_STATE_REL, normalized);
+  return {
+    ok: true,
+    path: PRO_MOMENT_STATE_REL,
+    state: normalized,
+  };
+}
+
+function getMomentStateEntry(state, momentId) {
+  const source = state && typeof state === "object" ? state : buildDefaultProMomentState();
+  return normalizeMomentStateEntry(source.moments?.[momentId]);
+}
+
+function getProMomentState(cwd) {
+  return readProMomentState(cwd).state;
+}
+
+function updateProMomentState(cwd, patch) {
+  const readResult = readProMomentState(cwd);
+  const current = readResult.state;
+  const next =
+    typeof patch === "function"
+      ? patch(current)
+      : {
+          ...current,
+          ...(patch || {}),
+          global: {
+            ...current.global,
+            ...((patch && patch.global) || {}),
+          },
+          moments: {
+            ...current.moments,
+            ...((patch && patch.moments) || {}),
+          },
+        };
+  return writeProMomentState(cwd, next);
+}
+
+function futureTimestamp(value, nowMs) {
+  const ts = Date.parse(value || "");
+  return Number.isFinite(ts) && ts > nowMs ? ts : null;
+}
+
+function getSuppressionState(state, momentId, options = {}) {
+  const source = state && typeof state === "object" ? state : buildDefaultProMomentState();
+  const proactive = options.proactive !== false;
+  const respectRecentShown = options.respectRecentShown !== false;
+  const nowMs = Date.parse(options.now || new Date().toISOString());
+  const momentState = getMomentStateEntry(source, momentId);
+  const globalUntil = futureTimestamp(source.global?.suppressedUntil, nowMs);
+  const momentUntil = futureTimestamp(momentState.suppressedUntil, nowMs);
+  const lastShownCandidates = [source.global?.lastShownAt, momentState.lastShownAt]
+    .map((value) => Date.parse(value || ""))
+    .filter((value) => Number.isFinite(value));
+  const lastShownAtMs = lastShownCandidates.length ? Math.max(...lastShownCandidates) : null;
+  const recentlyShownUntil =
+    lastShownAtMs !== null
+      ? lastShownAtMs + RECENTLY_SHOWN_SUPPRESSION_HOURS * 60 * 60 * 1000
+      : null;
+  const recentShownActive =
+    respectRecentShown &&
+    Number.isFinite(recentlyShownUntil) &&
+    recentlyShownUntil > nowMs;
+
+  return {
+    global: source.global,
+    momentState,
+    globalCooldownActive: proactive && Boolean(globalUntil),
+    momentCooldownActive: proactive && Boolean(momentUntil),
+    recentlyShownActive: recentShownActive,
+    globalSuppressedUntil: globalUntil ? new Date(globalUntil).toISOString() : null,
+    momentSuppressedUntil: momentUntil ? new Date(momentUntil).toISOString() : null,
+    recentlyShownUntil:
+      recentShownActive && Number.isFinite(recentlyShownUntil)
+        ? new Date(recentlyShownUntil).toISOString()
+        : null,
+  };
+}
+
+module.exports = {
+  PRO_MOMENT_STATE_REL,
+  RECENTLY_SHOWN_SUPPRESSION_HOURS,
+  buildDefaultMomentStateEntry,
+  buildDefaultProMomentState,
+  getMomentStateEntry,
+  getProMomentState,
+  getSuppressionState,
+  readProMomentState,
+  updateProMomentState,
+  writeProMomentState,
+};