@gotza02/seq-thinking 1.1.0

package/src/utils/llm-adapter.ts

@@ -0,0 +1,76 @@
+/**
+ * LLM Adapter to call external CLI tools via child_process
+ * @module utils/llm-adapter
+ */
+
+import { execSync } from 'child_process';
+
+export interface LLMResponse {
+  content: string;
+  error?: string;
+}
+
+export class LLMAdapter {
+  /**
+   * Main entry point to call an LLM based on provider
+   */
+  static async call(prompt: string, systemPrompt?: string): Promise<LLMResponse> {
+    const provider = process.env.provider || 'gemini';
+    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') {
+      return { content: `[MOCK RESPONSE from ${provider}] I have analyzed your request: ${prompt.substring(0, 50)}...` };
+    }
+
+    try {
+      switch (provider.toLowerCase()) {
+        case 'gemini':
+          return this.safeExec(`gemini ask ${this.escapeShell(combinedPrompt)}`);
+        case 'claude':
+          return this.safeExec(`claude ${this.escapeShell(combinedPrompt)} --non-interactive`);
+        case 'kimi':
+          return this.safeExec(`kimi chat ${this.escapeShell(combinedPrompt)}`);
+        case 'opencode':
+          return this.safeExec(`opencode ask ${this.escapeShell(combinedPrompt)}`);
+        default:
+          return { content: '', error: `Unsupported provider: ${provider}` };
+      }
+    } catch (error: any) {
+      console.error(`LLM Call Error (${provider}):`, error.message);
+      return { content: '', error: error.message };
+    }
+  }
+
+  /**
+   * Safely execute CLI command with timeout and existence check
+   */
+  private static safeExec(cmd: string): LLMResponse {
+    try {
+      // Check if command base exists (first word)
+      const baseCmd = cmd.split(' ')[0];
+      try {
+        execSync(`command -v ${baseCmd}`, { stdio: 'ignore' });
+      } catch {
+        return { content: '', error: `CLI tool '${baseCmd}' not found or not in PATH. Please install and login.` };
+      }
+
+      const output = execSync(cmd, { 
+        encoding: 'utf8', 
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: 30000 // 30 second timeout
+      });
+      return { content: output.trim() };
+    } catch (error: any) {
+      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/persistence.ts

@@ -0,0 +1,108 @@
+/**
+ * Persistence Manager for JSON-based file storage
+ * @module utils/persistence
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+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) {
+      console.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) {
+      console.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;
+      console.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

@@ -0,0 +1,21 @@
+{
+  "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"]
+}