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

package/tests/commands/install.test.ts

@@ -1,52 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-vi.mock('node:child_process', () => ({
-  execSync: vi.fn(),
-}));
-
-import { execSync } from 'node:child_process';
-import { installExtensionCommand } from '../../src/commands/install.js';
-
-const mockExecSync = vi.mocked(execSync);
-
-beforeEach(() => {
-  mockExecSync.mockClear();
-});
-
-describe('installExtensionCommand', () => {
-  it('runs npm install -g @studio-foundation/api when extension is "api"', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit'); });
-
-    await installExtensionCommand('api');
-
-    expect(mockExecSync).toHaveBeenCalledWith('npm install -g @studio-foundation/api', { stdio: 'inherit' });
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('@studio-foundation/api installed'));
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('exits with error for unknown extension', async () => {
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit'); });
-
-    await expect(installExtensionCommand('web')).rejects.toThrow('exit');
-
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown extension'));
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    errorSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('exits with error when npm install fails', async () => {
-    mockExecSync.mockImplementationOnce(() => { throw new Error('npm ERR! 404'); });
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit'); });
-
-    await expect(installExtensionCommand('api')).rejects.toThrow('exit');
-
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    errorSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-});

package/tests/commands/integrations.test.ts

@@ -1,158 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtemp, mkdir, writeFile, rm, readFile, access, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import type { IntegrationPluginDef } from '@studio-foundation/contracts';
-import { installIntegration, getIntegrationStatus, removeIntegration, runIntegrationTest } from '../../src/commands/integrations.js';
-import type { IntegrationTestResult } from '../../src/commands/integrations.js';
-
-let studioDir: string;
-let integrationsDir: string;
-
-beforeEach(async () => {
-  studioDir = await mkdtemp(join(tmpdir(), 'studio-int-test-'));
-  integrationsDir = join(studioDir, 'integrations');
-  await mkdir(integrationsDir, { recursive: true });
-});
-
-afterEach(async () => {
-  await rm(studioDir, { recursive: true, force: true });
-});
-
-describe('installIntegration — bundled source', () => {
-  it('installs a known bundled integration by @studio/integration-<name>', async () => {
-    await installIntegration('@studio-foundation/integration-linear', integrationsDir);
-    const destPath = join(integrationsDir, 'linear.integration.yaml');
-    await expect(access(destPath)).resolves.toBeUndefined();
-    const content = await readFile(destPath, 'utf-8');
-    expect(content).toContain('name: linear');
-  });
-
-  it('throws if integration name is unknown', async () => {
-    await expect(
-      installIntegration('@studio-foundation/integration-doesnotexist', integrationsDir)
-    ).rejects.toThrow("Unknown integration 'doesnotexist'");
-  });
-
-  it('throws if already installed', async () => {
-    await installIntegration('@studio-foundation/integration-linear', integrationsDir);
-    await expect(
-      installIntegration('@studio-foundation/integration-linear', integrationsDir)
-    ).rejects.toThrow("'linear' already installed");
-  });
-});
-
-describe('installIntegration — local path', () => {
-  it('installs from a local .integration.yaml file', async () => {
-    const localFile = join(studioDir, 'my-custom.integration.yaml');
-    await writeFile(localFile, 'name: my-custom\nversion: 1\ndescription: "Custom"');
-    await installIntegration(localFile, integrationsDir);
-    const destPath = join(integrationsDir, 'my-custom.integration.yaml');
-    await expect(access(destPath)).resolves.toBeUndefined();
-  });
-
-  it('throws if local file does not exist', async () => {
-    await expect(
-      installIntegration('/nonexistent/file.integration.yaml', integrationsDir)
-    ).rejects.toThrow('File not found');
-  });
-});
-
-describe('getIntegrationStatus', () => {
-  it('returns configured when all required vars are set in config', () => {
-    const plugin: IntegrationPluginDef = {
-      name: 'linear',
-      version: 1,
-      config: { required: ['LINEAR_API_KEY', 'LINEAR_WEBHOOK_SECRET'] },
-    };
-    const config = { LINEAR_API_KEY: 'abc', LINEAR_WEBHOOK_SECRET: 'secret' };
-    expect(getIntegrationStatus(plugin, config)).toBe('configured');
-  });
-
-  it('returns not-configured when a required var is missing', () => {
-    const plugin: IntegrationPluginDef = {
-      name: 'linear',
-      version: 1,
-      config: { required: ['LINEAR_API_KEY', 'LINEAR_WEBHOOK_SECRET'] },
-    };
-    const config = { LINEAR_API_KEY: 'abc' };
-    expect(getIntegrationStatus(plugin, config)).toBe('not-configured');
-  });
-
-  it('returns configured when plugin has no required vars', () => {
-    const plugin: IntegrationPluginDef = { name: 'webhook', version: 1 };
-    expect(getIntegrationStatus(plugin, {})).toBe('configured');
-  });
-});
-
-describe('removeIntegration', () => {
-  it('removes an installed integration file', async () => {
-    await installIntegration('@studio-foundation/integration-linear', integrationsDir);
-    const destPath = join(integrationsDir, 'linear.integration.yaml');
-    await expect(access(destPath)).resolves.toBeUndefined();
-
-    await removeIntegration('linear', integrationsDir);
-    await expect(access(destPath)).rejects.toThrow();
-  });
-
-  it('throws if integration is not installed', async () => {
-    await expect(
-      removeIntegration('doesnotexist', integrationsDir)
-    ).rejects.toThrow("Integration 'doesnotexist' not found");
-  });
-});
-
-describe('runIntegrationTest', () => {
-  it('makes an HTTP request with correct headers when auth is provided', async () => {
-    const fetchCalls: { url: string; init: RequestInit }[] = [];
-    const mockFetch = async (url: string, init: RequestInit) => {
-      fetchCalls.push({ url, init });
-      return new Response('{"data":{"viewer":{"id":"1","name":"Test"}}}', { status: 200 });
-    };
-
-    const plugin: IntegrationPluginDef = {
-      name: 'linear',
-      version: 1,
-      test: {
-        type: 'http',
-        endpoint: 'https://api.linear.app/graphql',
-        method: 'POST',
-        auth: 'bearer:${LINEAR_API_KEY}',
-        body: '{"query":"{ viewer { id name } }"}',
-        expect: { status: 200 },
-      },
-    };
-    const config = { LINEAR_API_KEY: 'my-api-key' };
-
-    const result = await runIntegrationTest(plugin, config, mockFetch as typeof fetch);
-    expect(result.success).toBe(true);
-    expect(fetchCalls[0]!.url).toBe('https://api.linear.app/graphql');
-    expect((fetchCalls[0]!.init.headers as Record<string, string>)['Authorization']).toBe('Bearer my-api-key');
-  });
-
-  it('returns success=false when HTTP status does not match expect.status', async () => {
-    const mockFetch = async () => new Response('Unauthorized', { status: 401 });
-    const plugin: IntegrationPluginDef = {
-      name: 'linear',
-      version: 1,
-      test: {
-        type: 'http',
-        endpoint: 'https://api.linear.app/graphql',
-        method: 'POST',
-        auth: 'bearer:my-key',
-        body: '{"query":"{ viewer { id } }"}',
-        expect: { status: 200 },
-      },
-    };
-    const result = await runIntegrationTest(plugin, {}, mockFetch as typeof fetch);
-    expect(result.success).toBe(false);
-    expect(result.statusCode).toBe(401);
-  });
-
-  it('throws when plugin has no test: block', async () => {
-    const plugin: IntegrationPluginDef = { name: 'webhook', version: 1 };
-    await expect(runIntegrationTest(plugin, {}, fetch)).rejects.toThrow(
-      "Integration 'webhook' has no test: configuration"
-    );
-  });
-});

package/tests/commands/ollama.test.ts

@@ -1,139 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-
-// Mock child_process before importing the module
-vi.mock('node:child_process', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('node:child_process')>();
-  return { ...actual, spawnSync: vi.fn() };
-});
-
-const { spawnSync } = await import('node:child_process');
-const { ollamaStatusCommand, ollamaStartCommand, ollamaStopCommand, ollamaPullCommand } = await import('../../src/commands/ollama.js');
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  vi.stubGlobal('fetch', undefined);
-});
-
-describe('ollamaStatusCommand', () => {
-  it('prints running + models when Ollama responds', async () => {
-    global.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        models: [
-          { name: 'llama3.3:latest', size: 4_200_000_000 },
-          { name: 'codellama:7b', size: 3_800_000_000 },
-        ],
-      }),
-    }) as unknown as typeof fetch;
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await ollamaStatusCommand('http://localhost:11434');
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('llama3.3:latest'));
-    logSpy.mockRestore();
-  });
-
-  it('prints not running when fetch fails', async () => {
-    global.fetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED')) as unknown as typeof fetch;
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await ollamaStatusCommand('http://localhost:11434');
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
-    logSpy.mockRestore();
-  });
-});
-
-describe('ollamaStartCommand', () => {
-  it('prints "already running" when Ollama is reachable', async () => {
-    global.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      json: async () => ({ models: [] }),
-    }) as unknown as typeof fetch;
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await ollamaStartCommand('http://localhost:11434');
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('already running'));
-    logSpy.mockRestore();
-  });
-
-  it('prints native ollama serve command when ollama is installed', async () => {
-    global.fetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED')) as unknown as typeof fetch;
-    vi.mocked(spawnSync).mockReturnValue({ status: 0 } as ReturnType<typeof spawnSync>);
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await ollamaStartCommand('http://localhost:11434');
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('ollama serve'));
-    logSpy.mockRestore();
-  });
-
-  it('prints docker run command when only docker is available', async () => {
-    global.fetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED')) as unknown as typeof fetch;
-    vi.mocked(spawnSync)
-      .mockReturnValueOnce({ status: 1 } as ReturnType<typeof spawnSync>) // ollama not found
-      .mockReturnValueOnce({ status: 0 } as ReturnType<typeof spawnSync>); // docker found
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await ollamaStartCommand('http://localhost:11434');
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('docker run'));
-    logSpy.mockRestore();
-  });
-
-  it('prints install instructions when neither is available', async () => {
-    global.fetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED')) as unknown as typeof fetch;
-    vi.mocked(spawnSync).mockReturnValue({ status: 1 } as ReturnType<typeof spawnSync>);
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await ollamaStartCommand('http://localhost:11434');
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('docker.com'));
-    logSpy.mockRestore();
-  });
-});
-
-describe('ollamaStopCommand', () => {
-  it('always prints stop instructions including docker stop', async () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await ollamaStopCommand();
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('docker stop'));
-    logSpy.mockRestore();
-  });
-});
-
-describe('ollamaPullCommand', () => {
-  it('exits with error when Ollama not running', async () => {
-    global.fetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED')) as unknown as typeof fetch;
-
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as (code?: number) => never);
-    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    await ollamaPullCommand('llama3.3', 'http://localhost:11434');
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    exitSpy.mockRestore();
-    errSpy.mockRestore();
-  });
-
-  it('streams pull and prints success', async () => {
-    const encoder = new TextEncoder();
-    const ndjson = '{"status":"pulling manifest"}\n{"status":"success"}\n';
-
-    let callCount = 0;
-    global.fetch = vi.fn().mockImplementation(async () => {
-      callCount++;
-      if (callCount === 1) {
-        return { ok: true, json: async () => ({ models: [] }) };
-      }
-      const stream = new ReadableStream({
-        start(controller) {
-          controller.enqueue(encoder.encode(ndjson));
-          controller.close();
-        },
-      });
-      return { ok: true, body: stream };
-    }) as unknown as typeof fetch;
-
-    const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await ollamaPullCommand('llama3.3', 'http://localhost:11434');
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Pulled llama3.3'));
-    writeSpy.mockRestore();
-    logSpy.mockRestore();
-  });
-});

package/tests/commands/project.test.ts

@@ -1,179 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdir, rm, access, readdir } from 'node:fs/promises';
-import { resolve, join } from 'node:path';
-
-// IMPORTANT: must be under /tmp, not a Studio repo subdirectory
-const TMP = resolve('/tmp', '.studio-project-test');
-const PROJECTS_DIR = join(TMP, '.studio', 'projects');
-
-beforeEach(async () => { await mkdir(PROJECTS_DIR, { recursive: true }); });
-afterEach(async () => { await rm(TMP, { recursive: true, force: true }); });
-
-async function exists(p: string): Promise<boolean> {
-  try { await access(p); return true; } catch { return false; }
-}
-
-describe.skip('createProjectDir', () => {
-  it('creates 5 empty subdirs when no template given', async () => {
-    const { createProjectDir } = await import('../../src/commands/project.js');
-    await createProjectDir(PROJECTS_DIR, 'my-app');
-
-    const projectDir = join(PROJECTS_DIR, 'my-app');
-    for (const sub of ['pipelines', 'agents', 'contracts', 'tools', 'inputs']) {
-      expect(await exists(join(projectDir, sub))).toBe(true);
-    }
-  });
-
-  it('creates 5 empty subdirs for blank template (no project/ subdir in template)', async () => {
-    const { createProjectDir } = await import('../../src/commands/project.js');
-    await createProjectDir(PROJECTS_DIR, 'my-app', 'blank');
-
-    const pipelinesDir = join(PROJECTS_DIR, 'my-app', 'pipelines');
-    expect(await exists(pipelinesDir)).toBe(true);
-    const entries = await readdir(pipelinesDir);
-    expect(entries).toEqual([]);
-  });
-
-  it('copies software template files into the project dir', async () => {
-    const { createProjectDir } = await import('../../src/commands/project.js');
-    await createProjectDir(PROJECTS_DIR, 'my-app', 'software');
-
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'pipelines', 'feature-builder.pipeline.yaml'))).toBe(true);
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'agents', 'coder.agent.yaml'))).toBe(true);
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'contracts', 'code-output.contract.yaml'))).toBe(true);
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'tools', 'repo-manager.tool.yaml'))).toBe(true);
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'inputs', 'example.input.yaml'))).toBe(true);
-  });
-
-  it('throws "already exists" when the project dir already exists', async () => {
-    const { createProjectDir } = await import('../../src/commands/project.js');
-    await createProjectDir(PROJECTS_DIR, 'my-app');
-    await expect(createProjectDir(PROJECTS_DIR, 'my-app')).rejects.toThrow("Project 'my-app' already exists");
-  });
-
-  it('throws "not found" with template list hint for invalid template', async () => {
-    const { createProjectDir } = await import('../../src/commands/project.js');
-    const err = await createProjectDir(PROJECTS_DIR, 'my-app', 'nonexistent').catch((e: Error) => e);
-    expect(err).toBeInstanceOf(Error);
-    expect((err as Error).message).toContain("Template 'nonexistent' not found");
-    expect((err as Error).message).toContain('studio templates list');
-  });
-});
-
-describe('validateProjectName', () => {
-  it('accepts valid lowercase alphanumeric names', async () => {
-    const { validateProjectName } = await import('../../src/commands/project.js');
-    expect(validateProjectName('software')).toBe(true);
-    expect(validateProjectName('legal-analyzer')).toBe(true);
-    expect(validateProjectName('my-project-v2')).toBe(true);
-    expect(validateProjectName('x')).toBe(true);
-    expect(validateProjectName('abc123')).toBe(true);
-  });
-
-  it('rejects names with uppercase letters', async () => {
-    const { validateProjectName } = await import('../../src/commands/project.js');
-    expect(validateProjectName('Legal')).not.toBe(true);
-    expect(validateProjectName('MY-PROJECT')).not.toBe(true);
-  });
-
-  it('rejects names with leading or trailing hyphens', async () => {
-    const { validateProjectName } = await import('../../src/commands/project.js');
-    expect(validateProjectName('-legal')).not.toBe(true);
-    expect(validateProjectName('legal-')).not.toBe(true);
-  });
-
-  it('rejects names with spaces or underscores', async () => {
-    const { validateProjectName } = await import('../../src/commands/project.js');
-    expect(validateProjectName('my project')).not.toBe(true);
-    expect(validateProjectName('my_project')).not.toBe(true);
-  });
-
-  it('returns an error string (not false) for invalid names', async () => {
-    const { validateProjectName } = await import('../../src/commands/project.js');
-    const result = validateProjectName('Bad Name');
-    expect(typeof result).toBe('string');
-    expect(result).toContain('lowercase');
-  });
-});
-
-describe.skip('createProjectDir with { withTools: false }', () => {
-  it('copies software template files but leaves tools/ empty', async () => {
-    const { createProjectDir } = await import('../../src/commands/project.js');
-    await createProjectDir(PROJECTS_DIR, 'my-app', 'software', { withTools: false });
-
-    // Non-tool template files are copied
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'pipelines', 'feature-builder.pipeline.yaml'))).toBe(true);
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'agents', 'coder.agent.yaml'))).toBe(true);
-
-    // tools/ directory exists but is empty
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'tools'))).toBe(true);
-    const toolFiles = await readdir(join(PROJECTS_DIR, 'my-app', 'tools'));
-    expect(toolFiles).toEqual([]);
-  });
-
-  it('blank template with { withTools: false } still creates all 5 subdirs including tools/', async () => {
-    const { createProjectDir } = await import('../../src/commands/project.js');
-    await createProjectDir(PROJECTS_DIR, 'my-blank', 'blank', { withTools: false });
-
-    for (const sub of ['pipelines', 'agents', 'contracts', 'tools', 'inputs']) {
-      expect(await exists(join(PROJECTS_DIR, 'my-blank', sub))).toBe(true);
-    }
-  });
-
-  it('default behavior (withTools: true) still copies tools', async () => {
-    const { createProjectDir } = await import('../../src/commands/project.js');
-    await createProjectDir(PROJECTS_DIR, 'my-app', 'software');
-
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'tools', 'repo-manager.tool.yaml'))).toBe(true);
-  });
-});
-
-describe.skip('projectAddDirect', () => {
-  it('creates project dirs with a valid name and no template', async () => {
-    const { projectAddDirect } = await import('../../src/commands/project.js');
-    const studioDir = join(TMP, '.studio');
-
-    await projectAddDirect(studioDir, 'legal-analyzer');
-
-    expect(await exists(join(PROJECTS_DIR, 'legal-analyzer', 'pipelines'))).toBe(true);
-    expect(await exists(join(PROJECTS_DIR, 'legal-analyzer', 'agents'))).toBe(true);
-  });
-
-  it('creates project with software template', async () => {
-    const { projectAddDirect } = await import('../../src/commands/project.js');
-    const studioDir = join(TMP, '.studio');
-
-    await projectAddDirect(studioDir, 'my-app', 'software');
-
-    expect(await exists(join(PROJECTS_DIR, 'my-app', 'pipelines', 'feature-builder.pipeline.yaml'))).toBe(true);
-  });
-
-  it('throws on invalid project name', async () => {
-    const { projectAddDirect } = await import('../../src/commands/project.js');
-    const studioDir = join(TMP, '.studio');
-    await expect(projectAddDirect(studioDir, 'Invalid Name')).rejects.toThrow('lowercase');
-  });
-
-  it('throws "already exists" when project already present', async () => {
-    const { projectAddDirect } = await import('../../src/commands/project.js');
-    const studioDir = join(TMP, '.studio');
-    await projectAddDirect(studioDir, 'legal-analyzer');
-    await expect(projectAddDirect(studioDir, 'legal-analyzer')).rejects.toThrow('already exists');
-  });
-});
-
-describe('projectCommand', () => {
-  it('exits 1 with deprecation message when called', async () => {
-    const { projectCommand } = await import('../../src/commands/project.js');
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    await projectCommand('add', [], {});
-
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('no longer supported'));
-
-    exitSpy.mockRestore();
-    consoleErrorSpy.mockRestore();
-  });
-});

package/tests/commands/registry/audit.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { rm, mkdir, writeFile } from 'node:fs/promises';
-import { resolve, join } from 'node:path';
-import { createHash } from 'node:crypto';
-
-const TMP = resolve(import.meta.dirname, '.tmp-audit');
-const STUDIO = join(TMP, '.studio');
-const TOOLS = join(STUDIO, 'tools');
-
-beforeEach(async () => {
-  await mkdir(TOOLS, { recursive: true });
-});
-afterEach(async () => { await rm(TMP, { recursive: true, force: true }); });
-
-describe('auditPackages', () => {
-  it('returns ok for intact file', async () => {
-    const content = 'name: my-tool\n';
-    const sha256 = createHash('sha256').update(content).digest('hex');
-    await writeFile(join(TOOLS, 'my-tool.tool.yaml'), content);
-    await writeFile(join(STUDIO, 'registry.lock.json'), JSON.stringify({
-      installed: { 'my-tool': { version: '1.0.0', type: 'tool', installed_at: '2026-02-28', sha256 } },
-    }));
-
-    const { auditPackages } = await import('../../../src/commands/registry/audit.js');
-    const results = await auditPackages({ studioDir: STUDIO });
-    expect(results[0].ok).toBe(true);
-    expect(results[0].status).toBe('ok');
-  });
-
-  it('returns tampered for modified file', async () => {
-    const original = 'name: my-tool\n';
-    const sha256 = createHash('sha256').update(original).digest('hex');
-    await writeFile(join(TOOLS, 'my-tool.tool.yaml'), 'name: evil-tool\n'); // tampered
-    await writeFile(join(STUDIO, 'registry.lock.json'), JSON.stringify({
-      installed: { 'my-tool': { version: '1.0.0', type: 'tool', installed_at: '2026-02-28', sha256 } },
-    }));
-
-    const { auditPackages } = await import('../../../src/commands/registry/audit.js');
-    const results = await auditPackages({ studioDir: STUDIO });
-    expect(results[0].ok).toBe(false);
-    expect(results[0].status).toBe('tampered');
-  });
-
-  it('returns missing when file does not exist', async () => {
-    const sha256 = createHash('sha256').update('content').digest('hex');
-    await writeFile(join(STUDIO, 'registry.lock.json'), JSON.stringify({
-      installed: { 'my-tool': { version: '1.0.0', type: 'tool', installed_at: '2026-02-28', sha256 } },
-    }));
-    // no file written to TOOLS
-
-    const { auditPackages } = await import('../../../src/commands/registry/audit.js');
-    const results = await auditPackages({ studioDir: STUDIO });
-    expect(results[0].ok).toBe(false);
-    expect(results[0].status).toBe('missing');
-  });
-});