@yemi33/minions 0.1.2431 → 0.1.2432

package/dashboard/js/render-other.js

@@ -33,6 +33,13 @@ function renderProjects(projects) {
 // a warning chip when branchMismatch (configured ≠ origin/HEAD) OR when the
 // local branch is behind main, and a compact "↑N ↓M" chip when ahead/behind
 // counts are non-zero.
+//
+// SEMANTICS SOURCE OF TRUTH: the branch/ahead-behind/dirty/main-drift semantics
+// below are mirrored (data-only, no HTML) in dashboard/shared/project-git-summary.js
+// so the Slim UX project-pill hover can render the SAME facts without forking
+// this HTML renderer (CLAUDE.md "no duplicate solutions"). Keep the two in sync;
+// this function stays the canonical HTML renderer (its unit tests extract it
+// standalone, so it deliberately does not call the shared helper).
 function _renderProjectBranch(p) {
   if (!p) return '';
   if (p.gitState === 'missing') return '<span class="project-warn" title="Project localPath does not exist on disk">(path not found)</span>';

package/dashboard/shared/project-git-summary.js

@@ -0,0 +1,239 @@
+// dashboard/shared/project-git-summary.js
+//
+// Pure, DOM-free summarizer of a /api/status project object's git + dispatch
+// state. This is the SINGLE source of truth for the *semantics* that the
+// classic Projects bar renders as HTML chips in dashboard/js/render-other.js
+// (_renderProjectBranch / _renderWorktreeModePill / _liveValidationTypesArray).
+// Slim UX loads this helper (it does NOT load render-other.js) to build the
+// project-pill hover panel without forking the classic branching logic
+// (CLAUDE.md "no duplicate solutions — reuse before re-implementing").
+//
+// It intentionally returns plain data only — no HTML, no escaping, no DOM — so
+// each surface renders it its own way (classic keeps its HTML chips; slim renders
+// a hover popover + a title-attribute fallback). Keep the field semantics in
+// lock-step with render-other.js; that file remains the canonical HTML renderer
+// and its unit tests (ahead-behind-badge-comparator-label.test.js,
+// dashboard-worktree-mode-pill.test.js) extract those functions standalone, so
+// they are deliberately NOT refactored to call this helper.
+
+// Mirrors render-other.js#_liveValidationTypesArray: normalize the single-string
+// legacy shape OR an array of strings into an array of non-empty strings.
+function _projectLiveValidationTypes(p) {
+  var raw = p && p.liveValidationType;
+  if (!raw) return [];
+  var arr = Array.isArray(raw) ? raw : [raw];
+  return arr.filter(function (t) { return typeof t === 'string' && t.length > 0; });
+}
+
+// Mirrors the checkout-mode classification in render-other.js#_renderWorktreeModePill.
+// Returns { kind, label, types, autoValidate, detail } where kind is one of
+// 'worktree' | 'live' | 'hybrid' | 'hybrid-invalid'.
+function _projectCheckoutMode(p) {
+  if (p && p.checkoutMode === 'live') {
+    var types = _projectLiveValidationTypes(p);
+    if (p.liveValidationInvalid) {
+      var effective = types.length > 0 ? types.join(', ') : 'none';
+      return {
+        kind: 'hybrid-invalid',
+        label: 'Hybrid · invalid',
+        types: types,
+        autoValidate: false,
+        detail: 'Invalid hybrid configuration — unsupported settings are ignored. '
+          + 'Effective live work-item types: ' + effective + '.',
+      };
+    }
+    if (types.length > 0) {
+      var typesText = types.join(', ');
+      var autoDispatch = p.liveValidationAutoDispatch === true;
+      return {
+        kind: 'hybrid',
+        label: 'Hybrid · ' + typesText + (autoDispatch ? ' · auto-validate' : ''),
+        types: types,
+        autoValidate: autoDispatch,
+        detail: 'Hybrid dispatch — only the "' + typesText + '" work-item type(s) run '
+          + 'in-place; all others use isolated worktrees. '
+          + (autoDispatch
+            ? 'A validation work item is dispatched automatically after each eligible coding work item.'
+            : 'Auto-validation is OFF — validation must be dispatched manually.'),
+      };
+    }
+    return {
+      kind: 'live',
+      label: 'Live checkout',
+      types: [],
+      autoValidate: false,
+      detail: 'Live-checkout dispatch — agents run in-place inside the project working '
+        + 'tree (no isolated worktree); capped to one mutating dispatch.',
+    };
+  }
+  return {
+    kind: 'worktree',
+    label: 'Worktrees',
+    types: [],
+    autoValidate: false,
+    detail: 'Worktree dispatch mode (default) — each agent runs in its own git worktree.',
+  };
+}
+
+// Summarize a single project object from GET /api/status.
+// Returns a plain object:
+//   {
+//     state,                 // 'missing'|'non-git'|'probe-timeout'|'stale'|'unknown'|'ok'
+//     available,             // true only when git branch data is present + fresh
+//     refreshing,            // true when the cached branch data is known-stale
+//     message,               // short label for non-ok/unavailable states (or null)
+//     branch, mainBranch, remoteDefaultBranch,
+//     detached, dirty,
+//     branchDiffersFromMain,
+//     ahead, behind, comparator, branchDiffersFromComparator, showAheadBehind,
+//     warn,                  // null | { kind:'main-drift'|'behind', text, detail }
+//     mode,                  // { kind, label, types, autoValidate, detail }
+//     lines,                 // [{ label, value }] ready-to-render rows
+//     warnings,              // [string] visible warning chips
+//     titleText,             // multi-fact "•"-joined string for a title= fallback
+//   }
+function summarizeProjectGit(p) {
+  var mode = _projectCheckoutMode(p || {});
+  var base = {
+    state: 'unknown',
+    available: false,
+    refreshing: false,
+    message: null,
+    branch: null,
+    mainBranch: null,
+    remoteDefaultBranch: null,
+    detached: false,
+    dirty: false,
+    branchDiffersFromMain: false,
+    ahead: null,
+    behind: null,
+    comparator: null,
+    branchDiffersFromComparator: false,
+    showAheadBehind: false,
+    warn: null,
+    mode: mode,
+    lines: [],
+    warnings: [],
+    titleText: '',
+  };
+
+  if (!p) return base;
+
+  // Non-ok git states — mirror the early returns of _renderProjectBranch.
+  if (p.gitState === 'missing') {
+    base.state = 'missing';
+    base.message = '(path not found)';
+    base.titleText = 'Project localPath does not exist on disk';
+    return base;
+  }
+  if (p.gitState === 'non-git') {
+    base.state = 'non-git';
+    base.message = '(not a git repo)';
+    base.titleText = 'Project path exists but is not a git repository';
+    return base;
+  }
+  if (p.gitState === 'probe-timeout') {
+    base.state = 'probe-timeout';
+    base.message = '(checking git…)';
+    base.titleText = 'Git status probe timed out (slow filesystem). The repository is valid and will refresh.';
+    return base;
+  }
+  if (p.gitState !== 'ok' || !p.gitBranch) {
+    // Nothing to show (classic returns an empty string here).
+    base.state = 'unknown';
+    return base;
+  }
+  if (p.gitStale) {
+    // Cached branch/dirty is known-stale — show a neutral refreshing state
+    // rather than a possibly-wrong branch name (parity with classic).
+    base.state = 'stale';
+    base.refreshing = true;
+    base.message = '(refreshing…)';
+    base.titleText = 'Branch changed outside the dashboard — refreshing…';
+    return base;
+  }
+
+  var branch = p.gitBranch;
+  var mainBranch = p.mainBranch || '';
+  var remoteDefault = p.remoteDefaultBranch || '';
+  var ahead = Number.isFinite(p.ahead) ? p.ahead : null;
+  var behind = Number.isFinite(p.behind) ? p.behind : null;
+  var branchDiffersFromMain = !!(mainBranch && branch !== mainBranch);
+  var comparator = mainBranch || remoteDefault;
+  // Comparator for ahead/behind is origin/<mainBranch || remoteDefaultBranch>
+  // (engine/queries.js _probeProjectGitStatus), never the branch's own upstream.
+  var comparatorRef = mainBranch || remoteDefault;
+  var branchDiffersFromComparator = !!(comparator && branch !== comparatorRef);
+  var showAheadBehind = ahead !== null && behind !== null && (ahead > 0 || behind > 0);
+
+  base.state = 'ok';
+  base.available = true;
+  base.branch = branch;
+  base.mainBranch = mainBranch || null;
+  base.remoteDefaultBranch = remoteDefault || null;
+  base.detached = !!p.gitDetached;
+  base.dirty = !!p.gitDirty;
+  base.branchDiffersFromMain = branchDiffersFromMain;
+  base.ahead = ahead;
+  base.behind = behind;
+  base.comparator = comparator || null;
+  base.branchDiffersFromComparator = branchDiffersFromComparator;
+  base.showAheadBehind = showAheadBehind;
+
+  // Warning chip — mirror _renderProjectBranch precedence: main drift wins over
+  // "behind".
+  if (p.branchMismatch) {
+    base.warn = {
+      kind: 'main-drift',
+      text: '⚠ main drift',
+      detail: 'Configured mainBranch (' + mainBranch + ') differs from origin/HEAD ('
+        + remoteDefault + ') — config is likely stale',
+    };
+  } else if (behind !== null && behind > 0) {
+    base.warn = {
+      kind: 'behind',
+      text: '⚠ behind',
+      detail: 'Local branch is ' + behind + ' commits behind origin/' + comparatorRef,
+    };
+  }
+
+  // Ready-to-render rows for a hover panel.
+  var branchValue = 'on: ' + branch
+    + (branchDiffersFromMain ? ' → ' + mainBranch : '')
+    + (base.detached ? ' (detached)' : '');
+  base.lines.push({ label: 'Branch', value: branchValue });
+  if (showAheadBehind) {
+    base.lines.push({
+      label: 'Ahead / behind',
+      value: '↑' + ahead + ' ↓' + behind
+        + (branchDiffersFromComparator ? ' vs ' + comparator : ''),
+    });
+  }
+  if (base.dirty) {
+    base.lines.push({ label: 'Working tree', value: '● uncommitted changes' });
+  }
+  base.lines.push({ label: 'Checkout', value: mode.label });
+  if (base.warn) base.warnings.push(base.warn.detail);
+
+  // "•"-joined multi-fact string for a title= attribute fallback. Mirrors the
+  // titleBits composition in _renderProjectBranch, then appends checkout mode.
+  var titleBits = ['on: ' + branch];
+  if (mainBranch) titleBits.push('configured main: ' + mainBranch);
+  if (remoteDefault) titleBits.push('origin/HEAD: ' + remoteDefault);
+  if (ahead !== null && behind !== null) titleBits.push('↑' + ahead + ' ↓' + behind + ' vs origin/' + comparatorRef);
+  if (base.detached) titleBits.push('(detached)');
+  if (base.dirty) titleBits.push('(dirty)');
+  titleBits.push('checkout: ' + mode.label);
+  if (base.warn) titleBits.push(base.warn.detail);
+  base.titleText = titleBits.join(' • ');
+
+  return base;
+}
+
+var MinionsProjectGitSummary = {
+  summarize: summarizeProjectGit,
+  liveValidationTypes: _projectLiveValidationTypes,
+  checkoutMode: _projectCheckoutMode,
+};
+
+if (typeof window !== 'undefined') window.MinionsProjectGitSummary = MinionsProjectGitSummary;

package/dashboard/slim/js/projects.js

@@ -25,6 +25,113 @@
     empty.textContent = 'No projects linked yet.';
     return empty;
   }
+  // ── Project-pill hover detail popover ────────────────────────
+  // Parity with the CLASSIC Projects bar (dashboard/js/render-other.js
+  // _renderProjectBranch / _renderWorktreeModePill): on hover/focus a pill shows
+  // the per-project git + dispatch detail — current branch, "→ main" drift,
+  // ahead/behind vs origin/main, dirty working tree, main-drift/behind warnings,
+  // and the checkout mode (Worktrees / Live checkout / Hybrid + validation types).
+  // All the semantics come from the SHARED, DOM-free summarizer
+  // window.MinionsProjectGitSummary.summarize (dashboard/shared/project-git-summary.js)
+  // so we don't fork the classic branching logic. Content is built with
+  // textContent/createElement only (no innerHTML — SEC-03 ratchet).
+  var _pillPopoverEl = null;
+  var _pillPopoverEscBound = false;
+
+  function _ensurePillPopover() {
+    if (_pillPopoverEl && document.body.contains(_pillPopoverEl)) return _pillPopoverEl;
+    var el = document.createElement('div');
+    el.className = 'slim-pill-popover';
+    el.id = 'slim-project-pill-popover';
+    el.setAttribute('role', 'tooltip');
+    el.hidden = true;
+    document.body.appendChild(el);
+    _pillPopoverEl = el;
+    if (!_pillPopoverEscBound) {
+      // Escape dismisses the popover (accessible non-blocking tooltip).
+      document.addEventListener('keydown', function(ev) {
+        if (ev.key === 'Escape' && _pillPopoverEl && !_pillPopoverEl.hidden) hidePillPopover();
+      });
+      _pillPopoverEscBound = true;
+    }
+    return el;
+  }
+
+  function _appendPopoverRow(parent, label, value, cls) {
+    var row = document.createElement('div');
+    row.className = 'slim-pill-popover-row' + (cls ? ' ' + cls : '');
+    if (label) {
+      var l = document.createElement('span');
+      l.className = 'slim-pill-popover-label';
+      l.textContent = label;
+      row.appendChild(l);
+    }
+    var v = document.createElement('span');
+    v.className = 'slim-pill-popover-value';
+    v.textContent = value;
+    row.appendChild(v);
+    parent.appendChild(row);
+  }
+
+  // Populate + position the popover under `pill` for the given status project
+  // object. No-op (and hides any open popover) when there is nothing to show.
+  function showPillPopover(pill, project) {
+    if (!pill || !project) return;
+    var summ = (window.MinionsProjectGitSummary && window.MinionsProjectGitSummary.summarize)
+      ? window.MinionsProjectGitSummary.summarize(project)
+      : null;
+    if (!summ) return;
+    var el = _ensurePillPopover();
+    el.textContent = '';
+
+    var header = document.createElement('div');
+    header.className = 'slim-pill-popover-header';
+    header.textContent = String(project.displayName || project.name || '');
+    el.appendChild(header);
+
+    if (summ.available) {
+      summ.lines.forEach(function(line) {
+        _appendPopoverRow(el, line.label, line.value);
+      });
+      if (summ.warn) {
+        _appendPopoverRow(el, '', summ.warn.text + ' — ' + summ.warn.detail, 'slim-pill-popover-warn');
+      }
+    } else if (summ.refreshing) {
+      _appendPopoverRow(el, '', summ.message || 'Refreshing…', 'slim-pill-popover-muted');
+    } else if (summ.message) {
+      _appendPopoverRow(el, '', summ.message, 'slim-pill-popover-muted');
+      _appendPopoverRow(el, 'Checkout', summ.mode.label);
+    } else {
+      // No git branch data (e.g. non-project path) — still show checkout mode.
+      _appendPopoverRow(el, 'Checkout', summ.mode.label);
+    }
+
+    // Link the pill to the popover for assistive tech while it's visible.
+    pill.setAttribute('aria-describedby', el.id);
+    el.hidden = false;
+
+    // Position below the pill, clamped to the viewport.
+    var r = pill.getBoundingClientRect();
+    var top = r.bottom + 6;
+    var left = r.left;
+    var maxLeft = window.innerWidth - el.offsetWidth - 8;
+    if (left > maxLeft) left = Math.max(8, maxLeft);
+    if (left < 8) left = 8;
+    el.style.top = top + 'px';
+    el.style.left = left + 'px';
+  }
+
+  function hidePillPopover() {
+    if (!_pillPopoverEl) return;
+    _pillPopoverEl.hidden = true;
+    // Drop stale aria-describedby links on all pills.
+    var group = document.getElementById('chat-context-pills');
+    if (group) {
+      var pills = group.querySelectorAll('.context-pill[aria-describedby]');
+      for (var i = 0; i < pills.length; i++) pills[i].removeAttribute('aria-describedby');
+    }
+  }
+
   // Strip variant: project pills. One selectable pill per project, single-select.
   // No auto-default: when nothing is explicitly chosen, no pill is active and the
   // indicator stays in the "Select project" state, so the picker never silently
@@ -32,7 +139,11 @@
   // choice back off. Returns a container of pill buttons built as real DOM nodes
   // (no innerHTML — SEC-03 ratchet, see test/unit.test.js DYNAMIC_INNERHTML_BASELINE);
   // the caller attaches a click listener via event delegation.
-  function makeContextPills(projects, selected, displayByName) {
+  //
+  // `projectByName` maps project name → the full /api/status project object so
+  // each pill can surface its git + checkout detail on hover/focus (see
+  // showPillPopover). It is optional — pills still render name-only without it.
+  function makeContextPills(projects, selected, displayByName, projectByName) {
     var group = document.createElement('span');
     group.id = 'chat-context-pills';
     group.className = 'context-pills';
@@ -49,15 +160,37 @@
       var isActive = p === selected;
       pill.classList.toggle('active', isActive);
       pill.setAttribute('aria-checked', isActive ? 'true' : 'false');
+      var proj = projectByName && projectByName[p];
+      if (proj) {
+        // title= is the graceful fallback (works with no JS / reduced-motion);
+        // the richer popover is layered on via hover/focus below.
+        var summ = (window.MinionsProjectGitSummary && window.MinionsProjectGitSummary.summarize)
+          ? window.MinionsProjectGitSummary.summarize(proj)
+          : null;
+        if (summ && summ.titleText) pill.title = summ.titleText;
+        _wirePillHover(pill, proj);
+      }
       group.appendChild(pill);
     }
     return group;
   }
+
+  // Bind hover + keyboard-focus reveal of the detail popover for one pill.
+  // Kept in a helper so the closure captures the correct project object per
+  // iteration (the loop uses `var`).
+  function _wirePillHover(pill, proj) {
+    pill.addEventListener('mouseenter', function() { showPillPopover(pill, proj); });
+    pill.addEventListener('mouseleave', hidePillPopover);
+    pill.addEventListener('focus', function() { showPillPopover(pill, proj); });
+    pill.addEventListener('blur', hidePillPopover);
+  }
   async function loadProjectsAndRenderContext(opts) {
     var stripEl = document.getElementById('chat-context-strip');
     var controlsEl = document.getElementById('chat-context-controls');
     if (!stripEl || !controlsEl) return;
     var preferProject = (opts && opts.preferProject) || null;
+    // Any prior hover popover belongs to pills we're about to replace.
+    if (typeof hidePillPopover === 'function') hidePillPopover();
     try {
       var res = await fetch('/api/status');
       if (!res.ok) throw new Error('HTTP ' + res.status);
@@ -66,7 +199,12 @@
         .filter(function(p) { return p && p.name; });
       var projects = projectList.map(function(p) { return String(p.name); });
       var displayByName = {};
-      projectList.forEach(function(p) { displayByName[String(p.name)] = String(p.displayName || p.name); });
+      var projectByName = {};
+      projectList.forEach(function(p) {
+        var key = String(p.name);
+        displayByName[key] = String(p.displayName || p.name);
+        projectByName[key] = p;
+      });
       if (projects.length === 0) {
         stripEl.style.display = '';
         controlsEl.replaceChildren(makeContextEmptyNode(), makeContextAddBtn());
@@ -84,7 +222,7 @@
         // deliberately do NOT fall back to projects[0] here (W-mqayzsj3) so CC
         // turns and project-scoped actions don't silently target the wrong
         // project.
-        var pills = makeContextPills(projects, currentProject, displayByName);
+        var pills = makeContextPills(projects, currentProject, displayByName, projectByName);
         stripEl.style.display = '';
         controlsEl.replaceChildren(pills, makeContextAddBtn());
         pills.addEventListener('click', function(ev) {

package/dashboard/slim/styles.css

@@ -576,6 +576,48 @@
     .chat-context-strip .context-pill.active:hover {
       background: var(--blue);
     }
+    /* Project-pill hover detail popover (parity with the classic Projects bar).
+       Fixed-position, pointer-events:none so it never traps the pointer or
+       focus — it's a passive tooltip dismissed on mouseleave/blur/Escape. */
+    .slim-pill-popover {
+      position: fixed;
+      z-index: 1200;
+      max-width: 320px;
+      pointer-events: none;
+      background: var(--surface2);
+      border: 1px solid var(--border);
+      border-radius: var(--radius, 8px);
+      box-shadow: 0 6px 20px rgba(0, 0, 0, 0.28);
+      padding: var(--space-2) var(--space-3);
+      font-size: var(--text-sm, 12px);
+      line-height: 1.4;
+      color: var(--text);
+    }
+    .slim-pill-popover[hidden] { display: none; }
+    .slim-pill-popover-header {
+      font-weight: 700;
+      color: var(--blue);
+      margin-bottom: 4px;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .slim-pill-popover-row {
+      display: flex;
+      gap: var(--space-2);
+      align-items: baseline;
+    }
+    .slim-pill-popover-label {
+      color: var(--muted);
+      flex: 0 0 auto;
+      min-width: 84px;
+    }
+    .slim-pill-popover-value {
+      color: var(--text);
+      word-break: break-word;
+    }
+    .slim-pill-popover-muted .slim-pill-popover-value { color: var(--muted); font-style: italic; }
+    .slim-pill-popover-warn .slim-pill-popover-value { color: var(--red); }
     .chat-context-strip .context-static {
       color: var(--text);
       font-weight: 500;

package/dashboard-build.js

@@ -8,7 +8,7 @@ const shared = require('./engine/shared');
 const { safeRead } = shared;
 
 const MINIONS_DIR = __dirname;
-const DASHBOARD_SHARED_JS = ['pr-merge-state', 'pr-filters', 'cc-suggestions', 'model-display', 'watches-source', 'welcome-popup'];
+const DASHBOARD_SHARED_JS = ['pr-merge-state', 'pr-filters', 'cc-suggestions', 'model-display', 'watches-source', 'project-git-summary', 'welcome-popup'];
 
 function buildDashboardHtml() {
   const dashDir = path.join(MINIONS_DIR, 'dashboard');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2431",
+  "version": "0.1.2432",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"