@memtensor/memos-local-openclaw-plugin 0.1.2 → 0.1.4

package/src/viewer/server.ts

@@ -155,7 +155,10 @@ export class ViewerServer {
 
       if (p === "/api/memories" && req.method === "GET") this.serveMemories(res, url);
       else if (p === "/api/stats") this.serveStats(res);
+      else if (p === "/api/metrics") this.serveMetrics(res, url);
       else if (p === "/api/search") this.serveSearch(req, res, url);
+      else if (p === "/api/tasks" && req.method === "GET") this.serveTasks(res, url);
+      else if (p.startsWith("/api/task/") && req.method === "GET") this.serveTaskDetail(res, p);
       else if (p === "/api/memory" && req.method === "POST") this.handleCreate(req, res);
       else if (p.startsWith("/api/memory/") && req.method === "PUT") this.handleUpdate(req, res, p);
       else if (p.startsWith("/api/memory/") && req.method === "DELETE") this.handleDelete(res, p);
@@ -302,12 +305,70 @@ export class ViewerServer {
     const totalRow = db.prepare("SELECT COUNT(*) as count FROM chunks" + where).get(...params) as any;
     const memories = db.prepare("SELECT * FROM chunks" + where + ` ORDER BY created_at ${sortBy} LIMIT ? OFFSET ?`).all(...params, limit, offset);
 
+    this.store.recordViewerEvent("list");
     this.jsonResponse(res, {
       memories, page, limit, total: totalRow.count,
       totalPages: Math.ceil(totalRow.count / limit),
     });
   }
 
+  private serveMetrics(res: http.ServerResponse, url: URL): void {
+    const days = Math.min(90, Math.max(7, Number(url.searchParams.get("days")) || 30));
+    const data = this.store.getMetrics(days);
+    this.jsonResponse(res, data);
+  }
+
+  private serveTasks(res: http.ServerResponse, url: URL): void {
+    this.store.recordViewerEvent("tasks_list");
+    const status = url.searchParams.get("status") ?? undefined;
+    const limit = Math.min(100, Math.max(1, Number(url.searchParams.get("limit")) || 50));
+    const offset = Math.max(0, Number(url.searchParams.get("offset")) || 0);
+    const { tasks, total } = this.store.listTasks({ status, limit, offset });
+
+    const items = tasks.map((t) => ({
+      id: t.id,
+      sessionKey: t.sessionKey,
+      title: t.title,
+      summary: t.summary ? (t.summary.length > 300 ? t.summary.slice(0, 297) + "..." : t.summary) : "",
+      status: t.status,
+      startedAt: t.startedAt,
+      endedAt: t.endedAt,
+      chunkCount: this.store.countChunksByTask(t.id),
+    }));
+
+    this.jsonResponse(res, { tasks: items, total, limit, offset });
+  }
+
+  private serveTaskDetail(res: http.ServerResponse, urlPath: string): void {
+    const taskId = urlPath.replace("/api/task/", "");
+    const task = this.store.getTask(taskId);
+    if (!task) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Task not found" }));
+      return;
+    }
+
+    const chunks = this.store.getChunksByTask(taskId);
+    const chunkItems = chunks.map((c) => ({
+      id: c.id,
+      role: c.role,
+      content: c.content.length > 500 ? c.content.slice(0, 497) + "..." : c.content,
+      summary: c.summary,
+      createdAt: c.createdAt,
+    }));
+
+    this.jsonResponse(res, {
+      id: task.id,
+      sessionKey: task.sessionKey,
+      title: task.title,
+      summary: task.summary,
+      status: task.status,
+      startedAt: task.startedAt,
+      endedAt: task.endedAt,
+      chunks: chunkItems,
+    });
+  }
+
   private serveStats(res: http.ServerResponse): void {
     const db = (this.store as any).db;
     const total = db.prepare("SELECT COUNT(*) as count FROM chunks").get() as any;
@@ -385,6 +446,7 @@ export class ViewerServer {
       if (!seenIds.has(r.id)) { seenIds.add(r.id); merged.push(r); }
     }
 
+    this.store.recordViewerEvent("search");
     this.jsonResponse(res, {
       results: merged,
       query: q,
@@ -407,7 +469,7 @@ export class ViewerServer {
           id, sessionKey: data.session_key || "manual", turnId: `manual-${now}`, seq: 0,
           role: data.role || "user", content: data.content || "", kind: data.kind || "paragraph",
           summary: data.summary || data.content?.slice(0, 100) || "",
-          createdAt: now, updatedAt: now, embedding: null,
+          taskId: null, createdAt: now, updatedAt: now, embedding: null,
         });
         this.jsonResponse(res, { ok: true, id, message: "Memory created" });
       } catch (err) {

package/SKILL.md

@@ -1,43 +0,0 @@
-# Memory Recall Skill — memos-local
-
-You have access to long-term conversation memory through three tools:
-`memory_search`, `memory_timeline`, `memory_get`.
-
-## When to Search
-
-- **DO search** when the user asks about a previous conversation, a specific detail (command, error, parameter, decision) you don't have in the current context, or when the topic clearly references past interactions.
-- **DO NOT search** when the current context already contains enough information to answer accurately.
-
-## Progressive Recall Chain
-
-Follow this 3-step chain. Stop as soon as you have sufficient evidence.
-
-### Step 1 — `memory_search`
-
-Start with the default call (no extra parameters → top 6 results, minScore 0.45).
-
-- If results are insufficient, **refine the query first** (add entity names, exact commands, error keywords).
-- If still insufficient, increase `maxResults` to 12, then 20.
-- As a last resort, lower `minScore` to 0.35.
-- **Never repeat the exact same query with the same parameters** — vary query wording or adjust parameters.
-
-### Step 2 — `memory_timeline`
-
-When a search hit looks relevant but the `original_excerpt` is too short to confirm, call `memory_timeline` with the hit's `ref` to get surrounding context (±2 turns by default).
-
-### Step 3 — `memory_get`
-
-When you need the exact original text (to verify a command, a code snippet, an error stack), call `memory_get` with the `ref` and request up to 2000 characters (max 8000).
-
-## How to Answer
-
-1. **Evidence-based**: Only state facts backed by `original_excerpt`, timeline entries, or `memory_get` content. Do not fabricate details.
-2. **Cite sources**: When referencing a memory, mention the approximate time and context (e.g., "In our conversation about deploying the API…").
-3. **Acknowledge gaps**: If memory search returns no relevant results, say so honestly rather than guessing.
-
-## Anti-Patterns to Avoid
-
-- Searching on every single turn (only search when needed).
-- Repeating the same failed query without modification.
-- Ignoring `original_excerpt` and only using `summary` — the excerpt is the primary evidence.
-- Making claims based solely on `summary` without checking the original text when details matter.