chainlesschain 0.45.11 → 0.45.19

package/src/harness/compression-telemetry.js

@@ -0,0 +1,214 @@
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+} from "node:fs";
+import { join } from "node:path";
+import { getHomeDir } from "../lib/paths.js";
+import { createTelemetryRecord } from "../runtime/contracts/telemetry-record.js";
+
+function getMetricsDir() {
+  const dir = join(getHomeDir(), "metrics");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function telemetryPath() {
+  return join(getMetricsDir(), "compression.jsonl");
+}
+
+export function recordCompressionMetric(stats, meta = {}) {
+  if (!stats || typeof stats !== "object") return;
+
+  const record = createTelemetryRecord(
+    {
+      ...stats,
+      provider: meta.provider || null,
+      model: meta.model || null,
+      source: meta.source || null,
+    },
+    meta,
+  );
+
+  const event = {
+    timestamp: record.timestamp,
+    stats,
+    meta,
+    record,
+  };
+
+  try {
+    appendFileSync(telemetryPath(), JSON.stringify(event) + "\n", "utf-8");
+  } catch (_err) {
+    // Non-critical
+  }
+}
+
+export function getCompressionTelemetrySummary(options = {}) {
+  const filePath = telemetryPath();
+  const limit = options.limit || 500;
+  const windowMs = options.windowMs || null;
+  const provider = options.provider || null;
+  const model = options.model || null;
+  const now = Date.now();
+  if (!existsSync(filePath)) {
+    return emptyCompressionSummary();
+  }
+
+  const lines = readFileSync(filePath, "utf-8")
+    .split("\n")
+    .filter((line) => line.trim())
+    .slice(-limit);
+
+  const samples = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (!parsed?.stats) continue;
+      const record = parsed.record || null;
+      const recordTimestamp = record?.timestamp || parsed.timestamp || 0;
+      const recordProvider = record?.provider || parsed?.meta?.provider || null;
+      const recordModel = record?.model || parsed?.meta?.model || null;
+      if (windowMs && now - recordTimestamp > windowMs) continue;
+      if (provider && recordProvider !== provider) continue;
+      if (model && recordModel !== model) continue;
+      samples.push(parsed);
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  if (samples.length === 0) {
+    return emptyCompressionSummary();
+  }
+
+  const variantDistribution = {};
+  const strategyMap = new Map();
+  const providerMap = new Map();
+  const modelMap = new Map();
+  let totalSavedTokens = 0;
+  let totalOriginalTokens = 0;
+  let totalCompressedTokens = 0;
+  let compressedSamples = 0;
+
+  for (const sample of samples) {
+    const stats = sample.stats || {};
+    totalSavedTokens += stats.saved || 0;
+    totalOriginalTokens += stats.originalTokens || 0;
+    totalCompressedTokens += stats.compressedTokens || 0;
+    if ((stats.saved || 0) > 0 || stats.strategy !== "none") {
+      compressedSamples++;
+    }
+
+    const variant = stats.abVariant || "default";
+    variantDistribution[variant] = (variantDistribution[variant] || 0) + 1;
+
+    const strategies = String(stats.strategy || "none").split("+");
+    for (const strategy of strategies) {
+      const key = strategy || "none";
+      const current = strategyMap.get(key) || {
+        strategy: key,
+        hits: 0,
+        savedTokens: 0,
+      };
+      current.hits += 1;
+      current.savedTokens += stats.saved || 0;
+      strategyMap.set(key, current);
+    }
+
+    const providerKey = sample?.meta?.provider || "unknown";
+    const modelKey = sample?.meta?.model || "unknown";
+    accumulateSlice(providerMap, providerKey, stats);
+    accumulateSlice(modelMap, modelKey, stats);
+  }
+
+  const strategyDistribution = [...strategyMap.values()]
+    .map((entry) => ({
+      ...entry,
+      hitRate: samples.length > 0 ? entry.hits / samples.length : 0,
+    }))
+    .sort((a, b) => b.hits - a.hits);
+
+  return {
+    samples: samples.length,
+    compressedSamples,
+    hitRate: samples.length > 0 ? compressedSamples / samples.length : 0,
+    totalSavedTokens,
+    averageSavedTokens:
+      samples.length > 0 ? Math.round(totalSavedTokens / samples.length) : 0,
+    totalOriginalTokens,
+    totalCompressedTokens,
+    netSavingsRate:
+      totalOriginalTokens > 0
+        ? (totalOriginalTokens - totalCompressedTokens) / totalOriginalTokens
+        : 0,
+    filters: {
+      limit,
+      windowMs,
+      provider,
+      model,
+    },
+    variantDistribution,
+    strategyDistribution,
+    providerDistribution: finalizeSliceDistribution(providerMap, samples.length),
+    modelDistribution: finalizeSliceDistribution(modelMap, samples.length),
+  };
+}
+
+export function resetCompressionTelemetry() {
+  try {
+    rmSync(telemetryPath(), { force: true });
+  } catch (_err) {
+    // Non-critical
+  }
+}
+
+function emptyCompressionSummary() {
+  return {
+    samples: 0,
+    compressedSamples: 0,
+    hitRate: 0,
+    totalSavedTokens: 0,
+    averageSavedTokens: 0,
+    totalOriginalTokens: 0,
+    totalCompressedTokens: 0,
+    netSavingsRate: 0,
+    filters: {
+      limit: 500,
+      windowMs: null,
+      provider: null,
+      model: null,
+    },
+    variantDistribution: {},
+    strategyDistribution: [],
+    providerDistribution: [],
+    modelDistribution: [],
+  };
+}
+
+function accumulateSlice(map, key, stats) {
+  const current = map.get(key) || {
+    key,
+    samples: 0,
+    compressedSamples: 0,
+    savedTokens: 0,
+  };
+  current.samples += 1;
+  current.savedTokens += stats.saved || 0;
+  if ((stats.saved || 0) > 0 || stats.strategy !== "none") {
+    current.compressedSamples += 1;
+  }
+  map.set(key, current);
+}
+
+function finalizeSliceDistribution(map, totalSamples) {
+  return [...map.values()]
+    .map((entry) => ({
+      ...entry,
+      hitRate: entry.samples > 0 ? entry.compressedSamples / entry.samples : 0,
+      share: totalSamples > 0 ? entry.samples / totalSamples : 0,
+    }))
+    .sort((a, b) => b.samples - a.samples);
+}

package/src/harness/feature-flags.js

@@ -0,0 +1,157 @@
+/**
+ * Feature Flag System — runtime feature gating for gradual rollout.
+ *
+ * Flags are stored in .chainlesschain/config.json under "features" key.
+ * Each flag can be:
+ *   - boolean (true/false)
+ *   - number 0-100 (percentage rollout, hashed by machine-id)
+ *   - object { enabled, variant, description }
+ */
+
+import { loadConfig, getConfigValue, saveConfig } from "../lib/config-manager.js";
+import { createHash } from "node:crypto";
+import { hostname } from "node:os";
+
+const FLAG_REGISTRY = {
+  BACKGROUND_TASKS: {
+    description: "Enable background task queue with daemon execution",
+    default: false,
+  },
+  WORKTREE_ISOLATION: {
+    description: "Enable git worktree isolation for agent tasks",
+    default: false,
+  },
+  CONTEXT_SNIP: {
+    description: "Enable snipCompact strategy in context compression",
+    default: false,
+  },
+  CONTEXT_COLLAPSE: {
+    description: "Enable contextCollapse strategy in context compression",
+    default: false,
+  },
+  JSONL_SESSION: {
+    description: "Use JSONL append-only format for session persistence",
+    default: true,
+  },
+  PROMPT_COMPRESSOR: {
+    description: "Enable CLI prompt compressor (auto/snip/collapse)",
+    default: true,
+  },
+  COMPRESSION_AB: {
+    description:
+      "A/B test compression thresholds (variants: aggressive, balanced, relaxed)",
+    default: { enabled: false, variant: "balanced" },
+  },
+};
+
+export function feature(name) {
+  const value = _resolve(name);
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return _percentageCheck(name, value);
+  if (value && typeof value === "object") return Boolean(value.enabled);
+  const defaultValue = _getDefault(name);
+  if (typeof defaultValue === "boolean") return defaultValue;
+  if (typeof defaultValue === "number") return _percentageCheck(name, defaultValue);
+  if (defaultValue && typeof defaultValue === "object") {
+    return Boolean(defaultValue.enabled);
+  }
+  return false;
+}
+
+export function featureVariant(name) {
+  const value = _resolve(name);
+  if (value && typeof value === "object" && value.variant) {
+    return value.variant;
+  }
+  return null;
+}
+
+export function listFeatures() {
+  const config = loadConfig();
+  const features = config.features || {};
+  const result = [];
+
+  for (const [name, meta] of Object.entries(FLAG_REGISTRY)) {
+    const raw = features[name];
+    const enabled = feature(name);
+    const source =
+      raw !== undefined
+        ? "config"
+        : process.env[`CC_FLAG_${name}`] !== undefined
+          ? "env"
+          : "default";
+
+    result.push({
+      name,
+      enabled,
+      description: meta.description,
+      source,
+      raw: raw !== undefined ? raw : meta.default,
+    });
+  }
+
+  for (const [name, raw] of Object.entries(features)) {
+    if (!FLAG_REGISTRY[name]) {
+      result.push({
+        name,
+        enabled: Boolean(raw),
+        description: "(user-defined)",
+        source: "config",
+        raw,
+      });
+    }
+  }
+
+  return result;
+}
+
+export function setFeature(name, value) {
+  const config = loadConfig();
+  if (!config.features) config.features = {};
+  config.features[name] = value;
+  saveConfig(config);
+}
+
+export function getFlagInfo(name) {
+  return FLAG_REGISTRY[name] || null;
+}
+
+function _resolve(name) {
+  const envKey = `CC_FLAG_${name}`;
+  if (process.env[envKey] !== undefined) {
+    const envVal = process.env[envKey];
+    if (envVal === "true" || envVal === "1") return true;
+    if (envVal === "false" || envVal === "0") return false;
+    const num = Number(envVal);
+    if (!isNaN(num)) return num;
+    return envVal;
+  }
+
+  const configVal = getConfigValue(`features.${name}`);
+  if (configVal !== undefined) return configVal;
+
+  return undefined;
+}
+
+function _getDefault(name) {
+  const meta = FLAG_REGISTRY[name];
+  return meta ? meta.default : false;
+}
+
+function _percentageCheck(name, percentage) {
+  if (percentage <= 0) return false;
+  if (percentage >= 100) return true;
+  const hash = createHash("md5")
+    .update(`${name}:${_machineId()}`)
+    .digest("hex");
+  const bucket = parseInt(hash.slice(0, 8), 16) % 100;
+  return bucket < percentage;
+}
+
+let _cachedMachineId = null;
+function _machineId() {
+  if (!_cachedMachineId) {
+    _cachedMachineId = hostname() || "unknown";
+  }
+  return _cachedMachineId;
+}