@paths.design/caws-cli 2.0.1 → 3.1.0

package/templates/apps/tools/caws/tools-allow.json

@@ -0,0 +1,331 @@
+[
+  "node",
+  "npm",
+  "yarn",
+  "pnpm",
+  "git",
+  "docker",
+  "kubectl",
+  "aws",
+  "azure",
+  "gcloud",
+  "terraform",
+  "ansible",
+  "curl",
+  "wget",
+  "grep",
+  "sed",
+  "awk",
+  "bash",
+  "sh",
+  "zsh",
+  "fish",
+  "python",
+  "python3",
+  "pip",
+  "pip3",
+  "virtualenv",
+  "conda",
+  "java",
+  "javac",
+  "gradle",
+  "maven",
+  "go",
+  "gofmt",
+  "rust",
+  "cargo",
+  "rustfmt",
+  "clippy",
+  "ruby",
+  "gem",
+  "bundle",
+  "rbenv",
+  "php",
+  "composer",
+  "dotnet",
+  "nuget",
+  "swift",
+  "xcodebuild",
+  "make",
+  "cmake",
+  "ninja",
+  "gcc",
+  "clang",
+  "ld",
+  "ar",
+  "strip",
+  "objdump",
+  "nm",
+  "readelf",
+  "file",
+  "hexdump",
+  "xxd",
+  "base64",
+  "openssl",
+  "ssh",
+  "scp",
+  "rsync",
+  "tar",
+  "gzip",
+  "bzip2",
+  "xz",
+  "zip",
+  "unzip",
+  "7z",
+  "jq",
+  "yq",
+  "xmlstarlet",
+  "html-xml-utils",
+  "pandoc",
+  "asciidoc",
+  "rst2html",
+  "markdown",
+  "remark",
+  "prettier",
+  "eslint",
+  "tslint",
+  "stylelint",
+  "htmlhint",
+  "csslint",
+  "jsonlint",
+  "yamllint",
+  "shellcheck",
+  "hadolint",
+  "dockerfile_lint",
+  "markdownlint",
+  "proselint",
+  "vale",
+  "alex",
+  "write-good",
+  "textlint",
+  "redpen",
+  "languagetool",
+  "grammarly",
+  "codespell",
+  "typos",
+  "aspell",
+  "hunspell",
+  "sort",
+  "uniq",
+  "cut",
+  "paste",
+  "join",
+  "split",
+  "tr",
+  "column",
+  "fold",
+  "fmt",
+  "pr",
+  "head",
+  "tail",
+  "wc",
+  "nl",
+  "od",
+  "strings",
+  "iconv",
+  "dos2unix",
+  "unix2dos",
+  "mac2unix",
+  "unix2mac",
+  "pbcopy",
+  "pbpaste",
+  "xclip",
+  "xsel",
+  "tmux",
+  "screen",
+  "vim",
+  "nvim",
+  "emacs",
+  "nano",
+  "micro",
+  "code",
+  "atom",
+  "sublime",
+  "vimr",
+  "macvim",
+  "gvim",
+  "vscode",
+  "intellij",
+  "pycharm",
+  "webstorm",
+  "phpstorm",
+  "rubymine",
+  "clion",
+  "goland",
+  "rider",
+  "datagrip",
+  "android-studio",
+  "xcode",
+  "eclipse",
+  "netbeans",
+  "idea",
+  "studio",
+  "vs",
+  "visualstudio",
+  "monodevelop",
+  "xamarin",
+  "rider",
+  "resharper",
+  "testcafe",
+  "cypress",
+  "playwright",
+  "puppeteer",
+  "selenium",
+  "webdriver",
+  "jest",
+  "mocha",
+  "jasmine",
+  "karma",
+  "vitest",
+  "testing-library",
+  "enzyme",
+  "react-testing-library",
+  "vue-test-utils",
+  "angular-testing-library",
+  "svelte-testing-library",
+  "lit-testing-library",
+  "ember-testing",
+  "backbone-testing",
+  "jquery-testing",
+  "dojo-testing",
+  "dojo",
+  "mootools",
+  "prototype",
+  "yui",
+  "extjs",
+  "sencha",
+  "backbone",
+  "marionette",
+  "chaplin",
+  "thorax",
+  "handlebars",
+  "mustache",
+  "underscore",
+  "lodash",
+  "ramda",
+  "functional",
+  "lazy",
+  "bluebird",
+  "q",
+  "deferred",
+  "async",
+  "await",
+  "generator",
+  "co",
+  "redux",
+  "mobx",
+  "flux",
+  "reflux",
+  "alt",
+  "flummox",
+  "delorean",
+  "cerebral",
+  "kea",
+  "zustand",
+  "jotai",
+  "recoil",
+  "valtio",
+  "effector",
+  "xstate",
+  "robot",
+  "easy-peasy",
+  "pullstate",
+  "akita",
+  "ngrx",
+  "ngxs",
+  "akita",
+  "elf",
+  "pinia",
+  "overmind",
+  "stately",
+  "context",
+  "useContext",
+  "useReducer",
+  "useState",
+  "useEffect",
+  "useMemo",
+  "useCallback",
+  "useRef",
+  "useImperativeHandle",
+  "useLayoutEffect",
+  "useDebugValue",
+  "useDeferredValue",
+  "useTransition",
+  "useId",
+  "useSyncExternalStore",
+  "createContext",
+  "createElement",
+  "cloneElement",
+  "isValidElement",
+  "ReactDOM",
+  "render",
+  "hydrate",
+  "createRoot",
+  "unmountComponentAtNode",
+  "findDOMNode",
+  "createPortal",
+  "unstable_batchedUpdates",
+  "flushSync",
+  "React",
+  "Component",
+  "PureComponent",
+  "memo",
+  "lazy",
+  "Suspense",
+  "ErrorBoundary",
+  "Profiler",
+  "StrictMode",
+  "Fragment",
+  "createRef",
+  "forwardRef",
+  "createContext",
+  "createElement",
+  "cloneElement",
+  "isValidElement",
+  "Children",
+  "map",
+  "forEach",
+  "count",
+  "only",
+  "toArray",
+  "ReactDOM",
+  "render",
+  "hydrate",
+  "createRoot",
+  "unmountComponentAtNode",
+  "findDOMNode",
+  "createPortal",
+  "unstable_batchedUpdates",
+  "flushSync",
+  "React",
+  "Component",
+  "PureComponent",
+  "memo",
+  "lazy",
+  "Suspense",
+  "ErrorBoundary",
+  "Profiler",
+  "StrictMode",
+  "Fragment",
+  "createRef",
+  "forwardRef",
+  "createContext",
+  "createElement",
+  "cloneElement",
+  "isValidElement",
+  "Children",
+  "map",
+  "forEach",
+  "count",
+  "only",
+  "toArray",
+  "ReactDOM",
+  "render",
+  "hydrate",
+  "createRoot",
+  "unmountComponentAtNode",
+  "findDOMNode",
+  "createPortal",
+  "unstable_batchedUpdates",
+  "flushSync"
+]

package/templates/apps/tools/caws/validate.js

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview CAWS Validation Tool
+ * @author @darianrosebrook
+ *
+ * Note: For enhanced TypeScript version with schema validation, use validate.ts
+ * This .js version provides basic validation for backward compatibility
+ */
+
+/**
+ * Validates a working specification file
+ * @param {string} specPath - Path to the working specification file
+ * @returns {Object} Validation result with valid boolean and errors array
+ */
+function validateWorkingSpec(specPath) {
+  try {
+    const fs = require('fs');
+    const yaml = require('js-yaml');
+
+    if (!fs.existsSync(specPath)) {
+      return {
+        valid: false,
+        errors: [{ message: `Specification file not found: ${specPath}` }],
+      };
+    }
+
+    const specContent = fs.readFileSync(specPath, 'utf8');
+    const spec = yaml.load(specContent);
+
+    // Basic validation
+    const errors = [];
+
+    if (!spec.id) errors.push({ message: 'Missing required field: id' });
+    if (!spec.title) errors.push({ message: 'Missing required field: title' });
+    if (!spec.risk_tier) errors.push({ message: 'Missing required field: risk_tier' });
+
+    if (spec.risk_tier && (spec.risk_tier < 1 || spec.risk_tier > 3)) {
+      errors.push({ message: 'Risk tier must be 1, 2, or 3' });
+    }
+
+    if (!spec.scope || !spec.scope.in || spec.scope.in.length === 0) {
+      errors.push({ message: 'Scope IN must not be empty' });
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors: errors,
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [{ message: `Validation error: ${error.message}` }],
+    };
+  }
+}
+
+// Handle direct script execution
+if (require.main === module) {
+  const specPath = process.argv[2];
+  if (!specPath) {
+    console.error('Usage: node validate.js <spec-path>');
+    console.log('');
+    console.log('Note: For enhanced schema validation, use: npx tsx validate.ts spec <spec-path>');
+    process.exit(1);
+  }
+
+  const result = validateWorkingSpec(specPath);
+  if (result.valid) {
+    console.log('✅ Working specification is valid');
+  } else {
+    console.error('❌ Working specification is invalid:');
+    result.errors.forEach((error) => console.error(`  - ${error.message}`));
+    process.exit(1);
+  }
+}
+
+module.exports = validateWorkingSpec;

package/templates/apps/tools/caws/validate.ts

@@ -0,0 +1,228 @@
+#!/usr/bin/env tsx
+
+/**
+ * CAWS Validation Tool
+ * CLI wrapper for CawsValidator with schema validation
+ *
+ * @author @darianrosebrook
+ */
+
+import * as path from 'path';
+import { CawsValidator } from './shared/validator.js';
+import { ValidationResult } from './shared/types.js';
+
+class ValidateCLI {
+  private validator: CawsValidator;
+
+  constructor() {
+    this.validator = new CawsValidator();
+  }
+
+  /**
+   * Validate a working specification file
+   */
+  validateWorkingSpec(specPath: string): ValidationResult {
+    try {
+      const result = this.validator.validateWorkingSpec(specPath);
+
+      if (result.passed) {
+        console.log('✅ Working specification is valid');
+        console.log(`   Score: ${(result.score * 100).toFixed(0)}%`);
+
+        if (result.warnings && result.warnings.length > 0) {
+          console.log('\n⚠️  Warnings:');
+          result.warnings.forEach((warning) => console.log(`  - ${warning}`));
+        }
+
+        if (result.details) {
+          console.log('\n📊 Details:');
+          if (result.details.risk_tier) {
+            console.log(`  Tier: ${result.details.risk_tier}`);
+          }
+          if (result.details.acceptance_count) {
+            console.log(`  Acceptance Criteria: ${result.details.acceptance_count}`);
+          }
+          if (result.details.contract_count) {
+            console.log(`  Contracts: ${result.details.contract_count}`);
+          }
+        }
+      } else {
+        console.error('❌ Working specification is invalid:');
+        if (result.errors && result.errors.length > 0) {
+          result.errors.forEach((error) => console.error(`  - ${error}`));
+        }
+      }
+
+      return result;
+    } catch (error) {
+      console.error(`❌ Validation failed: ${error}`);
+      return {
+        passed: false,
+        errors: [`Validation error: ${error}`],
+        score: 0,
+        details: {},
+      };
+    }
+  }
+
+  /**
+   * Validate a provenance file
+   */
+  validateProvenance(provenancePath: string): ValidationResult {
+    try {
+      const result = this.validator.validateProvenance(provenancePath);
+
+      if (result.passed) {
+        console.log('✅ Provenance file is valid');
+        console.log(`   Score: ${(result.score * 100).toFixed(0)}%`);
+
+        if (result.details) {
+          console.log('\n📊 Provenance Details:');
+          if (result.details.agent) {
+            console.log(`  Agent: ${result.details.agent}`);
+          }
+          if (result.details.model) {
+            console.log(`  Model: ${result.details.model}`);
+          }
+          if (result.details.commit) {
+            console.log(`  Commit: ${result.details.commit}`);
+          }
+        }
+      } else {
+        console.error('❌ Provenance file is invalid:');
+        if (result.errors && result.errors.length > 0) {
+          result.errors.forEach((error) => console.error(`  - ${error}`));
+        }
+      }
+
+      return result;
+    } catch (error) {
+      console.error(`❌ Provenance validation failed: ${error}`);
+      return {
+        passed: false,
+        errors: [`Validation error: ${error}`],
+        score: 0,
+        details: {},
+      };
+    }
+  }
+
+  /**
+   * Validate a JSON file against a schema
+   */
+  validateJsonSchema(jsonPath: string, schemaPath: string): ValidationResult {
+    try {
+      const result = this.validator.validateJsonAgainstSchema(jsonPath, schemaPath);
+
+      if (result.passed) {
+        console.log('✅ JSON file is valid against schema');
+      } else {
+        console.error('❌ JSON file is invalid:');
+        if (result.errors && result.errors.length > 0) {
+          result.errors.forEach((error) => console.error(`  - ${error}`));
+        }
+      }
+
+      return result;
+    } catch (error) {
+      console.error(`❌ Schema validation failed: ${error}`);
+      return {
+        passed: false,
+        errors: [`Validation error: ${error}`],
+        score: 0,
+        details: {},
+      };
+    }
+  }
+
+  /**
+   * Validate a YAML file against a schema
+   */
+  validateYamlSchema(yamlPath: string, schemaPath: string): ValidationResult {
+    try {
+      const result = this.validator.validateYamlAgainstSchema(yamlPath, schemaPath);
+
+      if (result.passed) {
+        console.log('✅ YAML file is valid against schema');
+      } else {
+        console.error('❌ YAML file is invalid:');
+        if (result.errors && result.errors.length > 0) {
+          result.errors.forEach((error) => console.error(`  - ${error}`));
+        }
+      }
+
+      return result;
+    } catch (error) {
+      console.error(`❌ Schema validation failed: ${error}`);
+      return {
+        passed: false,
+        errors: [`Validation error: ${error}`],
+        score: 0,
+        details: {},
+      };
+    }
+  }
+}
+
+// Main CLI handler
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const command = process.argv[2];
+  const cli = new ValidateCLI();
+
+  switch (command) {
+    case 'spec': {
+      const specPath = process.argv[3] || '.caws/working-spec.yaml';
+      const result = cli.validateWorkingSpec(specPath);
+      process.exit(result.passed ? 0 : 1);
+    }
+
+    case 'provenance': {
+      const provenancePath = process.argv[3] || '.agent/provenance.json';
+      const result = cli.validateProvenance(provenancePath);
+      process.exit(result.passed ? 0 : 1);
+    }
+
+    case 'json': {
+      const jsonPath = process.argv[3];
+      const schemaPath = process.argv[4];
+
+      if (!jsonPath || !schemaPath) {
+        console.error('Usage: validate.ts json <json-file> <schema-file>');
+        process.exit(1);
+      }
+
+      const result = cli.validateJsonSchema(jsonPath, schemaPath);
+      process.exit(result.passed ? 0 : 1);
+    }
+
+    case 'yaml': {
+      const yamlPath = process.argv[3];
+      const schemaPath = process.argv[4];
+
+      if (!yamlPath || !schemaPath) {
+        console.error('Usage: validate.ts yaml <yaml-file> <schema-file>');
+        process.exit(1);
+      }
+
+      const result = cli.validateYamlSchema(yamlPath, schemaPath);
+      process.exit(result.passed ? 0 : 1);
+    }
+
+    default:
+      console.log('CAWS Validation Tool');
+      console.log('');
+      console.log('Commands:');
+      console.log('  spec [path]              - Validate working specification');
+      console.log('  provenance [path]        - Validate provenance file');
+      console.log('  json <file> <schema>     - Validate JSON against schema');
+      console.log('  yaml <file> <schema>     - Validate YAML against schema');
+      console.log('');
+      console.log('Examples:');
+      console.log('  validate.ts spec .caws/working-spec.yaml');
+      console.log('  validate.ts provenance .agent/provenance.json');
+      console.log('  validate.ts yaml .caws/waivers.yml schemas/waivers.schema.json');
+      process.exit(1);
+  }
+}
+
+export { ValidateCLI };