grimoire-framework 1.0.0

package/.grimoire/product/templates/engine/schemas/task.schema.json

@@ -0,0 +1,154 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Task Template Variables",
+  "description": "Schema for Task template variables",
+  "type": "object",
+  "required": ["id", "name", "description", "status"],
+  "properties": {
+    "id": {
+      "type": "string",
+      "description": "Task ID"
+    },
+    "name": {
+      "type": "string",
+      "minLength": 3,
+      "maxLength": 150,
+      "description": "Task name"
+    },
+    "description": {
+      "type": "string",
+      "minLength": 10,
+      "description": "Task description"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["Pending", "In Progress", "Completed", "Blocked", "Cancelled"],
+      "description": "Task status"
+    },
+    "storyRef": {
+      "type": "string",
+      "description": "Reference to parent story"
+    },
+    "assignee": {
+      "type": "string",
+      "description": "Task assignee"
+    },
+    "estimate": {
+      "type": "string",
+      "description": "Time estimate (e.g., 2h, 1d)"
+    },
+    "priority": {
+      "type": "string",
+      "enum": ["P0", "P1", "P2", "P3"],
+      "description": "Task priority"
+    },
+    "type": {
+      "type": "string",
+      "enum": ["Development", "Design", "Testing", "Documentation", "Research", "Bugfix", "Refactor"],
+      "description": "Task type"
+    },
+    "inputs": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Required inputs"
+    },
+    "outputs": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Expected outputs"
+    },
+    "steps": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["step"],
+        "properties": {
+          "step": {
+            "type": "string",
+            "description": "Step description"
+          },
+          "completed": {
+            "type": "boolean",
+            "default": false
+          },
+          "notes": {
+            "type": "string"
+          }
+        }
+      },
+      "description": "Task steps"
+    },
+    "validation": {
+      "type": "object",
+      "properties": {
+        "criteria": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "commands": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      },
+      "description": "Validation criteria"
+    },
+    "dependencies": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Task dependencies"
+    },
+    "blockedBy": {
+      "type": "string",
+      "description": "Blocking issue if status is Blocked"
+    },
+    "completedAt": {
+      "type": "string",
+      "format": "date-time",
+      "description": "Completion timestamp"
+    },
+    "notes": {
+      "type": "string",
+      "description": "Additional notes"
+    },
+    "files": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["path", "action"],
+        "properties": {
+          "path": { "type": "string" },
+          "action": {
+            "type": "string",
+            "enum": ["created", "modified", "deleted"]
+          }
+        }
+      },
+      "description": "Files affected by this task"
+    },
+    "elicitation": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "questions": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["question"],
+            "properties": {
+              "question": { "type": "string" },
+              "type": {
+                "type": "string",
+                "enum": ["text", "choice", "confirm"]
+              },
+              "options": {
+                "type": "array",
+                "items": { "type": "string" }
+              }
+            }
+          }
+        }
+      },
+      "description": "Elicitation configuration"
+    }
+  }
+}

package/.grimoire/product/templates/engine/validator.js

@@ -0,0 +1,295 @@
+/**
+ * JSON Schema Validator Module
+ * Validates rendered template output against JSON schemas using Ajv
+ *
+ * @module validator
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const Ajv = require('ajv');
+const addFormats = require('ajv-formats');
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * TemplateValidator class for validating template output
+ */
+class TemplateValidator {
+  /**
+   * Create a TemplateValidator instance
+   * @param {Object} options - Configuration options
+   * @param {string} options.schemasDir - Path to schemas directory
+   */
+  constructor(options = {}) {
+    this.schemasDir = options.schemasDir ||
+      path.join(process.cwd(), '.grimoire', 'product', 'templates', 'engine', 'schemas');
+
+    this.ajv = new Ajv({
+      allErrors: true,
+      verbose: true,
+      strict: false,
+      validateFormats: true,
+    });
+
+    // Add format validators
+    addFormats(this.ajv);
+
+    // Add custom formats
+    this.registerCustomFormats();
+
+    // Schema cache
+    this.schemas = new Map();
+  }
+
+  /**
+   * Register custom validation formats
+   */
+  registerCustomFormats() {
+    // Semantic version format
+    this.ajv.addFormat('semver', {
+      validate: (str) => /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?(\+[a-zA-Z0-9.]+)?$/.test(str),
+    });
+
+    // Slug format (URL-safe string)
+    this.ajv.addFormat('slug', {
+      validate: (str) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(str),
+    });
+
+    // Story ID format (e.g., "3.6", "12.1")
+    this.ajv.addFormat('story-id', {
+      validate: (str) => /^\d+\.\d+$/.test(str),
+    });
+
+    // Epic ID format (e.g., "EPIC-S3")
+    this.ajv.addFormat('epic-id', {
+      validate: (str) => /^EPIC-[A-Z0-9]+$/.test(str),
+    });
+  }
+
+  /**
+   * Load a schema by template type
+   * @param {string} templateType - Template type (prd, adr, etc.)
+   * @returns {Promise<Object>} Loaded schema
+   */
+  async loadSchema(templateType) {
+    if (this.schemas.has(templateType)) {
+      return this.schemas.get(templateType);
+    }
+
+    // Handle versioned schema aliases (e.g., prd-v2 -> prd-v2.schema.json)
+    const schemaAliases = {
+      'prd-v2': 'prd-v2',
+    };
+
+    const schemaName = schemaAliases[templateType] || templateType;
+    const schemaPath = path.join(this.schemasDir, `${schemaName}.schema.json`);
+
+    try {
+      const content = await fs.readFile(schemaPath, 'utf-8');
+      const schema = JSON.parse(content);
+      this.schemas.set(templateType, schema);
+      return schema;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Schema not found for template type: ${templateType}`);
+      }
+      throw new Error(`Failed to load schema for ${templateType}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Register a schema directly
+   * @param {string} templateType - Template type
+   * @param {Object} schema - JSON Schema object
+   */
+  registerSchema(templateType, schema) {
+    this.schemas.set(templateType, schema);
+    this.ajv.addSchema(schema, templateType);
+  }
+
+  /**
+   * Validate data against a template schema
+   * @param {Object} data - Data to validate
+   * @param {string} templateType - Template type for schema lookup
+   * @returns {Promise<Object>} Validation result
+   */
+  async validate(data, templateType) {
+    const schema = await this.loadSchema(templateType);
+
+    // Get cached validator or compile and cache it with AJV
+    let validate = this.ajv.getSchema(templateType);
+    if (!validate) {
+      // Register schema with AJV for proper caching using $id or templateType as key
+      const schemaId = schema.$id || templateType;
+      if (!this.ajv.getSchema(schemaId)) {
+        this.ajv.addSchema(schema, templateType);
+      }
+      validate = this.ajv.getSchema(templateType);
+
+      // Fallback to compile if addSchema didn't work (edge case)
+      if (!validate) {
+        validate = this.ajv.compile(schema);
+      }
+    }
+
+    const isValid = validate(data);
+
+    if (isValid) {
+      return {
+        isValid: true,
+        errors: [],
+        data,
+      };
+    }
+
+    return {
+      isValid: false,
+      errors: this.formatErrors(validate.errors),
+      data,
+    };
+  }
+
+  /**
+   * Validate rendered markdown content structure
+   * @param {string} content - Rendered markdown content
+   * @param {Object} template - Template with metadata
+   * @returns {Object} Validation result
+   */
+  validateStructure(content, template) {
+    const errors = [];
+    const metadata = template.metadata || {};
+
+    // Check required sections from template metadata
+    if (metadata.required_sections) {
+      for (const section of metadata.required_sections) {
+        const sectionRegex = new RegExp(`^##?\\s+${section}`, 'mi');
+        if (!sectionRegex.test(content)) {
+          errors.push(`Missing required section: ${section}`);
+        }
+      }
+    }
+
+    // Check for empty required fields
+    if (metadata.variables) {
+      for (const variable of metadata.variables) {
+        if (variable.required) {
+          const placeholder = `{{${variable.name}}}`;
+          if (content.includes(placeholder)) {
+            errors.push(`Unresolved required variable: ${variable.name}`);
+          }
+        }
+      }
+    }
+
+    // Check minimum content length
+    if (metadata.min_length && content.length < metadata.min_length) {
+      errors.push(`Content too short: ${content.length} < ${metadata.min_length} characters`);
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Format Ajv errors into readable messages
+   * @param {Array} errors - Ajv error objects
+   * @returns {Array<string>} Formatted error messages
+   */
+  formatErrors(errors) {
+    if (!errors) return [];
+
+    return errors.map(error => {
+      const path = error.instancePath || '/';
+      const message = error.message;
+      const params = error.params;
+
+      let details = '';
+      if (params) {
+        if (params.additionalProperty) {
+          details = ` (unknown property: ${params.additionalProperty})`;
+        } else if (params.missingProperty) {
+          details = ` (missing: ${params.missingProperty})`;
+        } else if (params.allowedValues) {
+          details = ` (allowed: ${params.allowedValues.join(', ')})`;
+        }
+      }
+
+      return `${path}: ${message}${details}`;
+    });
+  }
+
+  /**
+   * Extract data from rendered markdown for validation
+   * @param {string} content - Rendered markdown content
+   * @param {Object} template - Template with metadata
+   * @returns {Object} Extracted data object
+   */
+  extractDataFromMarkdown(content, template) {
+    const data = {};
+    const lines = content.split('\n');
+
+    // Extract frontmatter values (key: value format)
+    for (const line of lines) {
+      const match = line.match(/^\*\*([^:]+):\*\*\s*(.+)$/);
+      if (match) {
+        const key = match[1].toLowerCase().replace(/\s+/g, '_');
+        const value = match[2].trim();
+        data[key] = value;
+      }
+    }
+
+    // Extract title from first heading
+    const titleMatch = content.match(/^#\s+(.+)$/m);
+    if (titleMatch) {
+      data.title = titleMatch[1].trim();
+    }
+
+    return data;
+  }
+
+  /**
+   * Check if all schemas exist for supported template types
+   * @param {Array<string>} templateTypes - Template types to check
+   * @returns {Promise<Object>} Check result with missing schemas
+   */
+  async checkSchemas(templateTypes) {
+    const missing = [];
+    const found = [];
+
+    for (const type of templateTypes) {
+      try {
+        await this.loadSchema(type);
+        found.push(type);
+      } catch {
+        missing.push(type);
+      }
+    }
+
+    return {
+      complete: missing.length === 0,
+      found,
+      missing,
+    };
+  }
+
+  /**
+   * Clear schema cache
+   * @param {string} templateType - Specific schema to clear, or all if not provided
+   */
+  clearCache(templateType) {
+    if (templateType) {
+      this.schemas.delete(templateType);
+    } else {
+      this.schemas.clear();
+    }
+  }
+}
+
+module.exports = {
+  TemplateValidator,
+};
+

package/.grimoire/product/templates/epic.hbs

@@ -0,0 +1,213 @@
+---
+template_id: epic
+template_name: Epic
+version: 1.0
+variables:
+  - name: id
+    type: string
+    required: true
+    prompt: "Epic ID (e.g., EPIC-S3):"
+  - name: title
+    type: string
+    required: true
+    prompt: "Epic title:"
+  - name: status
+    type: choice
+    required: true
+    choices: [Planning, In Progress, Completed, On Hold, Cancelled]
+    default: Planning
+  - name: owner
+    type: string
+    required: true
+    prompt: "Epic owner:"
+  - name: objective
+    type: text
+    required: true
+    prompt: "What is the epic's main objective?"
+---
+
+# {{id}}: {{title}}
+
+**Status:** {{#ifEqual status "Planning"}}📋{{/ifEqual}}{{#ifEqual status "In Progress"}}🔄{{/ifEqual}}{{#ifEqual status "Completed"}}✅{{/ifEqual}}{{#ifEqual status "On Hold"}}⏸️{{/ifEqual}}{{#ifEqual status "Cancelled"}}❌{{/ifEqual}} {{status}}
+**Owner:** {{owner}}
+**Created:** {{formatDate now "YYYY-MM-DD"}}
+{{#if updated}}**Updated:** {{updated}}{{/if}}
+
+---
+
+## Objective
+
+{{objective}}
+
+{{#if businessValue}}
+## Business Value
+
+{{businessValue}}
+{{/if}}
+
+---
+
+{{#if stakeholders}}
+## Stakeholders
+
+{{#each stakeholders}}
+- {{this}}
+{{/each}}
+{{/if}}
+
+---
+
+## Scope
+
+{{#if scope}}
+### In Scope
+{{#each scope.inScope}}
+- {{this}}
+{{/each}}
+
+{{#if scope.outOfScope}}
+### Out of Scope
+{{#each scope.outOfScope}}
+- {{this}}
+{{/each}}
+{{/if}}
+{{else}}
+_Scope to be defined._
+{{/if}}
+
+---
+
+## Stories
+
+{{#if stories}}
+| ID | Title | Points | Priority | Status |
+|----|-------|--------|----------|--------|
+{{#each stories}}
+| [{{this.id}}](./stories/story-{{this.id}}.md) | {{this.title}} | {{default this.points "-"}} | {{default this.priority "Medium"}} | {{default this.status "Draft"}} |
+{{/each}}
+
+**Total Points:** {{#if progress}}{{progress.totalPoints}}{{else}}_TBD_{{/if}}
+{{else}}
+_Stories to be defined._
+{{/if}}
+
+---
+
+{{#if sprints}}
+## Sprint Planning
+
+{{#each sprints}}
+### Sprint {{this.number}}
+{{#if this.goal}}**Goal:** {{this.goal}}{{/if}}
+
+{{#if this.stories}}
+**Stories:**
+{{#each this.stories}}
+- {{this}}
+{{/each}}
+{{/if}}
+
+{{/each}}
+{{/if}}
+
+---
+
+## Success Criteria
+
+{{#if successCriteria}}
+{{#each successCriteria}}
+- [ ] {{this.criteria}}{{#if this.metric}} ({{this.metric}}: {{this.target}}){{/if}}
+{{/each}}
+{{else}}
+_Success criteria to be defined._
+{{/if}}
+
+---
+
+## Technical Requirements
+
+{{#if technicalRequirements}}
+{{#each technicalRequirements}}
+- {{this}}
+{{/each}}
+{{else}}
+_Technical requirements to be defined._
+{{/if}}
+
+---
+
+## Risks
+
+{{#if risks}}
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+{{#each risks}}
+| {{this.risk}} | {{default this.impact "Medium"}} | {{default this.mitigation "TBD"}} |
+{{/each}}
+{{else}}
+_No risks identified._
+{{/if}}
+
+---
+
+## Dependencies
+
+{{#if dependencies}}
+**Depends on:**
+{{#each dependencies.dependsOn}}
+- {{this}}
+{{/each}}
+
+{{#if dependencies.blocks}}
+**Blocks:**
+{{#each dependencies.blocks}}
+- {{this}}
+{{/each}}
+{{/if}}
+{{else}}
+_No dependencies._
+{{/if}}
+
+---
+
+## Documentation
+
+{{#if documentation}}
+| Type | Location | Status |
+|------|----------|--------|
+{{#each documentation}}
+| {{this.type}} | {{this.location}} | {{default this.status "Pending"}} |
+{{/each}}
+{{else}}
+_Documentation requirements to be defined._
+{{/if}}
+
+---
+
+## Progress
+
+{{#if progress}}
+- **Total Points:** {{progress.totalPoints}}
+- **Completed Points:** {{progress.completedPoints}}
+- **Progress:** {{progress.percentComplete}}%
+
+```
+[{{#times 10}}{{#if (lt @index (divide ../progress.percentComplete 10))}}█{{else}}░{{/if}}{{/times}}] {{progress.percentComplete}}%
+```
+{{else}}
+_Progress tracking to be updated._
+{{/if}}
+
+---
+
+## Change Log
+
+| Date | Version | Description | Author |
+|------|---------|-------------|--------|
+| {{formatDate now "YYYY-MM-DD"}} | 1.0 | Epic created | grimoire Template Engine |
+
+---
+
+**Generated by:** grimoire Template Engine v2.0
+**Template Version:** epic-1.0
+

package/.grimoire/product/templates/eslintrc-security.json

@@ -0,0 +1,32 @@
+{
+  "env": {
+    "node": true,
+    "es2021": true
+  },
+  "extends": [
+    "eslint:recommended"
+  ],
+  "plugins": [
+    "security",
+    "no-secrets"
+  ],
+  "parserOptions": {
+    "ecmaVersion": 2021,
+    "sourceType": "module"
+  },
+  "rules": {
+    "security/detect-object-injection": "error",
+    "security/detect-non-literal-regexp": "warn",
+    "security/detect-unsafe-regex": "error",
+    "security/detect-buffer-noassert": "error",
+    "security/detect-child-process": "error",
+    "security/detect-disable-mustache-escape": "error",
+    "security/detect-eval-with-expression": "error",
+    "security/detect-no-csrf-before-method-override": "error",
+    "security/detect-non-literal-fs-filename": "warn",
+    "security/detect-non-literal-require": "error",
+    "security/detect-possible-timing-attacks": "warn",
+    "security/detect-pseudoRandomBytes": "error",
+    "no-secrets/no-secrets": "error"
+  }
+}