lazyclaw 5.0.1 → 5.0.2

package/mcp/client.mjs

@@ -0,0 +1,87 @@
+// MCP client — spawn external MCP servers over stdio, list their tools,
+// and register each one in mas/tools/registry.mjs with a stable prefix
+// ("mcp:<server>:<tool>"). Defaults: sensitive=true (so the approve hook
+// gates every external call), category="mcp:<server>". Per-server
+// allowGlob narrows which tools are exposed.
+//
+// The real transport uses @modelcontextprotocol/sdk's StdioClientTransport;
+// tests inject a fake transport via __setTransport so the spec can run
+// without the binary.
+
+import * as registry from '../mas/tools/registry.mjs';
+
+let _transport = null;
+export function __setTransport(t) { _transport = t; }
+
+const SERVERS = new Map();  // name -> { client, tools }
+
+function matchGlob(name, glob) {
+  if (!glob || glob === '*') return true;
+  const re = new RegExp('^' + glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$');
+  return re.test(name);
+}
+
+async function realTransport({ command, args, env }) {
+  const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
+  const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
+  const transport = new StdioClientTransport({ command, args: args || [], env });
+  const client = new Client({ name: 'lazyclaw', version: '5.0.0' }, { capabilities: {} });
+  await client.connect(transport);
+  return {
+    listTools: () => client.listTools(),
+    callTool: (req) => client.callTool(req),
+    close:    () => client.close(),
+  };
+}
+
+export async function startServer({ name, command, args = [], env = {}, allowGlob = '*', sensitive = true } = {}) {
+  if (!name || !command) throw new Error('startServer: name + command required');
+  if (SERVERS.has(name)) throw new Error(`startServer: server "${name}" already running`);
+
+  const transport = _transport || { connect: realTransport };
+  const client = await transport.connect({ command, args, env });
+  const { tools = [] } = await client.listTools();
+
+  const registered = [];
+  for (const t of tools) {
+    if (!matchGlob(t.name, allowGlob)) continue;
+    const toolName = `mcp:${name}:${t.name}`;
+    const rec = {
+      name: toolName,
+      category: `mcp:${name}`,
+      sensitive,
+      description: t.description || `MCP tool ${t.name} on server ${name}`,
+      parameters: t.inputSchema || { type: 'object', properties: {} },
+      async exec(callArgs) {
+        try {
+          const res = await client.callTool({ name: t.name, arguments: callArgs || {} });
+          const text = (res?.content || [])
+            .filter(c => c.type === 'text')
+            .map(c => c.text)
+            .join('\n');
+          return { ok: true, text, raw: res };
+        } catch (e) {
+          return { ok: false, error: `${toolName}: ${e.message}` };
+        }
+      },
+    };
+    registry.register(rec);
+    registered.push(toolName);
+  }
+
+  SERVERS.set(name, { client, tools: registered });
+  return { ok: true, name, tools: registered };
+}
+
+export async function stopServer(name) {
+  const entry = SERVERS.get(name);
+  if (!entry) return { ok: false, error: `stopServer: ${name} not running` };
+  for (const toolName of entry.tools) registry.unregister(toolName);
+  try { await entry.client.close(); } catch { /* best-effort */ }
+  SERVERS.delete(name);
+  return { ok: true, name };
+}
+
+export function listServers() {
+  return [...SERVERS.entries()].map(([name, e]) => ({ name, toolCount: e.tools.length }));
+}

package/mcp/server_spawn.mjs

@@ -0,0 +1,25 @@
+// server_spawn — drive startServer from cfg.mcp.servers[] at daemon boot.
+//
+// cfg.mcp.servers = [
+//   { name: 'fs', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '/tmp'],
+//     allowGlob: 'read_*' },
+//   { name: 'git', command: 'mcp-git', args: [] },
+// ]
+
+import { startServer, stopServer, listServers } from './client.mjs';
+
+export async function startConfigured(cfg) {
+  const servers = cfg?.mcp?.servers || [];
+  const results = [];
+  for (const s of servers) {
+    try { results.push(await startServer(s)); }
+    catch (e) { results.push({ ok: false, name: s.name, error: e.message }); }
+  }
+  return results;
+}
+
+export async function stopAll() {
+  for (const { name } of listServers()) {
+    try { await stopServer(name); } catch { /* best-effort */ }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "5.0.1",
+  "version": "5.0.2",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama, orchestrating multi-step LLM workflows, and running multi-agent Slack teams with cross-task memory. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",
@@ -67,6 +67,8 @@
     "workflow/",
     "web/",
     "mas/",
+    "mcp/",
+    "tui/",
     "gateway/",
     "docs/multi-agent.md",
     "scripts/loop-worker.mjs",

package/tui/banner.generated.mjs

@@ -0,0 +1,18 @@
+// AUTO-GENERATED placeholder — replace by running `npm run build:splash`.
+export const banner = {
+  rows: [
+    "    ⣀⣠⣤⣶⣶⣦⣄⡀         ",
+    "  ⢠⣾⠟⠉   ⠈⠙⢿⣦         ",
+    "  ⣿⠁  ●     ●  ⣿        ",
+    "  ⣿⡀   ⠈⠉⠉⠁   ⣿        ",
+    "  ⠘⢿⣦⡀     ⢀⣴⡿⠃         ",
+    "    ⠈⠙⠻⠷⠶⠶⠿⠟⠋           ",
+    "       ⢸⠁  ⢸           ",
+    "       ⢸⠉  ⠉⠉⠉⠉         ",
+    "        lazyclaw        ",
+    "                        "
+  ],
+  width: 24,
+  height: 10,
+  fg: "#FFB347"
+};

package/tui/editor.mjs

@@ -0,0 +1,82 @@
+// tui/editor.mjs — multiline input state machine (spec §5.8).
+//
+// Pure-functional core (makeEditorState, applyKey) so it is testable
+// without ink stdin. The React component <Editor/> wraps useInput().
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { theme } from './theme.mjs';
+
+export function makeEditorState({ history = [] } = {}) {
+  return {
+    buffer: '',
+    cursor: 0,
+    historyIdx: history.length,
+    history,
+    lastSubmit: null,
+    lastWasPaste: false,
+  };
+}
+
+export function applyKey(state, evt) {
+  const { input = '', key = {}, paste = false } = evt;
+  const next = { ...state, lastSubmit: null, lastWasPaste: false };
+
+  if (key.return && key.shift) {
+    next.buffer = state.buffer + '\n';
+    next.cursor = next.buffer.length;
+    return next;
+  }
+  if (key.return) {
+    next.lastSubmit = state.buffer;
+    next.buffer = '';
+    next.cursor = 0;
+    next.historyIdx = state.history.length;
+    return next;
+  }
+  if (key.upArrow) {
+    const idx = Math.max(0, state.historyIdx - 1);
+    if (state.history[idx] !== undefined) {
+      next.historyIdx = idx;
+      next.buffer = state.history[idx];
+      next.cursor = next.buffer.length;
+    }
+    return next;
+  }
+  if (key.downArrow) {
+    const idx = Math.min(state.history.length, state.historyIdx + 1);
+    next.historyIdx = idx;
+    next.buffer = state.history[idx] !== undefined ? state.history[idx] : '';
+    next.cursor = next.buffer.length;
+    return next;
+  }
+  if (key.backspace || key.delete) {
+    next.buffer = state.buffer.slice(0, -1);
+    next.cursor = next.buffer.length;
+    return next;
+  }
+  if (input) {
+    next.buffer = state.buffer + input;
+    next.cursor = next.buffer.length;
+    next.lastWasPaste = paste || input.length >= 16;
+    return next;
+  }
+  return next;
+}
+
+export function Editor({ history, onSubmit }) {
+  const [state, setState] = useState(() => makeEditorState({ history }));
+  useInput((input, key) => {
+    const next = applyKey(state, { input, key });
+    setState(next);
+  });
+  useEffect(() => {
+    if (state.lastSubmit !== null && onSubmit) onSubmit(state.lastSubmit);
+  }, [state.lastSubmit]);
+
+  const lines = state.buffer.split('\n');
+  return React.createElement(
+    Box,
+    { flexDirection: 'column' },
+    lines.map((ln, i) => React.createElement(Text, { key: i }, i === 0 ? theme.accent('› ') + ln : '  ' + ln))
+  );
+}

package/tui/ghost.mjs

@@ -0,0 +1,42 @@
+// tui/ghost.mjs — ink port of the v4 readline ghost autocomplete
+// (cli.mjs:1388-1500). Pure functions; the React surface is owned
+// by tui/repl.mjs which renders the suggestion dim-styled.
+import { theme } from './theme.mjs';
+
+function matches(prefix, cmds) {
+  return cmds.filter((c) => c.startsWith(prefix) && c !== prefix);
+}
+
+export function computeGhost(buffer, cmds) {
+  if (!buffer.startsWith('/')) return null;
+  const ms = matches(buffer, cmds);
+  if (ms.length === 0) return null;
+  const suggestion = ms[0];
+  return {
+    suggestion,
+    suffix: suggestion.slice(buffer.length),
+    candidates: ms,
+    idx: 0,
+  };
+}
+
+export function cycleGhost(ghost, cmds) {
+  if (!ghost || !ghost.candidates || ghost.candidates.length === 0) return ghost;
+  const next = (ghost.idx + 1) % ghost.candidates.length;
+  const suggestion = ghost.candidates[next];
+  return {
+    suggestion,
+    suffix: suggestion.slice(suggestion.length - (suggestion.length - ghost.candidates[ghost.idx].length + ghost.suffix.length)),
+    candidates: ghost.candidates,
+    idx: next,
+  };
+}
+
+export function acceptGhost(buffer, ghost) {
+  if (!ghost) return buffer;
+  return ghost.suggestion;
+}
+
+export function ghostStyle(suffix) {
+  return theme.dim(suffix);
+}

package/tui/repl.mjs

@@ -0,0 +1,89 @@
+// tui/repl.mjs — REPL host with mid-stream interrupt-and-redirect
+// (spec §5.8). Pure state functions for testability; the React
+// mount lives at the bottom and is exercised only when stdin isTTY.
+import React, { useState, useEffect } from 'react';
+import { Box, useApp } from 'ink';
+import { Splash } from './splash.mjs';
+import { Editor } from './editor.mjs';
+
+export function makeReplState() {
+  return {
+    streaming: false,
+    controller: null,
+    pendingPrepend: null,
+    nextTurnFirstMessage: null,
+    history: [],
+  };
+}
+
+export function onUserInput(state, { text, controller }) {
+  if (state.streaming && state.controller) {
+    // mid-stream interrupt — abort current turn, queue text for next turn.
+    try { state.controller.abort(); } catch {}
+    return { ...state, pendingPrepend: text };
+  }
+  // idle — start a new turn.
+  return {
+    ...state,
+    streaming: true,
+    controller,
+    history: [...state.history, text],
+  };
+}
+
+export function onEscape(state) {
+  if (state.streaming && state.controller) {
+    try { state.controller.abort(); } catch {}
+  }
+  return { ...state, streaming: false, controller: null, pendingPrepend: null };
+}
+
+export function onTurnComplete(state, { reason } = {}) {
+  void reason;
+  const promoted = state.pendingPrepend;
+  return {
+    ...state,
+    streaming: false,
+    controller: null,
+    pendingPrepend: null,
+    nextTurnFirstMessage: promoted,
+  };
+}
+
+export function consumeNextTurnFirstMessage(state) {
+  const msg = state.nextTurnFirstMessage;
+  return [{ ...state, nextTurnFirstMessage: null }, msg];
+}
+
+// ─── React mount ─────────────────────────────────────────────────────────
+export function ReplApp({ splashProps, runTurn }) {
+  const [state, setState] = useState(makeReplState);
+  const { exit } = useApp();
+
+  async function handleSubmit(text) {
+    if (text === '/exit') { exit(); return; }
+    const controller = new AbortController();
+    setState((s) => onUserInput(s, { text, controller }));
+    try {
+      await runTurn(text, controller.signal);
+      setState((s) => onTurnComplete(s, { reason: 'done' }));
+    } catch (err) {
+      setState((s) => onTurnComplete(s, { reason: err.name === 'AbortError' ? 'aborted' : 'error' }));
+    }
+  }
+
+  useEffect(() => {
+    const [next, msg] = consumeNextTurnFirstMessage(state);
+    if (msg) {
+      setState(next);
+      handleSubmit(msg);
+    }
+  }, [state.nextTurnFirstMessage]);
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column' },
+    React.createElement(Splash, splashProps),
+    React.createElement(Editor, { history: state.history, onSubmit: handleSubmit })
+  );
+}

package/tui/splash.mjs

@@ -0,0 +1,107 @@
+// tui/splash.mjs — two-column launch splash (spec §5.1).
+//
+// Public surface:
+//   - <Splash {...props} />            ink component for live REPL mount
+//   - renderSplashToString(props)      pure string builder used by tests
+//                                       and by the non-TTY path.
+//
+// Layout: 24-cell sloth gutter (cols 0-23) | 2-cell separator (24-25)
+//   | 52-cell right column (cols 26-77) | 2-cell right padding.
+// Footer: exactly 4 lines, blank row separates body from footer.
+import React from 'react';
+import { Box, Text } from 'ink';
+import stringWidth from 'string-width';
+import { theme } from './theme.mjs';
+import { banner } from './banner.generated.mjs';
+
+const RIGHT_COL_WIDTH = 52;
+const GUTTER_WIDTH = 24;
+
+function fit(text, max) {
+  if (stringWidth(text) <= max) return text.padEnd(max);
+  let lo = 0, hi = text.length;
+  while (lo < hi) {
+    const mid = (lo + hi + 1) >> 1;
+    if (stringWidth(text.slice(0, mid) + '…') <= max) lo = mid;
+    else hi = mid - 1;
+  }
+  return (text.slice(0, lo) + '…').padEnd(max);
+}
+
+function shortCwd(cwd) {
+  const home = process.env.HOME || '';
+  if (home && cwd.startsWith(home)) return '~' + cwd.slice(home.length);
+  return cwd;
+}
+
+function toolRow({ category, sensitive, verbs }) {
+  const label = sensitive ? `(sensitive) ${category}` : category;
+  const labelWidth = sensitive ? 20 : 9;
+  const tail = verbs.slice(0, 6).join(' · ');
+  const more = verbs.length > 6 ? ` (${verbs.length - 6} more)` : '';
+  return `${fit(label, labelWidth)}${tail}${more}`;
+}
+
+function skillRow({ group, names }) {
+  const tail = names.slice(0, 6).join(' · ');
+  const more = names.length > 6 ? ` (${names.length - 6} more)` : '';
+  return `${fit(group, 9)}${tail}${more}`;
+}
+
+function buildBody(props) {
+  const { tools = [], skills = [] } = props;
+  const right = [];
+  right.push('Available Tools');
+  right.push('─'.repeat(45));
+  for (const t of tools.slice(0, 8)) right.push(toolRow(t));
+  if (tools.length > 8) right.push(`... and ${tools.length - 8} more tool groups`);
+  right.push('');
+  right.push('Available Skills');
+  right.push('─'.repeat(45));
+  for (const s of skills.slice(0, 8)) right.push(skillRow(s));
+  if (skills.length > 8) right.push(`... and ${skills.length - 8} more skill groups`);
+
+  const left = banner.rows.slice();
+  while (left.length < right.length) left.push('');
+  while (right.length < left.length) right.push('');
+
+  const lines = [];
+  for (let i = 0; i < left.length; i++) {
+    const lhs = fit(left[i], GUTTER_WIDTH);
+    const rhs = fit(right[i], RIGHT_COL_WIDTH);
+    lines.push(`  ${lhs}  ${rhs}`);
+  }
+  return lines;
+}
+
+function buildFooter(props) {
+  const { provider, model, trainer = {}, sessionId, cwd } = props;
+  const tProv = trainer.provider || provider;
+  const tModel = trainer.model || model;
+  const sid = (sessionId || '').slice(0, 8);
+  const cwdShort = shortCwd(cwd || process.cwd());
+  return [
+    fit(`  provider · ${provider} · ${model}`, 56) + fit(`cwd · ${cwdShort}`, 22),
+    fit(`  trainer  · ${tProv} · ${tModel}  session ${sid}`, 78),
+    fit('  slash    · /help · /model · /trainer · /skills · /tools · /exit', 78),
+    fit('  hint     · Shift+Enter newline · Ctrl-R recall · Esc interrupt', 78),
+  ];
+}
+
+export function renderSplashToString(props, { columns = 80 } = {}) {
+  void columns; // currently fixed-width at 80; <72 fallback is in cli.mjs
+  const body = buildBody(props);
+  const footer = buildFooter(props);
+  return [...body, '', ...footer].join('\n');
+}
+
+export function Splash(props) {
+  const lines = renderSplashToString(props).split('\n');
+  return React.createElement(
+    Box,
+    { flexDirection: 'column' },
+    lines.map((line, i) =>
+      React.createElement(Text, { key: i, color: i < banner.height ? theme.fg : undefined }, line)
+    )
+  );
+}

package/tui/theme.mjs

@@ -0,0 +1,39 @@
+// tui/theme.mjs — single source of truth for lazyclaw v5 color tokens.
+// The amber hex is also stamped into tui/banner.generated.mjs so the
+// sloth gutter and the prompt accent stay visually paired.
+import chalk from 'chalk';
+
+const AMBER_HEX = '#FFB347';
+
+function amber(text) {
+  return chalk.hex(AMBER_HEX)(text);
+}
+
+function dim(text) {
+  return chalk.dim(text);
+}
+
+function accent(text) {
+  return chalk.bold.hex(AMBER_HEX)(text);
+}
+
+function muted(text) {
+  return chalk.gray(text);
+}
+
+function plain(text) {
+  return text;
+}
+
+export const theme = {
+  amber: AMBER_HEX,
+  fg: AMBER_HEX,
+  colorize: amber,
+  dim,
+  accent,
+  muted,
+  plain,
+};
+
+// Compatibility: some callers want the colorizer when reading `theme.amber`.
+// Keep the hex on the property for builders, and expose `colorize` for runtime use.