ompchamber 0.3.0

package/src/shared/lib/chat/read-sse.ts

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Minimal client-side SSE frame reader for `fetch` responses. Both the chat
+ * mock stream and the filesystem search stream hand-rolled
+ * `response.body.getReader()` + `split('\n\n')` + `event:`/`data:` parsing;
+ * this is the one implementation they share.
+ *
+ * Frame rules follow the SSE spec where the two consumers agreed and take the
+ * more complete behavior where they diverged:
+ * - `event:` defaults to `"message"` when absent.
+ * - Multiple `data:` lines in one frame join with `\n` (neither endpoint emits
+ *   them today, so single-line frames are byte-identical to before).
+ * - Comment lines (`:` prefix) are ignored.
+ * - A trailing frame without a terminating blank line is still delivered.
+ *
+ * Abort is cooperative: a fired `signal` cancels the reader and resolves
+ * normally — callers inspect `signal.aborted` themselves.
+ */
+
+/** Return `true` from a frame handler to stop reading (e.g. a terminal frame). */
+export type SseFrameHandler = (event: string, data: string) => void | boolean;
+
+/** Parse one raw frame block into `{ event, data }`; null for comment/blank frames. */
+function parseFrame(frame: string): { event: string; data: string } | null {
+  const trimmed = frame.trim();
+  if (!trimmed) return null;
+
+  let event = 'message';
+  const dataLines: string[] = [];
+  for (const line of trimmed.split('\n')) {
+    if (line.startsWith(':')) continue;
+    if (line.startsWith('event:')) {
+      event = line.replace(/^event:\s*/, '').trim();
+    } else if (line.startsWith('data:')) {
+      dataLines.push(line.replace(/^data:\s*/, ''));
+    }
+  }
+
+  if (dataLines.length === 0) return null;
+  return { event, data: dataLines.join('\n') };
+}
+
+/** Deliver one frame to the handler; true when the handler asked to stop. */
+function consumeFrame(frame: string, onFrame: SseFrameHandler): boolean {
+  const parsed = parseFrame(frame);
+  if (!parsed) return false;
+  return onFrame(parsed.event, parsed.data) === true;
+}
+
+/**
+ * Read `response.body` as SSE frames, invoking `onFrame(event, data)` for each.
+ * Resolves when the stream ends, the handler stops it, or `signal` aborts.
+ */
+export async function readSseStream(
+  response: Response,
+  onFrame: SseFrameHandler,
+  signal?: AbortSignal,
+): Promise<void> {
+  const reader = response.body?.getReader();
+  if (!reader) return;
+
+  const decoder = new TextDecoder('utf-8');
+  let buffer = '';
+
+  try {
+    for (;;) {
+      if (signal?.aborted) {
+        try {
+          await reader.cancel();
+        } catch {
+          // Reader already released.
+        }
+        return;
+      }
+
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const frames = buffer.split('\n\n');
+      buffer = frames.pop() ?? '';
+      for (const frame of frames) {
+        if (consumeFrame(frame, onFrame)) return;
+      }
+    }
+
+    if (buffer) consumeFrame(buffer, onFrame);
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+      // Already released or cancelled.
+    }
+  }
+}

package/src/shared/lib/chat/stream-service.ts

@@ -0,0 +1,273 @@
+import { getDb } from '@/server/db.server';
+import { GoogleGenAI } from '@google/genai';
+import type { ChatMessageData, ToolCallData } from '@/shared/types';
+
+// Helper to delay execution for realistic stream simulation
+const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export interface StreamSendEvent {
+  (event: string, data: any): void;
+}
+
+// Persists the completed AI message to SQLite
+async function persistAiMessage(sessionId: string, aiMessage: ChatMessageData) {
+  try {
+    const db = await getDb();
+    const existing = await db.get('SELECT * FROM chat_sessions WHERE session_id = ?', [sessionId]);
+    let currentMessages: any[] = [];
+    let title = existing?.title || `Session ${sessionId}`;
+
+    if (existing?.messages) {
+      try {
+        currentMessages = JSON.parse(existing.messages);
+      } catch {
+        currentMessages = [];
+      }
+    }
+
+    const nextMessages = [...currentMessages, aiMessage];
+    await db.run(
+      'INSERT OR REPLACE INTO chat_sessions (session_id, title, messages, updated_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)',
+      [sessionId, title, JSON.stringify(nextMessages)]
+    );
+  } catch (err) {
+    console.error('Failed to persist streamed message:', err);
+  }
+}
+
+// Handler for real Gemini API streaming
+export async function handleGeminiStreaming(options: {
+  apiKey: string;
+  prompt: string;
+  modelName: string;
+  sessionId: string;
+  messageId: string;
+  timeStr: string;
+  sendEvent: StreamSendEvent;
+  isAborted: () => boolean;
+}) {
+  const { apiKey, prompt, sessionId, messageId, timeStr, sendEvent, isAborted } = options;
+  const ai = new GoogleGenAI({
+    apiKey,
+    httpOptions: {
+      headers: {
+        'User-Agent': 'aistudio-build',
+      },
+    },
+  });
+
+  sendEvent('thinking_start', { title: 'Deep Reasoning' });
+  const thoughtText = `Deconstructing prompt: "${prompt}".\nAnalyzing project context, evaluating edge dependencies, and generating validated response.`;
+  
+  // Stream thinking chunk
+  sendEvent('thinking_chunk', { delta: thoughtText });
+  sendEvent('thinking_end', {
+    thought: thoughtText,
+    summary: 'Analyze context and stream response',
+    duration: '0.8s',
+  });
+
+  sendEvent('content_start', {});
+
+  const responseStream = await ai.models.generateContentStream({
+    model: 'gemini-3.8-flash',
+    contents: prompt || 'Hello',
+    config: {
+      systemInstruction: 'You are OMPChamber AI Assistant, integrated with Oh-My-Pi, remisJS, and Bun runtime environments. Provide concise, clean, markdown-formatted responses.',
+    },
+  });
+
+  let fullContent = '';
+  for await (const chunk of responseStream) {
+    if (isAborted()) break;
+    const textChunk = chunk.text || '';
+    if (textChunk) {
+      fullContent += textChunk;
+      sendEvent('content_chunk', { delta: textChunk });
+    }
+  }
+
+  sendEvent('content_end', {});
+
+  const summary = 'Generation completed successfully via Gemini API.';
+  sendEvent('summary', { summary });
+
+  const finalMessage: ChatMessageData = {
+    id: messageId,
+    role: 'ai',
+    date: `Today, ${timeStr}`,
+    timestamp: timeStr,
+    thinking: {
+      duration: '0.8s',
+      thought: thoughtText,
+      summary: 'Analyze context and stream response',
+    },
+    content: fullContent,
+    summary,
+  };
+
+  sendEvent('done', { message: finalMessage });
+  await persistAiMessage(sessionId, finalMessage);
+}
+
+// Handler for domain-aware simulated streaming with tool executions & chunked tokens
+export async function handleSimulatedStreaming(options: {
+  prompt: string;
+  modelName: string;
+  workspaceName: string;
+  sessionId: string;
+  messageId: string;
+  timeStr: string;
+  sendEvent: StreamSendEvent;
+  isAborted: () => boolean;
+}) {
+  const { prompt, workspaceName, sessionId, messageId, timeStr, sendEvent, isAborted } = options;
+
+  // 1. Thinking Phase - Calm and steady pacing
+  sendEvent('thinking_start', { title: 'Thinking' });
+  await delay(300);
+  if (isAborted()) return;
+
+  const thinkingSteps = [
+    `1. Deconstruct user prompt: "${prompt || 'Diagnostic check'}".\n`,
+    `2. Target context: ${workspaceName} with Bun v1.2.4 runtime.\n`,
+    `3. Inspecting active edge routes, module boundaries, and build dependencies.\n`,
+    `4. Executing workspace verification and synthesizing patch.\n`,
+  ];
+
+  let accumulatedThought = '';
+  for (const step of thinkingSteps) {
+    if (isAborted()) return;
+    accumulatedThought += step;
+    sendEvent('thinking_chunk', { delta: step });
+    await delay(350);
+  }
+
+  sendEvent('thinking_end', {
+    thought: accumulatedThought.trim(),
+    summary: 'Deconstruct prompt, execute workspace diagnostics, and formulate implementation patch.',
+    duration: '1.4s',
+  });
+
+  await delay(300);
+  if (isAborted()) return;
+
+  // 2. Tool Execution Phase
+  const readToolId = `tc-${Date.now()}-read`;
+  const readTool: ToolCallData = {
+    id: readToolId,
+    type: 'read_file',
+    title: 'Read File',
+    target: 'examples/index.js',
+    command: 'read_file examples/index.js',
+    status: 'running',
+  };
+
+  sendEvent('tool_start', readTool);
+  await delay(450);
+  if (isAborted()) return;
+
+  const readOutput = `// examples/index.ts\nconst port = Number(Bun.env.PORT) || 3000;\n\nBun.serve({\n  port,\n  fetch() {\n    return Response.json({ status: 'healthy', runtime: 'bun' });\n  },\n});\n\nconsole.log(\`Server running at http://localhost:\${port}/\`);`;
+  
+  sendEvent('tool_output_chunk', { id: readToolId, delta: readOutput });
+  sendEvent('tool_end', {
+    id: readToolId,
+    status: 'success',
+    duration: '18ms',
+    output: readOutput,
+  });
+
+  await delay(350);
+  if (isAborted()) return;
+
+  const bashToolId = `tc-${Date.now()}-bash`;
+  const bashTool: ToolCallData = {
+    id: bashToolId,
+    type: 'bash',
+    title: 'Diagnostic Command',
+    target: 'bun --version && bun pm ls',
+    command: 'bun --version && bun pm ls',
+    status: 'running',
+  };
+
+  sendEvent('tool_start', bashTool);
+  await delay(500);
+  if (isAborted()) return;
+
+  const bashOutput = 'Bun v1.2.4\n├── @remis/edge@1.0.4\n├── lucide-preact@1.47.0\n└── tailwindcss@4.1.14';
+  sendEvent('tool_output_chunk', { id: bashToolId, delta: bashOutput });
+  sendEvent('tool_end', {
+    id: bashToolId,
+    status: 'success',
+    duration: '85ms',
+    output: bashOutput,
+  });
+
+  await delay(400);
+  if (isAborted()) return;
+
+  // 3. Content Streaming Phase - Smooth and natural word-by-word streaming
+  sendEvent('content_start', {});
+
+  const promptSnippet = prompt.length > 50 ? `${prompt.slice(0, 50)}...` : prompt;
+  const contentParagraphs = [
+    `I've processed your request: **"${promptSnippet || 'Workspace diagnostic'}"**.\n\n`,
+    `### Diagnostics & Environment Status\n`,
+    `- **Workspace Target**: \`${workspaceName}\`\n`,
+    `- **Runtime Target**: Bun v1.2.4 with native TypeScript striping\n`,
+    `- **Edge Adapter**: remisJS edge routes & build plugins\n`,
+    `- **Module Integrity**: All 14 workspace modules validated with 0 errors\n\n`,
+    `The runtime environment is healthy and all diagnostics passed successfully. You can inspect the detailed telemetry matrix or execute further chamber commands directly.`,
+  ];
+
+  let fullContent = '';
+  for (const para of contentParagraphs) {
+    if (isAborted()) return;
+    // Break into small token chunks for natural streaming cadence
+    const words = para.split(' ');
+    for (let i = 0; i < words.length; i++) {
+      if (isAborted()) return;
+      const chunk = (i === 0 ? '' : ' ') + words[i];
+      fullContent += chunk;
+      sendEvent('content_chunk', { delta: chunk });
+      await delay(50);
+    }
+  }
+
+  sendEvent('content_end', {});
+
+  // 4. Summary Event
+  const summaryText = 'Execution completed in 1.8s with 0 errors.';
+  sendEvent('summary', { summary: summaryText });
+
+  const finalMessage: ChatMessageData = {
+    id: messageId,
+    role: 'ai',
+    date: `Today, ${timeStr}`,
+    timestamp: timeStr,
+    thinking: {
+      duration: '1.4s',
+      thought: accumulatedThought.trim(),
+      summary: 'Deconstruct prompt, execute workspace diagnostics, and formulate implementation patch.',
+    },
+    toolCalls: [
+      {
+        ...readTool,
+        status: 'success',
+        duration: '18ms',
+        output: readOutput,
+      },
+      {
+        ...bashTool,
+        status: 'success',
+        duration: '85ms',
+        output: bashOutput,
+      },
+    ],
+    content: fullContent,
+    summary: summaryText,
+  };
+
+  sendEvent('done', { message: finalMessage });
+  await persistAiMessage(sessionId, finalMessage);
+}

package/src/shared/lib/chat/task-result-parser.ts

@@ -0,0 +1,166 @@
+export interface TaskResultMeta {
+  lines?: string;
+  size?: string;
+}
+
+export interface TaskResultFileItem {
+  path: string;
+  description?: string;
+}
+
+export interface TaskResultStructuredOutput {
+  summary?: string;
+  files?: TaskResultFileItem[];
+  architecture?: string;
+  report?: string;
+  [key: string]: unknown;
+}
+
+export interface ParsedTaskNotice {
+  intro: string;
+  id?: string;
+  agent?: string;
+  status?: string;
+  duration?: string;
+  meta?: TaskResultMeta;
+  rawOutput: string;
+  formattedJson?: string;
+  structuredOutput?: TaskResultStructuredOutput;
+  outro?: string;
+}
+
+/** Scan a JSON document prefix for bracket balance and string state. */
+function jsonScanState(text: string): { stack: string[]; inString: boolean; escaped: boolean } {
+  const stack: string[] = [];
+  let inString = false;
+  let escaped = false;
+  for (const ch of text) {
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === '\\') escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === '{' || ch === '[') stack.push(ch === '{' ? '}' : ']');
+    else if (ch === '}' || ch === ']') stack.pop();
+  }
+  return { stack, inString, escaped };
+}
+
+/** Best-effort repair for a JSON payload truncated by the preview size limit:
+ *  seal the open string, drop dangling separators/keys, and append the missing
+ *  closing brackets. Returns null when the document cannot be repaired. */
+function healTruncatedJson(text: string): string | null {
+  let healed = text;
+  for (let attempt = 0; attempt < 16; attempt += 1) {
+    const { stack, inString, escaped } = jsonScanState(healed);
+    let candidate = healed;
+    if (inString) {
+      if (escaped) candidate = candidate.slice(0, -1);
+      candidate += '"';
+    }
+    candidate = candidate
+      .replace(/,\s*"[^"]*"\s*:\s*$/, '')
+      .replace(/"[^"]*"\s*:\s*$/, '')
+      .replace(/,\s*$/, '');
+    candidate += [...stack].reverse().join('');
+    candidate = candidate.replace(/,\s*(?=[}\]])/g, '');
+    try {
+      JSON.parse(candidate);
+      return candidate;
+    } catch {
+      const cut = healed.lastIndexOf(',');
+      if (cut <= 0) return null;
+      healed = healed.slice(0, cut);
+    }
+  }
+  return null;
+}
+
+/**
+ * Parses XML-style <task-result> embedded inside system notices.
+ * Handles metadata, <output>...</output>, and <preview full-output="agent://...">...</preview> payloads.
+ * The full-output URI remains inert metadata; preview content is rendered locally.
+ * Truncated preview JSON is healed so the structured view still renders.
+ */
+export function parseTaskNotice(text: string): ParsedTaskNotice | null {
+  if (!text) return null;
+  const match = text.match(/([\s\S]*?)<task-result\b([^>]*)>([\s\S]*?)<\/task-result>([\s\S]*)/i);
+  if (!match) return null;
+
+  const intro = match[1].trim();
+  const attrs = match[2];
+  const innerBody = match[3].trim();
+  const outro = match[4].trim();
+
+  const id = attrs.match(/\bid=["']([^"']+)["']/i)?.[1];
+  const agent = attrs.match(/\bagent=["']([^"']+)["']/i)?.[1];
+  const status = attrs.match(/\bstatus=["']([^"']+)["']/i)?.[1];
+  const duration = attrs.match(/\bduration=["']([^"']+)["']/i)?.[1];
+
+  // Extract <meta ... />
+  let meta: TaskResultMeta | undefined;
+  const metaMatch = innerBody.match(/<meta\b([^>]*)\/?>/i);
+  if (metaMatch) {
+    const metaAttrs = metaMatch[1];
+    const lines = metaAttrs.match(/\blines=["']([^"']+)["']/i)?.[1];
+    const size = metaAttrs.match(/\bsize=["']([^"']+)["']/i)?.[1];
+    if (lines || size) {
+      meta = { lines, size };
+    }
+  }
+
+  let rawOutput = '';
+  const outputMatch = innerBody.match(/<output\b[^>]*>([\s\S]*?)<\/output>/i);
+  if (outputMatch) {
+    rawOutput = outputMatch[1].trim();
+  } else {
+    const previewMatch = innerBody.match(/<preview\b[^>]*>([\s\S]*?)<\/preview>/i);
+    const previewPayload = previewMatch?.[1].trim();
+    if (previewPayload) {
+      rawOutput = previewPayload;
+    } else {
+      rawOutput = innerBody
+        .replace(/<meta\b[^>]*\/?>(?:\s*<\/meta>)?|<\/?preview\b[^>]*>/gi, '')
+        .trim();
+    }
+  }
+
+  // Attempt JSON parsing
+  let structuredOutput: TaskResultStructuredOutput | undefined;
+  let formattedJson: string | undefined;
+
+  if (rawOutput.startsWith('{') || rawOutput.startsWith('[')) {
+    try {
+      const parsed = JSON.parse(rawOutput);
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        structuredOutput = parsed as TaskResultStructuredOutput;
+        formattedJson = JSON.stringify(parsed, null, 2);
+      }
+    } catch {
+      const healed = healTruncatedJson(rawOutput);
+      if (healed) {
+        const parsed: unknown = JSON.parse(healed);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+          structuredOutput = parsed as TaskResultStructuredOutput;
+          formattedJson = JSON.stringify(parsed, null, 2);
+          rawOutput = healed;
+        }
+      }
+    }
+  }
+
+  return {
+    intro: intro || (id ? `Background job ${id} completed` : 'System notice'),
+    id,
+    agent,
+    status,
+    duration,
+    meta,
+    rawOutput,
+    formattedJson,
+    structuredOutput,
+    outro: outro || undefined,
+  };
+}