wispy-cli 0.7.0 → 0.8.0

package/bin/wispy.mjs

@@ -22,6 +22,150 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const args = process.argv.slice(2);
 
+// ── cron sub-command ──────────────────────────────────────────────────────────
+if (args[0] === "cron") {
+  const { WispyEngine, CronManager, WISPY_DIR } = await import(
+    path.join(__dirname, "..", "core", "index.mjs")
+  );
+  const { createInterface } = await import("node:readline");
+
+  const sub = args[1];
+
+  // Init engine for cron commands that need it
+  const engine = new WispyEngine();
+  await engine.init({ skipMcp: true });
+  const cron = new CronManager(WISPY_DIR, engine);
+  await cron.init();
+
+  if (!sub || sub === "list") {
+    const jobs = cron.list();
+    if (jobs.length === 0) {
+      console.log("No cron jobs configured. Use: wispy cron add");
+    } else {
+      console.log(`\n🕐 Cron Jobs (${jobs.length}):\n`);
+      for (const j of jobs) {
+        const status = j.enabled ? "✅" : "⏸️ ";
+        const schedStr = j.schedule.kind === "cron" ? j.schedule.expr
+          : j.schedule.kind === "every" ? `every ${j.schedule.ms / 60000}min`
+          : `at ${j.schedule.time}`;
+        console.log(`  ${status} ${j.id.slice(0, 8)} ${j.name.padEnd(20)} ${schedStr}`);
+        console.log(`       Task: ${j.task.slice(0, 60)}${j.task.length > 60 ? "..." : ""}`);
+        if (j.channel) console.log(`       Channel: ${j.channel}`);
+        if (j.nextRun) console.log(`       Next run: ${new Date(j.nextRun).toLocaleString()}`);
+        console.log("");
+      }
+    }
+    process.exit(0);
+  }
+
+  if (sub === "add") {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+
+    console.log("\n🕐 Add Cron Job\n");
+    const name = await ask("  Job name: ");
+    const task = await ask("  Task (what to do): ");
+    const schedKind = await ask("  Schedule type (cron/every/at) [cron]: ") || "cron";
+    let schedule = { kind: schedKind };
+
+    if (schedKind === "cron") {
+      const expr = await ask("  Cron expression (e.g. '0 9 * * *'): ");
+      const tz = await ask("  Timezone [Asia/Seoul]: ") || "Asia/Seoul";
+      schedule = { kind: "cron", expr: expr.trim(), tz: tz.trim() };
+    } else if (schedKind === "every") {
+      const mins = await ask("  Interval in minutes: ");
+      schedule = { kind: "every", ms: parseFloat(mins) * 60_000 };
+    } else if (schedKind === "at") {
+      const time = await ask("  Run at (ISO datetime, e.g. 2025-01-01T09:00:00): ");
+      schedule = { kind: "at", time: time.trim() };
+    }
+
+    const channel = await ask("  Channel (e.g. telegram:12345, or leave empty): ");
+    rl.close();
+
+    const job = await cron.add({
+      name: name.trim(),
+      task: task.trim(),
+      schedule,
+      channel: channel.trim() || null,
+      enabled: true,
+    });
+
+    console.log(`\n✅ Job created: ${job.id}`);
+    console.log(`   Next run: ${job.nextRun ? new Date(job.nextRun).toLocaleString() : "N/A"}`);
+    process.exit(0);
+  }
+
+  if (sub === "remove" && args[2]) {
+    const id = args[2];
+    // Support partial ID match
+    const all = cron.list();
+    const match = all.find(j => j.id === id || j.id.startsWith(id));
+    if (!match) {
+      console.error(`Job not found: ${id}`);
+      process.exit(1);
+    }
+    await cron.remove(match.id);
+    console.log(`✅ Removed job: ${match.name} (${match.id})`);
+    process.exit(0);
+  }
+
+  if (sub === "run" && args[2]) {
+    const id = args[2];
+    const all = cron.list();
+    const match = all.find(j => j.id === id || j.id.startsWith(id));
+    if (!match) {
+      console.error(`Job not found: ${id}`);
+      process.exit(1);
+    }
+    console.log(`🌿 Running job: ${match.name}...`);
+    const result = await cron.runNow(match.id);
+    console.log(result.output ?? result.error);
+    process.exit(0);
+  }
+
+  if (sub === "history" && args[2]) {
+    const id = args[2];
+    const all = cron.list();
+    const match = all.find(j => j.id === id || j.id.startsWith(id));
+    if (!match) {
+      console.error(`Job not found: ${id}`);
+      process.exit(1);
+    }
+    const history = await cron.getHistory(match.id);
+    console.log(`\n📋 History for "${match.name}" (last ${history.length} runs):\n`);
+    for (const h of history) {
+      const icon = h.status === "success" ? "✅" : "❌";
+      console.log(`  ${icon} ${new Date(h.startedAt).toLocaleString()}`);
+      console.log(`     ${h.output?.slice(0, 100) ?? h.error ?? ""}`);
+      console.log("");
+    }
+    if (history.length === 0) console.log("  No runs yet.");
+    process.exit(0);
+  }
+
+  if (sub === "start") {
+    console.log("🌿 Starting cron scheduler... (Ctrl+C to stop)\n");
+    cron.start();
+    process.on("SIGINT", () => { cron.stop(); process.exit(0); });
+    process.on("SIGTERM", () => { cron.stop(); process.exit(0); });
+    setInterval(() => {}, 60_000);
+    await new Promise(() => {});
+  }
+
+  console.log(`
+🕐 Wispy Cron Commands:
+
+  wispy cron list              — list all jobs
+  wispy cron add               — interactive job creation
+  wispy cron remove <id>       — delete a job
+  wispy cron run <id>          — trigger immediately
+  wispy cron history <id>      — show past runs
+  wispy cron start             — start scheduler (foreground)
+`);
+  process.exit(0);
+}
+
 // ── channel sub-command ───────────────────────────────────────────────────────
 if (args[0] === "channel") {
   const { channelSetup, channelList, channelTest } = await import(
@@ -77,9 +221,35 @@ if (serveMode || telegramMode || discordMode || slackMode) {
 
   await manager.startAll(only);
 
+  // Start cron scheduler if in serve mode
+  let cronManager = null;
+  if (serveMode) {
+    try {
+      const { WispyEngine, CronManager, WISPY_DIR } = await import(
+        path.join(__dirname, "..", "core", "index.mjs")
+      );
+      const engine = new WispyEngine();
+      await engine.init({ skipMcp: true });
+      cronManager = new CronManager(WISPY_DIR, engine);
+      await cronManager.init();
+      cronManager.start();
+      console.error("[wispy] Cron scheduler started");
+    } catch (err) {
+      console.error("[wispy] Failed to start cron scheduler:", err.message);
+    }
+  }
+
   // Keep process alive and stop cleanly on Ctrl+C
-  process.on("SIGINT",  async () => { await manager.stopAll(); process.exit(0); });
-  process.on("SIGTERM", async () => { await manager.stopAll(); process.exit(0); });
+  process.on("SIGINT",  async () => {
+    if (cronManager) cronManager.stop();
+    await manager.stopAll();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    if (cronManager) cronManager.stop();
+    await manager.stopAll();
+    process.exit(0);
+  });
 
   // Prevent Node from exiting
   setInterval(() => {}, 60_000);

package/core/cron.mjs

@@ -0,0 +1,346 @@
+/**
+ * core/cron.mjs — Task scheduler for Wispy
+ *
+ * Manages scheduled jobs stored in ~/.wispy/cron/jobs.json
+ * History stored in ~/.wispy/cron/history/<jobId>.json
+ *
+ * Schedule types:
+ * - cron: standard 5-field cron expression (uses cron-parser)
+ * - every: interval in ms (e.g., 1800000 for 30 minutes)
+ * - at: one-shot at specific ISO datetime
+ */
+
+import path from "node:path";
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+
+const MAX_HISTORY_PER_JOB = 50;
+const TICK_INTERVAL_MS = 30_000; // Check every 30 seconds
+
+export class CronManager {
+  constructor(wispyDir, engine) {
+    this.cronDir = path.join(wispyDir, "cron");
+    this.jobsFile = path.join(this.cronDir, "jobs.json");
+    this.historyDir = path.join(this.cronDir, "history");
+    this.engine = engine;
+    this._jobs = [];
+    this._timer = null;
+    this._running = false;
+    this._cronParser = null; // lazy-loaded
+  }
+
+  /**
+   * Initialize: load jobs from disk
+   */
+  async init() {
+    await mkdir(this.cronDir, { recursive: true });
+    await mkdir(this.historyDir, { recursive: true });
+    await this._loadJobs();
+    return this;
+  }
+
+  /**
+   * Lazy-load cron-parser
+   */
+  async _getCronParser() {
+    if (!this._cronParser) {
+      try {
+        const mod = await import("cron-parser");
+        // v5 API: CronExpressionParser.parse(expr, { tz })
+        // v4 API: parseExpression(expr, { tz })
+        this._cronParser = mod.CronExpressionParser ?? mod.default ?? mod;
+      } catch {
+        this._cronParser = null;
+      }
+    }
+    return this._cronParser;
+  }
+
+  // ── Job Management ────────────────────────────────────────────────────────
+
+  async add(jobDef) {
+    const { randomUUID } = await import("node:crypto");
+    const job = {
+      id: jobDef.id ?? randomUUID(),
+      name: jobDef.name ?? "unnamed",
+      schedule: jobDef.schedule,
+      task: jobDef.task,
+      channel: jobDef.channel ?? null,
+      enabled: jobDef.enabled !== false,
+      createdAt: new Date().toISOString(),
+      lastRun: null,
+      nextRun: null,
+    };
+
+    // Compute next run time
+    job.nextRun = await this._computeNextRun(job);
+
+    this._jobs.push(job);
+    await this._saveJobs();
+    return job;
+  }
+
+  async remove(id) {
+    const before = this._jobs.length;
+    this._jobs = this._jobs.filter(j => j.id !== id);
+    if (this._jobs.length < before) {
+      await this._saveJobs();
+      return true;
+    }
+    return false;
+  }
+
+  async update(id, patch) {
+    const idx = this._jobs.findIndex(j => j.id === id);
+    if (idx === -1) return null;
+    this._jobs[idx] = { ...this._jobs[idx], ...patch };
+    // Recompute next run if schedule changed
+    if (patch.schedule) {
+      this._jobs[idx].nextRun = await this._computeNextRun(this._jobs[idx]);
+    }
+    await this._saveJobs();
+    return this._jobs[idx];
+  }
+
+  list() {
+    return [...this._jobs];
+  }
+
+  get(id) {
+    return this._jobs.find(j => j.id === id) ?? null;
+  }
+
+  // ── Scheduler ─────────────────────────────────────────────────────────────
+
+  /**
+   * Start the scheduler loop
+   */
+  start() {
+    if (this._running) return;
+    this._running = true;
+    this._tick();
+    this._timer = setInterval(() => this._tick(), TICK_INTERVAL_MS);
+    console.error(`[wispy-cron] Scheduler started (checking every ${TICK_INTERVAL_MS / 1000}s)`);
+  }
+
+  /**
+   * Stop the scheduler
+   */
+  stop() {
+    this._running = false;
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    console.error("[wispy-cron] Scheduler stopped");
+  }
+
+  /**
+   * Manually trigger a job right now
+   */
+  async runNow(id) {
+    const job = this.get(id);
+    if (!job) return { success: false, error: "Job not found" };
+    return this._executeJob(job);
+  }
+
+  // ── History ───────────────────────────────────────────────────────────────
+
+  async getHistory(id, limit = 20) {
+    const histFile = path.join(this.historyDir, `${id}.json`);
+    try {
+      const raw = await readFile(histFile, "utf8");
+      const history = JSON.parse(raw);
+      return history.slice(-limit);
+    } catch {
+      return [];
+    }
+  }
+
+  // ── Internal ──────────────────────────────────────────────────────────────
+
+  async _tick() {
+    const now = Date.now();
+    for (const job of this._jobs) {
+      if (!job.enabled) continue;
+      if (!job.nextRun) continue;
+
+      const nextRunMs = new Date(job.nextRun).getTime();
+      if (now >= nextRunMs) {
+        // Execute and update
+        this._executeJob(job).catch(err => {
+          console.error(`[wispy-cron] Job "${job.name}" error:`, err.message);
+        });
+      }
+    }
+  }
+
+  async _executeJob(job) {
+    const startedAt = new Date().toISOString();
+    let output = "";
+    let status = "success";
+    let error = null;
+
+    try {
+      // Run via engine
+      const response = await this.engine.processMessage(null, job.task, {
+        noSave: true,
+        systemPrompt: `You are Wispy 🌿, running a scheduled task. Task name: "${job.name}". Execute the task and provide a concise summary. Always end with 🌿.`,
+      });
+      output = response.content;
+
+      // Deliver to channel if configured
+      if (job.channel) {
+        await this._deliverToChannel(job.channel, job.name, output);
+      }
+    } catch (err) {
+      status = "failed";
+      error = err.message;
+      output = `Error: ${err.message}`;
+    }
+
+    const runRecord = {
+      jobId: job.id,
+      startedAt,
+      completedAt: new Date().toISOString(),
+      status,
+      output: output.slice(0, 2000),
+      error,
+    };
+
+    // Save to history
+    await this._appendHistory(job.id, runRecord);
+
+    // Update job metadata
+    const idx = this._jobs.findIndex(j => j.id === job.id);
+    if (idx !== -1) {
+      this._jobs[idx].lastRun = startedAt;
+      this._jobs[idx].nextRun = await this._computeNextRun(this._jobs[idx]);
+      await this._saveJobs();
+    }
+
+    return { success: status === "success", output, error };
+  }
+
+  async _deliverToChannel(channel, jobName, output) {
+    const [type, id] = channel.split(":");
+    const message = `🌿 **${jobName}**\n\n${output}`;
+
+    try {
+      switch (type) {
+        case "telegram": {
+          const cfg = await this._loadChannelConfig("telegram");
+          if (!cfg?.token) return;
+          const url = `https://api.telegram.org/bot${cfg.token}/sendMessage`;
+          await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ chat_id: id, text: message.slice(0, 4096) }),
+          });
+          break;
+        }
+        case "discord": {
+          // Discord webhook format
+          const cfg = await this._loadChannelConfig("discord");
+          if (!cfg?.webhookUrl) return;
+          await fetch(cfg.webhookUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ content: message.slice(0, 2000) }),
+          });
+          break;
+        }
+        default:
+          console.error(`[wispy-cron] Unknown channel type: ${type}`);
+      }
+    } catch (err) {
+      console.error(`[wispy-cron] Channel delivery failed: ${err.message}`);
+    }
+  }
+
+  async _loadChannelConfig(name) {
+    try {
+      const channelsPath = path.join(path.dirname(this.cronDir), "channels.json");
+      const raw = await readFile(channelsPath, "utf8");
+      const cfg = JSON.parse(raw);
+      return cfg[name] ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  async _computeNextRun(job) {
+    const schedule = job.schedule;
+    if (!schedule) return null;
+
+    const now = new Date();
+
+    try {
+      if (schedule.kind === "at") {
+        const t = new Date(schedule.time);
+        // One-shot: if in the future, return it; if past, return null (disable)
+        return t > now ? t.toISOString() : null;
+      }
+
+      if (schedule.kind === "every") {
+        const intervalMs = schedule.ms ?? schedule.interval ?? 60_000;
+        // If lastRun exists, add interval to it; otherwise start from now
+        const base = job.lastRun ? new Date(job.lastRun).getTime() : Date.now();
+        return new Date(base + intervalMs).toISOString();
+      }
+
+      if (schedule.kind === "cron") {
+        const parser = await this._getCronParser();
+        if (!parser) {
+          console.error("[wispy-cron] cron-parser not available, skipping cron schedule");
+          return null;
+        }
+
+        const tz = schedule.tz ?? "UTC";
+        let interval;
+        // Support both v4 (parseExpression) and v5 (CronExpressionParser.parse) APIs
+        if (typeof parser.parse === "function") {
+          // v5: CronExpressionParser.parse(expr, options)
+          interval = parser.parse(schedule.expr, { currentDate: now, tz });
+        } else if (typeof parser.parseExpression === "function") {
+          // v4: module.parseExpression(expr, options)
+          interval = parser.parseExpression(schedule.expr, { currentDate: now, tz });
+        } else {
+          console.error("[wispy-cron] cron-parser API not recognized");
+          return null;
+        }
+        return interval.next().toISOString();
+      }
+    } catch (err) {
+      console.error(`[wispy-cron] Failed to compute next run: ${err.message}`);
+    }
+
+    return null;
+  }
+
+  async _appendHistory(jobId, record) {
+    const histFile = path.join(this.historyDir, `${jobId}.json`);
+    let history = [];
+    try {
+      history = JSON.parse(await readFile(histFile, "utf8"));
+    } catch {}
+    history.push(record);
+    if (history.length > MAX_HISTORY_PER_JOB) {
+      history = history.slice(-MAX_HISTORY_PER_JOB);
+    }
+    await writeFile(histFile, JSON.stringify(history, null, 2) + "\n", "utf8");
+  }
+
+  async _loadJobs() {
+    try {
+      const raw = await readFile(this.jobsFile, "utf8");
+      this._jobs = JSON.parse(raw);
+    } catch {
+      this._jobs = [];
+    }
+  }
+
+  async _saveJobs() {
+    await mkdir(this.cronDir, { recursive: true });
+    await writeFile(this.jobsFile, JSON.stringify(this._jobs, null, 2) + "\n", "utf8");
+  }
+}

package/core/engine.mjs

@@ -19,6 +19,7 @@ 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";
 
 const MAX_TOOL_ROUNDS = 10;
 const MAX_CONTEXT_CHARS = 40_000;
@@ -30,6 +31,7 @@ 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._initialized = false;
     this._activeWorkstream = config.workstream
       ?? process.env.WISPY_WORKSTREAM
@@ -56,6 +58,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 +214,18 @@ 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);
       default:
         return this.tools.execute(name, args);
     }
@@ -476,10 +493,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 +537,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,5 @@ 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";

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;
+    }
+  }
+}

package/lib/wispy-repl.mjs

@@ -25,6 +25,7 @@ import {
   WISPY_DIR,
   CONVERSATIONS_DIR,
   MEMORY_DIR,
+  MemoryManager,
 } from "../core/index.mjs";
 
 // ---------------------------------------------------------------------------
@@ -325,6 +326,10 @@ ${bold("Wispy Commands:")}
   ${cyan("/skills")}            List installed skills
   ${cyan("/sessions")}          List sessions
   ${cyan("/mcp")} [list|connect|disconnect|config|reload]  MCP management
+  ${cyan("/remember")} <text>   Save text to main memory (MEMORY.md)
+  ${cyan("/forget")} <key>      Delete a memory file
+  ${cyan("/memories")}          List all memory files
+  ${cyan("/recall")} <query>    Search memories
   ${cyan("/quit")} or ${cyan("/exit")}    Exit
 `);
     return true;
@@ -555,6 +560,60 @@ ${bold("Wispy Commands:")}
     return true;
   }
 
+  // ── Memory commands ──────────────────────────────────────────────────────────
+
+  if (cmd === "/remember") {
+    const text = parts.slice(1).join(" ");
+    if (!text) { console.log(yellow("Usage: /remember <text>")); return true; }
+    await engine.memory.append("MEMORY", text);
+    console.log(green("✅ Saved to MEMORY.md"));
+    return true;
+  }
+
+  if (cmd === "/forget") {
+    const key = parts[1];
+    if (!key) { console.log(yellow("Usage: /forget <key>")); return true; }
+    const result = await engine.memory.delete(key);
+    if (result.success) {
+      console.log(green(`🗑️  Deleted memory: ${key}`));
+    } else {
+      console.log(red(`Memory "${key}" not found.`));
+    }
+    return true;
+  }
+
+  if (cmd === "/memories") {
+    const keys = await engine.memory.list();
+    if (keys.length === 0) {
+      console.log(dim("No memories stored yet. Use /remember <text> or ask wispy to remember things."));
+    } else {
+      console.log(bold(`\n🧠 Memories (${keys.length}):\n`));
+      for (const k of keys) {
+        console.log(`  ${cyan(k.key.padEnd(30))} ${dim(k.preview ?? "")}`);
+      }
+    }
+    return true;
+  }
+
+  if (cmd === "/recall") {
+    const query = parts.slice(1).join(" ");
+    if (!query) { console.log(yellow("Usage: /recall <query>")); return true; }
+    const results = await engine.memory.search(query);
+    if (results.length === 0) {
+      console.log(dim(`No memories found for: "${query}"`));
+    } else {
+      console.log(bold(`\n🔍 Memory search: "${query}"\n`));
+      for (const r of results) {
+        console.log(`  ${cyan(r.key)} ${dim(`(${r.matchCount} matches)`)}`);
+        for (const s of r.snippets.slice(0, 3)) {
+          console.log(`    ${dim(`L${s.lineNumber}:`)} ${s.text.slice(0, 100)}`);
+        }
+        console.log("");
+      }
+    }
+    return true;
+  }
+
   if (cmd === "/quit" || cmd === "/exit") {
     console.log(dim(`🌿 Bye! (${engine.providers.formatCost()})`));
     engine.destroy();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wispy-cli",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "🌿 Wispy — AI workspace assistant with multi-agent orchestration and multi-channel bot support",
   "license": "Apache-2.0",
   "author": "Minseo & Poropo",
@@ -44,15 +44,17 @@
     "test": "node --test test/basic.test.mjs"
   },
   "dependencies": {
+    "cron-parser": "^5.5.0",
     "ink": "^5.2.1",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
-    "react": "^18.3.1"
+    "react": "^18.3.1",
+    "uuid": "^13.0.0"
   },
   "peerDependencies": {
-    "grammy": ">=1.0.0",
+    "@slack/bolt": ">=3.0.0",
     "discord.js": ">=14.0.0",
-    "@slack/bolt": ">=3.0.0"
+    "grammy": ">=1.0.0"
   },
   "peerDependenciesMeta": {
     "grammy": {