@jungjaehoon/mama-core 1.1.2 → 1.1.3

package/dist/embedding-server/mobile/daemon.d.ts

@@ -0,0 +1,128 @@
+/**
+ * @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
+ * import { ClaudeDaemon } from './daemon';
+ * const daemon = new ClaudeDaemon('/path/to/project', 'session_123');
+ * await daemon.spawn();
+ * daemon.send('Hello Claude!');
+ * daemon.on('output', (data) => console.log(data));
+ */
+import { EventEmitter } from 'events';
+/**
+ * ANSI escape code regex pattern
+ */
+export declare const ANSI_REGEX: RegExp;
+/**
+ * Output event data
+ */
+export interface OutputEvent {
+    type: 'stdout' | 'stderr';
+    text: string;
+    raw: string;
+    parsed?: unknown;
+    sessionId: string;
+}
+/**
+ * Error event data
+ */
+export interface ErrorEvent {
+    error: Error;
+    sessionId: string;
+}
+/**
+ * Exit event data
+ */
+export interface ExitEvent {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    sessionId: string;
+    manual?: boolean;
+}
+/**
+ * Tool use event data
+ */
+export interface ToolUseEvent {
+    tool: string;
+    toolId: string;
+    input: unknown;
+    sessionId: string;
+}
+/**
+ * Tool complete event data
+ */
+export interface ToolCompleteEvent {
+    index: number;
+    sessionId: string;
+}
+/**
+ * Response complete event data
+ */
+export interface ResponseCompleteEvent {
+    sessionId: string;
+    result: unknown;
+    duration_ms?: number;
+}
+/**
+ * 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
+ */
+export declare class ClaudeDaemon extends EventEmitter {
+    private projectDir;
+    private sessionId;
+    private process;
+    private _pid;
+    private _isRunning;
+    private buffer;
+    /**
+     * Create a new ClaudeDaemon instance
+     * @param projectDir - Working directory for Claude Code
+     * @param sessionId - Unique session identifier
+     */
+    constructor(projectDir: string, sessionId: string);
+    /**
+     * Check if the daemon is currently running
+     */
+    get isRunning(): boolean;
+    /**
+     * Get the process ID
+     */
+    get pid(): number | null;
+    /**
+     * Spawn the Claude Code subprocess with stream-json mode
+     * @returns Promise that resolves when process is ready
+     * @throws Error if spawn fails or process is already running
+     */
+    spawn(): Promise<void>;
+    /**
+     * Send a message to Claude via stdin (stream-json format)
+     * @param message - Message to send
+     * @throws Error if process is not running
+     */
+    send(message: string): void;
+    /**
+     * Kill the Claude Code subprocess
+     * @param signal - Signal to send to process
+     */
+    kill(signal?: NodeJS.Signals): void;
+    /**
+     * Check if the daemon is currently running
+     * @returns True if running
+     */
+    isActive(): boolean;
+    /**
+     * Get the process ID
+     * @returns Process ID or null
+     */
+    getPid(): number | null;
+}
+//# sourceMappingURL=daemon.d.ts.map

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

@@ -0,0 +1,303 @@
+"use strict";
+/**
+ * @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
+ * import { ClaudeDaemon } from './daemon';
+ * const daemon = new ClaudeDaemon('/path/to/project', 'session_123');
+ * await daemon.spawn();
+ * daemon.send('Hello Claude!');
+ * daemon.on('output', (data) => console.log(data));
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeDaemon = exports.ANSI_REGEX = void 0;
+const events_1 = require("events");
+const child_process_1 = require("child_process");
+/**
+ * ANSI escape code regex pattern
+ */
+// eslint-disable-next-line no-control-regex
+exports.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 events_1.EventEmitter {
+    projectDir;
+    sessionId;
+    process;
+    _pid;
+    _isRunning;
+    buffer;
+    /**
+     * Create a new ClaudeDaemon instance
+     * @param projectDir - Working directory for Claude Code
+     * @param 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 = '';
+    }
+    /**
+     * Check if the daemon is currently running
+     */
+    get isRunning() {
+        return this._isRunning;
+    }
+    /**
+     * Get the process ID
+     */
+    get pid() {
+        return this._pid;
+    }
+    /**
+     * Spawn the Claude Code subprocess with stream-json mode
+     * @returns Promise that resolves when process is ready
+     * @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) => {
+            let settled = false;
+            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 = (0, child_process_1.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 || null;
+                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 {
+                                // 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(exports.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,
+                    });
+                    if (!settled) {
+                        settled = true;
+                        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,
+                    });
+                    // Reject if process exits before we resolve
+                    if (!settled) {
+                        settled = true;
+                        reject(new Error(`Process exited with code ${code} before ready`));
+                    }
+                });
+                // Process should be ready immediately in stream-json mode
+                setTimeout(() => {
+                    if (this._isRunning && !settled) {
+                        settled = true;
+                        resolve();
+                    }
+                }, 100);
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                console.error(`[MobileDaemon] Failed to spawn session ${this.sessionId}:`, error.message);
+                this._isRunning = false;
+                this.emit('error', {
+                    error,
+                    sessionId: this.sessionId,
+                });
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Send a message to Claude via stdin (stream-json format)
+     * @param 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 signal - 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);
+            // Note: exit event will be emitted by process.on('exit') handler
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            console.error(`[MobileDaemon] Error killing session ${this.sessionId}:`, error.message);
+            // Ensure state is consistent even if kill fails
+            this._isRunning = false;
+            this.emit('error', {
+                error,
+                sessionId: this.sessionId,
+            });
+        }
+    }
+    /**
+     * Check if the daemon is currently running
+     * @returns True if running
+     */
+    isActive() {
+        return this._isRunning && this.process !== null;
+    }
+    /**
+     * Get the process ID
+     * @returns Process ID or null
+     */
+    getPid() {
+        return this._pid;
+    }
+}
+exports.ClaudeDaemon = ClaudeDaemon;
+//# sourceMappingURL=daemon.js.map

package/dist/embedding-server/mobile/output-parser.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @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
+ * import { OutputParser } from './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
+ */
+export type MessageType = 'stream' | 'tool_use' | 'tool_complete' | 'complete' | 'error';
+/**
+ * Parsed output event
+ */
+export interface ParsedEvent {
+    type: MessageType;
+    text?: string;
+    tool?: string;
+    status?: string;
+    message?: string;
+    args?: string | null;
+}
+/**
+ * Tool detection result
+ */
+interface ToolDetectResult {
+    tool: string;
+    args: string | null;
+}
+/**
+ * Tool detection patterns
+ */
+export declare const TOOL_PATTERNS: RegExp[];
+/**
+ * Error patterns
+ */
+export declare const ERROR_PATTERNS: RegExp[];
+/**
+ * Completion/prompt patterns
+ */
+export declare const COMPLETE_PATTERNS: RegExp[];
+/**
+ * ANSI escape code regex pattern
+ */
+export declare const ANSI_REGEX: RegExp;
+/**
+ * OutputParser class - parses Claude Code stdout
+ */
+export declare class OutputParser {
+    private buffer;
+    private lastToolDetected;
+    /**
+     * Create a new OutputParser instance
+     */
+    constructor();
+    /**
+     * Parse a stdout chunk into events
+     * @param chunk - Raw stdout data
+     * @returns Array of parsed events
+     */
+    parse(chunk: string | Buffer): ParsedEvent[];
+    /**
+     * Remove ANSI escape codes from text
+     * @param text - Text with potential ANSI codes
+     * @returns Clean text
+     */
+    stripAnsi(text: string): string;
+    /**
+     * Detect tool usage pattern in text
+     * @param text - Text to analyze
+     * @returns Tool info or null
+     */
+    detectToolUse(text: string): ToolDetectResult | null;
+    /**
+     * Detect tool completion pattern in text
+     * @param text - Text to analyze
+     * @returns Tool name or null
+     */
+    detectToolComplete(text: string): string | null;
+    /**
+     * Detect completion pattern in text
+     * @param text - Text to analyze
+     * @returns True if completion detected
+     */
+    detectComplete(text: string): boolean;
+    /**
+     * Detect error pattern in text
+     * @param text - Text to analyze
+     * @returns Error message or null
+     */
+    detectError(text: string): string | null;
+    /**
+     * Flush any remaining buffer content
+     * @returns Remaining events
+     */
+    flush(): ParsedEvent[];
+    /**
+     * Reset the parser state
+     */
+    reset(): void;
+    /**
+     * Get current buffer content
+     * @returns Buffer content
+     */
+    getBuffer(): string;
+}
+export {};
+//# sourceMappingURL=output-parser.d.ts.map