@hasna/recordings 0.1.0 → 0.1.2

package/dist/types/index.d.ts

@@ -0,0 +1,103 @@
+export interface Recording {
+    id: string;
+    audio_path: string | null;
+    raw_text: string;
+    processed_text: string | null;
+    processing_mode: ProcessingMode;
+    model_used: string;
+    enhancement_model: string | null;
+    duration_ms: number;
+    language: string | null;
+    tags: string[];
+    agent_id: string | null;
+    project_id: string | null;
+    session_id: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+}
+export type ProcessingMode = "raw" | "enhanced";
+export interface CreateRecordingInput {
+    audio_path?: string;
+    raw_text: string;
+    processed_text?: string;
+    processing_mode?: ProcessingMode;
+    model_used?: string;
+    enhancement_model?: string;
+    duration_ms?: number;
+    language?: string;
+    tags?: string[];
+    agent_id?: string;
+    project_id?: string;
+    session_id?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RecordingFilter {
+    agent_id?: string;
+    project_id?: string;
+    session_id?: string;
+    processing_mode?: ProcessingMode;
+    tags?: string[];
+    search?: string;
+    since?: string;
+    until?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface Agent {
+    id: string;
+    name: string;
+    description: string | null;
+    role: string;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    last_seen_at: string;
+}
+export interface Project {
+    id: string;
+    name: string;
+    path: string;
+    description: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface RecordingsConfig {
+    openai_api_key: string;
+    enhancement_api_key: string;
+    transcription_model: string;
+    enhancement_model: string;
+    language: string;
+    audio_format: "wav" | "mp3" | "m4a" | "webm";
+    sample_rate: number;
+    record_command: string;
+    hotkey: string;
+    auto_enhance: boolean;
+    enhance_triggers: string[];
+    db_path: string;
+    audio_dir: string;
+    max_recording_seconds: number;
+}
+export interface TranscriptionResult {
+    text: string;
+    duration_ms: number;
+    model: string;
+    language: string | null;
+}
+export interface EnhancementResult {
+    original: string;
+    enhanced: string;
+    model: string;
+    reasoning: string | null;
+}
+export declare class RecordingNotFoundError extends Error {
+    constructor(id: string);
+}
+export declare class RecordingError extends Error {
+    constructor(message: string);
+}
+export declare class TranscriptionError extends Error {
+    constructor(message: string);
+}
+export declare class EnhancementError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,55 +1,46 @@
 {
   "name": "@hasna/recordings",
-  "version": "0.1.0",
-  "description": "Local AI-powered voice recording & transcription — record, transcribe, polish, search",
+  "version": "0.1.2",
   "type": "module",
+  "description": "Speech-to-text recording tool with MCP and CLI — records, transcribes, and optionally enhances text using AI",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
-    "recordings": "dist/index.js"
+    "recordings": "dist/cli/index.js",
+    "recordings-mcp": "dist/mcp/index.js"
   },
-  "files": [
-    "dist",
-    "scripts",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "postinstall": "bun run scripts/postinstall.ts",
-    "dev": "bun run dev:api & bun run dev:web",
-    "dev:api": "bun run packages/api-server/src/index.ts",
-    "dev:web": "cd apps/web && bun run dev",
-    "mcp": "bun run packages/mcp-server/src/index.ts",
-    "build": "bun run build.ts",
-    "prepublishOnly": "bun run build"
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
+  "scripts": {
+    "build": "bun run build:cli && bun run build:mcp && bun run build:lib && tsc --emitDeclarationOnly --outDir dist",
+    "build:cli": "bun build src/cli/index.ts --target=bun --outfile=dist/cli/index.js --external=commander --external=chalk --external=openai",
+    "build:mcp": "bun build src/mcp/index.ts --target=bun --outfile=dist/mcp/index.js --external=@modelcontextprotocol/sdk --external=openai",
+    "build:lib": "bun build src/index.ts --target=bun --outfile=dist/index.js --external=openai",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage",
+    "dev:cli": "bun run src/cli/index.ts",
+    "dev:mcp": "bun run src/mcp/index.ts"
   },
-  "engines": {
-    "bun": ">=1.3.9"
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "openai": "^5.1.0",
+    "zod": "^3.24.2"
   },
-  "author": "Hasna",
-  "license": "Apache-2.0",
-  "keywords": [
-    "recordings",
-    "transcription",
-    "voice",
-    "openai",
-    "whisper",
-    "mcp",
-    "cli",
-    "bun"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/hasna/recordings.git"
+  "devDependencies": {
+    "@types/bun": "^1.2.5",
+    "typescript": "^5.8.2"
   },
-  "bugs": {
-    "url": "https://github.com/hasna/recordings/issues"
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
   },
-  "homepage": "https://github.com/hasna/recordings#readme",
-  "workspaces": [
-    "apps/*",
-    "packages/*"
-  ]
+  "license": "MIT",
+  "author": "Hasna <andrei@hasna.com>"
 }

package/src/__tests__/agents.test.ts

@@ -0,0 +1,136 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { tmpdir } from "os";
+import { join } from "path";
+import { mkdirSync, rmSync, existsSync } from "fs";
+import {
+  getDatabase,
+  closeDatabase,
+  resetDatabase,
+} from "../db/database.js";
+import { registerAgent, getAgent, listAgents } from "../db/agents.js";
+import { type Database } from "bun:sqlite";
+
+let tempDir: string;
+let db: Database;
+
+beforeEach(() => {
+  resetDatabase();
+  tempDir = join(tmpdir(), `open-recordings-test-agents-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(tempDir, { recursive: true });
+  const dbPath = join(tempDir, "test.db");
+  db = getDatabase(dbPath);
+});
+
+afterEach(() => {
+  closeDatabase();
+  resetDatabase();
+  if (existsSync(tempDir)) {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+describe("registerAgent", () => {
+  test("creates a new agent with name only", () => {
+    const agent = registerAgent("maximus", undefined, undefined, db);
+    expect(agent).toBeDefined();
+    expect(agent.name).toBe("maximus");
+    expect(agent.role).toBe("agent");
+    expect(agent.description).toBeNull();
+    expect(agent.metadata).toEqual({});
+    expect(agent.id).toHaveLength(8);
+    expect(agent.created_at).toBeDefined();
+    expect(agent.last_seen_at).toBeDefined();
+  });
+
+  test("creates a new agent with description and role", () => {
+    const agent = registerAgent("cassius", "A helper agent", "assistant", db);
+    expect(agent.name).toBe("cassius");
+    expect(agent.description).toBe("A helper agent");
+    expect(agent.role).toBe("assistant");
+  });
+
+  test("returns existing agent and updates last_seen_at (idempotent)", () => {
+    const first = registerAgent("aurelius", undefined, undefined, db);
+    // Wait a tiny bit to ensure timestamp difference
+    const second = registerAgent("aurelius", undefined, undefined, db);
+
+    expect(second.id).toBe(first.id);
+    expect(second.name).toBe("aurelius");
+    // last_seen_at should be updated
+    expect(new Date(second.last_seen_at).getTime()).toBeGreaterThanOrEqual(
+      new Date(first.last_seen_at).getTime()
+    );
+  });
+
+  test("does not duplicate agents on re-register", () => {
+    registerAgent("brutus", undefined, undefined, db);
+    registerAgent("brutus", undefined, undefined, db);
+    registerAgent("brutus", undefined, undefined, db);
+
+    const agents = listAgents(db);
+    const brutusAgents = agents.filter((a) => a.name === "brutus");
+    expect(brutusAgents).toHaveLength(1);
+  });
+});
+
+describe("getAgent", () => {
+  test("finds agent by ID", () => {
+    const created = registerAgent("titus", undefined, undefined, db);
+    const found = getAgent(created.id, db);
+    expect(found).toBeDefined();
+    expect(found!.name).toBe("titus");
+  });
+
+  test("finds agent by name", () => {
+    registerAgent("nero", "The emperor", undefined, db);
+    const found = getAgent("nero", db);
+    expect(found).toBeDefined();
+    expect(found!.description).toBe("The emperor");
+  });
+
+  test("finds agent by partial ID prefix", () => {
+    const created = registerAgent("cicero", undefined, undefined, db);
+    const prefix = created.id.substring(0, 4);
+    const found = getAgent(prefix, db);
+    expect(found).toBeDefined();
+    expect(found!.name).toBe("cicero");
+  });
+
+  test("returns null for non-existent agent", () => {
+    const found = getAgent("nonexistent", db);
+    expect(found).toBeNull();
+  });
+});
+
+describe("listAgents", () => {
+  test("returns empty array when no agents", () => {
+    const agents = listAgents(db);
+    expect(agents).toEqual([]);
+  });
+
+  test("returns all agents ordered by last_seen_at DESC", () => {
+    registerAgent("alpha", undefined, undefined, db);
+    registerAgent("beta", undefined, undefined, db);
+    registerAgent("gamma", undefined, undefined, db);
+
+    const agents = listAgents(db);
+    expect(agents).toHaveLength(3);
+    // All three agents are present
+    const names = agents.map((a) => a.name);
+    expect(names).toContain("alpha");
+    expect(names).toContain("beta");
+    expect(names).toContain("gamma");
+  });
+
+  test("parses metadata JSON correctly", () => {
+    const agent = registerAgent("delta", undefined, undefined, db);
+    // Manually update metadata for testing
+    db.query("UPDATE agents SET metadata = ? WHERE id = ?").run(
+      JSON.stringify({ tool: "test" }),
+      agent.id
+    );
+
+    const found = getAgent(agent.id, db);
+    expect(found!.metadata).toEqual({ tool: "test" });
+  });
+});

package/src/__tests__/config.test.ts

@@ -0,0 +1,252 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { tmpdir } from "os";
+import { join } from "path";
+import { mkdirSync, rmSync, existsSync, writeFileSync } from "fs";
+import { loadConfig, getDataDir, ensureDataDir, DEFAULT_CONFIG } from "../lib/config.js";
+
+let tempDir: string;
+
+// Save and restore env vars
+const savedEnv: Record<string, string | undefined> = {};
+const envKeys = [
+  "OPENAI_API_KEY",
+  "RECORDINGS_API_KEY",
+  "RECORDINGS_ENHANCEMENT_KEY",
+  "RECORDINGS_MODEL",
+  "RECORDINGS_ENHANCEMENT_MODEL",
+  "RECORDINGS_LANGUAGE",
+  "RECORDINGS_DB_PATH",
+  "RECORDINGS_AUDIO_DIR",
+  "RECORDINGS_MAX_SECONDS",
+];
+
+beforeEach(() => {
+  tempDir = join(tmpdir(), `open-recordings-test-config-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(tempDir, { recursive: true });
+
+  // Save env vars
+  for (const key of envKeys) {
+    savedEnv[key] = process.env[key];
+    delete process.env[key];
+  }
+});
+
+afterEach(() => {
+  // Restore env vars
+  for (const key of envKeys) {
+    if (savedEnv[key] !== undefined) {
+      process.env[key] = savedEnv[key];
+    } else {
+      delete process.env[key];
+    }
+  }
+
+  if (existsSync(tempDir)) {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+describe("DEFAULT_CONFIG", () => {
+  test("has expected default values", () => {
+    expect(DEFAULT_CONFIG.transcription_model).toBe("gpt-4o-mini-transcribe");
+    expect(DEFAULT_CONFIG.enhancement_model).toBe("gpt-4o");
+    expect(DEFAULT_CONFIG.language).toBe("en");
+    expect(DEFAULT_CONFIG.audio_format).toBe("wav");
+    expect(DEFAULT_CONFIG.sample_rate).toBe(16000);
+    expect(DEFAULT_CONFIG.record_command).toBe("sox");
+    expect(DEFAULT_CONFIG.hotkey).toBe("space");
+    expect(DEFAULT_CONFIG.auto_enhance).toBe(true);
+    expect(DEFAULT_CONFIG.max_recording_seconds).toBe(300);
+    expect(DEFAULT_CONFIG.enhance_triggers).toContain("say it better");
+    expect(DEFAULT_CONFIG.enhance_triggers).toContain("rewrite this");
+  });
+});
+
+describe("loadConfig", () => {
+  test("returns defaults when no config file or env vars", () => {
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.transcription_model).toBe("gpt-4o-mini-transcribe");
+    expect(config.enhancement_model).toBe("gpt-4o");
+    expect(config.language).toBe("en");
+    expect(config.audio_format).toBe("wav");
+    expect(config.auto_enhance).toBe(true);
+  });
+
+  test("loads config from file", () => {
+    const configPath = join(tempDir, "config.json");
+    writeFileSync(
+      configPath,
+      JSON.stringify({
+        transcription_model: "whisper-1",
+        language: "fr",
+        auto_enhance: false,
+      })
+    );
+
+    const config = loadConfig(configPath);
+    expect(config.transcription_model).toBe("whisper-1");
+    expect(config.language).toBe("fr");
+    expect(config.auto_enhance).toBe(false);
+    // Other defaults still present
+    expect(config.audio_format).toBe("wav");
+  });
+
+  test("ignores invalid JSON config file", () => {
+    const configPath = join(tempDir, "bad-config.json");
+    writeFileSync(configPath, "this is not json {{{");
+
+    const config = loadConfig(configPath);
+    // Should fall back to defaults
+    expect(config.transcription_model).toBe("gpt-4o-mini-transcribe");
+  });
+
+  test("env var OPENAI_API_KEY overrides config", () => {
+    process.env.OPENAI_API_KEY = "sk-env-key";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.openai_api_key).toBe("sk-env-key");
+  });
+
+  test("env var RECORDINGS_API_KEY overrides OPENAI_API_KEY", () => {
+    process.env.OPENAI_API_KEY = "sk-openai";
+    process.env.RECORDINGS_API_KEY = "sk-recordings";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.openai_api_key).toBe("sk-recordings");
+  });
+
+  test("env var RECORDINGS_ENHANCEMENT_KEY sets enhancement_api_key", () => {
+    process.env.RECORDINGS_ENHANCEMENT_KEY = "sk-enhance";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.enhancement_api_key).toBe("sk-enhance");
+  });
+
+  test("env var RECORDINGS_MODEL overrides transcription_model", () => {
+    process.env.RECORDINGS_MODEL = "whisper-1";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.transcription_model).toBe("whisper-1");
+  });
+
+  test("env var RECORDINGS_ENHANCEMENT_MODEL overrides enhancement_model", () => {
+    process.env.RECORDINGS_ENHANCEMENT_MODEL = "gpt-3.5-turbo";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.enhancement_model).toBe("gpt-3.5-turbo");
+  });
+
+  test("env var RECORDINGS_LANGUAGE overrides language", () => {
+    process.env.RECORDINGS_LANGUAGE = "de";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.language).toBe("de");
+  });
+
+  test("env var RECORDINGS_DB_PATH overrides db_path", () => {
+    process.env.RECORDINGS_DB_PATH = "/custom/db.sqlite";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.db_path).toBe("/custom/db.sqlite");
+  });
+
+  test("env var RECORDINGS_AUDIO_DIR overrides audio_dir", () => {
+    process.env.RECORDINGS_AUDIO_DIR = "/custom/audio";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.audio_dir).toBe("/custom/audio");
+  });
+
+  test("env var RECORDINGS_MAX_SECONDS overrides max_recording_seconds", () => {
+    process.env.RECORDINGS_MAX_SECONDS = "60";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.max_recording_seconds).toBe(60);
+  });
+
+  test("sets default db_path when not configured", () => {
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.db_path).toBeTruthy();
+    expect(config.db_path).toContain("recordings.db");
+  });
+
+  test("sets default audio_dir when not configured", () => {
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.audio_dir).toBeTruthy();
+    expect(config.audio_dir).toContain("audio");
+  });
+
+  test("enhancement_api_key falls back to openai_api_key", () => {
+    process.env.OPENAI_API_KEY = "sk-shared";
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    expect(config.enhancement_api_key).toBe("sk-shared");
+  });
+
+  test("file config values are overridden by env vars", () => {
+    const configPath = join(tempDir, "config.json");
+    writeFileSync(
+      configPath,
+      JSON.stringify({ language: "fr", transcription_model: "file-model" })
+    );
+    process.env.RECORDINGS_LANGUAGE = "ja";
+
+    const config = loadConfig(configPath);
+    expect(config.language).toBe("ja"); // env wins
+    expect(config.transcription_model).toBe("file-model"); // no env override for this
+  });
+});
+
+describe("ensureDataDir", () => {
+  test("creates audio_dir and db directory", () => {
+    const audioDir = join(tempDir, "audio-out");
+    const dbPath = join(tempDir, "db-dir/recordings.db");
+    const config = {
+      ...DEFAULT_CONFIG,
+      audio_dir: audioDir,
+      db_path: dbPath,
+    };
+
+    ensureDataDir(config);
+    expect(existsSync(audioDir)).toBe(true);
+    expect(existsSync(join(tempDir, "db-dir"))).toBe(true);
+  });
+});
+
+describe("getDataDir", () => {
+  test("returns a string", () => {
+    const dir = getDataDir();
+    expect(typeof dir).toBe("string");
+    expect(dir).toContain(".recordings");
+  });
+});
+
+describe("loadSecretKey (via loadConfig)", () => {
+  test("loads API key from ~/.secrets with double quotes", () => {
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    // The key is either loaded from ~/.secrets or empty
+    expect(typeof config.openai_api_key).toBe("string");
+  });
+
+  test("loads secret key with single quotes format", () => {
+    // We can't easily mock ~/.secrets, but we test the regex patterns directly
+    // by testing the config loading with different env overrides
+    // The loadSecretKey function is internal, so we test its effect indirectly
+    // When no env var is set and no ~/.secrets has the key, it returns ""
+    const config = loadConfig(join(tempDir, "nonexistent.json"));
+    // At minimum, the function doesn't crash
+    expect(config).toBeDefined();
+  });
+});
+
+describe("findConfigFile (via loadConfig without explicit path)", () => {
+  test("loads config without explicit path (uses findConfigFile)", () => {
+    // When no configPath is given, findConfigFile walks up from cwd
+    const config = loadConfig();
+    expect(config).toBeDefined();
+    expect(config.transcription_model).toBeTruthy();
+  });
+});
+
+describe("ensureDataDir edge cases", () => {
+  test("handles db_path without directory separator", () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      audio_dir: join(tempDir, "audio"),
+      db_path: "recordings.db", // no directory part
+    };
+    // Should not throw - dbDir will be empty string
+    ensureDataDir(config);
+    expect(existsSync(join(tempDir, "audio"))).toBe(true);
+  });
+});