openspecui 0.0.0 → 0.2.0

package/references/openspec/src/core/view.ts

@@ -1,189 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import chalk from 'chalk';
-import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progress.js';
-import { MarkdownParser } from './parsers/markdown-parser.js';
-
-export class ViewCommand {
-  async execute(targetPath: string = '.'): Promise<void> {
-    const openspecDir = path.join(targetPath, 'openspec');
-    
-    if (!fs.existsSync(openspecDir)) {
-      console.error(chalk.red('No openspec directory found'));
-      process.exit(1);
-    }
-
-    console.log(chalk.bold('\nOpenSpec Dashboard\n'));
-    console.log('═'.repeat(60));
-
-    // Get changes and specs data
-    const changesData = await this.getChangesData(openspecDir);
-    const specsData = await this.getSpecsData(openspecDir);
-
-    // Display summary metrics
-    this.displaySummary(changesData, specsData);
-
-    // Display active changes
-    if (changesData.active.length > 0) {
-      console.log(chalk.bold.cyan('\nActive Changes'));
-      console.log('─'.repeat(60));
-      changesData.active.forEach(change => {
-        const progressBar = this.createProgressBar(change.progress.completed, change.progress.total);
-        const percentage = change.progress.total > 0 
-          ? Math.round((change.progress.completed / change.progress.total) * 100)
-          : 0;
-        
-        console.log(
-          `  ${chalk.yellow('◉')} ${chalk.bold(change.name.padEnd(30))} ${progressBar} ${chalk.dim(`${percentage}%`)}`
-        );
-      });
-    }
-
-    // Display completed changes
-    if (changesData.completed.length > 0) {
-      console.log(chalk.bold.green('\nCompleted Changes'));
-      console.log('─'.repeat(60));
-      changesData.completed.forEach(change => {
-        console.log(`  ${chalk.green('✓')} ${change.name}`);
-      });
-    }
-
-    // Display specifications
-    if (specsData.length > 0) {
-      console.log(chalk.bold.blue('\nSpecifications'));
-      console.log('─'.repeat(60));
-      
-      // Sort specs by requirement count (descending)
-      specsData.sort((a, b) => b.requirementCount - a.requirementCount);
-      
-      specsData.forEach(spec => {
-        const reqLabel = spec.requirementCount === 1 ? 'requirement' : 'requirements';
-        console.log(
-          `  ${chalk.blue('▪')} ${chalk.bold(spec.name.padEnd(30))} ${chalk.dim(`${spec.requirementCount} ${reqLabel}`)}`
-        );
-      });
-    }
-
-    console.log('\n' + '═'.repeat(60));
-    console.log(chalk.dim(`\nUse ${chalk.white('openspec list --changes')} or ${chalk.white('openspec list --specs')} for detailed views`));
-  }
-
-  private async getChangesData(openspecDir: string): Promise<{
-    active: Array<{ name: string; progress: { total: number; completed: number } }>;
-    completed: Array<{ name: string }>;
-  }> {
-    const changesDir = path.join(openspecDir, 'changes');
-    
-    if (!fs.existsSync(changesDir)) {
-      return { active: [], completed: [] };
-    }
-
-    const active: Array<{ name: string; progress: { total: number; completed: number } }> = [];
-    const completed: Array<{ name: string }> = [];
-
-    const entries = fs.readdirSync(changesDir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      if (entry.isDirectory() && entry.name !== 'archive') {
-        const progress = await getTaskProgressForChange(changesDir, entry.name);
-        
-        if (progress.total === 0 || progress.completed === progress.total) {
-          completed.push({ name: entry.name });
-        } else {
-          active.push({ name: entry.name, progress });
-        }
-      }
-    }
-
-    // Sort active changes by completion percentage (ascending) and then by name for deterministic ordering
-    active.sort((a, b) => {
-      const percentageA = a.progress.total > 0 ? a.progress.completed / a.progress.total : 0;
-      const percentageB = b.progress.total > 0 ? b.progress.completed / b.progress.total : 0;
-
-      if (percentageA < percentageB) return -1;
-      if (percentageA > percentageB) return 1;
-      return a.name.localeCompare(b.name);
-    });
-    completed.sort((a, b) => a.name.localeCompare(b.name));
-
-    return { active, completed };
-  }
-
-  private async getSpecsData(openspecDir: string): Promise<Array<{ name: string; requirementCount: number }>> {
-    const specsDir = path.join(openspecDir, 'specs');
-    
-    if (!fs.existsSync(specsDir)) {
-      return [];
-    }
-
-    const specs: Array<{ name: string; requirementCount: number }> = [];
-    const entries = fs.readdirSync(specsDir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const specFile = path.join(specsDir, entry.name, 'spec.md');
-        
-        if (fs.existsSync(specFile)) {
-          try {
-            const content = fs.readFileSync(specFile, 'utf-8');
-            const parser = new MarkdownParser(content);
-            const spec = parser.parseSpec(entry.name);
-            const requirementCount = spec.requirements.length;
-            specs.push({ name: entry.name, requirementCount });
-          } catch (error) {
-            // If spec cannot be parsed, include with 0 count
-            specs.push({ name: entry.name, requirementCount: 0 });
-          }
-        }
-      }
-    }
-
-    return specs;
-  }
-
-  private displaySummary(
-    changesData: { active: any[]; completed: any[] },
-    specsData: any[]
-  ): void {
-    const totalChanges = changesData.active.length + changesData.completed.length;
-    const totalSpecs = specsData.length;
-    const totalRequirements = specsData.reduce((sum, spec) => sum + spec.requirementCount, 0);
-    
-    // Calculate total task progress
-    let totalTasks = 0;
-    let completedTasks = 0;
-    
-    changesData.active.forEach(change => {
-      totalTasks += change.progress.total;
-      completedTasks += change.progress.completed;
-    });
-    
-    changesData.completed.forEach(() => {
-      // Completed changes count as 100% done (we don't know exact task count)
-      // This is a simplification
-    });
-
-    console.log(chalk.bold('Summary:'));
-    console.log(`  ${chalk.cyan('●')} Specifications: ${chalk.bold(totalSpecs)} specs, ${chalk.bold(totalRequirements)} requirements`);
-    console.log(`  ${chalk.yellow('●')} Active Changes: ${chalk.bold(changesData.active.length)} in progress`);
-    console.log(`  ${chalk.green('●')} Completed Changes: ${chalk.bold(changesData.completed.length)}`);
-    
-    if (totalTasks > 0) {
-      const overallProgress = Math.round((completedTasks / totalTasks) * 100);
-      console.log(`  ${chalk.magenta('●')} Task Progress: ${chalk.bold(`${completedTasks}/${totalTasks}`)} (${overallProgress}% complete)`);
-    }
-  }
-
-  private createProgressBar(completed: number, total: number, width: number = 20): string {
-    if (total === 0) return chalk.dim('─'.repeat(width));
-    
-    const percentage = completed / total;
-    const filled = Math.round(percentage * width);
-    const empty = width - filled;
-    
-    const filledBar = chalk.green('█'.repeat(filled));
-    const emptyBar = chalk.dim('░'.repeat(empty));
-    
-    return `[${filledBar}${emptyBar}]`;
-  }
-}

package/references/openspec/src/index.ts

@@ -1,2 +0,0 @@
-export * from './cli/index.js';
-export * from './core/index.js';

package/references/openspec/src/utils/file-system.ts

@@ -1,187 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
-function isMarkerOnOwnLine(content: string, markerIndex: number, markerLength: number): boolean {
-  let leftIndex = markerIndex - 1;
-  while (leftIndex >= 0 && content[leftIndex] !== '\n') {
-    const char = content[leftIndex];
-    if (char !== ' ' && char !== '\t' && char !== '\r') {
-      return false;
-    }
-    leftIndex--;
-  }
-
-  let rightIndex = markerIndex + markerLength;
-  while (rightIndex < content.length && content[rightIndex] !== '\n') {
-    const char = content[rightIndex];
-    if (char !== ' ' && char !== '\t' && char !== '\r') {
-      return false;
-    }
-    rightIndex++;
-  }
-
-  return true;
-}
-
-function findMarkerIndex(
-  content: string,
-  marker: string,
-  fromIndex = 0
-): number {
-  let currentIndex = content.indexOf(marker, fromIndex);
-
-  while (currentIndex !== -1) {
-    if (isMarkerOnOwnLine(content, currentIndex, marker.length)) {
-      return currentIndex;
-    }
-
-    currentIndex = content.indexOf(marker, currentIndex + marker.length);
-  }
-
-  return -1;
-}
-
-export class FileSystemUtils {
-  private static isWindowsBasePath(basePath: string): boolean {
-    return /^[A-Za-z]:[\\/]/.test(basePath) || basePath.startsWith('\\');
-  }
-
-  private static normalizeSegments(segments: string[]): string[] {
-    return segments
-      .flatMap((segment) => segment.split(/[\\/]+/u))
-      .filter((part) => part.length > 0);
-  }
-
-  static joinPath(basePath: string, ...segments: string[]): string {
-    const normalizedSegments = this.normalizeSegments(segments);
-
-    if (this.isWindowsBasePath(basePath)) {
-      const normalizedBasePath = path.win32.normalize(basePath);
-      return normalizedSegments.length
-        ? path.win32.join(normalizedBasePath, ...normalizedSegments)
-        : normalizedBasePath;
-    }
-
-    const posixBasePath = basePath.replace(/\\/g, '/');
-
-    return normalizedSegments.length
-      ? path.posix.join(posixBasePath, ...normalizedSegments)
-      : path.posix.normalize(posixBasePath);
-  }
-
-  static async createDirectory(dirPath: string): Promise<void> {
-    await fs.mkdir(dirPath, { recursive: true });
-  }
-
-  static async fileExists(filePath: string): Promise<boolean> {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch (error: any) {
-      if (error.code !== 'ENOENT') {
-        console.debug(`Unable to check if file exists at ${filePath}: ${error.message}`);
-      }
-      return false;
-    }
-  }
-
-  static async canWriteFile(filePath: string): Promise<boolean> {
-    try {
-      const stats = await fs.stat(filePath);
-
-      if (!stats.isFile()) {
-        return true;
-      }
-
-      return (stats.mode & 0o222) !== 0;
-    } catch (error: any) {
-      if (error.code === 'ENOENT') {
-        return true;
-      }
-
-      console.debug(`Unable to determine write permissions for ${filePath}: ${error.message}`);
-      return false;
-    }
-  }
-
-  static async directoryExists(dirPath: string): Promise<boolean> {
-    try {
-      const stats = await fs.stat(dirPath);
-      return stats.isDirectory();
-    } catch (error: any) {
-      if (error.code !== 'ENOENT') {
-        console.debug(`Unable to check if directory exists at ${dirPath}: ${error.message}`);
-      }
-      return false;
-    }
-  }
-
-  static async writeFile(filePath: string, content: string): Promise<void> {
-    const dir = path.dirname(filePath);
-    await this.createDirectory(dir);
-    await fs.writeFile(filePath, content, 'utf-8');
-  }
-
-  static async readFile(filePath: string): Promise<string> {
-    return await fs.readFile(filePath, 'utf-8');
-  }
-
-  static async updateFileWithMarkers(
-    filePath: string,
-    content: string,
-    startMarker: string,
-    endMarker: string
-  ): Promise<void> {
-    let existingContent = '';
-    
-    if (await this.fileExists(filePath)) {
-      existingContent = await this.readFile(filePath);
-      
-      const startIndex = findMarkerIndex(existingContent, startMarker);
-      const endIndex = startIndex !== -1
-        ? findMarkerIndex(existingContent, endMarker, startIndex + startMarker.length)
-        : findMarkerIndex(existingContent, endMarker);
-
-      if (startIndex !== -1 && endIndex !== -1) {
-        if (endIndex < startIndex) {
-          throw new Error(
-            `Invalid marker state in ${filePath}. End marker appears before start marker.`
-          );
-        }
-
-        const before = existingContent.substring(0, startIndex);
-        const after = existingContent.substring(endIndex + endMarker.length);
-        existingContent = before + startMarker + '\n' + content + '\n' + endMarker + after;
-      } else if (startIndex === -1 && endIndex === -1) {
-        existingContent = startMarker + '\n' + content + '\n' + endMarker + '\n\n' + existingContent;
-      } else {
-        throw new Error(`Invalid marker state in ${filePath}. Found start: ${startIndex !== -1}, Found end: ${endIndex !== -1}`);
-      }
-    } else {
-      existingContent = startMarker + '\n' + content + '\n' + endMarker;
-    }
-    
-    await this.writeFile(filePath, existingContent);
-  }
-
-  static async ensureWritePermissions(dirPath: string): Promise<boolean> {
-    try {
-      // If directory doesn't exist, check parent directory permissions
-      if (!await this.directoryExists(dirPath)) {
-        const parentDir = path.dirname(dirPath);
-        if (!await this.directoryExists(parentDir)) {
-          await this.createDirectory(parentDir);
-        }
-        return await this.ensureWritePermissions(parentDir);
-      }
-      
-      const testFile = path.join(dirPath, '.openspec-test-' + Date.now());
-      await fs.writeFile(testFile, '');
-      await fs.unlink(testFile);
-      return true;
-    } catch (error: any) {
-      console.debug(`Insufficient permissions to write to ${dirPath}: ${error.message}`);
-      return false;
-    }
-  }
-}

package/references/openspec/src/utils/index.ts

@@ -1,2 +0,0 @@
-// Shared utilities will be implemented here
-export {};

package/references/openspec/src/utils/interactive.ts

@@ -1,7 +0,0 @@
-export function isInteractive(noInteractiveFlag?: boolean): boolean {
-  if (noInteractiveFlag) return false;
-  if (process.env.OPEN_SPEC_INTERACTIVE === '0') return false;
-  return !!process.stdin.isTTY;
-}
-
-

package/references/openspec/src/utils/item-discovery.ts

@@ -1,45 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
-export async function getActiveChangeIds(root: string = process.cwd()): Promise<string[]> {
-  const changesPath = path.join(root, 'openspec', 'changes');
-  try {
-    const entries = await fs.readdir(changesPath, { withFileTypes: true });
-    const result: string[] = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'archive') continue;
-      const proposalPath = path.join(changesPath, entry.name, 'proposal.md');
-      try {
-        await fs.access(proposalPath);
-        result.push(entry.name);
-      } catch {
-        // skip directories without proposal.md
-      }
-    }
-    return result.sort();
-  } catch {
-    return [];
-  }
-}
-
-export async function getSpecIds(root: string = process.cwd()): Promise<string[]> {
-  const specsPath = path.join(root, 'openspec', 'specs');
-  const result: string[] = [];
-  try {
-    const entries = await fs.readdir(specsPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
-      const specFile = path.join(specsPath, entry.name, 'spec.md');
-      try {
-        await fs.access(specFile);
-        result.push(entry.name);
-      } catch {
-        // ignore
-      }
-    }
-  } catch {
-    // ignore
-  }
-  return result.sort();
-}
-

package/references/openspec/src/utils/match.ts

@@ -1,26 +0,0 @@
-export function nearestMatches(input: string, candidates: string[], max: number = 5): string[] {
-  const scored = candidates.map(candidate => ({ candidate, distance: levenshtein(input, candidate) }));
-  scored.sort((a, b) => a.distance - b.distance);
-  return scored.slice(0, max).map(s => s.candidate);
-}
-
-export function levenshtein(a: string, b: string): number {
-  const m = a.length;
-  const n = b.length;
-  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-  for (let i = 0; i <= m; i++) dp[i][0] = i;
-  for (let j = 0; j <= n; j++) dp[0][j] = j;
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      dp[i][j] = Math.min(
-        dp[i - 1][j] + 1,
-        dp[i][j - 1] + 1,
-        dp[i - 1][j - 1] + cost
-      );
-    }
-  }
-  return dp[m][n];
-}
-
-

package/references/openspec/src/utils/task-progress.ts

@@ -1,43 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
-const TASK_PATTERN = /^[-*]\s+\[[\sx]\]/i;
-const COMPLETED_TASK_PATTERN = /^[-*]\s+\[x\]/i;
-
-export interface TaskProgress {
-  total: number;
-  completed: number;
-}
-
-export function countTasksFromContent(content: string): TaskProgress {
-  const lines = content.split('\n');
-  let total = 0;
-  let completed = 0;
-  for (const line of lines) {
-    if (line.match(TASK_PATTERN)) {
-      total++;
-      if (line.match(COMPLETED_TASK_PATTERN)) {
-        completed++;
-      }
-    }
-  }
-  return { total, completed };
-}
-
-export async function getTaskProgressForChange(changesDir: string, changeName: string): Promise<TaskProgress> {
-  const tasksPath = path.join(changesDir, changeName, 'tasks.md');
-  try {
-    const content = await fs.readFile(tasksPath, 'utf-8');
-    return countTasksFromContent(content);
-  } catch {
-    return { total: 0, completed: 0 };
-  }
-}
-
-export function formatTaskStatus(progress: TaskProgress): string {
-  if (progress.total === 0) return 'No tasks';
-  if (progress.completed === progress.total) return '✓ Complete';
-  return `${progress.completed}/${progress.total} tasks`;
-}
-
-

package/references/openspec/test/cli-e2e/basic.test.ts

@@ -1,156 +0,0 @@
-import { afterAll, describe, it, expect } from 'vitest';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { tmpdir } from 'os';
-import { runCLI, cliProjectRoot } from '../helpers/run-cli.js';
-import { AI_TOOLS } from '../../src/core/config.js';
-
-async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-const tempRoots: string[] = [];
-
-async function prepareFixture(fixtureName: string): Promise<string> {
-  const base = await fs.mkdtemp(path.join(tmpdir(), 'openspec-cli-e2e-'));
-  tempRoots.push(base);
-  const projectDir = path.join(base, 'project');
-  await fs.mkdir(projectDir, { recursive: true });
-  const fixtureDir = path.join(cliProjectRoot, 'test', 'fixtures', fixtureName);
-  await fs.cp(fixtureDir, projectDir, { recursive: true });
-  return projectDir;
-}
-
-afterAll(async () => {
-  await Promise.all(tempRoots.map((dir) => fs.rm(dir, { recursive: true, force: true })));
-});
-
-describe('openspec CLI e2e basics', () => {
-  it('shows help output', async () => {
-    const result = await runCLI(['--help']);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain('Usage: openspec');
-    expect(result.stderr).toBe('');
-
-  });
-
-  it('shows dynamic tool ids in init help', async () => {
-    const result = await runCLI(['init', '--help']);
-    expect(result.exitCode).toBe(0);
-
-    const expectedTools = AI_TOOLS.filter((tool) => tool.available)
-      .map((tool) => tool.value)
-      .join(', ');
-    const normalizedOutput = result.stdout.replace(/\s+/g, ' ').trim();
-    expect(normalizedOutput).toContain(
-      `Use "all", "none", or a comma-separated list of: ${expectedTools}`
-    );
-  });
-
-  it('reports the package version', async () => {
-    const pkgRaw = await fs.readFile(path.join(cliProjectRoot, 'package.json'), 'utf-8');
-    const pkg = JSON.parse(pkgRaw);
-    const result = await runCLI(['--version']);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toBe(pkg.version);
-  });
-
-  it('validates the tmp-init fixture with --all --json', async () => {
-    const projectDir = await prepareFixture('tmp-init');
-    const result = await runCLI(['validate', '--all', '--json'], { cwd: projectDir });
-    expect(result.exitCode).toBe(0);
-    const output = result.stdout.trim();
-    expect(output).not.toBe('');
-    const json = JSON.parse(output);
-    expect(json.summary?.totals?.failed).toBe(0);
-    expect(json.items.some((item: any) => item.id === 'c1' && item.type === 'change')).toBe(true);
-  });
-
-  it('returns an error for unknown items in the fixture', async () => {
-    const projectDir = await prepareFixture('tmp-init');
-    const result = await runCLI(['validate', 'does-not-exist'], { cwd: projectDir });
-    expect(result.exitCode).toBe(1);
-    expect(result.stderr).toContain("Unknown item 'does-not-exist'");
-  });
-
-  describe('init command non-interactive options', () => {
-    it('initializes with --tools all option', async () => {
-      const projectDir = await prepareFixture('tmp-init');
-      const emptyProjectDir = path.join(projectDir, '..', 'empty-project');
-      await fs.mkdir(emptyProjectDir, { recursive: true });
-
-      const codexHome = path.join(emptyProjectDir, '.codex');
-      const result = await runCLI(['init', '--tools', 'all'], {
-        cwd: emptyProjectDir,
-        env: { CODEX_HOME: codexHome },
-      });
-      expect(result.exitCode).toBe(0);
-      expect(result.stdout).toContain('Tool summary:');
-
-      // Check that tool configurations were created
-      const claudePath = path.join(emptyProjectDir, 'CLAUDE.md');
-      const cursorProposal = path.join(emptyProjectDir, '.cursor/commands/openspec-proposal.md');
-      expect(await fileExists(claudePath)).toBe(true);
-      expect(await fileExists(cursorProposal)).toBe(true);
-    });
-
-    it('initializes with --tools list option', async () => {
-      const projectDir = await prepareFixture('tmp-init');
-      const emptyProjectDir = path.join(projectDir, '..', 'empty-project');
-      await fs.mkdir(emptyProjectDir, { recursive: true });
-
-      const result = await runCLI(['init', '--tools', 'claude'], { cwd: emptyProjectDir });
-      expect(result.exitCode).toBe(0);
-      expect(result.stdout).toContain('Tool summary:');
-
-      const claudePath = path.join(emptyProjectDir, 'CLAUDE.md');
-      const cursorProposal = path.join(emptyProjectDir, '.cursor/commands/openspec-proposal.md');
-      expect(await fileExists(claudePath)).toBe(true);
-      expect(await fileExists(cursorProposal)).toBe(false); // Not selected
-    });
-
-    it('initializes with --tools none option', async () => {
-      const projectDir = await prepareFixture('tmp-init');
-      const emptyProjectDir = path.join(projectDir, '..', 'empty-project');
-      await fs.mkdir(emptyProjectDir, { recursive: true });
-
-      const result = await runCLI(['init', '--tools', 'none'], { cwd: emptyProjectDir });
-      expect(result.exitCode).toBe(0);
-      expect(result.stdout).toContain('Tool summary:');
-
-      const claudePath = path.join(emptyProjectDir, 'CLAUDE.md');
-      const cursorProposal = path.join(emptyProjectDir, '.cursor/commands/openspec-proposal.md');
-      const rootAgentsPath = path.join(emptyProjectDir, 'AGENTS.md');
-
-      expect(await fileExists(rootAgentsPath)).toBe(true);
-      expect(await fileExists(claudePath)).toBe(false);
-      expect(await fileExists(cursorProposal)).toBe(false);
-    });
-
-    it('returns error for invalid tool names', async () => {
-      const projectDir = await prepareFixture('tmp-init');
-      const emptyProjectDir = path.join(projectDir, '..', 'empty-project');
-      await fs.mkdir(emptyProjectDir, { recursive: true });
-
-      const result = await runCLI(['init', '--tools', 'invalid-tool'], { cwd: emptyProjectDir });
-      expect(result.exitCode).toBe(1);
-      expect(result.stderr).toContain('Invalid tool(s): invalid-tool');
-      expect(result.stderr).toContain('Available values:');
-    });
-
-    it('returns error when combining reserved keywords with explicit ids', async () => {
-      const projectDir = await prepareFixture('tmp-init');
-      const emptyProjectDir = path.join(projectDir, '..', 'empty-project');
-      await fs.mkdir(emptyProjectDir, { recursive: true });
-
-      const result = await runCLI(['init', '--tools', 'all,claude'], { cwd: emptyProjectDir });
-      expect(result.exitCode).toBe(1);
-      expect(result.stderr).toContain('Cannot combine reserved values "all" or "none" with specific tool IDs');
-    });
-  });
-});