@townco/debugger 0.1.28 → 0.1.29

package/src/analysis-db.ts

@@ -0,0 +1,238 @@
+import { Database } from "bun:sqlite";
+import type { Connection, Table } from "@lancedb/lancedb";
+import { connect } from "@lancedb/lancedb";
+import type { SessionAnalysis } from "./analysis/types";
+
+export class AnalysisDb {
+  private db: Database;
+  private lanceDb: Connection | null = null;
+  private embeddingTable: Table | null = null;
+  private lanceDbInitialized: Promise<void>;
+
+  constructor(dbPath: string) {
+    // Open the main debugger database (not readonly, since we need to write)
+    this.db = new Database(dbPath);
+    console.log("AnalysisDb: Opening database at", dbPath);
+
+    this.initTables();
+    this.lanceDbInitialized = this.initLanceDb(dbPath);
+  }
+
+  private async initLanceDb(dbPath: string): Promise<void> {
+    try {
+      // LanceDB stores in a directory, use same location as SQLite db
+      const lanceDbPath = dbPath.replace(/\.db$/, ".lancedb");
+      console.log("AnalysisDb: Initializing LanceDB at", lanceDbPath);
+
+      this.lanceDb = await connect(lanceDbPath);
+
+      // Check if table exists, create if not
+      const tableNames = await this.lanceDb.tableNames();
+      if (tableNames.includes("session_embeddings")) {
+        this.embeddingTable =
+          await this.lanceDb.openTable("session_embeddings");
+      } else {
+        // Create table with schema
+        this.embeddingTable = await this.lanceDb.createTable(
+          "session_embeddings",
+          [{ session_id: "placeholder", embedding: new Array(1536).fill(0) }],
+        );
+      }
+
+      console.log("AnalysisDb: LanceDB initialized successfully");
+    } catch (error) {
+      console.error("Failed to initialize LanceDB:", error);
+      console.warn("Embedding functionality will be disabled");
+    }
+  }
+
+  private initTables() {
+    console.log("AnalysisDb: Initializing SQLite tables...");
+
+    // Create session_analyses table
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS session_analyses (
+        session_id TEXT PRIMARY KEY,
+        analysis_json TEXT NOT NULL,
+        analyzed_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
+
+    // Create index on analyzed_at for sorting
+    this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_session_analyses_analyzed_at
+      ON session_analyses(analyzed_at)
+    `);
+
+    console.log("AnalysisDb: SQLite tables initialized");
+  }
+
+  saveAnalysis(analysis: SessionAnalysis): void {
+    const now = new Date().toISOString();
+
+    this.db.run(
+      `INSERT INTO session_analyses (
+        session_id, analysis_json, analyzed_at, updated_at
+      ) VALUES (?, ?, ?, ?)
+      ON CONFLICT(session_id) DO UPDATE SET
+        analysis_json = excluded.analysis_json,
+        updated_at = excluded.updated_at
+      `,
+      [analysis.session_id, JSON.stringify(analysis), now, now],
+    );
+  }
+
+  getAnalysis(sessionId: string): SessionAnalysis | null {
+    const row = this.db
+      .query<{ analysis_json: string }, [string]>(
+        `SELECT analysis_json FROM session_analyses WHERE session_id = ?`,
+      )
+      .get(sessionId);
+
+    if (!row) return null;
+
+    return JSON.parse(row.analysis_json) as SessionAnalysis;
+  }
+
+  listAnalyses(limit = 50, offset = 0): SessionAnalysis[] {
+    const rows = this.db
+      .query<{ analysis_json: string }, [number, number]>(
+        `SELECT analysis_json FROM session_analyses
+         ORDER BY analyzed_at DESC
+         LIMIT ? OFFSET ?`,
+      )
+      .all(limit, offset);
+
+    return rows.map((row) => JSON.parse(row.analysis_json) as SessionAnalysis);
+  }
+
+  /**
+   * Saves an embedding for a session analysis.
+   * If an embedding already exists for this session, it will be replaced.
+   */
+  async saveEmbedding(
+    sessionId: string,
+    embedding: Float32Array,
+  ): Promise<void> {
+    // Wait for LanceDB to initialize
+    await this.lanceDbInitialized;
+
+    if (!this.embeddingTable) {
+      console.warn("LanceDB not initialized, skipping embedding save");
+      return;
+    }
+
+    try {
+      // LanceDB uses add() to insert/upsert records
+      // Convert Float32Array to regular array for LanceDB
+      const embeddingArray = Array.from(embedding);
+
+      await this.embeddingTable.add([
+        {
+          session_id: sessionId,
+          embedding: embeddingArray,
+        },
+      ]);
+
+      console.log(`AnalysisDb: Saved embedding for session ${sessionId}`);
+    } catch (error) {
+      console.error(`Failed to save embedding for ${sessionId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Retrieves the embedding for a session.
+   * Returns null if no embedding exists.
+   */
+  async getEmbedding(sessionId: string): Promise<Float32Array | null> {
+    // Wait for LanceDB to initialize
+    await this.lanceDbInitialized;
+
+    if (!this.embeddingTable) {
+      return null;
+    }
+
+    try {
+      // We need to do a vector search to query LanceDB
+      // Use a dummy vector and large limit to get all records, then filter
+      const dummyVector = new Array(1536).fill(0);
+      const allRecords = await this.embeddingTable
+        .search(dummyVector)
+        .limit(1000) // Should be enough for most use cases
+        .toArray();
+
+      const record = allRecords.find((r: any) => r.session_id === sessionId);
+
+      if (!record) {
+        return null;
+      }
+
+      const embedding = record.embedding;
+      return new Float32Array(embedding);
+    } catch (error) {
+      console.error("Error retrieving embedding:", error);
+      return null;
+    }
+  }
+
+  /**
+   * Searches for sessions with similar embeddings using KNN search.
+   * Returns session IDs with their distance scores (lower = more similar).
+   */
+  async searchSimilarSessions(
+    embedding: Float32Array,
+    limit = 10,
+  ): Promise<Array<{ session_id: string; distance: number }>> {
+    // Wait for LanceDB to initialize
+    await this.lanceDbInitialized;
+
+    if (!this.embeddingTable) {
+      return [];
+    }
+
+    try {
+      // LanceDB vector search
+      const embeddingArray = Array.from(embedding);
+      const results = await this.embeddingTable
+        .search(embeddingArray)
+        .limit(limit)
+        .toArray();
+
+      return results.map((result: any) => ({
+        session_id: result.session_id,
+        distance: result._distance,
+      }));
+    } catch (error) {
+      console.error("Error searching similar sessions:", error);
+      return [];
+    }
+  }
+
+  /**
+   * Checks if an embedding exists for a session.
+   */
+  async hasEmbedding(sessionId: string): Promise<boolean> {
+    // Wait for LanceDB to initialize
+    await this.lanceDbInitialized;
+
+    if (!this.embeddingTable) {
+      return false;
+    }
+
+    try {
+      // Use a dummy vector search to get all records, then check if session exists
+      const dummyVector = new Array(1536).fill(0);
+      const allRecords = await this.embeddingTable
+        .search(dummyVector)
+        .limit(1000)
+        .toArray();
+
+      return allRecords.some((r: any) => r.session_id === sessionId);
+    } catch (error) {
+      console.error("Error checking embedding existence:", error);
+      return false;
+    }
+  }
+}

package/src/comparison-db.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { ComparisonDb } from "./comparison-db";
+import type { ComparisonDimension } from "./types";
 
 const TEST_DB = "test-comparison.db";
 
@@ -27,7 +28,7 @@ describe("ComparisonDb", () => {
     const now = new Date().toISOString();
     const config = {
       id: "test-config",
-      dimension: "model" as const,
+      dimensions: ["model"] as ComparisonDimension[],
       controlModel: "model-a",
       variantModel: "model-b",
       createdAt: now,
@@ -39,7 +40,7 @@ describe("ComparisonDb", () => {
 
     // Compare non-timestamp fields and verify timestamps exist
     expect(saved?.id).toBe(config.id);
-    expect(saved?.dimension).toBe(config.dimension);
+    expect(saved?.dimensions).toEqual(config.dimensions);
     expect(saved?.controlModel).toBe(config.controlModel);
     expect(saved?.variantModel).toBe(config.variantModel);
     expect(saved?.createdAt).toBeDefined();
@@ -52,7 +53,7 @@ describe("ComparisonDb", () => {
   test("saves and retrieves config with tools", () => {
     const config = {
       id: "test-config-tools",
-      dimension: "tools" as const,
+      dimensions: ["tools"] as ComparisonDimension[],
       variantTools: ["tool-a", "tool-b"],
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
@@ -64,11 +65,32 @@ describe("ComparisonDb", () => {
     expect(saved?.variantTools).toEqual(["tool-a", "tool-b"]);
   });
 
+  test("saves and retrieves config with multiple dimensions", () => {
+    const config = {
+      id: "test-config-multi",
+      dimensions: ["model", "system_prompt", "tools"] as ComparisonDimension[],
+      controlModel: "model-a",
+      variantModel: "model-b",
+      variantSystemPrompt: "You are a test assistant",
+      variantTools: ["tool-a"],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    db.saveConfig(config);
+    const saved = db.getConfig("test-config-multi");
+
+    expect(saved?.dimensions).toEqual(["model", "system_prompt", "tools"]);
+    expect(saved?.variantModel).toBe("model-b");
+    expect(saved?.variantSystemPrompt).toBe("You are a test assistant");
+    expect(saved?.variantTools).toEqual(["tool-a"]);
+  });
+
   test("creates and lists runs", () => {
     const configId = "config-1";
     db.saveConfig({
       id: configId,
-      dimension: "model",
+      dimensions: ["model"] as ComparisonDimension[],
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
     });
@@ -86,7 +108,7 @@ describe("ComparisonDb", () => {
     const configId = "config-1";
     db.saveConfig({
       id: configId,
-      dimension: "model",
+      dimensions: ["model"] as ComparisonDimension[],
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
     });
@@ -100,6 +122,7 @@ describe("ComparisonDb", () => {
       totalTokens: 30,
       estimatedCost: 0.01,
       toolCallCount: 1,
+      toolCalls: [],
     };
 
     db.updateRunStatus(run.id, "completed", {

package/src/comparison-db.ts

@@ -8,7 +8,7 @@ import type {
   SessionMetrics,
 } from "./types";
 
-const SCHEMA_VERSION = 1;
+const SCHEMA_VERSION = 2;
 
 export class ComparisonDb {
   private db: Database;
@@ -34,7 +34,7 @@ export class ComparisonDb {
       this.db.run(`
         CREATE TABLE IF NOT EXISTS comparison_configs (
           id TEXT PRIMARY KEY,
-          dimension TEXT NOT NULL,
+          dimensions TEXT NOT NULL,
           control_model TEXT,
           variant_model TEXT,
           variant_system_prompt TEXT,
@@ -71,8 +71,32 @@ export class ComparisonDb {
       `);
     }
 
-    // Future migrations would go here:
-    // if (currentVersion < 2) { ... }
+    // Migration: rename 'dimension' column to 'dimensions' and convert to JSON array
+    if (currentVersion < 2) {
+      // Check if old 'dimension' column exists
+      const tableInfo = this.db
+        .query<{ name: string }, []>("PRAGMA table_info(comparison_configs)")
+        .all();
+      const hasDimensionColumn = tableInfo.some(
+        (col) => col.name === "dimension",
+      );
+      const hasDimensionsColumn = tableInfo.some(
+        (col) => col.name === "dimensions",
+      );
+
+      if (hasDimensionColumn && !hasDimensionsColumn) {
+        // Rename column and migrate data
+        this.db.run(
+          `ALTER TABLE comparison_configs RENAME COLUMN dimension TO dimensions`,
+        );
+        // Convert single dimension values to JSON arrays
+        this.db.run(`
+          UPDATE comparison_configs
+          SET dimensions = '["' || dimensions || '"]'
+          WHERE dimensions NOT LIKE '[%'
+        `);
+      }
+    }
 
     // Update schema version
     this.db.run(`PRAGMA user_version = ${SCHEMA_VERSION}`);
@@ -84,10 +108,10 @@ export class ComparisonDb {
     const now = new Date().toISOString();
     this.db.run(
       `
-      INSERT INTO comparison_configs (id, dimension, control_model, variant_model, variant_system_prompt, variant_tools, created_at, updated_at)
+      INSERT INTO comparison_configs (id, dimensions, control_model, variant_model, variant_system_prompt, variant_tools, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
-        dimension = excluded.dimension,
+        dimensions = excluded.dimensions,
         control_model = excluded.control_model,
         variant_model = excluded.variant_model,
         variant_system_prompt = excluded.variant_system_prompt,
@@ -96,7 +120,7 @@ export class ComparisonDb {
       `,
       [
         config.id,
-        config.dimension,
+        JSON.stringify(config.dimensions),
         config.controlModel ?? null,
         config.variantModel ?? null,
         config.variantSystemPrompt ?? null,
@@ -145,9 +169,32 @@ export class ComparisonDb {
       }
     }
 
+    // Parse dimensions from JSON array
+    let dimensions: ComparisonConfig["dimensions"] = [];
+    if (row.dimensions) {
+      try {
+        const parsed = JSON.parse(row.dimensions);
+        if (Array.isArray(parsed)) {
+          dimensions = parsed as ComparisonConfig["dimensions"];
+        } else if (typeof parsed === "string") {
+          // Handle case where it's a single dimension string (legacy format)
+          dimensions = [parsed as ComparisonConfig["dimensions"][number]];
+        }
+      } catch (e) {
+        // If JSON parsing fails, it might be a plain string (legacy format before migration)
+        if (typeof row.dimensions === "string" && row.dimensions.length > 0) {
+          dimensions = [
+            row.dimensions as ComparisonConfig["dimensions"][number],
+          ];
+        } else {
+          console.error("Failed to parse dimensions JSON:", e);
+        }
+      }
+    }
+
     return {
       id: row.id,
-      dimension: row.dimension as ComparisonConfig["dimension"],
+      dimensions,
       controlModel: row.control_model ?? undefined,
       variantModel: row.variant_model ?? undefined,
       variantSystemPrompt: row.variant_system_prompt ?? undefined,
@@ -303,7 +350,8 @@ export class ComparisonDb {
         return result.data;
       }
       console.error("Invalid metrics schema:", result.error);
-      return null;
+      const fallback = SessionMetricsSchema.safeParse({});
+      return fallback.success ? fallback.data : null;
     } catch (e) {
       console.error("Failed to parse metrics JSON:", e);
       return null;

package/src/components/AnalyzeAllButton.tsx

@@ -0,0 +1,81 @@
+import { Sparkles } from "lucide-react";
+import { useState } from "react";
+import { Button } from "./ui/button";
+
+interface Props {
+  sessionIds: string[];
+  onComplete?: () => void;
+}
+
+export function AnalyzeAllButton({ sessionIds, onComplete }: Props) {
+  const [loading, setLoading] = useState(false);
+  const [progress, setProgress] = useState<{
+    completed: number;
+    total: number;
+    errors: number;
+  } | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const handleAnalyzeAll = async () => {
+    setLoading(true);
+    setError(null);
+    setProgress({ completed: 0, total: sessionIds.length, errors: 0 });
+
+    try {
+      const response = await fetch("/api/analyze-all-sessions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sessionIds }),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.error || response.statusText);
+      }
+
+      const { results } = await response.json();
+
+      // Count successes and errors
+      const completed = results.filter((r: any) => r.success).length;
+      const errors = results.filter((r: any) => !r.success).length;
+
+      setProgress({ completed, total: sessionIds.length, errors });
+
+      if (onComplete) {
+        onComplete();
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Analysis failed";
+      setError(message);
+      console.error("Batch analysis error:", err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <div className="flex flex-col gap-2">
+      <Button
+        variant="default"
+        onClick={handleAnalyzeAll}
+        disabled={loading || sessionIds.length === 0}
+      >
+        <Sparkles className="size-4 mr-2" />
+        {loading
+          ? `Analyzing ${progress?.completed}/${progress?.total}...`
+          : `Analyze All (${sessionIds.length})`}
+      </Button>
+
+      {progress && !loading && (
+        <div className="text-sm text-muted-foreground">
+          Completed: {progress.completed}/{progress.total}
+          {progress.errors > 0 && ` (${progress.errors} errors)`}
+        </div>
+      )}
+
+      {error && (
+        <div className="text-sm text-destructive max-w-md">{error}</div>
+      )}
+    </div>
+  );
+}

package/src/components/DebuggerHeader.tsx

@@ -29,6 +29,7 @@ export function DebuggerHeader({
     typeof window !== "undefined" ? window.location.pathname : "/";
   const isSessionsActive = pathname === "/";
   const isTracesActive = pathname === "/traces";
+  const isFindSessionsActive = pathname === "/find-sessions";
   const isTownHallActive = pathname.startsWith("/town-hall");
   const [agentName, setAgentName] = useState<string>("Agent");
 
@@ -107,6 +108,17 @@ export function DebuggerHeader({
               >
                 Traces
               </a>
+              <a
+                href="/find-sessions"
+                className={cn(
+                  "px-3 py-1.5 rounded-md text-sm font-medium transition-colors",
+                  isFindSessionsActive
+                    ? "bg-muted text-foreground"
+                    : "text-muted-foreground hover:text-foreground hover:bg-muted/50",
+                )}
+              >
+                Find Sessions
+              </a>
               <a
                 href="/town-hall"
                 className={cn(

package/src/components/SessionAnalysisButton.tsx

@@ -0,0 +1,109 @@
+import { Eye, Sparkles } from "lucide-react";
+import { useState } from "react";
+import type { SessionAnalysis } from "../analysis/types";
+import { SessionAnalysisDialog } from "./SessionAnalysisDialog";
+import { Button } from "./ui/button";
+
+interface Props {
+  sessionId: string;
+  existingAnalysis?: SessionAnalysis | null;
+  onAnalysisComplete?: (analysis: SessionAnalysis) => void;
+}
+
+export function SessionAnalysisButton({
+  sessionId,
+  existingAnalysis,
+  onAnalysisComplete,
+}: Props) {
+  const [showDialog, setShowDialog] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [analysis, setAnalysis] = useState<SessionAnalysis | null>(
+    existingAnalysis || null,
+  );
+
+  // Show existing analysis without re-analyzing
+  const handleShowAnalysis = () => {
+    if (existingAnalysis) {
+      setAnalysis(existingAnalysis);
+      setShowDialog(true);
+    }
+  };
+
+  // Analyze (or re-analyze) the session
+  const handleAnalyze = async () => {
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch(`/api/analyze-session/${sessionId}`, {
+        method: "POST",
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.error || response.statusText);
+      }
+
+      const result = await response.json();
+      setAnalysis(result);
+      setShowDialog(true);
+
+      // Notify parent component
+      if (onAnalysisComplete) {
+        onAnalysisComplete(result);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Analysis failed";
+      setError(message);
+      console.error("Session analysis error:", err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <>
+      <div className="flex gap-2">
+        {existingAnalysis ? (
+          // Show both buttons when analysis exists
+          <>
+            <Button size="sm" onClick={handleShowAnalysis}>
+              <Eye className="size-4 mr-2" />
+              Show Analysis
+            </Button>
+            <Button
+              size="sm"
+              variant="outline"
+              onClick={handleAnalyze}
+              disabled={loading}
+            >
+              <Sparkles className="size-4 mr-2" />
+              {loading ? "Re-analyzing..." : "Re-analyze"}
+            </Button>
+          </>
+        ) : (
+          // Show only "Analyze Session" button if no analysis exists
+          <Button size="sm" onClick={handleAnalyze} disabled={loading}>
+            <Sparkles className="size-4 mr-2" />
+            {loading ? "Analyzing..." : "Analyze Session"}
+          </Button>
+        )}
+      </div>
+
+      {showDialog && analysis && (
+        <SessionAnalysisDialog
+          open={showDialog}
+          onClose={() => setShowDialog(false)}
+          analysis={analysis}
+        />
+      )}
+
+      {error && (
+        <div className="absolute top-14 right-4 bg-destructive text-white text-sm px-3 py-2 rounded shadow-lg max-w-md">
+          {error}
+        </div>
+      )}
+    </>
+  );
+}