archbyte 0.4.1 → 0.5.0

package/dist/cli/validate.js

@@ -1,299 +0,0 @@
-import chalk from "chalk";
-import * as fs from "fs";
-import * as path from "path";
-import { resolveArchitecturePath, loadArchitectureFile, loadRulesConfig, getRuleLevel, getThreshold, parseCustomRulesFromYaml, } from "./shared.js";
-/**
- * Check for layer bypass violations.
- * Returns violations where a connection skips layers (e.g. presentation → data).
- */
-export function checkNoLayerBypass(arch, realNodes, nodeMap, level) {
-    const violations = [];
-    const layerOrder = {
-        presentation: 0,
-        application: 1,
-        data: 2,
-    };
-    for (const edge of arch.edges) {
-        const src = nodeMap.get(edge.source);
-        const tgt = nodeMap.get(edge.target);
-        if (!src || !tgt)
-            continue;
-        const srcOrder = layerOrder[src.layer];
-        const tgtOrder = layerOrder[tgt.layer];
-        if (srcOrder === undefined || tgtOrder === undefined)
-            continue;
-        if (tgtOrder - srcOrder > 1) {
-            violations.push({
-                rule: "no-layer-bypass",
-                level,
-                message: `"${src.label}" (${src.layer}) → "${tgt.label}" (${tgt.layer})`,
-            });
-        }
-    }
-    return violations;
-}
-/**
- * Check for nodes exceeding the max connection threshold.
- */
-export function checkMaxConnections(arch, realNodes, level, threshold) {
-    const violations = [];
-    const connectionCounts = new Map();
-    for (const edge of arch.edges) {
-        connectionCounts.set(edge.source, (connectionCounts.get(edge.source) || 0) + 1);
-        connectionCounts.set(edge.target, (connectionCounts.get(edge.target) || 0) + 1);
-    }
-    for (const node of realNodes) {
-        const count = connectionCounts.get(node.id) || 0;
-        if (count > threshold) {
-            violations.push({
-                rule: "max-connections",
-                level,
-                message: `"${node.label}" has ${count} connections (threshold: ${threshold})`,
-            });
-        }
-    }
-    return violations;
-}
-/**
- * Check for orphan nodes (no connections).
- */
-export function checkNoOrphans(arch, realNodes, level) {
-    const violations = [];
-    const connectedIds = new Set();
-    for (const edge of arch.edges) {
-        connectedIds.add(edge.source);
-        connectedIds.add(edge.target);
-    }
-    for (const node of realNodes) {
-        if (!connectedIds.has(node.id)) {
-            violations.push({
-                rule: "no-orphans",
-                level,
-                message: `"${node.label}" has no connections`,
-            });
-        }
-    }
-    return violations;
-}
-/**
- * Check for circular dependencies.
- */
-export function checkCircularDeps(arch, realNodes, nodeMap, level) {
-    const violations = [];
-    const cycles = detectCycles(arch, realNodes);
-    for (const cycle of cycles) {
-        violations.push({
-            rule: "no-circular-deps",
-            level,
-            message: `Cycle: ${cycle.map((id) => nodeMap.get(id)?.label || id).join(" → ")}`,
-        });
-    }
-    return violations;
-}
-/**
- * Check if a node matches a custom rule matcher.
- */
-export function matchesNode(node, matcher) {
-    let matches = true;
-    if (matcher.type && node.type !== matcher.type)
-        matches = false;
-    if (matcher.layer && node.layer !== matcher.layer)
-        matches = false;
-    if (matcher.id && node.id !== matcher.id)
-        matches = false;
-    return matcher.not ? !matches : matches;
-}
-/**
- * Evaluate custom rules against the architecture.
- */
-export function evaluateCustomRules(arch, realNodes, nodeMap, customRules) {
-    const violations = [];
-    for (const rule of customRules) {
-        for (const edge of arch.edges) {
-            const src = nodeMap.get(edge.source);
-            const tgt = nodeMap.get(edge.target);
-            if (!src || !tgt)
-                continue;
-            if (matchesNode(src, rule.from) && matchesNode(tgt, rule.to)) {
-                violations.push({
-                    rule: rule.name,
-                    level: rule.level,
-                    message: `"${src.label}" (${src.layer}/${src.type}) → "${tgt.label}" (${tgt.layer}/${tgt.type})`,
-                });
-            }
-        }
-    }
-    return violations;
-}
-/**
- * Core validation logic — runs all rules and returns results without side effects.
- */
-export function runValidation(options) {
-    const diagramPath = resolveArchitecturePath(options);
-    const arch = loadArchitectureFile(diagramPath);
-    const config = loadRulesConfig(options.config);
-    const violations = [];
-    const realNodes = arch.nodes;
-    const nodeMap = new Map();
-    for (const node of realNodes) {
-        nodeMap.set(node.id, node);
-    }
-    const layerBypassLevel = getRuleLevel(config, "no-layer-bypass", "error");
-    if (layerBypassLevel !== "off") {
-        violations.push(...checkNoLayerBypass(arch, realNodes, nodeMap, layerBypassLevel));
-    }
-    const maxConnLevel = getRuleLevel(config, "max-connections", "warn");
-    if (maxConnLevel !== "off") {
-        const threshold = getThreshold(config, "max-connections", 6);
-        violations.push(...checkMaxConnections(arch, realNodes, maxConnLevel, threshold));
-    }
-    const orphanLevel = getRuleLevel(config, "no-orphans", "warn");
-    if (orphanLevel !== "off") {
-        violations.push(...checkNoOrphans(arch, realNodes, orphanLevel));
-    }
-    const circularLevel = getRuleLevel(config, "no-circular-deps", "error");
-    if (circularLevel !== "off") {
-        violations.push(...checkCircularDeps(arch, realNodes, nodeMap, circularLevel));
-    }
-    // Custom rules
-    const rootDir = process.cwd();
-    const configPath = options.config
-        ? path.resolve(rootDir, options.config)
-        : path.join(rootDir, ".archbyte", "archbyte.yaml");
-    if (fs.existsSync(configPath)) {
-        const yamlContent = fs.readFileSync(configPath, "utf-8");
-        const customRules = parseCustomRulesFromYaml(yamlContent);
-        if (customRules.length > 0) {
-            violations.push(...evaluateCustomRules(arch, realNodes, nodeMap, customRules));
-        }
-    }
-    return {
-        violations,
-        errors: violations.filter((v) => v.level === "error").length,
-        warnings: violations.filter((v) => v.level === "warn").length,
-        totalNodes: realNodes.length,
-        totalEdges: arch.edges.length,
-    };
-}
-/**
- * Run architecture fitness function validation.
- */
-export async function handleValidate(options) {
-    const result = runValidation(options);
-    // CI mode: output JSON and exit
-    if (options.ci) {
-        const output = {
-            passed: result.errors === 0,
-            errors: result.errors,
-            warnings: result.warnings,
-            violations: result.violations.map((v) => ({
-                rule: v.rule,
-                level: v.level,
-                message: v.message,
-            })),
-            summary: {
-                totalNodes: result.totalNodes,
-                totalEdges: result.totalEdges,
-            },
-        };
-        console.log(JSON.stringify(output, null, 2));
-        process.exit(result.errors > 0 ? 1 : 0);
-        return;
-    }
-    // Human-readable output
-    printValidationReport(result);
-    if (result.errors > 0) {
-        process.exit(1);
-    }
-}
-function printValidationReport(result) {
-    const projectName = process.cwd().split("/").pop() || "project";
-    console.log();
-    console.log(chalk.bold.cyan(`⚡ ArchByte Validate: ${projectName}`));
-    console.log();
-    // Group violations by rule for display
-    const ruleViolations = new Map();
-    for (const v of result.violations) {
-        if (!ruleViolations.has(v.rule))
-            ruleViolations.set(v.rule, []);
-        ruleViolations.get(v.rule).push(v);
-    }
-    // Print built-in rules (even if they passed)
-    const builtinRules = ["no-layer-bypass", "max-connections", "no-orphans", "no-circular-deps"];
-    for (const rule of builtinRules) {
-        const violations = ruleViolations.get(rule) || [];
-        printRuleResult(rule, violations.length > 0 ? violations[0].level : "error", violations.length, result.violations);
-    }
-    // Print custom rule results
-    for (const [rule, violations] of ruleViolations) {
-        if (builtinRules.includes(rule))
-            continue;
-        printRuleResult(rule, violations[0].level, violations.length, result.violations);
-    }
-    console.log();
-    const resultStr = result.errors > 0 ? chalk.red("FAIL") : chalk.green("PASS");
-    console.log(`  Result: ${result.warnings} warning${result.warnings !== 1 ? "s" : ""}, ${result.errors} error${result.errors !== 1 ? "s" : ""} ${resultStr}`);
-    console.log();
-}
-function printRuleResult(rule, level, count, violations) {
-    if (count === 0) {
-        console.log(chalk.green(`  ✓ ${rule}: passed (0 violations)`));
-    }
-    else {
-        const icon = level === "error" ? chalk.red("✗") : chalk.yellow("⚠");
-        const label = level === "error"
-            ? chalk.red(`${count} error${count !== 1 ? "s" : ""}`)
-            : chalk.yellow(`${count} warning${count !== 1 ? "s" : ""}`);
-        console.log(`  ${icon} ${rule}: ${label}`);
-        const ruleViolations = violations.filter((v) => v.rule === rule);
-        for (const v of ruleViolations) {
-            console.log(chalk.gray(`    → ${v.message}`));
-        }
-    }
-}
-/**
- * Detect cycles in the directed graph using DFS.
- * Returns an array of cycles, each represented as a list of node IDs.
- */
-function detectCycles(arch, realNodes) {
-    const adjacency = new Map();
-    for (const node of realNodes) {
-        adjacency.set(node.id, []);
-    }
-    for (const edge of arch.edges) {
-        const neighbors = adjacency.get(edge.source);
-        if (neighbors) {
-            neighbors.push(edge.target);
-        }
-    }
-    const visited = new Set();
-    const inStack = new Set();
-    const cycles = [];
-    const path = [];
-    function dfs(nodeId) {
-        visited.add(nodeId);
-        inStack.add(nodeId);
-        path.push(nodeId);
-        for (const neighbor of adjacency.get(nodeId) || []) {
-            if (!visited.has(neighbor)) {
-                dfs(neighbor);
-            }
-            else if (inStack.has(neighbor)) {
-                // Found a cycle — extract it from the path
-                const cycleStart = path.indexOf(neighbor);
-                if (cycleStart !== -1) {
-                    const cycle = [...path.slice(cycleStart), neighbor];
-                    cycles.push(cycle);
-                }
-            }
-        }
-        path.pop();
-        inStack.delete(nodeId);
-    }
-    for (const node of realNodes) {
-        if (!visited.has(node.id)) {
-            dfs(node.id);
-        }
-    }
-    return cycles;
-}