teleportation-cli 1.0.0

package/lib/machine-coders/gemini-cli-adapter.js

@@ -0,0 +1,406 @@
+/**
+ * Gemini CLI Adapter
+ * 
+ * Adapter for Gemini CLI using wrapper-based approval.
+ * 
+ * NOTE: Gemini CLI Hooks v1 (Issue #9070) is proposed but not yet fully
+ * implemented in v0.19.x. The hooks in .gemini/hooks/ are ready for when
+ * native hooks become available. Until then, we use wrapper mode.
+ * 
+ * Current approach (WRAPPER MODE):
+ * - Uses --output-format stream-json for real-time event parsing
+ * - Parses tool_use events from stream
+ * - Can kill process if tool is denied (tool may have started)
+ * - Approval callback invoked when tool_use event is detected
+ * 
+ * Future approach (NATIVE HOOKS - when available):
+ * - Configure .gemini/settings.json with hooks.BeforeTool
+ * - True pre-execution approval like Claude Code
+ * - Hooks in .gemini/hooks/ ready to use
+ * 
+ * Key characteristics:
+ * - Supports --yolo for auto-approve mode
+ * - 1M token context window (great for large repos)
+ * 
+ * @see .gemini/hooks/ for hook implementations (ready for native hooks)
+ */
+
+import { spawn } from 'child_process';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { createInterface } from 'readline';
+import { MachineCoder, CODER_NAMES } from './interface.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if a command exists on the system
+ * @param {string} command
+ * @returns {Promise<boolean>}
+ */
+async function commandExists(command) {
+  try {
+    await execAsync(`which ${command}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Gemini CLI Adapter
+ */
+export class GeminiCliAdapter extends MachineCoder {
+  name = CODER_NAMES.GEMINI_CLI;
+  displayName = 'Gemini CLI';
+  
+  // Track running processes for stop()
+  #runningProcesses = new Map();
+  
+  /**
+   * Check if Gemini CLI is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    return commandExists('gemini');
+  }
+  
+  /**
+   * Get Gemini CLI status
+   * @returns {Promise<Object>}
+   */
+  async getStatus() {
+    const available = await this.isAvailable();
+    
+    if (!available) {
+      return { available: false };
+    }
+    
+    try {
+      const { stdout } = await execAsync('gemini --version');
+      return {
+        available: true,
+        version: stdout.trim(),
+        models: [
+          'gemini-2.5-flash',
+          'gemini-2.5-flash-lite',
+          'gemini-2.5-pro',
+          'gemini-3-pro-preview',
+        ],
+      };
+    } catch {
+      return { available: true };
+    }
+  }
+  
+  /**
+   * Execute a task with Gemini CLI
+   * 
+   * Uses streaming JSON output to parse events in real-time.
+   * Can intercept tool_use events for approval.
+   * 
+   * @param {Object} options
+   * @returns {Promise<Object>}
+   */
+  async execute(options) {
+    const {
+      projectPath,
+      sessionId,
+      prompt,
+      onToolCall,
+      onProgress,
+      timeoutMs = 600000, // 10 min default
+      autoApprove = false,
+      model,
+    } = options;
+    
+    const executionId = `gemini-${Date.now()}`;
+    const args = [];
+    
+    // Add prompt
+    args.push('--prompt', prompt);
+    
+    // Streaming JSON output for event parsing
+    args.push('--output-format', 'stream-json');
+    
+    // Model selection
+    if (model) {
+      args.push('--model', model);
+    }
+    
+    // Auto-approve mode
+    if (autoApprove) {
+      args.push('--yolo');
+    }
+    
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      const toolCalls = [];
+      let finalOutput = '';
+      let finalStats = {};
+      let geminiSessionId = null;
+      let processKilled = false; // Flag to prevent race condition after kill
+      
+      const proc = spawn('gemini', args, {
+        cwd: projectPath,
+        env: {
+          ...process.env,
+          // Pass session ID for potential future hook integration
+          TELEPORTATION_SESSION_ID: sessionId,
+        },
+      });
+      
+      this.#runningProcesses.set(executionId, proc);
+      
+      // Timeout handling
+      const timeout = setTimeout(() => {
+        proc.kill('SIGTERM');
+        reject(new Error(`Execution timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      
+      // Parse JSONL stream line by line
+      const rl = createInterface({
+        input: proc.stdout,
+        crlfDelay: Infinity,
+      });
+      
+      rl.on('line', async (line) => {
+        if (!line.trim()) return;
+        if (processKilled) return; // Skip processing if process was killed
+        
+        try {
+          const event = JSON.parse(line);
+          
+          // Handle different event types
+          switch (event.type) {
+            case 'init':
+              geminiSessionId = event.session_id;
+              onProgress?.({
+                type: 'init',
+                timestamp: Date.now(),
+                data: {
+                  sessionId: event.session_id,
+                  model: event.model,
+                },
+              });
+              break;
+              
+            case 'message':
+              if (event.role === 'assistant') {
+                finalOutput = event.content || finalOutput;
+              }
+              onProgress?.({
+                type: 'message',
+                timestamp: Date.now(),
+                data: {
+                  role: event.role,
+                  content: event.content,
+                },
+              });
+              break;
+              
+            case 'tool_use':
+              const toolCall = {
+                id: event.tool_id || `tool-${toolCalls.length}`,
+                tool: event.tool_name,
+                input: event.parameters,
+                timestamp: Date.now(),
+              };
+              toolCalls.push(toolCall);
+              
+              onProgress?.({
+                type: 'tool_use',
+                timestamp: Date.now(),
+                data: toolCall,
+              });
+              
+              // Check approval if callback provided and not in auto-approve mode
+              if (onToolCall && !autoApprove) {
+                try {
+                  const decision = await onToolCall(toolCall);
+                  
+                  if (decision === 'deny') {
+                    // Kill the process - tool was denied
+                    processKilled = true; // Set flag to prevent race condition
+                    proc.kill('SIGTERM');
+                    clearTimeout(timeout);
+                    this.#runningProcesses.delete(executionId);
+                    
+                    resolve({
+                      success: false,
+                      output: finalOutput,
+                      error: `Tool '${toolCall.tool}' was denied`,
+                      toolCalls,
+                      stats: {
+                        durationMs: Date.now() - startTime,
+                        model: finalStats.model,
+                      },
+                      executionId,
+                      geminiSessionId,
+                    });
+                    return;
+                  }
+                } catch (err) {
+                  console.error(`[gemini-adapter] Error checking tool approval: ${err.message}`);
+                  // Continue on error - fail-safe to allow
+                }
+              }
+              break;
+              
+            case 'tool_result':
+              onProgress?.({
+                type: 'tool_result',
+                timestamp: Date.now(),
+                data: {
+                  toolId: event.tool_id,
+                  status: event.status,
+                  output: event.output,
+                },
+              });
+              break;
+              
+            case 'error':
+              onProgress?.({
+                type: 'error',
+                timestamp: Date.now(),
+                data: {
+                  message: event.message || event.error,
+                },
+              });
+              break;
+              
+            case 'result':
+              // Final result with stats
+              finalStats = {
+                tokensUsed: event.stats?.total_tokens,
+                inputTokens: event.stats?.input_tokens,
+                outputTokens: event.stats?.output_tokens,
+                durationMs: event.stats?.duration_ms,
+                toolCallCount: event.stats?.tool_calls,
+                model: event.stats?.model,
+              };
+              onProgress?.({
+                type: 'done',
+                timestamp: Date.now(),
+                data: finalStats,
+              });
+              break;
+          }
+        } catch (err) {
+          // Not valid JSON - might be raw output
+          onProgress?.({
+            type: 'output',
+            timestamp: Date.now(),
+            data: { text: line },
+          });
+        }
+      });
+      
+      let stderr = '';
+      proc.stderr.on('data', (data) => {
+        stderr += data.toString();
+        onProgress?.({
+          type: 'stderr',
+          timestamp: Date.now(),
+          data: { text: data.toString() },
+        });
+      });
+      
+      proc.on('close', (code) => {
+        clearTimeout(timeout);
+        this.#runningProcesses.delete(executionId);
+        
+        const durationMs = Date.now() - startTime;
+        
+        resolve({
+          success: code === 0,
+          output: finalOutput,
+          error: code !== 0 ? stderr || `Exit code: ${code}` : undefined,
+          toolCalls,
+          stats: {
+            ...finalStats,
+            durationMs: finalStats.durationMs || durationMs,
+          },
+          executionId,
+          geminiSessionId,
+        });
+      });
+      
+      proc.on('error', (err) => {
+        clearTimeout(timeout);
+        this.#runningProcesses.delete(executionId);
+        reject(err);
+      });
+    });
+  }
+  
+  /**
+   * Resume a Gemini session with a new prompt
+   * @param {string} sessionId - Gemini session ID to resume
+   * @param {string} prompt - New prompt
+   * @param {Object} options - Additional options
+   * @returns {Promise<Object>}
+   */
+  async resume(sessionId, prompt, options = {}) {
+    const {
+      projectPath = process.cwd(),
+      onToolCall,
+      onProgress,
+      timeoutMs = 600000,
+      autoApprove = false,
+      model,
+    } = options;
+    
+    const executionId = `gemini-resume-${Date.now()}`;
+    const args = ['--resume', sessionId, '--prompt', prompt, '--output-format', 'stream-json'];
+    
+    if (model) {
+      args.push('--model', model);
+    }
+    
+    if (autoApprove) {
+      args.push('--yolo');
+    }
+    
+    // Reuse execute logic with resume flag
+    return this.execute({
+      ...options,
+      projectPath,
+      prompt: `--resume ${sessionId} ${prompt}`, // Hack: will be overridden by args
+    });
+  }
+  
+  /**
+   * Stop a running execution
+   * @param {string} executionId
+   * @returns {Promise<boolean>}
+   */
+  async stop(executionId) {
+    const proc = this.#runningProcesses.get(executionId);
+    if (proc) {
+      proc.kill('SIGTERM');
+      this.#runningProcesses.delete(executionId);
+      return true;
+    }
+    return false;
+  }
+  
+  /**
+   * Get capabilities
+   * @returns {Object}
+   */
+  getCapabilities() {
+    return {
+      supportsResume: true,
+      supportsStreaming: true,
+      hasNativeApproval: false, // Native hooks proposed (Issue #9070) but not yet in v0.19.x
+      supportsModelSelection: true,
+      maxContextTokens: 1000000, // 1M tokens!
+      supportedTools: ['Bash', 'Read', 'Edit', 'Write', 'Glob', 'Grep', 'LS', 'WebSearch', 'WebFetch'],
+      // Hooks ready in .gemini/hooks/ for when native hooks become available
+      pendingNativeHooks: ['BeforeTool', 'AfterTool', 'SessionStart', 'SessionEnd'],
+    };
+  }
+}
+
+export default GeminiCliAdapter;

package/lib/machine-coders/index.js

@@ -0,0 +1,103 @@
+/**
+ * Machine Coders Module
+ * 
+ * Unified interface for different AI coding assistants:
+ * - Claude Code (via hooks)
+ * - Gemini CLI (via wrapper + streaming)
+ * - Goose CLI (via recipes)
+ * 
+ * @module lib/machine-coders
+ */
+
+export { MachineCoder, CODER_NAMES } from './interface.js';
+export { ClaudeCodeAdapter } from './claude-code-adapter.js';
+export { GeminiCliAdapter } from './gemini-cli-adapter.js';
+// export { GooseCliAdapter } from './goose-cli-adapter.js'; // TODO: implement
+
+/**
+ * Get a machine coder adapter by name
+ * @param {string} name - 'claude-code' | 'gemini-cli' | 'goose-cli'
+ * @returns {MachineCoder}
+ */
+export function getMachineCoder(name) {
+  switch (name) {
+    case 'claude-code':
+      const { ClaudeCodeAdapter } = require('./claude-code-adapter.js');
+      return new ClaudeCodeAdapter();
+    case 'gemini-cli':
+      const { GeminiCliAdapter } = require('./gemini-cli-adapter.js');
+      return new GeminiCliAdapter();
+    // case 'goose-cli':
+    //   const { GooseCliAdapter } = require('./goose-cli-adapter.js');
+    //   return new GooseCliAdapter();
+    default:
+      return null;
+  }
+}
+
+/**
+ * Get all available machine coders on this system
+ * @returns {Promise<MachineCoder[]>}
+ */
+export async function getAvailableCoders() {
+  const { ClaudeCodeAdapter } = await import('./claude-code-adapter.js');
+  const { GeminiCliAdapter } = await import('./gemini-cli-adapter.js');
+  
+  const coders = [
+    new ClaudeCodeAdapter(),
+    new GeminiCliAdapter(),
+  ];
+  
+  const available = [];
+  for (const coder of coders) {
+    if (await coder.isAvailable()) {
+      available.push(coder);
+    }
+  }
+  
+  return available;
+}
+
+/**
+ * Get the best available machine coder for a task
+ * Priority: Claude Code > Gemini CLI > Goose CLI
+ * 
+ * @param {Object} [preferences] - Optional preferences
+ * @param {string} [preferences.preferred] - Preferred coder name
+ * @param {boolean} [preferences.largeContext] - Prefer large context (Gemini)
+ * @returns {Promise<MachineCoder|null>}
+ */
+export async function getBestCoder(preferences = {}) {
+  const available = await getAvailableCoders();
+  
+  if (available.length === 0) {
+    return null;
+  }
+  
+  // If preferred coder is specified and available, use it
+  if (preferences.preferred) {
+    const preferred = available.find(c => c.name === preferences.preferred);
+    if (preferred) return preferred;
+  }
+  
+  // If large context needed, prefer Gemini
+  if (preferences.largeContext) {
+    const gemini = available.find(c => c.name === 'gemini-cli');
+    if (gemini) return gemini;
+  }
+  
+  // Default priority: Claude Code first
+  const priority = ['claude-code', 'gemini-cli', 'goose-cli'];
+  for (const name of priority) {
+    const coder = available.find(c => c.name === name);
+    if (coder) return coder;
+  }
+  
+  return available[0];
+}
+
+export default {
+  getMachineCoder,
+  getAvailableCoders,
+  getBestCoder,
+};

package/lib/machine-coders/interface.js

@@ -0,0 +1,168 @@
+/**
+ * Machine Coder Interface
+ * 
+ * Defines the common interface that all machine coders must implement.
+ * This allows Teleportation to work with Claude Code, Gemini CLI, Goose CLI,
+ * and future coding assistants in a uniform way.
+ */
+
+/**
+ * Known machine coder names
+ */
+export const CODER_NAMES = {
+  CLAUDE_CODE: 'claude-code',
+  GEMINI_CLI: 'gemini-cli',
+  GOOSE_CLI: 'goose-cli',
+};
+
+/**
+ * Tool call event (when the coder wants to use a tool)
+ * @typedef {Object} ToolCall
+ * @property {string} id - Unique ID for this tool call
+ * @property {string} tool - Tool name (e.g., 'Bash', 'Edit', 'Read')
+ * @property {Object} input - Tool input parameters
+ * @property {number} timestamp - When the tool was called
+ */
+
+/**
+ * Progress event (streaming updates from the coder)
+ * @typedef {Object} ProgressEvent
+ * @property {string} type - Event type: 'init' | 'message' | 'tool_use' | 'tool_result' | 'error' | 'done'
+ * @property {number} timestamp - Event timestamp
+ * @property {Object} [data] - Event-specific data
+ */
+
+/**
+ * Execution options
+ * @typedef {Object} ExecuteOptions
+ * @property {string} projectPath - Path to the project directory
+ * @property {string} sessionId - Teleportation session ID
+ * @property {string} prompt - The task/prompt to execute
+ * @property {Function} [onToolCall] - Callback for tool approval: (tool: ToolCall) => Promise<'allow' | 'deny' | 'ask'>
+ * @property {Function} [onProgress] - Callback for progress events: (event: ProgressEvent) => void
+ * @property {number} [timeoutMs] - Execution timeout in milliseconds
+ * @property {boolean} [autoApprove] - Skip approval checks (dangerous)
+ * @property {string} [model] - Specific model to use (if supported)
+ */
+
+/**
+ * Execution result
+ * @typedef {Object} ExecuteResult
+ * @property {boolean} success - Whether execution completed successfully
+ * @property {string} output - Final output/response
+ * @property {string} [error] - Error message if failed
+ * @property {ToolCall[]} toolCalls - List of tools that were called
+ * @property {Object} [stats] - Execution statistics
+ * @property {number} [stats.tokensUsed] - Total tokens used
+ * @property {number} [stats.cost] - Estimated cost in USD
+ * @property {number} [stats.durationMs] - Execution duration
+ * @property {string} [stats.model] - Model that was used
+ */
+
+/**
+ * Coder status
+ * @typedef {Object} CoderStatus
+ * @property {boolean} available - Whether the coder is available
+ * @property {string} [version] - CLI version
+ * @property {string[]} [models] - Available models
+ * @property {Object} [config] - Current configuration
+ */
+
+/**
+ * Base Machine Coder class
+ * All adapters should extend this class.
+ */
+export class MachineCoder {
+  /**
+   * Unique identifier for this coder
+   * @type {string}
+   */
+  name = 'base';
+  
+  /**
+   * Human-readable display name
+   * @type {string}
+   */
+  displayName = 'Base Machine Coder';
+  
+  /**
+   * Check if this coder is available on the system
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    throw new Error('Not implemented');
+  }
+  
+  /**
+   * Get the current status of this coder
+   * @returns {Promise<CoderStatus>}
+   */
+  async getStatus() {
+    return {
+      available: await this.isAvailable(),
+    };
+  }
+  
+  /**
+   * Execute a task/prompt
+   * @param {ExecuteOptions} options
+   * @returns {Promise<ExecuteResult>}
+   */
+  async execute(options) {
+    throw new Error('Not implemented');
+  }
+  
+  /**
+   * Resume a previous session with a new prompt
+   * @param {string} sessionId - Session to resume
+   * @param {string} prompt - New prompt/task
+   * @param {ExecuteOptions} [options] - Additional options
+   * @returns {Promise<ExecuteResult>}
+   */
+  async resume(sessionId, prompt, options = {}) {
+    // Default implementation: just execute with the prompt
+    // Subclasses can override for proper session resume
+    return this.execute({
+      ...options,
+      sessionId,
+      prompt,
+    });
+  }
+  
+  /**
+   * Stop/kill a running execution
+   * @param {string} executionId - Execution to stop
+   * @returns {Promise<boolean>}
+   */
+  async stop(executionId) {
+    throw new Error('Not implemented');
+  }
+  
+  /**
+   * Get capabilities of this coder
+   * @returns {Object}
+   */
+  getCapabilities() {
+    return {
+      // Whether this coder supports session resume
+      supportsResume: false,
+      
+      // Whether this coder supports streaming output
+      supportsStreaming: false,
+      
+      // Whether this coder has native approval hooks
+      hasNativeApproval: false,
+      
+      // Whether this coder supports model selection
+      supportsModelSelection: false,
+      
+      // Maximum context size (tokens)
+      maxContextTokens: 0,
+      
+      // Supported tools
+      supportedTools: [],
+    };
+  }
+}
+
+export default MachineCoder;