gencode-ai 0.4.0 → 0.5.0

package/scripts/tests/test-skills-functional.ts

@@ -0,0 +1,256 @@
+/**
+ * Skills Functional Verification Test
+ *
+ * Verifies:
+ * 1. Skill tool creation succeeds
+ * 2. Activating existing skill works
+ * 3. Arguments are correctly passed
+ * 4. Non-existent skill returns error
+ * 5. GEN_DEBUG=2 shows detailed information
+ *
+ * Usage:
+ *   npm run test:skills:func              # Normal mode
+ *   GEN_DEBUG=2 npm run test:skills:func  # Verbose debug mode
+ */
+
+import { createSkillTool, resetSkillDiscovery } from '../../src/core/tools/index.js';
+import { isVerboseDebugEnabled } from '../../src/base/utils/debug.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+interface TestResult {
+  name: string;
+  passed: boolean;
+  error?: string;
+  details?: string;
+}
+
+const results: TestResult[] = [];
+
+function logTest(name: string, passed: boolean, details?: string, error?: string) {
+  results.push({ name, passed, error, details });
+  const icon = passed ? '✓' : '✗';
+  const color = passed ? '\x1b[32m' : '\x1b[31m';
+  const reset = '\x1b[0m';
+  console.log(`${color}${icon}${reset} ${name}`);
+  if (details && isVerboseDebugEnabled('skills')) {
+    console.log(`  ${details}`);
+  }
+  if (error) {
+    console.log(`  Error: ${error}`);
+  }
+}
+
+async function setupTestSkill(cwd: string): Promise<string> {
+  const testDir = path.join(cwd, '.gen', 'skills', 'test-skill');
+  await fs.mkdir(testDir, { recursive: true });
+
+  const skillContent = `---
+name: test-skill
+description: A test skill for functional verification
+allowed-tools: [Read, Grep]
+---
+
+# Test Skill
+
+This is a test skill used for functional verification.
+
+## Instructions
+
+When activated with arguments: {{args}}
+
+This skill should demonstrate:
+1. Proper activation
+2. Argument substitution
+3. Content injection
+
+## Example
+
+Use this skill to verify the Skills system is working correctly.
+`;
+
+  const skillPath = path.join(testDir, 'SKILL.md');
+  await fs.writeFile(skillPath, skillContent, 'utf-8');
+
+  return skillPath;
+}
+
+async function cleanupTestSkill(cwd: string) {
+  const testDir = path.join(cwd, '.gen', 'skills', 'test-skill');
+  await fs.rm(testDir, { recursive: true, force: true });
+}
+
+async function testSkillActivation() {
+  console.log('Skills Functional Verification Test');
+  console.log('====================================\n');
+
+  const cwd = process.cwd();
+  let skillPath: string | undefined;
+
+  try {
+    // Setup: Create test skill
+    console.log('Setup: Creating test skill...');
+    skillPath = await setupTestSkill(cwd);
+    console.log(`Created test skill at ${skillPath}\n`);
+
+    // Reset discovery to pick up new test skill
+    resetSkillDiscovery();
+
+    // Test 1: Create Skill tool
+    console.log('Test 1: Creating Skill tool...');
+    let skillTool;
+    try {
+      skillTool = await createSkillTool(cwd);
+      logTest('Skill tool created successfully', true);
+    } catch (error) {
+      logTest(
+        'Skill tool creation failed',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+      return;
+    }
+
+    // Test 2: Activate existing skill
+    console.log('\nTest 2: Activating existing skill...');
+    try {
+      const result1 = await skillTool.execute(
+        { skill: 'test-skill', args: 'test-argument' },
+        { cwd, sessionId: 'test' }
+      );
+
+      if (result1.error) {
+        logTest('Skill activation returned error', false, undefined, result1.error);
+      } else {
+        const hasContent = result1.output && result1.output.length > 0;
+        const hasMetadata = result1.metadata?.title === 'Skill: test-skill';
+        logTest(
+          'Skill activated successfully',
+          hasContent && hasMetadata,
+          `Output length: ${result1.output?.length || 0}, Has metadata: ${hasMetadata}`
+        );
+      }
+    } catch (error) {
+      logTest(
+        'Skill activation threw exception',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 3: Verify argument passing
+    console.log('\nTest 3: Verifying argument passing...');
+    try {
+      const result2 = await skillTool.execute(
+        { skill: 'test-skill', args: 'custom-argument-123' },
+        { cwd, sessionId: 'test' }
+      );
+
+      const hasArgs = result2.output?.includes('custom-argument-123');
+      logTest(
+        'Arguments correctly passed to skill',
+        hasArgs || false,
+        hasArgs ? 'Found argument in output' : 'Argument not found in output'
+      );
+    } catch (error) {
+      logTest(
+        'Argument passing test threw exception',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 4: Activate non-existent skill
+    console.log('\nTest 4: Activating non-existent skill...');
+    try {
+      const result3 = await skillTool.execute(
+        { skill: 'non-existent-skill' },
+        { cwd, sessionId: 'test' }
+      );
+
+      if (result3.error) {
+        const hasNotFoundMsg = result3.error.includes('Skill not found');
+        logTest(
+          'Non-existent skill returns appropriate error',
+          hasNotFoundMsg,
+          hasNotFoundMsg ? 'Correct error message' : 'Unexpected error format'
+        );
+      } else {
+        logTest('Non-existent skill should return error but succeeded', false);
+      }
+    } catch (error) {
+      logTest(
+        'Non-existent skill test threw exception',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 5: Verify skill metadata
+    console.log('\nTest 5: Verifying skill metadata...');
+    try {
+      const result4 = await skillTool.execute(
+        { skill: 'test-skill' },
+        { cwd, sessionId: 'test' }
+      );
+
+      const hasTitle = result4.metadata?.title === 'Skill: test-skill';
+      const hasSubtitle = result4.metadata?.subtitle === 'A test skill for functional verification';
+      logTest(
+        'Skill metadata correctly populated',
+        hasTitle && hasSubtitle,
+        `Title: ${result4.metadata?.title}, Subtitle: ${result4.metadata?.subtitle}`
+      );
+    } catch (error) {
+      logTest(
+        'Metadata test threw exception',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+  } finally {
+    // Cleanup
+    if (skillPath) {
+      console.log('\nCleanup: Removing test skill...');
+      await cleanupTestSkill(cwd);
+    }
+  }
+
+  // Print summary
+  console.log('\n====================================');
+  console.log('Test Summary');
+  console.log('====================================');
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  console.log(`Total: ${results.length}`);
+  console.log(`Passed: ${passed}`);
+  console.log(`Failed: ${failed}`);
+
+  if (failed > 0) {
+    console.log('\nFailed Tests:');
+    results
+      .filter((r) => !r.passed)
+      .forEach((r) => {
+        console.log(`  - ${r.name}`);
+        if (r.error) {
+          console.log(`    ${r.error}`);
+        }
+      });
+  }
+
+  console.log('\n');
+
+  // Exit with appropriate code
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+testSkillActivation().catch((error) => {
+  console.error('Fatal error during Skills functional test:', error);
+  process.exit(1);
+});

package/scripts/tests/test-skills-loading.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * Skills Loading Test
+ *
+ * Tests skills discovery from all configured directories:
+ * - ~/.claude/skills/
+ * - ~/.gen/skills/
+ * - .claude/skills/
+ * - .gen/skills/
+ *
+ * Usage:
+ *   npm run test:skills                  # Normal mode
+ *   GEN_DEBUG_SKILLS=1 npm run test:skills  # Debug mode
+ *   npm run test:skills -- --verbose     # Show all skills
+ */
+
+import { SkillDiscovery } from '../../src/ext/skills/discovery.js';
+import { logger } from '../../src/base/utils/logger.js';
+import * as path from 'node:path';
+
+const args = process.argv.slice(2);
+const verbose = args.includes('--verbose');
+
+async function main(): Promise<void> {
+  console.log('Skills Discovery Test\n');
+
+  const cwd = process.cwd();
+  const discovery = new SkillDiscovery();
+
+  try {
+    logger.info('SkillsTest', 'Starting skills discovery', { cwd });
+
+    const startTime = Date.now();
+    const skills = await discovery.loadAll(cwd);
+    const duration = Date.now() - startTime;
+
+    console.log(`✓ Loaded ${skills.size} skills in ${duration}ms\n`);
+
+    if (verbose || skills.size <= 20) {
+      console.log('Discovered skills:');
+      for (const [name, skill] of skills) {
+        console.log(`  - ${name}`);
+        console.log(`    Description: ${skill.description}`);
+        if (skill.allowedTools) {
+          const tools = Array.isArray(skill.allowedTools)
+            ? skill.allowedTools.join(', ')
+            : skill.allowedTools;
+          console.log(`    Allowed tools: ${tools}`);
+        }
+        console.log();
+      }
+    } else {
+      console.log('Top 10 skills (use --verbose to see all):');
+      let count = 0;
+      for (const [name, skill] of skills) {
+        if (count++ >= 10) break;
+        console.log(`  - ${name}: ${skill.description}`);
+      }
+      console.log();
+    }
+
+    process.exit(0);
+  } catch (error) {
+    logger.error('SkillsTest', 'Skills discovery failed', {
+      error: error instanceof Error ? error.message : String(error),
+    });
+    console.error('✗ Failed to load skills');
+    if (error instanceof Error && error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/tests/test-subagents-functional.ts

@@ -0,0 +1,302 @@
+/**
+ * Subagents Functional Verification Test
+ *
+ * Verifies:
+ * 1. Task tool is available
+ * 2. Subagent configuration for different types (Explore, Plan, Bash, general-purpose)
+ * 3. Tool restrictions per agent type
+ * 4. max_turns configuration
+ * 5. Model override
+ *
+ * Note: This test validates subagent creation and configuration without
+ * making actual LLM API calls to avoid cost and credential requirements.
+ * For full end-to-end testing with actual execution, set GEN_PROVIDER and
+ * run with API credentials.
+ *
+ * Usage:
+ *   npm run test:subagents:func              # Normal mode (validation only)
+ *   GEN_DEBUG=2 npm run test:subagents:func  # Verbose debug mode
+ */
+
+import { Subagent } from '../../src/ext/subagents/subagent.js';
+import { SUBAGENT_CONFIGS } from '../../src/ext/subagents/configs.js';
+import { isVerboseDebugEnabled } from '../../src/base/utils/debug.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+interface TestResult {
+  name: string;
+  passed: boolean;
+  error?: string;
+  details?: string;
+}
+
+const results: TestResult[] = [];
+
+function logTest(name: string, passed: boolean, details?: string, error?: string) {
+  results.push({ name, passed, error, details });
+  const icon = passed ? '✓' : '✗';
+  const color = passed ? '\x1b[32m' : '\x1b[31m';
+  const reset = '\x1b[0m';
+  console.log(`${color}${icon}${reset} ${name}`);
+  if (details && isVerboseDebugEnabled('subagents')) {
+    console.log(`  ${details}`);
+  }
+  if (error) {
+    console.log(`  Error: ${error}`);
+  }
+}
+
+async function setupTestFile(cwd: string): Promise<string> {
+  const testFile = path.join(cwd, '.gen-test-subagent.txt');
+  await fs.writeFile(testFile, 'Test content for subagent verification', 'utf-8');
+  return testFile;
+}
+
+async function cleanupTestFile(testFile: string) {
+  await fs.unlink(testFile).catch(() => {});
+}
+
+async function testSubagentConfiguration() {
+  console.log('Subagents Functional Verification Test');
+  console.log('========================================\n');
+
+  const cwd = process.cwd();
+  let testFile: string | undefined;
+
+  try {
+    // Setup: Create test file
+    console.log('Setup: Creating test file...');
+    testFile = await setupTestFile(cwd);
+    console.log(`Created test file at ${testFile}\n`);
+
+    // Test 1: Explore agent configuration
+    console.log('Test 1: Verifying Explore agent configuration...');
+    try {
+      const exploreConfig = SUBAGENT_CONFIGS['Explore'];
+      const hasReadOnlyTools = exploreConfig.allowedTools.includes('Read') &&
+                               exploreConfig.allowedTools.includes('Glob') &&
+                               exploreConfig.allowedTools.includes('Grep');
+      const noWriteTools = !exploreConfig.allowedTools.includes('Write') &&
+                          !exploreConfig.allowedTools.includes('Edit');
+      const correctModel = exploreConfig.defaultModel === 'claude-haiku-4';
+      const correctMaxTurns = exploreConfig.maxTurns === 10;
+
+      const passed = hasReadOnlyTools && noWriteTools && correctModel && correctMaxTurns;
+      logTest(
+        'Explore agent has correct configuration',
+        passed,
+        `Tools: ${exploreConfig.allowedTools.join(', ')}, Model: ${exploreConfig.defaultModel}, MaxTurns: ${exploreConfig.maxTurns}`
+      );
+    } catch (error) {
+      logTest(
+        'Explore agent configuration failed',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 2: Plan agent configuration
+    console.log('\nTest 2: Verifying Plan agent configuration...');
+    try {
+      const planConfig = SUBAGENT_CONFIGS['Plan'];
+      const hasReadTools = planConfig.allowedTools.includes('Read');
+      const hasTodoWrite = planConfig.allowedTools.includes('TodoWrite');
+      const noExecutionTools = !planConfig.allowedTools.includes('Write') &&
+                              !planConfig.allowedTools.includes('Edit') &&
+                              !planConfig.allowedTools.includes('Bash');
+      const correctModel = planConfig.defaultModel === 'claude-sonnet-4';
+
+      const passed = hasReadTools && hasTodoWrite && noExecutionTools && correctModel;
+      logTest(
+        'Plan agent has correct configuration',
+        passed,
+        `Tools: ${planConfig.allowedTools.join(', ')}, Model: ${planConfig.defaultModel}`
+      );
+    } catch (error) {
+      logTest(
+        'Plan agent configuration failed',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 3: Bash agent configuration
+    console.log('\nTest 3: Verifying Bash agent configuration...');
+    try {
+      const bashConfig = SUBAGENT_CONFIGS['Bash'];
+      const onlyBashTool = bashConfig.allowedTools.length === 1 &&
+                          bashConfig.allowedTools[0] === 'Bash';
+      const correctModel = bashConfig.defaultModel === 'claude-haiku-4';
+      const correctMaxTurns = bashConfig.maxTurns === 20;
+
+      const passed = onlyBashTool && correctModel && correctMaxTurns;
+      logTest(
+        'Bash agent has correct configuration',
+        passed,
+        `Tools: ${bashConfig.allowedTools.join(', ')}, Model: ${bashConfig.defaultModel}, MaxTurns: ${bashConfig.maxTurns}`
+      );
+    } catch (error) {
+      logTest(
+        'Bash agent configuration failed',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 4: general-purpose agent configuration
+    console.log('\nTest 4: Verifying general-purpose agent configuration...');
+    try {
+      const gpConfig = SUBAGENT_CONFIGS['general-purpose'];
+      const hasWildcard = gpConfig.allowedTools.includes('*');
+      const correctModel = gpConfig.defaultModel === 'claude-sonnet-4';
+      const correctMaxTurns = gpConfig.maxTurns === 20;
+
+      const passed = hasWildcard && correctModel && correctMaxTurns;
+      logTest(
+        'general-purpose agent has correct configuration',
+        passed,
+        `Tools: ${gpConfig.allowedTools.join(', ')} (wildcard=all), Model: ${gpConfig.defaultModel}, MaxTurns: ${gpConfig.maxTurns}`
+      );
+    } catch (error) {
+      logTest(
+        'general-purpose agent configuration failed',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 5: Subagent creation with Explore type
+    console.log('\nTest 5: Creating Explore subagent instance...');
+    try {
+      const subagent = new Subagent({
+        type: 'Explore',
+        cwd,
+        description: 'Test Explore agent',
+      });
+
+      // Verify the subagent was created successfully
+      // We can't actually run it without API credentials, but we can verify creation
+      logTest('Explore subagent instance created successfully', true, 'Instance created');
+    } catch (error) {
+      logTest(
+        'Explore subagent creation failed',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 6: Subagent creation with model override
+    console.log('\nTest 6: Creating subagent with model override...');
+    try {
+      const subagent = new Subagent({
+        type: 'Explore',
+        model: 'claude-sonnet-4',
+        cwd,
+        description: 'Test model override',
+      });
+
+      logTest('Subagent with model override created successfully', true, 'Model: claude-sonnet-4');
+    } catch (error) {
+      logTest(
+        'Subagent model override failed',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 7: Subagent creation with max_turns override
+    console.log('\nTest 7: Creating subagent with max_turns override...');
+    try {
+      const subagent = new Subagent({
+        type: 'Explore',
+        cwd,
+        config: { maxTurns: 5 },
+        description: 'Test max_turns override',
+      });
+
+      logTest('Subagent with max_turns override created successfully', true, 'MaxTurns: 5');
+    } catch (error) {
+      logTest(
+        'Subagent max_turns override failed',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Test 8: Verify custom agent loader (if any exist)
+    console.log('\nTest 8: Checking for custom agents...');
+    try {
+      const { CustomAgentLoader } = await import('../src/ext/subagents/manager.js');
+      const loader = new CustomAgentLoader();
+      await loader.initialize();
+      const customAgents = await loader.listAgents(cwd);
+
+      logTest(
+        'Custom agent loader initialized',
+        true,
+        `Found ${customAgents.length} custom agent(s): ${customAgents.map(a => a.name).join(', ') || 'none'}`
+      );
+    } catch (error) {
+      logTest(
+        'Custom agent loader failed',
+        false,
+        undefined,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+
+    // Note about execution testing
+    console.log('\n----------------------------------------');
+    console.log('Note: Actual subagent execution testing requires API credentials.');
+    console.log('To test execution, ensure GEN_PROVIDER and appropriate API keys are set.');
+    console.log('This test validates configuration and setup without making API calls.');
+    console.log('----------------------------------------');
+
+  } finally {
+    // Cleanup
+    if (testFile) {
+      console.log('\nCleanup: Removing test file...');
+      await cleanupTestFile(testFile);
+    }
+  }
+
+  // Print summary
+  console.log('\n========================================');
+  console.log('Test Summary');
+  console.log('========================================');
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  console.log(`Total: ${results.length}`);
+  console.log(`Passed: ${passed}`);
+  console.log(`Failed: ${failed}`);
+
+  if (failed > 0) {
+    console.log('\nFailed Tests:');
+    results
+      .filter((r) => !r.passed)
+      .forEach((r) => {
+        console.log(`  - ${r.name}`);
+        if (r.error) {
+          console.log(`    ${r.error}`);
+        }
+      });
+  }
+
+  console.log('\n');
+
+  // Exit with appropriate code
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+testSubagentConfiguration().catch((error) => {
+  console.error('Fatal error during Subagents functional test:', error);
+  process.exit(1);
+});