@build-astron-co/nimbus 0.4.2 → 0.4.3

package/src/__tests__/tools.test.ts

@@ -1,144 +0,0 @@
-/**
- * Tests for embedded tool operation classes:
- *   - src/tools/file-ops.ts – FileSystemOperations
- *   - src/tools/git-ops.ts  – GitOperations
- *
- * These tests verify that the classes can be instantiated and that their
- * fundamental read/exists operations work against the real filesystem.
- * Git network operations (clone, push, pull) are NOT exercised here to keep
- * tests fast and hermetic.
- */
-
-import { describe, it, expect } from 'vitest';
-import { fileURLToPath } from 'node:url';
-import { join, dirname } from 'node:path';
-import { FileSystemOperations } from '../tools/file-ops';
-import { GitOperations } from '../tools/git-ops';
-
-// The repository root is two levels above this test file: src/__tests__/ -> src/ -> repo-root
-const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
-
-// ---------------------------------------------------------------------------
-// FileSystemOperations
-// ---------------------------------------------------------------------------
-
-describe('FileSystemOperations', () => {
-  it('can be instantiated with no arguments (defaults to cwd)', () => {
-    const ops = new FileSystemOperations();
-    expect(ops).toBeInstanceOf(FileSystemOperations);
-  });
-
-  it('can be instantiated with a specific base path', () => {
-    const ops = new FileSystemOperations(REPO_ROOT);
-    expect(ops).toBeInstanceOf(FileSystemOperations);
-  });
-
-  it('readFile reads the package.json at the repo root', async () => {
-    const ops = new FileSystemOperations(REPO_ROOT);
-    const content = await ops.readFile('package.json');
-    expect(typeof content).toBe('string');
-    expect(content.length).toBeGreaterThan(0);
-    // Verify it is valid JSON containing expected nimbus fields
-    const pkg = JSON.parse(content);
-    expect(pkg.name).toBe('@build-astron-co/nimbus');
-  });
-
-  it('exists() returns true for a known file', async () => {
-    const ops = new FileSystemOperations(REPO_ROOT);
-    const result = await ops.exists('package.json');
-    expect(result).toBe(true);
-  });
-
-  it('exists() returns false for a non-existent path', async () => {
-    const ops = new FileSystemOperations(REPO_ROOT);
-    const result = await ops.exists('this-file-does-not-exist-abc123.txt');
-    expect(result).toBe(false);
-  });
-
-  it('stat() returns file statistics for package.json', async () => {
-    const ops = new FileSystemOperations(REPO_ROOT);
-    const stats = await ops.stat('package.json');
-
-    expect(stats.isFile).toBe(true);
-    expect(stats.isDirectory).toBe(false);
-    expect(stats.size).toBeGreaterThan(0);
-    expect(stats.modifiedAt).toBeInstanceOf(Date);
-  });
-
-  it('readDir() lists the src directory', async () => {
-    const ops = new FileSystemOperations(REPO_ROOT);
-    const entries = await ops.readDir('src');
-
-    expect(Array.isArray(entries)).toBe(true);
-    expect(entries.length).toBeGreaterThan(0);
-    // src/ contains at least app.ts and version.ts
-    const names = entries.map(e => e.name);
-    expect(names).toContain('app.ts');
-    expect(names).toContain('version.ts');
-  });
-
-  it('readFile throws when attempting to read a sensitive file', async () => {
-    const ops = new FileSystemOperations(REPO_ROOT);
-    // .env files are blocked by the sensitive-file guard
-    await expect(ops.readFile('.env')).rejects.toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// GitOperations
-// ---------------------------------------------------------------------------
-
-describe('GitOperations', () => {
-  it('can be instantiated with no arguments (defaults to cwd)', () => {
-    const git = new GitOperations();
-    expect(git).toBeInstanceOf(GitOperations);
-  });
-
-  it('can be instantiated with a specific repo path', () => {
-    const git = new GitOperations(REPO_ROOT);
-    expect(git).toBeInstanceOf(GitOperations);
-  });
-
-  it('isRepo() returns true for the nimbus repository', async () => {
-    const git = new GitOperations(REPO_ROOT);
-    const result = await git.isRepo();
-    expect(result).toBe(true);
-  });
-
-  it('currentBranch() returns a non-empty string', async () => {
-    const git = new GitOperations(REPO_ROOT);
-    const branch = await git.currentBranch();
-    expect(typeof branch).toBe('string');
-    expect(branch.length).toBeGreaterThan(0);
-  });
-
-  it('status() returns a status result with expected shape', async () => {
-    const git = new GitOperations(REPO_ROOT);
-    const status = await git.status();
-    // StatusResult from simple-git has a `current` property and isClean()
-    expect(typeof status.isClean).toBe('function');
-    expect(typeof status.current).toBe('string');
-  });
-
-  it('listBranches() returns current branch and branch list', async () => {
-    const git = new GitOperations(REPO_ROOT);
-    const { current, branches } = await git.listBranches();
-    expect(typeof current).toBe('string');
-    expect(Array.isArray(branches)).toBe(true);
-    expect(branches.length).toBeGreaterThan(0);
-  });
-
-  it('listTags() returns an array', async () => {
-    const git = new GitOperations(REPO_ROOT);
-    const tags = await git.listTags();
-    expect(Array.isArray(tags)).toBe(true);
-  });
-
-  it('getShortHash() returns a short commit hash string', async () => {
-    const git = new GitOperations(REPO_ROOT);
-    const hash = await git.getShortHash('HEAD');
-    expect(typeof hash).toBe('string');
-    // Short hashes are typically 7–12 hex characters
-    expect(/^[0-9a-f]{4,12}$/.test(hash)).toBe(true);
-  });
-});

package/src/__tests__/version-json.test.ts

@@ -1,184 +0,0 @@
-/**
- * Version Command Tests — L3
- *
- * Validates that `nimbus version --json` returns valid JSON with
- * required fields: version, node, platform, arch.
- *
- * Also validates that `nimbus update` is an alias for `upgrade` in cli.ts.
- */
-
-import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// ---------------------------------------------------------------------------
-// L3: version --json
-// ---------------------------------------------------------------------------
-
-describe('versionCommand --json (L3)', () => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let consoleSpy: any;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let exitSpy: any;
-
-  beforeEach(() => {
-    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as never);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test('outputs valid JSON to stdout when json option is true', async () => {
-    const { versionCommand } = await import('../commands/version');
-    await versionCommand({ json: true });
-
-    // process.exit(0) should have been called
-    expect(exitSpy).toHaveBeenCalledWith(0);
-
-    // console.log should have been called with JSON
-    expect(consoleSpy).toHaveBeenCalled();
-
-    const jsonArg = consoleSpy.mock.calls[0][0] as string;
-    expect(() => JSON.parse(jsonArg)).not.toThrow();
-  });
-
-  test('JSON output contains required fields: version, node, platform, arch', async () => {
-    const { versionCommand } = await import('../commands/version');
-    await versionCommand({ json: true });
-
-    const jsonArg = consoleSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(jsonArg);
-
-    expect(parsed).toHaveProperty('version');
-    expect(parsed).toHaveProperty('node');
-    expect(parsed).toHaveProperty('platform');
-    expect(parsed).toHaveProperty('arch');
-  });
-
-  test('JSON version field is a non-empty string', async () => {
-    const { versionCommand } = await import('../commands/version');
-    await versionCommand({ json: true });
-
-    const jsonArg = consoleSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(jsonArg);
-
-    expect(typeof parsed.version).toBe('string');
-    expect(parsed.version.length).toBeGreaterThan(0);
-  });
-
-  test('JSON node field matches process.version', async () => {
-    const { versionCommand } = await import('../commands/version');
-    await versionCommand({ json: true });
-
-    const jsonArg = consoleSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(jsonArg);
-
-    expect(parsed.node).toBe(process.version);
-  });
-
-  test('JSON platform field matches process.platform', async () => {
-    const { versionCommand } = await import('../commands/version');
-    await versionCommand({ json: true });
-
-    const jsonArg = consoleSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(jsonArg);
-
-    expect(parsed.platform).toBe(process.platform);
-  });
-
-  test('JSON arch field matches process.arch', async () => {
-    const { versionCommand } = await import('../commands/version');
-    await versionCommand({ json: true });
-
-    const jsonArg = consoleSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(jsonArg);
-
-    expect(parsed.arch).toBe(process.arch);
-  });
-
-  test('without --json flag, does not call process.exit(0)', async () => {
-    const { versionCommand } = await import('../commands/version');
-    await versionCommand({ json: false });
-
-    expect(exitSpy).not.toHaveBeenCalledWith(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// L1: `nimbus update` alias for `upgrade`
-// ---------------------------------------------------------------------------
-
-describe('nimbus update alias (L1)', () => {
-  test('runCommand treats "update" the same as "upgrade"', async () => {
-    // Verify that both 'upgrade' and 'update' route to the upgrade handler
-    // by checking the COMMAND_ALIASES or the if-condition in cli.ts.
-    // We test this by importing runCommand and stubbing upgradeCommand.
-
-    const upgradeMod = await import('../commands/upgrade');
-    const upgradeSpy = vi.spyOn(upgradeMod, 'upgradeCommand').mockResolvedValue(undefined);
-
-    const { runCommand } = await import('../cli');
-    await runCommand(['update', '--check']);
-
-    expect(upgradeSpy).toHaveBeenCalledWith(expect.objectContaining({ check: true }));
-
-    upgradeSpy.mockRestore();
-  });
-
-  test('runCommand treats "upgrade" the same as "update"', async () => {
-    const upgradeMod = await import('../commands/upgrade');
-    const upgradeSpy = vi.spyOn(upgradeMod, 'upgradeCommand').mockResolvedValue(undefined);
-
-    const { runCommand } = await import('../cli');
-    await runCommand(['upgrade', '--check']);
-
-    expect(upgradeSpy).toHaveBeenCalledWith(expect.objectContaining({ check: true }));
-
-    upgradeSpy.mockRestore();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// L2: --quiet flag for doctor
-// ---------------------------------------------------------------------------
-
-describe('doctorCommand --quiet (L2)', () => {
-  test('DoctorOptions interface accepts quiet field', async () => {
-    const { doctorCommand } = await import('../commands/doctor');
-    // Just verifying the function can be called with quiet option without type errors
-    expect(typeof doctorCommand).toBe('function');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// L2: --quiet flag for logs
-// ---------------------------------------------------------------------------
-
-describe('parseLogsArgs --quiet (L2)', () => {
-  test('parses -q as quiet option', async () => {
-    const { parseLogsArgs } = await import('../commands/logs');
-    const { options } = parseLogsArgs(['my-pod', '-q']);
-    expect(options.quiet).toBe(true);
-  });
-
-  test('parses --quiet as quiet option', async () => {
-    const { parseLogsArgs } = await import('../commands/logs');
-    const { options } = parseLogsArgs(['my-pod', '--quiet']);
-    expect(options.quiet).toBe(true);
-  });
-
-  test('quiet is false when not provided', async () => {
-    const { parseLogsArgs } = await import('../commands/logs');
-    const { options } = parseLogsArgs(['my-pod']);
-    expect(options.quiet).toBeUndefined();
-  });
-
-  test('parses --quiet along with other flags', async () => {
-    const { parseLogsArgs } = await import('../commands/logs');
-    const { pod, options } = parseLogsArgs(['my-pod', '-n', 'default', '--quiet', '-f']);
-    expect(pod).toBe('my-pod');
-    expect(options.namespace).toBe('default');
-    expect(options.quiet).toBe(true);
-    expect(options.follow).toBe(true);
-  });
-});

package/src/__tests__/version.test.ts

@@ -1,49 +0,0 @@
-/**
- * Tests for src/version.ts
- *
- * Verifies that the module exports a valid semver VERSION string and a
- * non-empty BUILD_DATE string.
- */
-
-import { describe, it, expect } from 'vitest';
-import { VERSION, BUILD_DATE } from '../version';
-
-describe('version', () => {
-  it('exports VERSION as a non-empty string', () => {
-    expect(typeof VERSION).toBe('string');
-    expect(VERSION.length).toBeGreaterThan(0);
-  });
-
-  it('VERSION matches semver format (MAJOR.MINOR.PATCH)', () => {
-    // A loose semver pattern: digits separated by dots, with optional pre-release
-    const semverLoose = /^\d+\.\d+\.\d+/;
-    expect(semverLoose.test(VERSION)).toBe(true);
-  });
-
-  it('VERSION major version is a non-negative integer', () => {
-    const major = parseInt(VERSION.split('.')[0], 10);
-    expect(Number.isInteger(major)).toBe(true);
-    expect(major).toBeGreaterThanOrEqual(0);
-  });
-
-  it('VERSION minor and patch are non-negative integers', () => {
-    const parts = VERSION.split('.');
-    const minor = parseInt(parts[1], 10);
-    const patch = parseInt(parts[2], 10);
-    expect(minor).toBeGreaterThanOrEqual(0);
-    expect(patch).toBeGreaterThanOrEqual(0);
-  });
-
-  it('exports BUILD_DATE as a non-empty string', () => {
-    expect(typeof BUILD_DATE).toBe('string');
-    expect(BUILD_DATE.length).toBeGreaterThan(0);
-  });
-
-  it('BUILD_DATE is "dev" in development or ISO-like date in builds', () => {
-    // In dev mode the placeholder is detected and replaced with 'dev'.
-    // After a compiled build it is an ISO 8601 date string (YYYY-MM-DD).
-    const isDev = BUILD_DATE === 'dev';
-    const isISODate = /^\d{4}-\d{2}-\d{2}/.test(BUILD_DATE);
-    expect(isDev || isISODate).toBe(true);
-  });
-});

package/src/__tests__/watch.test.ts

@@ -1,129 +0,0 @@
-/**
- * Watch Command Tests (M3)
- *
- * Tests the nimbus watch command which watches files and triggers agent runs.
- * Validates glob matching, option parsing, and command export.
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-// ---------------------------------------------------------------------------
-// Import and verify exports
-// ---------------------------------------------------------------------------
-
-describe('watchCommand exports', () => {
-  it('watchCommand is exported from commands/watch.ts', async () => {
-    const { watchCommand } = await import('../commands/watch');
-    expect(typeof watchCommand).toBe('function');
-  });
-
-  it('WatchOptions interface supports required fields', () => {
-    // Type-level check via source inspection
-    const src = readFileSync(join(process.cwd(), 'src/commands/watch.ts'), 'utf-8');
-    expect(src).toContain('glob: string');
-    expect(src).toContain('run?:');
-    expect(src).toContain('debounce?:');
-    expect(src).toContain('autoApprove?:');
-    expect(src).toContain('maxRuns?:');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Glob matching logic (inline reproduction)
-// ---------------------------------------------------------------------------
-
-function matchGlob(filename: string, pattern: string): boolean {
-  const f = filename.replace(/\\/g, '/');
-  const p = pattern.replace(/\\/g, '/');
-
-  const regexStr = p
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-    .replace(/\*\*/g, '__GLOBSTAR__')
-    .replace(/\*/g, '[^/]*')
-    .replace(/\?/g, '[^/]')
-    .replace(/__GLOBSTAR__/g, '.*');
-
-  const re = new RegExp(`^${regexStr}$`);
-  const { basename } = require('node:path');
-  const base = basename(f);
-  return re.test(f) || (!/\//.test(p) && re.test(base));
-}
-
-describe('matchGlob (M3 — watch command glob matching)', () => {
-  it('matches *.tf against main.tf', () => {
-    expect(matchGlob('main.tf', '*.tf')).toBe(true);
-  });
-
-  it('matches *.tf against variables.tf', () => {
-    expect(matchGlob('variables.tf', '*.tf')).toBe(true);
-  });
-
-  it('does not match *.tf against main.ts', () => {
-    expect(matchGlob('main.ts', '*.tf')).toBe(false);
-  });
-
-  it('matches *.yaml against deploy.yaml', () => {
-    expect(matchGlob('deploy.yaml', '*.yaml')).toBe(true);
-  });
-
-  it('matches *.yaml against deploy.yml', () => {
-    expect(matchGlob('deploy.yml', '*.yaml')).toBe(false);
-  });
-
-  it('matches *.yml against deploy.yml', () => {
-    expect(matchGlob('deploy.yml', '*.yml')).toBe(true);
-  });
-
-  it('matches src/** against src/index.ts', () => {
-    expect(matchGlob('src/index.ts', 'src/**')).toBe(true);
-  });
-
-  it('matches src/** against src/utils/helper.ts', () => {
-    expect(matchGlob('src/utils/helper.ts', 'src/**')).toBe(true);
-  });
-
-  it('does not match src/** against lib/index.ts', () => {
-    expect(matchGlob('lib/index.ts', 'src/**')).toBe(false);
-  });
-
-  it('matches Dockerfile exactly', () => {
-    expect(matchGlob('Dockerfile', 'Dockerfile')).toBe(true);
-  });
-
-  it('matches nested *.tf in subdir', () => {
-    expect(matchGlob('modules/vpc/main.tf', '*.tf')).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// CLI wiring — watch is registered in cli.ts
-// ---------------------------------------------------------------------------
-
-describe('watch command wired in CLI (M3)', () => {
-  it('cli.ts contains nimbus watch handler', () => {
-    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
-    expect(src).toContain("command === 'watch'");
-  });
-
-  it('cli.ts imports watchCommand from commands/watch', () => {
-    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
-    expect(src).toContain("import('./commands/watch')");
-  });
-
-  it('cli.ts parses --run flag for watch', () => {
-    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
-    expect(src).toContain("watchOptions.run = args[++i]");
-  });
-
-  it('cli.ts parses --debounce flag for watch', () => {
-    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
-    expect(src).toContain("watchOptions.debounce");
-  });
-
-  it('cli.ts parses --auto-approve flag for watch', () => {
-    const src = readFileSync(join(process.cwd(), 'src/cli.ts'), 'utf-8');
-    expect(src).toContain("watchOptions.autoApprove = true");
-  });
-});