cli4ai 0.9.2 → 1.0.0

package/src/core/lockfile.test.ts

@@ -1,337 +0,0 @@
-/**
- * Tests for lockfile.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  getLockfilePath,
-  lockfileExists,
-  loadLockfile,
-  saveLockfile,
-  lockPackage,
-  unlockPackage,
-  getLockedPackage,
-  getLockedPackages,
-  isPackageLocked,
-  clearLockfile,
-  formatLockfile,
-  LOCKFILE_NAME,
-  LOCKFILE_VERSION,
-  type Lockfile,
-  type LockedPackage
-} from './lockfile.js';
-
-describe('lockfile', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-lockfile-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('getLockfilePath', () => {
-    test('returns correct path', () => {
-      const path = getLockfilePath(tempDir);
-      expect(path).toBe(join(tempDir, LOCKFILE_NAME));
-    });
-  });
-
-  describe('lockfileExists', () => {
-    test('returns false when no lockfile', () => {
-      expect(lockfileExists(tempDir)).toBe(false);
-    });
-
-    test('returns true when lockfile exists', () => {
-      writeFileSync(join(tempDir, LOCKFILE_NAME), '{}');
-      expect(lockfileExists(tempDir)).toBe(true);
-    });
-  });
-
-  describe('loadLockfile', () => {
-    test('returns empty lockfile when none exists', () => {
-      const lockfile = loadLockfile(tempDir);
-
-      expect(lockfile.lockfileVersion).toBe(LOCKFILE_VERSION);
-      expect(lockfile.packages).toEqual({});
-    });
-
-    test('loads existing lockfile', () => {
-      const existing: Lockfile = {
-        lockfileVersion: 1,
-        packages: {
-          github: {
-            name: 'github',
-            version: '1.0.0',
-            resolved: '/path/to/github'
-          }
-        }
-      };
-
-      writeFileSync(
-        join(tempDir, LOCKFILE_NAME),
-        JSON.stringify(existing)
-      );
-
-      const lockfile = loadLockfile(tempDir);
-      expect(lockfile.packages.github.name).toBe('github');
-      expect(lockfile.packages.github.version).toBe('1.0.0');
-    });
-
-    test('handles invalid JSON gracefully', () => {
-      writeFileSync(join(tempDir, LOCKFILE_NAME), 'invalid json');
-
-      const lockfile = loadLockfile(tempDir);
-      expect(lockfile.lockfileVersion).toBe(LOCKFILE_VERSION);
-      expect(lockfile.packages).toEqual({});
-    });
-  });
-
-  describe('saveLockfile', () => {
-    test('saves lockfile to disk', () => {
-      const lockfile: Lockfile = {
-        lockfileVersion: 1,
-        packages: {
-          tool: {
-            name: 'tool',
-            version: '2.0.0',
-            resolved: '/some/path'
-          }
-        }
-      };
-
-      saveLockfile(tempDir, lockfile);
-
-      const content = readFileSync(join(tempDir, LOCKFILE_NAME), 'utf-8');
-      const parsed = JSON.parse(content);
-
-      expect(parsed.lockfileVersion).toBe(1);
-      expect(parsed.packages.tool.version).toBe('2.0.0');
-    });
-
-    test('formats JSON with indentation', () => {
-      const lockfile: Lockfile = {
-        lockfileVersion: 1,
-        packages: {}
-      };
-
-      saveLockfile(tempDir, lockfile);
-
-      const content = readFileSync(join(tempDir, LOCKFILE_NAME), 'utf-8');
-      expect(content).toContain('  '); // Has indentation
-      expect(content.endsWith('\n')).toBe(true); // Trailing newline
-    });
-  });
-
-  describe('lockPackage', () => {
-    test('adds new package to lockfile', () => {
-      const pkg: LockedPackage = {
-        name: 'new-tool',
-        version: '1.0.0',
-        resolved: '/path/to/tool'
-      };
-
-      lockPackage(tempDir, pkg);
-
-      const lockfile = loadLockfile(tempDir);
-      expect(lockfile.packages['new-tool']).toEqual(pkg);
-    });
-
-    test('updates existing package', () => {
-      lockPackage(tempDir, {
-        name: 'tool',
-        version: '1.0.0',
-        resolved: '/old/path'
-      });
-
-      lockPackage(tempDir, {
-        name: 'tool',
-        version: '2.0.0',
-        resolved: '/new/path'
-      });
-
-      const lockfile = loadLockfile(tempDir);
-      expect(lockfile.packages.tool.version).toBe('2.0.0');
-      expect(lockfile.packages.tool.resolved).toBe('/new/path');
-    });
-
-    test('preserves other packages when adding', () => {
-      lockPackage(tempDir, { name: 'a', version: '1.0.0', resolved: '/a' });
-      lockPackage(tempDir, { name: 'b', version: '1.0.0', resolved: '/b' });
-      lockPackage(tempDir, { name: 'c', version: '1.0.0', resolved: '/c' });
-
-      const lockfile = loadLockfile(tempDir);
-      expect(Object.keys(lockfile.packages)).toEqual(['a', 'b', 'c']);
-    });
-  });
-
-  describe('unlockPackage', () => {
-    test('removes package from lockfile', () => {
-      lockPackage(tempDir, { name: 'tool', version: '1.0.0', resolved: '/path' });
-      unlockPackage(tempDir, 'tool');
-
-      const lockfile = loadLockfile(tempDir);
-      expect(lockfile.packages.tool).toBeUndefined();
-    });
-
-    test('handles non-existent package gracefully', () => {
-      // Should not throw
-      unlockPackage(tempDir, 'nonexistent');
-
-      const lockfile = loadLockfile(tempDir);
-      expect(lockfile.packages.nonexistent).toBeUndefined();
-    });
-
-    test('preserves other packages when removing', () => {
-      lockPackage(tempDir, { name: 'a', version: '1.0.0', resolved: '/a' });
-      lockPackage(tempDir, { name: 'b', version: '1.0.0', resolved: '/b' });
-      lockPackage(tempDir, { name: 'c', version: '1.0.0', resolved: '/c' });
-
-      unlockPackage(tempDir, 'b');
-
-      const lockfile = loadLockfile(tempDir);
-      expect(Object.keys(lockfile.packages)).toEqual(['a', 'c']);
-    });
-  });
-
-  describe('getLockedPackage', () => {
-    test('returns package when found', () => {
-      lockPackage(tempDir, {
-        name: 'github',
-        version: '1.0.0',
-        resolved: '/path'
-      });
-
-      const pkg = getLockedPackage(tempDir, 'github');
-      expect(pkg).not.toBeNull();
-      expect(pkg?.name).toBe('github');
-    });
-
-    test('returns null when not found', () => {
-      const pkg = getLockedPackage(tempDir, 'nonexistent');
-      expect(pkg).toBeNull();
-    });
-  });
-
-  describe('getLockedPackages', () => {
-    test('returns empty array when no packages', () => {
-      const packages = getLockedPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('returns all packages', () => {
-      lockPackage(tempDir, { name: 'a', version: '1.0.0', resolved: '/a' });
-      lockPackage(tempDir, { name: 'b', version: '2.0.0', resolved: '/b' });
-
-      const packages = getLockedPackages(tempDir);
-      expect(packages).toHaveLength(2);
-      expect(packages.map(p => p.name).sort()).toEqual(['a', 'b']);
-    });
-  });
-
-  describe('isPackageLocked', () => {
-    test('returns true when package is locked', () => {
-      lockPackage(tempDir, { name: 'tool', version: '1.0.0', resolved: '/path' });
-      expect(isPackageLocked(tempDir, 'tool')).toBe(true);
-    });
-
-    test('returns false when package not locked', () => {
-      expect(isPackageLocked(tempDir, 'nonexistent')).toBe(false);
-    });
-  });
-
-  describe('clearLockfile', () => {
-    test('removes all packages', () => {
-      lockPackage(tempDir, { name: 'a', version: '1.0.0', resolved: '/a' });
-      lockPackage(tempDir, { name: 'b', version: '1.0.0', resolved: '/b' });
-
-      clearLockfile(tempDir);
-
-      const lockfile = loadLockfile(tempDir);
-      expect(lockfile.packages).toEqual({});
-    });
-
-    test('preserves lockfile version', () => {
-      clearLockfile(tempDir);
-
-      const lockfile = loadLockfile(tempDir);
-      expect(lockfile.lockfileVersion).toBe(LOCKFILE_VERSION);
-    });
-  });
-
-  describe('formatLockfile', () => {
-    test('formats empty lockfile', () => {
-      const lockfile: Lockfile = {
-        lockfileVersion: 1,
-        packages: {}
-      };
-
-      const output = formatLockfile(lockfile);
-      expect(output).toContain('# cli4ai.lock');
-      expect(output).toContain('lockfileVersion: 1');
-    });
-
-    test('formats packages alphabetically', () => {
-      const lockfile: Lockfile = {
-        lockfileVersion: 1,
-        packages: {
-          zebra: { name: 'zebra', version: '1.0.0', resolved: '/z' },
-          apple: { name: 'apple', version: '2.0.0', resolved: '/a' },
-          monkey: { name: 'monkey', version: '3.0.0', resolved: '/m' }
-        }
-      };
-
-      const output = formatLockfile(lockfile);
-      const appleIndex = output.indexOf('apple@');
-      const monkeyIndex = output.indexOf('monkey@');
-      const zebraIndex = output.indexOf('zebra@');
-
-      expect(appleIndex).toBeLessThan(monkeyIndex);
-      expect(monkeyIndex).toBeLessThan(zebraIndex);
-    });
-
-    test('includes integrity when present', () => {
-      const lockfile: Lockfile = {
-        lockfileVersion: 1,
-        packages: {
-          tool: {
-            name: 'tool',
-            version: '1.0.0',
-            resolved: '/path',
-            integrity: 'sha256-abc123'
-          }
-        }
-      };
-
-      const output = formatLockfile(lockfile);
-      expect(output).toContain('integrity: sha256-abc123');
-    });
-
-    test('includes dependencies when present', () => {
-      const lockfile: Lockfile = {
-        lockfileVersion: 1,
-        packages: {
-          tool: {
-            name: 'tool',
-            version: '1.0.0',
-            resolved: '/path',
-            dependencies: {
-              'dep-a': '1.0.0',
-              'dep-b': '2.0.0'
-            }
-          }
-        }
-      };
-
-      const output = formatLockfile(lockfile);
-      expect(output).toContain('dependencies:');
-      expect(output).toContain('dep-a: "1.0.0"');
-      expect(output).toContain('dep-b: "2.0.0"');
-    });
-  });
-});

package/src/core/manifest.test.ts

@@ -1,327 +0,0 @@
-/**
- * Tests for manifest.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  validateManifest,
-  loadManifestOrThrow,
-  tryLoadManifest,
-  findManifest,
-  createManifest,
-  MANIFEST_FILENAME,
-  ManifestValidationError,
-  ManifestNotFoundError,
-  ManifestParseError
-} from './manifest.js';
-
-describe('manifest', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-manifest-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('validateManifest', () => {
-    test('accepts valid minimal manifest', () => {
-      const manifest = validateManifest({
-        name: 'my-tool',
-        version: '1.0.0',
-        entry: 'run.ts'
-      });
-
-      expect(manifest.name).toBe('my-tool');
-      expect(manifest.version).toBe('1.0.0');
-      expect(manifest.entry).toBe('run.ts');
-    });
-
-    test('accepts valid full manifest', () => {
-      const manifest = validateManifest({
-        name: 'github',
-        version: '2.1.0',
-        entry: 'run.ts',
-        description: 'GitHub CLI wrapper',
-        author: 'cliforai',
-        license: 'MIT',
-        runtime: 'bun',
-        commands: {
-          notifs: { description: 'Your notifications' },
-          repos: {
-            description: 'List repos',
-            args: [{ name: 'user', required: false }]
-          }
-        },
-        env: {
-          GITHUB_TOKEN: { required: false, description: 'Token' }
-        },
-        mcp: { enabled: true }
-      });
-
-      expect(manifest.name).toBe('github');
-      expect(manifest.commands?.notifs.description).toBe('Your notifications');
-      expect(manifest.mcp?.enabled).toBe(true);
-    });
-
-    test('accepts prerelease versions', () => {
-      const manifest = validateManifest({
-        name: 'tool',
-        version: '1.0.0-beta.1',
-        entry: 'run.ts'
-      });
-
-      expect(manifest.version).toBe('1.0.0-beta.1');
-    });
-
-    test('accepts all valid runtimes', () => {
-      for (const runtime of ['bun', 'node'] as const) {
-        const manifest = validateManifest({
-          name: 'tool',
-          version: '1.0.0',
-          entry: 'run.ts',
-          runtime
-        });
-        expect(manifest.runtime).toBe(runtime);
-      }
-    });
-
-    test('rejects null manifest', () => {
-      expect(() => validateManifest(null)).toThrow();
-    });
-
-    test('rejects non-object manifest', () => {
-      expect(() => validateManifest('string')).toThrow();
-      expect(() => validateManifest(123)).toThrow();
-      expect(() => validateManifest([])).toThrow();
-    });
-
-    test('rejects missing name', () => {
-      expect(() => validateManifest({
-        version: '1.0.0',
-        entry: 'run.ts'
-      })).toThrow();
-    });
-
-    test('rejects invalid name format', () => {
-      expect(() => validateManifest({
-        name: 'Invalid-Name',
-        version: '1.0.0',
-        entry: 'run.ts'
-      })).toThrow();
-
-      expect(() => validateManifest({
-        name: '123invalid',
-        version: '1.0.0',
-        entry: 'run.ts'
-      })).toThrow();
-
-      expect(() => validateManifest({
-        name: 'has_underscore',
-        version: '1.0.0',
-        entry: 'run.ts'
-      })).toThrow();
-    });
-
-    test('rejects missing version', () => {
-      expect(() => validateManifest({
-        name: 'tool',
-        entry: 'run.ts'
-      })).toThrow();
-    });
-
-    test('rejects invalid version format', () => {
-      expect(() => validateManifest({
-        name: 'tool',
-        version: 'invalid',
-        entry: 'run.ts'
-      })).toThrow();
-
-      expect(() => validateManifest({
-        name: 'tool',
-        version: '1.0',
-        entry: 'run.ts'
-      })).toThrow();
-    });
-
-    test('rejects missing entry', () => {
-      expect(() => validateManifest({
-        name: 'tool',
-        version: '1.0.0'
-      })).toThrow();
-    });
-
-    test('rejects empty entry', () => {
-      expect(() => validateManifest({
-        name: 'tool',
-        version: '1.0.0',
-        entry: ''
-      })).toThrow();
-    });
-
-    test('rejects invalid runtime', () => {
-      expect(() => validateManifest({
-        name: 'tool',
-        version: '1.0.0',
-        entry: 'run.ts',
-        runtime: 'python'
-      })).toThrow();
-    });
-
-    test('rejects commands without description', () => {
-      expect(() => validateManifest({
-        name: 'tool',
-        version: '1.0.0',
-        entry: 'run.ts',
-        commands: {
-          mycommand: {}
-        }
-      })).toThrow();
-    });
-  });
-
-  describe('loadManifestOrThrow', () => {
-    test('loads valid manifest from directory', () => {
-      writeFileSync(
-        join(tempDir, MANIFEST_FILENAME),
-        JSON.stringify({
-          name: 'test-tool',
-          version: '1.0.0',
-          entry: 'run.ts'
-        })
-      );
-
-      const manifest = loadManifestOrThrow(tempDir);
-      expect(manifest.name).toBe('test-tool');
-    });
-
-    test('throws ManifestNotFoundError when manifest not found', () => {
-      expect(() => loadManifestOrThrow(tempDir)).toThrow(ManifestNotFoundError);
-    });
-
-    test('throws ManifestParseError on invalid JSON', () => {
-      writeFileSync(join(tempDir, MANIFEST_FILENAME), 'not json');
-      expect(() => loadManifestOrThrow(tempDir)).toThrow(ManifestParseError);
-    });
-
-    test('throws ManifestValidationError on invalid manifest content', () => {
-      writeFileSync(
-        join(tempDir, MANIFEST_FILENAME),
-        JSON.stringify({ name: 'Invalid' }) // Missing version, entry
-      );
-      expect(() => loadManifestOrThrow(tempDir)).toThrow(ManifestValidationError);
-    });
-  });
-
-  describe('tryLoadManifest', () => {
-    test('returns manifest when valid', () => {
-      writeFileSync(
-        join(tempDir, MANIFEST_FILENAME),
-        JSON.stringify({
-          name: 'test-tool',
-          version: '1.0.0',
-          entry: 'run.ts'
-        })
-      );
-
-      const manifest = tryLoadManifest(tempDir);
-      expect(manifest).not.toBeNull();
-      expect(manifest?.name).toBe('test-tool');
-    });
-
-    test('returns null when not found', () => {
-      const manifest = tryLoadManifest(tempDir);
-      expect(manifest).toBeNull();
-    });
-
-    test('returns null on invalid JSON', () => {
-      writeFileSync(join(tempDir, MANIFEST_FILENAME), 'not json');
-      const manifest = tryLoadManifest(tempDir);
-      expect(manifest).toBeNull();
-    });
-
-    test('returns null on invalid manifest', () => {
-      writeFileSync(
-        join(tempDir, MANIFEST_FILENAME),
-        JSON.stringify({ name: 'Invalid' })
-      );
-      const manifest = tryLoadManifest(tempDir);
-      expect(manifest).toBeNull();
-    });
-  });
-
-  describe('findManifest', () => {
-    test('finds manifest in current directory', () => {
-      writeFileSync(
-        join(tempDir, MANIFEST_FILENAME),
-        JSON.stringify({
-          name: 'found-tool',
-          version: '1.0.0',
-          entry: 'run.ts'
-        })
-      );
-
-      const result = findManifest(tempDir);
-      expect(result).not.toBeNull();
-      expect(result?.manifest.name).toBe('found-tool');
-      expect(result?.dir).toBe(tempDir);
-    });
-
-    test('finds manifest in parent directory', () => {
-      const childDir = join(tempDir, 'child');
-      mkdirSync(childDir);
-
-      writeFileSync(
-        join(tempDir, MANIFEST_FILENAME),
-        JSON.stringify({
-          name: 'parent-tool',
-          version: '1.0.0',
-          entry: 'run.ts'
-        })
-      );
-
-      const result = findManifest(childDir);
-      expect(result).not.toBeNull();
-      expect(result?.manifest.name).toBe('parent-tool');
-      expect(result?.dir).toBe(tempDir);
-    });
-
-    test('returns null when no manifest found', () => {
-      const result = findManifest(tempDir);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('createManifest', () => {
-    test('creates minimal manifest', () => {
-      const manifest = createManifest('my-tool');
-
-      expect(manifest.name).toBe('my-tool');
-      expect(manifest.version).toBe('1.0.0');
-      expect(manifest.entry).toBe('run.ts');
-      expect(manifest.runtime).toBe('node');
-    });
-
-    test('normalizes name', () => {
-      const manifest = createManifest('My Tool Name');
-      expect(manifest.name).toBe('my-tool-name');
-    });
-
-    test('accepts options', () => {
-      const manifest = createManifest('tool', {
-        version: '2.0.0',
-        description: 'Custom description',
-        runtime: 'node'
-      });
-
-      expect(manifest.version).toBe('2.0.0');
-      expect(manifest.description).toBe('Custom description');
-      expect(manifest.runtime).toBe('node');
-    });
-  });
-});