@kikedealba/recap 0.0.0-stage → 0.9.0

package/dist/core/meeting.js

@@ -0,0 +1,201 @@
+import { mkdirSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { RecapError, errorMessage } from "../errors.js";
+import { rootDir } from "./config.js";
+import { idStamp, isoDate, isoNow, parseDate } from "./dates.js";
+import { exists, readText, writeAtomic } from "./fsutil.js";
+import { isRecord, swiftPretty } from "./json.js";
+import { isAlive } from "./proc.js";
+import { slug } from "./text.js";
+export const MEETING_MODES = ['remote', 'in-person'];
+export function recordingFileName(mode) {
+    return mode === 'remote' ? 'recording.mov' : 'recording.m4a';
+}
+export function emptyWrapup() {
+    return { titleChanged: false, projectResolved: false, pageCreated: false, backlogKeys: {} };
+}
+export const MEETING_FILE = 'meeting.json';
+export function durationSeconds(meeting, now = new Date()) {
+    const started = parseDate(meeting.startedAt);
+    if (!started)
+        return undefined;
+    const ended = parseDate(meeting.endedAt) ?? now;
+    return Math.trunc((ended.getTime() - started.getTime()) / 1000);
+}
+function validMeeting(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value['id'] === 'string' &&
+        typeof value['title'] === 'string' &&
+        (value['mode'] === 'remote' || value['mode'] === 'in-person') &&
+        typeof value['status'] === 'string' &&
+        ['starting', 'recording', 'recorded', 'failed', 'processing', 'processed'].includes(value['status']) &&
+        typeof value['createdAt'] === 'string' &&
+        parseDate(value['createdAt']) !== null);
+}
+export function decodeMeeting(text) {
+    const value = JSON.parse(text);
+    if (!validMeeting(value))
+        throw new Error('the meeting file is missing required fields');
+    const meeting = value;
+    meeting.schemaVersion = typeof meeting.schemaVersion === 'number' ? meeting.schemaVersion : 1;
+    meeting.stages = isRecord(meeting.stages) ? meeting.stages : {};
+    for (const [key, item] of Object.entries(meeting))
+        if (item === null)
+            delete meeting[key];
+    if (meeting.wrapup)
+        meeting.wrapup = { ...emptyWrapup(), ...meeting.wrapup };
+    if (meeting.bitaEntry)
+        meeting.bitaEntry = { ...meeting.bitaEntry, pageIds: Array.isArray(meeting.bitaEntry.pageIds) ? meeting.bitaEntry.pageIds : [] };
+    return meeting;
+}
+export function loadMeeting(dir) {
+    const file = path.join(dir, MEETING_FILE);
+    const text = readText(file);
+    try {
+        if (text === null)
+            throw new Error('no such file');
+        return decodeMeeting(text);
+    }
+    catch (error) {
+        throw new RecapError('MEETING_UNREADABLE', `Cannot read ${file}: ${errorMessage(error)}`);
+    }
+}
+export function encodeMeeting(meeting) {
+    return swiftPretty({ ...meeting, schemaVersion: meeting.schemaVersion ?? 1, stages: meeting.stages ?? {} });
+}
+export function saveMeeting(meeting, dir) {
+    writeAtomic(path.join(dir, MEETING_FILE), encodeMeeting(meeting));
+}
+export function updateMeeting(dir, change) {
+    const meeting = loadMeeting(dir);
+    change(meeting);
+    saveMeeting(meeting, dir);
+    return meeting;
+}
+export function recordingPath(dir, mode) {
+    const primary = path.join(dir, recordingFileName(mode));
+    if (mode !== 'remote' || exists(primary))
+        return primary;
+    const audio = path.join(dir, 'recording.m4a');
+    return exists(audio) ? audio : primary;
+}
+export function isActiveStatus(status) {
+    return status === 'recording' || status === 'starting';
+}
+export function reconcile(meeting, dir) {
+    if (!isActiveStatus(meeting.status))
+        return meeting;
+    if (meeting.recorderPid !== undefined && isAlive(meeting.recorderPid))
+        return meeting;
+    const created = parseDate(meeting.createdAt);
+    if (meeting.recorderPid === undefined && meeting.status === 'starting' && created && Date.now() - created.getTime() < 300_000)
+        return meeting;
+    let size = 0;
+    let modified = null;
+    try {
+        const info = statSync(recordingPath(dir, meeting.mode));
+        size = info.size;
+        modified = info.mtime;
+    }
+    catch {
+        size = 0;
+    }
+    try {
+        return updateMeeting(dir, (current) => {
+            current.status = size > 0 && current.startedAt !== undefined ? 'recorded' : 'failed';
+            current.endedAt = modified ? isoDate(modified) : isoNow();
+            delete current.recorderPid;
+            current.error = 'The recorder exited without closing the file cleanly';
+        });
+    }
+    catch {
+        return meeting;
+    }
+}
+export class MeetingStore {
+    root;
+    constructor(config) {
+        this.root = rootDir(config);
+    }
+    create(options) {
+        mkdirSync(this.root, { recursive: true });
+        const now = options.now ?? new Date();
+        const base = `${idStamp(now)}-${slug(options.title)}`;
+        let id = base;
+        let suffix = 2;
+        while (exists(path.join(this.root, id))) {
+            id = `${base}-${suffix}`;
+            suffix += 1;
+        }
+        const dir = path.join(this.root, id);
+        mkdirSync(dir, { recursive: true });
+        const meeting = {
+            schemaVersion: 1,
+            id,
+            title: options.title,
+            mode: options.mode,
+            status: 'starting',
+            createdAt: isoDate(now),
+            display: options.display,
+            bitaEntryId: options.bitaEntryId,
+            bitaDatabasePath: options.bita?.databasePath,
+            bitaDocsRoot: options.bita?.docsRoot,
+            stages: {},
+        };
+        saveMeeting(meeting, dir);
+        return { meeting, dir };
+    }
+    all() {
+        let names;
+        try {
+            names = readdirSync(this.root);
+        }
+        catch {
+            return [];
+        }
+        const found = [];
+        for (const name of names) {
+            const dir = path.join(this.root, name);
+            try {
+                found.push({ meeting: reconcile(loadMeeting(dir), dir), dir });
+            }
+            catch {
+                continue;
+            }
+        }
+        return found.sort((left, right) => (parseDate(right.meeting.createdAt)?.getTime() ?? 0) - (parseDate(left.meeting.createdAt)?.getTime() ?? 0));
+    }
+    resolve(reference) {
+        const meetings = this.all();
+        if (!reference || reference === 'last') {
+            const latest = meetings[0];
+            if (!latest)
+                throw new RecapError('NO_MEETINGS', `No meetings in ${this.root}`);
+            return latest;
+        }
+        const exact = meetings.find((item) => item.meeting.id === reference);
+        if (exact)
+            return exact;
+        const matches = meetings.filter((item) => item.meeting.id.includes(reference));
+        if (matches.length === 1 && matches[0])
+            return matches[0];
+        if (matches.length === 0)
+            throw new RecapError('MEETING_NOT_FOUND', `No meeting matches "${reference}"`);
+        throw new RecapError('MEETING_AMBIGUOUS', `"${reference}" matches ${matches.length} meetings`);
+    }
+    find(bitaEntryId) {
+        return this.all().find((item) => item.meeting.bitaEntryId === bitaEntryId) ?? null;
+    }
+}
+export function resolveTarget(store, reference, bitaEntryId) {
+    if (bitaEntryId !== undefined) {
+        const found = store.find(bitaEntryId);
+        if (!found)
+            throw new RecapError('MEETING_NOT_FOUND', `No meeting is linked to bita entry ${bitaEntryId}`);
+        return found;
+    }
+    if (reference === undefined)
+        throw new RecapError('MEETING_REQUIRED', 'Pass the meeting id, a unique part of it, "last" or --bita-entry');
+    return store.resolve(reference);
+}

package/dist/core/paths.js

@@ -0,0 +1,55 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { dataHome, platformContext, stateHome } from '@kikedealba/kit/platform';
+function env(key) {
+    const value = process.env[key];
+    return value && value.length > 0 ? value : undefined;
+}
+export function home() {
+    return env('HOME') ?? homedir();
+}
+export function isWindows() {
+    return process.platform === 'win32';
+}
+export function expandTilde(value) {
+    if (value === '~')
+        return home();
+    if (value.startsWith('~/') || value.startsWith('~\\'))
+        return path.join(home(), value.slice(2));
+    return path.resolve(value);
+}
+function context() {
+    return platformContext({ home: home() });
+}
+export function configFile() {
+    const override = env('RECAP_CONFIG_PATH');
+    if (override)
+        return path.resolve(override);
+    if (isWindows())
+        return path.join(env('APPDATA') ?? path.join(home(), 'AppData', 'Roaming'), 'recap', 'config.json');
+    return path.join(home(), '.config', 'recap', 'config.json');
+}
+export function configDir() {
+    return path.dirname(configFile());
+}
+export function stateDir() {
+    const override = env('RECAP_STATE_DIR');
+    if (override)
+        return path.resolve(override);
+    return path.join(stateHome(context()), 'recap');
+}
+export function dataDir() {
+    const override = env('RECAP_DATA_DIR');
+    if (override)
+        return path.resolve(override);
+    return path.join(dataHome(context()), 'recap');
+}
+export function activeFile() {
+    return path.join(stateDir(), 'active.json');
+}
+export function modelsDir() {
+    return path.join(dataDir(), 'models');
+}
+export function eventsLog() {
+    return path.join(stateDir(), 'events.log');
+}

package/dist/core/proc.js

@@ -0,0 +1,129 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { closeSync, mkdirSync, openSync } from 'node:fs';
+import path from 'node:path';
+import { RecapError } from "../errors.js";
+export function isAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function waitUntil(timeoutSeconds, intervalSeconds, condition) {
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    while (Date.now() < deadline) {
+        if (await condition())
+            return true;
+        await sleep(intervalSeconds * 1000);
+    }
+    return condition();
+}
+function needsShell(command) {
+    return process.platform === 'win32' && /\.(cmd|bat)$/i.test(command);
+}
+function quoteForCmd(arg) {
+    if (arg.length > 0 && !/[\s"&|<>^%()!,;=]/.test(arg))
+        return arg;
+    return `"${arg.replace(/"/g, '""')}"`;
+}
+export function commandLine(command, args) {
+    if (!needsShell(command))
+        return { command, args: [...args], shell: false };
+    return { command: quoteForCmd(command), args: args.map(quoteForCmd), shell: true };
+}
+export function exec(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const line = commandLine(command, args);
+        const child = spawn(line.command, line.args, {
+            env: options.env ?? process.env,
+            cwd: options.cwd,
+            windowsHide: true,
+            shell: line.shell,
+            detached: options.detached ?? false,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.once('spawn', () => {
+            if (child.pid !== undefined)
+                options.onSpawn?.(child.pid);
+        });
+        child.stdout.setEncoding('utf8').on('data', (chunk) => {
+            stdout += chunk;
+            options.onStdout?.(chunk);
+        });
+        child.stderr.setEncoding('utf8').on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.once('error', (error) => {
+            reject(new RecapError('SPAWN_FAILED', `Cannot start ${path.basename(command)}: ${error.message}`));
+        });
+        child.once('close', (code, signal) => {
+            resolve({ status: code ?? (signal ? 128 + signalNumber(signal) : 1), signal, stdout, stderr });
+        });
+        child.stdin.on('error', () => undefined);
+        child.stdin.end(options.input ?? '');
+    });
+}
+export function signalNumber(signal) {
+    const table = { SIGHUP: 1, SIGINT: 2, SIGKILL: 9, SIGTERM: 15 };
+    return table[signal] ?? 1;
+}
+export function spawnDetached(command, args, logPath, env = process.env) {
+    mkdirSync(path.dirname(logPath), { recursive: true });
+    const log = openSync(logPath, 'a');
+    try {
+        const line = commandLine(command, args);
+        const child = spawn(line.command, line.args, {
+            detached: true,
+            stdio: ['ignore', log, log],
+            env,
+            windowsHide: true,
+            shell: line.shell,
+        });
+        if (child.pid === undefined)
+            throw new RecapError('SPAWN_FAILED', `Cannot start ${path.basename(command)}`);
+        child.unref();
+        return child.pid;
+    }
+    finally {
+        closeSync(log);
+    }
+}
+export function signalProcess(pid, signal) {
+    try {
+        process.kill(pid, signal);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function signalTree(pid, signal) {
+    if (pid <= 1 || pid === process.pid)
+        return;
+    if (process.platform === 'win32') {
+        spawnSync('taskkill', ['/T', '/F', '/PID', String(pid)], { windowsHide: true, stdio: 'ignore' });
+        return;
+    }
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        signalProcess(pid, signal);
+    }
+}
+export async function terminateTree(pid) {
+    signalTree(pid, 'SIGTERM');
+    if (await waitUntil(3, 0.05, () => !isAlive(pid)))
+        return;
+    signalTree(pid, 'SIGKILL');
+    await waitUntil(1, 0.05, () => !isAlive(pid));
+}

package/dist/core/record.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import { exists } from "./fsutil.js";
+import { durationSeconds, recordingPath } from "./meeting.js";
+import { hasVideo, measureStorage } from "../media/media.js";
+import { liveFiles, readLines } from "../live/files.js";
+import { decodeAnswer, encodeAnswer } from "../live/stream.js";
+import { loadProposals, proposalJson } from "../bita/proposals.js";
+function existing(dir, name) {
+    const file = path.join(dir, name);
+    return exists(file) ? file : undefined;
+}
+export function meetingRecord(meeting, dir, detailed = false) {
+    const recording = recordingPath(dir, meeting.mode);
+    const live = liveFiles.transcript(dir);
+    const record = {
+        id: meeting.id,
+        title: meeting.title,
+        mode: meeting.mode,
+        status: meeting.status,
+        createdAt: meeting.createdAt,
+        startedAt: meeting.startedAt,
+        endedAt: meeting.endedAt,
+        durationSeconds: durationSeconds(meeting),
+        bitaEntryId: meeting.bitaEntryId,
+        bitaEntry: meeting.bitaEntry,
+        wrapup: meeting.wrapup,
+        error: meeting.error,
+        stages: meeting.stages,
+        dir,
+        recording: existing(dir, path.basename(recording)),
+        hasVideo: hasVideo(dir, meeting.mode),
+        storage: measureStorage(dir, meeting.mode),
+        video: meeting.video,
+        videoRemovedAt: meeting.videoRemovedAt,
+        transcript: existing(dir, 'transcript.md'),
+        summary: existing(dir, 'summary.md'),
+        transcriptSegments: existing(dir, 'transcript.json'),
+        frames: existing(dir, 'frames.json'),
+        liveTranscript: exists(live) ? live : null,
+    };
+    if (detailed) {
+        record['answers'] = readLines(liveFiles.answers(dir), decodeAnswer).map(encodeAnswer);
+        record['proposals'] = (loadProposals(dir)?.proposals ?? []).map(proposalJson);
+    }
+    return record;
+}

package/dist/core/self.js

@@ -0,0 +1,18 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { PACKAGE_ROOT } from "../version.js";
+import { spawnDetached } from "./proc.js";
+export function binEntry() {
+    const built = path.join(PACKAGE_ROOT, 'dist', 'bin', 'recap.js');
+    return existsSync(built) ? built : path.join(PACKAGE_ROOT, 'src', 'bin', 'recap.ts');
+}
+export function selfCommand() {
+    return [process.execPath, binEntry()];
+}
+export function spawnSelf(args, logPath) {
+    const [node, entry] = selfCommand();
+    return spawnDetached(node ?? process.execPath, [entry ?? binEntry(), ...args], logPath);
+}
+export function processInBackground(meetingId, dir, extra = []) {
+    return spawnSelf(['process', meetingId, ...extra], path.join(dir, 'process.log'));
+}

package/dist/core/text.js

@@ -0,0 +1,89 @@
+export function trimmed(text) {
+    return text.replace(/^[\s\u0085]+|[\s\u0085]+$/gu, '');
+}
+export function fold(text) {
+    return trimmed(text.normalize('NFD').replace(/\p{Mn}/gu, '').toLowerCase().normalize('NFC'));
+}
+export function tokens(text) {
+    return new Set(fold(text)
+        .split(/[^\p{L}\p{M}\p{N}]+/u)
+        .filter((token) => [...token].length > 1));
+}
+export function jaccard(a, b) {
+    return jaccardSets(tokens(a), tokens(b));
+}
+export function jaccardSets(left, right) {
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let shared = 0;
+    for (const token of left)
+        if (right.has(token))
+            shared += 1;
+    return shared / (left.size + right.size - shared);
+}
+export function setsEqual(left, right) {
+    if (left.size !== right.size)
+        return false;
+    for (const token of left)
+        if (!right.has(token))
+            return false;
+    return true;
+}
+export function suffix(text, length) {
+    const chars = [...text];
+    return chars.length <= length ? text : chars.slice(chars.length - length).join('');
+}
+export function prefix(text, length) {
+    const chars = [...text];
+    return chars.length <= length ? text : chars.slice(0, length).join('');
+}
+export function replaceAll(text, search, replacement) {
+    return text.split(search).join(replacement);
+}
+export function padEnd(text, length) {
+    const chars = [...text];
+    return chars.length >= length ? chars.slice(0, length).join('') : text + ' '.repeat(length - chars.length);
+}
+export function slug(text) {
+    const folded = text.normalize('NFD').replace(/\p{Mn}/gu, '').toLowerCase();
+    let out = '';
+    let pendingDash = false;
+    for (const char of folded) {
+        if (/^[a-z0-9]$/.test(char)) {
+            if (pendingDash && out.length > 0)
+                out += '-';
+            out += char;
+            pendingDash = false;
+        }
+        else {
+            pendingDash = true;
+        }
+    }
+    const cut = out.slice(0, 48).replace(/^-+|-+$/g, '');
+    return cut.length === 0 ? 'meeting' : cut;
+}
+export function formatDuration(seconds) {
+    if (seconds === undefined || seconds === null)
+        return '-';
+    const h = Math.trunc(seconds / 3600);
+    const m = Math.trunc((seconds % 3600) / 60);
+    const s = seconds % 60;
+    const two = (value) => String(value).padStart(2, '0');
+    return h > 0 ? `${h}h${two(m)}m` : `${m}m${two(s)}s`;
+}
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return 'Zero KB';
+    if (Math.abs(bytes) < 1000)
+        return `${bytes} bytes`;
+    const units = ['KB', 'MB', 'GB', 'TB', 'PB'];
+    let value = bytes / 1000;
+    let unit = 0;
+    while (Math.abs(value) >= 1000 && unit < units.length - 1) {
+        value /= 1000;
+        unit += 1;
+    }
+    const decimals = unit === 0 ? 0 : unit === 1 ? 1 : 2;
+    const text = value.toFixed(decimals).replace(/\.0+$/, '').replace(/(\.\d*?)0+$/, '$1');
+    return `${text} ${units[unit]}`;
+}

package/dist/core/tools.js

@@ -0,0 +1,91 @@
+import { constants, accessSync, statSync } from 'node:fs';
+import { userInfo } from 'node:os';
+import path from 'node:path';
+import { childEnvironment, platformContext, which } from '@kikedealba/kit/platform';
+import { RecapError } from "../errors.js";
+import { configFile, expandTilde, home } from "./paths.js";
+export const CHECKED_TOOLS = ['ffmpeg', 'whisper-cli', 'claude', 'bita'];
+export function installHint(tool, platform = process.platform) {
+    switch (tool) {
+        case 'ffmpeg':
+        case 'ffprobe':
+            return platform === 'darwin' ? 'brew install ffmpeg' : platform === 'win32' ? 'winget install Gyan.FFmpeg' : 'sudo apt install ffmpeg';
+        case 'whisper-cli':
+            return platform === 'darwin'
+                ? 'brew install whisper-cpp'
+                : platform === 'win32'
+                    ? 'download whisper-bin-x64.zip from https://github.com/ggml-org/whisper.cpp/releases and put whisper-cli.exe on PATH'
+                    : 'brew install whisper-cpp (Homebrew on Linux) or build whisper.cpp from https://github.com/ggml-org/whisper.cpp';
+        case 'claude':
+            return 'npm install -g @anthropic-ai/claude-code';
+        case 'bita':
+            return 'npm install -g @kikedealba/bita';
+    }
+}
+function isExecutable(file) {
+    try {
+        if (!statSync(file).isFile())
+            return false;
+        if (process.platform === 'win32')
+            return true;
+        accessSync(file, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function configuredPath(tool, config) {
+    return config.tools?.[tool];
+}
+function toolDirs(config) {
+    return Object.values(config.tools ?? {}).map((value) => path.dirname(expandTilde(value)));
+}
+function ctx() {
+    return platformContext({ home: home() });
+}
+export async function locateTool(tool, config) {
+    const configured = configuredPath(tool, config);
+    if (configured) {
+        const file = expandTilde(configured);
+        if (isExecutable(file))
+            return file;
+    }
+    if (tool === 'ffprobe') {
+        const ffmpeg = config.tools?.['ffmpeg'];
+        if (ffmpeg) {
+            const sibling = path.join(path.dirname(expandTilde(ffmpeg)), process.platform === 'win32' ? 'ffprobe.exe' : 'ffprobe');
+            if (isExecutable(sibling))
+                return sibling;
+        }
+    }
+    return which(tool, ctx(), toolDirs(config));
+}
+export async function requireTool(tool, config) {
+    const found = await locateTool(tool, config);
+    if (!found) {
+        throw new RecapError('DEPENDENCY_MISSING', `${tool} not found. Install it with \`${installHint(tool)}\` or set tools.${tool} in ${configFile()}`, {
+            hint: installHint(tool),
+        });
+    }
+    return found;
+}
+function currentUser() {
+    try {
+        return userInfo().username;
+    }
+    catch {
+        return '';
+    }
+}
+export function toolEnvironment(executable, config, base = process.env) {
+    const context = platformContext({ env: base, home: home() });
+    const environment = childEnvironment(context, [path.dirname(executable), ...toolDirs(config)]);
+    if (!environment['HOME'] && process.platform !== 'win32')
+        environment['HOME'] = home();
+    if (!environment['USER'])
+        environment['USER'] = currentUser();
+    if (!environment['LOGNAME'])
+        environment['LOGNAME'] = environment['USER'];
+    return environment;
+}

package/dist/errors.js

@@ -0,0 +1,36 @@
+export const EXIT = {
+    ok: 0,
+    failure: 1,
+    usage: 2,
+};
+export class RecapError extends Error {
+    code;
+    hint;
+    exitCode;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = 'RecapError';
+        this.code = code;
+        this.hint = options.hint;
+        this.exitCode = options.exitCode ?? EXIT.failure;
+    }
+    get description() {
+        return `${this.code}: ${this.message}`;
+    }
+}
+export function usageError(message, hint) {
+    return new RecapError('USAGE', message, { exitCode: EXIT.usage, ...(hint ? { hint } : {}) });
+}
+export function describeError(error) {
+    if (error instanceof RecapError)
+        return error.description;
+    return error instanceof Error ? error.message : String(error);
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function asRecapError(error) {
+    if (error instanceof RecapError)
+        return error;
+    return new RecapError('UNEXPECTED', errorMessage(error));
+}