@byte5ai/palaia 1.8.1 → 2.0.2

package/src/runner.ts

@@ -164,11 +164,24 @@ export async function run(
     cmdArgs = [...args];
   }
 
-  const result = await execCommand(cmd, cmdArgs, {
+  let result = await execCommand(cmd, cmdArgs, {
     timeoutMs,
     cwd: opts.workspace,
   });
 
+  // Retry once on lock/timeout errors (L-5: concurrent CLI write safety)
+  if (result.exitCode !== 0) {
+    const errMsg = result.stderr.trim() || result.stdout.trim();
+    const errLower = errMsg.toLowerCase();
+    if (errLower.includes("lock") || errLower.includes("timeout")) {
+      await new Promise((r) => setTimeout(r, 500));
+      result = await execCommand(cmd, cmdArgs, {
+        timeoutMs,
+        cwd: opts.workspace,
+      });
+    }
+  }
+
   if (result.exitCode !== 0) {
     const errMsg = result.stderr.trim() || result.stdout.trim();
     throw new Error(`Palaia CLI error (exit ${result.exitCode}): ${errMsg}`);

package/src/tools.ts

@@ -9,6 +9,7 @@
 import { Type } from "@sinclair/typebox";
 import { runJson, type RunnerOpts } from "./runner.js";
 import type { PalaiaPluginConfig } from "./config.js";
+import { sanitizeScope, isValidScope } from "./hooks.js";
 
 /** Shape returned by `palaia query --json` */
 interface QueryResult {
@@ -84,6 +85,11 @@ export function registerTools(api: any, config: PalaiaPluginConfig): void {
           description: "Filter by scope: private|team|shared:X|public",
         })
       ),
+      type: Type.Optional(
+        Type.String({
+          description: "Filter by entry type: memory|process|task",
+        })
+      ),
     }),
     async execute(
       _id: string,
@@ -92,6 +98,7 @@ export function registerTools(api: any, config: PalaiaPluginConfig): void {
         maxResults?: number;
         tier?: string;
         scope?: string;
+        type?: string;
       }
     ) {
       const limit = params.maxResults || config.maxResults || 5;
@@ -102,6 +109,11 @@ export function registerTools(api: any, config: PalaiaPluginConfig): void {
         args.push("--all");
       }
 
+      // Type filter (Issue #82)
+      if (params.type) {
+        args.push("--type", params.type);
+      }
+
       const result = await runJson<QueryResult>(args, opts);
 
       // Format as memory_search compatible output
@@ -190,18 +202,59 @@ export function registerTools(api: any, config: PalaiaPluginConfig): void {
             description: "Tags for categorization",
           })
         ),
+        type: Type.Optional(
+          Type.String({
+            description: "Entry type: memory|process|task (default: memory)",
+          })
+        ),
+        project: Type.Optional(
+          Type.String({
+            description: "Project name to associate this entry with",
+          })
+        ),
+        title: Type.Optional(
+          Type.String({
+            description: "Title for the entry",
+          })
+        ),
       }),
       async execute(
         _id: string,
-        params: { content: string; scope?: string; tags?: string[] }
+        params: {
+          content: string;
+          scope?: string;
+          tags?: string[];
+          type?: string;
+          project?: string;
+          title?: string;
+        }
       ) {
         const args: string[] = ["write", params.content];
         if (params.scope) {
-          args.push("--scope", params.scope);
+          if (!isValidScope(params.scope)) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `Invalid scope "${params.scope}". Valid scopes: private, team, public, shared:<name>`,
+                },
+              ],
+            };
+          }
+          args.push("--scope", sanitizeScope(params.scope));
         }
         if (params.tags && params.tags.length > 0) {
           args.push("--tags", params.tags.join(","));
         }
+        if (params.type) {
+          args.push("--type", params.type);
+        }
+        if (params.project) {
+          args.push("--project", params.project);
+        }
+        if (params.title) {
+          args.push("--title", params.title);
+        }
 
         const result = await runJson<WriteResult>(args, opts);