context-vault 2.17.1 → 3.0.2

package/src/linking.js

@@ -0,0 +1,100 @@
+import type { DatabaseSync } from "node:sqlite";
+
+export function parseRelatedTo(raw: string | null | undefined): string[] {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((id: unknown) => typeof id === "string" && (id as string).trim());
+  } catch {
+    return [];
+  }
+}
+
+export function resolveLinks(
+  db: DatabaseSync,
+  ids: string[],
+): Record<string, unknown>[] {
+  if (!ids.length) return [];
+  const unique = [...new Set(ids)];
+  const placeholders = unique.map(() => "?").join(",");
+  try {
+    return db
+      .prepare(
+        `SELECT * FROM vault
+         WHERE id IN (${placeholders})
+           AND (expires_at IS NULL OR expires_at > datetime('now'))
+           AND superseded_by IS NULL`,
+      )
+      .all(...unique) as unknown as Record<string, unknown>[];
+  } catch {
+    return [];
+  }
+}
+
+export function resolveBacklinks(
+  db: DatabaseSync,
+  entryId: string,
+): Record<string, unknown>[] {
+  if (!entryId) return [];
+  const likePattern = `%"${entryId}"%`;
+  try {
+    return db
+      .prepare(
+        `SELECT * FROM vault
+         WHERE related_to LIKE ?
+           AND (expires_at IS NULL OR expires_at > datetime('now'))
+           AND superseded_by IS NULL`,
+      )
+      .all(likePattern) as unknown as Record<string, unknown>[];
+  } catch {
+    return [];
+  }
+}
+
+export function collectLinkedEntries(
+  db: DatabaseSync,
+  primaryEntries: Record<string, unknown>[],
+): { forward: Record<string, unknown>[]; backward: Record<string, unknown>[] } {
+  const primaryIds = new Set(primaryEntries.map((e) => e.id as string));
+
+  const forwardIds: string[] = [];
+  for (const entry of primaryEntries) {
+    const ids = parseRelatedTo(entry.related_to as string);
+    for (const id of ids) {
+      if (!primaryIds.has(id)) forwardIds.push(id);
+    }
+  }
+  const forwardEntries = resolveLinks(db, forwardIds).filter(
+    (e) => !primaryIds.has(e.id as string),
+  );
+
+  const backwardSeen = new Set<string>();
+  const backwardEntries: Record<string, unknown>[] = [];
+  for (const entry of primaryEntries) {
+    const backlinks = resolveBacklinks(db, entry.id as string);
+    for (const bl of backlinks) {
+      if (!primaryIds.has(bl.id as string) && !backwardSeen.has(bl.id as string)) {
+        backwardSeen.add(bl.id as string);
+        backwardEntries.push(bl);
+      }
+    }
+  }
+
+  return { forward: forwardEntries, backward: backwardEntries };
+}
+
+export function validateRelatedTo(relatedTo: unknown): string | null {
+  if (relatedTo === undefined || relatedTo === null) return null;
+  if (!Array.isArray(relatedTo))
+    return "related_to must be an array of entry IDs";
+  for (const id of relatedTo) {
+    if (typeof id !== "string" || !id.trim()) {
+      return "each related_to entry must be a non-empty string ID";
+    }
+    if (id.length > 32) {
+      return `related_to ID too long (max 32 chars): "${id.slice(0, 32)}..."`;
+    }
+  }
+  return null;
+}

package/{node_modules/@context-vault/core/src/server/tools.js → src/register-tools.js}

@@ -1,8 +1,15 @@
-import { reindex } from "../index/index.js";
-import { captureAndIndex } from "../capture/index.js";
+import { reindex } from "@context-vault/core/index";
+import { captureAndIndex } from "@context-vault/core/capture";
 import { err } from "./helpers.js";
-import { sendTelemetryEvent } from "../core/telemetry.js";
-import pkg from "../../package.json" with { type: "json" };
+import { sendTelemetryEvent } from "./telemetry.js";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(
+  readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"),
+);
 
 import * as getContext from "./tools/get-context.js";
 import * as saveContext from "./tools/save-context.js";
@@ -33,8 +40,6 @@ const toolModules = [
 const TOOL_TIMEOUT_MS = 60_000;
 
 export function registerTools(server, ctx) {
-  const userId = ctx.userId !== undefined ? ctx.userId : undefined;
-
   function tracked(handler, toolName) {
     return async (...args) => {
       if (ctx.activeOps) ctx.activeOps.count++;
@@ -55,8 +60,6 @@ export function registerTools(server, ctx) {
         return result;
       } catch (e) {
         if (e.message === "TOOL_TIMEOUT") {
-          // Suppress any late rejection from the still-running handler to
-          // prevent unhandled promise rejection warnings in the host process.
           handlerPromise?.catch(() => {});
           if (ctx.toolStats) {
             ctx.toolStats.errors++;
@@ -105,7 +108,7 @@ export function registerTools(server, ctx) {
               auto: true,
             },
           });
-        } catch {} // never block on feedback capture
+        } catch {}
         throw e;
       } finally {
         clearTimeout(timer);
@@ -114,8 +117,7 @@ export function registerTools(server, ctx) {
     };
   }
 
-  // In hosted mode, skip reindex — DB is always in sync via writeEntry→indexEntry
-  let reindexDone = userId !== undefined ? true : false;
+  let reindexDone = false;
   let reindexPromise = null;
   let reindexAttempts = 0;
   let reindexFailed = false;
@@ -124,7 +126,6 @@ export function registerTools(server, ctx) {
   async function ensureIndexed() {
     if (reindexDone) return;
     if (reindexPromise) return reindexPromise;
-    // Assign promise synchronously to prevent concurrent calls from both entering reindex()
     const promise = reindex(ctx, { fullSync: true })
       .then((stats) => {
         reindexDone = true;
@@ -147,7 +148,7 @@ export function registerTools(server, ctx) {
           reindexDone = true;
           reindexFailed = true;
         } else {
-          reindexPromise = null; // Allow retry on next tool call
+          reindexPromise = null;
         }
       });
     reindexPromise = promise;

package/src/{server/index.js → server.js}

@@ -18,24 +18,19 @@ const pkg = JSON.parse(
   readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"),
 );
 
-import { resolveConfig } from "@context-vault/core/core/config";
-import { appendErrorLog } from "@context-vault/core/core/error-log";
-import {
-  sendTelemetryEvent,
-  maybeShowTelemetryNotice,
-} from "@context-vault/core/core/telemetry";
-import { embed } from "@context-vault/core/index/embed";
+import { resolveConfig } from "@context-vault/core/config";
+import { appendErrorLog } from "./error-log.js";
+import { sendTelemetryEvent, maybeShowTelemetryNotice } from "./telemetry.js";
+import { embed } from "@context-vault/core/embed";
 import {
   initDatabase,
   NativeModuleError,
   prepareStatements,
   insertVec,
   deleteVec,
-} from "@context-vault/core/index/db";
-import { registerTools } from "@context-vault/core/server/tools";
-import { pruneExpired } from "@context-vault/core/index/index";
-
-// ─── Phased Startup ─────────────────────────────────────────────────────────
+} from "@context-vault/core/db";
+import { registerTools } from "./register-tools.js";
+import { pruneExpired } from "@context-vault/core/index";
 
 async function main() {
   let phase = "CONFIG";
@@ -43,16 +38,13 @@ async function main() {
   let config;
 
   try {
-    // ── Phase: CONFIG ────────────────────────────────────────────────────────
     config = resolveConfig();
 
-    // ── Phase: DIRS ──────────────────────────────────────────────────────────
     phase = "DIRS";
     mkdirSync(config.dataDir, { recursive: true });
     mkdirSync(config.vaultDir, { recursive: true });
     maybeShowTelemetryNotice(config.dataDir);
 
-    // Verify vault directory is writable (catch permission issues early)
     try {
       const probe = join(config.vaultDir, ".write-probe");
       writeFileSync(probe, "");
@@ -68,7 +60,6 @@ async function main() {
       process.exit(1);
     }
 
-    // Write .context-mcp marker (non-fatal)
     try {
       const markerPath = join(config.vaultDir, ".context-mcp");
       const markerData = existsSync(markerPath)
@@ -93,7 +84,6 @@ async function main() {
 
     config.vaultDirExists = existsSync(config.vaultDir);
 
-    // Startup diagnostics
     console.error(`[context-vault] Vault: ${config.vaultDir}`);
     console.error(`[context-vault] Database: ${config.dbPath}`);
     console.error(`[context-vault] Dev dir: ${config.devDir}`);
@@ -101,11 +91,9 @@ async function main() {
       console.error(`[context-vault] WARNING: Vault directory not found!`);
     }
 
-    // ── Phase: DB ────────────────────────────────────────────────────────────
     phase = "DB";
-    const mode = config.hostedUrl ? "hosted" : "local";
-    db = await initDatabase(config.dbPath, { mode });
-    const stmts = prepareStatements(db, mode);
+    db = await initDatabase(config.dbPath);
+    const stmts = prepareStatements(db);
 
     const ctx = {
       db,
@@ -118,7 +106,6 @@ async function main() {
       toolStats: { ok: 0, errors: 0, lastError: null },
     };
 
-    // ── Phase: PRUNE ─────────────────────────────────────────────────────────
     try {
       const pruned = await pruneExpired(ctx);
       if (pruned > 0) {
@@ -132,16 +119,12 @@ async function main() {
       );
     }
 
-    // ── Phase: SERVER ────────────────────────────────────────────────────────
     phase = "SERVER";
     const server = new McpServer(
       { name: "context-vault", version: pkg.version },
       { capabilities: { tools: {} } },
     );
 
-    // Hot-reload config.json on every tool call (Option C from #144).
-    // resolveConfig() re-reads the small file each time — negligible I/O
-    // compared to DB queries and embedding operations that follow.
     let lastVaultDir = config.vaultDir;
     Object.defineProperty(ctx, "config", {
       get() {
@@ -160,7 +143,6 @@ async function main() {
 
     registerTools(server, ctx);
 
-    // ── Graceful Shutdown ────────────────────────────────────────────────────
     function closeDb() {
       try {
         if (db.inTransaction) {
@@ -189,7 +171,6 @@ async function main() {
             closeDb();
           }
         }, 100);
-        // Force shutdown after 5 seconds even if ops are still running
         setTimeout(() => {
           clearInterval(check);
           console.error(
@@ -204,12 +185,10 @@ async function main() {
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
 
-    // ── Phase: CONNECTED ─────────────────────────────────────────────────────
     phase = "CONNECTED";
     const transport = new StdioServerTransport();
     await server.connect(transport);
 
-    // ── Non-blocking Update Check ────────────────────────────────────────────
     setTimeout(() => {
       import("node:child_process")
         .then(({ execSync }) => {
@@ -251,7 +230,6 @@ async function main() {
     });
 
     if (err instanceof NativeModuleError) {
-      // Boxed diagnostic for native module mismatch
       console.error("");
       console.error(
         "╔══════════════════════════════════════════════════════════════╗",
@@ -269,7 +247,7 @@ async function main() {
       console.error(`  Node.js version: ${process.version}`);
       console.error(`  Error log:       ${join(dataDir, "error.log")}`);
       console.error("");
-      process.exit(78); // EX_CONFIG
+      process.exit(78);
     }
 
     console.error(
@@ -285,12 +263,6 @@ async function main() {
   }
 }
 
-// ─── Top-level Safety Net ────────────────────────────────────────────────────
-// Catch any errors that escape the main() try/catch (e.g. thrown in MCP
-// transport callbacks or in unrelated async chains).  Claude Code surfaces
-// stderr when a server exits unexpectedly, so every message written here will
-// be visible to the user.
-
 process.on("uncaughtException", (err) => {
   const dataDir = join(homedir(), ".context-mcp");
   const logEntry = {

package/src/status.js

@@ -0,0 +1,235 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { walkDir } from "@context-vault/core/files";
+import { isEmbedAvailable } from "@context-vault/core/embed";
+import { KIND_STALENESS_DAYS } from "@context-vault/core/categories";
+
+function countArchivedEntries(vaultDir) {
+  const archRoot = join(vaultDir, "_archive");
+  if (!existsSync(archRoot)) return 0;
+  try {
+    return walkDir(archRoot).length;
+  } catch {
+    return 0;
+  }
+}
+
+export function gatherVaultStatus(ctx, opts = {}) {
+  const { db, config } = ctx;
+  const errors = [];
+
+  let fileCount = 0;
+  const subdirs = [];
+  try {
+    if (existsSync(config.vaultDir)) {
+      for (const d of readdirSync(config.vaultDir, { withFileTypes: true })) {
+        if (d.isDirectory()) {
+          const dir = join(config.vaultDir, d.name);
+          const count = walkDir(dir).length;
+          fileCount += count;
+          if (count > 0) subdirs.push({ name: d.name, count });
+        }
+      }
+    }
+  } catch (e) {
+    errors.push(`File scan failed: ${e.message}`);
+  }
+
+  let kindCounts = [];
+  try {
+    kindCounts = db
+      .prepare(`SELECT kind, COUNT(*) as c FROM vault GROUP BY kind`)
+      .all();
+  } catch (e) {
+    errors.push(`Kind count query failed: ${e.message}`);
+  }
+
+  let categoryCounts = [];
+  try {
+    categoryCounts = db
+      .prepare(`SELECT category, COUNT(*) as c FROM vault GROUP BY category`)
+      .all();
+  } catch (e) {
+    errors.push(`Category count query failed: ${e.message}`);
+  }
+
+  let dbSize = "n/a";
+  let dbSizeBytes = 0;
+  try {
+    if (existsSync(config.dbPath)) {
+      dbSizeBytes = statSync(config.dbPath).size;
+      dbSize =
+        dbSizeBytes > 1024 * 1024
+          ? `${(dbSizeBytes / 1024 / 1024).toFixed(1)}MB`
+          : `${(dbSizeBytes / 1024).toFixed(1)}KB`;
+    }
+  } catch (e) {
+    errors.push(`DB size check failed: ${e.message}`);
+  }
+
+  let stalePaths = false;
+  let staleCount = 0;
+  try {
+    const result = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE file_path NOT LIKE ? || '%'`)
+      .get(config.vaultDir);
+    staleCount = result.c;
+    stalePaths = staleCount > 0;
+  } catch (e) {
+    errors.push(`Stale path check failed: ${e.message}`);
+  }
+
+  let expiredCount = 0;
+  try {
+    expiredCount = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE expires_at IS NOT NULL AND expires_at <= datetime('now')`)
+      .get().c;
+  } catch (e) {
+    errors.push(`Expired count failed: ${e.message}`);
+  }
+
+  let eventCount = 0;
+  try {
+    eventCount = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE category = 'event'`)
+      .get().c;
+  } catch (e) {
+    errors.push(`Event count failed: ${e.message}`);
+  }
+
+  let eventsWithoutTtlCount = 0;
+  try {
+    eventsWithoutTtlCount = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE category = 'event' AND expires_at IS NULL`)
+      .get().c;
+  } catch (e) {
+    errors.push(`Events without TTL count failed: ${e.message}`);
+  }
+
+  let embeddingStatus = null;
+  try {
+    const total = db.prepare(`SELECT COUNT(*) as c FROM vault`).get().c;
+    const indexed = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE rowid IN (SELECT rowid FROM vault_vec)`)
+      .get().c;
+    embeddingStatus = { indexed, total, missing: total - indexed };
+  } catch (e) {
+    errors.push(`Embedding status check failed: ${e.message}`);
+  }
+
+  const embedModelAvailable = isEmbedAvailable();
+
+  let autoCapturedFeedbackCount = 0;
+  try {
+    autoCapturedFeedbackCount = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE kind = 'feedback' AND tags LIKE '%"auto-captured"%'`)
+      .get().c;
+  } catch (e) {
+    errors.push(`Auto-captured feedback count failed: ${e.message}`);
+  }
+
+  let archivedCount = 0;
+  try {
+    archivedCount = countArchivedEntries(config.vaultDir);
+  } catch (e) {
+    errors.push(`Archived count failed: ${e.message}`);
+  }
+
+  let staleKnowledge = [];
+  try {
+    const stalenessKinds = Object.entries(KIND_STALENESS_DAYS);
+    if (stalenessKinds.length > 0) {
+      const kindClauses = stalenessKinds
+        .map(
+          ([kind, days]) =>
+            `(kind = '${kind}' AND COALESCE(updated_at, created_at) <= datetime('now', '-${days} days'))`,
+        )
+        .join(" OR ");
+      staleKnowledge = db
+        .prepare(
+          `SELECT kind, title, COALESCE(updated_at, created_at) as last_updated FROM vault WHERE category = 'knowledge' AND (${kindClauses}) AND (expires_at IS NULL OR expires_at > datetime('now')) ORDER BY last_updated ASC LIMIT 10`,
+        )
+        .all();
+    }
+  } catch (e) {
+    errors.push(`Stale knowledge check failed: ${e.message}`);
+  }
+
+  return {
+    fileCount,
+    subdirs,
+    kindCounts,
+    categoryCounts,
+    dbSize,
+    dbSizeBytes,
+    stalePaths,
+    staleCount,
+    expiredCount,
+    eventCount,
+    eventsWithoutTtlCount,
+    embeddingStatus,
+    embedModelAvailable,
+    autoCapturedFeedbackCount,
+    archivedCount,
+    staleKnowledge,
+    resolvedFrom: config.resolvedFrom,
+    errors,
+  };
+}
+
+export function computeGrowthWarnings(status, thresholds) {
+  if (!thresholds)
+    return { warnings: [], hasCritical: false, hasWarnings: false, actions: [], kindBreakdown: [] };
+
+  const t = thresholds;
+  const warnings = [];
+  const actions = [];
+
+  const total = status.embeddingStatus?.total ?? 0;
+  const { eventCount = 0, eventsWithoutTtlCount = 0, expiredCount = 0, dbSizeBytes = 0 } = status;
+
+  let totalExceeded = false;
+
+  if (t.totalEntries?.critical != null && total >= t.totalEntries.critical) {
+    totalExceeded = true;
+    warnings.push({ level: "critical", message: `Total entries: ${total.toLocaleString()} (exceeds critical limit of ${t.totalEntries.critical.toLocaleString()})` });
+  } else if (t.totalEntries?.warn != null && total >= t.totalEntries.warn) {
+    totalExceeded = true;
+    warnings.push({ level: "warn", message: `Total entries: ${total.toLocaleString()} (exceeds recommended ${t.totalEntries.warn.toLocaleString()})` });
+  }
+
+  if (t.eventEntries?.critical != null && eventCount >= t.eventEntries.critical) {
+    warnings.push({ level: "critical", message: `Event entries: ${eventCount.toLocaleString()} (exceeds critical limit of ${t.eventEntries.critical.toLocaleString()})` });
+  } else if (t.eventEntries?.warn != null && eventCount >= t.eventEntries.warn) {
+    const ttlNote = eventsWithoutTtlCount > 0 ? ` (${eventsWithoutTtlCount.toLocaleString()} without TTL)` : "";
+    warnings.push({ level: "warn", message: `Event entries: ${eventCount.toLocaleString()}${ttlNote} (exceeds recommended ${t.eventEntries.warn.toLocaleString()})` });
+  }
+
+  if (t.vaultSizeBytes?.critical != null && dbSizeBytes >= t.vaultSizeBytes.critical) {
+    warnings.push({ level: "critical", message: `Database size: ${(dbSizeBytes / 1024 / 1024).toFixed(1)}MB (exceeds critical limit of ${(t.vaultSizeBytes.critical / 1024 / 1024).toFixed(0)}MB)` });
+  } else if (t.vaultSizeBytes?.warn != null && dbSizeBytes >= t.vaultSizeBytes.warn) {
+    warnings.push({ level: "warn", message: `Database size: ${(dbSizeBytes / 1024 / 1024).toFixed(1)}MB (exceeds recommended ${(t.vaultSizeBytes.warn / 1024 / 1024).toFixed(0)}MB)` });
+  }
+
+  if (t.eventsWithoutTtl?.warn != null && eventsWithoutTtlCount >= t.eventsWithoutTtl.warn) {
+    warnings.push({ level: "warn", message: `Event entries without expires_at: ${eventsWithoutTtlCount.toLocaleString()} (exceeds recommended ${t.eventsWithoutTtl.warn.toLocaleString()})` });
+  }
+
+  const hasCritical = warnings.some((w) => w.level === "critical");
+
+  if (expiredCount > 0) {
+    actions.push(`Run \`context-vault prune\` to remove ${expiredCount} expired event entr${expiredCount === 1 ? "y" : "ies"}`);
+  }
+  if (eventsWithoutTtlCount > 0 && (eventCount >= (t.eventEntries?.warn ?? Infinity) || eventsWithoutTtlCount >= (t.eventsWithoutTtl?.warn ?? Infinity))) {
+    actions.push("Add `expires_at` to event/session entries to enable automatic cleanup");
+  }
+  if (total >= (t.totalEntries?.warn ?? Infinity)) {
+    actions.push("Run `context-vault archive` to move old ephemeral/event entries to _archive/");
+  }
+
+  const kindBreakdown = totalExceeded && status.kindCounts?.length
+    ? [...status.kindCounts].sort((a, b) => b.c - a.c).map(({ kind, c }) => ({ kind, count: c, pct: Math.round((c / total) * 100) }))
+    : [];
+
+  return { warnings, hasCritical, hasWarnings: warnings.length > 0, actions, kindBreakdown };
+}

package/{node_modules/@context-vault/core/src/core → src}/telemetry.js

@@ -1,23 +1,22 @@
 import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { API_URL, MARKETING_URL, GITHUB_ISSUES_URL } from "../constants.js";
+import { API_URL, MARKETING_URL, GITHUB_ISSUES_URL } from "@context-vault/core/constants";
+import type { VaultConfig } from "@context-vault/core/types";
 
 const TELEMETRY_ENDPOINT = `${API_URL}/telemetry`;
 const NOTICE_MARKER = ".telemetry-notice-shown";
 const FEEDBACK_PROMPT_MARKER = ".feedback-prompt-shown";
 
-export function isTelemetryEnabled(config) {
+export function isTelemetryEnabled(config: VaultConfig | undefined): boolean {
   const envVal = process.env.CONTEXT_VAULT_TELEMETRY;
   if (envVal !== undefined) return envVal === "1" || envVal === "true";
   return config?.telemetry === true;
 }
 
-/**
- * Fire-and-forget telemetry event. Never throws, never blocks.
- * Payload contains only: event, code, tool, cv_version, node_version, platform, arch, ts.
- * No message text, stack traces, vault content, file paths, or user identifiers.
- */
-export function sendTelemetryEvent(config, payload) {
+export function sendTelemetryEvent(
+  config: VaultConfig | undefined,
+  payload: { event: string; code?: string | null; tool?: string | null; cv_version: string },
+): void {
   if (!isTelemetryEnabled(config)) return;
 
   const event = {
@@ -39,11 +38,7 @@ export function sendTelemetryEvent(config, payload) {
   }).catch(() => {});
 }
 
-/**
- * Print the one-time telemetry notice to stderr.
- * Uses a marker file in dataDir to ensure it's only shown once.
- */
-export function maybeShowTelemetryNotice(dataDir) {
+export function maybeShowTelemetryNotice(dataDir: string): void {
   try {
     const markerPath = join(dataDir, NOTICE_MARKER);
     if (existsSync(markerPath)) return;
@@ -65,12 +60,7 @@ export function maybeShowTelemetryNotice(dataDir) {
   }
 }
 
-/**
- * Print a one-time feedback prompt after the user's first successful save.
- * Uses a marker file in dataDir to ensure it's only shown once.
- * Never throws, never blocks.
- */
-export function maybeShowFeedbackPrompt(dataDir) {
+export function maybeShowFeedbackPrompt(dataDir: string): void {
   try {
     const markerPath = join(dataDir, FEEDBACK_PROMPT_MARKER);
     if (existsSync(markerPath)) return;