qa360 2.1.5 → 2.1.6

package/dist/commands/init.js

@@ -530,9 +530,25 @@ export async function initCommand(options = {}) {
     try {
         console.log(chalk.bold.cyan('\n🚀 QA360 Pack Generator (v2)\n'));
         // Determine output file
-        const outputFile = options.output
-            ? resolve(options.output)
-            : join(process.cwd(), 'qa360.yml');
+        let outputFile;
+        if (options.output) {
+            const resolved = resolve(options.output);
+            // Check if it's a directory or if it doesn't have an extension
+            if (options.output.endsWith('/') || !options.output.includes('.')) {
+                // It's a directory path, create the file inside it
+                mkdirSync(resolved, { recursive: true });
+                outputFile = join(resolved, 'qa360.yml');
+            }
+            else {
+                // It's a file path, ensure parent directory exists
+                const dir = resolve(resolved, '..');
+                mkdirSync(dir, { recursive: true });
+                outputFile = resolved;
+            }
+        }
+        else {
+            outputFile = join(process.cwd(), 'qa360.yml');
+        }
         // Check if file exists
         if (existsSync(outputFile) && !options.force) {
             const overwrite = await inquirer.prompt([

package/dist/core/ai/anthropic-provider.js

@@ -36,6 +36,9 @@ export class AnthropicProvider {
         }
         // Try a minimal API call
         try {
+            // Use timeout with AbortController for compatibility
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
             const response = await fetch(`${this.baseURL}/v1/messages`, {
                 method: 'POST',
                 headers: {
@@ -43,13 +46,14 @@ export class AnthropicProvider {
                     'anthropic-version': this.version,
                     'content-type': 'application/json',
                 },
-                signal: AbortSignal.timeout(5000),
+                signal: controller.signal,
                 body: JSON.stringify({
                     model: this.defaultModel,
                     max_tokens: 1,
                     messages: [{ role: 'user', content: 'Hi' }]
                 })
             });
+            clearTimeout(timeoutId);
             // Anthropic may return 400 for malformed request but still be available
             // We consider it available if we get any response (not a network error)
             return response.status !== 401 && response.status !== 403;
@@ -65,46 +69,54 @@ export class AnthropicProvider {
             });
         }
         const messages = this.buildMessages(request);
-        const response = await fetch(`${this.baseURL}/v1/messages`, {
-            method: 'POST',
-            headers: {
-                'x-api-key': this.apiKey,
-                'anthropic-version': this.version,
-                'content-type': 'application/json',
-            },
-            signal: AbortSignal.timeout(this.timeout),
-            body: JSON.stringify({
-                model: this.defaultModel,
-                messages,
-                system: request.systemPrompt,
-                temperature: request.temperature ?? 0.7,
-                max_tokens: request.maxTokens ?? 4096,
-            })
-        });
-        if (!response.ok) {
-            const error = await response.text().catch(() => 'Unknown error');
-            throw new AnthropicError(`Anthropic request failed: ${response.status} ${error}`, {
-                status: response.status,
-                response: error
+        // Use timeout with AbortController for compatibility
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseURL}/v1/messages`, {
+                method: 'POST',
+                headers: {
+                    'x-api-key': this.apiKey,
+                    'anthropic-version': this.version,
+                    'content-type': 'application/json',
+                },
+                signal: controller.signal,
+                body: JSON.stringify({
+                    model: this.defaultModel,
+                    messages,
+                    system: request.systemPrompt,
+                    temperature: request.temperature ?? 0.7,
+                    max_tokens: request.maxTokens ?? 4096,
+                })
             });
+            if (!response.ok) {
+                const error = await response.text().catch(() => 'Unknown error');
+                throw new AnthropicError(`Anthropic request failed: ${response.status} ${error}`, {
+                    status: response.status,
+                    response: error
+                });
+            }
+            const data = await response.json();
+            if (data.error) {
+                throw new AnthropicError(`Anthropic API error: ${data.error.message}`, {
+                    type: data.error.type
+                });
+            }
+            const content = this.extractContent(data.content);
+            return {
+                content,
+                usage: {
+                    promptTokens: data.usage?.input_tokens || 0,
+                    completionTokens: data.usage?.output_tokens || 0,
+                    totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0),
+                },
+                model: data.model,
+                finishReason: data.stop_reason === 'end_turn' ? 'stop' : 'length'
+            };
         }
-        const data = await response.json();
-        if (data.error) {
-            throw new AnthropicError(`Anthropic API error: ${data.error.message}`, {
-                type: data.error.type
-            });
+        finally {
+            clearTimeout(timeoutId);
         }
-        const content = this.extractContent(data.content);
-        return {
-            content,
-            usage: {
-                promptTokens: data.usage?.input_tokens || 0,
-                completionTokens: data.usage?.output_tokens || 0,
-                totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0),
-            },
-            model: data.model,
-            finishReason: data.stop_reason === 'end_turn' ? 'stop' : 'length'
-        };
     }
     async *stream(request) {
         if (!this.apiKey) {

package/dist/core/ai/deepseek-provider.js

@@ -48,13 +48,17 @@ export class DeepSeekProvider {
         }
         // Try a minimal API call
         try {
+            // Use timeout with AbortController for compatibility
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
             const response = await fetch(`${this.baseURL}/v1/models`, {
                 method: 'GET',
                 headers: {
                     'Authorization': `Bearer ${this.apiKey}`,
                 },
-                signal: AbortSignal.timeout(5000),
+                signal: controller.signal,
             });
+            clearTimeout(timeoutId);
             return response.ok;
         }
         catch {
@@ -69,42 +73,50 @@ export class DeepSeekProvider {
             });
         }
         const messages = this.buildMessages(request);
-        const response = await fetch(`${this.baseURL}/v1/chat/completions`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            signal: AbortSignal.timeout(this.timeout),
-            body: JSON.stringify({
-                model: this.defaultModel,
-                messages,
-                temperature: request.temperature ?? 0.7,
-                max_tokens: request.maxTokens ?? 4096,
-            })
-        });
-        if (!response.ok) {
-            const errorText = await response.text().catch(() => 'Unknown error');
-            throw new DeepSeekError(`DeepSeek request failed: ${response.status} ${errorText}`, {
-                status: response.status,
-                response: errorText
+        // Use timeout with AbortController for compatibility
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseURL}/v1/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                signal: controller.signal,
+                body: JSON.stringify({
+                    model: this.defaultModel,
+                    messages,
+                    temperature: request.temperature ?? 0.7,
+                    max_tokens: request.maxTokens ?? 4096,
+                })
             });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Unknown error');
+                throw new DeepSeekError(`DeepSeek request failed: ${response.status} ${errorText}`, {
+                    status: response.status,
+                    response: errorText
+                });
+            }
+            const data = await response.json();
+            const choice = data.choices?.[0];
+            if (!choice) {
+                throw new DeepSeekError('No choices returned from DeepSeek');
+            }
+            return {
+                content: choice.message.content,
+                usage: {
+                    promptTokens: data.usage?.prompt_tokens || 0,
+                    completionTokens: data.usage?.completion_tokens || 0,
+                    totalTokens: data.usage?.total_tokens || 0,
+                },
+                model: data.model,
+                finishReason: choice.finish_reason === 'stop' ? 'stop' : 'length'
+            };
         }
-        const data = await response.json();
-        const choice = data.choices?.[0];
-        if (!choice) {
-            throw new DeepSeekError('No choices returned from DeepSeek');
+        finally {
+            clearTimeout(timeoutId);
         }
-        return {
-            content: choice.message.content,
-            usage: {
-                promptTokens: data.usage?.prompt_tokens || 0,
-                completionTokens: data.usage?.completion_tokens || 0,
-                totalTokens: data.usage?.total_tokens || 0,
-            },
-            model: data.model,
-            finishReason: choice.finish_reason === 'stop' ? 'stop' : 'length'
-        };
     }
     async *stream(request) {
         if (!this.apiKey) {

package/dist/core/ai/ollama-provider.js

@@ -32,9 +32,13 @@ export class OllamaProvider {
     }
     async isAvailable() {
         try {
+            // Use timeout with AbortSignal - wrap for compatibility
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
             const response = await fetch(`${this.baseUrl}/api/tags`, {
-                signal: AbortSignal.timeout(5000),
+                signal: controller.signal,
             });
+            clearTimeout(timeoutId);
             return response.ok;
         }
         catch {
@@ -43,37 +47,45 @@ export class OllamaProvider {
     }
     async generate(request) {
         const fullPrompt = this.buildFullPrompt(request);
-        const response = await fetch(`${this.baseUrl}/api/generate`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            signal: AbortSignal.timeout(this.timeout),
-            body: JSON.stringify({
+        // Use timeout with AbortController for compatibility
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseUrl}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                signal: controller.signal,
+                body: JSON.stringify({
+                    model: this.defaultModel,
+                    prompt: fullPrompt,
+                    stream: false,
+                    options: {
+                        temperature: request.temperature ?? 0.7,
+                        num_predict: request.maxTokens ?? 4096,
+                    }
+                })
+            });
+            if (!response.ok) {
+                throw new OllamaError(`Ollama request failed: ${response.status} ${response.statusText}`, { response: await response.text().catch(() => 'Unknown error') });
+            }
+            const data = await response.json();
+            if (data.error) {
+                throw new OllamaError(data.error);
+            }
+            return {
+                content: data.response,
+                usage: {
+                    promptTokens: data.prompt_eval_count || 0,
+                    completionTokens: data.eval_count || 0,
+                    totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+                },
                 model: this.defaultModel,
-                prompt: fullPrompt,
-                stream: false,
-                options: {
-                    temperature: request.temperature ?? 0.7,
-                    num_predict: request.maxTokens ?? 4096,
-                }
-            })
-        });
-        if (!response.ok) {
-            throw new OllamaError(`Ollama request failed: ${response.status} ${response.statusText}`, { response: await response.text().catch(() => 'Unknown error') });
+                finishReason: data.done_reason || 'stop',
+            };
         }
-        const data = await response.json();
-        if (data.error) {
-            throw new OllamaError(data.error);
+        finally {
+            clearTimeout(timeoutId);
         }
-        return {
-            content: data.response,
-            usage: {
-                promptTokens: data.prompt_eval_count || 0,
-                completionTokens: data.eval_count || 0,
-                totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
-            },
-            model: this.defaultModel,
-            finishReason: data.done_reason || 'stop',
-        };
     }
     async *stream(request) {
         const fullPrompt = this.buildFullPrompt(request);

package/dist/core/ai/openai-provider.js

@@ -36,13 +36,17 @@ export class OpenAIProvider {
         }
         // Try a minimal API call
         try {
+            // Use timeout with AbortController for compatibility
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
             const response = await fetch(`${this.baseURL}/models`, {
                 method: 'GET',
                 headers: {
                     'Authorization': `Bearer ${this.apiKey}`,
                 },
-                signal: AbortSignal.timeout(5000),
+                signal: controller.signal,
             });
+            clearTimeout(timeoutId);
             return response.ok;
         }
         catch {
@@ -56,42 +60,50 @@ export class OpenAIProvider {
             });
         }
         const messages = this.buildMessages(request);
-        const response = await fetch(`${this.baseURL}/chat/completions`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            signal: AbortSignal.timeout(this.timeout),
-            body: JSON.stringify({
-                model: this.defaultModel,
-                messages,
-                temperature: request.temperature ?? 0.7,
-                max_tokens: request.maxTokens ?? 4096,
-            })
-        });
-        if (!response.ok) {
-            const error = await response.text().catch(() => 'Unknown error');
-            throw new OpenAIError(`OpenAI request failed: ${response.status} ${error}`, {
-                status: response.status,
-                response: error
+        // Use timeout with AbortController for compatibility
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseURL}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                signal: controller.signal,
+                body: JSON.stringify({
+                    model: this.defaultModel,
+                    messages,
+                    temperature: request.temperature ?? 0.7,
+                    max_tokens: request.maxTokens ?? 4096,
+                })
             });
+            if (!response.ok) {
+                const error = await response.text().catch(() => 'Unknown error');
+                throw new OpenAIError(`OpenAI request failed: ${response.status} ${error}`, {
+                    status: response.status,
+                    response: error
+                });
+            }
+            const data = await response.json();
+            const choice = data.choices?.[0];
+            if (!choice) {
+                throw new OpenAIError('No choices returned from OpenAI');
+            }
+            return {
+                content: choice.message.content,
+                usage: {
+                    promptTokens: data.usage?.prompt_tokens || 0,
+                    completionTokens: data.usage?.completion_tokens || 0,
+                    totalTokens: data.usage?.total_tokens || 0,
+                },
+                model: data.model,
+                finishReason: choice.finish_reason === 'stop' ? 'stop' : 'length'
+            };
         }
-        const data = await response.json();
-        const choice = data.choices?.[0];
-        if (!choice) {
-            throw new OpenAIError('No choices returned from OpenAI');
+        finally {
+            clearTimeout(timeoutId);
         }
-        return {
-            content: choice.message.content,
-            usage: {
-                promptTokens: data.usage?.prompt_tokens || 0,
-                completionTokens: data.usage?.completion_tokens || 0,
-                totalTokens: data.usage?.total_tokens || 0,
-            },
-            model: data.model,
-            finishReason: choice.finish_reason === 'stop' ? 'stop' : 'length'
-        };
     }
     async *stream(request) {
         if (!this.apiKey) {

package/dist/core/pack-v2/loader.d.ts

@@ -2,6 +2,7 @@
  * QA360 Pack v2 Loader
  *
  * Loads and parses pack.yml v2 files from the filesystem.
+ * Supports environment variable substitution with ${VAR} and ${VAR:-default} syntax.
  */
 import { PackConfigV2, PackValidationResultV2, ValidationError } from '../types/pack-v2.js';
 export interface PackLoadResult {

package/dist/core/pack-v2/loader.js

@@ -2,12 +2,41 @@
  * QA360 Pack v2 Loader
  *
  * Loads and parses pack.yml v2 files from the filesystem.
+ * Supports environment variable substitution with ${VAR} and ${VAR:-default} syntax.
  */
 import { readFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
 import * as yaml from 'js-yaml';
 import { PackValidatorV2 } from './validator.js';
 import { PackMigrator } from './migrator.js';
+/**
+ * Substitute environment variables in a string
+ * Supports ${VAR} and ${VAR:-default} syntax
+ */
+function substituteEnvVars(str) {
+    return str.replace(/\$\{([^}:]+)(:-([^}]*))?\}/g, (match, varName, _, defaultValue) => {
+        return process.env[varName] ?? defaultValue ?? match;
+    });
+}
+/**
+ * Recursively substitute environment variables in an object
+ */
+function substituteEnvVarsRecursive(obj) {
+    if (typeof obj === 'string') {
+        return substituteEnvVars(obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(substituteEnvVarsRecursive);
+    }
+    if (obj !== null && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = substituteEnvVarsRecursive(value);
+        }
+        return result;
+    }
+    return obj;
+}
 export class PackLoaderV2 {
     cache = new Map();
     /**
@@ -30,16 +59,18 @@ export class PackLoaderV2 {
             const content = readFileSync(resolvedPath, 'utf-8');
             // Parse YAML
             const parsed = yaml.load(content);
+            // Substitute environment variables
+            const substituted = substituteEnvVarsRecursive(parsed);
             // Detect version
             const migrator = new PackMigrator();
-            const detectedVersion = migrator.detectVersion(parsed);
+            const detectedVersion = migrator.detectVersion(substituted);
             // Set format
             const format = detectedVersion === 1 ? 'v1' : detectedVersion === 2 ? 'v2' : 'unknown';
             // For v1 without migration
             if (detectedVersion === 1 && options?.migrate === false) {
                 return {
                     success: true,
-                    pack: parsed,
+                    pack: substituted,
                     format: 'v1',
                     migrated: false,
                     sourcePath: resolvedPath
@@ -51,10 +82,10 @@ export class PackLoaderV2 {
             let migrationWarnings = [];
             if (detectedVersion === 1) {
                 // Check for legacy format before migrating
-                if (migrator.isLegacyFormat(parsed)) {
+                if (migrator.isLegacyFormat(substituted)) {
                     return {
                         success: false,
-                        error: new Error(`Legacy pack format detected (version ${parsed.version || '0.9.x'}). ` +
+                        error: new Error(`Legacy pack format detected (version ${substituted.version || '0.9.x'}). ` +
                             `This format is no longer supported.\n\n` +
                             `To fix this:\n` +
                             `  1. Delete the old pack file: ${resolvedPath}\n` +
@@ -65,7 +96,7 @@ export class PackLoaderV2 {
                     };
                 }
                 // Migrate v1 to v2
-                const migrationResult = migrator.migrate(parsed);
+                const migrationResult = migrator.migrate(substituted);
                 if (!migrationResult.success) {
                     return {
                         success: false,
@@ -80,14 +111,14 @@ export class PackLoaderV2 {
                 migrationWarnings = migrationResult.warnings;
             }
             else if (detectedVersion === 2) {
-                pack = parsed;
+                pack = substituted;
             }
             else {
                 // Check for legacy format and provide helpful error
-                if (migrator.isLegacyFormat(parsed)) {
+                if (migrator.isLegacyFormat(substituted)) {
                     return {
                         success: false,
-                        error: new Error(`Legacy pack format detected (version ${parsed.version || '0.9.x'}). ` +
+                        error: new Error(`Legacy pack format detected (version ${substituted.version || '0.9.x'}). ` +
                             `This format is no longer supported.\n\n` +
                             `To fix this:\n` +
                             `  1. Delete the old pack file: ${resolvedPath}\n` +
@@ -99,7 +130,7 @@ export class PackLoaderV2 {
                 }
                 return {
                     success: false,
-                    error: new Error(`Unknown pack format. Version: ${parsed.version}`),
+                    error: new Error(`Unknown pack format. Version: ${substituted.version}`),
                     sourcePath: resolvedPath,
                     format: 'unknown'
                 };
@@ -189,13 +220,15 @@ export class PackLoaderV2 {
     async loadFromString(yamlContent, options) {
         try {
             const parsed = yaml.load(yamlContent);
+            // Substitute environment variables
+            const substituted = substituteEnvVarsRecursive(parsed);
             // Detect version and migrate if needed
             const migrator = new PackMigrator();
-            const detectedVersion = migrator.detectVersion(parsed);
+            const detectedVersion = migrator.detectVersion(substituted);
             let pack;
             let migrated = false;
             if (detectedVersion === 1) {
-                const migrationResult = migrator.migrate(parsed);
+                const migrationResult = migrator.migrate(substituted);
                 if (!migrationResult.success) {
                     return {
                         success: false,
@@ -206,12 +239,12 @@ export class PackLoaderV2 {
                 migrated = true;
             }
             else if (detectedVersion === 2) {
-                pack = parsed;
+                pack = substituted;
             }
             else {
                 return {
                     success: false,
-                    error: new Error(`Unknown pack format. Version: ${parsed.version}`)
+                    error: new Error(`Unknown pack format. Version: ${substituted.version}`)
                 };
             }
             // Validate if requested

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qa360",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "description": "QA360 Proof CLI - Quality as Cryptographic Proof",
   "type": "module",
   "main": "dist/index.js",