gthinking 1.2.1 → 2.1.1

package/src/llm/llm-service.ts

@@ -0,0 +1,285 @@
+/**
+ * LLM Service for GThinking v2.0.0
+ * 
+ * Secure LLM service that uses HTTP APIs instead of command-line
+ * to prevent command injection vulnerabilities.
+ * 
+ * @module llm/llm-service
+ */
+
+import type { ILLMProvider, LLMMessage, LLMRequestOptions, LLMResponse, LLMStreamChunk } from './providers/base';
+import { GeminiProvider } from './providers/gemini';
+import { CLIProvider } from './providers/cli';
+import { sanitizePrompt, validatePrompt } from './sanitization';
+import { LLMError } from '../core/errors';
+import { logger, createComponentLogger } from '../utils/logger';
+import type { EngineConfig } from '../types/core';
+
+/**
+ * LLM service configuration
+ */
+export interface LLMServiceConfig {
+  provider: 'gemini' | 'claude' | 'openai' | 'cli';
+  apiKey?: string;
+  model?: string;
+  cliCommand?: string;
+  cliArgs?: string[];
+  cliPromptPassingMethod?: 'stdin' | 'arg';
+  cliPromptFlag?: string;
+  timeoutMs?: number;
+  maxRetries?: number;
+}
+
+/**
+ * LLM Service
+ * 
+ * Provides a unified interface for interacting with various LLM providers
+ * with built-in security measures including input sanitization.
+ */
+export class LLMService {
+  private provider: ILLMProvider | null = null;
+  private readonly logger = createComponentLogger('LLMService');
+
+  /**
+   * Create a new LLM service
+   * 
+   * @param config - LLM service configuration
+   */
+  constructor(config: LLMServiceConfig) {
+    this.initializeProvider(config);
+  }
+
+  /**
+   * Create LLM service from engine configuration
+   * 
+   * @param config - Engine configuration
+   * @returns LLM service instance
+   */
+  static fromConfig(config: EngineConfig): LLMService {
+    const apiKey = config.llmApiKey;
+    
+    // Only require API key if NOT using CLI provider
+    if (config.llmProvider !== 'cli' && (apiKey === undefined || apiKey === '')) {
+      throw new LLMError('LLM API key not configured', config.llmProvider);
+    }
+
+    return new LLMService({
+      provider: config.llmProvider as any,
+      apiKey,
+      model: config.llmModel,
+      cliCommand: config.llmCliCommand || 'gemini', // Pass the command from config
+      cliArgs: config.llmCliArgs,
+      cliPromptPassingMethod: config.llmCliPromptPassingMethod,
+      cliPromptFlag: config.llmCliPromptFlag,
+      timeoutMs: config.llmTimeoutMs,
+      maxRetries: config.llmMaxRetries,
+    });
+  }
+
+  /**
+   * Complete a prompt with the LLM
+   * 
+   * @param prompt - User prompt
+   * @param systemPrompt - Optional system prompt
+   * @param options - Request options
+   * @returns LLM response
+   */
+  async complete(
+    prompt: string,
+    systemPrompt?: string,
+    options: LLMRequestOptions = {}
+  ): Promise<string> {
+    this.ensureProvider();
+
+    // Sanitize inputs
+    const sanitizedPrompt = sanitizePrompt(prompt);
+    const sanitizedSystemPrompt = systemPrompt ? sanitizePrompt(systemPrompt) : undefined;
+
+    // Validate inputs
+    const validation = validatePrompt(sanitizedPrompt);
+    if (!validation.safe) {
+      this.logger.warn('Prompt validation warnings', { issues: validation.issues });
+    }
+
+    const messages: LLMMessage[] = [];
+    
+    if (sanitizedSystemPrompt !== undefined) {
+      messages.push({ role: 'system', content: sanitizedSystemPrompt });
+    }
+    
+    messages.push({ role: 'user', content: sanitizedPrompt });
+
+    this.logger.debug('Sending completion request', { 
+      provider: this.provider!.name,
+      model: options.model,
+    });
+
+    const response = await this.provider!.complete(messages, options);
+    
+    return response.content;
+  }
+
+  /**
+   * Stream a prompt completion from the LLM
+   * 
+   * @param prompt - User prompt
+   * @param systemPrompt - Optional system prompt
+   * @param options - Request options
+   * @returns Async generator of stream chunks
+   */
+  async *stream(
+    prompt: string,
+    systemPrompt?: string,
+    options: LLMRequestOptions = {}
+  ): AsyncGenerator<string> {
+    this.ensureProvider();
+
+    // Sanitize inputs
+    const sanitizedPrompt = sanitizePrompt(prompt);
+    const sanitizedSystemPrompt = systemPrompt ? sanitizePrompt(systemPrompt) : undefined;
+
+    const messages: LLMMessage[] = [];
+    
+    if (sanitizedSystemPrompt !== undefined) {
+      messages.push({ role: 'system', content: sanitizedSystemPrompt });
+    }
+    
+    messages.push({ role: 'user', content: sanitizedPrompt });
+
+    this.logger.debug('Starting stream request', { 
+      provider: this.provider!.name,
+      model: options.model,
+    });
+
+    for await (const chunk of this.provider!.stream(messages, options)) {
+      if (chunk.content) {
+        yield chunk.content;
+      }
+    }
+  }
+
+  /**
+   * Complete with structured messages
+   * 
+   * @param messages - Array of messages
+   * @param options - Request options
+   * @returns LLM response
+   */
+  async completeMessages(
+    messages: LLMMessage[],
+    options: LLMRequestOptions = {}
+  ): Promise<LLMResponse> {
+    this.ensureProvider();
+
+    // Sanitize all messages
+    const sanitizedMessages = messages.map(msg => ({
+      ...msg,
+      content: sanitizePrompt(msg.content),
+    }));
+
+    this.logger.debug('Sending messages completion request', { 
+      provider: this.provider!.name,
+      messageCount: sanitizedMessages.length,
+    });
+
+    return this.provider!.complete(sanitizedMessages, options);
+  }
+
+  /**
+   * Check if the service is properly configured
+   * 
+   * @returns True if configured correctly
+   */
+  isConfigured(): boolean {
+    return this.provider !== null && this.provider.validateConfig();
+  }
+
+  /**
+   * Get the current provider name
+   * 
+   * @returns Provider name or null
+   */
+  getProviderName(): string | null {
+    return this.provider?.name ?? null;
+  }
+
+  /**
+   * Get available models for the current provider
+   * 
+   * @returns Array of model names
+   */
+  getAvailableModels(): string[] {
+    return this.provider?.availableModels ?? [];
+  }
+
+  /**
+   * Initialize the LLM provider
+   * 
+   * @param config - Service configuration
+   */
+  private initializeProvider(config: LLMServiceConfig): void {
+    switch (config.provider) {
+      case 'gemini':
+        this.provider = new GeminiProvider({
+          apiKey: config.apiKey,
+          model: config.model,
+          timeoutMs: config.timeoutMs,
+          maxRetries: config.maxRetries,
+        });
+        break;
+      
+      case 'claude':
+        // Claude provider would be implemented here
+        throw new LLMError('Claude provider not yet implemented', 'claude');
+      
+      case 'openai':
+        // OpenAI provider would be implemented here
+        throw new LLMError('OpenAI provider not yet implemented', 'openai');
+
+      case 'cli':
+        // Auto-configure defaults for known tools if not specified
+        let promptMethod = config.cliPromptPassingMethod || 'stdin';
+        let promptFlag = config.cliPromptFlag;
+        
+        // Smart defaults for Gemini if using cli command 'gemini'
+        if (config.cliCommand === 'gemini' && !config.cliPromptPassingMethod) {
+            promptMethod = 'arg';
+            promptFlag = '-p';
+        }
+
+        this.provider = new CLIProvider({
+            command: config.cliCommand || 'gemini',
+            args: config.cliArgs,
+            promptPassingMethod: promptMethod,
+            promptFlag: promptFlag,
+            timeoutMs: config.timeoutMs,
+            maxRetries: config.maxRetries
+        });
+        break;
+      
+      default:
+        throw new LLMError(`Unknown provider: ${config.provider}`, String(config.provider));
+    }
+
+    this.logger.info('LLM provider initialized', { provider: config.provider });
+  }
+
+  /**
+   * Ensure provider is initialized
+   */
+  private ensureProvider(): void {
+    if (this.provider === null) {
+      throw new LLMError('LLM provider not initialized', 'unknown');
+    }
+  }
+}
+
+/**
+ * Create an LLM service from configuration
+ * 
+ * @param config - Engine configuration
+ * @returns LLM service instance
+ */
+export function createLLMService(config: EngineConfig): LLMService {
+  return LLMService.fromConfig(config);
+}

package/src/llm/providers/base.ts

@@ -0,0 +1,146 @@
+/**
+ * Base LLM Provider Interface
+ * 
+ * @module llm/providers/base
+ */
+
+import type { LLMError } from '../../core/errors';
+
+/**
+ * LLM message role
+ */
+export type MessageRole = 'system' | 'user' | 'assistant';
+
+/**
+ * LLM message
+ */
+export interface LLMMessage {
+  role: MessageRole;
+  content: string;
+}
+
+/**
+ * LLM request options
+ */
+export interface LLMRequestOptions {
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+  topP?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  stopSequences?: string[];
+  timeoutMs?: number;
+}
+
+/**
+ * LLM response
+ */
+export interface LLMResponse {
+  content: string;
+  model: string;
+  usage: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+  finishReason: string;
+}
+
+/**
+ * LLM stream chunk
+ */
+export interface LLMStreamChunk {
+  content: string;
+  isComplete: boolean;
+}
+
+/**
+ * Base LLM provider interface
+ */
+export interface ILLMProvider {
+  readonly name: string;
+  readonly availableModels: string[];
+  
+  complete(messages: LLMMessage[], options?: LLMRequestOptions): Promise<LLMResponse>;
+  stream(messages: LLMMessage[], options?: LLMRequestOptions): AsyncGenerator<LLMStreamChunk>;
+  validateConfig(): boolean;
+}
+
+/**
+ * Base LLM provider class
+ */
+export abstract class BaseLLMProvider implements ILLMProvider {
+  abstract readonly name: string;
+  abstract readonly availableModels: string[];
+  
+  protected apiKey: string;
+  protected baseUrl: string;
+  protected defaultModel: string;
+  protected timeoutMs: number;
+  protected maxRetries: number;
+
+  constructor(config: {
+    apiKey: string;
+    baseUrl: string;
+    defaultModel: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+  }) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl;
+    this.defaultModel = config.defaultModel;
+    this.timeoutMs = config.timeoutMs ?? 30000;
+    this.maxRetries = config.maxRetries ?? 3;
+  }
+
+  abstract complete(
+    messages: LLMMessage[],
+    options?: LLMRequestOptions
+  ): Promise<LLMResponse>;
+
+  abstract stream(
+    messages: LLMMessage[],
+    options?: LLMRequestOptions
+  ): AsyncGenerator<LLMStreamChunk>;
+
+  validateConfig(): boolean {
+    return this.apiKey.length > 0 && this.baseUrl.length > 0;
+  }
+
+  protected getModel(options?: LLMRequestOptions): string {
+    return options?.model ?? this.defaultModel;
+  }
+
+  protected async withRetry<T>(
+    operation: () => Promise<T>,
+    retries = this.maxRetries
+  ): Promise<T> {
+    let lastError: Error | undefined;
+    
+    for (let i = 0; i <= retries; i++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error as Error;
+        
+        // Don't retry on certain errors
+        if (this.isNonRetryableError(error)) {
+          throw error;
+        }
+        
+        if (i < retries) {
+          const delay = Math.pow(2, i) * 1000; // Exponential backoff
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
+    }
+    
+    throw lastError;
+  }
+
+  protected isNonRetryableError(error: unknown): boolean {
+    // Override in subclasses for provider-specific logic
+    return false;
+  }
+}

package/src/llm/providers/cli.ts

@@ -0,0 +1,186 @@
+
+import { spawn } from 'child_process';
+import { BaseLLMProvider, type LLMMessage, type LLMRequestOptions, type LLMResponse, type LLMStreamChunk } from './base';
+import { LLMError } from '../../core/errors';
+import { logger } from '../../utils/logger';
+
+export interface CLIConfig {
+  command: string; // e.g., 'gemini', 'claude'
+  args?: string[];
+  promptPassingMethod?: 'stdin' | 'arg';
+  promptFlag?: string; // e.g. '-p'
+  timeoutMs?: number;
+  maxRetries?: number;
+}
+
+export class CLIProvider extends BaseLLMProvider {
+  readonly name = 'cli';
+  readonly availableModels = ['local-default']; // CLI usually handles the model selection internally or via args
+  private command: string;
+  private defaultArgs: string[];
+  private promptPassingMethod: 'stdin' | 'arg';
+  private promptFlag?: string;
+
+  constructor(config: CLIConfig) {
+    super({
+        apiKey: 'local-auth', // Placeholder for base class requirement
+        baseUrl: 'local',     // Placeholder
+        defaultModel: 'default',
+        timeoutMs: config.timeoutMs,
+        maxRetries: config.maxRetries
+    });
+    this.command = config.command;
+    this.defaultArgs = config.args || [];
+    this.promptPassingMethod = config.promptPassingMethod || 'stdin';
+    this.promptFlag = config.promptFlag;
+  }
+
+  // Helper to extract the actual prompt from messages
+  // CLIs usually accept a single prompt string, not a full chat history JSON
+  private getPromptText(messages: LLMMessage[]): string {
+    // Strategy: Concatenate system prompt and user messages
+    return messages.map(m => {
+        if (m.role === 'system') return `System: ${m.content}\n`;
+        if (m.role === 'user') return `User: ${m.content}\n`;
+        return `Assistant: ${m.content}\n`;
+    }).join('\n') + "\nResponse:";
+  }
+  
+  // Strategy for simple CLIs (like 'gemini "prompt"'):
+  // If the CLI accepts the prompt as the last argument
+  private getLatestPrompt(messages: LLMMessage[]): string {
+      const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
+      return lastUserMsg ? lastUserMsg.content : '';
+  }
+
+  async complete(
+    messages: LLMMessage[],
+    options: LLMRequestOptions = {}
+  ): Promise<LLMResponse> {
+    return this.withRetry(async () => {
+      const prompt = this.getLatestPrompt(messages);
+      
+      let args = [...this.defaultArgs];
+      
+      // Handle Prompt passing logic
+      if (this.promptPassingMethod === 'arg') {
+          if (this.promptFlag) {
+              args.push(this.promptFlag);
+          }
+          args.push(prompt);
+      }
+
+      return new Promise((resolve, reject) => {
+        logger.debug(`Executing CLI command: ${this.command}`, { args, method: this.promptPassingMethod });
+
+        const child = spawn(this.command, args, {
+            env: { ...process.env }, 
+            shell: false,
+            stdio: ['pipe', 'pipe', 'pipe'] 
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+
+        child.on('close', (code) => {
+            if (code !== 0) {
+                logger.error(`CLI execution failed`, { code, stderr });
+                reject(new LLMError(`CLI command failed with code ${code}: ${stderr}`, 'cli'));
+            } else {
+                resolve({
+                    content: stdout.trim(),
+                    model: 'cli-default',
+                    usage: {
+                        promptTokens: 0,
+                        completionTokens: 0,
+                        totalTokens: 0
+                    },
+                    finishReason: 'stop'
+                });
+            }
+        });
+
+        child.on('error', (err) => {
+            reject(new LLMError(`Failed to spawn CLI process: ${err.message}`, 'cli'));
+        });
+
+        // Only write to stdin if configured to do so
+        if (this.promptPassingMethod === 'stdin') {
+            child.stdin.write(prompt);
+            child.stdin.end();
+        } else {
+            // Even if passing by arg, we should end stdin to prevent hanging if process reads stdin
+            child.stdin.end();
+        }
+      });
+    });
+  }
+
+  async *stream(
+    messages: LLMMessage[],
+    options: LLMRequestOptions = {}
+  ): AsyncGenerator<LLMStreamChunk> {
+      const prompt = this.getLatestPrompt(messages);
+      let args = [...this.defaultArgs];
+
+      if (this.promptPassingMethod === 'arg') {
+          if (this.promptFlag) {
+              args.push(this.promptFlag);
+          }
+          args.push(prompt);
+      }
+      
+      const child = spawn(this.command, args, {
+          env: { ...process.env },
+          shell: false,
+          stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      if (this.promptPassingMethod === 'stdin') {
+          child.stdin.write(prompt);
+          child.stdin.end();
+      } else {
+          child.stdin.end();
+      }
+
+      // Use a manual iterator to handle backpressure properly would require
+      // implementing a ReadableStream-like behavior or simply yielding as we get data.
+      // For simplicity and effectiveness in this context, we'll iterate over the stdout stream.
+      
+      try {
+        for await (const chunk of child.stdout) {
+          yield {
+            content: chunk.toString(),
+            isComplete: false
+          };
+        }
+        
+        // Wait for process to exit to check for errors
+        await new Promise<void>((resolve, reject) => {
+            child.on('close', (code) => {
+                if (code !== 0) {
+                     // We can capture stderr here if needed, but for stream we just end
+                     // Ideally we would have collected stderr separately
+                     reject(new LLMError(`CLI stream failed with code ${code}`, 'cli'));
+                } else {
+                    resolve();
+                }
+            });
+            child.on('error', reject);
+        });
+
+        yield { content: '', isComplete: true };
+
+      } catch (error) {
+         throw new LLMError(`Stream error: ${(error as Error).message}`, 'cli');
+      }
+  }
+}