@a-company/paradigm 1.5.0

package/dist/upgrade-5B3YGGC6.js

@@ -0,0 +1,550 @@
+#!/usr/bin/env node
+import {
+  detectIDE,
+  loadParadigmFiles,
+  syncToIDE
+} from "./chunk-YDNKXH4Z.js";
+import {
+  parseParadigmConfig,
+  serializeParadigmConfig
+} from "./chunk-YO6DVTL7.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/upgrade.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import ora from "ora";
+var AVAILABLE_FEATURES = ["scan", "logger", "migrate"];
+function getTemplatesDir() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const possiblePaths = [
+    path.join(__dirname, "..", "..", "templates", "paradigm"),
+    path.join(__dirname, "..", "templates", "paradigm")
+  ];
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      return p;
+    }
+  }
+  return path.join(__dirname, "..", "templates", "paradigm");
+}
+async function upgradeCommand(targetPath, options) {
+  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  const projectName = path.basename(rootDir);
+  const spinner = ora();
+  console.log(chalk.blue("\n\u{1F504} Paradigm Upgrade\n"));
+  if (options.fromHorizon) {
+    const result = await migrateFromHorizon(rootDir, projectName, options, spinner);
+    console.log(chalk.blue("\n\u{1F4CB} Migration Summary\n"));
+    const icon = result.status === "added" || result.status === "updated" ? chalk.green("\u2713") : result.status === "skipped" ? chalk.yellow("\u25CB") : chalk.red("\u2717");
+    console.log(`  ${icon} ${chalk.bold(result.feature)}: ${result.message}`);
+    console.log();
+    if (result.status === "updated" || result.status === "added") {
+      console.log(chalk.blue("Next steps:\n"));
+      console.log(chalk.gray("  \u2022 Verify the migration:"));
+      console.log(chalk.cyan("    paradigm doctor\n"));
+      console.log(chalk.gray("  \u2022 Regenerate IDE files:"));
+      console.log(chalk.cyan("    paradigm sync\n"));
+    }
+    return;
+  }
+  let features = [];
+  if (options.all) {
+    features = ["migrate", "scan", "logger"];
+  } else if (options.features && options.features.length > 0) {
+    features = options.features.filter(
+      (f) => AVAILABLE_FEATURES.includes(f)
+    );
+  } else {
+    console.log(chalk.yellow("No features specified. Available upgrades:\n"));
+    console.log(chalk.cyan("  migrate") + chalk.gray("      - Migrate from .paradigm file to .paradigm/ directory"));
+    console.log(chalk.cyan("  scan") + chalk.gray("         - Add visual discovery (paradigm probe) support"));
+    console.log(chalk.cyan("  logger") + chalk.gray("       - Add Paradigm logger specification"));
+    console.log(chalk.cyan("  all") + chalk.gray("          - Apply all available upgrades"));
+    console.log(chalk.cyan("  --from-horizon") + chalk.gray(" - Migrate from Horizon to Paradigm"));
+    console.log();
+    console.log(chalk.gray("Usage:"));
+    console.log(chalk.gray("  paradigm upgrade --features scan"));
+    console.log(chalk.gray("  paradigm upgrade --features logger"));
+    console.log(chalk.gray("  paradigm upgrade --all"));
+    console.log(chalk.gray("  paradigm upgrade --from-horizon"));
+    console.log();
+    return;
+  }
+  const results = [];
+  const paradigmPath = path.join(rootDir, ".paradigm");
+  const exists = fs.existsSync(paradigmPath);
+  const isLegacyFile = exists && fs.statSync(paradigmPath).isFile();
+  const isDirectory = exists && fs.statSync(paradigmPath).isDirectory();
+  if (features.includes("migrate") || isLegacyFile && options.all) {
+    if (isLegacyFile) {
+      results.push(await migrateLegacy(rootDir, projectName, options, spinner));
+    } else if (isDirectory) {
+      results.push({
+        feature: "migrate",
+        status: "skipped",
+        message: "Already using .paradigm/ directory format"
+      });
+    } else {
+      results.push({
+        feature: "migrate",
+        status: "error",
+        message: "No .paradigm found to migrate"
+      });
+    }
+  }
+  const paradigmDir = path.join(rootDir, ".paradigm");
+  const hasParadigmDir = fs.existsSync(paradigmDir) && fs.statSync(paradigmDir).isDirectory();
+  if (!hasParadigmDir && !options.dryRun) {
+    if (!isLegacyFile) {
+      console.log(chalk.yellow("\u26A0\uFE0F  No .paradigm/ directory found."));
+      console.log(chalk.gray("   Run `paradigm init` first to initialize Paradigm.\n"));
+      return;
+    }
+  }
+  for (const feature of features) {
+    if (feature === "migrate") continue;
+    switch (feature) {
+      case "scan":
+        results.push(await upgradeScan(rootDir, projectName, options, spinner));
+        break;
+      case "logger":
+        results.push(await upgradeLogger(rootDir, options, spinner));
+        break;
+    }
+  }
+  if (!options.dryRun && results.some((r) => r.status === "added" || r.status === "updated")) {
+    spinner.start("Re-syncing IDE files...");
+    const files = loadParadigmFiles(rootDir);
+    if (files) {
+      const detection = detectIDE(rootDir);
+      if (detection.detected) {
+        const result = syncToIDE(rootDir, detection.detected, files, true);
+        if (result.success) {
+          spinner.succeed(`IDE files synced (${detection.detected})`);
+        } else {
+          spinner.warn("Could not sync IDE files");
+        }
+      } else {
+        spinner.info("No IDE detected, run `paradigm sync` to generate IDE files");
+      }
+    }
+  }
+  console.log(chalk.blue("\n\u{1F4CB} Upgrade Summary\n"));
+  for (const result of results) {
+    const icon = result.status === "added" || result.status === "updated" ? chalk.green("\u2713") : result.status === "skipped" ? chalk.yellow("\u25CB") : chalk.red("\u2717");
+    console.log(`  ${icon} ${chalk.bold(result.feature)}: ${result.message}`);
+  }
+  console.log();
+  const addedFeatures = results.filter((r) => r.status === "added" || r.status === "updated");
+  if (addedFeatures.length > 0) {
+    console.log(chalk.blue("Next steps:\n"));
+    if (addedFeatures.some((f) => f.feature === "scan")) {
+      console.log(chalk.gray("  \u2022 Generate the scan index:"));
+      console.log(chalk.cyan("    paradigm index\n"));
+    }
+    if (addedFeatures.some((f) => f.feature === "logger")) {
+      console.log(chalk.gray("  \u2022 Review the logger spec:"));
+      console.log(chalk.cyan("    .paradigm/specs/logger.md\n"));
+    }
+    console.log(chalk.gray("  \u2022 Verify setup:"));
+    console.log(chalk.cyan("    paradigm doctor\n"));
+  }
+}
+async function migrateLegacy(rootDir, projectName, options, spinner) {
+  const paradigmFile = path.join(rootDir, ".paradigm");
+  const paradigmDir = path.join(rootDir, ".paradigm");
+  const templatesDir = getTemplatesDir();
+  if (options.dryRun) {
+    return {
+      feature: "migrate",
+      status: "updated",
+      message: "Would migrate .paradigm file to .paradigm/ directory"
+    };
+  }
+  spinner.start("Migrating .paradigm file to directory...");
+  try {
+    const existingContent = fs.readFileSync(paradigmFile, "utf8");
+    let existingConfig = null;
+    try {
+      existingConfig = parseParadigmConfig(existingContent);
+    } catch {
+    }
+    const backupPath = path.join(rootDir, ".paradigm.backup");
+    fs.copyFileSync(paradigmFile, backupPath);
+    fs.unlinkSync(paradigmFile);
+    fs.mkdirSync(paradigmDir, { recursive: true });
+    fs.mkdirSync(path.join(paradigmDir, "specs"), { recursive: true });
+    fs.mkdirSync(path.join(paradigmDir, "docs"), { recursive: true });
+    fs.mkdirSync(path.join(paradigmDir, "prompts"), { recursive: true });
+    if (fs.existsSync(templatesDir)) {
+      copyTemplates(templatesDir, paradigmDir, projectName);
+    } else {
+      const config = existingConfig || parseParadigmConfig(`
+version: "1.0"
+project: "${projectName}"
+agent-guidelines:
+  overview: |
+    This project uses Paradigm for structured AI-assisted development.
+symbol-system:
+  "@": { name: Feature, description: User-facing capabilities, owner: purpose, examples: ["@login"] }
+logging:
+  enforce: true
+scan:
+  enabled: true
+conventions: []
+`);
+      fs.writeFileSync(
+        path.join(paradigmDir, "config.yaml"),
+        serializeParadigmConfig(config),
+        "utf8"
+      );
+    }
+    const oldScanIndex = path.join(rootDir, ".paradigm-scan-index.json");
+    const newScanIndex = path.join(paradigmDir, "scan-index.json");
+    if (fs.existsSync(oldScanIndex)) {
+      fs.renameSync(oldScanIndex, newScanIndex);
+    }
+    spinner.succeed(chalk.green("Migrated to .paradigm/ directory"));
+    return {
+      feature: "migrate",
+      status: "updated",
+      message: "Converted to directory format (backup at .paradigm.backup)"
+    };
+  } catch (err) {
+    spinner.fail(chalk.red("Migration failed"));
+    return {
+      feature: "migrate",
+      status: "error",
+      message: err.message
+    };
+  }
+}
+async function upgradeScan(rootDir, projectName, options, spinner) {
+  const paradigmDir = path.join(rootDir, ".paradigm");
+  const scanIndexPath = path.join(paradigmDir, "scan-index.json");
+  const scanSpecPath = path.join(paradigmDir, "specs", "scan.md");
+  const templatesDir = getTemplatesDir();
+  if (fs.existsSync(scanIndexPath) && fs.existsSync(scanSpecPath) && !options.force) {
+    return {
+      feature: "scan",
+      status: "skipped",
+      message: "Already configured (use --force to reconfigure)"
+    };
+  }
+  if (options.dryRun) {
+    return {
+      feature: "scan",
+      status: "added",
+      message: "Would add scan spec and index placeholder"
+    };
+  }
+  spinner.start("Setting up paradigm scan...");
+  try {
+    fs.mkdirSync(path.join(paradigmDir, "specs"), { recursive: true });
+    const templateScanSpec = path.join(templatesDir, "specs", "scan.md");
+    if (fs.existsSync(templateScanSpec)) {
+      fs.copyFileSync(templateScanSpec, scanSpecPath);
+    }
+    if (!fs.existsSync(scanIndexPath)) {
+      const placeholderIndex = {
+        $meta: {
+          version: "1.0.0",
+          project: projectName,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          paradigmVersion: "0.2.0",
+          sources: { purposeFiles: 0, portalFiles: 0, premiseFiles: 0 }
+        },
+        components: {},
+        features: {},
+        flows: {},
+        state: {},
+        gates: {},
+        signals: {},
+        screens: {},
+        symbolMap: {},
+        _placeholder: true,
+        _message: "Run `paradigm index` to populate this index"
+      };
+      fs.writeFileSync(scanIndexPath, JSON.stringify(placeholderIndex, null, 2), "utf8");
+    }
+    spinner.succeed(chalk.green("Scan feature configured"));
+    return {
+      feature: "scan",
+      status: "added",
+      message: "Added scan spec and index placeholder"
+    };
+  } catch (err) {
+    spinner.fail(chalk.red("Failed to configure scan"));
+    return {
+      feature: "scan",
+      status: "error",
+      message: err.message
+    };
+  }
+}
+async function upgradeLogger(rootDir, options, spinner) {
+  const paradigmDir = path.join(rootDir, ".paradigm");
+  const loggerSpecPath = path.join(paradigmDir, "specs", "logger.md");
+  const templatesDir = getTemplatesDir();
+  if (fs.existsSync(loggerSpecPath) && !options.force) {
+    return {
+      feature: "logger",
+      status: "skipped",
+      message: "Already configured (use --force to reconfigure)"
+    };
+  }
+  if (options.dryRun) {
+    return {
+      feature: "logger",
+      status: "added",
+      message: "Would add logger specification"
+    };
+  }
+  spinner.start("Setting up logger spec...");
+  try {
+    fs.mkdirSync(path.join(paradigmDir, "specs"), { recursive: true });
+    const templateLoggerSpec = path.join(templatesDir, "specs", "logger.md");
+    if (fs.existsSync(templateLoggerSpec)) {
+      fs.copyFileSync(templateLoggerSpec, loggerSpecPath);
+    } else {
+      const minimalSpec = `# Paradigm Logger Specification
+
+Use the Paradigm logger instead of raw console.log/print statements.
+
+## API
+
+\`\`\`
+log.component('#login-handler').info('Starting login', { email })
+log.component('#database').debug('Query executed', { duration })
+log.gate('^authenticated').warn('Access denied', { userId })
+log.signal('!login-success').info('User authenticated')
+\`\`\`
+
+## Log Levels
+
+- \`debug\` - Verbose debugging info
+- \`info\` - General information
+- \`warn\` - Warning conditions
+- \`error\` - Error conditions
+
+See full specification for implementation details.
+`;
+      fs.writeFileSync(loggerSpecPath, minimalSpec, "utf8");
+    }
+    spinner.succeed(chalk.green("Logger spec configured"));
+    return {
+      feature: "logger",
+      status: "added",
+      message: "Added logger specification"
+    };
+  } catch (err) {
+    spinner.fail(chalk.red("Failed to configure logger"));
+    return {
+      feature: "logger",
+      status: "error",
+      message: err.message
+    };
+  }
+}
+function copyTemplates(src, dest, projectName) {
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      if (!fs.existsSync(destPath)) {
+        fs.mkdirSync(destPath, { recursive: true });
+      }
+      copyTemplates(srcPath, destPath, projectName);
+    } else {
+      if (!fs.existsSync(destPath)) {
+        let content = fs.readFileSync(srcPath, "utf8");
+        content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+        fs.writeFileSync(destPath, content, "utf8");
+      }
+    }
+  }
+}
+async function migrateFromHorizon(rootDir, _projectName, options, spinner) {
+  const horizonDir = path.join(rootDir, ".horizon");
+  const paradigmDir = path.join(rootDir, ".paradigm");
+  if (!fs.existsSync(horizonDir)) {
+    return {
+      feature: "from-horizon",
+      status: "skipped",
+      message: "No .horizon directory found to migrate"
+    };
+  }
+  if (fs.existsSync(paradigmDir) && !options.force) {
+    return {
+      feature: "from-horizon",
+      status: "skipped",
+      message: ".paradigm already exists (use --force to overwrite)"
+    };
+  }
+  if (options.dryRun) {
+    console.log(chalk.cyan("\nDry run - would perform the following:\n"));
+    console.log(chalk.gray("  \u2022 Rename .horizon/ \u2192 .paradigm/"));
+    const gateFiles = findFiles(rootDir, "gate.yaml");
+    if (gateFiles.length > 0) {
+      console.log(chalk.gray(`  \u2022 Rename ${gateFiles.length} gate.yaml \u2192 portal.yaml`));
+    }
+    const dreamFiles = findFiles(rootDir, ".dream");
+    if (dreamFiles.length > 0) {
+      console.log(chalk.gray(`  \u2022 Rename ${dreamFiles.length} .dream \u2192 .premise`));
+    }
+    console.log(chalk.gray("  \u2022 Update content references (horizon\u2192paradigm, gate\u2192portal, dream\u2192premise)"));
+    console.log();
+    return {
+      feature: "from-horizon",
+      status: "updated",
+      message: "Would migrate Horizon to Paradigm (dry run)"
+    };
+  }
+  spinner.start("Migrating from Horizon to Paradigm...");
+  try {
+    if (fs.existsSync(horizonDir)) {
+      if (fs.existsSync(paradigmDir)) {
+        const backupDir = path.join(rootDir, ".paradigm.backup-" + Date.now());
+        fs.renameSync(paradigmDir, backupDir);
+        spinner.text = "Backed up existing .paradigm...";
+      }
+      fs.renameSync(horizonDir, paradigmDir);
+      spinner.text = "Renamed .horizon to .paradigm...";
+    }
+    spinner.text = "Renaming gate.yaml files...";
+    const gateFiles = findFiles(rootDir, "gate.yaml");
+    for (const gateFile of gateFiles) {
+      const dir = path.dirname(gateFile);
+      const newPath = path.join(dir, "portal.yaml");
+      fs.renameSync(gateFile, newPath);
+      let content = fs.readFileSync(newPath, "utf8");
+      content = updateContent(content);
+      fs.writeFileSync(newPath, content, "utf8");
+    }
+    spinner.text = "Renaming .dream files...";
+    const dreamFiles = findFiles(rootDir, ".dream");
+    for (const dreamFile of dreamFiles) {
+      const dir = path.dirname(dreamFile);
+      const newPath = path.join(dir, ".premise");
+      fs.renameSync(dreamFile, newPath);
+      let content = fs.readFileSync(newPath, "utf8");
+      content = updateContent(content);
+      fs.writeFileSync(newPath, content, "utf8");
+    }
+    spinner.text = "Updating file contents...";
+    if (fs.existsSync(paradigmDir)) {
+      updateDirectoryContents(paradigmDir);
+    }
+    const scanIndex = path.join(paradigmDir, "scan-index.json");
+    const probeIndex = path.join(paradigmDir, "probe-index.json");
+    if (fs.existsSync(scanIndex)) {
+      let content = fs.readFileSync(scanIndex, "utf8");
+      content = updateContent(content);
+      fs.writeFileSync(probeIndex, content, "utf8");
+      fs.unlinkSync(scanIndex);
+    }
+    spinner.text = "Updating .purpose file contents...";
+    const purposeFiles = findFiles(rootDir, ".purpose");
+    for (const purposeFile of purposeFiles) {
+      let content = fs.readFileSync(purposeFile, "utf8");
+      const updated = updateContent(content);
+      if (updated !== content) {
+        fs.writeFileSync(purposeFile, updated, "utf8");
+      }
+    }
+    spinner.text = "Updating IDE instruction files...";
+    const ideFiles = [".cursorrules", ".windsurfrules", ".github/copilot-instructions.md"];
+    for (const ideFile of ideFiles) {
+      const fullPath = path.join(rootDir, ideFile);
+      if (fs.existsSync(fullPath)) {
+        let content = fs.readFileSync(fullPath, "utf8");
+        content = updateContent(content);
+        fs.writeFileSync(fullPath, content, "utf8");
+      }
+    }
+    spinner.succeed(chalk.green("Migration complete!"));
+    return {
+      feature: "from-horizon",
+      status: "updated",
+      message: `Migrated: ${gateFiles.length} portal files, ${dreamFiles.length} premise files`
+    };
+  } catch (err) {
+    spinner.fail(chalk.red("Migration failed"));
+    return {
+      feature: "from-horizon",
+      status: "error",
+      message: err.message
+    };
+  }
+}
+function findFiles(dir, filename) {
+  const results = [];
+  const skipDirs = ["node_modules", ".git", "dist", "build", ".paradigm"];
+  function walk(currentDir) {
+    try {
+      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          if (!skipDirs.includes(entry.name) && !entry.name.startsWith(".")) {
+            walk(fullPath);
+          }
+        } else if (entry.name === filename) {
+          results.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  walk(dir);
+  return results;
+}
+function updateContent(content) {
+  return content.replace(/Horizon/g, "Paradigm").replace(/horizon/g, "paradigm").replace(/Dreamscape/g, "Prism").replace(/dreamscape/g, "prism").replace(/Dream\b/g, "Premise").replace(/dream\b/g, "premise").replace(/\bGate\b/g, "Portal").replace(/\bgate\b/g, "portal").replace(/\bScan\b/g, "Probe").replace(/\bscan\b/g, "probe").replace(/gate\.yaml/g, "portal.yaml").replace(/\.dream\b/g, ".premise").replace(/scan-index\.json/g, "probe-index.json").replace(/\.horizon\//g, ".paradigm/").replace(/\.horizon$/g, ".paradigm").replace(/HORIZON_SYMBOLS/g, "PARADIGM_SYMBOLS");
+}
+function updateDirectoryContents(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      updateDirectoryContents(fullPath);
+    } else if (entry.name.endsWith(".yaml") || entry.name.endsWith(".md") || entry.name.endsWith(".json")) {
+      let content = fs.readFileSync(fullPath, "utf8");
+      const updated = updateContent(content);
+      if (updated !== content) {
+        fs.writeFileSync(fullPath, updated, "utf8");
+      }
+    }
+  }
+}
+function getAvailableUpgrades(rootDir) {
+  const available = [];
+  const paradigmPath = path.join(rootDir, ".paradigm");
+  if (!fs.existsSync(paradigmPath)) {
+    return available;
+  }
+  const isLegacyFile = fs.statSync(paradigmPath).isFile();
+  if (isLegacyFile) {
+    available.push("migrate");
+    return available;
+  }
+  const paradigmDir = paradigmPath;
+  const scanIndexPath = path.join(paradigmDir, "scan-index.json");
+  if (!fs.existsSync(scanIndexPath)) {
+    available.push("scan");
+  }
+  const loggerSpecPath = path.join(paradigmDir, "specs", "logger.md");
+  if (!fs.existsSync(loggerSpecPath)) {
+    available.push("logger");
+  }
+  return available;
+}
+export {
+  getAvailableUpgrades,
+  upgradeCommand
+};

package/dist/validate-F3YHBCRZ.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import {
+  formatValidationResult,
+  parseGateConfig,
+  validateGateConfig
+} from "./chunk-IRKUEJVW.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/portal/validate.ts
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+async function gateValidateCommand(configPath) {
+  const cwd = process.cwd();
+  const absolutePath = path.resolve(cwd, configPath);
+  console.log(chalk.blue("\n\u{1F50D} Validating Gate Configuration...\n"));
+  const spinner = ora(`Parsing ${configPath}...`).start();
+  try {
+    const config = await parseGateConfig(absolutePath);
+    spinner.succeed("Parsed portal.yaml");
+    const result = validateGateConfig(config);
+    console.log(chalk.white(`
+Gates: ${config.gates.length}`));
+    console.log(chalk.white(`Flows: ${config.flows.length}`));
+    console.log(formatValidationResult(result));
+    if (!result.valid) {
+      process.exit(1);
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail("Validation failed");
+    console.log(chalk.red(`Error: ${error.message}
+`));
+    process.exit(1);
+  }
+}
+export {
+  gateValidateCommand
+};

package/dist/validate-QEEY6KFS.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import {
+  formatValidationResult,
+  getAllPurposeFiles,
+  validatePurposeFile
+} from "./chunk-PW2EXJQT.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/purpose/validate.ts
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+async function purposeValidateCommand(targetPath) {
+  const cwd = process.cwd();
+  const absolutePath = path.resolve(cwd, targetPath);
+  console.log(chalk.blue("\n\u{1F50D} Validating Purpose Files...\n"));
+  const spinner = ora("Finding purpose files...").start();
+  try {
+    const files = await getAllPurposeFiles(absolutePath);
+    spinner.succeed(`Found ${files.length} purpose file(s)`);
+    let hasErrors = false;
+    let totalWarnings = 0;
+    let totalErrors = 0;
+    for (const { filePath, data } of files) {
+      const relativePath = path.relative(cwd, filePath);
+      const result = validatePurposeFile(data, relativePath);
+      const errors = result.issues.filter((i) => i.type === "error").length;
+      const warnings = result.issues.filter((i) => i.type === "warning").length;
+      totalErrors += errors;
+      totalWarnings += warnings;
+      if (!result.valid) {
+        hasErrors = true;
+      }
+      if (result.issues.length > 0) {
+        console.log(chalk.white(`
+${relativePath}`));
+        console.log(formatValidationResult(result));
+      } else {
+        console.log(chalk.green(`  \u2713 ${relativePath}`));
+      }
+    }
+    console.log(chalk.white("\n" + "\u2500".repeat(50)));
+    if (hasErrors) {
+      console.log(chalk.red(`
+\u274C Validation failed: ${totalErrors} error(s), ${totalWarnings} warning(s)
+`));
+      process.exit(1);
+    } else if (totalWarnings > 0) {
+      console.log(chalk.yellow(`
+\u2713 Valid with ${totalWarnings} warning(s)
+`));
+    } else {
+      console.log(chalk.green("\n\u2713 All purpose files are valid\n"));
+    }
+  } catch (error) {
+    spinner.fail("Validation failed");
+    console.log(chalk.red(`Error: ${error.message}
+`));
+    process.exit(1);
+  }
+}
+export {
+  purposeValidateCommand
+};