@qazuor/claude-code-config 0.1.0

package/templates/scripts/validate-registry.sh

@@ -0,0 +1,225 @@
+#!/usr/bin/env bash
+#
+# Code Registry Validation Script
+#
+# Validates .code-registry.json against its JSON schema and checks data integrity
+#
+# Exit codes:
+#   0 - Validation passed
+#   1 - Validation failed
+#
+
+set -euo pipefail
+
+# Colors
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+REGISTRY_FILE=".claude/sessions/planning/.code-registry.json"
+SCHEMA_FILE=".claude/schemas/code-registry.schema.json"
+
+error() {
+  echo -e "${RED}✗ $1${NC}"
+  exit 1
+}
+
+warning() {
+  echo -e "${YELLOW}⚠ $1${NC}"
+}
+
+success() {
+  echo -e "${GREEN}✓ $1${NC}"
+}
+
+info() {
+  echo -e "${BLUE}ℹ $1${NC}"
+}
+
+echo -e "${BLUE}🔍 Validating code registry...${NC}"
+echo ""
+
+# ============================================================================
+# 1. Check file existence
+# ============================================================================
+
+if [ ! -f "$REGISTRY_FILE" ]; then
+  error "Code registry not found: $REGISTRY_FILE"
+fi
+
+success "Registry file exists"
+
+if [ ! -f "$SCHEMA_FILE" ]; then
+  error "Schema file not found: $SCHEMA_FILE"
+fi
+
+success "Schema file exists"
+
+# ============================================================================
+# 2. Validate JSON syntax
+# ============================================================================
+
+if ! jq empty "$REGISTRY_FILE" 2>/dev/null; then
+  error "Registry is not valid JSON"
+fi
+
+success "Registry is valid JSON"
+
+# ============================================================================
+# 3. Validate against JSON Schema (using Node + AJV)
+# ============================================================================
+
+echo ""
+echo "📋 Validating against schema..."
+
+# Create temporary validation script
+TEMP_SCRIPT=$(mktemp)
+cat > "$TEMP_SCRIPT" << 'EOF'
+const Ajv = require('ajv');
+const addFormats = require('ajv-formats');
+const fs = require('fs');
+
+const ajv = new Ajv({ allErrors: true, verbose: true });
+addFormats(ajv);
+
+const schemaPath = process.argv[2];
+const dataPath = process.argv[3];
+
+try {
+  const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
+  const data = JSON.parse(fs.readFileSync(dataPath, 'utf-8'));
+
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+
+  if (!valid) {
+    console.error('Schema validation failed:');
+    console.error(JSON.stringify(validate.errors, null, 2));
+    process.exit(1);
+  }
+
+  console.log('✓ Schema validation passed');
+  process.exit(0);
+} catch (error) {
+  console.error('Validation error:', error.message);
+  process.exit(1);
+}
+EOF
+
+if node "$TEMP_SCRIPT" "$SCHEMA_FILE" "$REGISTRY_FILE" 2>/dev/null; then
+  success "Schema validation passed"
+else
+  rm -f "$TEMP_SCRIPT"
+  error "Schema validation failed"
+fi
+
+rm -f "$TEMP_SCRIPT"
+
+# ============================================================================
+# 4. Extract and display statistics
+# ============================================================================
+
+echo ""
+echo "📊 Registry Statistics"
+echo "======================"
+
+VERSION=$(jq -r '.version' "$REGISTRY_FILE")
+GENERATED_AT=$(jq -r '.generatedAt' "$REGISTRY_FILE")
+LAST_PLANNING=$(jq -r '.lastPlanningNumber' "$REGISTRY_FILE")
+TOTAL_SESSIONS=$(jq '.registry | length' "$REGISTRY_FILE")
+
+echo "   Version: $VERSION"
+echo "   Generated: $GENERATED_AT"
+echo "   Last planning number: $LAST_PLANNING"
+echo "   Total sessions: $TOTAL_SESSIONS"
+
+# Count by type
+FEATURE_COUNT=$(jq '[.registry[] | select(.type == "feature")] | length' "$REGISTRY_FILE")
+REFACTOR_COUNT=$(jq '[.registry[] | select(.type == "refactor")] | length' "$REGISTRY_FILE")
+BUGFIX_COUNT=$(jq '[.registry[] | select(.type == "bugfix")] | length' "$REGISTRY_FILE")
+
+echo ""
+echo "   By Type:"
+echo "   ├─ Features: $FEATURE_COUNT"
+echo "   ├─ Refactors: $REFACTOR_COUNT"
+echo "   └─ Bugfixes: $BUGFIX_COUNT"
+
+# Count by status
+ACTIVE_COUNT=$(jq '[.registry[] | select(.status == "active")] | length' "$REGISTRY_FILE")
+COMPLETED_COUNT=$(jq '[.registry[] | select(.status == "completed")] | length' "$REGISTRY_FILE")
+ARCHIVED_COUNT=$(jq '[.registry[] | select(.status == "archived")] | length' "$REGISTRY_FILE")
+CANCELLED_COUNT=$(jq '[.registry[] | select(.status == "cancelled")] | length' "$REGISTRY_FILE")
+
+echo ""
+echo "   By Status:"
+echo "   ├─ Active: $ACTIVE_COUNT"
+echo "   ├─ Completed: $COMPLETED_COUNT"
+echo "   ├─ Archived: $ARCHIVED_COUNT"
+echo "   └─ Cancelled: $CANCELLED_COUNT"
+
+# Total tasks
+TOTAL_TASKS=$(jq '[.registry[].tasks | length] | add // 0' "$REGISTRY_FILE")
+echo ""
+echo "   Total tasks: $TOTAL_TASKS"
+
+# ============================================================================
+# 5. Validate session paths exist
+# ============================================================================
+
+echo ""
+echo "🔍 Validating session paths..."
+
+MISSING_PATHS=0
+jq -r '.registry[].sessionPath' "$REGISTRY_FILE" | while read -r path; do
+  SESSION_PATH=".claude/sessions/planning/$path"
+  if [ ! -d "$SESSION_PATH" ]; then
+    warning "Session path not found: $path"
+    ((MISSING_PATHS++))
+  fi
+done
+
+if [ "$MISSING_PATHS" -eq 0 ]; then
+  success "All session paths exist"
+fi
+
+# ============================================================================
+# 6. Check staleness
+# ============================================================================
+
+echo ""
+echo "⏰ Checking freshness..."
+
+CURRENT_TIME=$(date +%s)
+GENERATED_TIME=$(date -d "$GENERATED_AT" +%s 2>/dev/null || echo "0")
+
+if [ "$GENERATED_TIME" -gt 0 ]; then
+  TIME_DIFF=$((CURRENT_TIME - GENERATED_TIME))
+  DAYS_OLD=$((TIME_DIFF / 86400))
+
+  if [ $DAYS_OLD -gt 7 ]; then
+    warning "Registry is $DAYS_OLD days old - consider regenerating"
+    info "Run: pnpm claude:sync:registry"
+  else
+    success "Registry is fresh ($DAYS_OLD days old)"
+  fi
+else
+  warning "Could not determine registry age"
+fi
+
+# ============================================================================
+# Summary
+# ============================================================================
+
+echo ""
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+success "Code registry validation complete"
+echo ""
+echo "   Sessions: $TOTAL_SESSIONS ($ACTIVE_COUNT active)"
+echo "   Tasks: $TOTAL_TASKS"
+echo "   Last planning: $LAST_PLANNING"
+echo ""
+
+exit 0

package/templates/scripts/validate-schemas.ts

@@ -0,0 +1,283 @@
+#!/usr/bin/env tsx
+/**
+ * Schema Validation Script
+ *
+ * Validates JSON files and markdown frontmatter against JSON schemas.
+ * Uses ajv for schema validation.
+ *
+ * Exit codes:
+ *   0 - All validations passed
+ *   1 - Validation failed
+ */
+
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, resolve, dirname, basename } from 'node:path';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+
+// Initialize ajv with formats (for date-time, uri, etc.)
+const ajv = new Ajv({ allErrors: true, strict: false });
+addFormats(ajv);
+
+// Counters
+let totalFiles = 0;
+let validFiles = 0;
+let invalidFiles = 0;
+const errors: Array<{ file: string; path?: string; error: string }> = [];
+
+// Directories
+const SCHEMAS_DIR = resolve(process.cwd(), '.claude/schemas');
+const PLANNING_DIR = resolve(process.cwd(), '.claude/sessions/planning');
+
+// Schema mappings: filename pattern -> schema file
+const SCHEMA_MAPPINGS: Record<string, string> = {
+  'PDR.md': 'pdr.schema.json',
+  'tech-analysis.md': 'tech-analysis.schema.json',
+  'TODOs.md': 'todos.schema.json',
+  'problems.md': 'problems.schema.json',
+  '.checkpoint.json': 'checkpoint.schema.json',
+  '.code-registry.json': 'code-registry.schema.json'
+};
+
+// Schema cache
+const schemaCache = new Map<string, ReturnType<typeof ajv.compile>>();
+
+/**
+ * Load and compile a JSON schema (with caching)
+ */
+function loadSchema(schemaFile: string) {
+  // Return cached schema if exists
+  if (schemaCache.has(schemaFile)) {
+    return schemaCache.get(schemaFile)!;
+  }
+  try {
+    const schemaPath = join(SCHEMAS_DIR, schemaFile);
+    const schemaData = readFileSync(schemaPath, 'utf-8');
+    const schema = JSON.parse(schemaData);
+    const compiled = ajv.compile(schema);
+
+    // Cache the compiled schema
+    schemaCache.set(schemaFile, compiled);
+
+    return compiled;
+  } catch (error) {
+    console.error(`❌ Error loading schema ${schemaFile}:`, error);
+    return null;
+  }
+}
+
+/**
+ * Extract frontmatter from markdown file
+ */
+function extractFrontmatter(content: string): Record<string, string> | null {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---/;
+  const match = content.match(frontmatterRegex);
+
+  if (!match) {
+    return null;
+  }
+
+  try {
+    // Simple YAML-like parsing (supports basic key: value pairs)
+    const yamlContent = match[1];
+    const data: Record<string, string> = {};
+
+    yamlContent.split('\n').forEach((line) => {
+      const colonIndex = line.indexOf(':');
+      if (colonIndex > 0) {
+        const key = line.substring(0, colonIndex).trim();
+        const value = line.substring(colonIndex + 1).trim();
+
+        // Remove quotes if present
+        data[key] = value.replace(/^["']|["']$/g, '');
+      }
+    });
+
+    return data;
+  } catch (error) {
+    console.error('  Error parsing frontmatter:', error);
+    return null;
+  }
+}
+
+/**
+ * Validate a JSON file against a schema
+ */
+function validateJsonFile(filePath: string, schemaFile: string): boolean {
+  totalFiles++;
+
+  const validate = loadSchema(schemaFile);
+  if (!validate) {
+    invalidFiles++;
+    errors.push({ file: filePath, error: `Schema ${schemaFile} not found or invalid` });
+    return false;
+  }
+
+  try {
+    const fileContent = readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(fileContent);
+
+    const valid = validate(data);
+
+    if (valid) {
+      validFiles++;
+      console.log(`  ✓ ${basename(filePath)}`);
+      return true;
+    }
+
+    invalidFiles++;
+    console.log(`  ✗ ${basename(filePath)}`);
+
+    if (validate.errors) {
+      validate.errors.forEach((error) => {
+        console.log(`    → ${error.instancePath || '/'}: ${error.message}`);
+        errors.push({
+          file: filePath,
+          path: error.instancePath,
+          error: error.message || 'Unknown error'
+        });
+      });
+    }
+
+    return false;
+  } catch (error) {
+    invalidFiles++;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(`  ✗ ${basename(filePath)} - ${errorMessage}`);
+    errors.push({ file: filePath, error: errorMessage });
+    return false;
+  }
+}
+
+/**
+ * Validate a markdown file's frontmatter
+ */
+function validateMarkdownFile(filePath: string, schemaFile: string): boolean {
+  totalFiles++;
+
+  const validate = loadSchema(schemaFile);
+  if (!validate) {
+    invalidFiles++;
+    errors.push({ file: filePath, error: `Schema ${schemaFile} not found or invalid` });
+    return false;
+  }
+
+  try {
+    const fileContent = readFileSync(filePath, 'utf-8');
+    const frontmatter = extractFrontmatter(fileContent);
+
+    if (!frontmatter) {
+      console.log(`  ⚠ ${basename(filePath)} - No frontmatter found (skipping)`);
+      totalFiles--; // Don't count files without frontmatter
+      return true;
+    }
+
+    const valid = validate(frontmatter);
+
+    if (valid) {
+      validFiles++;
+      console.log(`  ✓ ${basename(filePath)}`);
+      return true;
+    }
+
+    invalidFiles++;
+    console.log(`  ✗ ${basename(filePath)}`);
+
+    if (validate.errors) {
+      validate.errors.forEach((error) => {
+        console.log(`    → ${error.instancePath || '/'}: ${error.message}`);
+        errors.push({
+          file: filePath,
+          path: error.instancePath,
+          error: error.message || 'Unknown error'
+        });
+      });
+    }
+
+    return false;
+  } catch (error) {
+    invalidFiles++;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(`  ✗ ${basename(filePath)} - ${errorMessage}`);
+    errors.push({ file: filePath, error: errorMessage });
+    return false;
+  }
+}
+
+/**
+ * Find all files matching a pattern in a directory
+ */
+function findFiles(baseDir: string, pattern: string): string[] {
+  const results: string[] = [];
+
+  function walk(dir: string) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Skip node_modules and hidden directories
+        if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+          walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        if (entry.name === pattern || entry.name.endsWith(pattern)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  }
+
+  walk(baseDir);
+  return results;
+}
+
+/**
+ * Main validation logic
+ */
+function main() {
+  console.log('🔍 Validating schemas...\n');
+
+  // Validate each file type
+  for (const [filePattern, schemaFile] of Object.entries(SCHEMA_MAPPINGS)) {
+    console.log(`📄 Validating ${filePattern} files against ${schemaFile}...`);
+
+    const files = findFiles(PLANNING_DIR, filePattern);
+
+    if (files.length === 0) {
+      console.log('  (No files found)\n');
+      continue;
+    }
+
+    files.forEach((file) => {
+      if (file.endsWith('.json')) {
+        validateJsonFile(file, schemaFile);
+      } else if (file.endsWith('.md')) {
+        validateMarkdownFile(file, schemaFile);
+      }
+    });
+
+    console.log('');
+  }
+
+  // Summary
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  if (invalidFiles === 0) {
+    console.log('✅ All validations passed!');
+    console.log(`   Total files: ${totalFiles}`);
+    console.log(`   Valid: ${validFiles}`);
+    process.exit(0);
+  }
+
+  console.log('❌ Validation failed!');
+  console.log(`   Total files: ${totalFiles}`);
+  console.log(`   Valid: ${validFiles}`);
+  console.log(`   Invalid: ${invalidFiles}`);
+  console.log(`   Errors: ${errors.length}`);
+  process.exit(1);
+}
+
+main();

package/templates/scripts/validate-structure.sh

@@ -0,0 +1,165 @@
+#!/bin/bash
+
+# validate-structure.sh
+# Validates the complete .claude directory structure
+
+set -e
+
+echo "🔍 Validating .claude directory structure..."
+echo ""
+
+ERRORS=0
+WARNINGS=0
+
+# Colors
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+GREEN='\033[0;32m'
+NC='\033[0m' # No Color
+
+error() {
+  echo -e "${RED}✗ $1${NC}"
+  ERRORS=$((ERRORS + 1))
+}
+
+warning() {
+  echo -e "${YELLOW}⚠ $1${NC}"
+  WARNINGS=$((WARNINGS + 1))
+}
+
+success() {
+  echo -e "${GREEN}✓ $1${NC}"
+}
+
+# Check required directories
+echo "📁 Checking directory structure..."
+
+REQUIRED_DIRS=(
+  ".claude/agents"
+  ".claude/commands"
+  ".claude/skills"
+  ".claude/docs"
+  ".claude/docs/standards"
+  ".claude/docs/workflows"
+  ".claude/docs/diagrams"
+  ".claude/docs/learnings"
+  ".claude/schemas"
+  ".claude/scripts"
+  ".claude/sessions"
+  ".claude/sessions/planning"
+)
+
+for dir in "${REQUIRED_DIRS[@]}"; do
+  if [ ! -d "$dir" ]; then
+    error "Missing directory: $dir"
+  else
+    success "Directory exists: $dir"
+  fi
+done
+
+echo ""
+echo "📄 Checking required files..."
+
+REQUIRED_FILES=(
+  "CLAUDE.md"
+  ".claude/docs/INDEX.md"
+  ".claude/docs/quick-start.md"
+  ".claude/docs/glossary.md"
+  ".claude/agents/README.md"
+  ".claude/commands/README.md"
+  ".claude/skills/README.md"
+  ".claude/scripts/health-check.sh"
+)
+
+for file in "${REQUIRED_FILES[@]}"; do
+  if [ ! -f "$file" ]; then
+    error "Missing file: $file"
+  else
+    success "File exists: $file"
+  fi
+done
+
+echo ""
+echo "🔢 Checking file counts..."
+
+# Count agents (excluding README.md)
+AGENT_COUNT=$(find .claude/agents -name "*.md" -type f ! -name "README.md" | wc -l)
+echo "   Agents: $AGENT_COUNT (expected: 13)"
+if [ "$AGENT_COUNT" -ne 13 ]; then
+  warning "Agent count mismatch"
+fi
+
+# Count commands (excluding README.md)
+COMMAND_COUNT=$(find .claude/commands -name "*.md" -type f ! -name "README.md" | wc -l)
+echo "   Commands: $COMMAND_COUNT (expected: 16)"
+if [ "$COMMAND_COUNT" -ne 16 ]; then
+  warning "Command count mismatch"
+fi
+
+# Count skills (excluding README.md)
+SKILL_COUNT=$(find .claude/skills -name "*.md" -type f ! -name "README.md" | wc -l)
+echo "   Skills: $SKILL_COUNT (expected: 16)"
+if [ "$SKILL_COUNT" -ne 16 ]; then
+  warning "Skill count mismatch"
+fi
+
+# Count workflows (excluding README.md)
+WORKFLOW_COUNT=$(find .claude/docs/workflows -name "*.md" -type f ! -name "README.md" | wc -l)
+echo "   Workflows: $WORKFLOW_COUNT (expected: 9)"
+if [ "$WORKFLOW_COUNT" -ne 9 ]; then
+  warning "Workflow count mismatch"
+fi
+
+# Count diagrams
+DIAGRAM_COUNT=$(find .claude/docs/diagrams -name "*.mmd" -type f | wc -l)
+echo "   Diagrams: $DIAGRAM_COUNT (expected: 4)"
+if [ "$DIAGRAM_COUNT" -ne 4 ]; then
+  warning "Diagram count mismatch"
+fi
+
+# Count learnings (excluding README.md)
+LEARNING_COUNT=$(find .claude/docs/learnings -name "*.md" -type f ! -name "README.md" | wc -l)
+echo "   Learnings: $LEARNING_COUNT (expected: 8)"
+if [ "$LEARNING_COUNT" -ne 8 ]; then
+  warning "Learning count mismatch"
+fi
+
+# Count schemas
+SCHEMA_COUNT=$(find .claude/schemas -name "*.schema.json" -type f 2>/dev/null | wc -l)
+echo "   Schemas: $SCHEMA_COUNT (expected: 7)"
+if [ "$SCHEMA_COUNT" -ne 7 ]; then
+  warning "Schema count mismatch"
+fi
+
+echo ""
+echo "🔐 Checking script permissions..."
+
+SCRIPTS=(
+  ".claude/scripts/health-check.sh"
+  ".claude/scripts/validate-structure.sh"
+  ".claude/scripts/validate-docs.sh"
+)
+
+for script in "${SCRIPTS[@]}"; do
+  if [ -f "$script" ]; then
+    if [ -x "$script" ]; then
+      success "Executable: $script"
+    else
+      warning "Not executable: $script (run: chmod +x $script)"
+    fi
+  fi
+done
+
+echo ""
+echo "📊 Summary"
+echo "=========="
+if [ $ERRORS -eq 0 ] && [ $WARNINGS -eq 0 ]; then
+  success "All structure validation checks passed!"
+  exit 0
+elif [ $ERRORS -eq 0 ]; then
+  warning "$WARNINGS warnings found"
+  exit 0
+else
+  error "$ERRORS errors and $WARNINGS warnings found"
+  exit 1
+fi