wispy-cli 1.3.0 → 1.4.0

package/core/user-model.mjs

@@ -0,0 +1,302 @@
+/**
+ * core/user-model.mjs — User modeling for personalized responses (Hermes-inspired)
+ *
+ * Wispy builds a deepening understanding of who you are — behavioral patterns,
+ * preferences, and working style — beyond simple memory facts.
+ *
+ * Storage: ~/.wispy/user-model.json
+ */
+
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+const MODEL_FILE = "user-model.json";
+const UPDATE_INTERVAL = 10; // Update every N messages
+
+const DEFAULT_MODEL = {
+  basics: {
+    name: null,
+    language: null,
+    role: null,
+    expertise: [],
+    os: null,
+  },
+  preferences: {
+    responseStyle: null,
+    codeStyle: null,
+    frameworkPreferences: [],
+    communicationLanguage: null,
+  },
+  patterns: {
+    peakHours: [],
+    avgSessionLength: 0,
+    commonTasks: [],
+    totalSessions: 0,
+    totalMessages: 0,
+  },
+  updatedAt: null,
+};
+
+export class UserModel {
+  constructor(wispyDir, engine = null) {
+    this.wispyDir = wispyDir;
+    this.modelPath = join(wispyDir, MODEL_FILE);
+    this.engine = engine;
+    this._cache = null;
+    this._messagesSinceUpdate = 0;
+  }
+
+  // ── Storage ──────────────────────────────────────────────────────────────────
+
+  async _load() {
+    if (this._cache) return this._cache;
+    try {
+      const raw = await readFile(this.modelPath, "utf8");
+      this._cache = { ...DEFAULT_MODEL, ...JSON.parse(raw) };
+    } catch {
+      this._cache = JSON.parse(JSON.stringify(DEFAULT_MODEL));
+    }
+    return this._cache;
+  }
+
+  async _save(model) {
+    await mkdir(this.wispyDir, { recursive: true });
+    model.updatedAt = new Date().toISOString();
+    this._cache = model;
+    await writeFile(this.modelPath, JSON.stringify(model, null, 2) + "\n", "utf8");
+  }
+
+  // ── Observation ──────────────────────────────────────────────────────────────
+
+  /**
+   * Observe a conversation and update the user model.
+   * Lightweight — only runs every UPDATE_INTERVAL messages.
+   * Non-blocking (should be called with fire-and-forget).
+   *
+   * @param {Array} messages  Conversation messages
+   */
+  async observe(messages) {
+    try {
+      if (!this.engine) return;
+
+      // Track total messages
+      const model = await this._load();
+      const userMessages = messages.filter(m => m.role === "user");
+      model.patterns.totalMessages += userMessages.length;
+
+      this._messagesSinceUpdate += userMessages.length;
+
+      // Only do AI analysis every UPDATE_INTERVAL messages
+      if (this._messagesSinceUpdate < UPDATE_INTERVAL) {
+        await this._save(model);
+        return;
+      }
+
+      this._messagesSinceUpdate = 0;
+
+      // Record current hour as a peak hour signal
+      const currentHour = new Date().getHours();
+      if (!model.patterns.peakHours.includes(currentHour)) {
+        model.patterns.peakHours.push(currentHour);
+        if (model.patterns.peakHours.length > 12) {
+          // Keep only the most recent 12
+          model.patterns.peakHours = model.patterns.peakHours.slice(-12);
+        }
+      }
+
+      // AI-powered analysis (lightweight)
+      const recentUserContent = userMessages.slice(-10).map(m => m.content).join("\n---\n").slice(0, 2000);
+      if (!recentUserContent) return;
+
+      const analysisPrompt = `Analyze these user messages and extract insights about the user.
+Be conservative — only assert things that are clearly evident.
+
+Messages:
+${recentUserContent}
+
+Current known profile:
+${JSON.stringify(model.basics, null, 2)}
+
+Respond with JSON only (include only fields where you have HIGH confidence):
+{
+  "basics": {
+    "name": null or "string if mentioned",
+    "language": null or "ko|en|ja|zh|...",
+    "role": null or "developer|student|designer|...",
+    "expertise": [] or ["tech1", "tech2"],
+    "os": null or "macOS|Windows|Linux"
+  },
+  "preferences": {
+    "responseStyle": null or "concise|detailed",
+    "codeStyle": null or "functional|oop|...",
+    "frameworkPreferences": [],
+    "communicationLanguage": null or "Korean|English|..."
+  },
+  "commonTasks": []
+}`;
+
+      let analysisResult;
+      try {
+        const res = await this.engine.providers.chat(
+          [
+            { role: "system", content: "You are a user behavior analysis system. Respond with JSON only. Be conservative — only include fields with high confidence." },
+            { role: "user", content: analysisPrompt },
+          ],
+          [],
+          {}
+        );
+        analysisResult = res.type === "text" ? res.text : "";
+      } catch {
+        await this._save(model);
+        return;
+      }
+
+      // Parse and merge
+      const jsonMatch = analysisResult.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        await this._save(model);
+        return;
+      }
+
+      let extracted;
+      try {
+        extracted = JSON.parse(jsonMatch[0]);
+      } catch {
+        await this._save(model);
+        return;
+      }
+
+      // Merge basics (non-destructive — only update null fields or extend arrays)
+      if (extracted.basics) {
+        for (const [key, val] of Object.entries(extracted.basics)) {
+          if (val === null || val === undefined) continue;
+          if (Array.isArray(val)) {
+            // Extend array with new unique values
+            const current = model.basics[key] ?? [];
+            model.basics[key] = [...new Set([...current, ...val])];
+          } else if (!model.basics[key]) {
+            // Only set if not already known
+            model.basics[key] = val;
+          }
+        }
+      }
+
+      // Merge preferences
+      if (extracted.preferences) {
+        for (const [key, val] of Object.entries(extracted.preferences)) {
+          if (val === null || val === undefined) continue;
+          if (Array.isArray(val)) {
+            const current = model.preferences[key] ?? [];
+            model.preferences[key] = [...new Set([...current, ...val])];
+          } else if (!model.preferences[key]) {
+            model.preferences[key] = val;
+          }
+        }
+      }
+
+      // Merge common tasks
+      if (extracted.commonTasks?.length > 0) {
+        const current = model.patterns.commonTasks ?? [];
+        model.patterns.commonTasks = [...new Set([...current, ...extracted.commonTasks])].slice(0, 20);
+      }
+
+      await this._save(model);
+    } catch {
+      // User model update should never throw
+    }
+  }
+
+  // ── Query methods ─────────────────────────────────────────────────────────────
+
+  async getProfile() {
+    const model = await this._load();
+    return model.basics;
+  }
+
+  async getPreferences() {
+    const model = await this._load();
+    return model.preferences;
+  }
+
+  async getExpertise() {
+    const model = await this._load();
+    return model.basics.expertise ?? [];
+  }
+
+  async getWorkingPattern() {
+    const model = await this._load();
+    return {
+      peakHours: model.patterns.peakHours,
+      avgSessionLength: model.patterns.avgSessionLength,
+      commonTasks: model.patterns.commonTasks,
+    };
+  }
+
+  /**
+   * Generate a personalized addition to the system prompt.
+   * Only adds context if we have meaningful data.
+   */
+  async getSystemPromptAddition() {
+    try {
+      const model = await this._load();
+      const parts = [];
+
+      const { basics, preferences, patterns } = model;
+
+      if (basics.name) parts.push(`User's name: ${basics.name}`);
+      if (basics.role) parts.push(`Role: ${basics.role}`);
+      if (basics.os) parts.push(`OS: ${basics.os}`);
+      if (basics.expertise?.length > 0) parts.push(`Expertise: ${basics.expertise.join(", ")}`);
+
+      if (preferences.communicationLanguage) {
+        parts.push(`Preferred language: ${preferences.communicationLanguage}`);
+      }
+      if (preferences.responseStyle) {
+        parts.push(`Response style preference: ${preferences.responseStyle}`);
+      }
+      if (preferences.frameworkPreferences?.length > 0) {
+        parts.push(`Framework preferences: ${preferences.frameworkPreferences.join(", ")}`);
+      }
+
+      if (patterns.commonTasks?.length > 0) {
+        parts.push(`Common tasks: ${patterns.commonTasks.slice(0, 5).join(", ")}`);
+      }
+
+      if (patterns.peakHours?.length > 0) {
+        const currentHour = new Date().getHours();
+        const isActive = patterns.peakHours.includes(currentHour);
+        if (!isActive && patterns.peakHours.length > 3) {
+          parts.push(`Note: User is usually active around hours ${patterns.peakHours.slice(0, 5).join(", ")}`);
+        }
+      }
+
+      if (parts.length === 0) return null;
+
+      return `## User Profile\n${parts.map(p => `- ${p}`).join("\n")}`;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Update total sessions count.
+   */
+  async recordSession() {
+    try {
+      const model = await this._load();
+      model.patterns.totalSessions = (model.patterns.totalSessions ?? 0) + 1;
+      await this._save(model);
+    } catch { /* ignore */ }
+  }
+
+  /**
+   * Manually update profile fields.
+   */
+  async updateProfile(updates) {
+    const model = await this._load();
+    if (updates.basics) Object.assign(model.basics, updates.basics);
+    if (updates.preferences) Object.assign(model.preferences, updates.preferences);
+    await this._save(model);
+    return model;
+  }
+}

package/lib/channels/email.mjs

@@ -0,0 +1,187 @@
+/**
+ * lib/channels/email.mjs — Email channel adapter
+ *
+ * Uses nodemailer (send) + imapflow (receive) — optional peer dependencies.
+ * Install: npm install nodemailer imapflow
+ *
+ * Config (channels.json):
+ *   {
+ *     "email": {
+ *       "imap": { "host": "imap.gmail.com", "port": 993, "user": "...", "password": "..." },
+ *       "smtp": { "host": "smtp.gmail.com", "port": 587, "user": "...", "password": "..." },
+ *       "allowedSenders": ["trusted@example.com"],
+ *       "pollIntervalMs": 30000,
+ *       "subjectPrefix": "[wispy]"
+ *     }
+ *   }
+ *
+ * For Gmail: use App Passwords (2FA required), not your main password.
+ */
+
+import { ChannelAdapter } from "./base.mjs";
+
+let nodemailer, ImapFlow;
+
+async function loadDeps() {
+  const missing = [];
+  try {
+    nodemailer = (await import("nodemailer")).default;
+  } catch {
+    missing.push("nodemailer");
+  }
+  try {
+    ImapFlow = (await import("imapflow")).ImapFlow;
+  } catch {
+    missing.push("imapflow");
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `Email adapter requires: npm install ${missing.join(" ")}`
+    );
+  }
+}
+
+export class EmailAdapter extends ChannelAdapter {
+  constructor(config = {}) {
+    super(config);
+    this.imapConfig = config.imap ?? {};
+    this.smtpConfig = config.smtp ?? {};
+    this.allowedSenders = (config.allowedSenders ?? []).map(s => s.toLowerCase());
+    this.pollIntervalMs = config.pollIntervalMs ?? 30_000;
+    this.subjectPrefix = config.subjectPrefix ?? "[wispy]";
+    this._transporter = null;
+    this._pollTimer = null;
+    this._seen = new Set(); // Track processed message UIDs
+  }
+
+  async start() {
+    await loadDeps();
+
+    // Verify SMTP
+    this._transporter = nodemailer.createTransport({
+      host: this.smtpConfig.host,
+      port: this.smtpConfig.port ?? 587,
+      secure: (this.smtpConfig.port ?? 587) === 465,
+      auth: {
+        user: this.smtpConfig.user,
+        pass: this.smtpConfig.password,
+      },
+    });
+
+    try {
+      await this._transporter.verify();
+      console.log(`✅ Email SMTP connected (${this.smtpConfig.user})`);
+    } catch (err) {
+      throw new Error(`Email SMTP verify failed: ${err.message}`);
+    }
+
+    // Start IMAP polling
+    await this._poll(); // Initial poll
+    this._pollTimer = setInterval(() => this._poll().catch(() => {}), this.pollIntervalMs);
+    console.log(`✅ Email IMAP polling every ${this.pollIntervalMs / 1000}s`);
+  }
+
+  async stop() {
+    if (this._pollTimer) {
+      clearInterval(this._pollTimer);
+      this._pollTimer = null;
+    }
+    if (this._transporter) {
+      this._transporter.close?.();
+      this._transporter = null;
+    }
+  }
+
+  async sendMessage(chatId, text) {
+    // chatId is the reply-to email address
+    if (!this._transporter) throw new Error("Email adapter not started");
+
+    const subject = `${this.subjectPrefix} Response`;
+    const MAX_LEN = 50000;
+
+    await this._transporter.sendMail({
+      from: this.smtpConfig.user,
+      to: chatId,
+      subject,
+      text: text.slice(0, MAX_LEN),
+    });
+  }
+
+  async _poll() {
+    const client = new ImapFlow({
+      host: this.imapConfig.host,
+      port: this.imapConfig.port ?? 993,
+      secure: true,
+      auth: {
+        user: this.imapConfig.user,
+        pass: this.imapConfig.password,
+      },
+      logger: false,
+    });
+
+    try {
+      await client.connect();
+
+      const lock = await client.getMailboxLock("INBOX");
+      try {
+        // Search for unread messages with our subject prefix (or all unread)
+        const criteria = ["UNSEEN"];
+
+        for await (const msg of client.fetch(criteria, { envelope: true, bodyStructure: true })) {
+          const uid = String(msg.uid);
+          if (this._seen.has(uid)) continue;
+          this._seen.add(uid);
+
+          const from = msg.envelope.from?.[0];
+          if (!from) continue;
+
+          const senderEmail = from.address?.toLowerCase() ?? "";
+          const senderName = from.name ?? senderEmail;
+
+          // Filter allowed senders
+          if (
+            this.allowedSenders.length > 0 &&
+            !this.allowedSenders.includes(senderEmail)
+          ) continue;
+
+          // Get message body
+          let bodyText = "";
+          try {
+            for await (const part of client.download(uid, { uid: true })) {
+              for await (const chunk of part.content) {
+                bodyText += chunk.toString("utf8");
+              }
+            }
+          } catch {
+            bodyText = `[Subject: ${msg.envelope.subject ?? "(no subject)"}]`;
+          }
+
+          // Strip HTML if needed (simple approach)
+          bodyText = bodyText
+            .replace(/<[^>]+>/g, " ")
+            .replace(/\s+/g, " ")
+            .trim()
+            .slice(0, 4000);
+
+          if (!bodyText) continue;
+
+          // Emit (chatId = reply address)
+          this._emit(senderEmail, senderEmail, senderName, bodyText, msg);
+
+          // Mark as read
+          try {
+            await client.messageFlagsAdd({ uid: [msg.uid] }, ["\\Seen"]);
+          } catch { /* non-fatal */ }
+        }
+      } finally {
+        lock.release();
+      }
+    } catch (err) {
+      if (process.env.WISPY_DEBUG) {
+        console.error("[email] IMAP poll error:", err.message);
+      }
+    } finally {
+      try { await client.logout(); } catch { /* ignore */ }
+    }
+  }
+}

package/lib/channels/index.mjs

@@ -333,9 +333,12 @@ export class ChannelManager {
     const cfg = await loadChannelsConfig();
 
     const entries = [
-      { name: "telegram", AdapterClass: () => import("./telegram.mjs").then(m => m.TelegramAdapter) },
-      { name: "discord",  AdapterClass: () => import("./discord.mjs").then(m => m.DiscordAdapter) },
-      { name: "slack",    AdapterClass: () => import("./slack.mjs").then(m => m.SlackAdapter) },
+      { name: "telegram",  AdapterClass: () => import("./telegram.mjs").then(m => m.TelegramAdapter) },
+      { name: "discord",   AdapterClass: () => import("./discord.mjs").then(m => m.DiscordAdapter) },
+      { name: "slack",     AdapterClass: () => import("./slack.mjs").then(m => m.SlackAdapter) },
+      { name: "whatsapp",  AdapterClass: () => import("./whatsapp.mjs").then(m => m.WhatsAppAdapter) },
+      { name: "signal",    AdapterClass: () => import("./signal.mjs").then(m => m.SignalAdapter) },
+      { name: "email",     AdapterClass: () => import("./email.mjs").then(m => m.EmailAdapter) },
     ];
 
     for (const { name, AdapterClass } of entries) {
@@ -413,6 +416,9 @@ export class ChannelManager {
       (process.env.WISPY_SLACK_BOT_TOKEN ?? cfg.botToken) &&
       (process.env.WISPY_SLACK_APP_TOKEN ?? cfg.appToken)
     );
+    if (name === "whatsapp") return true; // No token needed, uses QR
+    if (name === "signal")   return !!(cfg.number);
+    if (name === "email")    return !!(cfg.imap?.user && cfg.smtp?.user);
     return false;
   }
 }
@@ -460,8 +466,54 @@ export async function channelSetup(channelName) {
     console.log("\n✅ Slack tokens saved! Run: wispy --slack");
   }
 
+  else if (channelName === "whatsapp") {
+    console.log("WhatsApp requires: npm install whatsapp-web.js qrcode-terminal");
+    console.log("(Check peer dependency instructions)\n");
+    const raw = (await ask("  Allowed phone numbers (comma-separated, e.g. +821012345678): ")).trim();
+    const allowedNumbers = raw ? raw.split(",").map(n => n.trim()).filter(Boolean) : [];
+    cfg.whatsapp = { ...(cfg.whatsapp ?? {}), enabled: true, allowedNumbers };
+    await saveChannelsConfig(cfg);
+    console.log("\n✅ WhatsApp config saved! Run: wispy --serve (QR code will appear)");
+    console.log("   Make sure whatsapp-web.js is installed first.");
+  }
+
+  else if (channelName === "signal") {
+    console.log("Signal requires signal-cli installed: https://github.com/AsamK/signal-cli");
+    console.log("Register first: signal-cli -a +NUMBER register && signal-cli -a +NUMBER verify CODE\n");
+    const number = (await ask("  Your Signal number (e.g. +821012345678): ")).trim();
+    if (!number) { rl.close(); return; }
+    const raw = (await ask("  Allowed sender numbers (comma-separated, empty = all): ")).trim();
+    const allowedNumbers = raw ? raw.split(",").map(n => n.trim()).filter(Boolean) : [];
+    const signalCliPath = (await ask("  signal-cli path [signal-cli]: ")).trim() || "signal-cli";
+    cfg.signal = { ...(cfg.signal ?? {}), enabled: true, number, allowedNumbers, signalCliPath };
+    await saveChannelsConfig(cfg);
+    console.log("\n✅ Signal config saved! Run: wispy --serve");
+  }
+
+  else if (channelName === "email") {
+    console.log("Email requires: npm install nodemailer imapflow\n");
+    const imapHost = (await ask("  IMAP host (e.g. imap.gmail.com): ")).trim();
+    const imapPort = parseInt((await ask("  IMAP port [993]: ")).trim() || "993", 10);
+    const smtpHost = (await ask("  SMTP host (e.g. smtp.gmail.com): ")).trim();
+    const smtpPort = parseInt((await ask("  SMTP port [587]: ")).trim() || "587", 10);
+    const user = (await ask("  Email address: ")).trim();
+    const password = (await ask("  Email password (use App Password for Gmail): ")).trim();
+    const raw = (await ask("  Allowed senders (comma-separated, empty = all): ")).trim();
+    const allowedSenders = raw ? raw.split(",").map(s => s.trim()).filter(Boolean) : [];
+    if (!imapHost || !smtpHost || !user || !password) { console.log("❌ Required fields missing."); rl.close(); return; }
+    cfg.email = {
+      ...(cfg.email ?? {}), enabled: true,
+      imap: { host: imapHost, port: imapPort, user, password },
+      smtp: { host: smtpHost, port: smtpPort, user, password },
+      allowedSenders,
+    };
+    await saveChannelsConfig(cfg);
+    console.log("\n✅ Email config saved! Run: wispy --serve");
+    console.log("   Make sure nodemailer and imapflow are installed first.");
+  }
+
   else {
-    console.log(`Unknown channel: ${channelName}. Use: telegram, discord, slack`);
+    console.log(`Unknown channel: ${channelName}. Use: telegram, discord, slack, whatsapp, signal, email`);
   }
 
   rl.close();
@@ -469,16 +521,21 @@ export async function channelSetup(channelName) {
 
 export async function channelList() {
   const cfg = await loadChannelsConfig();
-  const channels = ["telegram", "discord", "slack"];
+  const channels = ["telegram", "discord", "slack", "whatsapp", "signal", "email"];
 
   console.log("\n🌿 Configured channels:\n");
   for (const name of channels) {
     const c = cfg[name];
-    if (!c) { console.log(`  ○ ${name.padEnd(10)} not configured`); continue; }
+    if (!c) { console.log(`  ○ ${name.padEnd(12)} not configured`); continue; }
     const enabled = c.enabled !== false;
-    const hasToken = name === "slack" ? !!(c.botToken && c.appToken) : !!c.token;
-    const status = !hasToken ? "no token" : enabled ? "✅ enabled" : "disabled";
-    console.log(`  ${enabled && hasToken ? "●" : "○"} ${name.padEnd(10)} ${status}`);
+    let hasToken = false;
+    if (name === "slack") hasToken = !!(c.botToken && c.appToken);
+    else if (name === "whatsapp") hasToken = true;
+    else if (name === "signal") hasToken = !!c.number;
+    else if (name === "email") hasToken = !!(c.imap?.user && c.smtp?.user);
+    else hasToken = !!c.token;
+    const status = !hasToken ? "no config" : enabled ? "✅ enabled" : "disabled";
+    console.log(`  ${enabled && hasToken ? "●" : "○"} ${name.padEnd(12)} ${status}`);
   }
   console.log(`\nConfig file: ${CHANNELS_CONFIG}\n`);
 }