claude-cli-advanced-starter-pack 1.0.0

package/src/templates/issue-body.js

@@ -0,0 +1,284 @@
+/**
+ * Issue Body Templates
+ *
+ * Generates comprehensive GitHub issue bodies with codebase analysis
+ */
+
+/**
+ * Generate a comprehensive issue body
+ */
+export function generateIssueBody(data) {
+  const {
+    description,
+    expectedBehavior,
+    actualBehavior,
+    acceptanceCriteria = [],
+    codeAnalysis = {},
+    apiStatus = {},
+    references = [],
+    todoList = [],
+    testScenarios = [],
+    priority,
+    labels = [],
+  } = data;
+
+  const sections = [];
+
+  // Problem Statement
+  sections.push(`## Problem Statement\n\n${description}`);
+
+  // Expected vs Actual (for bugs)
+  if (expectedBehavior || actualBehavior) {
+    sections.push(`## Expected vs Actual Behavior
+
+**Expected**: ${expectedBehavior || 'N/A'}
+**Actual**: ${actualBehavior || 'N/A'}`);
+  }
+
+  // Acceptance Criteria
+  if (acceptanceCriteria.length > 0) {
+    const criteria = acceptanceCriteria
+      .map((c) => `- [ ] ${c}`)
+      .join('\n');
+    sections.push(`## Acceptance Criteria\n\n${criteria}`);
+  }
+
+  // Code Analysis
+  if (codeAnalysis.relevantFiles?.length > 0 || codeAnalysis.keyFunctions?.length > 0) {
+    sections.push(generateCodeAnalysisSection(codeAnalysis));
+  }
+
+  // API Status (for full-stack features)
+  if (apiStatus.layers?.length > 0) {
+    sections.push(generateApiStatusSection(apiStatus));
+  }
+
+  // Reference Documents
+  if (references.length > 0) {
+    const refList = references.map((r) => `- ${r}`).join('\n');
+    sections.push(`## Reference Documents\n\n${refList}`);
+  }
+
+  // Recommended Approach / Todo List
+  if (todoList.length > 0) {
+    sections.push(generateTodoSection(todoList));
+  }
+
+  // Testing
+  if (testScenarios.length > 0) {
+    sections.push(generateTestingSection(testScenarios));
+  }
+
+  // Metadata footer
+  sections.push(`---
+*Created by GitHub Task Kit*`);
+
+  return sections.join('\n\n---\n\n');
+}
+
+/**
+ * Generate code analysis section
+ */
+function generateCodeAnalysisSection(analysis) {
+  const parts = ['## Code Analysis'];
+
+  // Relevant Files & Functions table
+  if (analysis.relevantFiles?.length > 0) {
+    parts.push('### Relevant Files & Functions\n');
+    parts.push('| File | Line | Function/Component | Purpose |');
+    parts.push('|------|------|-------------------|---------|');
+
+    for (const fileInfo of analysis.relevantFiles) {
+      for (const def of fileInfo.definitions || []) {
+        parts.push(
+          `| \`${fileInfo.file}\` | ${def.line} | \`${def.name}()\` | ${def.type} |`
+        );
+      }
+    }
+  }
+
+  // Key Functions
+  if (analysis.keyFunctions?.length > 0) {
+    parts.push('\n### Key Functions to Modify\n');
+    for (const func of analysis.keyFunctions.slice(0, 5)) {
+      parts.push(`- \`${func.file}:${func.line}\` - \`${func.name}()\``);
+    }
+  }
+
+  // Patterns to Follow
+  if (analysis.patterns?.length > 0) {
+    parts.push('\n### Patterns to Follow\n');
+    for (const pattern of analysis.patterns.slice(0, 3)) {
+      parts.push(`- **${pattern.keyword}**: Found in \`${pattern.file}\``);
+    }
+  }
+
+  // Code Snippets
+  if (analysis.codeSnippets?.length > 0) {
+    parts.push('\n### Code Snippets\n');
+    for (const snippet of analysis.codeSnippets.slice(0, 2)) {
+      const ext = snippet.file.split('.').pop();
+      const lang = getLanguageForExt(ext);
+      parts.push(`\`\`\`${lang}
+// From: ${snippet.file}:${snippet.startLine}-${snippet.endLine}
+${snippet.content}
+\`\`\``);
+    }
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Generate API status section for full-stack features
+ */
+function generateApiStatusSection(apiStatus) {
+  const parts = ['## Full-Stack API Status'];
+
+  parts.push('### Stack Verification Matrix\n');
+  parts.push('| Layer | Component | Status | File Location |');
+  parts.push('|-------|-----------|--------|---------------|');
+
+  for (const layer of apiStatus.layers || []) {
+    const status = layer.exists ? '✅' : '❌';
+    const location = layer.file ? `\`${layer.file}:${layer.line || ''}\`` : '-';
+    parts.push(`| ${layer.layer} | \`${layer.component}\` | ${status} | ${location} |`);
+  }
+
+  // Missing layers
+  const missing = (apiStatus.layers || []).filter((l) => !l.exists);
+  if (missing.length > 0) {
+    parts.push('\n### Missing Layers (MUST IMPLEMENT)\n');
+    for (const layer of missing) {
+      parts.push(`- [ ] **${layer.layer}**: Create \`${layer.component}\``);
+    }
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Generate todo section
+ */
+function generateTodoSection(todoList) {
+  const parts = ['## Recommended Approach'];
+
+  parts.push('### Todo List\n');
+  for (let i = 0; i < todoList.length; i++) {
+    const item = todoList[i];
+    parts.push(`- [ ] **Step ${i + 1}**: ${item.task}`);
+    if (item.details) {
+      parts.push(`  - ${item.details}`);
+    }
+    if (item.file) {
+      parts.push(`  - File: \`${item.file}\``);
+    }
+  }
+
+  // Dependencies
+  const deps = todoList.filter((t) => t.dependsOn);
+  if (deps.length > 0) {
+    parts.push('\n### Dependencies\n');
+    for (const dep of deps) {
+      parts.push(`- Step ${todoList.indexOf(dep) + 1} depends on Step ${dep.dependsOn}`);
+    }
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Generate testing section
+ */
+function generateTestingSection(scenarios) {
+  const parts = ['## Testing'];
+
+  parts.push('### Test Scenarios\n');
+  for (let i = 0; i < scenarios.length; i++) {
+    const scenario = scenarios[i];
+    parts.push(`${i + 1}. [ ] **${scenario.name}**`);
+    if (scenario.steps) {
+      for (const step of scenario.steps) {
+        parts.push(`   - ${step}`);
+      }
+    }
+    if (scenario.expected) {
+      parts.push(`   - Expected: ${scenario.expected}`);
+    }
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Get language name for syntax highlighting
+ */
+function getLanguageForExt(ext) {
+  const map = {
+    js: 'javascript',
+    jsx: 'jsx',
+    ts: 'typescript',
+    tsx: 'tsx',
+    py: 'python',
+    rs: 'rust',
+    go: 'go',
+    java: 'java',
+    cs: 'csharp',
+    rb: 'ruby',
+    php: 'php',
+    swift: 'swift',
+    kt: 'kotlin',
+  };
+  return map[ext] || ext;
+}
+
+/**
+ * Generate a simple issue body (minimal template)
+ */
+export function generateSimpleIssueBody(data) {
+  const { description, acceptanceCriteria = [] } = data;
+
+  let body = `## Description\n\n${description}`;
+
+  if (acceptanceCriteria.length > 0) {
+    body += '\n\n## Acceptance Criteria\n\n';
+    body += acceptanceCriteria.map((c) => `- [ ] ${c}`).join('\n');
+  }
+
+  body += '\n\n---\n*Created by GitHub Task Kit*';
+
+  return body;
+}
+
+/**
+ * Default acceptance criteria suggestions based on issue type
+ */
+export function suggestAcceptanceCriteria(issueType, keywords = []) {
+  const suggestions = {
+    bug: [
+      'Bug is reproducible and root cause identified',
+      'Fix implemented and tested locally',
+      'No regression in related functionality',
+      'Error handling covers edge cases',
+    ],
+    feature: [
+      'Feature implemented according to requirements',
+      'UI matches design specifications (if applicable)',
+      'Unit tests added for new functionality',
+      'Documentation updated',
+    ],
+    refactor: [
+      'Code refactored without changing behavior',
+      'All existing tests still pass',
+      'Code follows project style guidelines',
+      'No new warnings or errors introduced',
+    ],
+    documentation: [
+      'Documentation is accurate and complete',
+      'Examples are working and tested',
+      'Links are valid and accessible',
+    ],
+  };
+
+  return suggestions[issueType] || suggestions.feature;
+}

package/src/testing/config.js

@@ -0,0 +1,411 @@
+/**
+ * Testing Configuration Module
+ *
+ * Manages testing modes, credentials, and environment configuration
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+// Default paths
+const CONFIG_DIR = join(process.cwd(), '.gtask');
+const TESTING_RULES_FILE = 'TESTING_RULES.md';
+
+/**
+ * Testing mode definitions
+ */
+export const TESTING_MODES = {
+  ralph: {
+    name: 'Ralph Loop',
+    description: 'Continuous test-fix cycle until all tests pass',
+    recommended: true,
+    defaults: {
+      maxIterations: 10,
+      completionPromise: 'all tasks complete and tests passing',
+    },
+  },
+  manual: {
+    name: 'Manual Testing',
+    description: 'You control when tests run',
+    recommended: false,
+  },
+  minimal: {
+    name: 'Minimal Testing',
+    description: 'Only test at the end of all tasks',
+    recommended: false,
+  },
+};
+
+/**
+ * Environment definitions
+ */
+export const ENVIRONMENTS = {
+  localhost: {
+    name: 'Localhost',
+    description: 'Local development server',
+    urlTemplate: 'http://localhost:{port}',
+    defaultPort: 5173,
+    requiresSetup: ['npm run dev'],
+    recommended: true,
+  },
+  ngrok: {
+    name: 'ngrok Tunnel',
+    description: 'Expose local server via ngrok',
+    urlTemplate: 'https://{subdomain}.ngrok.dev',
+    requiresSetup: ['npm run dev', 'ngrok http {port}'],
+    recommended: false,
+  },
+  custom: {
+    name: 'Custom URL',
+    description: 'Custom deployment URL',
+    urlTemplate: '{url}',
+    requiresSetup: [],
+    recommended: false,
+  },
+};
+
+/**
+ * Credential source options
+ */
+export const CREDENTIAL_SOURCES = {
+  env: {
+    name: 'Environment Variables',
+    description: 'Read from .env file or system environment',
+    envVars: {
+      username: 'TEST_USER_USERNAME',
+      password: 'TEST_USER_PASSWORD',
+    },
+    recommended: true,
+    secure: true,
+  },
+  config: {
+    name: 'Config File',
+    description: 'Store in .gtask/testing.json (gitignored)',
+    recommended: false,
+    secure: false,
+  },
+  prompt: {
+    name: 'Prompt Each Time',
+    description: 'Ask for credentials when tests run',
+    recommended: false,
+    secure: true,
+  },
+  none: {
+    name: 'No Authentication',
+    description: 'Tests do not require login',
+    recommended: false,
+    secure: true,
+  },
+};
+
+/**
+ * Testing configuration structure
+ */
+export function createTestingConfig(options = {}) {
+  return {
+    version: '1.0.0',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+
+    // Testing mode
+    mode: options.mode || 'manual',
+    ralphConfig: options.mode === 'ralph' ? {
+      maxIterations: options.maxIterations || 10,
+      completionPromise: options.completionPromise || 'all tasks complete and tests passing',
+      autoRetry: true,
+    } : null,
+
+    // Environment
+    environment: {
+      type: options.envType || 'localhost',
+      baseUrl: options.baseUrl || 'http://localhost:5173',
+      port: options.port || 5173,
+      requiresSetup: options.requiresSetup || [],
+    },
+
+    // Credentials
+    credentials: {
+      source: options.credentialSource || 'env',
+      envVars: options.envVars || {
+        username: 'TEST_USER_USERNAME',
+        password: 'TEST_USER_PASSWORD',
+      },
+      // Only stored if source is 'config'
+      username: options.credentialSource === 'config' ? options.username : undefined,
+      password: options.credentialSource === 'config' ? options.password : undefined,
+    },
+
+    // Playwright configuration
+    playwright: {
+      enabled: options.playwrightEnabled ?? true,
+      configPath: options.playwrightConfig || 'playwright.config.ts',
+      browser: options.browser || 'chromium',
+      headless: options.headless ?? true,
+      timeout: options.timeout || 30000,
+    },
+
+    // Test selectors (for login flow)
+    selectors: {
+      usernameInput: options.usernameSelector || '[data-testid="username-input"]',
+      passwordInput: options.passwordSelector || '[data-testid="password-input"]',
+      loginButton: options.loginButtonSelector || '[data-testid="login-submit"]',
+      loginSuccessIndicator: options.loginSuccessSelector || '[data-testid="dashboard"]',
+    },
+
+    // Persistent rules file path
+    rulesFile: options.rulesFile || null,
+  };
+}
+
+/**
+ * Save testing configuration
+ */
+export function saveTestingConfig(config) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+
+  const configPath = join(CONFIG_DIR, 'testing.json');
+  config.updatedAt = new Date().toISOString();
+
+  writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+
+  // Add to .gitignore if credentials are stored
+  if (config.credentials.source === 'config') {
+    ensureGitignore('.gtask/testing.json');
+  }
+
+  return configPath;
+}
+
+/**
+ * Load testing configuration
+ */
+export function loadTestingConfig() {
+  const configPath = join(CONFIG_DIR, 'testing.json');
+
+  if (!existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if testing is configured
+ */
+export function hasTestingConfig() {
+  return existsSync(join(CONFIG_DIR, 'testing.json'));
+}
+
+/**
+ * Generate TESTING_RULES.md template
+ */
+export function generateTestingRules(config) {
+  const envSection = config.environment.type === 'ngrok'
+    ? `
+## Environment
+- **Testing URL**: ${config.environment.baseUrl}
+- **Environment Type**: ngrok tunnel
+- **Requires**: npm run dev + ngrok running
+- **Backend**: Railway (not local Vite proxy)
+`
+    : config.environment.type === 'localhost'
+    ? `
+## Environment
+- **Testing URL**: ${config.environment.baseUrl}
+- **Environment Type**: Local development
+- **Requires**: npm run dev
+- **Port**: ${config.environment.port}
+`
+    : `
+## Environment
+- **Testing URL**: ${config.environment.baseUrl}
+- **Environment Type**: Custom/Production
+`;
+
+  const credentialSection = config.credentials.source === 'env'
+    ? `
+## Credentials (Environment Variables)
+- **Username env var**: \`${config.credentials.envVars.username}\`
+- **Password env var**: \`${config.credentials.envVars.password}\`
+
+Set these in your .env file or system environment before running tests.
+`
+    : config.credentials.source === 'config'
+    ? `
+## Credentials (Stored in config)
+Credentials are stored in .gtask/testing.json (gitignored).
+`
+    : config.credentials.source === 'prompt'
+    ? `
+## Credentials (Prompt)
+You will be prompted for credentials each time tests run.
+`
+    : `
+## Credentials
+No authentication required for these tests.
+`;
+
+  const selectorSection = `
+## Login Selectors
+- **Username input**: \`${config.selectors.usernameInput}\`
+- **Password input**: \`${config.selectors.passwordInput}\`
+- **Login button**: \`${config.selectors.loginButton}\`
+- **Success indicator**: \`${config.selectors.loginSuccessIndicator}\`
+`;
+
+  const modeSection = config.mode === 'ralph'
+    ? `
+## Testing Mode: Ralph Loop
+- **Max iterations**: ${config.ralphConfig.maxIterations}
+- **Completion promise**: "${config.ralphConfig.completionPromise}"
+- **Behavior**: Automatically retry tests after fixes until all pass
+`
+    : config.mode === 'manual'
+    ? `
+## Testing Mode: Manual
+Run tests manually when ready: \`gtask test\`
+`
+    : `
+## Testing Mode: Minimal
+Tests will only run after all tasks are complete.
+`;
+
+  return `# Testing Rules
+
+This file contains persistent testing rules for this project.
+Generated by GitHub Task Kit.
+
+---
+${envSection}
+---
+${credentialSection}
+---
+${selectorSection}
+---
+${modeSection}
+---
+
+## Playwright Commands
+
+\`\`\`bash
+# Run all tests
+npx playwright test
+
+# Run specific test file
+npx playwright test auth-login.spec.ts
+
+# Run in headed mode (see browser)
+npx playwright test --headed
+
+# Run with UI mode
+npx playwright test --ui
+\`\`\`
+
+## Important Notes
+
+1. **Never commit credentials** to git
+2. **Always check the testing URL** before running tests
+3. **Ralph Loop will auto-retry** up to ${config.ralphConfig?.maxIterations || 10} times
+4. **Stop tests with Ctrl+C** if stuck in a loop
+
+---
+*Generated by GitHub Task Kit - ${new Date().toISOString()}*
+`;
+}
+
+/**
+ * Save testing rules markdown file
+ */
+export function saveTestingRules(config, filename = TESTING_RULES_FILE) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+
+  const rulesPath = join(CONFIG_DIR, filename);
+  const content = generateTestingRules(config);
+
+  writeFileSync(rulesPath, content, 'utf8');
+
+  // Update config with rules file path
+  config.rulesFile = rulesPath;
+
+  return rulesPath;
+}
+
+/**
+ * Ensure .gitignore includes sensitive files
+ */
+function ensureGitignore(pattern) {
+  const gitignorePath = join(process.cwd(), '.gitignore');
+
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, `# gtask sensitive files\n${pattern}\n`, 'utf8');
+    return;
+  }
+
+  const content = readFileSync(gitignorePath, 'utf8');
+  if (!content.includes(pattern)) {
+    writeFileSync(gitignorePath, content + `\n# gtask sensitive files\n${pattern}\n`, 'utf8');
+  }
+}
+
+/**
+ * Get credentials based on config
+ */
+export function getCredentials(config) {
+  if (!config || config.credentials.source === 'none') {
+    return null;
+  }
+
+  if (config.credentials.source === 'env') {
+    return {
+      username: process.env[config.credentials.envVars.username] || null,
+      password: process.env[config.credentials.envVars.password] || null,
+    };
+  }
+
+  if (config.credentials.source === 'config') {
+    return {
+      username: config.credentials.username,
+      password: config.credentials.password,
+    };
+  }
+
+  // 'prompt' returns null - caller should prompt user
+  return null;
+}
+
+/**
+ * Validate testing configuration
+ */
+export function validateConfig(config) {
+  const errors = [];
+
+  if (!config.environment?.baseUrl) {
+    errors.push('Base URL is required');
+  }
+
+  if (config.credentials?.source === 'env') {
+    const creds = getCredentials(config);
+    if (!creds?.username || !creds?.password) {
+      errors.push(
+        `Environment variables not set: ${config.credentials.envVars.username}, ${config.credentials.envVars.password}`
+      );
+    }
+  }
+
+  if (config.mode === 'ralph' && !config.ralphConfig) {
+    errors.push('Ralph configuration missing');
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}