@hasna/recordings 0.0.3

package/src/db/agents.ts

@@ -0,0 +1,81 @@
+import { type Database } from "bun:sqlite";
+import { getDatabase, shortUuid } from "./database.js";
+import type { Agent } from "../types/index.js";
+
+function parseAgent(row: Record<string, unknown>): Agent {
+  return {
+    id: row["id"] as string,
+    name: row["name"] as string,
+    description: (row["description"] as string) || null,
+    role: (row["role"] as string) || "agent",
+    metadata: JSON.parse((row["metadata"] as string) || "{}") as Record<string, unknown>,
+    created_at: row["created_at"] as string,
+    last_seen_at: row["last_seen_at"] as string,
+  };
+}
+
+export function registerAgent(
+  name: string,
+  description?: string,
+  role?: string,
+  db?: Database
+): Agent {
+  const d = db || getDatabase();
+  const now = new Date().toISOString();
+
+  // Check if agent exists by name
+  const existing = d
+    .query("SELECT * FROM agents WHERE name = ?")
+    .get(name) as Record<string, unknown> | undefined;
+
+  if (existing) {
+    d.query("UPDATE agents SET last_seen_at = ? WHERE id = ?").run(
+      now,
+      existing["id"] as string
+    );
+    return getAgent(existing["id"] as string, d)!;
+  }
+
+  const id = shortUuid();
+  d.query(
+    "INSERT INTO agents (id, name, description, role, created_at, last_seen_at) VALUES (?, ?, ?, ?, ?, ?)"
+  ).run(id, name, description || null, role || "agent", now, now);
+
+  return getAgent(id, d)!;
+}
+
+export function getAgent(
+  idOrName: string,
+  db?: Database
+): Agent | null {
+  const d = db || getDatabase();
+
+  // Try by ID
+  let row = d
+    .query("SELECT * FROM agents WHERE id = ?")
+    .get(idOrName) as Record<string, unknown> | undefined;
+
+  // Try by name
+  if (!row) {
+    row = d
+      .query("SELECT * FROM agents WHERE name = ?")
+      .get(idOrName) as Record<string, unknown> | undefined;
+  }
+
+  // Try by partial ID prefix
+  if (!row) {
+    row = d
+      .query("SELECT * FROM agents WHERE id LIKE ? || '%'")
+      .get(idOrName) as Record<string, unknown> | undefined;
+  }
+
+  return row ? parseAgent(row) : null;
+}
+
+export function listAgents(db?: Database): Agent[] {
+  const d = db || getDatabase();
+  const rows = d
+    .query("SELECT * FROM agents ORDER BY last_seen_at DESC")
+    .all() as Record<string, unknown>[];
+  return rows.map(parseAgent);
+}

package/src/db/database.ts

@@ -0,0 +1,126 @@
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { loadConfig } from "../lib/config.js";
+
+let _db: Database | null = null;
+
+const MIGRATIONS = [
+  // Migration 0: Initial schema
+  `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT UNIQUE NOT NULL,
+    description TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    role TEXT DEFAULT 'agent',
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS recordings (
+    id TEXT PRIMARY KEY,
+    audio_path TEXT,
+    raw_text TEXT NOT NULL,
+    processed_text TEXT,
+    processing_mode TEXT NOT NULL DEFAULT 'raw' CHECK(processing_mode IN ('raw', 'enhanced')),
+    model_used TEXT NOT NULL DEFAULT 'gpt-4o-mini-transcribe',
+    enhancement_model TEXT,
+    duration_ms INTEGER DEFAULT 0,
+    language TEXT,
+    tags TEXT DEFAULT '[]',
+    agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    session_id TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS recording_tags (
+    recording_id TEXT NOT NULL REFERENCES recordings(id) ON DELETE CASCADE,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (recording_id, tag)
+  );
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_recordings_agent ON recordings(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_recordings_project ON recordings(project_id);
+  CREATE INDEX IF NOT EXISTS idx_recordings_session ON recordings(session_id);
+  CREATE INDEX IF NOT EXISTS idx_recordings_created ON recordings(created_at);
+  CREATE INDEX IF NOT EXISTS idx_recordings_mode ON recordings(processing_mode);
+  CREATE INDEX IF NOT EXISTS idx_recording_tags_tag ON recording_tags(tag);
+  `,
+];
+
+export function getDatabase(dbPath?: string): Database {
+  if (_db) return _db;
+
+  const path = dbPath || loadConfig().db_path;
+
+  // Ensure directory exists
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+
+  _db = new Database(path, { create: true });
+
+  // Pragmas for production SQLite
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA busy_timeout = 5000");
+  _db.run("PRAGMA foreign_keys = ON");
+
+  runMigrations(_db);
+  return _db;
+}
+
+function runMigrations(db: Database): void {
+  // Ensure _migrations table exists
+  db.run(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      id INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+
+  const result = db
+    .query("SELECT MAX(id) as max_id FROM _migrations")
+    .get() as { max_id: number | null } | null;
+
+  const currentLevel = result?.max_id ?? -1;
+
+  for (let i = currentLevel + 1; i < MIGRATIONS.length; i++) {
+    db.run(MIGRATIONS[i]!);
+    db.query("INSERT INTO _migrations (id) VALUES (?)").run(i);
+  }
+}
+
+export function closeDatabase(): void {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+
+export function resetDatabase(): void {
+  _db = null;
+}
+
+export function getDbPath(): string {
+  return loadConfig().db_path;
+}
+
+export function shortUuid(): string {
+  return crypto.randomUUID().slice(0, 8);
+}

package/src/db/projects.ts

@@ -0,0 +1,71 @@
+import { type Database } from "bun:sqlite";
+import { getDatabase } from "./database.js";
+import type { Project } from "../types/index.js";
+
+function parseProject(row: Record<string, unknown>): Project {
+  return {
+    id: row["id"] as string,
+    name: row["name"] as string,
+    path: row["path"] as string,
+    description: (row["description"] as string) || null,
+    created_at: row["created_at"] as string,
+    updated_at: row["updated_at"] as string,
+  };
+}
+
+export function registerProject(
+  name: string,
+  path: string,
+  description?: string,
+  db?: Database
+): Project {
+  const d = db || getDatabase();
+  const now = new Date().toISOString();
+
+  // Check if project exists by path (idempotent)
+  const existing = d
+    .query("SELECT * FROM projects WHERE path = ?")
+    .get(path) as Record<string, unknown> | undefined;
+
+  if (existing) {
+    d.query("UPDATE projects SET updated_at = ? WHERE id = ?").run(
+      now,
+      existing["id"] as string
+    );
+    return getProject(existing["id"] as string, d)!;
+  }
+
+  const id = crypto.randomUUID();
+  d.query(
+    "INSERT INTO projects (id, name, path, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
+  ).run(id, name, path, description || null, now, now);
+
+  return getProject(id, d)!;
+}
+
+export function getProject(
+  idOrPath: string,
+  db?: Database
+): Project | null {
+  const d = db || getDatabase();
+
+  let row = d
+    .query("SELECT * FROM projects WHERE id = ?")
+    .get(idOrPath) as Record<string, unknown> | undefined;
+
+  if (!row) {
+    row = d
+      .query("SELECT * FROM projects WHERE path = ?")
+      .get(idOrPath) as Record<string, unknown> | undefined;
+  }
+
+  return row ? parseProject(row) : null;
+}
+
+export function listProjects(db?: Database): Project[] {
+  const d = db || getDatabase();
+  const rows = d
+    .query("SELECT * FROM projects ORDER BY updated_at DESC")
+    .all() as Record<string, unknown>[];
+  return rows.map(parseProject);
+}

package/src/db/recordings.ts

@@ -0,0 +1,219 @@
+import { type Database } from "bun:sqlite";
+import { getDatabase, shortUuid } from "./database.js";
+import type {
+  Recording,
+  CreateRecordingInput,
+  RecordingFilter,
+} from "../types/index.js";
+import { RecordingNotFoundError } from "../types/index.js";
+
+function parseRow(row: Record<string, unknown>): Recording {
+  return {
+    id: row["id"] as string,
+    audio_path: (row["audio_path"] as string) || null,
+    raw_text: row["raw_text"] as string,
+    processed_text: (row["processed_text"] as string) || null,
+    processing_mode: (row["processing_mode"] as Recording["processing_mode"]) || "raw",
+    model_used: (row["model_used"] as string) || "gpt-4o-mini-transcribe",
+    enhancement_model: (row["enhancement_model"] as string) || null,
+    duration_ms: (row["duration_ms"] as number) || 0,
+    language: (row["language"] as string) || null,
+    tags: JSON.parse((row["tags"] as string) || "[]") as string[],
+    agent_id: (row["agent_id"] as string) || null,
+    project_id: (row["project_id"] as string) || null,
+    session_id: (row["session_id"] as string) || null,
+    metadata: JSON.parse((row["metadata"] as string) || "{}") as Record<string, unknown>,
+    created_at: row["created_at"] as string,
+  };
+}
+
+export function createRecording(
+  input: CreateRecordingInput,
+  db?: Database
+): Recording {
+  const d = db || getDatabase();
+  const id = crypto.randomUUID();
+  const tagsJson = JSON.stringify(input.tags || []);
+  const metadataJson = JSON.stringify(input.metadata || {});
+
+  d.query(
+    `INSERT INTO recordings (id, audio_path, raw_text, processed_text, processing_mode, model_used, enhancement_model, duration_ms, language, tags, agent_id, project_id, session_id, metadata)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.audio_path || null,
+    input.raw_text,
+    input.processed_text || null,
+    input.processing_mode || "raw",
+    input.model_used || "gpt-4o-mini-transcribe",
+    input.enhancement_model || null,
+    input.duration_ms || 0,
+    input.language || null,
+    tagsJson,
+    input.agent_id || null,
+    input.project_id || null,
+    input.session_id || null,
+    metadataJson
+  );
+
+  // Insert tags into normalized table
+  if (input.tags && input.tags.length > 0) {
+    const insertTag = d.query(
+      "INSERT OR IGNORE INTO recording_tags (recording_id, tag) VALUES (?, ?)"
+    );
+    for (const tag of input.tags) {
+      insertTag.run(id, tag);
+    }
+  }
+
+  return getRecording(id, d)!;
+}
+
+export function getRecording(
+  id: string,
+  db?: Database
+): Recording | null {
+  const d = db || getDatabase();
+
+  // Try by ID first
+  let row = d
+    .query("SELECT * FROM recordings WHERE id = ?")
+    .get(id) as Record<string, unknown> | undefined;
+
+  // Try by partial ID prefix
+  if (!row) {
+    row = d
+      .query("SELECT * FROM recordings WHERE id LIKE ? || '%'")
+      .get(id) as Record<string, unknown> | undefined;
+  }
+
+  return row ? parseRow(row) : null;
+}
+
+export function listRecordings(
+  filter?: RecordingFilter,
+  db?: Database
+): Recording[] {
+  const d = db || getDatabase();
+  const conditions: string[] = [];
+  const params: (string | number)[] = [];
+
+  if (filter?.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filter.agent_id);
+  }
+  if (filter?.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter?.session_id) {
+    conditions.push("session_id = ?");
+    params.push(filter.session_id);
+  }
+  if (filter?.processing_mode) {
+    conditions.push("processing_mode = ?");
+    params.push(filter.processing_mode);
+  }
+  if (filter?.tags && filter.tags.length > 0) {
+    for (const tag of filter.tags) {
+      conditions.push(
+        "id IN (SELECT recording_id FROM recording_tags WHERE tag = ?)"
+      );
+      params.push(tag);
+    }
+  }
+  if (filter?.search) {
+    conditions.push(
+      "(raw_text LIKE ? OR processed_text LIKE ? OR tags LIKE ?)"
+    );
+    const q = `%${filter.search}%`;
+    params.push(q, q, q);
+  }
+  if (filter?.since) {
+    conditions.push("created_at >= ?");
+    params.push(filter.since);
+  }
+  if (filter?.until) {
+    conditions.push("created_at <= ?");
+    params.push(filter.until);
+  }
+
+  const where =
+    conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filter?.limit || 50;
+  const offset = filter?.offset || 0;
+
+  const sql = `SELECT * FROM recordings ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`;
+  params.push(limit, offset);
+
+  const rows = d.query(sql).all(...params) as Record<string, unknown>[];
+  return rows.map(parseRow);
+}
+
+export function deleteRecording(
+  id: string,
+  db?: Database
+): boolean {
+  const d = db || getDatabase();
+  const result = d.query("DELETE FROM recordings WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+
+export function searchRecordings(
+  query: string,
+  filter?: RecordingFilter,
+  db?: Database
+): Recording[] {
+  return listRecordings({ ...filter, search: query }, db);
+}
+
+export function getRecordingStats(db?: Database): {
+  total: number;
+  raw: number;
+  enhanced: number;
+  total_duration_ms: number;
+  by_model: Record<string, number>;
+} {
+  const d = db || getDatabase();
+
+  const total = (
+    d.query("SELECT COUNT(*) as c FROM recordings").get() as { c: number }
+  ).c;
+  const raw = (
+    d
+      .query(
+        "SELECT COUNT(*) as c FROM recordings WHERE processing_mode = 'raw'"
+      )
+      .get() as { c: number }
+  ).c;
+  const enhanced = (
+    d
+      .query(
+        "SELECT COUNT(*) as c FROM recordings WHERE processing_mode = 'enhanced'"
+      )
+      .get() as { c: number }
+  ).c;
+  const totalDuration = (
+    d
+      .query("SELECT COALESCE(SUM(duration_ms), 0) as d FROM recordings")
+      .get() as { d: number }
+  ).d;
+
+  const modelRows = d
+    .query(
+      "SELECT model_used, COUNT(*) as c FROM recordings GROUP BY model_used"
+    )
+    .all() as { model_used: string; c: number }[];
+  const byModel: Record<string, number> = {};
+  for (const row of modelRows) {
+    byModel[row.model_used] = row.c;
+  }
+
+  return {
+    total,
+    raw,
+    enhanced,
+    total_duration_ms: totalDuration,
+    by_model: byModel,
+  };
+}

package/src/index.ts

@@ -0,0 +1,81 @@
+// ── Types ───────────────────────────────────────────────────────────────────
+export type {
+  Recording,
+  CreateRecordingInput,
+  RecordingFilter,
+  ProcessingMode,
+  Agent,
+  Project,
+  RecordingsConfig,
+  TranscriptionResult,
+  EnhancementResult,
+} from "./types/index.js";
+
+export {
+  RecordingNotFoundError,
+  RecordingError,
+  TranscriptionError,
+  EnhancementError,
+} from "./types/index.js";
+
+// ── Database ────────────────────────────────────────────────────────────────
+export {
+  getDatabase,
+  closeDatabase,
+  resetDatabase,
+  getDbPath,
+  shortUuid,
+} from "./db/database.js";
+
+// ── Recordings CRUD ─────────────────────────────────────────────────────────
+export {
+  createRecording,
+  getRecording,
+  listRecordings,
+  deleteRecording,
+  searchRecordings,
+  getRecordingStats,
+} from "./db/recordings.js";
+
+// ── Agents ──────────────────────────────────────────────────────────────────
+export { registerAgent, getAgent, listAgents } from "./db/agents.js";
+
+// ── Projects ────────────────────────────────────────────────────────────────
+export {
+  registerProject,
+  getProject,
+  listProjects,
+} from "./db/projects.js";
+
+// ── Config ──────────────────────────────────────────────────────────────────
+export {
+  loadConfig,
+  getDataDir,
+  ensureDataDir,
+  DEFAULT_CONFIG,
+} from "./lib/config.js";
+
+// ── Transcription ───────────────────────────────────────────────────────────
+export {
+  transcribeAudio,
+  transcribeBuffer,
+  resetClient,
+} from "./lib/transcriber.js";
+
+// ── Enhancement ─────────────────────────────────────────────────────────────
+export {
+  needsEnhancement,
+  enhanceText,
+  processText,
+  resetEnhancementClient,
+} from "./lib/enhancer.js";
+
+// ── Recorder ────────────────────────────────────────────────────────────────
+export {
+  startRecording,
+  stopRecording,
+  isRecording,
+  getCurrentFile,
+  checkRecordingDeps,
+  recordDuration,
+} from "./lib/recorder.js";