@howlil/ez-agents 2.0.0 → 3.0.0

package/commands/ez/debug.md

@@ -162,7 +162,7 @@ Task(
 <success_criteria>
 - [ ] Active sessions checked
 - [ ] Symptoms gathered (if new)
-- [ ] gsd-debugger spawned with context
+- [ ] ez-debugger spawned with context
 - [ ] Checkpoints handled correctly
 - [ ] Root cause confirmed before fixing
 </success_criteria>

package/commands/ez/map-codebase.md

@@ -51,7 +51,7 @@ Check for .planning/STATE.md - loads context if project already initialized
 <process>
 1. Check if .planning/codebase/ already exists (offer to refresh or skip)
 2. Create .planning/codebase/ directory structure
-3. Spawn 4 parallel gsd-codebase-mapper agents:
+3. Spawn 4 parallel ez-codebase-mapper agents:
    - Agent 1: tech focus → writes STACK.md, INTEGRATIONS.md
    - Agent 2: arch focus → writes ARCHITECTURE.md, STRUCTURE.md
    - Agent 3: quality focus → writes CONVENTIONS.md, TESTING.md

package/commands/ez/reapply-patches.md

@@ -66,7 +66,7 @@ Exit.
 
 For each file in `backup-meta.json`:
 
-1. **Read the backed-up version** (user's modified copy from `gsd-local-patches/`)
+1. **Read the backed-up version** (user's modified copy from `ez-local-patches/`)
 2. **Read the newly installed version** (current file after update)
 3. **Compare and merge:**
 
@@ -97,8 +97,8 @@ After reapplying, regenerate the file manifest so future updates correctly detec
 ## Step 5: Cleanup option
 
 Ask user:
-- "Keep patch backups for reference?" → preserve `gsd-local-patches/`
-- "Clean up patch backups?" → remove `gsd-local-patches/` directory
+- "Keep patch backups for reference?" → preserve `ez-local-patches/`
+- "Clean up patch backups?" → remove `ez-local-patches/` directory
 
 ## Step 6: Report
 

package/commands/ez/research-phase.md

@@ -184,7 +184,7 @@ Task(
 <success_criteria>
 - [ ] Phase validated against roadmap
 - [ ] Existing research checked
-- [ ] gsd-phase-researcher spawned with context
+- [ ] ez-phase-researcher spawned with context
 - [ ] Checkpoints handled correctly
 - [ ] User knows next steps
 </success_criteria>

package/{get-shit-done → ez-agents}/bin/ez-tools.cjs

@@ -172,7 +172,7 @@ async function main() {
   const command = args[0];
 
   if (!command) {
-    error('Usage: gsd-tools <command> [args] [--raw] [--cwd <path>]\nCommands: state, resolve-model, find-phase, commit, verify-summary, verify, frontmatter, template, generate-slug, current-timestamp, list-todos, verify-path-exists, config-ensure-section, init');
+    error('Usage: ez-tools <command> [args] [--raw] [--cwd <path>]\nCommands: state, resolve-model, find-phase, commit, verify-summary, verify, frontmatter, template, generate-slug, current-timestamp, list-todos, verify-path-exists, config-ensure-section, init');
   }
 
   switch (command) {

package/{get-shit-done → ez-agents}/bin/lib/assistant-adapter.cjs

@@ -1,205 +1,205 @@
-#!/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
+
+/**
+ * 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
+};