assistme 0.2.8 → 0.3.0

package/src/agent/memory.test.ts

@@ -1,45 +1,9 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
-// Build a fluent mock that mimics the Supabase query builder chain
-function createSupabaseMock() {
-  let finalResult: Record<string, unknown> = { data: [], error: null };
-
-  const chain: Record<string, unknown> = {};
-  const methods = [
-    "select", "insert", "update", "delete", "eq", "neq", "not",
-    "or", "in", "order", "limit", "single", "from",
-  ];
-  for (const method of methods) {
-    chain[method] = vi.fn().mockReturnValue(chain);
-  }
-
-  // Make the chain thenable (for await)
-  chain.then = (resolve: (value: unknown) => void) => resolve(finalResult);
-  chain.single = vi.fn().mockImplementation(() => {
-    const singleChain = { ...chain, then: (resolve: (value: unknown) => void) => resolve(finalResult) };
-    return singleChain;
-  });
+const mockCallMcpHandler = vi.fn();
 
-  const mockSupabase = {
-    from: vi.fn().mockReturnValue(chain),
-    _chain: chain,
-    _setResult(result: Record<string, unknown>) {
-      finalResult = result;
-      chain.then = (resolve: (value: unknown) => void) => resolve(result);
-      chain.single = vi.fn().mockImplementation(() => ({
-        ...chain,
-        then: (resolve: (value: unknown) => void) => resolve(result),
-      }));
-    },
-  };
-
-  return mockSupabase;
-}
-
-let mockSb: ReturnType<typeof createSupabaseMock>;
-
-vi.mock("../db/supabase.js", () => ({
-  getSupabase: () => mockSb,
+vi.mock("../db/api-client.js", () => ({
+  callMcpHandler: (...args: unknown[]) => mockCallMcpHandler(...args),
 }));
 
 vi.mock("../utils/logger.js", () => ({
@@ -58,12 +22,11 @@ describe("MemoryManager", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockSb = createSupabaseMock();
     manager = new MemoryManager("user-123");
   });
 
   describe("remember()", () => {
-    it("inserts a memory with default values", async () => {
+    it("stores a memory with default values", async () => {
       const mockData = {
         id: "mem-1",
         user_id: "user-123",
@@ -77,16 +40,23 @@ describe("MemoryManager", () => {
         last_accessed_at: null,
         created_at: "2026-01-01",
       };
-      mockSb._setResult({ data: mockData, error: null });
+      mockCallMcpHandler.mockResolvedValueOnce(mockData);
 
       const result = await manager.remember("User prefers dark mode");
 
-      expect(mockSb.from).toHaveBeenCalledWith("agent_memories");
+      expect(mockCallMcpHandler).toHaveBeenCalledWith("memory.store", {
+        category: "general",
+        content: "User prefers dark mode",
+        importance: 5,
+        tags: [],
+        source_message_id: null,
+        expires_at: null,
+      });
       expect(result.content).toBe("User prefers dark mode");
       expect(result.category).toBe("general");
     });
 
-    it("inserts with custom category and importance", async () => {
+    it("stores with custom category and importance", async () => {
       const mockData = {
         id: "mem-2",
         user_id: "user-123",
@@ -100,7 +70,7 @@ describe("MemoryManager", () => {
         last_accessed_at: null,
         created_at: "2026-01-01",
       };
-      mockSb._setResult({ data: mockData, error: null });
+      mockCallMcpHandler.mockResolvedValueOnce(mockData);
 
       const result = await manager.remember("Likes TypeScript", "preference", {
         importance: 8,
@@ -112,12 +82,10 @@ describe("MemoryManager", () => {
       expect(result.importance).toBe(8);
     });
 
-    it("throws on DB error", async () => {
-      mockSb._setResult({ data: null, error: { message: "DB down" } });
+    it("throws on edge function error", async () => {
+      mockCallMcpHandler.mockRejectedValueOnce(new Error("Edge function error"));
 
-      await expect(manager.remember("test")).rejects.toThrow(
-        "Failed to store memory"
-      );
+      await expect(manager.remember("test")).rejects.toThrow();
     });
 
     it("computes expiry from expiresInDays", async () => {
@@ -134,46 +102,54 @@ describe("MemoryManager", () => {
         last_accessed_at: null,
         created_at: "2026-01-01",
       };
-      mockSb._setResult({ data: mockData, error: null });
+      mockCallMcpHandler.mockResolvedValueOnce(mockData);
 
       const result = await manager.remember("temp context", "context", {
         expiresInDays: 7,
       });
 
       expect(result.expires_at).not.toBeNull();
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "memory.store",
+        expect.objectContaining({
+          expires_at: expect.any(String),
+        })
+      );
     });
   });
 
   describe("buildMemoryPrompt()", () => {
     it("returns empty string when no memories", async () => {
-      mockSb._setResult({ data: [], error: null });
+      mockCallMcpHandler.mockResolvedValueOnce([]);
       const result = await manager.buildMemoryPrompt();
       expect(result).toBe("");
     });
   });
 
   describe("list()", () => {
-    it("queries agent_memories with user_id filter", async () => {
-      mockSb._setResult({ data: [], error: null });
+    it("calls memory.list action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce([]);
       await manager.list();
-      expect(mockSb.from).toHaveBeenCalledWith("agent_memories");
-      expect(mockSb._chain.eq).toHaveBeenCalledWith("user_id", "user-123");
+      expect(mockCallMcpHandler).toHaveBeenCalledWith("memory.list", {
+        category: null,
+        limit: 20,
+      });
     });
 
-    it("throws on DB error", async () => {
-      mockSb._setResult({ data: null, error: { message: "fail" } });
-      await expect(manager.list()).rejects.toThrow("Failed to list memories");
+    it("returns empty array on null response", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(null);
+      const result = await manager.list();
+      expect(result).toEqual([]);
     });
   });
 
   describe("remove()", () => {
-    it("calls delete on agent_memories", async () => {
-      mockSb._setResult({ error: null });
+    it("calls memory.remove action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(undefined);
       await manager.remove("mem-1");
-      expect(mockSb.from).toHaveBeenCalledWith("agent_memories");
-      expect(mockSb._chain.delete).toHaveBeenCalled();
-      expect(mockSb._chain.eq).toHaveBeenCalledWith("id", "mem-1");
-      expect(mockSb._chain.eq).toHaveBeenCalledWith("user_id", "user-123");
+      expect(mockCallMcpHandler).toHaveBeenCalledWith("memory.remove", {
+        memory_id: "mem-1",
+      });
     });
   });
 });

package/src/agent/memory.ts

@@ -1,4 +1,4 @@
-import { getSupabase } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
 
 export type MemoryCategory =
@@ -26,10 +26,8 @@ export interface Memory {
 // ── Memory Manager ──────────────────────────────────────────────────
 
 export class MemoryManager {
-  private userId: string;
-
-  constructor(userId: string) {
-    this.userId = userId;
+  constructor(_userId: string) {
+    // userId is no longer needed — auth is handled by the MCP token in callMcpHandler
   }
 
   /**
@@ -46,74 +44,38 @@ export class MemoryManager {
       expiresInDays?: number;
     }
   ): Promise<Memory> {
-    const sb = getSupabase();
-
     const expiresAt = options?.expiresInDays
       ? new Date(
           Date.now() + options.expiresInDays * 86400_000
         ).toISOString()
       : null;
 
-    const { data, error } = await sb
-      .from("agent_memories")
-      .insert({
-        user_id: this.userId,
-        category,
-        content,
-        importance: options?.importance ?? 5,
-        tags: options?.tags ?? [],
-        source_message_id: options?.sourceMessageId ?? null,
-        expires_at: expiresAt,
-      })
-      .select()
-      .single();
+    const data = await callMcpHandler<Memory>("memory.store", {
+      category,
+      content,
+      importance: options?.importance ?? 5,
+      tags: options?.tags ?? [],
+      source_message_id: options?.sourceMessageId ?? null,
+      expires_at: expiresAt,
+    });
 
-    if (error) throw new Error(`Failed to store memory: ${error.message}`);
     log.debug(`Memory stored: [${category}] ${content.slice(0, 80)}...`);
-    return data as Memory;
+    return data;
   }
 
   /**
    * Search memories by query text. Uses ILIKE + tag containment.
    */
   async search(query: string, limit = 10): Promise<Memory[]> {
-    const sb = getSupabase();
-
-    // Sanitize query for use in ILIKE to prevent injection
-    const sanitized = query.replace(/[%_]/g, "\\$&");
-
-    const { data, error } = await sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .or(
-        `content.ilike.%${sanitized}%,tags.cs.{${sanitized}}`
-      )
-      .order("importance", { ascending: false })
-      .limit(limit);
-
-    if (error) {
-      log.warn(`Memory search failed: ${error.message}`);
+    try {
+      return await callMcpHandler<Memory[]>("memory.search", {
+        query,
+        limit,
+      });
+    } catch (err) {
+      log.warn(`Memory search failed: ${err instanceof Error ? err.message : err}`);
       return [];
     }
-
-    // Increment access_count for each matched memory individually
-    if (data && data.length > 0) {
-      const now = new Date().toISOString();
-      await Promise.all(
-        data.map((m) =>
-          sb
-            .from("agent_memories")
-            .update({
-              access_count: m.access_count + 1,
-              last_accessed_at: now,
-            })
-            .eq("id", m.id)
-        )
-      );
-    }
-
-    return (data || []) as Memory[];
   }
 
   /**
@@ -122,49 +84,13 @@ export class MemoryManager {
    * Automatically filters out expired memories.
    */
   async getContext(maxItems = 20): Promise<Memory[]> {
-    const sb = getSupabase();
-    const now = new Date().toISOString();
-
-    // Get instructions first (always relevant)
-    const { data: instructions } = await sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .eq("category", "instruction")
-      .or(`expires_at.is.null,expires_at.gt.${now}`)
-      .order("importance", { ascending: false })
-      .limit(5);
-
-    // Get preferences
-    const { data: preferences } = await sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .eq("category", "preference")
-      .or(`expires_at.is.null,expires_at.gt.${now}`)
-      .order("importance", { ascending: false })
-      .limit(5);
-
-    // Get most important general memories
-    const { data: general } = await sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .not("category", "in", '("instruction","preference")')
-      .or(`expires_at.is.null,expires_at.gt.${now}`)
-      .order("importance", { ascending: false })
-      .order("updated_at", { ascending: false })
-      .limit(maxItems - 10);
-
-    const all = [
-      ...(instructions || []),
-      ...(preferences || []),
-      ...(general || []),
-    ] as Memory[];
+    const all = await callMcpHandler<Memory[]>("memory.get_context", {
+      max_items: maxItems,
+    });
 
     // Deduplicate by id
     const seen = new Set<string>();
-    return all.filter((m) => {
+    return (all || []).filter((m) => {
       if (seen.has(m.id)) return false;
       seen.add(m.id);
       return true;
@@ -210,22 +136,11 @@ export class MemoryManager {
     category?: MemoryCategory,
     limit = 20
   ): Promise<Memory[]> {
-    const sb = getSupabase();
-    let query = sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .order("importance", { ascending: false })
-      .order("created_at", { ascending: false })
-      .limit(limit);
-
-    if (category) {
-      query = query.eq("category", category);
-    }
-
-    const { data, error } = await query;
-    if (error) throw new Error(`Failed to list memories: ${error.message}`);
-    return (data || []) as Memory[];
+    const data = await callMcpHandler<Memory[]>("memory.list", {
+      category: category || null,
+      limit,
+    });
+    return data || [];
   }
 
   async add(
@@ -238,29 +153,13 @@ export class MemoryManager {
   }
 
   async remove(memoryId: string): Promise<void> {
-    const sb = getSupabase();
-    const { error } = await sb
-      .from("agent_memories")
-      .delete()
-      .eq("id", memoryId)
-      .eq("user_id", this.userId);
-
-    if (error) throw new Error(`Failed to delete memory: ${error.message}`);
+    await callMcpHandler("memory.remove", { memory_id: memoryId });
   }
 
   async clear(category?: MemoryCategory): Promise<number> {
-    const sb = getSupabase();
-    let query = sb
-      .from("agent_memories")
-      .delete()
-      .eq("user_id", this.userId);
-
-    if (category) {
-      query = query.eq("category", category);
-    }
-
-    const { error, count } = await query.select("id");
-    if (error) throw new Error(`Failed to clear memories: ${error.message}`);
-    return count || 0;
+    const result = await callMcpHandler<{ count: number }>("memory.clear", {
+      category: category || null,
+    });
+    return result.count;
   }
 }

package/src/agent/processor.ts

@@ -21,6 +21,7 @@ import { getBrowser } from "../tools/browser.js";
 import { MemoryManager } from "./memory.js";
 import { SkillManager } from "./skills.js";
 import { type ToolCallRecord } from "./skill-extractor.js";
+import { evaluateAndMaybeCreateSkill } from "./skill-evaluator.js";
 import { withRetry } from "../utils/retry.js";
 import {
   createBrowserMcpServer,
@@ -58,15 +59,25 @@ Available capabilities:
    - PROACTIVELY use memory_store during tasks when you discover user preferences, habits, or important context
    - Before completing a task, consider if anything learned should be remembered for future conversations
 
-4. SKILL PLANNING (pre-task):
-   - Before executing a complex task, analyze if it matches an existing skill (use skill_invoke)
-   - If no matching skill exists, consider whether this task represents a reusable workflow
-   - To create a new skill: use skill_create to save a draft, then ASK the user if they want to add it
-   - If the user approves, use skill_add to add it to their collection, then proceed with the task
-   - If a skill's instructions could be improved based on your experience, use skill_improve
-   - Use skill_search to find relevant skills when the task doesn't obviously match the listed skills
-   - Skills use {{variable_name}} placeholders for user-specific data (repos, channels, boards, etc.)
-   - Use skill_configure to set variable values after creating skills or when the user provides their data
+4. SKILL-AWARE EXECUTION (CRITICAL — follow this for EVERY task):
+   Step A — Search: Before executing ANY task, check if an existing skill matches (use skill_invoke or skill_search).
+   Step B — If skill found: load it with skill_invoke and follow its instructions precisely. If the instructions are incomplete or wrong, adapt and improve as you go — note what changed.
+   Step C — If NO skill found: BEFORE executing, draft a skill plan following the Agent Skills format:
+     Skill Draft: [kebab-case-name]
+     Description: [what this skill does and when to use it]
+     Steps:
+     1. [first step]
+     2. [second step]
+     ...
+     The draft should be a reusable workflow, not specific to this one request. Use generic placeholders where the user provided specific values.
+   Step D — Execute: Follow the skill draft (or loaded skill) step by step. Refine the draft as you discover better approaches, edge cases, or missing steps.
+   Step E — After execution: The system will automatically evaluate whether to save the skill. You do NOT need to call skill_create manually.
+
+   Agent Skills format reference (agentskills.io):
+   - name: 1-64 chars, lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens
+   - description: 1-1024 chars, describe what the skill does AND when to use it, include keywords for discoverability
+   - body: markdown step-by-step instructions, examples, edge cases. Keep under 500 lines.
+   - Progressive disclosure: metadata (~100 tokens) → instructions (<5000 tokens) → references (on demand)
 
 5. JOB AUTOMATION:
    - When the user describes their job/role/daily work, use skill_generate to decompose it into automatable skills
@@ -103,6 +114,14 @@ Guidelines:
 - Summarize results clearly at the end
 - When you learn something about the user (preferences, habits), use memory_store to remember it
 
+CRITICAL — Ask before you guess:
+- Before executing a task, verify you have all required information. If anything is ambiguous or missing, use request_user_input to ask.
+- First try to resolve unknowns yourself: check memories, read workspace files (e.g. git remote, config files), or infer from conversation history.
+- If you still lack a critical piece of information after self-resolution, ASK the user via request_user_input. Do NOT guess, assume defaults, or proceed with incomplete information.
+- Examples of when to ask: which account/repo/project to target, what format the user wants, which of multiple options to choose, credentials or URLs that cannot be inferred.
+- Keep questions specific and actionable. Explain what you already know and what exactly you need.
+- After receiving the answer, store it with memory_store if it is likely to be useful in future conversations.
+
 Workspace path: {workspace_path}`;
 
 const MAX_HISTORY_ENTRIES = 10;
@@ -134,6 +153,22 @@ export class TaskProcessor {
     this.sessionId = sessionId;
   }
 
+  /**
+   * Post-task: resume the same Agent SDK session to evaluate whether
+   * to create/update a skill. The agent already has full context from
+   * the task it just completed — no need to re-describe anything.
+   */
+  private async evaluateSkillPostTask(
+    agentSessionId: string,
+    model: string
+  ): Promise<void> {
+    await evaluateAndMaybeCreateSkill({
+      sessionId: agentSessionId,
+      skillManager: this.skillManager,
+      model,
+    });
+  }
+
   async processTask(task: AgentTask): Promise<void> {
     const config = getConfig();
     resetEventSequence();
@@ -150,6 +185,7 @@ export class TaskProcessor {
     let finalResponse = "";
     const toolCallRecords: ToolCallRecord[] = [];
     let tokenUsage: Record<string, number> | undefined;
+    let agentSessionId: string | undefined;
 
     try {
       // Task is already claimed atomically by pollAndClaimTask in session.ts
@@ -171,7 +207,8 @@ export class TaskProcessor {
       }
 
       // Inject lightweight skill descriptions (full content loaded on-demand via skill_invoke)
-      const skillPrompt = this.skillManager.buildSkillDescriptions();
+      // Pass task prompt so relevant skills are prioritized to the top
+      const skillPrompt = this.skillManager.buildSkillDescriptions(task.prompt);
       if (skillPrompt) {
         systemPrompt += skillPrompt;
       }
@@ -234,13 +271,13 @@ export class TaskProcessor {
         "mcp__assistme-agent__skill_improve",
         "mcp__assistme-agent__skill_invoke",
         "mcp__assistme-agent__skill_search",
-        "mcp__assistme-agent__skill_configure",
         "mcp__assistme-agent__skill_generate",
         "mcp__assistme-agent__skill_link_job",
         "mcp__assistme-agent__skill_browse",
         "mcp__assistme-agent__skill_add",
         "mcp__assistme-agent__skill_publish",
-        // User confirmation
+        // User interaction
+        "mcp__assistme-agent__request_user_input",
         "mcp__assistme-agent__request_user_confirmation",
         // Job automation tools
         "mcp__assistme-agent__job_run",
@@ -275,7 +312,7 @@ export class TaskProcessor {
           "assistme-agent": agentToolsServer,
         },
         hooks: eventHooks,
-        persistSession: false,
+        persistSession: true,
         abortController,
       };
 
@@ -347,7 +384,10 @@ export class TaskProcessor {
             }
 
             default:
-              // system, user, tool_progress, etc. — log but no action needed
+              // Capture session ID from init message for post-task session resume
+              if (message.type === "system" && "subtype" in message && (message as Record<string, unknown>).subtype === "init") {
+                agentSessionId = (message as Record<string, unknown>).session_id as string;
+              }
               log.debug(`SDK message type: ${message.type}`);
               break;
           }
@@ -374,9 +414,11 @@ export class TaskProcessor {
       }
       this.historyCache.set(task.conversation_id, convHistory);
 
-      // Note: Memory extraction and skill creation are handled by the agent itself
-      // during task execution via memory_store and skill_create tools.
-      // No separate LLM API calls needed — the agent SDK handles everything.
+      // Post-task: resume the same session to evaluate skill creation (fire-and-forget)
+      if (agentSessionId) {
+        this.evaluateSkillPostTask(agentSessionId, config.model)
+          .catch((err) => log.debug(`Post-task skill evaluation skipped: ${err}`));
+      }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       log.error(`Task failed: ${errorMsg}`);