assistme 0.2.2 → 0.2.4

package/src/agent/mcp-servers.ts

@@ -10,7 +10,6 @@ import { log } from "../utils/logger.js";
 import type { MemoryManager, MemoryCategory } from "./memory.js";
 import type { SkillManager } from "./skills.js";
 import { substituteArguments, preprocessDynamicContext } from "./skills.js";
-import { decomposeJob, generateSkillFromDescription } from "./skill-extractor.js";
 import { getSupabase } from "../db/supabase.js";
 import { JobRunner } from "./job-runner.js";
 import {
@@ -405,8 +404,9 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
       ),
       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: '电商运营', 'Frontend Dev', 'Data Analyst'"
@@ -415,137 +415,67 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
             "Description of the user's job, role, and daily tasks. Can be in any language. " +
               "Example: '我是电商运营，每天要看竞品价格、写商品文案、回复客户评论'"
           ),
-          auto_create: z
-            .boolean()
-            .optional()
-            .describe("If true, automatically create all generated skills. If false (default), return the plan for review first."),
         },
         async (args) => {
-          // Step 1: Decompose job into skill specs
           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 not auto-creating, return the decomposition plan
-          if (!args.auto_create) {
-            let response = `## Job Analysis: ${args.job_name}\n\nI identified **${specs.length} skills** from your job description:\n\n`;
 
-            const byPriority = { high: [] as typeof specs, medium: [] as typeof specs, low: [] as typeof specs };
-            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";
-              response += `### ${label}\n`;
-              for (const s of items) {
-                const auto = s.automatable ? "" : " (needs human assistance)";
-                response += `- **${s.name}**: ${s.description}${auto}\n`;
-              }
-              response += "\n";
-            }
+          let response = `## Job: ${args.job_name}\n`;
+          response += `**Description:** ${args.job_description}\n\n`;
 
-            response += `Call \`skill_generate\` again with \`job_name: "${args.job_name}"\` and \`auto_create: true\` to create all these skills, `;
-            response += "or use `skill_create` to create individual skills manually.";
-
-            return { content: [{ type: "text", text: response }] };
-          }
-
-          // Step 2: Auto-create — generate full skills for each spec
-          const created: string[] = [];
-          const failed: string[] = [];
-
-          // Generate skills in parallel (batch of 3 to avoid rate limits)
-          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;
-                // Check for duplicates
-                const existing = skillManager.findSimilar(generated.name);
-                if (existing) {
-                  failed.push(`${spec.name} (duplicate of "${existing.name}")`);
-                  continue;
-                }
-
-                // Create in skills table (draft)
-                const createResult = await skillManager.create(
-                  generated.name,
-                  generated.description || spec.description,
-                  generated.steps,
-                  {
-                    source: "job_generated",
-                    emoji: generated.emoji,
-                    keywords: generated.keywords,
-                  }
-                );
-
-                if (createResult) {
-                  // Add to user's collection (approval)
-                  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 (existingNames.length > 0) {
+            response += `**Existing skills (do NOT duplicate):** ${existingNames.join(", ")}\n\n`;
           }
 
-          // Step 3: Save job to DB, link generated skills, and mark as analyzed
-          if (userId) {
-            saveJobToDb(
-              userId,
-              args.job_name,
-              args.job_description,
-              created
-            ).catch((err) => {
-              log.debug(`saveJobToDb error: ${err}`);
-            });
-          }
+          response += `**Your task:** Analyze this job description and decompose it into 4-10 automatable skills. `;
+          response += `For each skill, call \`skill_create\` with:\n`;
+          response += `- name: kebab-case name (e.g. "slack-message-check")\n`;
+          response += `- description: one-line description\n`;
+          response += `- instructions: detailed step-by-step markdown instructions the agent can follow\n`;
+          response += `- emoji: a single emoji representing the skill\n\n`;
+          response += `After creating each skill, call \`skill_add\` with the returned skill ID to add it to the user's collection.\n\n`;
+          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.\n\n`;
+          response += `**Guidelines for skill instructions:**\n`;
+          response += `- Write clear, actionable markdown steps\n`;
+          response += `- Reference browser tools (browser_navigate, browser_click, browser_read_page, etc.) for web tasks\n`;
+          response += `- Include error handling steps\n`;
+          response += `- Use placeholders like {query}, {date} for variable inputs\n`;
+          response += `- Each skill should be a single, well-defined workflow (10-25 steps)\n`;
 
-          let response = `## Skills Generated for "${args.job_name}"\n\n`;
-          response += `Created **${created.length}/${specs.length}** skills from your job description:\n\n`;
-
-          for (const name of created) {
-            const skill = skillManager.get(name);
-            const emoji = skill?.metadata.emoji || "";
-            response += `- ${emoji} **${name}**: ${skill?.description || ""}\n`;
+          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." }],
+            };
           }
 
-          if (failed.length > 0) {
-            response += `\nFailed to create: ${failed.join(", ")}\n`;
+          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}`,
+              }],
+            };
           }
-
-          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(

package/src/agent/processor.test.ts

@@ -92,11 +92,8 @@ vi.mock("./skills.js", () => ({
   },
 }));
 
-vi.mock("./memory-extractor.js", () => ({
-  extractMemoriesWithLLM: vi.fn().mockResolvedValue([]),
-}));
 vi.mock("./skill-extractor.js", () => ({
-  // Only ToolCallRecord type is used — no functions imported
+  // Only ToolCallRecord type is used
 }));
 
 vi.mock("../utils/rate-limiter.js", () => ({

package/src/agent/processor.ts

@@ -20,7 +20,6 @@ import { log, newCorrelationId, setCorrelationId } from "../utils/logger.js";
 import { getBrowser } from "../tools/browser.js";
 import { MemoryManager } from "./memory.js";
 import { SkillManager } from "./skills.js";
-import { extractMemoriesWithLLM } from "./memory-extractor.js";
 import { type ToolCallRecord } from "./skill-extractor.js";
 import { withRetry } from "../utils/retry.js";
 import {
@@ -56,6 +55,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)
@@ -232,6 +233,7 @@ export class TaskProcessor {
         "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",
@@ -367,35 +369,9 @@ export class TaskProcessor {
       }
       this.historyCache.set(task.conversation_id, convHistory);
 
-      // ── Post-task extraction (fire-and-forget, non-blocking) ──────
-
-      // Auto-extract memories using LLM
-      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 {
-                // Non-critical — skip individual memory failures
-              }
-            }
-            if (memories.length > 0) {
-              log.success(`${memories.length} memory(s) auto-extracted`);
-            }
-          })
-          .catch(() => {});
-      }
-
-      // Note: Skill creation/improvement is now handled pre-task via the
-      // skill_create → user approval → skill_add flow, not post-task extraction.
+      // 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.
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       log.error(`Task failed: ${errorMsg}`);