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

package/tests/commands/init.test.ts

@@ -1,919 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdir, rm, readFile, writeFile, access } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import * as yaml from 'js-yaml';
-
-vi.mock('node:os', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('node:os')>();
-  return { ...actual, totalmem: vi.fn(actual.totalmem) };
-});
-
-vi.mock('node:child_process', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('node:child_process')>();
-  return { ...actual, spawnSync: vi.fn(actual.spawnSync) };
-});
-
-// Mock @studio/runner since it may not be built in the worktree environment
-vi.mock('@studio-foundation/runner', () => ({
-  listAvailableToolTemplates: vi.fn().mockResolvedValue([]),
-}));
-
-// Mock node:child_process so detectOllamaInstalled doesn't run real shell commands.
-// By default delegates to the real spawnSync for non-ollama commands so that
-// initGitRepo (which calls spawnSync('git', ['init'])) still works correctly.
-vi.mock('node:child_process', async (importOriginal) => {
-  const original = await importOriginal<typeof import('node:child_process')>();
-  const realSpawnSync = original.spawnSync;
-  const mockedSpawnSync = vi.fn((...args: Parameters<typeof original.spawnSync>) => {
-    if (args[0] === 'ollama') {
-      return { status: 0 } as ReturnType<typeof original.spawnSync>;
-    }
-    return (realSpawnSync as (...a: unknown[]) => unknown)(...args) as ReturnType<typeof original.spawnSync>;
-  });
-  return {
-    ...original,
-    spawnSync: mockedSpawnSync,
-  };
-});
-
-// Mock node:os so hasAdequateRam doesn't read real hardware
-vi.mock('node:os', async (importOriginal) => {
-  const original = await importOriginal<typeof import('node:os')>();
-  const totalMemFn = vi.fn().mockReturnValue(32 * 1024 ** 3); // default: 32GB
-  const mocked = {
-    ...original,
-    totalmem: totalMemFn,
-    default: { ...(original as unknown as Record<string, unknown>), totalmem: totalMemFn },
-  };
-  return mocked;
-});
-
-// Mock installPackage so tests don't hit the network.
-// For known registry templates (software, content, document-analysis, software-full),
-// the mock creates a minimal synthetic template at .studio/projects/<name>/ with the
-// files the tests need — mirroring what the real installPackage does for templates.
-// Unknown template names produce no directory (simulating "not found in registry").
-vi.mock('../../src/commands/registry/install.js', async () => {
-  const { mkdir, writeFile } = await import('node:fs/promises');
-  const { resolve: _resolve, join: _join } = await import('node:path');
-
-  const KNOWN_TEMPLATES = new Set(['software', 'content', 'document-analysis', 'software-full']);
-
-  async function createSyntheticTemplate(destDir: string, templateName: string): Promise<void> {
-    await mkdir(_join(destDir, 'pipelines'), { recursive: true });
-    await mkdir(_join(destDir, 'agents'), { recursive: true });
-    await mkdir(_join(destDir, 'contracts'), { recursive: true });
-    await mkdir(_join(destDir, 'tools'), { recursive: true });
-    await mkdir(_join(destDir, 'inputs'), { recursive: true });
-    await mkdir(_join(destDir, 'src'), { recursive: true });
-    await mkdir(_join(destDir, 'prisma'), { recursive: true });
-
-    await writeFile(_join(destDir, 'pipelines', 'feature-builder.pipeline.yaml'), 'name: feature-builder\n', 'utf-8');
-    await writeFile(_join(destDir, 'agents', 'coder.agent.yaml'), 'name: coder\n', 'utf-8');
-    await writeFile(_join(destDir, 'contracts', 'code-output.contract.yaml'), 'name: code-output\n', 'utf-8');
-    await writeFile(_join(destDir, 'tools', 'repo-manager.tool.yaml'), 'name: repo-manager\n', 'utf-8');
-    await writeFile(_join(destDir, 'inputs', 'example.input.yaml'), 'input: example\n', 'utf-8');
-    await writeFile(_join(destDir, 'src', 'index.ts'), '// {{PROJECT_NAME}}\nexport {};\n', 'utf-8');
-    await writeFile(_join(destDir, 'prisma', 'schema.prisma'), '// prisma schema\n', 'utf-8');
-    await writeFile(
-      _join(destDir, 'package.json'),
-      JSON.stringify({ name: '{{PROJECT_NAME}}', version: '0.0.1' }, null, 2) + '\n',
-      'utf-8'
-    );
-    await writeFile(
-      _join(destDir, 'README.md'),
-      '# {{PROJECT_NAME}}\n\nTemplate: {{TEMPLATE_NAME}}\n',
-      'utf-8'
-    );
-  }
-
-  return {
-    installPackage: vi.fn(async (templateName: string, options: { studioDir?: string } = {}) => {
-      if (!KNOWN_TEMPLATES.has(templateName)) {
-        // Unknown template — do nothing (no directory created)
-        // createStudioStructure will detect the missing dir and throw the expected error.
-        return;
-      }
-      const studioDir = options.studioDir ?? _resolve(process.cwd(), '.studio');
-      const destDir = _resolve(studioDir, 'projects', templateName);
-      await createSyntheticTemplate(destDir, templateName);
-    }),
-  };
-});
-
-// Use /tmp as base to avoid interference from the Studio repo's own .studio/
-const TMP = resolve('/tmp', '.studio-init-test');
-
-beforeEach(async () => {
-  // Clean up any stale /tmp/.studio left by worktree tests — findStudioDir would find it
-  // walking up from TMP and incorrectly report "already initialized"
-  await rm('/tmp/.studio', { recursive: true, force: true });
-  await mkdir(TMP, { 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('createStudioStructure', () => {
-  it('creates .studio/ directory structure', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-
-    expect(await exists(resolve(TMP, '.studio'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'config.yaml'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'pipelines'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'agents'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'contracts'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'tools'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'inputs'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'runs', 'logs'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'registry.lock.json'))).toBe(true);
-  });
-
-  it('adds .studio/config.yaml, .studio/runs/, and *.keymap.json to .gitignore', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-
-    const gitignore = await readFile(resolve(TMP, '.gitignore'), 'utf-8');
-    expect(gitignore).toContain('.studio/config.yaml');
-    expect(gitignore).toContain('.studio/runs/');
-    expect(gitignore).toContain('*.keymap.json');
-  });
-
-  it('appends to existing .gitignore without duplicating', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    const gitignorePath = resolve(TMP, '.gitignore');
-    await writeFile(gitignorePath, 'node_modules/\n.studio/config.yaml\n');
-
-    await createStudioStructure(TMP);
-
-    const content = await readFile(gitignorePath, 'utf-8');
-    const lines = content.split('\n').filter((l) => l.trim() === '.studio/config.yaml');
-    expect(lines.length).toBe(1); // no duplicate
-  });
-
-  it('creates flat structure (no projects/ subdir) when templateName is provided', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP, 'software');
-
-    expect(await exists(resolve(TMP, '.studio', 'pipelines'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'agents'))).toBe(true);
-  });
-
-  it('writes empty registry.lock.json', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-
-    const content = await readFile(resolve(TMP, '.studio', 'registry.lock.json'), 'utf-8');
-    expect(JSON.parse(content)).toEqual({ installed: {} });
-  });
-});
-
-describe('initCommand already initialized', () => {
-  it('throws when .studio/ already exists', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    // First init
-    await createStudioStructure(TMP);
-    // Second init should throw
-    await expect(createStudioStructure(TMP)).rejects.toThrow('already initialized');
-  });
-
-  it('error message includes path to the found .studio/', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-    try {
-      await createStudioStructure(TMP);
-      expect.fail('should have thrown');
-    } catch (err) {
-      expect(err instanceof Error && err.message).toContain('.studio');
-    }
-  });
-});
-
-describe('createStudioStructure with templates', () => {
-  it('copies template project files when templateName is software', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP, 'software');
-
-    expect(await exists(resolve(TMP, '.studio', 'pipelines', 'feature-builder.pipeline.yaml'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'agents', 'coder.agent.yaml'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'contracts', 'code-output.contract.yaml'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'tools', 'repo-manager.tool.yaml'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'inputs', 'example.input.yaml'))).toBe(true);
-  });
-
-  it('creates empty dirs for blank template (no project/ subdir)', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP, 'blank');
-
-    expect(await exists(resolve(TMP, '.studio', 'pipelines'))).toBe(true);
-    const { readdir } = await import('node:fs/promises');
-    const entries = await readdir(resolve(TMP, '.studio', 'pipelines'));
-    expect(entries).toEqual([]);
-  });
-
-  it('throws with helpful message when template does not exist', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await expect(createStudioStructure(TMP, 'xyz')).rejects.toThrow(
-      "Template 'xyz' not found"
-    );
-  });
-
-  it('error message mentions studio templates list', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    try {
-      await createStudioStructure(TMP, 'xyz');
-      expect.fail('should have thrown');
-    } catch (err) {
-      expect(err instanceof Error && err.message).toContain('studio templates list');
-    }
-  });
-
-  it('flat structure: template files copied directly into .studio/', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP, 'software');
-
-    expect(await exists(resolve(TMP, '.studio', 'pipelines', 'feature-builder.pipeline.yaml'))).toBe(true);
-  });
-});
-
-describe('validateApiKeyFormat', () => {
-  it('accepts a valid Anthropic key', async () => {
-    const { validateApiKeyFormat } = await import('../../src/commands/init.js');
-    expect(validateApiKeyFormat('anthropic', 'sk-ant-api03-abc123')).toBe(true);
-  });
-
-  it('rejects an Anthropic key with wrong prefix', async () => {
-    const { validateApiKeyFormat } = await import('../../src/commands/init.js');
-    const result = validateApiKeyFormat('anthropic', 'sk-wrong-key');
-    expect(typeof result).toBe('string'); // returns error message
-    expect(result).toContain('sk-ant-');
-  });
-
-  it('accepts a valid OpenAI key', async () => {
-    const { validateApiKeyFormat } = await import('../../src/commands/init.js');
-    expect(validateApiKeyFormat('openai', 'sk-proj-abc123')).toBe(true);
-  });
-
-  it('rejects an OpenAI key with wrong prefix', async () => {
-    const { validateApiKeyFormat } = await import('../../src/commands/init.js');
-    const result = validateApiKeyFormat('openai', 'wrong-key');
-    expect(typeof result).toBe('string');
-    expect(result).toContain('sk-');
-  });
-
-  it('accepts any key for unknown provider', async () => {
-    const { validateApiKeyFormat } = await import('../../src/commands/init.js');
-    expect(validateApiKeyFormat('later', '')).toBe(true);
-  });
-});
-
-describe('backupStudioDir', () => {
-  it('moves .studio/ to a backup directory', async () => {
-    const { createStudioStructure, backupStudioDir } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-
-    const backupPath = await backupStudioDir(TMP);
-
-    // Original .studio/ is gone
-    expect(await exists(resolve(TMP, '.studio'))).toBe(false);
-    // Backup dir exists
-    expect(await exists(backupPath)).toBe(true);
-  });
-
-  it('backup directory name starts with .studio.backup-', async () => {
-    const { createStudioStructure, backupStudioDir } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-
-    const backupPath = await backupStudioDir(TMP);
-    const backupName = backupPath.split('/').at(-1)!;
-
-    expect(backupName).toMatch(/^\.studio\.backup-\d{4}-\d{2}-\d{2}-\d{2}h\d{2}m\d{2}s$/);
-  });
-
-  it('backup preserves files from original .studio/', async () => {
-    const { createStudioStructure, backupStudioDir } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-
-    const backupPath = await backupStudioDir(TMP);
-
-    expect(await exists(resolve(backupPath, 'config.yaml'))).toBe(true);
-    expect(await exists(resolve(backupPath, 'registry.lock.json'))).toBe(true);
-  });
-
-  it('throws if .studio/ does not exist', async () => {
-    const { backupStudioDir } = await import('../../src/commands/init.js');
-    await expect(backupStudioDir(TMP)).rejects.toThrow();
-  });
-});
-
-describe('directInit', () => {
-  it('creates structure and writes provider config', async () => {
-    const { directInit } = await import('../../src/commands/init.js');
-    await directInit(TMP, 'software', 'anthropic', 'sk-ant-test-key');
-
-    expect(await exists(resolve(TMP, '.studio', 'pipelines', 'feature-builder.pipeline.yaml'))).toBe(true);
-
-    const raw = await readFile(resolve(TMP, '.studio', 'config.yaml'), 'utf-8');
-    const parsed = yaml.load(raw) as Record<string, unknown>;
-    const providers = parsed.providers as Record<string, { apiKey: string }>;
-    expect(providers.anthropic.apiKey).toBe('sk-ant-test-key');
-  });
-
-  it('skips writing config when provider is "later"', async () => {
-    const { directInit } = await import('../../src/commands/init.js');
-    await directInit(TMP, 'software', 'later', '');
-
-    expect(await exists(resolve(TMP, '.studio'))).toBe(true);
-    // Config.yaml exists (from template) but has no providers key written by directInit
-    const raw = await readFile(resolve(TMP, '.studio', 'config.yaml'), 'utf-8');
-    // The template config.yaml has anthropic placeholder but no actual key
-    expect(raw).not.toContain('sk-ant-');
-  });
-
-  it('throws when template does not exist', async () => {
-    const { directInit } = await import('../../src/commands/init.js');
-    await expect(
-      directInit(TMP, 'nonexistent', 'anthropic', 'sk-ant-key')
-    ).rejects.toThrow("Template 'nonexistent' not found");
-  });
-
-  it('throws when .studio/ already exists', async () => {
-    const { directInit } = await import('../../src/commands/init.js');
-    await directInit(TMP, 'software', 'anthropic', 'sk-ant-key');
-    await expect(
-      directInit(TMP, 'software', 'anthropic', 'sk-ant-key')
-    ).rejects.toThrow('already initialized');
-  });
-
-  it('works with force: backup then directInit succeeds', async () => {
-    const { directInit, backupStudioDir } = await import('../../src/commands/init.js');
-    // First init
-    await directInit(TMP, 'software', 'anthropic', 'sk-ant-first');
-    // Backup + reinit
-    await backupStudioDir(TMP);
-    await directInit(TMP, 'software', 'anthropic', 'sk-ant-second');
-
-    const raw = await readFile(resolve(TMP, '.studio', 'config.yaml'), 'utf-8');
-    const parsed = yaml.load(raw) as Record<string, unknown>;
-    const providers = parsed.providers as Record<string, { apiKey: string }>;
-    expect(providers.anthropic.apiKey).toBe('sk-ant-second');
-  });
-
-  it('writes ollama config when provider is ollama (no api key needed)', async () => {
-    const { directInit } = await import('../../src/commands/init.js');
-    await directInit(TMP, 'software', 'ollama', '');
-    const studioDir = resolve(TMP, '.studio');
-    const raw = await readFile(resolve(studioDir, 'config.yaml'), 'utf-8');
-    const parsed = yaml.load(raw) as Record<string, unknown>;
-    const providers = parsed.providers as Record<string, unknown>;
-    expect(providers.ollama).toEqual({});
-    const defaults = parsed.defaults as { provider: string; model: string };
-    expect(defaults.provider).toBe('ollama');
-    expect(defaults.model).toBe('llama3.3');
-  });
-});
-
-describe('createStudioStructure with withTools: false', () => {
-  it('does not copy tool files from template', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP, 'software', false);
-
-    const toolsDir = resolve(TMP, '.studio', 'tools');
-    expect(await exists(toolsDir)).toBe(true);
-
-    const { readdir } = await import('node:fs/promises');
-    const toolFiles = await readdir(toolsDir);
-    expect(toolFiles).toEqual([]);
-  });
-
-  it('still copies other template files when withTools is false', async () => {
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP, 'software', false);
-
-    expect(await exists(resolve(TMP, '.studio', 'pipelines', 'feature-builder.pipeline.yaml'))).toBe(true);
-    expect(await exists(resolve(TMP, '.studio', 'agents', 'coder.agent.yaml'))).toBe(true);
-  });
-});
-
-describe('directInit with provider=ollama (no apiKey)', () => {
-  it('writes empty providers.ollama config without requiring an apiKey', async () => {
-    const { directInit } = await import('../../src/commands/init.js');
-    await directInit(TMP, 'software', 'ollama', '');
-
-    const raw = await readFile(resolve(TMP, '.studio', 'config.yaml'), 'utf-8');
-    const parsed = yaml.load(raw) as Record<string, unknown>;
-    const providers = parsed.providers as Record<string, unknown>;
-    expect(providers['ollama']).toEqual({});
-  });
-});
-
-describe('directInit with noTools: true', () => {
-  it('creates project without copying tool files', async () => {
-    const { directInit } = await import('../../src/commands/init.js');
-    await directInit(TMP, 'software', 'anthropic', 'sk-ant-key', true);
-
-    const toolsDir = resolve(TMP, '.studio', 'tools');
-    expect(await exists(toolsDir)).toBe(true);
-
-    const { readdir } = await import('node:fs/promises');
-    const toolFiles = await readdir(toolsDir);
-    expect(toolFiles).toEqual([]);
-  });
-
-  it('still creates config.yaml when noTools is true', async () => {
-    const { directInit } = await import('../../src/commands/init.js');
-    await directInit(TMP, 'software', 'anthropic', 'sk-ant-key', true);
-
-    expect(await exists(resolve(TMP, '.studio', 'config.yaml'))).toBe(true);
-  });
-});
-
-describe('writeProviderToConfig', () => {
-  // We need a fresh .studio/ for each test — reuse the outer TMP/beforeEach/afterEach.
-
-  it('writes anthropic key and defaults to config.yaml', async () => {
-    const { createStudioStructure, writeProviderToConfig } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-
-    const studioDir = resolve(TMP, '.studio');
-    await writeProviderToConfig(studioDir, 'anthropic', { apiKey: 'sk-ant-test-key' });
-
-    const raw = await readFile(resolve(studioDir, 'config.yaml'), 'utf-8');
-    const parsed = yaml.load(raw) as Record<string, unknown>;
-
-    const providers = parsed.providers as Record<string, { apiKey: string }>;
-    expect(providers.anthropic.apiKey).toBe('sk-ant-test-key');
-
-    const defaults = parsed.defaults as { provider: string; model: string };
-    expect(defaults.provider).toBe('anthropic');
-    expect(defaults.model).toBe('claude-sonnet-4-20250514');
-  });
-
-  it('writes openai key and defaults to config.yaml', async () => {
-    const { createStudioStructure, writeProviderToConfig } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-
-    const studioDir = resolve(TMP, '.studio');
-    await writeProviderToConfig(studioDir, 'openai', { apiKey: 'sk-openai-test-key' });
-
-    const raw = await readFile(resolve(studioDir, 'config.yaml'), 'utf-8');
-    const parsed = yaml.load(raw) as Record<string, unknown>;
-
-    const providers = parsed.providers as Record<string, { apiKey: string }>;
-    expect(providers.openai.apiKey).toBe('sk-openai-test-key');
-
-    const defaults = parsed.defaults as { provider: string; model: string };
-    expect(defaults.provider).toBe('openai');
-    expect(defaults.model).toBe('gpt-4o');
-  });
-
-  it('is idempotent — writing twice does not duplicate keys', async () => {
-    const { createStudioStructure, writeProviderToConfig } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-
-    const studioDir = resolve(TMP, '.studio');
-    await writeProviderToConfig(studioDir, 'anthropic', { apiKey: 'sk-ant-first' });
-    await writeProviderToConfig(studioDir, 'anthropic', { apiKey: 'sk-ant-second' });
-
-    const raw = await readFile(resolve(studioDir, 'config.yaml'), 'utf-8');
-    const parsed = yaml.load(raw) as Record<string, unknown>;
-    const providers = parsed.providers as Record<string, { apiKey: string }>;
-    expect(providers.anthropic.apiKey).toBe('sk-ant-second');
-  });
-
-  it('writes ollama config with empty credentials and llama3.3 default model', async () => {
-    const { createStudioStructure, writeProviderToConfig } = await import('../../src/commands/init.js');
-    await createStudioStructure(TMP);
-    const studioDir = resolve(TMP, '.studio');
-    await writeProviderToConfig(studioDir, 'ollama', {});
-
-    const raw = await readFile(resolve(studioDir, 'config.yaml'), 'utf-8');
-    const parsed = yaml.load(raw) as Record<string, unknown>;
-    const providers = parsed.providers as Record<string, unknown>;
-    expect(providers.ollama).toEqual({});
-    expect(providers.ollama).not.toHaveProperty('apiKey');
-    const defaults = parsed.defaults as { provider: string; model: string };
-    expect(defaults.provider).toBe('ollama');
-    expect(defaults.model).toBe('llama3.3');
-  });
-});
-
-// Helper: create a synthetic template directory with the files generateAppFiles needs.
-// Used by generateAppFiles tests since the bundled project templates were removed
-// (they now live in the community registry).
-async function createSyntheticTemplateDir(dir: string): Promise<void> {
-  await mkdir(resolve(dir, 'src'), { recursive: true });
-  await mkdir(resolve(dir, 'prisma'), { recursive: true });
-  await writeFile(resolve(dir, 'src', 'index.ts'), '// {{PROJECT_NAME}}\nexport {};\n', 'utf-8');
-  await writeFile(resolve(dir, 'prisma', 'schema.prisma'), '// prisma schema\n', 'utf-8');
-  await writeFile(
-    resolve(dir, 'package.json'),
-    JSON.stringify({ name: '{{PROJECT_NAME}}', version: '0.0.1' }, null, 2) + '\n',
-    'utf-8'
-  );
-  await writeFile(resolve(dir, 'README.md'), '# {{PROJECT_NAME}}\n\nTemplate: {{TEMPLATE_NAME}}\n', 'utf-8');
-}
-
-describe('generateAppFiles', () => {
-  it('copies src/ with placeholder replacement', async () => {
-    const { generateAppFiles } = await import('../../src/commands/init.js');
-    const templateDir = resolve(TMP, '_template');
-    await createSyntheticTemplateDir(templateDir);
-
-    await generateAppFiles(templateDir, TMP, {
-      PROJECT_NAME: 'my-app',
-      TEMPLATE_NAME: 'software',
-      YEAR: '2026',
-    });
-
-    const srcIndex = await readFile(resolve(TMP, 'src', 'index.ts'), 'utf-8');
-    expect(srcIndex).toContain('my-app');
-    expect(srcIndex).not.toContain('{{PROJECT_NAME}}');
-  });
-
-  it('copies package.json with placeholder replacement', async () => {
-    const { generateAppFiles } = await import('../../src/commands/init.js');
-    const templateDir = resolve(TMP, '_template');
-    await createSyntheticTemplateDir(templateDir);
-
-    await generateAppFiles(templateDir, TMP, {
-      PROJECT_NAME: 'cool-project',
-      TEMPLATE_NAME: 'software',
-      YEAR: '2026',
-    });
-
-    const pkg = JSON.parse(await readFile(resolve(TMP, 'package.json'), 'utf-8'));
-    expect(pkg.name).toBe('cool-project');
-  });
-
-  it('copies README.md with placeholder replacement', async () => {
-    const { generateAppFiles } = await import('../../src/commands/init.js');
-    const templateDir = resolve(TMP, '_template');
-    await createSyntheticTemplateDir(templateDir);
-
-    await generateAppFiles(templateDir, TMP, {
-      PROJECT_NAME: 'my-app',
-      TEMPLATE_NAME: 'software',
-      YEAR: '2026',
-    });
-
-    const readme = await readFile(resolve(TMP, 'README.md'), 'utf-8');
-    expect(readme).toContain('my-app');
-    expect(readme).toContain('software');
-    expect(readme).not.toContain('{{PROJECT_NAME}}');
-  });
-
-  it('copies prisma/schema.prisma', async () => {
-    const { generateAppFiles } = await import('../../src/commands/init.js');
-    const templateDir = resolve(TMP, '_template');
-    await createSyntheticTemplateDir(templateDir);
-
-    await generateAppFiles(templateDir, TMP, {
-      PROJECT_NAME: 'my-app',
-      TEMPLATE_NAME: 'software',
-      YEAR: '2026',
-    });
-
-    expect(await exists(resolve(TMP, 'prisma', 'schema.prisma'))).toBe(true);
-  });
-
-  it('skips items not present in template (blank template has no src/)', async () => {
-    const { generateAppFiles } = await import('../../src/commands/init.js');
-    // Use an empty template dir (no src/, no package.json, etc.)
-    const templateDir = resolve(TMP, '_blank_template');
-    await mkdir(templateDir, { recursive: true });
-
-    await expect(
-      generateAppFiles(templateDir, TMP, {
-        PROJECT_NAME: 'x',
-        TEMPLATE_NAME: 'blank',
-        YEAR: '2026',
-      })
-    ).resolves.not.toThrow();
-
-    // blank template has no src/ so it should not be created
-    expect(await exists(resolve(TMP, 'src'))).toBe(false);
-  });
-
-  it('returns list of generated top-level items', async () => {
-    const { generateAppFiles } = await import('../../src/commands/init.js');
-    const templateDir = resolve(TMP, '_template');
-    await createSyntheticTemplateDir(templateDir);
-
-    const generated = await generateAppFiles(templateDir, TMP, {
-      PROJECT_NAME: 'my-app',
-      TEMPLATE_NAME: 'software',
-      YEAR: '2026',
-    });
-
-    expect(generated).toContain('package.json');
-    expect(generated).toContain('README.md');
-    expect(generated).toContain('src/');    // directories have trailing slash
-    expect(generated).toContain('prisma/'); // directories have trailing slash
-  });
-});
-
-describe('initGitRepo', () => {
-  it('creates a .git/ directory in cwd', async () => {
-    const { initGitRepo } = await import('../../src/commands/init.js');
-    await initGitRepo(TMP);
-    expect(await exists(resolve(TMP, '.git'))).toBe(true);
-  });
-
-  it('returns true when it initializes git', async () => {
-    const { initGitRepo } = await import('../../src/commands/init.js');
-    const result = await initGitRepo(TMP);
-    expect(result).toBe(true);
-  });
-
-  it('returns false (skips) when .git/ already exists', async () => {
-    const { initGitRepo } = await import('../../src/commands/init.js');
-    await initGitRepo(TMP);
-    const result = await initGitRepo(TMP);
-    expect(result).toBe(false);
-  });
-});
-
-describe('generateFullApp', () => {
-  it('creates .studio/ AND src/ AND package.json AND README.md', async () => {
-    const { generateFullApp } = await import('../../src/commands/init.js');
-    await generateFullApp(TMP, 'my-app', 'software');
-
-    expect(await exists(resolve(TMP, '.studio', 'pipelines'))).toBe(true);
-    expect(await exists(resolve(TMP, 'src', 'index.ts'))).toBe(true);
-    expect(await exists(resolve(TMP, 'package.json'))).toBe(true);
-    expect(await exists(resolve(TMP, 'README.md'))).toBe(true);
-    expect(await exists(resolve(TMP, 'prisma', 'schema.prisma'))).toBe(true);
-  });
-
-  it('applies PROJECT_NAME placeholder in package.json', async () => {
-    const { generateFullApp } = await import('../../src/commands/init.js');
-    await generateFullApp(TMP, 'cool-app', 'software');
-
-    const pkg = JSON.parse(await readFile(resolve(TMP, 'package.json'), 'utf-8'));
-    expect(pkg.name).toBe('cool-app');
-  });
-
-  it('initializes a git repository', async () => {
-    const { generateFullApp } = await import('../../src/commands/init.js');
-    const result = await generateFullApp(TMP, 'my-app', 'software');
-    expect(result.gitInitialized).toBe(true);
-    expect(await exists(resolve(TMP, '.git'))).toBe(true);
-  });
-
-  it('throws when template does not exist', async () => {
-    const { generateFullApp } = await import('../../src/commands/init.js');
-    await expect(generateFullApp(TMP, 'my-app', 'nonexistent-template')).rejects.toThrow();
-  });
-
-  it('skips git init when skipGit option is true', async () => {
-    const { generateFullApp } = await import('../../src/commands/init.js');
-    const result = await generateFullApp(TMP, 'my-app', 'software', { skipGit: true });
-    expect(result.gitInitialized).toBe(false);
-    expect(await exists(resolve(TMP, '.git'))).toBe(false);
-    expect(await exists(resolve(TMP, '.studio'))).toBe(true);
-  });
-});
-
-describe('validateProjectName', () => {
-  it('accepts valid names', async () => {
-    const { validateProjectName } = await import('../../src/commands/init.js');
-    expect(validateProjectName('my-app')).toBe(true);
-    expect(validateProjectName('my_project')).toBe(true);
-    expect(validateProjectName('MyApp123')).toBe(true);
-    expect(validateProjectName('app.v2')).toBe(true);
-  });
-
-  it('rejects empty string', async () => {
-    const { validateProjectName } = await import('../../src/commands/init.js');
-    expect(validateProjectName('')).toBeTypeOf('string');
-  });
-
-  it('rejects names with spaces or tabs', async () => {
-    const { validateProjectName } = await import('../../src/commands/init.js');
-    expect(validateProjectName('my app')).toBeTypeOf('string');
-    expect(validateProjectName('my\tapp')).toBeTypeOf('string');
-  });
-
-  it('rejects names starting with a hyphen', async () => {
-    const { validateProjectName } = await import('../../src/commands/init.js');
-    const result = validateProjectName('-bad');
-    expect(result).toBeTypeOf('string');
-    expect(result as string).toContain('letter or digit');
-  });
-
-  it('rejects names with special characters', async () => {
-    const { validateProjectName } = await import('../../src/commands/init.js');
-    expect(validateProjectName('my@app')).toBeTypeOf('string');
-    expect(validateProjectName('app!')).toBeTypeOf('string');
-    expect(validateProjectName('app/dir')).toBeTypeOf('string');
-  });
-
-  it('rejects whitespace-only names', async () => {
-    const { validateProjectName } = await import('../../src/commands/init.js');
-    expect(validateProjectName('   ')).toBeTypeOf('string');
-  });
-
-  it('rejects names starting with a dot', async () => {
-    const { validateProjectName } = await import('../../src/commands/init.js');
-    expect(validateProjectName('.hidden')).toBeTypeOf('string');
-  });
-});
-
-describe('detectOllamaInstalled', () => {
-  let spawnSyncMock: ReturnType<typeof vi.fn>;
-
-  beforeEach(async () => {
-    const childProcess = await import('node:child_process');
-    spawnSyncMock = vi.mocked(childProcess.spawnSync);
-    spawnSyncMock.mockReset(); // clear any mockReturnValue from previous test
-  });
-
-  it('returns true when ollama --version exits 0', async () => {
-    spawnSyncMock.mockReturnValue({ status: 0 });
-    const { detectOllamaInstalled } = await import('../../src/commands/init.js');
-    expect(detectOllamaInstalled()).toBe(true);
-  });
-
-  it('returns false when ollama --version exits non-zero', async () => {
-    spawnSyncMock.mockReturnValue({ status: 1 });
-    const { detectOllamaInstalled } = await import('../../src/commands/init.js');
-    expect(detectOllamaInstalled()).toBe(false);
-  });
-
-  it('returns false when ollama is not found (status null)', async () => {
-    spawnSyncMock.mockReturnValue({ status: null });
-    const { detectOllamaInstalled } = await import('../../src/commands/init.js');
-    expect(detectOllamaInstalled()).toBe(false);
-  });
-});
-
-describe('hasAdequateRam', () => {
-  let totalMemMock: ReturnType<typeof vi.fn>;
-
-  beforeEach(async () => {
-    const os = await import('node:os');
-    totalMemMock = vi.mocked(os.totalmem);
-    totalMemMock.mockReset(); // clear any mockReturnValue from previous test
-  });
-
-  afterEach(() => {
-    totalMemMock.mockReturnValue(32 * 1024 ** 3); // restore default so later describe blocks aren't affected
-  });
-
-  it('returns true when RAM >= 16GB', async () => {
-    totalMemMock.mockReturnValue(16 * 1024 ** 3);
-    const { hasAdequateRam } = await import('../../src/commands/init.js');
-    expect(hasAdequateRam()).toBe(true);
-  });
-
-  it('returns true when RAM > 16GB', async () => {
-    totalMemMock.mockReturnValue(32 * 1024 ** 3);
-    const { hasAdequateRam } = await import('../../src/commands/init.js');
-    expect(hasAdequateRam()).toBe(true);
-  });
-
-  it('returns false when RAM < 16GB', async () => {
-    totalMemMock.mockReturnValue(8 * 1024 ** 3);
-    const { hasAdequateRam } = await import('../../src/commands/init.js');
-    expect(hasAdequateRam()).toBe(false);
-  });
-
-  it('returns false when os.totalmem throws', async () => {
-    totalMemMock.mockImplementation(() => { throw new Error('no access'); });
-    const { hasAdequateRam } = await import('../../src/commands/init.js');
-    expect(hasAdequateRam()).toBe(false);
-  });
-});
-
-describe('generateFullApp (registry-backed)', () => {
-  it('calls installPackage when template is specified', async () => {
-    // Mock installPackage so it doesn't hit the network, and verify it is called
-    const installPackageMock = vi.fn().mockResolvedValue(undefined);
-    vi.doMock('../../src/commands/registry/install.js', () => ({
-      installPackage: installPackageMock,
-    }));
-    vi.resetModules();
-
-    const { createStudioStructure } = await import('../../src/commands/init.js');
-    // Verify createStudioStructure still works (the basic init path, which doesn't call installPackage)
-    await createStudioStructure(TMP);
-    expect(await exists(resolve(TMP, '.studio'))).toBe(true);
-
-    vi.doUnmock('../../src/commands/registry/install.js');
-    vi.resetModules();
-  });
-
-  it('uses installed template dir (.studio/projects/<name>/) for app scaffold', async () => {
-    // This test verifies the new flow: installPackage is called and scaffold is read
-    // from the installed location, not from local bundled templates.
-    const installPackageMock = vi.fn().mockResolvedValue(undefined);
-    vi.doMock('../../src/commands/registry/install.js', () => ({
-      installPackage: installPackageMock,
-    }));
-    vi.resetModules();
-
-    // Set up a fake installed template directory before calling generateFullApp
-    const studioDir = resolve(TMP, '.studio');
-    const installedTemplateDir = resolve(studioDir, 'projects', 'software');
-    await mkdir(installedTemplateDir, { recursive: true });
-    // Write a minimal package.json so generateAppFiles has something to copy
-    await writeFile(
-      resolve(installedTemplateDir, 'package.json'),
-      JSON.stringify({ name: '{{PROJECT_NAME}}', version: '0.0.1' }),
-      'utf-8'
-    );
-
-    // Also seed local .studio/ structure that createStudioStructure expects
-    // (createStudioStructure will throw "already initialized" if .studio already exists,
-    //  so we skip that by noting this test pre-creates .studio; use generateAppFiles directly)
-    const { generateAppFiles } = await import('../../src/commands/init.js');
-    const generated = await generateAppFiles(installedTemplateDir, TMP, {
-      PROJECT_NAME: 'registry-app',
-      TEMPLATE_NAME: 'software',
-      YEAR: '2026',
-    });
-
-    const pkg = JSON.parse(await readFile(resolve(TMP, 'package.json'), 'utf-8'));
-    expect(pkg.name).toBe('registry-app');
-    expect(generated).toContain('package.json');
-
-    vi.doUnmock('../../src/commands/registry/install.js');
-    vi.resetModules();
-  });
-});
-
-describe('detectHardware', () => {
-  it('returns totalRamGb as a positive number', async () => {
-    const { detectHardware } = await import('../../src/commands/init.js');
-    const hw = detectHardware();
-    expect(hw.totalRamGb).toBeGreaterThan(0);
-  });
-
-  it('returns all expected fields', async () => {
-    const { detectHardware } = await import('../../src/commands/init.js');
-    const hw = detectHardware();
-    expect(typeof hw.hasDocker).toBe('boolean');
-    expect(typeof hw.hasNativeOllama).toBe('boolean');
-    expect(typeof hw.ollamaAvailable).toBe('boolean');
-    expect(hw.ollamaAvailable).toBe(hw.hasDocker || hw.hasNativeOllama);
-  });
-});
-
-describe('writeProviderToConfig — ollama (no apiKey)', () => {
-  it('writes empty providers.ollama object when apiKey is undefined', async () => {
-    const { writeProviderToConfig } = await import('../../src/commands/init.js');
-    const studioDir = resolve(TMP, '.studio');
-    await mkdir(studioDir, { recursive: true });
-
-    await writeProviderToConfig(studioDir, 'ollama', undefined, 'llama3.3');
-
-    const raw = await readFile(resolve(studioDir, 'config.yaml'), 'utf-8');
-    const parsed = yaml.load(raw) as Record<string, unknown>;
-    const providers = parsed.providers as Record<string, unknown>;
-    expect(providers['ollama']).toEqual({});
-    const defaults = parsed.defaults as Record<string, unknown>;
-    expect(defaults['provider']).toBe('ollama');
-    expect(defaults['model']).toBe('llama3.3');
-  });
-});
-
-describe('detectHardware with mocks', () => {
-  it('returns ollamaAvailable=true when docker reports success', async () => {
-    // spawnSync is mocked at module level — configure it
-    const cp = await import('node:child_process');
-    vi.mocked(cp.spawnSync).mockReturnValue({ status: 0 } as ReturnType<typeof cp.spawnSync>);
-    const os = await import('node:os');
-    vi.mocked(os.totalmem).mockReturnValue(16 * 1024 ** 3);
-
-    const { detectHardware } = await import('../../src/commands/init.js');
-    const hw = detectHardware();
-    expect(hw.hasDocker).toBe(true);
-    expect(hw.ollamaAvailable).toBe(true);
-  });
-
-  it('returns ollamaAvailable=false when neither docker nor ollama present', async () => {
-    const cp = await import('node:child_process');
-    vi.mocked(cp.spawnSync).mockReturnValue({ status: 1 } as ReturnType<typeof cp.spawnSync>);
-    const os = await import('node:os');
-    vi.mocked(os.totalmem).mockReturnValue(8 * 1024 ** 3);
-
-    const { detectHardware } = await import('../../src/commands/init.js');
-    const hw = detectHardware();
-    expect(hw.hasDocker).toBe(false);
-    expect(hw.hasNativeOllama).toBe(false);
-    expect(hw.ollamaAvailable).toBe(false);
-  });
-
-  it('returns totalRamGb correctly from os.totalmem()', async () => {
-    const os = await import('node:os');
-    vi.mocked(os.totalmem).mockReturnValue(32 * 1024 ** 3);
-
-    const { detectHardware } = await import('../../src/commands/init.js');
-    const hw = detectHardware();
-    expect(hw.totalRamGb).toBeCloseTo(32, 0);
-  });
-});