chainlesschain 0.162.148 → 0.162.150

package/src/lib/stress-tester.js

@@ -95,6 +95,71 @@ export function ensureStressTables(db) {
   `);
 }
 
+/**
+ * Rehydrate _runs/_results from the persisted stress_test_runs/
+ * stress_test_results tables. The `cc` CLI runs every command in a fresh
+ * process, so without this the Maps start empty and a run recorded in a prior
+ * invocation is invisible (`cc stress list` shows "No stress tests recorded.";
+ * `cc stress show <id>` throws "Stress test not found"). Call after
+ * ensureStressTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _runs.clear();
+  _results.clear();
+
+  const resultRows = db.prepare(`SELECT * FROM stress_test_results`).all();
+  for (const row of resultRows) {
+    let bottlenecks = [];
+    let capacityRecommendations = [];
+    try {
+      bottlenecks = row.bottlenecks ? JSON.parse(row.bottlenecks) : [];
+    } catch {
+      bottlenecks = [];
+    }
+    try {
+      capacityRecommendations = row.capacity_recommendations
+        ? JSON.parse(row.capacity_recommendations)
+        : [];
+    } catch {
+      capacityRecommendations = [];
+    }
+    _results.set(row.test_id, {
+      resultId: row.result_id,
+      testId: row.test_id,
+      tps: row.tps,
+      avgResponseTime: row.avg_response_time,
+      p50ResponseTime: row.p50_response_time,
+      p95ResponseTime: row.p95_response_time,
+      p99ResponseTime: row.p99_response_time,
+      errorRate: row.error_rate,
+      bottlenecks,
+      capacityRecommendations,
+      createdAt: row.created_at,
+    });
+  }
+
+  const runRows = db.prepare(`SELECT * FROM stress_test_runs`).all();
+  for (const row of runRows) {
+    _runs.set(row.test_id, {
+      testId: row.test_id,
+      loadLevel: row.load_level,
+      concurrency: row.concurrency,
+      requestsPerSecond: row.requests_per_second,
+      duration: row.duration,
+      status: row.status,
+      startedAt: row.started_at,
+      completedAt: row.completed_at ?? null,
+      // _seq is a per-process monotonic tiebreaker; started_at is the primary
+      // sort key. Reassign in load order — ties (same ms) are the only case it
+      // affects and are cosmetic for history ordering.
+      _seq: ++_seq,
+    });
+  }
+
+  return _runs.size + _results.size;
+}
+
 /* ── Synthetic metrics ─────────────────────────────────────── */
 
 // Deterministic quasi-random: stable across runs for the same inputs. Tests

package/src/lib/tech-learning-engine.js

@@ -169,6 +169,81 @@ export function ensureTechLearningTables(db) {
   );
 }
 
+/**
+ * Rehydrate _profiles/_practices from the persisted tech_stack_profiles/
+ * learned_practices tables. The `cc` CLI runs every command in a fresh process,
+ * so without this the Maps start empty and a profile/practice recorded in a
+ * prior invocation is invisible (`cc tech profile` returns null, `cc tech
+ * practices` shows nothing, `cc tech recommend` can't infer the latest stack).
+ * Call after ensureTechLearningTables(db). The profile's frameworks/databases/
+ * tools/libraries are not stored as columns — they are reconstructed from the
+ * classified tech_stack exactly as analyzeTechStack derives them.
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _profiles.clear();
+  _practices.clear();
+
+  const profileRows = db.prepare(`SELECT * FROM tech_stack_profiles`).all();
+  for (const row of profileRows) {
+    let classified = [];
+    let deps = [];
+    let languages = [];
+    try {
+      classified = row.tech_stack ? JSON.parse(row.tech_stack) : [];
+    } catch {
+      classified = [];
+    }
+    try {
+      deps = row.dependencies ? JSON.parse(row.dependencies) : [];
+    } catch {
+      deps = [];
+    }
+    try {
+      languages = row.languages ? JSON.parse(row.languages) : [];
+    } catch {
+      languages = [];
+    }
+    const byType = (t) =>
+      classified.filter((d) => d.type === t).map((d) => d.name);
+    _profiles.set(row.project_path, {
+      profileId: row.profile_id,
+      projectPath: row.project_path,
+      languages,
+      frameworks: byType(TECH_TYPES.FRAMEWORK),
+      databases: byType(TECH_TYPES.DATABASE),
+      tools: byType(TECH_TYPES.TOOL),
+      libraries: byType(TECH_TYPES.LIBRARY),
+      totalDependencies: deps.length,
+      analysisTimestamp: row.analysis_timestamp,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  const practiceRows = db.prepare(`SELECT * FROM learned_practices`).all();
+  for (const row of practiceRows) {
+    _practices.set(row.practice_id, {
+      practiceId: row.practice_id,
+      techType: row.tech_type,
+      techName: row.tech_name,
+      patternName: row.pattern_name,
+      level: row.level,
+      description: row.description ?? "",
+      codeExample: row.code_example ?? "",
+      usageCount: row.usage_count ?? 0,
+      score: row.score ?? 0,
+      source: row.source,
+      learnedAt: row.learned_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  return _profiles.size + _practices.size;
+}
+
 /* ── Parsers for dependency manifests ──────────────────────── */
 
 function _readIfExists(filePath) {

package/src/lib/telemetry/span-recorder.js

@@ -0,0 +1,237 @@
+/**
+ * TelemetryRecorder (Phase 7) — a dependency-free, OpenTelemetry-SHAPED span +
+ * metrics recorder for the agent's real execution (model calls, tool calls,
+ * cache, retries, failures). The plan asks to "引入 OpenTelemetry，覆盖模型、
+ * 工具、缓存、重试和失败分类" — but pulling the `@opentelemetry/*` SDK in (a
+ * heavy dep tree that also needs a running collector) is the wrong default for a
+ * ~2 MB CLI. This records the SAME span/attribute model and can emit OTLP JSON
+ * (`toOtlp()`) so a real collector can ingest it later, without the dependency.
+ *
+ * It captures the plan's metric set — per-name durations (avg/p50/p95/max),
+ * counters (token / cost / cache-hit / retry), and failure classification — and
+ * `summary()` renders them. The clock is injected so tests are deterministic.
+ */
+
+let _seq = 0;
+function spanId() {
+  _seq = (_seq + 1) % Number.MAX_SAFE_INTEGER;
+  // 16-hex-ish id derived from a monotonic counter (deterministic, no RNG —
+  // Math.random is intentionally avoided so callers can snapshot/replay).
+  return _seq.toString(16).padStart(16, "0");
+}
+
+export class TelemetryRecorder {
+  constructor({
+    now = () => Date.now(),
+    serviceName = "chainlesschain-cli",
+  } = {}) {
+    this._now = typeof now === "function" ? now : () => now;
+    this.serviceName = serviceName;
+    this._spans = []; // completed spans
+    this._counters = new Map(); // name → { total, byAttr }
+    this._failures = new Map(); // category → count
+  }
+
+  /**
+   * Start a span. Returns a handle; call `.end()` (optionally with a status /
+   * extra attributes) to record it. Nesting is expressed via `parentId`.
+   */
+  startSpan(name, attributes = {}, { parentId = null } = {}) {
+    const id = spanId();
+    const start = this._now();
+    const attrs = { ...attributes };
+    const events = [];
+    const self = this;
+    let ended = false;
+    return {
+      id,
+      name,
+      setAttribute(k, v) {
+        attrs[k] = v;
+        return this;
+      },
+      addEvent(evName, evAttrs = {}) {
+        events.push({
+          name: evName,
+          time: self._now(),
+          attributes: { ...evAttrs },
+        });
+        return this;
+      },
+      /**
+       * Record a failure on this span, classified into a category (defaults to
+       * the error name) so `summary().failures` aggregates by cause.
+       */
+      recordException(err, category) {
+        const cat = category || err?.code || err?.name || "error";
+        attrs["failure.category"] = cat;
+        attrs["error"] = true;
+        events.push({
+          name: "exception",
+          time: self._now(),
+          attributes: {
+            "exception.message": err?.message || String(err),
+            "exception.category": cat,
+          },
+        });
+        self._failures.set(cat, (self._failures.get(cat) || 0) + 1);
+        return this;
+      },
+      end(extra = {}) {
+        if (ended) return; // idempotent
+        ended = true;
+        const endTime = self._now();
+        Object.assign(attrs, extra.attributes || {});
+        const status = extra.status || (attrs.error ? "error" : "ok");
+        self._spans.push({
+          id,
+          parentId,
+          name,
+          startTime: start,
+          endTime,
+          durationMs: endTime - start,
+          status,
+          attributes: attrs,
+          events,
+        });
+      },
+    };
+  }
+
+  /** Increment a named counter (tokens, cost, cache.hit, retry, …). */
+  counter(name, value = 1, attributes = {}) {
+    const entry = this._counters.get(name) || { total: 0, byAttr: {} };
+    entry.total += value;
+    for (const [k, v] of Object.entries(attributes)) {
+      const key = `${k}=${v}`;
+      entry.byAttr[key] = (entry.byAttr[key] || 0) + value;
+    }
+    this._counters.set(name, entry);
+    return entry.total;
+  }
+
+  _percentile(sorted, p) {
+    if (sorted.length === 0) return 0;
+    // nearest-rank
+    const rank = Math.ceil((p / 100) * sorted.length);
+    return sorted[Math.min(rank, sorted.length) - 1];
+  }
+
+  /** Aggregate metrics across everything recorded so far. */
+  summary() {
+    const byName = {};
+    for (const s of this._spans) {
+      (byName[s.name] = byName[s.name] || []).push(s);
+    }
+    const durations = {};
+    for (const [name, spans] of Object.entries(byName)) {
+      const ds = spans.map((s) => s.durationMs).sort((a, b) => a - b);
+      const total = ds.reduce((a, b) => a + b, 0);
+      const errors = spans.filter((s) => s.status === "error").length;
+      durations[name] = {
+        count: spans.length,
+        errors,
+        totalMs: total,
+        avgMs: Math.round(total / spans.length),
+        p50Ms: this._percentile(ds, 50),
+        p95Ms: this._percentile(ds, 95),
+        maxMs: ds[ds.length - 1] || 0,
+      };
+    }
+    const counters = {};
+    for (const [name, entry] of this._counters) {
+      counters[name] = { total: entry.total, byAttr: { ...entry.byAttr } };
+    }
+    const failures = {};
+    let failureTotal = 0;
+    for (const [cat, n] of this._failures) {
+      failures[cat] = n;
+      failureTotal += n;
+    }
+    return {
+      spanCount: this._spans.length,
+      durations,
+      counters,
+      failures,
+      failureTotal,
+    };
+  }
+
+  /** OTLP/JSON-shaped export (resourceSpans) — ingestible by an OTel collector. */
+  toOtlp() {
+    return {
+      resourceSpans: [
+        {
+          resource: {
+            attributes: [
+              { key: "service.name", value: { stringValue: this.serviceName } },
+            ],
+          },
+          scopeSpans: [
+            {
+              scope: { name: "chainlesschain.cli" },
+              spans: this._spans.map((s) => ({
+                traceId: "0".repeat(32),
+                spanId: s.id,
+                parentSpanId: s.parentId || "",
+                name: s.name,
+                startTimeUnixNano: s.startTime * 1e6,
+                endTimeUnixNano: s.endTime * 1e6,
+                status: { code: s.status === "error" ? 2 : 1 },
+                attributes: Object.entries(s.attributes).map(([k, v]) => ({
+                  key: k,
+                  value:
+                    typeof v === "number"
+                      ? { doubleValue: v }
+                      : typeof v === "boolean"
+                        ? { boolValue: v }
+                        : { stringValue: String(v) },
+                })),
+                events: s.events.map((e) => ({
+                  name: e.name,
+                  timeUnixNano: e.time * 1e6,
+                  attributes: Object.entries(e.attributes).map(([k, v]) => ({
+                    key: k,
+                    value: { stringValue: String(v) },
+                  })),
+                })),
+              })),
+            },
+          ],
+        },
+      ],
+    };
+  }
+
+  spans() {
+    return this._spans.slice();
+  }
+
+  reset() {
+    this._spans = [];
+    this._counters = new Map();
+    this._failures = new Map();
+  }
+}
+
+/** Render a summary as a compact text block. */
+export function formatTelemetry(summary) {
+  const lines = [];
+  lines.push(`Telemetry: ${summary.spanCount} span(s)`);
+  for (const [name, d] of Object.entries(summary.durations)) {
+    lines.push(
+      `  ${name}: n=${d.count}${d.errors ? ` err=${d.errors}` : ""} ` +
+        `avg=${d.avgMs}ms p50=${d.p50Ms}ms p95=${d.p95Ms}ms max=${d.maxMs}ms`,
+    );
+  }
+  for (const [name, c] of Object.entries(summary.counters)) {
+    lines.push(`  ${name}: ${c.total}`);
+  }
+  if (summary.failureTotal > 0) {
+    const parts = Object.entries(summary.failures)
+      .map(([cat, n]) => `${cat}=${n}`)
+      .join(", ");
+    lines.push(`  failures: ${summary.failureTotal} (${parts})`);
+  }
+  return lines.join("\n");
+}

package/src/lib/tenant-saas.js

@@ -830,6 +830,113 @@ export function _resetState() {
   _seq = 0;
 }
 
+/**
+ * Rehydrate the in-memory Maps from the persisted saas_* tables. The CLI runs
+ * every subcommand in a fresh node process, so these module-level Maps start
+ * empty each invocation. Every write dual-writes (Map + INSERT OR REPLACE) but
+ * every read (getTenant/listTenants/getUsage/getActiveSubscription/
+ * listSubscriptions/getSaasStats) is Map-only, and nothing SELECTed the tables
+ * back — so a tenant created in one invocation was invisible in the next
+ * (`No tenants.` / `Tenant not found`), and every follow-up subscribe/record/
+ * check-quota/configure/delete threw "Tenant not found". Call after
+ * ensureTenantTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureTenantTables(db);
+  _tenants.clear();
+  _subscriptions.clear();
+  _usage.clear();
+  _slugIndex.clear();
+  _tenantSubs.clear();
+  _tenantUsage.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, slug, config, status, plan, db_path, owner_id,
+              created_at, updated_at, deleted_at
+         FROM saas_tenants ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt config cell must not sink the whole tenant list.
+    let config = null;
+    try {
+      config = r.config ? JSON.parse(r.config) : null;
+    } catch {
+      config = null;
+    }
+    _tenants.set(r.id, {
+      id: r.id,
+      name: r.name,
+      slug: r.slug,
+      config,
+      status: r.status,
+      plan: r.plan,
+      dbPath: r.db_path || null,
+      ownerId: r.owner_id || null,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      deletedAt: r.deleted_at == null ? null : Number(r.deleted_at),
+      _seq: ++_seq,
+    });
+    if (r.slug) _slugIndex.set(r.slug, r.id);
+    _tenantSubs.set(r.id, new Set());
+    _tenantUsage.set(r.id, new Set());
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, tenant_id, metric, value, period, recorded_at
+         FROM saas_usage ORDER BY recorded_at ASC`,
+    )
+    .all()) {
+    _usage.set(r.id, {
+      id: r.id,
+      tenantId: r.tenant_id,
+      metric: r.metric,
+      value: Number(r.value),
+      period: r.period,
+      recordedAt: Number(r.recorded_at),
+      _seq: ++_seq,
+    });
+    if (!_tenantUsage.has(r.tenant_id))
+      _tenantUsage.set(r.tenant_id, new Set());
+    _tenantUsage.get(r.tenant_id).add(r.id);
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, tenant_id, plan, status, started_at, expires_at, cancelled_at,
+              payment_method, amount, created_at
+         FROM saas_subscriptions ORDER BY created_at ASC`,
+    )
+    .all()) {
+    let paymentMethod = null;
+    try {
+      paymentMethod = r.payment_method ? JSON.parse(r.payment_method) : null;
+    } catch {
+      paymentMethod = null;
+    }
+    _subscriptions.set(r.id, {
+      id: r.id,
+      tenantId: r.tenant_id,
+      plan: r.plan,
+      status: r.status,
+      startedAt: Number(r.started_at),
+      expiresAt: r.expires_at == null ? null : Number(r.expires_at),
+      cancelledAt: r.cancelled_at == null ? null : Number(r.cancelled_at),
+      paymentMethod,
+      amount: r.amount == null ? null : Number(r.amount),
+      createdAt: Number(r.created_at),
+      _seq: ++_seq,
+    });
+    if (!_tenantSubs.has(r.tenant_id)) _tenantSubs.set(r.tenant_id, new Set());
+    _tenantSubs.get(r.tenant_id).add(r.id);
+  }
+
+  return _tenants.size + _usage.size + _subscriptions.size;
+}
+
 /* ═══════════════════════════════════════════════════════════════
  * Phase 97 V2 — Tenant Maturity + Subscription Lifecycle
  * Strictly additive. Legacy surface above is preserved.

package/src/lib/terraform-manager.js

@@ -65,6 +65,73 @@ export function ensureTerraformTables(db) {
   `);
 }
 
+/**
+ * Rehydrate _workspaces/_runs from the persisted terraform_workspaces/
+ * terraform_runs tables. The `cc` CLI runs every command in a fresh process, so
+ * without this the Maps start empty and a workspace/run created in a prior
+ * invocation is invisible (`cc terraform workspaces`/`runs` show nothing;
+ * `cc terraform plan <id>` throws "Workspace not found" for a persisted
+ * workspace). Call after ensureTerraformTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _workspaces.clear();
+  _runs.clear();
+
+  const wsRows = db.prepare(`SELECT * FROM terraform_workspaces`).all();
+  for (const row of wsRows) {
+    let variables = {};
+    let providers = [];
+    try {
+      variables = row.variables ? JSON.parse(row.variables) : {};
+    } catch {
+      variables = {};
+    }
+    try {
+      providers = row.providers ? JSON.parse(row.providers) : [];
+    } catch {
+      providers = [];
+    }
+    _workspaces.set(row.id, {
+      id: row.id,
+      name: row.name,
+      description: row.description ?? "",
+      terraformVersion: row.terraform_version,
+      workingDirectory: row.working_directory,
+      autoApply: !!row.auto_apply,
+      status: row.status,
+      lastRunId: row.last_run_id ?? null,
+      lastRunAt: row.last_run_at ?? null,
+      stateVersion: row.state_version ?? 0,
+      variables,
+      providers,
+      createdAt: row.created_at ?? null,
+    });
+  }
+
+  const runRows = db.prepare(`SELECT * FROM terraform_runs`).all();
+  for (const row of runRows) {
+    _runs.set(row.id, {
+      id: row.id,
+      workspaceId: row.workspace_id,
+      runType: row.run_type,
+      status: row.status,
+      planOutput: row.plan_output ?? null,
+      applyOutput: row.apply_output ?? null,
+      resourcesAdded: row.resources_added ?? 0,
+      resourcesChanged: row.resources_changed ?? 0,
+      resourcesDestroyed: row.resources_destroyed ?? 0,
+      triggeredBy: row.triggered_by ?? null,
+      startedAt: row.started_at ?? null,
+      completedAt: row.completed_at ?? null,
+      errorMessage: row.error_message ?? null,
+      createdAt: row.created_at ?? null,
+    });
+  }
+
+  return _workspaces.size + _runs.size;
+}
+
 /* ── Workspace Management ─────────────────────────────────── */
 
 export function listWorkspaces(filter = {}) {