@jungjaehoon/mama-core 1.0.2 → 1.1.0

package/src/embedding-server/mobile/daemon.js

@@ -1,313 +0,0 @@
-/**
- * @fileoverview Claude Code Daemon - stream-json based subprocess manager
- * @module mobile/daemon
- * @version 1.5.2
- *
- * Manages Claude Code as a subprocess using stream-json mode for
- * bidirectional JSON communication.
- *
- * @example
- * const { ClaudeDaemon } = require('./daemon');
- * const daemon = new ClaudeDaemon('/path/to/project', 'session_123');
- * await daemon.spawn();
- * daemon.send('Hello Claude!');
- * daemon.on('output', (data) => console.log(data));
- */
-
-const { EventEmitter } = require('events');
-const { spawn } = require('child_process');
-
-/**
- * ANSI escape code regex pattern
- * @type {RegExp}
- */
-// eslint-disable-next-line no-control-regex
-const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
-
-/**
- * ClaudeDaemon class - manages Claude Code subprocess via stream-json
- * @extends EventEmitter
- *
- * @fires ClaudeDaemon#output - When stdout data is received
- * @fires ClaudeDaemon#error - When an error occurs
- * @fires ClaudeDaemon#exit - When the process exits
- */
-class ClaudeDaemon extends EventEmitter {
-  /**
-   * Create a new ClaudeDaemon instance
-   * @param {string} projectDir - Working directory for Claude Code
-   * @param {string} sessionId - Unique session identifier
-   */
-  constructor(projectDir, sessionId) {
-    super();
-    this.projectDir = projectDir;
-    this.sessionId = sessionId;
-    this.process = null;
-    this.pid = null;
-    this.isRunning = false;
-    this.buffer = '';
-  }
-
-  /**
-   * Spawn the Claude Code subprocess with stream-json mode
-   * @returns {Promise<void>}
-   * @throws {Error} If spawn fails or process is already running
-   */
-  async spawn() {
-    if (this.isRunning) {
-      throw new Error('Daemon is already running');
-    }
-
-    return new Promise((resolve, reject) => {
-      try {
-        // Use stream-json mode for bidirectional JSON communication
-        const args = [
-          '--dangerously-skip-permissions',
-          '--input-format',
-          'stream-json',
-          '--output-format',
-          'stream-json',
-        ];
-
-        // Spawn Claude Code CLI
-        this.process = spawn('claude', args, {
-          cwd: this.projectDir,
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env: {
-            ...process.env,
-            CLAUDE_CODE_ENTRY_POINT: 'cli',
-          },
-        });
-
-        // Store PID
-        this.pid = this.process.pid;
-        this.isRunning = true;
-
-        console.error(
-          `[MobileDaemon] Session ${this.sessionId} spawned with PID ${this.pid} (stream-json mode)`
-        );
-
-        // Handle stdout data (JSON stream)
-        this.process.stdout.on('data', (chunk) => {
-          this.buffer += chunk.toString();
-
-          // Try to parse complete JSON objects from buffer
-          let newlineIndex;
-          while ((newlineIndex = this.buffer.indexOf('\n')) !== -1) {
-            const line = this.buffer.slice(0, newlineIndex).trim();
-            this.buffer = this.buffer.slice(newlineIndex + 1);
-
-            if (line) {
-              try {
-                const parsed = JSON.parse(line);
-                console.error(
-                  `[MobileDaemon] Parsed JSON: ${JSON.stringify(parsed).substring(0, 100)}...`
-                );
-
-                // Detect tool usage (content_block_start with tool_use type)
-                if (
-                  parsed.type === 'content_block_start' &&
-                  parsed.content_block?.type === 'tool_use'
-                ) {
-                  const toolBlock = parsed.content_block;
-                  console.error(`[MobileDaemon] Tool use detected: ${toolBlock.name}`);
-                  this.emit('tool_use', {
-                    tool: toolBlock.name,
-                    toolId: toolBlock.id,
-                    input: toolBlock.input,
-                    sessionId: this.sessionId,
-                  });
-                }
-
-                // Detect tool completion (content_block_stop after tool_use)
-                if (parsed.type === 'content_block_stop' && parsed.index !== undefined) {
-                  console.error(`[MobileDaemon] Tool complete for block ${parsed.index}`);
-                  this.emit('tool_complete', {
-                    index: parsed.index,
-                    sessionId: this.sessionId,
-                  });
-                }
-
-                // Extract text content from various message types
-                let textContent = '';
-                if (parsed.type === 'assistant' && parsed.message?.content) {
-                  // Assistant message with content blocks
-                  for (const block of parsed.message.content) {
-                    if (block.type === 'text') {
-                      textContent += block.text;
-                    }
-                  }
-                } else if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
-                  // Streaming delta
-                  textContent = parsed.delta.text;
-                } else if (parsed.result?.content) {
-                  // Final result
-                  textContent = parsed.result.content;
-                }
-
-                if (textContent) {
-                  this.emit('output', {
-                    type: 'stdout',
-                    text: textContent,
-                    raw: line,
-                    parsed,
-                    sessionId: this.sessionId,
-                  });
-                }
-
-                // Detect response completion (result message)
-                if (parsed.type === 'result') {
-                  console.error(`[MobileDaemon] Response complete for session ${this.sessionId}`);
-                  this.emit('response_complete', {
-                    sessionId: this.sessionId,
-                    result: parsed.result,
-                    duration_ms: parsed.duration_ms,
-                  });
-                }
-              } catch (e) {
-                // Not valid JSON, emit as raw text
-                console.error(`[MobileDaemon] Raw output: ${line.substring(0, 100)}...`);
-                this.emit('output', {
-                  type: 'stdout',
-                  text: line,
-                  raw: line,
-                  sessionId: this.sessionId,
-                });
-              }
-            }
-          }
-        });
-
-        // Handle stderr data
-        this.process.stderr.on('data', (chunk) => {
-          const text = chunk.toString();
-          console.error(`[MobileDaemon] stderr: ${text.substring(0, 200)}`);
-          this.emit('output', {
-            type: 'stderr',
-            text: text.replace(ANSI_REGEX, ''),
-            raw: text,
-            sessionId: this.sessionId,
-          });
-        });
-
-        // Handle process errors
-        this.process.on('error', (err) => {
-          console.error(`[MobileDaemon] Error in session ${this.sessionId}:`, err.message);
-          this.isRunning = false;
-          this.emit('error', {
-            error: err,
-            sessionId: this.sessionId,
-          });
-          reject(err);
-        });
-
-        // Handle process exit
-        this.process.on('exit', (code, signal) => {
-          console.error(
-            `[MobileDaemon] Session ${this.sessionId} exited with code ${code}, signal ${signal}`
-          );
-          this.isRunning = false;
-          this.pid = null;
-          this.emit('exit', {
-            code,
-            signal,
-            sessionId: this.sessionId,
-          });
-        });
-
-        // Process should be ready immediately in stream-json mode
-        setTimeout(() => {
-          if (this.isRunning) {
-            resolve();
-          }
-        }, 100);
-      } catch (err) {
-        console.error(`[MobileDaemon] Failed to spawn session ${this.sessionId}:`, err.message);
-        this.isRunning = false;
-        this.emit('error', {
-          error: err,
-          sessionId: this.sessionId,
-        });
-        reject(err);
-      }
-    });
-  }
-
-  /**
-   * Send a message to Claude via stdin (stream-json format)
-   * @param {string} message - Message to send
-   * @throws {Error} If process is not running
-   */
-  send(message) {
-    if (!this.isRunning || !this.process || !this.process.stdin) {
-      throw new Error('Daemon is not running');
-    }
-
-    // Send as JSON object with type "user" and nested message object
-    const jsonMessage = JSON.stringify({
-      type: 'user',
-      message: {
-        role: 'user',
-        content: message,
-      },
-    });
-
-    this.process.stdin.write(jsonMessage + '\n');
-
-    console.error(
-      `[MobileDaemon] Sent JSON to session ${this.sessionId}: ${jsonMessage.substring(0, 100)}...`
-    );
-  }
-
-  /**
-   * Kill the Claude Code subprocess
-   * @param {string} [signal='SIGTERM'] - Signal to send to process
-   */
-  kill(signal = 'SIGTERM') {
-    if (!this.process) {
-      console.error(`[MobileDaemon] No process to kill for session ${this.sessionId}`);
-      return;
-    }
-
-    try {
-      console.error(`[MobileDaemon] Killing session ${this.sessionId} with signal ${signal}`);
-      this.process.kill(signal);
-      this.isRunning = false;
-
-      // Emit exit event
-      this.emit('exit', {
-        code: null,
-        signal,
-        sessionId: this.sessionId,
-        manual: true,
-      });
-    } catch (err) {
-      console.error(`[MobileDaemon] Error killing session ${this.sessionId}:`, err.message);
-      this.emit('error', {
-        error: err,
-        sessionId: this.sessionId,
-      });
-    }
-  }
-
-  /**
-   * Check if the daemon is currently running
-   * @returns {boolean}
-   */
-  isActive() {
-    return this.isRunning && this.process !== null;
-  }
-
-  /**
-   * Get the process ID
-   * @returns {number|null}
-   */
-  getPid() {
-    return this.pid;
-  }
-}
-
-module.exports = {
-  ClaudeDaemon,
-  ANSI_REGEX,
-};

package/src/embedding-server/mobile/output-parser.js

@@ -1,281 +0,0 @@
-/**
- * @fileoverview Output Parser - parses Claude Code stdout into structured events
- * @module mobile/output-parser
- * @version 1.5.0
- *
- * Parses raw stdout from Claude Code CLI, identifying message types
- * such as stream content, tool usage, completion, and errors.
- *
- * @example
- * const { OutputParser } = require('./output-parser');
- * const parser = new OutputParser();
- * const events = parser.parse(chunk);
- * // events: [{ type: 'stream', text: '...' }, { type: 'tool_use', tool: 'Read' }]
- */
-
-/**
- * Message types returned by the parser
- * @typedef {'stream'|'tool_use'|'tool_complete'|'complete'|'error'} MessageType
- */
-
-/**
- * Parsed output event
- * @typedef {Object} ParsedEvent
- * @property {MessageType} type - Event type
- * @property {string} [text] - Text content (for stream type)
- * @property {string} [tool] - Tool name (for tool_use type)
- * @property {string} [status] - Tool status (started/completed)
- * @property {string} [message] - Error message (for error type)
- */
-
-/**
- * Tool detection patterns
- * @type {RegExp[]}
- */
-const TOOL_PATTERNS = [
-  /Tool:\s*(\w+)/i,
-  /Using\s+(\w+)\s+tool/i,
-  /Calling\s+(\w+)/i,
-  /⏺\s*(\w+)/, // Claude Code uses this indicator
-  /\[(\w+)\]\s*Reading/i,
-  /\[(\w+)\]\s*Writing/i,
-  /\[(\w+)\]\s*Editing/i,
-];
-
-/**
- * Tool completion patterns
- * @type {RegExp[]}
- */
-const TOOL_COMPLETE_PATTERNS = [/Tool\s+(\w+)\s+completed/i, /(\w+)\s+finished/i, /✓\s*(\w+)/];
-
-/**
- * Error patterns
- * @type {RegExp[]}
- */
-const ERROR_PATTERNS = [
-  /Error:\s*(.+)/i,
-  /ERROR:\s*(.+)/i,
-  /Failed:\s*(.+)/i,
-  /Exception:\s*(.+)/i,
-];
-
-/**
- * Completion/prompt patterns
- * @type {RegExp[]}
- */
-const COMPLETE_PATTERNS = [
-  /^>\s*$/m, // Simple prompt
-  /^\$\s*$/m, // Shell prompt
-  /^claude>\s*$/im, // Claude prompt
-  /\n\n\n$/, // Multiple empty lines
-];
-
-/**
- * ANSI escape code regex pattern
- * @type {RegExp}
- */
-// eslint-disable-next-line no-control-regex
-const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
-
-/**
- * OutputParser class - parses Claude Code stdout
- */
-class OutputParser {
-  /**
-   * Create a new OutputParser instance
-   */
-  constructor() {
-    this.buffer = '';
-    this.lastToolDetected = null;
-  }
-
-  /**
-   * Parse a stdout chunk into events
-   * @param {string|Buffer} chunk - Raw stdout data
-   * @returns {ParsedEvent[]} Array of parsed events
-   */
-  parse(chunk) {
-    const text = typeof chunk === 'string' ? chunk : chunk.toString();
-    const cleanText = this.stripAnsi(text);
-
-    // Add to buffer for incomplete line handling
-    this.buffer += cleanText;
-
-    const events = [];
-
-    // Check for errors first (highest priority)
-    const errorResult = this.detectError(this.buffer);
-    if (errorResult) {
-      events.push({
-        type: 'error',
-        message: errorResult,
-      });
-      // Don't clear buffer entirely, might have more content
-    }
-
-    // Check for tool usage
-    const toolResult = this.detectToolUse(this.buffer);
-    if (toolResult) {
-      events.push({
-        type: 'tool_use',
-        tool: toolResult.tool,
-        status: 'started',
-        args: toolResult.args || null,
-      });
-      this.lastToolDetected = toolResult.tool;
-    }
-
-    // Check for tool completion
-    const toolComplete = this.detectToolComplete(this.buffer);
-    if (toolComplete) {
-      events.push({
-        type: 'tool_complete',
-        tool: toolComplete,
-        status: 'completed',
-      });
-    }
-
-    // Check for completion
-    if (this.detectComplete(this.buffer)) {
-      events.push({
-        type: 'complete',
-      });
-    }
-
-    // Always emit stream event with the text
-    if (cleanText.trim()) {
-      events.push({
-        type: 'stream',
-        text: cleanText,
-      });
-    }
-
-    // Clear buffer if we have complete lines (ends with newline)
-    if (this.buffer.endsWith('\n')) {
-      this.buffer = '';
-    } else {
-      // Keep only the incomplete last line
-      const lastNewline = this.buffer.lastIndexOf('\n');
-      if (lastNewline !== -1) {
-        this.buffer = this.buffer.substring(lastNewline + 1);
-      }
-    }
-
-    return events;
-  }
-
-  /**
-   * Remove ANSI escape codes from text
-   * @param {string} text - Text with potential ANSI codes
-   * @returns {string} Clean text
-   */
-  stripAnsi(text) {
-    return text.replace(ANSI_REGEX, '');
-  }
-
-  /**
-   * Detect tool usage pattern in text
-   * @param {string} text - Text to analyze
-   * @returns {Object|null} Tool info or null
-   */
-  detectToolUse(text) {
-    for (const pattern of TOOL_PATTERNS) {
-      const match = text.match(pattern);
-      if (match) {
-        const tool = match[1];
-        // Try to extract args if present
-        const argsMatch = text.match(new RegExp(`${tool}[:\\s]+(.+?)(?:\\n|$)`, 'i'));
-        return {
-          tool,
-          args: argsMatch ? argsMatch[1].trim() : null,
-        };
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Detect tool completion pattern in text
-   * @param {string} text - Text to analyze
-   * @returns {string|null} Tool name or null
-   */
-  detectToolComplete(text) {
-    for (const pattern of TOOL_COMPLETE_PATTERNS) {
-      const match = text.match(pattern);
-      if (match) {
-        return match[1];
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Detect completion pattern in text
-   * @param {string} text - Text to analyze
-   * @returns {boolean} True if completion detected
-   */
-  detectComplete(text) {
-    for (const pattern of COMPLETE_PATTERNS) {
-      if (pattern.test(text)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Detect error pattern in text
-   * @param {string} text - Text to analyze
-   * @returns {string|null} Error message or null
-   */
-  detectError(text) {
-    for (const pattern of ERROR_PATTERNS) {
-      const match = text.match(pattern);
-      if (match) {
-        return match[1].trim();
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Flush any remaining buffer content
-   * @returns {ParsedEvent[]} Remaining events
-   */
-  flush() {
-    const events = [];
-    if (this.buffer.trim()) {
-      events.push({
-        type: 'stream',
-        text: this.buffer,
-      });
-    }
-    this.buffer = '';
-    this.lastToolDetected = null;
-    return events;
-  }
-
-  /**
-   * Reset the parser state
-   */
-  reset() {
-    this.buffer = '';
-    this.lastToolDetected = null;
-  }
-
-  /**
-   * Get current buffer content
-   * @returns {string}
-   */
-  getBuffer() {
-    return this.buffer;
-  }
-}
-
-module.exports = {
-  OutputParser,
-  TOOL_PATTERNS,
-  ERROR_PATTERNS,
-  COMPLETE_PATTERNS,
-  ANSI_REGEX,
-};