ai-sprint-kit 2.0.4 → 2.1.1

package/lib/ci-generator.js

@@ -0,0 +1,248 @@
+const fs = require('fs/promises');
+const path = require('path');
+
+/**
+ * Generate GitHub Actions workflow
+ */
+async function generateGitHubActions(targetDir) {
+  const workflowDir = path.join(targetDir, '.github/workflows');
+  const workflowPath = path.join(workflowDir, 'ai-sprint-validate.yml');
+
+  const workflow = `name: AI Sprint Validation
+
+on:
+  pull_request:
+    branches: [main, develop]
+  push:
+    branches: [main, develop]
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+
+      - name: Install AI Sprint Kit CLI
+        run: npm install -g ai-sprint-kit
+
+      - name: Validate Installation
+        run: ai-sprint validate
+
+      - name: Run Diagnostics
+        run: ai-sprint doctor
+`;
+
+  await fs.mkdir(workflowDir, { recursive: true });
+  await fs.writeFile(workflowPath, workflow, 'utf8');
+
+  return workflowPath;
+}
+
+/**
+ * Generate GitLab CI configuration
+ */
+async function generateGitLabCI(targetDir) {
+  const gitlabCIPath = path.join(targetDir, '.gitlab-ci.yml');
+
+  const gitlabCI = `stages:
+  - validate
+
+variables:
+  NODE_VERSION: "18"
+
+ai-sprint-validate:
+  stage: validate
+  image: node:18
+
+  before_script:
+    - npm install -g ai-sprint-kit
+
+  script:
+    - ai-sprint validate
+    - ai-sprint doctor
+
+  only:
+    - merge_requests
+    - main
+    - develop
+`;
+
+  await fs.writeFile(gitlabCIPath, gitlabCI, 'utf8');
+
+  return gitlabCIPath;
+}
+
+/**
+ * Generate Bitbucket Pipelines configuration
+ */
+async function generateBitbucketPipelines(targetDir) {
+  const pipelinesPath = path.join(targetDir, 'bitbucket-pipelines.yml');
+
+  const pipelines = `image: node:18
+
+pipelines:
+  pull-requests:
+    '**':
+      - step:
+          name: AI Sprint Validation
+          script:
+            - npm install -g ai-sprint-kit
+            - ai-sprint validate
+            - ai-sprint doctor
+
+  branches:
+    main:
+      - step:
+          name: AI Sprint Validation
+          script:
+            - npm install -g ai-sprint-kit
+            - ai-sprint validate
+            - ai-sprint doctor
+    develop:
+      - step:
+          name: AI Sprint Validation
+          script:
+            - npm install -g ai-sprint-kit
+            - ai-sprint validate
+            - ai-sprint doctor
+`;
+
+  await fs.writeFile(pipelinesPath, pipelines, 'utf8');
+
+  return pipelinesPath;
+}
+
+/**
+ * Detect which CI platform is being used
+ */
+async function detectCIPlatform(targetDir) {
+  // Check for GitHub Actions
+  const githubDir = path.join(targetDir, '.github');
+  try {
+    await fs.access(githubDir);
+    return 'github';
+  } catch {}
+
+  // Check for GitLab CI
+  const gitlabCI = path.join(targetDir, '.gitlab-ci.yml');
+  try {
+    await fs.access(gitlabCI);
+    return 'gitlab';
+  } catch {}
+
+  // Check for Bitbucket Pipelines
+  const bitbucketCI = path.join(targetDir, 'bitbucket-pipelines.yml');
+  try {
+    await fs.access(bitbucketCI);
+    return 'bitbucket';
+  } catch {}
+
+  // No CI detected
+  return null;
+}
+
+/**
+ * Initialize CI configuration
+ */
+async function initCI(targetDir, platform) {
+  const detected = await detectCIPlatform(targetDir);
+  const selectedPlatform = platform || detected || 'github';
+
+  let generatedPath;
+
+  switch (selectedPlatform) {
+    case 'github':
+      generatedPath = await generateGitHubActions(targetDir);
+      break;
+    case 'gitlab':
+      generatedPath = await generateGitLabCI(targetDir);
+      break;
+    case 'bitbucket':
+      generatedPath = await generateBitbucketPipelines(targetDir);
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${selectedPlatform}`);
+  }
+
+  return {
+    platform: selectedPlatform,
+    path: generatedPath,
+    detected: detected || 'none'
+  };
+}
+
+/**
+ * Run CI validation (headless mode for CI systems)
+ */
+async function runCIValidation(targetDir) {
+  const { validateInstallation } = require('./validator');
+
+  const result = await validateInstallation(targetDir);
+
+  // Return CI-friendly output
+  return {
+    success: result.isValid(),
+    summary: result.summary(),
+    passed: result.passed,
+    failed: result.failed,
+    warnings: result.warnings,
+    // Exit code for CI
+    exitCode: result.isValid() ? 0 : 1
+  };
+}
+
+/**
+ * Format CI validation output for logging
+ */
+function formatCIOutput(ciResult) {
+  const lines = [];
+
+  lines.push('=== AI Sprint CI Validation ===\n');
+
+  if (ciResult.success) {
+    lines.push(`✅ PASSED: ${ciResult.summary.passed} checks passed`);
+  } else {
+    lines.push(`❌ FAILED: ${ciResult.summary.failed} checks failed`);
+  }
+
+  if (ciResult.summary.warnings > 0) {
+    lines.push(`⚠️  WARNINGS: ${ciResult.summary.warnings} warnings`);
+  }
+
+  lines.push(`\nTotal: ${ciResult.summary.total} checks`);
+
+  if (!ciResult.success && ciResult.failed.length > 0) {
+    lines.push('\nFailed checks:');
+    ciResult.failed.forEach(({ check, suggestion }) => {
+      lines.push(`  ✗ ${check}`);
+      lines.push(`    → ${suggestion}`);
+    });
+  }
+
+  if (ciResult.warnings.length > 0) {
+    lines.push('\nWarnings:');
+    ciResult.warnings.forEach(({ check, message }) => {
+      lines.push(`  ! ${check}`);
+      lines.push(`    → ${message}`);
+    });
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  generateGitHubActions,
+  generateGitLabCI,
+  generateBitbucketPipelines,
+  detectCIPlatform,
+  initCI,
+  runCIValidation,
+  formatCIOutput
+};

package/lib/interactive.js

@@ -0,0 +1,249 @@
+const readline = require('readline');
+const chalk = require('chalk');
+
+/**
+ * Create readline interface for interactive prompts
+ */
+function createReadline() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Prompt user with a yes/no question
+ */
+function promptQuestion(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(`${question} (y/n): `, (answer) => {
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+/**
+ * Prompt user to select from options
+ */
+function promptChoice(rl, question, options) {
+  return new Promise((resolve) => {
+    console.log(chalk.cyan(`\n${question}`));
+    options.forEach((opt, i) => {
+      console.log(chalk.gray(`  ${i + 1}. ${opt.label}`));
+    });
+
+    rl.question(chalk.cyan('\nSelect option (number): '), (answer) => {
+      const index = parseInt(answer) - 1;
+      if (index >= 0 && index < options.length) {
+        resolve(options[index].value);
+      } else {
+        resolve(options[0].value); // Default to first option
+      }
+    });
+  });
+}
+
+/**
+ * Interactive installation mode
+ */
+async function interactiveInstall() {
+  const rl = createReadline();
+
+  console.log(chalk.blue.bold('\n🎯 Interactive Installation\n'));
+  console.log(chalk.gray('Customize your AI Sprint Kit setup:\n'));
+
+  const preferences = {
+    includeHooks: true,
+    includeBrowserTesting: false,
+    ciPlatform: 'none'
+  };
+
+  // Ask about hooks
+  preferences.includeHooks = await promptQuestion(
+    rl,
+    chalk.yellow('Include automation hooks? (auto-format, lint-check)')
+  );
+
+  // Ask about browser testing
+  preferences.includeBrowserTesting = await promptQuestion(
+    rl,
+    chalk.yellow('Include browser testing infrastructure?')
+  );
+
+  // Ask about CI platform
+  console.log(chalk.cyan('\nCI/CD Platform:'));
+  console.log(chalk.gray('  Choose a platform for automated validation\n'));
+
+  const ciOptions = [
+    { label: 'None (skip CI setup)', value: 'none' },
+    { label: 'GitHub Actions', value: 'github' },
+    { label: 'GitLab CI', value: 'gitlab' },
+    { label: 'Bitbucket Pipelines', value: 'bitbucket' }
+  ];
+
+  preferences.ciPlatform = await promptChoice(
+    rl,
+    'Which CI/CD platform do you use?',
+    ciOptions
+  );
+
+  rl.close();
+
+  return preferences;
+}
+
+/**
+ * Show dry-run preview of what will be installed
+ */
+async function dryRunPreview(targetDir) {
+  const path = require('path');
+  const fs = require('fs/promises');
+
+  console.log(chalk.blue.bold('\n🔍 Dry Run - Installation Preview\n'));
+  console.log(chalk.cyan('Target directory:'));
+  console.log(chalk.gray(`  ${targetDir}\n`));
+
+  console.log(chalk.cyan('Files that will be created:\n'));
+
+  const filesToCreate = [
+    { path: '.claude/settings.json', desc: 'Claude Code configuration' },
+    { path: '.claude/.env.example', desc: 'Environment variables template' },
+    { path: '.claude/agents/', desc: '9 agent files (planner, implementer, tester, etc.)' },
+    { path: '.claude/commands/', desc: '13 command files (/plan, /code, /test, etc.)' },
+    { path: '.claude/workflows/', desc: 'Development workflow rules' },
+    { path: '.claude/hooks/', desc: 'Automation hooks (optional)' },
+    { path: '.claude/skills/', desc: 'Python scripts for advanced features' },
+    { path: 'ai_context/', desc: 'Context memory directories' },
+    { path: 'CLAUDE.md', desc: 'Framework documentation' },
+    { path: '.claude/docs/', desc: 'Additional documentation' }
+  ];
+
+  filesToCreate.forEach(file => {
+    const exists = file.path.endsWith('/')
+      ? checkDirExists(targetDir, file.path)
+      : checkFileExists(targetDir, file.path);
+
+    const status = exists
+      ? chalk.yellow('⚠ OVERWRITE')
+      : chalk.green('✓ CREATE');
+
+    console.log(`  ${status}  ${chalk.cyan(file.path.padEnd(30))} ${chalk.gray(file.desc)}`);
+  });
+
+  console.log(chalk.cyan('\nSummary:'));
+  console.log(chalk.gray(`  • ${filesToCreate.length} locations will be created/modified`));
+  console.log(chalk.gray(`  • Target: ${targetDir}`));
+  console.log(chalk.gray(`  • Run without --dry-run to proceed\n`));
+}
+
+/**
+ * Check if directory exists
+ */
+async function checkDirExists(targetDir, dirPath) {
+  const fs = require('fs/promises');
+  const path = require('path');
+  try {
+    await fs.access(path.join(targetDir, dirPath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if file exists
+ */
+async function checkFileExists(targetDir, filePath) {
+  const fs = require('fs/promises');
+  const path = require('path');
+  try {
+    await fs.access(path.join(targetDir, filePath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Show installation progress with detailed steps
+ */
+class InstallProgress {
+  constructor() {
+    this.steps = [];
+    this.currentStep = 0;
+  }
+
+  addStep(name, description) {
+    this.steps.push({ name, description, status: 'pending' });
+  }
+
+  startStep(stepIndex) {
+    this.currentStep = stepIndex;
+    this.steps[stepIndex].status = 'running';
+  }
+
+  completeStep(stepIndex) {
+    this.steps[stepIndex].status = 'complete';
+  }
+
+  failStep(stepIndex, error) {
+    this.steps[stepIndex].status = 'failed';
+    this.steps[stepIndex].error = error;
+  }
+
+  render() {
+    const lines = [];
+    lines.push(chalk.cyan('\n📦 Installation Progress:\n'));
+
+    this.steps.forEach((step, index) => {
+      const isCurrent = index === this.currentStep;
+
+      let status;
+      switch (step.status) {
+        case 'complete':
+          status = chalk.green('✓');
+          break;
+        case 'failed':
+          status = chalk.red('✗');
+          break;
+        case 'running':
+          status = chalk.yellow('⟳');
+          break;
+        default:
+          status = chalk.gray('○');
+      }
+
+      const name = isCurrent ? chalk.bold(step.name) : step.name;
+      lines.push(`  ${status}  ${name}`);
+
+      if (step.description && step.status !== 'complete') {
+        lines.push(chalk.gray(`     ${step.description}`));
+      }
+
+      if (step.error) {
+        lines.push(chalk.red(`     Error: ${step.error}`));
+      }
+    });
+
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  getProgress() {
+    const complete = this.steps.filter(s => s.status === 'complete').length;
+    return {
+      current: complete,
+      total: this.steps.length,
+      percent: Math.round((complete / this.steps.length) * 100)
+    };
+  }
+}
+
+module.exports = {
+  createReadline,
+  promptQuestion,
+  promptChoice,
+  interactiveInstall,
+  dryRunPreview,
+  InstallProgress
+};