@holoscript/framework 6.0.3

package/src/ai/__tests__/AICopilot.prod.test.ts

@@ -0,0 +1,341 @@
+/**
+ * AICopilot Production Tests
+ * Sprint CLXVI — adapter management, context, chat, generate, explain, autoFix
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AICopilot } from '../AICopilot';
+import type { AIAdapter } from '../AIAdapter';
+
+// ---------------------------------------------------------------------------
+// Mock adapters
+// ---------------------------------------------------------------------------
+
+function makeGenerateAdapter(overrides: Partial<AIAdapter> = {}): AIAdapter {
+  return {
+    id: 'mock-gen',
+    name: 'Mock Generate',
+    isReady: () => true,
+    generateHoloScript: vi.fn().mockResolvedValue({
+      holoScript: 'scene { @Renderable }',
+      objectCount: 3,
+      confidence: 0.9,
+      warnings: [],
+    }),
+    ...overrides,
+  } as AIAdapter;
+}
+
+function makeFullAdapter(): AIAdapter {
+  return {
+    id: 'mock-full',
+    name: 'Mock Full',
+    isReady: () => true,
+    generateHoloScript: vi.fn().mockResolvedValue({
+      holoScript: 'scene { @Physics }',
+      objectCount: 1,
+      confidence: 0.85,
+      warnings: ['large scene'],
+    }),
+    explainHoloScript: vi.fn().mockResolvedValue({
+      explanation: 'This is a physics scene.',
+      concepts: [],
+    }),
+    fixHoloScript: vi.fn().mockResolvedValue({
+      holoScript: 'fixed code',
+      fixes: [{ line: 5, issue: 'missing type', fix: 'added type' }],
+    }),
+    chat: vi.fn().mockResolvedValue('HoloScript is a spatial programming language.'),
+  } as AIAdapter;
+}
+
+// ---------------------------------------------------------------------------
+// Constructor and adapter management
+// ---------------------------------------------------------------------------
+
+describe('AICopilot', () => {
+  let copilot: AICopilot;
+
+  beforeEach(() => {
+    copilot = new AICopilot();
+  });
+
+  describe('adapter management', () => {
+    it('starts with no adapter', () => {
+      expect(copilot.getAdapter()).toBeNull();
+      expect(copilot.isReady()).toBe(false);
+    });
+
+    it('setAdapter makes it ready', () => {
+      copilot.setAdapter(makeGenerateAdapter());
+      expect(copilot.isReady()).toBe(true);
+    });
+
+    it('getAdapter returns set adapter', () => {
+      const adapter = makeGenerateAdapter();
+      copilot.setAdapter(adapter);
+      expect(copilot.getAdapter()).toBe(adapter);
+    });
+
+    it('constructor accepts adapter directly', () => {
+      const adapter = makeGenerateAdapter();
+      const c = new AICopilot(adapter);
+      expect(c.isReady()).toBe(true);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Context management
+  // -------------------------------------------------------------------------
+
+  describe('context management', () => {
+    it('starts with empty context', () => {
+      expect(copilot.getContext()).toEqual({});
+    });
+
+    it('updateContext merges partial context', () => {
+      copilot.updateContext({ stateKeys: ['hp', 'mana'] });
+      copilot.updateContext({ selectedEntity: { id: 'hero', type: 'player' } });
+      const ctx = copilot.getContext();
+      expect(ctx.stateKeys).toEqual(['hp', 'mana']);
+      expect(ctx.selectedEntity?.id).toBe('hero');
+    });
+
+    it('getContext returns a copy', () => {
+      copilot.updateContext({ entity: 'hero' } as any);
+      const ctx1 = copilot.getContext();
+      const ctx2 = copilot.getContext();
+      expect(ctx1).not.toBe(ctx2);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // History management
+  // -------------------------------------------------------------------------
+
+  describe('history', () => {
+    it('starts with empty history', () => {
+      expect(copilot.getHistory()).toHaveLength(0);
+    });
+
+    it('clearHistory empties history', async () => {
+      copilot.setAdapter(makeFullAdapter());
+      await copilot.chat('hello');
+      copilot.clearHistory();
+      expect(copilot.getHistory()).toHaveLength(0);
+    });
+
+    it('getHistory returns a copy', async () => {
+      copilot.setAdapter(makeFullAdapter());
+      await copilot.chat('hello');
+      expect(copilot.getHistory()).not.toBe(copilot.getHistory());
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // generateFromPrompt
+  // -------------------------------------------------------------------------
+
+  describe('generateFromPrompt', () => {
+    it('returns NO_ADAPTER error when no adapter is set', async () => {
+      const r = await copilot.generateFromPrompt('make a scene');
+      expect(r.error).toBe('NO_ADAPTER');
+    });
+
+    it('returns UNSUPPORTED when adapter lacks generateHoloScript', async () => {
+      copilot.setAdapter({} as AIAdapter);
+      const r = await copilot.generateFromPrompt('make a scene');
+      expect(r.error).toBe('UNSUPPORTED');
+    });
+
+    it('returns response with suggestion on success', async () => {
+      copilot.setAdapter(makeGenerateAdapter());
+      const r = await copilot.generateFromPrompt('make a scene');
+      expect(r.suggestions).toHaveLength(1);
+      expect(r.suggestions[0].type).toBe('create');
+      expect(r.suggestions[0].holoScript).toBeTruthy();
+    });
+
+    it('includes confidence in suggestion', async () => {
+      copilot.setAdapter(makeGenerateAdapter());
+      const r = await copilot.generateFromPrompt('test');
+      expect(r.suggestions[0].confidence).toBeGreaterThan(0);
+    });
+
+    it('calls adapter.generateHoloScript with prompt and options', async () => {
+      const adapter = makeGenerateAdapter();
+      copilot.setAdapter(adapter);
+      await copilot.generateFromPrompt('hello', { complexity: 'high' } as any);
+      expect(adapter.generateHoloScript).toHaveBeenCalledWith(
+        'hello',
+        expect.objectContaining({ complexity: 'high' })
+      );
+    });
+
+    it('includes warnings in response text', async () => {
+      const adapter = makeFullAdapter();
+      copilot.setAdapter(adapter);
+      const r = await copilot.generateFromPrompt('large scene');
+      expect(r.text).toContain('large scene');
+    });
+
+    it('adds user and assistant messages to history', async () => {
+      copilot.setAdapter(makeGenerateAdapter());
+      await copilot.generateFromPrompt('prompt text');
+      const h = copilot.getHistory();
+      expect(h.length).toBe(2);
+      expect(h[0].role).toBe('user');
+      expect(h[1].role).toBe('assistant');
+    });
+
+    it('returns error response on adapter throw', async () => {
+      const adapter = makeGenerateAdapter({
+        generateHoloScript: vi.fn().mockRejectedValue(new Error('network error')),
+      });
+      copilot.setAdapter(adapter);
+      const r = await copilot.generateFromPrompt('boom');
+      expect(r.error).toBe('network error');
+      expect(r.text).toContain('network error');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // suggestFromSelection
+  // -------------------------------------------------------------------------
+
+  describe('suggestFromSelection', () => {
+    it('returns NO_ADAPTER when no adapter', async () => {
+      const r = await copilot.suggestFromSelection();
+      expect(r.error).toBe('NO_ADAPTER');
+    });
+
+    it('returns message when no entity selected', async () => {
+      copilot.setAdapter(makeGenerateAdapter());
+      const r = await copilot.suggestFromSelection();
+      expect(r.text).toContain('No entity selected');
+      expect(r.error).toBeUndefined();
+    });
+
+    it('returns modify suggestion for selected entity', async () => {
+      copilot.setAdapter(makeGenerateAdapter());
+      copilot.updateContext({
+        selectedEntity: { id: 'hero', type: 'player', properties: { hp: 100 } },
+      });
+      const r = await copilot.suggestFromSelection();
+      expect(r.suggestions[0].type).toBe('modify');
+      expect(r.text).toContain('player');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // explainScene
+  // -------------------------------------------------------------------------
+
+  describe('explainScene', () => {
+    it('returns NO_ADAPTER when no adapter', async () => {
+      const r = await copilot.explainScene('code');
+      expect(r.error).toBe('NO_ADAPTER');
+    });
+
+    it('returns UNSUPPORTED when adapter lacks explainHoloScript', async () => {
+      copilot.setAdapter(makeGenerateAdapter()); // no explainHoloScript
+      const r = await copilot.explainScene('code');
+      expect(r.error).toBe('UNSUPPORTED');
+    });
+
+    it('returns explanation text on success', async () => {
+      copilot.setAdapter(makeFullAdapter());
+      const r = await copilot.explainScene('scene {}');
+      expect(r.text).toBe('This is a physics scene.');
+    });
+
+    it('returns error response on adapter throw', async () => {
+      const adapter = makeFullAdapter();
+      (adapter.explainHoloScript as any) = vi.fn().mockRejectedValue(new Error('fail'));
+      copilot.setAdapter(adapter);
+      const r = await copilot.explainScene('code');
+      expect(r.error).toBeTruthy();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // autoFix
+  // -------------------------------------------------------------------------
+
+  describe('autoFix', () => {
+    it('returns NO_ADAPTER when no adapter', async () => {
+      const r = await copilot.autoFix('code', ['err']);
+      expect(r.error).toBe('NO_ADAPTER');
+    });
+
+    it('returns UNSUPPORTED when adapter lacks fixHoloScript', async () => {
+      copilot.setAdapter(makeGenerateAdapter()); // no fixHoloScript
+      const r = await copilot.autoFix('code', ['err']);
+      expect(r.error).toBe('UNSUPPORTED');
+    });
+
+    it('returns fix suggestions on success', async () => {
+      copilot.setAdapter(makeFullAdapter());
+      const r = await copilot.autoFix('broken code', ['type error']);
+      expect(r.suggestions).toHaveLength(1);
+      expect(r.suggestions[0].type).toBe('fix');
+      expect(r.text).toContain('1 issue');
+    });
+
+    it('includes line info in fix suggestion description', async () => {
+      copilot.setAdapter(makeFullAdapter());
+      const r = await copilot.autoFix('bad', ['err']);
+      expect(r.suggestions[0].description).toContain('Line 5');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // chat
+  // -------------------------------------------------------------------------
+
+  describe('chat', () => {
+    it('returns NO_ADAPTER when no adapter', async () => {
+      const r = await copilot.chat('hello');
+      expect(r.error).toBe('NO_ADAPTER');
+    });
+
+    it('returns UNSUPPORTED when adapter lacks chat', async () => {
+      copilot.setAdapter(makeGenerateAdapter()); // no chat
+      const r = await copilot.chat('hello');
+      expect(r.error).toBe('UNSUPPORTED');
+    });
+
+    it('returns assistant response text', async () => {
+      copilot.setAdapter(makeFullAdapter());
+      const r = await copilot.chat('What is HoloScript?');
+      expect(r.text).toContain('HoloScript');
+    });
+
+    it('adds messages to history with correct roles', async () => {
+      copilot.setAdapter(makeFullAdapter());
+      await copilot.chat('first question');
+      const h = copilot.getHistory();
+      expect(h[0].role).toBe('user');
+      expect(h[0].content).toBe('first question');
+      expect(h[1].role).toBe('assistant');
+    });
+
+    it('passes history to adapter on multi-turn', async () => {
+      const adapter = makeFullAdapter();
+      copilot.setAdapter(adapter);
+      await copilot.chat('turn 1');
+      await copilot.chat('turn 2');
+      expect(adapter.chat).toHaveBeenCalledTimes(2);
+      const secondCall = (adapter.chat as any).mock.calls[1];
+      // Third arg is chat history
+      expect(secondCall[2].length).toBeGreaterThan(0);
+    });
+
+    it('returns error on adapter throw', async () => {
+      const adapter = makeFullAdapter();
+      (adapter.chat as any) = vi.fn().mockRejectedValue(new Error('timeout'));
+      copilot.setAdapter(adapter);
+      const r = await copilot.chat('hello');
+      expect(r.error).toBe('timeout');
+    });
+  });
+});

package/src/ai/__tests__/AICopilot.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { AICopilot } from '../AICopilot';
+import type { AIAdapter } from '../AIAdapter';
+
+function mockAdapter(overrides = {}): AIAdapter {
+  return {
+    id: 'mock',
+    name: 'Mock Adapter',
+    isReady: () => true,
+    generateHoloScript: vi.fn(async () => ({
+      holoScript: 'scene { }',
+      confidence: 0.9,
+      objectCount: 1,
+    })),
+    explainHoloScript: vi.fn(async () => ({
+      explanation: 'This is a scene.',
+    })),
+    fixHoloScript: vi.fn(async () => ({
+      holoScript: 'scene { }',
+      fixes: [{ line: 1, issue: 'typo', fix: 'fixed typo' }],
+    })),
+    chat: vi.fn(async () => 'Hello from AI'),
+    ...overrides,
+  };
+}
+
+describe('AICopilot', () => {
+  let copilot: AICopilot;
+  let adapter: AIAdapter;
+
+  beforeEach(() => {
+    adapter = mockAdapter();
+    copilot = new AICopilot();
+  });
+
+  // --- Adapter management ---
+  it('isReady returns false without adapter', () => {
+    expect(copilot.isReady()).toBe(false);
+  });
+
+  it('setAdapter makes copilot ready', () => {
+    copilot.setAdapter(adapter);
+    expect(copilot.isReady()).toBe(true);
+    expect(copilot.getAdapter()).toBe(adapter);
+  });
+
+  it('constructor with adapter sets it', () => {
+    const c2 = new AICopilot(adapter);
+    expect(c2.isReady()).toBe(true);
+  });
+
+  // --- Context management ---
+  it('getContext returns empty initially', () => {
+    expect(copilot.getContext()).toEqual({});
+  });
+
+  it('updateContext merges context', () => {
+    copilot.updateContext({ selectedEntity: { id: 'e1', type: 'mesh' } });
+    copilot.updateContext({ stateKeys: ['health', 'score'] });
+    const ctx = copilot.getContext();
+    expect(ctx.selectedEntity!.id).toBe('e1');
+    expect(ctx.stateKeys).toContain('health');
+  });
+
+  it('getContext returns shallow copy', () => {
+    copilot.updateContext({ stateKeys: ['a'] });
+    const c1 = copilot.getContext();
+    // Shallow copy: mutating the top-level object doesn't affect original
+    c1.selectedEntity = { id: 'injected', type: 'test' };
+    expect(copilot.getContext().selectedEntity).toBeUndefined();
+  });
+
+  // --- History management ---
+  it('getHistory returns empty initially', () => {
+    expect(copilot.getHistory()).toHaveLength(0);
+  });
+
+  it('clearHistory empties history', async () => {
+    copilot.setAdapter(adapter);
+    await copilot.generateFromPrompt('hello');
+    expect(copilot.getHistory().length).toBeGreaterThan(0);
+    copilot.clearHistory();
+    expect(copilot.getHistory()).toHaveLength(0);
+  });
+
+  // --- generateFromPrompt ---
+  it('generateFromPrompt returns error without adapter', async () => {
+    const result = await copilot.generateFromPrompt('make a box');
+    expect(result.error).toBe('NO_ADAPTER');
+  });
+
+  it('generateFromPrompt calls adapter and returns suggestions', async () => {
+    copilot.setAdapter(adapter);
+    const result = await copilot.generateFromPrompt('make a box');
+    expect(result.suggestions).toHaveLength(1);
+    expect(result.suggestions[0].type).toBe('create');
+    expect(adapter.generateHoloScript).toHaveBeenCalled();
+  });
+
+  it('generateFromPrompt adds to history', async () => {
+    copilot.setAdapter(adapter);
+    await copilot.generateFromPrompt('test');
+    const history = copilot.getHistory();
+    expect(history.length).toBeGreaterThanOrEqual(2);
+    expect(history[0].role).toBe('user');
+    expect(history[1].role).toBe('assistant');
+  });
+
+  it('generateFromPrompt handles adapter error', async () => {
+    const errorAdapter = mockAdapter({
+      generateHoloScript: vi.fn(async () => {
+        throw new Error('API down');
+      }),
+    });
+    copilot.setAdapter(errorAdapter);
+    const result = await copilot.generateFromPrompt('test');
+    expect(result.error).toContain('API down');
+  });
+
+  // --- suggestFromSelection ---
+  it('suggestFromSelection returns error without adapter', async () => {
+    const result = await copilot.suggestFromSelection();
+    expect(result.error).toBe('NO_ADAPTER');
+  });
+
+  it('suggestFromSelection returns message when no entity selected', async () => {
+    copilot.setAdapter(adapter);
+    const result = await copilot.suggestFromSelection();
+    expect(result.text).toContain('No entity selected');
+  });
+
+  it('suggestFromSelection works with entity', async () => {
+    copilot.setAdapter(adapter);
+    copilot.updateContext({
+      selectedEntity: { id: 'box1', type: 'mesh', properties: { color: 'red' } },
+    });
+    const result = await copilot.suggestFromSelection();
+    expect(result.suggestions).toHaveLength(1);
+    expect(result.suggestions[0].type).toBe('modify');
+  });
+
+  // --- explainScene ---
+  it('explainScene returns error without adapter', async () => {
+    const result = await copilot.explainScene('scene {}');
+    expect(result.error).toBe('NO_ADAPTER');
+  });
+
+  it('explainScene calls adapter', async () => {
+    copilot.setAdapter(adapter);
+    const result = await copilot.explainScene('scene { box {} }');
+    expect(result.text).toBe('This is a scene.');
+  });
+
+  // --- autoFix ---
+  it('autoFix returns error without adapter', async () => {
+    const result = await copilot.autoFix('broken', ['err1']);
+    expect(result.error).toBe('NO_ADAPTER');
+  });
+
+  it('autoFix returns fix suggestions', async () => {
+    copilot.setAdapter(adapter);
+    const result = await copilot.autoFix('broken code', ['syntax error']);
+    expect(result.suggestions).toHaveLength(1);
+    expect(result.suggestions[0].type).toBe('fix');
+  });
+
+  // --- chat ---
+  it('chat returns error without adapter', async () => {
+    const result = await copilot.chat('hi');
+    expect(result.error).toBe('NO_ADAPTER');
+  });
+
+  it('chat returns AI response', async () => {
+    copilot.setAdapter(adapter);
+    const result = await copilot.chat('how do I add physics?');
+    expect(result.text).toBe('Hello from AI');
+  });
+});