@iservu-inc/adf-cli 0.17.5 → 0.18.0

package/tests/harness-provider-switch.test.js

@@ -0,0 +1,204 @@
+const fs = require('fs-extra');
+const path = require('path');
+const RunManager = require('../lib/harness/run-manager');
+const ContextWindowManager = require('../lib/harness/context-window-manager');
+const ProviderBridge = require('../lib/harness/provider-bridge');
+const KnowledgeGraph = require('../lib/analysis/knowledge-graph');
+
+describe('Harness Provider Switch', () => {
+  const tempDir = path.join(__dirname, 'temp-provider-switch');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should transfer handoff between Anthropic and OpenAI', async () => {
+    // Phase 1: Start with Anthropic
+    const manager = new RunManager(tempDir);
+    const run = await manager.createRun({
+      workflow: 'balanced',
+      provider: { id: 'anthropic', model: 'claude-opus-4-6', contextWindowSize: 200000 }
+    });
+    await manager.startRun(run.id);
+
+    const runDir = manager.getRunDir(run.id);
+    const cwManager = new ContextWindowManager(runDir, run.id);
+
+    // Open window 1 (Anthropic)
+    await cwManager.openWindow({ tokenLimit: 200000 });
+
+    // Build knowledge
+    const kg = new KnowledgeGraph(path.join(tempDir, 'session'));
+    await fs.ensureDir(path.join(tempDir, 'session'));
+    kg.add([
+      { type: 'tech_stack', content: 'React with TypeScript', confidence: 95, source: 'q1' },
+      { type: 'architecture', content: 'REST API with Express', confidence: 88, source: 'q2' }
+    ]);
+
+    // Generate handoff with Anthropic context
+    const handoff = await cwManager.generateHandoffPackage({
+      progressSummary: '5 of 15 questions answered with Claude Opus 4.6',
+      completedWork: ['Block 1', 'Block 2'],
+      nextSteps: ['Block 3'],
+      knowledgeGraph: kg.toHandoffFormat(),
+      criticalAnswers: [
+        { questionId: 'q1', summary: 'React + TS', quality: 95 },
+        { questionId: 'q2', summary: 'Express REST', quality: 88 }
+      ],
+      position: {
+        currentBlock: 3,
+        totalBlocks: 5,
+        answeredIds: ['q1', 'q2', 'q3', 'q4', 'q5'],
+        remainingIds: ['q6', 'q7', 'q8', 'q9', 'q10']
+      },
+      activeRules: [{ id: 'rule_1', type: 'skip', questionId: 'q_skip' }],
+      sourceProviderId: 'anthropic'
+    });
+
+    await cwManager.closeWindow('completed');
+    await manager.pauseRun(run.id);
+
+    // Phase 2: Resume with OpenAI
+    await manager.resumeRun(run.id);
+
+    // Update run provider
+    const updatedRun = await manager.loadRun(run.id);
+    updatedRun.provider = { id: 'openai', model: 'gpt-5.2', contextWindowSize: 400000 };
+    await manager.saveRun(updatedRun);
+
+    // Open window 2 (OpenAI context)
+    const window2 = await cwManager.openWindow({ tokenLimit: 400000 });
+    expect(window2.sequence).toBe(2);
+
+    // Consume handoff
+    const consumed = await cwManager.consumeHandoffPackage('latest');
+    expect(consumed).not.toBeNull();
+
+    // Verify all data transferred correctly
+    expect(consumed.progressSummary).toContain('Claude Opus 4.6');
+    expect(consumed.sourceProviderId).toBe('anthropic');
+    expect(consumed.position.answeredIds.length).toBe(5);
+    expect(consumed.position.remainingIds.length).toBe(5);
+    expect(consumed.knowledgeGraph.highConfidenceItems.length).toBe(2);
+    expect(consumed.activeRules.length).toBe(1);
+    expect(consumed.criticalAnswers.length).toBe(2);
+
+    // Restore knowledge graph
+    const kg2 = new KnowledgeGraph(path.join(tempDir, 'session2'));
+    await fs.ensureDir(path.join(tempDir, 'session2'));
+    kg2.fromHandoffFormat(consumed.knowledgeGraph);
+    expect(kg2.has('tech_stack', 90)).toBe(true);
+    expect(kg2.has('architecture', 85)).toBe(true);
+  });
+
+  test('should transfer handoff between OpenAI and Google Gemini', async () => {
+    const manager = new RunManager(tempDir);
+    const run = await manager.createRun({
+      workflow: 'comprehensive',
+      provider: { id: 'openai', model: 'gpt-5.2', contextWindowSize: 400000 }
+    });
+    await manager.startRun(run.id);
+
+    const runDir = manager.getRunDir(run.id);
+    const cwManager = new ContextWindowManager(runDir, run.id);
+    await cwManager.openWindow();
+
+    // Generate handoff from OpenAI context
+    const handoff = await cwManager.generateHandoffPackage({
+      progressSummary: 'Phase 1 done with GPT-5.2',
+      position: {
+        currentBlock: 2,
+        totalBlocks: 8,
+        answeredIds: ['q1', 'q2', 'q3'],
+        remainingIds: ['q4', 'q5', 'q6', 'q7', 'q8']
+      },
+      knowledgeGraph: {
+        highConfidenceItems: [
+          { type: 'tech_stack', content: 'Python FastAPI', confidence: 92, sources: ['q1'] }
+        ],
+        totalItems: 1,
+        typesSeen: ['tech_stack']
+      },
+      sourceProviderId: 'openai'
+    });
+
+    await cwManager.closeWindow();
+    await manager.pauseRun(run.id);
+
+    // Resume with Google Gemini
+    await manager.resumeRun(run.id);
+    const updatedRun = await manager.loadRun(run.id);
+    updatedRun.provider = { id: 'google', model: 'gemini-3.1-pro-preview', contextWindowSize: 1000000 };
+    await manager.saveRun(updatedRun);
+
+    await cwManager.openWindow({ tokenLimit: 1000000 });
+    const consumed = await cwManager.consumeHandoffPackage('latest');
+
+    expect(consumed.sourceProviderId).toBe('openai');
+    expect(consumed.position.answeredIds.length).toBe(3);
+    expect(consumed.knowledgeGraph.highConfidenceItems[0].content).toBe('Python FastAPI');
+  });
+
+  test('provider bridge capabilities should be independent of handoff', () => {
+    const mockClient = {
+      sendMessage: jest.fn().mockResolvedValue({ text: 'ok', usage: { inputTokens: 10, outputTokens: 5 } })
+    };
+
+    // Start with Anthropic bridge
+    const bridge1 = new ProviderBridge(mockClient, 'anthropic', 'claude-opus-4-6');
+    expect(bridge1.getContextWindowSize(false)).toBe(200000);
+    expect(bridge1.getContextWindowSize(true)).toBe(1000000);
+    expect(bridge1.supportsCompaction()).toBe(true);
+
+    // Switch to OpenAI bridge (same client, different capabilities)
+    const bridge2 = new ProviderBridge(mockClient, 'openai', 'gpt-5.2');
+    expect(bridge2.getContextWindowSize(false)).toBe(400000);
+    expect(bridge2.supportsCompaction()).toBe(true);
+
+    // Switch to Google bridge (largest context)
+    const bridge3 = new ProviderBridge(mockClient, 'google', 'gemini-3.1-pro-preview');
+    expect(bridge3.getContextWindowSize(false)).toBe(1000000);
+    expect(bridge3.supportsInteractionsAPI()).toBe(true);
+    expect(bridge3.supportsThoughtSignatures()).toBe(true);
+
+    // Provider info for handoff is correct
+    expect(bridge1.getProviderInfo().id).toBe('anthropic');
+    expect(bridge2.getProviderInfo().id).toBe('openai');
+    expect(bridge3.getProviderInfo().id).toBe('google');
+  });
+
+  test('handoff package should be provider-agnostic format', async () => {
+    const manager = new RunManager(tempDir);
+    const run = await manager.createRun({ workflow: 'rapid' });
+    await manager.startRun(run.id);
+
+    const runDir = manager.getRunDir(run.id);
+    const cwManager = new ContextWindowManager(runDir, run.id);
+    await cwManager.openWindow();
+
+    const handoff = await cwManager.generateHandoffPackage({
+      progressSummary: 'Test',
+      position: { currentBlock: 1, totalBlocks: 3, answeredIds: ['q1'], remainingIds: ['q2'] },
+      sourceProviderId: 'anthropic'
+    });
+
+    // Handoff should contain no provider-specific API keys, tokens, or formats
+    const json = handoff.toJSON();
+    const jsonStr = JSON.stringify(json);
+
+    // Should not contain API key patterns
+    expect(jsonStr).not.toContain('sk-ant-');
+    expect(jsonStr).not.toContain('sk-');
+    expect(jsonStr).not.toContain('API_KEY');
+
+    // Should contain only portable data
+    expect(json.progressSummary).toBeDefined();
+    expect(json.position).toBeDefined();
+    expect(json.knowledgeGraph).toBeDefined();
+    expect(json.sourceProviderId).toBe('anthropic');
+  });
+});

package/tests/harness-run-manager.test.js

@@ -0,0 +1,131 @@
+const fs = require('fs-extra');
+const path = require('path');
+const RunManager = require('../lib/harness/run-manager');
+
+describe('RunManager', () => {
+  const tempDir = path.join(__dirname, 'temp-run-manager-test');
+  let manager;
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+    manager = new RunManager(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should create a new run', async () => {
+    const run = await manager.createRun({ workflow: 'rapid' });
+    expect(run.id).toMatch(/^run_/);
+    expect(run.status).toBe('initializing');
+    expect(run.workflow).toBe('rapid');
+
+    // Should have created files
+    const runDir = manager.getRunDir(run.id);
+    expect(await fs.pathExists(path.join(runDir, 'harness-run.json'))).toBe(true);
+    expect(await fs.pathExists(path.join(runDir, 'context-windows'))).toBe(true);
+    expect(await fs.pathExists(path.join(runDir, 'milestones'))).toBe(true);
+  });
+
+  test('should set current-run pointer on create', async () => {
+    const run = await manager.createRun();
+    const currentId = await manager.getCurrentRunId();
+    expect(currentId).toBe(run.id);
+  });
+
+  test('should load current run', async () => {
+    const created = await manager.createRun({ workflow: 'comprehensive' });
+    const loaded = await manager.getCurrentRun();
+    expect(loaded).not.toBeNull();
+    expect(loaded.id).toBe(created.id);
+    expect(loaded.workflow).toBe('comprehensive');
+  });
+
+  test('should return null when no current run', async () => {
+    const run = await manager.getCurrentRun();
+    expect(run).toBeNull();
+  });
+
+  test('should start a run', async () => {
+    const created = await manager.createRun();
+    const started = await manager.startRun(created.id);
+    expect(started.status).toBe('running');
+  });
+
+  test('should pause a run', async () => {
+    const created = await manager.createRun();
+    await manager.startRun(created.id);
+    const paused = await manager.pauseRun(created.id);
+    expect(paused.status).toBe('paused');
+  });
+
+  test('should resume a paused run', async () => {
+    const created = await manager.createRun();
+    await manager.startRun(created.id);
+    await manager.pauseRun(created.id);
+    const resumed = await manager.resumeRun(created.id);
+    expect(resumed.status).toBe('running');
+  });
+
+  test('should fail to resume non-paused run', async () => {
+    const created = await manager.createRun();
+    await manager.startRun(created.id);
+    await expect(manager.resumeRun(created.id)).rejects.toThrow('not paused');
+  });
+
+  test('should complete a run', async () => {
+    const created = await manager.createRun();
+    await manager.startRun(created.id);
+    const completed = await manager.completeRun(created.id);
+    expect(completed.status).toBe('completed');
+
+    // Should clear current-run pointer
+    const currentId = await manager.getCurrentRunId();
+    expect(currentId).toBeNull();
+  });
+
+  test('should fail a run', async () => {
+    const created = await manager.createRun();
+    await manager.startRun(created.id);
+    const failed = await manager.failRun(created.id, 'Something went wrong');
+    expect(failed.status).toBe('failed');
+  });
+
+  test('should list all runs', async () => {
+    await manager.createRun({ workflow: 'rapid' });
+    await manager.createRun({ workflow: 'balanced' });
+
+    const runs = await manager.listRuns();
+    expect(runs.length).toBe(2);
+  });
+
+  test('should return empty list when no runs', async () => {
+    const runs = await manager.listRuns();
+    expect(runs).toEqual([]);
+  });
+
+  test('should throw on non-existent run', async () => {
+    await expect(manager.startRun('run_nonexistent')).rejects.toThrow('Run not found');
+  });
+
+  test('should create run with provider info', async () => {
+    const run = await manager.createRun({
+      provider: { id: 'anthropic', model: 'claude-opus-4-6', contextWindowSize: 200000 }
+    });
+    expect(run.provider.id).toBe('anthropic');
+    expect(run.provider.model).toBe('claude-opus-4-6');
+  });
+
+  test('should create run with session linkage', async () => {
+    const run = await manager.createRun({ sessionId: '2026-01-01T00-00-00_balanced' });
+    expect(run.sessionId).toBe('2026-01-01T00-00-00_balanced');
+  });
+
+  test('should get event logger for run', async () => {
+    const run = await manager.createRun();
+    const logger = manager.getEventLogger(run.id);
+    expect(logger).toBeDefined();
+    expect(logger.filePath).toContain(run.id);
+  });
+});

package/tests/tool-detector.test.js

@@ -0,0 +1,152 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+const ToolDetector = require('../lib/utils/tool-detector');
+
+describe('ToolDetector', () => {
+  describe('expandPath', () => {
+    test('should expand ~ to home directory', () => {
+      const result = ToolDetector.expandPath('~/.cursor/');
+      expect(result).toBe(path.join(os.homedir(), '.cursor/'));
+    });
+
+    test('should expand %APPDATA% style env vars', () => {
+      process.env.TEST_VAR_XYZ = '/test/path';
+      const result = ToolDetector.expandPath('%TEST_VAR_XYZ%/Cursor/');
+      expect(result).toBe('/test/path/Cursor/');
+      delete process.env.TEST_VAR_XYZ;
+    });
+
+    test('should return path unchanged when no expansion needed', () => {
+      const result = ToolDetector.expandPath('/usr/local/bin/cursor');
+      expect(result).toBe('/usr/local/bin/cursor');
+    });
+
+    test('should replace unknown env vars with empty string', () => {
+      const result = ToolDetector.expandPath('%NONEXISTENT_VAR_12345%/path');
+      expect(result).toBe('/path');
+    });
+  });
+
+  describe('execQuiet', () => {
+    test('should resolve for a valid command', async () => {
+      // node --version works cross-platform
+      const result = await ToolDetector.execQuiet('node --version');
+      expect(result).toMatch(/^v\d+/);
+    });
+
+    test('should reject for an invalid command', async () => {
+      await expect(
+        ToolDetector.execQuiet('nonexistent_binary_xyz_12345 --version')
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('detectBinary', () => {
+    test('should detect node binary (always available)', async () => {
+      const result = await ToolDetector.detectBinary('node');
+      expect(result.found).toBe(true);
+      expect(result.path).toBeTruthy();
+    });
+
+    test('should not detect nonexistent binary', async () => {
+      const result = await ToolDetector.detectBinary('nonexistent_tool_xyz_12345');
+      expect(result.found).toBe(false);
+      expect(result.path).toBeNull();
+    });
+  });
+
+  describe('detectProjectConfigs', () => {
+    let tmpDir;
+
+    beforeEach(async () => {
+      tmpDir = path.join(os.tmpdir(), `adf-test-${Date.now()}`);
+      await fs.ensureDir(tmpDir);
+    });
+
+    afterEach(async () => {
+      await fs.remove(tmpDir);
+    });
+
+    test('should detect existing project config files', async () => {
+      await fs.writeFile(path.join(tmpDir, '.cursorrules'), '# rules');
+      const result = await ToolDetector.detectProjectConfigs(tmpDir, ['.cursorrules', '.cursor/rules/']);
+      expect(result.found).toBe(true);
+      expect(result.files).toContain('.cursorrules');
+    });
+
+    test('should detect existing config directories', async () => {
+      await fs.ensureDir(path.join(tmpDir, '.windsurf', 'rules'));
+      const result = await ToolDetector.detectProjectConfigs(tmpDir, ['.windsurfrules', '.windsurf/rules/']);
+      expect(result.found).toBe(true);
+      expect(result.files).toContain('.windsurf/rules/');
+    });
+
+    test('should return not found for missing configs', async () => {
+      const result = await ToolDetector.detectProjectConfigs(tmpDir, ['.cursorrules', '.cursor/rules/']);
+      expect(result.found).toBe(false);
+      expect(result.files).toHaveLength(0);
+    });
+  });
+
+  describe('detectConfigDirs', () => {
+    test('should detect existing directory', async () => {
+      // os.homedir() always exists
+      const result = await ToolDetector.detectConfigDirs([os.homedir()]);
+      expect(result.found).toBe(true);
+      expect(result.path).toBe(os.homedir());
+    });
+
+    test('should return not found for missing directories', async () => {
+      const result = await ToolDetector.detectConfigDirs(['/nonexistent_path_xyz_12345/']);
+      expect(result.found).toBe(false);
+      expect(result.path).toBeNull();
+    });
+  });
+
+  describe('detectAll', () => {
+    let tmpDir;
+
+    beforeEach(async () => {
+      tmpDir = path.join(os.tmpdir(), `adf-detect-all-${Date.now()}`);
+      await fs.ensureDir(tmpDir);
+    });
+
+    afterEach(async () => {
+      await fs.remove(tmpDir);
+    });
+
+    test('should return a Map with entries for all tools', async () => {
+      const results = await ToolDetector.detectAll(tmpDir);
+      expect(results).toBeInstanceOf(Map);
+      expect(results.size).toBeGreaterThanOrEqual(10);
+    });
+
+    test('each entry should have installed, method, and path fields', async () => {
+      const results = await ToolDetector.detectAll(tmpDir);
+      for (const [, entry] of results) {
+        expect(entry).toHaveProperty('installed');
+        expect(entry).toHaveProperty('method');
+        expect(entry).toHaveProperty('path');
+        expect(typeof entry.installed).toBe('boolean');
+      }
+    });
+
+    test('should detect tools via project config if present', async () => {
+      // Use a tool unlikely to be installed as a binary: trae
+      await fs.ensureDir(path.join(tmpDir, '.trae'));
+      await fs.writeJson(path.join(tmpDir, '.trae', 'config.json'), { test: true });
+      const results = await ToolDetector.detectAll(tmpDir);
+      const trae = results.get('trae');
+      // If trae binary is found it'll be 'binary', otherwise 'project-config'
+      expect(trae.installed).toBe(true);
+    });
+
+    test('a2a protocol entry should not be marked installed', async () => {
+      const results = await ToolDetector.detectAll(tmpDir);
+      const a2a = results.get('a2a');
+      expect(a2a.installed).toBe(false);
+      expect(a2a.method).toBe('protocol');
+    });
+  });
+});