ai-qakit 1.0.0

package/README.md

@@ -0,0 +1,240 @@
+# AI QAKit
+
+AI QAKit is a comprehensive QA toolkit that extends [AI DevKit](https://gitlab.enouvo.com/development-team/base-projects/ai-toolkits/ai-devkit) with AI-assisted testing capabilities. It provides QA-specific commands, skills, agents, and workflows for 5 AI-powered IDEs.
+
+## Features
+
+- **Full AI DevKit Inheritance**: All commands, skills, agents, and workflows from AI DevKit
+- **48 QA Commands**: Test generation, bug investigation, coverage analysis, and more
+- **10 QA Skills**: Test automation, API testing, UI testing, performance testing, etc.
+- **10 QA Agents**: Test architect, bug hunter, automation engineer, and more
+- **8 QA Workflows**: Test-driven QA, bug investigation, regression testing, etc.
+- **7 Documentation Templates**: Test plans, bug reports, quality reports, etc.
+- **Tool Integration**: Jira, Testmo, Playwright, WebdriverIO support
+
+## Supported IDEs
+
+| IDE | Directory | Status |
+|-----|-----------|--------|
+| Claude Code | `.claude/` | ✅ Full support |
+| Cursor IDE | `.cursor/` | ✅ Full support |
+| Kiro IDE | `.kiro/` | ✅ Full support |
+| Google Antigravity | `.antigravity/` | ✅ Full support |
+| OpenAI Codex | `.codex/` | ✅ Full support |
+
+## Installation
+
+```bash
+# Interactive mode (recommended)
+npx ai-qakit
+
+# Install for specific IDE
+npx ai-qakit --claude
+npx ai-qakit --cursor
+npx ai-qakit --kiro
+
+# Install for all IDEs
+npx ai-qakit --all
+
+# With backup
+npx ai-qakit --claude --backup
+
+# Hide from git (local only)
+npx ai-qakit --claude --hidden
+```
+
+## CLI Options
+
+| Option | Description |
+|--------|-------------|
+| `-h, --help` | Show help message |
+| `-v, --version` | Show version number |
+| `-f, --force` | Force overwrite (skip prompts) |
+| `--claude` | Install Claude Code templates |
+| `--cursor` | Install Cursor IDE templates |
+| `--kiro` | Install Kiro IDE templates |
+| `--antigravity` | Install Google Antigravity templates |
+| `--codex` | Install OpenAI Codex templates |
+| `--all` | Install all IDE templates |
+| `--backup` | Create backup before overwriting |
+| `--hidden` | Add to .git/info/exclude |
+
+## Quick Start
+
+### 1. Initialize AI QAKit
+
+```bash
+npx ai-qakit --claude
+```
+
+### 2. Explore QA Commands
+
+```bash
+# In Claude Code, use slash commands:
+/qakit:help              # Show all QA commands
+/qakit:test:generate-e2e # Generate E2E tests
+/qakit:bug:investigate   # Investigate a bug
+/qakit:review:coverage   # Analyze test coverage
+```
+
+### 3. Use QA Agents
+
+```bash
+# Invoke QA agents:
+/agent:test-architect    # Design test strategy
+/agent:bug-hunter        # Hunt for bugs
+/agent:automation-engineer # Build automation
+```
+
+## QA Commands Reference
+
+### Test Commands
+- `/qakit:test:create-test-case` - Create test cases
+- `/qakit:test:create-test-suite` - Create test suites
+- `/qakit:test:generate-api-tests` - Generate API tests
+- `/qakit:test:generate-ui-tests` - Generate UI tests
+- `/qakit:test:generate-e2e` - Generate E2E tests
+- `/qakit:test:generate-data` - Generate test data
+
+### Bug Commands
+- `/qakit:bug:investigate` - Investigate bugs
+- `/qakit:bug:report` - Create bug reports
+- `/qakit:bug:reproduce` - Create reproduction steps
+- `/qakit:bug:triage` - Triage bugs
+- `/qakit:bug:verify` - Verify bug fixes
+
+### Review Commands
+- `/qakit:review:test-review` - Review test quality
+- `/qakit:review:coverage` - Analyze coverage
+- `/qakit:review:quality-gate` - Check quality gates
+
+### Integration Commands
+- `/qakit:jira:analyze` - Analyze Jira tickets
+- `/qakit:jira:create-tests` - Create tests from Jira
+- `/qakit:testmo:sync` - Sync with Testmo
+- `/qakit:testmo:report` - Generate Testmo reports
+
+See [COMMANDS.md](./guide/COMMANDS.md) for the complete command reference.
+
+## QA Skills
+
+| Skill | Description |
+|-------|-------------|
+| test-automation | Test automation patterns and frameworks |
+| api-testing | REST, GraphQL, contract testing |
+| ui-testing | Playwright, WebdriverIO patterns |
+| performance-testing | k6, Artillery, benchmarking |
+| test-design | Test case design techniques |
+| bug-investigation | Root cause analysis |
+| quality-metrics | Coverage, defect density |
+| test-data-management | Fixtures, factories |
+| mobile-testing | Mobile testing patterns |
+| accessibility-testing | WCAG compliance |
+
+See [SKILLS.md](./guide/SKILLS.md) for detailed skill documentation.
+
+## QA Agents
+
+| Agent | Role |
+|-------|------|
+| test-architect | Design test strategies |
+| bug-hunter | Investigate bugs |
+| test-reviewer | Review test quality |
+| automation-engineer | Build automation |
+| performance-tester | Performance testing |
+| security-tester | Security testing |
+| qa-scout | Explore codebase |
+| accessibility-tester | A11y testing |
+| api-tester | API testing |
+| e2e-tester | E2E testing |
+
+## QA Workflows
+
+- **qa-primary-workflow** - Main QA workflow
+- **test-driven-qa-workflow** - TDD approach
+- **bug-investigation-workflow** - Bug hunting
+- **regression-testing-workflow** - Regression testing
+- **api-testing-workflow** - API testing
+- **e2e-testing-workflow** - E2E testing
+- **performance-testing-workflow** - Performance testing
+
+## Tool Integration
+
+### Playwright
+```typescript
+// AI QAKit generates Playwright tests
+import { test, expect } from '@playwright/test';
+
+test('user login flow', async ({ page }) => {
+  await page.goto('/login');
+  await page.fill('[data-testid="email"]', 'user@example.com');
+  await page.fill('[data-testid="password"]', 'password');
+  await page.click('[data-testid="submit"]');
+  await expect(page).toHaveURL('/dashboard');
+});
+```
+
+### WebdriverIO
+```typescript
+// AI QAKit generates WebdriverIO tests
+describe('Login', () => {
+  it('should login successfully', async () => {
+    await browser.url('/login');
+    await $('[data-testid="email"]').setValue('user@example.com');
+    await $('[data-testid="password"]').setValue('password');
+    await $('[data-testid="submit"]').click();
+    await expect(browser).toHaveUrl('/dashboard');
+  });
+});
+```
+
+### Jira Integration
+```bash
+# Analyze Jira ticket and create tests
+/qakit:jira:analyze PROJ-123
+/qakit:jira:create-tests PROJ-123
+```
+
+### Testmo Integration
+```bash
+# Sync test results with Testmo
+/qakit:testmo:sync
+/qakit:testmo:report
+```
+
+## Updating
+
+AI QAKit supports seamless updates:
+
+```bash
+# Update existing installation
+npx ai-qakit --claude
+
+# Update with backup
+npx ai-qakit --claude --backup
+```
+
+The CLI automatically detects existing installations and handles updates gracefully.
+
+## Development
+
+```bash
+# Clone repository
+git clone https://gitlab.enouvo.com/development-team/base-projects/ai-toolkits/ai-qakit.git
+
+# Install dependencies
+bun install
+
+# Run tests
+bun test
+
+# Build
+bun run build
+
+# Run locally
+bun run dev --claude
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import { parseArgs } from 'util';
+import { initCommand } from './commands/init.js';
+import { cleanCommand } from './commands/clean.js';
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { checkbox, confirm } from '@inquirer/prompts';
+import { fileURLToPath } from 'url';
+import { readManifest } from './utils/manifest.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Read version from package.json
+const packageJsonPath = join(__dirname, '..', 'package.json');
+const { version } = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const helpText = `
+ai-qakit v${version}
+
+AI QAKit CLI - Bootstrap your project with AI-assisted QA configurations
+
+Usage:
+  npx ai-qakit [options]
+
+Options:
+  -h, --help       Show this help message
+  -v, --version    Show version number
+  -f, --force      Force overwrite (skip prompts)
+  --claude         Target .claude directory (Claude Code)
+  --cursor         Target .cursor directory (Cursor IDE)
+  --kiro           Target .kiro directory (Kiro IDE)
+  --antigravity    Target .antigravity directory (Google Antigravity)
+  --codex          Target .codex directory (OpenAI Codex)
+  --all            Install for all supported IDEs
+  --hidden         Add to .git/info/exclude (hide from git locally)
+  --backup         Create backup before overwriting
+  --clean          Remove installed AI QAKit directories
+
+Examples:
+  npx ai-qakit                   # Interactive mode
+  npx ai-qakit --claude          # Install/update .claude
+  npx ai-qakit --cursor          # Install/update .cursor
+  npx ai-qakit --kiro            # Install/update .kiro
+  npx ai-qakit --all             # Install/update all IDEs
+  npx ai-qakit --claude --backup # Backup before update
+  npx ai-qakit --claude --hidden # Hide from git
+  npx ai-qakit --claude --clean  # Remove .claude directory
+  npx ai-qakit --all --clean     # Remove all IDE directories
+`;
+const IDE_CONFIGS = [
+    { name: 'Claude Code (.claude/)', value: 'claude', dir: '.claude', label: '.claude' },
+    { name: 'Cursor IDE (.cursor/)', value: 'cursor', dir: '.cursor', label: '.cursor' },
+    { name: 'Kiro IDE (.kiro/)', value: 'kiro', dir: '.kiro', label: '.kiro' },
+    { name: 'Google Antigravity (.antigravity/)', value: 'antigravity', dir: '.antigravity', label: '.antigravity' },
+    { name: 'OpenAI Codex (.codex/)', value: 'codex', dir: '.codex', label: '.codex' },
+];
+async function main() {
+    const { values } = parseArgs({
+        args: process.argv.slice(2),
+        options: {
+            help: { type: 'boolean', short: 'h' },
+            version: { type: 'boolean', short: 'v' },
+            force: { type: 'boolean', short: 'f' },
+            claude: { type: 'boolean' },
+            cursor: { type: 'boolean' },
+            kiro: { type: 'boolean' },
+            antigravity: { type: 'boolean' },
+            codex: { type: 'boolean' },
+            all: { type: 'boolean' },
+            hidden: { type: 'boolean' },
+            backup: { type: 'boolean' },
+            clean: { type: 'boolean' },
+        },
+    });
+    if (values.version) {
+        console.log(version);
+        process.exit(0);
+    }
+    if (values.help) {
+        console.log(helpText);
+        process.exit(0);
+    }
+    // Initialize selections
+    let selectedIDEs = {
+        claude: values.claude ?? false,
+        cursor: values.cursor ?? false,
+        kiro: values.kiro ?? false,
+        antigravity: values.antigravity ?? false,
+        codex: values.codex ?? false,
+    };
+    // Handle --all flag
+    if (values.all) {
+        selectedIDEs = {
+            claude: true,
+            cursor: true,
+            kiro: true,
+            antigravity: true,
+            codex: true,
+        };
+    }
+    // Handle --clean flag
+    if (values.clean) {
+        await cleanCommand({
+            ...selectedIDEs,
+            force: values.force ?? false,
+        });
+        return;
+    }
+    let backupSelected = values.backup ?? false;
+    let hiddenSelected = values.hidden ?? false;
+    let forceFromPrompt = false;
+    let isUpdate = false;
+    const cwd = process.cwd();
+    const hasAnySelection = Object.values(selectedIDEs).some(Boolean);
+    // Interactive mode if no flags provided
+    if (!hasAnySelection) {
+        console.log('');
+        const tools = await checkbox({
+            message: 'Which AI tools do you want to configure?',
+            choices: IDE_CONFIGS.map((ide) => ({
+                name: ide.name,
+                value: ide.value,
+                checked: ide.value === 'claude', // Default check Claude
+            })),
+        });
+        if (tools.length === 0) {
+            console.log('\nNo tools selected. Exiting.');
+            process.exit(0);
+        }
+        for (const tool of tools) {
+            selectedIDEs[tool] = true;
+        }
+        // Ask about hiding from git in interactive mode
+        if (!values.hidden) {
+            hiddenSelected = await confirm({
+                message: 'Hide AI QAKit directories from git? (adds to .git/info/exclude)',
+                default: false,
+            });
+        }
+    }
+    // Check for existing installations
+    const existingDirs = [];
+    const updateDirs = [];
+    for (const ide of IDE_CONFIGS) {
+        if (!selectedIDEs[ide.value])
+            continue;
+        const targetDir = join(cwd, ide.dir);
+        if (existsSync(targetDir)) {
+            const manifest = readManifest(targetDir);
+            if (manifest) {
+                updateDirs.push(ide.label);
+            }
+            else {
+                existingDirs.push(ide.label);
+            }
+        }
+    }
+    // Handle update scenario (has manifest)
+    if (updateDirs.length > 0) {
+        isUpdate = true;
+        if (!hasAnySelection && !values.backup) {
+            console.log(`\nExisting AI QAKit installation detected in ${updateDirs.join(', ')}`);
+            backupSelected = await confirm({
+                message: 'Create a backup before updating?',
+                default: true,
+            });
+            if (!backupSelected) {
+                const shouldOverride = await confirm({
+                    message: `Are you sure you want to override ${updateDirs.join(', ')}?`,
+                    default: false,
+                });
+                if (!shouldOverride) {
+                    console.log('\nOperation cancelled.');
+                    process.exit(0);
+                }
+                forceFromPrompt = true;
+            }
+        }
+    }
+    // Handle existing dirs without manifest
+    if (existingDirs.length > 0 && !values.force && !hasAnySelection) {
+        console.log(`\n${existingDirs.join(', ')} exists but was not installed via AI QAKit.`);
+        backupSelected = await confirm({
+            message: 'Create a backup before overwriting?',
+            default: true,
+        });
+        if (!backupSelected) {
+            const shouldOverride = await confirm({
+                message: `Are you sure you want to override ${existingDirs.join(', ')}?`,
+                default: false,
+            });
+            if (!shouldOverride) {
+                console.log('\nOperation cancelled.');
+                process.exit(0);
+            }
+            forceFromPrompt = true;
+        }
+    }
+    await initCommand({
+        force: values.force || backupSelected || isUpdate || forceFromPrompt,
+        ...selectedIDEs,
+        hidden: hiddenSelected,
+        backup: backupSelected,
+        isUpdate,
+    });
+}
+main().catch((error) => {
+    console.error('Error:', error.message);
+    process.exit(1);
+});

package/dist/commands/clean.d.ts

@@ -0,0 +1,10 @@
+export interface CleanOptions {
+    claude: boolean;
+    cursor: boolean;
+    kiro: boolean;
+    antigravity: boolean;
+    codex: boolean;
+    force: boolean;
+    _cwd?: string;
+}
+export declare function cleanCommand(options: CleanOptions): Promise<void>;

package/dist/commands/clean.js

@@ -0,0 +1,53 @@
+import { existsSync, rmSync } from 'fs';
+import { join } from 'path';
+import { log, readManifest } from '../utils/index.js';
+const IDE_CONFIGS = [
+    { platform: 'claude', dir: '.claude', label: 'Claude Code' },
+    { platform: 'cursor', dir: '.cursor', label: 'Cursor IDE' },
+    { platform: 'kiro', dir: '.kiro', label: 'Kiro IDE' },
+    { platform: 'antigravity', dir: '.antigravity', label: 'Google Antigravity' },
+    { platform: 'codex', dir: '.codex', label: 'OpenAI Codex' },
+];
+export async function cleanCommand(options) {
+    const cwd = options._cwd ?? process.cwd();
+    log.normal('');
+    log.title('🧹 AI QAKit Clean');
+    log.normal('');
+    const cleanedDirs = [];
+    const skippedDirs = [];
+    for (const config of IDE_CONFIGS) {
+        if (!options[config.platform])
+            continue;
+        const targetDir = join(cwd, config.dir);
+        if (!existsSync(targetDir)) {
+            log.muted(`   ${config.dir} does not exist, skipping...`);
+            continue;
+        }
+        const manifest = readManifest(targetDir);
+        if (!manifest && !options.force) {
+            log.warn(`⚠️  ${config.dir} was not installed via AI QAKit.`);
+            log.muted('   Use --force to remove anyway.');
+            skippedDirs.push(config.dir);
+            continue;
+        }
+        try {
+            rmSync(targetDir, { recursive: true, force: true });
+            log.success(`✅ Removed ${config.dir}`);
+            cleanedDirs.push(config.dir);
+        }
+        catch (error) {
+            log.error(`❌ Failed to remove ${config.dir}: ${error.message}`);
+        }
+    }
+    log.normal('');
+    if (cleanedDirs.length > 0) {
+        log.success(`🧹 Cleaned: ${cleanedDirs.join(', ')}`);
+    }
+    if (skippedDirs.length > 0) {
+        log.warn(`⚠️  Skipped: ${skippedDirs.join(', ')}`);
+    }
+    if (cleanedDirs.length === 0 && skippedDirs.length === 0) {
+        log.muted('   Nothing to clean.');
+    }
+    log.normal('');
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,20 @@
+import type { Platform } from '../utils/manifest.js';
+export interface InitOptions {
+    force: boolean;
+    claude: boolean;
+    cursor: boolean;
+    kiro: boolean;
+    antigravity: boolean;
+    codex: boolean;
+    hidden: boolean;
+    backup?: boolean;
+    isUpdate?: boolean;
+    /** For testing: override template paths */
+    _templatePaths?: Record<Platform, string>;
+    /** For testing: override working directory */
+    _cwd?: string;
+}
+/**
+ * Init command - copies IDE directories to current working directory
+ */
+export declare function initCommand(options: InitOptions): Promise<void>;