@skillit/client 0.2.0 → 0.3.1

package/src/__tests__/anthropic-prompt.test.ts

@@ -1,102 +0,0 @@
-// packages/client/src/__tests__/anthropic-prompt.test.ts
-import { describe, it, expect } from 'vitest';
-import { buildDraftPrompt, buildReviewPrompt } from '../model/anthropic.js';
-import type { DraftRequest, ReviewRequest, ExtractedSkill } from '@skillit/core';
-
-const baseSkill = (): ExtractedSkill =>
-  ({ name: 'my-tool', functions: [] }) as unknown as ExtractedSkill;
-
-const baseDraftReq = (overrides: Partial<DraftRequest> = {}): DraftRequest => ({
-  toolName: 'tool_a',
-  tag: 'useWhen',
-  suggestion: 'Add @useWhen annotation',
-  currentValue: undefined,
-  skill: baseSkill(),
-  ...overrides
-});
-
-const baseReviewReq = (overrides: Partial<ReviewRequest> = {}): ReviewRequest => ({
-  toolName: 'tool_a',
-  tag: 'useWhen',
-  draft: 'Use this tool when listing files',
-  suggestion: 'Add @useWhen annotation',
-  skill: baseSkill(),
-  ...overrides
-});
-
-describe('buildDraftPrompt', () => {
-  it('includes a Conventions section with guidance text when guidance is provided', () => {
-    const req = baseDraftReq({ guidance: 'Always use active voice.' });
-    const prompt = buildDraftPrompt(req);
-    expect(prompt).toContain('Conventions');
-    expect(prompt).toContain('Always use active voice.');
-  });
-
-  it('does NOT include a Conventions section when guidance is undefined', () => {
-    const req = baseDraftReq({ guidance: undefined });
-    const prompt = buildDraftPrompt(req);
-    expect(prompt).not.toContain('Conventions');
-  });
-
-  it('does NOT include a Conventions section when guidance is absent', () => {
-    const req = baseDraftReq();
-    const prompt = buildDraftPrompt(req);
-    expect(prompt).not.toContain('Conventions');
-  });
-
-  it('still includes core prompt content regardless of guidance', () => {
-    const req = baseDraftReq({ guidance: 'Some guidance.' });
-    const prompt = buildDraftPrompt(req);
-    expect(prompt).toContain('tool_a');
-    expect(prompt).toContain('@useWhen');
-  });
-
-  it('uses source-neutral framing (no hardcoded MCP) and keeps guidance', () => {
-    const req = baseDraftReq({ guidance: 'CLI conventions: use --flag syntax.' });
-    const prompt = buildDraftPrompt(req);
-    expect(prompt).not.toContain('MCP');
-    expect(prompt).toContain('skill annotations for "my-tool"');
-    expect(prompt).toContain('Conventions');
-    expect(prompt).toContain('CLI conventions: use --flag syntax.');
-  });
-});
-
-describe('buildReviewPrompt', () => {
-  it('includes a Conventions section with guidance text when guidance is provided', () => {
-    const req = baseReviewReq({ guidance: 'Always use active voice.' });
-    const prompt = buildReviewPrompt(req);
-    expect(prompt).toContain('Conventions');
-    expect(prompt).toContain('Always use active voice.');
-    expect(prompt.indexOf('Conventions')).toBeLessThan(prompt.indexOf('Respond with JSON only'));
-  });
-
-  it('does NOT include a Conventions section when guidance is undefined', () => {
-    const req = baseReviewReq({ guidance: undefined });
-    const prompt = buildReviewPrompt(req);
-    expect(prompt).not.toContain('Conventions');
-  });
-
-  it('does NOT include a Conventions section when guidance is absent', () => {
-    const req = baseReviewReq();
-    const prompt = buildReviewPrompt(req);
-    expect(prompt).not.toContain('Conventions');
-  });
-
-  it('still includes core prompt content regardless of guidance', () => {
-    const req = baseReviewReq({ guidance: 'Some guidance.' });
-    const prompt = buildReviewPrompt(req);
-    expect(prompt).toContain('tool_a');
-    expect(prompt).toContain('@useWhen');
-    expect(prompt).toContain('Use this tool when listing files');
-  });
-
-  it('uses source-neutral framing (no hardcoded MCP) and keeps guidance + JSON instruction', () => {
-    const req = baseReviewReq({ guidance: 'CLI conventions: use --flag syntax.' });
-    const prompt = buildReviewPrompt(req);
-    expect(prompt).not.toContain('MCP');
-    expect(prompt).toContain('skill annotation draft for "my-tool"');
-    expect(prompt).toContain('Conventions');
-    expect(prompt).toContain('CLI conventions: use --flag syntax.');
-    expect(prompt).toContain('Respond with JSON only');
-  });
-});

package/src/__tests__/cli-adapters.test.ts

@@ -1,119 +0,0 @@
-// packages/client/src/__tests__/cli-adapters.test.ts
-import { describe, it, expect } from 'vitest';
-import { claudeAdapter, codexAdapter, copilotAdapter, adapterFor } from '../model/cli/adapters.js';
-import { DRAFTER, REVIEWER } from '../model/models.js';
-
-describe('claudeAdapter', () => {
-  it('maps draft role to the drafter model and review role to the reviewer model', () => {
-    const draft = claudeAdapter.invocation('draft', 'PROMPT');
-    expect(draft.cmd).toBe('claude');
-    expect(draft.args).toEqual(['-p', '--output-format', 'json', '--model', DRAFTER]);
-    expect(draft.input).toBe('PROMPT');
-    const review = claudeAdapter.invocation('review', 'PROMPT');
-    expect(review.args).toContain(REVIEWER);
-  });
-
-  it('extracts result from the claude json envelope', () => {
-    const stdout = JSON.stringify({ type: 'result', is_error: false, result: 'the answer' });
-    expect(claudeAdapter.extractResult(stdout)).toBe('the answer');
-  });
-
-  it('throws when claude reports is_error', () => {
-    const stdout = JSON.stringify({ type: 'result', is_error: true, result: 'nope' });
-    expect(() => claudeAdapter.extractResult(stdout)).toThrow(/claude/i);
-  });
-
-  it('returns an empty result string (does not editorialize)', () => {
-    const stdout = JSON.stringify({ type: 'result', is_error: false, result: '' });
-    expect(claudeAdapter.extractResult(stdout)).toBe('');
-  });
-});
-
-describe('codexAdapter', () => {
-  it('invokes codex exec --json with the prompt on stdin and no per-role model', () => {
-    const inv = codexAdapter.invocation('draft', 'PROMPT');
-    expect(inv.cmd).toBe('codex');
-    expect(inv.args).toEqual(['exec', '--json']);
-    expect(inv.input).toBe('PROMPT');
-    // role-agnostic: review uses the same invocation
-    expect(codexAdapter.invocation('review', 'PROMPT').args).toEqual(['exec', '--json']);
-  });
-
-  it('extracts the last agent_message from the jsonl stream, skipping log/noise lines', () => {
-    const stdout = [
-      'some non-json log line',
-      JSON.stringify({ type: 'thread.started', thread_id: 'x' }),
-      JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'first' } }),
-      JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'final' } }),
-      JSON.stringify({ type: 'turn.completed' })
-    ].join('\n');
-    expect(codexAdapter.extractResult(stdout)).toBe('final');
-  });
-
-  it('returns an empty final agent_message, overriding an earlier non-empty one (last-wins on empty)', () => {
-    const stdout = [
-      JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: 'first' } }),
-      JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: '' } })
-    ].join('\n');
-    expect(codexAdapter.extractResult(stdout)).toBe('');
-  });
-
-  it('throws when no agent_message is present', () => {
-    expect(() => codexAdapter.extractResult('{"type":"turn.completed"}')).toThrow(/codex/i);
-  });
-
-  it('surfaces a turn.failed signal in the no-message error', () => {
-    const stdout = JSON.stringify({ type: 'turn.failed' });
-    expect(() => codexAdapter.extractResult(stdout)).toThrow(/turn\.failed/);
-  });
-});
-
-describe('copilotAdapter', () => {
-  it('pipes the prompt via stdin (not argv) so untrusted content stays out of argv', () => {
-    const inv = copilotAdapter.invocation('draft', 'PROMPT');
-    expect(inv.cmd).toBe('copilot');
-    expect(inv.args).toEqual(['--output-format', 'json', '--no-color']);
-    expect(inv.args).not.toContain('PROMPT');
-    expect(inv.input).toBe('PROMPT');
-  });
-
-  it('extracts the last assistant.message content from the jsonl stream, skipping deltas/result', () => {
-    const stdout = [
-      JSON.stringify({ type: 'assistant.message_delta', data: { deltaContent: 'the ' } }),
-      JSON.stringify({ type: 'assistant.message_delta', data: { deltaContent: 'answer' } }),
-      JSON.stringify({
-        type: 'assistant.message',
-        data: { content: 'the answer', toolRequests: [] }
-      }),
-      JSON.stringify({ type: 'result', exitCode: 0 })
-    ].join('\n');
-    expect(copilotAdapter.extractResult(stdout)).toBe('the answer');
-  });
-
-  it('returns an empty assistant.message content (does not editorialize)', () => {
-    const stdout = [
-      JSON.stringify({ type: 'assistant.message', data: { content: 'first', toolRequests: [] } }),
-      JSON.stringify({ type: 'assistant.message', data: { content: '', toolRequests: [] } })
-    ].join('\n');
-    expect(copilotAdapter.extractResult(stdout)).toBe('');
-  });
-
-  it('throws when no assistant.message is present', () => {
-    expect(() => copilotAdapter.extractResult('{"type":"result","exitCode":0}')).toThrow(
-      /copilot/i
-    );
-  });
-
-  it('surfaces a nonzero result exitCode in the no-message error', () => {
-    const stdout = JSON.stringify({ type: 'result', exitCode: 1 });
-    expect(() => copilotAdapter.extractResult(stdout)).toThrow(/exitCode 1/);
-  });
-});
-
-describe('adapterFor', () => {
-  it('returns the matching adapter', () => {
-    expect(adapterFor('claude')).toBe(claudeAdapter);
-    expect(adapterFor('codex')).toBe(codexAdapter);
-    expect(adapterFor('copilot')).toBe(copilotAdapter);
-  });
-});

package/src/__tests__/cli-client.test.ts

@@ -1,58 +0,0 @@
-// packages/client/src/__tests__/cli-client.test.ts
-import { describe, it, expect, vi } from 'vitest';
-import { CliModelClient } from '../model/cli/cli-client.js';
-import { claudeAdapter } from '../model/cli/adapters.js';
-import type { DraftRequest, ReviewRequest, ExtractedSkill } from '@skillit/core';
-
-const skill = { name: 'demo' } as unknown as ExtractedSkill;
-const draftReq: DraftRequest = {
-  toolName: 'gen',
-  tag: 'useWhen',
-  suggestion: 'say when',
-  currentValue: undefined,
-  skill
-};
-const reviewReq: ReviewRequest = {
-  toolName: 'gen',
-  tag: 'useWhen',
-  draft: 'When generating',
-  suggestion: 'say when',
-  skill
-};
-
-describe('CliModelClient', () => {
-  it('draft() returns the trimmed result extracted from the adapter envelope', async () => {
-    const runner = vi.fn(async () =>
-      JSON.stringify({ type: 'result', is_error: false, result: '  When generating output  ' })
-    );
-    const client = new CliModelClient(claudeAdapter, { runner });
-    const out = await client.draft(draftReq);
-    expect(out).toBe('When generating output');
-    // the adapter's invocation was forwarded to the runner
-    expect(runner).toHaveBeenCalledWith(
-      expect.objectContaining({ cmd: 'claude', args: expect.arrayContaining(['-p']) })
-    );
-  });
-
-  it('review() parses the verdict JSON out of the adapter result', async () => {
-    const runner = vi.fn(async () =>
-      JSON.stringify({
-        type: 'result',
-        is_error: false,
-        result: 'Sure: {"verdict":"revise","feedback":"too vague"}'
-      })
-    );
-    const client = new CliModelClient(claudeAdapter, { runner });
-    const res = await client.review(reviewReq);
-    expect(res).toEqual({ verdict: 'revise', feedback: 'too vague' });
-  });
-
-  it('passes the configured timeout through to the runner', async () => {
-    const runner = vi.fn(async () =>
-      JSON.stringify({ type: 'result', is_error: false, result: 'x' })
-    );
-    const client = new CliModelClient(claudeAdapter, { runner, timeoutMs: 5000 });
-    await client.draft(draftReq);
-    expect(runner).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 5000 }));
-  });
-});

package/src/__tests__/cli-run.test.ts

@@ -1,52 +0,0 @@
-// packages/client/src/__tests__/cli-run.test.ts
-import { describe, it, expect } from 'vitest';
-import { runCli } from '../model/cli/run.js';
-
-describe('runCli', () => {
-  it('returns stdout for a successful command', async () => {
-    const out = await runCli({ cmd: 'node', args: ['-e', 'process.stdout.write("hello")'] });
-    expect(out).toBe('hello');
-  });
-
-  it('writes input to stdin when provided', async () => {
-    const out = await runCli({
-      cmd: 'node',
-      args: ['-e', 'process.stdin.pipe(process.stdout)'],
-      input: 'piped-in'
-    });
-    expect(out).toBe('piped-in');
-  });
-
-  it('throws with the command and a stderr tail on non-zero exit', async () => {
-    await expect(
-      runCli({ cmd: 'node', args: ['-e', 'process.stderr.write("boom"); process.exit(3)'] })
-    ).rejects.toThrow(/node.*code 3.*boom/s);
-  });
-
-  it('does not leak args (e.g. a prompt passed as an argument) in the error', async () => {
-    let message = '';
-    try {
-      await runCli({ cmd: 'node', args: ['-e', 'process.exit(2)', 'SENSITIVE_PROMPT_TEXT'] });
-    } catch (error) {
-      message = error instanceof Error ? error.message : String(error);
-    }
-    expect(message).toMatch(/code 2/);
-    expect(message).not.toContain('SENSITIVE_PROMPT_TEXT');
-  });
-
-  it('rejects (does not crash on EPIPE) when the child exits before reading a large stdin prompt', async () => {
-    // 256 KB overflows the OS pipe buffer; the child exits without reading it,
-    // so the stdin write would EPIPE. Must reject with the exit code, not throw
-    // an unhandled stream error.
-    const bigPrompt = 'x'.repeat(256 * 1024);
-    await expect(
-      runCli({ cmd: 'node', args: ['-e', 'process.exit(1)'], input: bigPrompt })
-    ).rejects.toThrow(/code 1/);
-  });
-
-  it('throws a timeout error when the command exceeds timeoutMs', async () => {
-    await expect(
-      runCli({ cmd: 'node', args: ['-e', 'setTimeout(()=>{}, 10000)'], timeoutMs: 100 })
-    ).rejects.toThrow(/timed out after 100ms/);
-  });
-});

package/src/__tests__/detect-mode.test.ts

@@ -1,114 +0,0 @@
-import { detectRefineMode } from '../detect-mode.js';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-
-let tmpDir: string;
-
-afterEach(async () => {
-  if (tmpDir) await rm(tmpDir, { recursive: true, force: true });
-});
-
-describe('detectRefineMode', () => {
-  it('returns build when package.json has MCP SDK dependency', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    await writeFile(
-      join(tmpDir, 'package.json'),
-      JSON.stringify({ dependencies: { '@modelcontextprotocol/sdk': '^1.0.0' } })
-    );
-    expect(await detectRefineMode(tmpDir)).toBe('build');
-  });
-
-  it('returns runtime when mcp.json found in cwd', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    await writeFile(join(tmpDir, 'mcp.json'), '{}');
-    expect(await detectRefineMode(tmpDir)).toBe('runtime');
-  });
-
-  it('returns runtime when mcp.json found in ancestor', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    const sub = join(tmpDir, 'project');
-    await mkdir(sub, { recursive: true });
-    await writeFile(join(tmpDir, 'mcp.json'), '{}');
-    expect(await detectRefineMode(sub)).toBe('runtime');
-  });
-
-  it('returns ambiguous when both signals present', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    await writeFile(
-      join(tmpDir, 'package.json'),
-      JSON.stringify({ dependencies: { '@modelcontextprotocol/sdk': '^1.0.0' } })
-    );
-    await writeFile(join(tmpDir, 'mcp.json'), '{}');
-    expect(await detectRefineMode(tmpDir)).toBe('ambiguous');
-  });
-
-  it('returns ambiguous when neither signal present', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    expect(await detectRefineMode(tmpDir)).toBe('ambiguous');
-  });
-
-  it('returns build when package.json has a @modelcontextprotocol/server-* package', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    await writeFile(
-      join(tmpDir, 'package.json'),
-      JSON.stringify({ dependencies: { '@modelcontextprotocol/server-node': '^1.0.0' } })
-    );
-    expect(await detectRefineMode(tmpDir)).toBe('build');
-  });
-
-  it('returns runtime when mcpConfigPath is a known runtime config filename', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    // No mcp.json in cwd, no package.json — but --mcp points to a desktop config
-    expect(
-      await detectRefineMode(tmpDir, '/Users/example/.config/claude/claude_desktop_config.json')
-    ).toBe('runtime');
-  });
-
-  it('returns ambiguous (not build) when package.json only has @modelcontextprotocol/inspector', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    await writeFile(
-      join(tmpDir, 'package.json'),
-      JSON.stringify({ dependencies: { '@modelcontextprotocol/inspector': '^1.0.0' } })
-    );
-    // inspector is a consumer-only tool — should not signal build mode
-    expect(await detectRefineMode(tmpDir)).toBe('ambiguous');
-  });
-
-  it('returns ambiguous when cwd has MCP SDK dep AND mcpConfigPath is a runtime config', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    await writeFile(
-      join(tmpDir, 'package.json'),
-      JSON.stringify({ dependencies: { '@modelcontextprotocol/sdk': '^1.0.0' } })
-    );
-    expect(
-      await detectRefineMode(tmpDir, '/Users/example/.config/claude/claude_desktop_config.json')
-    ).toBe('ambiguous');
-  });
-
-  it('returns build when package.json is in an ancestor directory (monorepo nested cwd)', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    await writeFile(
-      join(tmpDir, 'package.json'),
-      JSON.stringify({ dependencies: { '@modelcontextprotocol/sdk': '^1.0.0' } })
-    );
-    const nested = join(tmpDir, 'packages', 'my-server', 'src');
-    await mkdir(nested, { recursive: true });
-    expect(await detectRefineMode(nested)).toBe('build');
-  });
-
-  it('returns runtime when mcpConfigPath contains mcpServers key (custom basename)', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    const configPath = join(tmpDir, 'my-custom-config.json');
-    await writeFile(configPath, JSON.stringify({ mcpServers: { myServer: {} } }));
-    expect(await detectRefineMode(tmpDir, configPath)).toBe('runtime');
-  });
-
-  it('returns ambiguous when mcpConfigPath has unknown basename and no mcpServers key', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-'));
-    const configPath = join(tmpDir, 'settings.json');
-    await writeFile(configPath, JSON.stringify({ someOtherKey: true }));
-    expect(await detectRefineMode(tmpDir, configPath)).toBe('ambiguous');
-  });
-});

package/src/__tests__/detect-source.test.ts

@@ -1,158 +0,0 @@
-import {
-  detectInstalledSources,
-  detectPackageManager,
-  detectProjectNature,
-  detectRefineSource
-} from '../detect-source.js';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { afterEach, describe, expect, it } from 'vitest';
-
-let tmpDir: string;
-
-afterEach(async () => {
-  if (tmpDir) await rm(tmpDir, { recursive: true, force: true });
-});
-
-async function writePkg(deps: Record<string, unknown>): Promise<string> {
-  tmpDir = await mkdtemp(join(tmpdir(), 'detect-source-'));
-  await writeFile(join(tmpDir, 'package.json'), JSON.stringify(deps));
-  return tmpDir;
-}
-
-describe('detectRefineSource', () => {
-  it('returns cli when only @skillit/cli is installed', async () => {
-    const dir = await writePkg({ dependencies: { '@skillit/cli': 'workspace:*' } });
-    expect(await detectRefineSource(dir)).toBe('cli');
-  });
-
-  it('returns mcp when only @skillit/mcp is installed', async () => {
-    const dir = await writePkg({ dependencies: { '@skillit/mcp': 'workspace:*' } });
-    expect(await detectRefineSource(dir)).toBe('mcp');
-  });
-
-  it('returns typedoc when typedoc-plugin-skillit is installed', async () => {
-    const dir = await writePkg({ devDependencies: { 'typedoc-plugin-skillit': '^1.0.0' } });
-    expect(await detectRefineSource(dir)).toBe('typedoc');
-  });
-
-  it('returns typedoc when @skillit/typedoc is installed', async () => {
-    const dir = await writePkg({ devDependencies: { '@skillit/typedoc': 'workspace:*' } });
-    expect(await detectRefineSource(dir)).toBe('typedoc');
-  });
-
-  it('returns ambiguous when cli and mcp are both installed', async () => {
-    const dir = await writePkg({
-      dependencies: { '@skillit/cli': 'workspace:*', '@skillit/mcp': 'workspace:*' }
-    });
-    expect(await detectRefineSource(dir)).toBe('ambiguous');
-  });
-
-  it('returns none when no skillit source package is installed', async () => {
-    const dir = await writePkg({ dependencies: { commander: '^14.0.0' } });
-    expect(await detectRefineSource(dir)).toBe('none');
-  });
-
-  it('returns none when package.json is missing or unreadable', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-source-'));
-    expect(await detectRefineSource(tmpDir)).toBe('none');
-  });
-});
-
-describe('detectInstalledSources', () => {
-  it('returns the deduped candidate list in stable order', async () => {
-    const dir = await writePkg({
-      dependencies: { '@skillit/mcp': 'workspace:*', '@skillit/cli': 'workspace:*' }
-    });
-    expect(await detectInstalledSources(dir)).toEqual(['cli', 'mcp']);
-  });
-
-  it('returns an empty list when no source package is installed', async () => {
-    const dir = await writePkg({ dependencies: { commander: '^14.0.0' } });
-    expect(await detectInstalledSources(dir)).toEqual([]);
-  });
-
-  it('returns an empty list when package.json is missing or unreadable', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-source-'));
-    expect(await detectInstalledSources(tmpDir)).toEqual([]);
-  });
-});
-
-describe('detectProjectNature', () => {
-  it('returns cli when commander is a dependency', async () => {
-    const dir = await writePkg({ dependencies: { commander: '^14.0.0' } });
-    expect(await detectProjectNature(dir)).toBe('cli');
-  });
-
-  it('returns cli when yargs is a dependency', async () => {
-    const dir = await writePkg({ dependencies: { yargs: '^17.0.0' } });
-    expect(await detectProjectNature(dir)).toBe('cli');
-  });
-
-  it('returns mcp when @modelcontextprotocol/sdk is a dependency', async () => {
-    const dir = await writePkg({ dependencies: { '@modelcontextprotocol/sdk': '^1.0.0' } });
-    expect(await detectProjectNature(dir)).toBe('mcp');
-  });
-
-  it('prefers cli over mcp when both indicators are present', async () => {
-    const dir = await writePkg({
-      dependencies: { commander: '^14.0.0', '@modelcontextprotocol/sdk': '^1.0.0' }
-    });
-    expect(await detectProjectNature(dir)).toBe('cli');
-  });
-
-  it('returns cli when a loadable bin exports a commander Command (no dep)', async () => {
-    // The bin fixture lives in-workspace so its `commander` import resolves;
-    // the temp dir only holds a package.json pointing `bin` at it.
-    const binPath = fileURLToPath(new URL('./fixtures/bin-with-program.mjs', import.meta.url));
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-source-'));
-    await writeFile(
-      join(tmpDir, 'package.json'),
-      JSON.stringify({ name: 'bin-only', bin: binPath })
-    );
-    expect(await detectProjectNature(tmpDir)).toBe('cli');
-  });
-
-  it('falls through to mcp when the bin does not load a commander Command', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-source-'));
-    await writeFile(
-      join(tmpDir, 'package.json'),
-      JSON.stringify({
-        name: 'mcp-no-bin',
-        dependencies: { '@modelcontextprotocol/sdk': '^1.0.0' }
-      })
-    );
-    expect(await detectProjectNature(tmpDir)).toBe('mcp');
-  });
-
-  it('returns typedoc for a plain TS library', async () => {
-    const dir = await writePkg({ dependencies: { zod: '^3.0.0' } });
-    expect(await detectProjectNature(dir)).toBe('typedoc');
-  });
-
-  it('returns typedoc when package.json is missing', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-source-'));
-    expect(await detectProjectNature(tmpDir)).toBe('typedoc');
-  });
-});
-
-describe('detectPackageManager', () => {
-  it('returns pnpm when pnpm-lock.yaml is present', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-source-'));
-    await writeFile(join(tmpDir, 'pnpm-lock.yaml'), '');
-    expect(detectPackageManager(tmpDir)).toBe('pnpm');
-  });
-
-  it('returns yarn when yarn.lock is present', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-source-'));
-    await writeFile(join(tmpDir, 'yarn.lock'), '');
-    expect(detectPackageManager(tmpDir)).toBe('yarn');
-  });
-
-  it('returns npm when no lockfile is present', async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'detect-source-'));
-    expect(detectPackageManager(tmpDir)).toBe('npm');
-  });
-});

package/src/__tests__/fixtures/bin-with-program.mjs

@@ -1,6 +0,0 @@
-import { Command } from 'commander';
-
-const program = new Command().name('bin-tool');
-program.command('build').description('Build the project');
-
-export { program };