maestro-flow 0.5.35 → 0.5.37

package/dashboard/dist-server/dashboard/src/server/wiki/virtual-wiki-adapters.js

@@ -1,4 +1,4 @@
-import { readFile } from 'node:fs/promises';
+import { readFile, open } from 'node:fs/promises';
 function slugify(s) {
     return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
 }
@@ -589,4 +589,554 @@ export async function loadSessionArchiveEntries(archiveAbsPath, archiveRelPath)
         return [];
     }
 }
+// ── Claude Code / Codex session adapters ─────────────────────────────────
+// Reads JSONL session transcripts from ~/.claude/ and ~/.codex/ and produces
+// compact WikiEntry notes for search and wiki-load.
+const MAX_SESSION_READ_BYTES = 512 * 1024;
+const MAX_SESSION_PEEK_BYTES = 8 * 1024;
+const MAX_USER_QUERIES = 25;
+const MAX_QUERY_LENGTH = 200;
+// Knowledge file path patterns → wiki entry ID derivation
+const KNOWLEDGE_DIR_PATTERN = /[\\/]\.workflow[\\/](specs|knowhow|issues|domain)[\\/](.+)$/;
+function deriveRelatedFromPaths(filePaths, sessionCwd) {
+    const related = [];
+    const seen = new Set();
+    for (const fp of filePaths) {
+        const normalized = fp.replace(/\\/g, '/');
+        const m = KNOWLEDGE_DIR_PATTERN.exec(normalized);
+        if (!m)
+            continue;
+        const [, dirType, relFile] = m;
+        const stem = relFile.replace(/\.[^.]+$/, '').replace(/[\\/]/g, '-');
+        let id;
+        switch (dirType) {
+            case 'specs':
+                id = `spec-${stem}`;
+                break;
+            case 'knowhow':
+                id = `knowhow-${stem}`;
+                break;
+            case 'issues': continue; // JSONL issues use different ID scheme
+            case 'domain':
+                id = `domain-${stem}`;
+                break;
+            default: continue;
+        }
+        if (!seen.has(id)) {
+            seen.add(id);
+            related.push(id);
+        }
+    }
+    return related.slice(0, 20);
+}
+async function readSessionHead(absPath, maxBytes = MAX_SESSION_READ_BYTES) {
+    let handle;
+    try {
+        handle = await open(absPath, 'r');
+        const buf = Buffer.alloc(maxBytes);
+        const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+        const text = buf.subarray(0, bytesRead).toString('utf-8');
+        const lines = text.split(/\r?\n/);
+        if (bytesRead === maxBytes)
+            lines.pop();
+        return lines.filter(l => l.trim());
+    }
+    catch {
+        return [];
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function peekSessionCwd(absPath) {
+    const lines = await readSessionHead(absPath, MAX_SESSION_PEEK_BYTES);
+    for (const line of lines.slice(0, 10)) {
+        try {
+            const row = JSON.parse(line);
+            if (row.type === 'session_meta') {
+                const p = row.payload;
+                return p?.cwd || null;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function stripCommandTags(content) {
+    return content
+        .replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>\s*/g, '')
+        .replace(/<command-message>[\s\S]*?<\/command-message>\s*/g, '')
+        .replace(/<command-name>(\/[^<]+)<\/command-name>/g, '$1')
+        .replace(/<command-args>([^<]*)<\/command-args>/g, ' $1')
+        .replace(/<system-reminder>[\s\S]*?<\/system-reminder>\s*/g, '')
+        .replace(/<[^>]+>/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+const NOISE_PREFIXES = ['Caveat:', '<local-command-caveat>', '<system-reminder>', 'No response requested'];
+const NOISE_COMMANDS = new Set(['/clear', '/help', '/config', '/compact', 'clear', 'help']);
+function isNoiseMessage(content) {
+    const t = content.trim();
+    if (t.length === 0)
+        return true;
+    if (NOISE_COMMANDS.has(t))
+        return true;
+    for (const p of NOISE_PREFIXES) {
+        if (t.startsWith(p))
+            return true;
+    }
+    return false;
+}
+const CODEX_PROTOCOL_MARKERS = ['# Analysis Mode Protocol', '# Write Mode Protocol', 'PURPOSE:', '## Mode Definition', '## Prompt Structure', '## Operation Boundaries'];
+function isCodexNoiseMessage(msg) {
+    if (msg.length > 500) {
+        const head = msg.slice(0, 200);
+        for (const m of CODEX_PROTOCOL_MARKERS) {
+            if (head.includes(m))
+                return true;
+        }
+    }
+    if (msg.length > 3000)
+        return true;
+    const t = msg.trim();
+    if (t.length === 0)
+        return true;
+    return false;
+}
+function extractCommands(content) {
+    const cmds = [];
+    const nameMatch = content.match(/<command-name>(\/[^<]+)<\/command-name>/);
+    if (nameMatch)
+        cmds.push(nameMatch[1]);
+    const slashMatch = content.match(/^(\/[\w-]+)/);
+    if (slashMatch && !cmds.includes(slashMatch[1]))
+        cmds.push(slashMatch[1]);
+    return cmds;
+}
+function buildSessionBody(meta) {
+    const lines = [`# ${meta.title}`, ''];
+    const infoParts = [meta.platform];
+    if (meta.projectSlug)
+        infoParts.push(meta.projectSlug);
+    infoParts.push(meta.cwd);
+    if (meta.branch)
+        infoParts.push(`br:${meta.branch}`);
+    if (meta.firstTs && meta.lastTs) {
+        infoParts.push(`${meta.firstTs.slice(0, 16)} — ${meta.lastTs.slice(11, 16)}`);
+    }
+    infoParts.push(`${meta.turnCount}t`);
+    lines.push(infoParts.join(' | '));
+    if (meta.queries.length > 0) {
+        lines.push('', '## Q');
+        for (const q of meta.queries)
+            lines.push(`- ${q}`);
+    }
+    if (meta.commands.length > 0) {
+        const meaningful = meta.commands.filter(c => !NOISE_COMMANDS.has(c));
+        if (meaningful.length > 0) {
+            lines.push('', `Cmds: ${meaningful.join(', ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+function slugify2(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+// ── Claude Code ──────────────────────────────────────────────────────────
+export function adaptClaudeCodeSession(jsonlLines, sourcePath, projectSlug) {
+    let sessionId = null;
+    let title = null;
+    let cwd = null;
+    let branch = null;
+    let firstTs = null;
+    let lastTs = null;
+    let turnCount = 0;
+    const queries = [];
+    const commandSet = new Set();
+    const editedFilePaths = new Set();
+    for (const line of jsonlLines) {
+        let row;
+        try {
+            row = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const type = row.type;
+        if (type === 'ai-title') {
+            title = asString(row.aiTitle) || title;
+            if (!sessionId)
+                sessionId = asString(row.sessionId);
+        }
+        if (type === 'user') {
+            turnCount++;
+            const msg = row.message;
+            const content = asString(msg?.content);
+            const ts = asString(row.timestamp);
+            if (!cwd)
+                cwd = asString(row.cwd);
+            if (!branch)
+                branch = asString(row.gitBranch) || null;
+            if (!sessionId)
+                sessionId = asString(row.sessionId);
+            if (!firstTs || (ts && ts < firstTs))
+                firstTs = ts;
+            if (!lastTs || (ts && ts > lastTs))
+                lastTs = ts;
+            for (const cmd of extractCommands(content))
+                commandSet.add(cmd);
+            if (queries.length < MAX_USER_QUERIES && content) {
+                const clean = stripCommandTags(content).slice(0, MAX_QUERY_LENGTH);
+                if (clean.length > 5 && !isNoiseMessage(clean))
+                    queries.push(clean);
+            }
+        }
+        if (type === 'assistant') {
+            const ts = asString(row.timestamp);
+            if (!lastTs || (ts && ts > lastTs))
+                lastTs = ts;
+            // Extract edited file paths from tool_use blocks
+            const msg = row.message;
+            const content = msg?.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === 'tool_use' && (block.name === 'Write' || block.name === 'Edit')) {
+                        const input = block.input;
+                        const fp = asString(input?.file_path);
+                        if (fp && editedFilePaths.size < 50)
+                            editedFilePaths.add(fp);
+                    }
+                }
+            }
+        }
+    }
+    if (!sessionId || turnCount === 0)
+        return null;
+    const displayTitle = title || `Claude session ${sessionId.slice(0, 8)}`;
+    const slug = slugify2(sessionId);
+    // Derive related wiki IDs from edited .workflow/ files
+    const related = deriveRelatedFromPaths(editedFilePaths, cwd || '');
+    const body = buildSessionBody({
+        platform: 'Claude Code',
+        title: displayTitle,
+        projectSlug,
+        cwd: cwd || '',
+        branch,
+        firstTs,
+        lastTs,
+        turnCount,
+        queries,
+        commands: [...commandSet],
+    });
+    const meaningfulCmds = [...commandSet].filter(c => !NOISE_COMMANDS.has(c));
+    const tags = ['session', 'claude'];
+    if (projectSlug)
+        tags.push(projectSlug);
+    if (branch)
+        tags.push(branch);
+    for (const cmd of meaningfulCmds)
+        tags.push(cmd);
+    return {
+        id: `cc-session-${slug}`,
+        type: 'note',
+        title: displayTitle,
+        summary: queries.slice(0, 3).join(' | ').slice(0, 240) || `Claude Code session (${turnCount} turns)`,
+        tags: tags.slice(0, 15),
+        status: 'completed',
+        created: firstTs || toIso(null),
+        updated: lastTs || toIso(null),
+        related,
+        source: { kind: 'virtual', path: sourcePath },
+        body,
+        raw: { sessionId, turnCount, commands: [...commandSet] },
+        ext: {
+            virtualKind: 'claude-session',
+            sessionId,
+            platform: 'claude',
+            cwd: cwd || '',
+            gitBranch: branch,
+            turnCount,
+            commandsUsed: [...commandSet],
+            editedFiles: [...editedFilePaths].slice(0, 30),
+        },
+        scope: null,
+        category: 'session',
+        specCategory: null,
+        createdBy: 'session-indexer',
+        sourceRef: sessionId,
+        parent: null,
+    };
+}
+export async function loadClaudeCodeSessions(projectDir, projectSlug, maxAgeDays, maxFiles) {
+    const names = await safeReaddirLocal(projectDir);
+    const jsonlFiles = names.filter(n => n.endsWith('.jsonl'));
+    const cutoff = Date.now() - maxAgeDays * 86400000;
+    const { stat: fsStat } = await import('node:fs/promises');
+    const candidates = [];
+    for (const name of jsonlFiles) {
+        try {
+            const s = await fsStat(`${projectDir}/${name}`);
+            if (s.mtimeMs >= cutoff && s.size > 200) {
+                candidates.push({ name, mtime: s.mtimeMs });
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    candidates.sort((a, b) => b.mtime - a.mtime);
+    const out = [];
+    for (const c of candidates.slice(0, maxFiles)) {
+        const absPath = `${projectDir}/${c.name}`;
+        const lines = await readSessionHead(absPath);
+        if (lines.length === 0)
+            continue;
+        const entry = adaptClaudeCodeSession(lines, `~/.claude/projects/${projectSlug}/${c.name}`, projectSlug);
+        if (entry)
+            out.push(entry);
+    }
+    return out;
+}
+// ── Codex ────────────────────────────────────────────────────────────────
+export function adaptCodexSession(jsonlLines, sourcePath, threadName) {
+    let sessionId = null;
+    let cwd = null;
+    let cliVersion = null;
+    let model = null;
+    let firstTs = null;
+    let lastTs = null;
+    let turnCount = 0;
+    const queries = [];
+    const editedFilePaths = new Set();
+    for (const line of jsonlLines) {
+        let row;
+        try {
+            row = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const type = row.type;
+        const ts = asString(row.timestamp);
+        if (ts) {
+            if (!firstTs || ts < firstTs)
+                firstTs = ts;
+            if (!lastTs || ts > lastTs)
+                lastTs = ts;
+        }
+        if (type === 'session_meta') {
+            const p = row.payload;
+            if (p) {
+                sessionId = asString(p.id) || sessionId;
+                cwd = asString(p.cwd) || cwd;
+                cliVersion = asString(p.cli_version) || cliVersion;
+            }
+        }
+        if (type === 'turn_context') {
+            const p = row.payload;
+            if (p) {
+                if (!cwd)
+                    cwd = asString(p.cwd) || null;
+                if (!model)
+                    model = asString(p.model) || null;
+            }
+        }
+        if (type === 'event_msg') {
+            const p = row.payload;
+            if (!p)
+                continue;
+            const evType = asString(p.type);
+            if (evType === 'user_message') {
+                turnCount++;
+                const msg = asString(p.message);
+                if (queries.length < MAX_USER_QUERIES && msg && !isCodexNoiseMessage(msg)) {
+                    const clean = msg.replace(/\s+/g, ' ').trim().slice(0, MAX_QUERY_LENGTH);
+                    if (clean.length > 10)
+                        queries.push(clean);
+                }
+            }
+            // Extract file paths from tool_use / file_write events
+            if (evType === 'tool_use' || evType === 'file_write' || evType === 'file_edit') {
+                const fp = asString(p.file_path) || asString(p.path);
+                if (fp && editedFilePaths.size < 50)
+                    editedFilePaths.add(fp);
+            }
+        }
+    }
+    if (!sessionId || turnCount === 0)
+        return null;
+    const displayTitle = threadName || `Codex session ${sessionId.slice(0, 8)}`;
+    const slug = slugify2(sessionId);
+    const related = deriveRelatedFromPaths(editedFilePaths, cwd || '');
+    const body = buildSessionBody({
+        platform: 'Codex',
+        title: displayTitle,
+        projectSlug: '',
+        cwd: cwd || '',
+        branch: null,
+        firstTs,
+        lastTs,
+        turnCount,
+        queries,
+        commands: [],
+    });
+    const tags = ['session', 'codex'];
+    if (model)
+        tags.push(model);
+    return {
+        id: `cdx-session-${slug}`,
+        type: 'note',
+        title: displayTitle,
+        summary: queries.slice(0, 3).join(' | ').slice(0, 240) || `Codex session (${turnCount} turns)`,
+        tags: tags.slice(0, 15),
+        status: 'completed',
+        created: firstTs || toIso(null),
+        updated: lastTs || toIso(null),
+        related,
+        source: { kind: 'virtual', path: sourcePath },
+        body,
+        raw: { sessionId, turnCount },
+        ext: {
+            virtualKind: 'codex-session',
+            sessionId,
+            platform: 'codex',
+            cwd: cwd || '',
+            cliVersion,
+            model,
+            turnCount,
+            editedFiles: [...editedFilePaths].slice(0, 30),
+        },
+        scope: null,
+        category: 'session',
+        specCategory: null,
+        createdBy: 'session-indexer',
+        sourceRef: sessionId,
+        parent: null,
+    };
+}
+export async function loadCodexSessionIndex(codexRoot) {
+    const indexPath = `${codexRoot}/session_index.jsonl`;
+    const titleMap = new Map();
+    let raw;
+    try {
+        raw = await readFile(indexPath, 'utf-8');
+    }
+    catch {
+        return titleMap;
+    }
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const row = JSON.parse(line);
+            const id = asString(row.id);
+            const name = asString(row.thread_name);
+            if (id && name)
+                titleMap.set(id, name);
+        }
+        catch {
+            continue;
+        }
+    }
+    return titleMap;
+}
+export async function loadCodexSessions(codexRoot, projectCwd, maxAgeDays, maxFiles) {
+    const sessionsDir = `${codexRoot}/sessions`;
+    const titleMap = await loadCodexSessionIndex(codexRoot);
+    const cutoff = Date.now() - maxAgeDays * 86400000;
+    const { stat: fsStat } = await import('node:fs/promises');
+    const allFiles = await findJsonlFilesRecursive(sessionsDir, 3);
+    const candidates = [];
+    for (const f of allFiles) {
+        try {
+            const s = await fsStat(f.absPath);
+            if (s.mtimeMs >= cutoff && s.size > 200) {
+                candidates.push({ ...f, mtime: s.mtimeMs });
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    candidates.sort((a, b) => b.mtime - a.mtime);
+    const normalizedProjectCwd = projectCwd.replace(/\\/g, '/').toLowerCase();
+    const out = [];
+    for (const c of candidates.slice(0, maxFiles * 3)) {
+        if (out.length >= maxFiles)
+            break;
+        // Phase 1: peek first 8KB to check CWD match (avoids reading 512KB for non-matching sessions)
+        const sessionCwd = await peekSessionCwd(c.absPath);
+        if (!sessionCwd)
+            continue;
+        const normalizedSessionCwd = sessionCwd.replace(/\\/g, '/').toLowerCase();
+        if (normalizedSessionCwd !== normalizedProjectCwd)
+            continue;
+        // Phase 2: full read only for matching sessions
+        const lines = await readSessionHead(c.absPath);
+        if (lines.length === 0)
+            continue;
+        let sessionId = null;
+        for (const line of lines.slice(0, 5)) {
+            try {
+                const row = JSON.parse(line);
+                if (row.type === 'session_meta') {
+                    const p = row.payload;
+                    sessionId = asString(p?.id) || null;
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        const threadName = sessionId ? (titleMap.get(sessionId) ?? null) : null;
+        const entry = adaptCodexSession(lines, `~/.codex/${c.relPath}`, threadName);
+        if (entry)
+            out.push(entry);
+    }
+    return out;
+}
+async function findJsonlFilesRecursive(dir, maxDepth, currentDepth = 0) {
+    if (currentDepth > maxDepth)
+        return [];
+    const out = [];
+    const names = await safeReaddirLocal(dir);
+    const { stat: fsStat } = await import('node:fs/promises');
+    for (const name of names) {
+        const full = `${dir}/${name}`;
+        try {
+            const s = await fsStat(full);
+            if (s.isDirectory()) {
+                const sub = await findJsonlFilesRecursive(full, maxDepth, currentDepth + 1);
+                out.push(...sub);
+            }
+            else if (name.endsWith('.jsonl')) {
+                const sessionsIdx = full.replace(/\\/g, '/').indexOf('/sessions/');
+                const relPath = sessionsIdx >= 0 ? `sessions${full.replace(/\\/g, '/').slice(sessionsIdx + '/sessions'.length)}` : name;
+                out.push({ absPath: full, relPath });
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return out;
+}
+async function safeReaddirLocal(dir) {
+    const { readdir: fsReaddir } = await import('node:fs/promises');
+    try {
+        return await fsReaddir(dir);
+    }
+    catch {
+        return [];
+    }
+}
+export function cwdToClaudeProjectSlug(cwd) {
+    return cwd
+        .replace(/:/g, '')
+        .replace(/[\\/]+/g, '--')
+        .replace(/^-+|-+$/g, '');
+}
 //# sourceMappingURL=virtual-wiki-adapters.js.map