@archznn/xavva 2.9.0 → 3.1.0

package/src/services/TestService.ts

@@ -0,0 +1,326 @@
+/**
+ * Serviço de execução de testes
+ * Suporta Maven e Gradle com modo watch
+ */
+
+import { Logger } from "../utils/ui";
+import { spawn } from "child_process";
+import { watch, type FSWatcher } from "fs";
+import path from "path";
+import { promisify } from "util";
+
+export interface TestOptions {
+    watch?: boolean;
+    coverage?: boolean;
+    filter?: string;
+    verbose?: boolean;
+    failFast?: boolean;
+    parallel?: boolean;
+}
+
+export interface TestResult {
+    success: boolean;
+    totalTests: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration: number;
+    failures: TestFailure[];
+}
+
+export interface TestFailure {
+    className: string;
+    methodName: string;
+    message: string;
+    stackTrace?: string;
+}
+
+export class TestService {
+    private buildTool: "maven" | "gradle";
+    private watcher: FSWatcher | null = null;
+    private isRunning = false;
+
+    constructor(buildTool: "maven" | "gradle") {
+        this.buildTool = buildTool;
+    }
+
+    async runTests(options: TestOptions = {}): Promise<TestResult> {
+        if (this.isRunning) {
+            Logger.warn("Test execution already in progress...");
+            return this.createEmptyResult();
+        }
+
+        this.isRunning = true;
+        const startTime = Date.now();
+
+        try {
+            Logger.section("Running Tests");
+            
+            if (options.filter) {
+                Logger.info("Filter", options.filter);
+            }
+            if (options.coverage) {
+                Logger.info("Coverage", "enabled");
+            }
+
+            const command = this.buildCommand(options);
+            const result = await this.executeTests(command, options.verbose);
+            
+            result.duration = Date.now() - startTime;
+            this.printResults(result);
+            
+            return result;
+        } finally {
+            this.isRunning = false;
+            Logger.endSection();
+        }
+    }
+
+    startWatch(options: TestOptions = {}): void {
+        if (this.watcher) {
+            Logger.warn("Test watcher already running");
+            return;
+        }
+
+        Logger.section("Test Watch Mode");
+        Logger.info("Watching", "src/test/**/*");
+        Logger.info("Press", "Ctrl+C to stop");
+        Logger.endSection();
+
+        // Run tests initially
+        this.runTests(options);
+
+        // Watch for changes
+        const testPath = path.join(process.cwd(), "src", "test");
+        const mainPath = path.join(process.cwd(), "src", "main");
+
+        this.watcher = watch(
+            [testPath, mainPath],
+            { recursive: true },
+            (eventType, filename) => {
+                if (filename && this.isTestFile(filename)) {
+                    Logger.watch(`Test file changed: ${filename}`);
+                    this.debounceRun(options);
+                }
+            }
+        );
+    }
+
+    stopWatch(): void {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+            Logger.info("Test watcher stopped");
+        }
+    }
+
+    private debounceRun(options: TestOptions): void {
+        // Simple debounce
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.runTests(options);
+        }, 500);
+    }
+
+    private debounceTimer: Timer | null = null;
+
+    private buildCommand(options: TestOptions): string[] {
+        if (this.buildTool === "maven") {
+            return this.buildMavenCommand(options);
+        } else {
+            return this.buildGradleCommand(options);
+        }
+    }
+
+    private buildMavenCommand(options: TestOptions): string[] {
+        const cmd = process.platform === "win32" ? "mvn.cmd" : "mvn";
+        const args: string[] = [cmd];
+
+        if (options.coverage) {
+            args.push("jacoco:prepare-agent");
+        }
+
+        args.push("test");
+
+        if (options.coverage) {
+            args.push("jacoco:report");
+        }
+
+        if (options.filter) {
+            // Maven surefire plugin syntax
+            args.push(`-Dtest=${options.filter}`);
+        }
+
+        if (options.failFast) {
+            args.push("-Dsurefire.failIfNoSpecifiedTests=false");
+        }
+
+        if (options.parallel) {
+            args.push("-Dsurefire.parallel=methods");
+            args.push("-Dsurefire.threadCount=4");
+        }
+
+        if (!options.verbose) {
+            args.push("-q");
+        }
+
+        return args;
+    }
+
+    private buildGradleCommand(options: TestOptions): string[] {
+        const cmd = process.platform === "win32" ? "gradle.bat" : "gradle";
+        const args: string[] = [cmd, "test"];
+
+        if (options.coverage) {
+            args.push("jacocoTestReport");
+        }
+
+        if (options.filter) {
+            args.push(`--tests`, options.filter);
+        }
+
+        if (options.failFast) {
+            args.push("--fail-fast");
+        }
+
+        if (options.parallel) {
+            args.push("--parallel");
+        }
+
+        if (!options.verbose) {
+            args.push("-q");
+        }
+
+        return args;
+    }
+
+    private executeTests(command: string[], verbose: boolean = false): Promise<TestResult> {
+        return new Promise((resolve) => {
+            const [cmd, ...args] = command;
+            const child = spawn(cmd, args, {
+                cwd: process.cwd(),
+                stdio: verbose ? "inherit" : "pipe",
+                shell: process.platform === "win32"
+            });
+
+            let stdout = "";
+            let stderr = "";
+
+            if (!verbose) {
+                child.stdout?.on("data", (data) => {
+                    stdout += data.toString();
+                });
+                child.stderr?.on("data", (data) => {
+                    stderr += data.toString();
+                });
+            }
+
+            const spinner = verbose ? () => {} : Logger.spinner("Running tests");
+
+            child.on("close", (code) => {
+                spinner(code === 0);
+                const result = this.parseTestOutput(stdout + stderr, code === 0);
+                resolve(result);
+            });
+
+            child.on("error", (error) => {
+                spinner(false);
+                Logger.error(`Failed to run tests: ${error.message}`);
+                resolve(this.createEmptyResult());
+            });
+        });
+    }
+
+    private parseTestOutput(output: string, success: boolean): TestResult {
+        const result: TestResult = {
+            success,
+            totalTests: 0,
+            passed: 0,
+            failed: 0,
+            skipped: 0,
+            duration: 0,
+            failures: []
+        };
+
+        if (this.buildTool === "maven") {
+            // Parse Maven Surefire output
+            const testsRun = output.match(/Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+),\s*Skipped:\s*(\d+)/);
+            if (testsRun) {
+                result.totalTests = parseInt(testsRun[1]);
+                result.failed = parseInt(testsRun[2]) + parseInt(testsRun[3]);
+                result.skipped = parseInt(testsRun[4]);
+                result.passed = result.totalTests - result.failed - result.skipped;
+            }
+
+            // Parse failures
+            const failureMatches = output.matchAll(/\[ERROR\]\s+(\S+)\.(\S+)\s+\[(.+?)\]\s+(.+)/g);
+            for (const match of failureMatches) {
+                result.failures.push({
+                    className: match[1],
+                    methodName: match[2],
+                    message: match[4]
+                });
+            }
+        } else {
+            // Parse Gradle output
+            const testsRun = output.match(/(\d+) tests completed,(\s*\d+ failed)?/);
+            if (testsRun) {
+                result.totalTests = parseInt(testsRun[1]);
+                const failed = testsRun[2] ? parseInt(testsRun[2].trim()) : 0;
+                result.failed = failed;
+                result.passed = result.totalTests - result.failed;
+            }
+        }
+
+        return result;
+    }
+
+    private printResults(result: TestResult): void {
+        Logger.divider();
+        
+        if (result.success && result.failed === 0) {
+            Logger.success(`All tests passed! (${result.passed} tests)`);
+        } else if (result.failed > 0) {
+            Logger.error(`${result.failed} test(s) failed`);
+        }
+
+        Logger.info("Total", result.totalTests);
+        Logger.info("Passed", `${Logger.C.success}${result.passed}${Logger.C.reset}`);
+        Logger.info("Failed", result.failed > 0 ? `${Logger.C.error}${result.failed}${Logger.C.reset}` : "0");
+        Logger.info("Skipped", result.skipped);
+        Logger.info("Duration", `${(result.duration / 1000).toFixed(2)}s`);
+
+        if (result.failures.length > 0) {
+            Logger.divider();
+            Logger.section("Failures");
+            for (const failure of result.failures.slice(0, 5)) {
+                Logger.error(`${failure.className}.${failure.methodName}`);
+                Logger.dim(`  ${failure.message}`);
+            }
+            if (result.failures.length > 5) {
+                Logger.dim(`  ... and ${result.failures.length - 5} more`);
+            }
+            Logger.endSection();
+        }
+    }
+
+    private isTestFile(filename: string): boolean {
+        return filename.endsWith("Test.java") || 
+               filename.endsWith("IT.java") || 
+               filename.endsWith("Tests.java");
+    }
+
+    private createEmptyResult(): TestResult {
+        return {
+            success: false,
+            totalTests: 0,
+            passed: 0,
+            failed: 0,
+            skipped: 0,
+            duration: 0,
+            failures: []
+        };
+    }
+}

package/src/types/args.ts

@@ -9,6 +9,7 @@ export interface BaseArgs {
     version?: boolean;
     verbose?: boolean;
     quiet?: boolean;
+    "debug-level"?: "silent" | "error" | "warn" | "info" | "verbose" | "trace" | "silly";
 }
 
 // ===== Args de Configuração de Projeto =====

package/src/types/config.ts

@@ -1,3 +1,16 @@
+export interface EnvironmentConfig {
+    port?: number;
+    profile?: string;
+    db?: {
+        url?: string;
+        username?: string;
+        password?: string;
+        driver?: string;
+    };
+    tomcat?: Partial<TomcatConfig>;
+    env?: Record<string, string>;
+}
+
 export interface TomcatConfig {
     path: string;
     port: number;
@@ -24,6 +37,8 @@ export interface ProjectConfig {
     encoding?: string;
     war?: boolean;
     cache?: boolean;
+    environment?: string;
+    environments?: Record<string, EnvironmentConfig>;
 }
 
 export interface AppConfig {
@@ -68,6 +83,29 @@ export interface CLIArguments {
     "dry-run"?: boolean;
     force?: boolean;
     src?: string;
+    // Multi-environment
+    env?: string;
+    environment?: string;
+    // Test runner
+    coverage?: boolean;
+    "fail-fast"?: boolean;
+    parallel?: boolean;
+    // HTTP client
+    interactive?: boolean;
+    "base-url"?: string;
+    body?: string;
+    file?: string;
+    header?: string | string[];
+    "content-type"?: string;
+    accept?: string;
+    param?: string | string[];
+    timeout?: string;
+    // Docker
+    tag?: string;
+    "java-version"?: string;
+    detached?: boolean;
+    registry?: string;
+    namespace?: string;
 }
 
 export interface CommandContext {

package/src/utils/ChangelogGenerator.ts

@@ -0,0 +1,255 @@
+import { execSync } from "child_process";
+import { writeFileSync } from "fs";
+import { join } from "path";
+
+interface Commit {
+    hash: string;
+    date: string;
+    message: string;
+    type: string;
+    scope?: string;
+    subject: string;
+    breaking: boolean;
+}
+
+interface Version {
+    version: string;
+    date: string;
+    commits: Commit[];
+}
+
+export class ChangelogGenerator {
+    private static readonly TYPES: Record<string, { title: string; emoji: string }> = {
+        feat: { title: "Features", emoji: "✨" },
+        fix: { title: "Bug Fixes", emoji: "🐛" },
+        docs: { title: "Documentation", emoji: "📚" },
+        style: { title: "Styles", emoji: "💎" },
+        refactor: { title: "Code Refactoring", emoji: "♻️" },
+        perf: { title: "Performance", emoji: "⚡" },
+        test: { title: "Tests", emoji: "🧪" },
+        build: { title: "Build System", emoji: "🏗️" },
+        ci: { title: "CI/CD", emoji: "🔄" },
+        chore: { title: "Chores", emoji: "🔧" },
+        revert: { title: "Reverts", emoji: "⏪" },
+    };
+
+    static generate(): string {
+        const commits = this.getCommits();
+        const versions = this.groupByVersion(commits);
+        return this.formatChangelog(versions);
+    }
+
+    static generateAndSave(outputPath: string = "CHANGELOG.md"): void {
+        const changelog = this.generate();
+        writeFileSync(outputPath, changelog);
+    }
+
+    private static getCommits(): Commit[] {
+        try {
+            // Get commits in format: hash|date|message
+            const log = execSync(
+                'git log --pretty=format:"%h|%ad|%s" --date=short --no-merges',
+                { encoding: "utf-8", cwd: process.cwd() }
+            );
+
+            return log
+                .trim()
+                .split("\n")
+                .map(line => this.parseCommit(line))
+                .filter((c): c is Commit => c !== null);
+        } catch {
+            return [];
+        }
+    }
+
+    private static parseCommit(line: string): Commit | null {
+        const match = line.match(/^([^|]+)\|([^|]+)\|(.+)$/);
+        if (!match) return null;
+
+        const [, hash, date, message] = match;
+        const parsed = this.parseConventionalCommit(message);
+
+        return {
+            hash,
+            date,
+            message,
+            ...parsed,
+        };
+    }
+
+    private static parseConventionalCommit(message: string): Omit<Commit, "hash" | "date" | "message"> {
+        // Pattern: type(scope)!: subject
+        // or: type!: subject
+        // or: type(scope): subject
+        // or: type: subject
+        const pattern = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)$/;
+        const match = message.match(pattern);
+
+        if (match) {
+            const [, type, scope, breaking, subject] = match;
+            return {
+                type,
+                scope,
+                subject,
+                breaking: !!breaking || subject.includes("BREAKING CHANGE"),
+            };
+        }
+
+        // Fallback: treat as chore if doesn't match conventional commit
+        return {
+            type: "chore",
+            subject: message,
+            breaking: message.includes("BREAKING CHANGE"),
+        };
+    }
+
+    private static groupByVersion(commits: Commit[]): Version[] {
+        // Group by version tags
+        const versions: Version[] = [];
+        let currentVersion = "Unreleased";
+        let currentDate = new Date().toISOString().split("T")[0];
+        let currentCommits: Commit[] = [];
+
+        // Try to get version tags
+        const tags = this.getVersionTags();
+        
+        if (tags.length === 0) {
+            // No tags, all commits are unreleased
+            return [{
+                version: "Unreleased",
+                date: currentDate,
+                commits,
+            }];
+        }
+
+        // Process commits and assign to versions
+        const versionMap = new Map<string, Commit[]>();
+        
+        for (const commit of commits) {
+            // Find which version this commit belongs to
+            const version = this.findVersionForCommit(commit.hash, tags);
+            if (!versionMap.has(version)) {
+                versionMap.set(version, []);
+            }
+            versionMap.get(version)!.push(commit);
+        }
+
+        // Convert to array
+        for (const [version, versionCommits] of versionMap) {
+            const tagDate = this.getTagDate(version === "Unreleased" ? null : version);
+            versions.push({
+                version,
+                date: tagDate || currentDate,
+                commits: versionCommits,
+            });
+        }
+
+        // Sort by version (newest first)
+        return versions.sort((a, b) => this.compareVersions(b.version, a.version));
+    }
+
+    private static getVersionTags(): string[] {
+        try {
+            const tags = execSync("git tag -l 'v*' --sort=-v:refname", { encoding: "utf-8" });
+            return tags.trim().split("\n").filter(Boolean);
+        } catch {
+            return [];
+        }
+    }
+
+    private static findVersionForCommit(hash: string, tags: string[]): string {
+        try {
+            // Check if commit is after a specific tag
+            for (const tag of tags) {
+                const result = execSync(`git merge-base --is-ancestor ${hash} ${tag} && echo "in" || echo "out"`, {
+                    encoding: "utf-8",
+                    cwd: process.cwd(),
+                });
+                if (result.trim() === "in") {
+                    return tag;
+                }
+            }
+        } catch {
+            // Ignore errors
+        }
+        return "Unreleased";
+    }
+
+    private static getTagDate(tag: string | null): string | null {
+        if (!tag) return null;
+        try {
+            const date = execSync(`git log -1 --format=%ad --date=short ${tag}`, { encoding: "utf-8" });
+            return date.trim();
+        } catch {
+            return null;
+        }
+    }
+
+    private static compareVersions(a: string, b: string): number {
+        if (a === "Unreleased") return -1;
+        if (b === "Unreleased") return 1;
+        
+        const parse = (v: string) => v.replace(/^v/, "").split(".").map(Number);
+        const aParts = parse(a);
+        const bParts = parse(b);
+        
+        for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+            const aPart = aParts[i] || 0;
+            const bPart = bParts[i] || 0;
+            if (aPart !== bPart) return aPart - bPart;
+        }
+        return 0;
+    }
+
+    private static formatChangelog(versions: Version[]): string {
+        const lines: string[] = [
+            "# Changelog\n",
+            "All notable changes to this project will be documented in this file.\n",
+            "The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),",
+            "and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n",
+        ];
+
+        for (const version of versions) {
+            lines.push(this.formatVersion(version));
+        }
+
+        return lines.join("\n");
+    }
+
+    private static formatVersion(version: Version): string {
+        const lines: string[] = [
+            `## [${version.version}] - ${version.date}`,
+            "",
+        ];
+
+        // Group commits by type
+        const byType = new Map<string, Commit[]>();
+        for (const commit of version.commits) {
+            if (!byType.has(commit.type)) {
+                byType.set(commit.type, []);
+            }
+            byType.get(commit.type)!.push(commit);
+        }
+
+        // Output in conventional order
+        const typeOrder = Object.keys(this.TYPES);
+        
+        for (const type of typeOrder) {
+            const commits = byType.get(type);
+            if (!commits || commits.length === 0) continue;
+
+            const { title, emoji } = this.TYPES[type];
+            lines.push(`### ${emoji} ${title}\n`);
+
+            for (const commit of commits) {
+                const scope = commit.scope ? `**${commit.scope}**: ` : "";
+                const breaking = commit.breaking ? " 💥 **BREAKING CHANGE**" : "";
+                lines.push(`- ${scope}${commit.subject} ([${commit.hash}])${breaking}`);
+            }
+
+            lines.push("");
+        }
+
+        return lines.join("\n");
+    }
+}