@kikedealba/recap 0.0.0-stage → 0.9.1

package/dist/pipeline/summary.js

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import { clock } from "../core/dates.js";
+import { readText, writeAtomic } from "../core/fsutil.js";
+import { isRecord, parseJsonSafe } from "../core/json.js";
+import { durationSeconds } from "../core/meeting.js";
+import { formatDuration, replaceAll, trimmed } from "../core/text.js";
+import { RecapError } from "../errors.js";
+import { resultText } from "./claude.js";
+import { loadResource } from "./resources.js";
+import { meetingHeader } from "./transcript.js";
+export function readFrames(dir) {
+    const value = parseJsonSafe(readText(path.join(dir, 'frames.json')) ?? '');
+    if (!Array.isArray(value))
+        return [];
+    return value.filter(isRecord).flatMap((item) => (typeof item['file'] === 'string' && typeof item['timeSeconds'] === 'number' ? [{ file: item['file'], timeSeconds: item['timeSeconds'] }] : []));
+}
+export function renderSummaryPrompt(meeting, transcript, frames, template = loadResource('summary-prompt.md')) {
+    const mode = meeting.mode === 'remote' ? 'remota (videollamada)' : 'presencial';
+    const speakers = meeting.mode === 'remote'
+        ? '- Hablantes: «Sala» es el micrófono local (quien graba y quien esté en su sala); «Remotos» es el audio de la llamada. No hay separación por persona; identifica a cada quien por contexto cuando se presenten o se nombren.'
+        : '- Hablantes: un solo micrófono en la sala, sin separación por persona; identifica a cada quien por contexto cuando se presenten o se nombren.';
+    let framesText = '';
+    if (frames.length > 0) {
+        const list = frames.map((frame) => `  - ${frame.file} [${clock(Math.trunc(frame.timeSeconds * 1000))}]`);
+        framesText = `- Capturas de pantalla (en el directorio actual; ábrelas con Read cuando el tema lo amerite, en especial diapositivas, documentos o demos):\n${list.join('\n')}`;
+    }
+    let text = template;
+    text = replaceAll(text, '{{title}}', meeting.title);
+    text = replaceAll(text, '{{date}}', meetingHeader(meeting).split(' · ')[0] ?? '');
+    text = replaceAll(text, '{{duration}}', formatDuration(durationSeconds(meeting)));
+    text = replaceAll(text, '{{mode}}', mode);
+    text = replaceAll(text, '{{speakers}}', speakers);
+    text = replaceAll(text, '{{frames}}', framesText);
+    text = replaceAll(text, '{{transcript}}', transcript);
+    return text;
+}
+export function summaryPromptFor(meeting, dir) {
+    const transcript = readText(path.join(dir, 'transcript.md'));
+    if (transcript === null)
+        throw new RecapError('NO_TRANSCRIPT', `"${meeting.title}" has no transcript yet; run \`recap process ${meeting.id}\``);
+    return renderSummaryPrompt(meeting, transcript, readFrames(dir));
+}
+export function saveSummary(body, meeting, dir) {
+    let content = trimmed(body);
+    const start = content.indexOf('## Resumen');
+    if (start !== -1)
+        content = content.slice(start);
+    if (content.length === 0)
+        throw new RecapError('EMPTY_SUMMARY', 'The summary is empty');
+    writeAtomic(path.join(dir, 'summary.md'), `# ${meeting.title}\n\n${meetingHeader(meeting)}\n\n${content}\n`);
+}
+export function extractSummary(output) {
+    const result = resultText(output);
+    const start = result.indexOf('## Resumen');
+    return start === -1 ? result : result.slice(start);
+}

package/dist/pipeline/transcript.js

@@ -0,0 +1,116 @@
+import { clock, esHeaderDate, parseDate } from "../core/dates.js";
+import { durationSeconds } from "../core/meeting.js";
+import { isRecord } from "../core/json.js";
+import { fold, formatDuration, jaccard, trimmed } from "../core/text.js";
+export function speakerLabel(channel) {
+    return channel === 'mic' ? 'Sala' : 'Remotos';
+}
+export function decodeSegment(value) {
+    if (!isRecord(value))
+        return null;
+    const { startMs, endMs, channel, text } = value;
+    if (typeof startMs !== 'number' || typeof endMs !== 'number' || typeof text !== 'string')
+        return null;
+    if (channel !== 'mic' && channel !== 'system')
+        return null;
+    return { startMs: Math.trunc(startMs), endMs: Math.trunc(endMs), channel, text };
+}
+export function orderedSegment(segment) {
+    return { startMs: segment.startMs, endMs: segment.endMs, channel: segment.channel, text: segment.text };
+}
+export const HALLUCINATIONS = [
+    'amara.org',
+    'subtitulos realizados por',
+    'subtitulos por la comunidad',
+    'gracias por ver el video',
+    'suscribete al canal',
+    'thanks for watching',
+    '[musica]',
+    '(musica)',
+    '[blank_audio]',
+];
+export function isHallucination(text) {
+    const normalized = fold(text);
+    if (normalized.length === 0)
+        return true;
+    return HALLUCINATIONS.some((pattern) => normalized.includes(pattern));
+}
+export function parseWhisper(text, channel) {
+    const value = JSON.parse(text);
+    if (!isRecord(value) || !Array.isArray(value['transcription']))
+        throw new Error('whisper output has no transcription');
+    const segments = [];
+    for (const item of value['transcription']) {
+        if (!isRecord(item) || !isRecord(item['offsets']) || typeof item['text'] !== 'string')
+            throw new Error('whisper output has an invalid segment');
+        const from = item['offsets']['from'];
+        const to = item['offsets']['to'];
+        if (typeof from !== 'number' || typeof to !== 'number')
+            throw new Error('whisper output has an invalid offset');
+        const content = trimmed(item['text']);
+        if (content.length === 0 || isHallucination(content))
+            continue;
+        segments.push({ startMs: from, endMs: to, channel, text: content });
+    }
+    return segments;
+}
+export const ECHO_WINDOW_MS = 2_500;
+export const ECHO_SIMILARITY = 0.5;
+export function isEcho(mic, system) {
+    const overlaps = mic.startMs <= system.endMs + ECHO_WINDOW_MS && system.startMs <= mic.endMs + ECHO_WINDOW_MS;
+    return overlaps && jaccard(mic.text, system.text) >= ECHO_SIMILARITY;
+}
+export function orderSegments(segments) {
+    return segments
+        .map((segment, index) => ({ segment, index }))
+        .sort((left, right) => {
+        const a = left.segment;
+        const b = right.segment;
+        if (a.startMs !== b.startMs)
+            return a.startMs - b.startMs;
+        if (a.channel !== b.channel)
+            return a.channel === 'system' ? -1 : 1;
+        return left.index - right.index;
+    })
+        .map((item) => item.segment);
+}
+export function mergeTranscripts(mic, system) {
+    const filtered = mic.filter((segment) => !system.some((other) => isEcho(segment, other)));
+    return orderSegments([...filtered, ...system]);
+}
+export const PARAGRAPH_GAP_MS = 4_000;
+export const PARAGRAPH_SPAN_MS = 30_000;
+export function paragraphs(segments) {
+    const result = [];
+    let lastEnd = Number.MIN_SAFE_INTEGER;
+    for (const segment of segments) {
+        const last = result[result.length - 1];
+        if (last && last.channel === segment.channel && segment.startMs - lastEnd <= PARAGRAPH_GAP_MS && segment.startMs - last.startMs < PARAGRAPH_SPAN_MS) {
+            last.text += ` ${segment.text}`;
+        }
+        else {
+            result.push({ startMs: segment.startMs, channel: segment.channel, text: segment.text });
+        }
+        lastEnd = Math.max(lastEnd, segment.endMs);
+    }
+    return result;
+}
+export function meetingHeader(meeting) {
+    const date = parseDate(meeting.startedAt) ?? parseDate(meeting.createdAt) ?? new Date();
+    const mode = meeting.mode === 'remote' ? 'remota' : 'presencial';
+    return `${esHeaderDate(date)} · ${formatDuration(durationSeconds(meeting))} · reunión ${mode}`;
+}
+export function transcriptMarkdown(meeting, segments) {
+    const lines = [`# Transcripción: ${meeting.title}`, '', meetingHeader(meeting), ''];
+    if (meeting.mode === 'remote') {
+        lines.push('> **Sala**: micrófono local (quien graba y quien esté en la misma sala). **Remotos**: audio de la llamada.', '');
+    }
+    const grouped = paragraphs(segments);
+    if (grouped.length === 0)
+        lines.push('_No se detectó voz en la grabación._');
+    for (const paragraph of grouped) {
+        const speaker = meeting.mode === 'remote' ? ` ${speakerLabel(paragraph.channel)}:` : '';
+        lines.push(`**[${clock(paragraph.startMs)}]${speaker}** ${paragraph.text}`, '');
+    }
+    return lines.join('\n');
+}

package/dist/setup/deps.js

@@ -0,0 +1,119 @@
+import { createWriteStream, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { home } from "../core/paths.js";
+import { exec } from "../core/proc.js";
+import { suffix, trimmed } from "../core/text.js";
+import { installHint, locateTool } from "../core/tools.js";
+import { RecapError } from "../errors.js";
+import { which } from '@kikedealba/kit/platform';
+export const BREW_CANDIDATES = ['/opt/homebrew/bin/brew', '/usr/local/bin/brew'];
+const BREW_FORMULAE = { ffmpeg: 'ffmpeg', 'whisper-cli': 'whisper-cpp' };
+const WINGET_IDS = { ffmpeg: 'Gyan.FFmpeg' };
+export async function installMissing(config, progress, platform = process.platform) {
+    const missing = [];
+    for (const tool of ['ffmpeg', 'whisper-cli'])
+        if (!(await locateTool(tool, config)))
+            missing.push(tool);
+    const report = { installed: [], manual: [] };
+    if (missing.length === 0)
+        return report;
+    if (platform === 'darwin') {
+        const brew = BREW_CANDIDATES.find((candidate) => existsSync(candidate)) ?? (await which('brew'));
+        const formulae = missing.map((tool) => BREW_FORMULAE[tool] ?? tool);
+        if (!brew)
+            throw new RecapError('BREW_MISSING', `Install Homebrew, or install ${formulae.join(' and ')} by hand`);
+        progress(`Installing ${formulae.join(', ')} with Homebrew...`);
+        const result = await exec(brew, ['install', ...formulae], { env: { ...process.env, HOMEBREW_NO_AUTO_UPDATE: '1' } });
+        if (result.status !== 0)
+            throw new RecapError('BREW_FAILED', `brew install ${formulae.join(' ')} failed: ${suffix(trimmed(result.stderr), 400)}`);
+        report.installed.push(...formulae);
+        return report;
+    }
+    if (platform === 'win32') {
+        const winget = await which('winget');
+        for (const tool of missing) {
+            const id = WINGET_IDS[tool];
+            if (!id || !winget) {
+                report.manual.push(`${tool}: ${installHint(tool, platform)}`);
+                continue;
+            }
+            progress(`Installing ${id} with winget...`);
+            const result = await exec(winget, ['install', '--id', id, '-e', '--accept-source-agreements', '--accept-package-agreements']);
+            if (result.status === 0)
+                report.installed.push(id);
+            else
+                report.manual.push(`${tool}: winget install ${id} failed (${suffix(trimmed(result.stdout + result.stderr), 200)})`);
+        }
+        return report;
+    }
+    for (const tool of missing)
+        report.manual.push(`${tool}: ${installHint(tool, platform)}`);
+    return report;
+}
+export async function download(url, target, progress) {
+    mkdirSync(path.dirname(target), { recursive: true });
+    const partial = `${target}.part`;
+    let offset = 0;
+    try {
+        offset = statSync(partial).size;
+    }
+    catch {
+        offset = 0;
+    }
+    const response = await fetch(url, { redirect: 'follow', headers: offset > 0 ? { Range: `bytes=${offset}-` } : {} });
+    if (response.status === 416) {
+        renameSync(partial, target);
+        return;
+    }
+    if (!response.ok || !response.body)
+        throw new RecapError('DOWNLOAD_FAILED', `Cannot download ${path.basename(url)}: HTTP ${response.status}`);
+    const append = offset > 0 && response.status === 206;
+    if (!append)
+        offset = 0;
+    progress(`Downloading ${path.basename(target)}${append ? ` (resuming at ${offset} bytes)` : ''}...`);
+    await pipeline(Readable.fromWeb(response.body), createWriteStream(partial, { flags: append ? 'a' : 'w' }));
+    rmSync(target, { force: true });
+    renameSync(partial, target);
+}
+export const RECAP_REPO = 'KikeDeAlba/recap';
+export const RECAP_ASSET_SUFFIX = '-macos-arm64.zip';
+export function recapAppTarget() {
+    return path.join(home(), 'Applications', 'Recap.app');
+}
+export async function installRecapApp(progress) {
+    if (process.platform !== 'darwin' || process.arch !== 'arm64')
+        throw new RecapError('CAPTURE_UNAVAILABLE', 'Recap.app only runs on Apple Silicon Macs');
+    const work = mkdtempSync(path.join(tmpdir(), 'recap-app-'));
+    try {
+        let zip = process.env['RECAP_APP_ZIP'] ?? null;
+        if (!zip) {
+            const response = await fetch(`https://api.github.com/repos/${RECAP_REPO}/releases/latest`, { headers: { Accept: 'application/vnd.github+json', 'User-Agent': 'recap-setup' } });
+            if (!response.ok)
+                throw new RecapError('DOWNLOAD_FAILED', `Cannot reach the recap releases: HTTP ${response.status}`);
+            const release = (await response.json());
+            const asset = (release.assets ?? []).find((item) => item.name.endsWith(RECAP_ASSET_SUFFIX));
+            if (!asset)
+                throw new RecapError('DOWNLOAD_FAILED', `The ${release.tag_name ?? 'latest'} release of recap has no ${RECAP_ASSET_SUFFIX} asset`);
+            zip = path.join(work, asset.name);
+            await download(asset.browser_download_url, zip, progress);
+        }
+        const unpacked = path.join(work, 'unpacked');
+        const extracted = await exec('/usr/bin/ditto', ['-x', '-k', zip, unpacked]);
+        const source = path.join(unpacked, 'Recap.app');
+        if (extracted.status !== 0 || !existsSync(source))
+            throw new RecapError('INSTALL_FAILED', `Could not unpack ${zip}: ${trimmed(extracted.stderr)}`);
+        const target = recapAppTarget();
+        mkdirSync(path.dirname(target), { recursive: true });
+        rmSync(target, { recursive: true, force: true });
+        const copied = await exec('/usr/bin/ditto', [source, target]);
+        if (copied.status !== 0)
+            throw new RecapError('INSTALL_FAILED', `Could not copy Recap.app: ${trimmed(copied.stderr)}`);
+        return target;
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+}

package/dist/setup/integration.js

@@ -0,0 +1,112 @@
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+import { agents } from '@kikedealba/kit';
+import { defineManifest, isInstalled, readManifest, registerTool } from '@kikedealba/kit/registry';
+import { bitaCommand } from "../bita/client.js";
+import { readText } from "../core/fsutil.js";
+import { isRecord } from "../core/json.js";
+import { home } from "../core/paths.js";
+import { stableCommand } from "../core/self.js";
+import { HOOK_EVENTS, MEETING_KINDS } from "../bita/hook.js";
+import { PACKAGE_ROOT, VERSION } from "../version.js";
+export const INSTALL_HINT = 'npm install -g @kikedealba/recap && recap setup';
+export const BASE_CAPABILITIES = ['meeting.process', 'meeting.import', 'meeting.minutes', 'meeting.ask', 'meeting.live', 'meeting.media'];
+export function capabilities(captureAvailable) {
+    return captureAvailable ? ['meeting.record', ...BASE_CAPABILITIES] : [...BASE_CAPABILITIES];
+}
+function subscription(bin) {
+    return {
+        tool: 'bita',
+        events: [...HOOK_EVENTS],
+        filter: { kind: Object.keys(MEETING_KINDS).sort() },
+        command: [...bin, 'bita-hook'],
+    };
+}
+export async function bitaSubscription(ctx) {
+    return subscription(await stableCommand(ctx));
+}
+export async function manifest(captureAvailable, subscribe = captureAvailable, ctx) {
+    const bin = await stableCommand(ctx);
+    return defineManifest({
+        name: 'recap',
+        version: VERSION,
+        description: 'Meeting recorder: local transcription, minutes, live answers',
+        bin,
+        capabilities: capabilities(captureAvailable),
+        subscribes: subscribe ? [subscription(bin)] : [],
+        homepage: 'https://github.com/KikeDeAlba/recap',
+        install: INSTALL_HINT,
+    });
+}
+export async function register(captureAvailable, subscribe = captureAvailable) {
+    return registerTool(await manifest(captureAvailable, subscribe));
+}
+export async function bitaLinked(config) {
+    const own = await readManifest('recap').catch(() => null);
+    if (!own || !isInstalled(own) || !own.subscribes.some((subscription) => subscription.tool === 'bita'))
+        return false;
+    return (await bitaCommand(config)) !== null;
+}
+export function commandSources() {
+    const dir = path.join(PACKAGE_ROOT, 'commands');
+    let names = [];
+    try {
+        names = readdirSync(dir).filter((name) => name.endsWith('.md')).sort();
+    }
+    catch {
+        return [];
+    }
+    return names.map((name) => ({ name: name.slice(0, -3), file: path.join(dir, name) }));
+}
+export function integration() {
+    return {
+        tool: 'recap',
+        version: VERSION,
+        description: 'Record meetings and turn them into minutes with recap',
+        skills: [{ name: 'recap', dir: path.join(PACKAGE_ROOT, 'skills', 'recap') }],
+        commands: commandSources(),
+        claude: {
+            permissions: {
+                allow: ['Bash(recap status:*)', 'Bash(recap list:*)', 'Bash(recap show:*)', 'Bash(recap wait:*)', 'Bash(recap prompt:*)', 'Bash(recap --version)'],
+            },
+        },
+    };
+}
+export function claudePluginInstalled() {
+    const claudeHome = process.env['CLAUDE_CONFIG_DIR'] ?? path.join(home(), '.claude');
+    const text = readText(path.join(claudeHome, 'plugins', 'installed_plugins.json'));
+    if (text === null)
+        return false;
+    try {
+        const value = JSON.parse(text);
+        const plugins = isRecord(value) && isRecord(value['plugins']) ? value['plugins'] : isRecord(value) ? value : {};
+        return Object.keys(plugins).some((key) => key.startsWith('recap@'));
+    }
+    catch {
+        return text.includes('"recap@');
+    }
+}
+export function parseAgents(raw) {
+    if (raw === undefined || raw === 'detected')
+        return 'detected';
+    if (raw === 'all' || raw === 'none')
+        return raw;
+    const wanted = raw.split(',').map((item) => item.trim()).filter((item) => item.length > 0);
+    const invalid = wanted.filter((item) => !agents.AGENTS.includes(item));
+    if (invalid.length > 0)
+        throw new Error(`Unknown agent ${invalid.join(', ')}; use ${agents.AGENTS.join(', ')}, detected, all or none`);
+    return wanted;
+}
+export async function installAgents(choice, exec) {
+    if (choice === 'none')
+        return [];
+    let list = choice === 'detected' ? await agents.detectAgents() : choice === 'all' ? [...agents.AGENTS] : choice;
+    const steps = [];
+    if (list.includes('claude') && claudePluginInstalled()) {
+        list = list.filter((agent) => agent !== 'claude');
+        steps.push({ agent: 'claude', item: 'integration', state: 'present', detail: 'the recap plugin for Claude Code is installed; it already carries the skill and commands' });
+    }
+    if (list.length === 0)
+        return steps;
+    return [...steps, ...(await agents.installIntegration(integration(), { agents: list, ...(exec ? { exec } : {}) }))];
+}

package/dist/setup/legacy.js

@@ -0,0 +1,28 @@
+import { isRecord, parseJsonSafe } from "../core/json.js";
+export function legacyHookIndexes(data) {
+    if (!Array.isArray(data))
+        return [];
+    const indexes = [];
+    data.forEach((hook, index) => {
+        if (!isRecord(hook) || !Array.isArray(hook['command']))
+            return;
+        const command = hook['command'].filter((part) => typeof part === 'string');
+        if (command[command.length - 1] === 'bita-hook' && command.some((part) => /recap/i.test(part)))
+            indexes.push(index + 1);
+    });
+    return indexes;
+}
+export async function removeLegacyHook(bita) {
+    const listed = await bita.run(['hooks', '--json']).catch(() => null);
+    if (!listed || listed.status !== 0)
+        return 0;
+    const envelope = parseJsonSafe(listed.stdout.trim().split('\n').pop() ?? '');
+    const indexes = legacyHookIndexes(isRecord(envelope) ? envelope['data'] : undefined);
+    let removed = 0;
+    for (const index of indexes.sort((a, b) => b - a)) {
+        const result = await bita.run(['hooks', 'rm', String(index), '--json']).catch(() => null);
+        if (result?.status === 0)
+            removed += 1;
+    }
+    return removed;
+}

package/dist/version.js

@@ -0,0 +1,6 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+export const VERSION = JSON.parse(readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8')).version;
+export const SCHEMA_VERSION = 1;

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@kikedealba/recap",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.9.1",
+  "description": "Meeting recorder CLI: local transcription with whisper.cpp, minutes written by Claude Code, live answers and bita integration.",
+  "license": "MIT",
+  "author": "Jesus Enrique De Alba Gaytan",
+  "homepage": "https://github.com/KikeDeAlba/recap#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KikeDeAlba/recap.git"
+  },
+  "bugs": {
+    "url": "https://github.com/KikeDeAlba/recap/issues"
+  },
+  "keywords": [
+    "meetings",
+    "recording",
+    "transcription",
+    "minutes",
+    "whisper",
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "opencode"
+  ],
+  "type": "module",
+  "packageManager": "pnpm@11.22.0",
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "recap": "dist/bin/recap.js"
+  },
+  "files": [
+    "dist",
+    "Resources/*.md",
+    "skills",
+    "commands",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "pnpm build",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test \"test/**/*.test.ts\"",
+    "recap": "node src/bin/recap.ts"
+  },
+  "dependencies": {
+    "@kikedealba/kit": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.7.2"
+  }
+}