@paths.design/caws-cli 7.0.2 → 7.0.3

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

@@ -1,305 +0,0 @@
-/**
- * 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

@@ -1,174 +0,0 @@
-/**
- * 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';
-    });
-  }
-}