@qazuor/claude-code-config 0.1.0

package/templates/schemas/todos.schema.json

@@ -0,0 +1,234 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://example.com/schemas/todos.schema.json",
+  "title": "TODOs Document",
+  "description": "JSON Schema for validating TODOs documents with atomized tasks",
+  "type": "object",
+  "required": ["metadata", "summary", "phases", "tasks"],
+  "properties": {
+    "metadata": {
+      "type": "object",
+      "required": ["planningCode", "relatedPDR", "relatedTechAnalysis", "version"],
+      "properties": {
+        "planningCode": {
+          "type": "string",
+          "pattern": "^P(F|R|B)?-\\d{3,4}$",
+          "description": "Planning code with mandatory dash (e.g., P-001, PF-004, PR-002, PB-042)"
+        },
+        "relatedPDR": {
+          "type": "string",
+          "description": "Path to related PDR document"
+        },
+        "relatedTechAnalysis": {
+          "type": "string",
+          "description": "Path to related tech-analysis document"
+        },
+        "version": {
+          "type": "string",
+          "pattern": "^\\d+\\.\\d+(\\.\\d+)?$"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "updatedAt": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "summary": {
+      "type": "object",
+      "required": ["totalTasks", "totalPhases", "totalHours", "completedTasks"],
+      "properties": {
+        "totalTasks": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "totalPhases": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "totalHours": {
+          "type": "number",
+          "minimum": 0.5
+        },
+        "completedTasks": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "completedHours": {
+          "type": "number",
+          "minimum": 0
+        },
+        "percentComplete": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 100
+        }
+      }
+    },
+    "phases": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "name", "description", "estimatedHours", "tasks"],
+        "properties": {
+          "id": {
+            "type": "integer",
+            "minimum": 1
+          },
+          "name": {
+            "type": "string",
+            "minLength": 3
+          },
+          "description": {
+            "type": "string",
+            "minLength": 10
+          },
+          "estimatedHours": {
+            "type": "number",
+            "minimum": 0.5
+          },
+          "priority": {
+            "type": "string",
+            "enum": ["P0", "P1", "P2", "P3"]
+          },
+          "status": {
+            "type": "string",
+            "enum": ["pending", "in-progress", "completed", "blocked"],
+            "default": "pending"
+          },
+          "tasks": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^P(F|R|B)\\d{3,4}-\\d+(\\.\\d+)?$"
+            },
+            "description": "Task codes belonging to this phase"
+          },
+          "blockingFor": {
+            "type": "array",
+            "items": {
+              "type": "integer"
+            },
+            "description": "Phase IDs that are blocked by this phase"
+          }
+        }
+      }
+    },
+    "tasks": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["code", "title", "description", "estimatedHours", "priority", "phase", "status"],
+        "properties": {
+          "code": {
+            "type": "string",
+            "pattern": "^P(F|R|B)\\d{3,4}-\\d+(\\.\\d+)?$",
+            "description": "Task code (e.g., PF001-1, PF004-2.1, PR002-5, PB042-1)"
+          },
+          "title": {
+            "type": "string",
+            "minLength": 5,
+            "maxLength": 200
+          },
+          "description": {
+            "type": "string",
+            "minLength": 10
+          },
+          "estimatedHours": {
+            "type": "number",
+            "minimum": 0.5,
+            "maximum": 4,
+            "description": "Tasks must be atomized: 0.5-4 hours each"
+          },
+          "actualHours": {
+            "type": "number",
+            "minimum": 0
+          },
+          "priority": {
+            "type": "string",
+            "enum": ["P0", "P1", "P2", "P3"]
+          },
+          "phase": {
+            "type": "integer",
+            "minimum": 1,
+            "description": "Phase ID this task belongs to"
+          },
+          "status": {
+            "type": "string",
+            "enum": ["pending", "in-progress", "completed", "blocked", "skipped"],
+            "default": "pending"
+          },
+          "dependencies": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^P(F|R|B)\\d{3,4}-\\d+(\\.\\d+)?$"
+            },
+            "description": "Task codes that must complete before this task"
+          },
+          "canParallelize": {
+            "type": "boolean",
+            "default": false,
+            "description": "Can be done in parallel with other tasks"
+          },
+          "assignedTo": {
+            "type": "string",
+            "description": "Agent or person assigned to this task"
+          },
+          "tags": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": ["documentation", "code", "testing", "review", "deployment", "refactor", "research"]
+            }
+          },
+          "githubIssue": {
+            "type": "integer",
+            "description": "Related GitHub issue number"
+          },
+          "startedAt": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "completedAt": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "notes": {
+            "type": "string"
+          },
+          "blockedBy": {
+            "type": "string",
+            "description": "Reason if task is blocked"
+          }
+        }
+      }
+    },
+    "validation": {
+      "type": "object",
+      "properties": {
+        "allTasksAtomized": {
+          "type": "boolean",
+          "description": "All tasks are 0.5-4 hours"
+        },
+        "noCyclicDependencies": {
+          "type": "boolean",
+          "description": "No circular dependencies detected"
+        },
+        "allDependenciesExist": {
+          "type": "boolean",
+          "description": "All referenced dependencies exist"
+        },
+        "totalHoursMatch": {
+          "type": "boolean",
+          "description": "Sum of task hours matches totalHours"
+        }
+      }
+    }
+  }
+}

package/templates/schemas/workflows.schema.json

@@ -0,0 +1,69 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://example.com/schemas/workflows.schema.json",
+  "title": "Workflows",
+  "description": "JSON Schema for validating workflow definitions",
+  "type": "object",
+  "required": ["metadata", "workflows"],
+  "properties": {
+    "metadata": {
+      "type": "object",
+      "required": ["version"],
+      "properties": {
+        "version": {"type": "string", "pattern": "^\\d+\\.\\d+(\\.\\d+)?$"},
+        "lastUpdated": {"type": "string", "format": "date-time"}
+      }
+    },
+    "workflows": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "name", "level", "criteria", "steps"],
+        "properties": {
+          "id": {"type": "string", "pattern": "^WF-L\\d$"},
+          "name": {"type": "string"},
+          "level": {"type": "integer", "minimum": 1, "maximum": 3},
+          "criteria": {
+            "type": "object",
+            "required": ["duration", "complexity"],
+            "properties": {
+              "duration": {"type": "string"},
+              "complexity": {"type": "string", "enum": ["trivial", "low", "medium", "high"]},
+              "requiresPDR": {"type": "boolean"},
+              "requiresTechAnalysis": {"type": "boolean"},
+              "requiresTODOs": {"type": "boolean"}
+            }
+          },
+          "steps": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "required": ["id", "name", "description"],
+              "properties": {
+                "id": {"type": "integer", "minimum": 1},
+                "name": {"type": "string"},
+                "description": {"type": "string"},
+                "agent": {"type": "string"},
+                "command": {"type": "string"},
+                "skill": {"type": "string"},
+                "optional": {"type": "boolean", "default": false},
+                "parallelizable": {"type": "boolean", "default": false},
+                "estimatedMinutes": {"type": "integer", "minimum": 1}
+              }
+            }
+          },
+          "outputs": {
+            "type": "array",
+            "items": {"type": "string"}
+          },
+          "validation": {
+            "type": "array",
+            "items": {"type": "string"}
+          }
+        }
+      }
+    }
+  }
+}

package/templates/scripts/add-changelogs.sh

@@ -0,0 +1,105 @@
+#!/bin/bash
+
+# Script to add CHANGELOG section to all .claude/*.md files
+# Usage: bash .claude/scripts/add-changelogs.sh
+
+set -e
+
+CHANGELOG_TEMPLATE="
+
+---
+
+## Changelog
+
+| Version | Date | Changes | Author | Related |
+|---------|------|---------|--------|---------|
+| 1.0.0 | 2025-10-31 | Initial version | @tech-lead | P-004 |
+"
+
+# Function to add changelog if not exists
+add_changelog() {
+  local file="$1"
+
+  # Skip if file already has Changelog section
+  if grep -q "^## Changelog" "$file"; then
+    echo "  ⏭️  Skipped (already has changelog): $(basename "$file")"
+    return
+  fi
+
+  # Add changelog at the end
+  echo "$CHANGELOG_TEMPLATE" >> "$file"
+  echo "  ✅ Added changelog: $(basename "$file")"
+}
+
+echo "🔍 Adding CHANGELOG sections to .claude files..."
+echo ""
+
+# Process all markdown files in .claude (excluding README.md and specific docs)
+total=0
+added=0
+
+# Commands
+echo "📋 Processing commands..."
+for file in .claude/commands/**/*.md; do
+  if [[ -f "$file" ]] && [[ "$(basename "$file")" != "README.md" ]]; then
+    add_changelog "$file"
+    ((total++))
+  fi
+done
+
+# Skills
+echo ""
+echo "🎯 Processing skills..."
+for file in .claude/skills/**/*.md; do
+  if [[ -f "$file" ]] && [[ "$(basename "$file")" != "README.md" ]]; then
+    add_changelog "$file"
+    ((total++))
+  fi
+done
+
+# Agents
+echo ""
+echo "🤖 Processing agents..."
+for file in .claude/agents/**/*.md; do
+  if [[ -f "$file" ]] && [[ "$(basename "$file")" != "README.md" ]]; then
+    add_changelog "$file"
+    ((total++))
+  fi
+done
+
+# Docs (selected files, not all)
+echo ""
+echo "📚 Processing documentation..."
+for file in .claude/docs/{quick-start,glossary,mcp-servers,doc-sync,system-maintenance,CHECKPOINT-SYSTEM,RECOMMENDED-HOOKS}.md; do
+  if [[ -f "$file" ]]; then
+    add_changelog "$file"
+    ((total++))
+  fi
+done
+
+# Workflows
+for file in .claude/docs/workflows/*.md; do
+  if [[ -f "$file" ]] && [[ "$(basename "$file")" != "README.md" ]] && [[ "$(basename "$file")" != "INDEX.md" ]]; then
+    add_changelog "$file"
+    ((total++))
+  fi
+done
+
+# Standards
+for file in .claude/docs/standards/*.md; do
+  if [[ -f "$file" ]]; then
+    add_changelog "$file"
+    ((total++))
+  fi
+done
+
+# Learnings
+for file in .claude/docs/learnings/*.md; do
+  if [[ -f "$file" ]] && [[ "$(basename "$file")" != "README.md" ]]; then
+    add_changelog "$file"
+    ((total++))
+  fi
+done
+
+echo ""
+echo "✅ Done! Processed $total files"

package/templates/scripts/generate-code-registry.ts

@@ -0,0 +1,270 @@
+#!/usr/bin/env tsx
+/**
+ * Code Registry Generator
+ *
+ * Generates .code-registry.json from all planning sessions.
+ * The registry provides quick lookup of planning codes and their task codes.
+ *
+ * Usage:
+ *   tsx .claude/scripts/generate-code-registry.ts
+ *
+ * Output:
+ *   .claude/sessions/planning/.code-registry.json
+ */
+
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+interface RegistrySession {
+  code: string;
+  type: 'feature' | 'refactor' | 'bugfix';
+  fullCode: string;
+  sessionPath: string;
+  status: 'active' | 'completed' | 'archived' | 'cancelled';
+  createdAt?: string;
+  completedAt?: string;
+  archivedAt?: string;
+  tasks: string[];
+}
+
+interface CodeRegistry {
+  version: string;
+  generatedAt: string;
+  lastPlanningNumber: number;
+  registry: RegistrySession[];
+}
+
+const PLANNING_ROOT = resolve(process.cwd(), '.claude/sessions/planning');
+const REGISTRY_PATH = join(PLANNING_ROOT, '.code-registry.json');
+
+/**
+ * Extract task codes from TODOs.md content
+ */
+function extractTaskCodes(content: string): string[] {
+  const taskCodes: string[] = [];
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    // Match heading: ### PF004-1: Task Title or ### PF004-1 Task Title
+    const headingMatch = line.match(/^###\s+(P[FRB]\d{3,4}-\d+(?:\.\d+)?)/);
+    if (headingMatch) {
+      taskCodes.push(headingMatch[1]);
+    }
+  }
+
+  return taskCodes;
+}
+
+/**
+ * Determine session status from checkpoint or TODOs
+ */
+function determineStatus(sessionPath: string): RegistrySession['status'] {
+  const checkpointPath = join(sessionPath, '.checkpoint.json');
+
+  try {
+    if (existsSync(checkpointPath)) {
+      const checkpoint = JSON.parse(readFileSync(checkpointPath, 'utf-8'));
+      if (checkpoint.currentPhase === 4 && checkpoint.status === 'completed') {
+        return 'completed';
+      }
+      return 'active';
+    }
+  } catch (error) {
+    console.warn(`  Warning: Could not read checkpoint at ${checkpointPath}`);
+  }
+
+  // Fallback: check if all tasks in TODOs are completed
+  const todosPath = join(sessionPath, 'TODOs.md');
+  try {
+    if (existsSync(todosPath)) {
+      const content = readFileSync(todosPath, 'utf-8');
+      const hasIncompleteTasks = /^-\s+\[\s\]/m.test(content);
+      return hasIncompleteTasks ? 'active' : 'completed';
+    }
+  } catch (error) {
+    console.warn(`  Warning: Could not read TODOs at ${todosPath}`);
+  }
+
+  return 'active';
+}
+
+/**
+ * Extract planning code and type from session directory name
+ */
+function parsePlanningCode(dirName: string): { code: string; type: RegistrySession['type']; fullCode: string } {
+  // Pattern: P-001, PF-004, PR-002, PB-042
+  const match = dirName.match(/^(P([FRB])?-\d{3,4})/);
+  if (!match) {
+    return { code: 'UNKNOWN', type: 'feature', fullCode: dirName };
+  }
+
+  const code = match[1];
+  const prefix = match[2];
+
+  let type: RegistrySession['type'] = 'feature';
+  if (prefix === 'R') type = 'refactor';
+  if (prefix === 'B') type = 'bugfix';
+  if (!prefix) type = 'feature'; // P-XXX defaults to feature
+
+  return { code, type, fullCode: dirName };
+}
+
+/**
+ * Extract creation date from git or filesystem
+ */
+function getCreationDate(sessionPath: string): string | undefined {
+  try {
+    const stat = statSync(sessionPath);
+    // Format as ISO 8601 date-time
+    const date = stat.birthtime || stat.mtime;
+    return date.toISOString();
+  } catch (error) {
+    return undefined;
+  }
+}
+
+/**
+ * Find all planning sessions (excluding archived)
+ */
+function findPlanningSessions(baseDir: string): string[] {
+  const sessions: string[] = [];
+
+  try {
+    const entries = readdirSync(baseDir);
+
+    for (const entry of entries) {
+      const fullPath = join(baseDir, entry);
+
+      // Skip non-directories, hidden files, and archived folder
+      if (entry.startsWith('.') || entry === 'archived' || !statSync(fullPath).isDirectory()) {
+        continue;
+      }
+
+      // Must match planning code pattern
+      if (/^P[FRB]?-\d{3,4}/.test(entry)) {
+        sessions.push(fullPath);
+      }
+    }
+  } catch (error) {
+    console.error(`Error reading planning directory: ${error}`);
+  }
+
+  return sessions;
+}
+
+/**
+ * Calculate last planning number from all sessions
+ */
+function calculateLastPlanningNumber(sessions: RegistrySession[]): number {
+  let maxNumber = 0;
+
+  for (const session of sessions) {
+    const match = session.code.match(/(\d+)/);
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > maxNumber) {
+        maxNumber = num;
+      }
+    }
+  }
+
+  return maxNumber;
+}
+
+/**
+ * Generate code registry
+ */
+function generateRegistry(): CodeRegistry {
+  const sessionPaths = findPlanningSessions(PLANNING_ROOT);
+  const sessions: RegistrySession[] = [];
+
+  console.log(`Found ${sessionPaths.length} planning sessions\n`);
+
+  for (const sessionPath of sessionPaths) {
+    const dirName = sessionPath.split('/').pop()!;
+    const { code, type, fullCode } = parsePlanningCode(dirName);
+    const status = determineStatus(sessionPath);
+    const createdAt = getCreationDate(sessionPath);
+
+    // Extract task codes from TODOs.md
+    let tasks: string[] = [];
+    const todosPath = join(sessionPath, 'TODOs.md');
+    try {
+      if (existsSync(todosPath)) {
+        const content = readFileSync(todosPath, 'utf-8');
+        tasks = extractTaskCodes(content);
+      }
+    } catch (error) {
+      console.warn(`  Warning: Could not read TODOs.md for ${code}`);
+    }
+
+    sessions.push({
+      code,
+      type,
+      fullCode,
+      sessionPath: dirName,
+      status,
+      createdAt,
+      tasks
+    });
+
+    console.log(`  ✓ ${code} (${type}) - ${tasks.length} tasks - ${status}`);
+  }
+
+  // Sort sessions by code
+  sessions.sort((a, b) => a.code.localeCompare(b.code));
+
+  const lastPlanningNumber = calculateLastPlanningNumber(sessions);
+
+  return {
+    version: '1.0.0',
+    generatedAt: new Date().toISOString(),
+    lastPlanningNumber,
+    registry: sessions
+  };
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  console.log('🔍 Generating code registry from planning sessions...\n');
+
+  const registry = generateRegistry();
+
+  console.log(`\n✅ Registry generated successfully!`);
+  console.log(`   Version: ${registry.version}`);
+  console.log(`   Sessions: ${registry.registry.length}`);
+  console.log(`   Last Planning Number: ${registry.lastPlanningNumber}`);
+  console.log(`   Output: ${REGISTRY_PATH}\n`);
+
+  writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2), 'utf-8');
+
+  // Print summary by status
+  const statusCounts = registry.registry.reduce((acc, session) => {
+    acc[session.status] = (acc[session.status] || 0) + 1;
+    return acc;
+  }, {} as Record<string, number>);
+
+  console.log('📊 Status summary:');
+  Object.entries(statusCounts).forEach(([status, count]) => {
+    console.log(`   ${status}: ${count}`);
+  });
+
+  // Print summary by type
+  const typeCounts = registry.registry.reduce((acc, session) => {
+    acc[session.type] = (acc[session.type] || 0) + 1;
+    return acc;
+  }, {} as Record<string, number>);
+
+  console.log('\n📋 Type summary:');
+  Object.entries(typeCounts).forEach(([type, count]) => {
+    console.log(`   ${type}: ${count}`);
+  });
+
+  // Total tasks
+  const totalTasks = registry.registry.reduce((sum, session) => sum + session.tasks.length, 0);
+  console.log(`\n📝 Total tasks: ${totalTasks}`);
+}
+
+main();