@maskweaver/plugin 0.1.0

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@maskweaver/plugin",
+  "version": "0.1.0",
+  "description": "Maskweaver plugin for opencode - Expert AI personas",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir dist --target node --external @opencode-ai/plugin",
+    "dev": "bun run --watch ./src/index.ts",
+    "test": "bun test"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "ai",
+    "persona",
+    "mask",
+    "expert",
+    "maskweaver"
+  ],
+  "author": "ULJI SOFT <ulgerang@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ulgerang/maskweaver.git",
+    "directory": "packages/plugin"
+  },
+  "homepage": "https://github.com/ulgerang/maskweaver#readme",
+  "bugs": {
+    "url": "https://github.com/ulgerang/maskweaver/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@maskweaver/core": "^0.1.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@opencode-ai/plugin": {
+      "optional": true
+    }
+  }
+}

package/src/hooks/sessionCreated.ts

@@ -0,0 +1,40 @@
+/**
+ * Session Created Hook
+ * 
+ * Handles initialization when a new session is created.
+ */
+
+import type { MaskweaverState } from '../index';
+
+export async function handleSessionCreated(
+  session: any,
+  state: MaskweaverState,
+  client: any
+): Promise<void> {
+  try {
+    const categories = await state.maskLoader.listCategories();
+    const masks = await state.maskLoader.listAll();
+    
+    // Log available masks
+    await client.app.log({
+      service: 'maskweaver',
+      level: 'info',
+      message: 'Session created - masks available',
+      extra: {
+        categories: categories.length,
+        masks: masks.length,
+      },
+    });
+    
+    // If there's a default mask configured, apply it
+    // For now, just notify that masks are available
+    
+  } catch (error) {
+    await client.app.log({
+      service: 'maskweaver',
+      level: 'error',
+      message: 'Failed to initialize masks for session',
+      extra: { error: String(error) },
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,94 @@
+/**
+ * Maskweaver Plugin for opencode
+ * 
+ * Applies expert personas (masks) to AI assistants.
+ * 가면술사 - opencode 플러그인
+ */
+
+import type { Plugin } from '@opencode-ai/plugin';
+import { MaskLoader } from '@maskweaver/core';
+import { handleSessionCreated } from './hooks/sessionCreated';
+import { createSelectMaskTool } from './tools/selectMask';
+import { createListMasksTool } from './tools/listMasks';
+
+export interface MaskweaverState {
+  maskLoader: MaskLoader;
+  activeMask: any | null;
+}
+
+/**
+ * Maskweaver Plugin
+ * 
+ * Give your AI coding assistant expert personalities.
+ */
+export const MaskweaverPlugin: Plugin = async (ctx) => {
+  const { directory, client } = ctx;
+  
+  // Initialize mask loader
+  const masksDir = `${directory}/.opencode/masks`;
+  const maskLoader = new MaskLoader({ masksDir });
+  
+  try {
+    await maskLoader.loadCatalog();
+    await client.app.log({
+      service: 'maskweaver',
+      level: 'info',
+      message: 'Maskweaver initialized',
+      extra: { masksDir },
+    });
+  } catch (error) {
+    // Fallback to default masks directory
+    await client.app.log({
+      service: 'maskweaver',
+      level: 'warn',
+      message: 'Custom masks not found, using defaults',
+    });
+  }
+  
+  // Store in context for tools
+  const state: MaskweaverState = {
+    maskLoader,
+    activeMask: null,
+  };
+  
+  return {
+    /**
+     * Session Created Hook
+     * 
+     * Called when a new session is created.
+     * Can inject initial system prompt or provide mask selection.
+     */
+    'session.created': async (session) => {
+      await handleSessionCreated(session, state, client);
+    },
+    
+    /**
+     * Tool Execute Hooks
+     * 
+     * Track tool usage with masks for analytics.
+     */
+    'tool.execute.after': async (input, output) => {
+      if (state.activeMask) {
+        await client.app.log({
+          service: 'maskweaver',
+          level: 'debug',
+          message: `Tool executed with mask`,
+          extra: {
+            tool: input.tool,
+            mask: state.activeMask.metadata.id,
+          },
+        });
+      }
+    },
+    
+    /**
+     * Custom Tools
+     */
+    tool: {
+      select_mask: createSelectMaskTool(state),
+      list_masks: createListMasksTool(state),
+    },
+  };
+};
+
+export default MaskweaverPlugin;

package/src/tools/listMasks.ts

@@ -0,0 +1,87 @@
+/**
+ * List Masks Tool
+ * 
+ * Lists all available expert persona masks.
+ */
+
+import { tool } from '@opencode-ai/plugin';
+import type { MaskweaverState } from '../index';
+
+export function createListMasksTool(state: MaskweaverState) {
+  return tool({
+    description: `List all available expert persona masks.
+Returns masks grouped by category with their expertise areas.
+
+Use this to discover which expert personas are available before applying one with select_mask.`,
+    
+    args: {
+      category: tool.schema.string().optional().describe(
+        'Filter by category (e.g., "software-engineering", "ai-ml")'
+      ),
+      tag: tool.schema.string().optional().describe(
+        'Filter by tag (e.g., "tdd", "architecture", "systems")'
+      ),
+    },
+    
+    async execute(args, context) {
+      const { category, tag } = args;
+      const { maskLoader } = state;
+      
+      try {
+        const allMasks = await maskLoader.listAll();
+        const categories = await maskLoader.listCategories();
+        
+        // Filter by category if specified
+        let filtered = allMasks;
+        if (category) {
+          filtered = allMasks.filter(m => m.category === category);
+        }
+        
+        // Filter by tag if specified
+        if (tag) {
+          filtered = filtered.filter(m => m.tags.includes(tag));
+        }
+        
+        // Group by category
+        const grouped: Record<string, Array<{
+          id: string;
+          name: string;
+          tags: string[];
+        }>> = {};
+        
+        for (const mask of filtered) {
+          if (!grouped[mask.category]) {
+            grouped[mask.category] = [];
+          }
+          grouped[mask.category].push({
+            id: mask.id,
+            name: mask.name,
+            tags: mask.tags,
+          });
+        }
+        
+        // Format summary
+        const summary = categories.map(cat => 
+          `${cat.name} (${cat.count} masks): ${cat.description}`
+        ).join('\n');
+        
+        return {
+          success: true,
+          summary: `Found ${filtered.length} masks across ${Object.keys(grouped).length} categories`,
+          categories: summary,
+          masks: grouped,
+          activeMask: state.activeMask ? {
+            id: state.activeMask.metadata.id,
+            name: state.activeMask.profile.name,
+          } : null,
+          hint: 'Use select_mask with a mask ID to apply a persona (e.g., select_mask("linus-torvalds"))',
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: `Failed to list masks: ${error}`,
+        };
+      }
+    },
+  });
+}

package/src/tools/selectMask.ts

@@ -0,0 +1,80 @@
+/**
+ * Select Mask Tool
+ * 
+ * Allows users to apply an expert persona (mask) to the AI.
+ */
+
+import { tool } from '@opencode-ai/plugin';
+import { promptBuilder } from '@maskweaver/core';
+import type { MaskweaverState } from '../index';
+
+export function createSelectMaskTool(state: MaskweaverState) {
+  return tool({
+    description: `Apply an expert persona (mask) to the AI assistant. 
+This transforms how the AI thinks, communicates, and approaches problems.
+
+Example personas: linus-torvalds (systems programming), martin-fowler (architecture), kent-beck (TDD)
+
+Use list_masks first to see all available masks.`,
+    
+    args: {
+      maskId: tool.schema.string().describe(
+        'ID of the mask to apply (e.g., "linus-torvalds")'
+      ),
+      mode: tool.schema.enum(['minimal', 'standard', 'rich']).optional().describe(
+        'Prompt richness: minimal (core only), standard (default), rich (full context)'
+      ),
+    },
+    
+    async execute(args, context) {
+      const { maskId, mode = 'standard' } = args;
+      const { maskLoader } = state;
+      
+      try {
+        const mask = await maskLoader.load(maskId);
+        
+        if (!mask) {
+          return {
+            success: false,
+            message: `Mask '${maskId}' not found. Use list_masks to see available options.`,
+          };
+        }
+        
+        // Build system prompt based on mode
+        let systemPrompt: string;
+        switch (mode) {
+          case 'minimal':
+            systemPrompt = promptBuilder.minimal(mask);
+            break;
+          case 'rich':
+            systemPrompt = promptBuilder.rich(mask);
+            break;
+          default:
+            systemPrompt = promptBuilder.build(mask);
+        }
+        
+        // Store active mask
+        state.activeMask = mask;
+        
+        return {
+          success: true,
+          message: `🎭 Mask '${mask.profile.name}' applied.\n\n> ${mask.profile.tagline}`,
+          mask: {
+            id: mask.metadata.id,
+            name: mask.profile.name,
+            category: mask.category,
+            expertise: mask.profile.expertise,
+            tone: mask.behavior.communicationStyle.tone,
+          },
+          systemPrompt,
+          instruction: 'The system prompt above has been applied. The AI will now respond as this persona.',
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: `Failed to load mask: ${error}`,
+        };
+      }
+    },
+  });
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}