@kikedealba/recap 0.0.0-stage → 0.9.1

package/dist/live/ask.js

@@ -0,0 +1,77 @@
+import { randomUUID } from 'node:crypto';
+import { settingsOf } from "../core/config.js";
+import { isoNow, minuteStamp, parseDate } from "../core/dates.js";
+import { replaceAll, trimmed } from "../core/text.js";
+import { RecapError } from "../errors.js";
+import { streamArguments, streamClaude } from "../pipeline/claude.js";
+import { loadResource } from "../pipeline/resources.js";
+import { existingRepos } from "./context.js";
+import { appendLines, liveFiles } from "./files.js";
+import { loadLiveTranscript, renderLive, transcriptWindow } from "./merger.js";
+import { AskStreamReducer, ProgressDescriber, encodeAnswer } from "./stream.js";
+export const READ_TOOLS = ['Read', 'Grep', 'Glob'];
+export const GIT_SUBCOMMANDS = ['log', 'show', 'diff'];
+export const AVAILABLE_TOOLS = ['Read', 'Grep', 'Glob', 'Bash'];
+export function allowedTools(context) {
+    return [...READ_TOOLS, ...existingRepos(context).flatMap((repo) => GIT_SUBCOMMANDS.map((sub) => `Bash(git -C ${repo.path} ${sub}:*)`))];
+}
+export function askAddDirs(context) {
+    return [...(context.docsRoot ? [context.docsRoot] : []), ...existingRepos(context).map((repo) => repo.path)];
+}
+export function renderAskPrompt(template, request, context, segments) {
+    const window = transcriptWindow(segments, request.windowSeconds);
+    const labelled = request.meeting.mode === 'remote';
+    const title = request.meeting.bitaEntry?.title ?? request.meeting.title;
+    const question = request.question ? trimmed(request.question) : '';
+    const questionBlock = question.length > 0
+        ? `La pregunta que hay que responder es:\n\n> ${question}\n\nUsa la transcripción solo como contexto.`
+        : 'No te dieron la pregunta: identifícala en la transcripción de abajo. Es la última pregunta dirigida a quien graba (la persona del micrófono «Sala» en reuniones remotas) o la última que quedó sin responder. Si hay varias, responde la más reciente.';
+    const pages = context.pages.length === 0
+        ? '  (sin páginas registradas para este proyecto)'
+        : context.pages.map((page) => `  ${'  '.repeat(Math.max(0, page.depth))}- #${page.pageId} ${page.title} — ${page.relPath}`).join('\n');
+    const repos = existingRepos(context);
+    const reposText = repos.length === 0 ? '  (sin repositorios registrados)' : repos.map((repo) => `  - ${repo.slug}: ${repo.path} (git: \`git -C ${repo.path} log|show|diff …\`)`).join('\n');
+    const speakers = labelled
+        ? '«Sala» es el micrófono local (quien graba y quien esté en su sala); «Remotos» es el audio de la llamada.'
+        : 'Un solo micrófono en la sala, sin separación por persona.';
+    let text = template;
+    text = replaceAll(text, '{{title}}', title);
+    text = replaceAll(text, '{{project}}', context.project ?? 'sin proyecto');
+    text = replaceAll(text, '{{now}}', minuteStamp(parseDate(request.now) ?? new Date()));
+    text = replaceAll(text, '{{questionBlock}}', questionBlock);
+    text = replaceAll(text, '{{docsRoot}}', context.docsRoot ?? '(desconocida)');
+    text = replaceAll(text, '{{pages}}', pages);
+    text = replaceAll(text, '{{repos}}', reposText);
+    text = replaceAll(text, '{{speakers}}', speakers);
+    text = replaceAll(text, '{{transcript}}', renderLive(window, labelled));
+    return text;
+}
+export async function runAsk(config, request, context, emit, onSpawn) {
+    const segments = loadLiveTranscript(request.dir);
+    const explicit = request.question && trimmed(request.question).length > 0 ? trimmed(request.question) : null;
+    if (explicit === null && segments.length === 0)
+        throw new RecapError('NO_QUESTION', 'The live transcript is empty; pass --question');
+    const prompt = renderAskPrompt(loadResource('ask-prompt.md'), request, context, segments);
+    if (explicit !== null)
+        emit({ type: 'question', text: explicit });
+    const describer = new ProgressDescriber(context.docsRoot, existingRepos(context));
+    const args = streamArguments([allowedTools(context).join(' ')], askAddDirs(context), settingsOf(config).assistModel, AVAILABLE_TOOLS);
+    const reducer = new AskStreamReducer(explicit);
+    const result = await streamClaude(prompt, request.dir, config, args, (line) => {
+        for (const event of reducer.consume(line, describer))
+            emit(event);
+    }, onSpawn);
+    const { events, answer } = reducer.finish(result.status, result.stderr, randomUUID().toLowerCase(), request.now, transcriptWindow(segments, request.windowSeconds));
+    answer.auto = request.auto ? true : undefined;
+    if (request.questionMs !== undefined || request.channel !== undefined) {
+        answer.questionMs = request.questionMs;
+        answer.channel = request.channel;
+    }
+    answer.askId = request.askId;
+    for (const event of events)
+        emit(event);
+    answer.answeredAt = isoNow();
+    appendLines([encodeAnswer(answer)], liveFiles.answers(request.dir));
+    emit({ type: 'done', answer });
+    return answer;
+}

package/dist/live/asking.js

@@ -0,0 +1,185 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, readdirSync, rmSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { isoNow, parseDate } from "../core/dates.js";
+import { readText, writeAtomic } from "../core/fsutil.js";
+import { isRecord, swiftLine } from "../core/json.js";
+import { withDirectoryLock } from "../core/lock.js";
+import { isAlive } from "../core/proc.js";
+import { RecapError } from "../errors.js";
+import { liveFiles } from "./files.js";
+export function decodeAskingState(value) {
+    if (!isRecord(value) || typeof value['startedAt'] !== 'string' || parseDate(value['startedAt']) === null)
+        return null;
+    if (value['id'] !== undefined && value['id'] !== null && typeof value['id'] !== 'string')
+        return null;
+    if (value['question'] !== undefined && value['question'] !== null && typeof value['question'] !== 'string')
+        return null;
+    return {
+        id: typeof value['id'] === 'string' ? value['id'] : undefined,
+        question: typeof value['question'] === 'string' ? value['question'] : null,
+        startedAt: value['startedAt'],
+        auto: value['auto'] === true,
+        questionMs: typeof value['questionMs'] === 'number' && Number.isInteger(value['questionMs']) ? value['questionMs'] : undefined,
+        channel: value['channel'] === 'mic' || value['channel'] === 'system' ? value['channel'] : undefined,
+        state: value['state'] === 'queued' || value['state'] === 'running' ? value['state'] : undefined,
+        pid: typeof value['pid'] === 'number' && Number.isInteger(value['pid']) ? value['pid'] : undefined,
+    };
+}
+export function encodeAskingState(state) {
+    return swiftLine({
+        id: state.id,
+        question: state.question,
+        startedAt: state.startedAt,
+        auto: state.auto,
+        questionMs: state.questionMs,
+        channel: state.channel,
+        state: state.state,
+        pid: state.pid,
+    });
+}
+export function isRunningAsk(state) {
+    return state.state !== 'queued';
+}
+export function readLegacyAsking(meetingDir) {
+    const text = readText(liveFiles.asking(meetingDir));
+    if (text === null)
+        return null;
+    try {
+        return decodeAskingState(JSON.parse(text));
+    }
+    catch {
+        return null;
+    }
+}
+export function makeAskId() {
+    return randomUUID().toLowerCase();
+}
+export function isValidAskId(id) {
+    return id.length > 0 && id.length <= 64 && !id.startsWith('-') && /^[a-z0-9-]+$/.test(id);
+}
+function boardFile(meetingDir, id) {
+    return path.join(liveFiles.askingDir(meetingDir), `${id}.json`);
+}
+function lockDir(meetingDir) {
+    return path.join(liveFiles.askingDir(meetingDir), '.board.lock');
+}
+function stored(meetingDir) {
+    const folder = liveFiles.askingDir(meetingDir);
+    let names = [];
+    try {
+        names = readdirSync(folder).filter((name) => name.endsWith('.json') && !name.startsWith('.'));
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const name of names) {
+        const file = path.join(folder, name);
+        const text = readText(file);
+        if (text === null)
+            continue;
+        let state = null;
+        try {
+            state = decodeAskingState(JSON.parse(text));
+        }
+        catch {
+            state = null;
+        }
+        if (!state)
+            continue;
+        let modified = 0;
+        try {
+            modified = statSync(file).mtimeMs;
+        }
+        catch {
+            modified = 0;
+        }
+        found.push({ file, state, alive: state.pid === undefined ? true : isAlive(state.pid), modified });
+    }
+    return found
+        .sort((left, right) => (left.modified === right.modified ? (left.file < right.file ? -1 : left.file > right.file ? 1 : 0) : left.modified - right.modified))
+        .map(({ file, state, alive }) => ({ file, state, alive }));
+}
+export function boardEntries(meetingDir) {
+    return stored(meetingDir)
+        .filter((item) => item.alive)
+        .map((item) => item.state);
+}
+export function latestRunning(entries) {
+    let winner = null;
+    for (const state of entries) {
+        if (!isRunningAsk(state))
+            continue;
+        const time = parseDate(state.startedAt)?.getTime() ?? 0;
+        if (!winner || time >= winner.time)
+            winner = { state, time };
+    }
+    return winner?.state ?? null;
+}
+function refreshLegacy(meetingDir) {
+    const legacy = liveFiles.asking(meetingDir);
+    const latest = latestRunning(boardEntries(meetingDir));
+    if (!latest) {
+        rmSync(legacy, { force: true });
+        return;
+    }
+    writeAtomic(legacy, encodeAskingState(latest));
+}
+export function writeBoard(meetingDir, state) {
+    if (!state.id || !isValidAskId(state.id))
+        throw new RecapError('ASK_ID_INVALID', `Invalid ask id ${state.id ?? '(none)'}`);
+    const id = state.id;
+    withDirectoryLock(lockDir(meetingDir), () => {
+        writeAtomic(boardFile(meetingDir, id), encodeAskingState(state));
+        refreshLegacy(meetingDir);
+    });
+}
+export function removeBoard(meetingDir, id) {
+    if (!isValidAskId(id))
+        return;
+    try {
+        withDirectoryLock(lockDir(meetingDir), () => {
+            rmSync(boardFile(meetingDir, id), { force: true });
+            refreshLegacy(meetingDir);
+        });
+    }
+    catch {
+        return;
+    }
+}
+export function pruneBoard(meetingDir) {
+    if (!existsSync(liveFiles.askingDir(meetingDir)))
+        return;
+    try {
+        withDirectoryLock(lockDir(meetingDir), () => {
+            for (const item of stored(meetingDir))
+                if (!item.alive)
+                    rmSync(item.file, { force: true });
+            refreshLegacy(meetingDir);
+        });
+    }
+    catch {
+        return;
+    }
+}
+export async function performAsk(options, body) {
+    const id = options.id ?? makeAskId();
+    const question = options.question && options.question.trim().length > 0 ? options.question.trim() : null;
+    writeBoard(options.dir, {
+        id,
+        question,
+        startedAt: options.now ?? isoNow(),
+        auto: options.auto,
+        questionMs: options.questionMs,
+        channel: options.channel,
+        state: 'running',
+        pid: options.pid ?? process.pid,
+    });
+    try {
+        return await body();
+    }
+    finally {
+        removeBoard(options.dir, id);
+    }
+}

package/dist/live/context.js

@@ -0,0 +1,90 @@
+import path from 'node:path';
+import { isDirectory } from "../core/fsutil.js";
+import { isRecord } from "../core/json.js";
+import { trimmed } from "../core/text.js";
+export function emptyContext(overrides = {}) {
+    return { project: null, docsRoot: null, pages: [], repos: [], ...overrides };
+}
+export function existingRepos(context) {
+    return context.repos.filter((repo) => repo.exists);
+}
+export function parsePages(data) {
+    const list = isRecord(data) && Array.isArray(data['pages']) ? data['pages'] : [];
+    const result = [];
+    const walk = (items, depth) => {
+        for (const item of items) {
+            if (!isRecord(item))
+                continue;
+            const id = item['pageId'];
+            const title = item['title'];
+            if (typeof id !== 'number' || !Number.isInteger(id) || typeof title !== 'string')
+                continue;
+            result.push({
+                pageId: id,
+                title,
+                relPath: typeof item['relPath'] === 'string' ? item['relPath'] : '',
+                depth: typeof item['depth'] === 'number' && Number.isInteger(item['depth']) ? item['depth'] : depth,
+            });
+            if (Array.isArray(item['children']))
+                walk(item['children'], depth + 1);
+        }
+    };
+    walk(list, 0);
+    return result;
+}
+export function parseRepos(data) {
+    const list = isRecord(data) && Array.isArray(data['repos']) ? data['repos'] : [];
+    const seen = new Set();
+    const result = [];
+    for (const item of list) {
+        if (!isRecord(item))
+            continue;
+        const repoPath = item['path'];
+        if (typeof repoPath !== 'string' || repoPath.length === 0 || seen.has(repoPath))
+            continue;
+        seen.add(repoPath);
+        const slugValue = typeof item['slug'] === 'string' && item['slug'].length > 0 ? item['slug'] : path.basename(repoPath);
+        const reported = typeof item['exists'] === 'boolean' ? item['exists'] : true;
+        result.push({ path: repoPath, slug: slugValue, exists: reported && isDirectory(repoPath) });
+    }
+    return result;
+}
+function metaRoot(meta) {
+    return typeof meta?.['root'] === 'string' ? meta['root'] : null;
+}
+export async function loadProjectContext(project, docsRoot, bita) {
+    const context = emptyContext({ project: project && trimmed(project).length > 0 ? project : null, docsRoot: docsRoot ?? null });
+    if (!bita)
+        return context;
+    if (context.project) {
+        const pages = await bita.invoke(['docs', 'page', 'ls', '--project', context.project]).catch(() => null);
+        if (pages?.ok) {
+            context.pages = parsePages(pages.data);
+            context.docsRoot ??= metaRoot(pages.meta);
+        }
+        const repos = await bita.invoke(['project', 'repo', 'ls', '--project', context.project]).catch(() => null);
+        if (repos?.ok)
+            context.repos = parseRepos(repos.data);
+    }
+    if (context.docsRoot === null) {
+        const tree = await bita.invoke(['docs', 'tree']).catch(() => null);
+        if (tree?.ok)
+            context.docsRoot = metaRoot(tree.meta);
+    }
+    return context;
+}
+export function meetingProjectName(meeting) {
+    return meeting.bitaEntry?.projectName ?? meeting.wrapup?.project ?? null;
+}
+export async function meetingProject(meeting, bita) {
+    const name = meetingProjectName(meeting);
+    if (name && trimmed(name).length > 0)
+        return name;
+    const pageId = meeting.wrapup?.pageId ?? meeting.bitaEntry?.pageIds[0];
+    if (!bita || pageId === undefined)
+        return null;
+    const response = await bita.invoke(['docs', 'page', 'show', String(pageId), '--no-markdown']).catch(() => null);
+    if (!response?.ok || !isRecord(response.data))
+        return null;
+    return typeof response.data['projectName'] === 'string' ? response.data['projectName'] : null;
+}

package/dist/live/dedupe.js

@@ -0,0 +1,21 @@
+import { jaccard, jaccardSets, tokens } from "../core/text.js";
+export const DEDUPE_THRESHOLD = 0.5;
+export const STOPWORDS = new Set([
+    'el', 'la', 'los', 'las', 'lo', 'un', 'una', 'unos', 'unas', 'de', 'del', 'al', 'en', 'por', 'para', 'con',
+    'sin', 'se', 'es', 'son', 'como', 'cual', 'cuales', 'donde', 'cuando', 'quien', 'que', 'y', 'o',
+    'u', 'le', 'les', 'su', 'sus', 'me', 'mi', 'te', 'tu', 'nos', 'este', 'esta', 'esto', 'ese', 'esa', 'eso',
+    'hay', 'ya', 'mas', 'pero', 'si', 'no', 'muy', 'hace', 'hacer', 'puede', 'podemos',
+]);
+export function questionTokens(text) {
+    return new Set([...tokens(text)].filter((token) => !STOPWORDS.has(token)));
+}
+export function questionSimilarity(a, b) {
+    const left = questionTokens(a);
+    const right = questionTokens(b);
+    if (left.size === 0 || right.size === 0)
+        return jaccard(a, b);
+    return jaccardSets(left, right);
+}
+export function isDuplicateQuestion(question, known) {
+    return known.some((other) => questionSimilarity(question, other) >= DEDUPE_THRESHOLD);
+}