wispy-cli 2.7.10 → 2.7.12

package/core/memory.mjs

@@ -293,4 +293,247 @@ ${recentUserMsgs.slice(0, 2000)}`;
       return null;
     }
   }
+
+  // ── v2.8 Enhanced Memory Methods ────────────────────────────────────────────
+
+  /**
+   * Get top N most relevant memories for a given user message.
+   * Uses keyword matching + recency scoring + frequency weighting.
+   *
+   * @param {string} userMessage
+   * @param {number} limit - max memories to return (default 3)
+   * @returns {Promise<string|null>} formatted system message injection or null
+   */
+  async getRelevantMemories(userMessage, limit = 3) {
+    if (!userMessage?.trim()) return null;
+
+    try {
+      await this._ensureDir();
+      const terms = this._extractKeywords(userMessage);
+      if (terms.length === 0) return null;
+
+      // Collect all memory files with metadata
+      const allKeys = await this.list();
+      if (allKeys.length === 0) return null;
+
+      const scored = [];
+      const now = Date.now();
+
+      for (const item of allKeys) {
+        const content = await readFile(item.path, "utf8").catch(() => "");
+        if (!content.trim()) continue;
+
+        // 1. Keyword match score
+        const lower = content.toLowerCase();
+        let matchScore = 0;
+        for (const term of terms) {
+          // Count occurrences for stronger weighting
+          const regex = new RegExp(term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
+          const matches = (lower.match(regex) ?? []).length;
+          matchScore += matches;
+        }
+        if (matchScore === 0) continue;
+
+        // 2. Recency score (0–1, decays over 30 days)
+        const ageDays = item.updatedAt
+          ? (now - new Date(item.updatedAt).getTime()) / (1000 * 60 * 60 * 24)
+          : 30;
+        const recencyScore = Math.max(0, 1 - ageDays / 30);
+
+        // 3. Frequency score (often-accessed memories rank higher)
+        const freq = this._accessFrequency.get(item.key) ?? 0;
+        const freqScore = Math.min(freq / 10, 1); // cap at 10 accesses = 1.0
+
+        // Combined score
+        const totalScore = matchScore * 2 + recencyScore * 1.5 + freqScore;
+
+        scored.push({ key: item.key, content, score: totalScore });
+      }
+
+      if (scored.length === 0) return null;
+
+      // Sort by score descending, take top N
+      scored.sort((a, b) => b.score - a.score);
+      const top = scored.slice(0, limit);
+
+      // Format as system message injection
+      const parts = top.map(m => {
+        const snippet = m.content.trim().slice(0, 500);
+        return `### memory:${m.key}\n${snippet}`;
+      });
+
+      return parts.join("\n\n");
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Auto-extract important facts from conversation and save to memory.
+   * Triggered every AUTO_EXTRACT_INTERVAL messages.
+   *
+   * @param {Array<{role,content}>} messages - conversation history
+   * @param {Function} aiCall - async (prompt) => string
+   * @returns {Promise<string|null>} extracted facts or null
+   */
+  async autoExtractFacts(messages, aiCall) {
+    if (!messages?.length || !aiCall) return null;
+
+    // Only run every N messages to avoid excessive AI calls
+    const userMsgs = messages.filter(m => m.role === "user");
+    if (userMsgs.length % AUTO_EXTRACT_INTERVAL !== 0) return null;
+
+    const recentMsgs = messages.slice(-AUTO_EXTRACT_INTERVAL * 2);
+    const conversationText = recentMsgs
+      .map(m => `${m.role === "user" ? "User" : "Assistant"}: ${
+        typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+      }`)
+      .join("\n\n");
+
+    if (!conversationText.trim()) return null;
+
+    try {
+      const prompt = `Analyze this conversation and extract key facts, preferences, or important information worth remembering for future sessions. Be specific and concise. Format as bullet points. If nothing important, reply "nothing".
+
+Conversation:
+${conversationText.slice(0, 3000)}
+
+Examples of things to extract:
+- User preferences (tools, languages, styles)
+- Project names and goals  
+- Personal context (name, location, role)
+- Decisions made
+- Important deadlines or dates`;
+
+      const result = await aiCall(prompt);
+      if (!result || result.toLowerCase().trim() === "nothing") return null;
+
+      const today = new Date().toISOString().slice(0, 10);
+
+      // Deduplicate: check if very similar content already exists
+      const existingDaily = await this.get(`daily/${today}`);
+      if (existingDaily?.content?.includes(result.slice(0, 50))) return null;
+
+      await this.append(`daily/${today}`, result.slice(0, 800));
+      return result;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Fuzzy search across all memory files.
+   * Extends base search() with recency and frequency weighting.
+   *
+   * @param {string} query
+   * @param {object} opts
+   * @param {number} [opts.limit]
+   * @param {boolean} [opts.fuzzy] - enable fuzzy matching (default true)
+   * @returns {Promise<Array>}
+   */
+  async searchEnhanced(query, opts = {}) {
+    if (!query?.trim()) return [];
+    await this._ensureDir();
+
+    const terms = this._extractKeywords(query);
+    if (terms.length === 0) return [];
+
+    const results = [];
+    await this._searchDirEnhanced(this.memoryDir, this.memoryDir, terms, results, opts.fuzzy !== false);
+
+    const now = Date.now();
+
+    // Apply recency and frequency weighting to results
+    for (const r of results) {
+      try {
+        const fileStat = await stat(r.path).catch(() => null);
+        const ageDays = fileStat?.mtime
+          ? (now - fileStat.mtime.getTime()) / (1000 * 60 * 60 * 24)
+          : 30;
+        const recencyBonus = Math.max(0, 1 - ageDays / 30) * 2;
+        const freqBonus = Math.min((this._accessFrequency.get(r.key) ?? 0) / 5, 1);
+        r.matchCount = r.matchCount + recencyBonus + freqBonus;
+      } catch { /* ignore stat errors */ }
+    }
+
+    results.sort((a, b) => b.matchCount - a.matchCount);
+    return results.slice(0, opts.limit ?? MAX_SEARCH_RESULTS);
+  }
+
+  async _searchDirEnhanced(baseDir, dir, terms, results, fuzzy = true) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this._searchDirEnhanced(baseDir, fullPath, terms, results, fuzzy);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const content = await readFile(fullPath, "utf8").catch(() => "");
+        const lines = content.split("\n");
+        const key = path.relative(baseDir, fullPath).replace(/\.md$/, "");
+
+        let matchCount = 0;
+        const matchingLines = [];
+
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const lower = line.toLowerCase();
+
+          let lineMatches = terms.filter(t => lower.includes(t)).length;
+
+          // Fuzzy: also check for partial matches (e.g. "proj" matches "project")
+          if (fuzzy && lineMatches === 0) {
+            lineMatches = terms.filter(t =>
+              t.length >= 4 && lower.split(/\s+/).some(word => word.startsWith(t.slice(0, -1)))
+            ).length * 0.5; // partial credit
+          }
+
+          if (lineMatches > 0) {
+            matchCount += lineMatches;
+            matchingLines.push({
+              lineNumber: i + 1,
+              text: line.slice(0, MAX_SNIPPET_CHARS),
+            });
+          }
+        }
+
+        if (matchCount > 0) {
+          results.push({
+            key,
+            path: fullPath,
+            matchCount,
+            snippets: matchingLines.slice(0, 5),
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Extract meaningful keywords from a string for search/scoring.
+   * Filters out common stop words.
+   */
+  _extractKeywords(text) {
+    const STOP_WORDS = new Set([
+      "the", "a", "an", "is", "are", "was", "were", "be", "been",
+      "have", "has", "had", "do", "does", "did", "will", "would",
+      "could", "should", "may", "might", "can", "shall",
+      "i", "you", "he", "she", "it", "we", "they", "me", "him", "her",
+      "us", "them", "my", "your", "his", "its", "our", "their",
+      "this", "that", "these", "those", "what", "which", "who",
+      "how", "when", "where", "why", "and", "or", "but", "not",
+      "in", "on", "at", "to", "for", "of", "with", "by", "from",
+      "up", "out", "as", "if", "then", "than", "so", "just",
+    ]);
+
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\s]/g, " ")
+      .split(/\s+/)
+      .filter(w => w.length >= 3 && !STOP_WORDS.has(w));
+  }
 }

package/core/providers.mjs

@@ -169,6 +169,16 @@ export class ProviderRegistry {
             functionCall: { name: tc.name, args: tc.args },
           })),
         });
+      } else if (m.images && m.images.length > 0) {
+        // Multimodal message with images (Google format)
+        const parts = m.images.map(img => ({
+          inlineData: { mimeType: img.mimeType, data: img.data },
+        }));
+        if (m.content) parts.push({ text: m.content });
+        contents.push({
+          role: m.role === "assistant" ? "model" : "user",
+          parts,
+        });
       } else {
         contents.push({
           role: m.role === "assistant" ? "model" : "user",

package/core/secrets.mjs

@@ -44,15 +44,15 @@ export class SecretsManager {
   async resolve(key) {
     if (!key) return null;
 
-    // 1. In-memory cache
-    if (this._cache.has(key)) return this._cache.get(key);
-
-    // 2. Environment variable
+    // 1. Environment variable (always takes priority — can be overridden at runtime)
     if (process.env[key]) {
       this._cache.set(key, process.env[key]);
       return process.env[key];
     }
 
+    // 2. In-memory cache (from previous keychain/secrets.json lookup)
+    if (this._cache.has(key)) return this._cache.get(key);
+
     // 3. macOS Keychain — try common service name patterns
     const keychainValue = await this._fromKeychain(key, null);
     if (keychainValue) {

package/core/session.mjs

@@ -5,6 +5,9 @@
  *   - create({ workstream?, channel?, chatId? }) → Session
  *   - get(id) → Session
  *   - list(filter?) → Session[]
+ *   - listSessions(options?) → metadata array (from disk)
+ *   - loadSession(id) → full session with messages (alias for load)
+ *   - forkSession(id) → new session copied from existing
  *   - addMessage(id, message) → void
  *   - clear(id) → void
  *   - save(id) → void
@@ -16,7 +19,7 @@
 
 import os from "node:os";
 import path from "node:path";
-import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { readFile, writeFile, mkdir, readdir, stat } from "node:fs/promises";
 import { SESSIONS_DIR } from "./config.mjs";
 
 export class Session {
@@ -90,6 +93,109 @@ export class SessionManager {
     });
   }
 
+  /**
+   * List all sessions from disk with metadata (for CLI listing / picking).
+   * Returns sorted by updatedAt descending (most recent first).
+   *
+   * @param {object} options
+   * @param {string} [options.workstream] - Filter by workstream (default: current dir sessions only via all=false)
+   * @param {boolean} [options.all] - Include sessions from all workstreams
+   * @param {number} [options.limit] - Max sessions to return (default: 50)
+   * @returns {Array<{id, workstream, channel, chatId, createdAt, updatedAt, model, messageCount, firstMessage, cwd}>}
+   */
+  async listSessions(options = {}) {
+    const { workstream = null, all: showAll = false, limit = 50 } = options;
+    let files;
+    try {
+      files = await readdir(SESSIONS_DIR);
+    } catch {
+      return [];
+    }
+
+    const sessionFiles = files.filter(f => f.endsWith(".json"));
+    const results = [];
+
+    for (const file of sessionFiles) {
+      const id = file.replace(".json", "");
+      const filePath = path.join(SESSIONS_DIR, file);
+      try {
+        const [raw, fileStat] = await Promise.all([
+          readFile(filePath, "utf8"),
+          stat(filePath),
+        ]);
+        let data;
+        try { data = JSON.parse(raw); } catch { continue; }
+        if (!data || !data.id) continue;
+
+        // Apply workstream filter
+        if (!showAll && workstream && data.workstream !== workstream) continue;
+
+        const messages = Array.isArray(data.messages) ? data.messages : [];
+        const userMessages = messages.filter(m => m.role === "user");
+        const firstMessage = userMessages[0]?.content ?? messages[0]?.content ?? "";
+
+        results.push({
+          id: data.id,
+          workstream: data.workstream ?? "default",
+          channel: data.channel ?? null,
+          chatId: data.chatId ?? null,
+          createdAt: data.createdAt ?? fileStat.birthtime.toISOString(),
+          updatedAt: data.updatedAt ?? fileStat.mtime.toISOString(),
+          model: data.model ?? null,
+          messageCount: messages.length,
+          firstMessage: firstMessage.slice(0, 120),
+          cwd: data.cwd ?? null,
+        });
+      } catch {
+        continue;
+      }
+    }
+
+    // Sort by updatedAt descending
+    results.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+    return results.slice(0, limit);
+  }
+
+  /**
+   * Load a session by ID and return the full session (alias for load with better name).
+   * Returns null if not found.
+   */
+  async loadSession(id) {
+    return this.getOrLoad(id);
+  }
+
+  /**
+   * Fork a session: copy its message history into a new session.
+   * The new session starts from the same history but diverges from here.
+   *
+   * @param {string} id - Source session ID
+   * @param {object} opts - Additional options for the new session (workstream, etc.)
+   * @returns {Session} - The new forked session
+   */
+  async forkSession(id, opts = {}) {
+    // Load source session
+    const source = await this.getOrLoad(id);
+    if (!source) {
+      throw new Error(`Session not found: ${id}`);
+    }
+
+    // Create a new session with same metadata
+    const forked = this.create({
+      workstream: opts.workstream ?? source.workstream,
+      channel: opts.channel ?? null,
+      chatId: opts.chatId ?? null,
+    });
+
+    // Copy message history (deep copy)
+    forked.messages = source.messages.map(m => ({ ...m }));
+    forked.updatedAt = new Date().toISOString();
+
+    // Save the forked session
+    await this.save(forked.id);
+
+    return forked;
+  }
+
   /**
    * Add a message to a session.
    */

package/lib/commands/review.mjs

@@ -0,0 +1,272 @@
+/**
+ * lib/commands/review.mjs — Code review mode for Wispy
+ *
+ * wispy review                       Review uncommitted changes
+ * wispy review --base <branch>       Review against base branch
+ * wispy review --commit <sha>        Review specific commit
+ * wispy review --title <title>       Add context title
+ * wispy review --json                Output as JSON
+ */
+
+import { execSync } from "node:child_process";
+import path from "node:path";
+import { WispyEngine } from "../../core/engine.mjs";
+
+const CODE_REVIEW_SYSTEM_PROMPT = `You are a senior code reviewer. Analyze the following diff and provide:
+1. A brief summary of the changes
+2. Issues found, categorized by severity (critical, warning, info)
+3. Specific line-level comments with suggestions
+4. An overall assessment (approve, request-changes, comment)
+
+Be constructive and specific. Reference line numbers when possible.
+
+Format your response as follows:
+## Summary
+[Brief summary of what changed]
+
+## Issues Found
+### Critical
+[List critical issues, or "None" if clean]
+
+### Warnings
+[List warnings, or "None"]
+
+### Info
+[List informational notes, or "None"]
+
+## File Comments
+[File-by-file comments with line references]
+
+## Assessment
+**Verdict:** [approve | request-changes | comment]
+[Brief overall assessment]`;
+
+/**
+ * Get git diff based on options.
+ */
+function getDiff(options = {}) {
+  const { base, commit, staged, cwd = process.cwd() } = options;
+  const execOpts = { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" };
+
+  let diff = "";
+
+  if (commit) {
+    // Review a specific commit
+    try {
+      diff = execSync(`git show ${commit}`, execOpts);
+    } catch (err) {
+      throw new Error(`Failed to get commit ${commit}: ${err.stderr?.slice(0, 200) ?? err.message}`);
+    }
+  } else if (base) {
+    // Review changes since base branch
+    try {
+      diff = execSync(`git diff ${base}...HEAD`, execOpts);
+    } catch (err) {
+      throw new Error(`Failed to diff against ${base}: ${err.stderr?.slice(0, 200) ?? err.message}`);
+    }
+  } else {
+    // Default: all uncommitted changes (staged + unstaged + untracked summary)
+    try {
+      const stageDiff = execSync("git diff --cached", execOpts);
+      const unstaged = execSync("git diff", execOpts);
+      diff = [stageDiff, unstaged].filter(Boolean).join("\n");
+
+      // Also include untracked file names if any
+      try {
+        const untracked = execSync("git ls-files --others --exclude-standard", execOpts).trim();
+        if (untracked) {
+          diff += `\n\n# Untracked files:\n${untracked.split("\n").map(f => `# + ${f}`).join("\n")}`;
+        }
+      } catch {}
+    } catch (err) {
+      throw new Error(`Failed to get git diff: ${err.stderr?.slice(0, 200) ?? err.message}`);
+    }
+  }
+
+  return diff.trim();
+}
+
+/**
+ * Get some context about the repo.
+ */
+function getRepoContext(cwd = process.cwd()) {
+  const execOpts = { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" };
+  const context = {};
+
+  try {
+    context.branch = execSync("git rev-parse --abbrev-ref HEAD", execOpts).trim();
+  } catch {}
+
+  try {
+    context.lastCommit = execSync("git log -1 --pretty=%B", execOpts).trim().slice(0, 200);
+  } catch {}
+
+  try {
+    const stat = execSync("git diff --stat", execOpts).trim();
+    context.stat = stat.slice(0, 500);
+  } catch {}
+
+  return context;
+}
+
+/**
+ * Parse the AI review response into structured JSON.
+ */
+function parseReviewResponse(text) {
+  const result = {
+    summary: "",
+    issues: { critical: [], warning: [], info: [] },
+    fileComments: [],
+    assessment: { verdict: "comment", explanation: "" },
+    raw: text,
+  };
+
+  // Extract summary
+  const summaryMatch = text.match(/## Summary\n([\s\S]*?)(?=##|$)/);
+  if (summaryMatch) result.summary = summaryMatch[1].trim();
+
+  // Extract issues
+  const criticalMatch = text.match(/### Critical\n([\s\S]*?)(?=###|##|$)/);
+  if (criticalMatch) {
+    const content = criticalMatch[1].trim();
+    if (content && content.toLowerCase() !== "none") {
+      result.issues.critical = content.split("\n").filter(l => l.trim() && l.trim() !== "-").map(l => l.replace(/^[-*•]\s*/, "").trim());
+    }
+  }
+
+  const warningsMatch = text.match(/### Warning[s]?\n([\s\S]*?)(?=###|##|$)/);
+  if (warningsMatch) {
+    const content = warningsMatch[1].trim();
+    if (content && content.toLowerCase() !== "none") {
+      result.issues.warning = content.split("\n").filter(l => l.trim() && l.trim() !== "-").map(l => l.replace(/^[-*•]\s*/, "").trim());
+    }
+  }
+
+  const infoMatch = text.match(/### Info\n([\s\S]*?)(?=###|##|$)/);
+  if (infoMatch) {
+    const content = infoMatch[1].trim();
+    if (content && content.toLowerCase() !== "none") {
+      result.issues.info = content.split("\n").filter(l => l.trim() && l.trim() !== "-").map(l => l.replace(/^[-*•]\s*/, "").trim());
+    }
+  }
+
+  // Extract assessment
+  const assessmentMatch = text.match(/## Assessment\n([\s\S]*?)(?=##|$)/);
+  if (assessmentMatch) {
+    const assessText = assessmentMatch[1].trim();
+    const verdictMatch = assessText.match(/\*\*Verdict:\*\*\s*(approve|request-changes|comment)/i);
+    if (verdictMatch) result.assessment.verdict = verdictMatch[1].toLowerCase();
+    result.assessment.explanation = assessText.replace(/\*\*Verdict:\*\*[^\n]*\n?/, "").trim();
+  }
+
+  return result;
+}
+
+/**
+ * Main review handler.
+ */
+export async function handleReviewCommand(args = []) {
+  // Parse args
+  const options = {
+    base: null,
+    commit: null,
+    title: null,
+    json: false,
+    cwd: process.cwd(),
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--base" && args[i + 1]) { options.base = args[++i]; }
+    else if (args[i] === "--commit" && args[i + 1]) { options.commit = args[++i]; }
+    else if (args[i] === "--title" && args[i + 1]) { options.title = args[++i]; }
+    else if (args[i] === "--json") { options.json = true; }
+  }
+
+  // Check git
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      cwd: options.cwd, stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch {
+    console.error("❌ Not inside a git repository.");
+    process.exit(1);
+  }
+
+  // Get the diff
+  let diff;
+  try {
+    diff = getDiff(options);
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
+
+  if (!diff) {
+    console.log("✅ Nothing to review — no changes found.");
+    process.exit(0);
+  }
+
+  const context = getRepoContext(options.cwd);
+
+  // Build review prompt
+  let prompt = "";
+  if (options.title) prompt += `# ${options.title}\n\n`;
+  if (context.branch) prompt += `**Branch:** \`${context.branch}\`\n`;
+  if (options.base) prompt += `**Review type:** Changes since \`${options.base}\`\n`;
+  if (options.commit) prompt += `**Commit:** \`${options.commit}\`\n`;
+  if (context.stat) prompt += `\n**Stats:**\n\`\`\`\n${context.stat}\n\`\`\`\n`;
+  prompt += `\n**Diff:**\n\`\`\`diff\n${diff.slice(0, 50_000)}\n\`\`\``;
+
+  if (diff.length > 50_000) {
+    prompt += `\n\n*(diff truncated — ${diff.length} chars total)*`;
+  }
+
+  // Show what we're reviewing
+  if (!options.json) {
+    if (options.commit) {
+      console.log(`\n🔍 Reviewing commit ${options.commit}...`);
+    } else if (options.base) {
+      console.log(`\n🔍 Reviewing changes since ${options.base}...`);
+    } else {
+      console.log("\n🔍 Reviewing uncommitted changes...");
+    }
+    if (context.stat) {
+      console.log(`\n${context.stat}\n`);
+    }
+    process.stdout.write("🌿 ");
+  }
+
+  // Send to AI
+  let reviewText = "";
+  try {
+    const engine = new WispyEngine();
+    const initResult = await engine.init({ skipMcp: true });
+    if (!initResult) {
+      console.error("❌ No AI provider configured. Set an API key to use code review.");
+      process.exit(1);
+    }
+
+    const response = await engine.processMessage(null, prompt, {
+      systemPrompt: CODE_REVIEW_SYSTEM_PROMPT,
+      onChunk: options.json ? null : (chunk) => process.stdout.write(chunk),
+      noSave: true,
+      skipSkillCapture: true,
+      skipUserModel: true,
+    });
+
+    reviewText = response.content;
+    try { engine.destroy(); } catch {}
+  } catch (err) {
+    console.error(`❌ Review failed: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (!options.json) {
+    console.log("\n");
+    return;
+  }
+
+  // JSON output
+  const structured = parseReviewResponse(reviewText);
+  console.log(JSON.stringify(structured, null, 2));
+}