memorix 1.1.7 → 1.1.9

package/src/orchestrate/adapters/claude.ts

@@ -1,111 +1,111 @@
-/**
- * Claude Code CLI adapter.
- *
- * Invocation: claude -p - --output-format stream-json --verbose --bare
- *   --permission-mode bypassPermissions --mcp-config <path>
- *
- * --bare is essential for headless orchestration: it skips hooks, LSP,
- * plugin sync, attribution, auto-memory, background prefetches,
- * keychain reads, and CLAUDE.md auto-discovery. Without --bare,
- * Claude Code attempts interactive operations that cause hangs
- * in non-TTY orchestrated environments.
- *
- * --mcp-config is passed alongside --bare so the agent can still
- * access Memorix MCP tools (session_start, store, handoff, etc.).
- *
- * Uses stream-json output format for:
- *   - Real-time tool_use / text / thinking events
- *   - Token usage tracking per model
- *   - Session ID capture for future session reuse
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { spawnAgentWithStream, isCommandAvailable } from './spawn-helper.js';
-import { parseClaudeStreamLine, createStreamState } from './claude-stream.js';
-import type { AgentAdapter, AgentProcess, SpawnOptions } from './types.js';
-
-/**
- * Resolve the MCP config path for a project directory.
- * Checks for existing .claude/settings.local.json (from hooks install),
- * then .claude/settings.json, then falls back to generating a temporary
- * config that includes the Memorix MCP server.
- */
-function resolveMcpConfigPath(projectDir: string): string | null {
-  // Prefer existing project-level config (from `memorix hooks install --agent claude`)
-  const localPath = path.join(projectDir, '.claude', 'settings.local.json');
-  try { if (fs.existsSync(localPath)) return localPath; } catch { /* ignore */ }
-
-  const settingsPath = path.join(projectDir, '.claude', 'settings.json');
-  try { if (fs.existsSync(settingsPath)) return settingsPath; } catch { /* ignore */ }
-
-  // No existing config — generate a temporary one with Memorix MCP server
-  const mcpConfig = {
-    mcpServers: {
-      memorix: {
-        command: process.execPath,
-        args: [path.resolve(path.dirname(process.execPath), '..', 'lib', 'node_modules', 'memorix', 'dist', 'index.js'), 'serve', '--transport', 'stdio'],
-      },
-    },
-  };
-
-  // Try to use the memorix CLI directly (more reliable than path guessing)
-  const memorixCmd = process.platform === 'win32' ? 'memorix.cmd' : 'memorix';
-  mcpConfig.mcpServers.memorix = {
-    command: memorixCmd,
-    args: ['serve', '--transport', 'stdio'],
-  };
-
-  try {
-    const claudeDir = path.join(projectDir, '.claude');
-    fs.mkdirSync(claudeDir, { recursive: true });
-    const tempPath = path.join(claudeDir, 'settings.local.json');
-    fs.writeFileSync(tempPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
-    return tempPath;
-  } catch {
-    return null;
-  }
-}
-
-export class ClaudeAdapter implements AgentAdapter {
-  name = 'claude';
-
-  async available(): Promise<boolean> {
-    return isCommandAvailable('claude');
-  }
-
-  spawn(prompt: string, opts: SpawnOptions): AgentProcess {
-    const state = createStreamState();
-
-    const args = [
-      '-p', '-',
-      '--output-format', 'stream-json',
-      '--verbose',
-      '--bare',
-      '--permission-mode', 'bypassPermissions',
-    ];
-
-    // Pass MCP config so the agent can use Memorix tools even in --bare mode
-    const mcpConfigPath = opts.cwd ? resolveMcpConfigPath(opts.cwd) : null;
-    if (mcpConfigPath) {
-      args.push('--mcp-config', mcpConfigPath);
-    }
-
-    if (opts.resumeSessionId) {
-      args.push('--resume', opts.resumeSessionId);
-    }
-
-    return spawnAgentWithStream(
-      'claude',
-      args,
-      opts,
-      prompt,
-      (line) => parseClaudeStreamLine(line, state),
-      (result) => ({
-        ...result,
-        tokenUsage: Object.keys(state.usage).length > 0 ? { ...state.usage } : undefined,
-        sessionId: state.sessionId,
-      }),
-    );
-  }
-}
+/**
+ * Claude Code CLI adapter.
+ *
+ * Invocation: claude -p - --output-format stream-json --verbose --bare
+ *   --permission-mode bypassPermissions --mcp-config <path>
+ *
+ * --bare is essential for headless orchestration: it skips hooks, LSP,
+ * plugin sync, attribution, auto-memory, background prefetches,
+ * keychain reads, and CLAUDE.md auto-discovery. Without --bare,
+ * Claude Code attempts interactive operations that cause hangs
+ * in non-TTY orchestrated environments.
+ *
+ * --mcp-config is passed alongside --bare so the agent can still
+ * access Memorix MCP tools (session_start, store, handoff, etc.).
+ *
+ * Uses stream-json output format for:
+ *   - Real-time tool_use / text / thinking events
+ *   - Token usage tracking per model
+ *   - Session ID capture for future session reuse
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawnAgentWithStream, isCommandAvailable } from './spawn-helper.js';
+import { parseClaudeStreamLine, createStreamState } from './claude-stream.js';
+import type { AgentAdapter, AgentProcess, SpawnOptions } from './types.js';
+
+/**
+ * Resolve the MCP config path for a project directory.
+ * Checks for existing .claude/settings.local.json (from hooks install),
+ * then .claude/settings.json, then falls back to generating a temporary
+ * config that includes the Memorix MCP server.
+ */
+function resolveMcpConfigPath(projectDir: string): string | null {
+  // Prefer existing project-level config (from `memorix hooks install --agent claude`)
+  const localPath = path.join(projectDir, '.claude', 'settings.local.json');
+  try { if (fs.existsSync(localPath)) return localPath; } catch { /* ignore */ }
+
+  const settingsPath = path.join(projectDir, '.claude', 'settings.json');
+  try { if (fs.existsSync(settingsPath)) return settingsPath; } catch { /* ignore */ }
+
+  // No existing config — generate a temporary one with Memorix MCP server
+  const mcpConfig = {
+    mcpServers: {
+      memorix: {
+        command: process.execPath,
+        args: [path.resolve(path.dirname(process.execPath), '..', 'lib', 'node_modules', 'memorix', 'dist', 'index.js'), 'serve', '--transport', 'stdio'],
+      },
+    },
+  };
+
+  // Try to use the memorix CLI directly (more reliable than path guessing)
+  const memorixCmd = process.platform === 'win32' ? 'memorix.cmd' : 'memorix';
+  mcpConfig.mcpServers.memorix = {
+    command: memorixCmd,
+    args: ['serve', '--transport', 'stdio'],
+  };
+
+  try {
+    const claudeDir = path.join(projectDir, '.claude');
+    fs.mkdirSync(claudeDir, { recursive: true });
+    const tempPath = path.join(claudeDir, 'settings.local.json');
+    fs.writeFileSync(tempPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
+    return tempPath;
+  } catch {
+    return null;
+  }
+}
+
+export class ClaudeAdapter implements AgentAdapter {
+  name = 'claude';
+
+  async available(): Promise<boolean> {
+    return isCommandAvailable('claude');
+  }
+
+  spawn(prompt: string, opts: SpawnOptions): AgentProcess {
+    const state = createStreamState();
+
+    const args = [
+      '-p', '-',
+      '--output-format', 'stream-json',
+      '--verbose',
+      '--bare',
+      '--permission-mode', 'bypassPermissions',
+    ];
+
+    // Pass MCP config so the agent can use Memorix tools even in --bare mode
+    const mcpConfigPath = opts.cwd ? resolveMcpConfigPath(opts.cwd) : null;
+    if (mcpConfigPath) {
+      args.push('--mcp-config', mcpConfigPath);
+    }
+
+    if (opts.resumeSessionId) {
+      args.push('--resume', opts.resumeSessionId);
+    }
+
+    return spawnAgentWithStream(
+      'claude',
+      args,
+      opts,
+      prompt,
+      (line) => parseClaudeStreamLine(line, state),
+      (result) => ({
+        ...result,
+        tokenUsage: Object.keys(state.usage).length > 0 ? { ...state.usage } : undefined,
+        sessionId: state.sessionId,
+      }),
+    );
+  }
+}

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

@@ -1,134 +1,134 @@
-/**
- * Codex CLI JSONL parser.
- *
- * Parses NDJSON from `codex exec --json`
- * into AgentMessage events.
- *
- * Event types (from real codex-cli 0.97.0 output):
- *   - "thread.started" → thread_id (session)
- *   - "turn.started"   → turn begins
- *   - "item.completed" → agent_message / tool_call / tool_result items
- *   - "turn.completed" → usage summary
- */
-
-import type { AgentMessage, TokenUsage } from './types.js';
-
-// ── Codex JSONL shapes ──────────────────────────────────────
-
-interface CodexEvent {
-  type: string;
-  thread_id?: string;
-  item?: {
-    id?: string;
-    type?: string;
-    text?: string;
-    name?: string;
-    arguments?: string;
-    output?: string;
-    call_id?: string;
-  };
-  usage?: {
-    input_tokens?: number;
-    output_tokens?: number;
-    cached_input_tokens?: number;
-  };
-}
-
-// ── State ───────────────────────────────────────────────────
-
-export interface CodexStreamState {
-  sessionId?: string;
-  usage: Record<string, TokenUsage>;
-  isError: boolean;
-}
-
-// ── Parser ──────────────────────────────────────────────────
-
-/**
- * Parse a single NDJSON line from Codex --json output.
- * Returns zero or more AgentMessage events.
- */
-export function parseCodexStreamLine(
-  raw: string,
-  state: CodexStreamState,
-): AgentMessage[] {
-  const line = raw.trim();
-  if (!line) return [];
-
-  let parsed: CodexEvent;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return [];
-  }
-
-  const messages: AgentMessage[] = [];
-
-  switch (parsed.type) {
-    case 'thread.started':
-      if (parsed.thread_id) {
-        state.sessionId = parsed.thread_id;
-      }
-      break;
-
-    case 'item.completed':
-      if (parsed.item) {
-        switch (parsed.item.type) {
-          case 'agent_message':
-            if (parsed.item.text) {
-              messages.push({ type: 'text', content: parsed.item.text });
-            }
-            break;
-          case 'tool_call':
-          case 'function_call':
-            messages.push({
-              type: 'tool_use',
-              tool: parsed.item.name ?? 'unknown',
-              callId: parsed.item.call_id ?? parsed.item.id,
-              input: parsed.item.arguments ? { raw: parsed.item.arguments } : undefined,
-            });
-            break;
-          case 'tool_output':
-          case 'function_call_output':
-            messages.push({
-              type: 'tool_result',
-              callId: parsed.item.call_id ?? parsed.item.id,
-              output: parsed.item.output
-                ? (parsed.item.output.length > 4096 ? parsed.item.output.slice(0, 4096) : parsed.item.output)
-                : undefined,
-            });
-            break;
-        }
-      }
-      break;
-
-    case 'turn.completed':
-      // Extract token usage — Codex doesn't provide per-model breakdown,
-      // so we use a generic "codex" model key
-      if (parsed.usage) {
-        const model = 'codex';
-        state.usage[model] = {
-          inputTokens: parsed.usage.input_tokens ?? 0,
-          outputTokens: parsed.usage.output_tokens ?? 0,
-          cacheReadTokens: parsed.usage.cached_input_tokens ?? 0,
-          cacheWriteTokens: 0,
-          model,
-        };
-      }
-      break;
-
-    case 'error':
-      state.isError = true;
-      messages.push({ type: 'error', content: String((parsed as unknown as Record<string, unknown>).message ?? 'Unknown error') });
-      break;
-  }
-
-  return messages;
-}
-
-/**
- * Create a fresh parser state.
- */
-export function createCodexStreamState(): CodexStreamState {
-  return { usage: {}, isError: false };
-}
+/**
+ * Codex CLI JSONL parser.
+ *
+ * Parses NDJSON from `codex exec --json`
+ * into AgentMessage events.
+ *
+ * Event types (from real codex-cli 0.97.0 output):
+ *   - "thread.started" → thread_id (session)
+ *   - "turn.started"   → turn begins
+ *   - "item.completed" → agent_message / tool_call / tool_result items
+ *   - "turn.completed" → usage summary
+ */
+
+import type { AgentMessage, TokenUsage } from './types.js';
+
+// ── Codex JSONL shapes ──────────────────────────────────────
+
+interface CodexEvent {
+  type: string;
+  thread_id?: string;
+  item?: {
+    id?: string;
+    type?: string;
+    text?: string;
+    name?: string;
+    arguments?: string;
+    output?: string;
+    call_id?: string;
+  };
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+    cached_input_tokens?: number;
+  };
+}
+
+// ── State ───────────────────────────────────────────────────
+
+export interface CodexStreamState {
+  sessionId?: string;
+  usage: Record<string, TokenUsage>;
+  isError: boolean;
+}
+
+// ── Parser ──────────────────────────────────────────────────
+
+/**
+ * Parse a single NDJSON line from Codex --json output.
+ * Returns zero or more AgentMessage events.
+ */
+export function parseCodexStreamLine(
+  raw: string,
+  state: CodexStreamState,
+): AgentMessage[] {
+  const line = raw.trim();
+  if (!line) return [];
+
+  let parsed: CodexEvent;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return [];
+  }
+
+  const messages: AgentMessage[] = [];
+
+  switch (parsed.type) {
+    case 'thread.started':
+      if (parsed.thread_id) {
+        state.sessionId = parsed.thread_id;
+      }
+      break;
+
+    case 'item.completed':
+      if (parsed.item) {
+        switch (parsed.item.type) {
+          case 'agent_message':
+            if (parsed.item.text) {
+              messages.push({ type: 'text', content: parsed.item.text });
+            }
+            break;
+          case 'tool_call':
+          case 'function_call':
+            messages.push({
+              type: 'tool_use',
+              tool: parsed.item.name ?? 'unknown',
+              callId: parsed.item.call_id ?? parsed.item.id,
+              input: parsed.item.arguments ? { raw: parsed.item.arguments } : undefined,
+            });
+            break;
+          case 'tool_output':
+          case 'function_call_output':
+            messages.push({
+              type: 'tool_result',
+              callId: parsed.item.call_id ?? parsed.item.id,
+              output: parsed.item.output
+                ? (parsed.item.output.length > 4096 ? parsed.item.output.slice(0, 4096) : parsed.item.output)
+                : undefined,
+            });
+            break;
+        }
+      }
+      break;
+
+    case 'turn.completed':
+      // Extract token usage — Codex doesn't provide per-model breakdown,
+      // so we use a generic "codex" model key
+      if (parsed.usage) {
+        const model = 'codex';
+        state.usage[model] = {
+          inputTokens: parsed.usage.input_tokens ?? 0,
+          outputTokens: parsed.usage.output_tokens ?? 0,
+          cacheReadTokens: parsed.usage.cached_input_tokens ?? 0,
+          cacheWriteTokens: 0,
+          model,
+        };
+      }
+      break;
+
+    case 'error':
+      state.isError = true;
+      messages.push({ type: 'error', content: String((parsed as unknown as Record<string, unknown>).message ?? 'Unknown error') });
+      break;
+  }
+
+  return messages;
+}
+
+/**
+ * Create a fresh parser state.
+ */
+export function createCodexStreamState(): CodexStreamState {
+  return { usage: {}, isError: false };
+}

package/src/orchestrate/adapters/codex.ts

@@ -1,41 +1,41 @@
-/**
- * Codex CLI adapter.
- *
- * Invocation: codex "<prompt>"
- */
-
-import { spawnAgentWithStream, isCommandAvailable } from './spawn-helper.js';
-import { parseCodexStreamLine, createCodexStreamState } from './codex-stream.js';
-import type { AgentAdapter, AgentProcess, SpawnOptions } from './types.js';
-
-export class CodexAdapter implements AgentAdapter {
-  name = 'codex';
-
-  async available(): Promise<boolean> {
-    return isCommandAvailable('codex');
-  }
-
-  spawn(prompt: string, opts: SpawnOptions): AgentProcess {
-    const state = createCodexStreamState();
-
-    // Use stdin ('-') to avoid shell escaping issues with long prompts
-    // --dangerously-bypass-approvals-and-sandbox: auto-approve + full write access for orchestrated headless mode
-    // --json: emit JSONL events to stdout for streaming + token tracking
-    const args = opts.resumeSessionId
-      ? ['exec', 'resume', opts.resumeSessionId, '--dangerously-bypass-approvals-and-sandbox', '--json', '-']
-      : ['exec', '--dangerously-bypass-approvals-and-sandbox', '--json', '-'];
-
-    return spawnAgentWithStream(
-      'codex',
-      args,
-      opts,
-      prompt,
-      (line) => parseCodexStreamLine(line, state),
-      (result) => ({
-        ...result,
-        tokenUsage: Object.keys(state.usage).length > 0 ? { ...state.usage } : undefined,
-        sessionId: state.sessionId,
-      }),
-    );
-  }
-}
+/**
+ * Codex CLI adapter.
+ *
+ * Invocation: codex "<prompt>"
+ */
+
+import { spawnAgentWithStream, isCommandAvailable } from './spawn-helper.js';
+import { parseCodexStreamLine, createCodexStreamState } from './codex-stream.js';
+import type { AgentAdapter, AgentProcess, SpawnOptions } from './types.js';
+
+export class CodexAdapter implements AgentAdapter {
+  name = 'codex';
+
+  async available(): Promise<boolean> {
+    return isCommandAvailable('codex');
+  }
+
+  spawn(prompt: string, opts: SpawnOptions): AgentProcess {
+    const state = createCodexStreamState();
+
+    // Use stdin ('-') to avoid shell escaping issues with long prompts
+    // --dangerously-bypass-approvals-and-sandbox: auto-approve + full write access for orchestrated headless mode
+    // --json: emit JSONL events to stdout for streaming + token tracking
+    const args = opts.resumeSessionId
+      ? ['exec', 'resume', opts.resumeSessionId, '--dangerously-bypass-approvals-and-sandbox', '--json', '-']
+      : ['exec', '--dangerously-bypass-approvals-and-sandbox', '--json', '-'];
+
+    return spawnAgentWithStream(
+      'codex',
+      args,
+      opts,
+      prompt,
+      (line) => parseCodexStreamLine(line, state),
+      (result) => ({
+        ...result,
+        tokenUsage: Object.keys(state.usage).length > 0 ? { ...state.usage } : undefined,
+        sessionId: state.sessionId,
+      }),
+    );
+  }
+}