claude-cli-advanced-starter-pack 1.0.0

package/src/commands/test-setup.js

@@ -0,0 +1,456 @@
+/**
+ * Testing Setup Wizard Command
+ *
+ * Interactive setup for testing configuration including:
+ * - Testing mode (Ralph Loop, Manual, Minimal)
+ * - Environment (localhost, ngrok, custom)
+ * - Credentials (env vars, config file, prompt)
+ * - Playwright configuration
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { showHeader, showSuccess, showError, showWarning, showInfo } from '../cli/menu.js';
+import {
+  TESTING_MODES,
+  ENVIRONMENTS,
+  CREDENTIAL_SOURCES,
+  createTestingConfig,
+  saveTestingConfig,
+  saveTestingRules,
+  loadTestingConfig,
+  hasTestingConfig,
+} from '../testing/config.js';
+
+/**
+ * Run the testing setup wizard
+ */
+export async function runTestSetup(options) {
+  showHeader('Testing Setup Wizard');
+
+  // Check for existing config
+  if (hasTestingConfig() && !options.force) {
+    const existing = loadTestingConfig();
+    console.log(chalk.dim('Existing testing configuration found:'));
+    console.log(chalk.dim(`  Mode: ${existing.mode}`));
+    console.log(chalk.dim(`  Environment: ${existing.environment.type}`));
+    console.log(chalk.dim(`  URL: ${existing.environment.baseUrl}`));
+    console.log('');
+
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: 'Overwrite existing configuration?',
+        default: false,
+      },
+    ]);
+
+    if (!overwrite) {
+      console.log(chalk.yellow('Setup cancelled. Use --force to overwrite.'));
+      return;
+    }
+  }
+
+  const config = {};
+
+  // Step 1: Testing Mode
+  console.log(chalk.cyan.bold('\n📋 Step 1: Testing Mode\n'));
+
+  const modeChoices = Object.entries(TESTING_MODES).map(([key, mode]) => ({
+    name: `${mode.name}${mode.recommended ? chalk.green(' (Recommended)') : ''}\n   ${chalk.dim(mode.description)}`,
+    value: key,
+    short: mode.name,
+  }));
+
+  const { testingMode } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'testingMode',
+      message: 'How should tests be run?',
+      choices: modeChoices,
+      default: 'ralph',
+    },
+  ]);
+
+  config.mode = testingMode;
+
+  // Ralph-specific configuration
+  if (testingMode === 'ralph') {
+    console.log('');
+    console.log(chalk.dim('Ralph Loop continuously runs tests and retries fixes until all pass.'));
+
+    const { maxIterations, completionPromise } = await inquirer.prompt([
+      {
+        type: 'number',
+        name: 'maxIterations',
+        message: 'Maximum retry iterations:',
+        default: 10,
+        validate: (n) => (n > 0 && n <= 50 ? true : 'Enter 1-50'),
+      },
+      {
+        type: 'input',
+        name: 'completionPromise',
+        message: 'Completion phrase (what Claude should say when done):',
+        default: 'all tasks complete and tests passing',
+      },
+    ]);
+
+    config.maxIterations = maxIterations;
+    config.completionPromise = completionPromise;
+  }
+
+  // Step 2: Environment
+  console.log(chalk.cyan.bold('\n🌐 Step 2: Testing Environment\n'));
+
+  const envChoices = Object.entries(ENVIRONMENTS).map(([key, env]) => ({
+    name: `${env.name}${env.recommended ? chalk.green(' (Recommended)') : ''}\n   ${chalk.dim(env.description)}`,
+    value: key,
+    short: env.name,
+  }));
+
+  const { envType } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'envType',
+      message: 'Where should tests run?',
+      choices: envChoices,
+      default: 'localhost',
+    },
+  ]);
+
+  config.envType = envType;
+
+  // Environment-specific configuration
+  if (envType === 'localhost') {
+    const { port } = await inquirer.prompt([
+      {
+        type: 'number',
+        name: 'port',
+        message: 'Development server port:',
+        default: 5173,
+      },
+    ]);
+    config.port = port;
+    config.baseUrl = `http://localhost:${port}`;
+    config.requiresSetup = ['npm run dev'];
+  } else if (envType === 'ngrok') {
+    const { subdomain, port } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'subdomain',
+        message: 'ngrok subdomain (e.g., my.app.benefits360):',
+        default: 'my.app',
+        validate: (s) => (s.length > 0 ? true : 'Subdomain required'),
+      },
+      {
+        type: 'number',
+        name: 'port',
+        message: 'Local port to tunnel:',
+        default: 5173,
+      },
+    ]);
+    config.port = port;
+    config.baseUrl = `https://${subdomain}.ngrok.dev`;
+    config.requiresSetup = ['npm run dev', `ngrok http ${port}`];
+  } else if (envType === 'custom') {
+    const { customUrl } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'customUrl',
+        message: 'Custom testing URL:',
+        default: 'https://example.com',
+        validate: (url) => {
+          try {
+            new URL(url);
+            return true;
+          } catch {
+            return 'Enter a valid URL';
+          }
+        },
+      },
+    ]);
+    config.baseUrl = customUrl;
+    config.requiresSetup = [];
+  }
+
+  // Step 3: Credentials
+  console.log(chalk.cyan.bold('\n🔐 Step 3: Test Credentials\n'));
+
+  const { needsAuth } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'needsAuth',
+      message: 'Do your tests require login/authentication?',
+      default: true,
+    },
+  ]);
+
+  if (needsAuth) {
+    const credChoices = Object.entries(CREDENTIAL_SOURCES)
+      .filter(([key]) => key !== 'none')
+      .map(([key, source]) => ({
+        name: `${source.name}${source.recommended ? chalk.green(' (Recommended)') : ''}${source.secure ? chalk.blue(' 🔒') : ''}\n   ${chalk.dim(source.description)}`,
+        value: key,
+        short: source.name,
+      }));
+
+    const { credentialSource } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'credentialSource',
+        message: 'How should credentials be managed?',
+        choices: credChoices,
+        default: 'env',
+      },
+    ]);
+
+    config.credentialSource = credentialSource;
+
+    if (credentialSource === 'env') {
+      const { usernameVar, passwordVar } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'usernameVar',
+          message: 'Username environment variable name:',
+          default: 'TEST_USER_USERNAME',
+        },
+        {
+          type: 'input',
+          name: 'passwordVar',
+          message: 'Password environment variable name:',
+          default: 'TEST_USER_PASSWORD',
+        },
+      ]);
+
+      config.envVars = {
+        username: usernameVar,
+        password: passwordVar,
+      };
+
+      // Check if env vars are set
+      const hasUsername = !!process.env[usernameVar];
+      const hasPassword = !!process.env[passwordVar];
+
+      if (!hasUsername || !hasPassword) {
+        console.log('');
+        showWarning('Environment variables not currently set!');
+        console.log(chalk.dim(`Add to your .env file or shell:`));
+        console.log(chalk.dim(`  export ${usernameVar}="your_username"`));
+        console.log(chalk.dim(`  export ${passwordVar}="your_password"`));
+      }
+    } else if (credentialSource === 'config') {
+      showWarning('Credentials will be stored in .gtask/testing.json');
+      console.log(chalk.dim('This file will be added to .gitignore'));
+      console.log('');
+
+      const { username, password } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'username',
+          message: 'Test username:',
+          validate: (u) => (u.length > 0 ? true : 'Username required'),
+        },
+        {
+          type: 'password',
+          name: 'password',
+          message: 'Test password:',
+          mask: '*',
+          validate: (p) => (p.length > 0 ? true : 'Password required'),
+        },
+      ]);
+
+      config.username = username;
+      config.password = password;
+    }
+
+    // Login selectors
+    console.log('');
+    console.log(chalk.dim('Configure login form selectors (used by Playwright):'));
+
+    const { customSelectors } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'customSelectors',
+        message: 'Use custom selectors? (No = use defaults)',
+        default: false,
+      },
+    ]);
+
+    if (customSelectors) {
+      const selectors = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'usernameSelector',
+          message: 'Username input selector:',
+          default: '[data-testid="username-input"]',
+        },
+        {
+          type: 'input',
+          name: 'passwordSelector',
+          message: 'Password input selector:',
+          default: '[data-testid="password-input"]',
+        },
+        {
+          type: 'input',
+          name: 'loginButtonSelector',
+          message: 'Login button selector:',
+          default: '[data-testid="login-submit"]',
+        },
+        {
+          type: 'input',
+          name: 'loginSuccessSelector',
+          message: 'Login success indicator selector:',
+          default: '[data-testid="dashboard"]',
+        },
+      ]);
+
+      Object.assign(config, selectors);
+    }
+  } else {
+    config.credentialSource = 'none';
+  }
+
+  // Step 4: Playwright Configuration
+  console.log(chalk.cyan.bold('\n🎭 Step 4: Playwright Configuration\n'));
+
+  const { usePlaywright } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'usePlaywright',
+      message: 'Will you use Playwright for E2E testing?',
+      default: true,
+    },
+  ]);
+
+  config.playwrightEnabled = usePlaywright;
+
+  if (usePlaywright) {
+    // Check if playwright is installed
+    const playwrightConfigExists = existsSync(join(process.cwd(), 'playwright.config.ts')) ||
+      existsSync(join(process.cwd(), 'playwright.config.js'));
+
+    if (!playwrightConfigExists) {
+      showInfo('No playwright.config found in current directory.');
+
+      const { initPlaywright } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'initPlaywright',
+          message: 'Would you like to initialize Playwright?',
+          choices: [
+            { name: 'Yes - Run npx playwright install', value: 'install' },
+            { name: 'Skip - I\'ll set it up later', value: 'skip' },
+            { name: 'Show me the commands', value: 'show' },
+          ],
+        },
+      ]);
+
+      if (initPlaywright === 'install') {
+        console.log('');
+        console.log(chalk.dim('Run these commands after setup:'));
+        console.log(chalk.cyan('  npm init playwright@latest'));
+        console.log(chalk.cyan('  npx playwright install'));
+      } else if (initPlaywright === 'show') {
+        console.log('');
+        console.log(chalk.dim('Playwright setup commands:'));
+        console.log(chalk.cyan('  npm init playwright@latest  # Initialize Playwright'));
+        console.log(chalk.cyan('  npx playwright install      # Install browsers'));
+        console.log(chalk.cyan('  npx playwright test         # Run tests'));
+        console.log(chalk.cyan('  npx playwright test --ui    # Interactive UI mode'));
+      }
+    } else {
+      console.log(chalk.green('✓ Playwright config found'));
+    }
+
+    const { browser, headless } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'browser',
+        message: 'Default browser for tests:',
+        choices: [
+          { name: 'Chromium (Recommended)', value: 'chromium' },
+          { name: 'Firefox', value: 'firefox' },
+          { name: 'WebKit (Safari)', value: 'webkit' },
+          { name: 'All browsers', value: 'all' },
+        ],
+        default: 'chromium',
+      },
+      {
+        type: 'confirm',
+        name: 'headless',
+        message: 'Run tests in headless mode?',
+        default: true,
+      },
+    ]);
+
+    config.browser = browser;
+    config.headless = headless;
+  }
+
+  // Step 5: Generate files
+  console.log(chalk.cyan.bold('\n📄 Step 5: Generate Configuration\n'));
+
+  const spinner = ora('Creating configuration files...').start();
+
+  const testingConfig = createTestingConfig(config);
+
+  // Save main config
+  const configPath = saveTestingConfig(testingConfig);
+  spinner.text = 'Saved testing.json';
+
+  // Save testing rules markdown
+  const { generateRules } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'generateRules',
+      message: 'Generate TESTING_RULES.md documentation?',
+      default: true,
+    },
+  ]);
+
+  let rulesPath = null;
+  if (generateRules) {
+    rulesPath = saveTestingRules(testingConfig);
+    spinner.text = 'Saved TESTING_RULES.md';
+  }
+
+  spinner.succeed('Configuration files created');
+
+  // Summary
+  const details = [
+    `Mode: ${TESTING_MODES[config.mode].name}`,
+    `Environment: ${config.baseUrl}`,
+    `Credentials: ${CREDENTIAL_SOURCES[config.credentialSource].name}`,
+    `Playwright: ${config.playwrightEnabled ? 'Enabled' : 'Disabled'}`,
+    '',
+    `Config: ${configPath}`,
+  ];
+
+  if (rulesPath) {
+    details.push(`Rules: ${rulesPath}`);
+  }
+
+  if (config.requiresSetup?.length > 0) {
+    details.push('');
+    details.push('Before running tests:');
+    for (const cmd of config.requiresSetup) {
+      details.push(`  ${cmd}`);
+    }
+  }
+
+  showSuccess('Testing Setup Complete!', details);
+
+  // Show next steps
+  console.log(chalk.dim('\nNext steps:'));
+  console.log(chalk.dim('  gtask test         - Run tests'));
+  console.log(chalk.dim('  gtask test --watch - Watch mode'));
+  if (config.mode === 'ralph') {
+    console.log(chalk.dim('  gtask sync watch   - Start Ralph loop with task tracking'));
+  }
+
+  return testingConfig;
+}

package/src/commands/validate.js

@@ -0,0 +1,67 @@
+/**
+ * Validate Command
+ *
+ * Validates templates for hardcoded values and ensures platform agnosticism.
+ */
+
+import chalk from 'chalk';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { showHeader, showSuccess, showError } from '../cli/menu.js';
+import { scanDirectory, formatViolations } from '../utils/validate-templates.js';
+
+/**
+ * Run template validation
+ */
+export async function runValidate(options = {}) {
+  showHeader('Template Validation');
+
+  const { path: targetPath = 'templates', fix = false, verbose = false } = options;
+
+  const fullPath = join(process.cwd(), targetPath);
+
+  if (!existsSync(fullPath)) {
+    showError('Directory not found', `Could not find: ${fullPath}`);
+    return false;
+  }
+
+  console.log(chalk.dim(`  Scanning: ${fullPath}`));
+  console.log(chalk.dim(`  Checking for hardcoded values...\n`));
+
+  const violations = scanDirectory(fullPath, {
+    extensions: ['.md', '.js', '.ts', '.json'],
+    exclude: ['node_modules', '.git', 'dist', 'build', 'cache'],
+  });
+
+  console.log(formatViolations(violations));
+
+  if (violations.length === 0) {
+    showSuccess('Validation Passed', [
+      '',
+      'All templates use parameterized values.',
+      'No hardcoded project-specific values detected.',
+    ]);
+    return true;
+  }
+
+  console.log(chalk.yellow('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.yellow.bold('\nHow to Fix:\n'));
+  console.log(chalk.dim('  1. Replace hardcoded values with {{placeholder}} syntax'));
+  console.log(chalk.dim('  2. Add the placeholder path to tech-stack.schema.json'));
+  console.log(chalk.dim('  3. Set default values in tech-stack.defaults.json'));
+  console.log('');
+  console.log(chalk.dim('  Example transformations:'));
+  console.log(chalk.dim('    --project-name=my-project'));
+  console.log(chalk.green('    --project-name={{deployment.frontend.projectName}}'));
+  console.log('');
+  console.log(chalk.dim('    ngrok http 5174'));
+  console.log(chalk.green('    {{devEnvironment.tunnel.startCommand}}'));
+  console.log('');
+  console.log(chalk.dim('    projectId: "abc123-..."'));
+  console.log(chalk.green('    projectId: "{{deployment.backend.projectId}}"'));
+  console.log('');
+
+  return false;
+}
+
+export default runValidate;

package/src/config/tech-stack.defaults.json

@@ -0,0 +1,182 @@
+{
+  "version": "2.0.0",
+  "project": {
+    "name": "{{PROJECT_NAME}}",
+    "description": "{{PROJECT_DESCRIPTION}}",
+    "rootPath": "."
+  },
+  "frontend": {
+    "framework": "{{FRONTEND_FRAMEWORK}}",
+    "buildTool": "{{FRONTEND_BUILD_TOOL}}",
+    "stateManager": "{{FRONTEND_STATE_MANAGER}}",
+    "styling": "{{FRONTEND_STYLING}}",
+    "port": "{{FRONTEND_PORT}}",
+    "devCommand": "{{FRONTEND_DEV_COMMAND}}",
+    "buildCommand": "{{FRONTEND_BUILD_COMMAND}}",
+    "distDir": "{{FRONTEND_DIST_DIR}}"
+  },
+  "backend": {
+    "language": "{{BACKEND_LANGUAGE}}",
+    "framework": "{{BACKEND_FRAMEWORK}}",
+    "apiStyle": "{{BACKEND_API_STYLE}}",
+    "port": "{{BACKEND_PORT}}",
+    "devCommand": "{{BACKEND_DEV_COMMAND}}",
+    "healthEndpoint": "{{BACKEND_HEALTH_ENDPOINT}}"
+  },
+  "database": {
+    "primary": "{{DATABASE_TYPE}}",
+    "orm": "{{DATABASE_ORM}}",
+    "host": "{{DATABASE_HOST}}",
+    "port": "{{DATABASE_PORT}}"
+  },
+  "deployment": {
+    "frontend": {
+      "platform": "{{DEPLOY_FRONTEND_PLATFORM}}",
+      "projectName": "{{DEPLOY_FRONTEND_PROJECT}}",
+      "productionUrl": "{{DEPLOY_FRONTEND_URL}}",
+      "deployCommand": "{{DEPLOY_FRONTEND_COMMAND}}"
+    },
+    "backend": {
+      "platform": "{{DEPLOY_BACKEND_PLATFORM}}",
+      "projectId": "{{DEPLOY_BACKEND_PROJECT_ID}}",
+      "serviceId": "{{DEPLOY_BACKEND_SERVICE_ID}}",
+      "environmentId": "{{DEPLOY_BACKEND_ENV_ID}}",
+      "productionUrl": "{{DEPLOY_BACKEND_URL}}",
+      "selfHostedConfig": {
+        "sshUser": "{{SELF_HOSTED_SSH_USER}}",
+        "sshHost": "{{SELF_HOSTED_SSH_HOST}}",
+        "sshPort": 22,
+        "deployScript": "{{SELF_HOSTED_DEPLOY_SCRIPT}}",
+        "appPath": "{{SELF_HOSTED_APP_PATH}}"
+      }
+    },
+    "cicd": "{{CICD_PLATFORM}}"
+  },
+  "devEnvironment": {
+    "tunnel": {
+      "service": "{{TUNNEL_SERVICE}}",
+      "url": "{{TUNNEL_URL}}",
+      "subdomain": "{{TUNNEL_SUBDOMAIN}}",
+      "startCommand": "{{TUNNEL_START_COMMAND}}",
+      "adminPort": "{{TUNNEL_ADMIN_PORT}}"
+    },
+    "container": "{{CONTAINER_RUNTIME}}",
+    "packageManager": "{{PACKAGE_MANAGER}}"
+  },
+  "testing": {
+    "e2e": {
+      "framework": "{{E2E_FRAMEWORK}}",
+      "configFile": "{{E2E_CONFIG_FILE}}",
+      "testCommand": "{{E2E_TEST_COMMAND}}",
+      "browsers": ["{{E2E_BROWSERS}}"],
+      "headless": true,
+      "timeout": 30000
+    },
+    "unit": {
+      "framework": "{{UNIT_TEST_FRAMEWORK}}",
+      "testCommand": "{{UNIT_TEST_COMMAND}}",
+      "coverageTarget": 80
+    },
+    "selectors": {
+      "strategy": "{{SELECTOR_STRATEGY}}",
+      "username": "{{SELECTOR_USERNAME}}",
+      "password": "{{SELECTOR_PASSWORD}}",
+      "loginButton": "{{SELECTOR_LOGIN_BUTTON}}",
+      "loginSuccess": "{{SELECTOR_LOGIN_SUCCESS}}"
+    },
+    "credentials": {
+      "usernameEnvVar": "{{TEST_USERNAME_ENV_VAR}}",
+      "passwordEnvVar": "{{TEST_PASSWORD_ENV_VAR}}"
+    }
+  },
+  "versionControl": {
+    "provider": "{{VCS_PROVIDER}}",
+    "owner": "{{VCS_OWNER}}",
+    "repo": "{{VCS_REPO}}",
+    "defaultBranch": "{{VCS_DEFAULT_BRANCH}}",
+    "projectBoard": {
+      "type": "{{PROJECT_BOARD_TYPE}}",
+      "number": "{{PROJECT_BOARD_NUMBER}}",
+      "id": "{{PROJECT_BOARD_ID}}",
+      "url": "{{PROJECT_BOARD_URL}}"
+    }
+  },
+  "urls": {
+    "local": {
+      "frontend": "http://localhost:{{FRONTEND_PORT}}",
+      "backend": "http://localhost:{{BACKEND_PORT}}",
+      "api": "http://localhost:{{BACKEND_PORT}}/api"
+    },
+    "tunnel": {
+      "frontend": "{{TUNNEL_URL}}",
+      "backend": "{{TUNNEL_URL}}"
+    },
+    "production": {
+      "frontend": "{{DEPLOY_FRONTEND_URL}}",
+      "backend": "{{DEPLOY_BACKEND_URL}}"
+    }
+  },
+  "tokenManagement": {
+    "enabled": false,
+    "dailyBudget": 200000,
+    "thresholds": {
+      "compact": 0.75,
+      "archive": 0.85,
+      "respawn": 0.90
+    },
+    "trackingFile": ".claude/hooks/cache/token-usage.json"
+  },
+  "happyMode": {
+    "enabled": false,
+    "dashboardUrl": null,
+    "checkpointInterval": 10,
+    "verbosity": "condensed",
+    "notifications": {
+      "onTaskComplete": true,
+      "onError": true,
+      "onCheckpoint": false
+    }
+  },
+  "agents": {
+    "enabled": true,
+    "l1": {
+      "model": "sonnet",
+      "tools": ["Task", "Read", "Grep", "Glob", "WebSearch"],
+      "maxTokens": 16000
+    },
+    "l2": {
+      "model": "sonnet",
+      "tools": ["Read", "Edit", "Write", "Bash", "Grep", "Glob"],
+      "maxTokens": 8000
+    },
+    "l3": {
+      "model": "haiku",
+      "tools": ["Read", "Grep"],
+      "maxTokens": 500
+    },
+    "maxConcurrent": 4
+  },
+  "phasedDevelopment": {
+    "enabled": true,
+    "defaultScale": "M",
+    "successTarget": 0.95,
+    "progressFile": ".claude/docs/{project-slug}/PROGRESS.json",
+    "generateArtifacts": {
+      "executiveSummary": true,
+      "deploymentRunbook": true,
+      "rollbackPlan": true,
+      "testPlan": true
+    }
+  },
+  "hooks": {
+    "enabled": true,
+    "priorities": {
+      "lifecycle": 100,
+      "tools": 1000,
+      "automation": 2000
+    },
+    "errorBehavior": "approve",
+    "cacheDir": ".claude/hooks/cache",
+    "configDir": ".claude/hooks/config"
+  }
+}