@hasna/recordings 0.0.3 → 0.1.2

package/dist/index.js

@@ -0,0 +1,832 @@
+// @bun
+var __require = import.meta.require;
+
+// src/types/index.ts
+class RecordingNotFoundError extends Error {
+  constructor(id) {
+    super(`Recording not found: ${id}`);
+    this.name = "RecordingNotFoundError";
+  }
+}
+
+class RecordingError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RecordingError";
+  }
+}
+
+class TranscriptionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TranscriptionError";
+  }
+}
+
+class EnhancementError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EnhancementError";
+  }
+}
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+
+// src/lib/config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  openai_api_key: "",
+  enhancement_api_key: "",
+  transcription_model: "gpt-4o-mini-transcribe",
+  enhancement_model: "gpt-4o",
+  language: "en",
+  audio_format: "wav",
+  sample_rate: 16000,
+  record_command: "sox",
+  hotkey: "space",
+  auto_enhance: true,
+  enhance_triggers: [
+    "say it better",
+    "rewrite this",
+    "make it sound",
+    "clean this up",
+    "fix this",
+    "rephrase",
+    "write it properly",
+    "make it professional",
+    "improve this",
+    "polish this"
+  ],
+  db_path: "",
+  audio_dir: "",
+  max_recording_seconds: 300
+};
+function loadConfig(configPath) {
+  const config = { ...DEFAULT_CONFIG };
+  const filePath = configPath || findConfigFile() || join(getDataDir(), "config.json");
+  if (existsSync(filePath)) {
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const fileConfig = JSON.parse(raw);
+      Object.assign(config, fileConfig);
+    } catch {}
+  }
+  if (process.env.OPENAI_API_KEY) {
+    config.openai_api_key = process.env.OPENAI_API_KEY;
+  }
+  if (process.env.RECORDINGS_API_KEY) {
+    config.openai_api_key = process.env.RECORDINGS_API_KEY;
+  }
+  if (process.env.RECORDINGS_ENHANCEMENT_KEY) {
+    config.enhancement_api_key = process.env.RECORDINGS_ENHANCEMENT_KEY;
+  }
+  if (process.env.RECORDINGS_MODEL) {
+    config.transcription_model = process.env.RECORDINGS_MODEL;
+  }
+  if (process.env.RECORDINGS_ENHANCEMENT_MODEL) {
+    config.enhancement_model = process.env.RECORDINGS_ENHANCEMENT_MODEL;
+  }
+  if (process.env.RECORDINGS_LANGUAGE) {
+    config.language = process.env.RECORDINGS_LANGUAGE;
+  }
+  if (process.env.RECORDINGS_DB_PATH) {
+    config.db_path = process.env.RECORDINGS_DB_PATH;
+  }
+  if (process.env.RECORDINGS_AUDIO_DIR) {
+    config.audio_dir = process.env.RECORDINGS_AUDIO_DIR;
+  }
+  if (process.env.RECORDINGS_MAX_SECONDS) {
+    config.max_recording_seconds = parseInt(process.env.RECORDINGS_MAX_SECONDS, 10);
+  }
+  if (!config.openai_api_key) {
+    config.openai_api_key = loadSecretKey("OPENAI_API_KEY");
+  }
+  if (!config.enhancement_api_key) {
+    config.enhancement_api_key = config.openai_api_key || loadSecretKey("OPENAI_API_KEY");
+  }
+  if (!config.db_path) {
+    config.db_path = join(getDataDir(), "recordings.db");
+  }
+  if (!config.audio_dir) {
+    config.audio_dir = join(getDataDir(), "audio");
+  }
+  return config;
+}
+function findConfigFile() {
+  let dir = process.cwd();
+  const root = "/";
+  while (dir !== root) {
+    const candidate = join(dir, ".recordings", "config.json");
+    if (existsSync(candidate))
+      return candidate;
+    const parent = join(dir, "..");
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function getDataDir() {
+  let dir = process.cwd();
+  const root = "/";
+  while (dir !== root) {
+    const candidate = join(dir, ".recordings");
+    if (existsSync(candidate))
+      return candidate;
+    const parent = join(dir, "..");
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return join(homedir(), ".recordings");
+}
+function loadSecretKey(keyName) {
+  const secretsPath = join(homedir(), ".secrets");
+  if (!existsSync(secretsPath))
+    return "";
+  try {
+    const content = readFileSync(secretsPath, "utf-8");
+    const match = content.match(new RegExp(`export\\s+${keyName}\\s*=\\s*"([^"]+)"`));
+    if (match)
+      return match[1];
+    const match2 = content.match(new RegExp(`export\\s+${keyName}\\s*=\\s*'([^']+)'`));
+    if (match2)
+      return match2[1];
+    const match3 = content.match(new RegExp(`${keyName}\\s*=\\s*(.+)`));
+    if (match3)
+      return match3[1].trim().replace(/^["']|["']$/g, "");
+  } catch {}
+  return "";
+}
+function ensureDataDir(config) {
+  const { mkdirSync } = __require("fs");
+  mkdirSync(config.audio_dir, { recursive: true });
+  const dbDir = config.db_path.substring(0, config.db_path.lastIndexOf("/"));
+  if (dbDir)
+    mkdirSync(dbDir, { recursive: true });
+}
+
+// src/db/database.ts
+var _db = null;
+var MIGRATIONS = [
+  `
+  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);
+  `
+];
+function getDatabase(dbPath) {
+  if (_db)
+    return _db;
+  const path = dbPath || loadConfig().db_path;
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  _db = new Database(path, { create: true });
+  _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) {
+  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();
+  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);
+  }
+}
+function closeDatabase() {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+function resetDatabase() {
+  _db = null;
+}
+function getDbPath() {
+  return loadConfig().db_path;
+}
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+// src/db/recordings.ts
+function parseRow(row) {
+  return {
+    id: row["id"],
+    audio_path: row["audio_path"] || null,
+    raw_text: row["raw_text"],
+    processed_text: row["processed_text"] || null,
+    processing_mode: row["processing_mode"] || "raw",
+    model_used: row["model_used"] || "gpt-4o-mini-transcribe",
+    enhancement_model: row["enhancement_model"] || null,
+    duration_ms: row["duration_ms"] || 0,
+    language: row["language"] || null,
+    tags: JSON.parse(row["tags"] || "[]"),
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    session_id: row["session_id"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"]
+  };
+}
+function createRecording(input, db) {
+  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);
+  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);
+}
+function getRecording(id, db) {
+  const d = db || getDatabase();
+  let row = d.query("SELECT * FROM recordings WHERE id = ?").get(id);
+  if (!row) {
+    row = d.query("SELECT * FROM recordings WHERE id LIKE ? || '%'").get(id);
+  }
+  return row ? parseRow(row) : null;
+}
+function listRecordings(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  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);
+  return rows.map(parseRow);
+}
+function deleteRecording(id, db) {
+  const d = db || getDatabase();
+  const result = d.query("DELETE FROM recordings WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+function searchRecordings(query, filter, db) {
+  return listRecordings({ ...filter, search: query }, db);
+}
+function getRecordingStats(db) {
+  const d = db || getDatabase();
+  const total = d.query("SELECT COUNT(*) as c FROM recordings").get().c;
+  const raw = d.query("SELECT COUNT(*) as c FROM recordings WHERE processing_mode = 'raw'").get().c;
+  const enhanced = d.query("SELECT COUNT(*) as c FROM recordings WHERE processing_mode = 'enhanced'").get().c;
+  const totalDuration = d.query("SELECT COALESCE(SUM(duration_ms), 0) as d FROM recordings").get().d;
+  const modelRows = d.query("SELECT model_used, COUNT(*) as c FROM recordings GROUP BY model_used").all();
+  const byModel = {};
+  for (const row of modelRows) {
+    byModel[row.model_used] = row.c;
+  }
+  return {
+    total,
+    raw,
+    enhanced,
+    total_duration_ms: totalDuration,
+    by_model: byModel
+  };
+}
+// src/db/agents.ts
+function parseAgent(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    description: row["description"] || null,
+    role: row["role"] || "agent",
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"],
+    last_seen_at: row["last_seen_at"]
+  };
+}
+function registerAgent(name, description, role, db) {
+  const d = db || getDatabase();
+  const now = new Date().toISOString();
+  const existing = d.query("SELECT * FROM agents WHERE name = ?").get(name);
+  if (existing) {
+    d.query("UPDATE agents SET last_seen_at = ? WHERE id = ?").run(now, existing["id"]);
+    return getAgent(existing["id"], 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);
+}
+function getAgent(idOrName, db) {
+  const d = db || getDatabase();
+  let row = d.query("SELECT * FROM agents WHERE id = ?").get(idOrName);
+  if (!row) {
+    row = d.query("SELECT * FROM agents WHERE name = ?").get(idOrName);
+  }
+  if (!row) {
+    row = d.query("SELECT * FROM agents WHERE id LIKE ? || '%'").get(idOrName);
+  }
+  return row ? parseAgent(row) : null;
+}
+function listAgents(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
+  return rows.map(parseAgent);
+}
+// src/db/projects.ts
+function parseProject(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    path: row["path"],
+    description: row["description"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+function registerProject(name, path, description, db) {
+  const d = db || getDatabase();
+  const now = new Date().toISOString();
+  const existing = d.query("SELECT * FROM projects WHERE path = ?").get(path);
+  if (existing) {
+    d.query("UPDATE projects SET updated_at = ? WHERE id = ?").run(now, existing["id"]);
+    return getProject(existing["id"], 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);
+}
+function getProject(idOrPath, db) {
+  const d = db || getDatabase();
+  let row = d.query("SELECT * FROM projects WHERE id = ?").get(idOrPath);
+  if (!row) {
+    row = d.query("SELECT * FROM projects WHERE path = ?").get(idOrPath);
+  }
+  return row ? parseProject(row) : null;
+}
+function listProjects(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
+  return rows.map(parseProject);
+}
+// src/lib/transcriber.ts
+import OpenAI from "openai";
+import { createReadStream } from "fs";
+var _client = null;
+function getClient(config) {
+  if (_client)
+    return _client;
+  if (!config.openai_api_key) {
+    throw new TranscriptionError("OpenAI API key not configured. Set OPENAI_API_KEY env var or add to ~/.secrets");
+  }
+  _client = new OpenAI({ apiKey: config.openai_api_key });
+  return _client;
+}
+function resetClient() {
+  _client = null;
+}
+async function transcribeAudio(audioPath, config) {
+  const client = getClient(config);
+  const startTime = Date.now();
+  try {
+    const transcription = await client.audio.transcriptions.create({
+      file: createReadStream(audioPath),
+      model: config.transcription_model,
+      language: config.language || undefined,
+      response_format: "json"
+    });
+    const durationMs = Date.now() - startTime;
+    return {
+      text: transcription.text,
+      duration_ms: durationMs,
+      model: config.transcription_model,
+      language: transcription.language
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    throw new TranscriptionError(`Transcription failed: ${msg}`);
+  }
+}
+async function transcribeBuffer(buffer, filename, config) {
+  const client = getClient(config);
+  const startTime = Date.now();
+  try {
+    const file = new File([new Uint8Array(buffer)], filename, {
+      type: getMimeType(filename)
+    });
+    const transcription = await client.audio.transcriptions.create({
+      file,
+      model: config.transcription_model,
+      language: config.language || undefined,
+      response_format: "json"
+    });
+    const durationMs = Date.now() - startTime;
+    return {
+      text: transcription.text,
+      duration_ms: durationMs,
+      model: config.transcription_model,
+      language: transcription.language
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    throw new TranscriptionError(`Transcription failed: ${msg}`);
+  }
+}
+function getMimeType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "wav":
+      return "audio/wav";
+    case "mp3":
+      return "audio/mpeg";
+    case "m4a":
+      return "audio/mp4";
+    case "webm":
+      return "audio/webm";
+    case "mp4":
+      return "audio/mp4";
+    case "mpeg":
+    case "mpga":
+      return "audio/mpeg";
+    default:
+      return "audio/wav";
+  }
+}
+// src/lib/enhancer.ts
+import OpenAI2 from "openai";
+var _enhancementClient = null;
+function getEnhancementClient(config) {
+  if (_enhancementClient)
+    return _enhancementClient;
+  const key = config.enhancement_api_key || config.openai_api_key;
+  if (!key) {
+    throw new EnhancementError("API key not configured for enhancement. Set OPENAI_API_KEY or RECORDINGS_ENHANCEMENT_KEY");
+  }
+  _enhancementClient = new OpenAI2({ apiKey: key });
+  return _enhancementClient;
+}
+function resetEnhancementClient() {
+  _enhancementClient = null;
+}
+function needsEnhancement(text, config) {
+  const lower = text.toLowerCase().trim();
+  for (const trigger of config.enhance_triggers) {
+    if (lower.includes(trigger.toLowerCase())) {
+      return {
+        needs: true,
+        reason: `Explicit trigger: "${trigger}"`,
+        instruction: extractInstruction(text, trigger)
+      };
+    }
+  }
+  const instructionPatterns = [
+    /(?:write|draft|compose|create)\s+(?:an?\s+)?(?:email|message|response|reply|letter|note|text|slack|dm)/i,
+    /(?:give|provide|send)\s+(?:them|him|her|it|the\s+agent|the\s+team)\s+(?:full\s+)?instructions/i,
+    /(?:tell|ask)\s+(?:them|him|her|it|the\s+agent)\s+(?:to|that)/i,
+    /(?:make\s+it|make\s+this)\s+(?:sound|look|read)\s+(?:more\s+)?(?:professional|formal|casual|friendly|better)/i,
+    /(?:ok\s+so|okay\s+so|alright\s+so)\s+(?:say|write|tell|put)/i,
+    /(?:i\s+need|i\s+want)\s+(?:the\s+agent|it|them|you)\s+to\s+(?:build|create|implement|design|make)/i
+  ];
+  for (const pattern of instructionPatterns) {
+    if (pattern.test(text)) {
+      return {
+        needs: true,
+        reason: `Instruction pattern detected`,
+        instruction: text
+      };
+    }
+  }
+  return { needs: false, reason: "Direct dictation", instruction: text };
+}
+function extractInstruction(text, trigger) {
+  const lower = text.toLowerCase();
+  const idx = lower.indexOf(trigger.toLowerCase());
+  if (idx === -1)
+    return text;
+  const after = text.substring(idx + trigger.length).trim();
+  const before = text.substring(0, idx).trim();
+  if (before.length > after.length && before.length > 10) {
+    return before;
+  }
+  return text;
+}
+async function enhanceText(rawText, instruction, config) {
+  const client = getEnhancementClient(config);
+  try {
+    const response = await client.chat.completions.create({
+      model: config.enhancement_model,
+      messages: [
+        {
+          role: "system",
+          content: `You are a writing assistant. The user has dictated speech that needs to be transformed into polished output.
+
+Rules:
+- Output ONLY the enhanced/rewritten text \u2014 no explanations, no preamble
+- Preserve the user's intent and meaning
+- Fix grammar, structure, and clarity
+- If the user is giving instructions (e.g., "write an email saying..."), produce the actual output (the email), not a description of it
+- If the user says "say it better" or similar, rewrite their preceding text to be clearer and more professional
+- Match the appropriate tone (formal for business, casual for personal)`
+        },
+        {
+          role: "user",
+          content: instruction
+        }
+      ],
+      temperature: 0.3,
+      max_tokens: 4096
+    });
+    const enhanced = response.choices[0]?.message?.content?.trim() || rawText;
+    return {
+      original: rawText,
+      enhanced,
+      model: config.enhancement_model,
+      reasoning: null
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    throw new EnhancementError(`Enhancement failed: ${msg}`);
+  }
+}
+async function processText(rawText, config) {
+  if (!config.auto_enhance) {
+    return { text: rawText, mode: "raw", enhancement_model: null };
+  }
+  const detection = needsEnhancement(rawText, config);
+  if (!detection.needs) {
+    return { text: rawText, mode: "raw", enhancement_model: null };
+  }
+  const result = await enhanceText(rawText, detection.instruction, config);
+  return {
+    text: result.enhanced,
+    mode: "enhanced",
+    enhancement_model: result.model
+  };
+}
+// src/lib/recorder.ts
+import { spawn } from "child_process";
+import { join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var _recordProcess = null;
+var _currentFile = null;
+async function checkRecordingDeps() {
+  try {
+    const proc = Bun.spawn(["which", "sox"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return { available: true, tool: "sox", message: "sox is available" };
+    }
+  } catch {}
+  try {
+    const proc = Bun.spawn(["which", "rec"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return { available: true, tool: "rec", message: "rec is available" };
+    }
+  } catch {}
+  try {
+    const proc = Bun.spawn(["which", "ffmpeg"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return {
+        available: true,
+        tool: "ffmpeg",
+        message: "ffmpeg is available"
+      };
+    }
+  } catch {}
+  return {
+    available: false,
+    tool: "none",
+    message: "No recording tool found. Install sox: brew install sox (macOS) or apt install sox (Linux)"
+  };
+}
+function startRecording(config) {
+  if (_recordProcess) {
+    throw new RecordingError("Already recording. Stop the current recording first.");
+  }
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const filename = `recording-${timestamp}.${config.audio_format}`;
+  const filepath = join2(config.audio_dir, filename);
+  const args = buildRecordArgs(filepath, config);
+  _recordProcess = spawn(args[0], args.slice(1), {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  _currentFile = filepath;
+  _recordProcess.on("error", (err) => {
+    _recordProcess = null;
+    _currentFile = null;
+    throw new RecordingError(`Recording process error: ${err.message}`);
+  });
+  _recordProcess.on("exit", () => {
+    _recordProcess = null;
+  });
+  return filepath;
+}
+function stopRecording() {
+  if (!_recordProcess) {
+    return null;
+  }
+  const filepath = _currentFile;
+  _recordProcess.kill("SIGINT");
+  _recordProcess = null;
+  _currentFile = null;
+  return filepath;
+}
+function isRecording() {
+  return _recordProcess !== null;
+}
+function getCurrentFile() {
+  return _currentFile;
+}
+function buildRecordArgs(filepath, config) {
+  const format = config.audio_format;
+  const rate = config.sample_rate;
+  const maxSeconds = config.max_recording_seconds;
+  return [
+    "rec",
+    "-r",
+    rate.toString(),
+    "-c",
+    "1",
+    "-b",
+    "16",
+    filepath,
+    "trim",
+    "0",
+    maxSeconds.toString()
+  ];
+}
+async function recordDuration(seconds, config) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const filename = `recording-${timestamp}.${config.audio_format}`;
+  const filepath = join2(config.audio_dir, filename);
+  const args = [
+    "rec",
+    "-r",
+    config.sample_rate.toString(),
+    "-c",
+    "1",
+    "-b",
+    "16",
+    filepath,
+    "trim",
+    "0",
+    seconds.toString()
+  ];
+  const proc = Bun.spawn(args, {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0 && !existsSync2(filepath)) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new RecordingError(`Recording failed (exit ${exitCode}): ${stderr}`);
+  }
+  return filepath;
+}
+export {
+  transcribeBuffer,
+  transcribeAudio,
+  stopRecording,
+  startRecording,
+  shortUuid,
+  searchRecordings,
+  resetEnhancementClient,
+  resetDatabase,
+  resetClient,
+  registerProject,
+  registerAgent,
+  recordDuration,
+  processText,
+  needsEnhancement,
+  loadConfig,
+  listRecordings,
+  listProjects,
+  listAgents,
+  isRecording,
+  getRecordingStats,
+  getRecording,
+  getProject,
+  getDbPath,
+  getDatabase,
+  getDataDir,
+  getCurrentFile,
+  getAgent,
+  ensureDataDir,
+  enhanceText,
+  deleteRecording,
+  createRecording,
+  closeDatabase,
+  checkRecordingDeps,
+  TranscriptionError,
+  RecordingNotFoundError,
+  RecordingError,
+  EnhancementError,
+  DEFAULT_CONFIG
+};