shmakk 1.2.0 → 1.2.2

package/src/markdown.js

@@ -0,0 +1,217 @@
+// Markdown-to-ANSI renderer for terminal output.
+// Converts common markdown syntax to ANSI escape sequences for
+// bold, italic, headers, lists, blockquotes, links, code, etc.
+//
+// Designed for streaming-friendly line-by-line rendering:
+//   renderLine(line, opts) — renders a single line
+//   renderBlock(text, opts) — renders a full text block (calls renderLine)
+
+// ── ANSI helpers ────────────────────────────────────────────────────────────
+
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const ITALIC = '\x1b[3m';
+const UNDERLINE = '\x1b[4m';
+const RESET = '\x1b[0m';
+
+const COLORS = {
+  black:   '\x1b[30m',
+  red:     '\x1b[31m',
+  green:   '\x1b[32m',
+  yellow:  '\x1b[33m',
+  blue:    '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan:    '\x1b[36m',
+  white:   '\x1b[37m',
+  brightBlack:  '\x1b[90m',
+  brightRed:    '\x1b[91m',
+  brightGreen:  '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue:   '\x1b[94m',
+  brightCyan:   '\x1b[96m',
+};
+
+// ── Inline formatting ───────────────────────────────────────────────────────
+
+function renderInline(text, enabled) {
+  if (!enabled) {
+    // Strip markdown markers when colors are off
+    return text
+      .replace(/\*\*\*(.+?)\*\*\*/g, '$1')
+      .replace(/\*\*(.+?)\*\*/g, '$1')
+      .replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, '$1')
+      .replace(/`(.+?)`/g, '$1');
+  }
+
+  let result = text;
+
+  // Bold + italic: ***text***
+  result = result.replace(/\*\*\*(.+?)\*\*\*/g, `${BOLD}${ITALIC}$1${RESET}`);
+
+  // Bold: **text**
+  result = result.replace(/\*\*(.+?)\*\*/g, `${BOLD}$1${RESET}`);
+
+  // Italic: *text* (single asterisk, not part of **)
+  result = result.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, `${ITALIC}$1${RESET}`);
+
+  // Inline code: `text`
+  result = result.replace(/`([^`]+)`/g, `${COLORS.brightBlack}${BOLD}$1${RESET}`);
+
+  // Links: [text](url) — keep text, show URL dimmed
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => {
+    if (label === url) return `${UNDERLINE}${url}${RESET}`;
+    return `${UNDERLINE}${label}${RESET} ${DIM}(${url})${RESET}`;
+  });
+
+  return result;
+}
+
+// ── Block-level rendering ───────────────────────────────────────────────────
+
+const HORIZONTAL_RULE_RE = /^[-*_]{3,}\s*$/;
+const HEADER_RE = /^(#{1,6})\s+(.+)$/;
+const UNORDERED_LIST_RE = /^(\s*)[-*+]\s+(.+)$/;
+const ORDERED_LIST_RE = /^(\s*)(\d+)\.\s+(.+)$/;
+const BLOCKQUOTE_RE = /^>\s?(.*)$/;
+const CODE_FENCE_RE = /^```(\S*)$/;
+
+function renderLine(line, opts = {}) {
+  const { enabled = true, colors = true } = opts;
+  const trim = line.trimEnd();
+  if (!trim) return '';
+
+  // Code fence — pass through as-is (handled by renderBlock)
+  if (CODE_FENCE_RE.test(trim)) {
+    if (!enabled || !colors) return line;
+    return `${COLORS.brightBlack}${trim}${RESET}`;
+  }
+
+  // Horizontal rule
+  if (HORIZONTAL_RULE_RE.test(trim)) {
+    if (!enabled || !colors) return '---';
+    const width = Math.min(process.stdout.columns || 80, 80);
+    return DIM + '\u2500'.repeat(width - 1) + RESET;
+  }
+
+  // Headers
+  const hMatch = trim.match(HEADER_RE);
+  if (hMatch) {
+    const level = hMatch[1].length;
+    const text = renderInline(hMatch[2], enabled && colors);
+    if (!enabled || !colors) {
+      // Structural only: uppercase headers
+      return level <= 2 ? text.toUpperCase() : text;
+    }
+    if (level <= 2) {
+      return `${BOLD}${UNDERLINE}${text}${RESET}`;
+    }
+    return `${BOLD}${text}${RESET}`;
+  }
+
+  // Blockquote
+  const bqMatch = trim.match(BLOCKQUOTE_RE);
+  if (bqMatch) {
+    const text = renderInline(bqMatch[1], enabled && colors);
+    if (!enabled || !colors) return `  ${text}`;
+    return `${COLORS.brightBlack}\u2502 ${text}${RESET}`;
+  }
+
+  // Unordered list
+  const ulMatch = trim.match(UNORDERED_LIST_RE);
+  if (ulMatch) {
+    const indent = ulMatch[1];
+    const text = renderInline(ulMatch[2], enabled && colors);
+    if (!enabled || !colors) return `  ${indent}\u2022 ${text}`;
+    return `${indent}${COLORS.cyan}\u2022${RESET} ${text}`;
+  }
+
+  // Ordered list
+  const olMatch = trim.match(ORDERED_LIST_RE);
+  if (olMatch) {
+    const indent = olMatch[1];
+    const num = olMatch[2];
+    const text = renderInline(olMatch[3], enabled && colors);
+    if (!enabled || !colors) return `  ${indent}${num}. ${text}`;
+    return `${indent}${COLORS.cyan}${num}.${RESET} ${text}`;
+  }
+
+  // Regular line — apply inline formatting
+  return renderInline(trim, enabled && colors);
+}
+
+function renderBlock(text, opts = {}) {
+  const { enabled = true, colors = true } = opts;
+  const src = String(text || '');
+  if (!src) return src;
+
+  const lines = src.split('\n');
+  const out = [];
+  let inCodeBlock = false;
+  let codeLang = '';
+  let codeLines = [];
+
+  function flushCode() {
+    if (!codeLines.length) return;
+    if (!enabled || !colors) {
+      out.push(`[${codeLang || 'code'}]`);
+      for (const l of codeLines) out.push(`  ${l}`);
+      codeLines = [];
+      return;
+    }
+    const head = `${COLORS.brightCyan}${BOLD}${codeLang || 'code'}${RESET}`;
+    out.push(head);
+    for (const l of codeLines) {
+      out.push(`${COLORS.brightBlack}${l}${RESET}`);
+    }
+    codeLines = [];
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const fenceMatch = raw.match(CODE_FENCE_RE);
+
+    if (fenceMatch && !inCodeBlock) {
+      // Opening fence
+      flushCode();
+      // Flush any accumulated regular lines first is handled above
+      inCodeBlock = true;
+      codeLang = fenceMatch[1] || '';
+      continue;
+    }
+
+    if (fenceMatch && inCodeBlock) {
+      // Closing fence
+      flushCode();
+      inCodeBlock = false;
+      codeLang = '';
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeLines.push(raw);
+      continue;
+    }
+
+    // Code fences might contain ``` with trailing text that isn't a fence
+    // Handle ``` that appears mid-line (unusual, but possible)
+    if (raw.startsWith('```') && !fenceMatch) {
+      // This is caught by the regex above, but just in case:
+      codeLines.push(raw);
+      continue;
+    }
+
+    const rendered = renderLine(raw, { enabled, colors });
+    out.push(rendered);
+  }
+
+  // If file ends inside a code block, still flush it
+  flushCode();
+
+  return out.join('\n');
+}
+
+module.exports = {
+  renderInline,
+  renderLine,
+  renderBlock,
+};

package/src/notify.js

@@ -0,0 +1,34 @@
+// Desktop notification support via notify-send (libnotify).
+// Falls back silently if notify-send is not available or no notification
+// daemon is running.
+
+const { execFile } = require('child_process');
+
+const NOTIFY_BIN = 'notify-send';
+
+function available() {
+  try {
+    const { execFileSync } = require('child_process');
+    execFileSync('which', [NOTIFY_BIN], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Fire a desktop notification. Never throws — failures are silent.
+// Delegates to a subprocess so the main loop isn't blocked.
+function notify(summary, body, urgency) {
+  if (!available()) return;
+  const args = [summary || 'shmakk'];
+  if (body) args.push(body);
+  args.push('--app-name=shmakk', '--category=im.received');
+  if (urgency === 'critical') args.push('--urgency=critical');
+  if (urgency === 'low') args.push('--urgency=low');
+  execFile(NOTIFY_BIN, args, (err) => {
+    // Silently ignore — notification daemon may not be running.
+    void err;
+  });
+}
+
+module.exports = { notify, available };

package/src/pty.js

@@ -1,4 +1,4 @@
-const pty = require('node-pty');
+const pty = require('@lydell/node-pty');
 const { EventEmitter } = require('events');
 const { detectShell } = require('./shell');
 const { configureForShell } = require('./hooks');

package/src/review.js

@@ -1,9 +1,16 @@
 // Y/n prompt with cooperative cancellation. The returned `ask` accepts an
 // optional `{ onCancel }` callback that fires when the user hits Ctrl-C.
 
-function makePrompter(pty, write) {
+function makePrompter(pty, write, opts = {}) {
+  const { onNotify } = opts;
   return function ask(question, defaultYes, { onCancel, onWhy } = {}) {
     return new Promise((resolve) => {
+      if (onNotify) {
+        try {
+          const body = typeof question === 'string' ? question.replace(/\x1b\[[0-9;]*m/g, '') : String(question || '');
+          onNotify('shmakk needs your attention', body.slice(0, 120));
+        } catch {}
+      }
       const tag = defaultYes ? '[Y/n/?]' : '[y/N/?]';
       write(`${question} ${tag} `);
       let buf = '';

package/src/self-commands.js

@@ -80,6 +80,35 @@ const SELF_COMMANDS = [
     action: 'show-plan',
   },
 
+  // ── Agent overview ──
+  {
+    patterns: [
+      /^(?:show\s+)?(?:agent\s+)?overview$/i,
+      /^what\s+(?:agents?|specialists?)\s+(?:are|is)\s+(?:working|running|active)[\s?]*$/i,
+      /^who\s+(?:is\s+)?working[\s?]*$/i,
+      /^team\s+(?:status|overview)$/i,
+    ],
+    action: 'agent-overview',
+  },
+  // "agent skills" — show skills used by agents
+  {
+    patterns: [
+      /^agent\s+skills?$/i,
+      /^(?:show\s+)?agent\s+skills?$/i,
+    ],
+    action: 'agent-skills',
+  },
+  // "agent <role|id>" — drill into a specific agent
+  {
+    patterns: [
+      /^agent\s+(\S[\s\S]*)$/i,
+      /^show\s+agent\s+(\S[\s\S]*)$/i,
+      /^(?:detail|inspect|follow)\s+agent\s+(\S[\s\S]*)$/i,
+    ],
+    action: 'agent-detail',
+    needsArg: true,
+  },
+
   // ── Session ──
   {
     patterns: [/^(?:shmakk\s+)?status$/i],
@@ -355,6 +384,19 @@ const SELF_COMMANDS = [
     ],
     action: 'review-edits',
   },
+
+  // ── Sidebar (meta / out-of-band query) ──
+  // "Sidebar: what files did you touch?" runs the agent with full context
+  // but the query and response are never added to conversation history.
+  // Use this for meta-questions, status checks, and side-channel queries.
+  {
+    patterns: [
+      /^Sidebar:\s*(.+)$/i,
+      /^sidebar\s+(.+)$/i,
+    ],
+    action: 'sidebar-query',
+    needsArg: true,
+  },
 ];
 
 function matchSelfCommand(input) {
@@ -404,6 +446,70 @@ function executeSelfCommand(match, write, ctx = {}) {
     // ── Plan ──
     case 'show-plan':     ctl.showPlan(); break;
 
+    // ── Agent overview ──
+    case 'agent-overview': {
+      const overview = require('./agent-overview');
+      const agents = overview.getAll();
+      const lines = overview.formatOverview(agents);
+      for (const line of lines) write(line + '\r\n');
+      break;
+    }
+    case 'agent-detail': {
+      const overview = require('./agent-overview');
+      const query = (match.arg || '').trim();
+      // Try exact id match first, then role match
+      let agent = overview.get(query);
+      if (!agent) {
+        const byRole = overview.findByRole(query);
+        if (byRole.length === 1) {
+          agent = byRole[0];
+        } else if (byRole.length > 1) {
+          write(`\x1b[36m[shmakk]\x1b[0m ${byRole.length} agents match "\x1b[1m${query}\x1b[0m":\r\n`);
+          for (const a of byRole) {
+            const icon = overview.statusIcon(a.status);
+            write(`  ${icon} \x1b[36m${a.id}\x1b[0m  \x1b[2m${a.role} · ${a.status}\x1b[0m\r\n`);
+          }
+          write(`\r\n\x1b[2mUse "agent <id>" to drill into a specific one.\x1b[0m\r\n`);
+          break;
+        }
+      }
+      if (!agent) {
+        write(`\x1b[33m[shmakk] no agent found matching "\x1b[1m${query}\x1b[0m"\r\n`);
+        write(`\x1b[2mTry "agent overview" to see all agents.\x1b[0m\r\n`);
+        break;
+      }
+      const lines = overview.formatAgentDetail(agent);
+      for (const line of lines) write(line + '\r\n');
+      break;
+    }
+    case 'agent-skills': {
+      const overview = require('./agent-overview');
+      const agents = overview.getAll();
+      if (!agents.length) {
+        write('\x1b[2mNo agents registered.\x1b[0m\r\n');
+        break;
+      }
+      const skillMap = new Map();
+      for (const a of agents) {
+        if (!a.skill) continue;
+        if (!skillMap.has(a.skill)) {
+          skillMap.set(a.skill, { skill: a.skill, source: a.skillSource, agents: [] });
+        }
+        skillMap.get(a.skill).agents.push(a.role);
+      }
+      if (!skillMap.size) {
+        write('\x1b[2mNo skills used by agents (all using roster hints).\x1b[0m\r\n');
+        break;
+      }
+      write(`\x1b[1mAgent Skills\x1b[0m\r\n\r\n`);
+      for (const [name, info] of skillMap) {
+        const roles = [...new Set(info.agents)].join(', ');
+        write(`  \x1b[36m${name}\x1b[0m  \x1b[2mused by: ${roles}\x1b[0m\r\n`);
+        if (info.source) write(`    \x1b[2msource: ${info.source}\x1b[0m\r\n`);
+      }
+      break;
+    }
+
     // ── Session ──
     case 'status':        ctl.status(); break;
     case 'stats':         ctl.stats(); break;
@@ -637,10 +743,10 @@ function executeSelfCommand(match, write, ctx = {}) {
       const list = listEndpoints(opts.workspace || process.cwd());
       const current = getCurrentEndpointName();
       if (!list.length) {
-        write('[shmakk] no endpoints configured in ~/.config/shmakk/endpoints.js\r\n');
+        write('[shmakk] no endpoints configured in ~/.config/shmakk/endpoints.json\r\n');
         break;
       }
-      write('[shmakk] available endpoints:\r\n');
+      write('[shmakk] available model endpoints:\r\n');
       for (const ep of list) {
         const marker = ep === current ? ' \x1b[1m*\x1b[0m ' : '   ';
         write(`${marker}${ep}\r\n`);

package/src/session.js

@@ -11,6 +11,7 @@ const { clearIndex } = require('./workspace-index');
 const { loadGlossary } = require('./glossary');
 const { isConfigured } = require('./llm');
 const { makePrompter, decisionBanner } = require('./review');
+const { notify } = require('./notify');
 const { workspaceWarning } = require('./safety');
 const { createMCPManager } = require('./mcp-client');
 const { clearEdits } = require('./edit-tracker');
@@ -164,8 +165,11 @@ function makeToolConfirm(opts, ask, out, getAbort) {
 async function runOneSession(opts, registerSession) {
   const session = startSession({ debug: opts.debug, voiceEnabled: !!opts.voice });
   let colorsEnabled = opts.colors !== false;
+  let markdownEnabled = opts.markdown !== false;
   const out = (s) => session.stdoutWrite(colorsEnabled ? s : stripAnsi(s));
-  const ask = makePrompter(session, out);
+  const ask = makePrompter(session, out, {
+    onNotify: opts.notify ? (summary, body) => notify(summary, body) : null,
+  });
   const glossary = loadGlossary();
   // Workspace tracking: explicit --workspace is "pinned"; otherwise cwd
   // floats with the inner shell's `cd`. When both pinned and cwd differ,
@@ -392,6 +396,7 @@ async function runOneSession(opts, registerSession) {
             history,
             profile: opts.profile || voiceRouting.profile || 'balanced',
             colors: colorsEnabled,
+            markdown: markdownEnabled,
             voiceMode: true,
             specialistHint: voiceRouting.specialistHint,
             mcpManager,
@@ -622,6 +627,44 @@ async function runOneSession(opts, registerSession) {
         audit.append({ kind: 'self-command', cmd: lastCmd, action: selfCmd.action, cwd });
         // Clear any stale correction state so it doesn't leak into next command
         correctionOrigin = null;
+
+        // ── Sidebar query: run the agent with context but don't persist to history ──
+        if (selfCmd.action === 'sidebar-query' && selfCmd.arg) {
+          if (!isConfigured()) {
+            out('\r\n\x1b[33m[shmakk] LLM not configured — sidebar query ignored\x1b[0m\r\n');
+            session.childWrite('\r');
+            return;
+          }
+          await withAI(async (ctrl) => {
+            const sidebarRouting = routeToSpecialist(selfCmd.arg, [...history, { role: 'user', content: selfCmd.arg }]);
+            out('\x1b[36m[shmakk sidebar] (Ctrl-C to interrupt)\x1b[0m\r\n');
+            try {
+              const updated = await runAgent({
+                input: selfCmd.arg,
+                roots: currentRoots(),
+                glossary,
+                confirmTool: makeToolConfirm(opts, ask, out, () => ctrl.abort()),
+                write: out,
+                signal: ctrl.signal,
+                history,
+                profile: opts.profile || sidebarRouting.profile || 'balanced',
+                colors: colorsEnabled,
+                markdown: markdownEnabled,
+                specialistHint: sidebarRouting.specialistHint,
+                mcpManager,
+              });
+              // Don't update history — sidebar queries are out-of-band.
+              // (runAgent already records turns in session search internally.)
+            } catch (e) {
+              if (!isAbortError(e)) {
+                out(`\x1b[31m[shmakk sidebar] error: ${e.message}\x1b[0m\r\n`);
+              }
+            }
+          });
+          session.childWrite('\r');
+          return;
+        }
+
         if (selfCmd.confirm) {
           const go = await ask(`Run ${selfCmd.action}?`, true, { onCancel: () => {} });
           if (!go) { session.childWrite('\r'); return; }
@@ -641,11 +684,18 @@ async function runOneSession(opts, registerSession) {
     // - Failed  (code != 0): give agent the original command the user typed, not any
     //   corrected variant — if a correction was applied but also failed, correctionOrigin
     //   still holds the user's original input and that's what the agent should reason about.
+    //
+    // After a correction was applied (whether it succeeded or failed), we MUST skip
+    // re-running correction on the original — otherwise it would propose the same fix
+    // again and enter an infinite loop (correct → feed corrected → succeed/fail →
+    // agent sees original → correction proposes same thing → feed again → ...).
     let cmd = lastCmd;
+    let correctionAlreadyTried = false;
     if (code === 0) {
       if (correctionOrigin && !opts.noAi) {
         cmd = correctionOrigin;
         correctionOrigin = null;
+        correctionAlreadyTried = true;
       } else {
         flushPending();
         return;
@@ -657,14 +707,19 @@ async function runOneSession(opts, registerSession) {
       if (correctionOrigin) {
         cmd = correctionOrigin;
         correctionOrigin = null;
+        correctionAlreadyTried = true;
       }
     }
 
     audit.append({ kind: 'failed-command', cmd, exit: code, cwd });
 
     // ── Correction runs standalone (no LLM needed) ──
+    // Skip correction if one was already applied for this input —
+    // re-running correction on the same original would just propose the same fix.
     let decision;
-    if (opts.noCorrection) {
+    if (correctionAlreadyTried) {
+      decision = { category: 'not_a_correction', proposed: null, safety: 'uncertain', reason: 'correction already tried — routing to agent' };
+    } else if (opts.noCorrection) {
       decision = { category: 'not_a_correction', proposed: null, safety: 'uncertain', reason: 'correction disabled' };
     } else {
       try {
@@ -761,6 +816,7 @@ async function runOneSession(opts, registerSession) {
         signal: ctrl.signal,
         profile: agentProfile,
         colors: colorsEnabled,
+        markdown: markdownEnabled,
         specialistHint: routing.specialistHint,
         mcpManager,
       };