gthinking 1.3.0 → 2.1.2

package/src/core/config.ts

@@ -0,0 +1,462 @@
+/**
+ * Configuration for gthinking v2.0.0
+ * Centralized configuration management
+ */
+
+import { z } from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { ConfigurationError } from './errors';
+
+/**
+ * LLM Provider configuration schema
+ */
+export const LLMProviderConfigSchema = z.object({
+  provider: z.enum(['gemini', 'claude', 'openai', 'kimi', 'custom', 'cli']),
+  apiKey: z.string().optional(), // Made optional for CLI mode
+  baseUrl: z.string().url().optional(),
+  model: z.string().optional(),
+  cliCommand: z.string().default('gemini'),
+  cliArgs: z.array(z.string()).default([]), // Extra args e.g. ['--temperature', '0.7']
+  cliPromptPassingMethod: z.enum(['stdin', 'arg']).default('stdin'),
+  cliPromptFlag: z.string().optional(), // e.g. '-p' if method is 'arg'
+  timeout: z.number().positive().default(30000),
+  maxRetries: z.number().nonnegative().default(3),
+  rateLimitPerMinute: z.number().positive().default(60),
+});
+
+export type LLMProviderConfig = z.infer<typeof LLMProviderConfigSchema>;
+
+/**
+ * Search configuration schema
+ */
+export const SearchConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  providers: z.array(z.enum(['google', 'bing', 'brave', 'duckduckgo'])).default(['google']),
+  apiKeys: z.record(z.string()).default({}),
+  maxResults: z.number().positive().max(100).default(10),
+  timeout: z.number().positive().default(30000),
+  cacheResults: z.boolean().default(true),
+  cacheTTL: z.number().positive().default(3600000), // 1 hour
+});
+
+export type SearchConfig = z.infer<typeof SearchConfigSchema>;
+
+/**
+ * Cache configuration schema
+ */
+export const CacheConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  maxSize: z.number().positive().default(1000),
+  defaultTTL: z.number().positive().default(3600000), // 1 hour
+  checkInterval: z.number().positive().default(60000), // 1 minute
+  persistence: z.enum(['none', 'file', 'redis']).default('none'),
+  persistencePath: z.string().optional(),
+});
+
+export type CacheConfig = z.infer<typeof CacheConfigSchema>;
+
+/**
+ * Logging configuration schema
+ */
+export const LoggingConfigSchema = z.object({
+  level: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+  enableConsole: z.boolean().default(true),
+  enableFile: z.boolean().default(false),
+  logDir: z.string().default('./logs'),
+  maxFiles: z.number().positive().default(5),
+  maxSize: z.string().default('10m'),
+});
+
+export type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
+
+/**
+ * Stage configuration schema
+ */
+export const StageConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  timeout: z.number().positive().default(60000),
+  maxRetries: z.number().nonnegative().default(2),
+  parallel: z.boolean().default(false),
+  required: z.boolean().default(false),
+});
+
+export type StageConfig = z.infer<typeof StageConfigSchema>;
+
+/**
+ * Pipeline configuration schema
+ */
+export const PipelineConfigSchema = z.object({
+  stages: z.object({
+    search: StageConfigSchema.default({}),
+    analysis: StageConfigSchema.default({}),
+    reasoning: StageConfigSchema.default({}),
+    learning: StageConfigSchema.default({}),
+    planning: StageConfigSchema.default({}),
+    creativity: StageConfigSchema.default({}),
+    synthesis: StageConfigSchema.default({}),
+    evaluation: StageConfigSchema.default({}),
+  }).default({}),
+  enableDynamicPipeline: z.boolean().default(true),
+  enableStreaming: z.boolean().default(false),
+  maxConcurrentStages: z.number().positive().default(3),
+  defaultTimeout: z.number().positive().default(300000), // 5 minutes
+  errorHandling: z.enum(['stop', 'continue']).default('stop'),
+});
+
+export type PipelineConfig = z.infer<typeof PipelineConfigSchema>;
+
+/**
+ * Main configuration schema
+ */
+export const GThinkingConfigSchema = z.object({
+  version: z.string().default('2.0.0'),
+  llm: LLMProviderConfigSchema.default({ provider: 'gemini' }),
+  search: SearchConfigSchema.default({}),
+  cache: CacheConfigSchema.default({}),
+  logging: LoggingConfigSchema.default({}),
+  pipeline: PipelineConfigSchema.default({}),
+  security: z.object({
+    enableInputSanitization: z.boolean().default(true),
+    enableRateLimiting: z.boolean().default(true),
+    maxRequestsPerMinute: z.number().positive().default(100),
+    maxQueryLength: z.number().positive().default(10000),
+  }).default({}),
+  session: z.object({
+    maxSessions: z.number().positive().default(1000),
+    sessionTTL: z.number().positive().default(3600000), // 1 hour
+    enablePersistence: z.boolean().default(false),
+    persistencePath: z.string().optional(),
+  }).default({}),
+  metrics: z.object({
+    enabled: z.boolean().default(true),
+    collectDetailedMetrics: z.boolean().default(false),
+    metricsInterval: z.number().positive().default(60000),
+  }).default({}),
+});
+
+export type GThinkingConfig = z.infer<typeof GThinkingConfigSchema>;
+
+/**
+ * Default configuration
+ */
+export const defaultConfig: GThinkingConfig = {
+  version: '2.0.0',
+  llm: {
+    provider: 'gemini',
+    timeout: 30000,
+    maxRetries: 3,
+    rateLimitPerMinute: 60,
+    cliCommand: 'gemini',
+    cliArgs: [],
+    cliPromptPassingMethod: 'stdin',
+  },
+  search: {
+    enabled: true,
+    providers: ['google'],
+    apiKeys: {},
+    maxResults: 10,
+    timeout: 30000,
+    cacheResults: true,
+    cacheTTL: 3600000,
+  },
+  cache: {
+    enabled: true,
+    maxSize: 1000,
+    defaultTTL: 3600000,
+    checkInterval: 60000,
+    persistence: 'none',
+  },
+  logging: {
+    level: 'info',
+    enableConsole: true,
+    enableFile: false,
+    logDir: './logs',
+    maxFiles: 5,
+    maxSize: '10m',
+  },
+  pipeline: {
+    stages: {
+      search: { enabled: true, timeout: 60000, maxRetries: 2, parallel: false, required: false },
+      analysis: { enabled: true, timeout: 60000, maxRetries: 2, parallel: false, required: false },
+      reasoning: { enabled: true, timeout: 120000, maxRetries: 2, parallel: false, required: false },
+      learning: { enabled: true, timeout: 30000, maxRetries: 1, parallel: true, required: false },
+      planning: { enabled: true, timeout: 60000, maxRetries: 2, parallel: false, required: false },
+      creativity: { enabled: true, timeout: 120000, maxRetries: 2, parallel: false, required: false },
+      synthesis: { enabled: true, timeout: 60000, maxRetries: 2, parallel: false, required: true },
+      evaluation: { enabled: true, timeout: 30000, maxRetries: 1, parallel: true, required: false },
+    },
+    enableDynamicPipeline: true,
+    enableStreaming: false,
+    maxConcurrentStages: 3,
+    defaultTimeout: 300000,
+    errorHandling: 'stop',
+  },
+  security: {
+    enableInputSanitization: true,
+    enableRateLimiting: true,
+    maxRequestsPerMinute: 100,
+    maxQueryLength: 10000,
+  },
+  session: {
+    maxSessions: 1000,
+    sessionTTL: 3600000,
+    enablePersistence: false,
+  },
+  metrics: {
+    enabled: true,
+    collectDetailedMetrics: false,
+    metricsInterval: 60000,
+  },
+};
+
+/**
+ * Configuration manager class
+ */
+export class ConfigManager {
+  private config: GThinkingConfig;
+  private validators: Map<string, (value: unknown) => boolean> = new Map();
+
+  constructor(initialConfig: Partial<GThinkingConfig> = {}) {
+    this.config = this.mergeConfig(defaultConfig, initialConfig);
+    this.loadFromMCPConfig();
+    this.loadFromEnvironment();
+    this.validateConfig();
+  }
+
+  /**
+   * Load configuration from ~/.gemini/settings.json if it exists
+   */
+  public loadFromMCPConfig(): void {
+    try {
+      const homeDir = os.homedir();
+      const configPath = path.join(homeDir, '.gemini', 'settings.json');
+
+      if (fs.existsSync(configPath)) {
+        const fileContent = fs.readFileSync(configPath, 'utf-8');
+        const settings = JSON.parse(fileContent);
+        
+        // Check for gthinking specific config or generic mcpServers config
+        const gthinkingConfig = settings.mcpServers?.gthinking;
+        
+        if (gthinkingConfig && gthinkingConfig.env) {
+          const envConfig: Partial<GThinkingConfig> = {};
+          const env = gthinkingConfig.env;
+
+          // Map env vars from settings.json to config
+          if (env.GTHINKING_LLM_PROVIDER) {
+            envConfig.llm = {
+              ...this.config.llm,
+              provider: env.GTHINKING_LLM_PROVIDER,
+            };
+          }
+          if (env.GTHINKING_LLM_API_KEY) {
+            envConfig.llm = {
+              ...envConfig.llm,
+              ...this.config.llm,
+              apiKey: env.GTHINKING_LLM_API_KEY,
+            };
+          }
+          if (env.GTHINKING_LLM_CLI_COMMAND) {
+            envConfig.llm = {
+              ...envConfig.llm,
+              ...this.config.llm,
+              cliCommand: env.GTHINKING_LLM_CLI_COMMAND,
+            };
+          }
+          // Add other mappings as needed...
+
+          this.updateConfig(envConfig);
+        }
+      }
+    } catch (error) {
+      // Ignore errors when loading optional config file
+      // logger.warn('Failed to load MCP settings', { error });
+    }
+  }
+
+  /**
+   * Get the current configuration
+   * @returns The current configuration
+   */
+  public getConfig(): GThinkingConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Get a specific configuration value
+   * @param path - The configuration path (e.g., 'llm.provider')
+   * @returns The configuration value
+   */
+  public get<T>(path: string): T | undefined {
+    const parts = path.split('.');
+    let current: unknown = this.config;
+    
+    for (const part of parts) {
+      if (current === null || current === undefined) {
+        return undefined;
+      }
+      current = (current as Record<string, unknown>)[part];
+    }
+    
+    return current as T;
+  }
+
+  /**
+   * Update the configuration
+   * @param updates - Configuration updates
+   */
+  public updateConfig(updates: Partial<GThinkingConfig>): void {
+    this.config = this.mergeConfig(this.config, updates);
+    this.validateConfig();
+  }
+
+  /**
+   * Update a specific configuration value
+   * @param path - The configuration path
+   * @param value - The new value
+   */
+  public set<T>(path: string, value: T): void {
+    const parts = path.split('.');
+    let current: Record<string, unknown> = this.config as Record<string, unknown>;
+    
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (!(part in current)) {
+        current[part] = {};
+      }
+      current = current[part] as Record<string, unknown>;
+    }
+    
+    current[parts[parts.length - 1]] = value;
+    this.validateConfig();
+  }
+
+  /**
+   * Load configuration from environment variables
+   */
+  public loadFromEnvironment(): void {
+    const envConfig: Partial<GThinkingConfig> = {};
+
+    // LLM configuration
+    if (process.env.GTHINKING_LLM_PROVIDER) {
+      envConfig.llm = {
+        ...this.config.llm,
+        provider: process.env.GTHINKING_LLM_PROVIDER as 'gemini' | 'claude' | 'openai' | 'kimi' | 'custom',
+      };
+    }
+    if (process.env.GTHINKING_LLM_API_KEY) {
+      envConfig.llm = {
+        ...envConfig.llm,
+        ...this.config.llm,
+        apiKey: process.env.GTHINKING_LLM_API_KEY,
+      };
+    }
+    if (process.env.GTHINKING_LLM_CLI_COMMAND) {
+      envConfig.llm = {
+        ...envConfig.llm,
+        ...this.config.llm,
+        cliCommand: process.env.GTHINKING_LLM_CLI_COMMAND,
+      };
+    }
+    if (process.env.GTHINKING_LLM_CLI_ARGS) {
+        // Expect comma-separated args
+        const args = process.env.GTHINKING_LLM_CLI_ARGS.split(',').map(s => s.trim());
+        envConfig.llm = { ...envConfig.llm, ...this.config.llm, cliArgs: args };
+    }
+    if (process.env.GTHINKING_LLM_CLI_PROMPT_METHOD) {
+        envConfig.llm = { 
+            ...envConfig.llm, 
+            ...this.config.llm, 
+            cliPromptPassingMethod: process.env.GTHINKING_LLM_CLI_PROMPT_METHOD as 'stdin' | 'arg' 
+        };
+    }
+    if (process.env.GTHINKING_LLM_CLI_PROMPT_FLAG) {
+        envConfig.llm = { ...envConfig.llm, ...this.config.llm, cliPromptFlag: process.env.GTHINKING_LLM_CLI_PROMPT_FLAG };
+    }
+
+    // Search configuration
+    if (process.env.GTHINKING_SEARCH_API_KEY) {
+      envConfig.search = {
+        ...this.config.search,
+        apiKeys: { google: process.env.GTHINKING_SEARCH_API_KEY },
+      };
+    }
+
+    // Logging configuration
+    if (process.env.GTHINKING_LOG_LEVEL) {
+      envConfig.logging = {
+        ...this.config.logging,
+        level: process.env.GTHINKING_LOG_LEVEL as 'debug' | 'info' | 'warn' | 'error',
+      };
+    }
+
+    this.updateConfig(envConfig);
+  }
+
+  /**
+   * Register a custom validator
+   * @param path - The configuration path
+   * @param validator - The validator function
+   */
+  public registerValidator(path: string, validator: (value: unknown) => boolean): void {
+    this.validators.set(path, validator);
+  }
+
+  /**
+   * Merge configurations
+   * @param base - Base configuration
+   * @param override - Override configuration
+   * @returns Merged configuration
+   */
+  private mergeConfig(
+    base: GThinkingConfig,
+    override: Partial<GThinkingConfig>
+  ): GThinkingConfig {
+    return {
+      ...base,
+      ...override,
+      llm: { ...base.llm, ...override.llm },
+      search: { ...base.search, ...override.search },
+      cache: { ...base.cache, ...override.cache },
+      logging: { ...base.logging, ...override.logging },
+      pipeline: {
+        ...base.pipeline,
+        ...override.pipeline,
+        stages: {
+          ...base.pipeline.stages,
+          ...override.pipeline?.stages,
+        },
+      },
+      security: { ...base.security, ...override.security },
+      session: { ...base.session, ...override.session },
+      metrics: { ...base.metrics, ...override.metrics },
+    };
+  }
+
+  /**
+   * Validate the configuration
+   */
+  private validateConfig(): void {
+    const result = GThinkingConfigSchema.safeParse(this.config);
+    
+    if (!result.success) {
+      throw new ConfigurationError(
+        'Invalid configuration: ' + result.error.message,
+        { errors: result.error.errors }
+      );
+    }
+
+    // Run custom validators
+    for (const [path, validator] of this.validators) {
+      const value = this.get(path);
+      if (!validator(value)) {
+        throw new ConfigurationError(`Validation failed for ${path}`);
+      }
+    }
+  }
+}
+
+// Export a singleton instance
+export const configManager = new ConfigManager();