@polderlabs/bizar 6.2.5 → 6.3.0

package/cli/commands/validate.test.mjs

@@ -1,379 +0,0 @@
-/**
- * cli/commands/validate.test.mjs
- *
- * v6.2.0 — Unit tests for the new `bizar validate` subcommand.
- *
- * We exercise `runValidate()` directly. CLINE_DIR is mocked via
- * `process.env.CLINE_DIR`; a minimal-but-complete Bizar install is
- * staged inside a tmpdir. We then progressively delete files to
- * verify each check fails with a sensible message.
- */
-import { test, describe, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, chmodSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Writable } from 'node:stream';
-
-const { runValidate } = await import('./validate.mjs');
-
-const ORIG_CLINE_DIR = process.env.CLINE_DIR;
-const ORIG_HOME = process.env.HOME;
-
-let workDir;
-
-function freshWorkDir() {
-  const root = mkdtempSync(join(tmpdir(), 'bizar-validate-'));
-  process.env.CLINE_DIR = root;
-  // v6.2.5 — also redirect HOME so the skill-marketplace-registered
-  // check (which reads ~/.agents/.skill-lock.json) points at the
-  // test's tmpdir and doesn't fail because the user's real $HOME
-  // doesn't happen to have one.
-  process.env.HOME = root;
-  return root;
-}
-
-function makeFakeClineInstall(root) {
-  writeFileSync(
-    join(root, 'cline.json'),
-    JSON.stringify({
-      $schema: 'https://docs.cline.bot/config.json',
-      plugin: [[
-        './plugins/bizar',
-        { loopThresholdWarn: 5, loopThresholdEscalate: 8, loopThresholdBlock: 12, loopWindowSize: 10 },
-      ]],
-      default_agent: 'odin',
-      permission: 'allow',
-      snapshot: false,
-      instructions: ['.cline/instructions/bizar-tools.md'],
-      provider: {
-        '9router': {
-          baseUrl: 'http://localhost:20128/v1',
-          apiKey: '${env:NINEROUTER_KEY}',
-          models: { 'minimax/MiniMax-M3': { reasoning: true } },
-        },
-        minimax: { models: {} },
-      },
-    }, null, 2),
-  );
-  const agentsDir = join(root, 'agents');
-  mkdirSync(agentsDir, { recursive: true });
-  for (const f of [
-    'odin.md', 'vor.md', 'frigg.md', 'quick.md',
-    'mimir.md', 'heimdall.md', 'hermod.md', 'thor.md', 'baldr.md',
-    'tyr.md', 'vidarr.md', 'forseti.md',
-    'semble-search.md', 'agent-browser.md',
-  ]) {
-    writeFileSync(join(agentsDir, f), '# fake agent');
-  }
-  writeFileSync(join(agentsDir, 'odin.yaml'), 'name: odin\ndescription: odin\n');
-  const cmdsDir = join(root, 'commands');
-  mkdirSync(cmdsDir, { recursive: true });
-  for (const f of [
-    'audit.md', 'bizar.md', 'explain.md', 'init.md', 'learn.md',
-    'plan.md', 'plow-through.md', 'pr-review.md', 'tailscale-serve.md',
-    'visual-plan.md',
-    'team.md', 'test.md', 'validate.md', 'setup-provider.md',
-  ]) {
-    writeFileSync(join(cmdsDir, f), '# fake command');
-  }
-  const skillsDir = join(root, 'skills');
-  mkdirSync(skillsDir, { recursive: true });
-  for (const skill of ['9router', 'bizar', 'obsidian']) {
-    mkdirSync(join(skillsDir, skill), { recursive: true });
-    writeFileSync(join(skillsDir, skill, 'SKILL.md'), '# fake skill');
-  }
-  const rulesDir = join(root, 'rules');
-  mkdirSync(rulesDir, { recursive: true });
-  for (const r of ['general.md', 'git.md', 'javascript.md', 'python.md', 'testing.md', 'thinking.md', 'uncertainty.md']) {
-    writeFileSync(join(rulesDir, r), '# fake rule');
-  }
-  const hooksDir = join(root, 'hooks');
-  mkdirSync(hooksDir, { recursive: true });
-  for (const h of ['PreToolUse', 'PostToolUse', 'TaskStart', 'TaskResume', 'UserPromptSubmit']) {
-    // Cline hooks must be executable scripts with a shebang line.
-    writeFileSync(join(hooksDir, h), '#!/usr/bin/env node\n// fake hook\n');
-    chmodSync(join(hooksDir, h), 0o755);
-  }
-  // v6.2.5 — also register each skill in ~/.agents/.skill-lock.json
-  // (the SOURCE OF TRUTH for `npx skills list` since Cline v3.0.39).
-  // The fake install writes an entry per skill in `config/skills/`
-  // (the real source of truth, derived from disk) so the
-  // skill-marketplace-registered check passes.
-  const agentsSkillsDir = join(root, '.agents', 'skills');
-  mkdirSync(agentsSkillsDir, { recursive: true });
-  const skillLockPath = join(root, '.agents', '.skill-lock.json');
-  const lockEntries = {};
-  const actualSkillsRoot = '/home/drb0rk/Projects/BizarHarness/config/skills';
-  const skillList = ['9router', '9router-chat', '9router-embeddings', '9router-image',
-                     '9router-stt', '9router-tts', '9router-web-fetch', '9router-web-search',
-                     'bizar', 'cpp-coding-standards', 'cpp-testing', 'cubesandbox',
-                     'embedded-esp-idf', 'glyph', 'harness-engineering', 'lightrag',
-                     'memory-protocol', 'obsidian', 'read-the-damn-docs', 'self-improvement'];
-  for (const skill of skillList) {
-    mkdirSync(join(agentsSkillsDir, skill), { recursive: true });
-    writeFileSync(join(agentsSkillsDir, skill, 'SKILL.md'), '# fake skill');
-    lockEntries[skill] = {
-      source: 'bizar/builtin',
-      sourceType: 'local',
-      sourceUrl: 'https://github.com/DrB0rk/BizarHarness',
-      skillPath: `config/skills/${skill}/SKILL.md`,
-      skillFolderHash: 'fake',
-      pluginName: 'bizar',
-      installedAt: '2026-07-10T00:00:00.000Z',
-      updatedAt: '2026-07-10T00:00:00.000Z',
-    };
-  }
-  writeFileSync(skillLockPath, JSON.stringify({ version: 3, skills: lockEntries }, null, 2));
-  const pluginDir = join(root, 'plugins', 'bizar');
-  mkdirSync(pluginDir, { recursive: true });
-  writeFileSync(join(pluginDir, 'index.ts'), '// fake plugin entry — >100 bytes to pass size check\n'.repeat(10));
-  mkdirSync(join(pluginDir, 'src'), { recursive: true });
-  writeFileSync(
-    join(pluginDir, 'src', 'clineruntime.ts'),
-    'export class ClineRuntime { config = { enableAgentTeams: true }; }\n',
-  );
-  // node_modules with the required runtime deps
-  const nmDir = join(pluginDir, 'node_modules');
-  mkdirSync(nmDir, { recursive: true });
-  mkdirSync(join(nmDir, 'zod'), { recursive: true });
-  writeFileSync(join(nmDir, 'zod', 'package.json'), '{}');
-  mkdirSync(join(nmDir, '@cline'), { recursive: true });
-  for (const dep of ['@cline/sdk', '@cline/core', '@cline/shared']) {
-    mkdirSync(join(nmDir, dep), { recursive: true });
-    writeFileSync(join(nmDir, dep, 'package.json'), '{}');
-  }
-}
-
-beforeEach(() => {
-  workDir = freshWorkDir();
-  makeFakeClineInstall(workDir);
-});
-
-afterEach(() => {
-  if (workDir && existsSync(workDir)) rmSync(workDir, { recursive: true, force: true });
-  if (ORIG_CLINE_DIR === undefined) delete process.env.CLINE_DIR;
-  else process.env.CLINE_DIR = ORIG_CLINE_DIR;
-  if (ORIG_HOME === undefined) delete process.env.HOME;
-  else process.env.HOME = ORIG_HOME;
-});
-
-/**
- * Capture stdout + exit code for a single runValidate() call.
- * The test runner writes its own progress to stdout, so we swap
- * process.stdout for a sink Writable during the call.
- */
-async function captureRun(opts) {
-  const captured = [];
-  const sink = new Writable({
-    write(chunk, _enc, cb) {
-      captured.push(Buffer.from(chunk));
-      cb();
-    },
-  });
-  const origStdoutDescriptor = Object.getOwnPropertyDescriptor(process, 'stdout');
-  const origExit = process.exit;
-  let exitCode = null;
-  Object.defineProperty(process, 'stdout', { value: sink, configurable: true, writable: true });
-  process.exit = (code) => { exitCode = code; };
-  try {
-    await runValidate(opts);
-  } finally {
-    if (origStdoutDescriptor) Object.defineProperty(process, 'stdout', origStdoutDescriptor);
-    process.exit = origExit;
-  }
-  return { stdout: Buffer.concat(captured).toString('utf8'), exitCode };
-}
-
-describe('runValidate() — JSON output', () => {
-  test('returns structured JSON with passed/failed/results', async () => {
-    const { stdout, exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 0, 'should exit 0 on success');
-    const parsed = JSON.parse(stdout);
-    assert.equal(typeof parsed.passed, 'number');
-    assert.equal(typeof parsed.failed, 'number');
-    assert.ok(Array.isArray(parsed.results));
-    assert.ok(parsed.results.length >= 18, 'expected at least 18 checks');
-    for (const r of parsed.results) {
-      assert.ok(typeof r.name === 'string');
-      assert.ok(typeof r.ok === 'boolean');
-      assert.ok(typeof r.message === 'string');
-    }
-  });
-
-  test('fails on missing team command', async () => {
-    rmSync(join(workDir, 'commands', 'team.md'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1, 'should exit 1 on team-command-present failure');
-  });
-
-  test('fails on missing test command', async () => {
-    rmSync(join(workDir, 'commands', 'test.md'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1);
-  });
-
-  test('fails on missing validate command', async () => {
-    rmSync(join(workDir, 'commands', 'validate.md'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1);
-  });
-
-  test('fails on missing agent file', async () => {
-    rmSync(join(workDir, 'agents', 'mimir.md'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1);
-  });
-
-  test('fails when cline.json missing', async () => {
-    rmSync(join(workDir, 'cline.json'));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1);
-  });
-
-  test('fails when enableAgentTeams is false in clineruntime.ts', async () => {
-    writeFileSync(
-      join(workDir, 'plugins', 'bizar', 'src', 'clineruntime.ts'),
-      'export class ClineRuntime { config = { enableAgentTeams: false }; }\n',
-    );
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1, 'should fail when enableAgentTeams is false');
-  });
-
-  test('passes when no provider is configured (v6.2.2+ — user must configure)', async () => {
-    // v6.2.2: the installer no longer touches provider config. The
-    // user must add their own provider. The provider-config check
-    // is therefore ALWAYS lenient — it just reports state.
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    delete cfg.provider;
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { exitCode, stdout } = await captureRun({ json: true });
-    assert.equal(exitCode, 0, 'no-provider must not fail validation (v6.2.2+ contract)');
-    const parsed = JSON.parse(stdout);
-    const p = parsed.results.find((r) => r.name === 'provider-config');
-    assert.ok(p, 'provider-config check should be present');
-    assert.equal(p.ok, true, 'provider-config always returns ok (lenient)');
-    assert.match(p.message, /no provider configured/);
-  });
-
-  test('reports user-configured providers when present', async () => {
-    // User has set up their own provider (anything goes).
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    cfg.provider = {
-      'my-custom-provider': {
-        baseUrl: 'https://my-llm.example/v1',
-        apiKey: 'sk-test',
-        models: { 'my-model-1': {}, 'my-model-2': {} },
-      },
-    };
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { exitCode, stdout } = await captureRun({ json: true });
-    assert.equal(exitCode, 0);
-    const parsed = JSON.parse(stdout);
-    const p = parsed.results.find((r) => r.name === 'provider-config');
-    assert.match(p.message, /my-custom-provider/);
-    assert.match(p.message, /2 models/);
-  });
-
-  test('reports both providers if user has multiple', async () => {
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    cfg.provider = {
-      'a': { baseUrl: 'https://a.example/v1', models: { 'm1': {} } },
-      'b': { baseUrl: 'https://b.example/v1', models: { 'm2': {}, 'm3': {} } },
-    };
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { exitCode, stdout } = await captureRun({ json: true });
-    assert.equal(exitCode, 0);
-    const parsed = JSON.parse(stdout);
-    const p = parsed.results.find((r) => r.name === 'provider-config');
-    assert.match(p.message, /\ba\b/);
-    assert.match(p.message, /\bb\b/);
-  });
-
-  test('default mode is lenient on 9router-unreachable', async () => {
-    const { stdout, exitCode } = await captureRun({ json: true });
-    const parsed = JSON.parse(stdout);
-    const nineR = parsed.results.find((r) => r.name === '9router-reachable');
-    assert.ok(nineR, '9router-reachable check should be present');
-    if (!nineR.ok) {
-      // 9router is not running. Default mode must be lenient.
-      assert.equal(exitCode, 0, 'default mode should be lenient when 9router is down');
-    } else {
-      // 9router is running (some test envs have it). Just confirm the
-      // check is in the list and exit code is sane.
-      assert.equal(exitCode, 0, 'expected exit 0 when all critical checks pass');
-    }
-  });
-
-  test('--strict fails when 9router is unreachable', async () => {
-    // We can't easily kill 9router in a test, but we can prove that
-    // --strict mode would fail if 9router were down: set NINEROUTER_URL
-    // to a port nothing is listening on.
-    const origUrl = process.env.NINEROUTER_URL;
-    process.env.NINEROUTER_URL = 'http://127.0.0.1:1';  // nothing here
-    try {
-      const { exitCode } = await captureRun({ json: true, strict: true });
-      assert.equal(exitCode, 1, 'strict mode should fail when 9router is unreachable');
-    } finally {
-      if (origUrl === undefined) delete process.env.NINEROUTER_URL;
-      else process.env.NINEROUTER_URL = origUrl;
-    }
-  });
-
-  test('--only filters to a single check', async () => {
-    const { stdout, exitCode } = await captureRun({ json: true, only: 'team-command-present' });
-    assert.equal(exitCode, 0);
-    const parsed = JSON.parse(stdout);
-    assert.equal(parsed.results.length, 1);
-    assert.equal(parsed.results[0].name, 'team-command-present');
-    assert.equal(parsed.results[0].ok, true);
-  });
-
-  test('--only on a missing file fails with exit 1', async () => {
-    rmSync(join(workDir, 'commands', 'team.md'));
-    const { exitCode } = await captureRun({ json: true, only: 'team-command-present' });
-    assert.equal(exitCode, 1);
-  });
-
-  test('--only with an unknown name exits 2', async () => {
-    const { exitCode } = await captureRun({ json: true, only: 'this-does-not-exist' });
-    assert.equal(exitCode, 2);
-  });
-
-  test('v6.2.4 — mistake-limit-floor warns when clineruntimeMaxConsecutiveMistakes is < 10', async () => {
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    cfg.plugin = [['./plugins/bizar', { clineruntimeMaxConsecutiveMistakes: 3 }]];
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { stdout, exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 0, 'mistake-limit-floor is lenient so exit stays 0');
-    const parsed = JSON.parse(stdout);
-    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
-    assert.ok(check, 'mistake-limit-floor check should be present');
-    assert.equal(check.ok, false, 'low mistake limit should warn');
-    assert.match(check.message, /BELOW the recommended minimum/);
-    assert.match(check.message, /clineruntimeMaxConsecutiveMistakes=3/);
-  });
-
-  test('v6.2.4 — mistake-limit-floor OK when clineruntimeMaxConsecutiveMistakes >= 10', async () => {
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    cfg.plugin = [['./plugins/bizar', { clineruntimeMaxConsecutiveMistakes: 15 }]];
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { stdout, exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 0);
-    const parsed = JSON.parse(stdout);
-    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
-    assert.equal(check.ok, true);
-    assert.match(check.message, /15/);
-  });
-
-  test('v6.2.4 — mistake-limit-floor OK when no plugin entry (legacy cline.json)', async () => {
-    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    delete cfg.plugin;
-    writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { stdout } = await captureRun({ json: true });
-    const parsed = JSON.parse(stdout);
-    const check = parsed.results.find((r) => r.name === 'mistake-limit-floor');
-    assert.match(check.message, /no plugin entries/);
-    assert.equal(check.ok, true);
-  });
-});