ultra-builder-pro-cli 0.5.3 → 0.7.0

package/orchestrator/code-graph-watcher.cjs

@@ -1,121 +0,0 @@
-'use strict';
-
-// Phase 6.4 — code-review-graph live watcher.
-//
-// fs-watch the project's source tree, debounce bursts of editor saves, and
-// hand batches off to an onBatch callback. Callers wire the callback to
-// whatever keeps the graph fresh (e.g. the external code-review-graph MCP
-// server's build_or_update_graph_tool). Keeping the glue in callers means
-// this module has no MCP-client dependency and is trivial to unit-test.
-//
-// PLAN D24: real-time feedback beats startup rebuilds; agents learn about
-// impact radius immediately after save, not after the next phase boot.
-
-const chokidar = require('chokidar');
-
-const DEFAULT_INCLUDE_EXT = new Set([
-  '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs',
-  '.py', '.go', '.rs', '.java', '.rb', '.php',
-  '.c', '.cc', '.cpp', '.h', '.hpp',
-  '.swift', '.kt', '.scala',
-]);
-
-const DEFAULT_EXCLUDE_GLOBS = Object.freeze([
-  '**/node_modules/**',
-  '**/.git/**',
-  '**/.ultra/**',
-  '**/.code-review-graph/**',
-  '**/dist/**',
-  '**/build/**',
-  '**/coverage/**',
-  '**/.next/**',
-]);
-
-function hasCodeExt(p, includeExt) {
-  const idx = p.lastIndexOf('.');
-  if (idx < 0) return false;
-  return includeExt.has(p.slice(idx).toLowerCase());
-}
-
-function startWatcher({
-  repoRoot,
-  debounceMs = 500,
-  includeExt = DEFAULT_INCLUDE_EXT,
-  excludeGlobs = DEFAULT_EXCLUDE_GLOBS,
-  largeBatchThreshold = 50,
-  onBatch,
-} = {}) {
-  if (!repoRoot) throw new Error('startWatcher: repoRoot required');
-  if (typeof onBatch !== 'function') throw new Error('startWatcher: onBatch required');
-
-  let stopped = false;
-  let ready = false;
-  let timer = null;
-  // kind → latest kind; path → {kind, ts} so rapid edit+add collapses cleanly.
-  const pending = new Map();
-
-  const w = chokidar.watch(repoRoot, {
-    ignored: excludeGlobs,
-    ignoreInitial: true,
-    persistent: true,
-    awaitWriteFinish: { stabilityThreshold: 20, pollInterval: 10 },
-  });
-
-  const readyPromise = new Promise((resolve) => {
-    w.once('ready', () => { ready = true; resolve(); });
-  });
-
-  function record(kind, p) {
-    // Drop events fired during chokidar's initial scan — ignoreInitial=true
-    // mostly handles this but awaitWriteFinish can still surface add events
-    // from files that existed when the watcher started.
-    if (stopped || !ready) return;
-    if (!hasCodeExt(p, includeExt)) return;
-    pending.set(p, { kind, ts: Date.now() });
-    schedule();
-  }
-
-  function schedule() {
-    if (timer) return;
-    timer = setTimeout(flush, debounceMs);
-  }
-
-  function flush() {
-    timer = null;
-    if (pending.size === 0) return;
-    const changes = Array.from(pending.entries()).map(([p, meta]) => ({ path: p, kind: meta.kind, ts: meta.ts }));
-    pending.clear();
-    const batch = {
-      changes,
-      large_batch: changes.length >= largeBatchThreshold,
-      ts: new Date().toISOString(),
-    };
-    try { onBatch(batch); }
-    catch (err) { process.stderr.write(`code-graph-watcher onBatch error: ${err.message}\n`); }
-  }
-
-  w.on('add', (p) => record('add', p));
-  w.on('change', (p) => record('change', p));
-  w.on('unlink', (p) => record('unlink', p));
-  w.on('error', (err) => process.stderr.write(`watcher error: ${err.message}\n`));
-
-  return {
-    stop() {
-      if (stopped) return;
-      stopped = true;
-      if (timer) clearTimeout(timer);
-      timer = null;
-      w.close().catch(() => { /* ignore close errors */ });
-    },
-    ready() { return readyPromise; },
-    get running() { return !stopped; },
-    get pendingCount() { return pending.size; },
-    flushNow: flush,
-  };
-}
-
-module.exports = {
-  startWatcher,
-  DEFAULT_INCLUDE_EXT,
-  DEFAULT_EXCLUDE_GLOBS,
-};

package/orchestrator/tests/code-graph-watcher.test.cjs

@@ -1,183 +0,0 @@
-'use strict';
-
-// Phase 6.4 — code-graph watcher:
-//   • fs-watch project code paths, debounce bursts, deliver batches via
-//     onBatch callback. The watcher itself does not talk to the external
-//     code-review-graph MCP server — that glue lives in callers (daemon /
-//     CLI / smoke scripts) so the watcher stays testable with just an
-//     onBatch spy.
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const watcher = require('../code-graph-watcher.cjs');
-
-function mkTree(layout = {}) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-watch-'));
-  for (const [rel, content] of Object.entries(layout)) {
-    const file = path.join(root, rel);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, content);
-  }
-  return root;
-}
-
-function cleanupTree(root) {
-  try { fs.rmSync(root, { recursive: true, force: true }); } catch (_) { /* ignore */ }
-}
-
-function waitForBatches(batches, count, timeoutMs = 1500) {
-  return new Promise((resolve, reject) => {
-    const start = Date.now();
-    const timer = setInterval(() => {
-      if (batches.length >= count) { clearInterval(timer); resolve(); return; }
-      if (Date.now() - start > timeoutMs) { clearInterval(timer); reject(new Error(`timed out waiting for ${count} batches, got ${batches.length}`)); }
-    }, 20);
-  });
-}
-
-async function waitStable(handle) {
-  // Block on chokidar's 'ready' so initial add events from pre-existing
-  // files don't leak into test assertions.
-  await handle.ready();
-}
-
-test('touch a watched file → onBatch fires with that path after debounce', async () => {
-  const root = mkTree({ 'src/a.js': '// initial\n' });
-  const batches = [];
-  const handle = watcher.startWatcher({
-    repoRoot: root,
-    debounceMs: 80,
-    onBatch: (b) => batches.push(b),
-  });
-  try {
-    await waitStable(handle);
-    fs.writeFileSync(path.join(root, 'src/a.js'), '// changed\n');
-    await waitForBatches(batches, 1);
-    assert.equal(batches.length, 1);
-    assert.ok(batches[0].changes.some((c) => c.path.endsWith('src/a.js')));
-  } finally {
-    handle.stop();
-    cleanupTree(root);
-  }
-});
-
-test('debounce merges bursts: 3 writes within window → 1 batch', async () => {
-  const root = mkTree({ 'src/a.js': '0', 'src/b.js': '0', 'src/c.js': '0' });
-  const batches = [];
-  const handle = watcher.startWatcher({
-    repoRoot: root,
-    debounceMs: 100,
-    onBatch: (b) => batches.push(b),
-  });
-  try {
-    await waitStable(handle);
-    fs.writeFileSync(path.join(root, 'src/a.js'), '1');
-    fs.writeFileSync(path.join(root, 'src/b.js'), '1');
-    fs.writeFileSync(path.join(root, 'src/c.js'), '1');
-    await waitForBatches(batches, 1);
-    // Give a bit extra time in case a 2nd batch is coming (it shouldn't).
-    await new Promise((r) => setTimeout(r, 150));
-    assert.equal(batches.length, 1, `expected 1 merged batch, got ${batches.length}`);
-    const paths = new Set(batches[0].changes.map((c) => path.basename(c.path)));
-    assert.ok(paths.has('a.js') && paths.has('b.js') && paths.has('c.js'));
-  } finally {
-    handle.stop();
-    cleanupTree(root);
-  }
-});
-
-test('excludePaths: node_modules changes are ignored', async () => {
-  const root = mkTree({
-    'src/a.js': '0',
-    'node_modules/lib/x.js': '0',
-  });
-  const batches = [];
-  const handle = watcher.startWatcher({
-    repoRoot: root,
-    debounceMs: 80,
-    onBatch: (b) => batches.push(b),
-  });
-  try {
-    await waitStable(handle);
-    fs.writeFileSync(path.join(root, 'node_modules/lib/x.js'), '1');
-    await new Promise((r) => setTimeout(r, 200));
-    // If only node_modules was changed, no batch should fire.
-    assert.equal(batches.length, 0, 'node_modules write should be ignored');
-    // Sanity: a real source change still fires.
-    fs.writeFileSync(path.join(root, 'src/a.js'), '1');
-    await waitForBatches(batches, 1);
-    assert.equal(batches.length, 1);
-    assert.ok(batches[0].changes.every((c) => !c.path.includes('node_modules')));
-  } finally {
-    handle.stop();
-    cleanupTree(root);
-  }
-});
-
-test('stop(): subsequent writes do not deliver', async () => {
-  const root = mkTree({ 'src/a.js': '0' });
-  const batches = [];
-  const handle = watcher.startWatcher({
-    repoRoot: root,
-    debounceMs: 80,
-    onBatch: (b) => batches.push(b),
-  });
-  try {
-    await waitStable(handle);
-    handle.stop();
-    fs.writeFileSync(path.join(root, 'src/a.js'), '1');
-    await new Promise((r) => setTimeout(r, 200));
-    assert.equal(batches.length, 0);
-  } finally {
-    cleanupTree(root);
-  }
-});
-
-test('large_batch flag: >threshold changes in one burst', async () => {
-  const files = {};
-  for (let i = 0; i < 12; i++) files[`src/f${i}.js`] = '0';
-  const root = mkTree(files);
-  const batches = [];
-  const handle = watcher.startWatcher({
-    repoRoot: root,
-    debounceMs: 120,
-    largeBatchThreshold: 10, // lower for test speed
-    onBatch: (b) => batches.push(b),
-  });
-  try {
-    await waitStable(handle);
-    for (let i = 0; i < 12; i++) fs.writeFileSync(path.join(root, `src/f${i}.js`), '1');
-    await waitForBatches(batches, 1);
-    await new Promise((r) => setTimeout(r, 150));
-    assert.equal(batches.length, 1);
-    assert.equal(batches[0].changes.length, 12);
-    assert.equal(batches[0].large_batch, true);
-  } finally {
-    handle.stop();
-    cleanupTree(root);
-  }
-});
-
-test('non-code files ignored (e.g. .log, .tmp)', async () => {
-  const root = mkTree({ 'src/a.js': '0', 'run.log': '0', 'tmp.tmp': '0' });
-  const batches = [];
-  const handle = watcher.startWatcher({
-    repoRoot: root,
-    debounceMs: 80,
-    onBatch: (b) => batches.push(b),
-  });
-  try {
-    await waitStable(handle);
-    fs.writeFileSync(path.join(root, 'run.log'), '1');
-    fs.writeFileSync(path.join(root, 'tmp.tmp'), '1');
-    await new Promise((r) => setTimeout(r, 200));
-    assert.equal(batches.length, 0);
-  } finally {
-    handle.stop();
-    cleanupTree(root);
-  }
-});

package/skills/gemini-collab/SKILL.md

@@ -1,51 +0,0 @@
----
-name: gemini-collab
-description: Ask Gemini CLI for an explicitly requested, read-only second opinion on a bounded review, diagnosis, architecture, or comparison question.
----
-
-# Gemini Collaboration
-
-Claude Code remains primary and owns scope, evidence, edits, verification, and the final answer.
-Gemini is an untrusted read-only advisor. Use this skill only when the user explicitly requests a
-Gemini perspective.
-
-## Preconditions
-
-1. Confirm `gemini --version` and authentication.
-2. Fix the workspace, files or diff range, question, evidence standard, and expected response shape.
-3. Write the primary analysis first when independence matters.
-4. Never send secrets, unrelated files, or an unbounded home directory.
-
-## Modes
-
-- `review`: findings against an exact diff or file set.
-- `understand`: a bounded architecture or flow question.
-- `opinion`: one decision with named constraints and alternatives.
-- `compare`: independent answers to the same question.
-- `free`: another tightly scoped read-only prompt.
-
-## Safe invocation
-
-Create a session directory under `.ultra/collab/`, then use Gemini's plan approval mode:
-
-```bash
-SESSION_PATH=".ultra/collab/$(date +%Y%m%d-%H%M%S)-gemini-<mode>"
-mkdir -p "${SESSION_PATH}"
-gemini --approval-mode plan \
-  --output-format text \
-  -p "<bounded prompt>" \
-  > "${SESSION_PATH}/gemini-output.md" \
-  2> "${SESSION_PATH}/gemini-error.log"
-```
-
-Do not use auto-edit, YOLO, or permission bypass.
-
-## Synthesis
-
-1. Read the output only after the process exits and the file is non-empty.
-2. Verify consequential claims against the current checkout, tests, runtime, or primary docs.
-3. Separate agreement, useful dissent, and unsupported assertions.
-4. Return one Claude Code-owned conclusion; do not paste an unreviewed advisor transcript.
-
-If Gemini is missing, unauthenticated, times out, or returns empty output, report the degraded path
-and continue with primary evidence. Never block the user's task solely on advisor failure.

package/skills/gemini-collab/evals/evals.json

@@ -1,42 +0,0 @@
-{
-  "skill_name": "gemini-collab",
-  "evals": [
-    {
-      "id": 1,
-      "prompt": "/gemini-collab review",
-      "expected_output": "Claude creates a session directory, invokes gemini CLI to review current changes, reads the output file, and presents a synthesis report",
-      "assertions": [
-        "Creates a session directory under .ultra/collab/ with gemini-review in the name",
-        "Uses 'gemini -p' with --yolo flag to invoke Gemini CLI",
-        "Does NOT use '-o text' flag (Gemini outputs to stdout by default)",
-        "Redirects output to a file (> output.md)",
-        "Uses Read tool to read the output file",
-        "Presents a synthesis with Consensus and Divergent Views sections"
-      ]
-    },
-    {
-      "id": 2,
-      "prompt": "/gemini-collab compare 'Should we use Redis or Memcached for our caching layer?'",
-      "expected_output": "Claude answers independently first, then sends the same question to Gemini, reads output, and presents a comparative synthesis",
-      "assertions": [
-        "Claude writes its own answer BEFORE invoking Gemini",
-        "Sends the question to Gemini without revealing Claude's position",
-        "Creates session directory under .ultra/collab/",
-        "Reads Gemini output with Read tool",
-        "Presents both analyses side by side with synthesis"
-      ]
-    },
-    {
-      "id": 3,
-      "prompt": "/gemini-collab understand",
-      "expected_output": "Claude invokes Gemini in sandbox mode to analyze the project, reads output, and synthesizes with its own understanding",
-      "assertions": [
-        "Uses --sandbox flag for read-only analysis",
-        "Uses gemini -p with a project analysis prompt",
-        "Installs from @google/gemini-cli (not @anthropic-ai/gemini-cli)",
-        "Redirects to file, reads with Read tool",
-        "Produces a unified project understanding report"
-      ]
-    }
-  ]
-}