cli4ai 0.9.1 → 1.0.0

package/src/commands/init.test.ts

@@ -1,211 +0,0 @@
-/**
- * Integration tests for init command
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { initCommand } from './init.js';
-
-describe('init command', () => {
-  let tempDir: string;
-  let originalCwd: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-init-test-'));
-    originalCwd = process.cwd();
-    process.chdir(tempDir);
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('with name argument (creates subdirectory)', () => {
-    test('creates cli4ai.json in subdirectory', async () => {
-      await initCommand('test-tool', {});
-
-      expect(existsSync(join(tempDir, 'test-tool', 'cli4ai.json'))).toBe(true);
-    });
-
-    test('creates run.ts entry file in subdirectory', async () => {
-      await initCommand('test-tool', {});
-
-      expect(existsSync(join(tempDir, 'test-tool', 'run.ts'))).toBe(true);
-    });
-
-    test('creates README.md and package.json', async () => {
-      await initCommand('test-tool', {});
-
-      expect(existsSync(join(tempDir, 'test-tool', 'README.md'))).toBe(true);
-      expect(existsSync(join(tempDir, 'test-tool', 'package.json'))).toBe(true);
-    });
-
-    test('creates the subdirectory', async () => {
-      await initCommand('new-project', {});
-
-      expect(existsSync(join(tempDir, 'new-project'))).toBe(true);
-    });
-  });
-
-  describe('without name argument (uses current directory)', () => {
-    test('creates cli4ai.json in current directory', async () => {
-      await initCommand(undefined, {});
-
-      expect(existsSync(join(tempDir, 'cli4ai.json'))).toBe(true);
-    });
-
-    test('creates run.ts entry file', async () => {
-      await initCommand(undefined, {});
-
-      expect(existsSync(join(tempDir, 'run.ts'))).toBe(true);
-    });
-
-    test('uses directory name as package name', async () => {
-      await initCommand(undefined, {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'cli4ai.json'), 'utf-8'));
-      // Name is normalized from the temp dir name
-      expect(manifest.name).toBeDefined();
-      expect(typeof manifest.name).toBe('string');
-    });
-  });
-
-  describe('manifest content', () => {
-    test('manifest has correct name', async () => {
-      await initCommand('my-cool-tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'my-cool-tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.name).toBe('my-cool-tool');
-    });
-
-    test('manifest has default version', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.version).toBe('1.0.0');
-    });
-
-    test('manifest has default runtime node', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.runtime).toBe('node');
-    });
-
-    test('manifest has entry pointing to run.ts', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.entry).toBe('run.ts');
-    });
-
-    test('manifest has hello command defined', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.commands?.hello).toBeDefined();
-      expect(manifest.commands?.hello?.description).toBe('Say hello');
-    });
-
-    test('manifest includes dependencies', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.dependencies).toBeDefined();
-      expect(manifest.dependencies['@cli4ai/lib']).toBeDefined();
-      expect(manifest.dependencies['commander']).toBeDefined();
-    });
-  });
-
-  describe('entry file content', () => {
-    test('run.ts starts with tsx shebang', async () => {
-      await initCommand('tool', {});
-
-      const content = readFileSync(join(tempDir, 'tool', 'run.ts'), 'utf-8');
-      expect(content.startsWith('#!/usr/bin/env npx tsx')).toBe(true);
-    });
-
-    test('run.ts has hello command', async () => {
-      await initCommand('tool', {});
-
-      const content = readFileSync(join(tempDir, 'tool', 'run.ts'), 'utf-8');
-      expect(content).toContain('hello');
-    });
-
-    test('run.ts uses cli4ai SDK helpers', async () => {
-      await initCommand('tool', {});
-
-      const content = readFileSync(join(tempDir, 'tool', 'run.ts'), 'utf-8');
-      expect(content).toContain("@cli4ai/lib");
-      expect(content).toContain('output(');
-    });
-  });
-
-  describe('runtime option', () => {
-    test('respects runtime option', async () => {
-      await initCommand('tool', { runtime: 'bun' });
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.runtime).toBe('bun');
-    });
-
-    test('both runtimes use run.ts with tsx', async () => {
-      // Node runtime (default)
-      await initCommand('tool', { runtime: 'node' });
-      let manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.entry).toBe('run.ts');
-      expect(existsSync(join(tempDir, 'tool', 'run.ts'))).toBe(true);
-
-      // Bun runtime
-      rmSync(join(tempDir, 'tool'), { recursive: true, force: true });
-      await initCommand('tool', { runtime: 'bun' });
-      manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.entry).toBe('run.ts');
-      expect(existsSync(join(tempDir, 'tool', 'run.ts'))).toBe(true);
-    });
-  });
-
-  describe('test scaffolding', () => {
-    test('creates vitest.config.ts', async () => {
-      await initCommand('tool', {});
-      expect(existsSync(join(tempDir, 'tool', 'vitest.config.ts'))).toBe(true);
-    });
-
-    test('creates run.test.ts with vitest imports', async () => {
-      await initCommand('tool', {});
-      const content = readFileSync(join(tempDir, 'tool', 'run.test.ts'), 'utf-8');
-      expect(content).toContain("from 'vitest'");
-      expect(content).toContain('describe(');
-    });
-
-    test('package.json has vitest dev dependency', async () => {
-      await initCommand('tool', {});
-      const pkg = JSON.parse(readFileSync(join(tempDir, 'tool', 'package.json'), 'utf-8'));
-      expect(pkg.devDependencies).toBeDefined();
-      expect(pkg.devDependencies['vitest']).toBeDefined();
-      expect(pkg.devDependencies['tsx']).toBeDefined();
-    });
-
-    test('package.json has test script', async () => {
-      await initCommand('tool', {});
-      const pkg = JSON.parse(readFileSync(join(tempDir, 'tool', 'package.json'), 'utf-8'));
-      expect(pkg.scripts?.test).toBe('vitest run');
-    });
-  });
-
-  describe('tsconfig.json', () => {
-    test('creates tsconfig.json', async () => {
-      await initCommand('tool', {});
-      expect(existsSync(join(tempDir, 'tool', 'tsconfig.json'))).toBe(true);
-    });
-
-    test('tsconfig uses NodeNext module resolution', async () => {
-      await initCommand('tool', {});
-      const tsconfig = JSON.parse(readFileSync(join(tempDir, 'tool', 'tsconfig.json'), 'utf-8'));
-      expect(tsconfig.compilerOptions.moduleResolution).toBe('NodeNext');
-    });
-  });
-});

package/src/core/config.test.ts

@@ -1,188 +0,0 @@
-/**
- * Tests for config.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  ensureLocalDir,
-  getGlobalPackages,
-  getLocalPackages,
-  findPackage,
-  LOCAL_DIR,
-  LOCAL_PACKAGES_DIR,
-  DEFAULT_CONFIG
-} from './config.js';
-
-describe('config', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-config-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('DEFAULT_CONFIG', () => {
-    test('has expected defaults', () => {
-      expect(DEFAULT_CONFIG.registry).toBe('https://registry.cli4ai.com');
-      expect(DEFAULT_CONFIG.localRegistries).toEqual([]);
-      expect(DEFAULT_CONFIG.defaultRuntime).toBe('node');
-      expect(DEFAULT_CONFIG.mcp.transport).toBe('stdio');
-      expect(DEFAULT_CONFIG.telemetry).toBe(false);
-    });
-  });
-
-  describe('ensureLocalDir', () => {
-    test('creates .cli4ai directory', () => {
-      ensureLocalDir(tempDir);
-
-      expect(existsSync(join(tempDir, LOCAL_DIR))).toBe(true);
-    });
-
-    test('creates packages subdirectory', () => {
-      ensureLocalDir(tempDir);
-
-      expect(existsSync(join(tempDir, LOCAL_PACKAGES_DIR))).toBe(true);
-    });
-
-    test('is idempotent', () => {
-      ensureLocalDir(tempDir);
-      ensureLocalDir(tempDir);
-
-      expect(existsSync(join(tempDir, LOCAL_PACKAGES_DIR))).toBe(true);
-    });
-  });
-
-  describe('getLocalPackages', () => {
-    test('returns empty array when no packages dir', () => {
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('returns empty array when packages dir empty', () => {
-      ensureLocalDir(tempDir);
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('returns installed packages', () => {
-      ensureLocalDir(tempDir);
-
-      // Create a mock package
-      const pkgDir = join(tempDir, LOCAL_PACKAGES_DIR, 'test-tool');
-      mkdirSync(pkgDir);
-      writeFileSync(
-        join(pkgDir, 'cli4ai.json'),
-        JSON.stringify({
-          name: 'test-tool',
-          version: '1.0.0',
-          entry: 'run.ts'
-        })
-      );
-
-      const packages = getLocalPackages(tempDir);
-
-      expect(packages).toHaveLength(1);
-      expect(packages[0].name).toBe('test-tool');
-      expect(packages[0].version).toBe('1.0.0');
-    });
-
-    test('ignores directories without manifest', () => {
-      ensureLocalDir(tempDir);
-
-      // Create a directory without cli4ai.json
-      const invalidDir = join(tempDir, LOCAL_PACKAGES_DIR, 'invalid');
-      mkdirSync(invalidDir);
-      writeFileSync(join(invalidDir, 'readme.txt'), 'not a package');
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('ignores files in packages dir', () => {
-      ensureLocalDir(tempDir);
-
-      // Create a file instead of directory
-      writeFileSync(
-        join(tempDir, LOCAL_PACKAGES_DIR, 'somefile.txt'),
-        'not a package'
-      );
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('handles invalid JSON gracefully', () => {
-      ensureLocalDir(tempDir);
-
-      const pkgDir = join(tempDir, LOCAL_PACKAGES_DIR, 'bad-json');
-      mkdirSync(pkgDir);
-      writeFileSync(join(pkgDir, 'cli4ai.json'), 'invalid json');
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('returns multiple packages', () => {
-      ensureLocalDir(tempDir);
-
-      // Create multiple packages
-      for (const name of ['pkg-a', 'pkg-b', 'pkg-c']) {
-        const pkgDir = join(tempDir, LOCAL_PACKAGES_DIR, name);
-        mkdirSync(pkgDir);
-        writeFileSync(
-          join(pkgDir, 'cli4ai.json'),
-          JSON.stringify({
-            name,
-            version: '1.0.0',
-            entry: 'run.ts'
-          })
-        );
-      }
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toHaveLength(3);
-      expect(packages.map(p => p.name).sort()).toEqual(['pkg-a', 'pkg-b', 'pkg-c']);
-    });
-  });
-
-  describe('findPackage', () => {
-    test('finds local package', () => {
-      ensureLocalDir(tempDir);
-
-      const pkgDir = join(tempDir, LOCAL_PACKAGES_DIR, 'local-tool');
-      mkdirSync(pkgDir);
-      writeFileSync(
-        join(pkgDir, 'cli4ai.json'),
-        JSON.stringify({
-          name: 'local-tool',
-          version: '1.0.0',
-          entry: 'run.ts'
-        })
-      );
-
-      const pkg = findPackage('local-tool', tempDir);
-
-      expect(pkg).not.toBeNull();
-      expect(pkg?.name).toBe('local-tool');
-    });
-
-    test('returns null when package not found', () => {
-      const pkg = findPackage('nonexistent', tempDir);
-      expect(pkg).toBeNull();
-    });
-
-    test('searches without project dir', () => {
-      // Should not throw, just search global
-      const pkg = findPackage('test');
-      // May or may not find depending on global state
-      expect(pkg === null || typeof pkg === 'object').toBe(true);
-    });
-  });
-});

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