aiwf 0.3.3 → 0.3.4

package/src/lib/backup-manager.js

@@ -0,0 +1,270 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import { 
+  TOOL_DIRS, 
+  AIWF_DIRS, 
+  FILES,
+  getBackupDirName as getBackupDirNamePath 
+} from '../utils/paths.js';
+
+let BACKUP_DIR = null;
+
+/**
+ * Generate backup directory name with timestamp
+ * @returns {string} Backup directory name
+ */
+function getBackupDirName() {
+  return getBackupDirNamePath();
+}
+
+/**
+ * Backup a single file with proper naming convention
+ * @param {string} filePath - File to backup
+ * @param {string} backupDir - Backup directory path
+ * @returns {Promise<string|null>} Backup file path or null
+ */
+async function backupFile(filePath, backupDir) {
+  try {
+    const exists = await fs.access(filePath).then(() => true).catch(() => false);
+    if (exists) {
+      await fs.mkdir(backupDir, { recursive: true });
+      const backupPath = `${filePath}.bak`;
+      await fs.copyFile(filePath, backupPath);
+      
+      // Tool-specific backup file naming rules
+      let bakFileName;
+      if (filePath.startsWith(TOOL_DIRS.CLAUDE_COMMANDS + '/')) {
+        // Claude Code command files
+        const relativePath = filePath.substring(TOOL_DIRS.CLAUDE_COMMANDS.length + 1);
+        bakFileName = `claude-commands-aiwf-${relativePath.replace(/\//g, '-')}.bak`;
+      } else if (filePath.startsWith(TOOL_DIRS.GEMINI_PROMPTS + '/')) {
+        // Gemini CLI prompt files
+        const relativePath = filePath.substring(TOOL_DIRS.GEMINI_PROMPTS.length + 1);
+        bakFileName = `gemini-prompts-aiwf-${relativePath.replace(/\//g, '-')}.bak`;
+      } else if (filePath.startsWith(TOOL_DIRS.CURSOR_RULES + '/')) {
+        // Cursor rule files
+        const relativePath = filePath.substring(TOOL_DIRS.CURSOR_RULES.length + 1);
+        bakFileName = `cursor-rules-${relativePath.replace(/\//g, '-')}.bak`;
+      } else if (filePath.startsWith(TOOL_DIRS.WINDSURF_RULES + '/')) {
+        // Windsurf rule files
+        const relativePath = filePath.substring(TOOL_DIRS.WINDSURF_RULES.length + 1);
+        bakFileName = `windsurf-rules-${relativePath.replace(/\//g, '-')}.bak`;
+      } else if (filePath.startsWith(AIWF_DIRS.ROOT + '/')) {
+        // AIWF core files
+        const relativePath = filePath.substring(AIWF_DIRS.ROOT.length + 1);
+        bakFileName = `aiwf-${relativePath.replace(/\//g, '-')}.bak`;
+      } else {
+        // Other files
+        bakFileName = path.basename(filePath) + '.bak';
+      }
+      
+      const destPath = path.join(backupDir, bakFileName);
+      await fs.rename(backupPath, destPath);
+      return destPath;
+    }
+  } catch (error) {
+    // Backup failed, but continue
+  }
+  return null;
+}
+
+/**
+ * Backup commands and documentation files
+ * @param {Object} messages - Localized messages
+ * @param {string} [commandsDir] - Commands directory
+ * @returns {Promise<Array<string>>} Array of backed up file paths
+ */
+async function backupCommandsAndDocs(messages, commandsDir = TOOL_DIRS.CLAUDE_COMMANDS) {
+  if (!BACKUP_DIR) BACKUP_DIR = getBackupDirName();
+  const spinner = ora(messages.backingUp).start();
+  const backedUpFiles = [];
+  await fs.mkdir(BACKUP_DIR, { recursive: true });
+  
+  try {
+    // Files that will be updated and need backup
+    const filesToBackup = Object.values(FILES.CLAUDE_MD);
+    
+    // Backup CLAUDE.md files
+    for (const file of filesToBackup) {
+      const backupPath = await backupFile(file, BACKUP_DIR);
+      if (backupPath) {
+        backedUpFiles.push(backupPath);
+      }
+    }
+    
+    // Backup all command files
+    const commandsExist = await fs.access(commandsDir).then(() => true).catch(() => false);
+    if (commandsExist) {
+      try {
+        const commandFiles = await fs.readdir(commandsDir);
+        for (const file of commandFiles) {
+          const filePath = path.join(commandsDir, file);
+          const stat = await fs.stat(filePath);
+          if (stat.isFile() && file.endsWith('.md')) {
+            const backupPath = await backupFile(filePath, BACKUP_DIR);
+            if (backupPath) {
+              backedUpFiles.push(backupPath);
+            }
+          }
+        }
+      } catch (error) {
+        // Commands directory might be empty or have issues
+      }
+    }
+    
+    // Backup IDE rule files (Cursor)
+    const cursorRulesExist = await fs.access(TOOL_DIRS.CURSOR_RULES).then(() => true).catch(() => false);
+    if (cursorRulesExist) {
+      try {
+        const cursorFiles = await fs.readdir(TOOL_DIRS.CURSOR_RULES);
+        for (const file of cursorFiles) {
+          if (file.endsWith('.mdc')) {
+            const filePath = path.join(TOOL_DIRS.CURSOR_RULES, file);
+            const backupPath = await backupFile(filePath, BACKUP_DIR);
+            if (backupPath) {
+              backedUpFiles.push(backupPath);
+            }
+          }
+        }
+      } catch (error) {
+        // Cursor rules directory might have issues
+      }
+    }
+    
+    // Backup IDE rule files (Windsurf)
+    const windsurfRulesExist = await fs.access(TOOL_DIRS.WINDSURF_RULES).then(() => true).catch(() => false);
+    if (windsurfRulesExist) {
+      try {
+        const windsurfFiles = await fs.readdir(TOOL_DIRS.WINDSURF_RULES);
+        for (const file of windsurfFiles) {
+          if (file.endsWith('.md')) {
+            const filePath = path.join(TOOL_DIRS.WINDSURF_RULES, file);
+            const backupPath = await backupFile(filePath, BACKUP_DIR);
+            if (backupPath) {
+              backedUpFiles.push(backupPath);
+            }
+          }
+        }
+      } catch (error) {
+        // Windsurf rules directory might have issues
+      }
+    }
+    
+    if (backedUpFiles.length > 0) {
+      spinner.succeed(chalk.green(messages.backupComplete.replace('{count}', backedUpFiles.length)));
+    } else {
+      spinner.succeed(chalk.gray(messages.noFilesToBackup));
+    }
+    return backedUpFiles;
+  } catch (error) {
+    spinner.fail(chalk.red(messages.backupFailed));
+    throw error;
+  }
+}
+
+/**
+ * Restore files from backup
+ * @param {Object} spinner - Ora spinner instance
+ * @param {Object} messages - Localized messages
+ * @returns {Promise<void>}
+ */
+async function restoreFromBackup(spinner, messages) {
+  if (!BACKUP_DIR) return;
+  
+  try {
+    spinner.text = messages.restoringBackup;
+    
+    // Get all backup files
+    const backupFiles = await fs.readdir(BACKUP_DIR);
+    let restoredCount = 0;
+    
+    for (const bakFile of backupFiles) {
+      if (bakFile.endsWith('.bak')) {
+        const backupPath = path.join(BACKUP_DIR, bakFile);
+        let originalPath;
+        
+        // Determine original path from backup filename
+        if (bakFile.startsWith('claude-commands-aiwf-')) {
+          const relativePath = bakFile
+            .replace('claude-commands-aiwf-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(TOOL_DIRS.CLAUDE_COMMANDS, relativePath);
+        } else if (bakFile.startsWith('gemini-prompts-aiwf-')) {
+          const relativePath = bakFile
+            .replace('gemini-prompts-aiwf-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(TOOL_DIRS.GEMINI_PROMPTS, relativePath);
+        } else if (bakFile.startsWith('cursor-rules-')) {
+          const relativePath = bakFile
+            .replace('cursor-rules-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(TOOL_DIRS.CURSOR_RULES, relativePath);
+        } else if (bakFile.startsWith('windsurf-rules-')) {
+          const relativePath = bakFile
+            .replace('windsurf-rules-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(TOOL_DIRS.WINDSURF_RULES, relativePath);
+        } else if (bakFile.startsWith('aiwf-')) {
+          const relativePath = bakFile
+            .replace('aiwf-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(AIWF_DIRS.ROOT, relativePath);
+        } else {
+          // Simple filename.ext.bak format
+          originalPath = bakFile.replace('.bak', '');
+        }
+        
+        try {
+          // Ensure directory exists
+          await fs.mkdir(path.dirname(originalPath), { recursive: true });
+          // Copy backup to original location
+          await fs.copyFile(backupPath, originalPath);
+          restoredCount++;
+        } catch (error) {
+          // Individual file restore failed, continue with others
+        }
+      }
+    }
+    
+    // Clean up backup directory
+    await fs.rm(BACKUP_DIR, { recursive: true, force: true });
+    BACKUP_DIR = null;
+    
+    spinner.text = messages.backupRestored.replace('{count}', restoredCount);
+  } catch (error) {
+    spinner.fail(chalk.red(messages.restoreFailed));
+    throw error;
+  }
+}
+
+/**
+ * Get current backup directory
+ * @returns {string|null} Current backup directory path
+ */
+function getCurrentBackupDir() {
+  return BACKUP_DIR;
+}
+
+/**
+ * Set backup directory
+ * @param {string} dir - Backup directory path
+ */
+function setBackupDir(dir) {
+  BACKUP_DIR = dir;
+}
+
+export {
+  getBackupDirName,
+  backupFile,
+  backupCommandsAndDocs,
+  restoreFromBackup,
+  getCurrentBackupDir,
+  setBackupDir
+};

package/src/lib/file-downloader.js

@@ -0,0 +1,208 @@
+import https from 'https';
+import { createWriteStream } from 'fs';
+import { pipeline } from 'stream/promises';
+import path from 'path';
+
+const GITHUB_RAW_URL = 'https://raw.githubusercontent.com/moonklabs/aiwf/main';
+const GITHUB_CONTENT_PREFIX = 'claude-code/aiwf';
+
+// Pre-defined list of command files
+const COMMAND_FILES = [
+  'aiwf_changelog.md',
+  'aiwf_code_review.md',
+  'aiwf_commit.md',
+  'aiwf_compress_aggressive_persona.md',
+  'aiwf_compress_context.md',
+  'aiwf_compress_minimal_persona.md',
+  'aiwf_compress_stats.md',
+  'aiwf_compress_with_persona.md',
+  'aiwf_create_feature_ledger.md',
+  'aiwf_create_general_task.md',
+  'aiwf_create_milestone_plan.md',
+  'aiwf_create_prd.md',
+  'aiwf_create_sprint_tasks.md',
+  'aiwf_create_sprints_from_milestone.md',
+  'aiwf_default_mode.md',
+  'aiwf_discuss_review.md',
+  'aiwf_do_task.md',
+  'aiwf_docs.md',
+  'aiwf_evaluate.md',
+  'aiwf_get_feature_details.md',
+  'aiwf_infinite.md',
+  'aiwf_initialize.md',
+  'aiwf_issue_create.md',
+  'aiwf_link_feature_to_milestone.md',
+  'aiwf_list_features.md',
+  'aiwf_mermaid.md',
+  'aiwf_persona_architect.md',
+  'aiwf_persona_backend.md',
+  'aiwf_persona_data_analyst.md',
+  'aiwf_persona_frontend.md',
+  'aiwf_persona_security.md',
+  'aiwf_persona_status.md',
+  'aiwf_pr_create.md',
+  'aiwf_prime.md',
+  'aiwf_project_review.md',
+  'aiwf_switch_language.md',
+  'aiwf_test.md',
+  'aiwf_testing_review.md',
+  'aiwf_tm-run-all-subtask.md',
+  'aiwf_ultrathink_code_advanced.md',
+  'aiwf_ultrathink_code_basic.md',
+  'aiwf_ultrathink_general.md',
+  'aiwf_update_docs_kr.md',
+  'aiwf_update_feature_status.md',
+  'aiwf_yolo.md'
+];
+
+// Pre-defined list of global rules files
+const GLOBAL_RULES_FILES = [
+  'code-style-guide.md',
+  'coding-principles.md',
+  'development-process.md',
+  'global-rules.md'
+];
+
+// Pre-defined list of manual rules files
+const MANUAL_RULES_FILES = [
+  'generate-plan-docs.md'
+];
+
+// Pre-defined list of template files (these might not exist in the repo)
+const TEMPLATE_FILES = [
+  // Add template files here when they are available
+];
+
+// Pre-defined list of prompt files (these might not exist in the repo)
+const PROMPT_FILES = [
+  // Add prompt files here when they are available
+];
+
+/**
+ * Fetch content from URL
+ * @param {string} url - The URL to fetch from
+ * @returns {Promise<string>} The response content
+ */
+async function fetchContent(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers: { 'User-Agent': 'aiwf' } }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          resolve(data);
+        } else {
+          reject(new Error(`Failed to fetch ${url}: ${res.statusCode}`));
+        }
+        res.destroy();
+      });
+    }).on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Download a file from URL to destination path
+ * @param {string} url - The URL to download from
+ * @param {string} destPath - The destination file path
+ * @returns {Promise<void>}
+ */
+async function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers: { 'User-Agent': 'aiwf' } }, (response) => {
+      if (response.statusCode !== 200) {
+        response.destroy();
+        reject(new Error(`Failed to download ${url}: ${response.statusCode}`));
+        return;
+      }
+      const file = createWriteStream(destPath);
+      pipeline(response, file)
+        .then(() => {
+          resolve();
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    }).on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Download files from a predefined list
+ * @param {string} githubPath - GitHub repository path
+ * @param {string} localPath - Local destination path
+ * @param {Array<string>} fileList - List of files to download
+ * @param {Object} spinner - Ora spinner instance
+ * @param {Object} messages - Localized messages
+ * @returns {Promise<void>}
+ */
+async function downloadFileList(githubPath, localPath, fileList, spinner, messages) {
+  for (const fileName of fileList) {
+    try {
+      const destPath = path.join(localPath, fileName);
+      const downloadUrl = `${GITHUB_RAW_URL}/${githubPath}/${fileName}`;
+      
+      await downloadFile(downloadUrl, destPath);
+      if (spinner) {
+        spinner.text = `${messages.downloading}: ${fileName}`;
+      }
+    } catch (error) {
+      // Skip files that don't exist, but log the error
+      if (spinner) {
+        spinner.text = `${messages.skipping || 'Skipping'}: ${fileName}`;
+      }
+    }
+  }
+}
+
+/**
+ * Download directory contents using predefined file lists
+ * @param {string} githubPath - GitHub repository path
+ * @param {string} localPath - Local destination path
+ * @param {Object} spinner - Ora spinner instance
+ * @param {Object} messages - Localized messages
+ * @param {string} [selectedLanguage='en'] - Selected language
+ * @returns {Promise<void>}
+ */
+async function downloadDirectory(githubPath, localPath, spinner, messages, selectedLanguage = 'en') {
+  try {
+    // Determine which file list to use based on the path
+    let fileList = [];
+    
+    if (githubPath.includes('.claude/commands/aiwf')) {
+      fileList = COMMAND_FILES;
+    } else if (githubPath.includes('rules/global')) {
+      fileList = GLOBAL_RULES_FILES;
+    } else if (githubPath.includes('rules/manual')) {
+      fileList = MANUAL_RULES_FILES;
+    } else if (githubPath.includes('98_PROMPTS')) {
+      fileList = PROMPT_FILES;
+    } else if (githubPath.includes('99_TEMPLATES')) {
+      fileList = TEMPLATE_FILES;
+    } else {
+      // For unknown directories, try to download common files
+      fileList = ['README.md', 'index.md'];
+    }
+    
+    await downloadFileList(githubPath, localPath, fileList, spinner, messages);
+  } catch (error) {
+    throw new Error(`Failed to download directory ${githubPath}: ${error.message}`);
+  }
+}
+
+export {
+  fetchContent,
+  downloadFile,
+  downloadFileList,
+  downloadDirectory,
+  GITHUB_RAW_URL,
+  GITHUB_CONTENT_PREFIX,
+  COMMAND_FILES,
+  GLOBAL_RULES_FILES,
+  MANUAL_RULES_FILES,
+  TEMPLATE_FILES,
+  PROMPT_FILES
+};