@kikedealba/recap 0.0.0-stage → 0.9.0

package/dist/cli/router.js

@@ -0,0 +1,94 @@
+import { readManifest } from '@kikedealba/kit/registry';
+import { usageError } from "../errors.js";
+import { findCapture } from "../capture/capture.js";
+import { capabilities } from "../setup/integration.js";
+import { VERSION } from "../version.js";
+import { askCommand } from "./commands/ask.js";
+import { configCommand } from "./commands/config.js";
+import { bitaHookCommand } from "./commands/hook.js";
+import { liveWorkerCommand } from "./commands/live.js";
+import { compressVideoCommand, deleteCommand, pruneCommand, stripVideoCommand } from "./commands/media.js";
+import { proposalsCommand } from "./commands/proposals.js";
+import { listCommand, processCommand, promptCommand, saveSummaryCommand, showCommand, waitCommand } from "./commands/query.js";
+import { discardCommand, importCommand, startCommand, statusCommand, stopCommand } from "./commands/recording.js";
+import { setupCommand } from "./commands/setup.js";
+import { output } from "./output.js";
+async function capabilitiesCommand(argv) {
+    return output('capabilities', argv.includes('--json'), async () => {
+        const registered = await readManifest('recap').catch(() => null);
+        const capture = (await findCapture()) !== null;
+        const data = { name: 'recap', version: VERSION, envelope: 1, capabilities: capabilities(capture), emits: [] };
+        return { data: { ...data, ...(registered ? { subscribes: registered.subscribes } : {}) }, text: data.capabilities.join('\n') };
+    });
+}
+const COMMANDS = {
+    start: startCommand,
+    stop: stopCommand,
+    discard: discardCommand,
+    status: statusCommand,
+    list: listCommand,
+    show: showCommand,
+    process: processCommand,
+    import: importCommand,
+    'compress-video': compressVideoCommand,
+    'strip-video': stripVideoCommand,
+    prune: pruneCommand,
+    delete: deleteCommand,
+    prompt: promptCommand,
+    'save-summary': saveSummaryCommand,
+    'bita-hook': bitaHookCommand,
+    wait: waitCommand,
+    setup: setupCommand,
+    ask: askCommand,
+    proposals: proposalsCommand,
+    config: configCommand,
+    'live-worker': liveWorkerCommand,
+    capabilities: capabilitiesCommand,
+};
+export function help() {
+    return [
+        `recap ${VERSION} — record meetings, transcribe them locally and summarize them with Claude Code`,
+        '',
+        'Recording (macOS, through Recap.app):',
+        '  recap start --remote|--in-person [title] [--bita-entry id] [--display id] [--timeout s]',
+        '  recap stop [--no-process] [--timeout s]',
+        '  recap discard [meeting] [--bita-entry id]',
+        '  recap status',
+        '',
+        'Any system:',
+        '  recap import <audio|video file> [--title t] [--remote|--in-person] [--no-process|--background]',
+        '  recap process [meeting] [--from stage] [--only stage] [--background]',
+        '  recap list [--limit n] | show [meeting] [--bita-entry id] [--path] | wait [meeting] [--bita-entry id] [--timeout s]',
+        '  recap prompt [meeting] | save-summary <meeting> <file|->',
+        '  recap ask (--active|--meeting m|--bita-entry id) [--question q] [--window s] [--json-stream] | ask --sources --project p',
+        '  recap proposals ls|show|accept|reject <meeting> [n] [--bita-entry id] [--md file]',
+        '  recap compress-video <meeting> --preset light|medium|max | strip-video <meeting> | prune <meeting> --intermediates | delete <meeting>',
+        '  recap config get [key] | config set <key> <value>',
+        '  recap setup [--install-deps] [--skip-models] [--skip-permissions] [--skip-bita] [--skip-app] [--agents detected|all|none|claude,opencode,codex,gemini]',
+        '  recap capabilities',
+        '',
+        'Stages: audio, transcribe, frames, summarize, proposals, wrapup. Every command takes --json.',
+    ].join('\n');
+}
+export async function main(argv) {
+    const [name, ...rest] = argv;
+    if (name === undefined || name === '--help' || name === '-h' || name === 'help') {
+        process.stdout.write(`${help()}\n`);
+        return 0;
+    }
+    if (name === '--version' || name === '-v' || name === 'version') {
+        process.stdout.write(`${VERSION}\n`);
+        return 0;
+    }
+    const command = COMMANDS[name];
+    if (!command) {
+        return output(name, argv.includes('--json'), () => {
+            throw usageError(`Unknown command "${name}"`, 'Run `recap --help` to see the commands.');
+        });
+    }
+    if (rest.includes('--help') && name !== 'bita-hook') {
+        process.stdout.write(`${help()}\n`);
+        return 0;
+    }
+    return command(rest);
+}

package/dist/core/active.js

@@ -0,0 +1,46 @@
+import { rmSync } from 'node:fs';
+import { activeFile } from "./paths.js";
+import { readText, writeAtomic } from "./fsutil.js";
+import { isRecord, swiftPretty } from "./json.js";
+import { isActiveStatus, loadMeeting, reconcile } from "./meeting.js";
+export function loadActive() {
+    const text = readText(activeFile());
+    if (text === null)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        if (!isRecord(value) || typeof value['meetingId'] !== 'string' || typeof value['dir'] !== 'string' || typeof value['startedAt'] !== 'string')
+            return null;
+        if (value['mode'] !== 'remote' && value['mode'] !== 'in-person')
+            return null;
+        return { meetingId: value['meetingId'], dir: value['dir'], mode: value['mode'], startedAt: value['startedAt'] };
+    }
+    catch {
+        return null;
+    }
+}
+export function saveActive(active) {
+    writeAtomic(activeFile(), swiftPretty(active));
+}
+export function clearActive() {
+    rmSync(activeFile(), { force: true });
+}
+export function currentRecording() {
+    const active = loadActive();
+    if (!active)
+        return null;
+    let stored;
+    try {
+        stored = loadMeeting(active.dir);
+    }
+    catch {
+        clearActive();
+        return null;
+    }
+    const meeting = reconcile(stored, active.dir);
+    if (!isActiveStatus(meeting.status)) {
+        clearActive();
+        return null;
+    }
+    return { active, meeting };
+}

package/dist/core/config.js

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { RecapError, errorMessage } from "../errors.js";
+import { readText, writeAtomic, exists } from "./fsutil.js";
+import { isRecord, swiftPretty } from "./json.js";
+import { liveSettings } from "./live-settings.js";
+import { configFile, expandTilde, modelsDir } from "./paths.js";
+export const MODELS = {
+    whisper: {
+        fileName: 'ggml-large-v3-turbo.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin',
+    },
+    vad: {
+        fileName: 'ggml-silero-v5.1.2.bin',
+        url: 'https://huggingface.co/ggml-org/whisper-vad/resolve/main/ggml-silero-v5.1.2.bin',
+    },
+};
+function checkString(config, key) {
+    if (config[key] !== undefined && config[key] !== null && typeof config[key] !== 'string')
+        throw new Error(`${key} must be a string`);
+}
+export function parseConfig(text) {
+    const value = JSON.parse(text);
+    if (!isRecord(value))
+        throw new Error('the configuration must be a JSON object');
+    for (const key of ['root', 'language', 'whisperModel', 'summaryModel'])
+        checkString(value, key);
+    if (value['vocabulary'] !== undefined && value['vocabulary'] !== null) {
+        if (!Array.isArray(value['vocabulary']) || !value['vocabulary'].every((item) => typeof item === 'string'))
+            throw new Error('vocabulary must be a list of strings');
+    }
+    if (value['tools'] !== undefined && value['tools'] !== null) {
+        if (!isRecord(value['tools']) || !Object.values(value['tools']).every((item) => typeof item === 'string'))
+            throw new Error('tools must map names to paths');
+    }
+    if (value['live'] !== undefined && value['live'] !== null && !isRecord(value['live']))
+        throw new Error('live must be an object');
+    const cleaned = {};
+    for (const [key, item] of Object.entries(value))
+        if (item !== null)
+            cleaned[key] = item;
+    return cleaned;
+}
+export function loadConfig() {
+    const file = configFile();
+    if (!exists(file))
+        return {};
+    const text = readText(file);
+    if (text === null)
+        throw new RecapError('CONFIG_INVALID', `Cannot read ${file}`);
+    try {
+        return parseConfig(text);
+    }
+    catch (error) {
+        throw new RecapError('CONFIG_INVALID', `Cannot read ${file}: ${errorMessage(error)}`);
+    }
+}
+export function saveConfig(config) {
+    writeAtomic(configFile(), swiftPretty(config));
+}
+export function rootDir(config) {
+    const override = process.env['RECAP_ROOT'];
+    if (override)
+        return expandTilde(override);
+    return expandTilde(config.root ?? '~/Recap');
+}
+export function transcriptionLanguage(config) {
+    return config.language ?? 'es';
+}
+export function whisperModelPath(config) {
+    return config.whisperModel ? expandTilde(config.whisperModel) : path.join(modelsDir(), MODELS.whisper.fileName);
+}
+export function vadModelPath() {
+    return path.join(modelsDir(), MODELS.vad.fileName);
+}
+export function settingsOf(config) {
+    return liveSettings(config.live);
+}

package/dist/core/dates.js

@@ -0,0 +1,30 @@
+const MONTHS = ['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre'];
+const two = (value) => String(value).padStart(2, '0');
+export function isoDate(date) {
+    return date.toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+export function isoNow() {
+    return isoDate(new Date());
+}
+export function parseDate(value) {
+    if (!value)
+        return null;
+    const ms = Date.parse(value);
+    return Number.isNaN(ms) ? null : new Date(ms);
+}
+export function esHeaderDate(date) {
+    return `${date.getDate()} de ${MONTHS[date.getMonth()]} de ${date.getFullYear()}, ${two(date.getHours())}:${two(date.getMinutes())}`;
+}
+export function dayString(date) {
+    return `${date.getFullYear()}-${two(date.getMonth() + 1)}-${two(date.getDate())}`;
+}
+export function idStamp(date) {
+    return `${dayString(date)}-${two(date.getHours())}${two(date.getMinutes())}`;
+}
+export function minuteStamp(date) {
+    return `${dayString(date)} ${two(date.getHours())}:${two(date.getMinutes())}`;
+}
+export function clock(ms) {
+    const total = Math.max(0, Math.trunc(ms / 1000));
+    return `${two(Math.trunc(total / 3600))}:${two(Math.trunc((total % 3600) / 60))}:${two(total % 60)}`;
+}

package/dist/core/fsutil.js

@@ -0,0 +1,44 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+export function writeAtomic(file, content) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${Date.now()}.tmp`);
+    writeFileSync(temporary, content);
+    try {
+        renameSync(temporary, file);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        throw error;
+    }
+}
+export function readText(file) {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function exists(file) {
+    return existsSync(file);
+}
+export function isDirectory(file) {
+    try {
+        return statSync(file).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function fileSize(file) {
+    try {
+        return statSync(file).size;
+    }
+    catch {
+        return 0;
+    }
+}
+export function removePath(file) {
+    rmSync(file, { recursive: true, force: true });
+}

package/dist/core/json.js

@@ -0,0 +1,70 @@
+function encodeString(value, options) {
+    const text = JSON.stringify(value);
+    return options.escapeSlashes ? text.replace(/\//g, '\\/') : text;
+}
+function encodeValue(value, options, indent) {
+    if (value === null || value === undefined)
+        return 'null';
+    if (typeof value === 'string')
+        return encodeString(value, options);
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? JSON.stringify(value) : 'null';
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    const inner = `${indent}  `;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return options.pretty ? `[\n\n${indent}]` : '[]';
+        const items = value.map((item) => encodeValue(item, options, inner));
+        return options.pretty ? `[\n${items.map((item) => `${inner}${item}`).join(',\n')}\n${indent}]` : `[${items.join(',')}]`;
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        let keys = Object.keys(record).filter((key) => record[key] !== undefined);
+        if (options.sorted)
+            keys = keys.sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+        if (keys.length === 0)
+            return options.pretty ? `{\n\n${indent}}` : '{}';
+        const separator = options.pretty ? ' : ' : ':';
+        const entries = keys.map((key) => `${encodeString(key, options)}${separator}${encodeValue(record[key], options, inner)}`);
+        return options.pretty ? `{\n${entries.map((entry) => `${inner}${entry}`).join(',\n')}\n${indent}}` : `{${entries.join(',')}}`;
+    }
+    return 'null';
+}
+export function encodeJson(value, options = {}) {
+    return encodeValue(value, options, '');
+}
+export const swiftPretty = (value) => encodeJson(value, { pretty: true, sorted: true });
+export const swiftLine = (value) => encodeJson(value, { sorted: true });
+export const swiftDefault = (value) => encodeJson(value, { escapeSlashes: true });
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+export function asInt(value) {
+    return typeof value === 'number' && Number.isInteger(value) ? value : undefined;
+}
+export function asIntLoose(value) {
+    if (typeof value === 'number' && Number.isInteger(value))
+        return value;
+    if (typeof value === 'string' && /^[+-]?\d+$/.test(value))
+        return Number(value);
+    return undefined;
+}
+export function parseJsonSafe(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function extractBetween(text, open, close) {
+    const start = text.indexOf(open);
+    const end = text.lastIndexOf(close);
+    if (start === -1 || end === -1 || start >= end)
+        return undefined;
+    return parseJsonSafe(text.slice(start, end + 1));
+}

package/dist/core/live-settings.js

@@ -0,0 +1,140 @@
+import { RecapError } from "../errors.js";
+import { trimmed } from "./text.js";
+export const RANGES = {
+    chunkSeconds: [5, 60],
+    autoAskSeconds: [3, 120],
+    autoAskConcurrency: [1, 6],
+};
+export const DEFAULTS = {
+    maxChunkSeconds: 10,
+    autoAskMinSeconds: 5,
+    autoAskConcurrency: 3,
+    autoAskModel: 'haiku',
+};
+const clamp = (value, [low, high]) => Math.min(Math.max(value, low), high);
+function bool(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function int(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.trunc(value) : fallback;
+}
+function model(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = trimmed(value);
+    return text.length === 0 ? null : text;
+}
+export function liveSettings(config) {
+    return {
+        enabled: bool(config?.enabled, true),
+        openWindow: bool(config?.openWindow, true),
+        proposals: bool(config?.proposals, true),
+        maxChunkSeconds: clamp(int(config?.maxChunkSeconds, DEFAULTS.maxChunkSeconds), RANGES.chunkSeconds),
+        assistModel: model(config?.assistModel),
+        autoAsk: bool(config?.autoAsk, true),
+        autoAskModel: model(config?.autoAskModel) ?? DEFAULTS.autoAskModel,
+        autoAskMinSeconds: clamp(int(config?.autoAskMinSeconds, DEFAULTS.autoAskMinSeconds), RANGES.autoAskSeconds),
+        autoAskConcurrency: clamp(int(config?.autoAskConcurrency, DEFAULTS.autoAskConcurrency), RANGES.autoAskConcurrency),
+    };
+}
+export const CONFIG_KEYS = [
+    'live.enabled',
+    'live.openWindow',
+    'live.proposals',
+    'live.assistModel',
+    'live.maxChunkSeconds',
+    'live.autoAsk',
+    'live.autoAskModel',
+    'live.autoAskMinSeconds',
+    'live.autoAskConcurrency',
+];
+export function parseConfigKey(raw) {
+    const found = CONFIG_KEYS.find((key) => key === raw) ?? CONFIG_KEYS.find((key) => key.toLowerCase() === raw.toLowerCase());
+    if (!found)
+        throw new RecapError('CONFIG_KEY_UNKNOWN', `Unknown key "${raw}"; use one of ${CONFIG_KEYS.join(', ')}`);
+    return found;
+}
+export function configValue(key, live) {
+    const settings = liveSettings(live);
+    switch (key) {
+        case 'live.enabled':
+            return settings.enabled;
+        case 'live.openWindow':
+            return settings.openWindow;
+        case 'live.proposals':
+            return settings.proposals;
+        case 'live.assistModel':
+            return settings.assistModel;
+        case 'live.maxChunkSeconds':
+            return settings.maxChunkSeconds;
+        case 'live.autoAsk':
+            return settings.autoAsk;
+        case 'live.autoAskModel':
+            return settings.autoAskModel;
+        case 'live.autoAskMinSeconds':
+            return settings.autoAskMinSeconds;
+        case 'live.autoAskConcurrency':
+            return settings.autoAskConcurrency;
+    }
+}
+export function configValueText(value) {
+    if (value === null)
+        return 'null';
+    return String(value);
+}
+function parseBool(raw) {
+    const value = trimmed(raw).toLowerCase();
+    if (['true', 'on', 'yes', '1'].includes(value))
+        return true;
+    if (['false', 'off', 'no', '0'].includes(value))
+        return false;
+    throw new RecapError('CONFIG_VALUE_INVALID', `Expected true or false, got "${raw}"`);
+}
+function parseRange(key, raw, [low, high], unit) {
+    const text = trimmed(raw);
+    const value = /^[+-]?\d+$/.test(text) ? Number(text) : Number.NaN;
+    if (!Number.isInteger(value) || value < low || value > high) {
+        throw new RecapError('CONFIG_VALUE_INVALID', unit === 'seconds' ? `${key} takes whole seconds between ${low} and ${high}` : `${key} takes a whole number between ${low} and ${high}`);
+    }
+    return value;
+}
+function optionalModel(raw) {
+    const text = trimmed(raw);
+    return ['', 'null', 'none', 'default'].includes(text.toLowerCase()) ? undefined : text;
+}
+export function applyConfigValue(key, raw, live) {
+    const next = { ...(live ?? {}) };
+    switch (key) {
+        case 'live.enabled':
+            next.enabled = parseBool(raw);
+            break;
+        case 'live.openWindow':
+            next.openWindow = parseBool(raw);
+            break;
+        case 'live.proposals':
+            next.proposals = parseBool(raw);
+            break;
+        case 'live.assistModel':
+            next.assistModel = optionalModel(raw);
+            break;
+        case 'live.maxChunkSeconds':
+            next.maxChunkSeconds = parseRange(key, raw, RANGES.chunkSeconds, 'seconds');
+            break;
+        case 'live.autoAsk':
+            next.autoAsk = parseBool(raw);
+            break;
+        case 'live.autoAskModel':
+            next.autoAskModel = optionalModel(raw);
+            break;
+        case 'live.autoAskMinSeconds':
+            next.autoAskMinSeconds = parseRange(key, raw, RANGES.autoAskSeconds, 'seconds');
+            break;
+        case 'live.autoAskConcurrency':
+            next.autoAskConcurrency = parseRange(key, raw, RANGES.autoAskConcurrency, 'count');
+            break;
+    }
+    return next;
+}
+export function configSnapshot(live) {
+    return Object.fromEntries(CONFIG_KEYS.map((key) => [key, configValue(key, live)]));
+}

package/dist/core/lock.js

@@ -0,0 +1,114 @@
+import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { RecapError } from "../errors.js";
+import { readText } from "./fsutil.js";
+import { isAlive } from "./proc.js";
+import { trimmed } from "./text.js";
+export function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+export function lockOwner(file) {
+    const text = readText(file);
+    if (text === null)
+        return null;
+    const value = trimmed(text);
+    return /^\d+$/.test(value) ? Number(value) : null;
+}
+function steal(target) {
+    const aside = `${target}.stale-${process.pid}-${Math.random().toString(36).slice(2)}`;
+    try {
+        renameSync(target, aside);
+    }
+    catch {
+        return;
+    }
+    rmSync(aside, { recursive: true, force: true });
+}
+export class ProcessLock {
+    file;
+    constructor(file, code = 'ALREADY_PROCESSING', message = (pid) => `The meeting is already being processed (pid ${pid})`) {
+        this.file = file;
+        mkdirSync(path.dirname(file), { recursive: true });
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                writeFileSync(file, String(process.pid), { flag: 'wx' });
+                return;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+            const pid = lockOwner(file);
+            if (pid === process.pid)
+                return;
+            if (pid !== null && isAlive(pid))
+                throw new RecapError(code, message(pid));
+            if (pid === null && attempt < 20) {
+                sleepSync(10);
+                continue;
+            }
+            steal(file);
+        }
+    }
+    release() {
+        if (lockOwner(this.file) === process.pid)
+            rmSync(this.file, { force: true });
+    }
+}
+function tryLock(lockDir) {
+    const owner = path.join(lockDir, 'pid');
+    try {
+        mkdirSync(lockDir);
+        writeFileSync(owner, String(process.pid));
+        return true;
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw new RecapError('WRITE_FAILED', `Cannot take the lock ${lockDir}: ${error.message}`);
+        const pid = lockOwner(owner);
+        let age = 0;
+        try {
+            age = Date.now() - statSync(lockDir).mtimeMs;
+        }
+        catch {
+            return false;
+        }
+        if ((pid !== null && pid !== process.pid && !isAlive(pid)) || (pid === null && age > 2_000))
+            steal(lockDir);
+        return false;
+    }
+}
+function unlock(lockDir) {
+    if (lockOwner(path.join(lockDir, 'pid')) === process.pid)
+        rmSync(lockDir, { recursive: true, force: true });
+}
+export function withDirectoryLock(lockDir, body, timeoutMs = 15_000) {
+    mkdirSync(path.dirname(lockDir), { recursive: true });
+    const deadline = Date.now() + timeoutMs;
+    while (!tryLock(lockDir)) {
+        if (Date.now() > deadline)
+            throw new RecapError('WRITE_FAILED', `Timed out waiting for the lock ${lockDir}`);
+        sleepSync(5);
+    }
+    try {
+        return body();
+    }
+    finally {
+        unlock(lockDir);
+    }
+}
+export async function withDirectoryLockAsync(lockDir, body, timeoutMs = 60_000) {
+    mkdirSync(path.dirname(lockDir), { recursive: true });
+    const deadline = Date.now() + timeoutMs;
+    while (!tryLock(lockDir)) {
+        if (Date.now() > deadline)
+            throw new RecapError('WRITE_FAILED', `Timed out waiting for the lock ${lockDir}`);
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    try {
+        return await body();
+    }
+    finally {
+        unlock(lockDir);
+    }
+}