claude-cli-advanced-starter-pack 1.0.16 → 1.8.0

package/src/commands/install-scripts.js

@@ -0,0 +1,232 @@
+/**
+ * Install Scripts Command
+ *
+ * Copies utility scripts from templates to project's .claude/scripts/ directory.
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { existsSync, mkdirSync, readdirSync, copyFileSync, readFileSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { showHeader } from '../cli/menu.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, '../../templates/scripts');
+
+/**
+ * Available scripts with descriptions
+ */
+const SCRIPTS = [
+  {
+    id: 'validate-deployment',
+    file: 'validate-deployment.js',
+    name: 'Deployment Validator',
+    description: 'Pre-deployment environment validation for Railway, Cloudflare, Vercel',
+    category: 'deployment',
+  },
+  {
+    id: 'poll-deployment-status',
+    file: 'poll-deployment-status.js',
+    name: 'Deployment Poller',
+    description: 'Poll deployment status until complete or timeout',
+    category: 'deployment',
+  },
+  {
+    id: 'roadmap-scanner',
+    file: 'roadmap-scanner.js',
+    name: 'Roadmap Scanner',
+    description: 'Multi-roadmap progress dashboard',
+    category: 'project',
+  },
+  {
+    id: 'analyze-delegation-log',
+    file: 'analyze-delegation-log.js',
+    name: 'Delegation Log Analyzer',
+    description: 'Analyze Claude Code model usage and token consumption',
+    category: 'analysis',
+  },
+  {
+    id: 'autonomous-decision-logger',
+    file: 'autonomous-decision-logger.js',
+    name: 'Decision Logger',
+    description: 'JSONL audit trail for agent decisions',
+    category: 'logging',
+  },
+  {
+    id: 'phase-validation-gates',
+    file: 'phase-validation-gates.js',
+    name: 'Phase Validation Gates',
+    description: '5-gate validation (EXIST, INIT, REGISTER, INVOKE, PROPAGATE)',
+    category: 'phased-dev',
+  },
+  {
+    id: 'git-history-analyzer',
+    file: 'git-history-analyzer.py',
+    name: 'Git History Analyzer',
+    description: 'Security audit for sensitive data in git history (Python)',
+    category: 'security',
+  },
+];
+
+/**
+ * Run the install-scripts command
+ */
+export async function runInstallScripts(options = {}) {
+  showHeader('Install Utility Scripts');
+
+  console.log(chalk.dim('Copy utility scripts to .claude/scripts/ for project use.\n'));
+
+  const targetDir = join(process.cwd(), '.claude/scripts');
+
+  // Show available scripts
+  if (options.list) {
+    return showScriptList();
+  }
+
+  // Interactive selection
+  const { selections } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selections',
+      message: 'Select scripts to install:',
+      choices: SCRIPTS.map((script) => {
+        const installed = existsSync(join(targetDir, script.file));
+        const status = installed ? chalk.green(' [installed]') : '';
+
+        return {
+          name: `${script.name}${status}\n   ${chalk.dim(script.description)}`,
+          value: script.id,
+          short: script.name,
+          checked: !installed,
+        };
+      }),
+      pageSize: 10,
+    },
+  ]);
+
+  if (selections.length === 0) {
+    console.log(chalk.yellow('\nNo scripts selected.'));
+    return;
+  }
+
+  // Create target directory
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+    console.log(chalk.dim(`Created ${targetDir}`));
+  }
+
+  // Copy selected scripts
+  const spinner = ora('Installing scripts...').start();
+  const results = [];
+
+  for (const scriptId of selections) {
+    const script = SCRIPTS.find((s) => s.id === scriptId);
+    if (!script) continue;
+
+    try {
+      const sourcePath = join(TEMPLATES_DIR, script.file);
+      const targetPath = join(targetDir, script.file);
+
+      if (!existsSync(sourcePath)) {
+        results.push({ script, success: false, error: 'Template not found' });
+        continue;
+      }
+
+      copyFileSync(sourcePath, targetPath);
+      results.push({ script, success: true });
+    } catch (error) {
+      results.push({ script, success: false, error: error.message });
+    }
+  }
+
+  spinner.stop();
+
+  // Copy README if not exists
+  const readmePath = join(targetDir, 'README.md');
+  if (!existsSync(readmePath)) {
+    try {
+      const sourceReadme = join(TEMPLATES_DIR, 'README.md');
+      if (existsSync(sourceReadme)) {
+        copyFileSync(sourceReadme, readmePath);
+      }
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  // Display results
+  console.log(chalk.cyan.bold('\n📋 Installation Results\n'));
+
+  const successful = results.filter((r) => r.success);
+  const failed = results.filter((r) => !r.success);
+
+  if (successful.length > 0) {
+    console.log(chalk.green('✓ Installed:'));
+    for (const result of successful) {
+      console.log(`  - ${result.script.name}`);
+    }
+  }
+
+  if (failed.length > 0) {
+    console.log(chalk.red('\n✗ Failed:'));
+    for (const result of failed) {
+      console.log(`  - ${result.script.name}: ${result.error}`);
+    }
+  }
+
+  // Show usage tips
+  if (successful.length > 0) {
+    console.log(chalk.cyan('\n📚 Usage Tips\n'));
+    console.log(chalk.dim(`Scripts installed to: ${targetDir}\n`));
+
+    for (const result of successful) {
+      const script = result.script;
+      if (script.file.endsWith('.js')) {
+        console.log(chalk.white(`${script.name}:`));
+        console.log(chalk.dim(`  node .claude/scripts/${script.file} --help`));
+      } else if (script.file.endsWith('.py')) {
+        console.log(chalk.white(`${script.name}:`));
+        console.log(chalk.dim(`  python .claude/scripts/${script.file} --help`));
+      }
+      console.log('');
+    }
+  }
+}
+
+/**
+ * Show list of available scripts
+ */
+function showScriptList() {
+  const targetDir = join(process.cwd(), '.claude/scripts');
+
+  console.log(chalk.cyan.bold('Available Scripts\n'));
+
+  // Group by category
+  const categories = {};
+  for (const script of SCRIPTS) {
+    if (!categories[script.category]) {
+      categories[script.category] = [];
+    }
+    categories[script.category].push(script);
+  }
+
+  for (const [category, scripts] of Object.entries(categories)) {
+    const categoryName = category.charAt(0).toUpperCase() + category.slice(1);
+    console.log(chalk.white.bold(`\n${categoryName}:`));
+
+    for (const script of scripts) {
+      const installed = existsSync(join(targetDir, script.file));
+      const status = installed ? chalk.green(' [installed]') : '';
+
+      console.log(`  ${script.name}${status}`);
+      console.log(chalk.dim(`    ${script.description}`));
+      console.log(chalk.dim(`    File: ${script.file}`));
+    }
+  }
+
+  console.log('');
+}
+
+export default runInstallScripts;

package/src/commands/install-skill.js

@@ -0,0 +1,220 @@
+/**
+ * Install Skill Command
+ *
+ * Install individual skills to a project's .claude/skills/ folder
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, cpSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { showHeader, showSuccess, showError, showWarning, showInfo } from '../cli/menu.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Skills directory in the package
+const SKILLS_DIR = join(__dirname, '..', '..', 'templates', 'skills');
+
+/**
+ * Get available skills from the package
+ */
+function getAvailableSkills() {
+  const skills = [];
+
+  try {
+    if (!existsSync(SKILLS_DIR)) {
+      return skills;
+    }
+
+    const dirs = readdirSync(SKILLS_DIR, { withFileTypes: true });
+
+    for (const dir of dirs) {
+      if (dir.isDirectory()) {
+        const manifestPath = join(SKILLS_DIR, dir.name, 'skill.json');
+        const skillPath = join(SKILLS_DIR, dir.name, 'skill.md');
+
+        if (existsSync(manifestPath) && existsSync(skillPath)) {
+          try {
+            const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+            skills.push({
+              name: manifest.name || dir.name,
+              description: manifest.description || 'No description',
+              category: manifest.category || 'general',
+              portability: manifest.portability || 100,
+              directory: dir.name,
+            });
+          } catch (e) {
+            // Skip invalid manifests
+          }
+        }
+      }
+    }
+  } catch (e) {
+    // Return empty array on error
+  }
+
+  return skills;
+}
+
+/**
+ * Get installed skills in a project
+ */
+function getInstalledSkills(projectPath) {
+  const skillsDir = join(projectPath, '.claude', 'skills');
+  const installed = [];
+
+  try {
+    if (!existsSync(skillsDir)) {
+      return installed;
+    }
+
+    const dirs = readdirSync(skillsDir, { withFileTypes: true });
+
+    for (const dir of dirs) {
+      if (dir.isDirectory()) {
+        const skillPath = join(skillsDir, dir.name, 'skill.md');
+        if (existsSync(skillPath)) {
+          installed.push(dir.name);
+        }
+      }
+    }
+  } catch (e) {
+    // Return empty array on error
+  }
+
+  return installed;
+}
+
+/**
+ * Install a skill to the project
+ */
+function installSkill(skillName, projectPath) {
+  const sourcePath = join(SKILLS_DIR, skillName);
+  const targetPath = join(projectPath, '.claude', 'skills', skillName);
+
+  // Create target directory
+  mkdirSync(targetPath, { recursive: true });
+
+  // Copy all files recursively
+  cpSync(sourcePath, targetPath, { recursive: true });
+
+  return true;
+}
+
+/**
+ * Main install-skill command
+ */
+export async function installSkillCommand(options = {}) {
+  const projectPath = options.project || process.cwd();
+
+  showHeader();
+
+  console.log(chalk.cyan('\n  Install Skills\n'));
+
+  // Check if .claude directory exists
+  const claudeDir = join(projectPath, '.claude');
+  if (!existsSync(claudeDir)) {
+    showError('No .claude directory found. Run `ccasp init` first.');
+    return;
+  }
+
+  // Get available and installed skills
+  const availableSkills = getAvailableSkills();
+  const installedSkills = getInstalledSkills(projectPath);
+
+  if (availableSkills.length === 0) {
+    showWarning('No skills available in the package.');
+    return;
+  }
+
+  // Show skill list
+  console.log(chalk.white('  Available Skills:\n'));
+
+  for (const skill of availableSkills) {
+    const installed = installedSkills.includes(skill.directory);
+    const status = installed ? chalk.green('✓ installed') : chalk.gray('not installed');
+
+    console.log(
+      `  ${chalk.cyan(skill.name.padEnd(20))} ${status}`
+    );
+    console.log(
+      `    ${chalk.gray(skill.description)}`
+    );
+    console.log();
+  }
+
+  // Filter to uninstalled skills
+  const uninstalledSkills = availableSkills.filter(
+    (s) => !installedSkills.includes(s.directory)
+  );
+
+  if (uninstalledSkills.length === 0) {
+    showSuccess('All available skills are already installed!');
+    return;
+  }
+
+  // Ask which skills to install
+  const { selectedSkills } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedSkills',
+      message: 'Select skills to install:',
+      choices: uninstalledSkills.map((skill) => ({
+        name: `${skill.name} - ${skill.description}`,
+        value: skill.directory,
+        checked: false,
+      })),
+    },
+  ]);
+
+  if (selectedSkills.length === 0) {
+    showInfo('No skills selected.');
+    return;
+  }
+
+  // Install selected skills
+  const spinner = ora('Installing skills...').start();
+
+  try {
+    for (const skillName of selectedSkills) {
+      spinner.text = `Installing ${skillName}...`;
+      installSkill(skillName, projectPath);
+    }
+
+    spinner.succeed(`Installed ${selectedSkills.length} skill(s)`);
+
+    console.log(chalk.green('\n  ✓ Skills installed successfully!\n'));
+
+    console.log(chalk.yellow('  To use a skill, restart Claude Code CLI and use:'));
+    for (const skillName of selectedSkills) {
+      console.log(chalk.cyan(`    skill: "${skillName}"`));
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail('Installation failed');
+    showError(`Error: ${error.message}`);
+  }
+}
+
+/**
+ * List available skills (non-interactive)
+ */
+export function listSkills() {
+  const skills = getAvailableSkills();
+
+  console.log(chalk.cyan('\n  Available CCASP Skills:\n'));
+
+  for (const skill of skills) {
+    console.log(`  ${chalk.white(skill.name)}`);
+    console.log(`    ${chalk.gray(skill.description)}`);
+    console.log(`    Category: ${chalk.yellow(skill.category)} | Portability: ${chalk.green(skill.portability + '%')}`);
+    console.log();
+  }
+
+  return skills;
+}
+
+export default installSkillCommand;