claude-cli-advanced-starter-pack 1.0.0

package/src/commands/create-command.js

@@ -0,0 +1,337 @@
+/**
+ * Create Command
+ *
+ * Interactive wizard for creating Claude Code slash commands
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { showHeader, showSuccess, showError, showWarning, showInfo } from '../cli/menu.js';
+import { generateCommandTemplate, COMPLEXITY_LEVELS } from '../agents/templates.js';
+
+/**
+ * Run the create-command wizard
+ */
+export async function runCreateCommand(options) {
+  showHeader('Create Slash Command');
+
+  console.log(chalk.dim('Slash commands are invoked with / in Claude Code.'));
+  console.log(chalk.dim('They can delegate to skills, agents, or run standalone.\n'));
+
+  // Step 1: Command name
+  const { name } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Command name (without /):',
+      default: options.name || 'my-command',
+      validate: (input) => {
+        if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+          return 'Use kebab-case (lowercase letters, numbers, hyphens)';
+        }
+        return true;
+      },
+    },
+  ]);
+
+  // Step 2: Description
+  const { description } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Brief description (shown in menus):',
+      default: `Run ${name} workflow`,
+      validate: (input) => input.length > 0 || 'Description is required',
+    },
+  ]);
+
+  // Step 3: Complexity
+  console.log('');
+  console.log(chalk.cyan.bold('Complexity Levels:'));
+  Object.entries(COMPLEXITY_LEVELS).forEach(([key, level]) => {
+    console.log(chalk.dim(`  ${level.name}: ${level.description} (${level.duration})`));
+  });
+  console.log('');
+
+  const { complexity } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'complexity',
+      message: 'Expected complexity:',
+      choices: Object.entries(COMPLEXITY_LEVELS).map(([key, level]) => ({
+        name: `${level.name} - ${level.description}`,
+        value: key,
+        short: level.name,
+      })),
+      default: 'low',
+    },
+  ]);
+
+  // Step 4: Delegation
+  const { delegationType } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'delegationType',
+      message: 'What does this command use?',
+      choices: [
+        { name: 'Standalone - No delegation, instructions only', value: 'standalone' },
+        { name: 'Skill - Delegates to a skill package', value: 'skill' },
+        { name: 'Agent - Spawns a specific agent', value: 'agent' },
+        { name: 'Both - Uses skill + specific agent workflow', value: 'both' },
+      ],
+    },
+  ]);
+
+  let delegatesTo = '';
+  if (delegationType === 'skill' || delegationType === 'both') {
+    const { skillName } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'skillName',
+        message: 'Skill name:',
+        default: 'my-skill',
+      },
+    ]);
+    delegatesTo = `skill:${skillName}`;
+  }
+
+  if (delegationType === 'agent' || delegationType === 'both') {
+    const { agentName } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'agentName',
+        message: 'Agent name:',
+        default: 'my-agent',
+      },
+    ]);
+    delegatesTo = delegationType === 'both' ? `${delegatesTo} + @${agentName}` : `@${agentName}`;
+  }
+
+  // Step 5: Arguments
+  const { hasArgs } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'hasArgs',
+      message: 'Does this command accept arguments?',
+      default: false,
+    },
+  ]);
+
+  let args = '';
+  if (hasArgs) {
+    const { argsSpec } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'argsSpec',
+        message: 'Arguments format (e.g., "[target] [--flag]"):',
+        default: '[target]',
+      },
+    ]);
+    args = argsSpec;
+  }
+
+  // Step 6: Workflow steps
+  const { defineSteps } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'defineSteps',
+      message: 'Define workflow steps? (recommended)',
+      default: true,
+    },
+  ]);
+
+  const steps = [];
+  if (defineSteps) {
+    let addingSteps = true;
+    let stepNum = 1;
+
+    while (addingSteps) {
+      const { stepTitle, stepInstructions } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'stepTitle',
+          message: `Step ${stepNum} title:`,
+          default: stepNum === 1 ? 'Analyze' : stepNum === 2 ? 'Execute' : 'Report',
+        },
+        {
+          type: 'input',
+          name: 'stepInstructions',
+          message: `Step ${stepNum} instructions:`,
+          default: 'Perform this step of the workflow.',
+        },
+      ]);
+
+      steps.push({ title: stepTitle, instructions: stepInstructions });
+      stepNum++;
+
+      const { continueAdding } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'continueAdding',
+          message: 'Add another step?',
+          default: stepNum <= 3,
+        },
+      ]);
+      addingSteps = continueAdding;
+    }
+  }
+
+  // Step 7: Examples
+  const examples = [];
+  const { addExamples } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'addExamples',
+      message: 'Add usage examples?',
+      default: true,
+    },
+  ]);
+
+  if (addExamples) {
+    let addingExamples = true;
+    while (addingExamples) {
+      const { exampleDesc, exampleArgs } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'exampleDesc',
+          message: 'Example description:',
+          default: 'Basic usage',
+        },
+        {
+          type: 'input',
+          name: 'exampleArgs',
+          message: `Example args (after /${name}):`,
+          default: '',
+        },
+      ]);
+
+      examples.push({ description: exampleDesc, args: exampleArgs });
+
+      const { continueAdding } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'continueAdding',
+          message: 'Add another example?',
+          default: examples.length < 2,
+        },
+      ]);
+      addingExamples = continueAdding;
+    }
+  }
+
+  // Step 8: Related commands
+  const { relatedCommands } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'relatedCommands',
+      message: 'Related commands (comma-separated, without /):',
+      default: '',
+      filter: (input) =>
+        input
+          .split(',')
+          .map((c) => c.trim())
+          .filter(Boolean),
+    },
+  ]);
+
+  // Step 9: Output location
+  const { outputPath } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'outputPath',
+      message: 'Where should the command be created?',
+      choices: [
+        { name: '.claude/commands/ (standard location)', value: '.claude/commands' },
+        { name: 'Custom location', value: 'custom' },
+      ],
+    },
+  ]);
+
+  let finalPath = join(process.cwd(), outputPath, `${name}.md`);
+  if (outputPath === 'custom') {
+    const { customPath } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'customPath',
+        message: 'Custom path:',
+        default: `.claude/commands/${name}.md`,
+      },
+    ]);
+    finalPath = join(process.cwd(), customPath);
+  }
+
+  // Generate the command
+  const spinner = ora('Generating command...').start();
+
+  const commandContent = generateCommandTemplate({
+    name,
+    description,
+    complexity,
+    delegatesTo,
+    arguments: args,
+    steps,
+    examples,
+    relatedCommands,
+  });
+
+  // Ensure directory exists
+  const dir = dirname(finalPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  // Write the command file
+  writeFileSync(finalPath, commandContent, 'utf8');
+
+  // Try to update INDEX.md if it exists
+  const indexPath = join(dir, 'INDEX.md');
+  let indexUpdated = false;
+  if (existsSync(indexPath)) {
+    try {
+      const indexContent = readFileSync(indexPath, 'utf8');
+      const newEntry = `| \`/${name}\` | ${description} | ${complexity} |`;
+
+      // Check if command already in index
+      if (!indexContent.includes(`/${name}`)) {
+        // Find a good place to insert (before the last table row or at end of a table)
+        const tableMatch = indexContent.match(/(\|[^|]+\|[^|]+\|[^|]+\|\n)+/);
+        if (tableMatch) {
+          const updatedIndex = indexContent.replace(
+            tableMatch[0],
+            tableMatch[0] + newEntry + '\n'
+          );
+          writeFileSync(indexPath, updatedIndex, 'utf8');
+          indexUpdated = true;
+        }
+      }
+    } catch {
+      // Ignore index update errors
+    }
+  }
+
+  spinner.succeed('Command created');
+
+  // Summary
+  const details = [
+    `Name: /${name}`,
+    `Complexity: ${COMPLEXITY_LEVELS[complexity].name}`,
+    delegatesTo ? `Delegates to: ${delegatesTo}` : '',
+    args ? `Arguments: ${args}` : '',
+    `Steps: ${steps.length}`,
+    '',
+    `Location: ${finalPath}`,
+    indexUpdated ? 'INDEX.md: Updated' : '',
+  ].filter(Boolean);
+
+  showSuccess('Command Created!', details);
+
+  // Instructions
+  console.log(chalk.dim('\nTo use this command in Claude Code:'));
+  console.log(chalk.cyan(`  /${name}${args ? ` ${args}` : ''}`));
+  console.log('');
+
+  return { name, path: finalPath, complexity, delegatesTo };
+}

package/src/commands/create-hook.js

@@ -0,0 +1,262 @@
+/**
+ * Create Hook Command
+ *
+ * Interactive wizard for creating Claude Code enforcement hooks
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { showHeader, showSuccess, showError, showWarning, showInfo } from '../cli/menu.js';
+import {
+  generateHookTemplate,
+  HOOK_EVENT_TYPES,
+  HOOK_TOOLS,
+} from '../agents/templates.js';
+
+/**
+ * Run the create-hook wizard
+ */
+export async function runCreateHook(options) {
+  showHeader('Create Hook');
+
+  console.log(chalk.dim('Hooks enforce patterns and inject context in Claude Code.'));
+  console.log(chalk.dim('They run automatically on tool calls or user prompts.\n'));
+
+  // Step 1: Hook name
+  const { name } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Hook name (kebab-case):',
+      default: options.name || 'my-hook',
+      validate: (input) => {
+        if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+          return 'Use kebab-case (lowercase letters, numbers, hyphens)';
+        }
+        return true;
+      },
+    },
+  ]);
+
+  // Step 2: Description
+  const { description } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'description',
+      message: 'What does this hook do?',
+      default: `Enforce patterns for ${name}`,
+    },
+  ]);
+
+  // Step 3: Event type
+  console.log('');
+  console.log(chalk.cyan.bold('Event Types:'));
+  Object.entries(HOOK_EVENT_TYPES).forEach(([key, event]) => {
+    const canBlock = event.canBlock ? chalk.green('(can block)') : chalk.dim('(cannot block)');
+    console.log(chalk.dim(`  ${key}: ${event.description} ${canBlock}`));
+  });
+  console.log('');
+
+  const { eventType } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'eventType',
+      message: 'When should this hook trigger?',
+      choices: Object.entries(HOOK_EVENT_TYPES).map(([key, event]) => ({
+        name: `${key} - ${event.useCase}`,
+        value: key,
+        short: key,
+      })),
+      default: 'PreToolUse',
+    },
+  ]);
+
+  // Step 4: Target tools (for PreToolUse/PostToolUse)
+  let tools = [];
+  if (eventType === 'PreToolUse' || eventType === 'PostToolUse') {
+    const { selectedTools } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selectedTools',
+        message: 'Which tools should trigger this hook?',
+        choices: HOOK_TOOLS.map((tool) => ({
+          name: tool,
+          value: tool,
+          checked: tool === 'Edit' || tool === 'Write',
+        })),
+        validate: (input) => input.length > 0 || 'Select at least one tool',
+      },
+    ]);
+    tools = selectedTools;
+  }
+
+  // Step 5: Target file patterns
+  const { targetPatterns } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'targetPatterns',
+      message: 'File patterns to target (comma-separated, empty = all files):',
+      default: 'src/,apps/',
+      filter: (input) =>
+        input
+          .split(',')
+          .map((p) => p.trim())
+          .filter(Boolean),
+    },
+  ]);
+
+  // Step 6: Purpose - block or warn
+  const { purpose } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'purpose',
+      message: 'What should this hook do?',
+      choices: [
+        { name: 'Block - Prevent operations matching patterns', value: 'block' },
+        { name: 'Warn - Allow but show warnings', value: 'warn' },
+        { name: 'Inject - Add context to Claude\'s response', value: 'inject' },
+        { name: 'Log - Just log operations (no interference)', value: 'log' },
+      ],
+    },
+  ]);
+
+  // Step 7: Patterns based on purpose
+  let blockedPatterns = [];
+  let warningPatterns = [];
+  let blockReason = '';
+
+  if (purpose === 'block') {
+    const { patterns, reason } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'patterns',
+        message: 'Patterns to BLOCK (comma-separated):',
+        default: 'console.log,debugger',
+        filter: (input) =>
+          input
+            .split(',')
+            .map((p) => p.trim())
+            .filter(Boolean),
+      },
+      {
+        type: 'input',
+        name: 'reason',
+        message: 'Why should these be blocked?',
+        default: 'These patterns are not allowed in production code',
+      },
+    ]);
+    blockedPatterns = patterns;
+    blockReason = reason;
+  } else if (purpose === 'warn') {
+    const { patterns } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'patterns',
+        message: 'Patterns to WARN about (comma-separated):',
+        default: 'TODO,FIXME,HACK',
+        filter: (input) =>
+          input
+            .split(',')
+            .map((p) => p.trim())
+            .filter(Boolean),
+      },
+    ]);
+    warningPatterns = patterns;
+  }
+
+  // Step 8: Reference documentation
+  const { referenceDoc } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'referenceDoc',
+      message: 'Reference documentation path (optional):',
+      default: '',
+    },
+  ]);
+
+  // Step 9: Output location
+  const { outputPath } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'outputPath',
+      message: 'Where should the hook be created?',
+      choices: [
+        { name: '.claude/hooks/tools/ (standard location)', value: '.claude/hooks/tools' },
+        { name: 'Custom location', value: 'custom' },
+      ],
+    },
+  ]);
+
+  let finalPath = join(process.cwd(), outputPath, `${name}.js`);
+  if (outputPath === 'custom') {
+    const { customPath } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'customPath',
+        message: 'Custom path:',
+        default: `.claude/hooks/tools/${name}.js`,
+      },
+    ]);
+    finalPath = join(process.cwd(), customPath);
+  }
+
+  // Generate the hook
+  const spinner = ora('Generating hook...').start();
+
+  const hookContent = generateHookTemplate({
+    name,
+    description,
+    eventType,
+    tools,
+    targetPatterns,
+    blockedPatterns,
+    warningPatterns,
+    blockReason,
+    referenceDoc,
+  });
+
+  // Ensure directory exists
+  const dir = dirname(finalPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  // Write the hook file
+  writeFileSync(finalPath, hookContent, 'utf8');
+
+  spinner.succeed('Hook created');
+
+  // Summary
+  const details = [
+    `Name: ${name}`,
+    `Event: ${eventType}`,
+    tools.length > 0 ? `Tools: ${tools.join(', ')}` : '',
+    targetPatterns.length > 0 ? `File patterns: ${targetPatterns.join(', ')}` : '',
+    blockedPatterns.length > 0 ? `Blocked: ${blockedPatterns.join(', ')}` : '',
+    warningPatterns.length > 0 ? `Warnings: ${warningPatterns.join(', ')}` : '',
+    '',
+    `Location: ${finalPath}`,
+  ].filter(Boolean);
+
+  showSuccess('Hook Created!', details);
+
+  // Instructions
+  console.log(chalk.dim('\nTo activate this hook, add to .claude/settings.local.json:'));
+  console.log(chalk.cyan(`
+{
+  "hooks": {
+    "${eventType}": [
+      {
+        "command": "node ${finalPath.replace(process.cwd(), '.')}"${tools.length > 0 ? `,
+        "tools": [${tools.map((t) => `"${t}"`).join(', ')}]` : ''}
+      }
+    ]
+  }
+}
+`));
+
+  return { name, path: finalPath, eventType, tools };
+}