Intelligent prs init Implementation Plan¶

// packages/cli/src/utils/__tests__/clipboard.spec.ts
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { copyToClipboard } from '../clipboard.js';
import { execFileSync } from 'child_process';

vi.mock('child_process', () => ({
  execFileSync: vi.fn(),
}));

describe('copyToClipboard', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('returns true on success', () => {
    vi.mocked(execFileSync).mockReturnValue(Buffer.from(''));
    const result = copyToClipboard('hello');
    expect(result).toBe(true);
    expect(execFileSync).toHaveBeenCalled();
  });

  it('returns false when clipboard command fails', () => {
    vi.mocked(execFileSync).mockImplementation(() => {
      throw new Error('command not found');
    });
    const result = copyToClipboard('hello');
    expect(result).toBe(false);
  });

  it('passes text via stdin to the clipboard command', () => {
    vi.mocked(execFileSync).mockReturnValue(Buffer.from(''));
    copyToClipboard('test content');
    expect(execFileSync).toHaveBeenCalledWith(
      expect.any(String),
      expect.any(Array),
      expect.objectContaining({ input: 'test content' })
    );
  });
});

// packages/cli/src/utils/clipboard.ts
import { execFileSync } from 'child_process';

/**
 * Platform-specific clipboard commands.
 * Each entry is [binary, ...args].
 * Tried in order; first successful one wins.
 */
const CLIPBOARD_COMMANDS: Record<string, [string, string[]][]> = {
  darwin: [['pbcopy', []]],
  linux: [
    ['xclip', ['-selection', 'clipboard']],
    ['xsel', ['--clipboard', '--input']],
  ],
  win32: [['clip', []]],
};

/**
 * Copy text to the system clipboard.
 * Returns true on success, false if clipboard is unavailable.
 */
export function copyToClipboard(text: string): boolean {
  const commands = CLIPBOARD_COMMANDS[process.platform] ?? [];

  for (const [binary, args] of commands) {
    try {
      execFileSync(binary, args, { input: text, stdio: ['pipe', 'ignore', 'ignore'] });
      return true;
    } catch {
      // Try next command
    }
  }

  return false;
}

// packages/cli/src/utils/__tests__/backup.spec.ts
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { createBackup, isGitRepo } from '../backup.js';
import type { CliServices } from '../../services.js';

describe('isGitRepo', () => {
  it('returns true when .git exists', () => {
    const services = {
      fs: { existsSync: vi.fn().mockReturnValue(true) },
    } as unknown as CliServices;
    expect(isGitRepo(services)).toBe(true);
    expect(services.fs.existsSync).toHaveBeenCalledWith('.git');
  });

  it('returns false when .git does not exist', () => {
    const services = {
      fs: { existsSync: vi.fn().mockReturnValue(false) },
    } as unknown as CliServices;
    expect(isGitRepo(services)).toBe(false);
  });
});

describe('createBackup', () => {
  let mockServices: CliServices;

  beforeEach(() => {
    mockServices = {
      fs: {
        existsSync: vi.fn().mockReturnValue(true),
        readFileSync: vi.fn().mockReturnValue('file content'),
        writeFile: vi.fn().mockResolvedValue(undefined),
        mkdir: vi.fn().mockResolvedValue(undefined),
        readFile: vi.fn().mockResolvedValue('file content'),
        readdir: vi.fn().mockResolvedValue([]),
      },
      prompts: {} as CliServices['prompts'],
      cwd: '/mock',
    } as unknown as CliServices;
  });

  it('creates timestamped backup directory', async () => {
    const result = await createBackup(['CLAUDE.md'], mockServices);

    expect(mockServices.fs.mkdir).toHaveBeenCalledWith(
      expect.stringMatching(/^\.prs-backup\/\d{4}-\d{2}-\d{2}T/),
      { recursive: true }
    );
    expect(result.dir).toMatch(/^\.prs-backup\/\d{4}-\d{2}-\d{2}T/);
  });

  it('copies listed files to backup directory', async () => {
    await createBackup(['CLAUDE.md', '.cursorrules'], mockServices);

    expect(mockServices.fs.writeFile).toHaveBeenCalledTimes(2);
    expect(mockServices.fs.writeFile).toHaveBeenCalledWith(
      expect.stringContaining('CLAUDE.md'),
      'file content',
      'utf-8'
    );
  });

  it('skips files that do not exist', async () => {
    vi.mocked(mockServices.fs.existsSync).mockImplementation((p: string) => p !== '.cursorrules');
    await createBackup(['CLAUDE.md', '.cursorrules'], mockServices);

    expect(mockServices.fs.writeFile).toHaveBeenCalledTimes(1);
  });
});

// packages/cli/src/utils/backup.ts
import { basename } from 'path';
import type { CliServices } from '../services.js';

export interface BackupResult {
  dir: string;
  files: string[];
}

/**
 * Check if current directory is a git repository.
 */
export function isGitRepo(services: CliServices): boolean {
  return services.fs.existsSync('.git');
}

/**
 * Create a timestamped backup of the given files.
 * Only backs up files that exist on disk.
 */
export async function createBackup(
  filePaths: string[],
  services: CliServices
): Promise<BackupResult> {
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
  const dir = `.prs-backup/${timestamp}`;

  await services.fs.mkdir(dir, { recursive: true });

  const backedUp: string[] = [];
  for (const filePath of filePaths) {
    if (!services.fs.existsSync(filePath)) continue;

    const content = services.fs.readFileSync(filePath, 'utf-8');
    const dest = `${dir}/${basename(filePath)}`;
    await services.fs.writeFile(dest, content, 'utf-8');
    backedUp.push(filePath);
  }

  return { dir, files: backedUp };
}

// packages/cli/src/utils/__tests__/migration-prompt.spec.ts
import { describe, it, expect } from 'vitest';
import { generateMigrationPrompt, type MigrationPromptInput } from '../migration-prompt.js';

describe('generateMigrationPrompt', () => {
  const candidates: MigrationPromptInput[] = [
    { path: 'CLAUDE.md', sizeHuman: '3.4 KB', toolName: 'Claude Code' },
    { path: '.cursorrules', sizeHuman: '1.8 KB', toolName: 'Cursor' },
  ];

  it('includes all candidate files in the prompt', () => {
    const prompt = generateMigrationPrompt(candidates);
    expect(prompt).toContain('CLAUDE.md');
    expect(prompt).toContain('.cursorrules');
  });

  it('includes file sizes and tool names', () => {
    const prompt = generateMigrationPrompt(candidates);
    expect(prompt).toContain('3.4 KB');
    expect(prompt).toContain('Claude Code');
  });

  it('includes /promptscript skill reference', () => {
    const prompt = generateMigrationPrompt(candidates);
    expect(prompt).toContain('/promptscript');
  });

  it('includes modular .prs structure instructions', () => {
    const prompt = generateMigrationPrompt(candidates);
    expect(prompt).toContain('project.prs');
    expect(prompt).toContain('context.prs');
    expect(prompt).toContain('standards.prs');
    expect(prompt).toContain('restrictions.prs');
  });

  it('includes validation steps', () => {
    const prompt = generateMigrationPrompt(candidates);
    expect(prompt).toContain('prs validate');
    expect(prompt).toContain('prs compile');
  });

  it('handles single candidate', () => {
    const prompt = generateMigrationPrompt([candidates[0]!]);
    expect(prompt).toContain('CLAUDE.md');
    expect(prompt).not.toContain('.cursorrules');
  });
});

// packages/cli/src/utils/migration-prompt.ts

export interface MigrationPromptInput {
  path: string;
  sizeHuman: string;
  toolName: string;
}

/**
 * Generate a kick-start prompt for AI-assisted migration.
 * The prompt tells the AI what files to read and how to produce .prs output.
 * It does NOT include file contents -- the AI reads them from disk.
 */
export function generateMigrationPrompt(candidates: MigrationPromptInput[]): string {
  const fileList = candidates.map((c) => `- ${c.path} (${c.sizeHuman}, ${c.toolName})`).join('\n');

  return `Migrate my existing AI instructions to PromptScript.

I've just initialized PromptScript in this project. The following
instruction files need to be migrated to .prs format:

${fileList}

Use the /promptscript skill for the PromptScript language reference.

Steps:
1. Read each file listed above
2. Analyze the content and map to PromptScript blocks
3. Generate a modular .prs structure in .promptscript/:
   - project.prs (entry: @meta, @identity, @use directives)
   - context.prs (@context)
   - standards.prs (@standards)
   - restrictions.prs (@restrictions)
   - commands.prs (@shortcuts, @knowledge -- only if relevant content found)
4. Deduplicate overlapping content across files
5. Run: prs validate --strict
6. Run: prs compile --dry-run
`;
}

// packages/importer/src/__tests__/merger.spec.ts
import { describe, it, expect } from 'vitest';
import { mergeSections, type SourcedSection } from '../merger.js';
import { classifyConfidence } from '../confidence.js';

function section(
  targetBlock: string,
  content: string,
  source: string,
  confidence = 0.85
): SourcedSection {
  return {
    heading: targetBlock,
    content,
    targetBlock,
    confidence,
    level: classifyConfidence(confidence),
    source,
  };
}

describe('mergeSections', () => {
  it('groups sections by targetBlock', () => {
    const sections = [
      section('identity', 'You are a TS expert', 'CLAUDE.md'),
      section('standards', 'Use strict mode', 'CLAUDE.md'),
      section('identity', 'You are helpful', '.cursorrules'),
    ];

    const result = mergeSections(sections);

    expect(result.merged.has('identity')).toBe(true);
    expect(result.merged.has('standards')).toBe(true);
  });

  it('picks longest identity by character count', () => {
    const sections = [
      section('identity', 'You are a TypeScript expert working on complex systems', 'CLAUDE.md'),
      section('identity', 'You are helpful', '.cursorrules'),
    ];

    const result = mergeSections(sections);
    const identity = result.merged.get('identity')!;

    expect(identity.content).toContain('TypeScript expert');
    expect(identity.reviewComments).toHaveLength(1);
    expect(identity.reviewComments[0]).toContain('.cursorrules');
  });

  it('unions restrictions from all sources', () => {
    const sections = [
      section('restrictions', '- "Never use any"', 'CLAUDE.md'),
      section('restrictions', '- "Never commit secrets"', '.cursorrules'),
    ];

    const result = mergeSections(sections);
    const restrictions = result.merged.get('restrictions')!;

    expect(restrictions.content).toContain('Never use any');
    expect(restrictions.content).toContain('Never commit secrets');
  });

  it('deduplicates exact-match lines after whitespace normalization', () => {
    const sections = [
      section('restrictions', '- "Never use any"', 'CLAUDE.md'),
      section('restrictions', '-  "Never use any"', '.cursorrules'),
      section('restrictions', '- "Never commit secrets"', '.cursorrules'),
    ];

    const result = mergeSections(sections);
    const restrictions = result.merged.get('restrictions')!;

    const lines = restrictions.content.split('\n').filter((l) => l.trim().length > 0);
    expect(lines).toHaveLength(2);
    expect(result.deduplicatedCount).toBeGreaterThan(0);
  });

  it('concatenates knowledge with source attribution', () => {
    const sections = [
      section('knowledge', 'API docs here', 'CLAUDE.md'),
      section('knowledge', 'CLI reference', '.cursorrules'),
    ];

    const result = mergeSections(sections);
    const knowledge = result.merged.get('knowledge')!;

    expect(knowledge.content).toContain('# Source: CLAUDE.md');
    expect(knowledge.content).toContain('# Source: .cursorrules');
  });

  it('merges standards by concatenating with dedup', () => {
    const sections = [
      section('standards', 'typescript: ["Strict mode"]', 'CLAUDE.md'),
      section('standards', 'naming: ["kebab-case"]', '.cursorrules'),
    ];

    const result = mergeSections(sections);
    const standards = result.merged.get('standards')!;

    expect(standards.content).toContain('Strict mode');
    expect(standards.content).toContain('kebab-case');
  });

  it('reports overall confidence', () => {
    const sections = [
      section('identity', 'You are expert', 'CLAUDE.md', 0.9),
      section('standards', 'Use strict', 'CLAUDE.md', 0.7),
    ];

    const result = mergeSections(sections);
    expect(result.overallConfidence).toBeCloseTo(0.8, 1);
  });
});

// packages/importer/src/merger.ts
import type { ScoredSection } from './confidence.js';

/**
 * A ScoredSection with source file attribution.
 */
export interface SourcedSection extends ScoredSection {
  source: string;
}

/**
 * A merged block ready for emission.
 */
export interface MergedBlock {
  targetBlock: string;
  content: string;
  sources: string[];
  confidence: number;
  reviewComments: string[];
}

export interface MergeResult {
  merged: Map<string, MergedBlock>;
  deduplicatedCount: number;
  overallConfidence: number;
}

/**
 * Merge sections from multiple files by targetBlock.
 *
 * Merge rules per block type (from spec):
 * - identity: pick longest (char count after trim), others -> review comments
 * - restrictions: full union, dedup exact-match lines
 * - knowledge: concatenate with source attribution headers
 * - standards, context, shortcuts: concatenate with dedup
 */
export function mergeSections(sections: SourcedSection[]): MergeResult {
  const grouped = new Map<string, SourcedSection[]>();
  for (const s of sections) {
    const existing = grouped.get(s.targetBlock);
    if (existing) {
      existing.push(s);
    } else {
      grouped.set(s.targetBlock, [s]);
    }
  }

  const merged = new Map<string, MergedBlock>();
  let totalDeduped = 0;

  for (const [block, blockSections] of grouped) {
    if (block === 'identity') {
      merged.set(block, mergeIdentity(blockSections));
    } else if (block === 'knowledge') {
      merged.set(block, mergeWithAttribution(blockSections));
    } else {
      const result = mergeUnion(blockSections);
      totalDeduped += result.deduped;
      merged.set(block, result.block);
    }
  }

  const allConfidences = sections.map((s) => s.confidence);
  const overallConfidence =
    allConfidences.length > 0
      ? allConfidences.reduce((a, b) => a + b, 0) / allConfidences.length
      : 0;

  return { merged, deduplicatedCount: totalDeduped, overallConfidence };
}

function mergeIdentity(sections: SourcedSection[]): MergedBlock {
  const sorted = [...sections].sort((a, b) => b.content.trim().length - a.content.trim().length);
  const winner = sorted[0]!;
  const others = sorted.slice(1);

  const reviewComments = others.map(
    (s) => `# REVIEW: alt from ${s.source}: "${s.content.trim().slice(0, 60)}..."`
  );

  return {
    targetBlock: 'identity',
    content: winner.content,
    sources: sections.map((s) => s.source),
    confidence: winner.confidence,
    reviewComments,
  };
}

function mergeWithAttribution(sections: SourcedSection[]): MergedBlock {
  const parts = sections.map((s) => `# Source: ${s.source}\n${s.content}`);
  const avgConfidence = sections.reduce((sum, s) => sum + s.confidence, 0) / sections.length;

  return {
    targetBlock: sections[0]!.targetBlock,
    content: parts.join('\n\n'),
    sources: sections.map((s) => s.source),
    confidence: avgConfidence,
    reviewComments: [],
  };
}

function mergeUnion(sections: SourcedSection[]): { block: MergedBlock; deduped: number } {
  const seenLines = new Set<string>();
  const uniqueLines: string[] = [];
  let deduped = 0;

  for (const s of sections) {
    const lines = s.content.split('\n');
    for (const line of lines) {
      const normalized = line.trim().replace(/\s+/g, ' ');
      if (normalized.length === 0) continue;
      if (seenLines.has(normalized)) {
        deduped++;
        continue;
      }
      seenLines.add(normalized);
      uniqueLines.push(line);
    }
  }

  const avgConfidence = sections.reduce((sum, s) => sum + s.confidence, 0) / sections.length;

  return {
    block: {
      targetBlock: sections[0]!.targetBlock,
      content: uniqueLines.join('\n'),
      sources: sections.map((s) => s.source),
      confidence: avgConfidence,
      reviewComments: [],
    },
    deduped,
  };
}

// packages/importer/src/__tests__/multi-importer.spec.ts
import { describe, it, expect } from 'vitest';
import { resolve } from 'path';
import { importMultipleFiles } from '../multi-importer.js';

const fixturesDir = resolve(__dirname, 'fixtures');

describe('importMultipleFiles', () => {
  it('imports multiple files and returns modular output', async () => {
    const result = await importMultipleFiles(
      [resolve(fixturesDir, 'sample-claude.md'), resolve(fixturesDir, 'sample-copilot.md')],
      { projectName: 'test-project' }
    );

    expect(result.files.has('project.prs')).toBe(true);
    expect(result.files.get('project.prs')).toContain('@meta {');
    expect(result.files.get('project.prs')).toContain('@use ./');
    expect(result.overallConfidence).toBeGreaterThan(0);
  });

  it('project.prs contains @identity block', async () => {
    const result = await importMultipleFiles([resolve(fixturesDir, 'sample-claude.md')], {
      projectName: 'my-proj',
    });

    expect(result.files.get('project.prs')).toContain('@identity');
  });

  it('only emits files with content', async () => {
    const result = await importMultipleFiles([resolve(fixturesDir, 'sample-claude.md')], {
      projectName: 'test',
    });

    for (const [, content] of result.files) {
      expect(content.trim().length).toBeGreaterThan(0);
    }
  });

  it('returns per-file confidence reports', async () => {
    const result = await importMultipleFiles(
      [resolve(fixturesDir, 'sample-claude.md'), resolve(fixturesDir, 'sample-copilot.md')],
      { projectName: 'test' }
    );

    expect(result.perFileReports).toHaveLength(2);
    expect(result.perFileReports[0]!.file).toContain('sample-claude.md');
    expect(result.perFileReports[0]!.sectionCount).toBeGreaterThan(0);
  });

  it('reports deduplication count', async () => {
    const result = await importMultipleFiles(
      [resolve(fixturesDir, 'sample-claude.md'), resolve(fixturesDir, 'sample-copilot.md')],
      { projectName: 'test' }
    );

    expect(typeof result.deduplicatedCount).toBe('number');
  });

  it('skips files that fail to import with warnings', async () => {
    const result = await importMultipleFiles(
      [resolve(fixturesDir, 'sample-claude.md'), '/nonexistent/file.md'],
      { projectName: 'test' }
    );

    expect(result.files.has('project.prs')).toBe(true);
    expect(result.warnings.some((w) => w.includes('/nonexistent/file.md'))).toBe(true);
  });

  it('handles single file input', async () => {
    const result = await importMultipleFiles([resolve(fixturesDir, 'sample-claude.md')], {
      projectName: 'single',
    });

    expect(result.files.has('project.prs')).toBe(true);
  });
});

import type { MergedBlock } from './merger.js';

export interface ModularEmitOptions {
  projectName: string;
  syntaxVersion?: string;
}

/**
 * Emit merged blocks as modular .prs files.
 * Returns a Map<filename, content> where filenames are relative to .promptscript/.
 *
 * Layout:
 * - project.prs: @meta + @identity + @use directives
 * - context.prs: @context (if exists)
 * - standards.prs: @standards (if exists)
 * - restrictions.prs: @restrictions (if exists)
 * - commands.prs: @shortcuts + @knowledge (if exist)
 */
export function emitModularFiles(
  blocks: Map<string, MergedBlock>,
  options: ModularEmitOptions
): Map<string, string> {
  const files = new Map<string, string>();
  const syntaxVersion = options.syntaxVersion ?? '1.0.0';

  const useDirectives: string[] = [];
  const fileBlockMapping: Record<string, string[]> = {
    'context.prs': ['context'],
    'standards.prs': ['standards'],
    'restrictions.prs': ['restrictions'],
    'commands.prs': ['shortcuts', 'knowledge'],
  };

  for (const [filename, blockNames] of Object.entries(fileBlockMapping)) {
    const relevantBlocks = blockNames
      .map((name) => blocks.get(name))
      .filter((b): b is MergedBlock => b !== undefined);

    if (relevantBlocks.length === 0) continue;

    const lines: string[] = [];
    for (const block of relevantBlocks) {
      for (const comment of block.reviewComments) {
        lines.push(comment);
      }
      if (block.confidence < 0.5) {
        lines.push('# REVIEW: low confidence -- verify this mapping');
      }
      lines.push(`@${block.targetBlock} {`);
      lines.push('  """');
      for (const contentLine of block.content.split('\n')) {
        lines.push(`    ${contentLine}`);
      }
      lines.push('  """');
      lines.push('}');
      lines.push('');
    }

    const useName = filename.replace('.prs', '');
    useDirectives.push(`@use ./${useName}`);
    files.set(filename, lines.join('\n'));
  }

  // Emit project.prs
  const projectLines: string[] = [];
  projectLines.push('@meta {');
  projectLines.push(`  id: "${options.projectName}"`);
  projectLines.push(`  syntax: "${syntaxVersion}"`);
  projectLines.push('}');
  projectLines.push('');

  for (const dir of useDirectives) {
    projectLines.push(dir);
  }

  const identity = blocks.get('identity');
  if (identity) {
    projectLines.push('');
    for (const comment of identity.reviewComments) {
      projectLines.push(comment);
    }
    projectLines.push('@identity {');
    projectLines.push('  """');
    for (const line of identity.content.split('\n')) {
      projectLines.push(`    ${line}`);
    }
    projectLines.push('  """');
    projectLines.push('}');
  }

  projectLines.push('');
  files.set('project.prs', projectLines.join('\n'));

  return files;
}

// packages/importer/src/multi-importer.ts
import { basename } from 'path';
import { importFile } from './importer.js';
import { mergeSections, type SourcedSection } from './merger.js';
import { emitModularFiles, type ModularEmitOptions } from './emitter.js';

export interface MultiImportOptions extends ModularEmitOptions {}

export interface FileReport {
  file: string;
  sectionCount: number;
  confidence: number;
}

export interface MultiImportResult {
  /** Map of filename -> .prs content (relative to .promptscript/) */
  files: Map<string, string>;
  perFileReports: FileReport[];
  deduplicatedCount: number;
  overallConfidence: number;
  warnings: string[];
}

/**
 * Import multiple instruction files and produce modular .prs output.
 * Files that fail to import are skipped with warnings.
 */
export async function importMultipleFiles(
  filePaths: string[],
  options: MultiImportOptions
): Promise<MultiImportResult> {
  const allSections: SourcedSection[] = [];
  const perFileReports: FileReport[] = [];
  const warnings: string[] = [];

  for (const filePath of filePaths) {
    try {
      const result = await importFile(filePath);
      const source = basename(filePath);

      for (const section of result.sections) {
        allSections.push({ ...section, source });
      }

      perFileReports.push({
        file: filePath,
        sectionCount: result.sections.length,
        confidence: result.totalConfidence,
      });

      warnings.push(...result.warnings);
    } catch (error) {
      warnings.push(
        `Could not import ${filePath}: ${error instanceof Error ? error.message : String(error)}`
      );
    }
  }

  if (allSections.length === 0) {
    return {
      files: new Map([['project.prs', emitEmptyProject(options)]]),
      perFileReports,
      deduplicatedCount: 0,
      overallConfidence: 0,
      warnings,
    };
  }

  const mergeResult = mergeSections(allSections);
  const files = emitModularFiles(mergeResult.merged, options);

  return {
    files,
    perFileReports,
    deduplicatedCount: mergeResult.deduplicatedCount,
    overallConfidence: mergeResult.overallConfidence,
    warnings,
  };
}

function emitEmptyProject(options: MultiImportOptions): string {
  return `@meta {
  id: "${options.projectName}"
  syntax: "${options.syntaxVersion ?? '1.0.0'}"
}

@identity {
  """
  [No content could be imported. Edit this file manually.]
  """
}
`;
}

export { mergeSections } from './merger.js';
export type { SourcedSection, MergedBlock, MergeResult } from './merger.js';
export { importMultipleFiles } from './multi-importer.js';
export type { MultiImportOptions, MultiImportResult, FileReport } from './multi-importer.js';
export { emitModularFiles } from './emitter.js';
export type { ModularEmitOptions } from './emitter.js';

// packages/cli/src/utils/__tests__/ai-tools-detector.spec.ts
import { describe, it, expect, vi } from 'vitest';
import {
  detectAITools,
  hasMigrationCandidates,
  type AIToolsDetection,
} from '../ai-tools-detector.js';
import type { CliServices } from '../../services.js';

vi.mock('@promptscript/importer', () => ({
  detectFormat: vi.fn().mockReturnValue('claude'),
}));

describe('detectAITools -- enriched migration candidates', () => {
  it('returns MigrationCandidate objects with metadata', async () => {
    const mockServices = {
      fs: {
        existsSync: vi.fn().mockImplementation((p: string) => p === 'CLAUDE.md' || p === '.git'),
        readFile: vi.fn().mockResolvedValue('# My instructions\nYou are a helpful assistant'),
        readdir: vi.fn().mockResolvedValue([]),
        readFileSync: vi.fn().mockReturnValue('# My instructions\nYou are a helpful assistant'),
      },
      prompts: {} as CliServices['prompts'],
      cwd: '/mock',
    } as unknown as CliServices;

    const result = await detectAITools(mockServices);

    const candidate = result.migrationCandidates.find((c) => c.path === 'CLAUDE.md');
    expect(candidate).toBeDefined();
    expect(candidate!.path).toBe('CLAUDE.md');
    expect(candidate!.toolName).toBe('Claude Code');
    expect(typeof candidate!.sizeBytes).toBe('number');
    expect(typeof candidate!.sizeHuman).toBe('string');
  });

  it('hasMigrationCandidates works with enriched type', () => {
    const detection: AIToolsDetection = {
      detected: ['claude'],
      details: { claude: ['CLAUDE.md'] },
      migrationCandidates: [
        {
          path: 'CLAUDE.md',
          format: 'claude',
          sizeBytes: 1024,
          sizeHuman: '1.0 KB',
          toolName: 'Claude Code',
        },
      ],
    };
    expect(hasMigrationCandidates(detection)).toBe(true);
  });

  it('hasMigrationCandidates returns false when empty', () => {
    const detection: AIToolsDetection = {
      detected: [],
      details: {},
      migrationCandidates: [],
    };
    expect(hasMigrationCandidates(detection)).toBe(false);
  });
});