gru-ai 0.1.0

package/dist-server/server/parsers/session-scanner.d.ts

@@ -0,0 +1,56 @@
+export type LastEntryType = 'user' | 'assistant-tool' | 'assistant-text' | 'assistant-question' | 'unknown';
+export declare function projectLabel(dirName: string): string;
+/**
+ * Derive the Claude projects directory name from an absolute repo path.
+ * Inverse of the encoding Claude Code uses: `/Users/foo/bar` → `-Users-foo-bar`
+ */
+export declare function projectDirFromPath(repoPath: string): string;
+export declare function cleanPromptText(raw: string): string | undefined;
+export declare function extractInitialPrompt(filepath: string): string | undefined;
+/**
+ * Extract a named agent identity from the initial prompt of a subagent.
+ * Detects patterns like "You are Alex Rivera, Chief of Staff" or "You are Sarah Chen, CTO"
+ * Returns { name, role } if found, undefined otherwise.
+ */
+export declare function extractAgentIdentity(promptText: string): {
+    name: string;
+    role: string;
+} | undefined;
+/**
+ * Extract agent identity from a JSONL file's first user message.
+ * Reads the head of the file to find the initial prompt, then checks for agent identity patterns.
+ */
+export declare function extractAgentIdentityFromFile(filepath: string): {
+    name: string;
+    role: string;
+} | undefined;
+/**
+ * Scan a parent session JSONL for Agent tool_use/tool_result pairs.
+ * Returns a map of agentId → subagent_type (e.g. "a4df5875a493548ce" → "alex").
+ * Results are cached per parent file and invalidated on mtime change.
+ */
+export declare function extractSubagentTypesFromParent(parentFilePath: string, cache?: Map<string, {
+    mtime: number;
+    map: Map<string, string>;
+}>): Map<string, string>;
+/**
+ * Look up agent identity for a subagent by checking the parent session's Agent tool calls.
+ * Returns { name, role } if the subagent was spawned with a known subagent_type, undefined otherwise.
+ */
+export declare function resolveAgentFromParent(parentFilePath: string, childAgentId: string, cache?: Map<string, {
+    mtime: number;
+    map: Map<string, string>;
+}>): {
+    name: string;
+    role: string;
+} | undefined;
+/**
+ * Look up a known agent by its CLI agent-setting name (e.g. "riley", "sarah").
+ * Returns { name, role } if known, undefined otherwise.
+ */
+export declare function resolveAgentFromSetting(agentSetting: string): {
+    name: string;
+    role: string;
+} | undefined;
+export declare function isSystemContent(text: string): boolean;
+export declare function extractLatestPrompt(filepath: string): string | undefined;

package/dist-server/server/parsers/session-scanner.js

@@ -0,0 +1,390 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const PROMPT_TAIL_SIZE = 65536;
+const HEAD_SIZE = 16384;
+export function projectLabel(dirName) {
+    const decoded = dirName.replace(/^-/, '/').replace(/-/g, '/');
+    const parts = decoded.split('/').filter(Boolean);
+    return parts.slice(-3).join('/');
+}
+/**
+ * Derive the Claude projects directory name from an absolute repo path.
+ * Inverse of the encoding Claude Code uses: `/Users/foo/bar` → `-Users-foo-bar`
+ */
+export function projectDirFromPath(repoPath) {
+    return repoPath.replace(/\//g, '-');
+}
+function headRead(filepath, size = HEAD_SIZE) {
+    let fd = null;
+    try {
+        fd = fs.openSync(filepath, 'r');
+        const stat = fs.fstatSync(fd);
+        const readSize = Math.min(size, stat.size);
+        if (readSize === 0) {
+            fs.closeSync(fd);
+            return null;
+        }
+        const buffer = Buffer.allocUnsafe(readSize);
+        fs.readSync(fd, buffer, 0, readSize, 0);
+        fs.closeSync(fd);
+        fd = null;
+        return buffer.toString('utf-8');
+    }
+    catch {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* ignore */ }
+        }
+        return null;
+    }
+}
+export function cleanPromptText(raw) {
+    const lines = raw.trim().split('\n');
+    for (const rawLine of lines) {
+        let line = rawLine.replace(/<[^>]+>/g, '').trim();
+        if (!line)
+            continue;
+        if (line === 'Implement the following plan:')
+            continue;
+        if (line.startsWith('Caveat:'))
+            continue;
+        if (line.startsWith('# Plan:') || line.startsWith('## ')) {
+            line = line.replace(/^#+ (?:Plan:\s*)?/, '').trim();
+            if (!line)
+                continue;
+        }
+        return line.length > 80 ? line.slice(0, 80) + '...' : line;
+    }
+    return undefined;
+}
+export function extractInitialPrompt(filepath) {
+    // Try progressively larger reads to handle compacted/continued sessions
+    // where the first user entry can exceed 16KB
+    for (const size of [HEAD_SIZE, HEAD_SIZE * 16]) {
+        const content = headRead(filepath, size);
+        if (!content)
+            return undefined;
+        const lines = content.split('\n');
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type === 'user' || entry.message?.role === 'user') {
+                    const msgContent = entry.message?.content;
+                    if (typeof msgContent === 'string' && msgContent.length > 0) {
+                        return cleanPromptText(msgContent);
+                    }
+                    if (Array.isArray(msgContent)) {
+                        for (const block of msgContent) {
+                            const text = block.content ?? block.text;
+                            if (typeof text === 'string' && text.length > 0) {
+                                return cleanPromptText(text);
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Partial line at buffer boundary — try larger read
+            }
+        }
+    }
+    return undefined;
+}
+// --- Named agent detection ---
+/** Known named agents in the conductor system (loaded from agent-registry.json) */
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const registryPath = path.resolve(__dirname, '../../.claude/agent-registry.json');
+const registryData = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+const KNOWN_AGENTS = {};
+for (const agent of registryData.agents) {
+    if (agent.id !== 'ceo') {
+        KNOWN_AGENTS[agent.id] = { name: agent.name.split(' ')[0], role: agent.role };
+    }
+}
+// Generic roles (from subagent_type, not personality-driven -- not in registry)
+KNOWN_AGENTS['builder'] = { name: 'Builder', role: 'Engineer' };
+KNOWN_AGENTS['reviewer'] = { name: 'Reviewer', role: 'Code Reviewer' };
+KNOWN_AGENTS['auditor'] = { name: 'Auditor', role: 'Technical Auditor' };
+KNOWN_AGENTS['investigator'] = { name: 'Investigator', role: 'Codebase Scanner' };
+/**
+ * Extract a named agent identity from the initial prompt of a subagent.
+ * Detects patterns like "You are Alex Rivera, Chief of Staff" or "You are Sarah Chen, CTO"
+ * Returns { name, role } if found, undefined otherwise.
+ */
+export function extractAgentIdentity(promptText) {
+    if (!promptText)
+        return undefined;
+    // Check first 2000 chars for agent identity patterns
+    const head = promptText.slice(0, 2000);
+    // Pattern 1: "You are {FirstName} {LastName}, {Role}"
+    const youAreMatch = head.match(/You are (\w+)\s+\w+,\s*([^.\n]+)/);
+    if (youAreMatch) {
+        const firstName = youAreMatch[1].toLowerCase();
+        const known = KNOWN_AGENTS[firstName];
+        if (known)
+            return known;
+        // Unknown named agent — use what we found
+        return { name: youAreMatch[1], role: youAreMatch[2].trim() };
+    }
+    // Pattern 2: "# {FirstName} {LastName} --- {Role}" (personality file header)
+    const headerMatch = head.match(/^#\s+(\w+)\s+\w+\s*(?:---|—)\s*(.+)$/m);
+    if (headerMatch) {
+        const firstName = headerMatch[1].toLowerCase();
+        const known = KNOWN_AGENTS[firstName];
+        if (known)
+            return known;
+        return { name: headerMatch[1], role: headerMatch[2].trim() };
+    }
+    // Pattern 3: Check for known agent first names in the prompt
+    for (const [key, agent] of Object.entries(KNOWN_AGENTS)) {
+        // Look for "You are {Name}" or "as {Name}" in the prompt
+        const nameRegex = new RegExp(`\\b(?:You are|as)\\s+${key}\\b`, 'i');
+        if (nameRegex.test(head))
+            return agent;
+    }
+    return undefined;
+}
+/**
+ * Extract agent identity from a JSONL file's first user message.
+ * Reads the head of the file to find the initial prompt, then checks for agent identity patterns.
+ */
+export function extractAgentIdentityFromFile(filepath) {
+    const content = headRead(filepath, HEAD_SIZE);
+    if (!content)
+        return undefined;
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            if (entry.type === 'user' || entry.message?.role === 'user') {
+                const msgContent = entry.message?.content;
+                if (typeof msgContent === 'string' && msgContent.length > 0) {
+                    return extractAgentIdentity(msgContent);
+                }
+                if (Array.isArray(msgContent)) {
+                    for (const block of msgContent) {
+                        const text = block.content ?? block.text;
+                        if (typeof text === 'string' && text.length > 0) {
+                            const identity = extractAgentIdentity(text);
+                            if (identity)
+                                return identity;
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return undefined;
+}
+// --- Parent session cross-reference for subagent type detection ---
+/** Cache of parent file → (agentId → subagent_type) mappings */
+const parentAgentMapCache = new Map();
+/**
+ * Scan a parent session JSONL for Agent tool_use/tool_result pairs.
+ * Returns a map of agentId → subagent_type (e.g. "a4df5875a493548ce" → "alex").
+ * Results are cached per parent file and invalidated on mtime change.
+ */
+export function extractSubagentTypesFromParent(parentFilePath, cache) {
+    const cacheMap = cache ?? parentAgentMapCache;
+    // Check cache
+    let stat;
+    try {
+        stat = fs.statSync(parentFilePath);
+    }
+    catch {
+        return new Map();
+    }
+    const cached = cacheMap.get(parentFilePath);
+    if (cached && cached.mtime === stat.mtimeMs) {
+        return cached.map;
+    }
+    const result = new Map();
+    // Scan the entire file for Agent tool calls — they can appear anywhere in a
+    // long conversation. Previously limited to 2MB which missed late-session spawns.
+    const MAX_SCAN = stat.size;
+    let fd = null;
+    try {
+        fd = fs.openSync(parentFilePath, 'r');
+        const scanSize = Math.min(MAX_SCAN, stat.size);
+        let offset = 0;
+        let partial = '';
+        // Track pending Agent tool_use entries: tool_use_id → subagent_type
+        const pendingToolCalls = new Map();
+        while (offset < scanSize) {
+            const chunkSize = Math.min(65536, scanSize - offset);
+            const buffer = Buffer.allocUnsafe(chunkSize);
+            fs.readSync(fd, buffer, 0, chunkSize, offset);
+            offset += chunkSize;
+            const content = partial + buffer.toString('utf-8');
+            const lines = content.split('\n');
+            // Last line may be partial — save for next chunk
+            partial = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                // Quick pre-filter to avoid parsing every line
+                if (!trimmed.includes('"Agent"') && !trimmed.includes('agentId'))
+                    continue;
+                try {
+                    const entry = JSON.parse(trimmed);
+                    const blocks = entry?.message?.content;
+                    if (!Array.isArray(blocks))
+                        continue;
+                    for (const block of blocks) {
+                        // Agent tool_use → capture subagent_type keyed by tool_use id
+                        if (block.type === 'tool_use' && block.name === 'Agent' && block.input?.subagent_type) {
+                            pendingToolCalls.set(block.id, block.input.subagent_type);
+                        }
+                        // tool_result → match agentId to pending tool call
+                        if (block.type === 'tool_result' && typeof block.tool_use_id === 'string') {
+                            const subagentType = pendingToolCalls.get(block.tool_use_id);
+                            if (!subagentType)
+                                continue;
+                            // Extract agentId from the result text
+                            const resultText = typeof block.content === 'string'
+                                ? block.content
+                                : Array.isArray(block.content)
+                                    ? block.content.map((b) => b.text ?? '').join('')
+                                    : '';
+                            const match = resultText.match(/agentId:\s*(\w+)/);
+                            if (match) {
+                                result.set(match[1], subagentType);
+                                pendingToolCalls.delete(block.tool_use_id);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // skip malformed
+                }
+            }
+        }
+        fs.closeSync(fd);
+        fd = null;
+    }
+    catch {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    cacheMap.set(parentFilePath, { mtime: stat.mtimeMs, map: result });
+    return result;
+}
+/**
+ * Look up agent identity for a subagent by checking the parent session's Agent tool calls.
+ * Returns { name, role } if the subagent was spawned with a known subagent_type, undefined otherwise.
+ */
+export function resolveAgentFromParent(parentFilePath, childAgentId, cache) {
+    const typeMap = extractSubagentTypesFromParent(parentFilePath, cache);
+    const subagentType = typeMap.get(childAgentId);
+    if (!subagentType)
+        return undefined;
+    // Check known agents (normalize: subagent_type may include suffix like "alex" from "alex-cos")
+    const normalized = subagentType.toLowerCase().split('-')[0];
+    return KNOWN_AGENTS[normalized] ?? KNOWN_AGENTS[subagentType.toLowerCase()];
+}
+/**
+ * Look up a known agent by its CLI agent-setting name (e.g. "riley", "sarah").
+ * Returns { name, role } if known, undefined otherwise.
+ */
+export function resolveAgentFromSetting(agentSetting) {
+    const normalized = agentSetting.toLowerCase().split('-')[0];
+    return KNOWN_AGENTS[normalized] ?? KNOWN_AGENTS[agentSetting.toLowerCase()];
+}
+export function isSystemContent(text) {
+    const trimmed = text.trim();
+    if (/^<system-reminder>[\s\S]*<\/system-reminder>$/.test(trimmed))
+        return true;
+    if (/^<task-notification>[\s\S]*<\/task-notification>$/.test(trimmed))
+        return true;
+    if (trimmed.startsWith('Shell cwd was reset to'))
+        return true;
+    if (trimmed.startsWith('Called the ') && trimmed.includes(' tool with'))
+        return true;
+    if (trimmed.startsWith('Result of calling the '))
+        return true;
+    if (trimmed.startsWith('This session is being continued from a previous conversation'))
+        return true;
+    if (trimmed.startsWith('[Request interrupted by user'))
+        return true;
+    return false;
+}
+export function extractLatestPrompt(filepath) {
+    let fd = null;
+    try {
+        fd = fs.openSync(filepath, 'r');
+        const stat = fs.fstatSync(fd);
+        if (stat.size === 0) {
+            fs.closeSync(fd);
+            return undefined;
+        }
+        const chunkSize = PROMPT_TAIL_SIZE;
+        const maxRead = Math.min(stat.size, chunkSize * 8);
+        let offset = stat.size;
+        while (offset > stat.size - maxRead && offset > 0) {
+            const readSize = Math.min(chunkSize, offset);
+            offset -= readSize;
+            const buffer = Buffer.allocUnsafe(readSize);
+            fs.readSync(fd, buffer, 0, readSize, offset);
+            const content = buffer.toString('utf-8');
+            const lines = content.split('\n');
+            const startIdx = offset > 0 ? 1 : 0;
+            for (let i = lines.length - 1; i >= startIdx; i--) {
+                const line = lines[i].trim();
+                if (!line)
+                    continue;
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.type !== 'user' && entry.message?.role !== 'user')
+                        continue;
+                    const msgContent = entry.message?.content;
+                    if (typeof msgContent === 'string' && msgContent.trim().length > 0) {
+                        if (isSystemContent(msgContent))
+                            continue;
+                        fs.closeSync(fd);
+                        return cleanPromptText(msgContent);
+                    }
+                    if (Array.isArray(msgContent)) {
+                        for (const block of msgContent) {
+                            if (block.type === 'tool_result')
+                                continue;
+                            const text = block.content ?? block.text;
+                            if (typeof text === 'string' && text.trim().length > 0 && !isSystemContent(text)) {
+                                fs.closeSync(fd);
+                                return cleanPromptText(text);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // skip malformed
+                }
+            }
+        }
+        fs.closeSync(fd);
+        fd = null;
+    }
+    catch {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return undefined;
+}

package/dist-server/server/parsers/session-state.d.ts

@@ -0,0 +1,68 @@
+import type { SessionActivity } from '../types.js';
+import type { LastEntryType } from './session-scanner.js';
+type MachineState = 'working' | 'needs_input' | 'done';
+export interface SessionFileState {
+    byteOffset: number;
+    mtimeMs: number;
+    fileSize: number;
+    machineState: MachineState;
+    toolUseCount: number;
+    toolResultCount: number;
+    pendingInputTool: boolean;
+    lastActivityAt: string;
+    messageCount: number;
+    sessionId?: string;
+    model?: string;
+    cwd?: string;
+    gitBranch?: string;
+    version?: string;
+    slug?: string;
+    tasksId?: string;
+    initialPrompt?: string;
+    latestPrompt?: string;
+    agentName?: string;
+    agentRole?: string;
+    lastToolName?: string;
+    lastToolDetail?: string;
+}
+export interface DiscoveredFile {
+    filePath: string;
+    sessionId: string;
+    project: string;
+    projectDir: string;
+    isSubagent: boolean;
+    parentSessionId?: string;
+    agentId?: string;
+}
+export declare function getFileState(filePath: string, stateMap?: Map<string, SessionFileState>): SessionFileState | undefined;
+export declare function getAllFileStates(stateMap?: Map<string, SessionFileState>): Map<string, SessionFileState>;
+export declare function removeFileState(filePath: string, stateMap?: Map<string, SessionFileState>): void;
+/**
+ * Get or bootstrap state for a file. If not in the map, does a cold-start bootstrap.
+ */
+export declare function getOrBootstrap(filePath: string, stateMap?: Map<string, SessionFileState>): SessionFileState | null;
+/**
+ * Cold start: read last 64KB, feed through state machine, set byteOffset = fileSize.
+ */
+export declare function bootstrapFromTail(filePath: string, stateMap?: Map<string, SessionFileState>): SessionFileState | null;
+/**
+ * Main entry: read new bytes from file, feed through state machine, return updated state.
+ * Returns null if no new data.
+ */
+export declare function processFileUpdate(filePath: string, stateMap?: Map<string, SessionFileState>): SessionFileState | null;
+export declare function initializeAllFileStates(claudeHome: string, projectFilter?: string, stateMap?: Map<string, SessionFileState>): Map<string, DiscoveredFile>;
+/**
+ * Discover .jsonl session files under ~/.claude/projects/.
+ * When projectFilter is provided, only scan that single project directory
+ * instead of iterating all directories.
+ */
+export declare function discoverSessionFiles(claudeHome: string, projectFilter?: string): Map<string, DiscoveredFile>;
+/**
+ * Map machine state to SessionActivity for backward compatibility.
+ */
+export declare function toSessionActivity(state: SessionFileState): SessionActivity | null;
+/**
+ * Map machine state to LastEntryType for backward compatibility with deriveSessionStatus.
+ */
+export declare function machineStateToLastEntryType(state: SessionFileState): LastEntryType;
+export {};