tokentrace 0.1.0

package/fixtures/generic-jsonl/sample.jsonl

@@ -0,0 +1,2 @@
+{"timestamp":"2026-01-02T10:00:00.000Z","session_id":"demo-session","role":"user","model":"gpt-4.1-mini","cwd":"/tmp/tokentrace-demo","content":"Summarize this repository.","usage":{"input_tokens":120,"output_tokens":0,"total_tokens":120}}
+{"timestamp":"2026-01-02T10:00:03.000Z","session_id":"demo-session","role":"assistant","model":"gpt-4.1-mini","cwd":"/tmp/tokentrace-demo","content":"This repository contains a local analytics app.","usage":{"input_tokens":0,"output_tokens":85,"total_tokens":85},"tool_calls":[{"id":"tool-1","name":"read_file","status":"ok","duration_ms":34}]}

package/next.config.mjs

@@ -0,0 +1,7 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  serverExternalPackages: ["better-sqlite3"],
+  typedRoutes: false
+};
+
+export default nextConfig;

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "tokentrace",
+  "version": "0.1.0",
+  "description": "Local-first dashboard for AI CLI token, cost, and session analytics.",
+  "type": "module",
+  "homepage": "https://github.com/abhiyoheswaran1/tokentrace#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abhiyoheswaran1/tokentrace.git"
+  },
+  "bugs": {
+    "url": "https://github.com/abhiyoheswaran1/tokentrace/issues"
+  },
+  "bin": {
+    "tokentrace": "bin/tokentrace.js"
+  },
+  "files": [
+    "bin",
+    ".next/BUILD_ID",
+    ".next/*.json",
+    ".next/server",
+    ".next/static",
+    "public",
+    "app",
+    "components",
+    "src",
+    "scripts",
+    "dist",
+    "fixtures",
+    "next.config.mjs",
+    "postcss.config.mjs",
+    "tailwind.config.ts",
+    "tsconfig.json",
+    "components.json",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build && node scripts/build-cli-runtime.mjs",
+    "start": "next start",
+    "scan": "tsx scripts/scan.ts",
+    "db:migrate": "tsx scripts/db-migrate.ts",
+    "db:seed": "tsx scripts/db-seed.ts",
+    "reset": "tsx scripts/reset.ts",
+    "test": "vitest run",
+    "package:test": "npm test && npm pack --dry-run",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "keywords": [
+    "tokens",
+    "ai",
+    "cli",
+    "analytics",
+    "codex",
+    "claude",
+    "local-first",
+    "nextjs",
+    "sqlite"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@radix-ui/react-slot": "^1.1.1",
+    "better-sqlite3": "^11.7.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "date-fns": "^4.1.0",
+    "drizzle-orm": "^0.38.3",
+    "get-port": "^7.2.0",
+    "lucide-react": "^0.468.0",
+    "next": "^15.1.4",
+    "open": "^10.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "recharts": "^2.15.0",
+    "tailwind-merge": "^2.6.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^22.10.5",
+    "@types/react": "^19.0.4",
+    "@types/react-dom": "^19.0.2",
+    "autoprefixer": "^10.4.20",
+    "drizzle-kit": "^0.30.1",
+    "esbuild": "^0.28.0",
+    "eslint": "^9.17.0",
+    "eslint-config-next": "^15.1.4",
+    "postcss": "^8.4.49",
+    "tailwindcss": "^3.4.17",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}

package/postcss.config.mjs

@@ -0,0 +1,8 @@
+const config = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {}
+  }
+};
+
+export default config;

package/scripts/build-cli-runtime.mjs

@@ -0,0 +1,40 @@
+import { build } from "esbuild";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const outdir = path.join(process.cwd(), "dist", "runtime");
+
+await fs.rm(outdir, { recursive: true, force: true });
+await fs.mkdir(outdir, { recursive: true });
+
+const entryPoints = {
+  "db-migrate": "scripts/db-migrate.ts",
+  "db-seed": "scripts/db-seed.ts",
+  reset: "scripts/reset.ts",
+  scan: "scripts/scan.ts"
+};
+
+await Promise.all(
+  Object.entries(entryPoints).map(([name, entryPoint]) =>
+    build({
+      entryPoints: [entryPoint],
+      outfile: path.join(outdir, `${name}.mjs`),
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      target: "node18",
+      sourcemap: false,
+      packages: "external",
+      external: ["better-sqlite3"],
+      logLevel: "silent",
+      banner: {
+        js: "import { createRequire as __tokentraceCreateRequire } from 'node:module'; const require = __tokentraceCreateRequire(import.meta.url);"
+      },
+      alias: {
+        "@": process.cwd()
+      }
+    })
+  )
+);
+
+console.log(`TokenTrace CLI runtime built at ${outdir}`);

package/scripts/db-migrate.ts

@@ -0,0 +1,5 @@
+import { getDatabasePath, sqlite } from "@/src/db/client";
+import { applyMigrations } from "@/src/db/migrate-core";
+
+applyMigrations(sqlite);
+console.log(`TokenTrace database migrated at ${getDatabasePath()}`);

package/scripts/db-seed.ts

@@ -0,0 +1,5 @@
+import { getDatabasePath } from "@/src/db/client";
+import { seedDatabase } from "@/src/db/seed";
+
+seedDatabase();
+console.log(`TokenTrace seed data written to ${getDatabasePath()}`);

package/scripts/reset.ts

@@ -0,0 +1,5 @@
+import { getDatabasePath } from "@/src/db/client";
+import { resetDatabase } from "@/src/db/reset";
+
+resetDatabase();
+console.log(`TokenTrace database reset at ${getDatabasePath()}`);

package/scripts/scan.ts

@@ -0,0 +1,30 @@
+import { runScan } from "@/src/ingestion/scan";
+
+const args = process.argv.slice(2);
+const json = args.includes("--json");
+const force = args.includes("--force");
+const folders = args.filter((arg) => arg !== "--force" && arg !== "--json");
+
+const result = await runScan({
+  force,
+  folders,
+  includeDefaults: folders.length === 0
+});
+
+const summary = {
+  scanRunId: result.scanRunId,
+  filesScanned: result.filesScanned,
+  recordsImported: result.recordsImported,
+  warnings: result.warnings.length,
+  errors: result.errors.length
+};
+
+if (json) {
+  console.log(JSON.stringify(summary, null, 2));
+} else {
+  console.log("TokenTrace scan complete");
+  console.log(`Files scanned: ${summary.filesScanned}`);
+  console.log(`Records imported: ${summary.recordsImported}`);
+  console.log(`Warnings: ${summary.warnings}`);
+  console.log(`Errors: ${summary.errors}`);
+}

package/src/db/client.ts

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { applyMigrations } from "./migrate-core";
+import * as schema from "./schema";
+
+const defaultDbPath = path.join(process.cwd(), ".tokentrace", "tokentrace.db");
+
+function databaseUrlPath(value: string | undefined) {
+  if (!value?.startsWith("file:")) return null;
+  try {
+    return fileURLToPath(value);
+  } catch {
+    return value.slice("file:".length);
+  }
+}
+
+const dbPath = process.env.TOKENTRACE_DB ?? databaseUrlPath(process.env.DATABASE_URL) ?? defaultDbPath;
+
+fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+
+export const sqlite = new Database(dbPath);
+sqlite.pragma("foreign_keys = ON");
+applyMigrations(sqlite);
+
+export const db = drizzle(sqlite, { schema });
+
+export function getDatabasePath() {
+  return dbPath;
+}

package/src/db/migrate-core.ts

@@ -0,0 +1,147 @@
+import Database from "better-sqlite3";
+
+const ddl = `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS providers (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  type TEXT NOT NULL,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+CREATE TABLE IF NOT EXISTS tools (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS tools_provider_name_idx ON tools(provider_id, name);
+
+CREATE TABLE IF NOT EXISTS models (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  input_token_price REAL,
+  output_token_price REAL,
+  cached_input_token_price REAL,
+  currency TEXT NOT NULL DEFAULT 'USD',
+  effective_from INTEGER,
+  raw_metadata TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS models_provider_name_idx ON models(provider_id, name);
+
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  path TEXT NOT NULL,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS projects_path_idx ON projects(path);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL,
+  tool_id TEXT NOT NULL REFERENCES tools(id) ON DELETE CASCADE,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  started_at INTEGER,
+  ended_at INTEGER,
+  title TEXT,
+  source_file TEXT NOT NULL,
+  raw_metadata TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS sessions_source_id_idx ON sessions(source_id);
+CREATE INDEX IF NOT EXISTS sessions_tool_idx ON sessions(tool_id);
+CREATE INDEX IF NOT EXISTS sessions_project_idx ON sessions(project_id);
+CREATE INDEX IF NOT EXISTS sessions_started_idx ON sessions(started_at);
+
+CREATE TABLE IF NOT EXISTS interactions (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  timestamp INTEGER,
+  role TEXT NOT NULL,
+  model_id TEXT REFERENCES models(id) ON DELETE SET NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  reasoning_tokens INTEGER NOT NULL DEFAULT 0,
+  total_tokens INTEGER NOT NULL DEFAULT 0,
+  estimated_tokens INTEGER NOT NULL DEFAULT 0,
+  token_confidence TEXT NOT NULL DEFAULT 'unknown',
+  cost REAL,
+  cost_estimated INTEGER NOT NULL DEFAULT 0,
+  latency_ms INTEGER,
+  raw_text_preview TEXT,
+  raw_text TEXT,
+  raw_metadata TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS interactions_source_id_idx ON interactions(source_id);
+CREATE INDEX IF NOT EXISTS interactions_session_idx ON interactions(session_id);
+CREATE INDEX IF NOT EXISTS interactions_model_idx ON interactions(model_id);
+CREATE INDEX IF NOT EXISTS interactions_timestamp_idx ON interactions(timestamp);
+
+PRAGMA user_version;
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id TEXT PRIMARY KEY,
+  interaction_id TEXT NOT NULL REFERENCES interactions(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  status TEXT,
+  duration_ms INTEGER,
+  raw_metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS tool_calls_interaction_idx ON tool_calls(interaction_id);
+
+CREATE TABLE IF NOT EXISTS scan_runs (
+  id TEXT PRIMARY KEY,
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  files_scanned INTEGER NOT NULL DEFAULT 0,
+  records_imported INTEGER NOT NULL DEFAULT 0,
+  warnings TEXT NOT NULL DEFAULT '[]',
+  errors TEXT NOT NULL DEFAULT '[]'
+);
+
+CREATE TABLE IF NOT EXISTS scan_files (
+  id TEXT PRIMARY KEY,
+  scan_run_id TEXT NOT NULL REFERENCES scan_runs(id) ON DELETE CASCADE,
+  path TEXT NOT NULL,
+  modified_time INTEGER,
+  size_bytes INTEGER NOT NULL DEFAULT 0,
+  file_hash TEXT,
+  parser TEXT,
+  status TEXT NOT NULL,
+  records_imported INTEGER NOT NULL DEFAULT 0,
+  warnings TEXT NOT NULL DEFAULT '[]',
+  errors TEXT NOT NULL DEFAULT '[]',
+  raw_metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS scan_files_path_hash_idx ON scan_files(path, file_hash);
+CREATE INDEX IF NOT EXISTS scan_files_run_idx ON scan_files(scan_run_id);
+
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+`;
+
+export function applyMigrations(sqlite: Database.Database) {
+  sqlite.exec(ddl);
+  const columns = sqlite.prepare("PRAGMA table_info(interactions)").all() as Array<{ name: string }>;
+  if (!columns.some((column) => column.name === "token_confidence")) {
+    try {
+      sqlite.exec("ALTER TABLE interactions ADD COLUMN token_confidence TEXT NOT NULL DEFAULT 'unknown'");
+    } catch (error) {
+      if (
+        !(error instanceof Error) ||
+        !error.message.toLowerCase().includes("duplicate column")
+      ) {
+        throw error;
+      }
+    }
+  }
+}

package/src/db/reset.ts

@@ -0,0 +1,14 @@
+import { sqlite } from "./client";
+import { seedDatabase } from "./seed";
+
+export function resetDatabase() {
+  sqlite.exec(`
+    DELETE FROM tool_calls;
+    DELETE FROM interactions;
+    DELETE FROM sessions;
+    DELETE FROM projects;
+    DELETE FROM scan_files;
+    DELETE FROM scan_runs;
+  `);
+  seedDatabase();
+}

package/src/db/schema.ts

@@ -0,0 +1,259 @@
+import { relations, sql } from "drizzle-orm";
+import {
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+  uniqueIndex
+} from "drizzle-orm/sqlite-core";
+
+export const providers = sqliteTable("providers", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  type: text("type").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp_ms" })
+    .notNull()
+    .$defaultFn(() => new Date())
+});
+
+export const tools = sqliteTable(
+  "tools",
+  {
+    id: text("id").primaryKey(),
+    providerId: text("provider_id")
+      .notNull()
+      .references(() => providers.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" })
+      .notNull()
+      .$defaultFn(() => new Date())
+  },
+  (table) => ({
+    providerNameIdx: uniqueIndex("tools_provider_name_idx").on(
+      table.providerId,
+      table.name
+    )
+  })
+);
+
+export const models = sqliteTable(
+  "models",
+  {
+    id: text("id").primaryKey(),
+    providerId: text("provider_id")
+      .notNull()
+      .references(() => providers.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    inputTokenPrice: real("input_token_price"),
+    outputTokenPrice: real("output_token_price"),
+    cachedInputTokenPrice: real("cached_input_token_price"),
+    currency: text("currency").notNull().default("USD"),
+    effectiveFrom: integer("effective_from", { mode: "timestamp_ms" }),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type<Record<string, unknown>>()
+  },
+  (table) => ({
+    providerModelIdx: uniqueIndex("models_provider_name_idx").on(
+      table.providerId,
+      table.name
+    )
+  })
+);
+
+export const projects = sqliteTable(
+  "projects",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    path: text("path").notNull(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" })
+      .notNull()
+      .$defaultFn(() => new Date())
+  },
+  (table) => ({
+    pathIdx: uniqueIndex("projects_path_idx").on(table.path)
+  })
+);
+
+export const sessions = sqliteTable(
+  "sessions",
+  {
+    id: text("id").primaryKey(),
+    sourceId: text("source_id").notNull(),
+    toolId: text("tool_id")
+      .notNull()
+      .references(() => tools.id, { onDelete: "cascade" }),
+    projectId: text("project_id").references(() => projects.id, {
+      onDelete: "set null"
+    }),
+    startedAt: integer("started_at", { mode: "timestamp_ms" }),
+    endedAt: integer("ended_at", { mode: "timestamp_ms" }),
+    title: text("title"),
+    sourceFile: text("source_file").notNull(),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type<Record<string, unknown>>()
+  },
+  (table) => ({
+    sourceIdx: uniqueIndex("sessions_source_id_idx").on(table.sourceId),
+    toolIdx: index("sessions_tool_idx").on(table.toolId),
+    projectIdx: index("sessions_project_idx").on(table.projectId),
+    startedIdx: index("sessions_started_idx").on(table.startedAt)
+  })
+);
+
+export const interactions = sqliteTable(
+  "interactions",
+  {
+    id: text("id").primaryKey(),
+    sourceId: text("source_id").notNull(),
+    sessionId: text("session_id")
+      .notNull()
+      .references(() => sessions.id, { onDelete: "cascade" }),
+    timestamp: integer("timestamp", { mode: "timestamp_ms" }),
+    role: text("role").notNull(),
+    modelId: text("model_id").references(() => models.id, {
+      onDelete: "set null"
+    }),
+    inputTokens: integer("input_tokens").notNull().default(0),
+    outputTokens: integer("output_tokens").notNull().default(0),
+    cacheReadTokens: integer("cache_read_tokens").notNull().default(0),
+    cacheWriteTokens: integer("cache_write_tokens").notNull().default(0),
+    reasoningTokens: integer("reasoning_tokens").notNull().default(0),
+    totalTokens: integer("total_tokens").notNull().default(0),
+    estimatedTokens: integer("estimated_tokens", { mode: "boolean" })
+      .notNull()
+      .default(false),
+    tokenConfidence: text("token_confidence").notNull().default("unknown"),
+    cost: real("cost"),
+    costEstimated: integer("cost_estimated", { mode: "boolean" })
+      .notNull()
+      .default(false),
+    latencyMs: integer("latency_ms"),
+    rawTextPreview: text("raw_text_preview"),
+    rawText: text("raw_text"),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type<Record<string, unknown>>()
+  },
+  (table) => ({
+    sourceIdx: uniqueIndex("interactions_source_id_idx").on(table.sourceId),
+    sessionIdx: index("interactions_session_idx").on(table.sessionId),
+    modelIdx: index("interactions_model_idx").on(table.modelId),
+    timestampIdx: index("interactions_timestamp_idx").on(table.timestamp)
+  })
+);
+
+export const toolCalls = sqliteTable(
+  "tool_calls",
+  {
+    id: text("id").primaryKey(),
+    interactionId: text("interaction_id")
+      .notNull()
+      .references(() => interactions.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    status: text("status"),
+    durationMs: integer("duration_ms"),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type<Record<string, unknown>>()
+  },
+  (table) => ({
+    interactionIdx: index("tool_calls_interaction_idx").on(table.interactionId)
+  })
+);
+
+export const scanRuns = sqliteTable("scan_runs", {
+  id: text("id").primaryKey(),
+  startedAt: integer("started_at", { mode: "timestamp_ms" }).notNull(),
+  completedAt: integer("completed_at", { mode: "timestamp_ms" }),
+  filesScanned: integer("files_scanned").notNull().default(0),
+  recordsImported: integer("records_imported").notNull().default(0),
+  warnings: text("warnings", { mode: "json" }).$type<string[]>().notNull().default(sql`'[]'`),
+  errors: text("errors", { mode: "json" }).$type<string[]>().notNull().default(sql`'[]'`)
+});
+
+export const scanFiles = sqliteTable(
+  "scan_files",
+  {
+    id: text("id").primaryKey(),
+    scanRunId: text("scan_run_id")
+      .notNull()
+      .references(() => scanRuns.id, { onDelete: "cascade" }),
+    path: text("path").notNull(),
+    modifiedTime: integer("modified_time", { mode: "timestamp_ms" }),
+    sizeBytes: integer("size_bytes").notNull().default(0),
+    fileHash: text("file_hash"),
+    parser: text("parser"),
+    status: text("status").notNull(),
+    recordsImported: integer("records_imported").notNull().default(0),
+    warnings: text("warnings", { mode: "json" }).$type<string[]>().notNull().default(sql`'[]'`),
+    errors: text("errors", { mode: "json" }).$type<string[]>().notNull().default(sql`'[]'`),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type<Record<string, unknown>>()
+  },
+  (table) => ({
+    pathHashIdx: index("scan_files_path_hash_idx").on(table.path, table.fileHash),
+    scanRunIdx: index("scan_files_run_idx").on(table.scanRunId)
+  })
+);
+
+export const settings = sqliteTable("settings", {
+  key: text("key").primaryKey(),
+  value: text("value", { mode: "json" }).$type<unknown>().notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp_ms" })
+    .notNull()
+    .$defaultFn(() => new Date())
+});
+
+export const providerRelations = relations(providers, ({ many }) => ({
+  tools: many(tools),
+  models: many(models)
+}));
+
+export const toolRelations = relations(tools, ({ one, many }) => ({
+  provider: one(providers, {
+    fields: [tools.providerId],
+    references: [providers.id]
+  }),
+  sessions: many(sessions)
+}));
+
+export const modelRelations = relations(models, ({ one, many }) => ({
+  provider: one(providers, {
+    fields: [models.providerId],
+    references: [providers.id]
+  }),
+  interactions: many(interactions)
+}));
+
+export const projectRelations = relations(projects, ({ many }) => ({
+  sessions: many(sessions)
+}));
+
+export const sessionRelations = relations(sessions, ({ one, many }) => ({
+  tool: one(tools, {
+    fields: [sessions.toolId],
+    references: [tools.id]
+  }),
+  project: one(projects, {
+    fields: [sessions.projectId],
+    references: [projects.id]
+  }),
+  interactions: many(interactions)
+}));
+
+export const interactionRelations = relations(interactions, ({ one, many }) => ({
+  session: one(sessions, {
+    fields: [interactions.sessionId],
+    references: [sessions.id]
+  }),
+  model: one(models, {
+    fields: [interactions.modelId],
+    references: [models.id]
+  }),
+  toolCalls: many(toolCalls)
+}));
+
+export type Provider = typeof providers.$inferSelect;
+export type Tool = typeof tools.$inferSelect;
+export type Model = typeof models.$inferSelect;
+export type Project = typeof projects.$inferSelect;
+export type Session = typeof sessions.$inferSelect;
+export type Interaction = typeof interactions.$inferSelect;
+export type ToolCall = typeof toolCalls.$inferSelect;
+export type ScanRun = typeof scanRuns.$inferSelect;
+export type ScanFile = typeof scanFiles.$inferSelect;