musubi-sdd 0.5.0 → 0.6.0

package/README.md

@@ -22,7 +22,8 @@ MUSUBI is a comprehensive SDD (Specification Driven Development) framework that
 - 🧭 **Auto-Updating Project Memory** - Steering system maintains architecture, tech stack, and product context
 - 🚀 **Automatic Onboarding** - `musubi-onboard` analyzes existing projects and generates steering docs (2-5 minutes)
 - 🔄 **Auto-Sync** - `musubi-sync` detects codebase changes and keeps steering docs current
-- 🔍 **Intelligent Code Analysis** - `musubi-analyze` provides quality metrics, complexity analysis, and technical debt detection (v0.5.0)
+- 🔍 **Intelligent Code Analysis** - `musubi-analyze` provides quality metrics, complexity analysis, and technical debt detection
+- 🤝 **Team Collaboration** - `musubi-share` enables memory sharing, import/export, and multi-platform sync (v0.6.0)
 - ✅ **Complete Traceability** - Requirements → Design → Code → Tests mapping
 - 🌐 **Bilingual Documentation** - All agent-generated documents created in both English and Japanese
 
@@ -94,6 +95,12 @@ musubi-analyze --type=quality       # Quality metrics only
 musubi-analyze --type=dependencies  # Dependencies only
 musubi-analyze --type=security      # Security audit
 musubi-analyze --output=report.md   # Save report
+
+# Share project memories with team (v0.6.0)
+musubi-share export                 # Export memories to JSON
+musubi-share import memories.json   # Import from teammate
+musubi-share sync                   # Sync across AI platforms
+musubi-share status                 # Show sharing status
 ```
 
 ### Project Types
@@ -285,6 +292,15 @@ musubi-analyze --type=dependencies  # Dependency analysis
 musubi-analyze --type=security # Security vulnerabilities
 musubi-analyze --output=report.md   # Save report to file
 musubi-analyze --json          # JSON output
+
+# Share project memories with team (v0.6.0+)
+musubi-share export            # Export memories to JSON/YAML
+musubi-share export --output=memories.yaml  # YAML format
+musubi-share import memories.json  # Import and merge
+musubi-share import memories.json --strategy=theirs  # Auto-accept
+musubi-share sync              # Sync across AI platforms
+musubi-share sync --platform=cursor  # Sync specific platform
+musubi-share status            # Show sharing status
 ```
 
 #### musubi-onboard
@@ -365,7 +381,49 @@ musubi-sync --dry-run
 musubi-sync --auto-approve
 ```
 
-#### musubi status
+#### musubi-share
+
+Share and merge project memories across team members and AI platforms (v0.6.0+):
+
+```
+📤 MUSUBI Memory Export
+
+Export Summary:
+  File: team-memories.json
+  Format: json
+  Size: 1098.28 KB
+  Memories: 7 files
+  Agents: 1 platforms
+```
+
+**Features**:
+- **Export**: Share memories as JSON/YAML
+- **Import**: Merge memories from teammates
+- **Sync**: Synchronize across AI platforms
+- **Conflict Resolution**: Interactive, auto-accept, keep-local, or merge with markers
+- **Status**: Show installed platforms and memory counts
+
+**Usage**:
+```bash
+# Export memories
+musubi-share export
+musubi-share export --output=memories.yaml
+
+# Import and merge
+musubi-share import colleague-memories.json
+musubi-share import memories.json --strategy=theirs  # Auto-accept
+musubi-share import memories.json --strategy=ours    # Keep local
+musubi-share import memories.json --strategy=merge   # With markers
+
+# Platform sync
+musubi-share sync
+musubi-share sync --platform=cursor
+
+# Status check
+musubi-share status
+```
+
+####  musubi status
 
 Shows the current state of your MUSUBI project:
 

package/bin/musubi-analyze.js

@@ -106,7 +106,7 @@ function calculateComplexity(code) {
     /\bwhile\b/g,
     /\bcase\b/g,
     /\bcatch\b/g,
-    /\&\&/g,
+    /&&/g,
     /\|\|/g,
     /\?/g  // Ternary operator
   ];
@@ -347,20 +347,20 @@ async function generateReport(analysisData) {
   const timestamp = new Date().toISOString().split('T')[0];
   const reportPath = options.output || `steering/memories/code_quality_report_${timestamp}.md`;
   
-  let report = `# Code Quality Analysis Report\n\n`;
+  let report = '# Code Quality Analysis Report\n\n';
   report += `**Generated**: ${new Date().toISOString()}\n`;
-  report += `**Version**: MUSUBI v0.5.0\n\n`;
+  report += '**Version**: MUSUBI v0.5.0\n\n';
   
   if (analysisData.quality && analysisData.quality.summary) {
     const { summary } = analysisData.quality;
-    report += `## Quality Metrics\n\n`;
+    report += '## Quality Metrics\n\n';
     report += `- Total Files: ${summary.totalFiles}\n`;
     report += `- Average Complexity: ${summary.averageComplexity}\n`;
     report += `- Average Maintainability: ${summary.averageMaintainability}\n`;
     report += `- High Complexity Files: ${summary.highComplexityFiles}\n`;
     report += `- Low Maintainability Files: ${summary.lowMaintainabilityFiles}\n\n`;
     
-    report += `### Recommendations\n\n`;
+    report += '### Recommendations\n\n';
     if (summary.highComplexityFiles > 0) {
       report += `- ⚠️ ${summary.highComplexityFiles} files have high complexity. Consider refactoring.\n`;
     }
@@ -368,20 +368,20 @@ async function generateReport(analysisData) {
       report += `- ⚠️ ${summary.lowMaintainabilityFiles} files have low maintainability. Add comments and simplify logic.\n`;
     }
     if (summary.highComplexityFiles === 0 && summary.lowMaintainabilityFiles === 0) {
-      report += `- ✅ Code quality is excellent!\n`;
+      report += '- ✅ Code quality is excellent!\n';
     }
-    report += `\n`;
+    report += '\n';
   }
   
   if (analysisData.dependencies) {
-    report += `## Dependencies\n\n`;
+    report += '## Dependencies\n\n';
     report += `- Production: ${analysisData.dependencies.dependencies.length}\n`;
     report += `- Development: ${analysisData.dependencies.devDependencies.length}\n\n`;
   }
   
   if (analysisData.security) {
     const total = Object.values(analysisData.security).reduce((sum, count) => sum + count, 0);
-    report += `## Security\n\n`;
+    report += '## Security\n\n';
     report += `- Total Vulnerabilities: ${total}\n`;
     report += `- Critical: ${analysisData.security.critical || 0}\n`;
     report += `- High: ${analysisData.security.high || 0}\n`;
@@ -389,8 +389,8 @@ async function generateReport(analysisData) {
     report += `- Low: ${analysisData.security.low || 0}\n\n`;
   }
   
-  report += `---\n\n`;
-  report += `*Generated by MUSUBI v0.5.0*\n`;
+  report += '---\n\n';
+  report += '*Generated by MUSUBI v0.5.0*\n';
   
   fs.ensureDirSync(path.dirname(reportPath));
   fs.writeFileSync(reportPath, report);

package/bin/musubi-share.js

@@ -0,0 +1,437 @@
+#!/usr/bin/env node
+
+/**
+ * MUSUBI Share Script
+ *
+ * Share and merge project memories across team members and AI platforms:
+ * - Export project memories to shareable format
+ * - Import memories from other team members
+ * - Merge memories with conflict resolution
+ * - Sync across different AI platforms (Claude Code, Copilot, Cursor, etc.)
+ *
+ * Usage:
+ *   musubi-share export [--output <file>]
+ *   musubi-share import <file> [--strategy <strategy>]
+ *   musubi-share sync [--platform <platform>]
+ *   musubi-share status
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { glob } = require('glob');
+const yaml = require('js-yaml');
+const { program } = require('commander');
+
+// Configuration
+const CONFIG = {
+  steeringDir: 'steering',
+  memoriesDir: 'steering/memories',
+  agentDirs: ['.claude', '.github/copilot', '.cursor', '.windsurf'],
+  exportFormats: ['json', 'yaml'],
+  mergeStrategies: ['ours', 'theirs', 'merge', 'interactive'],
+};
+
+/**
+ * Export project memories to shareable format
+ */
+async function exportMemories(options = {}) {
+  console.log(chalk.blue.bold('\n📤 MUSUBI Memory Export\n'));
+
+  const outputFile = options.output || `musubi-memories-${Date.now()}.json`;
+  const format = path.extname(outputFile).slice(1) || 'json';
+
+  if (!CONFIG.exportFormats.includes(format)) {
+    console.error(chalk.red(`❌ Unsupported format: ${format}`));
+    console.log(chalk.gray(`Supported formats: ${CONFIG.exportFormats.join(', ')}`));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan('📋 Step 1: Collecting project memories...\n'));
+
+  const memories = {
+    metadata: {
+      exportedAt: new Date().toISOString(),
+      exportedBy: process.env.USER || 'unknown',
+      musubiVersion: require('../package.json').version,
+    },
+    project: {},
+    memories: {},
+    agents: {},
+  };
+
+  // Load project configuration
+  if (await fs.pathExists('steering/project.yml')) {
+    const projectYml = await fs.readFile('steering/project.yml', 'utf8');
+    memories.project = yaml.load(projectYml);
+    console.log(chalk.gray('  ✓ Loaded project.yml'));
+  }
+
+  // Load steering documents
+  const steeringFiles = ['product.md', 'structure.md', 'tech.md'];
+  for (const file of steeringFiles) {
+    const filePath = `steering/${file}`;
+    if (await fs.pathExists(filePath)) {
+      memories.project[file] = await fs.readFile(filePath, 'utf8');
+      console.log(chalk.gray(`  ✓ Loaded ${file}`));
+    }
+  }
+
+  // Load memory files
+  if (await fs.pathExists(CONFIG.memoriesDir)) {
+    const memoryFiles = await glob('*.md', { cwd: CONFIG.memoriesDir });
+    const memoryArray = Array.isArray(memoryFiles) ? memoryFiles : [];
+    for (const file of memoryArray) {
+      const filePath = path.join(CONFIG.memoriesDir, file);
+      memories.memories[file] = await fs.readFile(filePath, 'utf8');
+      console.log(chalk.gray(`  ✓ Loaded memory: ${file}`));
+    }
+  }
+
+  // Load agent configurations
+  for (const agentDir of CONFIG.agentDirs) {
+    if (await fs.pathExists(agentDir)) {
+      const agentName = path.basename(agentDir);
+      memories.agents[agentName] = {};
+
+      const agentFiles = await glob('**/*.md', { cwd: agentDir });
+      const agentArray = Array.isArray(agentFiles) ? agentFiles : [];
+      for (const file of agentArray) {
+        const filePath = path.join(agentDir, file);
+        memories.agents[agentName][file] = await fs.readFile(filePath, 'utf8');
+      }
+      console.log(chalk.gray(`  ✓ Loaded agent config: ${agentName} (${agentArray.length} files)`));
+    }
+  }
+
+  console.log(chalk.cyan('\n📋 Step 2: Writing export file...\n'));
+
+  // Write export file
+  let exportContent;
+  if (format === 'json') {
+    exportContent = JSON.stringify(memories, null, 2);
+  } else if (format === 'yaml') {
+    exportContent = yaml.dump(memories, { indent: 2, lineWidth: 100 });
+  }
+
+  await fs.writeFile(outputFile, exportContent);
+
+  const stats = await fs.stat(outputFile);
+  const fileSizeKB = (stats.size / 1024).toFixed(2);
+
+  console.log(chalk.green.bold('✅ Export complete!\n'));
+  console.log(chalk.white('Export Summary:'));
+  console.log(chalk.gray(`  File: ${outputFile}`));
+  console.log(chalk.gray(`  Format: ${format}`));
+  console.log(chalk.gray(`  Size: ${fileSizeKB} KB`));
+  console.log(chalk.gray(`  Memories: ${Object.keys(memories.memories).length} files`));
+  console.log(chalk.gray(`  Agents: ${Object.keys(memories.agents).length} platforms`));
+  console.log(chalk.white('\nShare this file with your team:\n'));
+  console.log(chalk.cyan(`  scp ${outputFile} teammate@host:/path/`));
+  console.log(chalk.cyan('  # or commit to shared repository\n'));
+}
+
+/**
+ * Import and merge memories from file
+ */
+async function importMemories(importFile, options = {}) {
+  console.log(chalk.blue.bold('\n📥 MUSUBI Memory Import\n'));
+
+  if (!await fs.pathExists(importFile)) {
+    console.error(chalk.red(`❌ Import file not found: ${importFile}`));
+    process.exit(1);
+  }
+
+  const strategy = options.strategy || 'interactive';
+  if (!CONFIG.mergeStrategies.includes(strategy)) {
+    console.error(chalk.red(`❌ Invalid merge strategy: ${strategy}`));
+    console.log(chalk.gray(`Supported strategies: ${CONFIG.mergeStrategies.join(', ')}`));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan('📋 Step 1: Loading import file...\n'));
+
+  const importContent = await fs.readFile(importFile, 'utf8');
+  const format = path.extname(importFile).slice(1);
+
+  let importedMemories;
+  try {
+    if (format === 'json') {
+      importedMemories = JSON.parse(importContent);
+    } else if (format === 'yaml' || format === 'yml') {
+      importedMemories = yaml.load(importContent);
+    } else {
+      throw new Error(`Unsupported format: ${format}`);
+    }
+  } catch (error) {
+    console.error(chalk.red(`❌ Failed to parse import file: ${error.message}`));
+    process.exit(1);
+  }
+
+  console.log(chalk.gray(`  Exported by: ${importedMemories.metadata.exportedBy}`));
+  console.log(chalk.gray(`  Exported at: ${importedMemories.metadata.exportedAt}`));
+  console.log(chalk.gray(`  MUSUBI version: ${importedMemories.metadata.musubiVersion}`));
+
+  console.log(chalk.cyan('\n📋 Step 2: Detecting conflicts...\n'));
+
+  const conflicts = [];
+  const currentVersion = require('../package.json').version;
+
+  // Check version compatibility
+  if (importedMemories.metadata.musubiVersion !== currentVersion) {
+    console.log(chalk.yellow(`  ⚠️  Version mismatch: ${importedMemories.metadata.musubiVersion} → ${currentVersion}`));
+  }
+
+  // Detect memory conflicts
+  for (const [file, content] of Object.entries(importedMemories.memories)) {
+    const localPath = path.join(CONFIG.memoriesDir, file);
+    if (await fs.pathExists(localPath)) {
+      const localContent = await fs.readFile(localPath, 'utf8');
+      if (localContent !== content) {
+        conflicts.push({
+          type: 'memory',
+          file,
+          localPath,
+          importedContent: content,
+          localContent,
+        });
+        console.log(chalk.yellow(`  ⚠️  Conflict: ${file}`));
+      }
+    }
+  }
+
+  if (conflicts.length === 0) {
+    console.log(chalk.green('  ✓ No conflicts detected'));
+  } else {
+    console.log(chalk.yellow(`\n  Found ${conflicts.length} conflict(s)`));
+  }
+
+  console.log(chalk.cyan('\n📋 Step 3: Merging memories...\n'));
+
+  let mergeCount = 0;
+
+  // Apply merge strategy
+  if (strategy === 'ours') {
+    console.log(chalk.gray('  Strategy: Keep local changes (ours)'));
+    console.log(chalk.gray('  Skipping conflicted files...\n'));
+  } else if (strategy === 'theirs') {
+    console.log(chalk.gray('  Strategy: Accept imported changes (theirs)'));
+    
+    for (const conflict of conflicts) {
+      await fs.writeFile(conflict.localPath, conflict.importedContent);
+      console.log(chalk.gray(`  ✓ Updated: ${conflict.file}`));
+      mergeCount++;
+    }
+  } else if (strategy === 'merge') {
+    console.log(chalk.gray('  Strategy: Auto-merge with markers'));
+    
+    for (const conflict of conflicts) {
+      const mergedContent = `${conflict.localContent}\n\n<<<<<<< LOCAL\n${conflict.localContent}\n=======\n${conflict.importedContent}\n>>>>>>> IMPORTED\n`;
+      await fs.writeFile(conflict.localPath, mergedContent);
+      console.log(chalk.gray(`  ✓ Merged with markers: ${conflict.file}`));
+      mergeCount++;
+    }
+  } else if (strategy === 'interactive') {
+    console.log(chalk.gray('  Strategy: Interactive resolution'));
+    console.log(chalk.yellow('\n  ⚠️  Interactive mode requires manual review'));
+    console.log(chalk.gray('  Re-run with --strategy=theirs to auto-accept\n'));
+  }
+
+  // Import new memories (no conflicts)
+  for (const [file, content] of Object.entries(importedMemories.memories)) {
+    const localPath = path.join(CONFIG.memoriesDir, file);
+    if (!await fs.pathExists(localPath)) {
+      await fs.ensureDir(CONFIG.memoriesDir);
+      await fs.writeFile(localPath, content);
+      console.log(chalk.gray(`  ✓ Added new memory: ${file}`));
+      mergeCount++;
+    }
+  }
+
+  console.log(chalk.green.bold('\n✅ Import complete!\n'));
+  console.log(chalk.white('Import Summary:'));
+  console.log(chalk.gray(`  Strategy: ${strategy}`));
+  console.log(chalk.gray(`  Conflicts: ${conflicts.length}`));
+  console.log(chalk.gray(`  Merged: ${mergeCount} files`));
+  
+  if (conflicts.length > 0 && strategy === 'interactive') {
+    console.log(chalk.yellow('\nNext steps:'));
+    console.log(chalk.gray('  1. Review conflicted files manually'));
+    console.log(chalk.gray('  2. Re-run with --strategy=theirs to accept all'));
+    console.log(chalk.gray('  3. Or edit files individually\n'));
+  }
+}
+
+/**
+ * Sync memories across AI platforms
+ */
+async function syncPlatforms(options = {}) {
+  console.log(chalk.blue.bold('\n🔄 MUSUBI Platform Sync\n'));
+
+  const targetPlatform = options.platform;
+  const availablePlatforms = [
+    'claude-code',
+    'github-copilot',
+    'cursor',
+    'windsurf',
+    'codex',
+    'qwen-code',
+    'gemini-cli'
+  ];
+
+  if (targetPlatform && !availablePlatforms.includes(targetPlatform)) {
+    console.error(chalk.red(`❌ Unknown platform: ${targetPlatform}`));
+    console.log(chalk.gray(`Available: ${availablePlatforms.join(', ')}`));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan('📋 Step 1: Detecting installed platforms...\n'));
+
+  const installedPlatforms = [];
+  const platformDirs = {
+    'claude-code': '.claude',
+    'github-copilot': '.github/copilot',
+    'cursor': '.cursor',
+    'windsurf': '.windsurf',
+  };
+
+  for (const [platform, dir] of Object.entries(platformDirs)) {
+    if (await fs.pathExists(dir)) {
+      installedPlatforms.push(platform);
+      console.log(chalk.gray(`  ✓ Found: ${platform} (${dir})`));
+    }
+  }
+
+  if (installedPlatforms.length === 0) {
+    console.log(chalk.yellow('  ⚠️  No AI platforms detected'));
+    console.log(chalk.gray('  Run musubi-init to set up an AI platform\n'));
+    return;
+  }
+
+  console.log(chalk.cyan('\n📋 Step 2: Syncing shared memories...\n'));
+
+  // Sync steering documents to all platforms
+  let syncCount = 0;
+
+  for (const platform of installedPlatforms) {
+    if (targetPlatform && platform !== targetPlatform) continue;
+
+    const platformDir = platformDirs[platform];
+    
+    // Sync AGENTS.md
+    const agentsSource = 'AGENTS.md';
+    const agentsTarget = path.join(platformDir, 'AGENTS.md');
+    
+    if (await fs.pathExists(agentsSource)) {
+      await fs.copy(agentsSource, agentsTarget);
+      console.log(chalk.gray(`  ✓ ${platform}: Synced AGENTS.md`));
+      syncCount++;
+    }
+  }
+
+  console.log(chalk.green.bold('\n✅ Sync complete!\n'));
+  console.log(chalk.white('Sync Summary:'));
+  console.log(chalk.gray(`  Platforms: ${installedPlatforms.length}`));
+  console.log(chalk.gray(`  Synced files: ${syncCount}`));
+  console.log(chalk.white('\nAll platforms now have consistent memories\n'));
+}
+
+/**
+ * Show sharing status
+ */
+async function showStatus() {
+  console.log(chalk.blue.bold('\n📊 MUSUBI Sharing Status\n'));
+
+  // Check project setup
+  console.log(chalk.white('Project Setup:'));
+  const hasProject = await fs.pathExists('steering/project.yml');
+  console.log(chalk.gray(`  project.yml: ${hasProject ? '✓' : '✗'}`));
+
+  // Check memories
+  if (await fs.pathExists(CONFIG.memoriesDir)) {
+    const memoryFiles = await glob('*.md', { cwd: CONFIG.memoriesDir });
+    const memoryArray = Array.isArray(memoryFiles) ? memoryFiles : [];
+    console.log(chalk.gray(`  Memories: ${memoryArray.length} files`));
+  } else {
+    console.log(chalk.gray('  Memories: 0 files'));
+  }
+
+  // Check platforms
+  console.log(chalk.white('\nInstalled Platforms:'));
+  const platformDirs = {
+    'Claude Code': '.claude',
+    'GitHub Copilot': '.github/copilot',
+    'Cursor': '.cursor',
+    'Windsurf': '.windsurf',
+    'Codex': '.codex',
+    'Qwen Code': '.qwen',
+  };
+
+  let installedCount = 0;
+  for (const [name, dir] of Object.entries(platformDirs)) {
+    const exists = await fs.pathExists(dir);
+    if (exists) {
+      console.log(chalk.green(`  ✓ ${name}`));
+      installedCount++;
+    } else {
+      console.log(chalk.gray(`  ✗ ${name}`));
+    }
+  }
+
+  console.log(chalk.white(`\nTotal: ${installedCount} platform(s) configured\n`));
+
+  // Export recommendation
+  if (hasProject) {
+    console.log(chalk.cyan('Ready to share:'));
+    console.log(chalk.gray('  Run: musubi-share export'));
+    console.log(chalk.gray('  Then share the generated file with your team\n'));
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  program
+    .name('musubi-share')
+    .description('Share and merge project memories across team members and AI platforms')
+    .version(require('../package.json').version);
+
+  program
+    .command('export')
+    .description('Export project memories to shareable format')
+    .option('-o, --output <file>', 'Output file path', `musubi-memories-${Date.now()}.json`)
+    .action(exportMemories);
+
+  program
+    .command('import <file>')
+    .description('Import and merge memories from file')
+    .option('-s, --strategy <strategy>', 'Merge strategy: ours, theirs, merge, interactive', 'interactive')
+    .action(importMemories);
+
+  program
+    .command('sync')
+    .description('Sync memories across AI platforms')
+    .option('-p, --platform <platform>', 'Target platform to sync')
+    .action(syncPlatforms);
+
+  program
+    .command('status')
+    .description('Show sharing status')
+    .action(showStatus);
+
+  program.parse();
+}
+
+// Run if called directly
+if (require.main === module) {
+  main().catch(error => {
+    console.error(chalk.red(`\n❌ Share failed: ${error.message}\n`));
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  });
+}
+
+module.exports = main;

package/bin/musubi-sync.js

@@ -208,7 +208,8 @@ async function analyzeCodebase() {
     nodir: true,
   });
 
-  const extensions = new Set(files.map(f => path.extname(f)).filter(Boolean));
+  const fileArray = Array.isArray(files) ? files : [];
+  const extensions = new Set(fileArray.map(f => path.extname(f)).filter(Boolean));
   const langMap = {
     '.js': 'javascript',
     '.ts': 'typescript',
@@ -229,7 +230,8 @@ async function analyzeCodebase() {
   const dirs = await glob('*/', {
     ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**', '.vscode/**'],
   });
-  state.directories = dirs.map(d => d.replace(/\/$/, '')).slice(0, 10);
+  const dirArray = Array.isArray(dirs) ? dirs : [];
+  state.directories = dirArray.map(d => d.replace(/\/$/, '')).slice(0, 10);
 
   return state;
 }
@@ -398,7 +400,7 @@ async function applyChanges(changes, currentConfig, actualState) {
 
   // Record change in memories
   await recordChangeInMemory(changes);
-  console.log(chalk.gray(`  Updated steering/memories/architecture_decisions.md`));
+  console.log(chalk.gray('  Updated steering/memories/architecture_decisions.md'));
 }
 
 /**
@@ -436,7 +438,7 @@ async function updateProjectYml(changes, actualState) {
 /**
  * Update tech.md with new frameworks
  */
-async function updateTechMd(changes, actualState) {
+async function updateTechMd(changes, _actualState) {
   const newFrameworks = changes
     .filter(c => c.type === 'new_frameworks')
     .flatMap(c => c.added);
@@ -482,7 +484,7 @@ async function updateTechMd(changes, actualState) {
 /**
  * Update structure.md with new directories
  */
-async function updateStructureMd(changes, actualState) {
+async function updateStructureMd(changes, _actualState) {
   const newDirs = changes
     .filter(c => c.type === 'new_directories')
     .flatMap(c => c.added);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musubi-sdd",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Ultimate Specification Driven Development Tool with 25 Agents for 7 AI Coding Platforms (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Windsurf, Codex, Qwen Code)",
   "main": "src/index.js",
   "bin": {
@@ -9,7 +9,8 @@
     "musubi-init": "bin/musubi-init.js",
     "musubi-onboard": "bin/musubi-onboard.js",
     "musubi-sync": "bin/musubi-sync.js",
-    "musubi-analyze": "bin/musubi-analyze.js"
+    "musubi-analyze": "bin/musubi-analyze.js",
+    "musubi-share": "bin/musubi-share.js"
   },
   "scripts": {
     "test": "jest",
@@ -44,7 +45,7 @@
     "chalk": "^4.1.2",
     "commander": "^11.0.0",
     "fs-extra": "^11.0.0",
-    "glob": "^10.0.0",
+    "glob": "^10.5.0",
     "inquirer": "^9.0.0",
     "js-yaml": "^4.1.0"
   },