@skillit/client 0.2.0 → 0.4.0

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 };

package/src/__tests__/init.test.ts

@@ -1,218 +0,0 @@
-import { buildInitCommand, type GenerateSkillOpts, type InitDeps } from '../commands/init.js';
-import type { RefineCommandOpts } from '../commands/refine.js';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-let tmpDir: string;
-let prevCwd: string;
-
-beforeEach(() => {
-  prevCwd = process.cwd();
-});
-
-afterEach(async () => {
-  process.chdir(prevCwd);
-  if (tmpDir) await rm(tmpDir, { recursive: true, force: true });
-});
-
-/**
- * A cli-nature project with a pnpm lockfile. Returns the realized cwd
- * (`process.cwd()` after chdir), since macOS resolves `/tmp` → `/private/tmp`.
- */
-async function writeCliFixture(): Promise<string> {
-  tmpDir = await mkdtemp(join(tmpdir(), 'init-'));
-  await writeFile(
-    join(tmpDir, 'package.json'),
-    JSON.stringify({ name: '@scope/my-tool', dependencies: { commander: '^14.0.0' } })
-  );
-  await writeFile(join(tmpDir, 'pnpm-lock.yaml'), '');
-  process.chdir(tmpDir);
-  return process.cwd();
-}
-
-/** An mcp-nature project (no commander/yargs, no loadable bin). */
-async function writeMcpFixture(): Promise<string> {
-  tmpDir = await mkdtemp(join(tmpdir(), 'init-'));
-  await writeFile(
-    join(tmpDir, 'package.json'),
-    JSON.stringify({
-      name: 'my-server',
-      dependencies: { '@modelcontextprotocol/sdk': '^1.0.0' }
-    })
-  );
-  await writeFile(join(tmpDir, 'pnpm-lock.yaml'), '');
-  process.chdir(tmpDir);
-  return process.cwd();
-}
-
-interface InstallCall {
-  pkg: string;
-  pm: string;
-  cwd: string;
-}
-
-function makeStubs(overrides?: Partial<InitDeps>): {
-  deps: InitDeps;
-  installCalls: InstallCall[];
-  generateCalls: GenerateSkillOpts[];
-  refineCalls: unknown[];
-} {
-  const installCalls: InstallCall[] = [];
-  const generateCalls: GenerateSkillOpts[] = [];
-  const refineCalls: unknown[] = [];
-  const deps: InitDeps = {
-    runInstall: async (pkg, pm, cwd) => {
-      installCalls.push({ pkg, pm, cwd });
-    },
-    generateSkill: async (opts) => {
-      generateCalls.push(opts);
-    },
-    runRefine: async (opts) => {
-      refineCalls.push(opts);
-    },
-    ...overrides
-  };
-  return { deps, installCalls, generateCalls, refineCalls };
-}
-
-async function run(deps: InitDeps, argv: string[] = []): Promise<void> {
-  const cmd = buildInitCommand(deps);
-  await cmd.parseAsync(argv, { from: 'user' });
-}
-
-describe('buildInitCommand', () => {
-  it('chooses @skillit/cli with the detected pnpm add command for a cli project', async () => {
-    const dir = await writeCliFixture();
-    const { deps, installCalls } = makeStubs();
-    await run(deps);
-    expect(installCalls).toHaveLength(1);
-    expect(installCalls[0]!.pkg).toBe('@skillit/cli');
-    expect(installCalls[0]!.pm).toBe('pnpm');
-    expect(installCalls[0]!.cwd).toBe(dir);
-  });
-
-  it('generates the skill into <cwd>/skills before and after refine', async () => {
-    const dir = await writeCliFixture();
-    const { deps, generateCalls } = makeStubs();
-    await run(deps);
-    // Generated once before refine (initial) and once after (reflecting the
-    // freshly-written JSDoc), both into the same out dir.
-    expect(generateCalls).toHaveLength(2);
-    expect(generateCalls[0]!.outDir).toBe(join(dir, 'skills'));
-    expect(generateCalls[1]!.outDir).toBe(join(dir, 'skills'));
-  });
-
-  it('runs refine between the initial generate and the post-refine regenerate', async () => {
-    await writeCliFixture();
-    const order: string[] = [];
-    const { deps } = makeStubs({
-      generateSkill: async () => {
-        order.push('generate');
-      },
-      runRefine: async () => {
-        order.push('refine');
-      }
-    });
-    await run(deps);
-    expect(order).toEqual(['generate', 'refine', 'generate']);
-  });
-
-  it('dispatches refine with the cli source', async () => {
-    await writeCliFixture();
-    const { deps, refineCalls } = makeStubs();
-    await run(deps);
-    expect(refineCalls).toHaveLength(1);
-    expect((refineCalls[0] as { source?: string }).source).toBe('cli');
-  });
-
-  it('respects an explicit --out directory', async () => {
-    const dir = await writeCliFixture();
-    const { deps, generateCalls } = makeStubs();
-    await run(deps, ['--out', 'docs/skills']);
-    expect(generateCalls[0]!.outDir).toBe(join(dir, 'docs/skills'));
-  });
-
-  it('throws with the exact command on install failure and skips generate + refine', async () => {
-    await writeCliFixture();
-    const generate = vi.fn();
-    const refine = vi.fn();
-    const { deps } = makeStubs({
-      runInstall: async (pkg, pm) => {
-        throw new Error(`install of ${pkg} via ${pm} failed`);
-      },
-      generateSkill: generate,
-      runRefine: refine
-    });
-    await expect(run(deps)).rejects.toThrow(/pnpm add -D @skillit\/cli/);
-    expect(generate).not.toHaveBeenCalled();
-    expect(refine).not.toHaveBeenCalled();
-  });
-
-  it('rejects an invalid --source value', async () => {
-    await writeCliFixture();
-    const { deps } = makeStubs();
-    await expect(run(deps, ['--source', 'bogus'])).rejects.toThrow(/cli\|mcp\|typedoc/);
-  });
-
-  it("degrades gracefully (no throw, no refine, prints guidance) when the cli program won't load", async () => {
-    await writeCliFixture();
-    const refine = vi.fn();
-    const { deps } = makeStubs({
-      generateSkill: async () => {
-        throw new Error('not a commander program');
-      },
-      runRefine: refine
-    });
-    // Capture via plain reassignment: vitest's console interceptor bypasses
-    // vi.spyOn(console, 'log') under this config.
-    const logged: string[] = [];
-    const originalLog = console.log;
-    console.log = (...args: unknown[]): void => {
-      logged.push(String(args[0]));
-    };
-    try {
-      await expect(run(deps)).resolves.toBeUndefined();
-    } finally {
-      console.log = originalLog;
-    }
-    expect(refine).not.toHaveBeenCalled();
-    const out = logged.join('\n');
-    expect(out).toMatch(/Installed @skillit\/cli/);
-    expect(out).toMatch(/not a commander program/);
-    expect(out).toMatch(/skillit refine --source cli --program/);
-  });
-
-  it('installs @skillit/mcp but skips generate + refine for an mcp project', async () => {
-    await writeMcpFixture();
-    const { deps, installCalls, generateCalls, refineCalls } = makeStubs();
-    // Override console.log directly: vitest's console interceptor bypasses
-    // vi.spyOn(console, 'log') here, so capture via a plain reassignment.
-    const logged: string[] = [];
-    const originalLog = console.log;
-    console.log = (...args: unknown[]): void => {
-      logged.push(String(args[0]));
-    };
-    try {
-      await run(deps);
-    } finally {
-      console.log = originalLog;
-    }
-    expect(installCalls).toHaveLength(1);
-    expect(installCalls[0]!.pkg).toBe('@skillit/mcp');
-    // CLI-first: no auto generate or refine for the mcp source this pass.
-    expect(generateCalls).toHaveLength(0);
-    expect(refineCalls).toHaveLength(0);
-    expect(logged.join('\n')).toMatch(/skillit refine --source mcp/);
-  });
-
-  it('threads --model-client and --model-cli-timeout into the refine dispatch', async () => {
-    await writeCliFixture();
-    const { deps, refineCalls } = makeStubs();
-    await run(deps, ['--source', 'cli', '--model-client', 'claude', '--model-cli-timeout', '7000']);
-    const opts = refineCalls[0] as RefineCommandOpts;
-    expect(opts.modelClient).toBe('claude');
-    expect(opts.modelCliTimeout).toBe('7000');
-  });
-});

package/src/__tests__/model-client-factory.test.ts

@@ -1,28 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createModelClient } from '../model/model-client-factory.js';
-import { AnthropicModelClient } from '../model/anthropic.js';
-import { CliModelClient } from '../model/cli/cli-client.js';
-
-describe('createModelClient', () => {
-  it("returns an AnthropicModelClient for 'api'", () => {
-    expect(createModelClient('api')).toBeInstanceOf(AnthropicModelClient);
-  });
-
-  it('returns a CliModelClient for a cli kind whose binary is present', () => {
-    // inject a pre-flight that reports the binary exists
-    const client = createModelClient('claude', { hasBinary: () => true });
-    expect(client).toBeInstanceOf(CliModelClient);
-  });
-
-  it('throws an actionable error when the cli binary is missing', () => {
-    expect(() => createModelClient('codex', { hasBinary: () => false })).toThrow(
-      /codex CLI not found on PATH.*--model-client api/s
-    );
-  });
-
-  it('throws on an invalid kind', () => {
-    expect(() => createModelClient('bogus')).toThrow(
-      /invalid --model-client.*api\|claude\|codex\|copilot/s
-    );
-  });
-});

package/src/__tests__/refine-resolve.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveModelClientKind, resolveRefineSource } from '../commands/refine.js';
-
-describe('resolveModelClientKind', () => {
-  it("defaults to 'api' when --model-client is omitted", () => {
-    expect(resolveModelClientKind(undefined)).toBe('api');
-  });
-  it('passes through a provided kind', () => {
-    expect(resolveModelClientKind('claude')).toBe('claude');
-  });
-});
-
-describe('resolveRefineSource', () => {
-  it('explicit --source cli wins over detection', () => {
-    const res = resolveRefineSource({ source: 'cli' }, 'mcp');
-    expect(res).toEqual({ kind: 'cli' });
-  });
-
-  it('explicit --source mcp requires --mcp', () => {
-    const res = resolveRefineSource({ source: 'mcp' }, 'none');
-    expect('error' in res && res.error).toMatch(/--mcp/);
-  });
-
-  it('explicit --source mcp with --mcp resolves to mcp', () => {
-    const res = resolveRefineSource({ source: 'mcp', mcp: 'mcp.json' }, 'none');
-    expect(res).toEqual({ kind: 'mcp' });
-  });
-
-  it('rejects an invalid --source value', () => {
-    const res = resolveRefineSource({ source: 'bogus' }, 'cli');
-    expect('error' in res && res.error).toMatch(/cli|mcp|typedoc/);
-  });
-
-  it('falls back to detection when --source is omitted', () => {
-    const res = resolveRefineSource({}, 'cli');
-    expect(res).toEqual({ kind: 'cli' });
-  });
-
-  it('detected mcp still requires --mcp', () => {
-    const res = resolveRefineSource({}, 'mcp');
-    expect('error' in res && res.error).toMatch(/--mcp/);
-  });
-
-  it('detected mcp with --mcp resolves to mcp', () => {
-    const res = resolveRefineSource({ mcp: 'mcp.json' }, 'mcp');
-    expect(res).toEqual({ kind: 'mcp' });
-  });
-
-  it('errors on ambiguous detection listing candidates and --source form', () => {
-    const res = resolveRefineSource({}, 'ambiguous', ['cli', 'mcp']);
-    const error = 'error' in res ? res.error : '';
-    expect(error).toMatch(/--source <cli\|mcp\|typedoc>/);
-    expect(error).toMatch(/cli/);
-    expect(error).toMatch(/mcp/);
-    expect(error).toMatch(/found: cli, mcp/);
-  });
-
-  it('errors on no detected source with the --source form', () => {
-    const res = resolveRefineSource({}, 'none');
-    expect('error' in res && res.error).toMatch(/--source <cli\|mcp\|typedoc>/);
-  });
-
-  it('errors that typedoc is not yet supported', () => {
-    const res = resolveRefineSource({ source: 'typedoc' }, 'none');
-    expect('error' in res && res.error).toMatch(/not yet supported/);
-  });
-
-  it('errors that detected typedoc is not yet supported', () => {
-    const res = resolveRefineSource({}, 'typedoc');
-    expect('error' in res && res.error).toMatch(/not yet supported/);
-  });
-});

package/src/bin.ts

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-// packages/client/src/bin.ts
-import { Command } from 'commander';
-import { buildMcpCommand, reportMcpErrorAndExit } from '@skillit/mcp';
-import { buildInitCommand } from './commands/init.js';
-import { buildRefineCommand } from './commands/refine.js';
-
-const program = new Command('skillit').description('skillit CLI').version('0.1.0');
-
-program.addCommand(buildRefineCommand());
-program.addCommand(buildInitCommand());
-program.addCommand(buildMcpCommand());
-
-program.parseAsync(process.argv).catch((err: unknown) => {
-  // Preserve the mcp exit-code contract for the `skillit mcp …` path; other
-  // errors keep the prior generic behavior (stderr message + exit 1).
-  reportMcpErrorAndExit(err);
-});