ai-sprint-kit 2.0.4 → 2.1.0

package/lib/recovery.js

@@ -0,0 +1,279 @@
+const fs = require('fs/promises');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+/**
+ * Detect incomplete/partial installation
+ */
+async function detectPartialInstallation(targetDir) {
+  const checks = {
+    hasClaudeDir: false,
+    hasAgents: false,
+    hasCommands: false,
+    hasSettings: false,
+    hasClaudeMd: false,
+    hasTempDir: false
+  };
+
+  // Check .claude directory
+  const claudeDir = path.join(targetDir, '.claude');
+  try {
+    await fs.access(claudeDir);
+    checks.hasClaudeDir = true;
+  } catch {}
+
+  // Check agents
+  const agentsDir = path.join(claudeDir, 'agents');
+  try {
+    const files = await fs.readdir(agentsDir);
+    checks.hasAgents = files.filter(f => f.endsWith('.md')).length >= 5;
+  } catch {}
+
+  // Check commands
+  const commandsDir = path.join(claudeDir, 'commands');
+  try {
+    const files = await fs.readdir(commandsDir);
+    checks.hasCommands = files.filter(f => f.endsWith('.md')).length >= 8;
+  } catch {}
+
+  // Check settings
+  const settingsPath = path.join(claudeDir, 'settings.json');
+  try {
+    await fs.access(settingsPath);
+    checks.hasSettings = true;
+  } catch {}
+
+  // Check CLAUDE.md
+  const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
+  try {
+    await fs.access(claudeMdPath);
+    checks.hasClaudeMd = true;
+  } catch {}
+
+  // Check temp directory (sign of failed install)
+  const tempDir = path.join(targetDir, '.ai-sprint-temp');
+  try {
+    await fs.access(tempDir);
+    checks.hasTempDir = true;
+  } catch {}
+
+  // Determine if installation is partial
+  const passedChecks = Object.values(checks).filter(Boolean).length;
+  const isPartial = passedChecks > 0 && passedChecks < 6;
+
+  return {
+    isPartial,
+    isComplete: passedChecks === 6,
+    isEmpty: passedChecks === 0,
+    checks,
+    passedChecks
+  };
+}
+
+/**
+ * Clean up temporary files from failed installations
+ */
+async function cleanupTempFiles(targetDir) {
+  const tempDirs = [
+    '.ai-sprint-temp',
+    '.ai-sprint-temp-update',
+    '.ai-sprint-backup'
+  ];
+
+  const cleaned = [];
+
+  for (const dir of tempDirs) {
+    const dirPath = path.join(targetDir, dir);
+    try {
+      await fs.access(dirPath);
+      await fs.rm(dirPath, { recursive: true, force: true });
+      cleaned.push(dir);
+    } catch {}
+  }
+
+  return cleaned;
+}
+
+/**
+ * Repair installation by fixing missing components
+ */
+async function repairInstallation(targetDir) {
+  const { cloneProRepo, copyProContent, cleanup } = require('./installer');
+
+  // Step 1: Detect issues
+  const diagnosis = await detectPartialInstallation(targetDir);
+
+  // Step 2: Clean temp files
+  const cleaned = await cleanupTempFiles(targetDir);
+
+  // Step 3: Clone latest version
+  const tempDir = await cloneProRepo(targetDir);
+
+  try {
+    // Step 4: Copy missing files (force=true to overwrite broken files)
+    await copyProContent(tempDir, targetDir, { force: true });
+
+    // Step 5: Cleanup
+    await cleanup(targetDir);
+
+    return {
+      success: true,
+      diagnosis,
+      cleaned,
+      message: 'Installation repaired successfully'
+    };
+  } catch (error) {
+    // Cleanup on failure
+    await cleanup(targetDir);
+    throw error;
+  }
+}
+
+/**
+ * Perform clean reinstall
+ */
+async function reinstallInstallation(targetDir) {
+  const { cloneProRepo, copyProContent, cleanup, checkExisting } = require('./installer');
+
+  // Step 1: Remove existing installation
+  const claudeDir = path.join(targetDir, '.claude');
+  const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
+  const aiContextDir = path.join(targetDir, 'ai_context');
+
+  const removed = [];
+
+  try {
+    await fs.access(claudeDir);
+    await fs.rm(claudeDir, { recursive: true, force: true });
+    removed.push('.claude/');
+  } catch {}
+
+  try {
+    await fs.access(claudeMdPath);
+    await fs.rm(claudeMdPath);
+    removed.push('CLAUDE.md');
+  } catch {}
+
+  try {
+    await fs.access(aiContextDir);
+    await fs.rm(aiContextDir, { recursive: true, force: true });
+    removed.push('ai_context/');
+  } catch {}
+
+  // Step 2: Clean temp files
+  const cleaned = await cleanupTempFiles(targetDir);
+
+  // Step 3: Fresh install
+  const tempDir = await cloneProRepo(targetDir);
+
+  try {
+    await copyProContent(tempDir, targetDir, { force: false });
+    await cleanup(targetDir);
+
+    return {
+      success: true,
+      removed,
+      cleaned,
+      message: 'Clean reinstall completed'
+    };
+  } catch (error) {
+    await cleanup(targetDir);
+    throw error;
+  }
+}
+
+/**
+ * Diagnose installation issues
+ */
+async function diagnoseIssues(targetDir) {
+  const issues = [];
+  const suggestions = [];
+
+  // Check temp directories
+  const tempDir = path.join(targetDir, '.ai-sprint-temp');
+  try {
+    await fs.access(tempDir);
+    issues.push('Temporary installation directory exists');
+    suggestions.push('Run: ai-sprint repair (or manually remove .ai-sprint-temp)');
+  } catch {}
+
+  // Check .claude directory
+  const claudeDir = path.join(targetDir, '.claude');
+  try {
+    const stat = await fs.stat(claudeDir);
+    if (!stat.isDirectory()) {
+      issues.push('.claude exists but is not a directory');
+      suggestions.push('Remove the .claude file and run: ai-sprint init');
+    }
+  } catch {
+    issues.push('.claude directory missing');
+    suggestions.push('Run: ai-sprint init');
+  }
+
+  // Check if CLAUDE.md is valid
+  const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
+  try {
+    const content = await fs.readFile(claudeMdPath, 'utf8');
+    if (!content.includes('AI Sprint') && !content.includes('Claude Code')) {
+      issues.push('CLAUDE.md exists but may not be AI Sprint Kit');
+      suggestions.push('Run: ai-sprint reinstall');
+    }
+  } catch {
+    issues.push('CLAUDE.md missing');
+    suggestions.push('Run: ai-sprint init or ai-sprint repair');
+  }
+
+  // Check permissions
+  try {
+    await fs.access(claudeDir, fs.constants.W_OK);
+  } catch {
+    issues.push('No write permission to .claude directory');
+    suggestions.push('Fix permissions: chmod +w .claude');
+  }
+
+  return { issues, suggestions };
+}
+
+/**
+ * Get recovery options based on installation state
+ */
+async function getRecoveryOptions(targetDir) {
+  const diagnosis = await detectPartialInstallation(targetDir);
+  const issues = await diagnoseIssues(targetDir);
+
+  const options = {
+    canRepair: false,
+    canReinstall: false,
+    recommended: null
+  };
+
+  if (diagnosis.isEmpty) {
+    options.canReinstall = true;
+    options.recommended = 'init';
+  } else if (diagnosis.isPartial) {
+    options.canRepair = true;
+    options.canReinstall = true;
+    options.recommended = 'repair';
+  } else if (diagnosis.isComplete && issues.issues.length > 0) {
+    options.canRepair = true;
+    options.canReinstall = true;
+    options.recommended = 'repair';
+  } else if (diagnosis.isComplete) {
+    options.recommended = 'validate';
+  }
+
+  return {
+    diagnosis,
+    issues,
+    options
+  };
+}
+
+module.exports = {
+  detectPartialInstallation,
+  cleanupTempFiles,
+  repairInstallation,
+  reinstallInstallation,
+  diagnoseIssues,
+  getRecoveryOptions
+};

package/lib/updater.js

@@ -0,0 +1,340 @@
+const fs = require('fs/promises');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const semver = require('semver');
+
+/**
+ * Get installed version from CLAUDE.md
+ */
+async function getInstalledVersion(targetDir) {
+  const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
+  try {
+    const content = await fs.readFile(claudeMdPath, 'utf8');
+    const match = content.match(/Version:\s*(\d+\.\d+\.\d+)/);
+    if (match) {
+      return match[1];
+    }
+  } catch {
+    // CLAUDE.md might not exist or be unreadable
+  }
+  return null;
+}
+
+/**
+ * Get latest version from GitHub repository
+ */
+async function getLatestVersion() {
+  try {
+    // Use gh CLI to get latest release tag
+    const output = execFileSync('gh', [
+      'release',
+      'list',
+      '--repo', 'apiasak/ai-sprint-pro',
+      '--limit', '1'
+    ], { encoding: 'utf8' });
+
+    // Output format: "v2.0.0 Release title"
+    const match = output.trim().match(/^v(\d+\.\d+\.\d+)/);
+    if (match) {
+      return match[1];
+    }
+  } catch (error) {
+    throw new Error('Failed to fetch latest version from GitHub');
+  }
+  return null;
+}
+
+/**
+ * Check if update is available
+ */
+async function checkUpdate(targetDir = process.cwd()) {
+  const installed = await getInstalledVersion(targetDir);
+  const latest = await getLatestVersion();
+
+  if (!installed) {
+    return {
+      hasUpdate: false,
+      installed: null,
+      latest,
+      message: 'Unable to determine installed version'
+    };
+  }
+
+  if (!latest) {
+    return {
+      hasUpdate: false,
+      installed,
+      latest: null,
+      message: 'Unable to fetch latest version'
+    };
+  }
+
+  const hasUpdate = semver.gt(latest, installed);
+
+  return {
+    hasUpdate,
+    installed,
+    latest,
+    message: hasUpdate
+      ? `Update available: ${installed} → ${latest}`
+      : `Already up to date (${installed})`
+  };
+}
+
+/**
+ * Backup configuration files
+ */
+async function backupConfig(targetDir) {
+  const backupDir = path.join(targetDir, '.ai-sprint-backup');
+  const configFiles = [
+    '.claude/settings.json',
+    '.claude/.env',
+    '.mcp.json'
+  ];
+
+  try {
+    // Create backup directory
+    await fs.mkdir(backupDir, { recursive: true });
+
+    // Copy each config file if it exists
+    for (const file of configFiles) {
+      const sourcePath = path.join(targetDir, file);
+      const backupPath = path.join(backupDir, path.basename(file));
+
+      try {
+        await fs.copyFile(sourcePath, backupPath);
+      } catch {
+        // File doesn't exist, skip
+      }
+    }
+
+    return backupDir;
+  } catch (error) {
+    throw new Error(`Failed to backup config: ${error.message}`);
+  }
+}
+
+/**
+ * Restore configuration files from backup
+ */
+async function restoreConfig(targetDir, backupDir) {
+  const configFiles = [
+    ['settings.json', '.claude/settings.json'],
+    ['.env', '.claude/.env'],
+    ['.mcp.json', '.mcp.json']
+  ];
+
+  try {
+    for (const [backupFile, targetFile] of configFiles) {
+      const sourcePath = path.join(backupDir, backupFile);
+      const destPath = path.join(targetDir, targetFile);
+
+      try {
+        await fs.copyFile(sourcePath, destPath);
+      } catch {
+        // Backup file doesn't exist, skip
+      }
+    }
+  } catch (error) {
+    throw new Error(`Failed to restore config: ${error.message}`);
+  }
+}
+
+/**
+ * Get changelog between versions
+ */
+async function getChangelog(fromVersion, toVersion) {
+  try {
+    const output = execFileSync('gh', [
+      'release',
+      'view',
+      `v${toVersion}`,
+      '--repo', 'apiasak/ai-sprint-pro',
+      '--json', 'body'
+    ], { encoding: 'utf8' });
+
+    const data = JSON.parse(output);
+    return data.body || 'No changelog available';
+  } catch {
+    return 'Changelog not available';
+  }
+}
+
+/**
+ * Update AI Sprint Kit installation
+ */
+async function updateInstallation(targetDir = process.cwd(), options = {}) {
+  const {
+    force = false,
+    backup = true
+  } = options;
+
+  // Step 1: Check for updates
+  const updateInfo = await checkUpdate(targetDir);
+
+  if (!updateInfo.hasUpdate && !force) {
+    return {
+      success: false,
+      message: updateInfo.message,
+      installed: updateInfo.installed,
+      latest: updateInfo.latest
+    };
+  }
+
+  // Step 2: Backup config
+  let backupDir = null;
+  if (backup) {
+    backupDir = await backupConfig(targetDir);
+  }
+
+  // Step 3: Clone latest version to temp directory
+  const tempDir = path.join(targetDir, '.ai-sprint-temp-update');
+
+  try {
+    // Remove temp dir if exists
+    await fs.rm(tempDir, { recursive: true, force: true });
+
+    // Clone latest version
+    execFileSync('git', [
+      'clone',
+      '--depth', '1',
+      '--branch', `v${updateInfo.latest}`,
+      'git@github.com:apiasak/ai-sprint-pro.git',
+      tempDir
+    ], { stdio: 'pipe' });
+
+    // Step 4: Copy new files (similar to installer.js)
+    await copyProContent(tempDir, targetDir, { force: true });
+
+    // Step 5: Restore config
+    if (backup && backupDir) {
+      await restoreConfig(targetDir, backupDir);
+    }
+
+    // Step 6: Get changelog
+    const changelog = await getChangelog(updateInfo.installed, updateInfo.latest);
+
+    // Step 7: Cleanup
+    await fs.rm(tempDir, { recursive: true, force: true });
+    if (backupDir) {
+      await fs.rm(backupDir, { recursive: true, force: true });
+    }
+
+    return {
+      success: true,
+      message: `Updated from ${updateInfo.installed} to ${updateInfo.latest}`,
+      from: updateInfo.installed,
+      to: updateInfo.latest,
+      changelog
+    };
+  } catch (error) {
+    // Cleanup on failure
+    await fs.rm(tempDir, { recursive: true, force: true });
+    if (backupDir) {
+      await fs.rm(backupDir, { recursive: true, force: true });
+    }
+
+    throw new Error(`Update failed: ${error.message}`);
+  }
+}
+
+/**
+ * Copy pro content (from installer.js, reused here)
+ */
+async function copyProContent(sourceDir, targetDir, options = {}) {
+  const { force = false } = options;
+
+  const itemsToCopy = [
+    { src: '.claude', dest: '.claude' },
+    { src: 'ai_context', dest: 'ai_context' },
+    { src: 'CLAUDE.md', dest: 'CLAUDE.md' },
+    { src: 'docs', dest: '.claude/docs' }
+  ];
+
+  for (const item of itemsToCopy) {
+    const sourcePath = path.join(sourceDir, item.src);
+    const destPath = path.join(targetDir, item.dest);
+
+    try {
+      const stat = await fs.stat(sourcePath);
+
+      if (stat.isDirectory()) {
+        await copyDirectory(sourcePath, destPath, force);
+      } else {
+        await copyFile(sourcePath, destPath, force);
+      }
+    } catch (error) {
+      throw new Error(`Failed to copy ${item.src}: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Copy directory recursively
+ */
+async function copyDirectory(src, dest, force) {
+  const exists = await fileExists(dest);
+
+  if (exists && !force) {
+    return; // Skip if exists and not forcing
+  }
+
+  if (exists && force) {
+    await fs.rm(dest, { recursive: true, force: true });
+  }
+
+  await fs.mkdir(dest, { recursive: true });
+
+  const entries = await fs.readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath, force);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Copy single file with force option
+ */
+async function copyFile(src, dest, force) {
+  const exists = await fileExists(dest);
+
+  if (exists && !force) {
+    return;
+  }
+
+  if (exists && force) {
+    await fs.rm(dest);
+  }
+
+  await fs.copyFile(src, dest);
+}
+
+/**
+ * Check if file exists
+ */
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  getInstalledVersion,
+  getLatestVersion,
+  checkUpdate,
+  backupConfig,
+  restoreConfig,
+  getChangelog,
+  updateInstallation,
+  copyProContent
+};