wispy-cli 0.7.0 → 0.9.0

package/core/engine.mjs

@@ -19,6 +19,8 @@ import { ProviderRegistry } from "./providers.mjs";
 import { ToolRegistry } from "./tools.mjs";
 import { SessionManager } from "./session.mjs";
 import { MCPManager, ensureDefaultMcpConfig } from "./mcp.mjs";
+import { MemoryManager } from "./memory.mjs";
+import { SubAgentManager } from "./subagents.mjs";
 
 const MAX_TOOL_ROUNDS = 10;
 const MAX_CONTEXT_CHARS = 40_000;
@@ -30,6 +32,8 @@ export class WispyEngine {
     this.tools = new ToolRegistry();
     this.sessions = new SessionManager();
     this.mcpManager = new MCPManager(config.mcpConfigPath ?? MCP_CONFIG_PATH);
+    this.memory = new MemoryManager(WISPY_DIR);
+    this.subagents = new SubAgentManager(this, this.sessions);
     this._initialized = false;
     this._activeWorkstream = config.workstream
       ?? process.env.WISPY_WORKSTREAM
@@ -56,6 +60,9 @@ export class WispyEngine {
     // Register built-in tools
     this.tools.registerBuiltin();
 
+    // Register memory tools
+    this._registerMemoryTools();
+
     // Initialize MCP
     if (!opts.skipMcp) {
       await ensureDefaultMcpConfig(this.mcpManager.configPath);
@@ -209,6 +216,29 @@ export class WispyEngine {
         return this._toolSpawnAsyncAgent(args, messages, session);
       case "ralph_loop":
         return this._toolRalphLoop(args, messages, session);
+      case "memory_save":
+        return this._toolMemorySave(args);
+      case "memory_search":
+        return this._toolMemorySearch(args);
+      case "memory_list":
+        return this._toolMemoryList();
+      case "memory_get":
+        return this._toolMemoryGet(args);
+      case "memory_append":
+        return this._toolMemoryAppend(args);
+      case "memory_delete":
+        return this._toolMemoryDelete(args);
+      // Sub-agent tools (v0.9)
+      case "spawn_subagent":
+        return this._toolSpawnSubagent(args, opts);
+      case "list_subagents":
+        return this._toolListSubagents();
+      case "get_subagent_result":
+        return this._toolGetSubagentResult(args);
+      case "kill_subagent":
+        return this._toolKillSubagent(args);
+      case "steer_subagent":
+        return this._toolSteerSubagent(args);
       default:
         return this.tools.execute(name, args);
     }
@@ -421,6 +451,88 @@ export class WispyEngine {
     return { success: true, iterations: MAX_ITERATIONS, result: lastResult, verified: false, message: "Max iterations reached" };
   }
 
+  // ── Sub-agent tools (v0.9) ──────────────────────────────────────────────────
+
+  async _toolSpawnSubagent(args, parentOpts = {}) {
+    const agent = await this.subagents.spawn({
+      task: args.task,
+      label: args.label,
+      model: args.model ?? null,
+      timeout: args.timeout_seconds ?? 300,
+      workstream: this._activeWorkstream,
+      onNotify: parentOpts?.onSubagentNotify ?? null,
+    });
+
+    return {
+      success: true,
+      id: agent.id,
+      label: agent.label,
+      status: agent.status,
+      message: `Sub-agent '${agent.label}' spawned (id: ${agent.id}). Use get_subagent_result to check when done.`,
+    };
+  }
+
+  async _toolListSubagents() {
+    const inMemory = this.subagents.list();
+    const history = await this.subagents.listHistory(20);
+
+    // Merge: in-memory takes precedence
+    const inMemoryIds = new Set(inMemory.map(a => a.id));
+    const combined = [
+      ...inMemory.map(a => a.toJSON()),
+      ...history.filter(h => !inMemoryIds.has(h.id)),
+    ].slice(0, 30);
+
+    return {
+      success: true,
+      agents: combined.map(a => ({
+        id: a.id,
+        label: a.label,
+        status: a.status,
+        task: a.task?.slice(0, 80),
+        model: a.model,
+        createdAt: a.createdAt,
+        completedAt: a.completedAt,
+      })),
+      total: combined.length,
+    };
+  }
+
+  async _toolGetSubagentResult(args) {
+    const inMemory = this.subagents.get(args.id);
+    if (inMemory) {
+      return {
+        success: true,
+        ...inMemory.toJSON(),
+        result_preview: inMemory.result?.slice(0, 500),
+      };
+    }
+
+    // Try disk
+    const disk = await this.subagents.loadFromDisk(args.id);
+    if (disk) {
+      return { success: true, ...disk, result_preview: disk.result?.slice(0, 500) };
+    }
+
+    return { success: false, error: `Sub-agent not found: ${args.id}` };
+  }
+
+  _toolKillSubagent(args) {
+    const agent = this.subagents.get(args.id);
+    if (!agent) return { success: false, error: `Sub-agent not found: ${args.id}` };
+    this.subagents.kill(args.id);
+    return { success: true, id: args.id, message: `Sub-agent '${agent.label}' killed.` };
+  }
+
+  _toolSteerSubagent(args) {
+    try {
+      this.subagents.steer(args.id, args.message);
+      return { success: true, id: args.id, message: `Guidance sent to sub-agent.` };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
   // ── Context optimization ─────────────────────────────────────────────────────
 
   _optimizeContext(messages, maxTokens = 30_000) {
@@ -476,10 +588,18 @@ export class WispyEngine {
       parts.push("## Project Context (WISPY.md)", wispyMd, "");
     }
 
-    // Load memories
-    const memories = await this._loadMemories();
-    if (memories) {
-      parts.push("## Persistent Memory", memories, "");
+    // Load memories via MemoryManager
+    try {
+      const memories = await this.memory.getContextForPrompt(lastUserMessage);
+      if (memories) {
+        parts.push("## Persistent Memory", memories, "");
+      }
+    } catch {
+      // Fallback to old method
+      const memories = await this._loadMemories();
+      if (memories) {
+        parts.push("## Persistent Memory", memories, "");
+      }
     }
 
     return parts.join("\n");
@@ -512,6 +632,154 @@ export class WispyEngine {
     return sections.length ? sections.join("\n\n") : null;
   }
 
+  // ── Memory tools ─────────────────────────────────────────────────────────────
+
+  _registerMemoryTools() {
+    const memoryTools = [
+      {
+        name: "memory_save",
+        description: "Save important information to persistent memory. Use this to remember facts, preferences, or information for future conversations.",
+        parameters: {
+          type: "object",
+          properties: {
+            key: { type: "string", description: "Memory key/filename (e.g., 'user', 'MEMORY', 'projects/myapp', 'daily/2025-01-01')" },
+            content: { type: "string", description: "Content to save" },
+            title: { type: "string", description: "Optional title for the memory file" },
+          },
+          required: ["key", "content"],
+        },
+      },
+      {
+        name: "memory_append",
+        description: "Append a new entry to an existing memory file without overwriting it.",
+        parameters: {
+          type: "object",
+          properties: {
+            key: { type: "string", description: "Memory key/filename" },
+            content: { type: "string", description: "Content to append" },
+          },
+          required: ["key", "content"],
+        },
+      },
+      {
+        name: "memory_search",
+        description: "Search across all memory files for information. Returns matching snippets.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query" },
+          },
+          required: ["query"],
+        },
+      },
+      {
+        name: "memory_list",
+        description: "List all memory files with their keys and previews.",
+        parameters: { type: "object", properties: {}, required: [] },
+      },
+      {
+        name: "memory_get",
+        description: "Get the full content of a specific memory file.",
+        parameters: {
+          type: "object",
+          properties: {
+            key: { type: "string", description: "Memory key to retrieve" },
+          },
+          required: ["key"],
+        },
+      },
+      {
+        name: "memory_delete",
+        description: "Delete a memory file.",
+        parameters: {
+          type: "object",
+          properties: {
+            key: { type: "string", description: "Memory key to delete" },
+          },
+          required: ["key"],
+        },
+      },
+    ];
+
+    for (const tool of memoryTools) {
+      this.tools._definitions.set(tool.name, tool);
+    }
+  }
+
+  async _toolMemorySave(args) {
+    try {
+      const result = await this.memory.save(args.key, args.content, { title: args.title });
+      return { success: true, key: args.key, message: `Saved to memory: ${args.key}` };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolMemoryAppend(args) {
+    try {
+      const result = await this.memory.append(args.key, args.content);
+      return { success: true, key: args.key, message: `Appended to memory: ${args.key}` };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolMemorySearch(args) {
+    try {
+      const results = await this.memory.search(args.query, { limit: 10 });
+      if (results.length === 0) {
+        return { success: true, results: [], message: "No memories found matching your query." };
+      }
+      return {
+        success: true,
+        results: results.map(r => ({
+          key: r.key,
+          matchCount: r.matchCount,
+          snippets: r.snippets.map(s => `[line ${s.lineNumber}] ${s.text}`),
+        })),
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolMemoryList() {
+    try {
+      const keys = await this.memory.list();
+      return {
+        success: true,
+        memories: keys.map(k => ({
+          key: k.key,
+          preview: k.preview,
+          size: k.size,
+          updatedAt: k.updatedAt,
+        })),
+        total: keys.length,
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolMemoryGet(args) {
+    try {
+      const mem = await this.memory.get(args.key);
+      if (!mem) return { success: false, error: `Memory "${args.key}" not found` };
+      return { success: true, key: args.key, content: mem.content };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolMemoryDelete(args) {
+    try {
+      const result = await this.memory.delete(args.key);
+      return result;
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
   // ── Cleanup ──────────────────────────────────────────────────────────────────
 
   destroy() {

package/core/index.mjs

@@ -10,3 +10,6 @@ export { ProviderRegistry } from "./providers.mjs";
 export { ToolRegistry } from "./tools.mjs";
 export { MCPClient, MCPManager, ensureDefaultMcpConfig } from "./mcp.mjs";
 export { loadConfig, saveConfig, detectProvider, PROVIDERS, WISPY_DIR, MCP_CONFIG_PATH, SESSIONS_DIR, CONVERSATIONS_DIR, MEMORY_DIR } from "./config.mjs";
+export { MemoryManager } from "./memory.mjs";
+export { CronManager } from "./cron.mjs";
+export { SubAgentManager, SubAgent } from "./subagents.mjs";

package/core/memory.mjs

@@ -0,0 +1,275 @@
+/**
+ * core/memory.mjs — Long-term memory system for Wispy
+ *
+ * File-based memory stored in ~/.wispy/memory/
+ * - MEMORY.md — main persistent memory
+ * - daily/YYYY-MM-DD.md — daily logs
+ * - projects/<name>.md — project-specific memory
+ * - user.md — user preferences/info
+ */
+
+import path from "node:path";
+import { readFile, writeFile, appendFile, mkdir, readdir, unlink, stat } from "node:fs/promises";
+
+const MAX_SEARCH_RESULTS = 20;
+const MAX_SNIPPET_CHARS = 200;
+
+export class MemoryManager {
+  constructor(wispyDir) {
+    this.memoryDir = path.join(wispyDir, "memory");
+  }
+
+  /**
+   * Ensure memory directory exists
+   */
+  async _ensureDir(subDir = "") {
+    const dir = subDir ? path.join(this.memoryDir, subDir) : this.memoryDir;
+    await mkdir(dir, { recursive: true });
+    return dir;
+  }
+
+  /**
+   * Resolve key to file path
+   * Keys can be: "user", "MEMORY", "daily/2025-01-01", "projects/myproject"
+   */
+  _keyToPath(key) {
+    // Normalize: strip .md extension if present
+    const clean = key.replace(/\.md$/, "");
+    return path.join(this.memoryDir, `${clean}.md`);
+  }
+
+  /**
+   * Save (overwrite) a memory file
+   */
+  async save(key, content, metadata = {}) {
+    await this._ensureDir();
+
+    // Ensure subdirectory exists
+    const filePath = this._keyToPath(key);
+    const dir = path.dirname(filePath);
+    await mkdir(dir, { recursive: true });
+
+    const ts = new Date().toISOString();
+    const header = metadata.title
+      ? `# ${metadata.title}\n\n_Last updated: ${ts}_\n\n`
+      : `_Last updated: ${ts}_\n\n`;
+
+    await writeFile(filePath, header + content, "utf8");
+    return { key, path: filePath };
+  }
+
+  /**
+   * Append to an existing memory file (creates if doesn't exist)
+   */
+  async append(key, content) {
+    await this._ensureDir();
+    const filePath = this._keyToPath(key);
+    const dir = path.dirname(filePath);
+    await mkdir(dir, { recursive: true });
+
+    const ts = new Date().toISOString().slice(0, 16);
+    await appendFile(filePath, `\n- [${ts}] ${content}\n`, "utf8");
+    return { key, path: filePath };
+  }
+
+  /**
+   * Get a specific memory file
+   */
+  async get(key) {
+    const filePath = this._keyToPath(key);
+    try {
+      const content = await readFile(filePath, "utf8");
+      return { key, content, path: filePath };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * List all memory keys (relative paths without .md)
+   */
+  async list() {
+    await this._ensureDir();
+    const keys = [];
+    await this._collectKeys(this.memoryDir, this.memoryDir, keys);
+    return keys;
+  }
+
+  async _collectKeys(baseDir, dir, keys) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this._collectKeys(baseDir, fullPath, keys);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const rel = path.relative(baseDir, fullPath).replace(/\.md$/, "");
+        const fileStat = await stat(fullPath).catch(() => null);
+        const content = await readFile(fullPath, "utf8").catch(() => "");
+        keys.push({
+          key: rel,
+          path: fullPath,
+          size: content.trim().length,
+          preview: content.trim().slice(0, 80).replace(/\n/g, " "),
+          updatedAt: fileStat?.mtime?.toISOString() ?? null,
+        });
+      }
+    }
+  }
+
+  /**
+   * Full-text search across all memory files
+   * Returns matching snippets with file path and line numbers
+   */
+  async search(query, opts = {}) {
+    if (!query?.trim()) return [];
+    await this._ensureDir();
+
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const results = [];
+    await this._searchDir(this.memoryDir, this.memoryDir, terms, results);
+
+    // Sort by relevance (number of term matches)
+    results.sort((a, b) => b.matchCount - a.matchCount);
+
+    return results.slice(0, opts.limit ?? MAX_SEARCH_RESULTS);
+  }
+
+  async _searchDir(baseDir, dir, terms, results) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this._searchDir(baseDir, fullPath, terms, results);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const content = await readFile(fullPath, "utf8").catch(() => "");
+        const lines = content.split("\n");
+        const key = path.relative(baseDir, fullPath).replace(/\.md$/, "");
+
+        let matchCount = 0;
+        const matchingLines = [];
+
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const lower = line.toLowerCase();
+          const lineMatches = terms.filter(t => lower.includes(t)).length;
+          if (lineMatches > 0) {
+            matchCount += lineMatches;
+            matchingLines.push({
+              lineNumber: i + 1,
+              text: line.slice(0, MAX_SNIPPET_CHARS),
+            });
+          }
+        }
+
+        if (matchCount > 0) {
+          results.push({
+            key,
+            path: fullPath,
+            matchCount,
+            snippets: matchingLines.slice(0, 5),
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Delete a memory file
+   */
+  async delete(key) {
+    const filePath = this._keyToPath(key);
+    try {
+      await unlink(filePath);
+      return { success: true, key };
+    } catch {
+      return { success: false, key, error: "Not found" };
+    }
+  }
+
+  /**
+   * Auto-capture important info from conversation messages
+   * Uses AI to extract key facts (called from engine)
+   */
+  async autoCapture(messages, aiCall) {
+    // Extract user messages for analysis
+    const recentUserMsgs = messages
+      .filter(m => m.role === "user")
+      .slice(-5)
+      .map(m => m.content)
+      .join("\n\n");
+
+    if (!recentUserMsgs.trim()) return null;
+
+    try {
+      const prompt = `Extract any important facts, preferences, or information from this conversation that should be remembered for future sessions. Be concise. If nothing important, reply "nothing".
+
+Conversation:
+${recentUserMsgs.slice(0, 2000)}`;
+
+      const result = await aiCall(prompt);
+      if (result && result.toLowerCase() !== "nothing") {
+        const today = new Date().toISOString().slice(0, 10);
+        await this.append(`daily/${today}`, result.slice(0, 500));
+        return result;
+      }
+    } catch {
+      // Silently fail — auto-capture is optional
+    }
+    return null;
+  }
+
+  /**
+   * Get today's daily log key
+   */
+  getDailyKey() {
+    return `daily/${new Date().toISOString().slice(0, 10)}`;
+  }
+
+  /**
+   * Get formatted memory context for injection into system prompt
+   */
+  async getContextForPrompt(query = "", maxChars = 3000) {
+    try {
+      const results = [];
+
+      // Always include MEMORY.md if it exists
+      const mainMemory = await this.get("MEMORY");
+      if (mainMemory?.content?.trim()) {
+        results.push(`### MEMORY.md\n${mainMemory.content.trim()}`);
+      }
+
+      // Include user.md if it exists
+      const userMemory = await this.get("user");
+      if (userMemory?.content?.trim()) {
+        results.push(`### user.md\n${userMemory.content.trim()}`);
+      }
+
+      // Search for relevant memories if query provided
+      if (query.trim()) {
+        const searchResults = await this.search(query, { limit: 5 });
+        for (const r of searchResults) {
+          if (r.key === "MEMORY" || r.key === "user") continue; // already included
+          const mem = await this.get(r.key);
+          if (mem?.content?.trim()) {
+            results.push(`### ${r.key}.md\n${mem.content.trim()}`);
+          }
+        }
+      }
+
+      const joined = results.join("\n\n");
+      return joined.slice(0, maxChars) || null;
+    } catch {
+      return null;
+    }
+  }
+}