mixdog 0.9.19 → 0.9.21

package/src/standalone/seeds.mjs

@@ -1,4 +1,5 @@
-import { mkdirSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
 
 export function ensureStandaloneEnvironment({ rootDir, dataDir }) {
   if (!rootDir) throw new Error('standalone rootDir is required');
@@ -14,4 +15,30 @@ export function ensureStandaloneEnvironment({ rootDir, dataDir }) {
   process.env.MIXDOG_PATCH_NATIVE_PREWARM ??= '0';
 
   mkdirSync(dataDir, { recursive: true });
+  seedBundledSkills({ rootDir, dataDir });
+}
+
+// Copy skills bundled in the package (src/defaults/skills/<name>/) into the
+// user data skills dir, but only when the target dir does not already exist —
+// never overwrite user-owned skill dirs.
+export function seedBundledSkills({ rootDir, dataDir }) {
+  const bundledDir = join(rootDir, 'defaults', 'skills');
+  if (!existsSync(bundledDir)) return;
+  const targetRoot = join(dataDir, 'skills');
+  let names;
+  try {
+    names = readdirSync(bundledDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of names) {
+    if (!entry.isDirectory()) continue;
+    const dest = join(targetRoot, entry.name);
+    if (existsSync(dest)) continue;
+    try {
+      cpSync(join(bundledDir, entry.name), dest, { recursive: true });
+    } catch {
+      // best-effort seeding; ignore individual copy failures
+    }
+  }
 }

package/src/tui/App.jsx

@@ -720,6 +720,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     openContextPicker: (...a) => openContextPicker(...a),
     openProfilePicker: (...a) => openProfilePicker(...a),
     openUpdatePicker: (...a) => openUpdatePicker(...a),
+    runDoctor: (...a) => store.runDoctor?.(...a),
     requestExit: (...a) => requestExit(...a),
   });
   const promptHintTimerRef = useRef(null);
@@ -845,34 +846,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     }, 2200);
   }, []);
 
-  // Copy the currently-highlighted selection to the OS clipboard. ink's fork
-  // refreshed store.getRenderSelectionText() on the synchronous render that the
-  // final setSelection() triggered, so the selected text is ready to read.
-  const copySelection = useCallback((attempt = 0) => {
-    const renderText = store.getRenderSelectionText?.();
-    const remembered = selectionTextRef.current || '';
-    // A selection that has partially scrolled out of the viewport renders —
-    // and therefore harvests — only its visible rows. The remembered text
-    // (captured while the selection was last fully painted) is the fuller
-    // copy; prefer whichever is longer so scrolling never shrinks a copy.
-    const text = renderText == null
-      ? remembered
-      : (remembered.length > renderText.length ? remembered : renderText);
-    if ((!text || !text.trim()) && attempt < 4) {
-      setTimeout(() => copySelection(attempt + 1), attempt === 0 ? 0 : 24);
-      return;
-    }
-    if (!text || !text.trim()) return;
-    selectionTextRef.current = text;
-    copyToClipboard(text)
-      .then(() => {
-        const lines = text.split('\n').length;
-        const chars = text.length;
-        showSelectionCopyHint(`copied ${chars} char${chars === 1 ? '' : 's'}${lines > 1 ? ` · ${lines} lines` : ''}`, 'plain');
-      })
-      .catch((e) => showSelectionCopyHint(`copy failed: ${e?.message || e}`, 'error'));
-  }, [store, showSelectionCopyHint]);
-
   // ── Post-mount input gate ──────────────────────────────────────────────
   // Let one event-loop poll pass so Ink processes (and discards, because
   // PromptInput is still disabled) any keystrokes queued during boot/first
@@ -1047,6 +1020,8 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     scrollTranscriptRows,
     queueScrollCoalesced,
     moveSelectionFocus,
+    getStitchedSelectionText,
+    clearStitchBuffer,
   } = useTranscriptScroll({
     store,
     frameColumns,
@@ -1067,6 +1042,42 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     selectionTextRef,
   });
 
+  // Copy the currently-highlighted selection to the OS clipboard. ink's fork
+  // refreshed store.getRenderSelectionText() on the synchronous render that the
+  // final setSelection() triggered, so the selected text is ready to read.
+  // NOTE: declared after useTranscriptScroll — the dependency array below
+  // evaluates getStitchedSelectionText at render time, so referencing it
+  // before the destructuring above is a TDZ ReferenceError.
+  const copySelection = useCallback((attempt = 0) => {
+    const renderText = store.getRenderSelectionText?.();
+    const remembered = selectionTextRef.current || '';
+    // A selection that has partially scrolled out of the viewport renders —
+    // and therefore harvests — only its visible rows. The remembered text
+    // (captured while the selection was last fully painted) is the fuller
+    // copy; prefer whichever is longer so scrolling never shrinks a copy.
+    let text = renderText == null
+      ? remembered
+      : (remembered.length > renderText.length ? remembered : renderText);
+    // The stitch buffer accumulates rows harvested across every scroll position
+    // during a transcript drag, so it can reconstruct rows that scrolled out of
+    // view entirely (neither renderText nor the last-full-paint remembered text
+    // ever saw them). Prefer it only when it is strictly longer than both.
+    const stitched = getStitchedSelectionText?.() || '';
+    if (stitched.length > text.length) text = stitched;
+    if ((!text || !text.trim()) && attempt < 4) {
+      setTimeout(() => copySelection(attempt + 1), attempt === 0 ? 0 : 24);
+      return;
+    }
+    if (!text || !text.trim()) return;
+    selectionTextRef.current = text;
+    copyToClipboard(text)
+      .then(() => {
+        const lines = text.split('\n').length;
+        const chars = text.length;
+        showSelectionCopyHint(`copied ${chars} char${chars === 1 ? '' : 's'}${lines > 1 ? ` · ${lines} lines` : ''}`, 'plain');
+      })
+      .catch((e) => showSelectionCopyHint(`copy failed: ${e?.message || e}`, 'error'));
+  }, [store, showSelectionCopyHint, getStitchedSelectionText]);
 
   useEffect(() => () => {
     stopSmoothScroll();
@@ -1102,6 +1113,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     queueScrollCoalesced,
     setSlashIndex,
     setMeasuredRowsVersion,
+    clearStitchBuffer,
   });
 
   // Enable extended keyboard reporting (kitty + xterm modifyOtherKeys)

package/src/tui/app/core-memory-picker.mjs

@@ -47,7 +47,7 @@ export function createCoreMemoryPicker({
         const rows = [
           {
             value: 'memory-toggle',
-            label: 'Memory on/off',
+            label: 'Memory',
             meta: memoryOn ? 'On' : 'Off',
             description: memoryOn
               ? 'Background memory cycles on'

package/src/tui/app/doctor.mjs

@@ -0,0 +1,175 @@
+/**
+ * doctor.mjs — /doctor installation health report builder.
+ *
+ * buildDoctorReport(runtime, getState) runs a fixed set of best-effort
+ * diagnostics against the live runtime accessors and returns a single
+ * multi-line string (one glyph-prefixed row per check). Every check is
+ * individually try/caught so one failure degrades to a single FAIL row
+ * instead of killing the whole report. No secrets are ever printed — only
+ * whether a token/auth is configured. The only network touch is the
+ * best-effort npm update check already used by /update; an unreachable
+ * registry downgrades to a WARN "check skipped" row, never a throw.
+ */
+import { compareSemver } from '../../runtime/shared/update-checker.mjs';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const GLYPH = { ok: '✓', warn: '⚠', fail: '✗' };
+
+function readPackageJson() {
+  try {
+    const dir = dirname(fileURLToPath(import.meta.url));
+    const raw = JSON.parse(readFileSync(join(dir, '..', '..', '..', 'package.json'), 'utf8'));
+    return raw && typeof raw === 'object' ? raw : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function buildDoctorReport(runtime = {}, getState = () => ({})) {
+  const rows = [];
+  const check = async (label, fn) => {
+    const row = (level, detail) => {
+      rows.push(`${GLYPH[level] || GLYPH.warn} ${label}: ${detail}`);
+    };
+    try {
+      await fn(row);
+    } catch (e) {
+      row('fail', `check failed: ${e?.message || e}`);
+    }
+  };
+  const pkg = readPackageJson();
+
+  // 1. mixdog version + update availability (best-effort registry check).
+  await check('mixdog', async (row) => {
+    const upd = (await runtime.checkForUpdate?.({})) || {};
+    const current = upd.currentVersion || pkg?.version || 'unknown';
+    const latest = upd.latestVersion;
+    if (latest == null) {
+      row('warn', `v${current} · update check skipped (registry unreachable)`);
+      return;
+    }
+    if (upd.updateAvailable) row('warn', `v${current} · update available → v${latest}`);
+    else row('ok', `v${current} · up to date`);
+  });
+
+  // 2. node version vs package.json engines (only when engines present).
+  await check('node', async (row) => {
+    const nodeVer = process.versions?.node || '0.0.0';
+    const engines = pkg?.engines?.node;
+    if (!engines) {
+      row('ok', `v${nodeVer}`);
+      return;
+    }
+    const m = String(engines).match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!m) {
+      row('warn', `v${nodeVer} · engines "${engines}" unparsed`);
+      return;
+    }
+    const required = `${m[1]}.${m[2] || 0}.${m[3] || 0}`;
+    const ok = compareSemver(nodeVer, required) >= 0;
+    row(ok ? 'ok' : 'fail', `v${nodeVer} · requires node ${engines}`);
+  });
+
+  // 3. providers: configured auth count; FAIL if the active route provider
+  //    has no auth.
+  await check('providers', async (row) => {
+    const setup = (await runtime.getProviderSetup?.()) || {};
+    const lists = [...(setup.api || []), ...(setup.oauth || []), ...(setup.local || [])];
+    const isAuthed = (p) => Boolean(p && (p.authenticated || p.enabled || p.detected));
+    const authed = lists.filter(isAuthed);
+    const active = getState()?.provider || '';
+    const activeEntry = active ? lists.find((p) => p.id === active) : null;
+    if (activeEntry && !isAuthed(activeEntry)) {
+      row('fail', `route ${active} has no auth · ${authed.length} configured`);
+      return;
+    }
+    if (active && !activeEntry) {
+      row('warn', `${authed.length} authed · route ${active} (not listed)`);
+      return;
+    }
+    row('ok', `${authed.length} authed · route ${active || 'unknown'}`);
+  });
+
+  // 4. MCP: connected/configured, failed servers named.
+  await check('mcp', async (row) => {
+    const m = runtime.mcpStatus?.() || {};
+    const servers = Array.isArray(m.servers) ? m.servers : [];
+    const conn = Number(m.connectedCount || 0);
+    const conf = Number(m.configuredCount || 0);
+    if (conf === 0) {
+      row('ok', 'no servers configured');
+      return;
+    }
+    const failed = servers
+      .filter((s) => s && (s.error || s.status === 'failed'))
+      .map((s) => s.name || s.id)
+      .filter(Boolean);
+    const detail = `${conn}/${conf} connected${failed.length ? ` · failed: ${failed.join(', ')}` : ''}`;
+    row(failed.length || conn < conf ? 'warn' : 'ok', detail);
+  });
+
+  // 5. memory: enabled/disabled (+ backend health only if the accessor
+  //    already exposes it; no new probing).
+  await check('memory', async (row) => {
+    const mem = runtime.getMemorySettings?.() || {};
+    const enabled = mem.enabled !== false;
+    let detail = enabled ? 'enabled' : 'disabled';
+    if (mem.backend) detail += ` · backend ${mem.backend}`;
+    const health = mem.backendHealth || mem.health;
+    if (health != null) {
+      detail += ` · ${typeof health === 'string' ? health : (health.ok ? 'healthy' : 'unhealthy')}`;
+    }
+    row(enabled ? 'ok' : 'warn', detail);
+  });
+
+  // 6. channels: enabled + worker status + configured tokens (names only).
+  await check('channels', async (row) => {
+    const settings = runtime.getChannelSettings?.({ includeStatus: true }) || {};
+    const enabled = settings.enabled !== false;
+    if (!enabled) {
+      row('ok', 'disabled');
+      return;
+    }
+    const worker = settings.status || runtime.getChannelWorkerStatus?.() || {};
+    const setup = runtime.getChannelSetup?.() || {};
+    const tokens = [];
+    if (setup.discord?.authenticated) tokens.push('discord');
+    if (setup.telegram?.authenticated) tokens.push('telegram');
+    if (setup.webhook?.authenticated) tokens.push('webhook');
+    const running = worker.running === true;
+    const detail = `enabled · worker ${running ? 'running' : 'stopped'} · tokens: ${tokens.length ? tokens.join(', ') : 'none'}`;
+    row(running ? 'ok' : 'warn', detail);
+  });
+
+  // 7. skills / plugins / hooks: counts + broken/disabled entries.
+  await check('skills', async (row) => {
+    const s = runtime.skillsStatus?.() || {};
+    const skills = Array.isArray(s.skills) ? s.skills : [];
+    const broken = skills.filter((x) => x && (x.broken || x.error || x.invalid));
+    const disabled = skills.filter((x) => x && x.disabled);
+    let detail = `${s.count ?? skills.length} available`;
+    if (disabled.length) detail += ` · ${disabled.length} disabled`;
+    if (broken.length) detail += ` · broken: ${broken.map((x) => x.name || x.id).filter(Boolean).join(', ')}`;
+    row(broken.length ? 'warn' : 'ok', detail);
+  });
+  await check('plugins', async (row) => {
+    const p = runtime.pluginsStatus?.() || {};
+    const plugins = Array.isArray(p.plugins) ? p.plugins : [];
+    const broken = plugins.filter((x) => x && (x.broken || x.error));
+    const disabled = plugins.filter((x) => x && x.disabled);
+    let detail = `${p.count ?? plugins.length} detected`;
+    if (disabled.length) detail += ` · ${disabled.length} disabled`;
+    if (broken.length) detail += ` · broken: ${broken.map((x) => x.title || x.name || x.id).filter(Boolean).join(', ')}`;
+    row(broken.length ? 'warn' : 'ok', detail);
+  });
+  await check('hooks', async (row) => {
+    const h = runtime.hooksStatus?.() || {};
+    const events = Array.isArray(h.events) ? h.events : [];
+    const enabled = h.enabled === true;
+    row('ok', `${enabled ? 'enabled' : 'disabled'} · ${events.length} event${events.length === 1 ? '' : 's'}`);
+  });
+
+  return ['mixdog doctor — installation health', ...rows].join('\n');
+}

package/src/tui/app/slash-commands.mjs

@@ -32,6 +32,7 @@ export const SLASH_COMMANDS = [
   { name: 'settings', usage: '/setting', aliases: ['setting', 'config'], aliasUsage: ['settings', 'config'], showAliasUsage: false, description: 'Open runtime settings' },
   { name: 'profile', usage: '/profile', description: 'Set your title and response language' },
   { name: 'update', usage: '/update', description: 'Check version and update mixdog' },
+  { name: 'doctor', usage: '/doctor', description: 'Diagnose installation health' },
   { name: 'quit', usage: '/quit', aliases: ['exit', 'q'], aliasUsage: ['exit', 'q'], description: 'Quit the TUI' },
 ];
 

package/src/tui/app/slash-dispatch.mjs

@@ -46,6 +46,7 @@ export function createSlashDispatch({
   openContextPicker,
   openProfilePicker,
   openUpdatePicker,
+  runDoctor,
   requestExit,
 }) {
   const runSlashCommand = (cmd, arg = '') => {
@@ -383,6 +384,14 @@ export function createSlashDispatch({
       case 'update':
         openUpdatePicker();
         return true;
+      case 'doctor':
+        if (state.commandBusy) {
+          store.pushNotice('wait for the current command to finish before /doctor', 'warn');
+          return false;
+        }
+        void Promise.resolve(runDoctor?.())
+          .catch((e) => store.pushNotice(`doctor failed: ${e?.message || e}`, 'error'));
+        return true;
       case 'quit':
         requestExit();
         return true;

package/src/tui/app/use-mouse-input.mjs

@@ -54,6 +54,7 @@ export function useMouseInput({
   queueScrollCoalesced,
   setSlashIndex,
   setMeasuredRowsVersion,
+  clearStitchBuffer,
 }) {
   const mouseZoomPassthroughTimerRef = useRef(null);
 
@@ -353,6 +354,8 @@ export function useMouseInput({
               const hi = { x: wr.x2, y: wr.y2 };
               const rect = linearSelection(lo, hi);
               stopSmoothScroll();
+              // Fresh word/line anchor: reset the stitch buffer (see char-drag).
+              clearStitchBuffer?.();
               dragRef.current = {
                 anchor: { x, y },
                 anchorScroll: region === 'transcript' ? scrollTargetRef.current : 0,
@@ -376,6 +379,9 @@ export function useMouseInput({
           // there; keep the transcript scroll anchor only for the transcript.
           // Plain single press clears any word/line anchorSpan (char-drag mode).
           stopSmoothScroll();
+          // Fresh char-drag anchor: drop any rows stitched from a prior
+          // selection so the new drag reconstructs only its own content.
+          clearStitchBuffer?.();
           dragRef.current = {
             anchor: { x, y },
             anchorScroll: region === 'transcript' ? scrollTargetRef.current : 0,

package/src/tui/app/use-transcript-scroll.mjs

@@ -44,6 +44,71 @@ export function useTranscriptScroll({
   // SCROLL_COALESCE_MS). Both call sites accumulate into pendingRows.
   const scrollCoalesceRef = useRef({ pendingRows: 0, timer: null });
   const selectionTextTimerRef = useRef(null);
+  // Stitch buffer: accumulates harvested transcript selection rows across scroll
+  // positions so Ctrl+C copies the FULL drag even after it auto-scrolled past the
+  // viewport. Keyed by scroll-invariant content row = screenY - scrollTarget at
+  // harvest time; value = row text. Only transcript-region drags accumulate.
+  const stitchBufferRef = useRef(new Map());
+  const stitchHarvestTimerRef = useRef(null);
+  // Scroll offset captured at the SCHEDULE (paint) time of the pending harvest —
+  // the deferred timer must key rows by the frame's scroll, not by whatever
+  // scrollTargetRef holds when the timer eventually fires (a scroll in between
+  // would mis-key the rows). Latest schedule wins (latest paint = latest frame).
+  const stitchHarvestScrollRef = useRef(0);
+
+  const clearStitchBuffer = useCallback(() => {
+    stitchBufferRef.current.clear();
+    if (stitchHarvestTimerRef.current) {
+      clearTimeout(stitchHarvestTimerRef.current);
+      stitchHarvestTimerRef.current = null;
+    }
+  }, []);
+
+  // Deferred (like rememberSelectionTextSoon) harvest of the currently visible
+  // selection rows into the stitch buffer. Runs on EVERY transcript selection
+  // paint AND on scroll-shift repaints (the rememberText:false path) so rows
+  // revealed only mid-scroll are captured. Later harvest of a key overwrites,
+  // handling partial↔full endpoint rows on retraction.
+  const harvestStitchRowsSoon = useCallback(() => {
+    if (dragRef.current.region !== 'transcript') return;
+    // Capture the scroll offset for THIS paint (schedule time). If a timer is
+    // already pending, only refresh the captured offset to the latest frame and
+    // reuse the existing timer.
+    stitchHarvestScrollRef.current = Number(scrollTargetRef.current) || 0;
+    if (stitchHarvestTimerRef.current) return;
+    stitchHarvestTimerRef.current = setTimeout(() => {
+      stitchHarvestTimerRef.current = null;
+      if (dragRef.current.region !== 'transcript') return;
+      const rows = store.getRenderSelectionRows?.();
+      if (!Array.isArray(rows)) return;
+      const scroll = stitchHarvestScrollRef.current;
+      for (const row of rows) {
+        if (!row || typeof row.y !== 'number') continue;
+        stitchBufferRef.current.set(row.y - scroll, typeof row.text === 'string' ? row.text : '');
+      }
+    }, 0);
+  }, [store]);
+
+  // Map the CURRENT rect + current scrollTarget onto the content-key range and
+  // join buffered rows sorted by key with '\n' (skipping missing keys). Returns
+  // '' when unusable so callers can fall back to render/remembered text.
+  const getStitchedSelectionText = useCallback(() => {
+    const buf = stitchBufferRef.current;
+    if (!buf.size) return '';
+    if (dragRef.current.region !== 'transcript') return '';
+    const rect = dragRef.current.rect;
+    if (!rect) return '';
+    const y1 = Number(rect.y1);
+    const y2 = Number(rect.y2);
+    if (!Number.isFinite(y1) || !Number.isFinite(y2)) return '';
+    const scroll = Number(scrollTargetRef.current) || 0;
+    const lo = Math.min(y1, y2) - scroll;
+    const hi = Math.max(y1, y2) - scroll;
+    const keys = [...buf.keys()].filter((k) => k >= lo && k <= hi).sort((a, b) => a - b);
+    if (!keys.length) return '';
+    const text = keys.map((k) => buf.get(k)).filter((t) => t != null).join('\n');
+    return text.trim() ? text : '';
+  }, []);
 
   const stopSmoothScroll = useCallback(() => {
     if (!scrollAnimationRef.current) return;
@@ -145,19 +210,24 @@ export function useTranscriptScroll({
         store.setRenderSelection?.(nextRect, { immediate: true });
       }
       if (needsCapture) rememberSelectionTextSoon();
+      if (nextRect) harvestStitchRowsSoon();
       return true;
     }
     state.rect = nextRect;
     state.t = Date.now();
     store.setRenderSelection?.(nextRect, immediate ? { immediate: true } : undefined);
     if (nextRect && rememberText && nextRect.captureText !== false) rememberSelectionTextSoon();
+    if (nextRect) harvestStitchRowsSoon();
     return true;
-  }, [store, rememberSelectionTextSoon]);
+  }, [store, rememberSelectionTextSoon, harvestStitchRowsSoon]);
 
   const applySelectionRect = useCallback((rect) => {
     const clippedRect = withSelectionClip(rect);
     dragRef.current.rect = clippedRect || null;
-    if (!clippedRect) selectionTextRef.current = '';
+    if (!clippedRect) {
+      selectionTextRef.current = '';
+      clearStitchBuffer();
+    }
     const state = selectionPaintRef.current;
     if (state.timer) {
       clearTimeout(state.timer);
@@ -165,7 +235,7 @@ export function useTranscriptScroll({
       state.pending = null;
     }
     paintSelectionRect(clippedRect, { rememberText: true, immediate: true });
-  }, [paintSelectionRect, withSelectionClip]);
+  }, [paintSelectionRect, withSelectionClip, clearStitchBuffer]);
 
   const applySelectionRectThrottled = useCallback((rect) => {
     const clippedRect = withSelectionClip(rect, { captureText: false });
@@ -274,6 +344,8 @@ export function useTranscriptScroll({
     paintState.pending = null;
     if (selectionTextTimerRef.current) clearTimeout(selectionTextTimerRef.current);
     selectionTextTimerRef.current = null;
+    if (stitchHarvestTimerRef.current) clearTimeout(stitchHarvestTimerRef.current);
+    stitchHarvestTimerRef.current = null;
     const coalesceState = scrollCoalesceRef.current;
     if (coalesceState.timer) clearTimeout(coalesceState.timer);
     coalesceState.timer = null;
@@ -512,5 +584,7 @@ export function useTranscriptScroll({
     scrollTranscriptRows,
     queueScrollCoalesced,
     moveSelectionFocus,
+    getStitchedSelectionText,
+    clearStitchBuffer,
   };
 }