@openpkg-ts/cli 0.3.0 → 0.3.1

package/src/commands/docs.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import type { OpenPkg } from '@openpkg-ts/spec';
-import { $ } from 'bun';
-
-const testSpec: OpenPkg = {
-  meta: { name: 'test-pkg', version: '1.0.0' },
-  exports: [
-    { id: 'fn-hello', name: 'hello', kind: 'function', signatures: [] },
-    { id: 'fn-world', name: 'world', kind: 'function', signatures: [] },
-  ],
-  types: [],
-};
-
-describe('docs command --adapter', () => {
-  test('--adapter fumadocs generates docs', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'docs-adapter-test-'));
-    const specPath = path.join(tmpDir, 'spec.json');
-    const outDir = path.join(tmpDir, 'out');
-
-    fs.writeFileSync(specPath, JSON.stringify(testSpec));
-
-    await $`bun packages/cli/bin/openpkg.ts docs ${specPath} --adapter fumadocs --output ${outDir}`.text();
-
-    expect(fs.existsSync(outDir)).toBe(true);
-    expect(fs.existsSync(path.join(outDir, 'hello.md'))).toBe(true);
-    expect(fs.existsSync(path.join(outDir, 'world.md'))).toBe(true);
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  test('--adapter raw falls through to default', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'docs-adapter-test-'));
-    const specPath = path.join(tmpDir, 'spec.json');
-
-    fs.writeFileSync(specPath, JSON.stringify(testSpec));
-
-    const result = await $`bun packages/cli/bin/openpkg.ts docs ${specPath} --adapter raw`.text();
-
-    expect(result).toContain('hello');
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  test('--adapter unknown exits with error', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'docs-adapter-test-'));
-    const specPath = path.join(tmpDir, 'spec.json');
-    const outDir = path.join(tmpDir, 'out');
-
-    fs.writeFileSync(specPath, JSON.stringify(testSpec));
-
-    const result = await $`bun packages/cli/bin/openpkg.ts docs ${specPath} --adapter unknown --output ${outDir}`.nothrow();
-
-    expect(result.exitCode).toBe(1);
-    // Error is written to stderr as JSON
-    const stderr = result.stderr.toString();
-    expect(stderr).toContain('Failed to load adapter');
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-});

package/src/commands/docs.ts

@@ -1,191 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { createDocs, type DocsInstance, loadSpec } from '@openpkg-ts/sdk';
-import type { OpenPkg } from '@openpkg-ts/spec';
-import { Command } from 'commander';
-
-type OutputFormat = 'md' | 'json' | 'html';
-
-interface DocsCommandOptions {
-  output?: string;
-  format?: OutputFormat;
-  split?: boolean;
-  export?: string;
-  adapter?: string;
-}
-
-async function readStdin(): Promise<string> {
-  const chunks: Buffer[] = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString('utf-8');
-}
-
-function getExtension(format: OutputFormat): string {
-  switch (format) {
-    case 'json':
-      return '.json';
-    case 'html':
-      return '.html';
-    default:
-      return '.md';
-  }
-}
-
-function renderExport(docs: DocsInstance, exportId: string, format: OutputFormat): string {
-  const exp = docs.getExport(exportId);
-  if (!exp) throw new Error(`Export not found: ${exportId}`);
-
-  switch (format) {
-    case 'json':
-      return JSON.stringify(docs.toJSON({ export: exportId }), null, 2);
-    case 'html':
-      return docs.toHTML({ export: exportId });
-    default:
-      return docs.toMarkdown({ export: exportId, frontmatter: true, codeSignatures: true });
-  }
-}
-
-function renderFull(docs: DocsInstance, format: OutputFormat): string {
-  switch (format) {
-    case 'json':
-      return JSON.stringify(docs.toJSON(), null, 2);
-    case 'html':
-      return docs.toHTML();
-    default:
-      return docs.toMarkdown({ frontmatter: true, codeSignatures: true });
-  }
-}
-
-export function createDocsCommand(): Command {
-  return new Command('docs')
-    .description('Generate documentation from OpenPkg spec')
-    .argument('<spec>', 'Path to openpkg.json spec file (use - for stdin)')
-    .option('-o, --output <path>', 'Output file or directory (default: stdout)')
-    .option('-f, --format <format>', 'Output format: md, json, html (default: md)', 'md')
-    .option('--split', 'Output one file per export (requires --output as directory)')
-    .option('-e, --export <name>', 'Generate docs for a single export by name')
-    .option('-a, --adapter <name>', 'Use adapter for generation (default: raw)')
-    .action(async (specPath: string, options: DocsCommandOptions) => {
-      const format = (options.format || 'md') as OutputFormat;
-
-      try {
-        // Handle adapter mode
-        if (options.adapter && options.adapter !== 'raw') {
-          // Dynamic import adapter to trigger self-registration
-          let getAdapter: typeof import('@openpkg-ts/adapters').getAdapter;
-          try {
-            const adapterModule = await import(`@openpkg-ts/adapters/${options.adapter}`);
-            const registryModule = await import('@openpkg-ts/adapters');
-            getAdapter = registryModule.getAdapter;
-          } catch {
-            console.error(JSON.stringify({ error: `Failed to load adapter: ${options.adapter}` }));
-            process.exit(1);
-          }
-
-          const adapter = getAdapter(options.adapter);
-          if (!adapter) {
-            console.error(JSON.stringify({ error: `Unknown adapter: ${options.adapter}` }));
-            process.exit(1);
-          }
-
-          if (!options.output) {
-            console.error(JSON.stringify({ error: '--adapter requires --output <directory>' }));
-            process.exit(1);
-          }
-
-          // Load spec
-          let spec: OpenPkg;
-          if (specPath === '-') {
-            const input = await readStdin();
-            spec = JSON.parse(input);
-          } else {
-            const specFile = path.resolve(specPath);
-            if (!fs.existsSync(specFile)) {
-              console.error(JSON.stringify({ error: `Spec file not found: ${specFile}` }));
-              process.exit(1);
-            }
-            spec = JSON.parse(fs.readFileSync(specFile, 'utf-8'));
-          }
-
-          await adapter.generate(spec, path.resolve(options.output));
-          console.error(`Generated docs with ${options.adapter} adapter to ${options.output}`);
-          return;
-        }
-
-        let docs: DocsInstance;
-
-        // Handle stdin
-        if (specPath === '-') {
-          const input = await readStdin();
-          const spec: OpenPkg = JSON.parse(input);
-          docs = loadSpec(spec);
-        } else {
-          const specFile = path.resolve(specPath);
-          if (!fs.existsSync(specFile)) {
-            console.error(JSON.stringify({ error: `Spec file not found: ${specFile}` }));
-            process.exit(1);
-          }
-          docs = createDocs(specFile);
-        }
-
-        // Single export mode
-        if (options.export) {
-          const exports = docs.getAllExports();
-          const exp = exports.find(e => e.name === options.export);
-          if (!exp) {
-            console.error(JSON.stringify({ error: `Export not found: ${options.export}` }));
-            process.exit(1);
-          }
-          const output = renderExport(docs, exp.id, format);
-          if (options.output && options.output !== '-') {
-            const outputPath = path.resolve(options.output);
-            fs.writeFileSync(outputPath, output);
-            console.error(`Wrote ${outputPath}`);
-          } else {
-            console.log(output);
-          }
-          return;
-        }
-
-        // Split mode: one file per export
-        if (options.split) {
-          if (!options.output) {
-            console.error(JSON.stringify({ error: '--split requires --output <directory>' }));
-            process.exit(1);
-          }
-
-          const outDir = path.resolve(options.output);
-          if (!fs.existsSync(outDir)) {
-            fs.mkdirSync(outDir, { recursive: true });
-          }
-
-          const exports = docs.getAllExports();
-          for (const exp of exports) {
-            const filename = `${exp.name}${getExtension(format)}`;
-            const filePath = path.join(outDir, filename);
-            const content = renderExport(docs, exp.id, format);
-            fs.writeFileSync(filePath, content);
-          }
-          console.error(`Wrote ${exports.length} files to ${outDir}`);
-          return;
-        }
-
-        // Single output mode
-        const output = renderFull(docs, format);
-
-        if (options.output && options.output !== '-') {
-          const outputPath = path.resolve(options.output);
-          fs.writeFileSync(outputPath, output);
-          console.error(`Wrote ${outputPath}`);
-        } else {
-          console.log(output);
-        }
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        console.error(JSON.stringify({ error: error.message }));
-        process.exit(1);
-      }
-    });
-}

package/src/commands/filter.test.ts

@@ -1,210 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { $ } from 'bun';
-
-describe('openpkg filter', () => {
-  let tmpDir: string;
-  let specPath: string;
-
-  const spec = {
-    openpkg: '0.4.0',
-    meta: { name: 'test-pkg' },
-    exports: [
-      { id: 'a', name: 'myFunction', kind: 'function', description: 'A function' },
-      { id: 'b', name: 'MyClass', kind: 'class', description: 'A class' },
-      { id: 'c', name: 'myVar', kind: 'variable' },
-      { id: 'd', name: 'deprecatedFn', kind: 'function', deprecated: true, description: 'Old' },
-      {
-        id: 'e',
-        name: 'taggedFn',
-        kind: 'function',
-        tags: [{ name: 'beta' }],
-        description: 'Beta feature',
-      },
-      {
-        id: 'f',
-        name: 'anotherClass',
-        kind: 'class',
-        source: { file: 'src/utils/helpers.ts' },
-      },
-    ],
-  };
-
-  beforeAll(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'filter-test-'));
-    specPath = path.join(tmpDir, 'spec.json');
-    fs.writeFileSync(specPath, JSON.stringify(spec));
-  });
-
-  afterAll(() => {
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it('filters by kind', async () => {
-    const output = await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --kind function`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(3);
-    expect(result.total).toBe(6);
-    expect(result.spec.exports.every((e: { kind: string }) => e.kind === 'function')).toBe(true);
-  });
-
-  it('filters by multiple kinds', async () => {
-    const output =
-      await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --kind function,class`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(5);
-  });
-
-  it('filters by name', async () => {
-    const output =
-      await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --name myFunction,MyClass`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(2);
-  });
-
-  it('filters by deprecated flag', async () => {
-    const output = await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --deprecated`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(1);
-    expect(result.spec.exports[0].name).toBe('deprecatedFn');
-  });
-
-  it('filters by non-deprecated', async () => {
-    const output =
-      await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --no-deprecated`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(5);
-  });
-
-  it('filters by has-description', async () => {
-    const output =
-      await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --has-description`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(4);
-  });
-
-  it('filters by missing-description', async () => {
-    const output =
-      await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --missing-description`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(2);
-  });
-
-  it('filters by search term', async () => {
-    const output = await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --search beta`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(1);
-    expect(result.spec.exports[0].name).toBe('taggedFn');
-  });
-
-  it('filters by tag', async () => {
-    const output = await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --tag beta`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(1);
-    expect(result.spec.exports[0].name).toBe('taggedFn');
-  });
-
-  it('filters by module path', async () => {
-    const output =
-      await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --module src/utils`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(1);
-    expect(result.spec.exports[0].name).toBe('anotherClass');
-  });
-
-  it('combines filters with AND logic', async () => {
-    const output =
-      await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --kind function --has-description`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(3);
-  });
-
-  it('outputs summary only with --summary', async () => {
-    const output =
-      await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --kind function --summary`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(3);
-    expect(result.total).toBe(6);
-    expect(result.spec).toBeUndefined();
-  });
-
-  it('outputs raw spec with --quiet', async () => {
-    const output =
-      await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --kind function --quiet`.text();
-    const result = JSON.parse(output);
-
-    expect(result.openpkg).toBe('0.4.0');
-    expect(result.exports.length).toBe(3);
-    expect(result.matched).toBeUndefined();
-  });
-
-  it('writes to file with --output', async () => {
-    const outPath = path.join(tmpDir, 'filtered.json');
-    await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --kind class -o ${outPath}`.text();
-
-    const content = JSON.parse(fs.readFileSync(outPath, 'utf-8'));
-    expect(content.matched).toBe(2);
-  });
-
-  it('errors on invalid kind', async () => {
-    const proc = await $`bun packages/cli/bin/openpkg.ts filter ${specPath} --kind invalid`
-      .nothrow()
-      .quiet();
-    const result = JSON.parse(proc.stderr.toString());
-
-    expect(result.error).toContain('Invalid kind(s): invalid');
-    expect(result.error).toContain('Valid kinds:');
-  });
-
-  it('returns all exports with no criteria', async () => {
-    const output = await $`bun packages/cli/bin/openpkg.ts filter ${specPath}`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(6);
-    expect(result.total).toBe(6);
-  });
-
-  it('handles empty spec', async () => {
-    const emptyPath = path.join(tmpDir, 'empty.json');
-    fs.writeFileSync(emptyPath, JSON.stringify({ openpkg: '0.4.0', meta: {}, exports: [] }));
-
-    const output = await $`bun packages/cli/bin/openpkg.ts filter ${emptyPath} --kind function`.text();
-    const result = JSON.parse(output);
-
-    expect(result.matched).toBe(0);
-    expect(result.total).toBe(0);
-  });
-
-  it('errors on malformed JSON', async () => {
-    const badPath = path.join(tmpDir, 'bad.json');
-    fs.writeFileSync(badPath, '{ invalid json }');
-
-    const proc = await $`bun packages/cli/bin/openpkg.ts filter ${badPath}`.nothrow().quiet();
-    const result = JSON.parse(proc.stderr.toString());
-
-    expect(result.error).toBeDefined();
-  });
-
-  it('errors on missing file', async () => {
-    const proc = await $`bun packages/cli/bin/openpkg.ts filter /nonexistent/path.json`
-      .nothrow()
-      .quiet();
-    const result = JSON.parse(proc.stderr.toString());
-
-    expect(result.error).toBeDefined();
-  });
-});

package/src/commands/filter.ts

@@ -1,131 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { filterSpec, type FilterCriteria } from '@openpkg-ts/sdk';
-import type { OpenPkg, SpecExportKind } from '@openpkg-ts/spec';
-import { Command } from 'commander';
-
-const VALID_KINDS: SpecExportKind[] = [
-  'function',
-  'class',
-  'variable',
-  'interface',
-  'type',
-  'enum',
-  'module',
-  'namespace',
-  'reference',
-  'external',
-];
-
-export type FilterResult = {
-  spec: OpenPkg;
-  matched: number;
-  total: number;
-};
-
-export type FilterSummaryResult = {
-  matched: number;
-  total: number;
-};
-
-function loadSpec(filePath: string): OpenPkg {
-  const resolved = path.resolve(filePath);
-  const content = fs.readFileSync(resolved, 'utf-8');
-  return JSON.parse(content) as OpenPkg;
-}
-
-function parseList(val?: string): string[] | undefined {
-  if (!val) return undefined;
-  return val
-    .split(',')
-    .map((s) => s.trim())
-    .filter(Boolean);
-}
-
-function validateKinds(kinds: string[]): SpecExportKind[] {
-  const invalid = kinds.filter((k) => !VALID_KINDS.includes(k as SpecExportKind));
-  if (invalid.length > 0) {
-    throw new Error(`Invalid kind(s): ${invalid.join(', ')}. Valid kinds: ${VALID_KINDS.join(', ')}`);
-  }
-  return kinds as SpecExportKind[];
-}
-
-export function createFilterCommand(): Command {
-  return new Command('filter')
-    .description('Filter an OpenPkg spec by various criteria')
-    .argument('<spec>', 'Path to spec file (JSON)')
-    .option('--kind <kinds>', 'Filter by kinds (comma-separated)')
-    .option('--name <names>', 'Filter by exact names (comma-separated)')
-    .option('--id <ids>', 'Filter by IDs (comma-separated)')
-    .option('--tag <tags>', 'Filter by tags (comma-separated)')
-    .option('--deprecated', 'Only deprecated exports')
-    .option('--no-deprecated', 'Exclude deprecated exports')
-    .option('--has-description', 'Only exports with descriptions')
-    .option('--missing-description', 'Only exports without descriptions')
-    .option('--search <term>', 'Search name/description (case-insensitive)')
-    .option('--module <path>', 'Filter by source file path (contains)')
-    .option('-o, --output <file>', 'Output file (default: stdout)')
-    .option('--summary', 'Only output matched/total counts')
-    .option('--quiet', 'Output raw spec only (no wrapper)')
-    .action(
-      async (
-        specPath: string,
-        options: {
-          kind?: string;
-          name?: string;
-          id?: string;
-          tag?: string;
-          deprecated?: boolean;
-          hasDescription?: boolean;
-          missingDescription?: boolean;
-          search?: string;
-          module?: string;
-          output?: string;
-          summary?: boolean;
-          quiet?: boolean;
-        }
-      ) => {
-        try {
-          const spec = loadSpec(specPath);
-
-          const criteria: FilterCriteria = {};
-
-          if (options.kind) {
-            const kinds = parseList(options.kind);
-            if (kinds) criteria.kinds = validateKinds(kinds);
-          }
-          if (options.name) criteria.names = parseList(options.name);
-          if (options.id) criteria.ids = parseList(options.id);
-          if (options.tag) criteria.tags = parseList(options.tag);
-          if (options.deprecated !== undefined) criteria.deprecated = options.deprecated;
-          if (options.hasDescription) criteria.hasDescription = true;
-          if (options.missingDescription) criteria.hasDescription = false;
-          if (options.search) criteria.search = options.search;
-          if (options.module) criteria.module = options.module;
-
-          const result = filterSpec(spec, criteria);
-
-          let output: OpenPkg | FilterResult | FilterSummaryResult;
-          if (options.summary) {
-            output = { matched: result.matched, total: result.total };
-          } else if (options.quiet) {
-            output = result.spec;
-          } else {
-            output = { spec: result.spec, matched: result.matched, total: result.total };
-          }
-
-          const json = JSON.stringify(output, null, 2);
-
-          if (options.output) {
-            fs.writeFileSync(path.resolve(options.output), json);
-          } else {
-            console.log(json);
-          }
-        } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err));
-          console.error(JSON.stringify({ error: error.message }, null, 2));
-          process.exit(1);
-        }
-      }
-    );
-}

package/src/commands/semver.ts

@@ -1,43 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { diffSpec, type OpenPkg, recommendSemverBump, type SemverBump } from '@openpkg-ts/spec';
-import { Command } from 'commander';
-
-export type SemverResult = {
-  bump: SemverBump;
-  reason: string;
-};
-
-function loadSpec(filePath: string): OpenPkg {
-  const resolved = path.resolve(filePath);
-  const content = fs.readFileSync(resolved, 'utf-8');
-  return JSON.parse(content) as OpenPkg;
-}
-
-export function createSemverCommand(): Command {
-  return new Command('semver')
-    .description('Recommend semver bump based on spec changes')
-    .argument('<old>', 'Path to old spec file (JSON)')
-    .argument('<new>', 'Path to new spec file (JSON)')
-    .action(async (oldPath: string, newPath: string) => {
-      try {
-        const oldSpec = loadSpec(oldPath);
-        const newSpec = loadSpec(newPath);
-
-        const diff = diffSpec(oldSpec, newSpec);
-        const recommendation = recommendSemverBump(diff);
-
-        const result: SemverResult = {
-          bump: recommendation.bump,
-          reason: recommendation.reason,
-        };
-
-        console.log(JSON.stringify(result, null, 2));
-        // Always exit 0 - this is a recommendation only
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        console.error(JSON.stringify({ error: error.message }, null, 2));
-        process.exit(1);
-      }
-    });
-}