@studio-foundation/cli 0.3.0-beta.1 → 0.3.0-beta.6

package/tests/output/progress-timer.test.ts

@@ -1,230 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// Mock ora BEFORE importing progress.ts
-const mockOraInstance = {
-  start: vi.fn().mockReturnThis(),
-  stop: vi.fn().mockReturnThis(),
-  succeed: vi.fn().mockReturnThis(),
-  fail: vi.fn().mockReturnThis(),
-  text: '',
-};
-vi.mock('ora', () => ({ default: vi.fn(() => mockOraInstance) }));
-
-// Helper functions for non-live tests
-function makeQuietDisplay() {
-  return new ProgressDisplay(false, 'quiet');
-}
-
-function stageStartEvent(n = 1, total = 3) {
-  return { stage_name: 'entity-extraction', stage_index: n - 1, total_stages: total, max_attempts: 3 };
-}
-
-import { ProgressDisplay } from '../../src/output/progress.js';
-
-describe('ProgressDisplay — timer utilities', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('clearTimer is idempotent (no error if called twice)', () => {
-    const d = new ProgressDisplay(false, 'quiet');
-    const p = d as unknown as { clearTimer(): void };
-    expect(() => {
-      p.clearTimer();
-      p.clearTimer();
-    }).not.toThrow();
-  });
-
-  it('startTimer calls updateFn with elapsed seconds after each tick', () => {
-    const d = new ProgressDisplay(false, 'quiet');
-    const p = d as unknown as {
-      resetStageTimer(): void;
-      startTimer(fn: (s: string) => void): void;
-      clearTimer(): void;
-    };
-    const calls: string[] = [];
-    p.resetStageTimer();
-    p.startTimer((s) => calls.push(s));
-
-    vi.advanceTimersByTime(1000);
-    expect(calls[0]).toBe('1s');
-
-    vi.advanceTimersByTime(2000);
-    expect(calls[2]).toBe('3s');
-
-    p.clearTimer();
-  });
-
-  it('clearTimer stops the interval (no more updateFn calls after clear)', () => {
-    const d = new ProgressDisplay(false, 'quiet');
-    const p = d as unknown as {
-      resetStageTimer(): void;
-      startTimer(fn: (s: string) => void): void;
-      clearTimer(): void;
-    };
-    const calls: string[] = [];
-    p.resetStageTimer();
-    p.startTimer((s) => calls.push(s));
-    vi.advanceTimersByTime(2000);
-    p.clearTimer();
-    const countAfterClear = calls.length;
-    vi.advanceTimersByTime(5000);
-    expect(calls.length).toBe(countAfterClear);
-  });
-
-  it('elapsedSeconds returns correct elapsed seconds', () => {
-    const d = new ProgressDisplay(false, 'quiet');
-    const p = d as unknown as {
-      resetStageTimer(): void;
-      elapsedSeconds(): number;
-    };
-    p.resetStageTimer();
-    vi.advanceTimersByTime(7500);
-    expect(p.elapsedSeconds()).toBe(7);
-  });
-});
-
-describe('ProgressDisplay — timer in non-live mode', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('updates spinner text with elapsed seconds every second', () => {
-    const d = makeQuietDisplay();
-    const events = d.getEvents();
-    events.onStageStart!(stageStartEvent());
-
-    vi.advanceTimersByTime(5000);
-
-    expect(mockOraInstance.text).toContain('5s');
-  });
-
-  it('clears timer on onStageComplete', () => {
-    const d = makeQuietDisplay();
-    const events = d.getEvents();
-    events.onStageStart!(stageStartEvent());
-    vi.advanceTimersByTime(3000);
-
-    events.onStageComplete!({
-      stage_name: 'entity-extraction', stage_index: 0, total_stages: 3,
-      status: 'success', attempts: 1, duration_ms: 3000,
-    });
-
-    const textAfterComplete = mockOraInstance.text;
-    vi.advanceTimersByTime(5000);
-    expect(mockOraInstance.text).toBe(textAfterComplete);
-  });
-
-  it('clears timer on onTaskRetry', () => {
-    const d = makeQuietDisplay();
-    const events = d.getEvents();
-    events.onStageStart!(stageStartEvent());
-    vi.advanceTimersByTime(2000);
-
-    events.onTaskRetry!({ stage: 'entity-extraction', attempt: 2, max_attempts: 3, failures: ['missing field'] });
-
-    const textAfterRetry = mockOraInstance.text;
-    vi.advanceTimersByTime(5000);
-    expect(mockOraInstance.text).toBe(textAfterRetry);
-  });
-
-  it('clears timer on interrupt()', () => {
-    const d = makeQuietDisplay();
-    const events = d.getEvents();
-    events.onStageStart!(stageStartEvent());
-    vi.advanceTimersByTime(2000);
-
-    d.interrupt();
-
-    const textAfterInterrupt = mockOraInstance.text;
-    vi.advanceTimersByTime(5000);
-    expect(mockOraInstance.text).toBe(textAfterInterrupt);
-  });
-});
-
-function makeLiveDisplay() {
-  return new ProgressDisplay(false, 'live');
-}
-
-function toolCallStartEvent() {
-  return { tool: 'repo_manager-write_file', params: { path: 'out.json' }, timestamp: Date.now() };
-}
-
-function toolCallCompleteEvent() {
-  return { tool: 'repo_manager-write_file', result: 'ok', duration_ms: 100, timestamp: Date.now() };
-}
-
-describe('ProgressDisplay — timer in live mode', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('thinkingSpinner text includes elapsed seconds after ticks', () => {
-    const d = makeLiveDisplay();
-    const events = d.getEvents();
-    events.onStageStart!(stageStartEvent());
-
-    vi.advanceTimersByTime(7000);
-
-    expect(mockOraInstance.text).toContain('7s');
-  });
-
-  it('after tool call completes, thinkingSpinner shows "from Xs" with accumulated time', () => {
-    const d = makeLiveDisplay();
-    const events = d.getEvents();
-    events.onStageStart!(stageStartEvent());
-    vi.advanceTimersByTime(10000);         // 10s thinking
-    events.onToolCallStart!(toolCallStartEvent());
-    vi.advanceTimersByTime(2000);          // 2s tool call
-    events.onToolCallComplete!(toolCallCompleteEvent());
-
-    // Spinner restarts — should show "from 12s"
-    expect(mockOraInstance.text).toContain('from 12s');
-  });
-
-  it('clears timer on onStageComplete in live mode', () => {
-    const d = makeLiveDisplay();
-    const events = d.getEvents();
-    events.onStageStart!(stageStartEvent());
-    vi.advanceTimersByTime(5000);
-
-    events.onStageComplete!({
-      stage_name: 'entity-extraction', stage_index: 0, total_stages: 3,
-      status: 'success', attempts: 1, duration_ms: 5000,
-    });
-
-    const textAfter = mockOraInstance.text;
-    vi.advanceTimersByTime(5000);
-    expect(mockOraInstance.text).toBe(textAfter);
-  });
-
-  it('clears timer on onAgentToken (stops updating while tokens stream)', () => {
-    const d = makeLiveDisplay();
-    const events = d.getEvents();
-    events.onStageStart!(stageStartEvent());
-    vi.advanceTimersByTime(3000);
-
-    const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-    events.onAgentToken!({ token: 'Hello', stage: 'entity-extraction', timestamp: Date.now() });
-    writeSpy.mockRestore();
-
-    const textAfterToken = mockOraInstance.text;
-    vi.advanceTimersByTime(5000);
-    expect(mockOraInstance.text).toBe(textAfterToken);
-  });
-});

package/tests/provider-validator.test.ts

@@ -1,182 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { validateApiKeyLive } from '../src/provider-validator.js';
-import { getCachedModels } from '../src/models-cache.js';
-
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-
-beforeEach(() => { mockFetch.mockReset(); });
-
-function mockResponse(status: number, body?: unknown): Response {
-  return {
-    status,
-    ok: status >= 200 && status < 300,
-    json: async () => body ?? {},
-  } as Response;
-}
-
-// ─── Anthropic ───────────────────────────────────────────────────────────────
-
-describe('validateApiKeyLive — anthropic', () => {
-  it('returns valid when /v1/models returns 200', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200, { data: [] }));
-    const result = await validateApiKeyLive('anthropic', 'sk-ant-valid-key');
-    expect(result.status).toBe('valid');
-  });
-
-  it('calls GET https://api.anthropic.com/v1/models with x-api-key header', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200, { data: [] }));
-    await validateApiKeyLive('anthropic', 'sk-ant-mykey');
-    const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-    expect(url).toBe('https://api.anthropic.com/v1/models');
-    expect((init.headers as Record<string, string>)['x-api-key']).toBe('sk-ant-mykey');
-  });
-
-  it('populates models cache on 200', async () => {
-    mockFetch.mockResolvedValueOnce(
-      mockResponse(200, {
-        data: [
-          { id: 'claude-sonnet-4-20250514' },
-          { id: 'claude-instant-1' }, // excluded by filter
-        ],
-      })
-    );
-    await validateApiKeyLive('anthropic', 'sk-ant-cache-pop');
-    const cached = getCachedModels('anthropic', 'sk-ant-cache-pop');
-    expect(cached).toContain('claude-sonnet-4-20250514');
-    expect(cached).not.toContain('claude-instant-1');
-  });
-
-  it('returns invalid with error message when 401', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(401));
-    const result = await validateApiKeyLive('anthropic', 'sk-ant-bad');
-    expect(result.status).toBe('invalid');
-    expect('error' in result && result.error).toContain('401');
-  });
-
-  it('returns invalid when 403', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(403));
-    const result = await validateApiKeyLive('anthropic', 'sk-ant-bad');
-    expect(result.status).toBe('invalid');
-  });
-
-  it('returns warning on network error', async () => {
-    mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED'));
-    const result = await validateApiKeyLive('anthropic', 'sk-ant-key');
-    expect(result.status).toBe('warning');
-    expect('message' in result && result.message).toMatch(/Could not validate/i);
-  });
-
-  it('returns warning on abort (timeout)', async () => {
-    const err = Object.assign(new Error('abort'), { name: 'AbortError' });
-    mockFetch.mockRejectedValueOnce(err);
-    const result = await validateApiKeyLive('anthropic', 'sk-ant-key');
-    expect(result.status).toBe('warning');
-    expect('message' in result && result.message).toMatch(/timed out/i);
-  });
-});
-
-// ─── OpenAI ──────────────────────────────────────────────────────────────────
-
-describe('validateApiKeyLive — openai', () => {
-  it('returns valid when /v1/models returns 200', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200, { data: [] }));
-    const result = await validateApiKeyLive('openai', 'sk-proj-valid');
-    expect(result.status).toBe('valid');
-  });
-
-  it('calls GET https://api.openai.com/v1/models with Authorization Bearer header', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200, { data: [] }));
-    await validateApiKeyLive('openai', 'sk-proj-mykey');
-    const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit];
-    expect(url).toBe('https://api.openai.com/v1/models');
-    expect((init.headers as Record<string, string>)['Authorization']).toBe('Bearer sk-proj-mykey');
-  });
-
-  it('populates models cache on 200', async () => {
-    mockFetch.mockResolvedValueOnce(
-      mockResponse(200, { data: [{ id: 'gpt-4o' }, { id: 'gpt-3.5-turbo' }] })
-    );
-    await validateApiKeyLive('openai', 'sk-openai-cache');
-    const cached = getCachedModels('openai', 'sk-openai-cache');
-    expect(cached).toContain('gpt-4o');
-    expect(cached).not.toContain('gpt-3.5-turbo');
-  });
-
-  it('returns invalid when 401', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(401));
-    const result = await validateApiKeyLive('openai', 'sk-bad');
-    expect(result.status).toBe('invalid');
-    expect('error' in result && result.error).toContain('401');
-  });
-});
-
-// ─── Google ──────────────────────────────────────────────────────────────────
-
-describe('validateApiKeyLive — google', () => {
-  it('returns valid when models endpoint returns 200', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200));
-    const result = await validateApiKeyLive('google', 'AIzaValid');
-    expect(result.status).toBe('valid');
-  });
-
-  it('includes API key as query param in URL', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200));
-    await validateApiKeyLive('google', 'AIzaMyKey');
-    const [url] = mockFetch.mock.calls[0] as [string, RequestInit];
-    expect(url).toContain('AIzaMyKey');
-    expect(url).toContain('generativelanguage.googleapis.com');
-  });
-
-  it('does NOT populate models cache (Google not supported)', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200));
-    await validateApiKeyLive('google', 'AIzaCache');
-    expect(getCachedModels('google', 'AIzaCache')).toBeNull();
-  });
-
-  it('returns invalid when 400 or 403', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(400));
-    const result = await validateApiKeyLive('google', 'AIzaBad');
-    expect(result.status).toBe('invalid');
-  });
-});
-
-// ─── Ollama ──────────────────────────────────────────────────────────────────
-
-describe('validateApiKeyLive — ollama', () => {
-  it('returns valid when Ollama /api/tags returns 200', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200));
-    const result = await validateApiKeyLive('ollama', '', { baseUrl: 'http://localhost:11434' });
-    expect(result.status).toBe('valid');
-  });
-
-  it('uses default http://localhost:11434 when no baseUrl', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200));
-    await validateApiKeyLive('ollama', '');
-    const [url] = mockFetch.mock.calls[0] as [string, RequestInit];
-    expect(url).toContain('localhost:11434');
-  });
-
-  it('uses custom baseUrl when provided', async () => {
-    mockFetch.mockResolvedValueOnce(mockResponse(200));
-    await validateApiKeyLive('ollama', '', { baseUrl: 'http://my-ollama:8080' });
-    const [url] = mockFetch.mock.calls[0] as [string, RequestInit];
-    expect(url).toContain('my-ollama:8080');
-  });
-
-  it('returns warning on connection refused', async () => {
-    mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED'));
-    const result = await validateApiKeyLive('ollama', '', { baseUrl: 'http://localhost:11434' });
-    expect(result.status).toBe('warning');
-  });
-});
-
-// ─── Unknown provider ────────────────────────────────────────────────────────
-
-describe('validateApiKeyLive — unknown provider', () => {
-  it('returns warning for unrecognized providers', async () => {
-    const result = await validateApiKeyLive('future-provider', 'some-key');
-    expect(result.status).toBe('warning');
-    expect('message' in result && result.message).toMatch(/cannot validate/i);
-  });
-});

package/tests/registry/cache.test.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { rm, readFile, mkdir, writeFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { RegistryCache } from '../../src/registry/cache.js';
-import type { RegistryIndex } from '../../src/registry/types.js';
-
-const TMP = resolve(import.meta.dirname, '.tmp-registry-cache');
-
-const MOCK_INDEX: RegistryIndex = {
-  generated_at: '2026-02-28T00:00:00Z',
-  version: '1',
-  packages: [
-    {
-      name: 'software',
-      type: 'template',
-      version: '1.0.0',
-      description: 'Test template',
-      author: 'studio-core',
-      license: 'MIT',
-      tags: ['software'],
-      studio_version: '>=7.0.0',
-      downloads: 0,
-    },
-  ],
-};
-
-beforeEach(async () => { await mkdir(TMP, { recursive: true }); });
-afterEach(async () => { await rm(TMP, { recursive: true, force: true }); });
-
-describe('RegistryCache', () => {
-  it('returns null when cache does not exist', async () => {
-    const cache = new RegistryCache(TMP);
-    expect(await cache.read()).toBeNull();
-  });
-
-  it('writes and reads back correctly', async () => {
-    const cache = new RegistryCache(TMP);
-    await cache.write(MOCK_INDEX);
-    const result = await cache.read();
-    expect(result).not.toBeNull();
-    expect(result!.packages).toHaveLength(1);
-    expect(result!.packages[0].name).toBe('software');
-  });
-
-  it('returns null when cache is expired', async () => {
-    const cache = new RegistryCache(TMP);
-    await cache.write(MOCK_INDEX);
-    // Force expire by overwriting with old _cached_at
-    const cachePath = resolve(TMP, 'index.json');
-    const data = JSON.parse(await readFile(cachePath, 'utf8'));
-    data._cached_at = new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString();
-    await writeFile(cachePath, JSON.stringify(data));
-    expect(await cache.read()).toBeNull();
-  });
-
-  it('isFresh returns false when no cache', async () => {
-    const cache = new RegistryCache(TMP);
-    expect(await cache.isFresh()).toBe(false);
-  });
-
-  it('isFresh returns true right after write', async () => {
-    const cache = new RegistryCache(TMP);
-    await cache.write(MOCK_INDEX);
-    expect(await cache.isFresh()).toBe(true);
-  });
-});

package/tests/registry/client.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { rm, mkdir } from 'node:fs/promises';
-import { resolve } from 'node:path';
-
-const TMP = resolve(import.meta.dirname, '.tmp-client');
-
-const MOCK_INDEX = {
-  generated_at: '2026-02-28T00:00:00Z',
-  version: '1',
-  packages: [
-    { name: 'software', type: 'template', version: '1.0.0', description: 'Test', author: 'studio-core', license: 'MIT', tags: [], studio_version: null, downloads: 0 },
-  ],
-};
-
-const MOCK_METADATA = {
-  name: 'software',
-  version: '1.0.0',
-  description: 'Code generation',
-  author: 'studio-core',
-  license: 'MIT',
-  tags: ['software'],
-  type: 'template',
-  studio_version: '>=7.0.0',
-};
-
-beforeEach(async () => {
-  await mkdir(TMP, { recursive: true });
-  vi.stubGlobal('fetch', vi.fn());
-});
-afterEach(async () => {
-  await rm(TMP, { recursive: true, force: true });
-  vi.unstubAllGlobals();
-});
-
-describe('RegistryClient.fetchIndex', () => {
-  it('fetches and returns the registry index', async () => {
-    const mockFetch = vi.mocked(fetch);
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => MOCK_INDEX,
-    } as Response);
-
-    const { RegistryClient } = await import('../../src/registry/client.js');
-    const client = new RegistryClient();
-    const index = await client.fetchIndex();
-    expect(index.packages).toHaveLength(1);
-    expect(index.packages[0].name).toBe('software');
-  });
-
-  it('throws on non-ok response', async () => {
-    vi.mocked(fetch).mockResolvedValueOnce({ ok: false, status: 404 } as Response);
-    const { RegistryClient } = await import('../../src/registry/client.js');
-    const client = new RegistryClient();
-    await expect(client.fetchIndex()).rejects.toThrow('Failed to fetch registry index');
-  });
-});
-
-describe('RegistryClient.fetchMetadata', () => {
-  it('fetches package metadata', async () => {
-    vi.mocked(fetch).mockResolvedValueOnce({
-      ok: true,
-      json: async () => MOCK_METADATA,
-    } as Response);
-    const { RegistryClient } = await import('../../src/registry/client.js');
-    const client = new RegistryClient();
-    const meta = await client.fetchMetadata('template', 'software');
-    expect(meta.name).toBe('software');
-    expect(meta.type).toBe('template');
-  });
-});

package/tests/registry/lockfile.test.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { rm, mkdir } from 'node:fs/promises';
-import { resolve, join } from 'node:path';
-import { RegistryLockfile } from '../../src/registry/lockfile.js';
-
-const TMP = resolve(import.meta.dirname, '.tmp-lockfile');
-const STUDIO = join(TMP, '.studio');
-
-beforeEach(async () => { await mkdir(STUDIO, { recursive: true }); });
-afterEach(async () => { await rm(TMP, { recursive: true, force: true }); });
-
-describe('RegistryLockfile', () => {
-  it('returns empty lockfile when file does not exist', async () => {
-    const lf = new RegistryLockfile(TMP);
-    const data = await lf.read();
-    expect(data.installed).toEqual({});
-  });
-
-  it('adds a package entry', async () => {
-    const lf = new RegistryLockfile(TMP);
-    await lf.add('software', {
-      version: '1.0.0',
-      type: 'template',
-      installed_at: '2026-02-28',
-      sha256: 'abc123',
-    });
-    const data = await lf.read();
-    expect(data.installed['software']).toMatchObject({
-      version: '1.0.0',
-      type: 'template',
-      sha256: 'abc123',
-    });
-  });
-
-  it('removes a package entry', async () => {
-    const lf = new RegistryLockfile(TMP);
-    await lf.add('software', { version: '1.0.0', type: 'template', installed_at: '2026-02-28', sha256: 'abc' });
-    await lf.remove('software');
-    const data = await lf.read();
-    expect(data.installed['software']).toBeUndefined();
-  });
-
-  it('lists installed packages', async () => {
-    const lf = new RegistryLockfile(TMP);
-    await lf.add('software', { version: '1.0.0', type: 'template', installed_at: '2026-02-28', sha256: 'abc' });
-    await lf.add('linear', { version: '1.0.0', type: 'integration', installed_at: '2026-02-28', sha256: 'def' });
-    const list = await lf.list();
-    expect(list).toHaveLength(2);
-    expect(list.map(e => e.name)).toContain('software');
-    expect(list.map(e => e.name)).toContain('linear');
-  });
-});
-
-describe('RegistryLockfile.addRequiredBy', () => {
-  it('adds required_by to an existing entry', async () => {
-    const { RegistryLockfile } = await import('../../src/registry/lockfile.js');
-    const lf = new RegistryLockfile(STUDIO);
-    await lf.add('repo-manager', { version: '1.0.0', type: 'tool', installed_at: '2026-02-28', sha256: 'abc' });
-
-    await lf.addRequiredBy('repo-manager', 'software-full');
-
-    const entry = await lf.get('repo-manager');
-    expect(entry?.required_by).toEqual(['software-full']);
-  });
-
-  it('does not duplicate if already present', async () => {
-    const { RegistryLockfile } = await import('../../src/registry/lockfile.js');
-    const lf = new RegistryLockfile(STUDIO);
-    await lf.add('repo-manager', { version: '1.0.0', type: 'tool', installed_at: '2026-02-28', sha256: 'abc', required_by: ['software-full'] });
-
-    await lf.addRequiredBy('repo-manager', 'software-full');
-
-    const entry = await lf.get('repo-manager');
-    expect(entry?.required_by).toEqual(['software-full']); // still just one
-  });
-
-  it('removes from required_by with removeRequiredBy', async () => {
-    const { RegistryLockfile } = await import('../../src/registry/lockfile.js');
-    const lf = new RegistryLockfile(STUDIO);
-    await lf.add('repo-manager', { version: '1.0.0', type: 'tool', installed_at: '2026-02-28', sha256: 'abc', required_by: ['software-full', 'other-pkg'] });
-
-    await lf.removeRequiredBy('repo-manager', 'software-full');
-
-    const entry = await lf.get('repo-manager');
-    expect(entry?.required_by).toEqual(['other-pkg']);
-  });
-});