@orquentra/codebuddy 2.7.0 → 2.9.0

package/README.md

@@ -52,6 +52,15 @@ This opens a live local page showing:
 
 It updates as you work, and the traces never leave your machine.
 
+## Telemetry
+
+CodeBuddy sends anonymous usage counts (tool names, timings, success, version,
+OS, agent client) so we can see which features are used. Prompts, code, file
+paths and repository names are never sent, and nothing is sent until a notice
+has been shown once in your terminal. Opt out with `codebuddy telemetry disable`,
+`CODEBUDDY_TELEMETRY=0` or `DO_NOT_TRACK=1`; CI never sends. Details:
+[docs/telemetry.md](https://github.com/Orquentra-Inc/CodeBuddy/blob/main/docs/telemetry.md).
+
 ## Try it without a database
 
 ```bash
@@ -66,6 +75,7 @@ needs more detail. Inspect missing or truncated evidence before editing.
 ## Documentation
 
 - [Full guide and examples](https://github.com/Orquentra-Inc/CodeBuddy/blob/348bb7c/README.md)
+- [Telemetry and the admin panel](https://github.com/Orquentra-Inc/CodeBuddy/blob/main/docs/telemetry.md)
 - [Token budgets](https://github.com/Orquentra-Inc/CodeBuddy/blob/main/docs/token-budgets.md)
 - [Optional LLM setup](https://github.com/Orquentra-Inc/CodeBuddy/blob/main/docs/llm-byok.md)
 - [Source and issues](https://github.com/Orquentra-Inc/CodeBuddy)

package/dist/adapters-S4HHTWJW.js

@@ -0,0 +1,24 @@
+import {
+  AUTOMATION_MODES,
+  CLIENT_ADAPTERS,
+  CLIENT_IDS,
+  LIFECYCLE_EVENTS,
+  MODE_LABELS,
+  parseClient,
+  parseMode,
+  sharedRulesReaders,
+  supportedModes
+} from "./chunk-W7GAXL6C.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  AUTOMATION_MODES,
+  CLIENT_ADAPTERS,
+  CLIENT_IDS,
+  LIFECYCLE_EVENTS,
+  MODE_LABELS,
+  parseClient,
+  parseMode,
+  sharedRulesReaders,
+  supportedModes
+};
+//# sourceMappingURL=adapters-S4HHTWJW.js.map

package/dist/{chunk-EEUFU7KV.js → chunk-2WH2Q4TA.js}

@@ -1,6 +1,6 @@
 import {
   refreshZvecIndex
-} from "./chunk-MSUAVR3R.js";
+} from "./chunk-GXOML4UZ.js";
 import {
   PlanFileStore,
   PlanLifecycle,
@@ -13,33 +13,36 @@ import {
   llmMemoryOptions,
   readPolicyFile,
   resolveRiskPaths
-} from "./chunk-YJIA2MFL.js";
-import {
-  recordTrace
-} from "./chunk-TUR6YKEE.js";
+} from "./chunk-F4BJ3DXW.js";
 import {
   SessionCapsuleLedger,
   coveringTestCandidates,
   estimateTokens
 } from "./chunk-GKNYMNFM.js";
+import {
+  readTraces,
+  recordTrace
+} from "./chunk-YN7TEIUH.js";
 import {
   codeBuddyConfigSchema,
   createRuntime,
   listFactsPage
-} from "./chunk-AK2UAE32.js";
+} from "./chunk-QN76UJP7.js";
 import {
   MemoryFileStore,
   VERSION
-} from "./chunk-JUAFCLRB.js";
+} from "./chunk-SRA4MDVG.js";
 import {
-  buildArchitectureMap,
   generateGraphifyGraph,
+  loadProjectArchitectureMap
+} from "./chunk-TLWGZVPC.js";
+import {
+  buildArchitectureMap,
   indexRepository,
   loadFreshIndex,
-  loadProjectArchitectureMap,
   neighbours,
   queryMap
-} from "./chunk-5EDGAZQN.js";
+} from "./chunk-ITQO632W.js";
 import {
   redactPersisted
 } from "./chunk-AL6VBTNA.js";
@@ -167,11 +170,154 @@ function checksum(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 
+// src/telemetry/telemetry.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var TELEMETRY_URL = "https://tanmay-hp-linux-server.tail41864f.ts.net/v1/events";
+var FLUSH_INTERVAL_MS = 10 * 6e4;
+var MAX_EVENTS = 500;
+var SEND_TIMEOUT_MS = 3e3;
+var NAME = /^[A-Za-z][A-Za-z0-9_:.-]{0,63}$/;
+function telemetryStatePath(home = homedir()) {
+  return join(home, ".codebuddy", "telemetry.json");
+}
+async function readTelemetryState(home = homedir()) {
+  try {
+    const state = JSON.parse(await readFile(telemetryStatePath(home), "utf8"));
+    if (typeof state.installId === "string" && state.installId) return state;
+  } catch {
+  }
+  return writeTelemetryState({ installId: randomUUID() }, home);
+}
+async function writeTelemetryState(state, home = homedir()) {
+  const path = telemetryStatePath(home);
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(path, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+  return state;
+}
+function telemetryBlocked(state, env = process.env) {
+  if (env.CODEBUDDY_TELEMETRY === "0") return "CODEBUDDY_TELEMETRY=0";
+  if (env.DO_NOT_TRACK === "1" || env.DO_NOT_TRACK === "true") return "DO_NOT_TRACK";
+  if (env.CI) return "CI";
+  if (state.disabled) return "disabled with `codebuddy telemetry disable`";
+  if (!telemetryUrl(env)) return "no collector configured";
+  if (!state.noticeAt) return "first-run notice not shown yet";
+  return null;
+}
+function telemetryUrl(env = process.env) {
+  return env.CODEBUDDY_TELEMETRY_URL ?? TELEMETRY_URL;
+}
+var TELEMETRY_NOTICE = `CodeBuddy collects anonymous usage data (which tools run, how long they take,
+success/failure, version, OS, agent client) to improve the product.
+Prompts, code, file paths and repository names are never sent.
+Opt out any time: \`codebuddy telemetry disable\` or CODEBUDDY_TELEMETRY=0.
+Details: https://github.com/Orquentra-Inc/CodeBuddy/blob/main/docs/telemetry.md`;
+async function showTelemetryNoticeOnce(write = (text) => process.stderr.write(text), options = {}) {
+  const env = options.env ?? process.env;
+  if (!(options.tty ?? process.stderr.isTTY)) return;
+  try {
+    const state = await readTelemetryState(options.home);
+    if (state.noticeAt || state.disabled || env.CODEBUDDY_TELEMETRY === "0" || env.CI) return;
+    if (!telemetryUrl(env)) return;
+    write(`
+${TELEMETRY_NOTICE}
+
+`);
+    await writeTelemetryState({ ...state, noticeAt: (/* @__PURE__ */ new Date()).toISOString() }, options.home);
+  } catch {
+  }
+}
+function anonymize(installId, value) {
+  return createHash2("sha256").update(`${installId}\0${value}`).digest("hex").slice(0, 16);
+}
+function toTelemetryEvents(installId, traces) {
+  return traces.map((trace) => ({
+    ts: trace.ts,
+    kind: NAME.test(trace.kind) ? trace.kind : "other",
+    name: NAME.test(trace.name) ? trace.name : "other",
+    ms: Math.max(0, Math.round(trace.ms) || 0),
+    ok: trace.ok === true,
+    ...typeof trace.tokensIn === "number" ? { tokensIn: trace.tokensIn } : {},
+    ...typeof trace.tokensOut === "number" ? { tokensOut: trace.tokensOut } : {},
+    ...trace.session ? { session: anonymize(installId, trace.session) } : {}
+  }));
+}
+async function flushTelemetry(repositoryRoot, options = {}) {
+  const env = options.env ?? process.env;
+  const now = options.now ?? Date.now();
+  try {
+    const state = await readTelemetryState(options.home);
+    if (telemetryBlocked(state, env)) return 0;
+    const cursorPath = join(repositoryRoot, ".codebuddy", "cache", "telemetry.json");
+    const cursor = await readFile(cursorPath, "utf8").then((raw) => JSON.parse(raw)).catch(() => ({}));
+    if (cursor.flushedAt && now - cursor.flushedAt < FLUSH_INTERVAL_MS) return 0;
+    const save = (next) => mkdir(dirname(cursorPath), { recursive: true }).then(
+      () => writeFile(cursorPath, JSON.stringify(next))
+    );
+    await save({ ...cursor, flushedAt: now });
+    const pending = (await readTraces(repositoryRoot, 1e4)).filter((trace) => !cursor.sentTs || trace.ts > cursor.sentTs).slice(-MAX_EVENTS);
+    const last = pending.at(-1);
+    if (!last) return 0;
+    const batch = {
+      installId: state.installId,
+      project: anonymize(state.installId, repositoryRoot),
+      version: VERSION,
+      platform: process.platform,
+      arch: process.arch,
+      node: process.versions.node.split(".")[0] ?? "",
+      clients: await (options.clients ?? (() => installedClients(repositoryRoot)))().catch(
+        () => []
+      ),
+      events: toTelemetryEvents(state.installId, pending)
+    };
+    const response = await (options.fetchImpl ?? fetch)(telemetryUrl(env), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(batch),
+      signal: AbortSignal.timeout(SEND_TIMEOUT_MS)
+    });
+    if (!response.ok) return 0;
+    await save({ sentTs: last.ts, flushedAt: now });
+    return batch.events.length;
+  } catch {
+    return 0;
+  }
+}
+async function traceCliCommand(command, started, root = process.cwd()) {
+  if (/^\[(hook|admin)\]/.test(command.description()) || command.name() === "serve") return;
+  if (!existsSync(join(root, ".codebuddy"))) return;
+  const path = [];
+  for (let current = command; current?.parent; current = current.parent) {
+    path.unshift(current.name());
+  }
+  await recordTrace(root, {
+    kind: "cli",
+    name: path.join(".") || "use",
+    ms: Date.now() - started,
+    ok: !process.exitCode
+  });
+  await flushTelemetry(root);
+}
+async function installedClients(repositoryRoot) {
+  const { CLIENT_IDS } = await import("./adapters-S4HHTWJW.js");
+  const { detectClient } = await import("./install-BXM56QCD.js");
+  const found = [];
+  for (const id of CLIENT_IDS) {
+    const status = await detectClient(id, repositoryRoot).catch(() => null);
+    if (status && (status.hooks || status.mcp)) found.push(id);
+  }
+  return found;
+}
+
 // src/mcp/tools/index.ts
 import { z } from "zod";
 
 // src/context/delivery.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var DELIVERY_VERSION = 1;
 var OMITTABLE_SECTIONS = [
   "plan",
@@ -190,7 +336,7 @@ async function applySessionDelivery(repositoryRoot, payload, options) {
   if (!options.sessionId) return output;
   const sections = OMITTABLE_SECTIONS.filter((key) => output[key] !== void 0).map((key) => ({
     key: `mcp:${key}`,
-    hash: createHash2("sha256").update(JSON.stringify(output[key])).digest("hex")
+    hash: createHash3("sha256").update(JSON.stringify(output[key])).digest("hex")
   }));
   try {
     await new SessionCapsuleLedger(repositoryRoot).exchange(options.sessionId, sections, {
@@ -217,7 +363,7 @@ async function applySessionDelivery(repositoryRoot, payload, options) {
         output = enforceContextBudget(output);
         return OMITTABLE_SECTIONS.filter((key) => output[key] !== void 0).map((key) => ({
           key: `mcp:${key}`,
-          hash: createHash2("sha256").update(JSON.stringify(output[key])).digest("hex")
+          hash: createHash3("sha256").update(JSON.stringify(output[key])).digest("hex")
         }));
       }
     });
@@ -230,7 +376,7 @@ async function applySessionDelivery(repositoryRoot, payload, options) {
 // src/suggest/engine.ts
 import { constants } from "fs";
 import { access } from "fs/promises";
-import { extname, join, resolve } from "path";
+import { extname, join as join2, resolve } from "path";
 
 // src/suggest/types.ts
 var SEVERITY_RANK = {
@@ -267,7 +413,7 @@ async function generateSuggestions(input) {
     resolveRelevantPlan(planStore, namespace, input.planId),
     memoryStore.findIncidentFactsForPaths({ namespace, paths: targetPaths }),
     buildArchitectureMap(repositoryRoot),
-    readPolicyFile(join(repositoryRoot, ".codebuddy", "policies.yaml"))
+    readPolicyFile(join2(repositoryRoot, ".codebuddy", "policies.yaml"))
   ]);
   const suggestions = [];
   for (const item of risks.items) {
@@ -347,7 +493,7 @@ async function generateSuggestions(input) {
   for (const rule of policyFile.rules) {
     const prefix = literalPrefix(rule.pattern);
     if (!prefix) continue;
-    if (await pathExists(join(repositoryRoot, prefix))) continue;
+    if (await pathExists(join2(repositoryRoot, prefix))) continue;
     suggestions.push({
       id: `stale_policy:${rule.id}`,
       category: "stale_policy",
@@ -391,7 +537,7 @@ function isTestableCode(path) {
 }
 async function hasSiblingTest(repositoryRoot, path) {
   for (const candidate of coveringTestCandidates(path)) {
-    if (await pathExists(join(repositoryRoot, candidate))) return true;
+    if (await pathExists(join2(repositoryRoot, candidate))) return true;
   }
   return false;
 }
@@ -1146,7 +1292,7 @@ import pino from "pino";
 
 // src/automation/project-sync.ts
 import { watch as fsWatch2 } from "fs";
-import { join as join2, relative, resolve as resolve3, sep } from "path";
+import { join as join3, relative, resolve as resolve3, sep } from "path";
 
 // src/indexer/watch.ts
 import { watch as fsWatch } from "fs";
@@ -1327,7 +1473,7 @@ function startProjectSync(options) {
         300
       );
       memoryWatcher = fsWatch2(
-        join2(repositoryRoot, ".codebuddy", "memory"),
+        join3(repositoryRoot, ".codebuddy", "memory"),
         { recursive: true },
         (_event, filename) => {
           const name = filename?.replace(/\\/g, "/") ?? "";
@@ -1361,7 +1507,7 @@ function startProjectSync(options) {
 
 // src/core/project-root.ts
 import { realpath, stat } from "fs/promises";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 import { isAbsolute, parse, resolve as resolve4 } from "path";
 async function resolveInitializedProjectRoot(configuredRoot, cwd = process.cwd()) {
   if (configuredRoot !== void 0 && !isAbsolute(configuredRoot)) {
@@ -1369,7 +1515,7 @@ async function resolveInitializedProjectRoot(configuredRoot, cwd = process.cwd()
   }
   const selected = resolve4(configuredRoot ?? cwd);
   const root = await realpath(selected);
-  if (root === parse(root).root || root === await realpath(homedir())) {
+  if (root === parse(root).root || root === await realpath(homedir2())) {
     throw new Error(
       "Select an initialized project folder, not the filesystem root or home folder."
     );
@@ -1519,8 +1665,11 @@ async function startMcpServer(options = {}) {
   });
   const server = new McpServer({ name: "codebuddy", version: VERSION });
   registerCodeBuddyTools(server, { config, database }, toolProfile);
+  const telemetry = setInterval(() => void flushTelemetry(projectRoot), 6e4);
+  telemetry.unref();
   const shutdown = async () => {
     logger.info("codebuddy MCP server shutting down");
+    clearInterval(telemetry);
     await server.close();
     await sync.close();
     await database.close();
@@ -1626,9 +1775,18 @@ function isConnectionRefused(error) {
 export {
   migrateMemoryToFiles,
   watchRepository,
+  telemetryStatePath,
+  readTelemetryState,
+  writeTelemetryState,
+  telemetryBlocked,
+  telemetryUrl,
+  TELEMETRY_NOTICE,
+  showTelemetryNoticeOnce,
+  flushTelemetry,
+  traceCliCommand,
   generateSuggestions,
   mcpToolInputSchemas,
   registerCodeBuddyTools,
   startMcpServer
 };
-//# sourceMappingURL=chunk-EEUFU7KV.js.map
+//# sourceMappingURL=chunk-2WH2Q4TA.js.map