specweave 0.12.6 → 0.13.0

package/dist/src/metrics/utils/tier-classifier.d.ts

@@ -0,0 +1,61 @@
+/**
+ * DORA Tier Classifier
+ *
+ * Maps metric values to DORA performance tiers based on industry benchmarks
+ *
+ * @see https://dora.dev/ - DORA Research
+ */
+import { DORAType } from '../types.js';
+/**
+ * Classify Deployment Frequency
+ *
+ * Benchmarks (deploys per year):
+ * - Elite: >365 (on-demand, multiple per day)
+ * - High: 52-365 (weekly to daily)
+ * - Medium: 12-52 (monthly to weekly)
+ * - Low: <12 (less than monthly)
+ *
+ * @param deploysPerYear - Number of deployments per year
+ * @returns DORA tier
+ */
+export declare function classifyDeploymentFrequency(deploysPerYear: number): DORAType;
+/**
+ * Classify Lead Time for Changes
+ *
+ * Benchmarks (hours from commit to production):
+ * - Elite: <1 hour
+ * - High: 1 hour to 1 day (24 hours)
+ * - Medium: 1 day to 1 week (168 hours)
+ * - Low: 1 week to 1 month (720 hours)
+ *
+ * @param hours - Average lead time in hours
+ * @returns DORA tier
+ */
+export declare function classifyLeadTime(hours: number): DORAType;
+/**
+ * Classify Change Failure Rate
+ *
+ * Benchmarks (percentage of failed deployments):
+ * - Elite: <5%
+ * - High: 5-10%
+ * - Medium: 10-15%
+ * - Low: >15%
+ *
+ * @param percentage - Change failure rate (0-100)
+ * @returns DORA tier
+ */
+export declare function classifyChangeFailureRate(percentage: number): DORAType;
+/**
+ * Classify Mean Time to Recovery (MTTR)
+ *
+ * Benchmarks (minutes to recover from incident):
+ * - Elite: <60 minutes (1 hour)
+ * - High: 60 minutes to 1 day (1440 minutes)
+ * - Medium: 1 day to 1 week (10080 minutes)
+ * - Low: >1 week
+ *
+ * @param minutes - Average recovery time in minutes
+ * @returns DORA tier
+ */
+export declare function classifyMTTR(minutes: number): DORAType;
+//# sourceMappingURL=tier-classifier.d.ts.map

package/dist/src/metrics/utils/tier-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-classifier.d.ts","sourceRoot":"","sources":["../../../../src/metrics/utils/tier-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,cAAc,EAAE,MAAM,GAAG,QAAQ,CAM5E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAMxD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,CAMtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAMtD"}

package/dist/src/metrics/utils/tier-classifier.js

@@ -0,0 +1,100 @@
+/**
+ * DORA Tier Classifier
+ *
+ * Maps metric values to DORA performance tiers based on industry benchmarks
+ *
+ * @see https://dora.dev/ - DORA Research
+ */
+/**
+ * Classify Deployment Frequency
+ *
+ * Benchmarks (deploys per year):
+ * - Elite: >365 (on-demand, multiple per day)
+ * - High: 52-365 (weekly to daily)
+ * - Medium: 12-52 (monthly to weekly)
+ * - Low: <12 (less than monthly)
+ *
+ * @param deploysPerYear - Number of deployments per year
+ * @returns DORA tier
+ */
+export function classifyDeploymentFrequency(deploysPerYear) {
+    if (deploysPerYear === 0)
+        return 'N/A';
+    if (deploysPerYear > 365)
+        return 'Elite';
+    if (deploysPerYear >= 52)
+        return 'High';
+    if (deploysPerYear >= 12)
+        return 'Medium';
+    return 'Low';
+}
+/**
+ * Classify Lead Time for Changes
+ *
+ * Benchmarks (hours from commit to production):
+ * - Elite: <1 hour
+ * - High: 1 hour to 1 day (24 hours)
+ * - Medium: 1 day to 1 week (168 hours)
+ * - Low: 1 week to 1 month (720 hours)
+ *
+ * @param hours - Average lead time in hours
+ * @returns DORA tier
+ */
+export function classifyLeadTime(hours) {
+    if (hours === 0)
+        return 'N/A';
+    if (hours < 1)
+        return 'Elite';
+    if (hours < 24)
+        return 'High';
+    if (hours < 168)
+        return 'Medium'; // 7 days
+    return 'Low';
+}
+/**
+ * Classify Change Failure Rate
+ *
+ * Benchmarks (percentage of failed deployments):
+ * - Elite: <5%
+ * - High: 5-10%
+ * - Medium: 10-15%
+ * - Low: >15%
+ *
+ * @param percentage - Change failure rate (0-100)
+ * @returns DORA tier
+ */
+export function classifyChangeFailureRate(percentage) {
+    if (percentage < 0)
+        return 'N/A'; // Invalid
+    if (percentage < 5)
+        return 'Elite';
+    if (percentage < 10)
+        return 'High';
+    if (percentage < 15)
+        return 'Medium';
+    return 'Low';
+}
+/**
+ * Classify Mean Time to Recovery (MTTR)
+ *
+ * Benchmarks (minutes to recover from incident):
+ * - Elite: <60 minutes (1 hour)
+ * - High: 60 minutes to 1 day (1440 minutes)
+ * - Medium: 1 day to 1 week (10080 minutes)
+ * - Low: >1 week
+ *
+ * @param minutes - Average recovery time in minutes
+ * @returns DORA tier
+ */
+export function classifyMTTR(minutes) {
+    if (minutes === 0)
+        return 'N/A';
+    if (minutes < 60)
+        return 'Elite';
+    if (minutes < 1440)
+        return 'High'; // 24 hours
+    if (minutes < 10080)
+        return 'Medium'; // 7 days
+    return 'Low';
+}
+//# sourceMappingURL=tier-classifier.js.map

package/dist/src/metrics/utils/tier-classifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-classifier.js","sourceRoot":"","sources":["../../../../src/metrics/utils/tier-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,2BAA2B,CAAC,cAAsB;IAChE,IAAI,cAAc,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACvC,IAAI,cAAc,GAAG,GAAG;QAAE,OAAO,OAAO,CAAC;IACzC,IAAI,cAAc,IAAI,EAAE;QAAE,OAAO,MAAM,CAAC;IACxC,IAAI,cAAc,IAAI,EAAE;QAAE,OAAO,QAAQ,CAAC;IAC1C,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC5C,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9B,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,OAAO,CAAC;IAC9B,IAAI,KAAK,GAAG,EAAE;QAAE,OAAO,MAAM,CAAC;IAC9B,IAAI,KAAK,GAAG,GAAG;QAAE,OAAO,QAAQ,CAAC,CAAE,SAAS;IAC5C,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,yBAAyB,CAAC,UAAkB;IAC1D,IAAI,UAAU,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC,CAAE,UAAU;IAC7C,IAAI,UAAU,GAAG,CAAC;QAAE,OAAO,OAAO,CAAC;IACnC,IAAI,UAAU,GAAG,EAAE;QAAE,OAAO,MAAM,CAAC;IACnC,IAAI,UAAU,GAAG,EAAE;QAAE,OAAO,QAAQ,CAAC;IACrC,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAC,OAAe;IAC1C,IAAI,OAAO,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAChC,IAAI,OAAO,GAAG,EAAE;QAAE,OAAO,OAAO,CAAC;IACjC,IAAI,OAAO,GAAG,IAAI;QAAE,OAAO,MAAM,CAAC,CAAE,WAAW;IAC/C,IAAI,OAAO,GAAG,KAAK;QAAE,OAAO,QAAQ,CAAC,CAAE,SAAS;IAChD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/src/testing/test-generator.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Test Generator - Converts YAML Test Specifications to Executable TypeScript Tests
+ *
+ * Takes test-cases (YAML) and generates executable integration tests.
+ *
+ * Supports:
+ * - Skill activation tests
+ * - API integration tests (Jira, ADO, GitHub)
+ * - End-to-end workflow tests
+ * - Uses .env credentials for real API calls
+ */
+export interface TestSpec {
+    name: string;
+    description: string;
+    type?: 'skill_activation' | 'api_integration' | 'e2e_workflow';
+    input: {
+        prompt?: string;
+        api_call?: {
+            method: string;
+            endpoint: string;
+            body?: any;
+            headers?: Record<string, string>;
+        };
+        setup?: string[];
+    };
+    expected_output: {
+        skill_activated?: boolean;
+        agent_invoked?: string;
+        api_response?: {
+            status: number;
+            body?: any;
+        };
+        files_created?: string[];
+        result?: any;
+    };
+    requires?: {
+        env_vars?: string[];
+        credentials?: string[];
+    };
+}
+export interface GeneratedTest {
+    skillName: string;
+    testFilePath: string;
+    testCount: number;
+    content: string;
+}
+export declare class TestGenerator {
+    private projectRoot;
+    private testSpecsDir;
+    private testOutputDir;
+    constructor(projectRoot?: string);
+    /**
+     * Generate tests for a specific skill
+     */
+    generateTestsForSkill(skillName: string): Promise<GeneratedTest | null>;
+    /**
+     * Generate tests for all skills
+     */
+    generateAllTests(): Promise<GeneratedTest[]>;
+    /**
+     * Load test spec from YAML file
+     */
+    private loadTestSpec;
+    /**
+     * Generate TypeScript test file from specs
+     */
+    private generateTestFile;
+    /**
+     * Generate file header with imports
+     */
+    private generateFileHeader;
+    /**
+     * Generate test class
+     */
+    private generateTestClass;
+    /**
+     * Generate individual test method
+     */
+    private generateTestMethod;
+    /**
+     * Generate skill activation test logic
+     */
+    private generateSkillActivationTest;
+    /**
+     * Generate API integration test logic
+     */
+    private generateApiIntegrationTest;
+    /**
+     * Generate generic test logic
+     */
+    private generateGenericTest;
+    /**
+     * Generate report method
+     */
+    private generateReportMethod;
+    /**
+     * Generate test runner
+     */
+    private generateTestRunner;
+    /**
+     * Format skill name for display
+     */
+    private formatSkillName;
+    /**
+     * Format class name
+     */
+    private formatClassName;
+    /**
+     * Convert to camelCase - sanitizes all special characters
+     */
+    private camelCase;
+    /**
+     * Escape string for use in single-quoted JavaScript strings
+     */
+    private escapeString;
+}
+//# sourceMappingURL=test-generator.d.ts.map

package/dist/src/testing/test-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-generator.d.ts","sourceRoot":"","sources":["../../../src/testing/test-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,kBAAkB,GAAG,iBAAiB,GAAG,cAAc,CAAC;IAC/D,KAAK,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE;YACT,MAAM,EAAE,MAAM,CAAC;YACf,QAAQ,EAAE,MAAM,CAAC;YACjB,IAAI,CAAC,EAAE,GAAG,CAAC;YACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;SAClC,CAAC;QACF,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;KAClB,CAAC;IACF,eAAe,EAAE;QACf,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,YAAY,CAAC,EAAE;YACb,MAAM,EAAE,MAAM,CAAC;YACf,IAAI,CAAC,EAAE,GAAG,CAAC;SACZ,CAAC;QACF,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QACzB,MAAM,CAAC,EAAE,GAAG,CAAC;KACd,CAAC;IACF,QAAQ,CAAC,EAAE;QACT,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;KACxB,CAAC;CACH;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,aAAa,CAAS;gBAElB,WAAW,GAAE,MAAsB;IAM/C;;OAEG;IACU,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAiDpF;;OAEG;IACU,gBAAgB,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IAuBzD;;OAEG;IACH,OAAO,CAAC,YAAY;IAsBpB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAexB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoC1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAwDzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAuC1B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IASnC;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAclC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAsC5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,SAAS;IAcjB;;OAEG;IACH,OAAO,CAAC,YAAY;CAGrB"}

package/dist/src/testing/test-generator.js

@@ -0,0 +1,370 @@
+/**
+ * Test Generator - Converts YAML Test Specifications to Executable TypeScript Tests
+ *
+ * Takes test-cases (YAML) and generates executable integration tests.
+ *
+ * Supports:
+ * - Skill activation tests
+ * - API integration tests (Jira, ADO, GitHub)
+ * - End-to-end workflow tests
+ * - Uses .env credentials for real API calls
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+export class TestGenerator {
+    constructor(projectRoot = process.cwd()) {
+        this.projectRoot = projectRoot;
+        this.testSpecsDir = path.join(projectRoot, 'tests', 'specs');
+        this.testOutputDir = path.join(projectRoot, 'tests', 'integration');
+    }
+    /**
+     * Generate tests for a specific skill
+     */
+    async generateTestsForSkill(skillName) {
+        const specsDir = path.join(this.testSpecsDir, skillName);
+        if (!fs.existsSync(specsDir)) {
+            console.warn(`No test specs found for skill: ${skillName}`);
+            return null;
+        }
+        // Read all YAML specs
+        const specFiles = fs.readdirSync(specsDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+        if (specFiles.length === 0) {
+            console.warn(`No YAML specs found in ${specsDir}`);
+            return null;
+        }
+        const specs = [];
+        for (const specFile of specFiles) {
+            const specPath = path.join(specsDir, specFile);
+            const spec = this.loadTestSpec(specPath);
+            if (spec) {
+                specs.push(spec);
+            }
+        }
+        if (specs.length === 0) {
+            return null;
+        }
+        // Generate TypeScript test file
+        const testContent = this.generateTestFile(skillName, specs);
+        // Write test file
+        const outputDir = path.join(this.testOutputDir, skillName);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        const testFilePath = path.join(outputDir, `${skillName}.test.ts`);
+        fs.writeFileSync(testFilePath, testContent, 'utf-8');
+        return {
+            skillName,
+            testFilePath,
+            testCount: specs.length,
+            content: testContent
+        };
+    }
+    /**
+     * Generate tests for all skills
+     */
+    async generateAllTests() {
+        const skillDirs = fs.readdirSync(this.testSpecsDir).filter(name => {
+            const fullPath = path.join(this.testSpecsDir, name);
+            return fs.statSync(fullPath).isDirectory();
+        });
+        const generated = [];
+        for (const skillName of skillDirs) {
+            try {
+                const result = await this.generateTestsForSkill(skillName);
+                if (result) {
+                    generated.push(result);
+                    console.log(`✅ Generated tests for ${skillName}: ${result.testCount} tests`);
+                }
+            }
+            catch (error) {
+                console.error(`❌ Failed to generate tests for ${skillName}:`, error.message);
+            }
+        }
+        return generated;
+    }
+    /**
+     * Load test spec from YAML file
+     */
+    loadTestSpec(filePath) {
+        try {
+            let content = fs.readFileSync(filePath, 'utf-8');
+            // Remove trailing --- if present (some YAML files have it)
+            content = content.replace(/\n---\s*$/g, '');
+            const spec = yaml.load(content);
+            // Validate spec
+            if (!spec || !spec.name || !spec.description) {
+                console.warn(`Invalid spec in ${filePath}: missing name or description`);
+                return null;
+            }
+            return spec;
+        }
+        catch (error) {
+            console.error(`Error loading spec ${filePath}:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Generate TypeScript test file from specs
+     */
+    generateTestFile(skillName, specs) {
+        const hasApiTests = specs.some(s => s.type === 'api_integration' || s.requires?.credentials);
+        const requiredCredentials = new Set();
+        specs.forEach(spec => {
+            spec.requires?.credentials?.forEach(cred => requiredCredentials.add(cred));
+        });
+        let content = this.generateFileHeader(skillName, hasApiTests, Array.from(requiredCredentials));
+        content += this.generateTestClass(skillName, specs);
+        content += this.generateTestRunner(skillName);
+        return content;
+    }
+    /**
+     * Generate file header with imports
+     */
+    generateFileHeader(skillName, hasApiTests, credentials) {
+        let header = `/**\n`;
+        header += ` * ${this.formatSkillName(skillName)} Tests\n`;
+        header += ` *\n`;
+        header += ` * Auto-generated from test specifications in tests/specs/${skillName}/\n`;
+        header += ` * \n`;
+        header += ` * Run: npm run test:integration:${skillName}\n`;
+        header += ` */\n\n`;
+        if (hasApiTests) {
+            if (credentials.includes('jira')) {
+                header += `import { JiraClient } from '../../src/integrations/jira/jira-client.js';\n`;
+            }
+            if (credentials.includes('ado')) {
+                header += `import { AdoClient } from '../../src/integrations/ado/ado-client.js';\n`;
+            }
+            if (credentials.includes('github')) {
+                header += `// import { GitHubClient } from '../../src/integrations/github/github-client.js';\n`;
+            }
+            header += `import { credentialsManager } from '../../src/core/credentials-manager.js';\n`;
+        }
+        header += `import * as fs from 'fs';\n`;
+        header += `import * as path from 'path';\n\n`;
+        header += `interface TestResult {\n`;
+        header += `  name: string;\n`;
+        header += `  status: 'PASS' | 'FAIL' | 'SKIP';\n`;
+        header += `  duration: number;\n`;
+        header += `  message?: string;\n`;
+        header += `  details?: any;\n`;
+        header += `}\n\n`;
+        return header;
+    }
+    /**
+     * Generate test class
+     */
+    generateTestClass(skillName, specs) {
+        const className = this.formatClassName(skillName);
+        let classContent = `class ${className}Test {\n`;
+        classContent += `  private results: TestResult[] = [];\n\n`;
+        // Add client properties if needed
+        const hasJira = specs.some(s => s.requires?.credentials?.includes('jira'));
+        const hasAdo = specs.some(s => s.requires?.credentials?.includes('ado'));
+        if (hasJira) {
+            classContent += `  private jiraClient: JiraClient;\n\n`;
+            classContent += `  constructor() {\n`;
+            classContent += `    this.jiraClient = new JiraClient();\n`;
+            classContent += `  }\n\n`;
+        }
+        else if (hasAdo) {
+            classContent += `  private adoClient: AdoClient;\n\n`;
+            classContent += `  constructor() {\n`;
+            classContent += `    this.adoClient = new AdoClient();\n`;
+            classContent += `  }\n\n`;
+        }
+        else {
+            classContent += `  constructor() {}\n\n`;
+        }
+        // Generate run method
+        classContent += `  async run(): Promise<void> {\n`;
+        classContent += `    console.log('╔══════════════════════════════════════════════════════════════╗');\n`;
+        classContent += `    console.log('║      ${this.formatSkillName(skillName)} Tests                        ║');\n`;
+        classContent += `    console.log('╚══════════════════════════════════════════════════════════════╝\\n');\n\n`;
+        classContent += `    try {\n`;
+        // Generate test calls
+        specs.forEach((spec, index) => {
+            classContent += `      await this.test${index + 1}_${this.camelCase(spec.name)}();\n`;
+        });
+        classContent += `    } catch (error) {\n`;
+        classContent += `      console.error('❌ Test suite failed:', error);\n`;
+        classContent += `    } finally {\n`;
+        classContent += `      await this.generateReport();\n`;
+        classContent += `    }\n`;
+        classContent += `  }\n\n`;
+        // Generate individual test methods
+        specs.forEach((spec, index) => {
+            classContent += this.generateTestMethod(spec, index + 1);
+        });
+        // Generate report method
+        classContent += this.generateReportMethod(skillName);
+        classContent += `}\n\n`;
+        return classContent;
+    }
+    /**
+     * Generate individual test method
+     */
+    generateTestMethod(spec, testNumber) {
+        const escapedName = this.escapeString(spec.name);
+        let method = `  private async test${testNumber}_${this.camelCase(spec.name)}(): Promise<void> {\n`;
+        method += `    const testName = 'Test ${testNumber}: ${escapedName}';\n`;
+        method += `    console.log(\`\\n🧪 \${testName}\`);\n`;
+        method += `    const start = Date.now();\n\n`;
+        method += `    try {\n`;
+        // Generate test logic based on type
+        if (spec.type === 'skill_activation') {
+            method += this.generateSkillActivationTest(spec);
+        }
+        else if (spec.type === 'api_integration') {
+            method += this.generateApiIntegrationTest(spec);
+        }
+        else {
+            method += this.generateGenericTest(spec);
+        }
+        method += `      this.results.push({\n`;
+        method += `        name: testName,\n`;
+        method += `        status: 'PASS',\n`;
+        method += `        duration: Date.now() - start,\n`;
+        method += `        message: 'Test passed successfully'\n`;
+        method += `      });\n`;
+        method += `      console.log('✅ PASS\\n');\n`;
+        method += `    } catch (error: any) {\n`;
+        method += `      this.results.push({\n`;
+        method += `        name: testName,\n`;
+        method += `        status: 'FAIL',\n`;
+        method += `        duration: Date.now() - start,\n`;
+        method += `        message: error.message\n`;
+        method += `      });\n`;
+        method += `      console.log(\`❌ FAIL: \${error.message}\\n\`);\n`;
+        method += `    }\n`;
+        method += `  }\n\n`;
+        return method;
+    }
+    /**
+     * Generate skill activation test logic
+     */
+    generateSkillActivationTest(spec) {
+        const prompt = spec.input.prompt ? this.escapeString(spec.input.prompt) : '';
+        return `      // Skill activation test - placeholder\n` +
+            `      // TODO: Implement skill activation detection\n` +
+            `      console.log('   Prompt: ${prompt}');\n` +
+            `      console.log('   Expected skill: ${spec.expected_output.skill_activated ? 'should activate' : 'should not activate'}');\n` +
+            `      \n`;
+    }
+    /**
+     * Generate API integration test logic
+     */
+    generateApiIntegrationTest(spec) {
+        const apiCall = spec.input.api_call;
+        if (!apiCall) {
+            return `      // API test without API call definition\n`;
+        }
+        const method = this.escapeString(apiCall.method);
+        const endpoint = this.escapeString(apiCall.endpoint);
+        return `      // API Integration test\n` +
+            `      console.log('   Making ${method} request to ${endpoint}');\n` +
+            `      // TODO: Implement actual API call\n` +
+            `      \n`;
+    }
+    /**
+     * Generate generic test logic
+     */
+    generateGenericTest(spec) {
+        const description = this.escapeString(spec.description);
+        return `      // Generic test\n` +
+            `      console.log('   Description: ${description}');\n` +
+            `      // TODO: Implement test logic\n` +
+            `      \n`;
+    }
+    /**
+     * Generate report method
+     */
+    generateReportMethod(skillName) {
+        return `  private async generateReport(): Promise<void> {\n` +
+            `    console.log('\\n╔══════════════════════════════════════════════════════════════╗');\n` +
+            `    console.log('║                      Test Results Summary                    ║');\n` +
+            `    console.log('╚══════════════════════════════════════════════════════════════╝\\n');\n\n` +
+            `    const passed = this.results.filter(r => r.status === 'PASS').length;\n` +
+            `    const failed = this.results.filter(r => r.status === 'FAIL').length;\n` +
+            `    const skipped = this.results.filter(r => r.status === 'SKIP').length;\n` +
+            `    const total = this.results.length;\n\n` +
+            `    console.log(\`Total Tests: \${total}\`);\n` +
+            `    console.log(\`✅ Passed: \${passed}\`);\n` +
+            `    console.log(\`❌ Failed: \${failed}\`);\n` +
+            `    console.log(\`⏭️  Skipped: \${skipped}\\n\`);\n\n` +
+            `    this.results.forEach(result => {\n` +
+            `      const icon = result.status === 'PASS' ? '✅' : result.status === 'FAIL' ? '❌' : '⏭️ ';\n` +
+            `      console.log(\`\${icon} \${result.name} (\${result.duration}ms)\`);\n` +
+            `      if (result.message) {\n` +
+            `        console.log(\`   \${result.message}\`);\n` +
+            `      }\n` +
+            `    });\n\n` +
+            `    // Save report\n` +
+            `    const resultsDir = path.join(process.cwd(), 'test-results', '${skillName}');\n` +
+            `    if (!fs.existsSync(resultsDir)) {\n` +
+            `      fs.mkdirSync(resultsDir, { recursive: true });\n` +
+            `    }\n\n` +
+            `    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n` +
+            `    const reportPath = path.join(resultsDir, \`${skillName}-\${timestamp}.json\`);\n\n` +
+            `    const report = {\n` +
+            `      suite: '${this.formatSkillName(skillName)} Tests',\n` +
+            `      timestamp: new Date().toISOString(),\n` +
+            `      summary: { total, passed, failed, skipped },\n` +
+            `      results: this.results\n` +
+            `    };\n\n` +
+            `    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));\n` +
+            `    console.log(\`\\n📊 Report saved to: \${reportPath}\`);\n` +
+            `  }\n`;
+    }
+    /**
+     * Generate test runner
+     */
+    generateTestRunner(skillName) {
+        const className = this.formatClassName(skillName);
+        return `// Run tests\n` +
+            `if (require.main === module) {\n` +
+            `  const test = new ${className}Test();\n` +
+            `  test.run().catch(error => {\n` +
+            `    console.error('Test suite failed:', error);\n` +
+            `    process.exit(1);\n` +
+            `  });\n` +
+            `}\n\n` +
+            `export { ${className}Test };\n`;
+    }
+    /**
+     * Format skill name for display
+     */
+    formatSkillName(skillName) {
+        return skillName.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    }
+    /**
+     * Format class name
+     */
+    formatClassName(skillName) {
+        return skillName.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('');
+    }
+    /**
+     * Convert to camelCase - sanitizes all special characters
+     */
+    camelCase(str) {
+        return str
+            .replace(/[^a-zA-Z0-9\s]+/g, ' ') // Replace all special chars with spaces
+            .trim() // Remove leading/trailing spaces
+            .split(/\s+/) // Split on whitespace
+            .map((word, index) => {
+            if (index === 0) {
+                return word.charAt(0).toLowerCase() + word.slice(1).toLowerCase();
+            }
+            return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+        })
+            .join('');
+    }
+    /**
+     * Escape string for use in single-quoted JavaScript strings
+     */
+    escapeString(str) {
+        return str.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+    }
+}
+//# sourceMappingURL=test-generator.js.map