mta-mcp 3.0.0 → 3.2.0

package/dist/index.js

@@ -5699,8 +5699,199 @@ async function listTroubleshootingCases(framework) {
   }
 }
 
+// src/tools/memory.ts
+import path18 from "path";
+var KnowledgeGraphManagerClass = null;
+async function loadKnowledgeGraphManager() {
+  if (!KnowledgeGraphManagerClass) {
+    try {
+      const module = await import("@modelcontextprotocol/server-memory");
+      KnowledgeGraphManagerClass = module.KnowledgeGraphManager;
+    } catch (error) {
+      console.error("\u65E0\u6CD5\u52A0\u8F7D @modelcontextprotocol/server-memory:", error);
+      throw new Error("\u77E5\u8BC6\u56FE\u8C31\u6A21\u5757\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 @modelcontextprotocol/server-memory");
+    }
+  }
+  return KnowledgeGraphManagerClass;
+}
+var memoryManager = null;
+async function getMemoryManager() {
+  if (!memoryManager) {
+    const Manager = await loadKnowledgeGraphManager();
+    const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
+    const memoryPath = path18.join(homeDir, ".mta", "memory.jsonl");
+    memoryManager = new Manager(memoryPath);
+  }
+  return memoryManager;
+}
+async function createEntities(args) {
+  const manager = await getMemoryManager();
+  const result = await manager.createEntities(args.entities);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        success: true,
+        created: result.length,
+        entities: result
+      }, null, 2)
+    }]
+  };
+}
+async function createRelations(args) {
+  const manager = await getMemoryManager();
+  const result = await manager.createRelations(args.relations);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        success: true,
+        created: result.length,
+        relations: result
+      }, null, 2)
+    }]
+  };
+}
+async function addObservations(args) {
+  const manager = await getMemoryManager();
+  const result = await manager.addObservations(args.observations);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        success: true,
+        results: result
+      }, null, 2)
+    }]
+  };
+}
+async function deleteEntities(args) {
+  const manager = await getMemoryManager();
+  await manager.deleteEntities(args.entityNames);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        success: true,
+        message: `\u5DF2\u5220\u9664 ${args.entityNames.length} \u4E2A\u5B9E\u4F53\u53CA\u5176\u5173\u8054\u5173\u7CFB`
+      }, null, 2)
+    }]
+  };
+}
+async function deleteObservations(args) {
+  const manager = await getMemoryManager();
+  await manager.deleteObservations(args.deletions);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        success: true,
+        message: "\u89C2\u5BDF\u5DF2\u5220\u9664"
+      }, null, 2)
+    }]
+  };
+}
+async function deleteRelations(args) {
+  const manager = await getMemoryManager();
+  await manager.deleteRelations(args.relations);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        success: true,
+        message: `\u5DF2\u5220\u9664 ${args.relations.length} \u4E2A\u5173\u7CFB`
+      }, null, 2)
+    }]
+  };
+}
+async function readGraph() {
+  const manager = await getMemoryManager();
+  const graph = await manager.readGraph();
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        entities: graph.entities.length,
+        relations: graph.relations.length,
+        graph
+      }, null, 2)
+    }]
+  };
+}
+async function searchNodes(args) {
+  const manager = await getMemoryManager();
+  const graph = await manager.searchNodes(args.query);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        query: args.query,
+        found: {
+          entities: graph.entities.length,
+          relations: graph.relations.length
+        },
+        graph
+      }, null, 2)
+    }]
+  };
+}
+async function openNodes(args) {
+  const manager = await getMemoryManager();
+  const graph = await manager.openNodes(args.names);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        requested: args.names,
+        found: {
+          entities: graph.entities.length,
+          relations: graph.relations.length
+        },
+        graph
+      }, null, 2)
+    }]
+  };
+}
+
+// src/tools/sequentialThinking.ts
+var SequentialThinkingServerClass = null;
+async function loadSequentialThinkingServer() {
+  if (!SequentialThinkingServerClass) {
+    try {
+      const module = await import("@modelcontextprotocol/server-sequential-thinking");
+      SequentialThinkingServerClass = module.SequentialThinkingServer;
+    } catch (error) {
+      console.error("\u65E0\u6CD5\u52A0\u8F7D @modelcontextprotocol/server-sequential-thinking:", error);
+      throw new Error("\u987A\u5E8F\u601D\u8003\u6A21\u5757\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 @modelcontextprotocol/server-sequential-thinking");
+    }
+  }
+  return SequentialThinkingServerClass;
+}
+var thinkingServer = null;
+async function getThinkingServer() {
+  if (!thinkingServer) {
+    const Server2 = await loadSequentialThinkingServer();
+    thinkingServer = new Server2();
+  }
+  return thinkingServer;
+}
+async function sequentialThinking(args) {
+  const server = await getThinkingServer();
+  const result = server.processThought(args);
+  if (result.isError) {
+    return result;
+  }
+  const parsedContent = JSON.parse(result.content[0].text);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(parsedContent, null, 2)
+    }]
+  };
+}
+
 // src/index.ts
-var SERVER_VERSION = "3.0.0";
+var SERVER_VERSION = "3.2.0";
 var logger3 = createLogger("Server");
 var CopilotPromptsMCPServer = class {
   constructor() {
@@ -6260,6 +6451,274 @@ var CopilotPromptsMCPServer = class {
               }
             }
           }
+        },
+        // ================== 知识图谱记忆工具 ==================
+        {
+          name: "create_entities",
+          description: "\u5728\u77E5\u8BC6\u56FE\u8C31\u4E2D\u521B\u5EFA\u591A\u4E2A\u65B0\u5B9E\u4F53",
+          inputSchema: {
+            type: "object",
+            properties: {
+              entities: {
+                type: "array",
+                description: "\u5B9E\u4F53\u6570\u7EC4",
+                items: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string", description: "\u5B9E\u4F53\u540D\u79F0\uFF08\u552F\u4E00\u6807\u8BC6\uFF09" },
+                    entityType: { type: "string", description: "\u5B9E\u4F53\u7C7B\u578B\uFF08\u5982 person\u3001project\u3001concept\uFF09" },
+                    observations: { type: "array", items: { type: "string" }, description: "\u5173\u4E8E\u8BE5\u5B9E\u4F53\u7684\u89C2\u5BDF/\u4E8B\u5B9E" }
+                  },
+                  required: ["name", "entityType", "observations"]
+                }
+              }
+            },
+            required: ["entities"]
+          }
+        },
+        {
+          name: "create_relations",
+          description: "\u5728\u77E5\u8BC6\u56FE\u8C31\u4E2D\u521B\u5EFA\u5B9E\u4F53\u4E4B\u95F4\u7684\u5173\u7CFB\uFF08\u4F7F\u7528\u4E3B\u52A8\u8BED\u6001\uFF09",
+          inputSchema: {
+            type: "object",
+            properties: {
+              relations: {
+                type: "array",
+                description: "\u5173\u7CFB\u6570\u7EC4",
+                items: {
+                  type: "object",
+                  properties: {
+                    from: { type: "string", description: "\u8D77\u59CB\u5B9E\u4F53\u540D\u79F0" },
+                    to: { type: "string", description: "\u76EE\u6807\u5B9E\u4F53\u540D\u79F0" },
+                    relationType: { type: "string", description: "\u5173\u7CFB\u7C7B\u578B\uFF08\u4E3B\u52A8\u8BED\u6001\uFF0C\u5982 works_at\u3001uses\u3001depends_on\uFF09" }
+                  },
+                  required: ["from", "to", "relationType"]
+                }
+              }
+            },
+            required: ["relations"]
+          }
+        },
+        {
+          name: "add_observations",
+          description: "\u5411\u73B0\u6709\u5B9E\u4F53\u6DFB\u52A0\u65B0\u7684\u89C2\u5BDF/\u4E8B\u5B9E",
+          inputSchema: {
+            type: "object",
+            properties: {
+              observations: {
+                type: "array",
+                description: "\u89C2\u5BDF\u6570\u7EC4",
+                items: {
+                  type: "object",
+                  properties: {
+                    entityName: { type: "string", description: "\u5B9E\u4F53\u540D\u79F0" },
+                    contents: { type: "array", items: { type: "string" }, description: "\u8981\u6DFB\u52A0\u7684\u89C2\u5BDF\u5185\u5BB9" }
+                  },
+                  required: ["entityName", "contents"]
+                }
+              }
+            },
+            required: ["observations"]
+          }
+        },
+        {
+          name: "delete_entities",
+          description: "\u5220\u9664\u5B9E\u4F53\u53CA\u5176\u5173\u8054\u7684\u5173\u7CFB",
+          inputSchema: {
+            type: "object",
+            properties: {
+              entityNames: {
+                type: "array",
+                items: { type: "string" },
+                description: "\u8981\u5220\u9664\u7684\u5B9E\u4F53\u540D\u79F0\u5217\u8868"
+              }
+            },
+            required: ["entityNames"]
+          }
+        },
+        {
+          name: "delete_observations",
+          description: "\u4ECE\u5B9E\u4F53\u4E2D\u5220\u9664\u7279\u5B9A\u7684\u89C2\u5BDF",
+          inputSchema: {
+            type: "object",
+            properties: {
+              deletions: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    entityName: { type: "string", description: "\u5B9E\u4F53\u540D\u79F0" },
+                    observations: { type: "array", items: { type: "string" }, description: "\u8981\u5220\u9664\u7684\u89C2\u5BDF" }
+                  },
+                  required: ["entityName", "observations"]
+                }
+              }
+            },
+            required: ["deletions"]
+          }
+        },
+        {
+          name: "delete_relations",
+          description: "\u4ECE\u77E5\u8BC6\u56FE\u8C31\u4E2D\u5220\u9664\u5173\u7CFB",
+          inputSchema: {
+            type: "object",
+            properties: {
+              relations: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    from: { type: "string", description: "\u8D77\u59CB\u5B9E\u4F53\u540D\u79F0" },
+                    to: { type: "string", description: "\u76EE\u6807\u5B9E\u4F53\u540D\u79F0" },
+                    relationType: { type: "string", description: "\u5173\u7CFB\u7C7B\u578B" }
+                  },
+                  required: ["from", "to", "relationType"]
+                }
+              }
+            },
+            required: ["relations"]
+          }
+        },
+        {
+          name: "read_graph",
+          description: "\u8BFB\u53D6\u6574\u4E2A\u77E5\u8BC6\u56FE\u8C31",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "search_nodes",
+          description: "\u5728\u77E5\u8BC6\u56FE\u8C31\u4E2D\u641C\u7D22\u8282\u70B9\uFF08\u6309\u540D\u79F0\u3001\u7C7B\u578B\u6216\u89C2\u5BDF\u5185\u5BB9\u5339\u914D\uFF09",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "\u641C\u7D22\u5173\u952E\u8BCD"
+              }
+            },
+            required: ["query"]
+          }
+        },
+        {
+          name: "open_nodes",
+          description: "\u6309\u540D\u79F0\u6253\u5F00\u7279\u5B9A\u8282\u70B9",
+          inputSchema: {
+            type: "object",
+            properties: {
+              names: {
+                type: "array",
+                items: { type: "string" },
+                description: "\u8981\u68C0\u7D22\u7684\u5B9E\u4F53\u540D\u79F0\u5217\u8868"
+              }
+            },
+            required: ["names"]
+          }
+        },
+        // ================== 顺序思考工具 ==================
+        {
+          name: "sequentialthinking",
+          description: `A detailed tool for dynamic and reflective problem-solving through thoughts.
+This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
+Each thought can build on, question, or revise previous insights as understanding deepens.
+
+When to use this tool:
+- Breaking down complex problems into steps
+- Planning and design with room for revision
+- Analysis that might need course correction
+- Problems where the full scope might not be clear initially
+- Problems that require a multi-step solution
+- Tasks that need to maintain context over multiple steps
+- Situations where irrelevant information needs to be filtered out
+
+Key features:
+- You can adjust total_thoughts up or down as you progress
+- You can question or revise previous thoughts
+- You can add more thoughts even after reaching what seemed like the end
+- You can express uncertainty and explore alternative approaches
+- Not every thought needs to build linearly - you can branch or backtrack
+- Generates a solution hypothesis
+- Verifies the hypothesis based on the Chain of Thought steps
+- Repeats the process until satisfied
+- Provides a correct answer
+
+Parameters explained:
+- thought: Your current thinking step, which can include:
+  * Regular analytical steps
+  * Revisions of previous thoughts
+  * Questions about previous decisions
+  * Realizations about needing more analysis
+  * Changes in approach
+  * Hypothesis generation
+  * Hypothesis verification
+- nextThoughtNeeded: True if you need more thinking, even if at what seemed like the end
+- thoughtNumber: Current number in sequence (can go beyond initial total if needed)
+- totalThoughts: Current estimate of thoughts needed (can be adjusted up/down)
+- isRevision: A boolean indicating if this thought revises previous thinking
+- revisesThought: If is_revision is true, which thought number is being reconsidered
+- branchFromThought: If branching, which thought number is the branching point
+- branchId: Identifier for the current branch (if any)
+- needsMoreThoughts: If reaching end but realizing more thoughts needed
+
+You should:
+1. Start with an initial estimate of needed thoughts, but be ready to adjust
+2. Feel free to question or revise previous thoughts
+3. Don't hesitate to add more thoughts if needed, even at the "end"
+4. Express uncertainty when present
+5. Mark thoughts that revise previous thinking or branch into new paths
+6. Ignore information that is irrelevant to the current step
+7. Generate a solution hypothesis when appropriate
+8. Verify the hypothesis based on the Chain of Thought steps
+9. Repeat the process until satisfied with the solution
+10. Provide a single, ideally correct answer as the final output
+11. Only set nextThoughtNeeded to false when truly done and a satisfactory answer is reached`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              thought: {
+                type: "string",
+                description: "Your current thinking step"
+              },
+              nextThoughtNeeded: {
+                type: "boolean",
+                description: "Whether another thought step is needed"
+              },
+              thoughtNumber: {
+                type: "integer",
+                description: "Current thought number (numeric value, e.g., 1, 2, 3)",
+                minimum: 1
+              },
+              totalThoughts: {
+                type: "integer",
+                description: "Estimated total thoughts needed (numeric value, e.g., 5, 10)",
+                minimum: 1
+              },
+              isRevision: {
+                type: "boolean",
+                description: "Whether this revises previous thinking"
+              },
+              revisesThought: {
+                type: "integer",
+                description: "Which thought is being reconsidered",
+                minimum: 1
+              },
+              branchFromThought: {
+                type: "integer",
+                description: "Branching point thought number",
+                minimum: 1
+              },
+              branchId: {
+                type: "string",
+                description: "Branch identifier"
+              },
+              needsMoreThoughts: {
+                type: "boolean",
+                description: "If more thoughts are needed"
+              }
+            },
+            required: ["thought", "nextThoughtNeeded", "thoughtNumber", "totalThoughts"]
+          }
         }
       ]
     }));
@@ -6372,6 +6831,38 @@ var CopilotPromptsMCPServer = class {
           case "list_troubleshooting_cases":
             result = await listTroubleshootingCases(args == null ? void 0 : args.framework);
             break;
+          // ================== 知识图谱记忆工具 ==================
+          case "create_entities":
+            result = await createEntities(args);
+            break;
+          case "create_relations":
+            result = await createRelations(args);
+            break;
+          case "add_observations":
+            result = await addObservations(args);
+            break;
+          case "delete_entities":
+            result = await deleteEntities(args);
+            break;
+          case "delete_observations":
+            result = await deleteObservations(args);
+            break;
+          case "delete_relations":
+            result = await deleteRelations(args);
+            break;
+          case "read_graph":
+            result = await readGraph();
+            break;
+          case "search_nodes":
+            result = await searchNodes(args);
+            break;
+          case "open_nodes":
+            result = await openNodes(args);
+            break;
+          // ================== 顺序思考工具 ==================
+          case "sequentialthinking":
+            result = await sequentialThinking(args);
+            break;
           default:
             throw new Error(`\u672A\u77E5\u5DE5\u5177: ${name}`);
         }
@@ -6455,6 +6946,16 @@ var CopilotPromptsMCPServer = class {
       `   \u2022 analyze_reference_project - \u6DF1\u5EA6\u5206\u6790\u53C2\u8003\u9879\u76EE`,
       `   \u2022 generate_project_skeleton - \u751F\u6210\u9879\u76EE\u9AA8\u67B6`,
       ``,
+      `\u{1F9E0} \u77E5\u8BC6\u56FE\u8C31\u8BB0\u5FC6:`,
+      `   \u2022 create_entities - \u521B\u5EFA\u5B9E\u4F53`,
+      `   \u2022 create_relations - \u521B\u5EFA\u5173\u7CFB`,
+      `   \u2022 add_observations - \u6DFB\u52A0\u89C2\u5BDF`,
+      `   \u2022 read_graph - \u8BFB\u53D6\u56FE\u8C31`,
+      `   \u2022 search_nodes - \u641C\u7D22\u8282\u70B9`,
+      ``,
+      `\u{1F914} \u987A\u5E8F\u601D\u8003:`,
+      `   \u2022 sequentialthinking - \u52A8\u6001\u53CD\u601D\u6027\u95EE\u9898\u89E3\u51B3`,
+      ``,
       `\u{1F4A1} \u63D0\u793A: \u5728 Copilot Chat \u4E2D\u4F7F\u7528 @mta \u8C03\u7528\u670D\u52A1`,
       `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`
     ];