dialectic 0.1.0

package/tests/shared-prompts.spec.ts

@@ -0,0 +1,318 @@
+import { 
+  appendSharedInstructions, 
+  INSTRUCTION_TYPES, 
+  getSharedSystemInstructions,
+  getSharedProposalInstructions,
+  getSharedCritiqueInstructions,
+  getSharedRefinementInstructions,
+  getSharedSummarizationInstructions
+} from '../src/agents/prompts/shared';
+
+describe('Shared Prompts', () => {
+  describe('INSTRUCTION_TYPES constants', () => {
+    it('should export all required instruction type constants', () => {
+      expect(INSTRUCTION_TYPES.SYSTEM).toBeDefined();
+      expect(INSTRUCTION_TYPES.PROPOSAL).toBeDefined();
+      expect(INSTRUCTION_TYPES.CRITIQUE).toBeDefined();
+      expect(INSTRUCTION_TYPES.REFINEMENT).toBeDefined();
+      expect(INSTRUCTION_TYPES.SUMMARIZATION).toBeDefined();
+    });
+
+    it('should have correct string values', () => {
+      expect(INSTRUCTION_TYPES.SYSTEM).toBe('system');
+      expect(INSTRUCTION_TYPES.PROPOSAL).toBe('proposal');
+      expect(INSTRUCTION_TYPES.CRITIQUE).toBe('critique');
+      expect(INSTRUCTION_TYPES.REFINEMENT).toBe('refinement');
+      expect(INSTRUCTION_TYPES.SUMMARIZATION).toBe('summarization');
+    });
+
+    it('should be usable in function calls', () => {
+      const result = appendSharedInstructions('test prompt', INSTRUCTION_TYPES.SYSTEM);
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan('test prompt'.length);
+    });
+  });
+
+  describe('Individual instruction functions', () => {
+    it('should return non-empty strings for all instruction types', () => {
+      expect(getSharedSystemInstructions()).toBeDefined();
+      expect(getSharedSystemInstructions().length).toBeGreaterThan(0);
+      
+      expect(getSharedProposalInstructions()).toBeDefined();
+      expect(getSharedProposalInstructions().length).toBeGreaterThan(0);
+      
+      expect(getSharedCritiqueInstructions()).toBeDefined();
+      expect(getSharedCritiqueInstructions().length).toBeGreaterThan(0);
+      
+      expect(getSharedRefinementInstructions()).toBeDefined();
+      expect(getSharedRefinementInstructions().length).toBeGreaterThan(0);
+      
+      expect(getSharedSummarizationInstructions()).toBeDefined();
+      expect(getSharedSummarizationInstructions().length).toBeGreaterThan(0);
+    });
+
+    it('should return different content for different instruction types', () => {
+      const systemInstructions = getSharedSystemInstructions();
+      const proposalInstructions = getSharedProposalInstructions();
+      const critiqueInstructions = getSharedCritiqueInstructions();
+      const refinementInstructions = getSharedRefinementInstructions();
+      const summarizationInstructions = getSharedSummarizationInstructions();
+
+      // All should be different from each other
+      expect(systemInstructions).not.toBe(proposalInstructions);
+      expect(systemInstructions).not.toBe(critiqueInstructions);
+      expect(systemInstructions).not.toBe(refinementInstructions);
+      expect(systemInstructions).not.toBe(summarizationInstructions);
+      
+      expect(proposalInstructions).not.toBe(critiqueInstructions);
+      expect(proposalInstructions).not.toBe(refinementInstructions);
+      expect(proposalInstructions).not.toBe(summarizationInstructions);
+      
+      expect(critiqueInstructions).not.toBe(refinementInstructions);
+      expect(critiqueInstructions).not.toBe(summarizationInstructions);
+      
+      expect(refinementInstructions).not.toBe(summarizationInstructions);
+    });
+
+    it('should return consistent results across multiple calls', () => {
+      const system1 = getSharedSystemInstructions();
+      const system2 = getSharedSystemInstructions();
+      expect(system1).toBe(system2);
+
+      const proposal1 = getSharedProposalInstructions();
+      const proposal2 = getSharedProposalInstructions();
+      expect(proposal1).toBe(proposal2);
+
+      const critique1 = getSharedCritiqueInstructions();
+      const critique2 = getSharedCritiqueInstructions();
+      expect(critique1).toBe(critique2);
+
+      const refinement1 = getSharedRefinementInstructions();
+      const refinement2 = getSharedRefinementInstructions();
+      expect(refinement1).toBe(refinement2);
+
+      const summarization1 = getSharedSummarizationInstructions();
+      const summarization2 = getSharedSummarizationInstructions();
+      expect(summarization1).toBe(summarization2);
+    });
+  });
+
+  describe('appendSharedInstructions() - Basic functionality', () => {
+    it('should append system instructions correctly', () => {
+      const prompt = 'You are an expert.';
+      const result = appendSharedInstructions(prompt, INSTRUCTION_TYPES.SYSTEM);
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result).toContain(prompt);
+      expect(result.length).toBeGreaterThan(prompt.length);
+    });
+
+    it('should append proposal instructions correctly', () => {
+      const prompt = 'Solve this problem.';
+      const result = appendSharedInstructions(prompt, INSTRUCTION_TYPES.PROPOSAL);
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result).toContain(prompt);
+      expect(result.length).toBeGreaterThan(prompt.length);
+    });
+
+    it('should append critique instructions correctly', () => {
+      const prompt = 'Review this proposal.';
+      const result = appendSharedInstructions(prompt, INSTRUCTION_TYPES.CRITIQUE);
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result).toContain(prompt);
+      expect(result.length).toBeGreaterThan(prompt.length);
+    });
+
+    it('should append refinement instructions correctly', () => {
+      const prompt = 'Refine your solution.';
+      const result = appendSharedInstructions(prompt, INSTRUCTION_TYPES.REFINEMENT);
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result).toContain(prompt);
+      expect(result.length).toBeGreaterThan(prompt.length);
+    });
+
+    it('should append summarization instructions correctly', () => {
+      const prompt = 'Summarize the debate.';
+      const result = appendSharedInstructions(prompt, INSTRUCTION_TYPES.SUMMARIZATION);
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result).toContain(prompt);
+      expect(result.length).toBeGreaterThan(prompt.length);
+    });
+
+    it('should return original prompt plus appended instructions', () => {
+      const prompt = 'Test prompt content';
+      const result = appendSharedInstructions(prompt, INSTRUCTION_TYPES.SYSTEM);
+      
+      // Should start with original prompt
+      expect(result.startsWith(prompt)).toBe(true);
+      
+      // Should be longer than original prompt
+      expect(result.length).toBeGreaterThan(prompt.length);
+      
+      // Should contain the original prompt exactly
+      expect(result.indexOf(prompt)).toBe(0);
+    });
+
+    it('should handle empty prompts', () => {
+      const result = appendSharedInstructions('', INSTRUCTION_TYPES.SYSTEM);
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('should handle prompts with existing content', () => {
+      const prompt = 'You are an expert software architect. Consider scalability and performance.';
+      const result = appendSharedInstructions(prompt, INSTRUCTION_TYPES.PROPOSAL);
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result).toContain(prompt);
+      expect(result.length).toBeGreaterThan(prompt.length);
+    });
+  });
+
+  describe('appendSharedInstructions() - Edge cases', () => {
+    it('should handle prompts of various lengths', () => {
+      const shortPrompt = 'Solve this.';
+      const mediumPrompt = 'You are an expert. Consider multiple factors and provide a comprehensive solution.';
+      const longPrompt = 'You are an expert software architect specializing in distributed systems and scalable architecture design. Consider scalability, performance, component boundaries, interfaces, architectural patterns, data flow, state management, and operational concerns. When proposing solutions, start with high-level architecture, identify key components, communication patterns, failure modes, and provide clear descriptions.';
+
+      const shortResult = appendSharedInstructions(shortPrompt, INSTRUCTION_TYPES.SYSTEM);
+      const mediumResult = appendSharedInstructions(mediumPrompt, INSTRUCTION_TYPES.SYSTEM);
+      const longResult = appendSharedInstructions(longPrompt, INSTRUCTION_TYPES.SYSTEM);
+
+      expect(shortResult).toContain(shortPrompt);
+      expect(mediumResult).toContain(mediumPrompt);
+      expect(longResult).toContain(longPrompt);
+
+      expect(shortResult.length).toBeGreaterThan(shortPrompt.length);
+      expect(mediumResult.length).toBeGreaterThan(mediumPrompt.length);
+      expect(longResult.length).toBeGreaterThan(longPrompt.length);
+    });
+
+    it('should be consistent across multiple calls', () => {
+      const prompt = 'Test prompt for consistency';
+      const result1 = appendSharedInstructions(prompt, INSTRUCTION_TYPES.CRITIQUE);
+      const result2 = appendSharedInstructions(prompt, INSTRUCTION_TYPES.CRITIQUE);
+      
+      expect(result1).toBe(result2);
+    });
+
+    it('should produce different results for different instruction types', () => {
+      const prompt = 'Same prompt for all types';
+      
+      const systemResult = appendSharedInstructions(prompt, INSTRUCTION_TYPES.SYSTEM);
+      const proposalResult = appendSharedInstructions(prompt, INSTRUCTION_TYPES.PROPOSAL);
+      const critiqueResult = appendSharedInstructions(prompt, INSTRUCTION_TYPES.CRITIQUE);
+      const refinementResult = appendSharedInstructions(prompt, INSTRUCTION_TYPES.REFINEMENT);
+      const summarizationResult = appendSharedInstructions(prompt, INSTRUCTION_TYPES.SUMMARIZATION);
+
+      // All should contain the original prompt
+      expect(systemResult).toContain(prompt);
+      expect(proposalResult).toContain(prompt);
+      expect(critiqueResult).toContain(prompt);
+      expect(refinementResult).toContain(prompt);
+      expect(summarizationResult).toContain(prompt);
+
+      // But should be different from each other
+      expect(systemResult).not.toBe(proposalResult);
+      expect(systemResult).not.toBe(critiqueResult);
+      expect(systemResult).not.toBe(refinementResult);
+      expect(systemResult).not.toBe(summarizationResult);
+      
+      expect(proposalResult).not.toBe(critiqueResult);
+      expect(proposalResult).not.toBe(refinementResult);
+      expect(proposalResult).not.toBe(summarizationResult);
+      
+      expect(critiqueResult).not.toBe(refinementResult);
+      expect(critiqueResult).not.toBe(summarizationResult);
+      
+      expect(refinementResult).not.toBe(summarizationResult);
+    });
+
+    it('should preserve original prompt content exactly', () => {
+      const prompt = 'Original prompt content with special characters: !@#$%^&*()';
+      const result = appendSharedInstructions(prompt, INSTRUCTION_TYPES.REFINEMENT);
+      
+      // Should start with exact original prompt
+      expect(result.startsWith(prompt)).toBe(true);
+      
+      // Should contain the exact original prompt at the beginning
+      expect(result.indexOf(prompt)).toBe(0);
+    });
+  });
+
+  describe('Integration testing', () => {
+    it('should work with realistic prompt scenarios', () => {
+      const realisticPrompt = `You are an expert software architect specializing in distributed systems and scalable architecture design.
+Consider scalability, performance, component boundaries, interfaces, architectural patterns, data flow, state management, and operational concerns.
+When proposing solutions, start with high-level architecture, identify key components, communication patterns, failure modes, and provide clear descriptions.
+When critiquing, look for scalability bottlenecks, missing components, architectural coherence, and operational complexity.`;
+
+      const result = appendSharedInstructions(realisticPrompt, INSTRUCTION_TYPES.SYSTEM);
+      
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      expect(result).toContain(realisticPrompt);
+      expect(result.length).toBeGreaterThan(realisticPrompt.length);
+    });
+
+    it('should maintain proper formatting', () => {
+      const multiLinePrompt = `Problem to solve:
+Design a scalable web application
+
+Requirements:
+- Handle 1M+ users
+- 99.9% uptime
+- Global deployment`;
+
+      const result = appendSharedInstructions(multiLinePrompt, INSTRUCTION_TYPES.PROPOSAL);
+      
+      expect(result).toBeDefined();
+      expect(result).toContain(multiLinePrompt);
+      expect(result.length).toBeGreaterThan(multiLinePrompt.length);
+    });
+
+    it('should work correctly with all instruction types in sequence', () => {
+      const basePrompt = 'Base prompt for testing';
+      
+      const systemResult = appendSharedInstructions(basePrompt, INSTRUCTION_TYPES.SYSTEM);
+      const proposalResult = appendSharedInstructions(basePrompt, INSTRUCTION_TYPES.PROPOSAL);
+      const critiqueResult = appendSharedInstructions(basePrompt, INSTRUCTION_TYPES.CRITIQUE);
+      const refinementResult = appendSharedInstructions(basePrompt, INSTRUCTION_TYPES.REFINEMENT);
+      const summarizationResult = appendSharedInstructions(basePrompt, INSTRUCTION_TYPES.SUMMARIZATION);
+
+      // All should work without errors
+      expect(systemResult).toBeDefined();
+      expect(proposalResult).toBeDefined();
+      expect(critiqueResult).toBeDefined();
+      expect(refinementResult).toBeDefined();
+      expect(summarizationResult).toBeDefined();
+
+      // All should contain the base prompt
+      expect(systemResult).toContain(basePrompt);
+      expect(proposalResult).toContain(basePrompt);
+      expect(critiqueResult).toContain(basePrompt);
+      expect(refinementResult).toContain(basePrompt);
+      expect(summarizationResult).toContain(basePrompt);
+
+      // All should be longer than the base prompt
+      expect(systemResult.length).toBeGreaterThan(basePrompt.length);
+      expect(proposalResult.length).toBeGreaterThan(basePrompt.length);
+      expect(critiqueResult.length).toBeGreaterThan(basePrompt.length);
+      expect(refinementResult.length).toBeGreaterThan(basePrompt.length);
+      expect(summarizationResult.length).toBeGreaterThan(basePrompt.length);
+    });
+  });
+});

package/tests/state-manager.spec.ts

@@ -0,0 +1,251 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { StateManager } from '../src/core/state-manager';
+import { DEBATE_STATUS, DebateSummary, SUMMARIZATION_METHODS } from '../src/types/debate.types';
+import { AGENT_ROLES } from '../src/types/agent.types';
+
+describe('StateManager promptSources', () => {
+  let tmpDir: string;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'debate-state-'));
+  });
+  afterEach(() => {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  });
+
+  it('persists promptSources in debate state file', async () => {
+    const sm = new StateManager(tmpDir);
+    const state = await sm.createDebate('Test Problem');
+    expect(state.status).toBe(DEBATE_STATUS.RUNNING);
+
+    await sm.setPromptSources(state.id, {
+      agents: [ { agentId: 'a1', role: 'architect', source: 'built-in' } ],
+      judge: { id: 'j1', source: 'file', path: 'C:/abs/path.md' }
+    });
+
+    const filePath = path.join(tmpDir, `${state.id}.json`);
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    expect(parsed.promptSources).toBeTruthy();
+    expect(parsed.promptSources.agents[0].agentId).toBe('a1');
+    expect(parsed.promptSources.judge.path).toContain('path.md');
+  });
+});
+
+// RED-phase: state manager not implemented yet.
+
+describe('StateManager (file-first persistence)', () => {
+  it('creates and persists a new debate on createDebate', async () => {
+    const sm = new StateManager();
+    const state = await sm.createDebate('Problem');
+    expect(state.id).toBeDefined();
+  });
+
+  it('beginRound creates a new round and increments currentRound', async () => {
+    const sm = new StateManager();
+    const state = await sm.createDebate('Problem');
+    expect(state.currentRound).toBe(0);
+    await sm.beginRound(state.id);
+    const loaded = await sm.getDebate(state.id);
+    expect(loaded?.currentRound).toBe(1);
+    expect(loaded?.rounds.length).toBe(1);
+  });
+
+  it('addContribution throws if called before beginRound', async () => {
+    const sm = new StateManager();
+    const state = await sm.createDebate('Problem');
+    await expect(sm.addContribution(state.id, {
+      agentId: 'a1',
+      agentRole: 'architect' as any,
+      type: 'proposal',
+      content: 'x',
+      metadata: {},
+    })).rejects.toThrow(/No active round/);
+  });
+});
+
+describe('StateManager - addSummary()', () => {
+  let tmpDir: string;
+  
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'debate-summary-'));
+  });
+
+  afterEach(() => {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  });
+
+  it('should add summary to current round', async () => {
+    const sm = new StateManager(tmpDir);
+    const state = await sm.createDebate('Test Problem');
+    await sm.beginRound(state.id);
+
+    const summary: DebateSummary = {
+      agentId: 'agent-1',
+      agentRole: AGENT_ROLES.ARCHITECT,
+      summary: 'Test summary text',
+      metadata: {
+        beforeChars: 1000,
+        afterChars: 500,
+        method: SUMMARIZATION_METHODS.LENGTH_BASED,
+        timestamp: new Date()
+      }
+    };
+
+    await sm.addSummary(state.id, summary);
+
+    const debate = await sm.getDebate(state.id);
+    expect(debate).toBeDefined();
+    expect(debate!.rounds.length).toBe(1);
+    const round = debate!.rounds[0];
+    expect(round).toBeDefined();
+    expect(round!.summaries).toBeDefined();
+    expect(Object.keys(round!.summaries!).length).toBe(1);
+    expect(round!.summaries!['agent-1']).toEqual(summary);
+  });
+
+  it('should initialize summaries array if not present', async () => {
+    const sm = new StateManager(tmpDir);
+    const state = await sm.createDebate('Test Problem');
+    await sm.beginRound(state.id);
+
+    // First summary should initialize the array
+    const summary1: DebateSummary = {
+      agentId: 'agent-1',
+      agentRole: AGENT_ROLES.ARCHITECT,
+      summary: 'First summary',
+      metadata: {
+        beforeChars: 1000,
+        afterChars: 500,
+        method: SUMMARIZATION_METHODS.LENGTH_BASED,
+        timestamp: new Date()
+      }
+    };
+
+    await sm.addSummary(state.id, summary1);
+
+    const debate = await sm.getDebate(state.id);
+    const round = debate!.rounds[0];
+    expect(round).toBeDefined();
+    expect(round!.summaries).toBeDefined();
+    expect(round!.summaries!['agent-1']).toBeDefined();
+    expect(round!.summaries!['agent-1']!.agentId).toBe('agent-1');
+  });
+
+  it('should support multiple summaries per round', async () => {
+    const sm = new StateManager(tmpDir);
+    const state = await sm.createDebate('Test Problem');
+    await sm.beginRound(state.id);
+
+    const summary1: DebateSummary = {
+      agentId: 'agent-1',
+      agentRole: AGENT_ROLES.ARCHITECT,
+      summary: 'Summary 1',
+      metadata: {
+        beforeChars: 1000,
+        afterChars: 500,
+        method: SUMMARIZATION_METHODS.LENGTH_BASED,
+        timestamp: new Date()
+      }
+    };
+
+    const summary2: DebateSummary = {
+      agentId: 'agent-2',
+      agentRole: AGENT_ROLES.PERFORMANCE,
+      summary: 'Summary 2',
+      metadata: {
+        beforeChars: 2000,
+        afterChars: 1000,
+        method: SUMMARIZATION_METHODS.LENGTH_BASED,
+        timestamp: new Date()
+      }
+    };
+
+    await sm.addSummary(state.id, summary1);
+    await sm.addSummary(state.id, summary2);
+
+    const debate = await sm.getDebate(state.id);
+    const round = debate!.rounds[0];
+    expect(round).toBeDefined();
+    expect(Object.keys(round!.summaries!).length).toBe(2);
+    const summaries = round!.summaries;
+    if (summaries) {
+      expect(summaries['agent-1']).toBeDefined();
+      expect(summaries['agent-2']).toBeDefined();
+      expect(summaries['agent-1']!.agentId).toBe('agent-1');
+      expect(summaries['agent-2']!.agentId).toBe('agent-2');
+    }
+  });
+
+  it('should persist summaries to disk', async () => {
+    const sm = new StateManager(tmpDir);
+    const state = await sm.createDebate('Test Problem');
+    await sm.beginRound(state.id);
+
+    const summary: DebateSummary = {
+      agentId: 'agent-1',
+      agentRole: AGENT_ROLES.ARCHITECT,
+      summary: 'Persisted summary',
+      metadata: {
+        beforeChars: 1500,
+        afterChars: 750,
+        method: SUMMARIZATION_METHODS.LENGTH_BASED,
+        timestamp: new Date(),
+        latencyMs: 200,
+        tokensUsed: 50
+      }
+    };
+
+    await sm.addSummary(state.id, summary);
+
+    // Read directly from file to verify persistence
+    const filePath = path.join(tmpDir, `${state.id}.json`);
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+
+    expect(parsed.rounds[0].summaries).toBeDefined();
+    expect(Object.keys(parsed.rounds[0].summaries).length).toBe(1);
+    expect(parsed.rounds[0].summaries['agent-1']).toBeDefined();
+    expect(parsed.rounds[0].summaries['agent-1'].summary).toBe('Persisted summary');
+    expect(parsed.rounds[0].summaries['agent-1'].metadata.latencyMs).toBe(200);
+    expect(parsed.rounds[0].summaries['agent-1'].metadata.tokensUsed).toBe(50);
+  });
+
+  it('should throw error if no active round', async () => {
+    const sm = new StateManager(tmpDir);
+    const state = await sm.createDebate('Test Problem');
+
+    const summary: DebateSummary = {
+      agentId: 'agent-1',
+      agentRole: AGENT_ROLES.ARCHITECT,
+      summary: 'Test summary',
+      metadata: {
+        beforeChars: 1000,
+        afterChars: 500,
+        method: SUMMARIZATION_METHODS.LENGTH_BASED,
+        timestamp: new Date()
+      }
+    };
+
+    await expect(sm.addSummary(state.id, summary)).rejects.toThrow(/No active round/);
+  });
+
+  it('should throw error if debate not found', async () => {
+    const sm = new StateManager(tmpDir);
+
+    const summary: DebateSummary = {
+      agentId: 'agent-1',
+      agentRole: AGENT_ROLES.ARCHITECT,
+      summary: 'Test summary',
+      metadata: {
+        beforeChars: 1000,
+        afterChars: 500,
+        method: SUMMARIZATION_METHODS.LENGTH_BASED,
+        timestamp: new Date()
+      }
+    };
+
+    await expect(sm.addSummary('nonexistent-id', summary)).rejects.toThrow(/not found/);
+  });
+});