@studio-foundation/cli 0.3.0-beta.1

package/tests/models-cache.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  setCachedModels,
+  getCachedModels,
+  parseAndCacheModels,
+  getAvailableModels,
+  filterModels,
+  sortModels,
+} from '../src/models-cache.js';
+
+// ─── filterModels ────────────────────────────────────────────────────────────
+
+describe('filterModels — anthropic', () => {
+  it('keeps claude-* models', () => {
+    const models = [
+      { id: 'claude-sonnet-4-20250514' },
+      { id: 'claude-haiku-4-20250514' },
+    ];
+    expect(filterModels('anthropic', models)).toEqual([
+      'claude-sonnet-4-20250514',
+      'claude-haiku-4-20250514',
+    ]);
+  });
+
+  it('excludes claude-instant*', () => {
+    const models = [
+      { id: 'claude-sonnet-4-20250514' },
+      { id: 'claude-instant-1' },
+    ];
+    expect(filterModels('anthropic', models)).not.toContain('claude-instant-1');
+  });
+
+  it('excludes claude-2*', () => {
+    const models = [
+      { id: 'claude-sonnet-4-20250514' },
+      { id: 'claude-2.1' },
+    ];
+    expect(filterModels('anthropic', models)).not.toContain('claude-2.1');
+  });
+
+  it('excludes non-claude models', () => {
+    const models = [{ id: 'gpt-4o' }, { id: 'claude-sonnet-4-20250514' }];
+    expect(filterModels('anthropic', models)).toEqual(['claude-sonnet-4-20250514']);
+  });
+});
+
+describe('filterModels — openai', () => {
+  it('keeps gpt-4* models', () => {
+    const models = [{ id: 'gpt-4o' }, { id: 'gpt-4-turbo' }];
+    const result = filterModels('openai', models);
+    expect(result).toContain('gpt-4o');
+    expect(result).toContain('gpt-4-turbo');
+  });
+
+  it('keeps o1* and o3* models', () => {
+    const models = [{ id: 'o1-preview' }, { id: 'o3-mini' }, { id: 'gpt-3.5-turbo' }];
+    const result = filterModels('openai', models);
+    expect(result).toContain('o1-preview');
+    expect(result).toContain('o3-mini');
+    expect(result).not.toContain('gpt-3.5-turbo');
+  });
+
+  it('excludes gpt-3.5* models', () => {
+    const models = [{ id: 'gpt-3.5-turbo' }, { id: 'gpt-4o' }];
+    expect(filterModels('openai', models)).toEqual(['gpt-4o']);
+  });
+});
+
+describe('filterModels — unknown provider', () => {
+  it('keeps all models for unknown providers', () => {
+    const models = [{ id: 'model-a' }, { id: 'model-b' }];
+    expect(filterModels('future-provider', models)).toEqual(['model-a', 'model-b']);
+  });
+});
+
+// ─── sortModels ──────────────────────────────────────────────────────────────
+
+describe('sortModels', () => {
+  it('sorts by created timestamp descending', () => {
+    const ids = ['old-model', 'new-model'];
+    const raw = [
+      { id: 'old-model', created: 1000 },
+      { id: 'new-model', created: 2000 },
+    ];
+    expect(sortModels(ids, raw)).toEqual(['new-model', 'old-model']);
+  });
+
+  it('sorts by created_at ISO string descending', () => {
+    const ids = ['model-a', 'model-b'];
+    const raw = [
+      { id: 'model-a', created_at: '2024-01-01T00:00:00Z' },
+      { id: 'model-b', created_at: '2025-01-01T00:00:00Z' },
+    ];
+    expect(sortModels(ids, raw)).toEqual(['model-b', 'model-a']);
+  });
+
+  it('falls back to lexicographic descending when no timestamp', () => {
+    const ids = ['claude-haiku', 'claude-sonnet', 'claude-opus'];
+    const raw = [{ id: 'claude-haiku' }, { id: 'claude-sonnet' }, { id: 'claude-opus' }];
+    const result = sortModels(ids, raw);
+    // lexicographic descending: sonnet > opus > haiku
+    expect(result[0]).toBe('claude-sonnet');
+  });
+});
+
+// ─── setCachedModels / getCachedModels ───────────────────────────────────────
+
+describe('setCachedModels / getCachedModels', () => {
+  it('returns null when no entry exists', () => {
+    expect(getCachedModels('anthropic', 'sk-ant-missing')).toBeNull();
+  });
+
+  it('returns stored models on cache hit', () => {
+    const models = ['claude-sonnet-4-20250514', 'claude-haiku-4-20250514'];
+    setCachedModels('anthropic', 'sk-ant-test1234', models);
+    expect(getCachedModels('anthropic', 'sk-ant-test1234')).toEqual(models);
+  });
+
+  it('uses first 8 chars of apiKey as part of cache key (different full keys, same prefix → same entry)', () => {
+    setCachedModels('anthropic', 'sk-ant-AAAAAAAA-different-suffix', ['model-a']);
+    // Same first 8 chars: 'sk-ant-A'
+    expect(getCachedModels('anthropic', 'sk-ant-AAAAAAAA-other-suffix')).toEqual(['model-a']);
+  });
+
+  it('returns null after TTL expires', () => {
+    const realNow = Date.now;
+    try {
+      // Set cache entry
+      Date.now = () => 0;
+      setCachedModels('anthropic', 'sk-ant-expiry-test', ['model-x']);
+      // Advance time past 24h
+      Date.now = () => 25 * 60 * 60 * 1000;
+      expect(getCachedModels('anthropic', 'sk-ant-expiry-test')).toBeNull();
+    } finally {
+      Date.now = realNow;
+    }
+  });
+
+  it('different providers do not share cache entries', () => {
+    setCachedModels('anthropic', 'sk-ant-shared', ['claude-model']);
+    expect(getCachedModels('openai', 'sk-ant-shared')).toBeNull();
+  });
+});
+
+// ─── parseAndCacheModels ─────────────────────────────────────────────────────
+
+describe('parseAndCacheModels', () => {
+  it('parses Anthropic response format, filters, and caches', () => {
+    const json = {
+      data: [
+        { id: 'claude-sonnet-4-20250514', created_at: '2025-05-14T00:00:00Z' },
+        { id: 'claude-instant-1' },     // excluded
+        { id: 'claude-2.1' },           // excluded
+      ],
+    };
+    parseAndCacheModels('anthropic', 'sk-ant-parse-test', json);
+    const cached = getCachedModels('anthropic', 'sk-ant-parse-test');
+    expect(cached).toContain('claude-sonnet-4-20250514');
+    expect(cached).not.toContain('claude-instant-1');
+    expect(cached).not.toContain('claude-2.1');
+  });
+
+  it('parses OpenAI response format', () => {
+    const json = {
+      data: [
+        { id: 'gpt-4o', created: 2000 },
+        { id: 'gpt-3.5-turbo', created: 1000 }, // excluded
+      ],
+    };
+    parseAndCacheModels('openai', 'sk-parse-openai', json);
+    const cached = getCachedModels('openai', 'sk-parse-openai');
+    expect(cached).toContain('gpt-4o');
+    expect(cached).not.toContain('gpt-3.5-turbo');
+  });
+
+  it('does not throw on malformed JSON', () => {
+    expect(() => parseAndCacheModels('anthropic', 'sk-ant-bad', null)).not.toThrow();
+    expect(() => parseAndCacheModels('anthropic', 'sk-ant-bad', { no_data: true })).not.toThrow();
+  });
+});
+
+// ─── getAvailableModels ──────────────────────────────────────────────────────
+
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+beforeEach(() => { mockFetch.mockReset(); });
+
+describe('getAvailableModels', () => {
+  it('returns cached models without fetching', async () => {
+    const models = ['claude-sonnet-4-20250514'];
+    setCachedModels('anthropic', 'sk-ant-cached', models);
+    const result = await getAvailableModels('anthropic', 'sk-ant-cached');
+    expect(result).toEqual(models);
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('fetches from Anthropic API on cache miss', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        data: [{ id: 'claude-sonnet-4-20250514' }, { id: 'claude-instant-1' }],
+      }),
+    });
+    const result = await getAvailableModels('anthropic', 'sk-ant-fetch-test');
+    expect(result).toContain('claude-sonnet-4-20250514');
+    expect(result).not.toContain('claude-instant-1');
+    expect(mockFetch).toHaveBeenCalledOnce();
+  });
+
+  it('fetches from OpenAI API on cache miss', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        data: [{ id: 'gpt-4o' }, { id: 'gpt-3.5-turbo' }],
+      }),
+    });
+    const result = await getAvailableModels('openai', 'sk-openai-fetch');
+    expect(result).toContain('gpt-4o');
+    expect(result).not.toContain('gpt-3.5-turbo');
+  });
+
+  it('returns [] on fetch error (never throws)', async () => {
+    mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED'));
+    const result = await getAvailableModels('anthropic', 'sk-ant-network-error');
+    expect(result).toEqual([]);
+  });
+
+  it('returns [] for google provider (not supported)', async () => {
+    const result = await getAvailableModels('google', 'AIzaKey');
+    expect(result).toEqual([]);
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('returns [] for local provider', async () => {
+    const result = await getAvailableModels('local', 'http://localhost:11434');
+    expect(result).toEqual([]);
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('populates cache after fetch so second call is free', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: [{ id: 'gpt-4o' }] }),
+    });
+    await getAvailableModels('openai', 'sk-cache-after-fetch');
+    await getAvailableModels('openai', 'sk-cache-after-fetch'); // second call
+    expect(mockFetch).toHaveBeenCalledOnce(); // still only one fetch
+  });
+});

package/tests/output/file-changes.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { FileChangeCollector, formatFileChanges, type FileChange } from '../../src/output/file-changes.js';
+
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+import { execSync } from 'node:child_process';
+const mockExecSync = vi.mocked(execSync);
+
+describe('FileChangeCollector', () => {
+  it('collects unique file paths from tool call events', () => {
+    const collector = new FileChangeCollector();
+
+    collector.onToolCallComplete({
+      tool: 'repo_manager-write_file',
+      result: { path: 'src/app.ts', written: true },
+      duration_ms: 10,
+      timestamp: Date.now(),
+    });
+    collector.onToolCallComplete({
+      tool: 'repo_manager-read_file',
+      result: { content: '...' },
+      duration_ms: 5,
+      timestamp: Date.now(),
+    });
+    collector.onToolCallComplete({
+      tool: 'repo_manager-write_file',
+      result: { path: 'src/app.ts', written: true },
+      duration_ms: 8,
+      timestamp: Date.now(),
+    });
+
+    expect(collector.getWrittenPaths()).toEqual(['src/app.ts']);
+  });
+
+  it('returns empty array when no write calls', () => {
+    const collector = new FileChangeCollector();
+    expect(collector.getWrittenPaths()).toEqual([]);
+  });
+
+  it('ignores failed tool calls', () => {
+    const collector = new FileChangeCollector();
+
+    collector.onToolCallComplete({
+      tool: 'repo_manager-write_file',
+      result: undefined,
+      error: 'Permission denied',
+      duration_ms: 10,
+      timestamp: Date.now(),
+    });
+
+    expect(collector.getWrittenPaths()).toEqual([]);
+  });
+
+  it('collects multiple distinct paths in order', () => {
+    const collector = new FileChangeCollector();
+
+    collector.onToolCallComplete({
+      tool: 'repo_manager-write_file',
+      result: { path: 'src/b.ts', written: true },
+      duration_ms: 10,
+      timestamp: Date.now(),
+    });
+    collector.onToolCallComplete({
+      tool: 'repo_manager-write_file',
+      result: { path: 'src/a.ts', written: true },
+      duration_ms: 10,
+      timestamp: Date.now(),
+    });
+
+    expect(collector.getWrittenPaths()).toEqual(['src/b.ts', 'src/a.ts']);
+  });
+});
+
+describe('FileChangeCollector.computeSummary', () => {
+  beforeEach(() => {
+    mockExecSync.mockReset();
+  });
+
+  it('returns null when no files were written', () => {
+    const collector = new FileChangeCollector();
+    const result = collector.computeSummary('/fake/repo');
+    expect(result).toBeNull();
+  });
+
+  it('parses git diff --numstat for modified files', () => {
+    mockExecSync.mockReturnValue('15\t3\tsrc/app.ts\n');
+
+    const collector = new FileChangeCollector();
+    collector.onToolCallComplete({
+      tool: 'repo_manager-write_file',
+      result: { path: 'src/app.ts', written: true },
+      duration_ms: 10,
+      timestamp: Date.now(),
+    });
+
+    const summary = collector.computeSummary('/fake/repo');
+    expect(summary).toEqual([
+      { path: 'src/app.ts', status: 'M', added: 15, removed: 3 },
+    ]);
+  });
+
+  it('marks files not in git diff as Added with line count', () => {
+    mockExecSync
+      .mockReturnValueOnce('')           // git diff --numstat returns nothing
+      .mockReturnValueOnce('42\n');      // wc -l for the new file
+
+    const collector = new FileChangeCollector();
+    collector.onToolCallComplete({
+      tool: 'repo_manager-write_file',
+      result: { path: 'src/new.ts', written: true },
+      duration_ms: 10,
+      timestamp: Date.now(),
+    });
+
+    const summary = collector.computeSummary('/fake/repo');
+    expect(summary).toEqual([
+      { path: 'src/new.ts', status: 'A', added: 42, removed: 0 },
+    ]);
+  });
+
+  it('returns null when git is not available', () => {
+    mockExecSync.mockImplementation(() => {
+      throw new Error('git not found');
+    });
+
+    const collector = new FileChangeCollector();
+    collector.onToolCallComplete({
+      tool: 'repo_manager-write_file',
+      result: { path: 'src/app.ts', written: true },
+      duration_ms: 10,
+      timestamp: Date.now(),
+    });
+
+    const summary = collector.computeSummary('/fake/repo');
+    expect(summary).toBeNull();
+  });
+});
+
+describe('formatFileChanges', () => {
+  it('formats modified files with +/- counts', () => {
+    const changes: FileChange[] = [
+      { path: 'src/app.ts', status: 'M', added: 15, removed: 3 },
+    ];
+    const lines = formatFileChanges(changes);
+    expect(lines).toContain('Changes:');
+    expect(lines).toContain('M');
+    expect(lines).toContain('src/app.ts');
+    expect(lines).toContain('+15');
+    expect(lines).toContain('-3');
+  });
+
+  it('formats added files with line count', () => {
+    const changes: FileChange[] = [
+      { path: 'src/new.ts', status: 'A', added: 42, removed: 0 },
+    ];
+    const lines = formatFileChanges(changes);
+    expect(lines).toContain('A');
+    expect(lines).toContain('src/new.ts');
+    expect(lines).toContain('new file');
+    expect(lines).toContain('42');
+  });
+
+  it('formats mixed M and A files', () => {
+    const changes: FileChange[] = [
+      { path: 'src/app.ts', status: 'M', added: 15, removed: 3 },
+      { path: 'src/new.ts', status: 'A', added: 42, removed: 0 },
+    ];
+    const lines = formatFileChanges(changes);
+    expect(lines).toContain('M');
+    expect(lines).toContain('A');
+  });
+
+  it('returns empty string for empty array', () => {
+    expect(formatFileChanges([])).toBe('');
+  });
+});