pmp-gywd 3.3.0

package/lib/validators/command-validator.js

@@ -0,0 +1,188 @@
+/**
+ * Command Validator
+ *
+ * Validates GYWD command markdown files for structure and content.
+ * Zero external dependencies.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse YAML frontmatter from markdown content
+ * @param {string} content - Markdown content
+ * @returns {object|null} Parsed frontmatter or null if not found
+ */
+function parseFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+
+  const frontmatter = {};
+  const lines = frontmatterMatch[1].split('\n');
+
+  for (const line of lines) {
+    const colonIndex = line.indexOf(':');
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+
+      // Handle arrays (lines starting with -)
+      if (value === '') {
+        const arrayLines = [];
+        const startIndex = lines.indexOf(line);
+        for (let i = startIndex + 1; i < lines.length; i++) {
+          if (lines[i].trim().startsWith('-')) {
+            arrayLines.push(lines[i].trim().slice(1).trim());
+          } else if (lines[i].trim() && !lines[i].startsWith(' ')) {
+            break;
+          }
+        }
+        if (arrayLines.length > 0) {
+          value = arrayLines;
+        }
+      }
+
+      frontmatter[key] = value;
+    }
+  }
+
+  return frontmatter;
+}
+
+/**
+ * Required sections for a valid command file
+ */
+const REQUIRED_SECTIONS = ['objective'];
+const PROCESS_SECTIONS = ['process', 'reference', 'output'];
+
+/**
+ * Validate a command file's structure
+ * @param {string} content - File content
+ * @param {string} fileName - File name for error messages
+ * @returns {{valid: boolean, errors: string[], warnings: string[], frontmatter: object|null}}
+ */
+function validateCommandStructure(content, _fileName) {
+  const errors = [];
+  const warnings = [];
+
+  // Check for frontmatter
+  const frontmatter = parseFrontmatter(content);
+  if (!frontmatter) {
+    warnings.push('Missing YAML frontmatter');
+  } else {
+    // Validate frontmatter fields
+    if (!frontmatter.name) {
+      errors.push('Frontmatter missing required field: name');
+    }
+    if (!frontmatter.description) {
+      errors.push('Frontmatter missing required field: description');
+    }
+  }
+
+  // Check for required sections
+  for (const section of REQUIRED_SECTIONS) {
+    const regex = new RegExp(`<${section}[^>]*>`, 'i');
+    if (!regex.test(content)) {
+      errors.push(`Missing required section: <${section}>`);
+    }
+  }
+
+  // Check for at least one process-type section
+  const hasProcessSection = PROCESS_SECTIONS.some(section => {
+    const regex = new RegExp(`<${section}[^>]*>`, 'i');
+    return regex.test(content);
+  });
+
+  if (!hasProcessSection) {
+    errors.push(`Missing <process>, <reference>, or <output> section`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    frontmatter,
+  };
+}
+
+/**
+ * Extract workflow references from command content
+ * @param {string} content - File content
+ * @returns {string[]} Array of referenced workflow paths
+ */
+function extractWorkflowReferences(content) {
+  const references = [];
+  const refMatches = content.matchAll(/@~\/.claude\/([^\s\n]+)/g);
+
+  for (const match of refMatches) {
+    // Strip trailing punctuation
+    const refPath = match[1].replace(/[`.,)]+$/, '');
+    if (refPath.includes('get-your-work-done/workflows/')) {
+      references.push(path.basename(refPath));
+    }
+  }
+
+  return references;
+}
+
+/**
+ * Validate workflow references exist
+ * @param {string[]} references - Array of workflow file names
+ * @param {string} workflowsDir - Path to workflows directory
+ * @returns {string[]} Array of missing workflow files
+ */
+function validateWorkflowReferences(references, workflowsDir) {
+  const missing = [];
+
+  for (const ref of references) {
+    const workflowPath = path.join(workflowsDir, ref);
+    if (!fs.existsSync(workflowPath)) {
+      missing.push(ref);
+    }
+  }
+
+  return missing;
+}
+
+/**
+ * Validate a command file
+ * @param {string} filePath - Path to the command file
+ * @param {string} workflowsDir - Path to workflows directory
+ * @returns {{valid: boolean, errors: string[], warnings: string[]}}
+ */
+function validateCommandFile(filePath, workflowsDir) {
+  if (!fs.existsSync(filePath)) {
+    return { valid: false, errors: [`File not found: ${filePath}`], warnings: [] };
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const fileName = path.basename(filePath);
+
+  // Validate structure
+  const structureResult = validateCommandStructure(content, fileName);
+
+  // Validate workflow references
+  const references = extractWorkflowReferences(content);
+  const missingWorkflows = validateWorkflowReferences(references, workflowsDir);
+
+  const errors = [...structureResult.errors];
+  for (const missing of missingWorkflows) {
+    errors.push(`Referenced workflow not found: ${missing}`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings: structureResult.warnings,
+  };
+}
+
+module.exports = {
+  parseFrontmatter,
+  validateCommandStructure,
+  extractWorkflowReferences,
+  validateWorkflowReferences,
+  validateCommandFile,
+};

package/lib/validators/index.js

@@ -0,0 +1,29 @@
+/**
+ * GYWD Validators
+ *
+ * Central export for all validation modules.
+ * Zero external dependencies.
+ */
+
+const schemaValidator = require('./schema-validator');
+const commandValidator = require('./command-validator');
+
+module.exports = {
+  // Schema validation
+  validateJsonSyntax: schemaValidator.validateJsonSyntax,
+  validateSchemaStructure: schemaValidator.validateSchemaStructure,
+  validateDataAgainstSchema: schemaValidator.validateDataAgainstSchema,
+  loadSchema: schemaValidator.loadSchema,
+  validateFile: schemaValidator.validateFile,
+
+  // Command validation
+  parseFrontmatter: commandValidator.parseFrontmatter,
+  validateCommandStructure: commandValidator.validateCommandStructure,
+  extractWorkflowReferences: commandValidator.extractWorkflowReferences,
+  validateWorkflowReferences: commandValidator.validateWorkflowReferences,
+  validateCommandFile: commandValidator.validateCommandFile,
+
+  // Namespaced exports
+  schema: schemaValidator,
+  command: commandValidator,
+};

package/lib/validators/schema-validator.js

@@ -0,0 +1,183 @@
+/**
+ * Schema Validator
+ *
+ * Validates JSON schemas and data files against schemas.
+ * Zero external dependencies - uses native JSON parsing.
+ */
+
+const fs = require('fs');
+
+/**
+ * Validate JSON syntax
+ * @param {string} content - JSON string to validate
+ * @returns {{valid: boolean, error?: string, data?: object}}
+ */
+function validateJsonSyntax(content) {
+  try {
+    const data = JSON.parse(content);
+    return { valid: true, data };
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+}
+
+/**
+ * Validate schema structure (basic validation without external deps)
+ * @param {object} schema - The schema object to validate
+ * @returns {string[]} Array of issues found
+ */
+function validateSchemaStructure(schema) {
+  const issues = [];
+
+  if (!schema.$schema) {
+    issues.push('Missing $schema declaration');
+  }
+
+  if (!schema.title) {
+    issues.push('Missing title');
+  }
+
+  if (!schema.type && !schema.properties && !schema.definitions) {
+    issues.push('Schema has no type, properties, or definitions');
+  }
+
+  // Check for valid type if present
+  const validTypes = ['object', 'array', 'string', 'number', 'boolean', 'null', 'integer'];
+  if (schema.type && !validTypes.includes(schema.type)) {
+    issues.push(`Invalid type: ${schema.type}`);
+  }
+
+  // Check required is an array if present
+  if (schema.required && !Array.isArray(schema.required)) {
+    issues.push('Required must be an array');
+  }
+
+  // Check properties is an object if present
+  if (schema.properties && typeof schema.properties !== 'object') {
+    issues.push('Properties must be an object');
+  }
+
+  return issues;
+}
+
+/**
+ * Validate data against a schema (basic validation)
+ * @param {object} data - The data to validate
+ * @param {object} schema - The schema to validate against
+ * @returns {{valid: boolean, errors: string[]}}
+ */
+function validateDataAgainstSchema(data, schema) {
+  const errors = [];
+
+  // Type validation
+  if (schema.type) {
+    const actualType = Array.isArray(data) ? 'array' : typeof data;
+    if (schema.type === 'integer') {
+      if (typeof data !== 'number' || !Number.isInteger(data)) {
+        errors.push(`Expected integer, got ${typeof data}`);
+      }
+    } else if (actualType !== schema.type) {
+      errors.push(`Expected ${schema.type}, got ${actualType}`);
+    }
+  }
+
+  // Required properties validation
+  if (schema.required && schema.type === 'object') {
+    for (const prop of schema.required) {
+      if (!(prop in data)) {
+        errors.push(`Missing required property: ${prop}`);
+      }
+    }
+  }
+
+  // Enum validation
+  if (schema.enum && !schema.enum.includes(data)) {
+    errors.push(`Value must be one of: ${schema.enum.join(', ')}`);
+  }
+
+  // Nested properties validation
+  if (schema.properties && typeof data === 'object' && data !== null) {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (key in data) {
+        const result = validateDataAgainstSchema(data[key], propSchema);
+        for (const err of result.errors) {
+          errors.push(`${key}: ${err}`);
+        }
+      }
+    }
+  }
+
+  // Array items validation
+  if (schema.items && Array.isArray(data)) {
+    data.forEach((item, index) => {
+      const result = validateDataAgainstSchema(item, schema.items);
+      for (const err of result.errors) {
+        errors.push(`[${index}]: ${err}`);
+      }
+    });
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Load and validate a schema file
+ * @param {string} schemaPath - Path to the schema file
+ * @returns {{valid: boolean, schema?: object, errors: string[]}}
+ */
+function loadSchema(schemaPath) {
+  if (!fs.existsSync(schemaPath)) {
+    return { valid: false, errors: [`Schema file not found: ${schemaPath}`] };
+  }
+
+  const content = fs.readFileSync(schemaPath, 'utf8');
+  const parseResult = validateJsonSyntax(content);
+
+  if (!parseResult.valid) {
+    return { valid: false, errors: [`Invalid JSON: ${parseResult.error}`] };
+  }
+
+  const structureIssues = validateSchemaStructure(parseResult.data);
+  if (structureIssues.length > 0) {
+    return { valid: false, schema: parseResult.data, errors: structureIssues };
+  }
+
+  return { valid: true, schema: parseResult.data, errors: [] };
+}
+
+/**
+ * Validate a data file against a schema file
+ * @param {string} dataPath - Path to the data file
+ * @param {string} schemaPath - Path to the schema file
+ * @returns {{valid: boolean, errors: string[]}}
+ */
+function validateFile(dataPath, schemaPath) {
+  // Load schema
+  const schemaResult = loadSchema(schemaPath);
+  if (!schemaResult.valid) {
+    return { valid: false, errors: schemaResult.errors.map(e => `Schema: ${e}`) };
+  }
+
+  // Load data
+  if (!fs.existsSync(dataPath)) {
+    return { valid: false, errors: [`Data file not found: ${dataPath}`] };
+  }
+
+  const content = fs.readFileSync(dataPath, 'utf8');
+  const parseResult = validateJsonSyntax(content);
+
+  if (!parseResult.valid) {
+    return { valid: false, errors: [`Invalid JSON: ${parseResult.error}`] };
+  }
+
+  // Validate data against schema
+  return validateDataAgainstSchema(parseResult.data, schemaResult.schema);
+}
+
+module.exports = {
+  validateJsonSyntax,
+  validateSchemaStructure,
+  validateDataAgainstSchema,
+  loadSchema,
+  validateFile,
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "pmp-gywd",
+  "version": "3.3.0",
+  "description": "PMP (GYWD - Get Your Work Done) - Decision-aware, context-engineered development system for Claude Code. Understands WHY code exists, not just WHAT it does.",
+  "bin": {
+    "pmp-gywd": "bin/install.js"
+  },
+  "files": [
+    "bin",
+    "commands",
+    "docs",
+    "get-your-work-done",
+    "lib"
+  ],
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --reporters=default --reporters=jest-junit",
+    "lint": "eslint bin lib scripts tests --ext .js",
+    "lint:fix": "eslint bin lib scripts tests --ext .js --fix",
+    "validate:schemas": "node scripts/validate-schemas.js",
+    "validate:commands": "node scripts/validate-commands.js",
+    "validate:all": "npm run validate:schemas && npm run validate:commands",
+    "generate:tests": "node scripts/generate-tests.js",
+    "generate:docs": "node scripts/generate-docs.js",
+    "analyze:deps": "node scripts/analyze-dependencies.js",
+    "precommit": "npm run lint && npm run validate:all && npm test",
+    "prepublishOnly": "npm run test:ci && npm run validate:all",
+    "release": "npm run lint && npm run validate:all && npm test"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "meta-prompting",
+    "context-engineering",
+    "spec-driven-development",
+    "decision-intelligence",
+    "pmp",
+    "gywd"
+  ],
+  "author": "cyberbloke9",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cyberbloke9/pmp-gywd.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cyberbloke9/pmp-gywd/issues"
+  },
+  "homepage": "https://github.com/cyberbloke9/pmp-gywd#readme",
+  "engines": {
+    "node": ">=16.7.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0"
+  }
+}