@maskweaver/plugin 0.2.0 → 0.3.1

package/dist/index.js

@@ -17,9 +17,8 @@ function parseSimpleYaml(content) {
     const line = lines[i];
     const trimmed = line.trimStart();
     if (!trimmed || trimmed.startsWith("#")) {
-      if (multilineKey) {
+      if (multilineKey)
         multilineValue.push("");
-      }
       continue;
     }
     const indent = line.length - trimmed.length;
@@ -51,9 +50,8 @@ function parseSimpleYaml(content) {
         const objKey = value.slice(0, colonIdx).trim();
         const objVal = value.slice(colonIdx + 1).trim();
         const arrayItem = {};
-        if (objVal) {
+        if (objVal)
           arrayItem[objKey] = parseValue(objVal);
-        }
         let j = i + 1;
         const itemIndent = indent + 2;
         while (j < lines.length) {
@@ -64,16 +62,14 @@ function parseSimpleYaml(content) {
             j++;
             continue;
           }
-          if (nextIndent < itemIndent || nextTrimmed.startsWith("- ")) {
+          if (nextIndent < itemIndent || nextTrimmed.startsWith("- "))
             break;
-          }
           if (nextTrimmed.includes(":")) {
             const nColonIdx = nextTrimmed.indexOf(":");
             const nKey = nextTrimmed.slice(0, nColonIdx).trim();
             const nVal = nextTrimmed.slice(nColonIdx + 1).trim();
-            if (nVal) {
+            if (nVal)
               arrayItem[nKey] = parseValue(nVal);
-            }
           }
           j++;
         }
@@ -110,8 +106,7 @@ function parseSimpleYaml(content) {
       }
       const colonIdx = trimmed.indexOf(":");
       const key = trimmed.slice(0, colonIdx).trim();
-      const rawValue = trimmed.slice(colonIdx + 1);
-      const value = rawValue.trim();
+      const value = trimmed.slice(colonIdx + 1).trim();
       const parent = stack[stack.length - 1];
       if (!value) {
         const nextLine = lines[i + 1];
@@ -169,21 +164,18 @@ class MaskLoader {
     this.masksDir = masksDir;
   }
   async loadCatalog() {
-    if (this.catalog) {
+    if (this.catalog)
       return this.catalog;
-    }
     const indexPath = path.join(this.masksDir, "index.json");
-    if (!fs.existsSync(indexPath)) {
-      throw new Error(`Mask catalog not found: ${indexPath}`);
-    }
+    if (!fs.existsSync(indexPath))
+      throw new Error(`Catalog not found: ${indexPath}`);
     const content = fs.readFileSync(indexPath, "utf-8");
     this.catalog = JSON.parse(content);
     return this.catalog;
   }
   async load(maskId) {
-    if (this.cache.has(maskId)) {
+    if (this.cache.has(maskId))
       return this.cache.get(maskId);
-    }
     const catalog = await this.loadCatalog();
     let entry = null;
     let categoryId = null;
@@ -195,20 +187,14 @@ class MaskLoader {
         break;
       }
     }
-    if (!entry || !categoryId) {
+    if (!entry || !categoryId)
       return null;
-    }
     const filePath = path.join(this.masksDir, entry.file);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`Mask file not found: ${filePath}`);
-    }
+    if (!fs.existsSync(filePath))
+      throw new Error(`File not found: ${filePath}`);
     const content = fs.readFileSync(filePath, "utf-8");
     const parsed = filePath.endsWith(".yaml") || filePath.endsWith(".yml") ? parseSimpleYaml(content) : JSON.parse(content);
-    const loadedMask = {
-      ...parsed,
-      category: categoryId,
-      filePath
-    };
+    const loadedMask = { ...parsed, category: categoryId, filePath };
     this.cache.set(maskId, loadedMask);
     return loadedMask;
   }
@@ -217,10 +203,7 @@ class MaskLoader {
     const result = [];
     for (const [categoryId, category] of Object.entries(catalog.categories)) {
       for (const mask of category.masks) {
-        result.push({
-          ...mask,
-          category: categoryId
-        });
+        result.push({ ...mask, category: categoryId });
       }
     }
     return result;
@@ -244,9 +227,8 @@ function buildRichPrompt(mask) {
   parts.push(mask.profile.background.trim());
   parts.push("");
   parts.push("YOUR EXPERTISE:");
-  for (const exp of mask.profile.expertise) {
+  for (const exp of mask.profile.expertise)
     parts.push(`- ${exp}`);
-  }
   parts.push("");
   parts.push("YOUR THINKING STYLE:");
   parts.push(mask.profile.thinkingStyle.trim());
@@ -261,84 +243,74 @@ function buildRichPrompt(mask) {
   parts.push(`- Technical depth: ${style.technicalDepth}`);
   parts.push("");
   parts.push("YOUR STRENGTHS:");
-  for (const strength of mask.profile.strengths) {
+  for (const strength of mask.profile.strengths)
     parts.push(`- ${strength}`);
-  }
-  if (mask.profile.limitations && mask.profile.limitations.length > 0) {
+  if (mask.profile.limitations?.length) {
     parts.push("");
     parts.push("ACKNOWLEDGE YOUR LIMITATIONS:");
-    for (const limitation of mask.profile.limitations) {
+    for (const limitation of mask.profile.limitations)
       parts.push(`- ${limitation}`);
-    }
   }
-  if (mask.behavior.signaturePhrases && mask.behavior.signaturePhrases.length > 0) {
+  if (mask.behavior.signaturePhrases?.length) {
     parts.push("");
     parts.push("PHRASES YOU MIGHT USE:");
-    for (const phrase of mask.behavior.signaturePhrases) {
+    for (const phrase of mask.behavior.signaturePhrases)
       parts.push(`- "${phrase}"`);
-    }
   }
   return parts.join(`
 `);
 }
-var MaskweaverPlugin = async (ctx) => {
-  const { directory, client } = ctx;
+var state = null;
+var MaskweaverPlugin = async ({ client, directory }) => {
+  const masksDir = path.join(directory, ".opencode", "masks");
+  state = {
+    maskLoader: null,
+    activeMask: null,
+    masksDir
+  };
   client.app.log({
     service: "maskweaver",
     level: "info",
-    message: "Maskweaver plugin loaded v0.2.0"
+    message: "Maskweaver plugin loaded v0.3.1"
   });
-  const state = {
-    maskLoader: null,
-    activeMask: null,
-    masksDir: path.join(directory, ".opencode", "masks")
-  };
-  if (fs.existsSync(state.masksDir)) {
-    state.maskLoader = new MaskLoader(state.masksDir);
+  if (fs.existsSync(masksDir)) {
+    state.maskLoader = new MaskLoader(masksDir);
     try {
       await state.maskLoader.loadCatalog();
       client.app.log({
         service: "maskweaver",
         level: "info",
-        message: `Masks directory found: ${state.masksDir}`
+        message: `Masks found at: ${masksDir}`
       });
     } catch (e) {
       client.app.log({
         service: "maskweaver",
         level: "warn",
-        message: `Failed to load mask catalog: ${e}`
+        message: `Failed to load masks: ${e}`
       });
       state.maskLoader = null;
     }
-  } else {
-    client.app.log({
-      service: "maskweaver",
-      level: "info",
-      message: "No masks directory found, using empty catalog"
-    });
   }
   return {
-    tools: [
-      {
-        name: "list_masks",
-        description: "List all available expert persona masks. Returns mask IDs, names, categories, and tags.",
-        parameters: {
-          type: "object",
-          properties: {
-            category: {
-              type: "string",
-              description: 'Optional: filter by category (e.g., "software-engineering", "ai-ml", "architecture")'
-            }
-          },
-          required: []
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (state?.activeMask) {
+        const maskPrompt = `<ACTIVE_PERSONA>
+You are currently embodying the "${state.activeMask.profile.name}" persona.
+
+${buildRichPrompt(state.activeMask)}
+</ACTIVE_PERSONA>`;
+        (output.system ||= []).push(maskPrompt);
+      }
+    },
+    tool: {
+      list_masks: {
+        description: "List all available expert persona masks.",
+        args: {
+          category: { type: "string", description: "Filter by category" }
         },
-        execute: async (args) => {
-          if (!state.maskLoader) {
-            return {
-              success: false,
-              error: "No masks directory found",
-              hint: "Create a masks catalog at .opencode/masks/index.json"
-            };
+        async execute(args) {
+          if (!state?.maskLoader) {
+            return "Error: No masks directory found. Create .opencode/masks/index.json";
           }
           try {
             const masks = await state.maskLoader.listAll();
@@ -347,198 +319,115 @@ var MaskweaverPlugin = async (ctx) => {
             if (args.category) {
               filtered = masks.filter((m) => m.category === args.category);
             }
-            return {
-              success: true,
-              activeMask: state.activeMask?.metadata.id || null,
-              categories,
-              masks: filtered.map((m) => ({
-                id: m.id,
-                name: m.name,
-                category: m.category,
-                tags: m.tags
-              })),
-              total: filtered.length
-            };
+            const lines = [];
+            lines.push(`Maskweaver v0.3.1 - ${filtered.length} masks available`);
+            lines.push(`Active mask: ${state.activeMask?.metadata.id || "none"}`);
+            lines.push("");
+            lines.push("Categories:");
+            for (const cat of categories) {
+              lines.push(`  - ${cat.id}: ${cat.name} (${cat.count} masks)`);
+            }
+            lines.push("");
+            lines.push("Masks:");
+            for (const mask of filtered) {
+              lines.push(`  - ${mask.id}: ${mask.name} [${mask.category}]`);
+            }
+            return lines.join(`
+`);
           } catch (e) {
-            return {
-              success: false,
-              error: `Failed to list masks: ${e}`
-            };
+            return `Error: ${e}`;
           }
         }
       },
-      {
-        name: "select_mask",
-        description: "Select and apply an expert persona mask. This changes the AI behavior to match the selected expert.",
-        parameters: {
-          type: "object",
-          properties: {
-            maskId: {
-              type: "string",
-              description: 'The mask ID to select (e.g., "kent-beck", "linus-torvalds", "martin-fowler")'
-            }
-          },
-          required: ["maskId"]
+      select_mask: {
+        description: "Select and apply an expert persona mask.",
+        args: {
+          maskId: { type: "string", description: 'Mask ID (e.g., "kent-beck")' }
         },
-        execute: async (args) => {
-          if (!state.maskLoader) {
-            return {
-              success: false,
-              error: "No masks directory found",
-              hint: "Create a masks catalog at .opencode/masks/index.json"
-            };
+        async execute(args) {
+          if (!state?.maskLoader) {
+            return "Error: No masks directory found.";
           }
           try {
             const mask = await state.maskLoader.load(args.maskId);
             if (!mask) {
               const available = await state.maskLoader.listAll();
-              return {
-                success: false,
-                error: `Mask not found: ${args.maskId}`,
-                availableMasks: available.map((m) => m.id)
-              };
+              return `Error: Mask "${args.maskId}" not found.
+Available: ${available.map((m) => m.id).join(", ")}`;
             }
             state.activeMask = mask;
-            client.app.log({
-              service: "maskweaver",
-              level: "info",
-              message: `Mask selected: ${mask.profile.name}`
-            });
-            return {
-              success: true,
-              mask: {
-                id: mask.metadata.id,
-                name: mask.profile.name,
-                tagline: mask.profile.tagline,
-                category: mask.category,
-                expertise: mask.profile.expertise
-              },
-              systemPromptPreview: mask.behavior.systemPrompt.slice(0, 200) + "...",
-              message: `Now embodying: ${mask.profile.name} - ${mask.profile.tagline}`
-            };
+            return `✓ Mask activated: ${mask.profile.name}
+
+"${mask.profile.tagline}"
+
+Expertise: ${mask.profile.expertise.join(", ")}
+
+The mask prompt will be injected into all future messages.`;
           } catch (e) {
-            return {
-              success: false,
-              error: `Failed to select mask: ${e}`
-            };
+            return `Error: ${e}`;
           }
         }
       },
-      {
-        name: "deselect_mask",
-        description: "Deselect the current mask and return to default AI behavior.",
-        parameters: {
-          type: "object",
-          properties: {},
-          required: []
-        },
-        execute: async () => {
-          const previousMask = state.activeMask;
-          state.activeMask = null;
-          if (previousMask) {
-            client.app.log({
-              service: "maskweaver",
-              level: "info",
-              message: `Mask deselected: ${previousMask.profile.name}`
-            });
-            return {
-              success: true,
-              previousMask: previousMask.metadata.id,
-              message: "Returned to default behavior"
-            };
+      deselect_mask: {
+        description: "Remove the current mask and return to default behavior.",
+        args: {},
+        async execute() {
+          const prev = state?.activeMask;
+          if (state)
+            state.activeMask = null;
+          if (prev) {
+            return `✓ Mask removed: ${prev.profile.name}
+Returned to default behavior.`;
           }
-          return {
-            success: true,
-            message: "No mask was active"
-          };
+          return "No mask was active.";
         }
       },
-      {
-        name: "get_mask_prompt",
-        description: "Get the full system prompt for a mask. Useful for understanding what a mask does.",
-        parameters: {
-          type: "object",
-          properties: {
-            maskId: {
-              type: "string",
-              description: "The mask ID to get prompt for. If not provided, uses the active mask."
-            }
-          },
-          required: []
+      get_mask_prompt: {
+        description: "View the full system prompt for a mask.",
+        args: {
+          maskId: { type: "string", description: "Mask ID (uses active mask if not specified)" }
         },
-        execute: async (args) => {
-          if (!state.maskLoader) {
-            return {
-              success: false,
-              error: "No masks directory found"
-            };
-          }
+        async execute(args) {
+          if (!state?.maskLoader)
+            return "Error: No masks directory.";
           const maskId = args.maskId || state.activeMask?.metadata.id;
-          if (!maskId) {
-            return {
-              success: false,
-              error: "No mask specified and no active mask"
-            };
-          }
+          if (!maskId)
+            return "Error: No mask specified and no active mask.";
           try {
             const mask = await state.maskLoader.load(maskId);
-            if (!mask) {
-              return {
-                success: false,
-                error: `Mask not found: ${maskId}`
-              };
-            }
-            return {
-              success: true,
-              maskId: mask.metadata.id,
-              name: mask.profile.name,
-              systemPrompt: buildRichPrompt(mask)
-            };
+            if (!mask)
+              return `Error: Mask "${maskId}" not found.`;
+            return `# ${mask.profile.name}
+
+${buildRichPrompt(mask)}`;
           } catch (e) {
-            return {
-              success: false,
-              error: `Failed to get mask prompt: ${e}`
-            };
+            return `Error: ${e}`;
           }
         }
       },
-      {
-        name: "maskweaver_status",
-        description: "Get the current Maskweaver status including active mask and available masks count.",
-        parameters: {
-          type: "object",
-          properties: {},
-          required: []
-        },
-        execute: async () => {
+      maskweaver_status: {
+        description: "Check Maskweaver status.",
+        args: {},
+        async execute() {
           let masksCount = 0;
           let categoriesCount = 0;
-          if (state.maskLoader) {
+          if (state?.maskLoader) {
             try {
               const masks = await state.maskLoader.listAll();
               const categories = await state.maskLoader.listCategories();
               masksCount = masks.length;
               categoriesCount = categories.length;
-            } catch (e) {}
+            } catch (_e) {}
           }
-          return {
-            success: true,
-            version: "0.2.0",
-            masksDir: state.masksDir,
-            masksAvailable: state.maskLoader !== null,
-            activeMask: state.activeMask ? {
-              id: state.activeMask.metadata.id,
-              name: state.activeMask.profile.name,
-              category: state.activeMask.category
-            } : null,
-            stats: {
-              masks: masksCount,
-              categories: categoriesCount
-            }
-          };
+          return `Maskweaver v0.3.1
+Masks directory: ${state?.masksDir}
+Available: ${state?.maskLoader ? "yes" : "no"}
+Total masks: ${masksCount}
+Categories: ${categoriesCount}
+Active mask: ${state?.activeMask ? `${state.activeMask.profile.name} (${state.activeMask.metadata.id})` : "none"}`;
         }
       }
-    ]
+    }
   };
 };
 var src_default = MaskweaverPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maskweaver/plugin",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Maskweaver plugin for opencode - Expert AI personas",
   "type": "module",
   "main": "./dist/index.js",