wispy-cli 1.3.0 → 1.4.0

package/bin/wispy.mjs

@@ -373,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")}
@@ -385,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
@@ -401,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(
@@ -860,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
 

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

@@ -25,6 +25,8 @@ 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;
@@ -42,6 +44,8 @@ export class WispyEngine {
     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;
@@ -80,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);
 
@@ -207,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,
@@ -324,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, {
@@ -392,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);
     }
@@ -742,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) {
@@ -1070,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

@@ -21,3 +21,6 @@ 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";