@orquentra/codebuddy 2.6.2 → 2.8.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-IBLJOHJL.js → chunk-3QGW53GD.js}

@@ -1,6 +1,6 @@
 import {
   LOCAL_EMBEDDING_MODEL
-} from "./chunk-JPHJBCZB.js";
+} from "./chunk-HPOR6YXA.js";
 
 // src/providers/local.ts
 import { homedir } from "os";
@@ -101,4 +101,4 @@ export {
   LocalModelProvider,
   rerankLocally
 };
-//# sourceMappingURL=chunk-IBLJOHJL.js.map
+//# sourceMappingURL=chunk-3QGW53GD.js.map

package/dist/{chunk-IMFUYEZA.js → chunk-6DONJW3W.js}

@@ -1,3 +1,6 @@
+import {
+  refreshZvecIndex
+} from "./chunk-GXOML4UZ.js";
 import {
   PlanFileStore,
   PlanLifecycle,
@@ -9,43 +12,46 @@ import {
   enforceContextBudget,
   llmMemoryOptions,
   readPolicyFile,
-  recordTrace,
   resolveRiskPaths
-} from "./chunk-R7CD6EXS.js";
+} from "./chunk-ZNLSCV3J.js";
 import {
   SessionCapsuleLedger,
+  coveringTestCandidates,
   estimateTokens
-} from "./chunk-J2EAZ4MA.js";
+} from "./chunk-GKNYMNFM.js";
 import {
-  buildArchitectureMap,
-  generateGraphifyGraph,
-  indexRepository,
-  loadArchitectureMap,
-  loadFreshIndex,
-  neighbours,
-  queryMap
-} from "./chunk-NERKZSSE.js";
+  readTraces,
+  recordTrace
+} from "./chunk-XL2HLACE.js";
 import {
   codeBuddyConfigSchema,
   createRuntime,
   listFactsPage
-} from "./chunk-2XDPKFUW.js";
+} from "./chunk-NY2YXP3R.js";
 import {
   MemoryFileStore,
   VERSION
-} from "./chunk-S6VEG4S2.js";
+} from "./chunk-6KGYAFG7.js";
 import {
-  redactPersisted
-} from "./chunk-GDJH7XJC.js";
+  generateGraphifyGraph,
+  loadProjectArchitectureMap
+} from "./chunk-TLWGZVPC.js";
 import {
-  refreshZvecIndex
-} from "./chunk-5FW3PMNP.js";
+  buildArchitectureMap,
+  indexRepository,
+  loadFreshIndex,
+  neighbours,
+  queryMap
+} from "./chunk-ITQO632W.js";
+import {
+  redactPersisted
+} from "./chunk-AL6VBTNA.js";
 import {
   configPath,
   loadPlanPolicy,
   loadRuntimeConfig,
   redactSecrets
-} from "./chunk-5KZY6OTG.js";
+} from "./chunk-KNR2P2UY.js";
 
 // src/core/migrate-to-files.ts
 import { createHash } from "crypto";
@@ -164,11 +170,138 @@ function checksum(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 
+// src/telemetry/telemetry.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+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 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",
@@ -187,7 +320,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, {
@@ -214,7 +347,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")
         }));
       }
     });
@@ -227,7 +360,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 = {
@@ -241,7 +374,7 @@ var SEVERITY_RANK = {
 var RISK_SUGGEST_THRESHOLD = 50;
 var BLAST_RADIUS_MEDIUM = 5;
 var BLAST_RADIUS_HIGH = 10;
-var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"]);
 async function generateSuggestions(input) {
   const repositoryRoot = resolve(input.repositoryRoot ?? process.cwd());
   const namespace = input.namespace;
@@ -264,7 +397,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) {
@@ -338,13 +471,13 @@ async function generateSuggestions(input) {
       title: `No test found for ${path}`,
       detail: "Consider adding a test alongside this change.",
       path,
-      evidence: [{ kind: "no_test", detail: "no *.test.* / *.spec.* sibling found" }]
+      evidence: [{ kind: "no_test", detail: "no conventional test file found" }]
     });
   }
   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",
@@ -381,21 +514,14 @@ function isTestableCode(path) {
   if (/\.(test|spec)\.[cm]?[jt]sx?$/.test(path)) return false;
   if (path.endsWith(".d.ts")) return false;
   if (path.includes("__tests__/")) return false;
+  if (/(^|\/)(test_[^/]*|[^/]*_test|conftest|__init__)\.py$|(^|\/)tests?\/.*\.py$/.test(path)) {
+    return false;
+  }
   return CODE_EXTENSIONS.has(extname(path).toLowerCase());
 }
 async function hasSiblingTest(repositoryRoot, path) {
-  const ext = extname(path);
-  const base = path.slice(0, path.length - ext.length);
-  const dir = base.includes("/") ? base.slice(0, base.lastIndexOf("/")) : "";
-  const name = base.includes("/") ? base.slice(base.lastIndexOf("/") + 1) : base;
-  const candidates = [
-    `${base}.test${ext}`,
-    `${base}.spec${ext}`,
-    `${dir ? `${dir}/` : ""}__tests__/${name}${ext}`,
-    `${dir ? `${dir}/` : ""}__tests__/${name}.test${ext}`
-  ];
-  for (const candidate of candidates) {
-    if (await pathExists(join(repositoryRoot, candidate))) return true;
+  for (const candidate of coveringTestCandidates(path)) {
+    if (await pathExists(join2(repositoryRoot, candidate))) return true;
   }
   return false;
 }
@@ -466,26 +592,31 @@ var INPUT_LIMITS = {
   arrayItems: 100,
   pathChars: 1024,
   taskChars: 2e3,
-  agentIdChars: 200
+  agentIdChars: 200,
+  /** Entity ids and list cursors are short; a megabyte one is never valid. */
+  idChars: 512
 };
 var deliverySchema = {
   sessionId: z.string().min(1).max(200).optional(),
   ack: z.string().regex(/^dlv_[a-z0-9]+$/).optional(),
   full: z.boolean().optional()
 };
+var pgText = (max) => z.string().min(1).max(max).refine((value) => !value.includes("\0"), "must not contain NUL bytes");
 var rememberSchema = {
-  sessionId: z.string().min(1).max(200).optional(),
-  content: z.string().min(1).max(INPUT_LIMITS.contentChars),
+  sessionId: pgText(200).optional(),
+  content: pgText(INPUT_LIMITS.contentChars),
   type: z.enum(["interaction", "fact", "summary"]).optional(),
-  idempotencyKey: z.string().min(1).max(200).optional(),
-  agentId: z.string().min(1).max(INPUT_LIMITS.agentIdChars).optional()
+  idempotencyKey: pgText(200).optional(),
+  agentId: pgText(INPUT_LIMITS.agentIdChars).optional()
 };
 var recallSchema = {
-  sessionId: z.string().min(1).max(200),
-  query: z.string().min(1).max(INPUT_LIMITS.taskChars),
+  sessionId: pgText(200),
+  query: pgText(INPUT_LIMITS.taskChars),
   budget: z.number().int().positive().optional(),
   callerModel: z.string().min(1).max(200).optional(),
-  conflictMode: z.enum(["all", "latest", "highest_confidence"]).optional()
+  conflictMode: z.enum(["all", "latest", "highest_confidence"]).optional(),
+  /** Return only system, message id + content and core stats (no provenance). */
+  compact: z.boolean().optional()
 };
 var shareSchema = {
   from: z.string().min(1).max(INPUT_LIMITS.agentIdChars).optional(),
@@ -521,15 +652,17 @@ var planPatchSchema = {
 };
 var mcpToolInputSchemas = {
   remember: z.object(rememberSchema),
-  remember_batch: z.object({ items: z.array(z.object(rememberSchema)).min(1) }),
+  remember_batch: z.object({
+    items: z.array(z.object(rememberSchema)).min(1).max(INPUT_LIMITS.batchItems)
+  }),
   recall: z.object(recallSchema),
   list_facts: z.object({
-    subject: z.string().optional(),
+    subject: z.string().max(INPUT_LIMITS.titleChars).optional(),
     limit: z.number().int().positive().max(100).default(50),
-    cursor: z.string().optional()
+    cursor: z.string().max(INPUT_LIMITS.idChars).optional()
   }),
   list_namespaces: z.object({}),
-  forget: z.object({ id: z.string().min(1) }),
+  forget: z.object({ id: z.string().min(1).max(INPUT_LIMITS.idChars) }),
   share: z.object(shareSchema),
   unshare: z.object(unshareSchema),
   plan_current: z.object({}),
@@ -731,10 +864,13 @@ function registerCodeBuddyTools(server, options, profile = "full") {
     "recall",
     {
       title: "Recall",
-      description: "Recall prompt-ready CodeBuddy context.",
+      description: "Recall prompt-ready CodeBuddy context. `budget` bounds message content (stats.tokensUsed); stats.responseTokens counts the whole JSON text returned (provenance and stats included) and stats.transportTokens the full tool result, which also repeats it as structuredContent. Pass compact=true for only message id + content.",
       inputSchema: mcpToolInputSchemas.recall.shape
     },
-    async (input) => viaDatabase("recall", (db) => db.memory.recall(toRecallInput(input)))
+    async (input) => viaDatabase(
+      "recall",
+      async (db) => withResponseTokens(await db.memory.recall(toRecallInput(input)), input.compact === true)
+    )
   );
   register(
     "list_facts",
@@ -939,12 +1075,10 @@ function registerCodeBuddyTools(server, options, profile = "full") {
     async (input) => json(neighbours(await cachedMap(), input.module, input.direction))
   );
   const tokenBudget = config.tokenBudget;
-  const cachedMap = async () => {
-    const { manifest } = await loadFreshIndex(projectRoot);
-    const cached = await loadArchitectureMap(projectRoot, manifest);
-    if (cached.map.modules.length > 0) return cached.map;
-    return buildArchitectureMap(projectRoot);
-  };
+  const cachedMap = async () => loadProjectArchitectureMap(
+    projectRoot,
+    loadFreshIndex(projectRoot).then(({ manifest }) => manifest)
+  );
   register(
     "context_bootstrap",
     {
@@ -1106,7 +1240,30 @@ function toRememberInput(input) {
   return cleanOptional(input);
 }
 function toRecallInput(input) {
-  return cleanOptional(input);
+  const { compact: _compact, ...rest } = input;
+  return cleanOptional(rest);
+}
+function withResponseTokens(result, compact) {
+  const stats = compact ? {
+    tokensUsed: result.stats.tokensUsed,
+    itemsIncluded: result.stats.itemsIncluded,
+    itemsSkipped: result.stats.itemsSkipped,
+    ...result.stats.budgetStatus ? { budgetStatus: result.stats.budgetStatus } : {}
+  } : { ...result.stats };
+  const value = compact ? {
+    system: result.system,
+    messages: result.messages.map((message) => ({
+      ...message.fact ? { id: message.fact.id } : {},
+      content: message.content
+    })),
+    stats
+  } : { ...result, stats };
+  for (let pass = 0; pass < 2; pass++) {
+    const serialized = serializeToolResult(value);
+    stats.responseTokens = estimateTokens(serialized.content[0]?.text);
+    stats.transportTokens = estimateTokens(serialized);
+  }
+  return value;
 }
 function cleanOptional(input) {
   return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
@@ -1119,7 +1276,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";
@@ -1300,7 +1457,7 @@ function startProjectSync(options) {
         300
       );
       memoryWatcher = fsWatch2(
-        join2(repositoryRoot, ".codebuddy", "memory"),
+        join3(repositoryRoot, ".codebuddy", "memory"),
         { recursive: true },
         (_event, filename) => {
           const name = filename?.replace(/\\/g, "/") ?? "";
@@ -1334,7 +1491,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)) {
@@ -1342,7 +1499,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."
     );
@@ -1492,8 +1649,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();
@@ -1599,9 +1759,17 @@ function isConnectionRefused(error) {
 export {
   migrateMemoryToFiles,
   watchRepository,
+  telemetryStatePath,
+  readTelemetryState,
+  writeTelemetryState,
+  telemetryBlocked,
+  telemetryUrl,
+  TELEMETRY_NOTICE,
+  showTelemetryNoticeOnce,
+  flushTelemetry,
   generateSuggestions,
   mcpToolInputSchemas,
   registerCodeBuddyTools,
   startMcpServer
 };
-//# sourceMappingURL=chunk-IMFUYEZA.js.map
+//# sourceMappingURL=chunk-6DONJW3W.js.map