wispy-cli 1.2.3 → 1.4.0

package/bin/wispy.mjs

@@ -156,6 +156,135 @@ if (args[0] === "disconnect") {
   process.exit(0);
 }
 
+// ── sync sub-command ──────────────────────────────────────────────────────────
+if (args[0] === "sync") {
+  const { SyncManager } = await import(
+    path.join(__dirname, "..", "core", "sync.mjs")
+  );
+
+  const sub = args[1]; // push | pull | status | auto | (undefined = bidirectional)
+
+  const green  = (s) => `\x1b[32m${s}\x1b[0m`;
+  const red    = (s) => `\x1b[31m${s}\x1b[0m`;
+  const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+  const cyan   = (s) => `\x1b[36m${s}\x1b[0m`;
+  const bold   = (s) => `\x1b[1m${s}\x1b[0m`;
+  const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
+
+  // Parse flags
+  const strategyIdx = args.indexOf("--strategy");
+  const strategy = strategyIdx !== -1 ? args[strategyIdx + 1] : null;
+  const memoryOnly   = args.includes("--memory-only");
+  const sessionsOnly = args.includes("--sessions-only");
+  const remoteUrlIdx = args.indexOf("--remote");
+  const remoteUrlArg = remoteUrlIdx !== -1 ? args[remoteUrlIdx + 1] : null;
+  const tokenIdx = args.indexOf("--token");
+  const tokenArg = tokenIdx !== -1 ? args[tokenIdx + 1] : null;
+
+  // Load config (or use overrides)
+  const cfg = await SyncManager.loadConfig();
+  const remoteUrl = remoteUrlArg ?? cfg.remoteUrl;
+  const token     = tokenArg ?? cfg.token;
+
+  // ── auto enable/disable ──
+  if (sub === "auto") {
+    const enable  = !args.includes("--off");
+    const disable = args.includes("--off");
+    if (disable) {
+      await SyncManager.disableAuto();
+      console.log(`\n${yellow("⏸")}  Auto-sync ${bold("disabled")}.\n`);
+    } else if (!remoteUrl) {
+      console.log(`\n${red("✗")} No remote URL configured.`);
+      console.log(dim(`   Use: wispy sync auto --remote https://vps.com:18790 --token <token>\n`));
+      process.exit(1);
+    } else {
+      await SyncManager.enableAuto(remoteUrl, token ?? "");
+      console.log(`\n${green("✓")}  Auto-sync ${bold("enabled")}.`);
+      console.log(`   Remote: ${cyan(remoteUrl)}`);
+      console.log(dim("   Sessions and memory will be synced automatically.\n"));
+    }
+    process.exit(0);
+  }
+
+  // ── status ──
+  if (sub === "status") {
+    if (!remoteUrl) {
+      console.log(`\n${red("✗")} No remote configured. Set via sync.json or --remote flag.\n`);
+      process.exit(1);
+    }
+    console.log(`\n🔄 ${bold("Sync Status")}\n`);
+    console.log(`   Remote: ${cyan(remoteUrl)}`);
+    const mgr = new SyncManager({ remoteUrl, token, strategy: strategy ?? "newer-wins" });
+    const s = await mgr.status(remoteUrl, token);
+    console.log(`   Connection: ${s.reachable ? green("✅ reachable") : red("✗ unreachable")}\n`);
+
+    const fmt = (label, info) => {
+      const parts = [];
+      if (info.localOnly > 0)  parts.push(`${yellow(info.localOnly + " local only")}`);
+      if (info.remoteOnly > 0) parts.push(`${cyan(info.remoteOnly + " remote only")}`);
+      if (info.inSync > 0)     parts.push(`${green(info.inSync + " in sync")}`);
+      console.log(`   ${bold(label.padEnd(14))} ${parts.join(", ") || dim("(empty)")}`);
+    };
+    fmt("Memory:",     s.memory);
+    fmt("Sessions:",   s.sessions);
+    fmt("Cron:",       s.cron);
+    fmt("Workstreams:",s.workstreams);
+    fmt("Permissions:",s.permissions);
+
+    const needPull = (s.memory.remoteOnly + s.sessions.remoteOnly + s.cron.remoteOnly + s.workstreams.remoteOnly + s.permissions.remoteOnly);
+    const needPush = (s.memory.localOnly + s.sessions.localOnly + s.cron.localOnly + s.workstreams.localOnly + s.permissions.localOnly);
+    if (needPull > 0 || needPush > 0) {
+      console.log(`\n   Action needed: ${needPull > 0 ? `pull ${yellow(needPull)} file(s)` : ""} ${needPush > 0 ? `push ${yellow(needPush)} file(s)` : ""}`.trimEnd());
+      console.log(dim("   Run 'wispy sync' to synchronize."));
+    } else {
+      console.log(`\n   ${green("✓")} Everything in sync!`);
+    }
+    console.log("");
+    process.exit(0);
+  }
+
+  // For push/pull/sync we need a remote URL
+  if (!remoteUrl) {
+    console.log(`\n${red("✗")} No remote configured.`);
+    console.log(dim("   Set remoteUrl in ~/.wispy/sync.json or use --remote <url>\n"));
+    process.exit(1);
+  }
+
+  const opts = { strategy: strategy ?? cfg.strategy ?? "newer-wins", memoryOnly, sessionsOnly };
+  const mgr = new SyncManager({ remoteUrl, token, ...opts });
+
+  if (sub === "push") {
+    console.log(`\n📤 ${bold("Pushing")} to ${cyan(remoteUrl)}...`);
+    const result = await mgr.push(remoteUrl, token, opts);
+    console.log(`   Pushed:  ${green(result.pushed)}`);
+    console.log(`   Skipped: ${dim(result.skipped)}`);
+    if (result.errors.length) result.errors.forEach(e => console.log(`   ${red("✗")} ${e}`));
+    console.log(`\n${result.errors.length === 0 ? green("✓ Done") : yellow("⚠ Done with errors")}.\n`);
+
+  } else if (sub === "pull") {
+    console.log(`\n📥 ${bold("Pulling")} from ${cyan(remoteUrl)}...`);
+    const result = await mgr.pull(remoteUrl, token, opts);
+    console.log(`   Pulled:    ${green(result.pulled)}`);
+    console.log(`   Skipped:   ${dim(result.skipped)}`);
+    if (result.conflicts) console.log(`   Conflicts: ${yellow(result.conflicts)} (saved as .conflict-* files)`);
+    if (result.errors.length) result.errors.forEach(e => console.log(`   ${red("✗")} ${e}`));
+    console.log(`\n${result.errors.length === 0 ? green("✓ Done") : yellow("⚠ Done with errors")}.\n`);
+
+  } else {
+    // Bidirectional sync (default)
+    console.log(`\n🔄 ${bold("Syncing")} with ${cyan(remoteUrl)}...`);
+    const result = await mgr.sync(remoteUrl, token, opts);
+    console.log(`   Pushed:    ${green(result.pushed)}`);
+    console.log(`   Pulled:    ${green(result.pulled)}`);
+    console.log(`   Skipped:   ${dim(result.skipped)}`);
+    if (result.conflicts) console.log(`   Conflicts: ${yellow(result.conflicts)} (saved as .conflict-* files)`);
+    if (result.errors.length) result.errors.forEach(e => console.log(`   ${red("✗")} ${e}`));
+    console.log(`\n${result.errors.length === 0 ? green("✓ Done") : yellow("⚠ Done with errors")}.\n`);
+  }
+
+  process.exit(0);
+}
+
 // ── deploy sub-command ────────────────────────────────────────────────────────
 if (args[0] === "deploy") {
   const { DeployManager } = await import(
@@ -244,6 +373,29 @@ if (args[0] === "deploy") {
     process.exit(0);
   }
 
+  if (sub === "modal") {
+    process.stdout.write(dm.generateModalConfig());
+    console.log(dim("\n# Save as modal_app.py, then: pip install modal && modal run modal_app.py"));
+    process.exit(0);
+  }
+
+  if (sub === "daytona") {
+    const { mkdir: mkdirDaytona, writeFile: writeDaytona } = await import("node:fs/promises");
+    const daytonaDir = path.join(process.cwd(), ".daytona");
+    await mkdirDaytona(daytonaDir, { recursive: true });
+    const daytonaConfigPath = path.join(daytonaDir, "config.yaml");
+    let exists = false;
+    try { await (await import("node:fs/promises")).access(daytonaConfigPath); exists = true; } catch {}
+    if (!exists) {
+      await writeDaytona(daytonaConfigPath, dm.generateDaytonaConfig(), "utf8");
+      console.log(green(`✅ Created .daytona/config.yaml`));
+    } else {
+      console.log(yellow(`⏭️  .daytona/config.yaml already exists (skipped)`));
+    }
+    console.log(dim("  Push to your repo and connect via Daytona workspace."));
+    process.exit(0);
+  }
+
   // Help
   console.log(`
 🚀 ${bold("Wispy Deploy Commands")}
@@ -256,6 +408,8 @@ if (args[0] === "deploy") {
   wispy deploy railway                 — print railway.json
   wispy deploy fly                     — print fly.toml
   wispy deploy render                  — print render.yaml
+  wispy deploy modal                   — generate Modal serverless config (modal_app.py)
+  wispy deploy daytona                 — generate Daytona workspace config (.daytona/config.yaml)
 
   ${cyan("Deploy:")}
   wispy deploy vps user@host           — SSH deploy: install + systemd setup
@@ -272,6 +426,67 @@ if (args[0] === "deploy") {
   process.exit(0);
 }
 
+// ── migrate sub-command ───────────────────────────────────────────────────────
+if (args[0] === "migrate") {
+  const { OpenClawMigrator, WISPY_DIR } = await import(
+    path.join(__dirname, "..", "core", "index.mjs")
+  );
+
+  const sub = args[1]; // "openclaw" (only supported source for now)
+  const dryRun = args.includes("--dry-run");
+  const memoryOnly = args.includes("--memory-only");
+
+  const green  = (s) => `\x1b[32m${s}\x1b[0m`;
+  const red    = (s) => `\x1b[31m${s}\x1b[0m`;
+  const bold   = (s) => `\x1b[1m${s}\x1b[0m`;
+  const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
+  const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+
+  if (!sub || sub === "openclaw") {
+    console.log(`\n🌿 ${bold("Wispy Migration Tool")} ${dim("— from OpenClaw")}\n`);
+    if (dryRun) console.log(yellow("  [DRY RUN — no files will be written]\n"));
+    if (memoryOnly) console.log(dim("  [memory-only mode]\n"));
+
+    const migrator = new OpenClawMigrator(WISPY_DIR);
+    const result = await migrator.migrate({ dryRun, memoryOnly });
+
+    console.log(migrator.formatReport());
+
+    if (result.success) {
+      if (dryRun) {
+        console.log(dim("\nRun without --dry-run to apply changes.\n"));
+      } else {
+        const counts = [
+          result.report.memories.length > 0 && `${result.report.memories.length} memory files`,
+          result.report.userModel.length > 0 && `${result.report.userModel.length} profile files`,
+          result.report.cronJobs.length > 0 && `${result.report.cronJobs.length} cron jobs`,
+          result.report.channels.length > 0 && `${result.report.channels.length} channels`,
+        ].filter(Boolean);
+
+        if (counts.length > 0) {
+          console.log(`\n${green("✅ Migration complete!")} Imported: ${counts.join(", ")}`);
+        } else {
+          console.log(`\n${dim("Nothing new to import (already migrated or empty).")}`);
+        }
+        console.log(dim("\nTip: run `wispy` to start chatting with your imported context.\n"));
+      }
+    } else {
+      console.error(`\n${red("❌ Migration failed:")} ${result.error}\n`);
+      process.exit(1);
+    }
+  } else {
+    console.log(`
+🔀 ${bold("Wispy Migrate Commands")}
+
+  wispy migrate openclaw              — import from OpenClaw (~/.openclaw/)
+  wispy migrate openclaw --dry-run    — preview what would be imported
+  wispy migrate openclaw --memory-only  — only import memories
+`);
+  }
+
+  process.exit(0);
+}
+
 // ── cron sub-command ──────────────────────────────────────────────────────────
 if (args[0] === "cron") {
   const { WispyEngine, CronManager, WISPY_DIR } = await import(
@@ -731,6 +946,9 @@ if (args[0] === "channel") {
   wispy channel setup telegram    — interactive Telegram bot setup
   wispy channel setup discord     — interactive Discord bot setup
   wispy channel setup slack       — interactive Slack bot setup
+  wispy channel setup whatsapp    — WhatsApp setup (requires: npm install whatsapp-web.js qrcode-terminal)
+  wispy channel setup signal      — Signal setup (requires: signal-cli)
+  wispy channel setup email       — Email setup (requires: npm install nodemailer imapflow)
   wispy channel list              — show configured channels
   wispy channel test <name>       — test a channel connection
 
@@ -805,7 +1023,7 @@ if (serveMode || telegramMode || discordMode || slackMode) {
 const isInteractiveStart = !args.some(a =>
   ["--serve", "--telegram", "--discord", "--slack", "--server",
    "status", "setup", "init", "connect", "disconnect", "deploy",
-   "cron", "audit", "log", "server", "node", "channel"].includes(a)
+   "cron", "audit", "log", "server", "node", "channel", "sync"].includes(a)
 );
 
 if (isInteractiveStart) {

package/core/deploy.mjs

@@ -121,6 +121,57 @@ WantedBy=multi-user.target
 `;
   }
 
+  generateModalConfig() {
+    const app = this.appName;
+    return `# modal_app.py — auto-generated by wispy deploy modal
+# Install: pip install modal
+# Run:     modal run modal_app.py
+import modal
+import subprocess
+
+app = modal.App("${app}")
+
+image = (
+    modal.Image.debian_slim()
+    .pip_install("nodeenv")
+    .run_commands(
+        "nodeenv /opt/node",
+        "/opt/node/bin/npm install -g wispy-cli",
+    )
+)
+
+
+@app.function(
+    image=image,
+    secrets=[modal.Secret.from_name("wispy-secrets")],
+    timeout=3600,
+    keep_warm=1,
+)
+def serve():
+    subprocess.run(
+        ["/opt/node/bin/wispy", "server", "--host", "0.0.0.0", "--port", "18790"],
+        check=True,
+    )
+
+
+@app.local_entrypoint()
+def main():
+    serve.remote()
+`;
+  }
+
+  generateDaytonaConfig() {
+    return `# .daytona/config.yaml — auto-generated by wispy deploy daytona
+# Daytona workspace config for wispy server
+name: ${this.appName}
+image: node:20-slim
+onCreateCommand: npm install -g wispy-cli
+postStartCommand: wispy server --host 0.0.0.0 --port \${PORT:-${this.port}}
+# Set secrets in Daytona workspace environment variables:
+# WISPY_SERVER_TOKEN, GOOGLE_AI_KEY (or other provider key)
+`;
+  }
+
   generateEnvExample() {
     const token = randomBytes(24).toString("hex");
     return `# Wispy Server Configuration

package/core/engine.mjs

@@ -24,6 +24,9 @@ import { SubAgentManager } from "./subagents.mjs";
 import { PermissionManager } from "./permissions.mjs";
 import { AuditLog, EVENT_TYPES } from "./audit.mjs";
 import { Harness } from "./harness.mjs";
+import { SyncManager, getSyncManager } from "./sync.mjs";
+import { SkillManager } from "./skills.mjs";
+import { UserModel } from "./user-model.mjs";
 
 const MAX_TOOL_ROUNDS = 10;
 const MAX_CONTEXT_CHARS = 40_000;
@@ -40,6 +43,9 @@ export class WispyEngine {
     this.permissions = new PermissionManager(config.permissions ?? {});
     this.audit = new AuditLog(WISPY_DIR);
     this.harness = new Harness(this.tools, this.permissions, this.audit, config);
+    this.sync = null; // SyncManager, initialized lazily
+    this.skills = new SkillManager(WISPY_DIR, this);
+    this.userModel = new UserModel(WISPY_DIR, this);
     this._initialized = false;
     this._workMdContent = null;
     this._workMdLoaded = false;
@@ -78,6 +84,9 @@ export class WispyEngine {
     // Register node tools
     this._registerNodeTools();
 
+    // Register skill tools
+    this._registerSkillTools();
+
     // Re-wire harness after tools are registered
     this.harness = new Harness(this.tools, this.permissions, this.audit, this.config);
 
@@ -93,6 +102,15 @@ export class WispyEngine {
       this.tools.registerMCP(this.mcpManager);
     }
 
+    // Initialize sync manager (if configured)
+    try {
+      this.sync = await getSyncManager();
+      // Auto-sync on startup: pull any new data from remote
+      if (this.sync?.auto && this.sync.remoteUrl) {
+        this.sync.pull(this.sync.remoteUrl, this.sync.token).catch(() => {});
+      }
+    } catch { /* sync is optional */ }
+
     this._initialized = true;
     return this;
   }
@@ -196,6 +214,21 @@ export class WispyEngine {
       this.sessions.save(session.id).catch(() => {});
     }
 
+    // Skills auto-capture (non-blocking fire-and-forget)
+    const currentMessages = session.messages ?? [];
+    if (currentMessages.length > 1 && !opts.skipSkillCapture) {
+      this.skills.autoCapture(currentMessages, session.id).then(skill => {
+        if (skill && opts.onSkillLearned) {
+          opts.onSkillLearned(skill);
+        }
+      }).catch(() => {});
+    }
+
+    // User model observation (non-blocking, every 10 messages)
+    if (currentMessages.length > 0 && !opts.skipUserModel) {
+      this.userModel.observe(currentMessages).catch(() => {});
+    }
+
     return {
       role: "assistant",
       content: responseText,
@@ -313,6 +346,7 @@ export class WispyEngine {
       "kill_subagent", "steer_subagent",
       "node_list", "node_status", "node_execute",
       "update_work_context",
+      "run_skill", "list_skills", "delete_skill",
     ]);
 
     const harnessResult = await this.harness.execute(name, args, {
@@ -381,6 +415,13 @@ export class WispyEngine {
         return this._toolNodeStatus();
       case "node_execute":
         return this._toolNodeExecute(args);
+      // Skill tools (v1.4)
+      case "run_skill":
+        return this._toolRunSkill(args, session);
+      case "list_skills":
+        return this._toolListSkills(args);
+      case "delete_skill":
+        return this._toolDeleteSkill(args);
       default:
         return this.tools.execute(name, args);
     }
@@ -731,6 +772,14 @@ export class WispyEngine {
       "",
     ];
 
+    // Load user model personalization
+    try {
+      const userModelAddition = await this.userModel.getSystemPromptAddition();
+      if (userModelAddition) {
+        parts.push(userModelAddition, "");
+      }
+    } catch { /* ignore */ }
+
     // Load WISPY.md context
     const wispyMd = await this._loadWispyMd();
     if (wispyMd) {
@@ -1059,6 +1108,89 @@ export class WispyEngine {
     }
   }
 
+  // ── Skill tools (v1.4) ───────────────────────────────────────────────────────
+
+  _registerSkillTools() {
+    const skillTools = [
+      {
+        name: "run_skill",
+        description: "Execute a saved skill by name. Skills are reusable task patterns learned from previous conversations.",
+        parameters: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Skill name (e.g., 'deploy-next-app')" },
+            args: { type: "object", description: "Optional args to template into the skill prompt ({{key}} placeholders)" },
+          },
+          required: ["name"],
+        },
+      },
+      {
+        name: "list_skills",
+        description: "List all available skills or search for specific ones.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Optional search query to filter skills" },
+          },
+        },
+      },
+      {
+        name: "delete_skill",
+        description: "Delete a saved skill by name.",
+        parameters: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Skill name to delete" },
+          },
+          required: ["name"],
+        },
+      },
+    ];
+
+    for (const tool of skillTools) {
+      this.tools._definitions.set(tool.name, tool);
+    }
+  }
+
+  async _toolRunSkill(args, session) {
+    try {
+      const skill = await this.skills.get(args.name);
+      if (!skill) {
+        const available = (await this.skills.list()).map(s => s.name);
+        return { success: false, error: `Skill '${args.name}' not found`, available };
+      }
+      const result = await this.skills.execute(args.name, args.args ?? {}, session?.id ?? null);
+      return { success: true, skill: args.name, result: result?.content ?? result };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolListSkills(args) {
+    try {
+      const skills = args?.query
+        ? await this.skills.search(args.query)
+        : await this.skills.list();
+      return {
+        success: true,
+        skills: skills.map(s => ({
+          name: s.name,
+          description: s.description,
+          tags: s.tags,
+          timesUsed: s.timesUsed ?? 0,
+          version: s.version ?? 1,
+        })),
+        total: skills.length,
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  async _toolDeleteSkill(args) {
+    return this.skills.delete(args.name);
+  }
+
   // ── Cleanup ──────────────────────────────────────────────────────────────────
 
   destroy() {

package/core/index.mjs

@@ -20,3 +20,7 @@ export { WispyServer } from "./server.mjs";
 export { NodeManager, CAPABILITIES } from "./nodes.mjs";
 export { Harness, Receipt, HarnessResult, computeUnifiedDiff } from "./harness.mjs";
 export { DeployManager } from "./deploy.mjs";
+export { SyncManager, getSyncManager, sha256 } from "./sync.mjs";
+export { SkillManager } from "./skills.mjs";
+export { UserModel } from "./user-model.mjs";
+export { OpenClawMigrator } from "./migrate.mjs";

package/core/memory.mjs

@@ -39,7 +39,8 @@ export class MemoryManager {
   }
 
   /**
-   * Save (overwrite) a memory file
+   * Save (overwrite) a memory file.
+   * If auto-sync is enabled, pushes the file to remote (non-blocking).
    */
   async save(key, content, metadata = {}) {
     await this._ensureDir();
@@ -55,6 +56,14 @@ export class MemoryManager {
       : `_Last updated: ${ts}_\n\n`;
 
     await writeFile(filePath, header + content, "utf8");
+
+    // Auto-sync: push to remote if configured (fire-and-forget)
+    try {
+      const { getSyncManager } = await import("./sync.mjs");
+      const syncMgr = await getSyncManager();
+      if (syncMgr?.auto) syncMgr.pushFile(filePath);
+    } catch { /* sync is optional */ }
+
     return { key, path: filePath };
   }