@redplanethq/corebrain 2.6.2 → 2.6.4

package/dist/server/tools/coding-tools.js

@@ -1,127 +1,149 @@
 import zod from 'zod';
 import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
-import { getSession, updateSession, listSessions, createSession, closeSession as closeStoredSession, } from '../../utils/coding-sessions.js';
+import { getPreferences } from '../../config/preferences.js';
+import { getSession, upsertSession, deleteSession, listRunningSessions, } from '../../utils/coding-sessions.js';
 import { getAgentConfig, buildStartArgs, buildResumeArgs, startAgentProcess, isProcessRunning, stopProcess, } from '../../utils/coding-runner.js';
-import { readAgentSessionOutput, agentSessionExists, getAgentReader } from '../../utils/coding-agents/index.js';
-// ============ Zod Schemas ============
-export const StartSessionSchema = zod.object({
-    agent: zod.string(),
+import { readAgentSessionOutput, agentSessionExists, getAgentReader, scanAllSessions, searchSessions } from '../../utils/coding-agents/index.js';
+// ============ Schemas ============
+const AskSchema = zod.object({
+    agent: zod.string().optional(),
     prompt: zod.string(),
     dir: zod.string(),
+    sessionId: zod.string().optional(),
     model: zod.string().optional(),
     systemPrompt: zod.string().optional(),
 });
-export const ResumeSessionSchema = zod.object({
-    sessionId: zod.string(),
-    prompt: zod.string(),
-});
-export const CloseSessionSchema = zod.object({
+const CloseSessionSchema = zod.object({
     sessionId: zod.string(),
 });
-export const ReadSessionSchema = zod.object({
+const ReadSessionSchema = zod.object({
     sessionId: zod.string(),
+    dir: zod.string(),
     lines: zod.number().optional(),
     offset: zod.number().optional(),
     tail: zod.boolean().optional(),
 });
-export const ListSessionsSchema = zod.object({});
+const ListSessionsSchema = zod.object({
+    agent: zod.string().optional(), // e.g. "claude-code" or "codex-cli"
+    since: zod.string().optional(), // ISO date string e.g. "2024-01-01"
+    dir: zod.string().optional(),
+    limit: zod.number().optional(),
+    offset: zod.number().optional(),
+});
+const SearchSessionsSchema = zod.object({
+    query: zod.string(),
+    dir: zod.string().optional(),
+    limit: zod.number().optional(),
+});
 // ============ JSON Schemas ============
 const jsonSchemas = {
-    coding_start_session: {
+    coding_ask: {
         type: 'object',
         properties: {
             agent: {
                 type: 'string',
-                description: 'Coding agent to use (e.g., "claude-code")',
+                description: 'Coding agent to use (e.g., "claude-code", "codex-cli"). Omit to use the configured default.',
             },
             prompt: {
                 type: 'string',
-                description: 'The task/prompt to send to the agent',
+                description: 'The question or task to send to the agent',
             },
             dir: {
                 type: 'string',
                 description: 'Working directory for the session (must exist)',
             },
+            sessionId: {
+                type: 'string',
+                description: 'Existing session ID to continue. Omit to start a new session.',
+            },
             model: {
                 type: 'string',
-                description: 'Model to use (optional)',
+                description: 'Model override (optional)',
             },
             systemPrompt: {
                 type: 'string',
-                description: 'System prompt (optional)',
+                description: 'System prompt override (optional, new sessions only)',
             },
         },
         required: ['agent', 'prompt', 'dir'],
     },
-    coding_resume_session: {
+    coding_close_session: {
         type: 'object',
         properties: {
-            sessionId: {
-                type: 'string',
-                description: 'Session ID to resume',
-            },
-            prompt: {
-                type: 'string',
-                description: 'The prompt to send to continue the session',
-            },
+            sessionId: { type: 'string', description: 'Session ID to close' },
         },
-        required: ['sessionId', 'prompt'],
+        required: ['sessionId'],
     },
-    coding_close_session: {
+    coding_read_session: {
         type: 'object',
         properties: {
-            sessionId: {
-                type: 'string',
-                description: 'Session ID to close',
+            sessionId: { type: 'string', description: 'Session ID to read output from' },
+            dir: { type: 'string', description: 'Working directory of the session' },
+            lines: { type: 'number', description: 'Number of lines to return' },
+            offset: { type: 'number', description: 'Line offset to start from (0-indexed)' },
+            tail: {
+                type: 'boolean',
+                description: 'If true, return the last N lines instead of first N',
             },
         },
-        required: ['sessionId'],
+        required: ['sessionId', 'dir'],
     },
-    coding_read_session: {
+    coding_list_sessions: {
         type: 'object',
         properties: {
-            sessionId: {
+            agent: {
                 type: 'string',
-                description: 'Session ID to read output from',
+                description: 'Filter to a specific agent (e.g. "claude-code", "codex-cli")',
             },
-            lines: {
+            since: {
+                type: 'string',
+                description: 'ISO date string to filter sessions updated after this date (e.g. "2024-03-01")',
+            },
+            dir: {
+                type: 'string',
+                description: 'Filter to a specific working directory (optional)',
+            },
+            limit: {
                 type: 'number',
-                description: 'Number of lines to return (default: all)',
+                description: 'Max sessions to return per page (default: 20)',
             },
             offset: {
                 type: 'number',
-                description: 'Line offset to start reading from (0-indexed, default: 0)',
-            },
-            tail: {
-                type: 'boolean',
-                description: 'If true, return the last N lines instead of first N (default: false)',
+                description: 'Sessions to skip for pagination (default: 0)',
             },
         },
-        required: ['sessionId'],
+        required: [],
     },
-    coding_list_sessions: {
+    coding_search_sessions: {
         type: 'object',
-        properties: {},
-        required: [],
-        description: 'List all coding sessions',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Search term to match against session titles',
+            },
+            dir: {
+                type: 'string',
+                description: 'Restrict search to a specific working directory (optional)',
+            },
+            limit: {
+                type: 'number',
+                description: 'Max results to return (default: 10)',
+            },
+        },
+        required: ['query'],
     },
 };
 // ============ Tool Definitions ============
 export const codingTools = [
     {
-        name: 'coding_start_session',
-        description: 'Start a new coding session with the specified agent (runs in background). After starting, the first coding_read_session call may return status="initializing" — this is normal while the agent boots. Wait a few seconds and retry before concluding failure.',
-        inputSchema: jsonSchemas.coding_start_session,
-    },
-    {
-        name: 'coding_resume_session',
-        description: 'Resume an existing coding session',
-        inputSchema: jsonSchemas.coding_resume_session,
+        name: 'coding_ask',
+        description: 'Send a prompt to a coding agent. Omit sessionId to start a new session; include it to continue an existing one. After calling, use coding_read_session to check output.',
+        inputSchema: jsonSchemas.coding_ask,
     },
     {
         name: 'coding_close_session',
-        description: 'Close/stop a coding session',
+        description: 'Stop a running coding session',
         inputSchema: jsonSchemas.coding_close_session,
     },
     {
@@ -131,79 +153,126 @@ export const codingTools = [
     },
     {
         name: 'coding_list_sessions',
-        description: 'List all coding sessions',
+        description: 'List all coding sessions from Claude\'s session history. Sorted by most recent. Supports date filtering.',
         inputSchema: jsonSchemas.coding_list_sessions,
     },
+    {
+        name: 'coding_search_sessions',
+        description: 'Search past coding sessions by title or first message content',
+        inputSchema: jsonSchemas.coding_search_sessions,
+    },
 ];
-// ============ Tool Handlers ============
-async function handleStartSession(params, logger) {
-    // Check if directory exists
+// ============ Helpers ============
+/**
+ * Resolve which agent to use.
+ * Priority: explicit param → defaultCodingAgent pref → only configured agent → error
+ */
+function resolveAgent(agentParam) {
+    if (agentParam)
+        return { agent: agentParam };
+    const prefs = getPreferences();
+    const coding = (prefs.coding ?? {});
+    const configured = Object.keys(coding);
+    if (configured.length === 0) {
+        return { error: 'No coding agents configured. Run: corebrain coding setup' };
+    }
+    if (prefs.defaultCodingAgent && coding[prefs.defaultCodingAgent]) {
+        return { agent: prefs.defaultCodingAgent };
+    }
+    if (configured.length === 1) {
+        return { agent: configured[0] };
+    }
+    return {
+        error: `Multiple agents configured (${configured.join(', ')}). Specify which to use or set a default with: corebrain coding setup`,
+    };
+}
+/**
+ * Auto-detect the agent for a session ID by trying all registered readers.
+ * Falls back to default agent or claude-code.
+ */
+function detectAgentForSession(sessionId, dir) {
+    // Check running session store first
+    const stored = getSession(sessionId);
+    if (stored?.agent)
+        return stored.agent;
+    // Try each reader's sessionExists
+    const readers = ['claude-code', 'codex-cli'];
+    for (const agentName of readers) {
+        const reader = getAgentReader(agentName);
+        if (reader?.sessionExists(dir, sessionId))
+            return agentName;
+    }
+    // Fall back to default
+    const prefs = getPreferences();
+    return prefs.defaultCodingAgent ?? 'claude-code';
+}
+// ============ Handlers ============
+async function handleAsk(params, logger) {
     if (!existsSync(params.dir)) {
+        return { success: false, error: `Directory "${params.dir}" does not exist` };
+    }
+    const resolved = resolveAgent(params.agent);
+    if ('error' in resolved)
+        return { success: false, error: resolved.error };
+    const agentName = resolved.agent;
+    const config = getAgentConfig(agentName);
+    if (!config) {
         return {
             success: false,
-            error: `Directory "${params.dir}" does not exist`,
+            error: `Agent "${agentName}" not configured. Run 'corebrain coding config --agent ${agentName}' to set up.`,
         };
     }
-    // Get agent config
-    const config = getAgentConfig(params.agent);
-    if (!config) {
+    const isResume = Boolean(params.sessionId);
+    const sessionId = params.sessionId ?? randomUUID();
+    // For resume, verify process is not already running
+    if (isResume && isProcessRunning(sessionId)) {
         return {
             success: false,
-            error: `Agent "${params.agent}" not configured. Run 'corebrain coding config --agent ${params.agent}' to set up.`,
+            error: `Session "${sessionId}" is already running. Wait for it to finish before sending another prompt.`,
         };
     }
-    // Generate session ID and create session
-    const sessionId = randomUUID();
-    const session = createSession({
+    // Build args
+    const args = isResume
+        ? buildResumeArgs(config, { prompt: params.prompt, sessionId })
+        : buildStartArgs(config, {
+            prompt: params.prompt,
+            sessionId,
+            model: params.model,
+            systemPrompt: params.systemPrompt,
+        });
+    // Upsert running session record
+    upsertSession({
         sessionId,
-        agent: params.agent,
-        prompt: params.prompt,
+        agent: agentName,
         dir: params.dir,
+        startedAt: Date.now(),
     });
-    updateSession(session);
-    // Build command args
-    const args = buildStartArgs(config, {
-        prompt: params.prompt,
-        sessionId,
-        model: params.model,
-        systemPrompt: params.systemPrompt,
-    });
-    // Start process in background
     const { pid, error } = startAgentProcess(sessionId, config, args, params.dir, logger);
     if (error) {
-        return {
-            success: false,
-            error: `Failed to start session: ${error}`,
-        };
+        deleteSession(sessionId);
+        return { success: false, error: `Failed to start: ${error}` };
     }
-    // If this agent has a session reader, wait until the session file appears
-    // before returning — this prevents callers from seeing a false "not started" state.
-    const hasReader = getAgentReader(params.agent) !== null;
-    if (hasReader) {
-        const POLL_INTERVAL_MS = 500;
-        const STARTUP_TIMEOUT_MS = 30_000;
-        const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+    // Store pid
+    upsertSession({ sessionId, agent: agentName, dir: params.dir, pid, startedAt: Date.now() });
+    // For agents with a session reader, wait until the session file appears
+    const hasReader = getAgentReader(agentName) !== null;
+    if (hasReader && !isResume) {
+        const deadline = Date.now() + 30_000;
         const sessionReady = await new Promise((resolve) => {
             function check() {
-                if (agentSessionExists(params.agent, params.dir, sessionId)) {
+                if (agentSessionExists(agentName, params.dir, sessionId))
                     return resolve(true);
-                }
-                if (!isProcessRunning(sessionId)) {
+                if (!isProcessRunning(sessionId))
                     return resolve(false);
-                }
-                if (Date.now() >= deadline) {
+                if (Date.now() >= deadline)
                     return resolve(false);
-                }
-                setTimeout(check, POLL_INTERVAL_MS);
+                setTimeout(check, 500);
             }
-            setTimeout(check, POLL_INTERVAL_MS);
+            setTimeout(check, 500);
         });
         if (!sessionReady) {
             stopProcess(sessionId);
-            session.status = 'error';
-            session.error = 'Session failed to start within 30 seconds';
-            session.updatedAt = Date.now();
-            updateSession(session);
+            deleteSession(sessionId);
             return {
                 success: false,
                 error: 'Session failed to start: agent did not produce output within 30 seconds',
@@ -215,142 +284,51 @@ async function handleStartSession(params, logger) {
         result: {
             sessionId,
             pid,
-            status: 'running',
-            message: 'Session started. Use coding_read_session to check output.',
-        },
-    };
-}
-async function handleResumeSession(params, logger) {
-    // Get existing session
-    const session = getSession(params.sessionId);
-    if (!session) {
-        return {
-            success: false,
-            error: `Session "${params.sessionId}" not found`,
-        };
-    }
-    // Check if already running
-    if (isProcessRunning(params.sessionId)) {
-        return {
-            success: false,
-            error: `Session "${params.sessionId}" is already running`,
-        };
-    }
-    // Check if directory still exists
-    if (!existsSync(session.dir)) {
-        return {
-            success: false,
-            error: `Session directory "${session.dir}" no longer exists`,
-        };
-    }
-    // Get agent config
-    const config = getAgentConfig(session.agent);
-    if (!config) {
-        return {
-            success: false,
-            error: `Agent "${session.agent}" not configured`,
-        };
-    }
-    // Update session status
-    session.status = 'running';
-    session.prompt = params.prompt;
-    session.updatedAt = Date.now();
-    updateSession(session);
-    // Build resume args
-    const args = buildResumeArgs(config, {
-        prompt: params.prompt,
-        sessionId: params.sessionId,
-    });
-    // Start process in background
-    const { pid, error } = startAgentProcess(params.sessionId, config, args, session.dir, logger);
-    if (error) {
-        return {
-            success: false,
-            error: `Failed to resume session: ${error}`,
-        };
-    }
-    return {
-        success: true,
-        result: {
-            sessionId: params.sessionId,
-            pid,
-            status: 'running',
-            message: 'Session resumed. Use coding_read_session to check output.',
+            resumed: isResume,
+            message: 'Use coding_read_session to check output.',
         },
     };
 }
 function handleCloseSession(params) {
-    const session = getSession(params.sessionId);
-    if (!session) {
-        return {
-            success: false,
-            error: `Session "${params.sessionId}" not found`,
-        };
-    }
-    // Stop the process if running (this triggers auto-save in runner)
-    const wasRunning = stopProcess(params.sessionId);
-    // Mark as closed in sessions.json
-    closeStoredSession(params.sessionId);
-    return {
-        success: true,
-        result: {
-            sessionId: params.sessionId,
-            wasRunning,
-            message: 'Session closed',
-        },
-    };
+    stopProcess(params.sessionId);
+    deleteSession(params.sessionId);
+    return { success: true, result: { sessionId: params.sessionId, message: 'Session closed' } };
 }
 async function handleReadSession(params) {
-    // First check stored session exists
-    const session = getSession(params.sessionId);
-    if (!session) {
-        return {
-            success: false,
-            error: `Session "${params.sessionId}" not found`,
-        };
-    }
-    // Check if process is still running
     const running = isProcessRunning(params.sessionId);
-    // Read from agent's session file using the appropriate reader
-    const { entries, totalLines, returnedLines, fileExists, fileSizeBytes, fileSizeHuman, error: readError, } = await readAgentSessionOutput(session.agent, session.dir, params.sessionId, {
+    // Detect agent: running store → reader probe → default
+    const agent = detectAgentForSession(params.sessionId, params.dir);
+    const { entries, totalLines, returnedLines, fileExists, fileSizeBytes, fileSizeHuman, error: readError, } = await readAgentSessionOutput(agent, params.dir, params.sessionId, {
         lines: params.lines,
         offset: params.offset,
         tail: params.tail,
     });
-    // Determine status
-    let status = session.status;
+    let status;
     let statusMessage;
     if (running && !fileExists) {
-        // Process is alive but hasn't written its session file yet — still booting
         status = 'initializing';
-        statusMessage =
-            'Session is starting up. The agent has not written output yet. Wait a few seconds and read again.';
+        statusMessage = 'Agent is booting. Wait a few seconds and read again.';
     }
     else if (running) {
         status = 'running';
     }
-    else if (fileExists && status === 'running') {
-        // Process finished, update status
+    else {
+        // Process finished — clean up running session record
+        const stored = getSession(params.sessionId);
+        if (stored)
+            deleteSession(params.sessionId);
         status = 'completed';
-        session.status = 'completed';
-        session.updatedAt = Date.now();
-        updateSession(session);
     }
     return {
         success: true,
         result: {
-            sessionId: session.sessionId,
-            agent: session.agent,
-            prompt: session.prompt,
-            dir: session.dir,
+            sessionId: params.sessionId,
+            dir: params.dir,
             status,
             ...(statusMessage ? { statusMessage } : {}),
             running,
             entries,
-            error: readError || session.error,
-            exitCode: null,
-            startedAt: session.startedAt,
-            updatedAt: session.updatedAt,
+            error: readError,
             totalLines,
             returnedLines,
             fileExists,
@@ -359,43 +337,69 @@ async function handleReadSession(params) {
         },
     };
 }
-function handleListSessions() {
-    const sessions = listSessions();
+async function handleListSessions(params) {
+    const since = params.since ? new Date(params.since).getTime() : undefined;
+    const { sessions, total, hasMore } = await scanAllSessions({
+        agent: params.agent,
+        dir: params.dir,
+        since,
+        limit: params.limit ?? 20,
+        offset: params.offset ?? 0,
+    });
+    const runningIds = new Set(listRunningSessions().map((s) => s.sessionId));
+    return {
+        success: true,
+        result: {
+            sessions: sessions.map((s) => ({
+                sessionId: s.sessionId,
+                agent: s.agent,
+                dir: s.dir,
+                title: s.title,
+                running: runningIds.has(s.sessionId),
+                createdAt: new Date(s.createdAt).toISOString(),
+                updatedAt: new Date(s.updatedAt).toISOString(),
+                fileSizeBytes: s.fileSizeBytes,
+            })),
+            total,
+            hasMore,
+            offset: params.offset ?? 0,
+        },
+    };
+}
+async function handleSearchSessions(params) {
+    const sessions = await searchSessions(params.query, {
+        dir: params.dir,
+        limit: params.limit ?? 10,
+    });
+    const runningIds = new Set(listRunningSessions().map((s) => s.sessionId));
     return {
         success: true,
         result: {
-            sessions: sessions.map(s => {
-                // Check if process is still running
-                const running = isProcessRunning(s.sessionId);
-                return {
-                    sessionId: s.sessionId,
-                    agent: s.agent,
-                    dir: s.dir,
-                    status: running ? 'running' : s.status,
-                    running,
-                    startedAt: s.startedAt,
-                    updatedAt: s.updatedAt,
-                };
-            }),
+            sessions: sessions.map((s) => ({
+                sessionId: s.sessionId,
+                dir: s.dir,
+                title: s.title,
+                running: runningIds.has(s.sessionId),
+                updatedAt: new Date(s.updatedAt).toISOString(),
+            })),
             count: sessions.length,
         },
     };
 }
-// ============ Tool Execution ============
+// ============ Dispatch ============
 export async function executeCodingTool(toolName, params, logger) {
     try {
         switch (toolName) {
-            case 'coding_start_session':
-                return await handleStartSession(StartSessionSchema.parse(params), logger);
-            case 'coding_resume_session':
-                return await handleResumeSession(ResumeSessionSchema.parse(params), logger);
+            case 'coding_ask':
+                return await handleAsk(AskSchema.parse(params), logger);
             case 'coding_close_session':
                 return handleCloseSession(CloseSessionSchema.parse(params));
             case 'coding_read_session':
                 return await handleReadSession(ReadSessionSchema.parse(params));
             case 'coding_list_sessions':
-                ListSessionsSchema.parse(params);
-                return handleListSessions();
+                return await handleListSessions(ListSessionsSchema.parse(params));
+            case 'coding_search_sessions':
+                return await handleSearchSessions(SearchSessionsSchema.parse(params));
             default:
                 return { success: false, error: `Unknown tool: ${toolName}` };
         }