vibe-squire 1.0.0

package/dist/ui/public/operator-activity.js

@@ -0,0 +1,223 @@
+(function () {
+  var Ui = window.VibeSquireUi;
+  if (!Ui) return;
+
+  var root = document.getElementById('activity-runs-root');
+  if (!root) return;
+
+  var POLL_WHILE_RUNNING_MS = 2500;
+  var esc = Ui.esc;
+  var fmtIso = Ui.fmtIso;
+
+  function fmtCount(v) {
+    return v == null ? '—' : String(v);
+  }
+
+  function renderItemsTable(items) {
+    if (!items || !items.length) return '';
+    var rows = items
+      .map(function (it) {
+        var detailParts = [];
+        if (it.kanbanIssueId) {
+          detailParts.push(
+            '<span class="mono">issue ' + esc(it.kanbanIssueId) + '</span>',
+          );
+        }
+        if (it.detail) {
+          detailParts.push(esc(it.detail));
+        }
+        var detail =
+          detailParts.length > 1
+            ? detailParts.join(' · ')
+            : detailParts[0] || '';
+        var author =
+          it.authorLogin &&
+          '<div class="muted" style="font-size:0.8rem">@' +
+            esc(it.authorLogin) +
+            '</div>';
+        return (
+          '<tr>' +
+          '<td class="mono">' +
+          '<a href="' +
+          esc(it.prUrl) +
+          '" target="_blank" rel="noopener noreferrer">#' +
+          esc(it.prNumber) +
+          '</a>' +
+          '<div class="activity-pr-title muted">' +
+          esc(it.prTitle) +
+          '</div>' +
+          (author || '') +
+          '</td>' +
+          '<td class="mono wrap">' +
+          esc(it.githubRepo) +
+          '</td>' +
+          '<td>' +
+          esc(it.decisionLabel) +
+          '</td>' +
+          '<td class="wrap muted">' +
+          detail +
+          '</td>' +
+          '</tr>'
+        );
+      })
+      .join('');
+    return (
+      '<details class="activity-details">' +
+      '<summary class="activity-details-summary">PR details (' +
+      items.length +
+      ')</summary>' +
+      '<div class="table-wrap activity-items-wrap">' +
+      '<table class="data-table activity-items-table">' +
+      '<thead><tr><th>PR</th><th>Repo</th><th>Outcome</th><th>Detail</th></tr></thead>' +
+      '<tbody>' +
+      rows +
+      '</tbody></table></div></details>'
+    );
+  }
+
+  function renderRun(r) {
+    var meta =
+      '<div class="activity-run-meta">' +
+      '<span class="activity-run-time mono">' +
+      esc(r.startedAtLabel || fmtIso(r.startedAt)) +
+      '</span>' +
+      '<span class="activity-pill activity-pill-trigger">' +
+      esc(r.trigger) +
+      '</span>' +
+      '<span class="activity-pill activity-pill-phase activity-pill-phase-' +
+      esc(r.phase) +
+      '">' +
+      esc(r.phaseLabel) +
+      '</span></div>';
+
+    var summaryBody = '';
+    if (r.phase === 'running') {
+      summaryBody +=
+        '<p class="muted activity-run-counts" style="margin:0.35rem 0 0">Sync in progress… ' +
+        (r.itemCount || 0) +
+        ' PR row(s) recorded so far.</p>';
+    }
+    if (r.phase === 'completed') {
+      summaryBody +=
+        '<p class="muted activity-run-counts" style="margin:0.35rem 0 0">' +
+        fmtCount(r.candidatesCount) +
+        ' PR(s) seen · ' +
+        fmtCount(r.issuesCreated) +
+        ' created · ' +
+        fmtCount(r.skippedUnmapped) +
+        ' unmapped · ' +
+        fmtCount(r.skippedBot) +
+        ' bot · ' +
+        fmtCount(r.skippedBoardLimit) +
+        ' board limit · ' +
+        fmtCount(r.skippedAlreadyTracked) +
+        ' already tracked · ' +
+        fmtCount(r.skippedLinkedExisting) +
+        ' linked existing</p>';
+    }
+    if (r.phase === 'aborted') {
+      summaryBody +=
+        '<p class="muted activity-run-msg" style="margin:0.35rem 0 0">' +
+        (r.abortReason
+          ? '<code class="mono">' + esc(r.abortReason) + '</code>'
+          : 'Aborted') +
+        '</p>';
+    }
+    if (r.phase === 'failed') {
+      summaryBody +=
+        '<p class="banner banner-error activity-run-msg" style="margin:0.5rem 0 0">' +
+        esc(r.errorMessage || 'Sync failed') +
+        '</p>';
+    }
+
+    var details = r.itemCount ? renderItemsTable(r.items) : '';
+
+    return (
+      '<div class="card activity-run">' +
+      '<div class="activity-run-summary">' +
+      meta +
+      summaryBody +
+      '</div>' +
+      details +
+      '</div>'
+    );
+  }
+
+  function renderRuns(runs) {
+    if (!runs || !runs.length) {
+      return (
+        '<div class="card activity-empty-card">' +
+        '<p class="muted" style="margin:0">No sync runs recorded yet. Runs appear when a sync starts.</p>' +
+        '</div>'
+      );
+    }
+    return runs.map(renderRun).join('');
+  }
+
+  var pollTimer = null;
+  var pollWanted = false;
+
+  function anyRunning(runs) {
+    if (!runs || !runs.length) return false;
+    for (var i = 0; i < runs.length; i++) {
+      if (runs[i].phase === 'running') return true;
+    }
+    return false;
+  }
+
+  function stopPoll() {
+    if (pollTimer != null) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+  }
+
+  function startPollInterval() {
+    stopPoll();
+    if (!pollWanted || document.visibilityState !== 'visible') return;
+    pollTimer = window.setInterval(function () {
+      void load();
+    }, POLL_WHILE_RUNNING_MS);
+  }
+
+  document.addEventListener('visibilitychange', function () {
+    if (document.visibilityState === 'hidden') {
+      stopPoll();
+    } else if (pollWanted) {
+      void load();
+      startPollInterval();
+    }
+  });
+
+  function schedulePollIfNeeded(runs) {
+    pollWanted = anyRunning(runs);
+    if (!pollWanted) {
+      stopPoll();
+      return;
+    }
+    startPollInterval();
+  }
+
+  async function load() {
+    try {
+      var res = await fetch('/api/activity/runs');
+      var text = await res.text();
+      if (!res.ok) throw new Error('HTTP ' + res.status);
+      var data = text ? JSON.parse(text) : { runs: [] };
+      var runs = data.runs || [];
+      root.innerHTML = renderRuns(runs);
+      schedulePollIfNeeded(runs);
+    } catch {
+      root.innerHTML =
+        '<div class="card"><p class="muted" style="margin:0">Could not load activity. Try refreshing the page.</p></div>';
+      stopPoll();
+      pollWanted = false;
+    }
+  }
+
+  Ui.onStatusSnapshot(function () {
+    void load();
+  });
+
+  void load();
+})();

package/dist/ui/public/operator-dashboard.js

@@ -0,0 +1,295 @@
+(function () {
+  const Ui = window.VibeSquireUi;
+  if (!Ui) return;
+
+  const pre = document.getElementById('status-snap');
+  const overview = document.getElementById('status-overview');
+  const bootEl = document.getElementById('boot-snapshot');
+  const msgEl = document.getElementById('action-msg');
+  const btnSync = document.getElementById('btn-sync');
+  const btnReinit = document.getElementById('btn-reinit');
+
+  const POLL_MS = 5 * 60 * 1000;
+  const esc = Ui.esc;
+  const fmtIso = Ui.fmtIso;
+
+  var reasonMap = {};
+  try {
+    var el = document.getElementById('setup-reasons');
+    if (el && el.textContent) reasonMap = JSON.parse(el.textContent);
+  } catch { /* embedded map unavailable — fall through to reason code */ }
+
+  function setupReasonHuman(reason) {
+    if (!reason) return 'Incomplete setup.';
+    return reasonMap[reason] || String(reason);
+  }
+
+  function ghHuman(state, message) {
+    if (state === 'ok') return 'Authenticated and ready.';
+    if (state === 'error') {
+      return message && String(message).trim()
+        ? String(message)
+        : 'GitHub CLI error — check `gh` output.';
+    }
+    if (state === 'unknown') return 'GitHub CLI status unknown.';
+    return String(state);
+  }
+
+  function destHuman(d) {
+    const m = {
+      ok: 'Reachable.',
+      degraded: 'Degraded — some calls may fail.',
+      error: 'Error — check MCP stdio command and server.',
+      unknown: 'Not probed yet.',
+    };
+    return m[d.state] || String(d.state);
+  }
+
+  /** Show Reinit when DB, gh, destination, or scout looks unhealthy (not mere setup skip). */
+  function needsReinit(snap) {
+    if (!snap || typeof snap !== 'object') return false;
+    const db = snap.database || {};
+    if (db.state === 'error') return true;
+    const gh = snap.gh || {};
+    if (gh.state && gh.state !== 'ok') return true;
+    const dest = (snap.destinations && snap.destinations[0]) || {};
+    if (dest.state === 'degraded' || dest.state === 'error') return true;
+    const scout = snap.scouts && snap.scouts[0];
+    if (scout && scout.state === 'error') return true;
+    return false;
+  }
+
+  function card(title, dotClass, lines) {
+    const body = (lines || [])
+      .filter(Boolean)
+      .map((l) => '<p>' + esc(l) + '</p>')
+      .join('');
+    return (
+      '<div class="status-card">' +
+      '<div class="status-card-head">' +
+      '<span class="status-dot ' +
+      esc(dotClass) +
+      '" aria-hidden="true"></span>' +
+      '<h3>' +
+      esc(title) +
+      '</h3></div>' +
+      '<div class="status-card-body">' +
+      body +
+      '</div></div>'
+    );
+  }
+
+  function renderOverview(snap) {
+    if (!overview || !snap) return;
+    const parts = [];
+
+    const gh = snap.gh || {};
+    let ghDot = 'status-neutral';
+    if (gh.state === 'ok') ghDot = 'status-ok';
+    else if (gh.state === 'error') ghDot = 'status-err';
+    else ghDot = 'status-warn';
+    const ghLines = [ghHuman(gh.state, gh.message)];
+    parts.push(card('GitHub CLI', ghDot, ghLines));
+
+    const db = snap.database || {};
+    const dbDot = db.state === 'ok' ? 'status-ok' : 'status-err';
+    const dbLines = [
+      db.state === 'ok' ? 'Database connected.' : 'Database error.',
+    ];
+    if (db.message) dbLines.push(db.message);
+    parts.push(card('Database', dbDot, dbLines));
+
+    const setup = snap.setup || {};
+    const setupDot = setup.complete ? 'status-ok' : 'status-warn';
+    const cfg = snap.configuration || {};
+    const setupLines = setup.complete
+      ? [
+          'Setup complete (sync allowed).',
+          'PR source: ' + String(cfg.source_type ?? '—'),
+          'Board: ' + String(cfg.destination_type ?? '—'),
+          'Mappings: ' + String(setup.mappingCount ?? 0),
+        ]
+      : [
+          'Finish MCP and routing (see checklist on dashboard).',
+          setupReasonHuman(setup.reason),
+        ];
+    parts.push(card('Setup', setupDot, setupLines));
+
+    const dest = (snap.destinations && snap.destinations[0]) || {};
+    let destDot = 'status-neutral';
+    if (dest.state === 'ok') destDot = 'status-ok';
+    else if (dest.state === 'degraded') destDot = 'status-warn';
+    else if (dest.state === 'error') destDot = 'status-err';
+    const destLines = ['Vibe Kanban (MCP).', destHuman(dest)];
+    if (dest.message) destLines.push(dest.message);
+    if (dest.lastOkAt) destLines.push('Last OK: ' + fmtIso(dest.lastOkAt));
+    parts.push(card('Destination', destDot, destLines));
+
+    const scout = snap.scouts && snap.scouts[0];
+    if (scout) {
+      let scDot = 'status-neutral';
+      if (scout.state === 'running') scDot = 'status-warn';
+      else if (scout.state === 'error') scDot = 'status-err';
+      else if (scout.state === 'skipped') scDot = 'status-warn';
+      else scDot = 'status-ok';
+      const scLines = [];
+      const sched = snap.scheduled_sync || {};
+      if (sched.enabled === false) {
+        scLines.push(
+          'Automatic polling is disabled — enable scheduled_sync_enabled in General settings (or SCHEDULED_SYNC_ENABLED).',
+        );
+      }
+      if (scout.state === 'running') {
+        scLines.push('Sync cycle running…');
+      } else {
+        scLines.push('GitHub PR scout: ' + String(scout.state));
+      }
+      if (scout.skipReason) {
+        scLines.push('Reason: ' + String(scout.skipReason));
+      }
+      if (scout.lastError && scout.state === 'error') {
+        scLines.push(String(scout.lastError));
+      }
+      const lp = scout.last_poll || {};
+      if (
+        lp.candidates_count != null ||
+        lp.skipped_unmapped != null ||
+        lp.issues_created != null
+      ) {
+        scLines.push(
+          'Last run: ' +
+            (lp.candidates_count ?? '—') +
+            ' PR(s), ' +
+            (lp.issues_created ?? '—') +
+            ' created, ' +
+            (lp.skipped_unmapped ?? '—') +
+            ' skipped (unmapped)',
+        );
+      }
+      scLines.push('Last poll: ' + fmtIso(scout.lastPollAt));
+      if (sched.enabled === false) {
+        scLines.push('Next scheduled: — (timer off)');
+      } else {
+        scLines.push('Next scheduled: ' + fmtIso(scout.nextPollAt));
+      }
+      parts.push(card('Sync & scout', scDot, scLines));
+    }
+
+    const ms = snap.manual_sync || {};
+    let manDot = 'status-ok';
+    if (ms.canRun === false) manDot = 'status-warn';
+    const manLines = [];
+    if (ms.canRun !== false) {
+      manLines.push('You can run “Sync now” anytime (respects cooldown after a run).');
+    } else if (ms.reason === 'cooldown' && ms.cooldownUntil) {
+      manLines.push('Manual sync on cooldown until ' + fmtIso(ms.cooldownUntil));
+    } else if (ms.reason === 'already_running') {
+      manDot = 'status-warn';
+      manLines.push('Wait — a sync cycle is already running.');
+    } else {
+      manLines.push('Manual sync unavailable: ' + String(ms.reason || 'unknown'));
+    }
+    parts.push(card('Manual sync', manDot, manLines));
+
+    overview.innerHTML = parts.join('');
+  }
+
+  function setMsg(t) {
+    if (!msgEl) return;
+    msgEl.textContent = t || '';
+    msgEl.style.display = t ? 'block' : 'none';
+  }
+
+  function renderManual(m) {
+    if (!m || !btnSync) return;
+    btnSync.disabled = m.canRun === false;
+    btnSync.title =
+      m.reason === 'cooldown' && m.cooldownUntil
+        ? 'Cooldown until ' + m.cooldownUntil
+        : 'Run one full sync cycle now (same as the scheduler, but immediate)';
+  }
+
+  function applySnapshot(snap) {
+    if (!snap) return;
+    renderOverview(snap);
+    if (pre) pre.textContent = JSON.stringify(snap, null, 2);
+    renderManual(snap.manual_sync);
+    if (btnReinit) {
+      btnReinit.style.display = needsReinit(snap) ? '' : 'none';
+    }
+  }
+
+  function readBoot() {
+    if (!bootEl || !bootEl.textContent.trim()) return null;
+    try {
+      return JSON.parse(bootEl.textContent);
+    } catch {
+      return null;
+    }
+  }
+
+  async function load() {
+    try {
+      const res = await fetch('/api/status');
+      const text = await res.text();
+      const snap = text ? JSON.parse(text) : null;
+      if (!res.ok) throw new Error('HTTP ' + res.status);
+      applySnapshot(snap);
+      setMsg('');
+    } catch (e) {
+      const err = e instanceof Error ? e.message : String(e);
+      if (pre) pre.textContent = 'Error: ' + err;
+    }
+  }
+
+  const boot = readBoot();
+  if (boot) applySnapshot(boot);
+
+  try {
+    const w = window;
+    if (w.__VS_STATUS_SNAPSHOT__) {
+      applySnapshot(w.__VS_STATUS_SNAPSHOT__);
+    }
+  } catch {
+    /* ignore */
+  }
+
+  Ui.onStatusSnapshot((snap) => applySnapshot(snap));
+
+  window.setInterval(() => void load(), POLL_MS);
+  void load();
+
+  btnSync?.addEventListener('click', async () => {
+    setMsg('');
+    const res = await fetch('/api/sync/run', { method: 'POST' });
+    const text = await res.text();
+    if (res.status === 429) {
+      try {
+        const j = JSON.parse(text);
+        setMsg('Cooldown — try after ' + (j.cooldownUntil || 'later'));
+      } catch {
+        setMsg('Cooldown');
+      }
+      return;
+    }
+    if (!res.ok) {
+      setMsg(text || 'HTTP ' + res.status);
+      return;
+    }
+    setMsg('Sync finished.');
+    void load();
+  });
+
+  btnReinit?.addEventListener('click', async () => {
+    if (!confirm('Run soft reinit? This resets scout backoff flags.')) return;
+    setMsg('');
+    const res = await fetch('/api/reinit', { method: 'POST' });
+    const text = await res.text();
+    if (!res.ok) {
+      setMsg(text || 'HTTP ' + res.status);
+      return;
+    }
+    setMsg('Reinit completed.');
+    void load();
+  });
+})();

package/dist/ui/public/operator-mappings.js

@@ -0,0 +1,97 @@
+(function () {
+  const form = document.getElementById('new-mapping-form');
+  const repoSel = document.getElementById('mk-repo');
+  const hVkRepo = document.getElementById('h-vk-repo');
+  const mkErr = document.getElementById('mk-err');
+  function setMkErr(t) {
+    if (!mkErr) return;
+    mkErr.textContent = t || '';
+    mkErr.style.display = t ? 'block' : 'none';
+  }
+
+  if (form && repoSel && hVkRepo) {
+    async function loadRepos() {
+      repoSel.innerHTML = '<option value="">Loading…</option>';
+      hVkRepo.value = '';
+      setMkErr('');
+      try {
+        const res = await fetch('/api/vibe-kanban/repos');
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          const msg =
+            typeof data.message === 'string'
+              ? data.message
+              : 'Could not load repositories (' + res.status + ').';
+          setMkErr(msg);
+          repoSel.innerHTML = '<option value="">—</option>';
+          return;
+        }
+        const repos = data.repos || [];
+        repoSel.innerHTML =
+          '<option value="">Select Vibe Kanban repository…</option>';
+        for (const r of repos) {
+          const opt = document.createElement('option');
+          opt.value = r.id;
+          opt.textContent = r.name ? r.name + ' — ' + r.id : r.id;
+          repoSel.appendChild(opt);
+        }
+        if (!repos.length) {
+          setMkErr('No repositories returned from MCP.');
+        }
+      } catch (e) {
+        setMkErr(e instanceof Error ? e.message : String(e));
+        repoSel.innerHTML = '<option value="">—</option>';
+      }
+    }
+
+    repoSel.addEventListener('change', () => {
+      hVkRepo.value = repoSel.value.trim();
+    });
+
+    form.addEventListener('submit', (e) => {
+      if (!hVkRepo.value.trim()) {
+        e.preventDefault();
+        alert('Choose a Vibe Kanban repository from the list.');
+      }
+    });
+
+    void loadRepos();
+  }
+
+  function wireRow(row) {
+    const id = row.getAttribute('data-id');
+    if (!id) return;
+    const editBtn = row.querySelector('.js-edit');
+    const saveBtn = row.querySelector('.js-save');
+    const cancelBtn = row.querySelector('.js-cancel');
+    const inputs = row.querySelectorAll('input.edit');
+
+    editBtn?.addEventListener('click', () => {
+      row.classList.add('is-editing');
+    });
+    cancelBtn?.addEventListener('click', () => {
+      location.reload();
+    });
+    saveBtn?.addEventListener('click', async () => {
+      if (inputs.length < 3) return;
+      const body = {
+        githubRepo: inputs[0].value.trim(),
+        vibeKanbanRepoId: inputs[1].value.trim(),
+        label: inputs[2].value.trim() || undefined,
+      };
+      const res = await fetch('/api/mappings/' + encodeURIComponent(id), {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      if (!res.ok) {
+        const t = await res.text();
+        alert(t || 'HTTP ' + res.status);
+        return;
+      }
+      location.reload();
+    });
+  }
+
+  document.querySelectorAll('.js-mapping-row').forEach(wireRow);
+})();

package/dist/ui/public/operator-shell.js

@@ -0,0 +1,43 @@
+(function () {
+  var g = window;
+  var VS = g.VibeSquireUi || {};
+  var SSE_EVENT =
+    VS.STATUS_SNAPSHOT_EVENT || g.__VS_SSE_EVENT__ || 'vibesquire:status-snapshot';
+  var stateEl = document.getElementById('nav-sse-state');
+
+  function setSse(s) {
+    if (!stateEl) return;
+    stateEl.textContent = s;
+    stateEl.className = 'sse sse-' + s;
+  }
+
+  function publishSnapshot(snap) {
+    if (!snap || typeof snap !== 'object') return;
+    try {
+      g.__VS_STATUS_SNAPSHOT__ = snap;
+    } catch {
+      /* ignore */
+    }
+    g.dispatchEvent(new CustomEvent(SSE_EVENT, { detail: snap }));
+  }
+
+  var es = new EventSource('/api/status/stream');
+  setSse('connecting');
+  es.onopen = function () {
+    setSse('open');
+  };
+  es.onerror = function () {
+    setSse('closed');
+  };
+  es.onmessage = function (ev) {
+    if (!ev.data || !String(ev.data).trim()) {
+      return;
+    }
+    try {
+      var snap = JSON.parse(ev.data);
+      publishSnapshot(snap);
+    } catch {
+      /* ignore */
+    }
+  };
+})();

package/dist/ui/public/operator-ui-shared.js

@@ -0,0 +1,40 @@
+(function (g) {
+  var VS = (g.VibeSquireUi = g.VibeSquireUi || {});
+
+  VS.STATUS_SNAPSHOT_EVENT = 'vibesquire:status-snapshot';
+  g.__VS_SSE_EVENT__ = VS.STATUS_SNAPSHOT_EVENT;
+
+  VS.esc = function (s) {
+    if (s == null || s === undefined) return '';
+    return String(s)
+      .replace(/&/g, '&')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;');
+  };
+
+  VS.fmtIso = function (iso) {
+    if (!iso) return '—';
+    try {
+      var d = new Date(iso);
+      return Number.isNaN(d.getTime()) ? String(iso) : d.toLocaleString();
+    } catch {
+      return String(iso);
+    }
+  };
+
+  /**
+   * Subscribe to status snapshots dispatched by operator-shell (SSE).
+   * @param {(snap: object) => void} callback
+   * @returns {() => void} unsubscribe
+   */
+  VS.onStatusSnapshot = function (callback) {
+    var handler = function (ev) {
+      if (ev && ev.detail) callback(ev.detail);
+    };
+    g.addEventListener(VS.STATUS_SNAPSHOT_EVENT, handler);
+    return function () {
+      g.removeEventListener(VS.STATUS_SNAPSHOT_EVENT, handler);
+    };
+  };
+})(window);