wispy-cli 1.3.0 → 1.4.0

package/core/migrate.mjs

@@ -0,0 +1,357 @@
+/**
+ * core/migrate.mjs — Migration tool for importing from OpenClaw
+ *
+ * Helps users switch from OpenClaw to Wispy by importing:
+ *   - Memories (MEMORY.md → ~/.wispy/memory/)
+ *   - Workspace files (SOUL.md, USER.md, IDENTITY.md → user-model)
+ *   - Cron jobs (openclaw cron format → wispy cron format)
+ *   - Channel configs (telegram token, etc.)
+ *
+ * SAFE: Read-only from OpenClaw. Copies to Wispy, never modifies OpenClaw.
+ */
+
+import { readFile, writeFile, mkdir, readdir, access, stat } from "node:fs/promises";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+
+const OPENCLAW_DIR = join(homedir(), ".openclaw");
+const OPENCLAW_WORKSPACE = join(OPENCLAW_DIR, "workspace");
+
+export class OpenClawMigrator {
+  constructor(wispyDir) {
+    this.wispyDir = wispyDir;
+    this.report = {
+      detected: false,
+      memories: [],
+      userModel: [],
+      cronJobs: [],
+      channels: [],
+      skipped: [],
+      errors: [],
+    };
+  }
+
+  // ── Detection ─────────────────────────────────────────────────────────────────
+
+  async detect() {
+    try {
+      await access(OPENCLAW_DIR);
+      this.report.detected = true;
+      return true;
+    } catch {
+      this.report.detected = false;
+      return false;
+    }
+  }
+
+  // ── Main migration entry ──────────────────────────────────────────────────────
+
+  /**
+   * Run full migration.
+   * @param {object} opts
+   * @param {boolean} opts.dryRun  — if true, only report what would be migrated
+   * @param {boolean} opts.memoryOnly  — if true, only migrate memories
+   */
+  async migrate(opts = {}) {
+    const { dryRun = false, memoryOnly = false } = opts;
+
+    const detected = await this.detect();
+    if (!detected) {
+      return {
+        success: false,
+        error: `OpenClaw not found at ${OPENCLAW_DIR}`,
+        report: this.report,
+      };
+    }
+
+    // Migrate memories
+    await this._migrateMemories(dryRun);
+
+    if (!memoryOnly) {
+      await this._migrateWorkspaceFiles(dryRun);
+      await this._migrateCronJobs(dryRun);
+      await this._migrateChannels(dryRun);
+    }
+
+    return {
+      success: true,
+      dryRun,
+      report: this.report,
+    };
+  }
+
+  // ── Memory migration ──────────────────────────────────────────────────────────
+
+  async _migrateMemories(dryRun) {
+    const memoryDir = join(this.wispyDir, "memory");
+
+    // Check for MEMORY.md in workspace root
+    const memoryMdPath = join(OPENCLAW_WORKSPACE, "MEMORY.md");
+    try {
+      const content = await readFile(memoryMdPath, "utf8");
+      if (content.trim()) {
+        const dest = join(memoryDir, "openclaw-import.md");
+        if (!dryRun) {
+          await mkdir(memoryDir, { recursive: true });
+          await writeFile(dest, `# Imported from OpenClaw MEMORY.md\n\n${content}`, "utf8");
+        }
+        this.report.memories.push({ source: memoryMdPath, dest, action: "copy" });
+      }
+    } catch { /* No MEMORY.md — skip */ }
+
+    // Check for memory/ subdirectory
+    const openclawMemoryDir = join(OPENCLAW_WORKSPACE, "memory");
+    try {
+      const files = await readdir(openclawMemoryDir);
+      for (const file of files) {
+        if (!file.endsWith(".md") && !file.endsWith(".json")) continue;
+        const src = join(openclawMemoryDir, file);
+        const dest = join(memoryDir, `openclaw-${file}`);
+        try {
+          const content = await readFile(src, "utf8");
+          if (content.trim()) {
+            if (!dryRun) {
+              await mkdir(memoryDir, { recursive: true });
+              await writeFile(dest, content, "utf8");
+            }
+            this.report.memories.push({ source: src, dest, action: "copy" });
+          }
+        } catch (err) {
+          this.report.errors.push(`Memory file ${file}: ${err.message}`);
+        }
+      }
+    } catch { /* No memory directory */ }
+  }
+
+  // ── Workspace files → user model ──────────────────────────────────────────────
+
+  async _migrateWorkspaceFiles(dryRun) {
+    const filesToProcess = [
+      { name: "USER.md", type: "user" },
+      { name: "IDENTITY.md", type: "identity" },
+      { name: "SOUL.md", type: "soul" },
+    ];
+
+    for (const { name, type } of filesToProcess) {
+      const src = join(OPENCLAW_WORKSPACE, name);
+      try {
+        const content = await readFile(src, "utf8");
+        if (!content.trim()) continue;
+
+        // Extract useful info and save to wispy memory
+        const dest = join(this.wispyDir, "memory", `openclaw-${name.toLowerCase()}`);
+        if (!dryRun) {
+          await mkdir(join(this.wispyDir, "memory"), { recursive: true });
+          await writeFile(dest, `# Imported from OpenClaw ${name}\n\n${content}`, "utf8");
+        }
+        this.report.userModel.push({ source: src, dest, type, action: "copy" });
+
+        // Parse USER.md for structured data
+        if (type === "user" && !dryRun) {
+          await this._importUserMd(content);
+        }
+      } catch { /* File doesn't exist, skip */ }
+    }
+  }
+
+  async _importUserMd(content) {
+    // Extract structured fields from USER.md
+    const userModelPath = join(this.wispyDir, "user-model.json");
+
+    let model = {};
+    try {
+      model = JSON.parse(await readFile(userModelPath, "utf8"));
+    } catch {
+      model = { basics: {}, preferences: {}, patterns: { peakHours: [], avgSessionLength: 0, commonTasks: [], totalSessions: 0, totalMessages: 0 } };
+    }
+
+    // Simple regex extraction
+    const nameMatch = content.match(/\*\*Name:\*\*\s*(.+)/);
+    if (nameMatch && !model.basics?.name) {
+      const name = nameMatch[1].replace(/\(.+\)/, "").trim();
+      model.basics = model.basics ?? {};
+      model.basics.name = name;
+    }
+
+    const tzMatch = content.match(/\*\*Timezone:\*\*\s*(.+)/);
+    if (tzMatch) {
+      model.basics = model.basics ?? {};
+      model.basics.timezone = tzMatch[1].trim();
+    }
+
+    // Korean name usually indicates Korean language preference
+    if (content.includes("민서") || content.includes("Korean") || content.toLowerCase().includes("asia/seoul")) {
+      model.preferences = model.preferences ?? {};
+      if (!model.preferences.communicationLanguage) {
+        model.preferences.communicationLanguage = "Korean";
+        model.basics.language = "ko";
+      }
+    }
+
+    // OS hints
+    if (content.includes("MacBook") || content.includes("macOS")) {
+      model.basics = model.basics ?? {};
+      model.basics.os = "macOS";
+    }
+
+    model.updatedAt = new Date().toISOString();
+    await mkdir(this.wispyDir, { recursive: true });
+    await writeFile(userModelPath, JSON.stringify(model, null, 2) + "\n", "utf8");
+  }
+
+  // ── Cron job migration ───────────────────────────────────────────────────────
+
+  async _migrateCronJobs(dryRun) {
+    // OpenClaw cron config locations
+    const candidates = [
+      join(OPENCLAW_DIR, "cron.json"),
+      join(OPENCLAW_DIR, "config", "cron.json"),
+      join(OPENCLAW_WORKSPACE, "cron.json"),
+    ];
+
+    for (const src of candidates) {
+      try {
+        const raw = await readFile(src, "utf8");
+        const openclawCron = JSON.parse(raw);
+
+        // Convert OpenClaw cron format to Wispy cron format
+        const wispyCronPath = join(this.wispyDir, "cron.json");
+        let wispyCron = [];
+        try {
+          wispyCron = JSON.parse(await readFile(wispyCronPath, "utf8"));
+        } catch { /* empty */ }
+
+        const converted = this._convertCronFormat(openclawCron);
+        const toAdd = converted.filter(j =>
+          !wispyCron.some(existing => existing.name === j.name)
+        );
+
+        if (toAdd.length > 0) {
+          if (!dryRun) {
+            await mkdir(this.wispyDir, { recursive: true });
+            await writeFile(wispyCronPath, JSON.stringify([...wispyCron, ...toAdd], null, 2) + "\n", "utf8");
+          }
+          for (const job of toAdd) {
+            this.report.cronJobs.push({ source: src, job: job.name, action: "import" });
+          }
+        }
+        break; // Only process first found
+      } catch { /* Not found or parse error */ }
+    }
+  }
+
+  _convertCronFormat(openclawCron) {
+    // OpenClaw cron is an array of job objects
+    const jobs = Array.isArray(openclawCron) ? openclawCron : (openclawCron.jobs ?? []);
+    return jobs.map(job => ({
+      name: job.name ?? job.id ?? `imported-${Date.now()}`,
+      schedule: job.schedule ?? job.cron ?? "0 9 * * *",
+      prompt: job.prompt ?? job.task ?? job.message ?? "Run imported cron job",
+      enabled: job.enabled !== false,
+      importedFrom: "openclaw",
+    }));
+  }
+
+  // ── Channel config migration ──────────────────────────────────────────────────
+
+  async _migrateChannels(dryRun) {
+    // Look for OpenClaw channel configs
+    const configCandidates = [
+      join(OPENCLAW_DIR, "openclaw.json"),
+      join(OPENCLAW_DIR, "config.json"),
+      join(OPENCLAW_DIR, "config", "openclaw.json"),
+    ];
+
+    for (const src of configCandidates) {
+      try {
+        const raw = await readFile(src, "utf8");
+        const config = JSON.parse(raw);
+
+        const channelsPath = join(this.wispyDir, "channels.json");
+        let wispyChannels = {};
+        try {
+          wispyChannels = JSON.parse(await readFile(channelsPath, "utf8"));
+        } catch { /* empty */ }
+
+        // Extract Telegram config
+        const telegramToken = config.telegram?.token
+          ?? config.channels?.telegram?.token
+          ?? config.plugins?.telegram?.token;
+
+        if (telegramToken && !wispyChannels.telegram) {
+          wispyChannels.telegram = { token: telegramToken };
+          this.report.channels.push({ channel: "telegram", action: "import" });
+        }
+
+        // Extract Discord config
+        const discordToken = config.discord?.token
+          ?? config.channels?.discord?.token;
+
+        if (discordToken && !wispyChannels.discord) {
+          wispyChannels.discord = { token: discordToken };
+          this.report.channels.push({ channel: "discord", action: "import" });
+        }
+
+        if (this.report.channels.length > 0 && !dryRun) {
+          await mkdir(this.wispyDir, { recursive: true });
+          await writeFile(channelsPath, JSON.stringify(wispyChannels, null, 2) + "\n", "utf8");
+        }
+
+        break; // Only process first found
+      } catch { /* Not found */ }
+    }
+  }
+
+  // ── Report formatting ─────────────────────────────────────────────────────────
+
+  formatReport() {
+    const r = this.report;
+    const lines = [];
+
+    if (!r.detected) {
+      return `❌ OpenClaw not found at ${OPENCLAW_DIR}`;
+    }
+
+    lines.push(`✅ OpenClaw detected at ${OPENCLAW_DIR}`);
+    lines.push("");
+
+    if (r.memories.length > 0) {
+      lines.push(`📝 Memories (${r.memories.length}):`);
+      for (const m of r.memories) {
+        lines.push(`  ${m.action}: ${basename(m.source)} → ${basename(m.dest)}`);
+      }
+    } else {
+      lines.push("📝 Memories: none found");
+    }
+
+    if (r.userModel.length > 0) {
+      lines.push(`👤 User profile files (${r.userModel.length}):`);
+      for (const u of r.userModel) {
+        lines.push(`  ${u.action}: ${u.source.replace(homedir(), "~")}`);
+      }
+    }
+
+    if (r.cronJobs.length > 0) {
+      lines.push(`⏰ Cron jobs (${r.cronJobs.length}):`);
+      for (const j of r.cronJobs) {
+        lines.push(`  import: ${j.job}`);
+      }
+    }
+
+    if (r.channels.length > 0) {
+      lines.push(`📡 Channels (${r.channels.length}):`);
+      for (const c of r.channels) {
+        lines.push(`  import: ${c.channel}`);
+      }
+    }
+
+    if (r.errors.length > 0) {
+      lines.push(`⚠️ Errors (${r.errors.length}):`);
+      for (const e of r.errors) {
+        lines.push(`  ${e}`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+}

package/core/skills.mjs

@@ -0,0 +1,339 @@
+/**
+ * core/skills.mjs — Self-improving learning loop (Hermes-inspired)
+ *
+ * After completing a complex multi-tool task, Wispy automatically creates
+ * a reusable "skill" — a saved prompt+tool pattern invokable with /skill-name.
+ *
+ * Skills are stored in ~/.wispy/skills/<name>.json
+ */
+
+import { readFile, writeFile, mkdir, unlink, readdir, access } from "node:fs/promises";
+import { join } from "node:path";
+
+const SKILLS_DIR_NAME = "skills";
+
+export class SkillManager {
+  constructor(wispyDir, engine = null) {
+    this.wispyDir = wispyDir;
+    this.skillsDir = join(wispyDir, SKILLS_DIR_NAME);
+    this.engine = engine; // WispyEngine reference for AI calls
+  }
+
+  // ── Storage helpers ──────────────────────────────────────────────────────────
+
+  async _ensureDir() {
+    await mkdir(this.skillsDir, { recursive: true });
+  }
+
+  _skillPath(name) {
+    // Sanitize: lowercase, hyphens only
+    const safe = name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    return join(this.skillsDir, `${safe}.json`);
+  }
+
+  async _read(name) {
+    try {
+      const raw = await readFile(this._skillPath(name), "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  async _write(skill) {
+    await this._ensureDir();
+    await writeFile(this._skillPath(skill.name), JSON.stringify(skill, null, 2) + "\n", "utf8");
+    return skill;
+  }
+
+  // ── CRUD ─────────────────────────────────────────────────────────────────────
+
+  /**
+   * Create a skill manually.
+   * @param {{ name, description, prompt, tools?, tags? }} opts
+   */
+  async create(opts) {
+    const now = new Date().toISOString();
+    const skill = {
+      name: opts.name,
+      description: opts.description ?? "",
+      version: 1,
+      prompt: opts.prompt,
+      tools: opts.tools ?? [],
+      tags: opts.tags ?? [],
+      createdAt: now,
+      updatedAt: now,
+      createdFrom: opts.createdFrom ?? null,
+      timesUsed: 0,
+      lastUsed: null,
+      improvements: [],
+    };
+    return this._write(skill);
+  }
+
+  get(name) {
+    return this._read(name);
+  }
+
+  async list() {
+    await this._ensureDir();
+    let files;
+    try {
+      files = await readdir(this.skillsDir);
+    } catch {
+      return [];
+    }
+    const skills = [];
+    for (const f of files.filter(f => f.endsWith(".json"))) {
+      try {
+        const raw = await readFile(join(this.skillsDir, f), "utf8");
+        skills.push(JSON.parse(raw));
+      } catch { /* skip corrupted */ }
+    }
+    return skills.sort((a, b) => (b.timesUsed ?? 0) - (a.timesUsed ?? 0));
+  }
+
+  async search(query) {
+    const all = await this.list();
+    if (!query) return all;
+    const q = query.toLowerCase();
+    return all.filter(s =>
+      s.name.includes(q) ||
+      s.description?.toLowerCase().includes(q) ||
+      s.tags?.some(t => t.toLowerCase().includes(q)) ||
+      s.prompt?.toLowerCase().includes(q)
+    );
+  }
+
+  async delete(name) {
+    try {
+      await unlink(this._skillPath(name));
+      return { success: true, name };
+    } catch {
+      return { success: false, error: `Skill '${name}' not found` };
+    }
+  }
+
+  async getStats(name) {
+    const skill = await this._read(name);
+    if (!skill) return null;
+    return {
+      name: skill.name,
+      timesUsed: skill.timesUsed ?? 0,
+      lastUsed: skill.lastUsed ?? null,
+      version: skill.version ?? 1,
+      improvements: skill.improvements?.length ?? 0,
+    };
+  }
+
+  // ── Auto-capture ──────────────────────────────────────────────────────────────
+
+  /**
+   * After a conversation, check if it's worth learning a skill.
+   * Non-blocking — caller should fire-and-forget.
+   *
+   * Criteria:
+   *  1. 3+ distinct tools used in sequence
+   *  2. No error in final assistant message
+   *  3. Pattern not already saved
+   *
+   * @param {Array} messages  Full conversation messages
+   * @param {string} sessionId  Session ID for attribution
+   * @returns {object|null} Created skill, or null
+   */
+  async autoCapture(messages, sessionId = null) {
+    try {
+      if (!this.engine) return null;
+
+      // Count distinct tool calls
+      const toolCalls = messages.filter(m => m.toolCalls?.length > 0);
+      const toolNames = new Set(toolCalls.flatMap(m => m.toolCalls?.map(tc => tc.name) ?? []));
+
+      if (toolNames.size < 3) return null;
+
+      // Check final assistant message for errors
+      const lastAssistant = [...messages].reverse().find(m => m.role === "assistant");
+      if (!lastAssistant?.content) return null;
+
+      const errorSignals = ["⚠️", "error:", "failed:", "could not", "unable to"];
+      const hasError = errorSignals.some(s => lastAssistant.content.toLowerCase().includes(s.toLowerCase()));
+      if (hasError) return null;
+
+      // Extract summary of what was done
+      const userMessages = messages.filter(m => m.role === "user");
+      if (userMessages.length === 0) return null;
+
+      const taskSummary = userMessages.map(m => m.content).join(" / ").slice(0, 500);
+
+      // Use AI to extract skill
+      const extractionPrompt = `Analyze this completed task and decide if it's worth saving as a reusable skill.
+
+Task summary: "${taskSummary}"
+Tools used: ${[...toolNames].join(", ")}
+
+A skill is worth saving if:
+- The task is a common, repeatable workflow (not a one-off question)
+- It involves a sequence of meaningful steps
+- Someone would plausibly repeat it
+
+If worth saving, respond with JSON:
+{
+  "worthy": true,
+  "name": "kebab-case-name-max-30-chars",
+  "description": "One sentence description",
+  "prompt": "Reusable instruction prompt that generalizes this task",
+  "tags": ["tag1", "tag2"]
+}
+
+If NOT worth saving, respond with: {"worthy": false}
+
+Respond with JSON only.`;
+
+      let extractionResult;
+      try {
+        const res = await this.engine.providers.chat(
+          [
+            { role: "system", content: "You are a skill extraction system. Respond with JSON only." },
+            { role: "user", content: extractionPrompt },
+          ],
+          [],
+          {}
+        );
+        extractionResult = res.type === "text" ? res.text : "";
+      } catch {
+        return null;
+      }
+
+      // Parse JSON response
+      const jsonMatch = extractionResult.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return null;
+
+      let extracted;
+      try {
+        extracted = JSON.parse(jsonMatch[0]);
+      } catch {
+        return null;
+      }
+
+      if (!extracted.worthy) return null;
+      if (!extracted.name || !extracted.prompt) return null;
+
+      // Check if already exists
+      const existing = await this._read(extracted.name);
+      if (existing) return null; // Don't overwrite existing skills
+
+      // Save
+      const skill = await this.create({
+        name: extracted.name,
+        description: extracted.description ?? "",
+        prompt: extracted.prompt,
+        tools: [...toolNames],
+        tags: extracted.tags ?? [],
+        createdFrom: sessionId,
+      });
+
+      return skill;
+    } catch {
+      return null; // Never fail silently
+    }
+  }
+
+  // ── Skill improvement ────────────────────────────────────────────────────────
+
+  /**
+   * Improve an existing skill using feedback.
+   * @param {string} name  Skill name
+   * @param {string} feedback  User feedback
+   * @returns {object|null} Updated skill
+   */
+  async improve(name, feedback) {
+    if (!this.engine) throw new Error("Engine required for AI-powered improvement");
+
+    const skill = await this._read(name);
+    if (!skill) throw new Error(`Skill '${name}' not found`);
+
+    const improvementPrompt = `Improve this skill's prompt based on user feedback.
+
+Current prompt:
+"${skill.prompt}"
+
+User feedback: "${feedback}"
+
+Create an improved version of the prompt that incorporates the feedback while keeping it general and reusable.
+Respond with JSON only: {"improved_prompt": "..."}`;
+
+    let result;
+    try {
+      const res = await this.engine.providers.chat(
+        [
+          { role: "system", content: "You are a skill improvement system. Respond with JSON only." },
+          { role: "user", content: improvementPrompt },
+        ],
+        [],
+        {}
+      );
+      result = res.type === "text" ? res.text : "";
+    } catch (err) {
+      throw new Error(`AI improvement failed: ${err.message}`);
+    }
+
+    const jsonMatch = result.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) throw new Error("Failed to parse improvement response");
+
+    let parsed;
+    try {
+      parsed = JSON.parse(jsonMatch[0]);
+    } catch {
+      throw new Error("Invalid JSON in improvement response");
+    }
+
+    if (!parsed.improved_prompt) throw new Error("No improved prompt in response");
+
+    // Update skill
+    skill.prompt = parsed.improved_prompt;
+    skill.version = (skill.version ?? 1) + 1;
+    skill.updatedAt = new Date().toISOString();
+    skill.improvements = skill.improvements ?? [];
+    skill.improvements.push({
+      date: new Date().toISOString(),
+      feedback,
+      version: skill.version,
+    });
+
+    return this._write(skill);
+  }
+
+  // ── Execution ────────────────────────────────────────────────────────────────
+
+  /**
+   * Execute a skill by name.
+   * @param {string} name  Skill name
+   * @param {object} args  Optional args to template into prompt
+   * @param {string} sessionId  Session to execute in
+   * @returns {string} Result text
+   */
+  async execute(name, args = {}, sessionId = null) {
+    if (!this.engine) throw new Error("Engine required for skill execution");
+
+    const skill = await this._read(name);
+    if (!skill) throw new Error(`Skill '${name}' not found`);
+
+    // Simple template: replace {{key}} with args[key]
+    let prompt = skill.prompt;
+    for (const [key, val] of Object.entries(args)) {
+      prompt = prompt.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), String(val));
+    }
+
+    const start = Date.now();
+    const result = await this.engine.processMessage(sessionId, prompt, {});
+    const duration = Date.now() - start;
+
+    // Update stats
+    skill.timesUsed = (skill.timesUsed ?? 0) + 1;
+    skill.lastUsed = new Date().toISOString();
+    skill._lastDuration = duration;
+    await this._write(skill);
+
+    return result;
+  }
+}