@howlil/ez-agents 3.4.2 → 4.0.0

package/bin/lib/model-provider.cjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+/**
+ * EZ Model Provider — Unified API for multiple AI providers
+ * 
+ * Supports: Anthropic, Moonshot (Kimi), Alibaba (Qwen), OpenAI
+ */
+
+const https = require('https');
+const { URL } = require('url');
+const Logger = require('./logger.cjs');
+const logger = new Logger();
+
+class ModelProvider {
+  /**
+   * Create model provider
+   * @param {Object} config - Configuration
+   */
+  constructor(config) {
+    this.provider = config.provider || 'anthropic';
+    this.model = config.model || 'sonnet';
+    this.apiKey = config.apiKey || process.env[`${this.provider.toUpperCase()}_API_KEY`];
+    
+    if (!this.apiKey && this.provider !== 'anthropic') {
+      logger.warn('API key not configured', { provider: this.provider });
+    }
+  }
+
+  /**
+   * Helper for HTTP requests
+   */
+  _httpRequest(options, data) {
+    return new Promise((resolve, reject) => {
+      const req = https.request(options, (res) => {
+        let body = '';
+        res.on('data', (chunk) => body += chunk);
+        res.on('end', () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(JSON.parse(body));
+            } catch (e) {
+              resolve(body);
+            }
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}: ${body}`));
+          }
+        });
+      });
+      req.on('error', reject);
+      if (data) req.write(JSON.stringify(data));
+      req.end();
+    });
+  }
+
+  /**
+   * Send chat message
+   * @param {Object[]} messages - Chat messages
+   * @param {Object} options - Chat options
+   * @returns {Promise<Object>} - Response
+   */
+  async chat(messages, options = {}) {
+    logger.info('Chat request', { 
+      provider: this.provider, 
+      model: this.model,
+      messageCount: messages.length 
+    });
+
+    switch (this.provider) {
+      case 'anthropic':
+        return this._chatAnthropic(messages, options);
+      case 'moonshot':
+        return this._chatMoonshot(messages, options);
+      case 'alibaba':
+      case 'qwen':
+        return this._chatQwen(messages, options);
+      case 'openai':
+        return this._chatOpenAI(messages, options);
+      default:
+        throw new Error(`Unsupported provider: ${this.provider}`);
+    }
+  }
+
+  /**
+   * Anthropic Claude API
+   */
+  async _chatAnthropic(messages, options) {
+    // Anthropic usually requires their SDK or complex headers
+    logger.debug('Anthropic chat', { model: this.model });
+    return {
+      content: '[Anthropic response placeholder - requires SDK]',
+      provider: 'anthropic',
+      model: this.model
+    };
+  }
+
+  /**
+   * Moonshot (Kimi) API
+   */
+  async _chatMoonshot(messages, options) {
+    const modelName = this.model === 'sonnet' ? 'moonshot-v1-8k' : this.model;
+    const data = {
+      model: modelName,
+      messages: messages,
+      temperature: options.temperature || 0.3
+    };
+
+    const reqOptions = {
+      hostname: 'api.moonshot.cn',
+      path: '/v1/chat/completions',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      }
+    };
+
+    try {
+      const response = await this._httpRequest(reqOptions, data);
+      return {
+        content: response.choices[0].message.content,
+        provider: 'moonshot',
+        model: modelName
+      };
+    } catch (error) {
+      logger.error('Moonshot API error', { error: error.message });
+      throw error;
+    }
+  }
+
+  /**
+   * Alibaba Qwen API (DashScope)
+   */
+  async _chatQwen(messages, options) {
+    // Map generic model names to Qwen specific ones
+    let modelName = this.model;
+    if (modelName === 'sonnet' || modelName === 'gpt-4') modelName = 'qwen-max';
+    if (modelName === 'haiku' || modelName === 'gpt-3.5-turbo') modelName = 'qwen-plus';
+
+    const data = {
+      model: modelName,
+      input: {
+        messages: messages
+      },
+      parameters: {
+        result_format: 'message',
+        temperature: options.temperature || 0.3
+      }
+    };
+
+    const reqOptions = {
+      hostname: 'dashscope.aliyuncs.com',
+      path: '/api/v1/services/aigc/text-generation/generation',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      }
+    };
+
+    try {
+      const response = await this._httpRequest(reqOptions, data);
+      return {
+        content: response.output.choices[0].message.content,
+        provider: 'alibaba',
+        model: modelName
+      };
+    } catch (error) {
+      logger.error('Qwen API error', { error: error.message });
+      throw error;
+    }
+  }
+
+  /**
+   * OpenAI API
+   */
+  async _chatOpenAI(messages, options) {
+    const modelName = this.model === 'sonnet' ? 'gpt-4-turbo' : this.model;
+    const data = {
+      model: modelName,
+      messages: messages,
+      temperature: options.temperature || 0.3
+    };
+
+    const reqOptions = {
+      hostname: 'api.openai.com',
+      path: '/v1/chat/completions',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      }
+    };
+
+    try {
+      const response = await this._httpRequest(reqOptions, data);
+      return {
+        content: response.choices[0].message.content,
+        provider: 'openai',
+        model: modelName
+      };
+    } catch (error) {
+      logger.error('OpenAI API error', { error: error.message });
+      throw error;
+    }
+  }
+
+  /**
+   * Count tokens (approximate)
+   * @param {string} text - Text to count
+   * @returns {number} - Approximate token count
+   */
+  countTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+
+  /**
+   * Get provider info
+   * @returns {Object} - Provider information
+   */
+  getInfo() {
+    return {
+      provider: this.provider,
+      model: this.model,
+      hasApiKey: !!this.apiKey
+    };
+  }
+}
+
+/**
+ * Create provider from config
+ * @param {Object} config - Provider config
+ * @returns {ModelProvider} - Model provider instance
+ */
+function createProvider(config) {
+  return new ModelProvider(config);
+}
+
+module.exports = {
+  ModelProvider,
+  createProvider
+};

package/bin/lib/package-manager-detector.cjs

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+
+/**
+ * Package Manager Detector — Auto-detect available package managers
+ *
+ * Detects package managers (npm, yarn, pnpm) using a multi-layer strategy:
+ * 1. Configuration override (.planning/config.json)
+ * 2. Lockfile presence (pnpm-lock.yaml, yarn.lock, package-lock.json)
+ * 3. System availability (which pnpm/yarn/npm)
+ * 4. Fallback to npm (always available with Node)
+ *
+ * Usage:
+ *   const PackageManagerDetector = require('./package-manager-detector.cjs');
+ *   const detector = new PackageManagerDetector(cwd);
+ *   const result = detector.detect();
+ *   // Returns: { manager, source, confidence, lockfilePath? }
+ */
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const Logger = require('./logger.cjs');
+
+/**
+ * Package Manager Detector class
+ * Detects available package managers with priority-based strategy
+ */
+class PackageManagerDetector {
+  /**
+   * Create a PackageManagerDetector instance
+   * @param {string} cwd - Working directory (default: process.cwd())
+   */
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+    this.logger = new Logger();
+    this.config = this.loadConfig();
+  }
+
+  /**
+   * Detect package manager with priority-based strategy
+   * @returns {Object} Detection result { manager, source, confidence, lockfilePath? }
+   */
+  detect() {
+    this.logger.info('Starting package manager detection', { cwd: this.cwd });
+
+    // Layer 1: Configuration override
+    const configManager = this._detectFromConfig();
+    if (configManager) {
+      this.logger.info('Package manager detected from config', { manager: configManager });
+      return {
+        manager: configManager,
+        source: 'config',
+        confidence: 'high',
+        configPath: '.planning/config.json'
+      };
+    }
+
+    // Layer 2: Lockfile detection
+    const lockfileManager = this.detectFromLockfile();
+    if (lockfileManager) {
+      const lockfilePath = this.getLockfilePath(lockfileManager);
+      this.logger.info('Package manager detected from lockfile', {
+        manager: lockfileManager,
+        lockfilePath
+      });
+      return {
+        manager: lockfileManager,
+        source: 'lockfile',
+        confidence: 'high',
+        lockfilePath
+      };
+    }
+
+    // Layer 3: System availability
+    const availableManagers = this.getAvailableManagers();
+    if (availableManagers.length > 0) {
+      // Prefer pnpm > yarn > npm (performance order)
+      const preferred = availableManagers.find(m => m === 'pnpm') ||
+                       availableManagers.find(m => m === 'yarn') ||
+                       availableManagers[0];
+      this.logger.info('Package manager detected from system', {
+        manager: preferred,
+        available: availableManagers
+      });
+      return {
+        manager: preferred,
+        source: 'system',
+        confidence: 'medium',
+        available: availableManagers
+      };
+    }
+
+    // Layer 4: Fallback to npm
+    this.logger.warn('No package manager detected, falling back to npm');
+    return {
+      manager: 'npm',
+      source: 'fallback',
+      confidence: 'low',
+      reason: 'No other package manager detected'
+    };
+  }
+
+  /**
+   * Detect package manager from configuration
+   * @private
+   * @returns {string|null} Package manager name or null
+   */
+  _detectFromConfig() {
+    const configManager = this.config?.packageManager?.default;
+    if (configManager && this.isPackageManagerInstalled(configManager)) {
+      return configManager;
+    }
+    return null;
+  }
+
+  /**
+   * Detect package manager from lockfile presence
+   * @returns {string|null} Package manager name or null
+   */
+  detectFromLockfile() {
+    const lockfiles = {
+      'pnpm-lock.yaml': 'pnpm',
+      'yarn.lock': 'yarn',
+      'package-lock.json': 'npm'
+    };
+
+    for (const [lockfile, manager] of Object.entries(lockfiles)) {
+      const lockfilePath = path.join(this.cwd, lockfile);
+      if (fs.existsSync(lockfilePath)) {
+        return manager;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get all available package managers installed on the system
+   * @returns {string[]} Array of available manager names
+   */
+  getAvailableManagers() {
+    const managers = ['pnpm', 'yarn', 'npm'];
+    const available = [];
+
+    for (const manager of managers) {
+      if (this.isPackageManagerInstalled(manager)) {
+        available.push(manager);
+      }
+    }
+
+    return available;
+  }
+
+  /**
+   * Check if a specific package manager is installed
+   * @param {string} manager - Package manager name
+   * @returns {boolean} True if installed
+   */
+  isPackageManagerInstalled(manager) {
+    try {
+      execFileSync(manager, ['--version'], {
+        stdio: 'pipe',
+        shell: false
+      });
+      return true;
+    } catch (err) {
+      this.logger.debug('Package manager not installed', { manager, error: err.message });
+      return false;
+    }
+  }
+
+  /**
+   * Get the lockfile path for a specific package manager
+   * @param {string} manager - Package manager name
+   * @returns {string} Full path to lockfile
+   */
+  getLockfilePath(manager) {
+    const lockfiles = {
+      'pnpm': 'pnpm-lock.yaml',
+      'yarn': 'yarn.lock',
+      'npm': 'package-lock.json'
+    };
+    return path.join(this.cwd, lockfiles[manager] || 'package-lock.json');
+  }
+
+  /**
+   * Load configuration from .planning/config.json
+   * @returns {Object} Configuration object
+   */
+  loadConfig() {
+    const configPath = path.join(this.cwd, '.planning', 'config.json');
+    try {
+      if (fs.existsSync(configPath)) {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+      }
+    } catch (err) {
+      this.logger.warn('Failed to load config', { path: configPath, error: err.message });
+    }
+    return {};
+  }
+}
+
+module.exports = PackageManagerDetector;