karajan-code 2.34.0 → 3.1.0

package/src/utils/telemetry.js

@@ -1,4 +1,30 @@
-const TELEMETRY_ENDPOINT = "https://karajan-code.web.app/api/telemetry";
+export const TELEMETRY_ENDPOINT = "https://karajan-code.web.app/api/telemetry";
+
+/**
+ * Build the exact JSON payload that would be POSTed for an event.
+ * Pure function: deterministic given (eventName, data) — exposed so
+ * `kj telemetry preview` can render the literal bytes the backend
+ * receives without performing any network call.
+ *
+ * The `data.version` field is folded into `v`; the rest of the
+ * event-specific keys ride through `...data` after the common ones,
+ * matching the order sent over the wire.
+ *
+ * @param {string} eventName
+ * @param {object} [data]
+ * @returns {object}
+ */
+export function buildTelemetryPayload(eventName, data = {}) {
+  const { version, ...rest } = data;
+  return {
+    event: eventName,
+    v: version || "unknown",
+    os: process.platform,
+    node: process.version,
+    ts: Date.now(),
+    ...rest
+  };
+}
 
 /**
  * Send an anonymous telemetry event. Non-blocking, fire-and-forget.
@@ -12,14 +38,7 @@ export async function sendTelemetryEvent(eventName, data, config) {
   if (!isTelemetryEnabled(config)) return;
 
   try {
-    const payload = {
-      event: eventName,
-      v: data.version || "unknown",
-      os: process.platform,
-      node: process.version,
-      ts: Date.now(),
-      ...data
-    };
+    const payload = buildTelemetryPayload(eventName, data);
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 3000);
     try {
@@ -48,12 +67,15 @@ export async function sendTelemetryEvent(eventName, data, config) {
 }
 
 /**
- * Check if telemetry is enabled (opt-out model).
- * Returns false only when the user explicitly sets telemetry: false.
+ * Check if telemetry is enabled (opt-in model).
+ *
+ * Returns true ONLY when the user explicitly answered "yes" in the
+ * `kj init` wizard and we persisted `telemetry: true` to their config.
+ * Anything else — undefined, null, missing key, false — disables sending.
  *
  * @param {object} [config] - Karajan config
  * @returns {boolean}
  */
 export function isTelemetryEnabled(config) {
-  return config?.telemetry !== false;
+  return config?.telemetry === true;
 }

package/src/utils/tool-call-extractor.js

@@ -0,0 +1,56 @@
+// KJC-TSK-0375 PR2 — Extract structured tool calls from an agent transcript.
+//
+// The ToolCorrectnessJudgeRole (PR1) consumes a list of `{tool, args}`
+// objects. The coder writes a raw transcript (provider-dependent format) to
+// disk per iteration. This module bridges the two: parse the transcript,
+// return the ordered list of tool invocations.
+//
+// Provider-agnostic interface; Claude stream-json is the only format
+// implemented today. New providers add a branch below — keep parsers
+// pure (no I/O), so the role tests can mock transcripts trivially.
+
+const PROVIDER_PARSERS = {
+  claude: parseClaudeStreamJson,
+};
+
+/**
+ * Extract tool calls from a transcript string.
+ *
+ * @param {object} args
+ * @param {string} args.transcript - raw agent output (stdout/stderr buffer).
+ * @param {string} [args.provider] - "claude" (default). Unknown returns [].
+ * @returns {Array<{tool:string, args:object}>}
+ */
+export function extractToolCalls({ transcript, provider = "claude" } = {}) {
+  if (typeof transcript !== "string" || transcript.length === 0) return [];
+  const parser = PROVIDER_PARSERS[provider];
+  if (!parser) return [];
+  return parser(transcript);
+}
+
+// Claude emits one JSON event per line. We care about `assistant` events
+// whose `message.content` is an array containing `tool_use` blocks with
+// `{type:"tool_use", name, input}`. Lines that fail to parse, that are
+// not `assistant`, or whose content is not an array are silently skipped:
+// the transcript also carries `system`, `result`, `rate_limit_event`, etc.
+function parseClaudeStreamJson(transcript) {
+  const out = [];
+  for (const raw of transcript.split("\n")) {
+    const line = raw.trim();
+    if (!line || line[0] !== "{") continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+    if (obj?.type !== "assistant") continue;
+    const content = obj?.message?.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (block?.type === "tool_use" && typeof block.name === "string") {
+        out.push({
+          tool: block.name,
+          args: block.input && typeof block.input === "object" ? block.input : {},
+        });
+      }
+    }
+  }
+  return out;
+}

package/src/utils/vector-store-orphans.js

@@ -0,0 +1,89 @@
+/**
+ * RAG vector-store orphan collector — KJC-TSK-0499 PR2.
+ *
+ * Enumerates distinct `project_slug` rows in `~/.karajan/rag.db`,
+ * augments each with chunk count + last_indexed_{at,commit}, and
+ * marks as orphan the slugs whose basename does not resolve to a
+ * directory in any of the configured `projectRoots`.
+ *
+ * Read-only. Returns rows + a copy-paste sqlite3 command per orphan.
+ * Deliberate inverse of the RAG indexer: never opens the DB for write.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { dbPath, openVecStore, projectSlug } from "../rag/vec-store.js";
+
+const DEFAULT_ROOTS = [
+  path.join(os.homedir(), "ws_npm-packages"),
+  path.join(os.homedir(), "ws_firebase"),
+  path.join(os.homedir(), "projects"),
+  path.join(os.homedir(), "code"),
+];
+
+async function listDirs(root) {
+  try {
+    const entries = await fs.readdir(root, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => path.join(root, e.name));
+  } catch {
+    return [];
+  }
+}
+
+async function buildSlugIndex(roots) {
+  const index = new Map();
+  for (const root of roots) {
+    for (const dir of await listDirs(root)) {
+      const slug = projectSlug(dir);
+      if (slug && !index.has(slug)) index.set(slug, dir);
+    }
+  }
+  return index;
+}
+
+function purgeCommand(slug) {
+  const slugSafe = slug.replace(/'/g, "''");
+  return `sqlite3 ${dbPath()} "DELETE FROM chunks WHERE project_slug='${slugSafe}'; DELETE FROM vec_store_meta WHERE project_slug='${slugSafe}';"`;
+}
+
+/**
+ * Collect RAG vector-store orphans.
+ * @param {object} [opts]
+ * @param {string[]} [opts.projectRoots] — directories to look for live
+ *   projects whose basename matches each slug. Defaults to the usual
+ *   `~/ws_*`, `~/projects`, `~/code` set.
+ * @returns {Promise<{rows: Array, orphans: Array, errors: Array}>}
+ */
+export async function collectVectorStoreOrphans({ projectRoots = DEFAULT_ROOTS } = {}) {
+  const rows = [];
+  const errors = [];
+  let db;
+  try { db = openVecStore(); } catch (e) {
+    return { rows, orphans: [], errors: [{ stage: "open", error: String(e?.message ?? e) }] };
+  }
+  try {
+    const stats = db.prepare(`
+      SELECT COALESCE(c.project_slug, '<null>') AS slug,
+             COUNT(c.id) AS chunkCount,
+             COALESCE(m.last_indexed_commit, '') AS lastCommit,
+             COALESCE(m.last_indexed_at, '') AS lastAt
+      FROM chunks c
+      LEFT JOIN vec_store_meta m ON m.project_slug = c.project_slug
+      GROUP BY c.project_slug
+      ORDER BY chunkCount DESC
+    `).all();
+    const slugIndex = await buildSlugIndex(projectRoots);
+    for (const r of stats) {
+      const resolved = slugIndex.get(r.slug) || null;
+      rows.push({ ...r, resolvedDir: resolved, orphan: !resolved && r.slug !== "<null>" });
+    }
+  } catch (e) {
+    errors.push({ stage: "query", error: String(e?.message ?? e) });
+  } finally {
+    try { db.close(); } catch { /* close errors are non-fatal */ }
+  }
+  const orphans = rows
+    .filter((r) => r.orphan)
+    .map((r) => ({ ...r, command: purgeCommand(r.slug) }));
+  return { rows, orphans, errors };
+}