@iservu-inc/adf-cli 0.13.0 → 0.14.0

package/tests/kiro-trae-generators.test.js

@@ -0,0 +1,43 @@
+const fs = require('fs-extra');
+const path = require('path');
+const KiroGenerator = require('../lib/generators/kiro-generator');
+const TraeGenerator = require('../lib/generators/trae-generator');
+
+describe('Kiro and Trae Generators', () => {
+  const tempDir = path.join(__dirname, 'temp-tool-test');
+  const sessionPath = path.join(tempDir, '.adf/sessions/test-session');
+
+  beforeEach(async () => {
+    await fs.ensureDir(path.join(sessionPath, 'outputs'));
+    // Mock outputs
+    await fs.writeFile(path.join(sessionPath, 'outputs/constitution.md'), '## Overview\nTest Overview\n## Key Principles\nPrinciple 1');
+    await fs.writeJson(path.join(sessionPath, '_metadata.json'), { projectName: 'Test Project' });
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('KiroGenerator should create product and technical markdown files', async () => {
+    const generator = new KiroGenerator(sessionPath, tempDir, 'balanced');
+    await generator.generate();
+
+    expect(await fs.pathExists(path.join(tempDir, '.kiro/product.md'))).toBe(true);
+    expect(await fs.pathExists(path.join(tempDir, '.kiro/technical.md'))).toBe(true);
+    
+    const productContent = await fs.readFile(path.join(tempDir, '.kiro/product.md'), 'utf-8');
+    expect(productContent).toContain('Test Project');
+    expect(productContent).toContain('Test Overview');
+  });
+
+  test('TraeGenerator should create config.json', async () => {
+    const generator = new TraeGenerator(sessionPath, tempDir, 'balanced');
+    await generator.generate();
+
+    expect(await fs.pathExists(path.join(tempDir, '.trae/config.json'))).toBe(true);
+    
+    const config = await fs.readJson(path.join(tempDir, '.trae/config.json'));
+    expect(config.framework.name).toBe('AgentDevFramework');
+    expect(config.project_structure.docs).toBe('docs/');
+  });
+});

package/tests/opencode-generator.test.js

@@ -0,0 +1,113 @@
+const fs = require('fs-extra');
+const path = require('path');
+const OpenCodeGenerator = require('../lib/generators/opencode-generator');
+
+const TEST_PROJECT_PATH = path.join(__dirname, 'test-project-opencode');
+const TEST_SESSION_PATH = path.join(TEST_PROJECT_PATH, '.adf', 'sessions', 'test-session');
+
+describe('OpenCodeGenerator', () => {
+  beforeEach(async () => {
+    // Clean up test directories
+    await fs.remove(TEST_PROJECT_PATH);
+    await fs.ensureDir(TEST_PROJECT_PATH);
+    await fs.ensureDir(TEST_SESSION_PATH);
+    await fs.ensureDir(path.join(TEST_SESSION_PATH, 'outputs'));
+    
+    // Create mock .env file
+    await fs.ensureDir(path.join(TEST_PROJECT_PATH, '.adf'));
+    await fs.writeFile(
+      path.join(TEST_PROJECT_PATH, '.adf', '.env'),
+      'ANTHROPIC_API_KEY=test-key\nOPENAI_API_KEY=test-key',
+      'utf-8'
+    );
+  });
+
+  afterEach(async () => {
+    // Clean up after tests
+    await fs.remove(TEST_PROJECT_PATH);
+  });
+
+  it('should generate opencode.json with correct filename and standard schema', async () => {
+    // Create mock PRP output
+    const prpContent = '# Product Requirement Prompt\n\n## 1. Goal Definition\nTest project';
+    await fs.writeFile(
+      path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+      prpContent,
+      'utf-8'
+    );
+
+    // Create metadata
+    await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+      framework: 'rapid',
+      projectName: 'Test Project'
+    });
+
+    const generator = new OpenCodeGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+    const result = await generator.generate();
+
+    // 1. Verify filename is opencode.json (not .opencode.json)
+    const configPath = path.join(TEST_PROJECT_PATH, 'opencode.json');
+    expect(await fs.pathExists(configPath)).toBe(true);
+    expect(result.config).toBe(configPath);
+
+    // 2. Read config
+    const config = await fs.readJson(configPath);
+
+    // 3. Verify plural keys (latest schema)
+    expect(config.providers).toBeDefined();
+    expect(config.agents).toBeDefined();
+    expect(config.mcpServers).toBeDefined();
+
+    // 4. Verify singular keys are NOT present
+    expect(config.provider).toBeUndefined();
+    expect(config.agent).toBeUndefined();
+    expect(config.mcp).toBeUndefined();
+  });
+
+  it('should support small_model field', async () => {
+    const generator = new OpenCodeGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+    const config = await generator.generateConfig();
+
+    expect(config.small_model).toBeDefined();
+    expect(typeof config.small_model).toBe('string');
+  });
+
+  it('should validate configuration before writing', async () => {
+    const generator = new OpenCodeGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+    
+    // Spy on validation method
+    const validateSpy = jest.spyOn(generator, 'validateConfig');
+    
+    // Mock validateConfig to throw if not implemented yet (this test expects the method to exist)
+    if (!generator.validateConfig) {
+      generator.validateConfig = () => { throw new Error('Validation not implemented'); };
+    }
+
+    try {
+      await generator.generate();
+    } catch (e) {
+      // Ignore generation errors, we just want to check if validate was called
+    }
+
+    // This test will fail if validateConfig doesn't exist or isn't called
+    // We expect it to fail initially as the method doesn't exist
+    expect(generator.validateConfig).toBeDefined(); 
+  });
+
+  it('should handle all supported providers correctly', async () => {
+    // Overwrite .env with all providers
+    await fs.writeFile(
+      path.join(TEST_PROJECT_PATH, '.adf', '.env'),
+      'ANTHROPIC_API_KEY=key\nOPENAI_API_KEY=key\nGEMINI_API_KEY=key\nOPENROUTER_API_KEY=key',
+      'utf-8'
+    );
+
+    const generator = new OpenCodeGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+    const config = await generator.generateConfig();
+
+    expect(config.providers.anthropic).toBeDefined();
+    expect(config.providers.openai).toBeDefined();
+    expect(config.providers.google).toBeDefined();
+    expect(config.providers.openrouter).toBeDefined();
+  });
+});

package/tests/synthesis-engine.test.js

@@ -0,0 +1,52 @@
+const fs = require('fs-extra');
+const path = require('path');
+const SynthesisEngine = require('../lib/analysis/synthesis-engine');
+
+describe('Synthesis Engine', () => {
+  const tempDir = path.join(__dirname, 'temp-synthesis-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should merge overlapping context data', () => {
+    const contexts = [
+      { name: 'Project A', overview: 'Overview 1', techStack: 'Node.js' },
+      { name: 'Project B', overview: 'Overview 2', techStack: 'React' }
+    ];
+
+    const merged = SynthesisEngine.merge(contexts);
+
+    expect(merged.name).toBe('Project B'); // Last one wins for singular fields
+    expect(merged.overview).toContain('Overview 1');
+    expect(merged.overview).toContain('Overview 2');
+    expect(merged.techStack).toContain('Node.js');
+    expect(merged.techStack).toContain('React');
+  });
+
+  test('should create a new augmented session folder', async () => {
+    const mergedContext = {
+      name: 'Test Project',
+      overview: 'Synthesized overview',
+      techStack: 'Node, React'
+    };
+
+    const adfDir = path.join(tempDir, '.adf');
+    await fs.ensureDir(adfDir);
+
+    const sessionPath = await SynthesisEngine.createAugmentedSession(tempDir, mergedContext, 'balanced');
+
+    expect(sessionPath).toContain('augmentation');
+    expect(await fs.pathExists(sessionPath)).toBe(true);
+
+    const progress = await fs.readJson(path.join(sessionPath, '_progress.json'));
+    expect(progress.status).toBe('in-progress');
+    // Pre-filled answers for the interviewer
+    expect(progress.answers['project-name'].text).toBe('Test Project');
+    expect(progress.answers['project-overview'].text).toBe('Synthesized overview');
+  });
+});

package/tests/tool-feature-registry.test.js

@@ -0,0 +1,23 @@
+const ToolFeatureRegistry = require('../lib/utils/tool-feature-registry');
+
+describe('Tool Feature Registry', () => {
+  test('should list all supported tools', () => {
+    const tools = ToolFeatureRegistry.listTools();
+    expect(tools).toContain('kiro');
+    expect(tools).toContain('trae');
+    expect(tools).toContain('codex-cli');
+    expect(tools).toContain('windsurf');
+  });
+
+  test('should get features for a specific tool', () => {
+    const features = ToolFeatureRegistry.getFeatures('kiro');
+    expect(features.supported).toBe(true);
+    expect(features.configFiles).toContain('.kiro/product.md');
+  });
+
+  test('should audit tools and return status report', () => {
+    const audit = ToolFeatureRegistry.audit();
+    expect(audit.totalCount).toBeGreaterThanOrEqual(10);
+    expect(audit.tools.kiro.status).toBe('supported');
+  });
+});