memorix 1.2.2 → 1.2.3

package/src/orchestrate/adapters/gemini-stream.ts

@@ -1,166 +1,166 @@
-/**
- * Gemini CLI stream-json parser.
- *
- * Parses NDJSON from `gemini --output-format stream-json`
- * into AgentMessage events.
- *
- * Event types (from real gemini-cli 0.37.1 output):
- *   - "init"        → session_id, model
- *   - "message"     → role=user|assistant, content
- *   - "tool_use"    → tool call requests
- *   - "tool_result" → tool output
- *   - "error"       → warnings/errors
- *   - "result"      → final stats with per-model token usage
- *
- * Note: Gemini may prefix MCP warnings before JSON on the init line.
- * The parser strips leading non-JSON text before parsing.
- */
-
-import type { AgentMessage, TokenUsage } from './types.js';
-
-// ── Gemini stream-json shapes ───────────────────────────────
-
-interface GeminiStreamLine {
-  type: string;
-  timestamp?: string;
-  session_id?: string;
-  model?: string;
-  role?: string;
-  content?: string;
-  delta?: boolean;
-  name?: string;
-  tool_name?: string;
-  arguments?: unknown;
-  parameters?: unknown;
-  call_id?: string;
-  tool_id?: string;
-  tool_use_id?: string;
-  output?: string;
-  status?: string;
-  error?: string;
-  stats?: {
-    total_tokens?: number;
-    input_tokens?: number;
-    output_tokens?: number;
-    cached?: number;
-    duration_ms?: number;
-    tool_calls?: number;
-    models?: Record<string, {
-      total_tokens?: number;
-      input_tokens?: number;
-      output_tokens?: number;
-      cached?: number;
-    }>;
-  };
-}
-
-// ── State ───────────────────────────────────────────────────
-
-export interface GeminiStreamState {
-  sessionId?: string;
-  usage: Record<string, TokenUsage>;
-  isError: boolean;
-}
-
-// ── Parser ──────────────────────────────────────────────────
-
-/**
- * Parse a single NDJSON line from Gemini stream-json output.
- * Returns zero or more AgentMessage events.
- */
-export function parseGeminiStreamLine(
-  raw: string,
-  state: GeminiStreamState,
-): AgentMessage[] {
-  let line = raw.trim();
-  if (!line) return [];
-
-  // Gemini may prefix MCP warning text before JSON on init line:
-  // "MCP issues detected. Run /mcp list for status.{"type":"init",...}"
-  const jsonStart = line.indexOf('{');
-  if (jsonStart > 0) {
-    line = line.slice(jsonStart);
-  }
-
-  let parsed: GeminiStreamLine;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return [];
-  }
-
-  const messages: AgentMessage[] = [];
-
-  switch (parsed.type) {
-    case 'init':
-      if (parsed.session_id) {
-        state.sessionId = parsed.session_id;
-      }
-      break;
-
-    case 'message':
-      if (parsed.role === 'assistant' && parsed.content) {
-        messages.push({ type: 'text', content: parsed.content });
-      }
-      break;
-
-    case 'tool_use':
-      messages.push({
-        type: 'tool_use',
-        tool: parsed.tool_name ?? parsed.name ?? 'unknown',
-        callId: parsed.tool_id ?? parsed.call_id,
-        input: (parsed.parameters ?? parsed.arguments) as Record<string, unknown> | undefined,
-      });
-      break;
-
-    case 'tool_result':
-      messages.push({
-        type: 'tool_result',
-        callId: parsed.tool_id ?? parsed.tool_use_id ?? parsed.call_id,
-        output: parsed.output
-          ? (parsed.output.length > 4096 ? parsed.output.slice(0, 4096) : parsed.output)
-          : parsed.content
-            ? (parsed.content.length > 4096 ? parsed.content.slice(0, 4096) : parsed.content)
-            : undefined,
-      });
-      break;
-
-    case 'error':
-      state.isError = true;
-      messages.push({ type: 'error', content: parsed.error ?? parsed.content ?? 'Unknown error' });
-      break;
-
-    case 'result':
-      // Extract per-model token usage from stats.models
-      if (parsed.stats?.models) {
-        for (const [model, mu] of Object.entries(parsed.stats.models)) {
-          state.usage[model] = {
-            inputTokens: mu.input_tokens ?? 0,
-            outputTokens: mu.output_tokens ?? 0,
-            cacheReadTokens: mu.cached ?? 0,
-            cacheWriteTokens: 0,
-            model,
-          };
-        }
-      } else if (parsed.stats) {
-        // Fallback: aggregate stats without per-model breakdown
-        state.usage['gemini'] = {
-          inputTokens: parsed.stats.input_tokens ?? 0,
-          outputTokens: parsed.stats.output_tokens ?? 0,
-          cacheReadTokens: parsed.stats.cached ?? 0,
-          cacheWriteTokens: 0,
-          model: 'gemini',
-        };
-      }
-      break;
-  }
-
-  return messages;
-}
-
-/**
- * Create a fresh parser state.
- */
-export function createGeminiStreamState(): GeminiStreamState {
-  return { usage: {}, isError: false };
-}
+/**
+ * Gemini CLI stream-json parser.
+ *
+ * Parses NDJSON from `gemini --output-format stream-json`
+ * into AgentMessage events.
+ *
+ * Event types (from real gemini-cli 0.37.1 output):
+ *   - "init"        → session_id, model
+ *   - "message"     → role=user|assistant, content
+ *   - "tool_use"    → tool call requests
+ *   - "tool_result" → tool output
+ *   - "error"       → warnings/errors
+ *   - "result"      → final stats with per-model token usage
+ *
+ * Note: Gemini may prefix MCP warnings before JSON on the init line.
+ * The parser strips leading non-JSON text before parsing.
+ */
+
+import type { AgentMessage, TokenUsage } from './types.js';
+
+// ── Gemini stream-json shapes ───────────────────────────────
+
+interface GeminiStreamLine {
+  type: string;
+  timestamp?: string;
+  session_id?: string;
+  model?: string;
+  role?: string;
+  content?: string;
+  delta?: boolean;
+  name?: string;
+  tool_name?: string;
+  arguments?: unknown;
+  parameters?: unknown;
+  call_id?: string;
+  tool_id?: string;
+  tool_use_id?: string;
+  output?: string;
+  status?: string;
+  error?: string;
+  stats?: {
+    total_tokens?: number;
+    input_tokens?: number;
+    output_tokens?: number;
+    cached?: number;
+    duration_ms?: number;
+    tool_calls?: number;
+    models?: Record<string, {
+      total_tokens?: number;
+      input_tokens?: number;
+      output_tokens?: number;
+      cached?: number;
+    }>;
+  };
+}
+
+// ── State ───────────────────────────────────────────────────
+
+export interface GeminiStreamState {
+  sessionId?: string;
+  usage: Record<string, TokenUsage>;
+  isError: boolean;
+}
+
+// ── Parser ──────────────────────────────────────────────────
+
+/**
+ * Parse a single NDJSON line from Gemini stream-json output.
+ * Returns zero or more AgentMessage events.
+ */
+export function parseGeminiStreamLine(
+  raw: string,
+  state: GeminiStreamState,
+): AgentMessage[] {
+  let line = raw.trim();
+  if (!line) return [];
+
+  // Gemini may prefix MCP warning text before JSON on init line:
+  // "MCP issues detected. Run /mcp list for status.{"type":"init",...}"
+  const jsonStart = line.indexOf('{');
+  if (jsonStart > 0) {
+    line = line.slice(jsonStart);
+  }
+
+  let parsed: GeminiStreamLine;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return [];
+  }
+
+  const messages: AgentMessage[] = [];
+
+  switch (parsed.type) {
+    case 'init':
+      if (parsed.session_id) {
+        state.sessionId = parsed.session_id;
+      }
+      break;
+
+    case 'message':
+      if (parsed.role === 'assistant' && parsed.content) {
+        messages.push({ type: 'text', content: parsed.content });
+      }
+      break;
+
+    case 'tool_use':
+      messages.push({
+        type: 'tool_use',
+        tool: parsed.tool_name ?? parsed.name ?? 'unknown',
+        callId: parsed.tool_id ?? parsed.call_id,
+        input: (parsed.parameters ?? parsed.arguments) as Record<string, unknown> | undefined,
+      });
+      break;
+
+    case 'tool_result':
+      messages.push({
+        type: 'tool_result',
+        callId: parsed.tool_id ?? parsed.tool_use_id ?? parsed.call_id,
+        output: parsed.output
+          ? (parsed.output.length > 4096 ? parsed.output.slice(0, 4096) : parsed.output)
+          : parsed.content
+            ? (parsed.content.length > 4096 ? parsed.content.slice(0, 4096) : parsed.content)
+            : undefined,
+      });
+      break;
+
+    case 'error':
+      state.isError = true;
+      messages.push({ type: 'error', content: parsed.error ?? parsed.content ?? 'Unknown error' });
+      break;
+
+    case 'result':
+      // Extract per-model token usage from stats.models
+      if (parsed.stats?.models) {
+        for (const [model, mu] of Object.entries(parsed.stats.models)) {
+          state.usage[model] = {
+            inputTokens: mu.input_tokens ?? 0,
+            outputTokens: mu.output_tokens ?? 0,
+            cacheReadTokens: mu.cached ?? 0,
+            cacheWriteTokens: 0,
+            model,
+          };
+        }
+      } else if (parsed.stats) {
+        // Fallback: aggregate stats without per-model breakdown
+        state.usage['gemini'] = {
+          inputTokens: parsed.stats.input_tokens ?? 0,
+          outputTokens: parsed.stats.output_tokens ?? 0,
+          cacheReadTokens: parsed.stats.cached ?? 0,
+          cacheWriteTokens: 0,
+          model: 'gemini',
+        };
+      }
+      break;
+  }
+
+  return messages;
+}
+
+/**
+ * Create a fresh parser state.
+ */
+export function createGeminiStreamState(): GeminiStreamState {
+  return { usage: {}, isError: false };
+}

package/src/orchestrate/adapters/gemini.ts

@@ -1,42 +1,42 @@
-/**
- * Gemini CLI adapter.
- *
- * Invocation: echo "<prompt>" | gemini --yolo
- * Headless mode is automatically triggered when stdin is piped (non-TTY).
- * No -p flag needed — it would append its value to stdin, polluting the prompt.
- * Ref: https://github.com/google-gemini/gemini-cli/blob/main/docs/cli/headless.md
- */
-
-import { spawnAgentWithStream, isCommandAvailable } from './spawn-helper.js';
-import { parseGeminiStreamLine, createGeminiStreamState } from './gemini-stream.js';
-import type { AgentAdapter, AgentProcess, SpawnOptions } from './types.js';
-
-export class GeminiAdapter implements AgentAdapter {
-  name = 'gemini';
-
-  async available(): Promise<boolean> {
-    return isCommandAvailable('gemini');
-  }
-
-  spawn(prompt: string, opts: SpawnOptions): AgentProcess {
-    const state = createGeminiStreamState();
-
-    // Prompt piped via stdin — Gemini auto-enters headless mode in non-TTY.
-    // --yolo auto-approves all tool calls (no interactive confirmations).
-    // --output-format stream-json: emit NDJSON events for streaming + token tracking.
-    const args = ['--yolo', '--output-format', 'stream-json'];
-
-    return spawnAgentWithStream(
-      'gemini',
-      args,
-      opts,
-      prompt,
-      (line) => parseGeminiStreamLine(line, state),
-      (result) => ({
-        ...result,
-        tokenUsage: Object.keys(state.usage).length > 0 ? { ...state.usage } : undefined,
-        sessionId: state.sessionId,
-      }),
-    );
-  }
-}
+/**
+ * Gemini CLI adapter.
+ *
+ * Invocation: echo "<prompt>" | gemini --yolo
+ * Headless mode is automatically triggered when stdin is piped (non-TTY).
+ * No -p flag needed — it would append its value to stdin, polluting the prompt.
+ * Ref: https://github.com/google-gemini/gemini-cli/blob/main/docs/cli/headless.md
+ */
+
+import { spawnAgentWithStream, isCommandAvailable } from './spawn-helper.js';
+import { parseGeminiStreamLine, createGeminiStreamState } from './gemini-stream.js';
+import type { AgentAdapter, AgentProcess, SpawnOptions } from './types.js';
+
+export class GeminiAdapter implements AgentAdapter {
+  name = 'gemini';
+
+  async available(): Promise<boolean> {
+    return isCommandAvailable('gemini');
+  }
+
+  spawn(prompt: string, opts: SpawnOptions): AgentProcess {
+    const state = createGeminiStreamState();
+
+    // Prompt piped via stdin — Gemini auto-enters headless mode in non-TTY.
+    // --yolo auto-approves all tool calls (no interactive confirmations).
+    // --output-format stream-json: emit NDJSON events for streaming + token tracking.
+    const args = ['--yolo', '--output-format', 'stream-json'];
+
+    return spawnAgentWithStream(
+      'gemini',
+      args,
+      opts,
+      prompt,
+      (line) => parseGeminiStreamLine(line, state),
+      (result) => ({
+        ...result,
+        tokenUsage: Object.keys(state.usage).length > 0 ? { ...state.usage } : undefined,
+        sessionId: state.sessionId,
+      }),
+    );
+  }
+}

package/src/orchestrate/adapters/index.ts

@@ -1,73 +1,73 @@
-/**
- * Agent adapter registry.
- */
-
-export { ClaudeAdapter } from './claude.js';
-export { CodexAdapter } from './codex.js';
-export { GeminiAdapter } from './gemini.js';
-export { OpenCodeAdapter } from './opencode.js';
-export type { AgentAdapter, AgentProcess, AgentProcessResult, AgentMessage, AgentMessageType, TokenUsage, SpawnOptions } from './types.js';
-
-import { ClaudeAdapter } from './claude.js';
-import { CodexAdapter } from './codex.js';
-import { GeminiAdapter } from './gemini.js';
-import { OpenCodeAdapter } from './opencode.js';
-import type { AgentAdapter } from './types.js';
-
-const REGISTRY: Record<string, () => AgentAdapter> = {
-  claude: () => new ClaudeAdapter(),
-  codex: () => new CodexAdapter(),
-  gemini: () => new GeminiAdapter(),
-  opencode: () => new OpenCodeAdapter(),
-};
-
-export interface AgentQuota {
-  name: string;
-  quota: number;
-}
-
-/**
- * Parse agent quota string: "claude:2,codex:1,gemini:2,opencode:2"
- * Plain names default to quota 1: "claude,codex" → [{claude,1},{codex,1}]
- */
-export function parseAgentQuotas(raw: string): AgentQuota[] {
-  const result: AgentQuota[] = [];
-  for (const token of raw.split(',').map(s => s.trim()).filter(Boolean)) {
-    const [name, countStr] = token.split(':');
-    const quota = countStr ? parseInt(countStr, 10) : 1;
-    if (!name || !Number.isFinite(quota) || quota < 1) {
-      console.error(`[orchestrate] Invalid agent quota: "${token}" — expected "name" or "name:N"`);
-      continue;
-    }
-    const key = name.toLowerCase();
-    if (!REGISTRY[key]) {
-      console.error(`[orchestrate] Unknown agent adapter: ${key} (available: ${Object.keys(REGISTRY).join(', ')})`);
-      continue;
-    }
-    result.push({ name: key, quota });
-  }
-  return result;
-}
-
-/** Build quota map from AgentQuota array */
-export function buildQuotaMap(quotas: AgentQuota[]): Record<string, number> {
-  const map: Record<string, number> = {};
-  for (const q of quotas) {
-    map[q.name] = (map[q.name] ?? 0) + q.quota;
-  }
-  return map;
-}
-
-/** Resolve adapter names to instances. Unknown names are skipped with a warning. */
-export function resolveAdapters(names: string[]): AgentAdapter[] {
-  const adapters: AgentAdapter[] = [];
-  for (const name of names) {
-    const factory = REGISTRY[name.toLowerCase()];
-    if (factory) {
-      adapters.push(factory());
-    } else {
-      console.error(`[orchestrate] Unknown agent adapter: ${name} (available: ${Object.keys(REGISTRY).join(', ')})`);
-    }
-  }
-  return adapters;
-}
+/**
+ * Agent adapter registry.
+ */
+
+export { ClaudeAdapter } from './claude.js';
+export { CodexAdapter } from './codex.js';
+export { GeminiAdapter } from './gemini.js';
+export { OpenCodeAdapter } from './opencode.js';
+export type { AgentAdapter, AgentProcess, AgentProcessResult, AgentMessage, AgentMessageType, TokenUsage, SpawnOptions } from './types.js';
+
+import { ClaudeAdapter } from './claude.js';
+import { CodexAdapter } from './codex.js';
+import { GeminiAdapter } from './gemini.js';
+import { OpenCodeAdapter } from './opencode.js';
+import type { AgentAdapter } from './types.js';
+
+const REGISTRY: Record<string, () => AgentAdapter> = {
+  claude: () => new ClaudeAdapter(),
+  codex: () => new CodexAdapter(),
+  gemini: () => new GeminiAdapter(),
+  opencode: () => new OpenCodeAdapter(),
+};
+
+export interface AgentQuota {
+  name: string;
+  quota: number;
+}
+
+/**
+ * Parse agent quota string: "claude:2,codex:1,gemini:2,opencode:2"
+ * Plain names default to quota 1: "claude,codex" → [{claude,1},{codex,1}]
+ */
+export function parseAgentQuotas(raw: string): AgentQuota[] {
+  const result: AgentQuota[] = [];
+  for (const token of raw.split(',').map(s => s.trim()).filter(Boolean)) {
+    const [name, countStr] = token.split(':');
+    const quota = countStr ? parseInt(countStr, 10) : 1;
+    if (!name || !Number.isFinite(quota) || quota < 1) {
+      console.error(`[orchestrate] Invalid agent quota: "${token}" — expected "name" or "name:N"`);
+      continue;
+    }
+    const key = name.toLowerCase();
+    if (!REGISTRY[key]) {
+      console.error(`[orchestrate] Unknown agent adapter: ${key} (available: ${Object.keys(REGISTRY).join(', ')})`);
+      continue;
+    }
+    result.push({ name: key, quota });
+  }
+  return result;
+}
+
+/** Build quota map from AgentQuota array */
+export function buildQuotaMap(quotas: AgentQuota[]): Record<string, number> {
+  const map: Record<string, number> = {};
+  for (const q of quotas) {
+    map[q.name] = (map[q.name] ?? 0) + q.quota;
+  }
+  return map;
+}
+
+/** Resolve adapter names to instances. Unknown names are skipped with a warning. */
+export function resolveAdapters(names: string[]): AgentAdapter[] {
+  const adapters: AgentAdapter[] = [];
+  for (const name of names) {
+    const factory = REGISTRY[name.toLowerCase()];
+    if (factory) {
+      adapters.push(factory());
+    } else {
+      console.error(`[orchestrate] Unknown agent adapter: ${name} (available: ${Object.keys(REGISTRY).join(', ')})`);
+    }
+  }
+  return adapters;
+}