mixdog 0.9.2 → 0.9.4

package/src/ui/statusline-agents.mjs

@@ -0,0 +1,213 @@
+/**
+ * src/ui/statusline-agents.mjs — agent worker/job normalization for the L2 line.
+ *
+ * Extracted verbatim from statusline.mjs: normalize/merge REPL agent workers &
+ * bridge jobs into a statusline payload, classify running vs hidden-maintenance
+ * workers, and enumerate active hidden agents from live session runtimes. No
+ * behavior change.
+ */
+import { forEachSessionRuntime } from '../runtime/agent/orchestrator/session/manager.mjs';
+import { listHiddenAgentNames } from '../runtime/agent/orchestrator/internal-agents.mjs';
+import { num, GRN, R, B } from './statusline-format.mjs';
+
+const DEFAULT_HIDDEN_STATUSLINE_AGENTS = Object.freeze(['explorer', 'cycle1-agent', 'cycle2-agent', 'cycle3-agent', 'scheduler-task', 'webhook-handler']);
+let _hiddenStatuslineAgents = null;
+
+export function summarizeWorkerTags(workers, limit = 3) {
+  const cleanLabels = [...new Set((Array.isArray(workers) ? workers : [])
+    .map((worker) => String(worker?.tag || '').trim())
+    .filter(Boolean))];
+  if (cleanLabels.length <= limit) return cleanLabels.join(', ');
+  return `${cleanLabels.slice(0, limit).join(', ')}, +${cleanLabels.length - limit}`;
+}
+
+function normalizeAgentWorkerForStatusline(worker = {}) {
+  const tag = String(worker.tag || worker.agent || worker.name || '').trim();
+  if (!tag) return null;
+  const statusText = String(worker.stage || worker.status || '').toLowerCase();
+  const status = isTerminalBridgeStatus(statusText) ? 'idle' : 'running';
+  return {
+    tag,
+    status,
+    startedAtMs: timeMs(worker.startedAt || worker.startTime || worker.createdAt),
+    agent: worker.agent || null,
+    stage: worker.stage || worker.status || null,
+    sessionId: worker.sessionId || null,
+    provider: worker.provider || null,
+    model: worker.model || null,
+  };
+}
+
+function normalizeAgentJobForStatusline(job = {}) {
+  const statusText = String(job.status || job.stage || '').toLowerCase();
+  if (!statusText) return null;
+  const taskId = String(job.task_id || job.taskId || '').trim();
+  const tag = String(job.tag || job.agent || job.type || taskId || '').trim();
+  if (!tag && !taskId) return null;
+  const startedAtMs = timeMs(job.startedAt);
+  const finishedAtMs = timeMs(job.finishedAt);
+  if (isTerminalBridgeStatus(statusText) && finishedAtMs > 0) {
+    return {
+      tag,
+      taskId,
+      status: 'finished',
+      finalStatus: statusText,
+      startedAtMs,
+      finishedAtMs,
+      agent: job.agent || null,
+      stage: job.stage || job.workerStatus || job.status || null,
+      sessionId: job.sessionId || null,
+      provider: job.provider || null,
+      model: job.model || null,
+    };
+  }
+  if (!/running/.test(statusText)) return null;
+  return {
+    tag,
+    taskId,
+    status: 'running',
+    startedAtMs,
+    agent: job.agent || null,
+    stage: job.stage || job.workerStatus || job.status || null,
+    sessionId: job.sessionId || null,
+    provider: job.provider || null,
+    model: job.model || null,
+  };
+}
+
+export function agentStatuslinePayload(agentWorkers = [], agentJobs = []) {
+  const byTag = new Map();
+  const finishedJobs = [];
+  for (const worker of Array.isArray(agentWorkers) ? agentWorkers : []) {
+    const row = normalizeAgentWorkerForStatusline(worker);
+    if (row) byTag.set(row.tag, row);
+  }
+  for (const job of Array.isArray(agentJobs) ? agentJobs : []) {
+    const row = normalizeAgentJobForStatusline(job);
+    if (!row) continue;
+    if (row.status === 'finished') {
+      finishedJobs.push(row);
+      continue;
+    }
+    const prev = byTag.get(row.tag);
+    byTag.set(row.tag, { ...(prev || {}), ...row, status: 'running' });
+  }
+  const workers = [...byTag.values()];
+  return {
+    workers,
+    finishedJobs: finishedJobs.sort((a, b) => (b.finishedAtMs || 0) - (a.finishedAtMs || 0)),
+    sessions: {
+      roles: workers.filter((w) => w.status !== 'idle').map((w) => w.tag),
+      workers,
+    },
+  };
+}
+
+export function classifyAgentWorkers(workers = []) {
+  const maintenance = [];
+  const runningWorkers = [];
+  const seenMaintenance = new Set();
+  const seenRunning = new Set();
+  for (const w of Array.isArray(workers) ? workers : []) {
+    const tag = String(w?.tag || '').trim();
+    if (!tag) continue;
+    const maint = hiddenWorkerLabel(w);
+    if (maint) {
+      if (w.status !== 'idle' && !seenMaintenance.has(maint)) {
+        seenMaintenance.add(maint);
+        maintenance.push(`${GRN}↻${R} ${B}${maint}${R}`);
+      }
+      continue;
+    }
+    if (w.status !== 'idle' && !seenRunning.has(tag)) {
+      seenRunning.add(tag);
+      runningWorkers.push(w);
+    }
+  }
+  return { maintenance, runningWorkers };
+}
+
+function hiddenWorkerLabel(worker = {}) {
+  const agent = String(worker?.agent || '').trim();
+  const tag = String(worker?.tag || '').trim();
+  return maintenanceLabel(agent) || (!agent ? maintenanceLabel(tag) : '');
+}
+
+function hiddenStatuslineAgents() {
+  if (_hiddenStatuslineAgents) return _hiddenStatuslineAgents;
+  const agents = new Set(DEFAULT_HIDDEN_STATUSLINE_AGENTS);
+  try {
+    for (const agent of listHiddenAgentNames()) {
+      const clean = String(agent || '').trim();
+      if (clean) agents.add(clean);
+    }
+  } catch {}
+  _hiddenStatuslineAgents = agents;
+  return agents;
+}
+
+function isActiveHiddenStatus(statusText) {
+  return /^(connecting|requesting|streaming|tool_running|running)$/i.test(String(statusText || '').trim());
+}
+
+export function activeHiddenAgentWorkers({ sessionId = '', clientHostPid = 0 } = {}) {
+  const agents = hiddenStatuslineAgents();
+  const ownerPid = positiveInt(clientHostPid);
+  const ownerSessionId = String(sessionId || '').trim();
+  const rows = [];
+  try {
+    for (const [runtimeSessionId, entry] of forEachSessionRuntime() || []) {
+      if (!entry || entry.closed === true) continue;
+      const session = entry.session || null;
+      if (!session || session.closed === true) continue;
+      const agent = String(session?.agent || '').trim();
+      if (!agent || !agents.has(agent)) continue;
+      const id = session?.id || runtimeSessionId || null;
+      if (ownerSessionId && id === ownerSessionId) continue;
+      const sessionOwnerId = String(session?.ownerSessionId || '').trim();
+      if (sessionOwnerId && ownerSessionId && sessionOwnerId !== ownerSessionId) continue;
+      const pid = positiveInt(session?.clientHostPid);
+      if (ownerPid && pid && pid !== ownerPid) continue;
+      const stage = String(entry.stage || session?.stage || session?.status || '').trim().toLowerCase();
+      const status = String(session?.status || stage || '').trim().toLowerCase();
+      if (!isActiveHiddenStatus(stage || status)) continue;
+      rows.push({
+        tag: String(session?.agentTag || `${agent}:${id || rows.length}`).trim(),
+        agent,
+        status: 'running',
+        stage: stage || status || 'running',
+        sessionId: id,
+        provider: session?.provider || null,
+        model: session?.model || null,
+      });
+    }
+  } catch {}
+  return rows;
+}
+
+function isTerminalBridgeStatus(statusText) {
+  return /idle|done|complete|success|closed|error|fail|cancel|killed|timeout/.test(String(statusText || '').toLowerCase());
+}
+
+function timeMs(value) {
+  if (typeof value === 'number' && Number.isFinite(value) && value > 0) return value;
+  const n = Date.parse(String(value || ''));
+  return Number.isFinite(n) ? n : 0;
+}
+
+function maintenanceLabel(tag) {
+  switch (tag) {
+    case 'cycle1-agent': return 'cycle1';
+    case 'cycle2-agent': return 'cycle2';
+    case 'cycle3-agent': return 'cycle3';
+    case 'scheduler-task': return 'scheduler';
+    case 'webhook-handler': return 'webhook';
+    case 'explorer': return 'explorer';
+    default: return '';
+  }
+}
+
+function positiveInt(value) {
+  const n = Number(value);
+  return Number.isInteger(n) && n > 0 ? n : 0;
+}

package/src/ui/statusline-format.mjs

@@ -0,0 +1,146 @@
+/**
+ * src/ui/statusline-format.mjs — pure formatting primitives for the footer.
+ *
+ * Extracted verbatim from statusline.mjs: ANSI SGR constants, the context%
+ * bar/segment formatters, small numeric helpers, and the TUI-independent
+ * formatElapsed() replica. No behavior change — statusline.mjs re-imports these.
+ */
+import { colorEnabled, rgb } from './ansi.mjs';
+import { displayModelName, shortenModelName } from './model-display.mjs';
+import { getModelMetadataSync } from '../runtime/agent/orchestrator/providers/model-catalog.mjs';
+
+// Token window used to compute a fallback context% from our own session usage.
+// The live gateway (when up) overrides this with the real route's window. This
+// is only the last resort for unknown local models.
+export const FALLBACK_CONTEXT_WINDOW = 200000;
+export const statusText = rgb(198, 198, 198);
+export const statusSubtle = rgb(136, 136, 136);
+export const statusAccent = rgb(215, 119, 87);
+
+function sgr(code) {
+  return colorEnabled() ? `\x1b[${code}m` : '';
+}
+
+export const R = sgr('0');
+export const B = sgr('1');
+export const D = sgr('38;2;136;136;136');
+export const GRN = sgr('38;2;0;170;75');
+export const YLW = sgr('38;2;255;193;7');
+export const RED = sgr('38;2;220;70;88');
+export const CYN = sgr('38;2;136;136;136');
+export const GREY = sgr('38;2;136;136;136');
+
+export function terminalColumns() {
+  const cols = Number(process.stdout?.columns);
+  return Number.isFinite(cols) && cols > 0 ? Math.floor(cols) : 120;
+}
+
+export function modelContextWindow(provider, model, explicitContextWindow = 0) {
+  const explicit = num(explicitContextWindow);
+  if (explicit > 0) return explicit;
+  const metaWindow = num(getModelMetadataSync(model, provider)?.contextWindow);
+  if (metaWindow > 0) return metaWindow;
+  return FALLBACK_CONTEXT_WINDOW;
+}
+
+export function formatModelSegment({ provider, model, effort, fast, cols }) {
+  const raw = String(model || '').trim();
+  const meta = getModelMetadataSync(raw, provider) || {};
+  const displayHint = String(meta.displayName || meta.display || meta.name || '').trim();
+  const modelName = shortenModelName(displayModelName(raw, provider, displayHint), cols);
+  const bits = [`${B}${modelName}${R}`];
+  if (effort) bits.push(`${B}${String(effort).toUpperCase()}${R}`);
+  if (fast === true) bits.push(`${B}FAST${R}`);
+  return bits.join(` ${D}·${R} `);
+}
+
+/** Display label for context % (clamped to 100); raw pct still drives bar/color thresholds. */
+export function contextPctDisplayLabel(ctxPct) {
+  const pct = Number(ctxPct);
+  if (!Number.isFinite(pct) || pct <= 0) return '0';
+  if (pct > 0 && pct < 1) return String(Math.round(pct * 10) / 10);
+  return String(Math.floor(Math.min(100, pct)));
+}
+
+export function formatContextSegment(ctxPct, cols) {
+  const raw = Number(ctxPct);
+  const pct = Number.isFinite(raw) ? Math.max(0, raw) : 0;
+  const barPct = clampPct(pct);
+  const fill = pct >= 90 ? RED : pct >= 70 ? YLW : GRN;
+  const label = contextPctDisplayLabel(pct);
+  // Keep a full-width bar wherever there is room for one. Below 80 cols the bar
+  // is dropped (label-only) so the footer never overflows a narrow terminal;
+  // at 80+ it stays a fixed 14 cells instead of shrinking to 8, which read as
+  // too small/cramped on mid-width terminals.
+  const cells = cols >= 80 ? 14 : 0;
+  if (!cells) return `${fill}${label}%${R}`;
+  const bar = makeBar(barPct, cells);
+  const filled = bar.replace(/░/g, '');
+  const empty = bar.replace(/▓/g, '');
+  return `${fill}${filled}${R}${D}${empty}${R} ${label}%`;
+}
+
+export function makeBar(pct, cells) {
+  let filled = Math.floor((Number(pct) || 0) * cells / 100);
+  if (filled < 0) filled = 0;
+  if (filled > cells) filled = cells;
+  if (pct >= 1 && filled === 0) filled = 1;
+  return '▓'.repeat(filled) + '░'.repeat(cells - filled);
+}
+
+export function colourPct(p) {
+  if (p >= 90) return `${RED}${p}%${R}`;
+  if (p >= 70) return `${YLW}${p}%${R}`;
+  return `${GRN}${p}%${R}`;
+}
+
+export function epochMsToHHMM(ms) {
+  const d = new Date(Number(ms));
+  if (!Number.isFinite(d.getTime())) return '';
+  return d.toLocaleTimeString('sv-SE', { hour: '2-digit', minute: '2-digit', hour12: false });
+}
+
+export function num(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : 0;
+}
+
+export function clampPct(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n)) return 0;
+  return Math.max(0, Math.min(100, n));
+}
+
+/** Human-friendly token count: 1234 -> 1.2k. */
+export function fmt(n) {
+  const v = Number(n) || 0;
+  if (v < 1000) return String(Math.round(v));
+  if (v < 1_000_000) {
+    const k = Math.round(v / 1000);
+    return k >= 1000 ? '1M' : `${k}k`;
+  }
+  return (v / 1_000_000).toFixed(1) + 'M';
+}
+
+// Byte-identical replica of src/tui/time-format.mjs formatDuration() with
+// DEFAULT options (no mostSignificantOnly / hideTrailingZeros), wrapped to drop
+// sub-1s like formatElapsed there. Output shape: '' (<1s), `Xs`, `Xm Ys`,
+// `Xh Ym Zs`, `Xd Yh Zm`. statusline.mjs is a standalone UI module that should
+// not depend on the React/ink TUI tree, so the algorithm is replicated rather
+// than imported. Used for ALL L2 elapsed (Agents/Explore/Search/Shell).
+export function formatElapsed(ms) {
+  if (!Number.isFinite(Number(ms))) return '';
+  const value = Math.max(0, Number(ms) || 0);
+  if (value < 60_000) {
+    if (value < 1_000) return '';
+    return `${Math.floor(value / 1000)}s`;
+  }
+  const days = Math.floor(value / 86_400_000);
+  const hours = Math.floor((value % 86_400_000) / 3_600_000);
+  const minutes = Math.floor((value % 3_600_000) / 60_000);
+  const seconds = Math.floor((value % 60_000) / 1000);
+  if (days > 0) return `${days}d ${hours}h ${minutes}m`;
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}

package/src/ui/statusline-segments.mjs

@@ -0,0 +1,148 @@
+/**
+ * src/ui/statusline-segments.mjs — filesystem-backed L2 segment sources.
+ *
+ * Extracted verbatim from statusline.mjs: the shell-jobs segment (owner-scoped
+ * job scan + liveness) and the memory-cycle segment (daemon state file). Both
+ * keep their own 1s process-local caches. No behavior change.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { formatElapsed } from './statusline-format.mjs';
+
+const DEFAULT_MIXDOG_HOME = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
+const DEFAULT_STANDALONE_DATA_DIR = join(DEFAULT_MIXDOG_HOME, 'data');
+const SHELL_JOBS_SEGMENT_CACHE_MS = 1000;
+
+let _shellJobsSegmentCache = { ownerPid: 0, at: 0, value: { count: 0, elapsedLabel: '' } };
+
+function dataDir() {
+  return process.env.MIXDOG_DATA_DIR || DEFAULT_STANDALONE_DATA_DIR;
+}
+
+export function shellJobsStatus({ clientHostPid } = {}) {
+  return _shellJobsStatusImpl({ clientHostPid });
+}
+
+// Memory cycle L2 segment source. The memory daemon writes
+// data/memory-cycle-state.json on every cycle start/finish (index.mjs
+// _writeCycleStateFile) — no HTTP call from the statusline path. Cached at
+// the same 1s cadence as the shell segment. Shows a single unified "Memory"
+// segment: running (spinner + elapsed) or backlog warning (yellow count).
+let _memoryCycleSegmentCache = { at: 0, value: null };
+const MEMORY_CYCLE_SEGMENT_CACHE_MS = 1000;
+const MEMORY_CYCLE_BACKLOG_WARN = 500;
+export function memoryCycleStatus() {
+  const now = Date.now();
+  if (now - _memoryCycleSegmentCache.at < MEMORY_CYCLE_SEGMENT_CACHE_MS) {
+    return _memoryCycleSegmentCache.value;
+  }
+  let value = null;
+  try {
+    const p = join(dataDir(), 'memory-cycle-state.json');
+    if (existsSync(p)) {
+      const state = JSON.parse(readFileSync(p, 'utf-8'));
+      const running = state?.running || null;
+      const backlog = state?.backlog || {};
+      // Stale-file guard: a daemon that died mid-run leaves running set —
+      // ignore anything not refreshed in the last 10 minutes.
+      const fresh = Number(state?.updatedAt) > now - 10 * 60_000;
+      if (fresh && running?.cycle && Number(running.started_at) > 0) {
+        value = { kind: 'running', startedAt: Number(running.started_at) };
+      } else if (fresh) {
+        const pending = Math.max(Number(backlog?.unchunked) || 0, Number(backlog?.cycle2_pending) || 0);
+        if (pending > MEMORY_CYCLE_BACKLOG_WARN) value = { kind: 'backlog', pending };
+      }
+    }
+  } catch { value = null; }
+  _memoryCycleSegmentCache = { at: now, value };
+  return value;
+}
+
+function _shellJobsStatusImpl({ clientHostPid } = {}) {
+  const ownerPid = positiveInt(clientHostPid);
+  const empty = { count: 0, elapsedLabel: '' };
+  if (!ownerPid) return empty;
+  const now = Date.now();
+  if (_shellJobsSegmentCache.ownerPid === ownerPid && now - _shellJobsSegmentCache.at < SHELL_JOBS_SEGMENT_CACHE_MS) {
+    return _shellJobsSegmentCache.value || empty;
+  }
+  let value = empty;
+  try {
+    const dir = join(dataDir(), 'shell-jobs');
+    if (!existsSync(dir)) {
+      _shellJobsSegmentCache = { ownerPid, at: now, value };
+      return value;
+    }
+    const names = readdirSync(dir);
+    const done = new Set(names.filter((n) => n.endsWith('.done')).map((n) => n.slice(0, -5)));
+    const ownerByJob = new Map();
+    for (const n of names) {
+      const i = n.lastIndexOf('.owner-');
+      if (i > 0) {
+        const pid = positiveInt(n.slice(i + 7));
+        if (pid) ownerByJob.set(n.slice(0, i), pid);
+      }
+    }
+    const ids = names
+      .filter((n) => n.endsWith('.json'))
+      .map((n) => n.slice(0, -5))
+      .filter((id) => !done.has(id) && ownerByJob.get(id) === ownerPid)
+      .sort((a, b) => jobStampMs(b) - jobStampMs(a))
+      .slice(0, 30);
+    let count = 0;
+    let oldestMs = Infinity;
+    for (const id of ids) {
+      const p = join(dir, `${id}.json`);
+      let detail;
+      try { detail = JSON.parse(readFileSync(p, 'utf-8')); } catch { continue; }
+      if (!isShellJobAlive(detail, p, dir, id)) continue;
+      count++;
+      try {
+        const st = statSync(p);
+        if (st.mtimeMs < oldestMs) oldestMs = st.mtimeMs;
+      } catch {}
+    }
+    if (!count) {
+      _shellJobsSegmentCache = { ownerPid, at: now, value };
+      return value;
+    }
+    const elapsedLabel = Number.isFinite(oldestMs) ? formatElapsed(Date.now() - oldestMs) : '';
+    value = { count, elapsedLabel };
+  } catch {
+    value = empty;
+  }
+  _shellJobsSegmentCache = { ownerPid, at: now, value };
+  return value;
+}
+
+function isShellJobAlive(detail, detailPath, dir, id) {
+  const pid = positiveInt(detail?.pid);
+  if (!pid) return false;
+  try {
+    const st = statSync(detailPath);
+    const timeoutMs = Number(detail?.timeoutMs);
+    const enforced = detail?.timeoutEnforced === true || existsSync(join(dir, `${id}.enforced`));
+    if (enforced && Number.isFinite(timeoutMs) && timeoutMs > 0 && Date.now() - st.mtimeMs > timeoutMs + 30 * 60_000) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === 'EPERM';
+  }
+}
+
+function jobStampMs(id) {
+  const m = /^job_(\d+)/.exec(String(id || ''));
+  return m ? Number(m[1]) : 0;
+}
+
+function positiveInt(value) {
+  const n = Number(value);
+  return Number.isInteger(n) && n > 0 ? n : 0;
+}