@townco/debugger 0.1.23 → 0.1.25

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@townco/debugger",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "type": "module",
   "engines": {
     "bun": ">=1.3.0"
   },
   "files": [
-    "src"
+    "src",
+    "tsconfig.json"
   ],
   "scripts": {
     "dev": "bun --hot src/index.ts",
@@ -19,18 +20,19 @@
     "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-slot": "^1.2.3",
     "@radix-ui/react-tabs": "^1.1.0",
-    "@townco/otlp-server": "0.1.23",
-    "@townco/ui": "0.1.68",
+    "@townco/otlp-server": "0.1.25",
+    "@townco/ui": "0.1.70",
     "bun-plugin-tailwind": "^0.1.2",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "lucide-react": "^0.545.0",
-    "react": "^19",
-    "react-dom": "^19",
-    "tailwind-merge": "^3.3.1"
+    "react": "19.2.1",
+    "react-dom": "19.2.1",
+    "tailwind-merge": "^3.3.1",
+    "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.65",
+    "@townco/tsconfig": "0.1.67",
     "@types/bun": "latest",
     "@types/react": "^19",
     "@types/react-dom": "^19",

package/src/App.tsx

@@ -1,8 +1,10 @@
 import { ThemeProvider } from "@townco/ui/gui";
 import { Component, type ReactNode } from "react";
 import "./index.css";
+import { ComparisonView } from "./pages/ComparisonView";
 import { SessionList } from "./pages/SessionList";
 import { SessionView } from "./pages/SessionView";
+import { TownHall } from "./pages/TownHall";
 import { TraceDetail } from "./pages/TraceDetail";
 import { TraceList } from "./pages/TraceList";
 
@@ -95,6 +97,17 @@ function AppContent() {
     return <TraceList />;
   }
 
+  // Route: /town-hall/compare/:runId
+  const comparisonMatch = pathname.match(/^\/town-hall\/compare\/(.+)$/);
+  if (comparisonMatch?.[1]) {
+    return <ComparisonView runId={comparisonMatch[1]} />;
+  }
+
+  // Route: /town-hall
+  if (pathname === "/town-hall") {
+    return <TownHall />;
+  }
+
   // Default: Session list
   return <SessionList />;
 }

package/src/comparison-db.test.ts

@@ -0,0 +1,113 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { ComparisonDb } from "./comparison-db";
+
+const TEST_DB = "test-comparison.db";
+
+describe("ComparisonDb", () => {
+  let db: ComparisonDb;
+
+  beforeEach(() => {
+    db = new ComparisonDb(TEST_DB);
+  });
+
+  afterEach(async () => {
+    db.close();
+    try {
+      await unlink(TEST_DB);
+    } catch {}
+  });
+
+  test("initializes tables and migrates", () => {
+    // Should not throw
+    new ComparisonDb(TEST_DB);
+  });
+
+  test("saves and retrieves config", () => {
+    const now = new Date().toISOString();
+    const config = {
+      id: "test-config",
+      dimension: "model" as const,
+      controlModel: "model-a",
+      variantModel: "model-b",
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    db.saveConfig(config);
+    const saved = db.getConfig("test-config");
+
+    // Compare non-timestamp fields and verify timestamps exist
+    expect(saved?.id).toBe(config.id);
+    expect(saved?.dimension).toBe(config.dimension);
+    expect(saved?.controlModel).toBe(config.controlModel);
+    expect(saved?.variantModel).toBe(config.variantModel);
+    expect(saved?.createdAt).toBeDefined();
+    expect(saved?.updatedAt).toBeDefined();
+    // Optional fields should be undefined when not set
+    expect(saved?.variantSystemPrompt).toBeUndefined();
+    expect(saved?.variantTools).toBeUndefined();
+  });
+
+  test("saves and retrieves config with tools", () => {
+    const config = {
+      id: "test-config-tools",
+      dimension: "tools" as const,
+      variantTools: ["tool-a", "tool-b"],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    db.saveConfig(config);
+    const saved = db.getConfig("test-config-tools");
+
+    expect(saved?.variantTools).toEqual(["tool-a", "tool-b"]);
+  });
+
+  test("creates and lists runs", () => {
+    const configId = "config-1";
+    db.saveConfig({
+      id: configId,
+      dimension: "model",
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    const run = db.createRun(configId, "session-1", "Hello");
+    expect(run.id).toBeDefined();
+    expect(run.status).toBe("pending");
+
+    const runs = db.listRuns();
+    expect(runs.length).toBe(1);
+    expect(runs[0]?.id).toBe(run.id);
+  });
+
+  test("updates run status and metrics", () => {
+    const configId = "config-1";
+    db.saveConfig({
+      id: configId,
+      dimension: "model",
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    const run = db.createRun(configId, "session-1", "Hello");
+
+    const metrics = {
+      durationMs: 1000,
+      inputTokens: 10,
+      outputTokens: 20,
+      totalTokens: 30,
+      estimatedCost: 0.01,
+      toolCallCount: 1,
+    };
+
+    db.updateRunStatus(run.id, "completed", {
+      controlMetrics: metrics,
+    });
+
+    const updated = db.getRun(run.id);
+    expect(updated?.status).toBe("completed");
+    expect(updated?.controlMetrics).toEqual(metrics);
+  });
+});

package/src/comparison-db.ts

@@ -0,0 +1,332 @@
+import { Database } from "bun:sqlite";
+import { SessionMetricsSchema, VariantToolsSchema } from "./schemas";
+import type {
+  ComparisonConfig,
+  ComparisonConfigRow,
+  ComparisonRun,
+  ComparisonRunRow,
+  SessionMetrics,
+} from "./types";
+
+const SCHEMA_VERSION = 1;
+
+export class ComparisonDb {
+  private db: Database;
+
+  constructor(dbPath: string) {
+    this.db = new Database(dbPath);
+    this.migrate();
+  }
+
+  close() {
+    this.db.close();
+  }
+
+  private migrate() {
+    // Get current schema version
+    const versionRow = this.db
+      .query<{ user_version: number }, []>("PRAGMA user_version")
+      .get();
+    const currentVersion = versionRow?.user_version ?? 0;
+
+    if (currentVersion < 1) {
+      // Initial schema
+      this.db.run(`
+        CREATE TABLE IF NOT EXISTS comparison_configs (
+          id TEXT PRIMARY KEY,
+          dimension TEXT NOT NULL,
+          control_model TEXT,
+          variant_model TEXT,
+          variant_system_prompt TEXT,
+          variant_tools TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )
+      `);
+
+      this.db.run(`
+        CREATE TABLE IF NOT EXISTS comparison_runs (
+          id TEXT PRIMARY KEY,
+          config_id TEXT NOT NULL,
+          source_session_id TEXT NOT NULL,
+          first_user_message TEXT NOT NULL,
+          start_message_index INTEGER NOT NULL DEFAULT 0,
+          turn_count INTEGER NOT NULL DEFAULT 1,
+          control_session_id TEXT,
+          variant_session_id TEXT,
+          status TEXT NOT NULL DEFAULT 'pending',
+          started_at TEXT NOT NULL,
+          completed_at TEXT,
+          control_metrics TEXT,
+          variant_metrics TEXT,
+          control_response TEXT,
+          variant_response TEXT,
+          FOREIGN KEY (config_id) REFERENCES comparison_configs(id)
+        )
+      `);
+
+      this.db.run(`
+        CREATE INDEX IF NOT EXISTS idx_comparison_runs_source_session
+        ON comparison_runs(source_session_id)
+      `);
+    }
+
+    // Future migrations would go here:
+    // if (currentVersion < 2) { ... }
+
+    // Update schema version
+    this.db.run(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+  }
+
+  // Comparison Config methods
+
+  saveConfig(config: ComparisonConfig): void {
+    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)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        dimension = excluded.dimension,
+        control_model = excluded.control_model,
+        variant_model = excluded.variant_model,
+        variant_system_prompt = excluded.variant_system_prompt,
+        variant_tools = excluded.variant_tools,
+        updated_at = excluded.updated_at
+      `,
+      [
+        config.id,
+        config.dimension,
+        config.controlModel ?? null,
+        config.variantModel ?? null,
+        config.variantSystemPrompt ?? null,
+        config.variantTools ? JSON.stringify(config.variantTools) : null,
+        config.createdAt || now,
+        now,
+      ],
+    );
+  }
+
+  getConfig(id: string): ComparisonConfig | null {
+    const row = this.db
+      .query<ComparisonConfigRow, [string]>(
+        `SELECT * FROM comparison_configs WHERE id = ?`,
+      )
+      .get(id);
+
+    if (!row) return null;
+    return this.rowToConfig(row);
+  }
+
+  getLatestConfig(): ComparisonConfig | null {
+    const row = this.db
+      .query<ComparisonConfigRow, []>(
+        `SELECT * FROM comparison_configs ORDER BY updated_at DESC LIMIT 1`,
+      )
+      .get();
+
+    if (!row) return null;
+    return this.rowToConfig(row);
+  }
+
+  private rowToConfig(row: ComparisonConfigRow): ComparisonConfig {
+    let variantTools: string[] | undefined;
+    if (row.variant_tools) {
+      try {
+        const parsed = JSON.parse(row.variant_tools);
+        const result = VariantToolsSchema.safeParse(parsed);
+        if (result.success) {
+          variantTools = result.data;
+        } else {
+          console.error("Invalid variant_tools schema:", result.error);
+        }
+      } catch (e) {
+        console.error("Failed to parse variant_tools JSON:", e);
+      }
+    }
+
+    return {
+      id: row.id,
+      dimension: row.dimension as ComparisonConfig["dimension"],
+      controlModel: row.control_model ?? undefined,
+      variantModel: row.variant_model ?? undefined,
+      variantSystemPrompt: row.variant_system_prompt ?? undefined,
+      variantTools,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  // Comparison Run methods
+
+  createRun(
+    configId: string,
+    sourceSessionId: string,
+    firstUserMessage: string,
+  ): ComparisonRun {
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+
+    this.db.run(
+      `
+      INSERT INTO comparison_runs (id, config_id, source_session_id, first_user_message, started_at, status)
+      VALUES (?, ?, ?, ?, ?, 'pending')
+      `,
+      [id, configId, sourceSessionId, firstUserMessage, now],
+    );
+
+    return {
+      id,
+      configId,
+      sourceSessionId,
+      firstUserMessage,
+      startMessageIndex: 0,
+      turnCount: 1,
+      controlSessionId: null,
+      variantSessionId: null,
+      status: "pending",
+      startedAt: now,
+      completedAt: null,
+      controlMetrics: null,
+      variantMetrics: null,
+      controlResponse: null,
+      variantResponse: null,
+    };
+  }
+
+  updateRunStatus(
+    id: string,
+    status: ComparisonRun["status"],
+    updates?: {
+      controlSessionId?: string;
+      variantSessionId?: string;
+      controlMetrics?: SessionMetrics;
+      variantMetrics?: SessionMetrics;
+      controlResponse?: string;
+      variantResponse?: string;
+    },
+  ): void {
+    const completedAt =
+      status === "completed" || status === "failed"
+        ? new Date().toISOString()
+        : null;
+
+    this.db.run(
+      `
+      UPDATE comparison_runs SET
+        status = ?,
+        completed_at = COALESCE(?, completed_at),
+        control_session_id = COALESCE(?, control_session_id),
+        variant_session_id = COALESCE(?, variant_session_id),
+        control_metrics = COALESCE(?, control_metrics),
+        variant_metrics = COALESCE(?, variant_metrics),
+        control_response = COALESCE(?, control_response),
+        variant_response = COALESCE(?, variant_response)
+      WHERE id = ?
+      `,
+      [
+        status,
+        completedAt,
+        updates?.controlSessionId ?? null,
+        updates?.variantSessionId ?? null,
+        updates?.controlMetrics ? JSON.stringify(updates.controlMetrics) : null,
+        updates?.variantMetrics ? JSON.stringify(updates.variantMetrics) : null,
+        updates?.controlResponse ?? null,
+        updates?.variantResponse ?? null,
+        id,
+      ],
+    );
+  }
+
+  getRun(id: string): ComparisonRun | null {
+    const row = this.db
+      .query<ComparisonRunRow, [string]>(
+        `SELECT * FROM comparison_runs WHERE id = ?`,
+      )
+      .get(id);
+
+    if (!row) return null;
+    return this.rowToRun(row);
+  }
+
+  listRuns(limit = 50, offset = 0): ComparisonRun[] {
+    const rows = this.db
+      .query<ComparisonRunRow, [number, number]>(
+        `SELECT * FROM comparison_runs ORDER BY started_at DESC LIMIT ? OFFSET ?`,
+      )
+      .all(limit, offset);
+
+    return rows.map((row) => this.rowToRun(row));
+  }
+
+  listRunsBySourceSession(sourceSessionId: string): ComparisonRun[] {
+    const rows = this.db
+      .query<ComparisonRunRow, [string]>(
+        `SELECT * FROM comparison_runs WHERE source_session_id = ? ORDER BY started_at DESC`,
+      )
+      .all(sourceSessionId);
+
+    return rows.map((row) => this.rowToRun(row));
+  }
+
+  /**
+   * Get all session IDs that were created as part of comparison runs.
+   * This includes both control and variant session IDs.
+   */
+  getComparisonSessionIds(): string[] {
+    const rows = this.db
+      .query<
+        {
+          control_session_id: string | null;
+          variant_session_id: string | null;
+        },
+        []
+      >(
+        `SELECT control_session_id, variant_session_id FROM comparison_runs WHERE control_session_id IS NOT NULL OR variant_session_id IS NOT NULL`,
+      )
+      .all();
+
+    const sessionIds: string[] = [];
+    for (const row of rows) {
+      if (row.control_session_id) sessionIds.push(row.control_session_id);
+      if (row.variant_session_id) sessionIds.push(row.variant_session_id);
+    }
+    return sessionIds;
+  }
+
+  private parseMetrics(json: string | null): SessionMetrics | null {
+    if (!json) return null;
+    try {
+      const parsed = JSON.parse(json);
+      const result = SessionMetricsSchema.safeParse(parsed);
+      if (result.success) {
+        return result.data;
+      }
+      console.error("Invalid metrics schema:", result.error);
+      return null;
+    } catch (e) {
+      console.error("Failed to parse metrics JSON:", e);
+      return null;
+    }
+  }
+
+  private rowToRun(row: ComparisonRunRow): ComparisonRun {
+    return {
+      id: row.id,
+      configId: row.config_id,
+      sourceSessionId: row.source_session_id,
+      firstUserMessage: row.first_user_message,
+      startMessageIndex: row.start_message_index,
+      turnCount: row.turn_count,
+      controlSessionId: row.control_session_id,
+      variantSessionId: row.variant_session_id,
+      status: row.status as ComparisonRun["status"],
+      startedAt: row.started_at,
+      completedAt: row.completed_at,
+      controlMetrics: this.parseMetrics(row.control_metrics),
+      variantMetrics: this.parseMetrics(row.variant_metrics),
+      controlResponse: row.control_response ?? null,
+      variantResponse: row.variant_response ?? null,
+    };
+  }
+}

package/src/components/DebuggerHeader.tsx

@@ -1,5 +1,14 @@
-import { ChatHeader, cn, ThemeToggle } from "@townco/ui/gui";
-import { ArrowLeft } from "lucide-react";
+import {
+  ChatHeader,
+  cn,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+  ThemeToggle,
+} from "@townco/ui/gui";
+import { ArrowLeft, Database, MoreVertical } from "lucide-react";
 import { useEffect, useState } from "react";
 import { Button } from "@/components/ui/button";
 
@@ -20,6 +29,7 @@ export function DebuggerHeader({
     typeof window !== "undefined" ? window.location.pathname : "/";
   const isSessionsActive = pathname === "/";
   const isTracesActive = pathname === "/traces";
+  const isTownHallActive = pathname.startsWith("/town-hall");
   const [agentName, setAgentName] = useState<string>("Agent");
 
   useEffect(() => {
@@ -35,6 +45,32 @@ export function DebuggerHeader({
       });
   }, []);
 
+  const handleResetDatabase = async () => {
+    if (
+      !window.confirm(
+        "Are you sure you want to reset the database? This will delete all traces and sessions.",
+      )
+    ) {
+      return;
+    }
+
+    try {
+      const response = await fetch("/api/reset-database", {
+        method: "POST",
+      });
+
+      if (response.ok) {
+        alert("Database reset successfully. Redirecting to home...");
+        window.location.href = "/";
+      } else {
+        const error = await response.text();
+        alert(`Failed to reset database: ${error}`);
+      }
+    } catch (error) {
+      alert(`Error resetting database: ${error}`);
+    }
+  };
+
   return (
     <ChatHeader.Root className="border-b border-border bg-card h-16">
       <div className="flex items-center gap-3 flex-1">
@@ -71,6 +107,17 @@ export function DebuggerHeader({
               >
                 Traces
               </a>
+              <a
+                href="/town-hall"
+                className={cn(
+                  "px-3 py-1.5 rounded-md text-sm font-medium transition-colors",
+                  isTownHallActive
+                    ? "bg-muted text-foreground"
+                    : "text-muted-foreground hover:text-foreground hover:bg-muted/50",
+                )}
+              >
+                Town Hall
+              </a>
             </nav>
           </div>
         ) : (
@@ -78,6 +125,19 @@ export function DebuggerHeader({
         )}
       </div>
       <ChatHeader.Actions>
+        <DropdownMenu>
+          <DropdownMenuTrigger asChild>
+            <Button variant="ghost" size="icon">
+              <MoreVertical className="size-4" />
+            </Button>
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="end">
+            <DropdownMenuItem onClick={handleResetDatabase}>
+              <Database className="mr-2 size-4" />
+              Reset Database
+            </DropdownMenuItem>
+          </DropdownMenuContent>
+        </DropdownMenu>
         <ThemeToggle />
       </ChatHeader.Actions>
     </ChatHeader.Root>