@howlil/ez-agents 3.1.0 → 3.4.2

package/ez-agents/bin/lib/assistant-adapter.cjs

@@ -1,205 +1,264 @@
-#!/usr/bin/env node
-
-/**
- * GSD Assistant Adapters — Unified interface for AI coding assistants
- * 
- * Adapters for: Claude Code, OpenCode, Gemini CLI, Codex
- * 
- * Usage:
- *   const { createAdapter } = require('./assistant-adapter.cjs');
- *   const adapter = createAdapter('claude-code');
- *   await adapter.spawnAgent('planner', { prompt: '...' });
- */
-
-const Logger = require('./logger.cjs');
-const logger = new Logger();
-
-/**
- * Base adapter interface
- */
-class AssistantAdapter {
-  constructor(name) {
-    if (new.target === AssistantAdapter) {
-      throw new Error('AssistantAdapter is abstract - use a concrete subclass');
-    }
-    this.name = name;
-  }
-
-  /**
-   * Spawn a subagent
-   * @param {string} type - Agent type
-   * @param {Object} options - Agent options
-   * @returns {Promise<Object>} - Agent result
-   */
-  async spawnAgent(type, options) {
-    throw new Error('spawnAgent must be implemented');
-  }
-
-  /**
-   * Call a tool/function
-   * @param {string} tool - Tool name
-   * @param {Object} params - Tool parameters
-   * @returns {Promise<any>} - Tool result
-   */
-  async callTool(tool, params) {
-    throw new Error('callTool must be implemented');
-  }
-
-  /**
-   * Select model for task
-   * @param {string} taskType - Task type (planning, execution, verification)
-   * @returns {string} - Model name
-   */
-  selectModel(taskType) {
-    throw new Error('selectModel must be implemented');
-  }
-
-  /**
-   * Get adapter info
-   * @returns {Object} - Adapter information
-   */
-  getInfo() {
-    return {
-      name: this.name,
-      type: this.constructor.name
-    };
-  }
-}
-
-/**
- * Claude Code adapter
- */
-class ClaudeCodeAdapter extends AssistantAdapter {
-  constructor() {
-    super('claude-code');
-  }
-
-  async spawnAgent(type, options) {
-    logger.info('Claude Code: spawning agent', { type });
-    // Would use Claude Code's Task tool in production
-    return { type, status: 'completed', result: '[Claude Code agent result]' };
-  }
-
-  async callTool(tool, params) {
-    logger.info('Claude Code: calling tool', { tool });
-    // Would use Claude Code's tool system
-    return { tool, status: 'success' };
-  }
-
-  selectModel(taskType) {
-    const models = {
-      planning: 'claude-3-opus',
-      execution: 'claude-3-sonnet',
-      verification: 'claude-3-sonnet'
-    };
-    return models[taskType] || models.execution;
-  }
-}
-
-/**
- * OpenCode adapter
- */
-class OpenCodeAdapter extends AssistantAdapter {
-  constructor() {
-    super('opencode');
-  }
-
-  async spawnAgent(type, options) {
-    logger.info('OpenCode: spawning agent', { type });
-    return { type, status: 'completed', result: '[OpenCode agent result]' };
-  }
-
-  async callTool(tool, params) {
-    logger.info('OpenCode: calling tool', { tool });
-    return { tool, status: 'success' };
-  }
-
-  selectModel(taskType) {
-    return 'gpt-4-turbo';
-  }
-}
-
-/**
- * Gemini CLI adapter
- */
-class GeminiAdapter extends AssistantAdapter {
-  constructor() {
-    super('gemini');
-  }
-
-  async spawnAgent(type, options) {
-    logger.info('Gemini: spawning agent', { type });
-    return { type, status: 'completed', result: '[Gemini agent result]' };
-  }
-
-  async callTool(tool, params) {
-    logger.info('Gemini: calling tool', { tool });
-    return { tool, status: 'success' };
-  }
-
-  selectModel(taskType) {
-    return 'gemini-pro';
-  }
-}
-
-/**
- * Codex adapter
- */
-class CodexAdapter extends AssistantAdapter {
-  constructor() {
-    super('codex');
-  }
-
-  async spawnAgent(type, options) {
-    logger.info('Codex: spawning agent', { type });
-    return { type, status: 'completed', result: '[Codex agent result]' };
-  }
-
-  async callTool(tool, params) {
-    logger.info('Codex: calling tool', { tool });
-    return { tool, status: 'success' };
-  }
-
-  selectModel(taskType) {
-    return 'codex-latest';
-  }
-}
-
-/**
- * Factory function to create adapter
- * @param {string} type - Adapter type
- * @returns {AssistantAdapter} - Adapter instance
- */
-function createAdapter(type) {
-  const adapters = {
-    'claude-code': ClaudeCodeAdapter,
-    'opencode': OpenCodeAdapter,
-    'gemini': GeminiAdapter,
-    'codex': CodexAdapter
-  };
-
-  const AdapterClass = adapters[type];
-  if (!AdapterClass) {
-    throw new Error(`Unknown adapter type: ${type}. Available: ${Object.keys(adapters).join(', ')}`);
-  }
-
-  return new AdapterClass();
-}
-
-/**
- * Get available adapters
- * @returns {string[]} - List of adapter names
- */
-function getAvailableAdapters() {
-  return ['claude-code', 'opencode', 'gemini', 'codex'];
-}
-
-module.exports = {
-  AssistantAdapter,
-  ClaudeCodeAdapter,
-  OpenCodeAdapter,
-  GeminiAdapter,
-  CodexAdapter,
-  createAdapter,
-  getAvailableAdapters
-};
+#!/usr/bin/env node
+
+/**
+ * EZ Assistant Adapters — Unified interface for AI coding assistants
+ * 
+ * Adapters for: Claude Code, OpenCode, Gemini CLI, Codex
+ * 
+ * Usage:
+ *   const { createAdapter } = require('./assistant-adapter.cjs');
+ *   const adapter = createAdapter('claude-code');
+ *   await adapter.spawnAgent('planner', { prompt: '...' });
+ */
+
+const Logger = require('./logger.cjs');
+const logger = new Logger();
+
+/**
+ * Base adapter interface
+ */
+class AssistantAdapter {
+  constructor(name) {
+    if (new.target === AssistantAdapter) {
+      throw new Error('AssistantAdapter is abstract - use a concrete subclass');
+    }
+    this.name = name;
+  }
+
+  /**
+   * Spawn a subagent
+   * @param {string} type - Agent type
+   * @param {Object} options - Agent options
+   * @returns {Promise<Object>} - Agent result
+   */
+  async spawnAgent(type, options) {
+    throw new Error('spawnAgent must be implemented');
+  }
+
+  /**
+   * Call a tool/function
+   * @param {string} tool - Tool name
+   * @param {Object} params - Tool parameters
+   * @returns {Promise<any>} - Tool result
+   */
+  async callTool(tool, params) {
+    throw new Error('callTool must be implemented');
+  }
+
+  /**
+   * Select model for task
+   * @param {string} taskType - Task type (planning, execution, verification)
+   * @returns {string} - Model name
+   */
+  selectModel(taskType) {
+    throw new Error('selectModel must be implemented');
+  }
+
+  /**
+   * Get adapter info
+   * @returns {Object} - Adapter information
+   */
+  getInfo() {
+    return {
+      name: this.name,
+      type: this.constructor.name
+    };
+  }
+}
+
+/**
+ * Claude Code adapter
+ */
+class ClaudeCodeAdapter extends AssistantAdapter {
+  constructor() {
+    super('claude-code');
+  }
+
+  async spawnAgent(type, options) {
+    logger.info('Claude Code: spawning agent', { type });
+    // Would use Claude Code's Task tool in production
+    return { type, status: 'completed', result: '[Claude Code agent result]' };
+  }
+
+  async callTool(tool, params) {
+    logger.info('Claude Code: calling tool', { tool });
+    // Would use Claude Code's tool system
+    return { tool, status: 'success' };
+  }
+
+  selectModel(taskType) {
+    const models = {
+      planning: 'claude-3-opus',
+      execution: 'claude-3-sonnet',
+      verification: 'claude-3-sonnet'
+    };
+    return models[taskType] || models.execution;
+  }
+}
+
+/**
+ * OpenCode adapter
+ */
+class OpenCodeAdapter extends AssistantAdapter {
+  constructor() {
+    super('opencode');
+  }
+
+  async spawnAgent(type, options) {
+    logger.info('OpenCode: spawning agent', { type });
+    return { type, status: 'completed', result: '[OpenCode agent result]' };
+  }
+
+  async callTool(tool, params) {
+    logger.info('OpenCode: calling tool', { tool });
+    return { tool, status: 'success' };
+  }
+
+  selectModel(taskType) {
+    return 'gpt-4-turbo';
+  }
+}
+
+/**
+ * Gemini CLI adapter
+ */
+class GeminiAdapter extends AssistantAdapter {
+  constructor() {
+    super('gemini');
+  }
+
+  async spawnAgent(type, options) {
+    logger.info('Gemini: spawning agent', { type });
+    return { type, status: 'completed', result: '[Gemini agent result]' };
+  }
+
+  async callTool(tool, params) {
+    logger.info('Gemini: calling tool', { tool });
+    return { tool, status: 'success' };
+  }
+
+  selectModel(taskType) {
+    return 'gemini-pro';
+  }
+}
+
+/**
+ * Codex adapter
+ */
+class CodexAdapter extends AssistantAdapter {
+  constructor() {
+    super('codex');
+  }
+
+  async spawnAgent(type, options) {
+    logger.info('Codex: spawning agent', { type });
+    return { type, status: 'completed', result: '[Codex agent result]' };
+  }
+
+  async callTool(tool, params) {
+    logger.info('Codex: calling tool', { tool });
+    return { tool, status: 'success' };
+  }
+
+  selectModel(taskType) {
+    return 'codex-latest';
+  }
+}
+
+/**
+ * Qwen Code adapter
+ */
+class QwenAdapter extends AssistantAdapter {
+  constructor() {
+    super('qwen');
+  }
+
+  async spawnAgent(type, options) {
+    logger.info('Qwen Code: spawning agent', { type });
+    // Qwen Code uses its own agent system
+    return { type, status: 'completed', result: '[Qwen Code agent result]' };
+  }
+
+  async callTool(tool, params) {
+    logger.info('Qwen Code: calling tool', { tool });
+    return { tool, status: 'success' };
+  }
+
+  selectModel(taskType) {
+    const models = {
+      planning: 'qwen-max',
+      execution: 'qwen-plus',
+      verification: 'qwen-plus'
+    };
+    return models[taskType] || models.execution;
+  }
+}
+
+/**
+ * Kimi Code adapter
+ */
+class KimiAdapter extends AssistantAdapter {
+  constructor() {
+    super('kimi');
+  }
+
+  async spawnAgent(type, options) {
+    logger.info('Kimi Code: spawning agent', { type });
+    return { type, status: 'completed', result: '[Kimi Code agent result]' };
+  }
+
+  async callTool(tool, params) {
+    logger.info('Kimi Code: calling tool', { tool });
+    return { tool, status: 'success' };
+  }
+
+  selectModel(taskType) {
+    const models = {
+      planning: 'moonshot-v1-32k',
+      execution: 'moonshot-v1-8k',
+      verification: 'moonshot-v1-8k'
+    };
+    return models[taskType] || models.execution;
+  }
+}
+
+/**
+ * Factory function to create adapter
+ * @param {string} type - Adapter type
+ * @returns {AssistantAdapter} - Adapter instance
+ */
+function createAdapter(type) {
+  const adapters = {
+    'claude-code': ClaudeCodeAdapter,
+    'opencode': OpenCodeAdapter,
+    'gemini': GeminiAdapter,
+    'codex': CodexAdapter,
+    'qwen': QwenAdapter,
+    'kimi': KimiAdapter
+  };
+
+  const AdapterClass = adapters[type];
+  if (!AdapterClass) {
+    throw new Error(`Unknown adapter type: ${type}. Available: ${Object.keys(adapters).join(', ')}`);
+  }
+
+  return new AdapterClass();
+}
+
+/**
+ * Get available adapters
+ * @returns {string[]} - List of adapter names
+ */
+function getAvailableAdapters() {
+  return ['claude-code', 'opencode', 'gemini', 'codex', 'qwen', 'kimi'];
+}
+
+module.exports = {
+  AssistantAdapter,
+  ClaudeCodeAdapter,
+  OpenCodeAdapter,
+  GeminiAdapter,
+  CodexAdapter,
+  createAdapter,
+  getAvailableAdapters
+};

package/ez-agents/bin/lib/audit-exec.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD Audit Exec — Command execution with full audit logging
+ * EZ Audit Exec — Command execution with full audit logging
  * 
  * Logs all command executions to audit file for security review:
  * - Timestamp, command, arguments, context
@@ -22,13 +22,25 @@ const logger = new Logger();
 
 const execFileAsync = promisify(execFile);
 
-// Audit log file path
-const AUDIT_DIR = join('.planning', 'logs');
-const AUDIT_FILE = join(AUDIT_DIR, `audit-${new Date().toISOString().split('T')[0]}.jsonl`);
+// Audit log file path - lazy init
+let _AUDIT_DIR;
+let _AUDIT_FILE;
 
-// Ensure audit directory exists
-if (!existsSync(AUDIT_DIR)) {
-  mkdirSync(AUDIT_DIR, { recursive: true });
+function getAuditDir() {
+  if (!_AUDIT_DIR) {
+    _AUDIT_DIR = join('.planning', 'logs');
+    if (!existsSync(_AUDIT_DIR)) {
+      mkdirSync(_AUDIT_DIR, { recursive: true });
+    }
+  }
+  return _AUDIT_DIR;
+}
+
+function getAuditFile() {
+  if (!_AUDIT_FILE) {
+    _AUDIT_FILE = join(getAuditDir(), `audit-${new Date().toISOString().split('T')[0]}.jsonl`);
+  }
+  return _AUDIT_FILE;
 }
 
 /**
@@ -36,8 +48,13 @@ if (!existsSync(AUDIT_DIR)) {
  * @param {Object} entry - Audit entry
  */
 function writeAudit(entry) {
-  const line = JSON.stringify(entry) + '\n';
-  appendFileSync(AUDIT_FILE, line, 'utf-8');
+  try {
+    const line = JSON.stringify(entry) + '\n';
+    appendFileSync(getAuditFile(), line, 'utf-8');
+  } catch (err) {
+    // Silently ignore audit write failures - logging is best-effort
+    // This can happen in temp test directories or when .planning doesn't exist
+  }
 }
 
 /**

package/ez-agents/bin/lib/auth.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD Auth — Secure credential storage using system keychain
+ * EZ Auth — Secure credential storage using system keychain
  * 
  * Stores API keys securely using:
  * - keytar for system keychain (Windows Credential Manager, macOS Keychain, libsecret)
@@ -25,6 +25,7 @@ const PROVIDERS = {
   ANTHROPIC: 'anthropic',
   MOONSHOT: 'moonshot',
   ALIBABA: 'alibaba',
+  QWEN: 'qwen',
   OPENAI: 'openai'
 };