@geminilight/mindos 0.6.72 → 0.6.73

package/_standalone/lib/acp/types.ts

@@ -0,0 +1,247 @@
+/**
+ * ACP (Agent Client Protocol) — Core Types for MindOS ACP integration.
+ * ACP uses JSON-RPC 2.0 over stdio (subprocess model), not HTTP.
+ * Sessions are stateful with prompt turns, tool calls, and streaming updates.
+ * Reference: https://agentclientprotocol.com
+ */
+
+/* ── Transport ────────────────────────────────────────────────────────── */
+
+/** How an ACP agent is spawned */
+export type AcpTransportType = 'stdio' | 'npx' | 'uvx' | 'binary';
+
+/* ── ContentBlock (ACP prompt format) ─────────────────────────────────── */
+
+export type AcpContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'image'; data: string; mimeType: string }
+  | { type: 'audio'; data: string; mimeType: string }
+  | { type: 'resource_link'; uri: string; name: string }
+  | { type: 'resource'; resource: { uri: string; text?: string; blob?: string } };
+
+/* ── StopReason ───────────────────────────────────────────────────────── */
+
+export type AcpStopReason = 'end_turn' | 'max_tokens' | 'max_turn_requests' | 'refusal' | 'cancelled';
+
+/* ── Modes & Config ───────────────────────────────────────────────────── */
+
+export interface AcpMode {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+export interface AcpConfigOptionEntry {
+  id: string;
+  label: string;
+}
+
+export interface AcpConfigOption {
+  type: 'select';
+  configId: string;
+  category: 'mode' | 'model' | 'thought_level' | 'other' | string;
+  label?: string;
+  currentValue: string;
+  options: AcpConfigOptionEntry[];
+}
+
+/* ── Auth ──────────────────────────────────────────────────────────────── */
+
+export interface AcpAuthMethod {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+/* ── Capabilities ─────────────────────────────────────────────────────── */
+
+/** What the agent declares it supports (from initialize response). */
+export interface AcpAgentCapabilities {
+  loadSession?: boolean;
+  mcpCapabilities?: { http?: boolean; sse?: boolean };
+  promptCapabilities?: { audio?: boolean; embeddedContext?: boolean; image?: boolean };
+  sessionCapabilities?: { list?: boolean };
+}
+
+/** What MindOS declares as a client (sent in initialize request). */
+export interface AcpClientCapabilities {
+  fs?: { readTextFile?: boolean; writeTextFile?: boolean };
+  terminal?: boolean;
+}
+
+/* ── Session ──────────────────────────────────────────────────────────── */
+
+export type AcpSessionState = 'idle' | 'active' | 'error';
+
+export interface AcpSession {
+  id: string;
+  agentId: string;
+  /** Session ID assigned by the agent — used in all JSON-RPC calls to the agent. */
+  agentSessionId?: string;
+  state: AcpSessionState;
+  cwd?: string;
+  createdAt: string;
+  lastActivityAt: string;
+  /** Agent capabilities from initialize response */
+  agentCapabilities?: AcpAgentCapabilities;
+  /** Modes available from session/new or session/load response */
+  modes?: AcpMode[];
+  /** Config options from session/new or session/load response */
+  configOptions?: AcpConfigOption[];
+  /** Auth methods from initialize response */
+  authMethods?: AcpAuthMethod[];
+}
+
+/** Lightweight session info returned by session/list. */
+export interface AcpSessionInfo {
+  sessionId: string;
+  title?: string;
+  cwd?: string;
+  updatedAt?: string;
+}
+
+/* ── Prompt ────────────────────────────────────────────────────────────── */
+
+export interface AcpPromptResponse {
+  sessionId: string;
+  text: string;
+  done: boolean;
+  stopReason?: AcpStopReason;
+  toolCalls?: AcpToolCall[];
+  metadata?: Record<string, unknown>;
+}
+
+/* ── ToolCall (full ACP model) ────────────────────────────────────────── */
+
+export type AcpToolCallKind =
+  | 'read' | 'edit' | 'delete' | 'move' | 'search'
+  | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+
+export type AcpToolCallStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+
+export interface AcpToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+/** Full tool call with status, kind, and content — used in session updates. */
+export interface AcpToolCallFull {
+  toolCallId: string;
+  title?: string;
+  kind?: AcpToolCallKind;
+  status: AcpToolCallStatus;
+  rawInput?: string;
+  rawOutput?: string;
+  content?: AcpContentBlock[];
+  locations?: { path: string; line?: number }[];
+}
+
+export interface AcpToolResult {
+  callId: string;
+  result: string;
+  isError?: boolean;
+}
+
+/* ── Plan ──────────────────────────────────────────────────────────────── */
+
+export type AcpPlanEntryStatus = 'pending' | 'in_progress' | 'completed';
+export type AcpPlanEntryPriority = 'high' | 'medium' | 'low';
+
+export interface AcpPlanEntry {
+  content: string;
+  status: AcpPlanEntryStatus;
+  priority: AcpPlanEntryPriority;
+}
+
+export interface AcpPlan {
+  entries: AcpPlanEntry[];
+}
+
+/* ── Session Updates (streaming) — Full ACP spec ──────────────────────── */
+
+export type AcpUpdateType =
+  | 'user_message_chunk'
+  | 'agent_message_chunk'
+  | 'agent_thought_chunk'
+  | 'tool_call'
+  | 'tool_call_update'
+  | 'plan'
+  | 'available_commands_update'
+  | 'current_mode_update'
+  | 'config_option_update'
+  | 'session_info_update'
+  // Legacy compat (mapped internally)
+  | 'text'
+  | 'tool_result'
+  | 'done'
+  | 'error';
+
+export interface AcpSessionUpdate {
+  sessionId: string;
+  type: AcpUpdateType;
+  /** Text content for message chunk types */
+  text?: string;
+  /** Structured tool call data */
+  toolCall?: AcpToolCallFull;
+  /** Tool result (legacy) */
+  toolResult?: AcpToolResult;
+  /** Plan entries */
+  plan?: AcpPlan;
+  /** Available commands (opaque to client) */
+  availableCommands?: unknown[];
+  /** Current mode ID */
+  currentModeId?: string;
+  /** Updated config options */
+  configOptions?: AcpConfigOption[];
+  /** Session info update */
+  sessionInfo?: { title?: string; updatedAt?: string };
+  /** Error message */
+  error?: string;
+}
+
+/* ── Permission ───────────────────────────────────────────────────────── */
+
+export type AcpPermissionOutcome = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
+
+/* ── Registry ─────────────────────────────────────────────────────────── */
+
+/** An entry from the ACP registry (registry.json) */
+export interface AcpRegistryEntry {
+  id: string;
+  name: string;
+  description: string;
+  version?: string;
+  transport: AcpTransportType;
+  command: string;
+  /** npm package name for npx-based agents (e.g. "@google/gemini-cli") */
+  packageName?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  tags?: string[];
+  homepage?: string;
+}
+
+/** Parsed registry response */
+export interface AcpRegistry {
+  version: string;
+  agents: AcpRegistryEntry[];
+  fetchedAt: string;
+}
+
+/* ── Error Codes ──────────────────────────────────────────────────────── */
+
+export const ACP_ERRORS = {
+  SESSION_NOT_FOUND: { code: -32001, message: 'Session not found' },
+  SESSION_BUSY: { code: -32002, message: 'Session is busy' },
+  AGENT_NOT_FOUND: { code: -32003, message: 'Agent not found in registry' },
+  SPAWN_FAILED: { code: -32004, message: 'Failed to spawn agent process' },
+  TRANSPORT_ERROR: { code: -32005, message: 'Transport error' },
+  AUTH_REQUIRED: { code: -32000, message: 'Authentication required' },
+  RESOURCE_NOT_FOUND: { code: -32006, message: 'Resource not found' },
+  PARSE_ERROR: { code: -32700, message: 'Parse error' },
+  INVALID_REQUEST: { code: -32600, message: 'Invalid request' },
+  METHOD_NOT_FOUND: { code: -32601, message: 'Method not found' },
+  INVALID_PARAMS: { code: -32602, message: 'Invalid params' },
+  INTERNAL_ERROR: { code: -32603, message: 'Internal error' },
+} as const;

package/_standalone/lib/agent/diff-worker.ts

@@ -0,0 +1,51 @@
+/**
+ * Worker thread for async LCS diff computation.
+ * Receives { before, after } messages, returns DiffLine[].
+ * Runs in a separate thread to avoid blocking the agent event loop.
+ */
+import { parentPort } from 'worker_threads';
+
+type DiffLineType = 'equal' | 'insert' | 'delete';
+interface DiffLine { type: DiffLineType; text: string; }
+
+function buildLineDiff(before: string, after: string): DiffLine[] {
+  const oldLines = before.split('\n');
+  const newLines = after.split('\n');
+  const m = oldLines.length;
+  const n = newLines.length;
+  const lcs: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+
+  for (let i = m - 1; i >= 0; i--) {
+    for (let j = n - 1; j >= 0; j--) {
+      lcs[i][j] = oldLines[i] === newLines[j]
+        ? 1 + lcs[i + 1][j + 1]
+        : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+    }
+  }
+
+  const rows: DiffLine[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < m || j < n) {
+    if (i < m && j < n && oldLines[i] === newLines[j]) {
+      rows.push({ type: 'equal', text: oldLines[i] });
+      i++; j++;
+    } else if (j < n && (i >= m || lcs[i][j + 1] >= lcs[i + 1][j])) {
+      rows.push({ type: 'insert', text: newLines[j] });
+      j++;
+    } else {
+      rows.push({ type: 'delete', text: oldLines[i] });
+      i++;
+    }
+  }
+  return rows;
+}
+
+parentPort?.on('message', ({ id, before, after }: { id: number; before: string; after: string }) => {
+  try {
+    const result = buildLineDiff(before, after);
+    parentPort?.postMessage({ id, result, error: null });
+  } catch (err) {
+    parentPort?.postMessage({ id, result: null, error: String(err) });
+  }
+});

package/_standalone/lib/agent/file-context.ts

@@ -0,0 +1,116 @@
+import { getFileContent } from '@/lib/fs';
+
+const MAX_DIR_FILES = 30;
+const MAX_KNOWLEDGE_FILE_SIZE = 20_000;
+
+/**
+ * Load attached and current files into context parts for the system prompt.
+ * Returns the context parts array and a list of file paths that failed to load.
+ * Deduplicates files and logs failures with the given mode label.
+ */
+export function loadAttachedFileContext(
+  attachedFiles: string[] | undefined,
+  currentFile: string | undefined,
+  mode: string,
+): { contextParts: string[]; failedFiles: string[] } {
+  const contextParts: string[] = [];
+  const failedFiles: string[] = [];
+  const seen = new Set<string>();
+
+  if (Array.isArray(attachedFiles) && attachedFiles.length > 0) {
+    for (const filePath of attachedFiles) {
+      if (seen.has(filePath)) continue;
+      seen.add(filePath);
+      try {
+        const content = truncate(getFileContent(filePath));
+        contextParts.push(`## Attached: ${filePath}\n\n${content}`);
+      } catch (err) {
+        console.warn(
+          `[ask] ${mode}: failed to read attached file "${filePath}":`,
+          err instanceof Error ? err.message : err,
+        );
+        failedFiles.push(filePath);
+      }
+    }
+  }
+
+  if (currentFile && !seen.has(currentFile)) {
+    seen.add(currentFile);
+    try {
+      const content = truncate(getFileContent(currentFile));
+      contextParts.push(`## Current file: ${currentFile}\n\n${content}`);
+    } catch (err) {
+      console.warn(
+        `[ask] ${mode}: failed to read currentFile "${currentFile}":`,
+        err instanceof Error ? err.message : err,
+      );
+      failedFiles.push(currentFile);
+    }
+  }
+
+  return { contextParts, failedFiles };
+}
+
+/**
+ * Expand attachedFiles entries: directory paths (trailing /) become individual file paths.
+ */
+export function expandAttachedFiles(raw: string[]): string[] {
+  const result: string[] = [];
+  const allFiles = getAllFilesSync(); // Would call lib/fs.collectAllFiles() in real code
+  for (const entry of raw) {
+    if (entry.endsWith('/')) {
+      const prefix = entry;
+      let count = 0;
+      for (const f of allFiles) {
+        if (f.startsWith(prefix) && ++count <= MAX_DIR_FILES) result.push(f);
+      }
+    } else {
+      result.push(entry);
+    }
+  }
+  return result;
+}
+
+/**
+ * Read a knowledge file with size check and truncation.
+ */
+export function readKnowledgeFile(
+  filePath: string,
+): { ok: boolean; content: string; truncated: boolean; error?: string } {
+  try {
+    const raw = getFileContent(filePath);
+    if (raw.length > MAX_KNOWLEDGE_FILE_SIZE) {
+      return {
+        ok: true,
+        content: truncate(raw),
+        truncated: true,
+      };
+    }
+    return { ok: true, content: raw, truncated: false };
+  } catch (err) {
+    return {
+      ok: false,
+      content: '',
+      truncated: false,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * Truncate content to prevent token overflow.
+ * Max ~100k chars ≈ ~25k tokens.
+ */
+export function truncate(content: string): string {
+  const MAX_FILE_CHARS = 20_000;
+  if (content.length <= MAX_FILE_CHARS) return content;
+  return content.slice(0, MAX_FILE_CHARS) + '\n... (truncated)';
+}
+
+/**
+ * Stub: would import from lib/fs but avoiding circular dependency.
+ * In real usage, import collectAllFiles from @/lib/fs.
+ */
+function getAllFilesSync(): string[] {
+  return [];
+}

package/_standalone/lib/agent/index.ts

@@ -0,0 +1,8 @@
+export { getModelConfig } from './model';
+export { getRequestScopedTools, knowledgeBaseTools, WRITE_TOOLS, truncate } from './tools';
+export { AGENT_SYSTEM_PROMPT } from './prompt';
+export {
+  estimateTokens, estimateStringTokens, getContextLimit, needsCompact,
+  truncateToolOutputs, compactMessages, hardPrune, createTransformContext,
+} from './context';
+export { toAgentMessages } from './to-agent-messages';

package/_standalone/lib/agent/stream-consumer.ts

@@ -0,0 +1,231 @@
+/**
+ * Parse MindOS SSE stream (6 event types) into structured Message parts.
+ *
+ * MindOS SSE format (backend: route.ts):
+ * - text_delta: { type, delta }
+ * - thinking_delta: { type, delta } (Anthropic extended thinking)
+ * - tool_start: { type, toolCallId, toolName, args }
+ * - tool_end: { type, toolCallId, output, isError }
+ * - done: { type, usage? }
+ * - error: { type, message }
+ *
+ * Frontend Message structure:
+ * - role: 'assistant'
+ * - content: concatenated text deltas (for display)
+ * - parts: structured [TextPart | ReasoningPart | ToolCallPart] (for detailed view)
+ */
+import type { Message, MessagePart, ToolCallPart, TextPart, ReasoningPart } from '@/lib/types';
+
+/** Tools that modify files — trigger files-changed notification on completion */
+const FILE_MUTATING_TOOLS = new Set([
+  'write_file', 'create_file', 'batch_create_files',
+  'update_section', 'insert_after_heading', 'delete_file',
+  'rename_file', 'create_space',
+]);
+
+/** Notify the app that files were changed by the AI agent */
+function notifyFilesChanged() {
+  if (typeof window !== 'undefined') {
+    window.dispatchEvent(new Event('mindos:files-changed'));
+  }
+}
+
+export async function consumeUIMessageStream(
+  body: ReadableStream<Uint8Array>,
+  onUpdate: (message: Message) => void,
+  signal?: AbortSignal,
+): Promise<Message> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  // Mutable working copies
+  const parts: MessagePart[] = [];
+  const toolCalls = new Map<string, ToolCallPart>();
+  let currentTextId: string | null = null;
+  let currentReasoningPart: ReasoningPart | null = null;
+
+  const startedAt = Date.now();
+
+  /** Build an immutable Message snapshot from current parts */
+  function buildMessage(): Message {
+    const clonedParts: MessagePart[] = parts.map(p => {
+      if (p.type === 'text') return { type: 'text' as const, text: p.text };
+      if (p.type === 'reasoning') return { type: 'reasoning' as const, text: p.text };
+      // ToolCallPart — shallow copy safe (primitive fields, input is replaced not mutated)
+      return { ...p };
+    });
+    const textContent = clonedParts
+      .filter((p): p is TextPart => p.type === 'text')
+      .map(p => p.text)
+      .join('');
+    return {
+      role: 'assistant',
+      content: textContent,
+      parts: clonedParts,
+      timestamp: startedAt,
+    };
+  }
+
+  /** Get or create the last text part with given ID */
+  function findOrCreateTextPart(id: string): TextPart {
+    if (currentTextId === id) {
+      const last = parts[parts.length - 1];
+      if (last && last.type === 'text') return last;
+    }
+    const part: TextPart = { type: 'text', text: '' };
+    parts.push(part);
+    currentTextId = id;
+    return part;
+  }
+
+  /** Get or create a tool call part */
+  function findOrCreateToolCall(toolCallId: string, toolName?: string): ToolCallPart {
+    let tc = toolCalls.get(toolCallId);
+    if (!tc) {
+      tc = {
+        type: 'tool-call',
+        toolCallId,
+        toolName: toolName ?? 'unknown',
+        input: undefined,
+        state: 'pending',
+      };
+      toolCalls.set(toolCallId, tc);
+      parts.push(tc);
+      currentTextId = null;
+    }
+    return tc;
+  }
+
+  try {
+    while (true) {
+      if (signal?.aborted) break;
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      // Process complete SSE lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? ''; // keep incomplete last line
+
+      let changed = false;
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+
+        // Standard SSE format: "data:{json}"
+        let jsonStr: string | null = null;
+        if (trimmed.startsWith('data:')) {
+          jsonStr = trimmed.slice(5).trim();
+        }
+
+        if (!jsonStr) continue;
+
+        let event: Record<string, unknown>;
+        try {
+          event = JSON.parse(jsonStr);
+        } catch {
+          continue; // skip malformed
+        }
+
+        const type = event.type as string;
+
+        switch (type) {
+          case 'text_delta': {
+            // Regular text from assistant
+            const part = findOrCreateTextPart('text');
+            part.text += (event.delta as string) ?? '';
+            changed = true;
+            break;
+          }
+
+          case 'thinking_delta': {
+            // Extended thinking (Anthropic)
+            if (!currentReasoningPart) {
+              currentReasoningPart = { type: 'reasoning', text: '' };
+              parts.push(currentReasoningPart);
+              currentTextId = null;
+            }
+            currentReasoningPart.text += (event.delta as string) ?? '';
+            changed = true;
+            break;
+          }
+
+          case 'tool_start': {
+            // Beginning of tool execution
+            const toolCallId = event.toolCallId as string;
+            const toolName = event.toolName as string;
+            const tc = findOrCreateToolCall(toolCallId, toolName);
+            tc.input = event.args;
+            tc.state = 'running';
+            changed = true;
+            break;
+          }
+
+          case 'tool_end': {
+            // Tool execution finished
+            const toolCallId = event.toolCallId as string;
+            const tc = toolCalls.get(toolCallId);
+            if (tc) {
+              const output = event.output as string;
+              tc.output = output ?? '';
+              tc.state = (event.isError ? 'error' : 'done');
+              changed = true;
+              // Notify when a file-modifying tool completes successfully
+              if (!event.isError && FILE_MUTATING_TOOLS.has(tc.toolName)) {
+                notifyFilesChanged();
+              }
+            }
+            break;
+          }
+
+          case 'error': {
+            // Stream error
+            const message = event.message as string;
+            parts.push({
+              type: 'text',
+              text: `\n\n**Stream Error:** ${message}`,
+            });
+            currentTextId = null;
+            changed = true;
+            break;
+          }
+
+          case 'done': {
+            // Stream completed cleanly — usage data is optional
+            // No state change needed; just marks end of SSE stream
+            break;
+          }
+
+          default:
+            // Ignore unknown event types
+            break;
+        }
+      }
+
+      // Emit once per reader batch, not per SSE line
+      if (changed) {
+        onUpdate(buildMessage());
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  // Finalize any tool calls still in running/pending state
+  // (stream ended unexpectedly — abort, network error, step limit)
+  let finalized = false;
+  for (const tc of toolCalls.values()) {
+    if (tc.state === 'running' || tc.state === 'pending') {
+      tc.state = 'error';
+      tc.output = tc.output ?? 'Stream ended before tool completed';
+      finalized = true;
+    }
+  }
+  if (finalized) {
+    onUpdate(buildMessage());
+  }
+
+  return buildMessage();
+}