@paths.design/caws-cli 2.0.1 → 3.1.0

package/templates/apps/tools/caws/shared/validator.ts

@@ -0,0 +1,305 @@
+/**
+ * CAWS Validator
+ * Shared validation utilities for working specs, provenance, and other data
+ *
+ * @author @darianrosebrook
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import Ajv from 'ajv';
+import yaml from 'js-yaml';
+import { ValidationResult, ContractValidationResult } from './types.js';
+import { CawsBaseTool } from './base-tool.js';
+
+export class CawsValidator extends CawsBaseTool {
+  private ajv: Ajv;
+
+  constructor() {
+    super();
+    this.ajv = new Ajv({
+      allErrors: true,
+      strict: false,
+      allowUnionTypes: true,
+    });
+  }
+
+  /**
+   * Validate a working spec file
+   */
+  validateWorkingSpec(specPath: string): ValidationResult {
+    try {
+      // Read the working spec file
+      const specContent = fs.readFileSync(specPath, 'utf-8');
+      let spec: any;
+
+      // Try to parse as YAML first, then JSON
+      try {
+        spec = yaml.load(specContent);
+      } catch {
+        try {
+          spec = JSON.parse(specContent);
+        } catch {
+          return {
+            passed: false,
+            score: 0,
+            details: {},
+            errors: ['Invalid JSON/YAML format in working spec'],
+          };
+        }
+      }
+
+      // Load schema if available
+      const schemaPath = path.join(this.getCawsDirectory(), 'schemas/working-spec.schema.json');
+
+      if (fs.existsSync(schemaPath)) {
+        const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+        const schema = JSON.parse(schemaContent);
+
+        // Validate against schema
+        const validate = this.ajv.compile(schema);
+        const valid = validate(spec);
+
+        if (!valid) {
+          return {
+            passed: false,
+            errors: validate.errors?.map((err) => `${err.instancePath}: ${err.message}`) || [],
+            score: 0,
+            details: {},
+          };
+        }
+      }
+
+      // Additional business logic validations
+      const warnings: string[] = [];
+
+      // Check risk tier thresholds
+      if (spec.risk_tier === 1 && spec.acceptance?.length < 5) {
+        warnings.push('Tier 1 specs should have at least 5 acceptance criteria');
+      }
+
+      if (spec.risk_tier === 2 && spec.contracts?.length === 0) {
+        warnings.push('Tier 2 specs should have contract definitions');
+      }
+
+      // Check for required non-functional requirements
+      const requiredNonFunctional = ['perf'];
+      const missingNonFunctional = requiredNonFunctional.filter(
+        (req) => !spec.non_functional?.[req]
+      );
+
+      if (missingNonFunctional.length > 0) {
+        warnings.push(`Missing non-functional requirements: ${missingNonFunctional.join(', ')}`);
+      }
+
+      return {
+        passed: true,
+        score: 1,
+        details: {},
+        warnings: warnings.length > 0 ? warnings : undefined,
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        score: 0,
+        details: {},
+        errors: [`Validation failed: ${error}`],
+      };
+    }
+  }
+
+  /**
+   * Validate a provenance file
+   */
+  validateProvenance(provenancePath: string): ValidationResult {
+    try {
+      const provenanceContent = fs.readFileSync(provenancePath, 'utf-8');
+      const provenance = JSON.parse(provenanceContent);
+
+      // Basic structure validation
+      const requiredFields = ['agent', 'model', 'commit', 'artifacts', 'results', 'approvals'];
+      const missingFields = requiredFields.filter((field) => !provenance[field]);
+
+      if (missingFields.length > 0) {
+        return {
+          passed: false,
+          score: 0,
+          details: {},
+          errors: [`Missing required fields: ${missingFields.join(', ')}`],
+        };
+      }
+
+      // Validate results structure
+      const requiredResults = ['coverage_branch', 'mutation_score', 'tests_passed'];
+      const missingResults = requiredResults.filter(
+        (field) => typeof provenance.results[field] !== 'number'
+      );
+
+      if (missingResults.length > 0) {
+        return {
+          passed: false,
+          score: 0,
+          details: {},
+          errors: [`Missing numeric results: ${missingResults.join(', ')}`],
+        };
+      }
+
+      return {
+        passed: true,
+        score: 1,
+        details: {},
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        score: 0,
+        details: {},
+        errors: [`Provenance validation failed: ${error}`],
+      };
+    }
+  }
+
+  /**
+   * Validate a JSON file against a schema
+   */
+  validateJsonAgainstSchema(jsonPath: string, schemaPath: string): ValidationResult {
+    try {
+      // Read JSON file
+      const jsonContent = fs.readFileSync(jsonPath, 'utf-8');
+      const jsonData = JSON.parse(jsonContent);
+
+      // Read schema file
+      const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+      const schema = JSON.parse(schemaContent);
+
+      // Validate
+      const validate = this.ajv.compile(schema);
+      const valid = validate(jsonData);
+
+      if (!valid) {
+        return {
+          passed: false,
+          score: 0,
+          details: {},
+          errors: validate.errors?.map((err) => `${err.instancePath}: ${err.message}`) || [],
+        };
+      }
+
+      return {
+        passed: true,
+        score: 1,
+        details: {},
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        score: 0,
+        details: {},
+        errors: [`Schema validation failed: ${error}`],
+      };
+    }
+  }
+
+  /**
+   * Validate a YAML file against a schema
+   */
+  validateYamlAgainstSchema(yamlPath: string, schemaPath: string): ValidationResult {
+    try {
+      // Read YAML file
+      const yamlContent = fs.readFileSync(yamlPath, 'utf-8');
+      const yamlData = yaml.load(yamlContent);
+
+      // Read schema file
+      const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+      const schema = JSON.parse(schemaContent);
+
+      // Validate
+      const validate = this.ajv.compile(schema);
+      const valid = validate(yamlData);
+
+      if (!valid) {
+        return {
+          passed: false,
+          score: 0,
+          details: {},
+          errors: validate.errors?.map((err) => `${err.instancePath}: ${err.message}`) || [],
+        };
+      }
+
+      return {
+        passed: true,
+        score: 1,
+        details: {},
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        score: 0,
+        details: {},
+        errors: [`YAML schema validation failed: ${error}`],
+      };
+    }
+  }
+
+  /**
+   * Validate file exists and is readable
+   */
+  validateFileExists(filePath: string): ValidationResult {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return {
+          passed: false,
+          score: 0,
+          details: {},
+          errors: [`File not found: ${filePath}`],
+        };
+      }
+
+      // Try to read the file
+      fs.accessSync(filePath, fs.constants.R_OK);
+      return {
+        passed: true,
+        score: 1,
+        details: {},
+      };
+    } catch {
+      return {
+        passed: false,
+        score: 0,
+        details: {},
+        errors: [`File not readable: ${filePath}`],
+      };
+    }
+  }
+
+  /**
+   * Validate directory exists and is writable
+   */
+  validateDirectoryExists(dirPath: string): ValidationResult {
+    try {
+      if (!fs.existsSync(dirPath)) {
+        return {
+          passed: false,
+          score: 0,
+          details: {},
+          errors: [`Directory not found: ${dirPath}`],
+        };
+      }
+
+      // Try to write to the directory
+      fs.accessSync(dirPath, fs.constants.W_OK);
+      return {
+        passed: true,
+        score: 1,
+        details: {},
+      };
+    } catch {
+      return {
+        passed: false,
+        score: 0,
+        details: {},
+        errors: [`Directory not writable: ${dirPath}`],
+      };
+    }
+  }
+}

package/templates/apps/tools/caws/shared/waivers-manager.ts

@@ -0,0 +1,174 @@
+/**
+ * CAWS Waivers Manager
+ * TypeScript wrapper for waivers management functionality
+ *
+ * @author @darianrosebrook
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import yaml from 'js-yaml';
+import { WaiverConfig } from './types.js';
+import { CawsBaseTool } from './base-tool.js';
+
+export class WaiversManager extends CawsBaseTool {
+  private readonly waiversPath: string;
+
+  constructor(waiversPath?: string) {
+    super();
+    this.waiversPath = waiversPath || path.join(this.getCawsDirectory(), 'waivers.yml');
+  }
+
+  /**
+   * Load waivers configuration
+   */
+  private loadWaiversConfig(): { waivers: WaiverConfig[] } {
+    try {
+      if (!fs.existsSync(this.waiversPath)) {
+        return { waivers: [] };
+      }
+
+      const content = fs.readFileSync(this.waiversPath, 'utf8');
+      return yaml.load(content) as { waivers: WaiverConfig[] };
+    } catch (error) {
+      this.logError(`Error loading waivers config: ${error}`);
+      return { waivers: [] };
+    }
+  }
+
+  /**
+   * Save waivers configuration
+   */
+  private saveWaiversConfig(config: { waivers: WaiverConfig[] }): void {
+    try {
+      const yamlContent = yaml.dump(config, { indent: 2 });
+      fs.writeFileSync(this.waiversPath, yamlContent);
+      this.logSuccess(`Waivers configuration saved to ${this.waiversPath}`);
+    } catch (error) {
+      this.logError(`Error saving waivers config: ${error}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get all waivers for a specific gate
+   */
+  async getWaiversByGate(gate: string): Promise<WaiverConfig[]> {
+    const config = this.loadWaiversConfig();
+    const now = new Date();
+
+    return config.waivers.filter((waiver) => {
+      // Check if waiver covers this gate
+      if (waiver.gate !== gate) {
+        return false;
+      }
+
+      // Check if waiver is still active
+      const expiresAt = new Date(waiver.expiry);
+      if (now > expiresAt) {
+        return false;
+      }
+
+      return waiver.status === 'active';
+    });
+  }
+
+  /**
+   * Check waiver status
+   */
+  async checkWaiverStatus(waiverId: string): Promise<{
+    active: boolean;
+    waiver?: WaiverConfig;
+    reason?: string;
+  }> {
+    const config = this.loadWaiversConfig();
+    const now = new Date();
+
+    const waiver = config.waivers.find((w) => w.created_at === waiverId);
+
+    if (!waiver) {
+      return { active: false, reason: 'Waiver not found' };
+    }
+
+    const expiresAt = new Date(waiver.expiry);
+    if (now > expiresAt) {
+      return { active: false, waiver, reason: 'Waiver expired' };
+    }
+
+    if (waiver.status !== 'active') {
+      return { active: false, waiver, reason: `Waiver status: ${waiver.status}` };
+    }
+
+    return { active: true, waiver };
+  }
+
+  /**
+   * Create a new waiver
+   */
+  async createWaiver(waiver: Omit<WaiverConfig, 'created_at'>): Promise<void> {
+    const config = this.loadWaiversConfig();
+
+    const newWaiver: WaiverConfig = {
+      ...waiver,
+      created_at: new Date().toISOString(),
+    };
+
+    config.waivers.push(newWaiver);
+    this.saveWaiversConfig(config);
+  }
+
+  /**
+   * Revoke a waiver
+   */
+  async revokeWaiver(gate: string, owner: string): Promise<void> {
+    const config = this.loadWaiversConfig();
+
+    const waiver = config.waivers.find(
+      (w) => w.gate === gate && w.owner === owner && w.status === 'active'
+    );
+
+    if (waiver) {
+      waiver.status = 'revoked';
+      this.saveWaiversConfig(config);
+      this.logSuccess(`Revoked waiver for gate: ${gate}`);
+    } else {
+      this.logWarning(`No active waiver found for gate: ${gate}`);
+    }
+  }
+
+  /**
+   * Cleanup expired waivers
+   */
+  async cleanupExpiredWaivers(): Promise<number> {
+    const config = this.loadWaiversConfig();
+    const now = new Date();
+
+    const activeWaivers = config.waivers.filter((waiver) => {
+      const expiresAt = new Date(waiver.expiry);
+      return now <= expiresAt;
+    });
+
+    const removedCount = config.waivers.length - activeWaivers.length;
+
+    if (removedCount > 0) {
+      config.waivers = activeWaivers;
+      this.saveWaiversConfig(config);
+      this.logSuccess(`Cleaned up ${removedCount} expired waiver(s)`);
+    }
+
+    return removedCount;
+  }
+
+  /**
+   * List all active waivers
+   */
+  async listActiveWaivers(): Promise<WaiverConfig[]> {
+    const config = this.loadWaiversConfig();
+    const now = new Date();
+
+    return config.waivers.filter((waiver) => {
+      const expiresAt = new Date(waiver.expiry);
+      return now <= expiresAt && waiver.status === 'active';
+    });
+  }
+}