kanbango 3.4.1 → 3.6.2

package/tests/fixtures/fake-opencode.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Fake opencode runner for workflow-gates tests.
+ * Env:
+ *   FAKE_OPENCODE_MODE = pass|fail|blocked|gate_pass|gate_fail|gate_missing|hang|exit1
+ *   FAKE_OPENCODE_REVIEW_MODE = gate_pass|gate_fail|gate_missing (optional; overrides when --agent is review)
+ *   FAKE_OPENCODE_ARGV_FILE = path to write JSON argv
+ *   FAKE_OPENCODE_HANG_MS = hang duration (default 60000)
+ */
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const agentIdx = args.indexOf('--agent');
+const agent = agentIdx >= 0 ? args[agentIdx + 1] : '';
+
+let mode = String(process.env.FAKE_OPENCODE_MODE || 'pass').trim();
+const reviewMode = String(process.env.FAKE_OPENCODE_REVIEW_MODE || '').trim();
+// Review agents: prefer review mode, else map testing modes to gate_* defaults.
+if (agent === 'temida' || agent === 'review' || /temida|review/i.test(agent)) {
+  if (reviewMode) {
+    mode = reviewMode;
+  } else if (mode === 'pass') {
+    mode = 'gate_pass';
+  } else if (mode === 'fail') {
+    mode = 'gate_fail';
+  } else if (mode === 'blocked' || mode === 'gate_missing') {
+    mode = mode === 'blocked' ? 'gate_missing' : mode;
+  }
+}
+
+const argvFile = process.env.FAKE_OPENCODE_ARGV_FILE;
+if (argvFile) {
+  try {
+    fs.mkdirSync(path.dirname(argvFile), { recursive: true });
+    fs.writeFileSync(argvFile, JSON.stringify(args, null, 2) + '\n', 'utf-8');
+  } catch (err) {
+    process.stderr.write(`argv write failed: ${err.message}\n`);
+  }
+}
+
+if (mode === 'hang') {
+  const ms = Number(process.env.FAKE_OPENCODE_HANG_MS || 60000);
+  setTimeout(() => process.exit(0), ms);
+  return;
+}
+
+const outputs = {
+  pass: { out: 'Tests green\nPASS\n', code: 0 },
+  fail: { out: 'Tests red\nFAIL\n', code: 1 },
+  blocked: { out: 'Missing env\nBLOCKED\n', code: 0 },
+  gate_pass: {
+    out: 'Nagroda: solidny diff.\nKara kosmetyczna: naming.\nWedka: ok.\nGATE: PASS\n',
+    code: 0
+  },
+  gate_fail: {
+    out: 'Kara: brak testow produkcji.\nWedka: dodaj testy.\nGATE: FAIL\n',
+    code: 0
+  },
+  gate_missing: {
+    out: 'Wyrok bez markera bramki.\nTylko narracja.\n',
+    code: 0
+  },
+  exit1: { out: 'crashed without verdict\n', code: 1 }
+};
+
+const picked = outputs[mode] || outputs.pass;
+process.stdout.write(picked.out);
+process.exit(picked.code);

package/tests/index.js

@@ -0,0 +1,19 @@
+const assert = require('assert');
+const path = require('path');
+
+function run() {
+  const pkg = require(path.join(__dirname, '..', 'index.js'));
+  assert.ok(pkg.kanban, 'index exports kanban');
+  assert.ok(pkg.plan, 'index exports plan');
+  assert.ok(pkg.workflow, 'index exports workflow');
+  assert.ok(pkg.guiRegistry, 'index exports guiRegistry');
+  assert.ok(pkg.playbook, 'index exports playbook');
+  assert.ok(pkg.kanban.COLS.includes('testing'));
+  assert.ok(pkg.kanban.COLS.includes('review'));
+  assert.strictEqual(typeof pkg.workflow.loadConfig, 'function');
+  assert.strictEqual(typeof pkg.workflow.maybeEnqueueOnColumnEnter, 'function');
+  assert.strictEqual(typeof pkg.plan.done, 'function');
+  console.log('✓ index.test.js passed');
+}
+
+run();

package/tests/kanban-cli.js

@@ -0,0 +1,118 @@
+const assert = require('assert');
+const crypto = require('crypto');
+const fs = require('fs').promises;
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PKG = path.join(__dirname, '..');
+const CLI = path.join(PKG, 'bin', 'kanban.js');
+const SRC_QA = path.join(PKG, 'agents', 'qa-tester.md');
+
+function runCli(cwd, args) {
+  return spawnSync(process.execPath, [CLI, ...args], {
+    cwd,
+    encoding: 'utf-8'
+  });
+}
+
+function sha256(content) {
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+async function run() {
+  // init creates testing/review dirs + README
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'kanbango-bin-'));
+  const init = runCli(root, ['init']);
+  assert.strictEqual(init.status, 0, init.stderr);
+  for (const col of ['testing', 'review', 'active', 'planned', 'icebox', 'done']) {
+    const st = await fs.stat(path.join(root, 'backlog', col));
+    assert.ok(st.isDirectory(), col);
+  }
+  const readme = await fs.readFile(path.join(root, 'backlog', 'README.md'), 'utf-8');
+  assert.ok(readme.includes('testing/'));
+  assert.ok(readme.includes('review/'));
+
+  // mcp-init --opencode copies agents + writes manifest
+  const ocRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kanbango-bin-oc-'));
+  const oc = runCli(ocRoot, ['mcp-init', '--opencode']);
+  assert.strictEqual(oc.status, 0, oc.stderr);
+  const agentDir = path.join(ocRoot, '.opencode', 'agent');
+  const agents = await fs.readdir(agentDir);
+  assert.ok(agents.includes('qa-tester.md'));
+  assert.ok(agents.includes('temida.md'));
+  assert.ok(agents.includes('.kanbango-agents.json'));
+  const temida = await fs.readFile(path.join(agentDir, 'temida.md'), 'utf-8');
+  assert.ok(temida.includes('GATE: PASS'));
+
+  const srcQa = await fs.readFile(SRC_QA, 'utf-8');
+  const srcHash = sha256(srcQa);
+  const manifest1 = JSON.parse(await fs.readFile(path.join(agentDir, '.kanbango-agents.json'), 'utf-8'));
+  assert.strictEqual(manifest1.agents['qa-tester.md'], srcHash);
+
+  // second run, identical source → unchanged
+  const againSame = runCli(ocRoot, ['mcp-init', '--opencode']);
+  assert.strictEqual(againSame.status, 0);
+  assert.ok(againSame.stdout.includes('Bez zmian') || againSame.stdout.includes('unchanged')
+    || againSame.stdout.includes('Pominięto') === false);
+  assert.ok(againSame.stdout.includes('Bez zmian .opencode/agent/qa-tester.md'));
+  assert.strictEqual(await fs.readFile(path.join(agentDir, 'qa-tester.md'), 'utf-8'), srcQa);
+
+  // local edit while manifest matches previous package hash → conflict, keep local
+  await fs.writeFile(path.join(agentDir, 'qa-tester.md'), 'KEEP_LOCAL_EDIT', 'utf-8');
+  const conflictRun = runCli(ocRoot, ['mcp-init', '--opencode']);
+  assert.strictEqual(conflictRun.status, 0);
+  assert.ok(
+    conflictRun.stdout.includes('Konflikt') || conflictRun.stdout.includes('Pominięto'),
+    `expected conflict/skip message, got: ${conflictRun.stdout}`
+  );
+  assert.strictEqual(
+    await fs.readFile(path.join(agentDir, 'qa-tester.md'), 'utf-8'),
+    'KEEP_LOCAL_EDIT'
+  );
+
+  // clean older package version: dest matches recorded hash, source "new" → auto update
+  // Simulate by writing dest = old body, manifest hash = old hash, then force-path via
+  // restoring package content is fixed; instead write dest to old body with matching manifest.
+  const oldBody = 'OLD_PACKAGE_VERSION\n';
+  const oldHash = sha256(oldBody);
+  await fs.writeFile(path.join(agentDir, 'qa-tester.md'), oldBody, 'utf-8');
+  const man = JSON.parse(await fs.readFile(path.join(agentDir, '.kanbango-agents.json'), 'utf-8'));
+  man.agents['qa-tester.md'] = oldHash;
+  await fs.writeFile(
+    path.join(agentDir, '.kanbango-agents.json'),
+    JSON.stringify(man, null, 2) + '\n',
+    'utf-8'
+  );
+  const autoUpdate = runCli(ocRoot, ['mcp-init', '--opencode']);
+  assert.strictEqual(autoUpdate.status, 0, autoUpdate.stderr);
+  assert.ok(
+    autoUpdate.stdout.includes('Zaktualizowano .opencode/agent/qa-tester.md'),
+    autoUpdate.stdout
+  );
+  assert.strictEqual(await fs.readFile(path.join(agentDir, 'qa-tester.md'), 'utf-8'), srcQa);
+  const manAfter = JSON.parse(await fs.readFile(path.join(agentDir, '.kanbango-agents.json'), 'utf-8'));
+  assert.strictEqual(manAfter.agents['qa-tester.md'], srcHash);
+
+  // --force overwrites local edit
+  await fs.writeFile(path.join(agentDir, 'qa-tester.md'), 'FORCE_ME', 'utf-8');
+  const forceRun = runCli(ocRoot, ['mcp-init', '--opencode', '--force']);
+  assert.strictEqual(forceRun.status, 0);
+  assert.strictEqual(await fs.readFile(path.join(agentDir, 'qa-tester.md'), 'utf-8'), srcQa);
+
+  // --claude does not create .opencode/agent
+  const claudeRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kanbango-bin-cl-'));
+  const cl = runCli(claudeRoot, ['mcp-init', '--claude']);
+  assert.strictEqual(cl.status, 0, cl.stderr);
+  await assert.rejects(
+    () => fs.access(path.join(claudeRoot, '.opencode', 'agent')),
+    (err) => err.code === 'ENOENT'
+  );
+
+  console.log('✓ bin-kanban.test.js passed');
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/tests/kanban.js

@@ -0,0 +1,104 @@
+const assert = require('assert');
+const fs = require('fs').promises;
+const os = require('os');
+const path = require('path');
+
+async function run() {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kanbango-kanban-'));
+  process.chdir(tempRoot);
+  const kanban = require(path.join(__dirname, '..', 'kanban.js'));
+
+  assert.ok(kanban.COLS.includes('testing'));
+  assert.ok(kanban.COLS.includes('review'));
+  assert.strictEqual(kanban.STATUS_MAP.testing, 'testing');
+  assert.strictEqual(kanban.STATUS_MAP.review, 'review');
+
+  await kanban.ensureBacklogDir();
+  for (const col of ['testing', 'review']) {
+    const st = await fs.stat(path.join(tempRoot, 'backlog', col));
+    assert.ok(st.isDirectory());
+  }
+
+  const ev = kanban.normalizeEvidence([{
+    diff: 'old',
+    test_command: 't',
+    stdout: '',
+    stderr: '',
+    exit_code: 0,
+    stage: 'testing',
+    agent: 'qa-tester',
+    verdict: 'pass',
+    summary: 'ok'
+  }]);
+  assert.strictEqual(ev[0].stage, 'testing');
+  assert.strictEqual(ev[0].verdict, 'pass');
+
+  const wf = kanban.normalizeWorkflow({
+    stage: 'review',
+    status: 'running',
+    agent: 'temida',
+    run_id: 'run-x'
+  });
+  assert.strictEqual(wf.stage, 'review');
+  assert.strictEqual(wf.status, 'running');
+
+  const task = await kanban.doCreate('Kanban unit', 'active', '—', {});
+  const moved = await kanban.updateTask(task.id, { column: 'testing' });
+  assert.strictEqual(moved.column, 'testing');
+
+  await assert.rejects(
+    () => kanban.updateTask(task.id, { column: 'done' }),
+    (err) => {
+      assert.strictEqual(err.code, 'INVALID_TRANSITION');
+      assert.deepStrictEqual(err.details.allowed_columns, ['active', 'review']);
+      assert.strictEqual(err.details.from, 'testing');
+      assert.strictEqual(err.details.to, 'done');
+      assert.ok(err.hint.includes('active, review'));
+      return true;
+    }
+  );
+  assert.deepStrictEqual(kanban.allowedColumnsFrom('active'), ['planned', 'testing', 'icebox']);
+  assert.deepStrictEqual(kanban.allowedColumnsFrom('review'), ['active', 'done']);
+  kanban.validateTransition('active', 'testing', '001');
+  kanban.validateTransition('testing', 'testing', '001');
+
+  const appended = await kanban.updateTask(task.id, {
+    appendEvidence: {
+      diff: '',
+      test_command: 'fake',
+      stdout: 'PASS',
+      stderr: '',
+      exit_code: 0,
+      stage: 'testing',
+      agent: 'qa-tester',
+      verdict: 'pass',
+      summary: 'PASS'
+    },
+    workflow: {
+      stage: 'testing',
+      status: 'pass',
+      agent: 'qa-tester',
+      run_id: 'run-1'
+    }
+  });
+  assert.ok(appended.evidence.some((e) => e.verdict === 'pass'));
+  assert.strictEqual(appended.workflow.status, 'pass');
+
+  assert.strictEqual(
+    kanban.deriveEpicStatus([{ column: 'testing' }], {}),
+    'active'
+  );
+  const progress = kanban.getEpicProgress([
+    { column: 'testing' },
+    { column: 'review' }
+  ]);
+  assert.strictEqual(progress.tasks_testing, 1);
+  assert.strictEqual(progress.tasks_review, 1);
+
+  console.log('✓ kanban.test.js passed');
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/tests/run.js

@@ -18,10 +18,16 @@ runNode(path.join('tests', 'update-tasks.test.js'), [], 'Update tasks test');
 runNode(path.join('tests', 'read-views.test.js'), [], 'Read views test');
 runNode(path.join('tests', 'mcp-server.test.js'), [], 'MCP server test');
 runNode(path.join('tests', 'gui-port.test.js'), [], 'GUI port test');
+runNode(path.join('tests', 'gui-cockpit.test.js'), [], 'GUI cockpit layout + workflow test');
 runNode(path.join('tests', 'fenced-text.test.js'), [], 'Fenced text test');
 runNode(path.join('tests', 'kanban-mermaid-vendor.test.js'), [], 'Kanban mermaid vendor route test');
 runNode(path.join('tests', 'plan-workflow.test.js'), [], 'Plan workflow test');
+runNode(path.join('tests', 'workflow-gates.test.js'), [], 'Workflow gates test');
+runNode(path.join('tests', 'kanban.js'), [], 'Kanban core test');
+runNode(path.join('tests', 'index.js'), [], 'Package index export test');
+runNode(path.join('tests', 'bin-kanban.test.js'), [], 'CLI bin/kanban test');
 runNode(path.join('tests', 'agent-playbook.test.js'), [], 'Agent playbook test');
 runNode(path.join('tests', 'epics.test.js'), [], 'Epics test');
+runNode(path.join('tests', 'kanban-epic-goals-adr.test.js'), [], 'Epic goals + ADR test');
 runNode(path.join('tests', 'delete-archive.test.js'), [], 'Delete/archive test');
 runNode(path.join('tests', 'race-conditions.test.js'), [], 'Race conditions test');