claude-code-workflow 6.1.4 → 6.2.1

package/ccw/src/commands/install.js

@@ -1,324 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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/stop.js

@@ -1,101 +0,0 @@
-import chalk from 'chalk';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
-
-/**
- * Find process using a specific port (Windows)
- * @param {number} port - Port number
- * @returns {Promise<string|null>} PID or null
- */
-async function findProcessOnPort(port) {
-  try {
-    const { stdout } = await execAsync(`netstat -ano | findstr :${port} | findstr LISTENING`);
-    const lines = stdout.trim().split('\n');
-    if (lines.length > 0) {
-      const parts = lines[0].trim().split(/\s+/);
-      return parts[parts.length - 1]; // PID is the last column
-    }
-  } catch {
-    // No process found
-  }
-  return null;
-}
-
-/**
- * Kill process by PID (Windows)
- * @param {string} pid - Process ID
- * @returns {Promise<boolean>} Success status
- */
-async function killProcess(pid) {
-  try {
-    await execAsync(`taskkill /PID ${pid} /F`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Stop command handler - stops the running CCW dashboard server
- * @param {Object} options - Command options
- */
-export async function stopCommand(options) {
-  const port = options.port || 3456;
-  const force = options.force || false;
-
-  console.log(chalk.blue.bold('\n  CCW Dashboard\n'));
-  console.log(chalk.gray(`  Checking server on port ${port}...`));
-
-  try {
-    // Try graceful shutdown via API first
-    const healthCheck = await fetch(`http://localhost:${port}/api/health`, {
-      signal: AbortSignal.timeout(2000)
-    }).catch(() => null);
-
-    if (healthCheck && healthCheck.ok) {
-      // CCW server is running - send shutdown signal
-      console.log(chalk.cyan('  CCW server found, sending shutdown signal...'));
-
-      await fetch(`http://localhost:${port}/api/shutdown`, {
-        method: 'POST',
-        signal: AbortSignal.timeout(5000)
-      }).catch(() => null);
-
-      // Wait a moment for shutdown
-      await new Promise(resolve => setTimeout(resolve, 500));
-
-      console.log(chalk.green.bold('\n  Server stopped successfully!\n'));
-      return;
-    }
-
-    // No CCW server responding, check if port is in use
-    const pid = await findProcessOnPort(port);
-
-    if (!pid) {
-      console.log(chalk.yellow(`  No server running on port ${port}\n`));
-      return;
-    }
-
-    // Port is in use by another process
-    console.log(chalk.yellow(`  Port ${port} is in use by process PID: ${pid}`));
-
-    if (force) {
-      console.log(chalk.cyan('  Force killing process...'));
-      const killed = await killProcess(pid);
-
-      if (killed) {
-        console.log(chalk.green.bold('\n  Process killed successfully!\n'));
-      } else {
-        console.log(chalk.red('\n  Failed to kill process. Try running as administrator.\n'));
-      }
-    } else {
-      console.log(chalk.gray(`\n  This is not a CCW server. Use --force to kill it:`));
-      console.log(chalk.white(`  ccw stop --force\n`));
-    }
-
-  } catch (err) {
-    console.error(chalk.red(`\n  Error: ${err.message}\n`));
-  }
-}

package/ccw/src/commands/tool.js

@@ -1,138 +0,0 @@
-/**
- * Tool Command - Execute and manage CCW tools
- */
-
-import chalk from 'chalk';
-import { listTools, executeTool, getTool, getAllToolSchemas } from '../tools/index.js';
-
-/**
- * List all available tools
- */
-async function listAction() {
-  const tools = listTools();
-
-  if (tools.length === 0) {
-    console.log(chalk.yellow('No tools registered'));
-    return;
-  }
-
-  console.log(chalk.bold.cyan('\nAvailable Tools:\n'));
-
-  for (const tool of tools) {
-    console.log(chalk.bold.white(`  ${tool.name}`));
-    console.log(chalk.gray(`    ${tool.description}`));
-
-    if (tool.parameters?.properties) {
-      const props = tool.parameters.properties;
-      const required = tool.parameters.required || [];
-
-      console.log(chalk.gray('    Parameters:'));
-      for (const [name, schema] of Object.entries(props)) {
-        const req = required.includes(name) ? chalk.red('*') : '';
-        const defaultVal = schema.default !== undefined ? chalk.gray(` (default: ${schema.default})`) : '';
-        console.log(chalk.gray(`      - ${name}${req}: ${schema.description}${defaultVal}`));
-      }
-    }
-    console.log();
-  }
-}
-
-/**
- * Show tool schema in MCP-compatible JSON format
- */
-async function schemaAction(options) {
-  const { name } = options;
-
-  if (name) {
-    const tool = getTool(name);
-    if (!tool) {
-      console.error(chalk.red(`Tool not found: ${name}`));
-      process.exit(1);
-    }
-
-    const schema = {
-      name: tool.name,
-      description: tool.description,
-      inputSchema: {
-        type: 'object',
-        properties: tool.parameters?.properties || {},
-        required: tool.parameters?.required || []
-      }
-    };
-    console.log(JSON.stringify(schema, null, 2));
-  } else {
-    const schemas = getAllToolSchemas();
-    console.log(JSON.stringify({ tools: schemas }, null, 2));
-  }
-}
-
-/**
- * Execute a tool with given parameters
- */
-async function execAction(toolName, options) {
-  if (!toolName) {
-    console.error(chalk.red('Tool name is required'));
-    console.error(chalk.gray('Usage: ccw tool exec edit_file --path file.txt --old "old" --new "new"'));
-    process.exit(1);
-  }
-
-  const tool = getTool(toolName);
-  if (!tool) {
-    console.error(chalk.red(`Tool not found: ${toolName}`));
-    console.error(chalk.gray('Use "ccw tool list" to see available tools'));
-    process.exit(1);
-  }
-
-  // Build params from CLI options
-  const params = {};
-
-  if (toolName === 'edit_file') {
-    if (!options.path || !options.old || !options.new) {
-      console.error(chalk.red('edit_file requires --path, --old, and --new parameters'));
-      console.error(chalk.gray('Usage: ccw tool exec edit_file --path file.txt --old "old text" --new "new text"'));
-      process.exit(1);
-    }
-    params.path = options.path;
-    params.oldText = options.old;
-    params.newText = options.new;
-  } else {
-    console.error(chalk.red(`Tool "${toolName}" is not supported via CLI parameters`));
-    console.error(chalk.gray('Currently only edit_file is supported'));
-    process.exit(1);
-  }
-
-  // Execute tool
-  const result = await executeTool(toolName, params);
-
-  // Always output JSON
-  console.log(JSON.stringify(result, null, 2));
-}
-
-/**
- * Tool command entry point
- */
-export async function toolCommand(subcommand, args, options) {
-  // Handle subcommands
-  switch (subcommand) {
-    case 'list':
-      await listAction();
-      break;
-    case 'schema':
-      await schemaAction({ name: args });
-      break;
-    case 'exec':
-      await execAction(args, options);
-      break;
-    default:
-      console.log(chalk.bold.cyan('\nCCW Tool System\n'));
-      console.log('Subcommands:');
-      console.log(chalk.gray('  list              List all available tools'));
-      console.log(chalk.gray('  schema [name]     Show tool schema (JSON)'));
-      console.log(chalk.gray('  exec <name>       Execute a tool'));
-      console.log();
-      console.log('Usage:');
-      console.log(chalk.gray('  ccw tool list'));
-      console.log(chalk.gray('  ccw tool schema edit_file'));
-      console.log(chalk.gray('  ccw tool exec edit_file --path file.txt --old "old text" --new "new text"'));
-  }
-}