claude-code-workflow 6.0.0

package/ccw/src/commands/install.js

@@ -0,0 +1,324 @@
+import { existsSync, mkdirSync, readdirSync, statSync, copyFileSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { showHeader, createSpinner, info, warning, error, summaryBox, divider } from '../utils/ui.js';
+import { createManifest, addFileEntry, addDirectoryEntry, saveManifest, findManifest, getAllManifests } from '../core/manifest.js';
+import { validatePath } from '../utils/path-resolver.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Source directories to install
+const SOURCE_DIRS = ['.claude', '.codex', '.gemini', '.qwen'];
+
+// Get package root directory (ccw/src/commands -> ccw)
+function getPackageRoot() {
+  return join(__dirname, '..', '..');
+}
+
+// Get source installation directory (parent of ccw)
+function getSourceDir() {
+  return join(getPackageRoot(), '..');
+}
+
+/**
+ * Install command handler
+ * @param {Object} options - Command options
+ */
+export async function installCommand(options) {
+  const version = getVersion();
+
+  // Show beautiful header
+  showHeader(version);
+
+  // Check for existing installations
+  const existingManifests = getAllManifests();
+  if (existingManifests.length > 0 && !options.force) {
+    info('Existing installations detected:');
+    console.log('');
+    existingManifests.forEach((m, i) => {
+      console.log(chalk.gray(`  ${i + 1}. ${m.installation_mode} - ${m.installation_path}`));
+      console.log(chalk.gray(`     Installed: ${new Date(m.installation_date).toLocaleDateString()}`));
+    });
+    console.log('');
+
+    const { proceed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'proceed',
+      message: 'Continue with new installation?',
+      default: true
+    }]);
+
+    if (!proceed) {
+      info('Installation cancelled');
+      return;
+    }
+  }
+
+  // Local installation from package source
+  const sourceDir = getSourceDir();
+
+  // Interactive mode selection
+  const mode = options.mode || await selectMode();
+
+  let installPath;
+  if (mode === 'Global') {
+    installPath = homedir();
+    info(`Global installation to: ${installPath}`);
+  } else {
+    const inputPath = options.path || await selectPath();
+
+    // Validate the installation path
+    const pathValidation = validatePath(inputPath, { mustExist: true });
+    if (!pathValidation.valid) {
+      error(`Invalid installation path: ${pathValidation.error}`);
+      process.exit(1);
+    }
+
+    installPath = pathValidation.path;
+    info(`Path installation to: ${installPath}`);
+  }
+
+  // Validate source directories exist
+  const availableDirs = SOURCE_DIRS.filter(dir => existsSync(join(sourceDir, dir)));
+
+  if (availableDirs.length === 0) {
+    error('No source directories found to install.');
+    error(`Expected directories in: ${sourceDir}`);
+    process.exit(1);
+  }
+
+  console.log('');
+  info(`Found ${availableDirs.length} directories to install: ${availableDirs.join(', ')}`);
+  divider();
+
+  // Check for existing installation at target path
+  const existingManifest = findManifest(installPath, mode);
+  if (existingManifest) {
+    warning('Existing installation found at this location');
+    const { backup } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'backup',
+      message: 'Create backup before reinstalling?',
+      default: true
+    }]);
+
+    if (backup) {
+      await createBackup(installPath, existingManifest);
+    }
+  }
+
+  // Create manifest
+  const manifest = createManifest(mode, installPath);
+
+  // Perform installation
+  console.log('');
+  const spinner = createSpinner('Installing files...').start();
+
+  let totalFiles = 0;
+  let totalDirs = 0;
+
+  try {
+    for (const dir of availableDirs) {
+      const srcPath = join(sourceDir, dir);
+      const destPath = join(installPath, dir);
+
+      spinner.text = `Installing ${dir}...`;
+
+      const { files, directories } = await copyDirectory(srcPath, destPath, manifest);
+      totalFiles += files;
+      totalDirs += directories;
+    }
+
+    // Copy CLAUDE.md to .claude directory
+    const claudeMdSrc = join(sourceDir, 'CLAUDE.md');
+    const claudeMdDest = join(installPath, '.claude', 'CLAUDE.md');
+    if (existsSync(claudeMdSrc) && existsSync(dirname(claudeMdDest))) {
+      spinner.text = 'Installing CLAUDE.md...';
+      copyFileSync(claudeMdSrc, claudeMdDest);
+      addFileEntry(manifest, claudeMdDest);
+      totalFiles++;
+    }
+
+    // Create version.json
+    const versionPath = join(installPath, '.claude', 'version.json');
+    if (existsSync(dirname(versionPath))) {
+      const versionData = {
+        version: version,
+        installedAt: new Date().toISOString(),
+        mode: mode,
+        installer: 'ccw'
+      };
+      writeFileSync(versionPath, JSON.stringify(versionData, null, 2), 'utf8');
+      addFileEntry(manifest, versionPath);
+      totalFiles++;
+    }
+
+    spinner.succeed('Installation complete!');
+
+  } catch (err) {
+    spinner.fail('Installation failed');
+    error(err.message);
+    process.exit(1);
+  }
+
+  // Save manifest
+  const manifestPath = saveManifest(manifest);
+
+  // Show summary
+  console.log('');
+  const summaryLines = [
+    chalk.green.bold('✓ Installation Successful'),
+    '',
+    chalk.white(`Mode: ${chalk.cyan(mode)}`),
+    chalk.white(`Path: ${chalk.cyan(installPath)}`),
+    chalk.white(`Version: ${chalk.cyan(version)}`),
+    '',
+    chalk.gray(`Files installed: ${totalFiles}`),
+    chalk.gray(`Directories created: ${totalDirs}`),
+    '',
+    chalk.gray(`Manifest: ${basename(manifestPath)}`)
+  ];
+
+  summaryBox({
+    title: ' Installation Summary ',
+    lines: summaryLines,
+    borderColor: 'green'
+  });
+
+  // Show next steps
+  console.log('');
+  info('Next steps:');
+  console.log(chalk.gray('  1. Restart Claude Code or your IDE'));
+  console.log(chalk.gray('  2. Run: ccw view - to open the workflow dashboard'));
+  console.log(chalk.gray('  3. Run: ccw uninstall - to remove this installation'));
+  console.log('');
+}
+
+/**
+ * Interactive mode selection
+ * @returns {Promise<string>} - Selected mode
+ */
+async function selectMode() {
+  const { mode } = await inquirer.prompt([{
+    type: 'list',
+    name: 'mode',
+    message: 'Select installation mode:',
+    choices: [
+      {
+        name: `${chalk.cyan('Global')} - Install to home directory (recommended)`,
+        value: 'Global'
+      },
+      {
+        name: `${chalk.yellow('Path')} - Install to specific project path`,
+        value: 'Path'
+      }
+    ]
+  }]);
+
+  return mode;
+}
+
+/**
+ * Interactive path selection
+ * @returns {Promise<string>} - Selected path
+ */
+async function selectPath() {
+  const { path } = await inquirer.prompt([{
+    type: 'input',
+    name: 'path',
+    message: 'Enter installation path:',
+    default: process.cwd(),
+    validate: (input) => {
+      if (!input) return 'Path is required';
+      if (!existsSync(input)) {
+        return `Path does not exist: ${input}`;
+      }
+      return true;
+    }
+  }]);
+
+  return path;
+}
+
+/**
+ * Create backup of existing installation
+ * @param {string} installPath - Installation path
+ * @param {Object} manifest - Existing manifest
+ */
+async function createBackup(installPath, manifest) {
+  const spinner = createSpinner('Creating backup...').start();
+
+  try {
+    const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace('T', '-').split('.')[0];
+    const backupDir = join(installPath, `.claude-backup-${timestamp}`);
+
+    mkdirSync(backupDir, { recursive: true });
+
+    // Copy existing .claude directory
+    const claudeDir = join(installPath, '.claude');
+    if (existsSync(claudeDir)) {
+      await copyDirectory(claudeDir, join(backupDir, '.claude'));
+    }
+
+    spinner.succeed(`Backup created: ${backupDir}`);
+  } catch (err) {
+    spinner.warn(`Backup failed: ${err.message}`);
+  }
+}
+
+/**
+ * Copy directory recursively
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ * @param {Object} manifest - Manifest to track files (optional)
+ * @returns {Object} - Count of files and directories
+ */
+async function copyDirectory(src, dest, manifest = null) {
+  let files = 0;
+  let directories = 0;
+
+  // Create destination directory
+  if (!existsSync(dest)) {
+    mkdirSync(dest, { recursive: true });
+    directories++;
+    if (manifest) addDirectoryEntry(manifest, dest);
+  }
+
+  const entries = readdirSync(src);
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      const result = await copyDirectory(srcPath, destPath, manifest);
+      files += result.files;
+      directories += result.directories;
+    } else {
+      copyFileSync(srcPath, destPath);
+      files++;
+      if (manifest) addFileEntry(manifest, destPath);
+    }
+  }
+
+  return { files, directories };
+}
+
+/**
+ * Get package version
+ * @returns {string} - Version string
+ */
+function getVersion() {
+  try {
+    const pkgPath = join(getPackageRoot(), 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return pkg.version || '1.0.0';
+  } catch {
+    return '1.0.0';
+  }
+}

package/ccw/src/commands/list.js

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+import { showBanner, divider, info } from '../utils/ui.js';
+import { getAllManifests } from '../core/manifest.js';
+
+/**
+ * List command handler - shows all installations
+ */
+export async function listCommand() {
+  showBanner();
+  console.log(chalk.cyan.bold('  Installed Claude Code Workflow Instances\n'));
+
+  const manifests = getAllManifests();
+
+  if (manifests.length === 0) {
+    info('No installations found.');
+    console.log('');
+    console.log(chalk.gray('  Run: ccw install - to install Claude Code Workflow'));
+    console.log('');
+    return;
+  }
+
+  manifests.forEach((m, i) => {
+    const modeColor = m.installation_mode === 'Global' ? chalk.cyan : chalk.yellow;
+
+    console.log(chalk.white.bold(`  ${i + 1}. `) + modeColor.bold(m.installation_mode));
+    console.log(chalk.gray(`     Path:    ${m.installation_path}`));
+    console.log(chalk.gray(`     Date:    ${new Date(m.installation_date).toLocaleDateString()}`));
+    console.log(chalk.gray(`     Version: ${m.application_version}`));
+    console.log(chalk.gray(`     Files:   ${m.files_count}`));
+    console.log(chalk.gray(`     Dirs:    ${m.directories_count}`));
+    console.log('');
+  });
+
+  divider();
+  console.log(chalk.gray('  Run: ccw uninstall - to remove an installation'));
+  console.log('');
+}

package/ccw/src/commands/serve.js

@@ -0,0 +1,67 @@
+import { startServer } from '../core/server.js';
+import { launchBrowser } from '../utils/browser-launcher.js';
+import { resolvePath, validatePath } from '../utils/path-resolver.js';
+import chalk from 'chalk';
+
+/**
+ * Serve command handler - starts dashboard server with live path switching
+ * @param {Object} options - Command options
+ */
+export async function serveCommand(options) {
+  const port = options.port || 3456;
+
+  // Validate project path
+  let initialPath = process.cwd();
+  if (options.path) {
+    const pathValidation = validatePath(options.path, { mustExist: true });
+    if (!pathValidation.valid) {
+      console.error(chalk.red(`\n  Error: ${pathValidation.error}\n`));
+      process.exit(1);
+    }
+    initialPath = pathValidation.path;
+  }
+
+  console.log(chalk.blue.bold('\n  CCW Dashboard Server\n'));
+  console.log(chalk.gray(`  Initial project: ${initialPath}`));
+  console.log(chalk.gray(`  Port: ${port}\n`));
+
+  try {
+    // Start server
+    console.log(chalk.cyan('  Starting server...'));
+    const server = await startServer({ port, initialPath });
+
+    const url = `http://localhost:${port}`;
+    console.log(chalk.green(`  Server running at ${url}`));
+
+    // Open browser
+    if (options.browser !== false) {
+      console.log(chalk.cyan('  Opening in browser...'));
+      try {
+        await launchBrowser(url);
+        console.log(chalk.green.bold('\n  Dashboard opened in browser!'));
+      } catch (err) {
+        console.log(chalk.yellow(`\n  Could not open browser: ${err.message}`));
+        console.log(chalk.gray(`  Open manually: ${url}`));
+      }
+    }
+
+    console.log(chalk.gray('\n  Press Ctrl+C to stop the server\n'));
+
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+      console.log(chalk.yellow('\n  Shutting down server...'));
+      server.close(() => {
+        console.log(chalk.green('  Server stopped.\n'));
+        process.exit(0);
+      });
+    });
+
+  } catch (error) {
+    console.error(chalk.red(`\n  Error: ${error.message}\n`));
+    if (error.code === 'EADDRINUSE') {
+      console.error(chalk.yellow(`  Port ${port} is already in use.`));
+      console.error(chalk.gray(`  Try a different port: ccw serve --port ${port + 1}\n`));
+    }
+    process.exit(1);
+  }
+}

package/ccw/src/commands/uninstall.js

@@ -0,0 +1,238 @@
+import { existsSync, unlinkSync, rmdirSync, readdirSync, statSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { showBanner, createSpinner, success, info, warning, error, summaryBox, divider } from '../utils/ui.js';
+import { getAllManifests, deleteManifest } from '../core/manifest.js';
+
+/**
+ * Uninstall command handler
+ * @param {Object} options - Command options
+ */
+export async function uninstallCommand(options) {
+  showBanner();
+  console.log(chalk.cyan.bold('  Uninstall Claude Code Workflow\n'));
+
+  // Get all manifests
+  const manifests = getAllManifests();
+
+  if (manifests.length === 0) {
+    warning('No installations found.');
+    info('Nothing to uninstall.');
+    return;
+  }
+
+  // Display installations
+  console.log(chalk.white.bold('  Found installations:\n'));
+
+  manifests.forEach((m, i) => {
+    const modeColor = m.installation_mode === 'Global' ? chalk.cyan : chalk.yellow;
+    console.log(chalk.white(`  ${i + 1}. `) + modeColor.bold(m.installation_mode));
+    console.log(chalk.gray(`     Path: ${m.installation_path}`));
+    console.log(chalk.gray(`     Date: ${new Date(m.installation_date).toLocaleDateString()}`));
+    console.log(chalk.gray(`     Version: ${m.application_version}`));
+    console.log(chalk.gray(`     Files: ${m.files_count} | Dirs: ${m.directories_count}`));
+    console.log('');
+  });
+
+  divider();
+
+  // Select installation to uninstall
+  let selectedManifest;
+
+  if (manifests.length === 1) {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Uninstall ${manifests[0].installation_mode} installation at ${manifests[0].installation_path}?`,
+      default: false
+    }]);
+
+    if (!confirm) {
+      info('Uninstall cancelled');
+      return;
+    }
+
+    selectedManifest = manifests[0];
+  } else {
+    const choices = manifests.map((m, i) => ({
+      name: `${m.installation_mode} - ${m.installation_path}`,
+      value: i
+    }));
+
+    choices.push({ name: chalk.gray('Cancel'), value: -1 });
+
+    const { selection } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selection',
+      message: 'Select installation to uninstall:',
+      choices
+    }]);
+
+    if (selection === -1) {
+      info('Uninstall cancelled');
+      return;
+    }
+
+    selectedManifest = manifests[selection];
+
+    // Confirm selection
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Are you sure you want to uninstall ${selectedManifest.installation_mode} installation?`,
+      default: false
+    }]);
+
+    if (!confirm) {
+      info('Uninstall cancelled');
+      return;
+    }
+  }
+
+  console.log('');
+
+  // Perform uninstallation
+  const spinner = createSpinner('Removing files...').start();
+
+  let removedFiles = 0;
+  let removedDirs = 0;
+  let failedFiles = [];
+
+  try {
+    // Remove files first (in reverse order to handle nested files)
+    const files = [...(selectedManifest.files || [])].reverse();
+
+    for (const fileEntry of files) {
+      const filePath = fileEntry.path;
+      spinner.text = `Removing: ${basename(filePath)}`;
+
+      try {
+        if (existsSync(filePath)) {
+          unlinkSync(filePath);
+          removedFiles++;
+        }
+      } catch (err) {
+        failedFiles.push({ path: filePath, error: err.message });
+      }
+    }
+
+    // Remove directories (in reverse order to remove nested dirs first)
+    const directories = [...(selectedManifest.directories || [])].reverse();
+
+    // Sort by path length (deepest first)
+    directories.sort((a, b) => b.path.length - a.path.length);
+
+    for (const dirEntry of directories) {
+      const dirPath = dirEntry.path;
+      spinner.text = `Removing directory: ${basename(dirPath)}`;
+
+      try {
+        if (existsSync(dirPath)) {
+          // Only remove if empty
+          const contents = readdirSync(dirPath);
+          if (contents.length === 0) {
+            rmdirSync(dirPath);
+            removedDirs++;
+          }
+        }
+      } catch (err) {
+        // Ignore directory removal errors (might not be empty)
+      }
+    }
+
+    // Try to clean up parent directories if empty
+    const installPath = selectedManifest.installation_path;
+    for (const dir of ['.claude', '.codex', '.gemini', '.qwen']) {
+      const dirPath = join(installPath, dir);
+      try {
+        if (existsSync(dirPath)) {
+          await removeEmptyDirs(dirPath);
+        }
+      } catch {
+        // Ignore
+      }
+    }
+
+    spinner.succeed('Uninstall complete!');
+
+  } catch (err) {
+    spinner.fail('Uninstall failed');
+    error(err.message);
+    return;
+  }
+
+  // Delete manifest
+  deleteManifest(selectedManifest.manifest_file);
+
+  // Show summary
+  console.log('');
+
+  if (failedFiles.length > 0) {
+    summaryBox({
+      title: ' Uninstall Summary ',
+      lines: [
+        chalk.yellow.bold('⚠ Partially Completed'),
+        '',
+        chalk.white(`Files removed: ${chalk.green(removedFiles)}`),
+        chalk.white(`Directories removed: ${chalk.green(removedDirs)}`),
+        chalk.white(`Failed: ${chalk.red(failedFiles.length)}`),
+        '',
+        chalk.gray('Some files could not be removed.'),
+        chalk.gray('They may be in use or require elevated permissions.'),
+      ],
+      borderColor: 'yellow'
+    });
+
+    if (process.env.DEBUG) {
+      console.log('');
+      console.log(chalk.gray('Failed files:'));
+      failedFiles.forEach(f => {
+        console.log(chalk.red(`  ${f.path}: ${f.error}`));
+      });
+    }
+  } else {
+    summaryBox({
+      title: ' Uninstall Summary ',
+      lines: [
+        chalk.green.bold('✓ Successfully Uninstalled'),
+        '',
+        chalk.white(`Files removed: ${chalk.green(removedFiles)}`),
+        chalk.white(`Directories removed: ${chalk.green(removedDirs)}`),
+        '',
+        chalk.gray('Manifest removed'),
+      ],
+      borderColor: 'green'
+    });
+  }
+
+  console.log('');
+}
+
+/**
+ * Recursively remove empty directories
+ * @param {string} dirPath - Directory path
+ */
+async function removeEmptyDirs(dirPath) {
+  if (!existsSync(dirPath)) return;
+
+  const stat = statSync(dirPath);
+  if (!stat.isDirectory()) return;
+
+  let files = readdirSync(dirPath);
+
+  // Recursively check subdirectories
+  for (const file of files) {
+    const filePath = join(dirPath, file);
+    if (statSync(filePath).isDirectory()) {
+      await removeEmptyDirs(filePath);
+    }
+  }
+
+  // Re-check after processing subdirectories
+  files = readdirSync(dirPath);
+  if (files.length === 0) {
+    rmdirSync(dirPath);
+  }
+}
+