wispy-cli 1.2.3 → 1.4.0

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;
+  }
+}