assistme 0.1.14 → 0.2.0

package/dist/{chunk-QXT7DH44.js → chunk-GHMZQ2UA.js}

@@ -116,8 +116,6 @@ var log = {
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-var CLI_AGENT_ID = "00000000-0000-0000-0000-000000000001";
-var DAYBOX_AGENT_ID = "00000000-0000-0000-0000-000000000002";
 var AUTH_DIR = join(homedir(), ".config", "assistme");
 var AUTH_FILE = join(AUTH_DIR, "auth.json");
 function ensureAuthDir() {
@@ -254,22 +252,6 @@ async function createTask(conversationId, _userId, sessionId, prompt) {
   if (error) throw new Error(`Failed to create task: ${error.message}`);
   return { ...data, prompt };
 }
-async function pollPendingTasks(sessionId) {
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("mcp_poll_tasks", {
-    p_token_hash: getTokenHash(),
-    p_session_id: sessionId
-  });
-  if (error) {
-    log.warn(`Task poll failed: ${error.message}`);
-    return [];
-  }
-  const rows = data || [];
-  return rows.map((row) => ({
-    ...row,
-    prompt: row.metadata?.prompt || row.content || ""
-  }));
-}
 async function pollAndClaimTask(sessionId) {
   const sb = getSupabase();
   const { data, error } = await sb.rpc("mcp_poll_and_claim_task", {
@@ -315,6 +297,33 @@ async function failTask(messageId, errorMessage) {
   });
   if (error) log.error(`Failed to update task status: ${error.message}`);
 }
+async function pollAndClaimJobRun(userId) {
+  const sb = getSupabase();
+  const { data, error } = await sb.rpc("claim_pending_job_run", {
+    p_user_id: userId
+  });
+  if (error) {
+    log.debug(`Job run poll failed: ${error.message}`);
+    return null;
+  }
+  if (!data) return null;
+  return data;
+}
+async function getConversationHistory(conversationId, excludeMessageId, limit = 20) {
+  const sb = getSupabase();
+  const { data, error } = await sb.from("conversation_messages").select("id, role, content, status, metadata, created_at").eq("conversation_id", conversationId).in("status", ["completed", "failed"]).neq("id", excludeMessageId).order("created_at", { ascending: false }).limit(limit);
+  if (error) {
+    log.debug(`Failed to fetch conversation history: ${error.message}`);
+    return [];
+  }
+  const rows = data || [];
+  return rows.reverse().map((row) => {
+    const prompt = row.metadata?.prompt || "";
+    const content = row.content || "";
+    const response = row.status === "failed" ? `[Task failed] ${content}` : content;
+    return { prompt, response };
+  }).filter((entry) => entry.prompt && entry.response);
+}
 var eventSequence = 0;
 function resetEventSequence() {
   eventSequence = 0;
@@ -331,19 +340,194 @@ async function emitEvent(messageId, eventType, eventData) {
   });
   if (error) log.warn(`Failed to emit event: ${error.message}`);
 }
-async function emitEvents(messageId, events) {
-  const sb = getSupabase();
-  const eventsJson = events.map((e) => {
-    eventSequence++;
-    return { type: e.type, data: e.data, seq: eventSequence };
-  });
-  const { error } = await sb.rpc("mcp_emit_events", {
-    p_token_hash: getTokenHash(),
-    p_message_id: messageId,
-    p_events: eventsJson
-  });
-  if (error) log.warn(`Failed to emit events batch: ${error.message}`);
-}
+
+// src/agent/job-runner.ts
+var JobRunner = class {
+  userId;
+  constructor(userId) {
+    this.userId = userId;
+  }
+  /**
+   * Load a job and its linked skills from the database.
+   * Skills are the agent's *capabilities* — not a fixed execution plan.
+   */
+  async loadJob(jobName) {
+    try {
+      const sb = getSupabase();
+      const { data, error } = await sb.rpc("get_job_with_skills", {
+        p_user_id: this.userId,
+        p_job_name: jobName
+      });
+      if (error || !data || data.length === 0) {
+        return null;
+      }
+      const rows = data;
+      const first = rows[0];
+      return {
+        jobId: first.job_id,
+        jobName: first.job_name,
+        jobDescription: first.job_description,
+        skills: rows.map((row) => ({
+          skillId: row.skill_id,
+          skillName: row.skill_name,
+          skillDescription: row.skill_description || "",
+          skillEmoji: row.skill_emoji || "",
+          skillContent: row.skill_content || ""
+        }))
+      };
+    } catch (err) {
+      log.debug(`Failed to load job "${jobName}": ${err}`);
+      return null;
+    }
+  }
+  /**
+   * List all jobs for the user.
+   */
+  async listJobs() {
+    try {
+      const sb = getSupabase();
+      const { data: jobs, error } = await sb.from("agent_jobs").select("id, name, description").eq("user_id", this.userId).eq("is_active", true).order("name");
+      if (error || !jobs) return [];
+      const result = [];
+      for (const job of jobs) {
+        const { count } = await sb.from("agent_job_skills").select("id", { count: "exact", head: true }).eq("job_id", job.id);
+        result.push({
+          id: job.id,
+          name: job.name,
+          description: job.description,
+          skillCount: count || 0
+        });
+      }
+      return result;
+    } catch (err) {
+      log.debug(`Failed to list jobs: ${err}`);
+      return [];
+    }
+  }
+  /**
+   * Create a job run record.
+   * This is just a timestamp + status tracker. The actual execution trace
+   * lives in the conversation transcript (message_events).
+   */
+  async createRun(jobId, options) {
+    try {
+      const sb = getSupabase();
+      const { data, error } = await sb.rpc("create_job_run", {
+        p_user_id: this.userId,
+        p_job_id: jobId,
+        p_session_id: options?.sessionId || null,
+        p_message_id: options?.messageId || null,
+        p_trigger_type: options?.triggerType || "manual"
+      });
+      if (error) {
+        log.debug(`Failed to create job run: ${error.message}`);
+        return null;
+      }
+      return data;
+    } catch (err) {
+      log.debug(`Job run creation error: ${err}`);
+      return null;
+    }
+  }
+  /**
+   * Mark a job run as completed/failed.
+   * Throws on failure so callers can handle (e.g. avoid duplicate execution).
+   */
+  async completeRun(runId, status = "completed", summary) {
+    const sb = getSupabase();
+    const { error } = await sb.rpc("complete_job_run", {
+      p_run_id: runId,
+      p_status: status,
+      p_summary: summary?.slice(0, 1e4) || null,
+      p_user_id: this.userId
+    });
+    if (error) {
+      log.error(`Failed to mark run ${runId} as ${status}: ${error.message}`);
+      throw new Error(`Run completion failed: ${error.message}`);
+    }
+  }
+  /**
+   * Get recent job run history.
+   */
+  async getRunHistory(jobName, limit = 10) {
+    try {
+      const sb = getSupabase();
+      const { data, error } = await sb.rpc("get_job_runs", {
+        p_user_id: this.userId,
+        p_job_name: jobName || null,
+        p_limit: limit
+      });
+      if (error || !data) return [];
+      return data.map((row) => ({
+        runId: row.run_id,
+        jobName: row.job_name,
+        status: row.status,
+        triggerType: row.trigger_type,
+        startedAt: row.started_at,
+        completedAt: row.completed_at || null,
+        summary: row.summary || null
+      }));
+    } catch (err) {
+      log.debug(`Run history error: ${err}`);
+      return [];
+    }
+  }
+  /**
+   * Build the agentic prompt for the agent to execute a job.
+   *
+   * This does NOT prescribe a fixed sequence. Instead, it tells the agent
+   * the job's goal and lists available skills as capabilities. The agent
+   * decides dynamically which skills to use, in what order, and how to
+   * chain them based on what it discovers at runtime.
+   */
+  buildJobPrompt(job, runId) {
+    let prompt = `## Job: ${job.jobName}
+`;
+    prompt += `*${job.jobDescription}*
+
+`;
+    prompt += `**Run ID:** ${runId}
+
+`;
+    prompt += `You are now acting as "${job.jobName}". `;
+    prompt += `Your goal is to accomplish the objectives described above using the skills and tools available to you.
+
+`;
+    prompt += `### Available Skills
+`;
+    prompt += `These skills are your capabilities for this job. `;
+    prompt += `Use \`skill_invoke\` to load any skill's full instructions when you need it. `;
+    prompt += `You do NOT need to use all of them \u2014 pick the ones relevant to the current situation.
+
+`;
+    for (const skill of job.skills) {
+      const emoji = skill.skillEmoji ? `${skill.skillEmoji} ` : "";
+      prompt += `- **${emoji}${skill.skillName}**: ${skill.skillDescription}
+`;
+    }
+    prompt += `
+### How to Work
+`;
+    prompt += `- **Be agentic**: Decide what to do based on what you discover. `;
+    prompt += `If checking Slack reveals a request that requires GitHub work, go do the GitHub work immediately \u2014 don't just note it for later.
+`;
+    prompt += `- **Chain dynamically**: One skill's output should inform your next action. `;
+    prompt += `For example, if you find an assigned GitHub issue, use your coding skills to implement it.
+`;
+    prompt += `- **Skip what's irrelevant**: If a capability doesn't apply right now, skip it.
+`;
+    prompt += `- **Use tools directly too**: You also have browser, file, and shell tools. `;
+    prompt += `Use them directly when a skill isn't needed \u2014 skills are guides, not mandatory steps.
+`;
+    prompt += `- **Respond and act**: If you find messages or issues that need replies, reply to them. `;
+    prompt += `If you find code tasks, implement them.
+
+`;
+    prompt += `When finished, provide a summary of what you accomplished and any items that need the user's attention.
+`;
+    return prompt;
+  }
+};
 
 export {
   getConfig,
@@ -354,8 +538,6 @@ export {
   setCorrelationId,
   newCorrelationId,
   log,
-  CLI_AGENT_ID,
-  DAYBOX_AGENT_ID,
   getSupabase,
   loginWithToken,
   getCurrentUserId,
@@ -366,12 +548,13 @@ export {
   setSessionBusy,
   getOrCreateCliConversation,
   createTask,
-  pollPendingTasks,
   pollAndClaimTask,
   claimTask,
   completeTask,
   failTask,
+  pollAndClaimJobRun,
+  getConversationHistory,
   resetEventSequence,
   emitEvent,
-  emitEvents
+  JobRunner
 };