gencode-ai 0.4.0 → 0.5.0

package/src/ext/subagents/types.ts

@@ -0,0 +1,241 @@
+/**
+ * Subagent System Types
+ *
+ * Types for the subagent system that enables isolated, specialized task execution.
+ * Based on Claude Code's Task tool architecture.
+ */
+
+import type { Message } from '../../core/providers/types.js';
+import type { DiscoverableResource, ResourceSource } from '../../base/discovery/types.js';
+
+/**
+ * Subagent Types
+ * - Explore: Fast read-only codebase exploration (haiku)
+ * - Plan: Architecture design and planning (sonnet)
+ * - Bash: Command execution specialist (haiku)
+ * - general-purpose: Full capabilities (sonnet)
+ */
+export type SubagentType = 'Explore' | 'Plan' | 'Bash' | 'general-purpose';
+
+/**
+ * Execution modes for subagents
+ */
+export type SubagentExecutionMode = 'foreground' | 'background';
+
+/**
+ * Single task definition for parallel execution (Phase 4)
+ */
+export interface ParallelTaskDefinition {
+  /** Short description (3-5 words) */
+  description: string;
+
+  /** Task prompt */
+  prompt: string;
+
+  /** Subagent type */
+  subagent_type: SubagentType;
+
+  /** Optional model override */
+  model?: string;
+
+  /** Optional max turns */
+  max_turns?: number;
+}
+
+/**
+ * Task tool input schema
+ * Defines parameters for launching a subagent
+ */
+export interface TaskInput {
+  /** Short description (3-5 words) for UI display */
+  description: string;
+
+  /** Detailed task instructions/prompt for the subagent */
+  prompt: string;
+
+  /** Type of subagent to spawn */
+  subagent_type: SubagentType;
+
+  /** Optional: specific model to use (overrides default for type) */
+  model?: string;
+
+  /** Optional: run in background (returns immediately with agent ID) */
+  run_in_background?: boolean;
+
+  /** Optional: resume a previous subagent by ID */
+  resume?: string;
+
+  /** Optional: max conversation turns (default: varies by type) */
+  max_turns?: number;
+
+  /** Optional: parallel tasks array (Phase 4) - mutually exclusive with single task */
+  tasks?: ParallelTaskDefinition[];
+}
+
+/**
+ * Task tool output
+ * Result from subagent execution
+ */
+export interface TaskOutput {
+  /** Whether task completed successfully */
+  success: boolean;
+
+  /** Summary result from subagent (for foreground execution) */
+  result?: string;
+
+  /** Unique agent ID (for tracking/resume) */
+  agentId: string;
+
+  /** Output file path (for background tasks) */
+  outputFile?: string;
+
+  /** Error message if failed */
+  error?: string;
+
+  /** Execution metadata */
+  metadata?: {
+    subagentType: SubagentType;
+    model: string;
+    turns: number;
+    durationMs: number;
+    tokenUsage?: { input: number; output: number };
+  };
+}
+
+/**
+ * Summary generation configuration
+ */
+export interface SummaryConfig {
+  /** Maximum length for summary (in characters) */
+  maxLength: number;
+
+  /** Truncation strategy: simple (hard cut) or smart (try to break at sentence) */
+  truncationStrategy?: 'simple' | 'smart';
+}
+
+/**
+ * Subagent configuration per type
+ * Defines capabilities and behavior for each subagent type
+ */
+export interface SubagentConfig {
+  /** Type identifier */
+  type: SubagentType;
+
+  /** Tools allowed for this agent type */
+  allowedTools: string[];
+
+  /** Default model to use */
+  defaultModel: string;
+
+  /** System prompt for this agent type */
+  systemPrompt: string;
+
+  /** Maximum conversation turns */
+  maxTurns: number;
+
+  /** Summary generation configuration (optional, uses defaults if not specified) */
+  summaryConfig?: SummaryConfig;
+}
+
+/**
+ * Subagent session state (for resume capability)
+ */
+export interface SubagentSession {
+  /** Unique session ID */
+  id: string;
+
+  /** Agent type */
+  type: SubagentType;
+
+  /** Original task description */
+  description: string;
+
+  /** Current execution status */
+  status: 'running' | 'completed' | 'error' | 'cancelled';
+
+  /** Messages (conversation history) */
+  messages: Message[];
+
+  /** Result summary (if completed) */
+  result?: string;
+
+  /** Error (if failed) */
+  error?: string;
+
+  /** Creation timestamp */
+  createdAt: Date;
+
+  /** Last update timestamp */
+  updatedAt: Date;
+
+  /** Token usage */
+  tokenUsage?: { input: number; output: number };
+}
+
+/**
+ * Background task metadata (for Phase 2)
+ */
+export interface BackgroundTask {
+  /** Task ID */
+  id: string;
+
+  /** Subagent session reference */
+  subagentId: string;
+
+  /** Task description */
+  description: string;
+
+  /** Current status */
+  status: 'running' | 'completed' | 'error';
+
+  /** Output file path */
+  outputFile: string;
+
+  /** Started at */
+  startedAt: Date;
+
+  /** Completed at (if finished) */
+  completedAt?: Date;
+}
+
+/**
+ * Custom Agent Definition - for discovery system
+ *
+ * Represents a user-defined custom agent loaded from JSON or Markdown files.
+ * This is the discoverable resource type used by the unified loading system.
+ */
+export interface CustomAgentDefinition extends DiscoverableResource {
+  /** Agent name (identifier) */
+  name: string;
+
+  /** Agent description */
+  description: string;
+
+  /** Tools this agent can use */
+  allowedTools: string[];
+
+  /** Default model to use */
+  defaultModel: string;
+
+  /** Maximum conversation turns */
+  maxTurns: number;
+
+  /** System prompt for the agent */
+  systemPrompt: string;
+
+  /** Source metadata (path, level, namespace) */
+  source: ResourceSource;
+}
+
+/**
+ * Convert CustomAgentDefinition to SubagentConfig
+ */
+export function customAgentToConfig(agent: CustomAgentDefinition): SubagentConfig {
+  return {
+    type: 'general-purpose', // Custom agents are general-purpose type
+    allowedTools: agent.allowedTools,
+    defaultModel: agent.defaultModel,
+    maxTurns: agent.maxTurns,
+    systemPrompt: agent.systemPrompt,
+  };
+}

package/src/index.ts

@@ -35,7 +35,7 @@ export {
   createProvider,
   inferProvider,
   ModelAliases,
-} from './providers/index.js';
+} from './core/providers/index.js';
 
 // Tools
 export {
@@ -51,7 +51,7 @@ export {
   bashTool,
   globTool,
   grepTool,
-} from './tools/index.js';
+} from './core/tools/index.js';
 
 // Permissions
 export {
@@ -61,7 +61,7 @@ export {
   type ConfirmCallback,
   PermissionManager,
   DEFAULT_PERMISSION_CONFIG,
-} from './permissions/index.js';
+} from './core/permissions/index.js';
 
 // Agent
 export {
@@ -73,7 +73,7 @@ export {
   type AgentEventError,
   type AgentEventDone,
   Agent,
-} from './agent/index.js';
+} from './core/agent/index.js';
 
 // Session
 export {
@@ -83,7 +83,7 @@ export {
   type SessionConfig,
   SessionManager,
   DEFAULT_SESSION_CONFIG,
-} from './session/index.js';
+} from './core/session/index.js';
 
 // Checkpointing
 export {
@@ -98,4 +98,4 @@ export {
   getCheckpointManager,
   initCheckpointManager,
   resetCheckpointManager,
-} from './checkpointing/index.js';
+} from './core/session/checkpointing/index.js';

package/tests/config/hooks-config.test.ts

@@ -0,0 +1,324 @@
+/**
+ * Tests for hooks configuration merging and fallback mechanism
+ *
+ * Verifies that hooks config:
+ * 1. Merges correctly from .claude and .gencode directories
+ * 2. GenCode settings override Claude settings at the same level
+ * 3. Arrays are concatenated properly
+ * 4. Deep merge works for nested objects
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { deepMerge } from '../../src/config/merger.js';
+import type { Settings } from '../../src/config/types.js';
+import type { HooksConfig } from '../../src/hooks/types.js';
+
+describe('Hooks Configuration Merging', () => {
+  it('should use gencode hooks when only gencode settings exist', () => {
+    const base: Settings = {};
+    const gencode: Settings = {
+      hooks: {
+        PostToolUse: [
+          {
+            matcher: 'Write',
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "gencode hook"',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const merged = deepMerge(base, gencode);
+
+    expect(merged.hooks).toBeDefined();
+    expect(merged.hooks?.PostToolUse).toHaveLength(1);
+    expect(merged.hooks?.PostToolUse?.[0].matcher).toBe('Write');
+    expect(merged.hooks?.PostToolUse?.[0].hooks[0].command).toBe('echo "gencode hook"');
+  });
+
+  it('should use claude hooks when gencode has no hooks (fallback)', () => {
+    const claude: Settings = {
+      hooks: {
+        PostToolUse: [
+          {
+            matcher: 'Edit',
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "claude hook"',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const gencode: Settings = {
+      provider: 'google', // Has other settings but no hooks
+    };
+
+    // Simulate merge order: claude first, then gencode
+    const merged = deepMerge(claude, gencode);
+
+    expect(merged.hooks).toBeDefined();
+    expect(merged.hooks?.PostToolUse).toHaveLength(1);
+    expect(merged.hooks?.PostToolUse?.[0].matcher).toBe('Edit');
+    expect(merged.hooks?.PostToolUse?.[0].hooks[0].command).toBe('echo "claude hook"');
+    expect(merged.provider).toBe('google');
+  });
+
+  it('should merge hooks from both claude and gencode', () => {
+    const claude: Settings = {
+      hooks: {
+        PostToolUse: [
+          {
+            matcher: 'Edit',
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "claude hook"',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const gencode: Settings = {
+      hooks: {
+        PostToolUse: [
+          {
+            matcher: 'Write',
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "gencode hook"',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    // Simulate merge order: claude first, then gencode
+    const merged = deepMerge(claude, gencode);
+
+    expect(merged.hooks).toBeDefined();
+    expect(merged.hooks?.PostToolUse).toHaveLength(2);
+
+    // Both hooks should be present
+    const editHook = merged.hooks?.PostToolUse?.find(h => h.matcher === 'Edit');
+    const writeHook = merged.hooks?.PostToolUse?.find(h => h.matcher === 'Write');
+
+    expect(editHook).toBeDefined();
+    expect(editHook?.hooks[0].command).toBe('echo "claude hook"');
+
+    expect(writeHook).toBeDefined();
+    expect(writeHook?.hooks[0].command).toBe('echo "gencode hook"');
+  });
+
+  it('should merge hooks from different events', () => {
+    const claude: Settings = {
+      hooks: {
+        PostToolUse: [
+          {
+            matcher: 'Edit',
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "claude post"',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const gencode: Settings = {
+      hooks: {
+        Stop: [
+          {
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "gencode stop"',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const merged = deepMerge(claude, gencode);
+
+    expect(merged.hooks).toBeDefined();
+    expect(merged.hooks?.PostToolUse).toBeDefined();
+    expect(merged.hooks?.Stop).toBeDefined();
+    expect(merged.hooks?.PostToolUse?.[0].hooks[0].command).toBe('echo "claude post"');
+    expect(merged.hooks?.Stop?.[0].hooks[0].command).toBe('echo "gencode stop"');
+  });
+
+  it('should handle gencode overriding same event as claude', () => {
+    const claude: Settings = {
+      hooks: {
+        SessionStart: [
+          {
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "claude session"',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const gencode: Settings = {
+      hooks: {
+        SessionStart: [
+          {
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "gencode session"',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const merged = deepMerge(claude, gencode);
+
+    expect(merged.hooks).toBeDefined();
+    expect(merged.hooks?.SessionStart).toHaveLength(2); // Both merged (arrays concatenated)
+
+    // Check both are present
+    const claudeHook = merged.hooks?.SessionStart?.[0];
+    const gencodeHook = merged.hooks?.SessionStart?.[1];
+
+    expect(claudeHook?.hooks[0].command).toBe('echo "claude session"');
+    expect(gencodeHook?.hooks[0].command).toBe('echo "gencode session"');
+  });
+
+  it('should deduplicate identical hooks', () => {
+    const claude: Settings = {
+      hooks: {
+        Stop: [
+          {
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "done"',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const gencode: Settings = {
+      hooks: {
+        Stop: [
+          {
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "done"', // Same as claude
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const merged = deepMerge(claude, gencode);
+
+    expect(merged.hooks).toBeDefined();
+    expect(merged.hooks?.Stop).toHaveLength(1); // Deduplicated
+    expect(merged.hooks?.Stop?.[0].hooks[0].command).toBe('echo "done"');
+  });
+
+  it('should handle complex nested hooks configuration', () => {
+    const claude: Settings = {
+      hooks: {
+        PreToolUse: [
+          {
+            matcher: 'Bash',
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "pre bash"',
+                timeout: 5000,
+                blocking: true,
+              },
+            ],
+          },
+        ],
+        PostToolUse: [
+          {
+            matcher: 'Write|Edit',
+            hooks: [
+              {
+                type: 'command',
+                command: 'npm run lint',
+                statusMessage: 'Running linter...',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const gencode: Settings = {
+      hooks: {
+        PostToolUse: [
+          {
+            matcher: 'Bash',
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo "post bash"',
+              },
+            ],
+          },
+        ],
+        Stop: [
+          {
+            hooks: [
+              {
+                type: 'command',
+                command: 'afplay done.mp3',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const merged = deepMerge(claude, gencode);
+
+    expect(merged.hooks).toBeDefined();
+    expect(merged.hooks?.PreToolUse).toHaveLength(1);
+    expect(merged.hooks?.PostToolUse).toHaveLength(2); // Merged from both
+    expect(merged.hooks?.Stop).toHaveLength(1);
+
+    // Verify PreToolUse from claude
+    expect(merged.hooks?.PreToolUse?.[0].matcher).toBe('Bash');
+    expect(merged.hooks?.PreToolUse?.[0].hooks[0].blocking).toBe(true);
+
+    // Verify PostToolUse from both
+    const lintHook = merged.hooks?.PostToolUse?.find(h => h.matcher === 'Write|Edit');
+    const bashHook = merged.hooks?.PostToolUse?.find(h => h.matcher === 'Bash');
+    expect(lintHook).toBeDefined();
+    expect(bashHook).toBeDefined();
+
+    // Verify Stop from gencode
+    expect(merged.hooks?.Stop?.[0].hooks[0].command).toBe('afplay done.mp3');
+  });
+});