tokentrace 0.1.0

package/components/ui/textarea.tsx

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { cn } from "@/src/lib/utils";
+
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {}
+
+const Textarea = React.forwardRef<HTMLTextAreaElement, TextareaProps>(({ className, ...props }, ref) => (
+  <textarea
+    className={cn(
+      "flex min-h-24 w-full rounded-md border bg-card px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50",
+      className
+    )}
+    ref={ref}
+    {...props}
+  />
+));
+Textarea.displayName = "Textarea";
+
+export { Textarea };

package/components.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "default",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.ts",
+    "css": "app/globals.css",
+    "baseColor": "neutral",
+    "cssVariables": true
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/src/lib/utils"
+  }
+}

package/dist/runtime/db-migrate.mjs

@@ -0,0 +1,410 @@
+import { createRequire as __tokentraceCreateRequire } from 'node:module'; const require = __tokentraceCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/db/client.ts
+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";
+
+// src/db/migrate-core.ts
+var 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)
+);
+`;
+function applyMigrations(sqlite2) {
+  sqlite2.exec(ddl);
+  const columns = sqlite2.prepare("PRAGMA table_info(interactions)").all();
+  if (!columns.some((column) => column.name === "token_confidence")) {
+    try {
+      sqlite2.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;
+      }
+    }
+  }
+}
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  interactionRelations: () => interactionRelations,
+  interactions: () => interactions,
+  modelRelations: () => modelRelations,
+  models: () => models,
+  projectRelations: () => projectRelations,
+  projects: () => projects,
+  providerRelations: () => providerRelations,
+  providers: () => providers,
+  scanFiles: () => scanFiles,
+  scanRuns: () => scanRuns,
+  sessionRelations: () => sessionRelations,
+  sessions: () => sessions,
+  settings: () => settings,
+  toolCalls: () => toolCalls,
+  toolRelations: () => toolRelations,
+  tools: () => tools
+});
+import { relations, sql } from "drizzle-orm";
+import {
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+  uniqueIndex
+} from "drizzle-orm/sqlite-core";
+var providers = sqliteTable("providers", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  type: text("type").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var 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(() => /* @__PURE__ */ new Date())
+  },
+  (table) => ({
+    providerNameIdx: uniqueIndex("tools_provider_name_idx").on(
+      table.providerId,
+      table.name
+    )
+  })
+);
+var 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()
+  },
+  (table) => ({
+    providerModelIdx: uniqueIndex("models_provider_name_idx").on(
+      table.providerId,
+      table.name
+    )
+  })
+);
+var projects = sqliteTable(
+  "projects",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    path: text("path").notNull(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+  },
+  (table) => ({
+    pathIdx: uniqueIndex("projects_path_idx").on(table.path)
+  })
+);
+var 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()
+  },
+  (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)
+  })
+);
+var 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()
+  },
+  (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)
+  })
+);
+var 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()
+  },
+  (table) => ({
+    interactionIdx: index("tool_calls_interaction_idx").on(table.interactionId)
+  })
+);
+var 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().notNull().default(sql`'[]'`),
+  errors: text("errors", { mode: "json" }).$type().notNull().default(sql`'[]'`)
+});
+var 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().notNull().default(sql`'[]'`),
+    errors: text("errors", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    pathHashIdx: index("scan_files_path_hash_idx").on(table.path, table.fileHash),
+    scanRunIdx: index("scan_files_run_idx").on(table.scanRunId)
+  })
+);
+var settings = sqliteTable("settings", {
+  key: text("key").primaryKey(),
+  value: text("value", { mode: "json" }).$type().notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var providerRelations = relations(providers, ({ many }) => ({
+  tools: many(tools),
+  models: many(models)
+}));
+var toolRelations = relations(tools, ({ one, many }) => ({
+  provider: one(providers, {
+    fields: [tools.providerId],
+    references: [providers.id]
+  }),
+  sessions: many(sessions)
+}));
+var modelRelations = relations(models, ({ one, many }) => ({
+  provider: one(providers, {
+    fields: [models.providerId],
+    references: [providers.id]
+  }),
+  interactions: many(interactions)
+}));
+var projectRelations = relations(projects, ({ many }) => ({
+  sessions: many(sessions)
+}));
+var 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)
+}));
+var 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)
+}));
+
+// src/db/client.ts
+var defaultDbPath = path.join(process.cwd(), ".tokentrace", "tokentrace.db");
+function databaseUrlPath(value) {
+  if (!value?.startsWith("file:")) return null;
+  try {
+    return fileURLToPath(value);
+  } catch {
+    return value.slice("file:".length);
+  }
+}
+var dbPath = process.env.TOKENTRACE_DB ?? databaseUrlPath(process.env.DATABASE_URL) ?? defaultDbPath;
+fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+var sqlite = new Database(dbPath);
+sqlite.pragma("foreign_keys = ON");
+applyMigrations(sqlite);
+var db = drizzle(sqlite, { schema: schema_exports });
+function getDatabasePath() {
+  return dbPath;
+}
+
+// scripts/db-migrate.ts
+applyMigrations(sqlite);
+console.log(`TokenTrace database migrated at ${getDatabasePath()}`);