@maskweaver/plugin 0.1.11 → 0.2.0

package/dist/index.js

@@ -1,18 +1,541 @@
 // src/index.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function parseSimpleYaml(content) {
+  const lines = content.split(`
+`);
+  const result = {};
+  const stack = [
+    { indent: -2, obj: result }
+  ];
+  let currentArrayKey = null;
+  let currentArray = [];
+  let multilineKey = null;
+  let multilineValue = [];
+  let multilineIndent = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trimStart();
+    if (!trimmed || trimmed.startsWith("#")) {
+      if (multilineKey) {
+        multilineValue.push("");
+      }
+      continue;
+    }
+    const indent = line.length - trimmed.length;
+    if (multilineKey) {
+      if (indent > multilineIndent || indent === multilineIndent && !trimmed.includes(":")) {
+        multilineValue.push(trimmed);
+        continue;
+      } else {
+        const parent = stack[stack.length - 1];
+        parent.obj[multilineKey] = multilineValue.join(`
+`).trim();
+        multilineKey = null;
+        multilineValue = [];
+      }
+    }
+    if (trimmed.startsWith("- ")) {
+      const value = trimmed.slice(2).trim();
+      while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+        const popped = stack.pop();
+        if (popped.key && currentArrayKey === popped.key) {
+          const parent = stack[stack.length - 1];
+          parent.obj[popped.key] = currentArray;
+          currentArrayKey = null;
+          currentArray = [];
+        }
+      }
+      if (value.includes(":")) {
+        const colonIdx = value.indexOf(":");
+        const objKey = value.slice(0, colonIdx).trim();
+        const objVal = value.slice(colonIdx + 1).trim();
+        const arrayItem = {};
+        if (objVal) {
+          arrayItem[objKey] = parseValue(objVal);
+        }
+        let j = i + 1;
+        const itemIndent = indent + 2;
+        while (j < lines.length) {
+          const nextLine = lines[j];
+          const nextTrimmed = nextLine.trimStart();
+          const nextIndent = nextLine.length - nextTrimmed.length;
+          if (!nextTrimmed || nextTrimmed.startsWith("#")) {
+            j++;
+            continue;
+          }
+          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) {
+              arrayItem[nKey] = parseValue(nVal);
+            }
+          }
+          j++;
+        }
+        i = j - 1;
+        currentArray.push(arrayItem);
+      } else {
+        currentArray.push(parseValue(value));
+      }
+      if (!currentArrayKey) {
+        for (let s = stack.length - 1;s >= 0; s--) {
+          if (stack[s].key) {
+            currentArrayKey = stack[s].key;
+            break;
+          }
+        }
+      }
+      continue;
+    }
+    if (trimmed.includes(":")) {
+      while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+        const popped = stack.pop();
+        if (popped.key && currentArrayKey === popped.key) {
+          const parent2 = stack[stack.length - 1];
+          parent2.obj[popped.key] = currentArray;
+          currentArrayKey = null;
+          currentArray = [];
+        }
+      }
+      if (currentArrayKey) {
+        const parent2 = stack[stack.length - 1];
+        parent2.obj[currentArrayKey] = currentArray;
+        currentArrayKey = null;
+        currentArray = [];
+      }
+      const colonIdx = trimmed.indexOf(":");
+      const key = trimmed.slice(0, colonIdx).trim();
+      const rawValue = trimmed.slice(colonIdx + 1);
+      const value = rawValue.trim();
+      const parent = stack[stack.length - 1];
+      if (!value) {
+        const nextLine = lines[i + 1];
+        if (nextLine && nextLine.trimStart().startsWith("|")) {
+          multilineKey = key;
+          multilineIndent = indent;
+          i++;
+          continue;
+        }
+        const newObj = {};
+        parent.obj[key] = newObj;
+        stack.push({ indent, obj: newObj, key });
+      } else if (value === "|" || value === ">") {
+        multilineKey = key;
+        multilineIndent = indent;
+      } else {
+        parent.obj[key] = parseValue(value);
+      }
+    }
+  }
+  if (multilineKey) {
+    const parent = stack[stack.length - 1];
+    parent.obj[multilineKey] = multilineValue.join(`
+`).trim();
+  }
+  if (currentArrayKey) {
+    const parent = stack[stack.length - 1];
+    parent.obj[currentArrayKey] = currentArray;
+  }
+  return result;
+}
+function parseValue(value) {
+  if (!value)
+    return "";
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "null" || value === "~")
+    return null;
+  const num = Number(value);
+  if (!isNaN(num) && value !== "")
+    return num;
+  return value;
+}
+
+class MaskLoader {
+  masksDir;
+  catalog = null;
+  cache = new Map;
+  constructor(masksDir) {
+    this.masksDir = masksDir;
+  }
+  async loadCatalog() {
+    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}`);
+    }
+    const content = fs.readFileSync(indexPath, "utf-8");
+    this.catalog = JSON.parse(content);
+    return this.catalog;
+  }
+  async load(maskId) {
+    if (this.cache.has(maskId)) {
+      return this.cache.get(maskId);
+    }
+    const catalog = await this.loadCatalog();
+    let entry = null;
+    let categoryId = null;
+    for (const [catId, category] of Object.entries(catalog.categories)) {
+      const found = category.masks.find((m) => m.id === maskId);
+      if (found) {
+        entry = found;
+        categoryId = catId;
+        break;
+      }
+    }
+    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}`);
+    }
+    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
+    };
+    this.cache.set(maskId, loadedMask);
+    return loadedMask;
+  }
+  async listAll() {
+    const catalog = await this.loadCatalog();
+    const result = [];
+    for (const [categoryId, category] of Object.entries(catalog.categories)) {
+      for (const mask of category.masks) {
+        result.push({
+          ...mask,
+          category: categoryId
+        });
+      }
+    }
+    return result;
+  }
+  async listCategories() {
+    const catalog = await this.loadCatalog();
+    return Object.entries(catalog.categories).map(([id, cat]) => ({
+      id,
+      name: cat.name,
+      description: cat.description,
+      count: cat.masks.length
+    }));
+  }
+}
+function buildRichPrompt(mask) {
+  const parts = [];
+  parts.push(`You are ${mask.profile.name}.`);
+  parts.push(`${mask.profile.tagline}`);
+  parts.push("");
+  parts.push("BACKGROUND:");
+  parts.push(mask.profile.background.trim());
+  parts.push("");
+  parts.push("YOUR EXPERTISE:");
+  for (const exp of mask.profile.expertise) {
+    parts.push(`- ${exp}`);
+  }
+  parts.push("");
+  parts.push("YOUR THINKING STYLE:");
+  parts.push(mask.profile.thinkingStyle.trim());
+  parts.push("");
+  parts.push("INSTRUCTIONS:");
+  parts.push(mask.behavior.systemPrompt.trim());
+  parts.push("");
+  const style = mask.behavior.communicationStyle;
+  parts.push("COMMUNICATION STYLE:");
+  parts.push(`- Tone: ${style.tone}`);
+  parts.push(`- Verbosity: ${style.verbosity}`);
+  parts.push(`- Technical depth: ${style.technicalDepth}`);
+  parts.push("");
+  parts.push("YOUR STRENGTHS:");
+  for (const strength of mask.profile.strengths) {
+    parts.push(`- ${strength}`);
+  }
+  if (mask.profile.limitations && mask.profile.limitations.length > 0) {
+    parts.push("");
+    parts.push("ACKNOWLEDGE YOUR LIMITATIONS:");
+    for (const limitation of mask.profile.limitations) {
+      parts.push(`- ${limitation}`);
+    }
+  }
+  if (mask.behavior.signaturePhrases && mask.behavior.signaturePhrases.length > 0) {
+    parts.push("");
+    parts.push("PHRASES YOU MIGHT USE:");
+    for (const phrase of mask.behavior.signaturePhrases) {
+      parts.push(`- "${phrase}"`);
+    }
+  }
+  return parts.join(`
+`);
+}
 var MaskweaverPlugin = async (ctx) => {
-  ctx.client.app.log({
+  const { directory, client } = ctx;
+  client.app.log({
     service: "maskweaver",
     level: "info",
-    message: "Maskweaver plugin loaded v0.1.11"
+    message: "Maskweaver plugin loaded v0.2.0"
   });
+  const state = {
+    maskLoader: null,
+    activeMask: null,
+    masksDir: path.join(directory, ".opencode", "masks")
+  };
+  if (fs.existsSync(state.masksDir)) {
+    state.maskLoader = new MaskLoader(state.masksDir);
+    try {
+      await state.maskLoader.loadCatalog();
+      client.app.log({
+        service: "maskweaver",
+        level: "info",
+        message: `Masks directory found: ${state.masksDir}`
+      });
+    } catch (e) {
+      client.app.log({
+        service: "maskweaver",
+        level: "warn",
+        message: `Failed to load mask catalog: ${e}`
+      });
+      state.maskLoader = null;
+    }
+  } else {
+    client.app.log({
+      service: "maskweaver",
+      level: "info",
+      message: "No masks directory found, using empty catalog"
+    });
+  }
   return {
     tools: [
       {
-        name: "maskweaver_test",
-        description: "Test tool for Maskweaver plugin",
-        parameters: {},
+        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: []
+        },
+        execute: async (args) => {
+          if (!state.maskLoader) {
+            return {
+              success: false,
+              error: "No masks directory found",
+              hint: "Create a masks catalog at .opencode/masks/index.json"
+            };
+          }
+          try {
+            const masks = await state.maskLoader.listAll();
+            const categories = await state.maskLoader.listCategories();
+            let filtered = masks;
+            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
+            };
+          } catch (e) {
+            return {
+              success: false,
+              error: `Failed to list masks: ${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"]
+        },
+        execute: async (args) => {
+          if (!state.maskLoader) {
+            return {
+              success: false,
+              error: "No masks directory found",
+              hint: "Create a masks catalog at .opencode/masks/index.json"
+            };
+          }
+          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)
+              };
+            }
+            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}`
+            };
+          } catch (e) {
+            return {
+              success: false,
+              error: `Failed to select mask: ${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"
+            };
+          }
+          return {
+            success: true,
+            message: "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: []
+        },
+        execute: async (args) => {
+          if (!state.maskLoader) {
+            return {
+              success: false,
+              error: "No masks directory found"
+            };
+          }
+          const maskId = args.maskId || state.activeMask?.metadata.id;
+          if (!maskId) {
+            return {
+              success: false,
+              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)
+            };
+          } catch (e) {
+            return {
+              success: false,
+              error: `Failed to get mask prompt: ${e}`
+            };
+          }
+        }
+      },
+      {
+        name: "maskweaver_status",
+        description: "Get the current Maskweaver status including active mask and available masks count.",
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        },
         execute: async () => {
-          return { success: true, message: "Maskweaver is working!" };
+          let masksCount = 0;
+          let categoriesCount = 0;
+          if (state.maskLoader) {
+            try {
+              const masks = await state.maskLoader.listAll();
+              const categories = await state.maskLoader.listCategories();
+              masksCount = masks.length;
+              categoriesCount = categories.length;
+            } 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
+            }
+          };
         }
       }
     ]

package/package.json

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