@maskweaver/plugin 0.1.11 → 0.3.0

package/dist/index.js

@@ -1,21 +1,440 @@
 // src/index.ts
-var MaskweaverPlugin = async (ctx) => {
-  ctx.client.app.log({
+import { tool } from "@opencode-ai/plugin";
+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 value = trimmed.slice(colonIdx + 1).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?.length) {
+    parts.push("");
+    parts.push("ACKNOWLEDGE YOUR LIMITATIONS:");
+    for (const limitation of mask.profile.limitations)
+      parts.push(`- ${limitation}`);
+  }
+  if (mask.behavior.signaturePhrases?.length) {
+    parts.push("");
+    parts.push("PHRASES YOU MIGHT USE:");
+    for (const phrase of mask.behavior.signaturePhrases)
+      parts.push(`- "${phrase}"`);
+  }
+  return parts.join(`
+`);
+}
+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.1.11"
+    message: "Maskweaver plugin loaded v0.3.0"
   });
+  if (fs.existsSync(masksDir)) {
+    state.maskLoader = new MaskLoader(masksDir);
+    try {
+      await state.maskLoader.loadCatalog();
+      client.app.log({
+        service: "maskweaver",
+        level: "info",
+        message: `Masks found at: ${masksDir}`
+      });
+    } catch (e) {
+      client.app.log({
+        service: "maskweaver",
+        level: "warn",
+        message: `Failed to load masks: ${e}`
+      });
+      state.maskLoader = null;
+    }
+  }
   return {
-    tools: [
-      {
-        name: "maskweaver_test",
-        description: "Test tool for Maskweaver plugin",
-        parameters: {},
-        execute: async () => {
-          return { success: true, message: "Maskweaver is working!" };
-        }
+    "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: tool({
+        description: "List all available expert persona masks. Shows mask IDs, names, categories, and tags.",
+        args: {
+          category: tool.schema.string().optional().describe("Filter by category (software-engineering, ai-ml, architecture)")
+        },
+        async execute(args, _context) {
+          if (!state?.maskLoader) {
+            return "Error: No masks directory found. Create .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);
+            }
+            const lines = [];
+            lines.push(`Maskweaver v0.3.0 - ${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}]`);
+              lines.push(`    Tags: ${mask.tags.join(", ")}`);
+            }
+            return lines.join(`
+`);
+          } catch (e) {
+            return `Error: ${e}`;
+          }
+        }
+      }),
+      select_mask: tool({
+        description: "Select and apply an expert persona mask. The AI will embody this expert personality.",
+        args: {
+          maskId: tool.schema.string().describe('Mask ID (e.g., "kent-beck", "linus-torvalds", "martin-fowler")')
+        },
+        async execute(args, _context) {
+          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 `Error: Mask "${args.maskId}" not found.
+Available: ${available.map((m) => m.id).join(", ")}`;
+            }
+            state.activeMask = mask;
+            return `✓ Mask activated: ${mask.profile.name}
+
+"${mask.profile.tagline}"
+
+Expertise: ${mask.profile.expertise.join(", ")}
+
+The mask prompt will be injected into all future messages in this session.`;
+          } catch (e) {
+            return `Error: ${e}`;
+          }
+        }
+      }),
+      deselect_mask: tool({
+        description: "Remove the current mask and return to default AI behavior.",
+        args: {},
+        async execute(_args, _context) {
+          const prev = state?.activeMask;
+          if (state)
+            state.activeMask = null;
+          if (prev) {
+            return `✓ Mask removed: ${prev.profile.name}
+Returned to default behavior.`;
+          }
+          return "No mask was active.";
+        }
+      }),
+      get_mask_prompt: tool({
+        description: "View the full system prompt for a mask.",
+        args: {
+          maskId: tool.schema.string().optional().describe("Mask ID. Uses active mask if not specified.")
+        },
+        async execute(args, _context) {
+          if (!state?.maskLoader)
+            return "Error: No masks directory.";
+          const maskId = args.maskId || state.activeMask?.metadata.id;
+          if (!maskId)
+            return "Error: No mask specified and no active mask.";
+          try {
+            const mask = await state.maskLoader.load(maskId);
+            if (!mask)
+              return `Error: Mask "${maskId}" not found.`;
+            return `# ${mask.profile.name}
+
+${buildRichPrompt(mask)}`;
+          } catch (e) {
+            return `Error: ${e}`;
+          }
+        }
+      }),
+      maskweaver_status: tool({
+        description: "Check Maskweaver status and active mask.",
+        args: {},
+        async execute(_args, _context) {
+          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) {}
+          }
+          const lines = [
+            "Maskweaver v0.3.0",
+            `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"}`
+          ];
+          return lines.join(`
+`);
+        }
+      })
+    }
   };
 };
 var src_default = MaskweaverPlugin;

package/package.json

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