lazyclaw 3.99.28 → 4.2.0

package/mas/tools/read.mjs

@@ -0,0 +1,45 @@
+// Read tool — reads a file (UTF-8) from the agent's workspace.
+//
+// Paths are resolved relative to the workspace cwd. Absolute paths are
+// allowed (the user opted into "lazyclaw 모든 권한"). Use the bash tool
+// to read binary blobs.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const NAME = 'read';
+export const DESCRIPTION = 'Read a file from disk (UTF-8). Returns the file contents or an error.';
+export const PARAMETERS = {
+  type: 'object',
+  properties: {
+    path: { type: 'string', description: 'Relative or absolute path to the file.' },
+    maxBytes: { type: 'number', description: 'Optional cap; default 500 KB. Larger files are truncated.' },
+  },
+  required: ['path'],
+};
+
+const DEFAULT_MAX_BYTES = 500_000;
+
+export async function exec(args, { cwd = process.cwd() } = {}) {
+  if (!args || typeof args.path !== 'string' || !args.path) {
+    return { ok: false, error: 'read: path is required' };
+  }
+  const max = Math.max(1024, Math.min(Number.isFinite(+args.maxBytes) ? +args.maxBytes : DEFAULT_MAX_BYTES, 5_000_000));
+  const resolved = path.isAbsolute(args.path) ? args.path : path.resolve(cwd, args.path);
+  try {
+    const stat = fs.statSync(resolved);
+    if (!stat.isFile()) return { ok: false, error: `read: not a regular file: ${resolved}` };
+    const buf = fs.readFileSync(resolved);
+    const truncated = buf.length > max;
+    const slice = truncated ? buf.subarray(0, max) : buf;
+    return {
+      ok: true,
+      path: resolved,
+      bytes: stat.size,
+      content: slice.toString('utf8'),
+      truncated,
+    };
+  } catch (err) {
+    return { ok: false, error: `read: ${err?.message || err}` };
+  }
+}

package/mas/tools/write.mjs

@@ -0,0 +1,42 @@
+// Write tool — overwrites or creates a file with the given content.
+//
+// Creates parent directories as needed. Atomic-ish: writes to <path>.tmp
+// then renames over the target so a crash mid-write doesn't leave a
+// partially-written file.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const NAME = 'write';
+export const DESCRIPTION = 'Create or overwrite a file with the given UTF-8 content. Returns {bytesWritten, path}.';
+export const PARAMETERS = {
+  type: 'object',
+  properties: {
+    path: { type: 'string', description: 'Relative or absolute path to write.' },
+    content: { type: 'string', description: 'The new file contents (UTF-8).' },
+  },
+  required: ['path', 'content'],
+};
+
+export async function exec(args, { cwd = process.cwd() } = {}) {
+  if (!args || typeof args.path !== 'string' || !args.path) {
+    return { ok: false, error: 'write: path is required' };
+  }
+  if (typeof args.content !== 'string') {
+    return { ok: false, error: 'write: content must be a string' };
+  }
+  const resolved = path.isAbsolute(args.path) ? args.path : path.resolve(cwd, args.path);
+  try {
+    fs.mkdirSync(path.dirname(resolved), { recursive: true });
+    const tmp = resolved + '.tmp';
+    fs.writeFileSync(tmp, args.content);
+    fs.renameSync(tmp, resolved);
+    return {
+      ok: true,
+      path: resolved,
+      bytesWritten: Buffer.byteLength(args.content, 'utf8'),
+    };
+  } catch (err) {
+    return { ok: false, error: `write: ${err?.message || err}` };
+  }
+}

package/memory.mjs

@@ -0,0 +1,193 @@
+// Layered memory for LazyClaw.
+//
+// Three storage shapes under <configDir>/memory/:
+//   core.md                — single curated file. User-edited or LLM-edited.
+//                            Long-lived; survives `dream()`. Mounted into
+//                            every goal tick + every `/loop --use-memory`.
+//   recent.jsonl           — append-only log of {sessionId, role, content,
+//                            ts}, one line per call to sessions.appendTurn.
+//                            Capped softly at RECENT_CAP entries; truncated
+//                            hard to RECENT_KEEP_AFTER_DREAM after dream().
+//   episodic/<topic>.md    — one file per topic produced by dream().
+//                            Filenames are kebab-case slugs derived from
+//                            the topic strings the provider returned.
+//
+// `appendRecent` is the only entry point sessions.appendTurn calls. It
+// swallows every error — memory must not break the session-write path.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const MEMORY_DIRNAME = 'memory';
+const RECENT_CAP = 200;
+const RECENT_KEEP_AFTER_DREAM = 50;
+
+export function defaultConfigDir() {
+  return process.env.LAZYCLAW_CONFIG_DIR || path.join(os.homedir(), '.lazyclaw');
+}
+
+export function memoryDir(configDir = defaultConfigDir()) { return path.join(configDir, MEMORY_DIRNAME); }
+export function corePath(configDir = defaultConfigDir()) { return path.join(memoryDir(configDir), 'core.md'); }
+export function recentPath(configDir = defaultConfigDir()) { return path.join(memoryDir(configDir), 'recent.jsonl'); }
+export function episodicDir(configDir = defaultConfigDir()) { return path.join(memoryDir(configDir), 'episodic'); }
+
+export function loadCore(configDir = defaultConfigDir()) {
+  const p = corePath(configDir);
+  if (!fs.existsSync(p)) return '';
+  return fs.readFileSync(p, 'utf8');
+}
+
+export function setCore(text, configDir = defaultConfigDir()) {
+  fs.mkdirSync(memoryDir(configDir), { recursive: true });
+  fs.writeFileSync(corePath(configDir), String(text || ''));
+}
+
+export function loadRecent(n = 20, configDir = defaultConfigDir()) {
+  const p = recentPath(configDir);
+  if (!fs.existsSync(p)) return [];
+  const lines = fs.readFileSync(p, 'utf8').split('\n').filter(Boolean);
+  const slice = n > 0 ? lines.slice(-n) : lines;
+  const out = [];
+  for (const l of slice) {
+    try { out.push(JSON.parse(l)); } catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+export function listEpisodic(configDir = defaultConfigDir()) {
+  const dir = episodicDir(configDir);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter(f => f.endsWith('.md')).map(f => f.slice(0, -3));
+}
+
+export function loadEpisodic(topic, configDir = defaultConfigDir()) {
+  const p = path.join(episodicDir(configDir), `${topic}.md`);
+  if (!fs.existsSync(p)) return '';
+  return fs.readFileSync(p, 'utf8');
+}
+
+// Sync, swallowed-failure write-through called from sessions.appendTurn.
+export function appendRecent(sessionId, role, content, configDir = defaultConfigDir()) {
+  try {
+    fs.mkdirSync(memoryDir(configDir), { recursive: true });
+    const line = JSON.stringify({
+      sessionId,
+      role,
+      content: String(content ?? ''),
+      ts: Date.now(),
+    }) + '\n';
+    fs.appendFileSync(recentPath(configDir), line);
+    // Cheap stat-based check to avoid read-rewrite on every append.
+    const st = fs.statSync(recentPath(configDir));
+    if (st.size > 1_000_000) {
+      const lines = fs.readFileSync(recentPath(configDir), 'utf8').split('\n').filter(Boolean);
+      if (lines.length > RECENT_CAP) {
+        fs.writeFileSync(recentPath(configDir), lines.slice(-RECENT_CAP).join('\n') + '\n');
+      }
+    }
+  } catch { /* swallow — memory failure must not break session writes */ }
+}
+
+// `dream(sessionId)` consolidates recent.jsonl into per-topic episodic
+// files using the active provider, then truncates recent.jsonl to the
+// last RECENT_KEEP_AFTER_DREAM entries. Returns { topics: [slug,...] }.
+//
+// The mock provider doesn't return JSON, so we accept any string and
+// fall back to a single "recent-<date>" topic containing the raw reply.
+// Real providers (Anthropic / OpenAI) typically obey the JSON instruction.
+export async function dream(sessionId, { provider, model, apiKey } = {}, configDir = defaultConfigDir()) {
+  if (!provider) throw new Error('dream() requires a provider');
+  const turns = loadRecent(1000, configDir);
+  if (turns.length === 0) return { topics: [] };
+
+  const prompt = [
+    'Below are recent chat turns. Group them under topics and summarise each topic in one paragraph.',
+    'Dedupe aggressively. If two turns cover the same topic, merge.',
+    'Output strict JSON of shape: {"topics": [{"topic": "kebab-case-slug", "summary": "..."}]}',
+    '',
+    'Turns:',
+    ...turns.map(t => `- [${t.role}@${t.sessionId}]: ${String(t.content).slice(0, 500)}`),
+  ].join('\n');
+
+  let raw = '';
+  for await (const chunk of provider.sendMessage([{ role: 'user', content: prompt }], { apiKey, model })) {
+    raw += chunk;
+  }
+  let parsed = null;
+  try {
+    const m = raw.match(/\{[\s\S]*\}/);
+    parsed = m ? JSON.parse(m[0]) : null;
+  } catch { parsed = null; }
+  const topics = (parsed?.topics && Array.isArray(parsed.topics) && parsed.topics.length)
+    ? parsed.topics
+    : [{ topic: 'recent-' + new Date().toISOString().slice(0, 10), summary: raw.slice(0, 4000) || '(no content)' }];
+
+  fs.mkdirSync(episodicDir(configDir), { recursive: true });
+  const written = [];
+  for (const t of topics) {
+    if (!t || !t.topic) continue;
+    const slug = String(t.topic).toLowerCase().replace(/[^a-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80) || 'untitled';
+    const p = path.join(episodicDir(configDir), `${slug}.md`);
+    fs.writeFileSync(p, `# ${slug}\n\n${t.summary || ''}\n`);
+    written.push(slug);
+  }
+
+  // Hard truncate recent.jsonl after a successful dream.
+  const rp = recentPath(configDir);
+  if (fs.existsSync(rp)) {
+    const lines = fs.readFileSync(rp, 'utf8').split('\n').filter(Boolean);
+    if (lines.length > RECENT_KEEP_AFTER_DREAM) {
+      fs.writeFileSync(rp, lines.slice(-RECENT_KEEP_AFTER_DREAM).join('\n') + '\n');
+    }
+  }
+  return { topics: written };
+}
+
+// Returns a single string suitable for prepending to a tick / loop
+// prompt. Core memory always comes first; episodic files are included
+// only when their topic slug substring-matches a word ≥3 chars from
+// the goal name + description.
+export function getMemoryForGoal(name, description = '', configDir = defaultConfigDir()) {
+  const parts = [];
+  const core = loadCore(configDir);
+  if (core.trim()) parts.push(`## Core memory\n${core}`);
+  const keywords = String(name + ' ' + description).toLowerCase()
+    .split(/[^a-z0-9]+/).filter(w => w.length >= 3);
+  if (keywords.length) {
+    const topics = listEpisodic(configDir);
+    for (const t of topics) {
+      const tl = t.toLowerCase();
+      if (keywords.some(k => tl.includes(k))) {
+        const body = loadEpisodic(t, configDir);
+        if (body.trim()) parts.push(`## Episodic: ${t}\n${body}`);
+      }
+    }
+  }
+  return parts.join('\n\n');
+}
+
+// Recall helper used by `/loop --recall "<query>"`. Tokenises the query,
+// scores recent and episodic entries by overlap, returns the top-N
+// matches as a single concatenated string. Cheap, no external index.
+export function recall(query, { topN = 3 } = {}, configDir = defaultConfigDir()) {
+  const tokens = String(query || '').toLowerCase().split(/[^a-z0-9]+/).filter(w => w.length >= 3);
+  if (!tokens.length) return '';
+  const candidates = [];
+  for (const slug of listEpisodic(configDir)) {
+    const body = loadEpisodic(slug, configDir);
+    candidates.push({ source: `episodic:${slug}`, body });
+  }
+  for (const turn of loadRecent(200, configDir)) {
+    candidates.push({ source: `recent:${turn.sessionId || '?'}`, body: String(turn.content || '') });
+  }
+  const scored = candidates.map((c) => {
+    const lower = c.body.toLowerCase();
+    let score = 0;
+    for (const t of tokens) {
+      if (lower.includes(t)) score += 1;
+    }
+    return { ...c, score };
+  }).filter(c => c.score > 0).sort((a, b) => b.score - a.score).slice(0, topN);
+  return scored.map(c => `## ${c.source} (score ${c.score})\n${c.body}`).join('\n\n');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lazyclaw",
-  "version": "3.99.28",
-  "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama and orchestrating multi-step LLM workflows. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
+  "version": "4.2.0",
+  "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",
     "anthropic",
@@ -15,22 +15,25 @@
     "workflow",
     "agent"
   ],
-  "homepage": "https://github.com/cmblir/LazyClaude",
+  "homepage": "https://github.com/cmblir/lazyclaw#readme",
   "bugs": {
-    "url": "https://github.com/cmblir/LazyClaude/issues"
+    "url": "https://github.com/cmblir/lazyclaw/issues"
   },
   "license": "MIT",
   "author": "cmblir",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/cmblir/LazyClaude.git",
-    "directory": "src/lazyclaw"
+    "url": "git+https://github.com/cmblir/lazyclaw.git"
   },
   "type": "module",
   "main": "cli.mjs",
   "bin": {
     "lazyclaw": "cli.mjs"
   },
+  "scripts": {
+    "test": "playwright test",
+    "test:bench": "node scripts/bench-providers.mjs"
+  },
   "files": [
     "cli.mjs",
     "daemon.mjs",
@@ -46,15 +49,32 @@
     "sandbox.mjs",
     "skills_install.mjs",
     "cron.mjs",
+    "loop-engine.mjs",
+    "loops.mjs",
+    "goals.mjs",
+    "memory.mjs",
+    "agents.mjs",
+    "teams.mjs",
+    "tasks.mjs",
+    "channels/",
     "providers/",
     "workflow/",
     "web/",
+    "mas/",
+    "docs/multi-agent.md",
+    "scripts/loop-worker.mjs",
     "README.md",
     "LICENSE"
   ],
   "engines": {
     "node": ">=18"
   },
+  "devDependencies": {
+    "@playwright/test": "^1.59.1",
+    "@types/node": "^25.6.0",
+    "playwright": "^1.59.1",
+    "typescript": "^6.0.3"
+  },
   "publishConfig": {
     "access": "public"
   }

package/providers/registry.mjs

@@ -42,7 +42,14 @@ export const mockProvider = {
   name: 'mock',
   async *sendMessage(messages, opts = {}) {
     const last = messages[messages.length - 1];
-    const reply = `mock-reply: ${last?.content ?? ''}`;
+    const sys = messages.find((m) => m.role === 'system')?.content || '';
+    // When a system message is present, prefix the echo with [sys:...]
+    // so callers (and especially tests) can verify what the provider
+    // saw in the system slot. No system → byte-identical to the prior
+    // shape so existing assertions stay green.
+    const reply = sys
+      ? `[sys:${String(sys).slice(0, 8000)}]\nmock-reply: ${last?.content ?? ''}`
+      : `mock-reply: ${last?.content ?? ''}`;
     // Honor opts.signal so the chat REPL's Ctrl+C handler (and any
     // other caller) can stop the stream mid-flight. The other concrete
     // providers already do this; the mock should match for symmetry.

package/providers/tool_use/anthropic.mjs

@@ -0,0 +1,151 @@
+// Anthropic tool-use adapter.
+//
+// Unlike providers/anthropic.mjs (which streams a single text response),
+// this module makes ONE non-streaming Messages API call at a time and
+// parses the result into a normalized envelope the agent-turn runner
+// can act on:
+//
+//   { kind: 'final',      text }
+//   { kind: 'tool_calls', text?, calls: [{id, name, input}], assistantContent }
+//
+// `assistantContent` is the raw `content` array from the API response;
+// the caller echoes it back verbatim on the next request so the model
+// can correlate tool_result blocks with the right tool_use ids.
+//
+// Anthropic's docs (Messages API tool-use, accessed Jan 2026):
+//   https://docs.anthropic.com/en/api/messages
+//   https://docs.anthropic.com/en/docs/build-with-claude/tool-use
+
+const ANTHROPIC_VERSION = '2023-06-01';
+const DEFAULT_MAX_TOKENS = 4096;
+const DEFAULT_BASE = 'https://api.anthropic.com/v1';
+
+export class AnthropicToolUseError extends Error {
+  constructor(message, code, body) {
+    super(message);
+    this.name = 'AnthropicToolUseError';
+    this.code = code || 'ANTHROPIC_ERR';
+    if (body) this.body = body;
+  }
+}
+
+// Convert a registry schema entry into Anthropic's `input_schema` shape.
+// Today the two are identical (both JSON Schema). We materialise this
+// helper anyway so future divergences (e.g. Anthropic-specific keys)
+// have a single place to land.
+export function toAnthropicTools(schemas) {
+  return (schemas || []).map((s) => ({
+    name: s.name,
+    description: s.description,
+    input_schema: s.parameters,
+  }));
+}
+
+export async function callOnce({
+  messages,
+  tools = [],
+  model,
+  apiKey,
+  system,
+  maxTokens = DEFAULT_MAX_TOKENS,
+  baseUrl,
+  fetchImpl,
+  signal,
+} = {}) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new AnthropicToolUseError('messages[] is required and non-empty', 'NO_MESSAGES');
+  }
+  if (!apiKey) {
+    throw new AnthropicToolUseError('apiKey is required', 'NO_API_KEY');
+  }
+  const url = `${(baseUrl || DEFAULT_BASE).replace(/\/$/, '')}/messages`;
+  const fetchFn = fetchImpl || globalThis.fetch;
+  const body = {
+    model: model || 'claude-opus-4-7',
+    max_tokens: maxTokens,
+    messages,
+  };
+  if (system && String(system).trim()) body.system = String(system);
+  if (tools && tools.length) body.tools = tools;
+
+  const res = await fetchFn(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': ANTHROPIC_VERSION,
+    },
+    body: JSON.stringify(body),
+    signal,
+  });
+  if (!res.ok) {
+    let raw = '';
+    try { raw = await res.text(); } catch { /* ignore */ }
+    throw new AnthropicToolUseError(`HTTP ${res.status}: ${raw.slice(0, 300)}`, 'HTTP_FAIL', raw);
+  }
+  const json = await res.json();
+  return parseResponse(json);
+}
+
+export function parseResponse(json) {
+  const content = Array.isArray(json?.content) ? json.content : [];
+  const textParts = [];
+  const calls = [];
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue;
+    if (block.type === 'text' && typeof block.text === 'string') {
+      textParts.push(block.text);
+    } else if (block.type === 'tool_use') {
+      if (!block.id || !block.name) continue;
+      calls.push({ id: block.id, name: block.name, input: block.input ?? {} });
+    }
+  }
+  const text = textParts.join('');
+  if (calls.length === 0) {
+    return { kind: 'final', text, raw: json };
+  }
+  return { kind: 'tool_calls', text, calls, assistantContent: content, raw: json };
+}
+
+// Anthropic accepts the agent_turn-native {role, content} shape
+// directly; no transformation needed. These helpers exist so the
+// agent-turn runner can call the same names across all adapters.
+export function normalizeHistory(turns) {
+  return Array.isArray(turns) ? [...turns] : [];
+}
+
+export function initialUserMessage(text) {
+  return { role: 'user', content: String(text) };
+}
+
+// Build the `messages` entries the runner appends to record the model's
+// own turn. Anthropic packs everything into one assistant message whose
+// content is the array of blocks the API returned, so we return that
+// inside a one-element array for shape parity with adapters that need
+// multiple entries (OpenAI).
+export function assistantTurnMessages(resp) {
+  return [{ role: 'assistant', content: resp.assistantContent }];
+}
+
+// Build the `messages` entries the runner appends after executing tools
+// so the next callOnce request has correctly-shaped tool_result blocks.
+// Anthropic groups all results inside a single user-role message; the
+// array wrapper exists for shape parity with adapters that emit one
+// tool-result message per call (OpenAI).
+//
+// `results` is an array aligned with the assistant turn's tool_calls:
+//   [{ id, content, isError? }]
+export function toolResultMessages(results) {
+  const content = (results || []).map((r) => ({
+    type: 'tool_result',
+    tool_use_id: r.id,
+    content: typeof r.content === 'string' ? r.content : JSON.stringify(r.content),
+    ...(r.isError ? { is_error: true } : {}),
+  }));
+  return [{ role: 'user', content }];
+}
+
+// Back-compat alias kept until external callers migrate.
+export function buildToolResultsMessage(results) {
+  return toolResultMessages(results)[0];
+}