batho 0.1.4__py3-none-any.whl

batho/dashboard/assets/js/glob.js

@@ -0,0 +1,94 @@
+/**
+ * Glob pattern matching for file path filtering.
+ *
+ * Supports:
+ *   `*`     — matches any sequence of characters except /
+ *   `**`    — matches any sequence including /
+ *   `?`     — matches exactly one character except /
+ *   `{a,b}` — matches a or b (comma-separated alternatives)
+ *
+ * All matching is case-insensitive on the path segment level.
+ */
+
+/**
+ * Convert a glob pattern to a RegExp.
+ */
+function globToRegex(pattern) {
+  let i = 0;
+  const len = pattern.length;
+  let result = '^';
+
+  while (i < len) {
+    const ch = pattern[i];
+
+    if (ch === '*') {
+      // Peek ahead for **
+      if (i + 1 < len && pattern[i + 1] === '*') {
+        // ** matches any path including separators
+        result += '.*';
+        i += 2;
+        // Skip trailing /
+        if (i < len && pattern[i] === '/') i++;
+      } else {
+        // * matches any characters except /
+        result += '[^/]*';
+        i++;
+      }
+    } else if (ch === '?') {
+      result += '[^/]';
+      i++;
+    } else if (ch === '{') {
+      // Find closing brace
+      const closeIdx = pattern.indexOf('}', i);
+      if (closeIdx === -1) {
+        result += '\\{';
+        i++;
+      } else {
+        const inner = pattern.slice(i + 1, closeIdx);
+        const alternatives = inner.split(',').map(escapeRegex).join('|');
+        result += `(?:${alternatives})`;
+        i = closeIdx + 1;
+      }
+    } else if (ch === '[') {
+      // Pass through character classes
+      const closeIdx = pattern.indexOf(']', i);
+      if (closeIdx === -1) {
+        result += '\\[';
+        i++;
+      } else {
+        result += pattern.slice(i, closeIdx + 1);
+        i = closeIdx + 1;
+      }
+    } else {
+      result += escapeRegex(ch);
+      i++;
+    }
+  }
+
+  result += '$';
+  return new RegExp(result, 'i');
+}
+
+function escapeRegex(ch) {
+  if ('.+^$|()[]{}\\'.includes(ch)) return '\\' + ch;
+  return ch;
+}
+
+/**
+ * Test whether path matches pattern.
+ */
+export function matchGlob(pattern, path) {
+  if (!pattern || pattern === '*' || pattern === '**') return true;
+  const re = globToRegex(pattern);
+  return re.test(path);
+}
+
+/**
+ * Filter an array of items by a glob pattern applied to a path field.
+ */
+export function filterByGlob(items, pattern, pathField) {
+  if (!pattern || pattern === '*' || pattern === '**') return items;
+  const accessor = typeof pathField === 'function' ? pathField : (item) => item[pathField];
+  const re = globToRegex(pattern);
+  return items.filter((item) => re.test(accessor(item)));
+}

batho/dashboard/assets/js/graph-stream.js

@@ -0,0 +1,158 @@
+/**
+ * Streaming JSON parser for large graph files.
+ * Uses a bracket-depth state machine to yield batches of entities/relationships
+ * from a streamed JSON response without holding the full parse in memory.
+ */
+
+const BATCH_SIZE = 500;
+
+/**
+ * Stream-parse graph JSON and invoke progress callbacks with batches.
+ * Falls back to standard JSON.parse on any error.
+ *
+ * @param {string} url - The bridge URL to fetch
+ * @param {function} onProgress - Called with {entities, relationships, percent}
+ * @returns {Promise<{entities: Array, relationships: Array}>}
+ */
+export async function streamParseGraph(url, onProgress) {
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (_) {
+    throw new Error('Network failure fetching graph data');
+  }
+
+  if (!response.ok) throw new Error(`HTTP ${response.status} fetching graph data`);
+
+  const contentType = response.headers.get('content-type') || '';
+  const contentLength = parseInt(response.headers.get('content-length') || '0', 10);
+
+  if (!response.body || !response.body.getReader || contentLength < 50000) {
+    return fallbackParse(response, onProgress);
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let loaded = 0;
+
+  const state = {
+    entities: [],
+    relationships: [],
+    currentArray: null,
+    depth: 0,
+    arrayDepth: -1,
+    inString: false,
+    escape: false,
+    braceDepth: 0,
+    bracketDepth: 0,
+    objectStart: -1,
+  };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    loaded += value.length;
+    buffer += decoder.decode(value, { stream: true });
+
+    try {
+      processChunk(buffer, state, onProgress, contentLength, loaded);
+      buffer = '';
+    } catch (_) {
+      return fallbackParse(response, onProgress);
+    }
+  }
+
+  if (state.entities.length === 0 && state.relationships.length === 0) {
+    return fallbackParse(response, onProgress);
+  }
+
+  if (onProgress) {
+    onProgress({
+      entities: state.entities,
+      relationships: state.relationships,
+      percent: 100,
+    });
+  }
+
+  return { entities: state.entities, relationships: state.relationships };
+}
+
+function processChunk(chunk, state, onProgress, total, loaded) {
+  for (let i = 0; i < chunk.length; i++) {
+    const ch = chunk[i];
+
+    if (state.escape) {
+      state.escape = false;
+      continue;
+    }
+
+    if (ch === '\\' && state.inString) {
+      state.escape = true;
+      continue;
+    }
+
+    if (ch === '"') {
+      state.inString = !state.inString;
+      continue;
+    }
+
+    if (state.inString) continue;
+
+    if (ch === '{') state.braceDepth++;
+    if (ch === '}') state.braceDepth--;
+    if (ch === '[') state.bracketDepth++;
+    if (ch === ']') state.bracketDepth--;
+
+    if (ch === '[' && !state.currentArray) {
+      const lookback = chunk.substring(Math.max(0, i - 20), i + 1);
+      if (lookback.match(/"entities"\s*:\s*\[/)) {
+        state.currentArray = 'entities';
+        state.arrayDepth = state.bracketDepth;
+        state.objectStart = i + 1;
+      } else if (lookback.match(/"relationships"\s*:\s*\[/)) {
+        state.currentArray = 'relationships';
+        state.arrayDepth = state.bracketDepth;
+        state.objectStart = i + 1;
+      }
+    }
+
+    if (state.currentArray && ch === '}' && state.braceDepth < state.arrayDepth) {
+      try {
+        const objStr = chunk.substring(state.objectStart, i + 1);
+        const obj = JSON.parse(objStr);
+        state[state.currentArray].push(obj);
+      } catch (_) { /* skip malformed object */ }
+      state.objectStart = i + 1;
+
+      if (state[state.currentArray].length % BATCH_SIZE === 0 && onProgress) {
+        onProgress({
+          entities: state.entities,
+          relationships: state.relationships,
+          percent: total > 0 ? Math.round((loaded / total) * 100) : 50,
+        });
+      }
+    }
+
+    if (ch === ']' && state.bracketDepth < state.arrayDepth) {
+      state.currentArray = null;
+      state.arrayDepth = -1;
+    }
+  }
+}
+
+async function fallbackParse(response, onProgress) {
+  const text = await response.text();
+  try {
+    const data = JSON.parse(text);
+    const entities = data.entities || [];
+    const relationships = data.relationships || [];
+    if (onProgress) {
+      onProgress({ entities, relationships, percent: 100 });
+    }
+    return { entities, relationships };
+  } catch (e) {
+    throw new Error(`Failed to parse graph JSON: ${e.message}`);
+  }
+}

batho/dashboard/assets/js/main.js

@@ -0,0 +1,175 @@
+/**
+ * Main bootstrap - mounts header, rail, registers routes.
+ */
+
+import { router } from './router.js';
+import { createHeaderBar } from '../../shared/components/header-bar.js';
+import { createSideRail } from '../../shared/components/side-rail.js';
+import { loadIndex } from './ctn-loader.js';
+import { renderOverview } from '../../pages/overview.js';
+import { renderHypergraph } from '../../pages/hypergraph.js';
+import { renderFiles } from '../../pages/files.js';
+import { renderRelationships } from '../../pages/relationships.js';
+import { renderRules } from '../../pages/rules.js';
+import { renderSnapshots } from '../../pages/snapshots.js';
+import { renderMetrics } from '../../pages/metrics.js';
+import { renderSearch } from '../../pages/search.js';
+
+async function init() {
+  const app = document.getElementById('app');
+  if (!app) {
+    console.error('[batho] #app not found');
+    return;
+  }
+
+  // Clear pre-mount skeleton.
+  app.innerHTML = '';
+  app.className = 'app';
+
+  // Try to load the index via the bridge API. If the server is unreachable
+  // we still mount the shell so navigation works and pages can render their own error states.
+  let indexData = { currentIndexId: '—', indexes: {} };
+  let indexLoadError = null;
+  try {
+    indexData = await loadIndex();
+  } catch (err) {
+    indexLoadError = err;
+    console.warn('[batho] Could not load index:', err);
+  }
+
+  const savedIndexId = localStorage.getItem('batho.activeIndexId');
+  const activeIndexId =
+    savedIndexId && indexData.indexes[savedIndexId]
+      ? savedIndexId
+      : indexData.currentIndexId;
+  const activeEntry = indexData.indexes[activeIndexId] || {};
+  const repoRoot = activeEntry.root || '…';
+
+  const header = createHeaderBar({
+    repoRoot,
+    indexId: activeIndexId,
+    indexes: indexData.indexes,
+  });
+  header.classList.add('app__header');
+  app.appendChild(header);
+
+  const sideRail = createSideRail(router);
+  sideRail.classList.add('app__rail');
+  app.appendChild(sideRail);
+
+  const main = document.createElement('main');
+  main.id = 'page-mount';
+  main.className = 'app__main';
+  app.appendChild(main);
+
+  const aside = document.createElement('aside');
+  aside.id = 'notice-slot';
+  aside.setAttribute('aria-live', 'polite');
+  aside.setAttribute('aria-atomic', 'true');
+  aside.className = 'notice-slot';
+  app.appendChild(aside);
+
+  router.register('#/overview', renderOverview);
+  router.register('#/hypergraph', renderHypergraph);
+  router.register('#/files', renderFiles);
+  router.register('#/relationships', renderRelationships);
+  router.register('#/rules', renderRules);
+  router.register('#/snapshots', renderSnapshots);
+  router.register('#/metrics', renderMetrics);
+  router.register('#/search', renderSearch);
+  router.register('*', async () => {
+    const container = document.createElement('div');
+    container.className = 'panel panel--stub not-found';
+    container.innerHTML = `
+      <div class="not-found__code">404</div>
+      <div class="not-found__divider"></div>
+      <div class="not-found__message">Route is not part of the cockpit.</div>
+      <button class="btn" data-navigate="#/overview">return to overview</button>
+    `;
+    container
+      .querySelector('[data-navigate]')
+      .addEventListener('click', () => router.navigate('#/overview'));
+    return container;
+  });
+
+  router.on('change', ({ path }) => localStorage.setItem('batho.lastRoute', path));
+
+  // React to index switches from the header dropdown by re-running the
+  // current route handler. This keeps page state consistent everywhere.
+  window.addEventListener('batho:index-changed', () => router.handle());
+
+  if (indexLoadError) {
+    showNotice(
+      `Index unavailable: ${indexLoadError.message}. Some pages may render limited data.`,
+      'warn'
+    );
+  }
+
+  if (isDevMode()) runTokenDriftCheck();
+
+  router.start();
+}
+
+function isDevMode() {
+  return new URLSearchParams(window.location.search).get('dev') === '1';
+}
+
+function showNotice(message, tone = 'info') {
+  const slot = document.getElementById('notice-slot');
+  if (!slot) return;
+  const el = document.createElement('div');
+  el.className = `notice notice--${tone}`;
+  el.textContent = message;
+  slot.appendChild(el);
+  // Auto-dismiss after 8s so the notice stack stays clean.
+  setTimeout(() => el.remove(), 8000);
+}
+
+async function runTokenDriftCheck() {
+  try {
+    const response = await fetch('/dashboard/DESIGN.md');
+    if (!response.ok) return;
+    const text = await response.text();
+    const match = text.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return;
+    const yaml = match[1];
+    const colorsMatch = yaml.match(/colors:\s*\n((?:\s{2}.+\n?)+)/);
+    if (!colorsMatch) return;
+    const designColors = {};
+    colorsMatch[1].split('\n').forEach((line) => {
+      const [key, value] = line.trim().split(/:\s*/);
+      if (key && value) designColors[key] = value;
+    });
+    const rootStyles = getComputedStyle(document.documentElement);
+    const checkColors = ['surface', 'primary', 'tertiary', 'error'];
+    const drift = [];
+    checkColors.forEach((color) => {
+      const cssValue = rootStyles.getPropertyValue(`--${color}`).trim();
+      const designValue = designColors[color];
+      if (
+        designValue &&
+        cssValue.toLowerCase() !== designValue.toLowerCase()
+      ) {
+        drift.push({ color, css: cssValue, design: designValue });
+      }
+    });
+    if (drift.length > 0) {
+      const notice = document.createElement('div');
+      notice.className = 'notice notice--warn';
+      notice.innerHTML = `<strong>Token Drift Detected:</strong>${drift
+        .map((d) => `<br>--${d.color}: ${d.css} (DESIGN: ${d.design})`)
+        .join('')}`;
+      const slot = document.getElementById('notice-slot');
+      if (slot) slot.appendChild(notice);
+    }
+  } catch (e) {
+    console.warn('[batho] Token drift check failed:', e);
+  }
+}
+
+if (document.readyState === 'loading') {
+  document.addEventListener('DOMContentLoaded', init);
+} else {
+  // Module scripts defer by default, but be defensive.
+  init();
+}

batho/dashboard/assets/js/router.js

@@ -0,0 +1,101 @@
+/**
+ * Hash-based router with register/navigate/on('change') API.
+ */
+
+const router = {
+  routes: new Map(),
+  listeners: new Map(),
+  defaultRoute: '#/overview',
+
+  register(path, handler) { this.routes.set(path, handler); },
+
+  navigate(path, params = {}) {
+    const queryString = Object.keys(params).length > 0
+      ? '?' + new URLSearchParams(params).toString() : '';
+    const hash = path.startsWith('#') ? path : `#${path}`;
+    location.hash = hash + queryString;
+  },
+
+  on(event, listener) {
+    if (!this.listeners.has(event)) this.listeners.set(event, []);
+    this.listeners.get(event).push(listener);
+  },
+
+  emit(event, data) {
+    const listeners = this.listeners.get(event) || [];
+    listeners.forEach(listener => listener(data));
+  },
+
+  parseHash(hash) {
+    if (!hash || hash === '#') return { path: this.defaultRoute, params: new URLSearchParams() };
+    const cleanHash = hash.startsWith('#') ? hash.slice(1) : hash;
+    const [pathPart, queryPart] = cleanHash.split('?');
+    const path = pathPart.startsWith('/') ? pathPart : '/' + pathPart;
+    const params = new URLSearchParams(queryPart || '');
+    return { path: '#' + path, params };
+  },
+
+  async handle() {
+    const { path, params } = this.parseHash(location.hash || this.defaultRoute);
+    this.emit('change', { path, params });
+    const handler = this.routes.get(path);
+
+    if (!handler) {
+      const wildcard = this.routes.get('*');
+      if (wildcard) {
+        try { this.mount(await wildcard({ path, params })); }
+        catch (err) { this.emit('error', err); this.mount(this.renderError(err)); }
+      } else { this.mount(this.render404(path)); }
+      return;
+    }
+
+    try { this.mount(await handler(params)); }
+    catch (err) { this.emit('error', err); this.mount(this.renderError(err)); }
+  },
+
+  mount(element) {
+    const mountPoint = document.getElementById('page-mount');
+    if (mountPoint) { mountPoint.innerHTML = ''; mountPoint.appendChild(element); }
+  },
+
+  render404(path) {
+    const container = document.createElement('div');
+    container.className = 'panel panel--stub not-found';
+    container.innerHTML = `
+      <div class="not-found__code">404</div>
+      <div class="not-found__divider"></div>
+      <div class="not-found__message">Route ${path} is not part of the cockpit.</div>
+      <button class="btn" data-navigate="#/overview">return to overview</button>
+    `;
+    container.querySelector('[data-navigate]').addEventListener('click', () => this.navigate('#/overview'));
+    return container;
+  },
+
+  renderError(err) {
+    const container = document.createElement('div');
+    container.className = 'panel error-panel';
+    container.innerHTML = `
+      <div class="error-panel__icon">⚠</div>
+      <div class="error-panel__title">Structural Fault</div>
+      <div class="error-panel__message">${this.escapeHtml(err.message || 'An unknown error occurred')}</div>
+      <div class="error-panel__actions">
+        <button class="btn" data-action="retry">retry</button>
+        <button class="btn" data-action="snapshots">open snapshots</button>
+      </div>
+    `;
+    container.querySelector('[data-action="retry"]').addEventListener('click', () => this.handle());
+    container.querySelector('[data-action="snapshots"]').addEventListener('click', () => this.navigate('#/snapshots'));
+    return container;
+  },
+
+  escapeHtml(text) { const d = document.createElement('div'); d.textContent = text; return d.innerHTML; },
+
+  start() {
+    const savedRoute = localStorage.getItem('batho.lastRoute');
+    if (savedRoute && !location.hash) location.hash = savedRoute;
+    window.addEventListener('hashchange', () => this.handle());
+    this.handle();
+  }
+};
+
+export { router };

batho/dashboard/assets/js/store.js

@@ -0,0 +1,53 @@
+/**
+ * LRU store with namespace isolation. LRU cap = 3 by index_id.
+ */
+
+const LRU_CAP = 3;
+
+const store = {
+  data: new Map(),
+  insertionOrder: [],
+
+  put(indexId, key, value) {
+    if (!this.data.has(indexId)) {
+      if (this.data.size >= LRU_CAP) {
+        const oldestIndexId = this.insertionOrder.shift();
+        this.data.delete(oldestIndexId);
+      }
+      this.insertionOrder.push(indexId);
+      this.data.set(indexId, new Map());
+    } else {
+      const idx = this.insertionOrder.indexOf(indexId);
+      if (idx > -1) { this.insertionOrder.splice(idx, 1); this.insertionOrder.push(indexId); }
+    }
+    this.data.get(indexId).set(key, value);
+  },
+
+  get(indexId, key) { const ns = this.data.get(indexId); return ns ? ns.get(key) : undefined; },
+  has(indexId, key) { const ns = this.data.get(indexId); return ns ? ns.has(key) : false; },
+  delete(indexId, key) { const ns = this.data.get(indexId); if (ns) ns.delete(key); },
+
+  clear(indexId) {
+    if (indexId) {
+      const ns = this.data.get(indexId);
+      if (ns) {
+        const idx = this.insertionOrder.indexOf(indexId);
+        if (idx > -1) this.insertionOrder.splice(idx, 1);
+        ns.clear();
+        this.data.delete(indexId);
+      }
+    } else { this.data.clear(); this.insertionOrder = []; }
+  },
+
+  keys(indexId) { const ns = this.data.get(indexId); return ns ? Array.from(ns.keys()) : []; },
+
+  size(indexId) {
+    if (indexId) { const ns = this.data.get(indexId); return ns ? ns.size : 0; }
+    let total = 0; for (const ns of this.data.values()) total += ns.size;
+    return total;
+  },
+
+  namespaces() { return Array.from(this.data.keys()); }
+};
+
+export { store };

batho/dashboard/index.html

@@ -0,0 +1,88 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <meta name="color-scheme" content="dark light" />
+  <meta name="description" content="Batho — brutalist code intelligence cockpit" />
+  <title>Batho Dashboard</title>
+  <link
+    rel="icon"
+    type="image/svg+xml"
+    href="data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'><rect x='2' y='2' width='12' height='12' fill='%2300d9ff'/></svg>"
+  />
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link
+    href="https://fonts.googleapis.com/css2?family=Inter:wght@500;600&family=Space+Grotesk:wght@500;700&family=JetBrains+Mono:wght@400;500&display=swap"
+    rel="stylesheet"
+  />
+  <link rel="stylesheet" href="/dashboard/assets/css/tokens.css" />
+  <link rel="stylesheet" href="/dashboard/assets/css/base.css" />
+  <link rel="stylesheet" href="/dashboard/assets/css/components.css" />
+  <link rel="stylesheet" href="/dashboard/assets/css/animations.css" />
+  <link rel="stylesheet" href="/dashboard/assets/css/graph.css" />
+  <style>
+    .notice-slot {
+      position: fixed;
+      bottom: 16px;
+      right: 16px;
+      z-index: 1000;
+      max-width: 400px;
+      pointer-events: none;
+    }
+    .notice {
+      padding: var(--space-pad);
+      margin-top: var(--space-gutter);
+      border: var(--hairline);
+      background: var(--surface-container);
+      font-size: var(--type-terminal-size);
+      pointer-events: auto;
+    }
+    .notice--warn {
+      border-color: var(--tertiary);
+      color: var(--tertiary);
+    }
+
+    /* Pre-mount skeleton so the page never flashes white. */
+    .app-bootstrap {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      height: 100vh;
+      width: 100vw;
+      color: var(--on-surface-variant, #aaa);
+      background: var(--surface, #0a0a0a);
+      font-family: var(--font-mono, monospace);
+      font-size: 12px;
+      letter-spacing: 0.04em;
+    }
+    .app-bootstrap__cursor {
+      display: inline-block;
+      width: 8px;
+      height: 12px;
+      background: var(--accent-cyan, #00d9ff);
+      margin-right: 8px;
+      animation: app-bootstrap-blink 1s steps(2) infinite;
+    }
+    @keyframes app-bootstrap-blink {
+      0%, 50% { opacity: 1; }
+      50.01%, 100% { opacity: 0; }
+    }
+  </style>
+</head>
+<body>
+  <div id="app">
+    <div class="app-bootstrap" role="status" aria-live="polite">
+      <span class="app-bootstrap__cursor" aria-hidden="true"></span>
+      <span>booting cockpit&hellip;</span>
+    </div>
+  </div>
+  <noscript>
+    <div style="padding:16px;font-family:monospace;background:#0a0a0a;color:#fff;">
+      Batho Dashboard requires JavaScript to render the cockpit.
+    </div>
+  </noscript>
+  <script type="module" src="/dashboard/assets/js/main.js"></script>
+</body>
+</html>