wispy-cli 2.7.9 → 2.7.11

package/core/loop-detector.mjs

@@ -0,0 +1,183 @@
+/**
+ * core/loop-detector.mjs — Tool-call loop detection for Wispy
+ *
+ * Detects four patterns:
+ *   1. Exact repeat: same tool + same args hash 3+ times in window
+ *   2. Oscillation: A→B→A→B pattern (alternating between two calls)
+ *   3. No progress: 5+ tool calls where result hash doesn't change
+ *   4. Error loop: same tool fails 3+ times in a row
+ *
+ * v1.0.0
+ */
+
+import { createHash } from "node:crypto";
+import { EventEmitter } from "node:events";
+
+/**
+ * Compute a short hash of any value.
+ */
+function hashValue(value) {
+  if (value === null || value === undefined) return "null";
+  let str;
+  try {
+    str = JSON.stringify(value);
+  } catch {
+    str = String(value);
+  }
+  return createHash("sha1").update(str).digest("hex").slice(0, 16);
+}
+
+export class LoopDetector extends EventEmitter {
+  /**
+   * @param {object} options
+   * @param {number} options.windowSize  - Look at last N calls (default 10)
+   * @param {number} options.maxRepeats  - Same call N times = loop (default 3)
+   * @param {number} options.maxNoProgress - N calls with no new output = stuck (default 5)
+   */
+  constructor(options = {}) {
+    super();
+    this.windowSize = options.windowSize ?? 10;
+    this.maxRepeats = options.maxRepeats ?? 3;
+    this.maxNoProgress = options.maxNoProgress ?? 5;
+
+    // Array of { tool, argsHash, resultHash, isError, timestamp }
+    this._history = [];
+
+    // How many warnings have been emitted (to decide force-break)
+    this._warningCount = 0;
+  }
+
+  /**
+   * Record a tool call result.
+   * @param {string} toolName
+   * @param {object} args
+   * @param {any} result  - The result (or Error/string on failure)
+   */
+  record(toolName, args, result) {
+    const argsHash = hashValue(args);
+    const isError = (result && typeof result === "object" && result.success === false)
+      || (result instanceof Error);
+
+    // Use error message as result hash if error, so errors are deduplicated
+    const resultForHash = isError
+      ? (result?.error ?? result?.message ?? "error")
+      : result;
+
+    const resultHash = hashValue(resultForHash);
+
+    this._history.push({
+      tool: toolName,
+      argsHash,
+      resultHash,
+      isError,
+      timestamp: Date.now(),
+    });
+
+    // Keep only the window
+    if (this._history.length > this.windowSize) {
+      this._history = this._history.slice(-this.windowSize);
+    }
+  }
+
+  /**
+   * Check if the agent is in a loop.
+   * @returns {{ looping: boolean, reason?: string, suggestion?: string, warningCount: number }}
+   */
+  check() {
+    const history = this._history;
+    if (history.length < 2) return { looping: false, warningCount: this._warningCount };
+
+    // ── 1. Exact repeat: same tool + same args hash N+ times in window ────────
+    const callKey = (e) => `${e.tool}:${e.argsHash}`;
+    const counts = new Map();
+    for (const entry of history) {
+      const key = callKey(entry);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    for (const [key, count] of counts) {
+      if (count >= this.maxRepeats) {
+        const [tool] = key.split(":");
+        this._warningCount++;
+        return {
+          looping: true,
+          reason: `exact_repeat`,
+          tool,
+          count,
+          warningCount: this._warningCount,
+          suggestion: `Loop detected: you've called ${tool} with the same arguments ${count} times. Try a different approach or verify the outcome before retrying.`,
+        };
+      }
+    }
+
+    // ── 2. Oscillation: A→B→A→B pattern ─────────────────────────────────────
+    if (history.length >= 4) {
+      const last4 = history.slice(-4).map(callKey);
+      // A→B→A→B
+      if (last4[0] === last4[2] && last4[1] === last4[3] && last4[0] !== last4[1]) {
+        const toolA = history[history.length - 4].tool;
+        const toolB = history[history.length - 3].tool;
+        this._warningCount++;
+        return {
+          looping: true,
+          reason: `oscillation`,
+          tool: `${toolA}↔${toolB}`,
+          warningCount: this._warningCount,
+          suggestion: `Loop detected: oscillating between ${toolA} and ${toolB}. These calls aren't making progress. Try a different strategy.`,
+        };
+      }
+    }
+
+    // ── 3. No progress: N consecutive calls with identical result hash ────────
+    if (history.length >= this.maxNoProgress) {
+      const recent = history.slice(-this.maxNoProgress);
+      const firstHash = recent[0].resultHash;
+      // All results are the same AND none are "null" (null = tool produced nothing)
+      if (firstHash !== "null" && recent.every(e => e.resultHash === firstHash)) {
+        const tool = recent[recent.length - 1].tool;
+        this._warningCount++;
+        return {
+          looping: true,
+          reason: `no_progress`,
+          tool,
+          count: this.maxNoProgress,
+          warningCount: this._warningCount,
+          suggestion: `Loop detected: ${this.maxNoProgress} consecutive tool calls produced identical results. The agent appears to be stuck — try a different approach.`,
+        };
+      }
+    }
+
+    // ── 4. Error loop: same tool fails 3+ times in a row ─────────────────────
+    if (history.length >= 3) {
+      const recent = history.slice(-3);
+      if (recent.every(e => e.isError && e.tool === recent[0].tool)) {
+        const tool = recent[0].tool;
+        this._warningCount++;
+        return {
+          looping: true,
+          reason: `error_loop`,
+          tool,
+          count: 3,
+          warningCount: this._warningCount,
+          suggestion: `Loop detected: ${tool} has failed 3 times in a row. Stop retrying and try a different approach or report the error.`,
+        };
+      }
+    }
+
+    return { looping: false, warningCount: this._warningCount };
+  }
+
+  /**
+   * Reset the detector state (e.g., after user intervention or successful progress).
+   */
+  reset() {
+    this._history = [];
+    this._warningCount = 0;
+  }
+
+  /**
+   * Returns the number of recorded entries.
+   */
+  get size() {
+    return this._history.length;
+  }
+}

package/core/memory.mjs

@@ -6,6 +6,12 @@
  * - daily/YYYY-MM-DD.md — daily logs
  * - projects/<name>.md — project-specific memory
  * - user.md — user preferences/info
+ *
+ * v2.8+ enhancements:
+ * - getRelevantMemories() — keyword + recency scoring for context injection
+ * - autoExtractFacts() — auto-flush important facts from conversation
+ * - Fuzzy search with recency + frequency weighting
+ * - Access frequency tracking
  */
 
 import path from "node:path";
@@ -13,10 +19,14 @@ import { readFile, writeFile, appendFile, mkdir, readdir, unlink, stat } from "n
 
 const MAX_SEARCH_RESULTS = 20;
 const MAX_SNIPPET_CHARS = 200;
+// How many messages must accumulate before autoExtractFacts triggers
+const AUTO_EXTRACT_INTERVAL = 10;
 
 export class MemoryManager {
   constructor(wispyDir) {
     this.memoryDir = path.join(wispyDir, "memory");
+    // Frequency tracking: key → access count (in-memory only, resets per session)
+    this._accessFrequency = new Map();
   }
 
   /**
@@ -88,6 +98,8 @@ export class MemoryManager {
     const filePath = this._keyToPath(key);
     try {
       const content = await readFile(filePath, "utf8");
+      // Track access frequency
+      this._accessFrequency.set(key, (this._accessFrequency.get(key) ?? 0) + 1);
       return { key, content, path: filePath };
     } catch {
       return null;
@@ -281,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));
+  }
 }