dialectic 0.1.0

package/tests/orchestrator.spec.ts

@@ -0,0 +1,207 @@
+import { DebateOrchestrator } from '../src/core/orchestrator';
+import { DebateConfig, DebateRound, DebateState, Solution } from '../src/types/debate.types';
+import { Agent } from '../src/core/agent';
+
+function createMockAgent(id: string, role: any): Agent {
+  return {
+    config: { id, role, model: 'gpt-4' },
+    propose: async () => ({ content: `${role} proposal`, metadata: {} }),
+    critique: async () => ({ content: `${role} critique`, metadata: {} }),
+    refine: async () => ({ content: `${role} refined`, metadata: {} }),
+    shouldSummarize: () => false,
+    prepareContext: async (context: any) => ({ context }),
+  } as any;
+}
+
+const mockJudge = {
+  synthesize: async (_problem: string, _rounds: DebateRound[]) => ({
+    description: 'final',
+    tradeoffs: [],
+    recommendations: [],
+    confidence: 80,
+    synthesizedBy: 'judge',
+  } as Solution),
+  prepareContext: async (_rounds: DebateRound[]) => ({ context: { problem: '', history: [] } }),
+} as any;
+
+function createMockStateManager() {
+  const state: DebateState = {
+    id: 'deb-test',
+    problem: '',
+    status: 'running',
+    currentRound: 0,
+    rounds: [],
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  } as any;
+
+  return {
+    createDebate: async (problem: string) => ({ ...state, problem }),
+    beginRound: async (_id: string) => {
+      const round = { roundNumber: state.rounds.length + 1, contributions: [], timestamp: new Date() } as DebateRound;
+      state.rounds.push(round);
+      state.currentRound = round.roundNumber;
+      state.updatedAt = new Date();
+      return round;
+    },
+    addContribution: async (_id: string, contrib: any) => {
+      const round = state.rounds[state.currentRound - 1];
+      if (!round) throw new Error('No active round');
+      round.contributions.push(contrib);
+      state.updatedAt = new Date();
+    },
+    completeDebate: async (_id: string, solution: Solution) => {
+      state.status = 'completed';
+      (state as any).finalSolution = solution;
+      state.updatedAt = new Date();
+    },
+    getState: () => state,
+  } as any;
+}
+
+describe('DebateOrchestrator (Flow 1)', () => {
+  it('runs the correct phases for rounds=3 and calls judge synthesis', async () => {
+    const agents = [createMockAgent('a1', 'architect'), createMockAgent('a2', 'performance')];
+    const sm = createMockStateManager();
+    const cfg: DebateConfig = {
+      rounds: 3,
+      terminationCondition: { type: 'fixed' },
+      synthesisMethod: 'judge',
+      includeFullHistory: true,
+      timeoutPerRound: 300000,
+    };
+
+    const orchestrator = new DebateOrchestrator(agents as any, mockJudge, sm as any, cfg);
+    await expect(orchestrator.runDebate('Design a caching system')).resolves.toBeDefined();
+
+    const state = (sm as any).getState();
+    expect(state.rounds.length).toBe(3);
+    // Each round should include refinement contributions
+    state.rounds.forEach((round: DebateRound) => {
+      const hasRefinement = round.contributions.some((c: any) => c.type === 'refinement');
+      expect(hasRefinement).toBe(true);
+    });
+  });
+
+  it('with rounds=1 runs all phases and synthesizes', async () => {
+    const agents = [createMockAgent('a1', 'architect'), createMockAgent('a2', 'performance')];
+    const sm = createMockStateManager();
+    const cfg: DebateConfig = {
+      rounds: 1,
+      terminationCondition: { type: 'fixed' },
+      synthesisMethod: 'judge',
+      includeFullHistory: true,
+      timeoutPerRound: 300000,
+    };
+
+    const orchestrator = new DebateOrchestrator(agents as any, mockJudge, sm as any, cfg);
+    await expect(orchestrator.runDebate('Design a rate limiting system')).resolves.toBeDefined();
+
+    const state = (sm as any).getState();
+    expect(state.rounds.length).toBe(1);
+    const hasProposal = state.rounds[0].contributions.some((c: any) => c.type === 'proposal');
+    const hasCritique = state.rounds[0].contributions.some((c: any) => c.type === 'critique');
+    const hasRefinement = state.rounds[0].contributions.some((c: any) => c.type === 'refinement');
+    expect(hasProposal && hasCritique && hasRefinement).toBe(true);
+  });
+
+  it('round 2 proposals are sourced from round 1 refinements with zeroed metadata', async () => {
+    const agents = [createMockAgent('a1', 'architect'), createMockAgent('a2', 'performance')];
+    const sm = createMockStateManager();
+    const cfg: DebateConfig = {
+      rounds: 2,
+      terminationCondition: { type: 'fixed' },
+      synthesisMethod: 'judge',
+      includeFullHistory: true,
+      timeoutPerRound: 300000,
+    };
+
+    const orchestrator = new DebateOrchestrator(agents as any, mockJudge, sm as any, cfg);
+    await orchestrator.runDebate('Design X');
+
+    const state = (sm as any).getState();
+    expect(state.rounds.length).toBe(2);
+
+    const r1 = state.rounds[0];
+    const r2 = state.rounds[1];
+
+    const r1RefByAgent: Record<string, string> = {};
+    r1.contributions.filter((c: any) => c.type === 'refinement').forEach((c: any) => {
+      r1RefByAgent[c.agentId] = c.content;
+    });
+
+    const r2Props = r2.contributions.filter((c: any) => c.type === 'proposal');
+    expect(r2Props.length).toBe(agents.length);
+
+    // Proposals in round 2 must equal refinements from round 1 per agent, with tokens/latency zero
+    for (const p of r2Props) {
+      expect(p.content).toBe(r1RefByAgent[p.agentId]);
+      expect(p.metadata?.tokensUsed ?? 0).toBe(0);
+      expect(p.metadata?.latencyMs ?? 0).toBe(0);
+      expect(typeof p.metadata?.model).toBe('string');
+    }
+  });
+
+  it('falls back to LLM proposal and warns when prior refinement is missing', async () => {
+    const agents = [createMockAgent('a1', 'architect'), createMockAgent('a2', 'performance')];
+
+    // Custom SM that drops refinement for agent a2 in round 1
+    const state: any = {
+      id: 'deb-test', problem: '', status: 'running', currentRound: 0, rounds: [], createdAt: new Date(), updatedAt: new Date(),
+    };
+    const sm = {
+      createDebate: async (problem: string) => ({ ...state, problem }),
+      beginRound: async (_id: string) => {
+        const round = { roundNumber: state.rounds.length + 1, contributions: [], timestamp: new Date() } as DebateRound;
+        state.rounds.push(round);
+        state.currentRound = round.roundNumber;
+        state.updatedAt = new Date();
+        return round;
+      },
+      addContribution: async (_id: string, contrib: any) => {
+        const round = state.rounds[state.currentRound - 1];
+        if (!round) throw new Error('No active round');
+        // Drop refinement for a2 in round 1 only
+        if (round.roundNumber === 1 && contrib.type === 'refinement' && contrib.agentId === 'a2') {
+          return;
+        }
+        round.contributions.push(contrib);
+        state.updatedAt = new Date();
+      },
+      completeDebate: async (_id: string, solution: Solution) => { state.status = 'completed'; (state as any).finalSolution = solution; state.updatedAt = new Date(); },
+      getState: () => state,
+    } as any;
+
+    // Spy on stderr warnings
+    const cli = await import('../src/cli/index');
+    const warnSpy = jest.spyOn(cli, 'writeStderr').mockImplementation(() => {});
+
+    const cfg: DebateConfig = {
+      rounds: 2,
+      terminationCondition: { type: 'fixed' },
+      synthesisMethod: 'judge',
+      includeFullHistory: true,
+      timeoutPerRound: 300000,
+    };
+
+    const orchestrator = new DebateOrchestrator(agents as any, mockJudge, sm as any, cfg);
+    await orchestrator.runDebate('Design Y');
+
+    const r1 = state.rounds[0];
+    const r2 = state.rounds[1];
+
+    // a1 should be carried over; a2 should fall back to LLM proposal content
+    const r1RefA1 = r1.contributions.find((c: any) => c.type === 'refinement' && c.agentId === 'a1')?.content;
+    const r2PropA1 = r2.contributions.find((c: any) => c.type === 'proposal' && c.agentId === 'a1')?.content;
+    expect(r2PropA1).toBe(r1RefA1);
+
+    const r2PropA2 = r2.contributions.find((c: any) => c.type === 'proposal' && c.agentId === 'a2')?.content;
+    expect(r2PropA2).toBe('performance proposal');
+
+    expect(warnSpy).toHaveBeenCalled();
+    const calls = warnSpy.mock.calls.flat().join(' ');
+    expect(calls).toMatch(/Missing previous refinement/);
+
+    warnSpy.mockRestore();
+  });
+});

package/tests/prompt-loader.spec.ts

@@ -0,0 +1,52 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { resolvePrompt } from '../src/utils/prompt-loader';
+
+describe('resolvePrompt', () => {
+  let tmpDir: string;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prompt-test-'));
+  });
+  afterEach(() => {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  });
+
+  it('returns built-in when no path provided', () => {
+    const res = resolvePrompt({ label: 'Agent A', configDir: tmpDir, defaultText: 'DEFAULT' });
+    expect(res.source).toBe('built-in');
+    expect(res.text).toBe('DEFAULT');
+  });
+
+  it('resolves relative path and reads entire file', () => {
+    const p = path.join(tmpDir, 'a.md');
+    fs.writeFileSync(p, '# Title\nHello world');
+    const res = resolvePrompt({ label: 'Agent B', configDir: tmpDir, promptPath: 'a.md', defaultText: 'DEFAULT' });
+    expect(res.source).toBe('file');
+    expect(res.absPath).toBe(p);
+    expect(res.text).toContain('Hello world');
+  });
+
+  it('falls back on missing file with warning', () => {
+    const res = resolvePrompt({ label: 'Agent C', configDir: tmpDir, promptPath: 'missing.md', defaultText: 'DEFAULT' });
+    expect(res.source).toBe('built-in');
+    expect(res.text).toBe('DEFAULT');
+  });
+
+  it('falls back on empty file', () => {
+    const p = path.join(tmpDir, 'empty.md');
+    fs.writeFileSync(p, '   \n\t');
+    const res = resolvePrompt({ label: 'Agent D', configDir: tmpDir, promptPath: 'empty.md', defaultText: 'DEFAULT' });
+    expect(res.source).toBe('built-in');
+    expect(res.text).toBe('DEFAULT');
+  });
+
+  it('accepts absolute path', () => {
+    const p = path.join(tmpDir, 'abs.md');
+    fs.writeFileSync(p, 'ABC');
+    const res = resolvePrompt({ label: 'Agent E', configDir: tmpDir, promptPath: p, defaultText: 'DEFAULT' });
+    expect(res.source).toBe('file');
+    expect(res.absPath).toBe(p);
+    expect(res.text).toBe('ABC');
+  });
+});

package/tests/prompts/architect.md

@@ -0,0 +1,16 @@
+# Architect System Prompt (Custom)
+
+You are a senior software architect specializing in pragmatic, production-ready designs.
+
+When proposing solutions:
+- Prefer simplicity and clear boundaries over gratuitous microservices
+- Identify critical components, data flows, and failure modes
+- Provide trade-offs and a short migration/rollout plan
+
+When critiquing:
+- Prioritize correctness, operability, and cost of ownership
+- Flag risky assumptions and unclear responsibilities
+
+When refining:
+- Address the most impactful risks first
+- Simplify where possible without losing essential capabilities

package/tests/provider-factory.spec.ts

@@ -0,0 +1,150 @@
+import { createProvider } from '../src/providers/provider-factory';
+import { OpenAIProvider } from '../src/providers/openai-provider';
+import { OpenRouterProvider } from '../src/providers/openrouter-provider';
+import { EXIT_CONFIG_ERROR } from '../src/utils/exit-codes';
+
+// Mock the provider classes
+jest.mock('../src/providers/openai-provider');
+jest.mock('../src/providers/openrouter-provider');
+
+describe('Provider Factory', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('createProvider', () => {
+    it('should create OpenAI provider with valid API key', () => {
+      process.env.OPENAI_API_KEY = 'test-openai-key';
+      
+      const provider = createProvider('openai');
+      
+      expect(OpenAIProvider).toHaveBeenCalledWith('test-openai-key');
+      expect(provider).toBeDefined();
+    });
+
+    it('should create OpenRouter provider with valid API key', () => {
+      process.env.OPENROUTER_API_KEY = 'test-openrouter-key';
+      
+      const provider = createProvider('openrouter');
+      
+      expect(OpenRouterProvider).toHaveBeenCalledWith('test-openrouter-key');
+      expect(provider).toBeDefined();
+    });
+
+    it('should throw error when OpenAI API key is missing', () => {
+      delete process.env.OPENAI_API_KEY;
+      
+      expect(() => createProvider('openai')).toThrow();
+      
+      try {
+        createProvider('openai');
+      } catch (error: any) {
+        expect(error.message).toBe('OPENAI_API_KEY is not set');
+        expect(error.code).toBe(EXIT_CONFIG_ERROR);
+      }
+    });
+
+    it('should throw error when OpenRouter API key is missing', () => {
+      delete process.env.OPENROUTER_API_KEY;
+      
+      expect(() => createProvider('openrouter')).toThrow();
+      
+      try {
+        createProvider('openrouter');
+      } catch (error: any) {
+        expect(error.message).toBe('OPENROUTER_API_KEY is not set');
+        expect(error.code).toBe(EXIT_CONFIG_ERROR);
+      }
+    });
+
+    it('should throw error for unsupported provider type', () => {
+      expect(() => createProvider('unsupported')).toThrow();
+      
+      try {
+        createProvider('unsupported');
+      } catch (error: any) {
+        expect(error.message).toBe('Unsupported provider type: unsupported. Supported types are: openai, openrouter');
+        expect(error.code).toBe(EXIT_CONFIG_ERROR);
+      }
+    });
+
+    it('should throw error for empty provider type', () => {
+      expect(() => createProvider('')).toThrow();
+      
+      try {
+        createProvider('');
+      } catch (error: any) {
+        expect(error.message).toBe('Unsupported provider type: . Supported types are: openai, openrouter');
+        expect(error.code).toBe(EXIT_CONFIG_ERROR);
+      }
+    });
+
+    it('should handle undefined provider type', () => {
+      expect(() => createProvider(undefined as any)).toThrow();
+      
+      try {
+        createProvider(undefined as any);
+      } catch (error: any) {
+        expect(error.message).toBe('Unsupported provider type: undefined. Supported types are: openai, openrouter');
+        expect(error.code).toBe(EXIT_CONFIG_ERROR);
+      }
+    });
+
+    it('should handle case sensitivity correctly', () => {
+      process.env.OPENAI_API_KEY = 'test-openai-key';
+      
+      // Should work with exact case
+      expect(() => createProvider('openai')).not.toThrow();
+      
+      // Should fail with different case
+      expect(() => createProvider('OpenAI')).toThrow();
+      expect(() => createProvider('OPENAI')).toThrow();
+    });
+
+    it('should handle whitespace in provider type', () => {
+      process.env.OPENAI_API_KEY = 'test-openai-key';
+      
+      expect(() => createProvider(' openai ')).toThrow();
+      
+      try {
+        createProvider(' openai ');
+      } catch (error: any) {
+        expect(error.message).toBe('Unsupported provider type:  openai . Supported types are: openai, openrouter');
+        expect(error.code).toBe(EXIT_CONFIG_ERROR);
+      }
+    });
+
+    it('should work with empty string API keys', () => {
+      process.env.OPENAI_API_KEY = '';
+      
+      expect(() => createProvider('openai')).toThrow();
+      
+      try {
+        createProvider('openai');
+      } catch (error: any) {
+        expect(error.message).toBe('OPENAI_API_KEY is not set');
+        expect(error.code).toBe(EXIT_CONFIG_ERROR);
+      }
+    });
+
+    it('should work with whitespace-only API keys', () => {
+      process.env.OPENAI_API_KEY = '   ';
+      
+      expect(() => createProvider('openai')).toThrow();
+      
+      try {
+        createProvider('openai');
+      } catch (error: any) {
+        expect(error.message).toBe('OPENAI_API_KEY is not set');
+        expect(error.code).toBe(EXIT_CONFIG_ERROR);
+      }
+    });
+  });
+});