@jungjaehoon/mama-core 2.4.1 → 4.1.0

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

@@ -1,129 +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
- * 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;
-    private cliSessionId;
-    /**
-     * 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

@@ -1,313 +0,0 @@
-"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 crypto_1 = require("crypto");
-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;
-    cliSessionId;
-    /**
-     * 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 = '';
-        this.cliSessionId = (0, crypto_1.randomUUID)();
-    }
-    /**
-     * 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 {
-                // Requires a modern Claude CLI build with stream-json support
-                // for --print/--verbose/--session-id/--setting-sources.
-                const args = [
-                    '--print',
-                    '--verbose',
-                    '--dangerously-skip-permissions',
-                    '--input-format',
-                    'stream-json',
-                    '--output-format',
-                    'stream-json',
-                    '--session-id',
-                    this.cliSessionId,
-                    '--setting-sources',
-                    'project,local',
-                ];
-                // 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

@@ -1,115 +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
- * 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