@nahisaho/shikigami 2.0.3 → 2.0.5

package/scripts/build-cowork-plugin.js

@@ -0,0 +1,587 @@
+#!/usr/bin/env node
+/**
+ * SHIKIGAMI Cowork Plugin Builder
+ * 
+ * Builds a Microsoft 365 Copilot Cowork plugin package (.zip)
+ * from SHIKIGAMI's Agent Skills.
+ * 
+ * Usage: npx shikigami cowork [options]
+ *   --out <dir>     Output directory (default: ./dist)
+ *   --check         Dry-run validation only
+ *   --help          Show help
+ * 
+ * Reference: https://learn.microsoft.com/microsoft-365/copilot/cowork/cowork-plugin-development
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// ── Constants ──────────────────────────────────────────────────────────────
+
+const MAX_COMPANIONS_PER_SKILL = 20;
+const MAX_COMPANION_SIZE = 5 * 1024 * 1024; // 5 MB
+const MAX_COMPANION_TOTAL = 10 * 1024 * 1024; // 10 MB per skill
+const MAX_SKILLS = 20;
+
+const PACKAGE_NAME = 'com.nahisaho.shikigami';
+const APP_ID = 'a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d'; // Stable GUID
+const ACCENT_COLOR = '#6B46C1';
+
+// ── Minimal PNG generators (no dependencies) ──────────────────────────────
+
+function createMinimalPNG(width, height, r, g, b) {
+  // Creates a minimal valid PNG with a solid color
+  // PNG signature
+  const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+
+  function crc32(buf) {
+    let crc = 0xFFFFFFFF;
+    const table = new Int32Array(256);
+    for (let i = 0; i < 256; i++) {
+      let c = i;
+      for (let j = 0; j < 8; j++) c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
+      table[i] = c;
+    }
+    for (let i = 0; i < buf.length; i++) {
+      crc = table[(crc ^ buf[i]) & 0xFF] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xFFFFFFFF) >>> 0;
+  }
+
+  function makeChunk(type, data) {
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(data.length);
+    const typeAndData = Buffer.concat([Buffer.from(type), data]);
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(typeAndData));
+    return Buffer.concat([len, typeAndData, crc]);
+  }
+
+  // IHDR
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8; // bit depth
+  ihdr[9] = 2; // color type RGB
+  ihdr[10] = 0; // compression
+  ihdr[11] = 0; // filter
+  ihdr[12] = 0; // interlace
+
+  // IDAT - raw image data
+  const rowSize = 1 + width * 3; // filter byte + RGB per pixel
+  const rawData = Buffer.alloc(rowSize * height);
+  for (let y = 0; y < height; y++) {
+    rawData[y * rowSize] = 0; // no filter
+    for (let x = 0; x < width; x++) {
+      const offset = y * rowSize + 1 + x * 3;
+      rawData[offset] = r;
+      rawData[offset + 1] = g;
+      rawData[offset + 2] = b;
+    }
+  }
+
+  const zlib = require('zlib');
+  const compressed = zlib.deflateSync(rawData);
+
+  // IEND
+  const iend = Buffer.alloc(0);
+
+  return Buffer.concat([
+    signature,
+    makeChunk('IHDR', ihdr),
+    makeChunk('IDAT', compressed),
+    makeChunk('IEND', iend),
+  ]);
+}
+
+// ── SKILL.md Parser ────────────────────────────────────────────────────────
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+
+  const yaml = match[1];
+  const result = {};
+
+  // Simple YAML parser for frontmatter fields
+  let currentKey = null;
+  let blockValue = [];
+  let inBlock = false;
+
+  for (const line of yaml.split('\n')) {
+    if (inBlock) {
+      if (line.match(/^\s{2,}/) || line.trim() === '') {
+        blockValue.push(line.replace(/^\s{2}/, ''));
+        continue;
+      } else {
+        result[currentKey] = blockValue.join('\n').trim();
+        inBlock = false;
+      }
+    }
+
+    const kvMatch = line.match(/^(\w[\w.-]*)\s*:\s*(.*)/);
+    if (kvMatch) {
+      currentKey = kvMatch[1];
+      const value = kvMatch[2].trim();
+      if (value === '|' || value === '>') {
+        inBlock = true;
+        blockValue = [];
+      } else {
+        result[currentKey] = value.replace(/^["']|["']$/g, '');
+      }
+    }
+  }
+
+  if (inBlock && currentKey) {
+    result[currentKey] = blockValue.join('\n').trim();
+  }
+
+  return result;
+}
+
+// ── Companion File Consolidation ───────────────────────────────────────────
+
+function consolidateCompanions(skillDir, skillName) {
+  /**
+   * If a skill has more than MAX_COMPANIONS_PER_SKILL companion files,
+   * consolidate them into category-level reference files.
+   * Returns an array of { relativePath, content } for the consolidated files.
+   */
+  const files = [];
+  const allFiles = [];
+
+  function walkDir(dir, prefix) {
+    if (!fs.existsSync(dir)) return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walkDir(fullPath, relPath);
+      } else if (entry.name !== 'SKILL.md') {
+        allFiles.push({ fullPath, relPath, name: entry.name });
+      }
+    }
+  }
+
+  walkDir(skillDir, '');
+
+  if (allFiles.length <= MAX_COMPANIONS_PER_SKILL) {
+    // No consolidation needed - return original files
+    return allFiles.map(f => ({
+      relativePath: f.relPath,
+      content: fs.readFileSync(f.fullPath),
+    }));
+  }
+
+  // Group by top-level directory
+  const groups = {};
+  for (const f of allFiles) {
+    const parts = f.relPath.split('/');
+    const topDir = parts.length > 1 ? parts[0] : '_root';
+    const subDir = parts.length > 2 ? parts.slice(0, 2).join('/') : topDir;
+    if (!groups[subDir]) groups[subDir] = [];
+    groups[subDir].push(f);
+  }
+
+  // If groups are still too many, merge into top-level categories
+  if (Object.keys(groups).length > MAX_COMPANIONS_PER_SKILL) {
+    const topGroups = {};
+    for (const f of allFiles) {
+      const topDir = f.relPath.split('/')[0] || '_root';
+      if (!topGroups[topDir]) topGroups[topDir] = [];
+      topGroups[topDir].push(f);
+    }
+
+    for (const [dir, dirFiles] of Object.entries(topGroups)) {
+      if (dir === '_root') {
+        for (const f of dirFiles) {
+          files.push({
+            relativePath: f.relPath,
+            content: fs.readFileSync(f.fullPath),
+          });
+        }
+        continue;
+      }
+
+      // Consolidate all files under this dir into one reference file
+      let consolidated = `# ${dir}\n\nConsolidated reference for ${skillName}.\n\n`;
+      for (const f of dirFiles) {
+        const content = fs.readFileSync(f.fullPath, 'utf-8');
+        const basename = path.basename(f.name, path.extname(f.name));
+        consolidated += `---\n\n## ${basename}\n\n${content}\n\n`;
+      }
+
+      files.push({
+        relativePath: `references/${dir}.md`,
+        content: Buffer.from(consolidated, 'utf-8'),
+      });
+    }
+  } else {
+    // Consolidate sub-directories into category files
+    for (const [subDir, subFiles] of Object.entries(groups)) {
+      if (subDir === '_root' || subFiles.length <= 1) {
+        for (const f of subFiles) {
+          files.push({
+            relativePath: f.relPath,
+            content: fs.readFileSync(f.fullPath),
+          });
+        }
+        continue;
+      }
+
+      let consolidated = `# ${subDir}\n\n`;
+      for (const f of subFiles) {
+        const content = fs.readFileSync(f.fullPath, 'utf-8');
+        const basename = path.basename(f.name, path.extname(f.name));
+        consolidated += `---\n\n## ${basename}\n\n${content}\n\n`;
+      }
+
+      files.push({
+        relativePath: `references/${subDir.replace(/\//g, '-')}.md`,
+        content: Buffer.from(consolidated, 'utf-8'),
+      });
+    }
+  }
+
+  return files;
+}
+
+// ── ZIP Builder (uses system zip or tar) ───────────────────────────────────
+
+function createZip(outputPath, files) {
+  /**
+   * Creates a zip file from an array of { path, content } entries.
+   * Uses a temp directory and system zip command.
+   */
+  const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'shikigami-cowork-'));
+
+  try {
+    // Write all files to temp directory
+    for (const file of files) {
+      const filePath = path.join(tmpDir, file.path);
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      if (Buffer.isBuffer(file.content)) {
+        fs.writeFileSync(filePath, file.content);
+      } else {
+        fs.writeFileSync(filePath, file.content, 'utf-8');
+      }
+    }
+
+    // Create zip
+    const absOutput = path.resolve(outputPath);
+    try {
+      execSync(`cd "${tmpDir}" && zip -r "${absOutput}" .`, { stdio: 'pipe' });
+    } catch {
+      // Fallback: try PowerShell (Windows)
+      try {
+        execSync(
+          `powershell -Command "Compress-Archive -Path '${tmpDir}${path.sep}*' -DestinationPath '${absOutput}' -Force"`,
+          { stdio: 'pipe' }
+        );
+      } catch {
+        console.error('❌ zip command not found. Install zip or use PowerShell.');
+        process.exit(1);
+      }
+    }
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// ── Manifest Generator ─────────────────────────────────────────────────────
+
+function generateManifest(skills, version) {
+  return {
+    '$schema': 'https://developer.microsoft.com/json-schemas/teams/vDevPreview/MicrosoftTeams.schema.json',
+    manifestVersion: 'devPreview',
+    version: version,
+    id: APP_ID,
+    packageName: PACKAGE_NAME,
+    developer: {
+      name: 'nahisaho',
+      websiteUrl: 'https://github.com/nahisaho/SHIKIGAMI',
+      privacyUrl: 'https://github.com/nahisaho/SHIKIGAMI/blob/main/LICENSE',
+      termsOfUseUrl: 'https://github.com/nahisaho/SHIKIGAMI/blob/main/LICENSE',
+    },
+    name: {
+      short: 'SHIKIGAMI',
+      full: 'SHIKIGAMI - Deep Research & Consulting Agent Skills for Copilot Cowork',
+    },
+    description: {
+      short: 'AI-powered deep research and consulting framework analysis',
+      full: 'SHIKIGAMI provides 4 specialized Agent Skills for Copilot Cowork: '
+        + 'deep research with hallucination prevention, 50+ consulting frameworks '
+        + '(SWOT, PEST, 5Forces, BCG Matrix, etc.), structured report writing, '
+        + 'and project planning with 5 Whys/JTBD purpose discovery.',
+    },
+    icons: {
+      color: 'color.png',
+      outline: 'outline.png',
+    },
+    accentColor: ACCENT_COLOR,
+    agentSkills: skills.map(s => ({ folder: `./skills/${s.name}` })),
+  };
+}
+
+// ── Validation ─────────────────────────────────────────────────────────────
+
+function validateSkill(skillDir, skillName) {
+  const errors = [];
+  const warnings = [];
+
+  const skillMdPath = path.join(skillDir, 'SKILL.md');
+  if (!fs.existsSync(skillMdPath)) {
+    errors.push(`SKILL.md not found in ${skillName}`);
+    return { errors, warnings };
+  }
+
+  const content = fs.readFileSync(skillMdPath, 'utf-8');
+  const frontmatter = parseFrontmatter(content);
+
+  if (!frontmatter) {
+    errors.push(`${skillName}: No YAML frontmatter found`);
+    return { errors, warnings };
+  }
+
+  // Validate name
+  if (!frontmatter.name) {
+    errors.push(`${skillName}: Missing 'name' field in frontmatter`);
+  } else {
+    if (frontmatter.name !== skillName) {
+      errors.push(`${skillName}: Frontmatter name '${frontmatter.name}' doesn't match folder '${skillName}'`);
+    }
+    if (frontmatter.name.length > 64) {
+      errors.push(`${skillName}: Name exceeds 64 characters`);
+    }
+    if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(frontmatter.name)) {
+      errors.push(`${skillName}: Name must be kebab-case`);
+    }
+  }
+
+  // Validate description
+  if (!frontmatter.description) {
+    errors.push(`${skillName}: Missing 'description' field in frontmatter`);
+  } else if (frontmatter.description.length > 1024) {
+    warnings.push(`${skillName}: Description exceeds 1024 characters (${frontmatter.description.length})`);
+  }
+
+  // Count companion files
+  const companions = consolidateCompanions(skillDir, skillName);
+  if (companions.length > MAX_COMPANIONS_PER_SKILL) {
+    errors.push(`${skillName}: ${companions.length} companion files after consolidation (max ${MAX_COMPANIONS_PER_SKILL})`);
+  }
+
+  const totalSize = companions.reduce((sum, f) => sum + f.content.length, 0);
+  if (totalSize > MAX_COMPANION_TOTAL) {
+    errors.push(`${skillName}: Total companion size ${(totalSize / 1024 / 1024).toFixed(1)}MB exceeds 10MB limit`);
+  }
+
+  const oversized = companions.filter(f => f.content.length > MAX_COMPANION_SIZE);
+  for (const f of oversized) {
+    errors.push(`${skillName}: ${f.relativePath} exceeds 5MB limit`);
+  }
+
+  return { errors, warnings, companions, frontmatter };
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  return {
+    out: args.includes('--out') ? args[args.indexOf('--out') + 1] : './dist',
+    check: args.includes('--check') || args.includes('--dry-run'),
+    help: args.includes('--help') || args.includes('-h'),
+  };
+}
+
+function showHelp() {
+  console.log(`
+🎭 SHIKIGAMI Cowork Plugin Builder
+
+Builds a Microsoft 365 Copilot Cowork plugin package (.zip)
+
+Usage: npx shikigami cowork [options]
+
+Options:
+  --out <dir>     Output directory (default: ./dist)
+  --check         Validation only (dry-run)
+  -h, --help      Show this help
+
+Output:
+  Creates shikigami-cowork-plugin.zip ready for M365 Admin Center upload.
+
+Reference:
+  https://learn.microsoft.com/microsoft-365/copilot/cowork/cowork-plugin-development
+`);
+}
+
+function build() {
+  const { out, check, help } = parseArgs();
+
+  if (help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  console.log('');
+  console.log('🎭 SHIKIGAMI Cowork Plugin Builder');
+  console.log('====================================');
+  console.log('');
+
+  // Locate skills directory
+  const packageDir = path.resolve(__dirname, '..');
+  let skillsRoot = path.join(packageDir, 'github-assets', 'skills');
+
+  // If running from installed package, check node_modules path
+  if (!fs.existsSync(skillsRoot)) {
+    skillsRoot = path.join(packageDir, '.github', 'skills');
+  }
+  // Also check project's .github/skills (after init)
+  if (!fs.existsSync(skillsRoot)) {
+    skillsRoot = path.join(process.cwd(), '.github', 'skills');
+  }
+
+  if (!fs.existsSync(skillsRoot)) {
+    console.error('❌ Skills directory not found.');
+    console.error('   Run `npx shikigami init` first to copy skills to your project.');
+    process.exit(1);
+  }
+
+  // Read package version
+  let version = '1.0.0';
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf-8'));
+    version = pkg.version || version;
+  } catch { /* ignore */ }
+
+  // Discover skills
+  const skillDirs = fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter(d => d.isDirectory() && d.name.startsWith('shikigami-'))
+    .map(d => d.name);
+
+  if (skillDirs.length === 0) {
+    console.error('❌ No skills found (expected shikigami-* directories)');
+    process.exit(1);
+  }
+
+  console.log(`📂 Skills root: ${skillsRoot}`);
+  console.log(`📦 Found ${skillDirs.length} skills`);
+  console.log('');
+
+  // Validate all skills
+  let hasErrors = false;
+  const validatedSkills = [];
+
+  for (const skillName of skillDirs) {
+    const skillDir = path.join(skillsRoot, skillName);
+    const result = validateSkill(skillDir, skillName);
+
+    if (result.errors.length > 0) {
+      hasErrors = true;
+      for (const err of result.errors) console.log(`  ❌ ${err}`);
+    }
+    for (const warn of result.warnings) console.log(`  ⚠️  ${warn}`);
+
+    if (result.errors.length === 0) {
+      const companionCount = result.companions ? result.companions.length : 0;
+      console.log(`  ✅ ${skillName} (${companionCount} companion files)`);
+      validatedSkills.push({
+        name: skillName,
+        dir: skillDir,
+        companions: result.companions,
+        frontmatter: result.frontmatter,
+      });
+    }
+  }
+
+  console.log('');
+
+  if (hasErrors) {
+    console.error('❌ Validation failed. Fix errors above before building.');
+    process.exit(1);
+  }
+
+  if (validatedSkills.length > MAX_SKILLS) {
+    console.error(`❌ Too many skills: ${validatedSkills.length} (max ${MAX_SKILLS})`);
+    process.exit(1);
+  }
+
+  if (check) {
+    console.log('✅ Validation passed (dry-run mode)');
+    console.log(`   ${validatedSkills.length} skills ready for packaging`);
+    process.exit(0);
+  }
+
+  // Build package
+  console.log('📦 Building Cowork plugin package...');
+
+  const zipFiles = [];
+
+  // 1. Generate manifest.json
+  const manifest = generateManifest(validatedSkills, version);
+  zipFiles.push({
+    path: 'manifest.json',
+    content: JSON.stringify(manifest, null, 2),
+  });
+  console.log('  ✅ manifest.json');
+
+  // 2. Generate icons
+  const colorPng = createMinimalPNG(192, 192, 107, 70, 193); // Purple (#6B46C1)
+  const outlinePng = createMinimalPNG(32, 32, 107, 70, 193);
+  zipFiles.push({ path: 'color.png', content: colorPng });
+  zipFiles.push({ path: 'outline.png', content: outlinePng });
+  console.log('  ✅ color.png (192×192)');
+  console.log('  ✅ outline.png (32×32)');
+
+  // 3. Copy skills with consolidation
+  for (const skill of validatedSkills) {
+    // Copy SKILL.md
+    const skillMd = fs.readFileSync(path.join(skill.dir, 'SKILL.md'));
+    zipFiles.push({
+      path: `skills/${skill.name}/SKILL.md`,
+      content: skillMd,
+    });
+
+    // Copy companion files (already consolidated)
+    for (const companion of skill.companions) {
+      zipFiles.push({
+        path: `skills/${skill.name}/${companion.relativePath}`,
+        content: companion.content,
+      });
+    }
+
+    console.log(`  ✅ skills/${skill.name}/ (${skill.companions.length + 1} files)`);
+  }
+
+  // 4. Create ZIP
+  const outDir = path.resolve(out);
+  fs.mkdirSync(outDir, { recursive: true });
+  const zipPath = path.join(outDir, 'shikigami-cowork-plugin.zip');
+
+  // Remove old zip if exists
+  if (fs.existsSync(zipPath)) {
+    fs.unlinkSync(zipPath);
+  }
+
+  createZip(zipPath, zipFiles);
+
+  const zipSize = fs.statSync(zipPath).size;
+  console.log('');
+  console.log(`✅ Plugin package created: ${zipPath}`);
+  console.log(`   Size: ${(zipSize / 1024).toFixed(1)} KB`);
+  console.log(`   Skills: ${validatedSkills.length}`);
+  console.log(`   Version: ${version}`);
+  console.log('');
+  console.log('📝 Next steps:');
+  console.log('   1. Open M365 Admin Center > Manage Apps > Upload Custom App');
+  console.log('   2. Upload shikigami-cowork-plugin.zip');
+  console.log('   3. Open Cowork > Sources & Skills to verify');
+  console.log('');
+  console.log('📖 https://learn.microsoft.com/microsoft-365/copilot/cowork/cowork-plugin-development');
+  console.log('');
+}
+
+build();

package/scripts/cli.js

@@ -32,7 +32,7 @@ Usage: npx shikigami [command] [options]
 Commands:
   init                    Initialize SHIKIGAMI files in current directory
   upgrade, update         Upgrade SHIKIGAMI files (same as init --force) (v1.23.0)
-  cowork [options]        Set up Microsoft Copilot Cowork MCP (v2.0.0)
+  cowork [options]        Build Copilot Cowork plugin package (v2.0.4)
   new [name]              Create a new research project
   find-related [keyword]  Find related projects by keywords (v1.7.0)
   inherit [options]       Prepare knowledge inheritance from past reports (v1.8.0)
@@ -42,8 +42,9 @@ Commands:
 Examples:
   npx shikigami init                           # Initialize SHIKIGAMI
   npx shikigami upgrade                        # Upgrade to latest version
-  npx shikigami cowork                         # Set up Copilot Cowork MCP (v2.0.0)
-  npx shikigami cowork --status                # Check Cowork installation status
+  npx shikigami cowork                         # Build Cowork plugin .zip
+  npx shikigami cowork --check                  # Validate skills (dry-run)
+  npx shikigami cowork --out ./dist             # Specify output directory
   npx shikigami new my-research                # Create new project "my-research"
   npx shikigami new                            # Create new project with auto-numbered name
   npx shikigami find-related レアアース         # Find projects related to "レアアース"
@@ -71,10 +72,9 @@ if (command === 'upgrade' || command === 'update') {
   process.exit(0);
 }
 
-// Cowork command (v2.0.0)
+// Cowork command (v2.0.4)
 if (command === 'cowork') {
-  const { setup } = require('./setup-cowork.js');
-  setup();
+  require('./build-cowork-plugin.js');
   process.exit(0);
 }
 

package/scripts/init.js

@@ -14,7 +14,7 @@ const packageDir = path.resolve(__dirname, '..');
 const projectRoot = process.cwd();
 
 const itemsToCopy = [
-  { src: '.github', dest: '.github', type: 'dir' },
+  { src: 'github-assets', dest: '.github', type: 'dir' },
   { src: '.vscode', dest: '.vscode', type: 'dir' },
   { src: 'mcp-server', dest: 'mcp-server', type: 'dir' },
   { src: 'AGENTS.md', dest: 'AGENTS.md', type: 'file' },
@@ -167,21 +167,10 @@ function init() {
   console.log(`📊 Summary: ${copiedCount} copied, ${overwrittenCount} overwritten, ${skippedCount} skipped`);
   console.log('');
 
-  // Check Cowork MCP status
-  try {
-    const { isInstalled, isMcpConfigured } = require('./setup-cowork.js');
-    if (!isInstalled() || !isMcpConfigured()) {
-      console.log('🤝 Copilot Cowork MCP (M365連携):');
-      console.log('   メール・カレンダー・Teams・OneDrive にCopilot CLIからアクセス可能に');
-      console.log('   セットアップ: npx shikigami cowork');
-      console.log('');
-    } else {
-      console.log('🤝 Copilot Cowork MCP: ✅ Configured');
-      console.log('');
-    }
-  } catch {
-    // Ignore errors from cowork check
-  }
+  // Cowork plugin hint
+  console.log('🤝 Copilot Cowork:');
+  console.log('   npx shikigami cowork でCoworkプラグインパッケージを生成');
+  console.log('');
 
   console.log('📝 Next steps:');
   console.log('   1. cd mcp-server && npm install && npm run build');

package/scripts/postinstall.js

@@ -22,7 +22,7 @@ const packageDir = path.resolve(__dirname, '..');
 const projectRoot = path.resolve(packageDir, '..', '..', '..');
 
 const itemsToCopy = [
-  { src: '.github', dest: '.github', type: 'dir' },
+  { src: 'github-assets', dest: '.github', type: 'dir' },
   { src: '.vscode', dest: '.vscode', type: 'dir' },
   { src: 'mcp-server', dest: 'mcp-server', type: 'dir' },
   { src: 'AGENTS.md', dest: 'AGENTS.md', type: 'file' },