@gotza02/seq-thinking 1.1.4 → 1.1.6

package/src/utils/llm-adapter.ts

@@ -1,110 +0,0 @@
-/**
- * LLM Adapter to call external CLI tools via child_process
- * @module utils/llm-adapter
- */
-
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { Logger } from './logger.js';
-
-const execAsync = promisify(exec);
-
-export interface LLMResponse {
-  content: string;
-  error?: string;
-}
-
-export class LLMAdapter {
-  /**
-   * Main entry point to call an LLM based on provider pool
-   */
-  static async call(prompt: string, systemPrompt?: string, providerOverride?: string): Promise<LLMResponse> {
-    const providerEnv = process.env.provider || 'gemini';
-    const providers = providerOverride ? [providerOverride] : providerEnv.split(',').map(p => p.trim());
-    
-    let lastError = '';
-
-    for (const provider of providers) {
-      const combinedPrompt = systemPrompt ? `${systemPrompt}\n\nUser: ${prompt}` : prompt;
-
-      // For testing/development: If MOCK_LLM is set, return mock data
-      if (process.env.MOCK_LLM === 'true') {
-        Logger.debug('LLM Mock Call', { provider, promptLength: prompt.length });
-        return { content: `[MOCK RESPONSE from ${provider}] I have analyzed your request: ${prompt.substring(0, 50)}...` };
-      }
-
-      Logger.info('LLM Call initiated', { provider });
-
-      try {
-        let response: LLMResponse;
-        switch (provider.toLowerCase()) {
-          case 'gemini':
-            response = await this.safeExec(`gemini ask ${this.escapeShell(combinedPrompt)}`);
-            break;
-          case 'claude':
-            response = await this.safeExec(`claude ${this.escapeShell(combinedPrompt)} --non-interactive`);
-            break;
-          case 'kimi':
-            response = await this.safeExec(`kimi chat ${this.escapeShell(combinedPrompt)}`);
-            break;
-          case 'opencode':
-            response = await this.safeExec(`opencode ask ${this.escapeShell(combinedPrompt)}`);
-            break;
-          default:
-            response = { content: '', error: `Unsupported provider: ${provider}` };
-        }
-
-        if (response.content && !response.error) {
-          return response; // Success!
-        }
-        
-        lastError = response.error || 'Unknown error';
-        Logger.warn(`Provider ${provider} failed, trying next...`, { error: lastError });
-
-      } catch (error: any) {
-        lastError = error.message;
-        Logger.error(`LLM Adapter Error with ${provider}`, { error: lastError });
-      }
-    }
-
-    return { content: '', error: `All providers failed. Last error: ${lastError}` };
-  }
-
-  /**
-   * Safely execute CLI command with timeout and existence check
-   */
-  private static async safeExec(cmd: string): Promise<LLMResponse> {
-    try {
-      // Check if command base exists (first word)
-      const baseCmd = cmd.split(' ')[0];
-      try {
-        await execAsync(`command -v ${baseCmd}`);
-      } catch {
-        const error = `CLI tool '${baseCmd}' not found or not in PATH. Please install and login.`;
-        Logger.warn('CLI tool missing', { baseCmd });
-        return { content: '', error };
-      }
-
-      const { stdout, stderr } = await execAsync(cmd, { 
-        timeout: 60000 // 60 second timeout
-      });
-
-      if (stderr && stderr.trim()) {
-        Logger.debug('CLI Stderr output', { baseCmd, stderr: stderr.substring(0, 100) });
-      }
-
-      return { content: stdout.trim() };
-    } catch (error: any) {
-      Logger.error('Execution failed', { command: cmd.substring(0, 50), error: error.message });
-      return { content: '', error: error.message };
-    }
-  }
-
-  /**
-   * Securely escape string for shell execution
-   */
-  private static escapeShell(cmd: string): string {
-    // For Unix-like systems, wrapping in single quotes and escaping existing single quotes
-    return "'" + cmd.replace(/'/g, "'\'" ) + "'";
-  }
-}

package/src/utils/logger.ts

@@ -1,56 +0,0 @@
-/**
- * Simple Structured Logging Utility
- * @module utils/logger
- */
-
-export enum LogLevel {
-  DEBUG = 0,
-  INFO = 1,
-  WARN = 2,
-  ERROR = 3
-}
-
-export class Logger {
-  private static level: LogLevel = LogLevel.INFO;
-
-  static setLevel(level: LogLevel) {
-    this.level = level;
-  }
-
-  static debug(message: string, context: any = {}) {
-    if (this.level <= LogLevel.DEBUG) {
-      this.log('DEBUG', message, context);
-    }
-  }
-
-  static info(message: string, context: any = {}) {
-    if (this.level <= LogLevel.INFO) {
-      this.log('INFO', message, context);
-    }
-  }
-
-  static warn(message: string, context: any = {}) {
-    if (this.level <= LogLevel.WARN) {
-      this.log('WARN', message, context);
-    }
-  }
-
-  static error(message: string, context: any = {}) {
-    if (this.level <= LogLevel.ERROR) {
-      this.log('ERROR', message, context);
-    }
-  }
-
-  private static log(level: string, message: string, context: any) {
-    const timestamp = new Date().toISOString();
-    const logEntry = {
-      timestamp,
-      level,
-      message,
-      ...context
-    };
-    
-    // Write to stderr to avoid interfering with MCP stdio protocol
-    process.stderr.write(JSON.stringify(logEntry) + '\n');
-  }
-}

package/src/utils/persistence.ts

@@ -1,109 +0,0 @@
-/**
- * Persistence Manager for JSON-based file storage
- * @module utils/persistence
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { Logger } from './logger.js';
-
-export class PersistenceManager {
-  private baseDir: string;
-
-  constructor(baseDir: string = './data') {
-    this.baseDir = baseDir;
-  }
-
-  /**
-   * Ensure storage directories exist
-   */
-  async initialize(subDirs: string[] = ['sessions', 'agents', 'tasks']) {
-    try {
-      await fs.mkdir(this.baseDir, { recursive: true });
-      for (const dir of subDirs) {
-        await fs.mkdir(path.join(this.baseDir, dir), { recursive: true });
-      }
-    } catch (error) {
-      Logger.error('Failed to initialize persistence directory', { error });
-      throw error;
-    }
-  }
-
-  /**
-   * Save an object to a JSON file
-   */
-  async save(collection: string, id: string, data: any) {
-    const filePath = path.join(this.baseDir, collection, `${id}.json`);
-    try {
-      // Handle Maps by converting them to objects/arrays for JSON serialization
-      const serializedData = this.serialize(data);
-      await fs.writeFile(filePath, JSON.stringify(serializedData, null, 2), 'utf8');
-    } catch (error) {
-      Logger.error(`Failed to save ${collection}/${id}`, { error });
-      throw error;
-    }
-  }
-
-  /**
-   * Load an object from a JSON file
-   */
-  async load<T>(collection: string, id: string): Promise<T | null> {
-    const filePath = path.join(this.baseDir, collection, `${id}.json`);
-    try {
-      const content = await fs.readFile(filePath, 'utf8');
-      return JSON.parse(content) as T;
-    } catch (error: any) {
-      if (error.code === 'ENOENT') return null;
-      Logger.error(`Failed to load ${collection}/${id}`, { error });
-      throw error;
-    }
-  }
-
-  /**
-   * List all IDs in a collection
-   */
-  async list(collection: string): Promise<string[]> {
-    const dirPath = path.join(this.baseDir, collection);
-    try {
-      const files = await fs.readdir(dirPath);
-      return files
-        .filter(f => f.endsWith('.json'))
-        .map(f => f.replace('.json', ''));
-    } catch (error: any) {
-      if (error.code === 'ENOENT') return [];
-      throw error;
-    }
-  }
-
-  /**
-   * Delete an object
-   */
-  async delete(collection: string, id: string) {
-    const filePath = path.join(this.baseDir, collection, `${id}.json`);
-    try {
-      await fs.unlink(filePath);
-    } catch (error: any) {
-      if (error.code !== 'ENOENT') throw error;
-    }
-  }
-
-  /**
-   * Helper to serialize complex objects (like Maps)
-   */
-  private serialize(obj: any): any {
-    if (obj instanceof Map) {
-      return { _type: 'Map', data: Array.from(obj.entries()) };
-    }
-    if (Array.isArray(obj)) {
-      return obj.map(item => this.serialize(item));
-    }
-    if (obj !== null && typeof obj === 'object' && !(obj instanceof Date)) {
-      const result: any = {};
-      for (const key in obj) {
-        result[key] = this.serialize(obj[key]);
-      }
-      return result;
-    }
-    return obj;
-  }
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}