tarsk 0.2.5 → 0.3.0

package/dist/routes/chat.js

@@ -0,0 +1,217 @@
+/**
+ * Chat routes for the REST API
+ *
+ * Handles chat message processing:
+ * - POST /api/chat - Send a message to the agent
+ */
+import { Hono } from 'hono';
+import { delay } from '../utils.js';
+import { streamAsyncGenerator } from '../lib/stream-helper.js';
+import { ResponseBuilder } from '../lib/response-builder.js';
+/**
+ * Creates chat routes
+ * @param threadManager - The ThreadManager instance
+ * @param neovateExecutor - The NeovateExecutor instance
+ * @param conversationManager - The ConversationManager instance
+ * @param processingStateManager - The ProcessingStateManager instance
+ * @returns Hono router with chat routes
+ */
+export function createChatRoutes(threadManager, neovateExecutor, conversationManager, processingStateManager) {
+    const router = new Hono();
+    /**
+     * POST /api/chat
+     * Send a message to the agent
+     *
+     * Request body:
+     * {
+     *   "threadId": "uuid",
+     *   "message": "User message content",
+     *   "model": "model-name",
+     *   "attachments": [
+     *     {
+     *       "name": "file.txt",
+     *       "content": "base64-encoded-content",
+     *       "size": 1024,
+     *       "mimeType": "text/plain"
+     *     }
+     *   ]
+     * }
+     *
+     * Response: Newline-delimited JSON stream of NeovateEvent objects
+     *
+     * Requirements:
+     * - 6.4 - THE CLI SHALL expose REST API endpoints for chat message processing
+     * - 8.5 - WHEN sending a chat message, THE App SHALL send a POST request with the message content and Selected_Thread context to the CLI
+     * - 5.4 - WHEN the Neovate command executes, THE CLI SHALL stream the output back to the App
+     */
+    router.post('/', async (c) => {
+        try {
+            const body = await c.req.json();
+            const { threadId, content, model: baseModel, provider, attachments, planMode } = body;
+            // Prepend provider name (lowercased) to the model if provider is provided
+            let model = baseModel;
+            if (provider && typeof provider === 'string') {
+                const providerPrefix = provider.toLowerCase();
+                // Only prepend if the model doesn't already start with this provider prefix
+                if (!model.startsWith(providerPrefix + '/')) {
+                    model = `${providerPrefix}/${model}`;
+                }
+            }
+            // Validate required fields
+            if (!threadId || typeof threadId !== 'string') {
+                const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'threadId is required and must be a string', 400);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return c.json(response, statusCode);
+            }
+            if (!content || typeof content !== 'string') {
+                const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'content is required and must be a string', 400);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return c.json(response, statusCode);
+            }
+            if (!model || typeof model !== 'string') {
+                const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'model is required and must be a string', 400);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return c.json(response, statusCode);
+            }
+            // Get thread metadata to build execution context
+            const thread = await threadManager.getThread(threadId);
+            if (!thread) {
+                const { response, statusCode } = ResponseBuilder.error('THREAD_NOT_FOUND', `Thread not found: ${threadId}`, 404);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return c.json(response, statusCode);
+            }
+            // Capture thread path for use in generators
+            const threadPath = thread.path;
+            // Check if this is a replay request
+            if (content.trim().toLowerCase() === 'replay') {
+                console.log('[ChatRoute] Replay request detected');
+                // Get the last message from conversation history
+                const lastMessages = await conversationManager.getLastMessages(threadPath, 1);
+                if (lastMessages.length === 0) {
+                    const { response, statusCode } = ResponseBuilder.error('NO_HISTORY', 'No previous conversation found to replay', 404);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    return c.json(response, statusCode);
+                }
+                const lastMessage = lastMessages[0];
+                // Check if message has a completed response
+                if (!lastMessage.response) {
+                    const { response, statusCode } = ResponseBuilder.error('NO_RESPONSE', 'Previous message has no completed response to replay', 404);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    return c.json(response, statusCode);
+                }
+                console.log('[ChatRoute] Replaying message:', {
+                    messageId: lastMessage.id,
+                    timestamp: lastMessage.timestamp,
+                    eventCount: lastMessage.response.events.length,
+                });
+                // Extract response to ensure TypeScript narrowing
+                const response = lastMessage.response;
+                // Create a generator for replay events
+                async function* replayGenerator() {
+                    // First, send a replay indicator event
+                    const replayEvent = {
+                        type: 'message',
+                        role: 'system',
+                        content: `🔄 Replaying previous conversation from ${lastMessage.timestamp}`
+                    };
+                    await delay(1000);
+                    yield replayEvent;
+                    // Then stream all the captured events
+                    for (const event of response.events) {
+                        console.log('[ChatRoute] Replaying event:', event);
+                        await delay(1000);
+                        yield event;
+                    }
+                    // Finally, send a completion indicator
+                    const completeEvent = {
+                        type: 'message',
+                        role: 'system',
+                        content: '✅ Replay complete'
+                    };
+                    await delay(1000);
+                    yield completeEvent;
+                }
+                return streamAsyncGenerator(c, replayGenerator());
+            }
+            // Normal chat flow - capture and execute
+            // Build execution context
+            const context = {
+                threadId,
+                threadPath,
+                model,
+                provider,
+                attachments,
+                planMode,
+            };
+            console.log('[ChatRoute] Execution context:', {
+                threadId,
+                threadPath,
+                model,
+                planMode,
+                attachmentCount: attachments?.length || 0,
+            });
+            // Start capturing the conversation
+            const messageId = await conversationManager.startMessage(threadId, threadPath, content, model, attachments, planMode);
+            // Mark thread as processing
+            processingStateManager.setProcessing(threadId);
+            // Create a generator for chat execution events
+            async function* chatExecutionGenerator() {
+                const capturedEvents = [];
+                let fullContent = '';
+                try {
+                    for await (const event of neovateExecutor.execute(content, context)) {
+                        // Capture the event
+                        capturedEvents.push(event);
+                        // Accumulate content from message events
+                        if (event.type === 'message' && event.content) {
+                            fullContent += event.content;
+                        }
+                        // Yield the event for streaming
+                        yield event;
+                    }
+                    // Complete the conversation message with captured data
+                    await conversationManager.completeMessage(threadPath, messageId, fullContent, capturedEvents);
+                    console.log('[ChatRoute] Conversation captured:', {
+                        messageId,
+                        eventCount: capturedEvents.length,
+                        contentLength: fullContent.length,
+                    });
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const errorEvent = {
+                        type: 'error',
+                        content: errorMessage,
+                        error: {
+                            code: 'STREAM_ERROR',
+                            message: errorMessage,
+                            details: error instanceof Error ? { stack: error.stack } : undefined
+                        }
+                    };
+                    // Capture the error event too
+                    capturedEvents.push(errorEvent);
+                    yield errorEvent;
+                    // Try to save the partial conversation even on error
+                    try {
+                        await conversationManager.completeMessage(threadPath, messageId, fullContent, capturedEvents);
+                    }
+                    catch (saveError) {
+                        console.error('[ChatRoute] Failed to save partial conversation:', saveError);
+                    }
+                }
+                finally {
+                    // Clear processing state when done
+                    processingStateManager.clearProcessing(threadId);
+                }
+            }
+            return streamAsyncGenerator(c, chatExecutionGenerator());
+        }
+        catch (error) {
+            const { response, statusCode } = ResponseBuilder.error('REQUEST_PARSE_ERROR', 'Failed to parse request body', 400, error instanceof Error ? error.message : String(error));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return c.json(response, statusCode);
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=chat.js.map

package/dist/routes/git.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import { MetadataManager } from '../managers/metadata-manager.js';
+export declare function createGitRoutes(metadataManager: MetadataManager): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=git.d.ts.map