@fermindi/pwn-cli 0.1.1 → 0.2.0

package/cli/migrate.js

@@ -0,0 +1,466 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { detectKnownAIFiles } from '../src/core/inject.js';
+
+/**
+ * Migration strategies for different AI file types
+ */
+const MIGRATION_STRATEGIES = {
+  'claude': migrateClaude,
+  'cursor': migrateCursor,
+  'memory-bank': migrateMemoryBank,
+  'copilot': migrateCopilot,
+};
+
+/**
+ * Parse markdown content to extract decisions, patterns, and tasks
+ */
+function parseMarkdownContent(content) {
+  const result = {
+    decisions: [],
+    patterns: [],
+    deadends: [],
+    tasks: [],
+    instructions: [],
+    raw: content
+  };
+
+  const lines = content.split('\n');
+  let currentSection = null;
+  let currentItem = [];
+
+  for (const line of lines) {
+    // Detect section headers
+    const h2Match = line.match(/^##\s+(.+)/);
+    if (h2Match) {
+      // Save previous item
+      if (currentItem.length > 0) {
+        categorizeItem(currentItem.join('\n'), currentSection, result);
+      }
+      currentSection = h2Match[1].toLowerCase();
+      currentItem = [line];
+      continue;
+    }
+
+    if (currentSection) {
+      currentItem.push(line);
+    }
+  }
+
+  // Save last item
+  if (currentItem.length > 0) {
+    categorizeItem(currentItem.join('\n'), currentSection, result);
+  }
+
+  return result;
+}
+
+/**
+ * Categorize a parsed item into the appropriate bucket
+ */
+function categorizeItem(content, sectionName, result) {
+  const lowerContent = content.toLowerCase();
+  const lowerSection = sectionName || '';
+
+  // Decision indicators
+  if (lowerSection.includes('decision') ||
+      lowerSection.includes('architecture') ||
+      lowerSection.includes('tech stack') ||
+      lowerContent.includes('we decided') ||
+      lowerContent.includes('decision:')) {
+    result.decisions.push(content);
+  }
+  // Dead-end indicators
+  else if (lowerSection.includes('avoid') ||
+           lowerSection.includes('don\'t') ||
+           lowerSection.includes('failed') ||
+           lowerSection.includes('dead') ||
+           lowerContent.includes('didn\'t work') ||
+           lowerContent.includes('don\'t use')) {
+    result.deadends.push(content);
+  }
+  // Task indicators
+  else if (lowerSection.includes('task') ||
+           lowerSection.includes('todo') ||
+           lowerSection.includes('backlog') ||
+           lowerSection.includes('current work') ||
+           content.includes('- [ ]') ||
+           content.includes('- [x]')) {
+    result.tasks.push(content);
+  }
+  // Pattern indicators
+  else if (lowerSection.includes('pattern') ||
+           lowerSection.includes('convention') ||
+           lowerSection.includes('style') ||
+           lowerSection.includes('rule')) {
+    result.patterns.push(content);
+  }
+  // Everything else goes to instructions
+  else {
+    result.instructions.push(content);
+  }
+}
+
+/**
+ * Generate DEC-XXX ID based on existing count
+ */
+function generateDecisionId(existingContent) {
+  const matches = existingContent.match(/DEC-(\d+)/g) || [];
+  const maxId = matches.reduce((max, match) => {
+    const num = parseInt(match.replace('DEC-', ''));
+    return num > max ? num : max;
+  }, 0);
+  return `DEC-${String(maxId + 1).padStart(3, '0')}`;
+}
+
+/**
+ * Generate DE-XXX ID based on existing count
+ */
+function generateDeadendId(existingContent) {
+  const matches = existingContent.match(/DE-(\d+)/g) || [];
+  const maxId = matches.reduce((max, match) => {
+    const num = parseInt(match.replace('DE-', ''));
+    return num > max ? num : max;
+  }, 0);
+  return `DE-${String(maxId + 1).padStart(3, '0')}`;
+}
+
+/**
+ * Migrate CLAUDE.md or claude.md
+ */
+function migrateClaude(filePath, cwd) {
+  const content = readFileSync(filePath, 'utf8');
+  const parsed = parseMarkdownContent(content);
+
+  return {
+    source: filePath,
+    type: 'claude',
+    parsed,
+    actions: generateMigrationActions(parsed, cwd)
+  };
+}
+
+/**
+ * Migrate .cursorrules or .cursor/rules
+ */
+function migrateCursor(filePath, cwd) {
+  const content = readFileSync(filePath, 'utf8');
+  const parsed = parseMarkdownContent(content);
+
+  return {
+    source: filePath,
+    type: 'cursor',
+    parsed,
+    actions: generateMigrationActions(parsed, cwd)
+  };
+}
+
+/**
+ * Migrate memory-bank/ directory
+ */
+function migrateMemoryBank(dirPath, cwd) {
+  const parsed = {
+    decisions: [],
+    patterns: [],
+    deadends: [],
+    tasks: [],
+    instructions: [],
+    raw: ''
+  };
+
+  const fileMapping = {
+    'projectbrief.md': 'instructions',
+    'productContext.md': 'decisions',
+    'systemPatterns.md': 'patterns',
+    'techContext.md': 'decisions',
+    'activeContext.md': 'tasks',
+    'progress.md': 'tasks',
+  };
+
+  try {
+    const files = readdirSync(dirPath);
+    for (const file of files) {
+      const filePath = join(dirPath, file);
+      if (!statSync(filePath).isFile()) continue;
+
+      const content = readFileSync(filePath, 'utf8');
+      const category = fileMapping[file] || 'instructions';
+
+      if (category === 'decisions') {
+        parsed.decisions.push(`<!-- From ${file} -->\n${content}`);
+      } else if (category === 'patterns') {
+        parsed.patterns.push(`<!-- From ${file} -->\n${content}`);
+      } else if (category === 'tasks') {
+        parsed.tasks.push(`<!-- From ${file} -->\n${content}`);
+      } else {
+        parsed.instructions.push(`<!-- From ${file} -->\n${content}`);
+      }
+    }
+  } catch (err) {
+    console.error(`Error reading memory-bank: ${err.message}`);
+  }
+
+  return {
+    source: dirPath,
+    type: 'memory-bank',
+    parsed,
+    actions: generateMigrationActions(parsed, cwd)
+  };
+}
+
+/**
+ * Migrate GitHub Copilot instructions
+ */
+function migrateCopilot(filePath, cwd) {
+  const content = readFileSync(filePath, 'utf8');
+  const parsed = parseMarkdownContent(content);
+
+  return {
+    source: filePath,
+    type: 'copilot',
+    parsed,
+    actions: generateMigrationActions(parsed, cwd)
+  };
+}
+
+/**
+ * Generate migration actions based on parsed content
+ */
+function generateMigrationActions(parsed, cwd) {
+  const actions = [];
+  const today = new Date().toISOString().split('T')[0];
+
+  // Decisions
+  if (parsed.decisions.length > 0) {
+    const targetPath = join(cwd, '.ai', 'memory', 'decisions.md');
+    let existingContent = '';
+    if (existsSync(targetPath)) {
+      existingContent = readFileSync(targetPath, 'utf8');
+    }
+
+    let newContent = '';
+    for (const decision of parsed.decisions) {
+      const id = generateDecisionId(existingContent + newContent);
+      newContent += `\n## ${id}: Migrated Decision\n`;
+      newContent += `**Date:** ${today}\n`;
+      newContent += `**Status:** Active\n`;
+      newContent += `**Source:** Migration\n\n`;
+      newContent += decision.replace(/^##\s+.+\n/, '') + '\n';
+    }
+
+    actions.push({
+      type: 'append',
+      target: targetPath,
+      content: newContent,
+      description: `Add ${parsed.decisions.length} decision(s) to decisions.md`
+    });
+  }
+
+  // Patterns
+  if (parsed.patterns.length > 0) {
+    const targetPath = join(cwd, '.ai', 'memory', 'patterns.md');
+    let newContent = '\n## Migrated Patterns\n\n';
+    for (const pattern of parsed.patterns) {
+      newContent += pattern.replace(/^##\s+.+\n/, '') + '\n\n';
+    }
+
+    actions.push({
+      type: 'append',
+      target: targetPath,
+      content: newContent,
+      description: `Add ${parsed.patterns.length} pattern(s) to patterns.md`
+    });
+  }
+
+  // Dead-ends
+  if (parsed.deadends.length > 0) {
+    const targetPath = join(cwd, '.ai', 'memory', 'deadends.md');
+    let existingContent = '';
+    if (existsSync(targetPath)) {
+      existingContent = readFileSync(targetPath, 'utf8');
+    }
+
+    let newContent = '';
+    for (const deadend of parsed.deadends) {
+      const id = generateDeadendId(existingContent + newContent);
+      newContent += `\n## ${id}: Migrated Dead-end\n`;
+      newContent += `**Date:** ${today}\n`;
+      newContent += `**Source:** Migration\n\n`;
+      newContent += deadend.replace(/^##\s+.+\n/, '') + '\n';
+    }
+
+    actions.push({
+      type: 'append',
+      target: targetPath,
+      content: newContent,
+      description: `Add ${parsed.deadends.length} dead-end(s) to deadends.md`
+    });
+  }
+
+  // Tasks
+  if (parsed.tasks.length > 0) {
+    const targetPath = join(cwd, '.ai', 'tasks', 'backlog.md');
+    let newContent = '\n## Migrated Tasks\n\n';
+    for (const task of parsed.tasks) {
+      newContent += task.replace(/^##\s+.+\n/, '') + '\n';
+    }
+
+    actions.push({
+      type: 'append',
+      target: targetPath,
+      content: newContent,
+      description: `Add ${parsed.tasks.length} task section(s) to backlog.md`
+    });
+  }
+
+  // Instructions (append to claude.md)
+  if (parsed.instructions.length > 0) {
+    const targetPath = join(cwd, '.ai', 'agents', 'claude.md');
+    let newContent = '\n\n---\n\n## Migrated Instructions\n\n';
+    for (const instruction of parsed.instructions) {
+      newContent += instruction + '\n\n';
+    }
+
+    actions.push({
+      type: 'append',
+      target: targetPath,
+      content: newContent,
+      description: `Add ${parsed.instructions.length} instruction section(s) to claude.md`
+    });
+  }
+
+  return actions;
+}
+
+/**
+ * Execute migration actions
+ */
+function executeMigrationActions(actions, dryRun = false) {
+  const results = [];
+
+  for (const action of actions) {
+    if (dryRun) {
+      results.push({ ...action, status: 'would-execute' });
+      continue;
+    }
+
+    try {
+      if (action.type === 'append') {
+        let existing = '';
+        if (existsSync(action.target)) {
+          existing = readFileSync(action.target, 'utf8');
+        }
+        writeFileSync(action.target, existing + action.content);
+        results.push({ ...action, status: 'success' });
+      }
+    } catch (err) {
+      results.push({ ...action, status: 'error', error: err.message });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Main migrate command
+ */
+export default async function migrateCommand(args = []) {
+  const dryRun = args.includes('--dry-run');
+  const cwd = process.cwd();
+
+  console.log('🔄 PWN Migration\n');
+
+  // Check if .ai/ exists
+  if (!existsSync(join(cwd, '.ai'))) {
+    console.log('❌ No .ai/ directory found.');
+    console.log('   Run "pwn inject" first to create the PWN workspace.\n');
+    process.exit(1);
+  }
+
+  // Detect migratable files
+  const detected = detectKnownAIFiles(cwd);
+  const migratable = detected.filter(f => f.migratable);
+
+  if (migratable.length === 0) {
+    console.log('✅ No migratable AI files detected.\n');
+    console.log('Supported sources:');
+    console.log('  - CLAUDE.md / claude.md');
+    console.log('  - .cursorrules / .cursor/rules');
+    console.log('  - memory-bank/');
+    console.log('  - .github/copilot-instructions.md\n');
+    process.exit(0);
+  }
+
+  console.log(`📄 Found ${migratable.length} migratable source(s):\n`);
+  for (const file of migratable) {
+    console.log(`   ${file.file} (${file.type})`);
+  }
+  console.log('');
+
+  // Process each file
+  const allActions = [];
+
+  for (const file of migratable) {
+    const strategy = MIGRATION_STRATEGIES[file.type];
+    if (!strategy) {
+      console.log(`   ⚠️  No migration strategy for ${file.type}`);
+      continue;
+    }
+
+    console.log(`📦 Analyzing ${file.file}...`);
+    const result = strategy(file.path, cwd);
+
+    console.log(`   Found: ${result.parsed.decisions.length} decisions, ${result.parsed.patterns.length} patterns, ${result.parsed.deadends.length} dead-ends, ${result.parsed.tasks.length} tasks, ${result.parsed.instructions.length} instructions`);
+
+    allActions.push(...result.actions);
+  }
+
+  if (allActions.length === 0) {
+    console.log('\n✅ Nothing to migrate (content may already be structured).\n');
+    process.exit(0);
+  }
+
+  console.log(`\n📋 Migration plan (${allActions.length} actions):\n`);
+  for (const action of allActions) {
+    const targetShort = action.target.replace(cwd, '.');
+    console.log(`   ${action.type}: ${targetShort}`);
+    console.log(`      → ${action.description}`);
+  }
+
+  if (dryRun) {
+    console.log('\n🔍 Dry run - no changes made.');
+    console.log('   Remove --dry-run to execute migration.\n');
+    process.exit(0);
+  }
+
+  console.log('\n🚀 Executing migration...\n');
+  const results = executeMigrationActions(allActions);
+
+  let successCount = 0;
+  let errorCount = 0;
+
+  for (const result of results) {
+    const targetShort = result.target.replace(cwd, '.');
+    if (result.status === 'success') {
+      console.log(`   ✅ ${targetShort}`);
+      successCount++;
+    } else {
+      console.log(`   ❌ ${targetShort}: ${result.error}`);
+      errorCount++;
+    }
+  }
+
+  console.log(`\n📊 Migration complete: ${successCount} succeeded, ${errorCount} failed\n`);
+
+  if (successCount > 0) {
+    console.log('💡 Next steps:');
+    console.log('   1. Review migrated content in .ai/memory/');
+    console.log('   2. Adjust DEC-XXX and DE-XXX entries as needed');
+    console.log('   3. Backup and remove original files:\n');
+    for (const file of migratable) {
+      console.log(`      mv ${file.file} .ai-migration-backup/`);
+    }
+    console.log('');
+  }
+}