wispy-cli 1.3.0 → 1.4.0

package/lib/channels/signal.mjs

@@ -0,0 +1,151 @@
+/**
+ * lib/channels/signal.mjs — Signal channel adapter
+ *
+ * Uses signal-cli via subprocess (optional — must be installed separately).
+ * Install signal-cli: https://github.com/AsamK/signal-cli
+ *
+ * Config (channels.json):
+ *   {
+ *     "signal": {
+ *       "number": "+1234567890",    // registered Signal number
+ *       "signalCliPath": "signal-cli",  // path to binary (default: signal-cli in PATH)
+ *       "allowedNumbers": ["+9876543210"]  // empty = all
+ *     }
+ *   }
+ *
+ * Limitations: signal-cli must be registered and linked to an account.
+ * Run: signal-cli -a +NUMBER register && signal-cli -a +NUMBER verify CODE
+ */
+
+import { ChannelAdapter } from "./base.mjs";
+import { spawn } from "node:child_process";
+
+export class SignalAdapter extends ChannelAdapter {
+  constructor(config = {}) {
+    super(config);
+    this.number = config.number;
+    this.signalCliPath = config.signalCliPath ?? "signal-cli";
+    this.allowedNumbers = config.allowedNumbers ?? [];
+    this._proc = null;
+    this._buffer = "";
+  }
+
+  async start() {
+    if (!this.number) {
+      throw new Error("Signal adapter requires config.number (your Signal phone number)");
+    }
+
+    // Test that signal-cli is available
+    await this._testBinary();
+
+    // Start signal-cli in JSON receive mode
+    this._proc = spawn(
+      this.signalCliPath,
+      ["-a", this.number, "--output=json", "receive", "--ignore-attachments"],
+      { stdio: ["ignore", "pipe", "pipe"] }
+    );
+
+    this._proc.stdout.setEncoding("utf8");
+    this._proc.stdout.on("data", (chunk) => {
+      this._buffer += chunk;
+      const lines = this._buffer.split("\n");
+      this._buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.trim()) this._handleLine(line.trim());
+      }
+    });
+
+    this._proc.stderr.setEncoding("utf8");
+    this._proc.stderr.on("data", (data) => {
+      if (process.env.WISPY_DEBUG) {
+        console.error("[signal-cli]", data.trim());
+      }
+    });
+
+    this._proc.on("error", (err) => {
+      console.error("⚠️ Signal adapter error:", err.message);
+    });
+
+    this._proc.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        console.warn(`⚠️ signal-cli exited with code ${code}`);
+      }
+    });
+
+    console.log(`✅ Signal adapter started for ${this.number}`);
+  }
+
+  async stop() {
+    if (this._proc) {
+      this._proc.kill("SIGTERM");
+      this._proc = null;
+    }
+  }
+
+  async sendMessage(chatId, text) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(
+        this.signalCliPath,
+        ["-a", this.number, "send", "-m", text, chatId],
+        { stdio: ["ignore", "pipe", "pipe"] }
+      );
+
+      let stderr = "";
+      proc.stderr.on("data", d => { stderr += d; });
+
+      proc.on("exit", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`signal-cli send failed (${code}): ${stderr.slice(0, 200)}`));
+      });
+
+      proc.on("error", reject);
+
+      // Timeout
+      setTimeout(() => {
+        proc.kill();
+        reject(new Error("signal-cli send timed out"));
+      }, 15000);
+    });
+  }
+
+  _handleLine(line) {
+    try {
+      const envelope = JSON.parse(line);
+      const dataMsg = envelope?.envelope?.dataMessage;
+      if (!dataMsg?.message) return;
+
+      const senderNumber = envelope.envelope.sourceNumber ?? envelope.envelope.source;
+      if (!senderNumber) return;
+
+      // Filter allowed numbers
+      if (
+        this.allowedNumbers.length > 0 &&
+        !this.allowedNumbers.includes(senderNumber)
+      ) return;
+
+      const senderName = envelope.envelope.sourceName ?? senderNumber;
+      this._emit(senderNumber, senderNumber, senderName, dataMsg.message, envelope);
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  async _testBinary() {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(this.signalCliPath, ["--version"], { stdio: "pipe" });
+      proc.on("exit", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(
+          `signal-cli not found or not working. Install from: https://github.com/AsamK/signal-cli`
+        ));
+      });
+      proc.on("error", () => {
+        reject(new Error(
+          `signal-cli binary not found at '${this.signalCliPath}'. ` +
+          `Install from: https://github.com/AsamK/signal-cli`
+        ));
+      });
+      setTimeout(() => { proc.kill(); resolve(); }, 5000);
+    });
+  }
+}

package/lib/channels/whatsapp.mjs

@@ -0,0 +1,141 @@
+/**
+ * lib/channels/whatsapp.mjs — WhatsApp channel adapter
+ *
+ * Uses whatsapp-web.js (optional peer dependency).
+ * Install: npm install whatsapp-web.js qrcode-terminal
+ *
+ * Config (channels.json):
+ *   { "whatsapp": { "allowedNumbers": ["+1234567890"], "sessionPath": "~/.wispy/whatsapp-session" } }
+ */
+
+import { ChannelAdapter } from "./base.mjs";
+
+let Client, LocalAuth, qrTerminal;
+
+async function loadDeps() {
+  if (Client) return true;
+  try {
+    const pkg = await import("whatsapp-web.js");
+    Client = pkg.Client;
+    LocalAuth = pkg.LocalAuth;
+  } catch {
+    return false;
+  }
+  try {
+    qrTerminal = (await import("qrcode-terminal")).default;
+  } catch {
+    qrTerminal = null;
+  }
+  return true;
+}
+
+export class WhatsAppAdapter extends ChannelAdapter {
+  constructor(config = {}) {
+    super(config);
+    this.client = null;
+    this.allowedNumbers = config.allowedNumbers ?? []; // e.g. ["+821012345678"]
+    this.sessionPath = config.sessionPath ?? null;
+    this._ready = false;
+  }
+
+  async start() {
+    const ok = await loadDeps();
+    if (!ok) {
+      throw new Error(
+        "whatsapp-web.js is not installed.\n" +
+        "Run: npm install whatsapp-web.js qrcode-terminal"
+      );
+    }
+
+    const authStrategy = new LocalAuth({
+      dataPath: this.sessionPath ?? undefined,
+    });
+
+    this.client = new Client({
+      authStrategy,
+      puppeteer: {
+        headless: true,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"],
+      },
+    });
+
+    this.client.on("qr", (qr) => {
+      console.log("\n📱 Scan this QR code with WhatsApp:\n");
+      if (qrTerminal) {
+        qrTerminal.generate(qr, { small: true });
+      } else {
+        console.log(qr);
+      }
+      console.log("\nWaiting for scan...\n");
+    });
+
+    this.client.on("ready", () => {
+      this._ready = true;
+      console.log("✅ WhatsApp connected.");
+    });
+
+    this.client.on("message", async (msg) => {
+      try {
+        // Filter: only allow configured numbers (or all if empty)
+        const from = msg.from; // e.g. "821012345678@c.us"
+        const normalized = "+" + from.replace("@c.us", "");
+        if (
+          this.allowedNumbers.length > 0 &&
+          !this.allowedNumbers.includes(normalized)
+        ) {
+          return; // Not allowed
+        }
+
+        const contact = await msg.getContact();
+        const username = contact.pushname ?? contact.name ?? normalized;
+
+        this._emit(from, from, username, msg.body, msg);
+      } catch (err) {
+        if (process.env.WISPY_DEBUG) {
+          console.error("[whatsapp] Message handler error:", err.message);
+        }
+      }
+    });
+
+    this.client.on("disconnected", (reason) => {
+      this._ready = false;
+      console.warn("⚠️ WhatsApp disconnected:", reason);
+    });
+
+    await this.client.initialize();
+  }
+
+  async stop() {
+    if (this.client) {
+      try {
+        await this.client.destroy();
+      } catch { /* ignore */ }
+      this.client = null;
+      this._ready = false;
+    }
+  }
+
+  async sendMessage(chatId, text) {
+    if (!this.client || !this._ready) {
+      throw new Error("WhatsApp client not ready");
+    }
+    // Split long messages (WhatsApp limit ~65000 chars, but keep it reasonable)
+    const MAX_LEN = 4000;
+    if (text.length <= MAX_LEN) {
+      await this.client.sendMessage(chatId, text);
+    } else {
+      const chunks = [];
+      for (let i = 0; i < text.length; i += MAX_LEN) {
+        chunks.push(text.slice(i, i + MAX_LEN));
+      }
+      for (const chunk of chunks) {
+        await this.client.sendMessage(chatId, chunk);
+        await new Promise(r => setTimeout(r, 500)); // Avoid rate limits
+      }
+    }
+  }
+
+  get isReady() {
+    return this._ready;
+  }
+}

package/lib/wispy-repl.mjs

@@ -461,33 +461,89 @@ ${bold("Permissions & Audit (v1.1):")}
   }
 
   if (cmd === "/skills") {
-    // Load skills from known locations
-    const skillDirs = [
-      "/opt/homebrew/lib/node_modules/openclaw/skills",
-      path.join(os.homedir(), ".openclaw", "workspace", "skills"),
-      path.join(WISPY_DIR, "skills"),
-    ];
-    const { readdir } = await import("node:fs/promises");
-    const allSkills = [];
-    for (const dir of skillDirs) {
-      try {
-        const entries = await readdir(dir);
-        for (const entry of entries) {
-          try {
-            const skillMd = await readFile(path.join(dir, entry, "SKILL.md"), "utf8");
-            allSkills.push({ name: entry, source: dir });
-          } catch {}
-        }
-      } catch {}
-    }
-    if (allSkills.length === 0) {
-      console.log(dim("No skills installed."));
+    // Wispy learned skills
+    const wispySkills = await engine.skills.list();
+    if (wispySkills.length > 0) {
+      console.log(bold(`\n🧠 Learned Skills (${wispySkills.length}):\n`));
+      for (const s of wispySkills) {
+        const used = s.timesUsed > 0 ? dim(` · used ${s.timesUsed}x`) : "";
+        const version = s.version > 1 ? dim(` · v${s.version}`) : "";
+        console.log(`  ${green("/" + s.name.padEnd(25))} ${s.description ?? ""}${used}${version}`);
+        if (s.tags?.length > 0) console.log(`  ${" ".repeat(27)}${dim(s.tags.map(t => "#" + t).join(" "))}`);
+      }
+      console.log(dim("\n  Run: /<skill-name> or /skill improve <name> \"feedback\""));
     } else {
-      console.log(bold(`\n🧩 Skills (${allSkills.length} installed):\n`));
-      for (const s of allSkills) {
-        console.log(`  ${green(s.name.padEnd(20))} ${dim(s.source.split("/").slice(-2).join("/"))}`);
+      console.log(dim("\nNo learned skills yet. Wispy will auto-learn from complex tasks!"));
+      console.log(dim("Create manually: /skill create <name>"));
+    }
+    return true;
+  }
+
+  // /skill <subcommand> — skill management
+  if (cmd === "/skill") {
+    const sub = parts[1];
+    if (!sub) {
+      console.log(`${bold("/skill commands:")} create <name> | improve <name> "feedback" | delete <name> | stats <name>`);
+      return true;
+    }
+
+    if (sub === "create") {
+      const name = parts[2];
+      if (!name) { console.log(yellow("Usage: /skill create <name>")); return true; }
+      // Capture from last conversation
+      const lastUser = conversation.filter(m => m.role === "user").slice(-3).map(m => m.content).join(" / ");
+      const lastAssistant = conversation.filter(m => m.role === "assistant").slice(-1)[0]?.content ?? "";
+      if (!lastUser) { console.log(yellow("No conversation to create skill from.")); return true; }
+      const skill = await engine.skills.create({
+        name,
+        description: `Created from last conversation`,
+        prompt: lastUser.slice(0, 500),
+        tools: [],
+        tags: [],
+      });
+      console.log(green(`✅ Skill '${name}' created!`));
+      console.log(dim(`  Prompt: ${skill.prompt.slice(0, 80)}...`));
+      return true;
+    }
+
+    if (sub === "improve") {
+      const name = parts[2];
+      const feedback = parts.slice(3).join(" ").replace(/^["']|["']$/g, "");
+      if (!name || !feedback) { console.log(yellow(`Usage: /skill improve <name> "feedback"`)); return true; }
+      try {
+        process.stdout.write(dim(`  Improving skill '${name}'...`));
+        const updated = await engine.skills.improve(name, feedback);
+        console.log(green(` ✓ done (v${updated.version})`));
+        console.log(dim(`  New prompt: ${updated.prompt.slice(0, 100)}...`));
+      } catch (err) {
+        console.log(red(` ✗ ${err.message}`));
       }
+      return true;
+    }
+
+    if (sub === "delete") {
+      const name = parts[2];
+      if (!name) { console.log(yellow("Usage: /skill delete <name>")); return true; }
+      const result = await engine.skills.delete(name);
+      if (result.success) console.log(green(`🗑️  Skill '${name}' deleted.`));
+      else console.log(red(`✗ ${result.error}`));
+      return true;
     }
+
+    if (sub === "stats") {
+      const name = parts[2];
+      if (!name) { console.log(yellow("Usage: /skill stats <name>")); return true; }
+      const stats = await engine.skills.getStats(name);
+      if (!stats) { console.log(red(`Skill '${name}' not found.`)); return true; }
+      console.log(bold(`\n📊 Skill: ${name}\n`));
+      console.log(`  Times used:   ${stats.timesUsed}`);
+      console.log(`  Version:      ${stats.version}`);
+      console.log(`  Improvements: ${stats.improvements}`);
+      if (stats.lastUsed) console.log(`  Last used:    ${new Date(stats.lastUsed).toLocaleString()}`);
+      return true;
+    }
+
+    console.log(`${bold("/skill commands:")} create <name> | improve <name> "feedback" | delete <name> | stats <name>`);
     return true;
   }
 
@@ -774,6 +830,25 @@ ${bold("Permissions & Audit (v1.1):")}
     process.exit(0);
   }
 
+  // ── Skill invocation: /skill-name ─────────────────────────────────────────
+  // Any unknown /command is checked against learned skills
+  const maybeSkillName = cmd.slice(1); // remove leading /
+  if (maybeSkillName && engine.skills) {
+    const skill = await engine.skills.get(maybeSkillName);
+    if (skill) {
+      console.log(dim(`🧠 Running skill: ${skill.name} (v${skill.version ?? 1})`));
+      try {
+        const result = await engine.skills.execute(maybeSkillName, {}, null);
+        if (result?.content) {
+          console.log(result.content);
+        }
+      } catch (err) {
+        console.log(red(`✗ Skill error: ${err.message}`));
+      }
+      return true;
+    }
+  }
+
   return false;
 }
 
@@ -820,6 +895,9 @@ async function runRepl(engine) {
         onChunk: (chunk) => process.stdout.write(chunk),
         systemPrompt: await engine._buildSystemPrompt(input),
         noSave: true,
+        onSkillLearned: (skill) => {
+          console.log(cyan(`\n💡 Learned new skill: '${skill.name}' — use /${skill.name} next time`));
+        },
       });
       console.log("\n");