cli4ai 0.9.2 → 1.0.1

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

package/src/core/routine-engine.test.ts

@@ -1,139 +0,0 @@
-/**
- * Tests for routine-engine.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  dryRunRoutine,
-  loadRoutineDefinition,
-  runRoutine,
-  RoutineParseError,
-  RoutineTemplateError,
-  RoutineValidationError,
-  type RoutineDefinition
-} from './routine-engine.js';
-
-describe('routine-engine', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-routine-engine-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  test('loadRoutineDefinition throws RoutineParseError on invalid JSON', () => {
-    const path = join(tempDir, 'bad.routine.json');
-    writeFileSync(path, '{not json');
-    expect(() => loadRoutineDefinition(path)).toThrow(RoutineParseError);
-  });
-
-  test('loadRoutineDefinition throws RoutineValidationError on duplicate step ids', () => {
-    const path = join(tempDir, 'dup.routine.json');
-    writeFileSync(
-      path,
-      JSON.stringify({
-        version: 1,
-        name: 'dup',
-        steps: [
-          { id: 'a', type: 'set', vars: {} },
-          { id: 'a', type: 'set', vars: {} }
-        ]
-      })
-    );
-    expect(() => loadRoutineDefinition(path)).toThrow(RoutineValidationError);
-  });
-
-  test('runRoutine executes exec+set steps and renders object result templates', async () => {
-    const def: RoutineDefinition = {
-      version: 1,
-      name: 'demo',
-      vars: {
-        lang: { default: 'rust' }
-      },
-      steps: [
-        {
-          id: 'hello',
-          type: 'exec',
-          cmd: 'bash',
-          args: ['-lc', "echo '{\"x\":1,\"lang\":\"{{vars.lang}}\"}'"],
-          capture: 'json'
-        },
-        {
-          id: 'setvars',
-          type: 'set',
-          vars: {
-            lang2: '{{steps.hello.json.lang}}',
-            x: '{{steps.hello.json.x}}'
-          }
-        },
-        {
-          id: 'echo',
-          type: 'exec',
-          cmd: 'bash',
-          args: ['-lc', "echo '{{vars.lang2}} {{vars.x}}'"],
-          capture: 'text'
-        }
-      ],
-      result: {
-        lang: '{{vars.lang2}}',
-        x: '{{vars.x}}',
-        raw: '{{steps.echo.stdout}}'
-      }
-    };
-
-    const summary = await runRoutine(def, { lang: 'typescript' }, tempDir);
-    expect(summary.status).toBe('success');
-    expect(summary.exitCode).toBe(0);
-    expect(summary.result).toEqual({
-      lang: 'typescript',
-      x: 1,
-      raw: 'typescript 1\n'
-    });
-  });
-
-  test('runRoutine fails fast on missing template path', async () => {
-    const def: RoutineDefinition = {
-      version: 1,
-      name: 'bad-template',
-      steps: [
-        {
-          id: 'set',
-          type: 'set',
-          vars: {
-            x: '{{steps.nope.json.0}}'
-          }
-        }
-      ]
-    };
-
-    await expect(runRoutine(def, {}, tempDir)).rejects.toThrow(RoutineTemplateError);
-  });
-
-  test('dryRunRoutine is lenient for missing step paths', async () => {
-    const def: RoutineDefinition = {
-      version: 1,
-      name: 'dry',
-      steps: [
-        {
-          id: 'set',
-          type: 'set',
-          vars: {
-            x: '{{steps.nope.json.0}}'
-          }
-        }
-      ],
-      result: { x: '{{vars.x}}' }
-    };
-
-    const plan = await dryRunRoutine(def, {}, tempDir);
-    expect(plan.vars.x).toBe('{{steps.nope.json.0}}');
-    expect(plan.result).toEqual({ x: '{{steps.nope.json.0}}' });
-  });
-});
-