@stackmemoryai/stackmemory 1.8.1 → 1.10.2

package/dist/src/integrations/mcp/handlers/skill-handlers.js

@@ -3,66 +3,31 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../../../core/monitoring/logger.js";
-function _getEnv(key, defaultValue) {
-  const value = process.env[key];
-  if (value === void 0) {
-    if (defaultValue !== void 0) return defaultValue;
-    throw new Error(`Environment variable ${key} is required`);
-  }
-  return value;
-}
-function _getOptionalEnv(key) {
-  return process.env[key];
-}
 import {
-  getSkillStorage,
-  getDefaultUserId
+  getSkillRegistry,
+  matchPromptFromRegistry
 } from "../../../core/skills/index.js";
 class SkillHandlers {
-  constructor(redisUrl, userId) {
-    this.redisUrl = redisUrl;
-    this.userId = userId || getDefaultUserId();
+  constructor(dbPath) {
+    this.dbPath = dbPath;
   }
-  skillStorage = null;
-  userId;
-  /**
-   * Lazy initialization of skill storage
-   */
-  getStorage() {
-    if (!this.skillStorage) {
-      const url = this.redisUrl || process.env["REDIS_URL"];
-      if (!url) {
-        throw new Error("REDIS_URL not configured for skill storage");
-      }
-      this.skillStorage = getSkillStorage({
-        redisUrl: url,
-        userId: this.userId
-      });
+  registry = null;
+  getRegistry() {
+    if (!this.registry) {
+      this.registry = getSkillRegistry(this.dbPath);
     }
-    return this.skillStorage;
-  }
-  /**
-   * Get current user ID
-   */
-  getUserId() {
-    return this.userId;
+    return this.registry;
   }
-  /**
-   * Check if skill storage is available
-   */
   isAvailable() {
-    return !!(this.redisUrl || process.env["REDIS_URL"]);
+    return !!(process.env["STACKMEMORY_SKILLS"] || process.env["SM_SKILLS"]);
   }
   // ============================================================
   // SKILL OPERATIONS
   // ============================================================
-  /**
-   * Record a new skill/learning
-   */
   async recordSkill(args, context) {
     try {
-      const storage = this.getStorage();
-      const skill = await storage.createSkill({
+      const registry = this.getRegistry();
+      const skill = registry.createSkill({
         content: args.content,
         category: args.category,
         priority: args.priority || "medium",
@@ -71,10 +36,6 @@ class SkillHandlers {
         source: args.source || "observation",
         sessionId: context.sessionId
       });
-      logger.info("Recorded skill via MCP", {
-        skillId: skill.id,
-        category: skill.category
-      });
       return { success: true, skill };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -82,13 +43,10 @@ class SkillHandlers {
       return { success: false, error: message };
     }
   }
-  /**
-   * Get relevant skills for current context
-   */
   async getRelevantSkills(args) {
     try {
-      const storage = this.getStorage();
-      const skills = await storage.getRelevantSkills({
+      const registry = this.getRegistry();
+      const skills = registry.getRelevantSkills({
         tool: args.tool,
         language: args.language,
         framework: args.framework,
@@ -102,12 +60,9 @@ class SkillHandlers {
       return { success: false, error: message };
     }
   }
-  /**
-   * Query skills with filters
-   */
   async querySkills(args) {
     try {
-      const storage = this.getStorage();
+      const registry = this.getRegistry();
       const query = {
         categories: args.categories,
         priorities: args.priorities,
@@ -119,7 +74,7 @@ class SkillHandlers {
         sortBy: args.sortBy || "priority",
         sortOrder: "desc"
       };
-      const skills = await storage.querySkills(query);
+      const skills = registry.querySkills(query);
       return { success: true, skills, total: skills.length };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -127,16 +82,11 @@ class SkillHandlers {
       return { success: false, error: message };
     }
   }
-  /**
-   * Validate/reinforce a skill
-   */
   async validateSkill(args) {
     try {
-      const storage = this.getStorage();
-      const skill = await storage.validateSkill(args.skill_id);
-      if (!skill) {
-        return { success: false, error: "Skill not found" };
-      }
+      const registry = this.getRegistry();
+      const skill = registry.validateSkill(args.skill_id);
+      if (!skill) return { success: false, error: "Skill not found" };
       return { success: true, skill };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -144,21 +94,16 @@ class SkillHandlers {
       return { success: false, error: message };
     }
   }
-  /**
-   * Update a skill
-   */
   async updateSkill(args) {
     try {
-      const storage = this.getStorage();
-      const skill = await storage.updateSkill({
+      const registry = this.getRegistry();
+      const skill = registry.updateSkill({
         id: args.skill_id,
         content: args.content,
         priority: args.priority,
         tags: args.tags
       });
-      if (!skill) {
-        return { success: false, error: "Skill not found" };
-      }
+      if (!skill) return { success: false, error: "Skill not found" };
       return { success: true, skill };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -166,16 +111,11 @@ class SkillHandlers {
       return { success: false, error: message };
     }
   }
-  /**
-   * Delete a skill
-   */
   async deleteSkill(args) {
     try {
-      const storage = this.getStorage();
-      const deleted = await storage.deleteSkill(args.skill_id);
-      if (!deleted) {
-        return { success: false, error: "Skill not found" };
-      }
+      const registry = this.getRegistry();
+      const deleted = registry.deleteSkill(args.skill_id);
+      if (!deleted) return { success: false, error: "Skill not found" };
       return { success: true };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -184,16 +124,26 @@ class SkillHandlers {
     }
   }
   // ============================================================
+  // MATCH PROMPT (NEW)
+  // ============================================================
+  async matchPrompt(args) {
+    try {
+      const result = matchPromptFromRegistry(args.prompt);
+      return { success: true, result };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to match prompt", { error: message });
+      return { success: false, error: message };
+    }
+  }
+  // ============================================================
   // SESSION JOURNAL OPERATIONS
   // ============================================================
-  /**
-   * Record a journal entry
-   */
   async recordJournalEntry(args, context) {
     try {
-      const storage = this.getStorage();
+      const registry = this.getRegistry();
       const sessionId = context.sessionId || "default";
-      const entry = await storage.createJournalEntry(
+      const entry = registry.createJournalEntry(
         sessionId,
         args.type,
         args.title,
@@ -207,14 +157,11 @@ class SkillHandlers {
       return { success: false, error: message };
     }
   }
-  /**
-   * Get session journal
-   */
   async getSessionJournal(args, context) {
     try {
-      const storage = this.getStorage();
+      const registry = this.getRegistry();
       const sessionId = args.session_id || context.sessionId || "default";
-      const entries = await storage.getSessionJournal(sessionId);
+      const entries = registry.getSessionJournal(sessionId);
       return { success: true, entries };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -222,20 +169,15 @@ class SkillHandlers {
       return { success: false, error: message };
     }
   }
-  /**
-   * Promote a journal entry to a skill
-   */
   async promoteToSkill(args) {
     try {
-      const storage = this.getStorage();
-      const skill = await storage.promoteToSkill(
+      const registry = this.getRegistry();
+      const skill = registry.promoteToSkill(
         args.entry_id,
         args.category,
         args.priority || "medium"
       );
-      if (!skill) {
-        return { success: false, error: "Journal entry not found" };
-      }
+      if (!skill) return { success: false, error: "Journal entry not found" };
       return { success: true, skill };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -246,13 +188,10 @@ class SkillHandlers {
   // ============================================================
   // SESSION MANAGEMENT
   // ============================================================
-  /**
-   * Start session tracking
-   */
   async startSession(args) {
     try {
-      const storage = this.getStorage();
-      await storage.startSession(args.session_id);
+      const registry = this.getRegistry();
+      registry.startSession(args.session_id);
       return { success: true };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -260,16 +199,11 @@ class SkillHandlers {
       return { success: false, error: message };
     }
   }
-  /**
-   * End session and get summary
-   */
   async endSession(args) {
     try {
-      const storage = this.getStorage();
-      const summary = await storage.endSession(args.session_id);
-      if (!summary) {
-        return { success: false, error: "Session not found" };
-      }
+      const registry = this.getRegistry();
+      const summary = registry.endSession(args.session_id);
+      if (!summary) return { success: false, error: "Session not found" };
       return { success: true, summary };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -278,60 +212,12 @@ class SkillHandlers {
     }
   }
   // ============================================================
-  // KNOWLEDGE MANAGEMENT
+  // METRICS
   // ============================================================
-  /**
-   * Get promotion candidates
-   */
-  async getPromotionCandidates() {
-    try {
-      const storage = this.getStorage();
-      const skills = await storage.getPromotionCandidates();
-      return { success: true, skills };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      logger.error("Failed to get promotion candidates", { error: message });
-      return { success: false, error: message };
-    }
-  }
-  /**
-   * Promote skill priority
-   */
-  async promoteSkillPriority(args) {
-    try {
-      const storage = this.getStorage();
-      const skill = await storage.promoteSkill(args.skill_id);
-      if (!skill) {
-        return { success: false, error: "Skill not found" };
-      }
-      return { success: true, skill };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      logger.error("Failed to promote skill priority", { error: message });
-      return { success: false, error: message };
-    }
-  }
-  /**
-   * Archive stale skills
-   */
-  async archiveStaleSkills(args) {
-    try {
-      const storage = this.getStorage();
-      const count = await storage.archiveStaleSkills(args.days_threshold || 90);
-      return { success: true, archivedCount: count };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      logger.error("Failed to archive stale skills", { error: message });
-      return { success: false, error: message };
-    }
-  }
-  /**
-   * Get skill storage metrics
-   */
   async getSkillMetrics() {
     try {
-      const storage = this.getStorage();
-      const metrics = await storage.getMetrics();
+      const registry = this.getRegistry();
+      const metrics = registry.getMetrics();
       return { success: true, metrics };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -520,6 +406,20 @@ const SKILL_TOOL_DEFINITIONS = [
       type: "object",
       properties: {}
     }
+  },
+  {
+    name: "match_prompt",
+    description: "Match a prompt against skill rules and return scored skill suggestions",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: {
+          type: "string",
+          description: "The prompt text to match against skill rules"
+        }
+      },
+      required: ["prompt"]
+    }
   }
 ];
 export {

package/dist/src/integrations/mcp/server.js

@@ -29,10 +29,6 @@ import { execSync } from "child_process";
 import { FrameManager } from "../../core/context/index.js";
 import { logger } from "../../core/monitoring/logger.js";
 import { isFeatureEnabled } from "../../core/config/feature-flags.js";
-import {
-  TaskPriority,
-  TaskStatus
-} from "../../features/tasks/linear-task-manager.js";
 import { BrowserMCPIntegration } from "../../features/browser/browser-mcp.js";
 import { TraceDetector } from "../../core/trace/trace-detector.js";
 import { LLMContextRetrieval } from "../../core/retrieval/index.js";
@@ -1353,6 +1349,15 @@ ${summary}...`, 0.8);
             case "linear_status":
               result = await this.handleLinearStatus(args);
               break;
+            case "linear_create_comment":
+              result = await this.handleLinearCreateComment(args);
+              break;
+            case "linear_update_comment":
+              result = await this.handleLinearUpdateComment(args);
+              break;
+            case "linear_list_comments":
+              result = await this.handleLinearListComments(args);
+              break;
             case "get_traces":
               result = await this.handleGetTraces(args);
               break;
@@ -2665,6 +2670,114 @@ Tokens: Valid`
       };
     }
   }
+  async getLinearClient() {
+    const { LinearClient } = await import("../linear/client.js");
+    const tokens = this.linearAuthManager.loadTokens();
+    if (!tokens) {
+      throw new Error("Linear not configured. Run: stackmemory linear setup");
+    }
+    return new LinearClient({
+      apiKey: tokens.accessToken,
+      useBearer: true,
+      onUnauthorized: async () => {
+        const refreshed = await this.linearAuthManager.refreshAccessToken();
+        return refreshed.accessToken;
+      }
+    });
+  }
+  async handleLinearCreateComment(args) {
+    const { issue_id, body } = args;
+    if (!issue_id || !body) {
+      return {
+        content: [
+          { type: "text", text: "Error: issue_id and body are required" }
+        ]
+      };
+    }
+    try {
+      const client = await this.getLinearClient();
+      const comment = await client.createComment(issue_id, body);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Comment created on ${issue_id}
+ID: ${comment.id}
+Preview: ${body.slice(0, 100)}${body.length > 100 ? "..." : ""}`
+          }
+        ],
+        metadata: { id: comment.id, issueId: issue_id }
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `Error creating comment: ${msg}` }]
+      };
+    }
+  }
+  async handleLinearUpdateComment(args) {
+    const { comment_id, body } = args;
+    if (!comment_id || !body) {
+      return {
+        content: [
+          { type: "text", text: "Error: comment_id and body are required" }
+        ]
+      };
+    }
+    try {
+      const client = await this.getLinearClient();
+      const comment = await client.updateComment(comment_id, body);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Comment ${comment_id} updated
+Preview: ${body.slice(0, 100)}${body.length > 100 ? "..." : ""}`
+          }
+        ],
+        metadata: { id: comment.id, updatedAt: comment.updatedAt }
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `Error updating comment: ${msg}` }]
+      };
+    }
+  }
+  async handleLinearListComments(args) {
+    const { issue_id } = args;
+    if (!issue_id) {
+      return {
+        content: [{ type: "text", text: "Error: issue_id is required" }]
+      };
+    }
+    try {
+      const client = await this.getLinearClient();
+      const comments = await client.getComments(issue_id);
+      const lines = comments.map(
+        (c) => `${c.id.slice(0, 8)} | ${c.user?.name ?? "unknown"} | ${new Date(c.createdAt).toISOString().slice(0, 10)} | ${c.body.slice(0, 60).replace(/\n/g, " ")}${c.body.length > 60 ? "..." : ""}`
+      );
+      const text = comments.length > 0 ? `${comments.length} comments on ${issue_id}:
+${lines.join("\n")}` : `No comments on ${issue_id}`;
+      return {
+        content: [{ type: "text", text }],
+        metadata: {
+          count: comments.length,
+          comments: comments.map((c) => ({
+            id: c.id,
+            author: c.user?.name,
+            createdAt: c.createdAt,
+            bodyPreview: c.body.slice(0, 200)
+          }))
+        }
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `Error listing comments: ${msg}` }]
+      };
+    }
+  }
   async handleGetTraces(args) {
     const { type, minScore, limit = 20 } = args;
     this.traceDetector.flush();
@@ -3238,8 +3351,6 @@ if (import.meta.url === `file://${process.argv[1]}`) {
   server.start().catch(console.error);
 }
 export {
-  TaskPriority,
-  TaskStatus,
   server_default as default,
   runMCPServer
 };