ultra-builder-pro-cli 0.6.0 → 0.8.1

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