@polka-codes/cli 0.9.93 → 0.9.95

package/dist/index.js

@@ -42709,6 +42709,10 @@ ${error48}`);
         const config3 = readConfig(path);
         configs.push(config3);
       } catch (error48) {
+        const errorCode = error48?.code;
+        if (errorCode === "ENOENT") {
+          continue;
+        }
         console.error(`Error loading config file: ${path}
 ${error48}`);
         throw error48;
@@ -94126,7 +94130,7 @@ function createGitReadBinaryFile(commit2) {
       };
     }
     const isWindows2 = process.platform === "win32";
-    const command = isWindows2 ? `cmd /c "git show ${quotedCommit}:${quotedUrl} | base64 -w 0 2>&1"` : `sh -c "git show ${quotedCommit}:${quotedUrl} | base64 2>&1"`;
+    const command = isWindows2 ? `cmd /c "git show ${quotedCommit}:${quotedUrl} | base64 -w 0"` : `sh -c "git show ${quotedCommit}:${quotedUrl} | base64"`;
     const result = await provider3.executeCommand(command, false);
     if (result.exitCode === 0) {
       const base64Data = result.stdout.replace(/\n/g, "");
@@ -112340,7 +112344,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.93";
+var version = "0.9.95";
 
 // src/commands/agent.ts
 init_src();
@@ -120272,6 +120276,15 @@ async function executeWorkflow(workflow3, input2, commandName, logger, providerO
   }
 }
 function createPolkaCodesServerTools(logger) {
+  function escapeRegexPattern(pattern) {
+    return pattern.replace(/[.+*?^${}()|[\]\\]/g, "\\$&");
+  }
+  function createWildcardRegex(pattern) {
+    const withWildcardsPlaceholders = pattern.replace(/\*/g, "\x00STAR\x00").replace(/\?/g, "\x00QUEST\x00");
+    const escaped = escapeRegexPattern(withWildcardsPlaceholders);
+    const withWildcards = escaped.replace(/\0STAR\0/g, ".*").replace(/\0QUEST\0/g, ".");
+    return new RegExp(`^${withWildcards}$`);
+  }
   return [
     {
       name: "code",
@@ -120595,33 +120608,92 @@ between different operations.
 
 Parameters:
 - operation (required): The operation to perform. Use "append" to add content, "replace" to overwrite all content, or "remove" to delete the topic.
-- topic (optional): The memory topic to update. Defaults to ":default:".
-- content (optional): The content to store (required for "append" and "replace" operations).
+- topics (optional): Array of topic names for batch operations. Content can be an array (one per topic) or a single string (broadcast to all topics).
+- topic (optional): Single memory topic to update. Defaults to ":default:".
+- content (optional): The content to store (required for "append" and "replace" operations). For batch operations with topics, provide an array of the same length or a single string to broadcast.
+
+Supports wildcards in topic name for remove operation:
+- Use "*" to remove all topics (e.g., topic ":plan:*")
+- Use pattern matching like ":plan:*" to remove all topics starting with ":plan:"
 
 Returns a message confirming the operation performed.`,
       inputSchema: exports_external.object({
-        operation: exports_external.enum(["append", "replace", "remove"]).describe("The operation: append (add content), replace (overwrite), or remove (delete topic)"),
-        topic: exports_external.string().optional().describe('The memory topic to update (defaults to ":default:")'),
-        content: exports_external.string().optional().describe("Content to store (required for append/replace, must be omitted for remove)")
+        operation: exports_external.enum(["append", "replace", "remove"]).describe("The operation: append (add content), replace (overwrite), or remove (delete topic(s))"),
+        topic: exports_external.string().optional().describe('Single memory topic to update (defaults to ":default:")'),
+        topics: exports_external.array(exports_external.string()).min(1).optional().describe("Array of topics for batch operations"),
+        content: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional().describe("Content to store (string or array for batch). Required for append/replace, omitted for remove")
+      }).refine((data) => {
+        if (data.topics && data.content) {
+          if (Array.isArray(data.content)) {
+            return data.content.length === data.topics.length;
+          }
+          return true;
+        }
+        if (!data.topics && data.content !== undefined && Array.isArray(data.content)) {
+          return false;
+        }
+        return true;
+      }, {
+        message: "For single topic mode, content must be a string. For batch mode with topics array, content can be an array (same length) or a string (broadcast to all topics)"
       }),
       handler: async (args, toolContext) => {
         const {
           operation,
-          topic = ":default:",
-          content
+          topic: singleTopic,
+          topics,
+          content: contentInput
         } = args;
-        toolContext.logger.info(`MCP: Memory operation "${operation}" on topic "${topic}"`);
+        toolContext.logger.info(`MCP: Memory operation "${operation}" on ${topics ? `${topics.length} topics` : `topic "${singleTopic}"`}`);
         const memoryStore = await getMemoryStore(toolContext.logger);
         if (!memoryStore) {
           return "Error: Memory store is not enabled. Configure it in your .polkacodes.yml with memory.enabled: true";
         }
         try {
-          if ((operation === "append" || operation === "replace") && !content) {
+          if (topics) {
+            if (operation === "remove" && contentInput !== undefined) {
+              return 'Error: Content must not be provided for "remove" operation';
+            }
+            if ((operation === "append" || operation === "replace") && contentInput === undefined) {
+              return 'Error: Content is required for "append" and "replace" operations';
+            }
+            const contents = Array.isArray(contentInput) ? contentInput : topics.map(() => contentInput);
+            const operations = topics.map((topic2, index) => ({
+              operation,
+              name: topic2,
+              content: operation === "remove" ? undefined : contents[index]
+            }));
+            await memoryStore.store.batchUpdateMemory(operations);
+            return `Batch operation "${operation}" completed on ${topics.length} topics:
+${topics.join(`
+`)}`;
+          }
+          const topic = singleTopic || ":default:";
+          if (operation === "remove" && (topic.includes("*") || topic.includes("?"))) {
+            const allEntries = await memoryStore.store.queryMemory({ scope: "auto" }, { operation: "select" });
+            if (!Array.isArray(allEntries)) {
+              return "Error: Unable to query memory entries";
+            }
+            const regex2 = createWildcardRegex(topic);
+            const matchingTopics = allEntries.filter((e2) => regex2.test(e2.name)).map((e2) => e2.name);
+            if (matchingTopics.length === 0) {
+              return `No topics found matching pattern "${topic}"`;
+            }
+            const operations = matchingTopics.map((matchingTopic) => ({
+              operation: "remove",
+              name: matchingTopic
+            }));
+            await memoryStore.store.batchUpdateMemory(operations);
+            return `Removed ${matchingTopics.length} topic(s) matching pattern "${topic}":
+${matchingTopics.join(`
+`)}`;
+          }
+          if ((operation === "append" || operation === "replace") && contentInput === undefined) {
             return 'Error: Content is required for "append" and "replace" operations';
           }
-          if (operation === "remove" && content !== undefined) {
+          if (operation === "remove" && contentInput !== undefined) {
             return 'Error: Content must not be provided for "remove" operation';
           }
+          const content = typeof contentInput === "string" ? contentInput : undefined;
           await memoryStore.store.updateMemory(operation, topic, content);
           const messages = {
             append: `Content appended to memory topic "${topic}"`,
@@ -120639,22 +120711,127 @@ Returns a message confirming the operation performed.`,
       description: `List all available memory topics.
 
 Use this to see what information has been stored and which topics are
-available to read from. Returns a list of topic names that have content.`,
-      inputSchema: exports_external.object({}),
-      handler: async (_args, toolContext) => {
-        toolContext.logger.info("MCP: Listing memory topics");
+available to read from. Returns a list of topic names that have content.
+
+Parameters:
+- pattern (optional): Filter topics by wildcard pattern (e.g., ":plan:*" for all plan topics)
+- scope (optional): Filter by scope ("auto", "project", or "global")`,
+      inputSchema: exports_external.object({
+        pattern: exports_external.string().optional().describe('Filter topics by wildcard pattern (e.g., ":plan:*")'),
+        scope: exports_external.enum(["auto", "project", "global"]).optional().describe('Filter by scope (defaults to "auto")')
+      }),
+      handler: async (args, toolContext) => {
+        const { pattern, scope } = args;
+        toolContext.logger.info(`MCP: Listing memory topics${pattern ? ` with pattern "${pattern}"` : ""}`);
         const memoryStore = await getMemoryStore(toolContext.logger);
         if (!memoryStore) {
           return "Error: Memory store is not enabled. Configure it in your .polkacodes.yml with memory.enabled: true";
         }
         try {
-          const entries = await memoryStore.store.queryMemory({ scope: "auto" }, { operation: "select" });
+          const query = {};
+          query.scope = scope ?? "auto";
+          const entries = await memoryStore.store.queryMemory(query, { operation: "select" });
           if (!entries || !Array.isArray(entries) || entries.length === 0) {
             return "No memory topics found.";
           }
-          const topics = [...new Set(entries.map((e2) => e2.name))];
-          return `Memory topics:
+          let topics = [...new Set(entries.map((e2) => e2.name))];
+          if (pattern) {
+            const regex2 = createWildcardRegex(pattern);
+            topics = topics.filter((t2) => regex2.test(t2));
+          }
+          if (topics.length === 0) {
+            return pattern ? `No memory topics found matching pattern "${pattern}"` : "No memory topics found.";
+          }
+          return `Memory topics (${topics.length}):
 ${topics.join(`
+`)}`;
+        } catch (error48) {
+          return `Error: ${error48 instanceof Error ? error48.message : String(error48)}`;
+        }
+      }
+    },
+    {
+      name: "memory_query",
+      description: `Query memory with advanced filters.
+
+Use this to search memory entries by content, metadata, or other criteria.
+Returns detailed entry information with metadata.
+
+Parameters:
+- search (optional): Search text to find in content
+- type (optional): Filter by entry type (note, todo, plan, etc.)
+- status (optional): Filter by status (open, completed, closed, etc.)
+- priority (optional): Filter by priority (null, low, medium, high)
+- tags (optional): Filter by tags
+- scope (optional): Filter by scope ("auto", "project", or "global")
+- operation (optional): Query operation - "select" returns entries, "count" returns count
+
+Returns matching entries with full metadata.`,
+      inputSchema: exports_external.object({
+        search: exports_external.string().optional().describe("Search text to find in content"),
+        type: exports_external.string().optional().describe("Filter by entry type (note, todo, plan, etc.)"),
+        status: exports_external.string().optional().describe("Filter by status (open, completed, closed, etc.)"),
+        priority: exports_external.string().optional().describe("Filter by priority (null, low, medium, high)"),
+        tags: exports_external.string().optional().describe("Filter by tags"),
+        scope: exports_external.enum(["auto", "project", "global"]).optional().describe('Filter by scope (defaults to "auto")'),
+        operation: exports_external.enum(["select", "count"]).optional().describe('Query operation (defaults to "select")')
+      }),
+      handler: async (args, toolContext) => {
+        const {
+          search,
+          type,
+          status,
+          priority,
+          tags,
+          scope,
+          operation = "select"
+        } = args;
+        toolContext.logger.info(`MCP: Querying memory - operation: "${operation}"`);
+        const memoryStore = await getMemoryStore(toolContext.logger);
+        if (!memoryStore) {
+          return "Error: Memory store is not enabled. Configure it in your .polkacodes.yml with memory.enabled: true";
+        }
+        try {
+          const memoryQuery = {};
+          memoryQuery.scope = scope ?? "auto";
+          if (search)
+            memoryQuery.search = search;
+          if (type)
+            memoryQuery.type = type;
+          if (status)
+            memoryQuery.status = status;
+          if (priority)
+            memoryQuery.priority = priority;
+          if (tags)
+            memoryQuery.tags = tags;
+          const result = await memoryStore.store.queryMemory(memoryQuery, { operation });
+          if (operation === "count") {
+            return `Found ${typeof result === "number" ? result : 0} matching entries`;
+          }
+          if (!Array.isArray(result) || result.length === 0) {
+            return "No matching entries found.";
+          }
+          const formatted = result.map((entry) => {
+            const lines = [];
+            lines.push(`Topic: ${entry.name}`);
+            if (entry.entry_type)
+              lines.push(`  Type: ${entry.entry_type}`);
+            if (entry.status)
+              lines.push(`  Status: ${entry.status}`);
+            if (entry.priority)
+              lines.push(`  Priority: ${entry.priority}`);
+            if (entry.tags)
+              lines.push(`  Tags: ${entry.tags}`);
+            if (entry.created_at)
+              lines.push(`  Created: ${new Date(entry.created_at).toISOString()}`);
+            lines.push(`  Content: ${entry.content?.substring(0, 100)}${entry.content && entry.content.length > 100 ? "..." : ""}`);
+            return lines.join(`
+`);
+          });
+          return `Found ${result.length} entries:
+
+${formatted.join(`
+
 `)}`;
         } catch (error48) {
           return `Error: ${error48 instanceof Error ? error48.message : String(error48)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/cli",
-  "version": "0.9.93",
+  "version": "0.9.95",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",