assistme 0.2.2 → 0.2.4

package/dist/index.js

@@ -1965,27 +1965,30 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       const sb = getSupabase();
       const source = options?.source || "manual";
       const metadata = options?.emoji ? { openclaw: { emoji: options.emoji } } : {};
-      const { data, error } = await sb.from("skills").upsert(
-        {
-          name,
-          description,
-          content,
-          version: "1.0.0",
-          author_id: this.userId,
-          emoji: options?.emoji || null,
-          keywords: options?.keywords || [],
-          metadata,
-          source,
-          is_public: false
-        },
-        { onConflict: "author_id,name" }
-      ).select("id, name").single();
+      const { data, error } = await sb.rpc("create_skill", {
+        p_user_id: this.userId,
+        p_name: name,
+        p_description: description,
+        p_content: content,
+        p_version: "1.0.0",
+        p_source: source,
+        p_emoji: options?.emoji || null,
+        p_keywords: options?.keywords || [],
+        p_metadata: metadata
+      });
       if (error) {
         log.debug(`Skill create failed for "${name}": ${error.message}`);
         return null;
       }
-      log.info(`Skill "${name}" created in skills table (pending approval)`);
-      return data;
+      const row = Array.isArray(data) ? data[0] : data;
+      if (!row) {
+        log.debug(`Skill create returned no data for "${name}"`);
+        return null;
+      }
+      const id = row.out_id || row.id;
+      const skillName = row.out_name || row.name;
+      log.info(`Skill "${skillName}" created in skills table (pending approval)`);
+      return { id, name: skillName };
     } catch (err) {
       log.debug(`Skill create error: ${err}`);
       return null;
@@ -2327,91 +2330,6 @@ function preprocessDynamicContext(content, cwd) {
   });
 }
 
-// src/agent/memory-extractor.ts
-var EXTRACTION_PROMPT = `You are a memory extraction system. Analyze the following conversation between a user and an AI assistant. Extract any facts worth remembering about the user for future conversations.
-
-Rules:
-- Only extract FACTUAL information about the user, not about the task itself
-- Be concise: each memory should be a single clear statement
-- Don't extract trivial/obvious things (e.g. "user asked a question")
-- Categories: "preference" (likes/dislikes/habits), "instruction" (standing orders like "always do X"), "context" (work/life info), "fact" (specific facts), "general" (other)
-- Importance: 3-4 for minor preferences, 5-6 for useful context, 7-8 for strong preferences/instructions, 9-10 for critical standing instructions
-- If nothing worth remembering, return an empty array
-- Max 3 memories per conversation
-- Support both English and Chinese content
-
-Respond with ONLY valid JSON \u2014 no markdown, no explanation:
-[{"content": "...", "category": "...", "importance": N, "tags": ["..."]}]
-
-If nothing to remember: []`;
-async function extractMemoriesWithLLM(taskPrompt, taskResult) {
-  const config = getConfig();
-  const apiKey = config.anthropicApiKey;
-  if (!apiKey) {
-    log.debug("No API key, skipping LLM memory extraction");
-    return [];
-  }
-  const truncatedPrompt = taskPrompt.slice(0, 2e3);
-  const truncatedResult = taskResult.slice(0, 3e3);
-  const userMessage = `<user_request>
-${truncatedPrompt}
-</user_request>
-
-<assistant_response>
-${truncatedResult}
-</assistant_response>`;
-  try {
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model: "claude-haiku-4-5-20251001",
-        max_tokens: 512,
-        system: EXTRACTION_PROMPT,
-        messages: [{ role: "user", content: userMessage }]
-      })
-    });
-    if (!response.ok) {
-      const errText = await response.text();
-      log.debug(`Memory extraction API error: ${response.status} ${errText.slice(0, 200)}`);
-      return [];
-    }
-    const data = await response.json();
-    const text = data.content?.[0]?.type === "text" ? data.content[0].text : "";
-    if (!text || text.trim() === "[]") {
-      log.debug("LLM memory extraction: nothing to remember");
-      return [];
-    }
-    const jsonStr = text.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-    const memories = JSON.parse(jsonStr);
-    const validCategories = [
-      "general",
-      "preference",
-      "instruction",
-      "context",
-      "skill_learned",
-      "fact"
-    ];
-    return memories.filter(
-      (m) => m.content && m.content.length > 5 && validCategories.includes(m.category)
-    ).map((m) => ({
-      content: m.content.slice(0, 500),
-      category: m.category,
-      importance: Math.max(1, Math.min(10, m.importance || 5)),
-      tags: Array.isArray(m.tags) ? m.tags.slice(0, 5) : []
-    })).slice(0, 3);
-  } catch (err) {
-    log.debug(
-      `LLM memory extraction failed: ${err instanceof Error ? err.message : err}`
-    );
-    return [];
-  }
-}
-
 // src/utils/retry.ts
 async function withRetry(fn, opts = {}) {
   const {
@@ -2883,138 +2801,6 @@ function getLimiterForTool(toolName) {
   return null;
 }
 
-// src/agent/skill-extractor.ts
-var DECOMPOSE_JOB_PROMPT = `You are a job analysis system. Given a person's job description, decompose their work into individual AUTOMATABLE SKILLS that an AI agent could learn and execute.
-
-The AI agent has these capabilities:
-- Control a real Chrome browser (navigate, click, type, read pages, take screenshots)
-- Read/write files on the local machine
-- Execute shell commands
-- Store memories and learn from interactions
-
-Rules:
-- Focus on RECURRING, REPETITIVE tasks that benefit from automation
-- Each skill should be a single, well-defined workflow
-- Prioritize tasks the person does frequently
-- Mark tasks as automatable:true only if the agent can handle them end-to-end
-- Name skills in kebab-case
-- Be specific \u2014 "check-email" is too vague, "summarize-unread-gmail" is better
-- Generate 5-15 skills depending on job complexity
-- Consider both web-based and file-based workflows
-
-Respond with ONLY valid JSON array \u2014 no markdown wrapping:
-[{"name": "skill-name", "description": "What this skill does", "category": "category", "priority": "high|medium|low", "automatable": true|false}]`;
-async function decomposeJob(jobDescription, existingSkillNames = []) {
-  const config = getConfig();
-  const apiKey = config.anthropicApiKey;
-  if (!apiKey) return [];
-  const existingNote = existingSkillNames.length > 0 ? `
-
-The agent already has these skills (do NOT duplicate): ${existingSkillNames.join(", ")}` : "";
-  try {
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model: "claude-haiku-4-5-20251001",
-        max_tokens: 2048,
-        system: DECOMPOSE_JOB_PROMPT,
-        messages: [
-          {
-            role: "user",
-            content: `<job_description>
-${jobDescription.slice(0, 3e3)}
-</job_description>${existingNote}`
-          }
-        ]
-      })
-    });
-    if (!response.ok) return [];
-    const data = await response.json();
-    const text = data.content?.[0]?.type === "text" ? data.content[0].text : "";
-    if (!text) return [];
-    const jsonStr = text.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-    const specs = JSON.parse(jsonStr);
-    if (!Array.isArray(specs)) return [];
-    return specs.filter((s) => s.name && s.description).map((s) => ({
-      ...s,
-      name: s.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")
-    }));
-  } catch (err) {
-    log.debug(`Job decomposition failed: ${err}`);
-    return [];
-  }
-}
-var GENERATE_PROMPT = `You are a skill authoring system for an AI agent. Given a skill name, description, and context about the user's work, generate detailed step-by-step instructions that the AI agent can follow to execute this skill.
-
-The AI agent has these capabilities:
-- Control a real Chrome browser (navigate, click, type, read pages, take screenshots)
-- Read/write files on the local machine
-- Execute shell commands (Bash)
-- Store memories about the user
-
-Rules:
-- Write clear, actionable markdown instructions
-- Use numbered steps with bold action names
-- Include error handling (what to do if a page doesn't load, element not found, etc.)
-- Use placeholders like {query}, {date}, {recipient} for variable inputs
-- Include a $ARGUMENTS line at the top if the skill accepts parameters
-- Be specific about which browser tools to use (browser_navigate, browser_click, etc.)
-- Include validation steps (verify the action worked)
-- Keep instructions thorough but concise (10-25 steps)
-
-Respond with ONLY valid JSON \u2014 no markdown wrapping:
-{"name": "skill-name", "description": "One-line description", "steps": "## Workflow\\n\\n$ARGUMENTS: describe expected arguments\\n\\n1. **Step one**\\n...", "emoji": "\u{1F527}", "keywords": ["keyword1", "keyword2"]}`;
-async function generateSkillFromDescription(name, description, jobContext) {
-  const config = getConfig();
-  const apiKey = config.anthropicApiKey;
-  if (!apiKey) return null;
-  const contextBlock = jobContext ? `
-
-<user_job_context>
-${jobContext.slice(0, 1e3)}
-</user_job_context>` : "";
-  try {
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model: "claude-haiku-4-5-20251001",
-        max_tokens: 2048,
-        system: GENERATE_PROMPT,
-        messages: [
-          {
-            role: "user",
-            content: `Generate a skill for:
-Name: ${name}
-Description: ${description}${contextBlock}`
-          }
-        ]
-      })
-    });
-    if (!response.ok) return null;
-    const data = await response.json();
-    const text = data.content?.[0]?.type === "text" ? data.content[0].text : "";
-    if (!text) return null;
-    const jsonStr = text.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-    const skill = JSON.parse(jsonStr);
-    if (!skill || !skill.name || !skill.steps) return null;
-    skill.name = skill.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-    return skill;
-  } catch (err) {
-    log.debug(`Skill generation failed: ${err}`);
-    return null;
-  }
-}
-
 // src/agent/mcp-servers.ts
 async function callTool(name, input) {
   const limiter = getLimiterForTool(name);
@@ -3356,130 +3142,93 @@ ${content}`;
       ),
       tool(
         "skill_generate",
-        "Generate new skills from a job description. Analyzes the user's work, decomposes it into automatable tasks, and creates skills for each one. Use this when the user describes their job/role and you want to set up skills to handle their work.",
+        "Prepare context for generating skills from a job description. Returns existing skills and job info so you can analyze the job and create skills using skill_create + skill_add. After creating all skills, call skill_link_job to link them to the job and mark it as analyzed.",
         {
           job_name: z.string().describe(
             "Short name for this job/role. Example: '\u7535\u5546\u8FD0\u8425', 'Frontend Dev', 'Data Analyst'"
           ),
           job_description: z.string().describe(
             "Description of the user's job, role, and daily tasks. Can be in any language. Example: '\u6211\u662F\u7535\u5546\u8FD0\u8425\uFF0C\u6BCF\u5929\u8981\u770B\u7ADE\u54C1\u4EF7\u683C\u3001\u5199\u5546\u54C1\u6587\u6848\u3001\u56DE\u590D\u5BA2\u6237\u8BC4\u8BBA'"
-          ),
-          auto_create: z.boolean().optional().describe("If true, automatically create all generated skills. If false (default), return the plan for review first.")
+          )
         },
         async (args) => {
           const existingNames = skillManager.getAll().map((s) => s.name);
-          const specs = await decomposeJob(args.job_description, existingNames);
-          if (specs.length === 0) {
-            return {
-              content: [{
-                type: "text",
-                text: "Could not decompose the job description into automatable skills. Try providing more detail about your daily tasks."
-              }]
-            };
-          }
-          if (!args.auto_create) {
-            let response2 = `## Job Analysis: ${args.job_name}
+          let response = `## Job: ${args.job_name}
+`;
+          response += `**Description:** ${args.job_description}
 
-I identified **${specs.length} skills** from your job description:
+`;
+          if (existingNames.length > 0) {
+            response += `**Existing skills (do NOT duplicate):** ${existingNames.join(", ")}
 
 `;
-            const byPriority = { high: [], medium: [], low: [] };
-            for (const s of specs) {
-              (byPriority[s.priority] || byPriority.medium).push(s);
-            }
-            for (const [priority, items] of Object.entries(byPriority)) {
-              if (items.length === 0) continue;
-              const label = priority === "high" ? "High Priority" : priority === "medium" ? "Medium Priority" : "Low Priority";
-              response2 += `### ${label}
+          }
+          response += `**Your task:** Analyze this job description and decompose it into 4-10 automatable skills. `;
+          response += `For each skill, call \`skill_create\` with:
 `;
-              for (const s of items) {
-                const auto = s.automatable ? "" : " (needs human assistance)";
-                response2 += `- **${s.name}**: ${s.description}${auto}
+          response += `- name: kebab-case name (e.g. "slack-message-check")
 `;
-              }
-              response2 += "\n";
-            }
-            response2 += `Call \`skill_generate\` again with \`job_name: "${args.job_name}"\` and \`auto_create: true\` to create all these skills, `;
-            response2 += "or use `skill_create` to create individual skills manually.";
-            return { content: [{ type: "text", text: response2 }] };
-          }
-          const created = [];
-          const failed = [];
-          for (let i = 0; i < specs.length; i += 3) {
-            const batch = specs.slice(i, i + 3);
-            const results = await Promise.allSettled(
-              batch.map(
-                (spec) => generateSkillFromDescription(spec.name, spec.description, args.job_description)
-              )
-            );
-            for (let j = 0; j < results.length; j++) {
-              const spec = batch[j];
-              const result = results[j];
-              if (result.status === "fulfilled" && result.value) {
-                const generated = result.value;
-                const existing = skillManager.findSimilar(generated.name);
-                if (existing) {
-                  failed.push(`${spec.name} (duplicate of "${existing.name}")`);
-                  continue;
-                }
-                const createResult = await skillManager.create(
-                  generated.name,
-                  generated.description || spec.description,
-                  generated.steps,
-                  {
-                    source: "job_generated",
-                    emoji: generated.emoji,
-                    keywords: generated.keywords
-                  }
-                );
-                if (createResult) {
-                  const added = await skillManager.addSkill(createResult.id);
-                  if (added) {
-                    created.push(generated.name);
-                  } else {
-                    failed.push(`${spec.name} (add failed)`);
-                  }
-                } else {
-                  failed.push(spec.name);
-                }
-              } else {
-                failed.push(spec.name);
-              }
-            }
-          }
-          if (userId) {
-            saveJobToDb(
-              userId,
-              args.job_name,
-              args.job_description,
-              created
-            ).catch((err) => {
-              log.debug(`saveJobToDb error: ${err}`);
-            });
-          }
-          let response = `## Skills Generated for "${args.job_name}"
+          response += `- description: one-line description
+`;
+          response += `- instructions: detailed step-by-step markdown instructions the agent can follow
+`;
+          response += `- emoji: a single emoji representing the skill
 
 `;
-          response += `Created **${created.length}/${specs.length}** skills from your job description:
+          response += `After creating each skill, call \`skill_add\` with the returned skill ID to add it to the user's collection.
 
 `;
-          for (const name of created) {
-            const skill = skillManager.get(name);
-            const emoji = skill?.metadata.emoji || "";
-            response += `- ${emoji} **${name}**: ${skill?.description || ""}
+          response += `After ALL skills are created and added, call \`skill_link_job\` with job_name="${args.job_name}" and the list of created skill names to link them and mark the job as analyzed.
+
 `;
-          }
-          if (failed.length > 0) {
-            response += `
-Failed to create: ${failed.join(", ")}
+          response += `**Guidelines for skill instructions:**
+`;
+          response += `- Write clear, actionable markdown steps
+`;
+          response += `- Reference browser tools (browser_navigate, browser_click, browser_read_page, etc.) for web tasks
+`;
+          response += `- Include error handling steps
+`;
+          response += `- Use placeholders like {query}, {date} for variable inputs
+`;
+          response += `- Each skill should be a single, well-defined workflow (10-25 steps)
 `;
-          }
-          response += "\nThese skills are now available. When you give me a task that matches, I'll automatically use the right skill.";
-          response += "\nUse `skill_invoke` to test any skill, or `skill_improve` to refine them after use.";
-          log.success(`Job "${args.job_name}": created ${created.length} skills`);
           return { content: [{ type: "text", text: response }] };
         }
       ),
+      tool(
+        "skill_link_job",
+        "Link created skills to a job and mark it as analyzed. Call this after creating all skills for a job via skill_create + skill_add.",
+        {
+          job_name: z.string().describe("Name of the job to link skills to"),
+          job_description: z.string().describe("Job description (used if job doesn't exist yet)"),
+          skill_names: z.array(z.string()).describe("Names of skills to link to this job")
+        },
+        async (args) => {
+          if (!userId) {
+            return {
+              content: [{ type: "text", text: "Not authenticated. Cannot link job." }]
+            };
+          }
+          try {
+            await saveJobToDb(userId, args.job_name, args.job_description, args.skill_names);
+            log.success(`Job "${args.job_name}": linked ${args.skill_names.length} skills and marked as analyzed`);
+            return {
+              content: [{
+                type: "text",
+                text: `Job "${args.job_name}" linked with ${args.skill_names.length} skills and marked as analyzed.`
+              }]
+            };
+          } catch (err) {
+            return {
+              content: [{
+                type: "text",
+                text: `Failed to link job: ${err instanceof Error ? err.message : err}`
+              }]
+            };
+          }
+        }
+      ),
       tool(
         "skill_browse",
         "Browse the skill marketplace to discover skills published by the community. Search by keyword, filter by category, and sort by popularity or rating.",
@@ -3877,6 +3626,8 @@ Available capabilities:
    - You can remember things about the user using memory_store
    - Use this when you learn preferences, important facts, or standing instructions
    - Your stored memories persist across conversations
+   - 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)
@@ -4019,6 +3770,7 @@ var TaskProcessor = class {
         "mcp__assistme-agent__skill_invoke",
         "mcp__assistme-agent__skill_search",
         "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",
@@ -4132,27 +3884,6 @@ var TaskProcessor = class {
         convHistory.splice(0, convHistory.length - MAX_HISTORY_ENTRIES * 2);
       }
       this.historyCache.set(task.conversation_id, convHistory);
-      if (this.memoryManager && finalResponse) {
-        const mm = this.memoryManager;
-        const taskIdRef = task.id;
-        extractMemoriesWithLLM(task.prompt, finalResponse).then(async (memories) => {
-          for (const mem of memories) {
-            try {
-              await mm.remember(mem.content, mem.category, {
-                importance: mem.importance,
-                tags: mem.tags,
-                sourceMessageId: taskIdRef
-              });
-              log.info(`Memory extracted: [${mem.category}] ${mem.content.slice(0, 60)}...`);
-            } catch {
-            }
-          }
-          if (memories.length > 0) {
-            log.success(`${memories.length} memory(s) auto-extracted`);
-          }
-        }).catch(() => {
-        });
-      }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       log.error(`Task failed: ${errorMsg}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "AssistMe CLI Agent - AI-powered assistant that controls your real browser",
   "type": "module",
   "main": "dist/index.js",