assistme 0.2.8 → 0.3.0

package/src/agent/scheduler.ts

@@ -1,4 +1,4 @@
-import { getSupabase, getCurrentUserId } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
 
 const SCHEDULER_INTERVAL = 30_000; // Check every 30 seconds
@@ -35,10 +35,8 @@ export function getNextRunTime(cronExpr: string, timezone: string, fromDate?: Da
 
   const [minExpr, hourExpr, domExpr, monExpr, dowExpr] = parts;
 
-  // Simple cron parser — handles: *, */N, N, N-M, N,M
   function parseField(expr: string, min: number, max: number): number[] {
     const values: number[] = [];
-
     for (const part of expr.split(",")) {
       if (part === "*") {
         for (let i = min; i <= max; i++) values.push(i);
@@ -52,7 +50,6 @@ export function getNextRunTime(cronExpr: string, timezone: string, fromDate?: Da
         values.push(parseInt(part));
       }
     }
-
     return values.sort((a, b) => a - b);
   }
 
@@ -60,17 +57,14 @@ export function getNextRunTime(cronExpr: string, timezone: string, fromDate?: Da
   const hours = parseField(hourExpr, 0, 23);
   const daysOfMonth = parseField(domExpr, 1, 31);
   const months = parseField(monExpr, 1, 12);
-  const daysOfWeek = parseField(dowExpr, 0, 6); // 0 = Sunday
+  const daysOfWeek = parseField(dowExpr, 0, 6);
 
   const useUTC = timezone === "UTC";
 
-  // Find the next matching time after 'now'
-  const candidate = new Date(now.getTime() + 60_000); // Start from next minute
+  const candidate = new Date(now.getTime() + 60_000);
   candidate.setSeconds(0, 0);
 
-  // Search up to 366 days ahead
   for (let i = 0; i < 527040; i++) {
-    // 366 * 24 * 60
     const m = useUTC ? candidate.getUTCMinutes() : candidate.getMinutes();
     const h = useUTC ? candidate.getUTCHours() : candidate.getHours();
     const dom = useUTC ? candidate.getUTCDate() : candidate.getDate();
@@ -87,10 +81,9 @@ export function getNextRunTime(cronExpr: string, timezone: string, fromDate?: Da
       return candidate;
     }
 
-    candidate.setTime(candidate.getTime() + 60_000); // Advance 1 minute
+    candidate.setTime(candidate.getTime() + 60_000);
   }
 
-  // Fallback: 24 hours from now
   return new Date(now.getTime() + 86400_000);
 }
 
@@ -103,10 +96,8 @@ export class Scheduler {
     this.onScheduledTask = onScheduledTask;
     this.running = true;
 
-    // Initialize next_run_at for tasks that don't have it yet
     await this.initializeNextRuns();
 
-    // Check for due tasks periodically
     this.timer = setInterval(() => this.checkDueTasks(), SCHEDULER_INTERVAL);
     log.info("Scheduler started (checking every 30s)");
   }
@@ -121,22 +112,15 @@ export class Scheduler {
 
   private async initializeNextRuns(): Promise<void> {
     try {
-      const userId = await getCurrentUserId();
-      const sb = getSupabase();
-      const { data } = await sb
-        .from("agent_scheduled_tasks")
-        .select("*")
-        .eq("user_id", userId)
-        .eq("enabled", true)
-        .is("next_run_at", null);
+      const data = await callMcpHandler<ScheduledTask[]>("schedule.get_uninitialized");
 
       if (data) {
         for (const task of data) {
           const nextRun = getNextRunTime(task.cron_expression, task.timezone);
-          await sb
-            .from("agent_scheduled_tasks")
-            .update({ next_run_at: nextRun.toISOString() })
-            .eq("id", task.id);
+          await callMcpHandler("schedule.update", {
+            task_id: task.id,
+            next_run_at: nextRun.toISOString(),
+          });
         }
       }
     } catch (err) {
@@ -148,44 +132,37 @@ export class Scheduler {
     if (!this.running || !this.onScheduledTask) return;
 
     try {
-      const userId = await getCurrentUserId();
-      const sb = getSupabase();
-
-      const { data: dueTasks } = await sb
-        .from("agent_scheduled_tasks")
-        .select("*")
-        .eq("user_id", userId)
-        .eq("enabled", true)
-        .lte("next_run_at", new Date().toISOString())
-        .order("next_run_at", { ascending: true })
-        .limit(1);
+      const dueTasks = await callMcpHandler<ScheduledTask[]>("schedule.check_due");
 
       if (!dueTasks || dueTasks.length === 0) return;
 
-      const task = dueTasks[0] as ScheduledTask;
+      const task = dueTasks[0];
       log.info(`Scheduled task due: "${task.name}"`);
 
-      // Calculate next run before executing
       const nextRun = getNextRunTime(task.cron_expression, task.timezone);
 
       // Update: set running, advance next_run_at
-      await sb
-        .from("agent_scheduled_tasks")
-        .update({
-          last_run_at: new Date().toISOString(),
-          next_run_at: nextRun.toISOString(),
-          run_count: task.run_count + 1,
-        })
-        .eq("id", task.id);
+      await callMcpHandler("schedule.update", {
+        task_id: task.id,
+        last_run_at: new Date().toISOString(),
+        next_run_at: nextRun.toISOString(),
+        run_count: task.run_count + 1,
+      });
 
       // Execute
       try {
         await this.onScheduledTask(task);
 
-        await sb.from("agent_scheduled_tasks").update({ last_error: null }).eq("id", task.id);
+        await callMcpHandler("schedule.update", {
+          task_id: task.id,
+          last_error: null,
+        });
       } catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
-        await sb.from("agent_scheduled_tasks").update({ last_error: errMsg }).eq("id", task.id);
+        await callMcpHandler("schedule.update", {
+          task_id: task.id,
+          last_error: errMsg,
+        });
         log.error(`Scheduled task "${task.name}" failed: ${errMsg}`);
       }
     } catch (err) {
@@ -197,68 +174,45 @@ export class Scheduler {
 // ── CRUD helpers for CLI commands ──────────────────────────────────
 
 export async function createScheduledTask(
-  userId: string,
+  _userId: string,
   name: string,
   prompt: string,
   cronExpression: string,
   timezone = "UTC"
 ): Promise<ScheduledTask> {
-  const sb = getSupabase();
   const nextRun = getNextRunTime(cronExpression, timezone);
 
-  const { data, error } = await sb
-    .from("agent_scheduled_tasks")
-    .insert({
-      user_id: userId,
-      name,
-      prompt,
-      cron_expression: cronExpression,
-      timezone,
-      next_run_at: nextRun.toISOString(),
-    })
-    .select()
-    .single();
-
-  if (error) throw new Error(`Failed to create schedule: ${error.message}`);
-  return data as ScheduledTask;
+  return callMcpHandler<ScheduledTask>("schedule.create", {
+    name,
+    prompt,
+    cron_expression: cronExpression,
+    timezone,
+    next_run_at: nextRun.toISOString(),
+  });
 }
 
-export async function listScheduledTasks(userId: string): Promise<ScheduledTask[]> {
-  const sb = getSupabase();
-  const { data, error } = await sb
-    .from("agent_scheduled_tasks")
-    .select("*")
-    .eq("user_id", userId)
-    .order("created_at", { ascending: false });
-
-  if (error) throw new Error(`Failed to list schedules: ${error.message}`);
-  return (data || []) as ScheduledTask[];
+export async function listScheduledTasks(_userId: string): Promise<ScheduledTask[]> {
+  return callMcpHandler<ScheduledTask[]>("schedule.list");
 }
 
 export async function toggleScheduledTask(taskId: string, enabled: boolean): Promise<void> {
-  const sb = getSupabase();
-  const update: Record<string, unknown> = { enabled };
+  const params: Record<string, unknown> = { task_id: taskId, enabled };
+
   if (enabled) {
-    // Recalculate next run when re-enabling
-    const { data } = await sb
-      .from("agent_scheduled_tasks")
-      .select("cron_expression, timezone")
-      .eq("id", taskId)
-      .single();
-    if (data) {
-      const nextRun = getNextRunTime(data.cron_expression, data.timezone);
-      update.next_run_at = nextRun.toISOString();
+    // Need to recalculate next run when re-enabling
+    const taskData = await callMcpHandler<{ cron_expression: string; timezone: string }>(
+      "schedule.get_task",
+      { task_id: taskId },
+    );
+    if (taskData) {
+      const nextRun = getNextRunTime(taskData.cron_expression, taskData.timezone);
+      params.next_run_at = nextRun.toISOString();
     }
   }
 
-  const { error } = await sb.from("agent_scheduled_tasks").update(update).eq("id", taskId);
-
-  if (error) throw new Error(`Failed to toggle schedule: ${error.message}`);
+  await callMcpHandler("schedule.toggle", params);
 }
 
 export async function deleteScheduledTask(taskId: string): Promise<void> {
-  const sb = getSupabase();
-  const { error } = await sb.from("agent_scheduled_tasks").delete().eq("id", taskId);
-
-  if (error) throw new Error(`Failed to delete schedule: ${error.message}`);
+  await callMcpHandler("schedule.delete", { task_id: taskId });
 }

package/src/agent/session.test.ts

@@ -15,17 +15,6 @@ const mockSession = {
   metadata: {},
 };
 
-// Build a fluent Supabase chain that does nothing
-const chain: Record<string, unknown> = {};
-const methods = [
-  "select", "insert", "update", "delete", "eq", "neq", "not",
-  "or", "in", "order", "limit", "single", "from", "lt",
-];
-for (const method of methods) {
-  chain[method] = vi.fn().mockReturnValue(chain);
-}
-chain.then = (resolve: (value: unknown) => void) => resolve({ data: [], error: null });
-
 const mockCreateSession = vi.fn().mockResolvedValue(mockSession);
 const mockUpdateHeartbeat = vi.fn().mockResolvedValue(undefined);
 const mockEndSession = vi.fn().mockResolvedValue(undefined);
@@ -35,6 +24,8 @@ const mockClaimTask = vi.fn().mockResolvedValue(true);
 const mockCreateTask = vi.fn().mockResolvedValue({ id: "task-001", prompt: "test" });
 const mockGetOrCreateCliConversation = vi.fn().mockResolvedValue("conv-001");
 
+const mockCleanupStaleSessions = vi.fn().mockResolvedValue(0);
+
 vi.mock("../db/supabase.js", () => ({
   createSession: (...args: unknown[]) => mockCreateSession(...args),
   updateHeartbeat: (...args: unknown[]) => mockUpdateHeartbeat(...args),
@@ -44,7 +35,12 @@ vi.mock("../db/supabase.js", () => ({
   claimTask: (...args: unknown[]) => mockClaimTask(...args),
   createTask: (...args: unknown[]) => mockCreateTask(...args),
   getOrCreateCliConversation: (...args: unknown[]) => mockGetOrCreateCliConversation(...args),
-  getSupabase: vi.fn().mockReturnValue({ from: vi.fn().mockReturnValue(chain) }),
+  cleanupStaleSessions: (...args: unknown[]) => mockCleanupStaleSessions(...args),
+  pollAndClaimJobRun: vi.fn().mockResolvedValue(null),
+}));
+
+vi.mock("../db/api-client.js", () => ({
+  callMcpHandler: vi.fn().mockResolvedValue(null),
 }));
 
 vi.mock("../utils/config.js", () => ({

package/src/agent/session.ts

@@ -8,11 +8,12 @@ import {
   claimTask,
   createTask,
   getOrCreateCliConversation,
-  getSupabase,
+  cleanupStaleSessions,
   AgentSession,
   ConversationMessage,
   PendingJobRun,
 } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { getConfig } from "../utils/config.js";
 import { log } from "../utils/logger.js";
 import { Scheduler, ScheduledTask } from "./scheduler.js";
@@ -21,7 +22,6 @@ import { JobRunner } from "./job-runner.js";
 const DEFAULT_HEARTBEAT_INTERVAL = 30_000; // 30 seconds
 const DEFAULT_POLL_INTERVAL = 2_000; // 2 seconds
 const MAX_POLL_INTERVAL = 30_000; // Max backoff: 30 seconds
-const STALE_SESSION_THRESHOLD = 120_000; // 2 minutes without heartbeat = stale
 
 export class SessionManager {
   private session: AgentSession | null = null;
@@ -93,9 +93,6 @@ export class SessionManager {
     return this.session;
   }
 
-  /**
-   * Schedule the next poll with exponential backoff on failures.
-   */
   private schedulePoll(): void {
     if (!this.running) return;
 
@@ -126,10 +123,6 @@ export class SessionManager {
     }
   }
 
-  /**
-   * Execute a pending job run triggered from the web UI.
-   * Loads the job, builds the agentic prompt, and processes it as a chat task.
-   */
   private async executeJobRun(jobRun: PendingJobRun): Promise<void> {
     if (!this.session || !this.userId || !this.conversationId || !this.onTask)
       return;
@@ -157,11 +150,10 @@ export class SessionManager {
 
     // Link session to run record (non-critical)
     try {
-      const sb = getSupabase();
-      await sb
-        .from("agent_job_runs")
-        .update({ session_id: this.session.id })
-        .eq("id", jobRun.id);
+      await callMcpHandler("job.link_run_session", {
+        run_id: jobRun.id,
+        session_id: this.session.id,
+      });
     } catch (linkErr) {
       log.debug(`Failed to link session to job run: ${linkErr}`);
     }
@@ -253,50 +245,19 @@ export class SessionManager {
     this.schedulePoll();
   }
 
-  /**
-   * Mark sessions as offline if they haven't sent a heartbeat recently.
-   * Runs once on startup to clean up orphaned sessions from crashed processes.
-   */
   private async cleanupStaleSessions(): Promise<void> {
-    if (!this.userId) return;
+    if (!this.userId || !this.session) return;
 
     try {
-      const sb = getSupabase();
-      const threshold = new Date(
-        Date.now() - STALE_SESSION_THRESHOLD
-      ).toISOString();
-
-      const { data: stale } = await sb
-        .from("agent_sessions")
-        .select("id")
-        .eq("user_id", this.userId)
-        .in("status", ["online", "busy"])
-        .lt("last_heartbeat_at", threshold)
-        .neq("id", this.session?.id || "");
-
-      if (stale && stale.length > 0) {
-        for (const s of stale) {
-          await sb
-            .from("agent_sessions")
-            .update({
-              status: "offline",
-              ended_at: new Date().toISOString(),
-              metadata: { ended_reason: "stale_session_cleanup" },
-            })
-            .eq("id", s.id);
-        }
-        log.info(`Cleaned up ${stale.length} stale session(s)`);
+      const cleaned = await cleanupStaleSessions(this.session.id);
+      if (cleaned > 0) {
+        log.info(`Cleaned up ${cleaned} stale session(s)`);
       }
     } catch (err) {
       log.debug(`Stale session cleanup error: ${err}`);
     }
   }
 
-  /**
-   * Submit a task from the interactive prompt or scheduled job.
-   * Sets processing=true BEFORE creating the task so the poll loop
-   * never races to pick it up.
-   */
   async submitTask(prompt: string): Promise<void> {
     if (!this.session || !this.userId || !this.conversationId || !this.onTask) {
       throw new Error("Session not started");
@@ -328,9 +289,6 @@ export class SessionManager {
     }
   }
 
-  /**
-   * Stop the session with a safety timeout to prevent hanging on shutdown.
-   */
   async stop(timeoutMs = 5_000): Promise<void> {
     this.running = false;
     this.scheduler.stop();
@@ -347,7 +305,6 @@ export class SessionManager {
 
     if (this.session) {
       try {
-        // Wrap DB call with a deadline to avoid hanging on shutdown
         await Promise.race([
           endSession(this.session.id),
           new Promise<never>((_, reject) =>

package/src/agent/skill-evaluator.ts

@@ -0,0 +1,258 @@
+import {
+  query,
+  type SDKAssistantMessage,
+  type SDKResultMessage,
+} from "@anthropic-ai/claude-agent-sdk";
+import { log } from "../utils/logger.js";
+import type { SkillManager } from "./skills.js";
+import { validateSkillName, normalizeSkillName } from "./skills.js";
+
+// ── Types ───────────────────────────────────────────────────────────
+
+interface SkillDecision {
+  action: "create" | "update" | "skip";
+  // For "create"
+  name?: string;
+  description?: string;
+  instructions?: string;
+  emoji?: string;
+  keywords?: string[];
+  // For "update"
+  existing_skill_name?: string;
+  improved_instructions?: string;
+  improved_description?: string;
+  // Always present
+  reason: string;
+}
+
+// ── Agent Skills format spec (agentskills.io) ───────────────────────
+
+const SKILL_EVALUATION_PROMPT = `You just completed a task. Now evaluate whether it should be saved as a reusable Agent Skill.
+
+## Agent Skills Format (agentskills.io)
+
+A skill follows the SKILL.md format:
+- name: 1-64 chars, lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens
+- description: 1-1024 chars, describe WHAT it does AND WHEN to use it, include searchable keywords
+- body: markdown step-by-step instructions, examples, edge cases. Keep under 500 lines, <5000 tokens.
+- Use generic placeholders (e.g. {url}, {query}, {product_name}) instead of specific values
+- Instructions should be a REUSABLE workflow, not a transcript of what just happened
+- Include error handling steps and tool references (browser_navigate, browser_read_page, Bash, Read, etc.)
+
+## Your Decision
+
+Respond with ONLY a JSON object (no markdown, no explanation outside the JSON). Choose one action:
+
+1. **"create"** — The task is a reusable workflow worth saving.
+   Include: name, description, instructions (full SKILL.md body), emoji, keywords (3-5, include Chinese if task was in Chinese)
+
+2. **"update"** — An existing skill should be improved based on what you just learned.
+   Include: existing_skill_name, improved_instructions (full updated body), improved_description (if changed)
+
+3. **"skip"** — Not worth capturing (simple Q&A, one-off, too vague, already fully covered by existing skill).
+
+Always include "reason" explaining your decision.
+
+Use your judgment — no rigid rules. Consider: Is this repeatable? Can it be generalized? Would it save time next time?`;
+
+// ── Evaluator ───────────────────────────────────────────────────────
+
+/**
+ * Post-task skill evaluator using Agent SDK session resume.
+ *
+ * Resumes the same session that just completed the task, so the agent
+ * has full context of what happened. No need to re-describe the task,
+ * tool calls, or results — it already knows everything.
+ */
+export async function evaluateAndMaybeCreateSkill(opts: {
+  sessionId: string;
+  skillManager: SkillManager;
+  model?: string;
+}): Promise<void> {
+  const { sessionId, skillManager, model } = opts;
+
+  if (!sessionId) {
+    log.debug("Skill evaluation skipped: no session ID to resume");
+    return;
+  }
+
+  // Build existing skills context so the agent knows what already exists
+  const existingSkills = skillManager.getAll();
+  const existingList = existingSkills.length > 0
+    ? existingSkills.map((s) => `- ${s.name}: ${s.description}`).join("\n")
+    : "(no existing skills)";
+
+  const prompt = `${SKILL_EVALUATION_PROMPT}
+
+## Existing Skills (do NOT duplicate these)
+${existingList}
+
+Respond with a JSON object now.`;
+
+  try {
+    let responseText = "";
+
+    for await (const message of query({
+      prompt,
+      options: {
+        resume: sessionId,
+        model,
+        maxTurns: 1,
+        allowedTools: [],
+      },
+    })) {
+      if (message.type === "assistant") {
+        const assistantMsg = message as SDKAssistantMessage;
+        for (const block of assistantMsg.message.content) {
+          if (block.type === "text") {
+            responseText += block.text;
+          }
+        }
+      } else if (message.type === "result") {
+        const resultMsg = message as SDKResultMessage;
+        if (resultMsg.subtype === "success" && "total_cost_usd" in resultMsg) {
+          log.debug(`Skill evaluation cost: $${(resultMsg as { total_cost_usd: number }).total_cost_usd.toFixed(4)}`);
+        }
+      }
+    }
+
+    // Parse the decision — try the full text first, then extract JSON
+    const decision = parseJsonResponse(responseText);
+    if (!decision) {
+      log.debug("Skill evaluation: no valid JSON in response");
+      return;
+    }
+
+    if (!["create", "update", "skip"].includes(decision.action)) {
+      log.debug("Skill evaluation: invalid action");
+      return;
+    }
+
+    // Execute the decision
+    await executeSkillDecision(decision, skillManager);
+  } catch (err) {
+    log.debug(`Skill evaluation error: ${err}`);
+  }
+}
+
+/**
+ * Execute the skill decision: create a new skill or update an existing one.
+ */
+async function executeSkillDecision(
+  decision: SkillDecision,
+  skillManager: SkillManager
+): Promise<void> {
+  switch (decision.action) {
+    case "create": {
+      if (!decision.name || !decision.instructions) {
+        log.debug("Skill create skipped: missing name or instructions");
+        return;
+      }
+
+      // Normalize name to valid kebab-case (model may return invalid format)
+      let skillName = decision.name;
+      if (validateSkillName(skillName)) {
+        skillName = normalizeSkillName(skillName);
+        if (!skillName || validateSkillName(skillName)) {
+          log.debug(`Skill create skipped: name "${decision.name}" cannot be normalized`);
+          return;
+        }
+        log.debug(`Normalized skill name: "${decision.name}" → "${skillName}"`);
+      }
+
+      // Check for duplicates
+      const existing = skillManager.findSimilar(skillName);
+      if (existing) {
+        log.debug(`Skill create skipped: similar skill "${existing.name}" exists`);
+        return;
+      }
+
+      const result = await skillManager.create(
+        skillName,
+        decision.description || "",
+        decision.instructions,
+        {
+          source: "auto_extracted",
+          emoji: decision.emoji,
+          keywords: decision.keywords,
+        }
+      );
+
+      if (result) {
+        // syncToAgentSkills is handled by skill_create flow; only sync here
+        // with sourceSkillId linkage since create() doesn't set it.
+        await skillManager.syncToAgentSkills(
+          skillName,
+          decision.description || "",
+          decision.instructions,
+          "1.0.0",
+          {
+            source: "auto_extracted",
+            emoji: decision.emoji,
+            keywords: decision.keywords,
+            sourceSkillId: result.id,
+          }
+        );
+        log.info(`Auto-created skill "${skillName}": ${decision.reason}`);
+      }
+      break;
+    }
+
+    case "update": {
+      if (!decision.existing_skill_name || !decision.improved_instructions) {
+        log.debug("Skill update skipped: missing skill name or instructions");
+        return;
+      }
+
+      const updated = skillManager.update(
+        decision.existing_skill_name,
+        decision.improved_instructions,
+        decision.improved_description
+      );
+
+      if (updated) {
+        log.info(`Auto-improved skill "${decision.existing_skill_name}": ${decision.reason}`);
+      } else {
+        log.debug(`Skill update failed: "${decision.existing_skill_name}" not found`);
+      }
+      break;
+    }
+
+    case "skip":
+      log.debug(`Skill evaluation: skip — ${decision.reason}`);
+      break;
+  }
+}
+
+/**
+ * Attempt to parse a SkillDecision from the model's response text.
+ * Tries the full text first (model returned pure JSON), then falls
+ * back to extracting the outermost balanced `{…}` block.
+ */
+function parseJsonResponse(text: string): SkillDecision | null {
+  const trimmed = text.trim();
+
+  // Fast path: entire response is JSON
+  try {
+    const parsed = JSON.parse(trimmed) as SkillDecision;
+    if (parsed.action) return parsed;
+  } catch { /* not pure JSON */ }
+
+  // Fallback: find the first balanced `{…}` block
+  const start = trimmed.indexOf("{");
+  if (start === -1) return null;
+
+  let depth = 0;
+  for (let i = start; i < trimmed.length; i++) {
+    if (trimmed[i] === "{") depth++;
+    else if (trimmed[i] === "}") depth--;
+    if (depth === 0) {
+      try {
+        return JSON.parse(trimmed.slice(start, i + 1)) as SkillDecision;
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}