ai-qakit 1.0.0

package/dist/commands/init.js

@@ -0,0 +1,195 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { log, copyDir, backupDir, getPackageVersion, getTemplatesDir, runSetupScript, addToGitExclude, cleanupEmptyDirs, createManifest, deleteRemovedFiles, getAllFiles, getFilesToDelete, readManifest, writeManifest, } from '../utils/index.js';
+const IDE_CONFIGS = [
+    {
+        platform: 'claude',
+        dir: '.claude',
+        label: 'Claude Code',
+        description: [
+            '  • .claude/agents/     - AI agent configurations',
+            '  • .claude/commands/   - Custom slash commands',
+            '  • .claude/skills/     - AI skills and references',
+            '  • .claude/workflows/  - QA workflows',
+            '  • .claude/CLAUDE.md   - Main configuration file',
+        ],
+    },
+    {
+        platform: 'cursor',
+        dir: '.cursor',
+        label: 'Cursor IDE',
+        description: [
+            '  • .cursor/rules/      - Cursor IDE rules',
+            '  • .cursor/commands/   - Command templates',
+        ],
+    },
+    {
+        platform: 'kiro',
+        dir: '.kiro',
+        label: 'Kiro IDE',
+        description: [
+            '  • .kiro/steering/     - Steering files',
+            '  • .kiro/specs/        - Spec templates',
+        ],
+    },
+    {
+        platform: 'antigravity',
+        dir: '.antigravity',
+        label: 'Google Antigravity',
+        description: [
+            '  • .antigravity/agents/  - Agent configurations',
+            '  • .antigravity/prompts/ - Custom prompts',
+        ],
+    },
+    {
+        platform: 'codex',
+        dir: '.codex',
+        label: 'OpenAI Codex',
+        description: [
+            '  • .codex/prompts/       - Custom prompts',
+            '  • .codex/config.toml    - Configuration file',
+        ],
+    },
+];
+/**
+ * Process a single IDE installation/update
+ */
+async function processIDE(config, options, cwd, templates) {
+    const targetDir = join(cwd, config.dir);
+    const templateDir = templates[config.platform];
+    // Check if template exists
+    if (!existsSync(templateDir)) {
+        log.warn(`⚠️  ${config.label} templates not found, skipping...`);
+        log.muted(`   Looking for: ${templateDir}`);
+        return false;
+    }
+    // Check existing directory
+    if (existsSync(targetDir) && !options.force) {
+        log.warn(`⚠️  ${config.dir} directory already exists.`);
+        log.muted('   Use --force to overwrite.');
+        return false;
+    }
+    // Backup if requested
+    if (options.backup && existsSync(targetDir)) {
+        const backupPath = join(cwd, `${config.dir}-bak`);
+        log.normal(`💾 Backing up ${config.dir} directory...`);
+        await backupDir(targetDir, backupPath);
+        log.muted(`   Backup created at ${config.dir}-bak/`);
+    }
+    const newFiles = getAllFiles(templateDir);
+    const existingManifest = readManifest(targetDir);
+    // Handle update mode
+    if (options.isUpdate && existingManifest) {
+        log.normal(`🔄 Updating ${config.dir} directory...`);
+        const filesToDelete = getFilesToDelete(existingManifest, newFiles);
+        if (filesToDelete.length > 0) {
+            const deleted = deleteRemovedFiles(targetDir, filesToDelete);
+            cleanupEmptyDirs(targetDir, deleted);
+            log.muted(`   Removed ${deleted.length} obsolete file(s)`);
+        }
+    }
+    else {
+        log.normal(`📦 Copying ${config.dir} directory...`);
+    }
+    // Copy files
+    await copyDir(templateDir, targetDir, options.force);
+    // Write manifest
+    const manifest = createManifest(getPackageVersion(), config.platform, newFiles);
+    if (existingManifest) {
+        manifest.installedAt = existingManifest.installedAt;
+    }
+    writeManifest(targetDir, manifest);
+    if (options.isUpdate) {
+        log.success(`✅ ${config.dir} directory updated!`);
+    }
+    else {
+        log.success(`✅ ${config.dir} directory copied successfully!`);
+    }
+    return true;
+}
+/**
+ * Init command - copies IDE directories to current working directory
+ */
+export async function initCommand(options) {
+    const cwd = options._cwd ?? process.cwd();
+    const templates = options._templatePaths ?? getTemplatesDir();
+    log.normal('');
+    log.title('🚀 Enouvo AI QAKit');
+    log.normal('');
+    const processedIDEs = [];
+    try {
+        // Process each selected IDE
+        for (const config of IDE_CONFIGS) {
+            if (!options[config.platform])
+                continue;
+            const success = await processIDE(config, options, cwd, templates);
+            if (success) {
+                processedIDEs.push(config);
+            }
+        }
+        if (processedIDEs.length === 0) {
+            log.warn('⚠️  No IDEs were configured.');
+            process.exit(1);
+        }
+        // Print success message
+        log.normal('');
+        log.success('✨ AI QAKit initialized successfully!');
+        log.normal('');
+        log.normal('What was added:');
+        for (const config of processedIDEs) {
+            for (const line of config.description) {
+                log.muted(line);
+            }
+        }
+        // Handle --hidden flag
+        if (options.hidden) {
+            const entriesToHide = processedIDEs.map((c) => `${c.dir}/`);
+            entriesToHide.push('.repomixignore', 'repomix-output.xml');
+            const added = addToGitExclude(cwd, entriesToHide);
+            if (added) {
+                log.success('🙈 Added to .git/info/exclude (hidden from git)');
+            }
+            else {
+                log.warn('⚠️  Not a git repository, skipped hiding from git');
+            }
+        }
+        // Run setup script for Claude if installed
+        if (options.claude && processedIDEs.some((c) => c.platform === 'claude')) {
+            log.normal('');
+            log.normal('📦 Running setup script...');
+            const result = runSetupScript(join(cwd, '.claude'));
+            if (result.success) {
+                log.success('✅ Setup completed successfully!');
+            }
+            else {
+                log.muted(`   ${result.message}`);
+            }
+        }
+        // Print next steps
+        log.normal('');
+        log.heading('Next steps:');
+        if (processedIDEs.some((c) => c.platform === 'claude')) {
+            log.muted('  1. Review and customize .claude/CLAUDE.md for your project');
+            log.muted('  2. Explore QA commands in .claude/commands/qakit/');
+        }
+        if (processedIDEs.some((c) => c.platform === 'cursor')) {
+            log.muted('  • Check .cursor/rules/ for QA rules');
+        }
+        if (processedIDEs.some((c) => c.platform === 'kiro')) {
+            log.muted('  • Check .kiro/steering/ for QA steering files');
+        }
+        if (processedIDEs.some((c) => c.platform === 'antigravity')) {
+            log.muted('  • Check .antigravity/agents/ for QA agents');
+        }
+        if (processedIDEs.some((c) => c.platform === 'codex')) {
+            log.muted('  • Check .codex/prompts/ for QA prompts');
+        }
+        log.muted('  • Start using AI-assisted QA with your enhanced capabilities!');
+        log.normal('');
+    }
+    catch (error) {
+        log.error('❌ Failed to copy files.');
+        log.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { initCommand } from './commands/init.js';
+export type { InitOptions } from './commands/init.js';
+export * from './utils/index.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { initCommand } from './commands/init.js';
+export * from './utils/index.js';

package/dist/utils/file-operations.d.ts

@@ -0,0 +1,18 @@
+export interface SetupResult {
+    success: boolean;
+    message: string;
+}
+/**
+ * Run the appropriate setup script based on the operating system
+ * @param targetDir - Path to the directory containing setup scripts
+ * @returns Result indicating success or failure with a message
+ */
+export declare function runSetupScript(targetDir: string): SetupResult;
+/**
+ * Copy directory recursively
+ */
+export declare function copyDir(src: string, dest: string, force: boolean): Promise<void>;
+/**
+ * Backup a directory before overwriting
+ */
+export declare function backupDir(sourceDir: string, targetBackupDir: string): Promise<boolean>;

package/dist/utils/file-operations.js

@@ -0,0 +1,79 @@
+import { existsSync } from 'fs';
+import { cp } from 'fs/promises';
+import { execSync, spawnSync } from 'child_process';
+import { join } from 'path';
+import { platform } from 'os';
+/**
+ * Run the appropriate setup script based on the operating system
+ * @param targetDir - Path to the directory containing setup scripts
+ * @returns Result indicating success or failure with a message
+ */
+export function runSetupScript(targetDir) {
+    const setupDir = join(targetDir, 'setup');
+    const isWindows = platform() === 'win32';
+    const scriptPath = isWindows
+        ? join(setupDir, 'setup.ps1')
+        : join(setupDir, 'setup.sh');
+    if (!existsSync(scriptPath)) {
+        return {
+            success: false,
+            message: `Setup script not found at ${scriptPath}`,
+        };
+    }
+    try {
+        if (isWindows) {
+            // Run PowerShell script on Windows
+            spawnSync('powershell', ['-ExecutionPolicy', 'Bypass', '-File', scriptPath], {
+                stdio: 'inherit',
+                cwd: setupDir,
+            });
+        }
+        else {
+            // Make script executable and run on macOS/Linux
+            execSync(`chmod +x "${scriptPath}"`, { cwd: setupDir });
+            spawnSync('bash', [scriptPath], {
+                stdio: 'inherit',
+                cwd: setupDir,
+            });
+        }
+        return {
+            success: true,
+            message: `Setup script completed successfully`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to run setup script: ${error.message}`,
+        };
+    }
+}
+/**
+ * Copy directory recursively
+ */
+export async function copyDir(src, dest, force) {
+    await cp(src, dest, {
+        recursive: true,
+        force,
+        errorOnExist: false,
+    });
+}
+/**
+ * Backup a directory before overwriting
+ */
+export async function backupDir(sourceDir, targetBackupDir) {
+    if (!existsSync(sourceDir)) {
+        return false;
+    }
+    // Remove existing backup if present
+    if (existsSync(targetBackupDir)) {
+        const { rm } = await import('fs/promises');
+        await rm(targetBackupDir, { recursive: true, force: true });
+    }
+    await cp(sourceDir, targetBackupDir, {
+        recursive: true,
+        force: true,
+        errorOnExist: false,
+    });
+    return true;
+}

package/dist/utils/git.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Add entries to .git/info/exclude to hide directories from git locally
+ */
+export declare function addToGitExclude(cwd: string, entries: string[]): boolean;

package/dist/utils/git.js

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync, appendFileSync } from 'fs';
+import { join } from 'path';
+/**
+ * Add entries to .git/info/exclude to hide directories from git locally
+ */
+export function addToGitExclude(cwd, entries) {
+    const gitExcludePath = join(cwd, '.git', 'info', 'exclude');
+    const gitDir = join(cwd, '.git');
+    // Check if .git directory exists
+    if (!existsSync(gitDir)) {
+        return false;
+    }
+    // Read existing exclude file content
+    let existingContent = '';
+    if (existsSync(gitExcludePath)) {
+        existingContent = readFileSync(gitExcludePath, 'utf-8');
+    }
+    // Filter out entries that are already in the file
+    const newEntries = entries.filter((entry) => !existingContent.includes(entry));
+    if (newEntries.length === 0) {
+        return true; // All entries already exist
+    }
+    // Append new entries
+    const contentToAdd = `\n# AI QAKit\n${newEntries.join('\n')}\n`;
+    appendFileSync(gitExcludePath, contentToAdd);
+    return true;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './logger.js';
+export * from './file-operations.js';
+export * from './git.js';
+export * from './package.js';
+export * from './manifest.js';

package/dist/utils/index.js

@@ -0,0 +1,5 @@
+export * from './logger.js';
+export * from './file-operations.js';
+export * from './git.js';
+export * from './package.js';
+export * from './manifest.js';

package/dist/utils/logger.d.ts

@@ -0,0 +1,22 @@
+export declare const colors: {
+    reset: string;
+    bold: string;
+    blue: string;
+    green: string;
+    yellow: string;
+    red: string;
+    gray: string;
+    cyan: string;
+    magenta: string;
+};
+export declare const log: {
+    normal: (msg: string) => void;
+    title: (msg: string) => void;
+    heading: (msg: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    muted: (msg: string) => void;
+    info: (msg: string) => void;
+    highlight: (msg: string) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,23 @@
+// ANSI color codes for terminal output
+export const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    blue: '\x1b[34m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    gray: '\x1b[90m',
+    cyan: '\x1b[36m',
+    magenta: '\x1b[35m',
+};
+export const log = {
+    normal: (msg) => console.log(msg),
+    title: (msg) => console.log(`${colors.bold}${msg}${colors.reset}`),
+    heading: (msg) => console.log(`${colors.blue}${msg}${colors.reset}`),
+    success: (msg) => console.log(`${colors.green}${msg}${colors.reset}`),
+    warn: (msg) => console.log(`${colors.yellow}${msg}${colors.reset}`),
+    error: (msg) => console.log(`${colors.red}${msg}${colors.reset}`),
+    muted: (msg) => console.log(`${colors.gray}${msg}${colors.reset}`),
+    info: (msg) => console.log(`${colors.cyan}${msg}${colors.reset}`),
+    highlight: (msg) => console.log(`${colors.magenta}${msg}${colors.reset}`),
+};

package/dist/utils/manifest.d.ts

@@ -0,0 +1,37 @@
+export declare const MANIFEST_FILENAME = ".ai-qakit-manifest.json";
+export type Platform = 'claude' | 'cursor' | 'kiro' | 'antigravity' | 'codex';
+export interface Manifest {
+    version: string;
+    installedAt: string;
+    updatedAt: string;
+    platform: Platform;
+    files: string[];
+}
+/**
+ * Get all files recursively from a directory
+ */
+export declare function getAllFiles(dir: string, baseDir?: string): string[];
+/**
+ * Read existing manifest from target directory
+ */
+export declare function readManifest(targetDir: string): Manifest | null;
+/**
+ * Write manifest to target directory
+ */
+export declare function writeManifest(targetDir: string, manifest: Manifest): void;
+/**
+ * Create a new manifest for initial installation
+ */
+export declare function createManifest(version: string, platform: Platform, files: string[]): Manifest;
+/**
+ * Calculate files to delete (in old manifest but not in new package)
+ */
+export declare function getFilesToDelete(oldManifest: Manifest, newFiles: string[]): string[];
+/**
+ * Delete files that were removed from package
+ */
+export declare function deleteRemovedFiles(targetDir: string, filesToDelete: string[]): string[];
+/**
+ * Clean up empty directories after file deletion
+ */
+export declare function cleanupEmptyDirs(targetDir: string, deletedFiles: string[]): void;

package/dist/utils/manifest.js

@@ -0,0 +1,120 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, rmdirSync } from 'fs';
+import { join, relative } from 'path';
+export const MANIFEST_FILENAME = '.ai-qakit-manifest.json';
+/**
+ * Get all files recursively from a directory
+ */
+export function getAllFiles(dir, baseDir = dir) {
+    const files = [];
+    if (!existsSync(dir)) {
+        return files;
+    }
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        // Skip manifest file itself
+        if (entry.name === MANIFEST_FILENAME) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            files.push(...getAllFiles(fullPath, baseDir));
+        }
+        else {
+            // Store relative path from base directory
+            files.push(relative(baseDir, fullPath));
+        }
+    }
+    return files.sort();
+}
+/**
+ * Read existing manifest from target directory
+ */
+export function readManifest(targetDir) {
+    const manifestPath = join(targetDir, MANIFEST_FILENAME);
+    if (!existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(manifestPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write manifest to target directory
+ */
+export function writeManifest(targetDir, manifest) {
+    const manifestPath = join(targetDir, MANIFEST_FILENAME);
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+}
+/**
+ * Create a new manifest for initial installation
+ */
+export function createManifest(version, platform, files) {
+    const now = new Date().toISOString();
+    return {
+        version,
+        installedAt: now,
+        updatedAt: now,
+        platform,
+        files: files.sort(),
+    };
+}
+/**
+ * Calculate files to delete (in old manifest but not in new package)
+ */
+export function getFilesToDelete(oldManifest, newFiles) {
+    const newFilesSet = new Set(newFiles);
+    return oldManifest.files.filter((file) => !newFilesSet.has(file));
+}
+/**
+ * Delete files that were removed from package
+ */
+export function deleteRemovedFiles(targetDir, filesToDelete) {
+    const deleted = [];
+    for (const file of filesToDelete) {
+        const fullPath = join(targetDir, file);
+        if (existsSync(fullPath)) {
+            try {
+                unlinkSync(fullPath);
+                deleted.push(file);
+            }
+            catch {
+                // Ignore errors (file might be locked, etc.)
+            }
+        }
+    }
+    return deleted;
+}
+/**
+ * Clean up empty directories after file deletion
+ */
+export function cleanupEmptyDirs(targetDir, deletedFiles) {
+    // Get unique parent directories
+    const dirs = new Set();
+    for (const file of deletedFiles) {
+        const parts = file.split('/');
+        for (let i = parts.length - 1; i > 0; i--) {
+            dirs.add(parts.slice(0, i).join('/'));
+        }
+    }
+    // Sort by depth (deepest first)
+    const sortedDirs = Array.from(dirs).sort((a, b) => b.split('/').length - a.split('/').length);
+    for (const dir of sortedDirs) {
+        const fullPath = join(targetDir, dir);
+        if (existsSync(fullPath)) {
+            try {
+                const contents = readdirSync(fullPath);
+                if (contents.length === 0) {
+                    // Use rmdir for empty directories
+                    rmdirSync(fullPath);
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+    }
+}

package/dist/utils/package.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Get the package root directory
+ * Works both in development (src/) and production (dist/)
+ */
+export declare function getPackageRoot(): string;
+/**
+ * Get the templates directory paths for all supported IDEs
+ */
+export declare function getTemplatesDir(): {
+    claude: string;
+    cursor: string;
+    kiro: string;
+    antigravity: string;
+    codex: string;
+};
+/**
+ * Get package version from package.json
+ */
+export declare function getPackageVersion(): string;

package/dist/utils/package.js

@@ -0,0 +1,47 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+/**
+ * Get the package root directory
+ * Works both in development (src/) and production (dist/)
+ */
+export function getPackageRoot() {
+    const cliDir = dirname(new URL(import.meta.url).pathname);
+    // Go up from utils/ to src/ or dist/, then up to package root
+    const root = join(cliDir, '..', '..');
+    // Verify we found the right directory by checking for package.json
+    if (existsSync(join(root, 'package.json'))) {
+        return root;
+    }
+    // Fallback: try one more level up (in case of nested dist structure)
+    const altRoot = join(root, '..');
+    if (existsSync(join(altRoot, 'package.json'))) {
+        return altRoot;
+    }
+    return root;
+}
+/**
+ * Get the templates directory paths for all supported IDEs
+ */
+export function getTemplatesDir() {
+    const packageRoot = getPackageRoot();
+    return {
+        claude: join(packageRoot, 'templates', '.claude'),
+        cursor: join(packageRoot, 'templates', '.cursor'),
+        kiro: join(packageRoot, 'templates', '.kiro'),
+        antigravity: join(packageRoot, 'templates', '.antigravity'),
+        codex: join(packageRoot, 'templates', '.codex'),
+    };
+}
+/**
+ * Get package version from package.json
+ */
+export function getPackageVersion() {
+    const packageJsonPath = join(getPackageRoot(), 'package.json');
+    try {
+        const { version } = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        return version;
+    }
+    catch {
+        return 'unknown';
+    }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "ai-qakit",
+  "version": "1.0.0",
+  "description": "AI QAKit CLI - Bootstrap your project with AI-assisted QA configurations, agents, commands, and skills for Claude Code, Cursor, Kiro, Antigravity, and Codex",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "ai-qakit": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/cli.js",
+    "dev": "npx ts-node src/cli.ts",
+    "start": "node dist/cli.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "qakit",
+    "qa",
+    "testing",
+    "automation",
+    "claude",
+    "cursor",
+    "kiro",
+    "antigravity",
+    "codex",
+    "cli",
+    "developer-tools",
+    "ai-agents"
+  ],
+  "author": "Enouvo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/user/ai-qakit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/user/ai-qakit/issues"
+  },
+  "homepage": "https://github.com/user/ai-qakit#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.14",
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.1.0"
+  }
+}