cli4ai 0.9.2 → 1.0.1

package/src/core/link.test.ts

@@ -1,238 +0,0 @@
-/**
- * Tests for link.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from 'fs';
-import { join, resolve } from 'path';
-import { tmpdir, homedir } from 'os';
-import {
-  ensureBinDir,
-  linkPackage,
-  linkPackageDirect,
-  unlinkPackage,
-  isPackageLinked,
-  getPathInstructions,
-  isBinInPath,
-  C4AI_BIN
-} from './link.js';
-import type { Manifest } from './manifest.js';
-
-describe('link', () => {
-  let tempDir: string;
-  let testBinDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-link-test-'));
-    testBinDir = join(tempDir, 'bin');
-    mkdirSync(testBinDir);
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  const createMockManifest = (name: string, version = '1.0.0'): Manifest => ({
-    name,
-    version,
-    entry: 'run.ts',
-    runtime: 'node'
-  });
-
-  describe('C4AI_BIN constant', () => {
-    test('is in home directory', () => {
-      expect(C4AI_BIN).toBe(resolve(homedir(), '.cli4ai', 'bin'));
-    });
-  });
-
-  describe('ensureBinDir', () => {
-    test('creates bin directory if not exists', () => {
-      // This test affects real filesystem, so we just verify function doesn't throw
-      expect(() => ensureBinDir()).not.toThrow();
-      expect(existsSync(C4AI_BIN)).toBe(true);
-    });
-  });
-
-  describe('linkPackage', () => {
-    test('creates wrapper script', () => {
-      const manifest = createMockManifest('test-tool');
-      const packagePath = join(tempDir, 'test-tool');
-
-      const binPath = linkPackage(manifest, packagePath);
-
-      expect(existsSync(binPath)).toBe(true);
-      const content = readFileSync(binPath, 'utf-8');
-      expect(content).toContain('#!/bin/sh');
-      // SECURITY: Package names are shell-escaped with single quotes
-      expect(content).toContain("cli4ai run 'test-tool'");
-    });
-
-    test('makes script executable', () => {
-      const manifest = createMockManifest('test-tool');
-      const packagePath = join(tempDir, 'test-tool');
-
-      const binPath = linkPackage(manifest, packagePath);
-
-      const stat = statSync(binPath);
-      // Check executable bit (0o755 = rwxr-xr-x)
-      const isExecutable = (stat.mode & 0o111) !== 0;
-      expect(isExecutable).toBe(true);
-    });
-
-    test('includes version in comment', () => {
-      const manifest = createMockManifest('my-tool', '2.5.0');
-      const packagePath = join(tempDir, 'my-tool');
-
-      const binPath = linkPackage(manifest, packagePath);
-
-      const content = readFileSync(binPath, 'utf-8');
-      // SECURITY: Version is shell-escaped in comment
-      expect(content).toContain("'my-tool'@'2.5.0'");
-    });
-  });
-
-  describe('linkPackageDirect', () => {
-    test('creates direct wrapper script', () => {
-      const manifest = createMockManifest('direct-tool');
-      const packagePath = join(tempDir, 'direct-tool');
-
-      const binPath = linkPackageDirect(manifest, packagePath);
-
-      expect(existsSync(binPath)).toBe(true);
-      const content = readFileSync(binPath, 'utf-8');
-      expect(content).toContain('#!/bin/sh');
-      expect(content).toContain('npx tsx');
-      expect(content).toContain('run.ts');
-    });
-
-    test('uses correct runtime from manifest (node)', () => {
-      const manifest: Manifest = {
-        name: 'node-tool',
-        version: '1.0.0',
-        entry: 'index.js',
-        runtime: 'node'
-      };
-      const packagePath = join(tempDir, 'node-tool');
-
-      const binPath = linkPackageDirect(manifest, packagePath);
-
-      const content = readFileSync(binPath, 'utf-8');
-      // Node.js doesn't use 'run' subcommand - it's just 'node <file>'
-      // SECURITY: Paths are now shell-escaped with single quotes
-      expect(content).toContain("exec node '");
-      expect(content).not.toContain('node run');
-    });
-
-    test('defaults to node runtime with tsx for TypeScript', () => {
-      const manifest: Manifest = {
-        name: 'no-runtime',
-        version: '1.0.0',
-        entry: 'run.ts'
-        // no runtime specified
-      };
-      const packagePath = join(tempDir, 'no-runtime');
-
-      const binPath = linkPackageDirect(manifest, packagePath);
-
-      const content = readFileSync(binPath, 'utf-8');
-      expect(content).toContain('npx tsx');
-    });
-
-    test('includes full path to entry', () => {
-      const manifest = createMockManifest('path-tool');
-      const packagePath = join(tempDir, 'path-tool');
-
-      const binPath = linkPackageDirect(manifest, packagePath);
-
-      const content = readFileSync(binPath, 'utf-8');
-      expect(content).toContain(resolve(packagePath, 'run.ts'));
-    });
-  });
-
-  describe('unlinkPackage', () => {
-    test('removes linked package', () => {
-      const manifest = createMockManifest('unlink-test');
-      const packagePath = join(tempDir, 'unlink-test');
-
-      const binPath = linkPackage(manifest, packagePath);
-      expect(existsSync(binPath)).toBe(true);
-
-      const result = unlinkPackage('unlink-test');
-
-      expect(result).toBe(true);
-      expect(existsSync(binPath)).toBe(false);
-    });
-
-    test('returns false for non-existent package', () => {
-      const result = unlinkPackage('nonexistent-package-name');
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('isPackageLinked', () => {
-    test('returns true for linked package', () => {
-      const manifest = createMockManifest('linked-tool');
-      const packagePath = join(tempDir, 'linked-tool');
-
-      linkPackage(manifest, packagePath);
-
-      expect(isPackageLinked('linked-tool')).toBe(true);
-    });
-
-    test('returns false for unlinked package', () => {
-      expect(isPackageLinked('not-linked-tool')).toBe(false);
-    });
-  });
-
-  describe('getPathInstructions', () => {
-    test('returns instructions string', () => {
-      const instructions = getPathInstructions();
-
-      expect(instructions).toContain('export PATH=');
-      expect(instructions).toContain(C4AI_BIN);
-      expect(instructions).toContain('source');
-    });
-
-    test('detects zsh shell', () => {
-      const originalShell = process.env.SHELL;
-      process.env.SHELL = '/bin/zsh';
-
-      const instructions = getPathInstructions();
-
-      expect(instructions).toContain('.zshrc');
-
-      process.env.SHELL = originalShell;
-    });
-
-    test('defaults to bash', () => {
-      const originalShell = process.env.SHELL;
-      process.env.SHELL = '/bin/bash';
-
-      const instructions = getPathInstructions();
-
-      expect(instructions).toContain('.bashrc');
-
-      process.env.SHELL = originalShell;
-    });
-  });
-
-  describe('isBinInPath', () => {
-    test('returns true when bin in PATH', () => {
-      const originalPath = process.env.PATH;
-      process.env.PATH = `${C4AI_BIN}:${originalPath}`;
-
-      expect(isBinInPath()).toBe(true);
-
-      process.env.PATH = originalPath;
-    });
-
-    test('returns false when bin not in PATH', () => {
-      const originalPath = process.env.PATH;
-      process.env.PATH = '/usr/bin:/usr/local/bin';
-
-      expect(isBinInPath()).toBe(false);
-
-      process.env.PATH = originalPath;
-    });
-  });
-});

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"');
-    });
-  });
-});