repoburg 1.3.196 → 1.3.197

package/agent-pane/backend/src/routes/threads.ts

@@ -0,0 +1,308 @@
+import type { FastifyInstance } from 'fastify';
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.ts';
+import { getProvider } from '../providers/registry.ts';
+import { broadcast } from '../ws/index.ts';
+import type { Session, Turn, DiscussionThread } from '../db/schema.ts';
+
+/** Raw DB row for turns — token_usage is a JSON string, not parsed; no items field. */
+interface TurnRow extends Omit<Turn, 'token_usage' | 'items'> {
+  token_usage: string | null;
+}
+
+/** Raw DB row for items — data is a JSON string, not parsed. */
+interface ItemRow extends Omit<Turn['items'][number], 'data'> {
+  data: string | null;
+}
+
+export async function registerThreadRoutes(fastify: FastifyInstance): Promise<void> {
+  // POST /api/sessions/:sessionId/threads — create thread + first AI turn
+  fastify.post<{
+    Params: { sessionId: string };
+    Body: {
+      itemId: string;
+      turnId: string;
+      startOffset: number;
+      endOffset: number;
+      selectedText: string;
+      message: string;
+    };
+  }>(
+    '/api/sessions/:sessionId/threads',
+    {
+      schema: {
+        body: {
+          type: 'object',
+          required: ['itemId', 'turnId', 'startOffset', 'endOffset', 'selectedText', 'message'],
+          properties: {
+            itemId: { type: 'string' },
+            turnId: { type: 'string' },
+            startOffset: { type: 'number' },
+            endOffset: { type: 'number' },
+            selectedText: { type: 'string' },
+            message: { type: 'string', minLength: 1 },
+          },
+        },
+      },
+    },
+    async (request, reply) => {
+      const { sessionId } = request.params;
+      const { itemId, turnId, startOffset, endOffset, selectedText, message } = request.body || {};
+
+      const db = getDb();
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId) as Session | undefined;
+      if (!session) {
+        return reply.code(404).send({ error: 'Session not found' });
+      }
+      if (session.is_running) {
+        return reply.code(409).send({ error: 'A turn is already running for this session' });
+      }
+
+      const threadId = uuidv4();
+      const now = new Date().toISOString();
+
+      // 1. Create the discussion thread row
+      db.prepare(
+        `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`,
+      ).run(threadId, sessionId, itemId, turnId, startOffset, endOffset, selectedText, now, now);
+
+      // 1b. Fork the Claude session at the anchor turn so the thread has its own
+      //     isolated conversation — main session context stays unaffected.
+      const provider = getProvider(session.runtime_type);
+      if (provider.forkSession) {
+        try {
+          const anchorTurn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as Turn | undefined;
+          if (anchorTurn) {
+            const forkedSessionId = await provider.forkSession(session, anchorTurn);
+            if (forkedSessionId) {
+              db.prepare('UPDATE discussion_threads SET external_thread_id = ? WHERE id = ?').run(forkedSessionId, threadId);
+            }
+          }
+        } catch (err) {
+          console.error(`[threads] forkSession failed for thread ${threadId}:`, err);
+          // Non-fatal — thread falls back to main session conversation
+        }
+      }
+
+      // 2. Format prompt with quoted text for AI context
+      const formattedPrompt = `[Quoting from your previous response]:\n> ${selectedText}\n\n${message}`;
+
+      // 3. Create the turn row with thread_id
+      const newTurnId = uuidv4();
+      db.prepare(
+        `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, thread_id, created_at, updated_at)
+         VALUES (?, ?, ?, NULL, NULL, NULL, NULL, 'pending', NULL, ?, ?, ?)`,
+      ).run(newTurnId, sessionId, formattedPrompt, threadId, now, now);
+
+      const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get(newTurnId) as Turn;
+
+      // 4. Start the AI turn (fire and forget — events stream via WS)
+      provider
+        .startTurn(session, turn)
+        .catch((err) => {
+          console.error(`[threads] Unhandled error for session ${sessionId}:`, err);
+        });
+
+      // 5. Build the thread response
+      const threadRow = db.prepare('SELECT * FROM discussion_threads WHERE id = ?').get(threadId) as DiscussionThread;
+      const thread: DiscussionThread = {
+        ...threadRow,
+        turns: [{ ...turn, items: [] }],
+      };
+
+      // 6. Broadcast thread creation
+      broadcast('thread:created', { sessionId, thread, turn });
+
+      return { thread, turn };
+    },
+  );
+
+  // POST /api/sessions/:sessionId/threads/:threadId/followup — add follow-up message to thread
+  fastify.post<{
+    Params: { sessionId: string; threadId: string };
+    Body: { message: string };
+  }>(
+    '/api/sessions/:sessionId/threads/:threadId/followup',
+    {
+      schema: {
+        body: {
+          type: 'object',
+          required: ['message'],
+          properties: {
+            message: { type: 'string', minLength: 1 },
+          },
+        },
+      },
+    },
+    async (request, reply) => {
+      const { sessionId, threadId } = request.params;
+      const { message } = request.body || {};
+
+      const db = getDb();
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId) as Session | undefined;
+      if (!session) {
+        return reply.code(404).send({ error: 'Session not found' });
+      }
+      if (session.is_running) {
+        return reply.code(409).send({ error: 'A turn is already running for this session' });
+      }
+
+      const thread = db
+        .prepare('SELECT * FROM discussion_threads WHERE id = ? AND session_id = ?')
+        .get(threadId, sessionId) as DiscussionThread | undefined;
+      if (!thread) {
+        return reply.code(404).send({ error: 'Thread not found' });
+      }
+      if (thread.status !== 'open') {
+        return reply.code(409).send({ error: 'Thread is resolved — reopen it first' });
+      }
+
+      // Create new turn with same thread_id
+      const newTurnId = uuidv4();
+      const now = new Date().toISOString();
+      db.prepare(
+        `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, thread_id, created_at, updated_at)
+         VALUES (?, ?, ?, NULL, NULL, NULL, NULL, 'pending', NULL, ?, ?, ?)`,
+      ).run(newTurnId, sessionId, message, threadId, now, now);
+
+      const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get(newTurnId) as Turn;
+
+      // Start the AI turn
+      getProvider(session.runtime_type)
+        .startTurn(session, turn)
+        .catch((err) => {
+          console.error(`[threads] followup error for session ${sessionId}:`, err);
+        });
+
+      broadcast('thread:followup', { sessionId, threadId, turn });
+
+      return { turn };
+    },
+  );
+
+  // PATCH /api/sessions/:sessionId/threads/:threadId — resolve or reopen
+  fastify.patch<{
+    Params: { sessionId: string; threadId: string };
+    Body: { status: 'resolved' | 'open' };
+  }>(
+    '/api/sessions/:sessionId/threads/:threadId',
+    {
+      schema: {
+        body: {
+          type: 'object',
+          required: ['status'],
+          properties: {
+            status: { type: 'string', enum: ['resolved', 'open'] },
+          },
+        },
+      },
+    },
+    async (request, reply) => {
+      const { sessionId, threadId } = request.params;
+      const { status } = request.body || {};
+
+      const db = getDb();
+      const thread = db
+        .prepare('SELECT * FROM discussion_threads WHERE id = ? AND session_id = ?')
+        .get(threadId, sessionId) as DiscussionThread | undefined;
+      if (!thread) {
+        return reply.code(404).send({ error: 'Thread not found' });
+      }
+
+      const now = new Date().toISOString();
+      const resolvedAt = status === 'resolved' ? now : null;
+      db.prepare(
+        'UPDATE discussion_threads SET status = ?, resolved_at = ?, updated_at = ? WHERE id = ?',
+      ).run(status, resolvedAt, now, threadId);
+
+      broadcast('thread:resolved', { sessionId, threadId, status });
+
+      return { id: threadId, status, resolved_at: resolvedAt };
+    },
+  );
+
+  // DELETE /api/sessions/:sessionId/threads/:threadId — delete thread + its turns + items
+  fastify.delete<{ Params: { sessionId: string; threadId: string } }>(
+    '/api/sessions/:sessionId/threads/:threadId',
+    async (request, reply) => {
+      const { sessionId, threadId } = request.params;
+      const db = getDb();
+
+      const thread = db
+        .prepare('SELECT id FROM discussion_threads WHERE id = ? AND session_id = ?')
+        .get(threadId, sessionId);
+      if (!thread) {
+        return reply.code(404).send({ error: 'Thread not found' });
+      }
+
+      // Clean up the thread's branched session entry (Claude provider)
+      const session = db.prepare('SELECT runtime_type FROM sessions WHERE id = ?').get(sessionId) as { runtime_type: string } | undefined;
+      if (session) {
+        const provider = getProvider(session.runtime_type);
+        provider.clearThreadBranch?.(sessionId, threadId);
+      }
+
+      // Delete items belonging to turns in this thread
+      db.prepare(
+        'DELETE FROM items WHERE turn_id IN (SELECT id FROM turns WHERE thread_id = ?)',
+      ).run(threadId);
+      // Delete turns in this thread
+      db.prepare('DELETE FROM turns WHERE thread_id = ?').run(threadId);
+      // Delete the thread row
+      db.prepare('DELETE FROM discussion_threads WHERE id = ?').run(threadId);
+
+      broadcast('thread:deleted', { sessionId, threadId });
+
+      return { success: true };
+    },
+  );
+
+  // GET /api/sessions/:sessionId/threads — list all threads with their turns
+  fastify.get<{ Params: { sessionId: string } }>('/api/sessions/:sessionId/threads', async (request, reply) => {
+    const { sessionId } = request.params;
+    const db = getDb();
+
+    const session = db.prepare('SELECT id FROM sessions WHERE id = ?').get(sessionId);
+    if (!session) {
+      return reply.code(404).send({ error: 'Session not found' });
+    }
+
+    const threadRows = db
+      .prepare('SELECT * FROM discussion_threads WHERE session_id = ? ORDER BY created_at ASC')
+      .all(sessionId) as DiscussionThread[];
+
+    // Attach turns + items for each thread
+    const result: DiscussionThread[] = [];
+    for (const tr of threadRows) {
+      const turnRows = db
+        .prepare('SELECT * FROM turns WHERE thread_id = ? ORDER BY created_at ASC')
+        .all(tr.id) as TurnRow[];
+
+      const itemRows = db
+        .prepare(
+          'SELECT * FROM items WHERE turn_id IN (SELECT id FROM turns WHERE thread_id = ?) ORDER BY created_at ASC',
+        )
+        .all(tr.id) as ItemRow[];
+
+      const itemsByTurn = new Map<string, Turn['items']>();
+      for (const row of itemRows) {
+        const item = { ...row, data: row.data ? JSON.parse(row.data) : null };
+        const list = itemsByTurn.get(item.turn_id) ?? [];
+        list.push(item);
+        itemsByTurn.set(item.turn_id, list);
+      }
+
+      result.push({
+        ...tr,
+        turns: turnRows.map((row) => ({
+          ...row,
+          token_usage: row.token_usage ? JSON.parse(row.token_usage) : null,
+          items: itemsByTurn.get(row.id) ?? [],
+        })),
+      });
+    }
+
+    return result;
+  });
+}

package/agent-pane/backend/src/routes/turns.ts

@@ -2,11 +2,14 @@ import type { FastifyInstance } from 'fastify';
 import { v4 as uuidv4 } from 'uuid';
 import { getDb } from '../db/index.ts';
 import { getProvider } from '../providers/registry.ts';
-import type { Session, Turn } from '../db/schema.ts';
+import type { Session, Turn, Attachment } from '../db/schema.ts';
 
 export async function registerTurnRoutes(fastify: FastifyInstance): Promise<void> {
   // POST /api/sessions/:id/turns — submit prompt, starts a turn
-  fastify.post<{ Params: { id: string }; Body: { user_prompt: string } }>(
+  fastify.post<{
+    Params: { id: string };
+    Body: { user_prompt: string; attachments?: Attachment[] };
+  }>(
     '/api/sessions/:id/turns',
     {
       schema: {
@@ -15,13 +18,25 @@ export async function registerTurnRoutes(fastify: FastifyInstance): Promise<void
           required: ['user_prompt'],
           properties: {
             user_prompt: { type: 'string', minLength: 1 },
+            attachments: {
+              type: 'array',
+              items: {
+                type: 'object',
+                required: ['name', 'media_type', 'data'],
+                properties: {
+                  name: { type: 'string' },
+                  media_type: { type: 'string' },
+                  data: { type: 'string' },
+                },
+              },
+            },
           },
         },
       },
     },
     async (request, reply) => {
       const { id } = request.params;
-      const { user_prompt } = request.body || {};
+      const { user_prompt, attachments } = request.body || {};
 
       if (!user_prompt || !user_prompt.trim()) {
         return reply.code(400).send({ error: 'user_prompt is required' });
@@ -37,24 +52,32 @@ export async function registerTurnRoutes(fastify: FastifyInstance): Promise<void
         return reply.code(409).send({ error: 'A turn is already running for this session' });
       }
 
-      // Create turn in DB
+      // Create turn in DB — store attachments as JSON if provided
       const turnId = uuidv4();
       const now = new Date().toISOString();
+      const attachmentsJson = attachments && attachments.length > 0 ? JSON.stringify(attachments) : null;
       db.prepare(
-        `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
-         VALUES (?, ?, ?, NULL, NULL, NULL, NULL, 'pending', NULL, ?, ?)`,
-      ).run(turnId, id, user_prompt, now, now);
+        `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, attachments, created_at, updated_at)
+         VALUES (?, ?, ?, NULL, NULL, NULL, NULL, 'pending', NULL, ?, ?, ?)`,
+      ).run(turnId, id, user_prompt, attachmentsJson, now, now);
 
       const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as Turn;
 
+      // Parse attachments from JSON string (DB stores as TEXT) before returning to frontend
+      const rawTurn = turn as Turn & { attachments: string | null };
+      const parsedTurn: Turn = {
+        ...turn,
+        attachments: rawTurn.attachments ? (JSON.parse(rawTurn.attachments) as Attachment[]) : null,
+      };
+
       // Fire and forget — events stream via WebSocket
       getProvider(session.runtime_type)
-        .startTurn(session, turn)
+        .startTurn(session, rawTurn)
         .catch((err) => {
           console.error(`[provider] Unhandled error for session ${id}:`, err);
         });
 
-      return turn;
+      return parsedTurn;
     },
   );