archbyte 0.4.2 → 0.5.1

package/dist/cli/patrol.js

@@ -1,596 +0,0 @@
-import * as path from "path";
-import * as fs from "fs";
-import { execSync } from "child_process";
-import chalk from "chalk";
-import { runValidation } from "./validate.js";
-import { loadPatrolIgnore } from "./shared.js";
-import { loadArchitectureJSON, diffArchitectures, hasStructuralChanges } from "./arch-diff.js";
-const PATROL_DIR = ".archbyte/patrols";
-/**
- * Convert a gitignore-style pattern to chokidar glob(s).
- */
-function toChokidarGlobs(line) {
-    // Directory pattern: "dist/" → "**/dist/**"
-    if (line.endsWith("/")) {
-        return [`**/${line.slice(0, -1)}/**`];
-    }
-    // Glob with extension: "*.pyc" → "**/*.pyc"
-    if (line.startsWith("*.")) {
-        return [`**/${line}`];
-    }
-    // Already a glob — pass through
-    if (line.includes("*") || line.includes("?")) {
-        return [line];
-    }
-    // Plain name: treat as both file and directory
-    return [`**/${line}`, `**/${line}/**`];
-}
-/**
- * Build chokidar ignored list from three layers:
- *   1. Baseline: hidden dirs + node_modules (always)
- *   2. .gitignore patterns (if present)
- *   3. archbyte.yaml patrol.ignore patterns (if configured)
- */
-function buildWatchIgnored(configPath) {
-    const ignored = [
-        /(^|[/\\])\./, // hidden files/dirs (.git, .archbyte, .venv, .next, etc.)
-        "**/node_modules/**",
-    ];
-    // Layer 2: .gitignore
-    const gitignorePath = path.join(process.cwd(), ".gitignore");
-    if (fs.existsSync(gitignorePath)) {
-        const lines = fs.readFileSync(gitignorePath, "utf-8").split("\n");
-        for (const raw of lines) {
-            const line = raw.trim();
-            if (!line || line.startsWith("#") || line.startsWith("!"))
-                continue;
-            ignored.push(...toChokidarGlobs(line));
-        }
-    }
-    // Layer 3: archbyte.yaml patrol.ignore
-    const userPatterns = loadPatrolIgnore(configPath);
-    for (const pattern of userPatterns) {
-        ignored.push(...toChokidarGlobs(pattern));
-    }
-    return ignored;
-}
-const HISTORY_FILE = "history.jsonl";
-const LATEST_FILE = "latest.json";
-function parseInterval(str) {
-    const match = str.match(/^(\d+)(s|m|h)$/);
-    if (!match) {
-        console.error(chalk.red(`Invalid interval: "${str}". Use format like 30s, 5m, 1h`));
-        process.exit(1);
-    }
-    const [, num, unit] = match;
-    const multipliers = { s: 1000, m: 60_000, h: 3_600_000 };
-    return parseInt(num) * multipliers[unit];
-}
-function ensurePatrolDir() {
-    const dir = path.join(process.cwd(), PATROL_DIR);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    return dir;
-}
-function loadLatestRecord(patrolDir) {
-    const latestPath = path.join(patrolDir, LATEST_FILE);
-    if (!fs.existsSync(latestPath))
-        return null;
-    try {
-        return JSON.parse(fs.readFileSync(latestPath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-function saveRecord(patrolDir, record) {
-    // Write latest
-    fs.writeFileSync(path.join(patrolDir, LATEST_FILE), JSON.stringify(record, null, 2), "utf-8");
-    // Append to history
-    fs.appendFileSync(path.join(patrolDir, HISTORY_FILE), JSON.stringify(record) + "\n", "utf-8");
-}
-function diffIssues(previous, current) {
-    const key = (i) => `${i.type}:${i.rule || i.metric}:${i.message}`;
-    const prevKeys = new Set(previous.map(key));
-    const currKeys = new Set(current.map(key));
-    return {
-        newIssues: current.filter((i) => !prevKeys.has(key(i))),
-        resolvedIssues: previous.filter((i) => !currKeys.has(key(i))),
-    };
-}
-/**
- * Load token usage from analysis.json metadata
- */
-function loadTokenUsage() {
-    try {
-        const analysisPath = path.join(process.cwd(), ".archbyte", "analysis.json");
-        if (!fs.existsSync(analysisPath))
-            return null;
-        const analysis = JSON.parse(fs.readFileSync(analysisPath, "utf-8"));
-        const tokenUsage = analysis.metadata?.tokenUsage;
-        if (tokenUsage?.input && tokenUsage?.output) {
-            return { input: tokenUsage.input, output: tokenUsage.output };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-// ─── Git change tracking ───
-function gitExec(cmd, rootDir) {
-    try {
-        return execSync(cmd, {
-            cwd: rootDir,
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"],
-        }).trim();
-    }
-    catch {
-        return null;
-    }
-}
-function captureGitState(rootDir, patrolDir) {
-    const commitHash = gitExec("git rev-parse HEAD", rootDir);
-    if (!commitHash)
-        return undefined;
-    const previous = loadLatestRecord(patrolDir);
-    const previousCommitHash = previous?.git?.commitHash;
-    let changedFiles = [];
-    let commitCount = 0;
-    if (previousCommitHash && previousCommitHash !== commitHash) {
-        const countStr = gitExec(`git rev-list --count ${previousCommitHash}..HEAD`, rootDir);
-        if (countStr)
-            commitCount = parseInt(countStr, 10) || 0;
-        const diff = gitExec(`git diff --name-only ${previousCommitHash}..HEAD`, rootDir);
-        if (diff)
-            changedFiles = diff.split("\n").filter(Boolean);
-    }
-    // Include uncommitted changes (staged + unstaged + untracked)
-    const unstaged = gitExec("git diff --name-only", rootDir);
-    if (unstaged) {
-        for (const f of unstaged.split("\n").filter(Boolean)) {
-            if (!changedFiles.includes(f))
-                changedFiles.push(f);
-        }
-    }
-    const staged = gitExec("git diff --name-only --cached", rootDir);
-    if (staged) {
-        for (const f of staged.split("\n").filter(Boolean)) {
-            if (!changedFiles.includes(f))
-                changedFiles.push(f);
-        }
-    }
-    const untracked = gitExec("git ls-files --others --exclude-standard", rootDir);
-    if (untracked) {
-        for (const f of untracked.split("\n").filter(Boolean)) {
-            if (!changedFiles.includes(f))
-                changedFiles.push(f);
-        }
-    }
-    return {
-        commitHash,
-        previousCommitHash,
-        commitCount,
-        changedFiles: changedFiles.slice(0, 100),
-        changedFileCount: changedFiles.length,
-    };
-}
-// ─── Structural diff → issues ───
-function structuralDiffToIssues(diff) {
-    const issues = [];
-    for (const node of diff.addedNodes) {
-        issues.push({
-            type: 'structural',
-            metric: 'component-added',
-            level: 'warn',
-            message: `New component: "${node.label}" (${node.type}, ${node.layer})`,
-            nodeIds: [node.id],
-        });
-    }
-    for (const node of diff.removedNodes) {
-        issues.push({
-            type: 'structural',
-            metric: 'component-removed',
-            level: 'warn',
-            message: `Removed component: "${node.label}" (${node.type}, ${node.layer})`,
-            nodeIds: [node.id],
-        });
-    }
-    for (const mod of diff.modifiedNodes) {
-        issues.push({
-            type: 'structural',
-            metric: 'component-modified',
-            level: 'warn',
-            message: `"${mod.id}" ${mod.field}: "${mod.from}" -> "${mod.to}"`,
-            nodeIds: [mod.id],
-        });
-    }
-    if (diff.addedEdges.length > 0 || diff.removedEdges.length > 0) {
-        issues.push({
-            type: 'structural',
-            metric: 'connections-changed',
-            level: 'warn',
-            message: `Connections: +${diff.addedEdges.length} added, -${diff.removedEdges.length} removed`,
-        });
-    }
-    return issues;
-}
-// ─── Metrics from validation ───
-function computeMetrics(result) {
-    return {
-        circularDependencies: result.violations.filter((v) => v.rule === "no-circular-deps").length,
-        highDegreeHubCount: result.violations.filter((v) => v.rule === "max-connections").length,
-        disconnectedComponentCount: result.violations.filter((v) => v.rule === "no-orphans").length,
-    };
-}
-/**
- * Run a full patrol cycle: snapshot → analyze → generate → validate → diff.
- */
-async function runPatrolCycle(options, patrolDir) {
-    const cycleStart = Date.now();
-    const rootDir = process.cwd();
-    // 0. Snapshot architecture before cycle for structural diff
-    const prevArch = loadArchitectureJSON(rootDir);
-    // 0b. Capture git state
-    const git = captureGitState(rootDir, patrolDir);
-    // 1. Run full analyze (static context → LLM pipeline, incremental)
-    try {
-        const { handleAnalyze } = await import("./analyze.js");
-        await handleAnalyze({ verbose: false, skipServeHint: true });
-    }
-    catch (err) {
-        console.error(chalk.yellow(`  Analyze failed: ${err instanceof Error ? err.message : String(err)}`));
-    }
-    // 2. Generate diagram from updated analysis
-    try {
-        const { handleGenerate } = await import("./generate.js");
-        await handleGenerate({ verbose: false });
-    }
-    catch (err) {
-        console.error(chalk.yellow(`  Generate failed: ${err instanceof Error ? err.message : String(err)}`));
-    }
-    // 3. Compute structural diff
-    const currArch = loadArchitectureJSON(rootDir);
-    let structuralDiff;
-    if (prevArch && currArch) {
-        const diff = diffArchitectures(prevArch, currArch);
-        if (hasStructuralChanges(diff)) {
-            structuralDiff = diff;
-        }
-    }
-    // 4. Validate (get rule violations)
-    const previous = loadLatestRecord(patrolDir);
-    const result = runValidation({
-        diagram: options.diagram,
-        config: options.config,
-    });
-    // Convert rule violations to audit issues
-    const ruleIssues = result.violations.map((v) => ({
-        type: 'rule-violation',
-        rule: v.rule,
-        level: v.level,
-        message: v.message,
-        ruleType: 'builtin',
-    }));
-    // Convert structural diff to audit issues
-    const structuralIssues = structuralDiff ? structuralDiffToIssues(structuralDiff) : [];
-    // Merge all issues
-    const allIssues = [...ruleIssues, ...structuralIssues];
-    // Diff against previous cycle
-    const prevIssues = previous?.issues ?? [];
-    const { newIssues, resolvedIssues } = diffIssues(prevIssues, allIssues);
-    // 5. Extract token usage
-    const tokenData = loadTokenUsage();
-    // 6. Build record with all fields (structured + flattened for UI)
-    const record = {
-        timestamp: new Date().toISOString(),
-        passed: result.errors === 0 && structuralIssues.length === 0,
-        issues: allIssues,
-        summary: {
-            ruleViolations: ruleIssues.length,
-            structuralIssues: structuralIssues.length,
-            totalIssues: allIssues.length,
-        },
-        newIssues,
-        resolvedIssues,
-        metrics: computeMetrics(result),
-        durationMs: Date.now() - cycleStart,
-        tokenUsage: tokenData
-            ? {
-                inputTokens: tokenData.input,
-                outputTokens: tokenData.output,
-                totalTokens: tokenData.input + tokenData.output,
-            }
-            : undefined,
-        // Structural diff
-        structuralDiff,
-        // Git context
-        git,
-        // Architecture counts
-        totalNodes: currArch?.nodes.length ?? 0,
-        totalEdges: currArch?.edges.length ?? 0,
-        // Flattened for UI (backward compat)
-        errors: result.errors,
-        warnings: result.warnings,
-        newViolations: newIssues.map((i) => ({
-            rule: i.rule || i.metric || "",
-            level: i.level,
-            message: i.message,
-        })),
-        resolvedViolations: resolvedIssues.map((i) => ({
-            rule: i.rule || i.metric || "",
-            level: i.level,
-            message: i.message,
-        })),
-    };
-    saveRecord(patrolDir, record);
-    return record;
-}
-function printPatrolResult(record, cycleNum) {
-    const time = new Date(record.timestamp).toLocaleTimeString();
-    const status = record.passed ? chalk.green("HEALTHY") : chalk.red("VIOLATION");
-    const duration = record.durationMs ? `${(record.durationMs / 1000).toFixed(1)}s` : "?";
-    console.log();
-    console.log(chalk.bold.cyan(`  Patrol #${cycleNum} | ${time} | ${status} | ${duration}`));
-    console.log(chalk.gray(`  Architecture: ${record.totalNodes} nodes, ${record.totalEdges} edges`));
-    // Token usage
-    if (record.tokenUsage) {
-        const tokens = record.tokenUsage;
-        console.log(chalk.gray(`  Tokens: ${tokens.inputTokens.toLocaleString()} in + ${tokens.outputTokens.toLocaleString()} out = ${tokens.totalTokens.toLocaleString()} total`));
-    }
-    // Git changes
-    if (record.git && (record.git.commitCount > 0 || record.git.changedFileCount > 0)) {
-        const parts = [];
-        if (record.git.commitCount > 0)
-            parts.push(`${record.git.commitCount} commit(s)`);
-        parts.push(`${record.git.changedFileCount} file(s) changed`);
-        console.log(chalk.gray(`  Git: ${parts.join(", ")}`));
-    }
-    // Structural changes
-    if (record.structuralDiff && hasStructuralChanges(record.structuralDiff)) {
-        const d = record.structuralDiff;
-        console.log(chalk.bold.yellow(`  Architecture drift detected:`));
-        for (const n of d.addedNodes) {
-            console.log(chalk.green(`    + ${n.label} (${n.type})`));
-        }
-        for (const n of d.removedNodes) {
-            console.log(chalk.red(`    - ${n.label} (${n.type})`));
-        }
-        for (const m of d.modifiedNodes) {
-            console.log(chalk.yellow(`    ~ ${m.id}: ${m.field} "${m.from}" -> "${m.to}"`));
-        }
-        if (d.addedEdges.length > 0) {
-            console.log(chalk.green(`    + ${d.addedEdges.length} new connection(s)`));
-        }
-        if (d.removedEdges.length > 0) {
-            console.log(chalk.red(`    - ${d.removedEdges.length} removed connection(s)`));
-        }
-    }
-    // New rule violations
-    const newRuleIssues = record.newIssues.filter((i) => i.type === "rule-violation");
-    if (newRuleIssues.length > 0) {
-        console.log(chalk.red(`  ${newRuleIssues.length} new rule violation(s):`));
-        for (const issue of newRuleIssues) {
-            const icon = issue.level === "error" ? chalk.red("!!") : chalk.yellow("!!");
-            const label = issue.rule || issue.metric || "unknown";
-            console.log(chalk.gray(`    ${icon} [${label}] ${issue.message}`));
-        }
-    }
-    // Resolved issues
-    if (record.resolvedIssues.length > 0) {
-        console.log(chalk.green(`  ${record.resolvedIssues.length} resolved:`));
-        for (const issue of record.resolvedIssues) {
-            const label = issue.rule || issue.metric || "unknown";
-            console.log(chalk.green(`    -- [${label}] ${issue.message}`));
-        }
-    }
-    // No changes at all
-    if (record.newIssues.length === 0 &&
-        record.resolvedIssues.length === 0 &&
-        (!record.structuralDiff || !hasStructuralChanges(record.structuralDiff))) {
-        console.log(chalk.gray(`  No changes. ${record.summary.ruleViolations} rules, ${record.summary.structuralIssues} structural`));
-    }
-}
-function printHistory(patrolDir) {
-    const historyPath = path.join(patrolDir, HISTORY_FILE);
-    if (!fs.existsSync(historyPath)) {
-        console.log(chalk.yellow("  No patrol history found. Run archbyte patrol to start."));
-        return;
-    }
-    const lines = fs.readFileSync(historyPath, "utf-8").trim().split("\n").filter(Boolean);
-    if (lines.length === 0) {
-        console.log(chalk.yellow("  No patrol history found."));
-        return;
-    }
-    const projectName = process.cwd().split("/").pop() || "project";
-    console.log();
-    console.log(chalk.bold.cyan(`  ArchByte Patrol History: ${projectName}`));
-    console.log();
-    // Show last 20 records (skip malformed lines)
-    const records = lines.slice(-20).flatMap((l) => {
-        try {
-            return [JSON.parse(l)];
-        }
-        catch {
-            return [];
-        }
-    });
-    // Health sparkline
-    const sparkline = records
-        .map((r) => (r.passed ? chalk.green("*") : chalk.red("*")))
-        .join("");
-    console.log(`  Health: ${sparkline}  (last ${records.length} patrols)`);
-    console.log();
-    // Table
-    console.log(chalk.gray("  Time                 Status    Nodes  Edges  Rules  Struct  New  Resolved  Git"));
-    console.log(chalk.gray("  " + "-".repeat(100)));
-    for (const r of records) {
-        const time = new Date(r.timestamp).toLocaleString().padEnd(20);
-        const status = r.passed ? chalk.green("PASS  ") : chalk.red("FAIL  ");
-        const nodes = String(r.totalNodes ?? "?").padEnd(6);
-        const edges = String(r.totalEdges ?? "?").padEnd(6);
-        const rules = String(r.summary?.ruleViolations ?? 0).padEnd(6);
-        const structural = String(r.summary?.structuralIssues ?? 0).padEnd(8);
-        const newV = String(r.newIssues?.length ?? 0).padEnd(5);
-        const resolved = String(r.resolvedIssues?.length ?? 0).padEnd(10);
-        const gitInfo = r.git
-            ? `${r.git.commitCount}c/${r.git.changedFileCount}f`
-            : "-";
-        console.log(`  ${time} ${status} ${nodes}${edges}${rules}${structural}${newV}${resolved}${gitInfo}`);
-    }
-    console.log();
-    // Summary
-    const totalPatrols = lines.length;
-    const failedPatrols = records.filter((r) => !r.passed).length;
-    const healthPct = totalPatrols > 0
-        ? Math.round(((totalPatrols - failedPatrols) / totalPatrols) * 100)
-        : 100;
-    console.log(`  Total patrols: ${totalPatrols} | Health rate: ${healthPct}% | Failed: ${failedPatrols}`);
-    console.log();
-}
-function handleViolationAction(record, action) {
-    if (record.newIssues.length === 0 && (!record.structuralDiff || !hasStructuralChanges(record.structuralDiff)))
-        return;
-    switch (action) {
-        case "json":
-            console.log(JSON.stringify({
-                event: "patrol-issue",
-                timestamp: record.timestamp,
-                newIssues: record.newIssues,
-                structuralDiff: record.structuralDiff,
-                git: record.git,
-            }));
-            break;
-        case "log":
-        default:
-            // Already printed in printPatrolResult
-            break;
-    }
-}
-/**
- * Run the architecture patrol daemon.
- * Each cycle: snapshot → analyze (incremental) → generate → validate → diff
- *
- * --once: run a single cycle then exit (used by UI "Run Now")
- */
-export async function handlePatrol(options) {
-    const projectName = process.cwd().split("/").pop() || "project";
-    const patrolDir = ensurePatrolDir();
-    // History mode
-    if (options.history) {
-        printHistory(patrolDir);
-        return;
-    }
-    const action = options.onViolation || "log";
-    // Run initial cycle immediately
-    let cycleNum = 1;
-    // Watch mode: trigger patrol cycle on source file changes
-    if (options.watch) {
-        const chokidar = await import("chokidar");
-        const userPatterns = loadPatrolIgnore(options.config);
-        console.log();
-        console.log(chalk.bold.cyan(`  ArchByte Patrol: ${projectName}`));
-        console.log(chalk.gray(`  Mode: watch | On violation: ${action}`));
-        console.log(chalk.gray(`  Detects: rule violations, architecture drift, git changes`));
-        console.log(chalk.gray(`  History: archbyte patrol --history`));
-        if (userPatterns.length > 0) {
-            console.log(chalk.gray(`  Ignoring: ${userPatterns.join(", ")} (from archbyte.yaml)`));
-        }
-        else {
-            console.log(chalk.gray(`  Tip: Add patrol.ignore in archbyte.yaml to exclude paths from watching`));
-        }
-        console.log(chalk.gray("  Press Ctrl+C to stop."));
-        // Set up watcher FIRST — its file handles keep the event loop alive
-        // so the process can't exit during the initial cycle.
-        let debounceTimer = null;
-        let running = false;
-        const triggerCycle = () => {
-            if (debounceTimer)
-                clearTimeout(debounceTimer);
-            debounceTimer = setTimeout(async () => {
-                if (running)
-                    return;
-                running = true;
-                cycleNum++;
-                try {
-                    const record = await runPatrolCycle(options, patrolDir);
-                    printPatrolResult(record, cycleNum);
-                    handleViolationAction(record, action);
-                }
-                catch (err) {
-                    console.error(chalk.red(`  Patrol cycle #${cycleNum} failed: ${err}`));
-                }
-                finally {
-                    running = false;
-                }
-            }, 500);
-        };
-        const watcher = chokidar.watch(".", {
-            cwd: process.cwd(),
-            ignoreInitial: true,
-            ignored: buildWatchIgnored(options.config),
-        });
-        watcher.on("change", triggerCycle);
-        watcher.on("add", triggerCycle);
-        watcher.on("unlink", triggerCycle);
-        const shutdown = () => {
-            watcher.close();
-            if (debounceTimer)
-                clearTimeout(debounceTimer);
-            console.log();
-            console.log(chalk.gray(`  Patrol stopped after ${cycleNum} cycles.`));
-            process.exit(0);
-        };
-        process.on("SIGINT", shutdown);
-        process.on("SIGTERM", shutdown);
-        // Now run initial cycle — watcher is already anchoring the event loop
-        try {
-            const record = await runPatrolCycle(options, patrolDir);
-            printPatrolResult(record, cycleNum);
-            handleViolationAction(record, action);
-        }
-        catch (err) {
-            console.error(chalk.red(`  Initial patrol cycle failed: ${err}`));
-        }
-        console.log(chalk.gray("  Watching for changes..."));
-        await new Promise(() => { });
-        return;
-    }
-    // Timer mode (default): poll on interval
-    const intervalMs = parseInterval(options.interval || "5m");
-    const intervalStr = options.interval || "5m";
-    console.log();
-    console.log(chalk.bold.cyan(`  ArchByte Patrol: ${projectName}`));
-    console.log(chalk.gray(`  Interval: ${intervalStr} | On violation: ${action}`));
-    console.log(chalk.gray(`  Detects: rule violations, architecture drift, git changes`));
-    console.log(chalk.gray(`  History: archbyte patrol --history`));
-    console.log(chalk.gray("  Press Ctrl+C to stop."));
-    const record = await runPatrolCycle(options, patrolDir);
-    printPatrolResult(record, cycleNum);
-    handleViolationAction(record, action);
-    // Patrol loop
-    const timer = setInterval(async () => {
-        cycleNum++;
-        try {
-            const record = await runPatrolCycle(options, patrolDir);
-            printPatrolResult(record, cycleNum);
-            handleViolationAction(record, action);
-        }
-        catch (err) {
-            console.error(chalk.red(`  Patrol cycle #${cycleNum} failed: ${err}`));
-        }
-    }, intervalMs);
-    // Graceful shutdown
-    const shutdown = () => {
-        clearInterval(timer);
-        console.log();
-        console.log(chalk.gray(`  Patrol stopped after ${cycleNum} cycles.`));
-        process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    // Keep alive
-    await new Promise(() => { });
-}

package/dist/cli/validate.d.ts

@@ -1,53 +0,0 @@
-import type { Architecture, ArchNode } from "../server/src/generator/index.js";
-import { type RuleLevel, type CustomRule, type CustomRuleMatcher } from "./shared.js";
-interface ValidateOptions {
-    diagram?: string;
-    config?: string;
-    ci?: boolean;
-}
-export interface Violation {
-    rule: string;
-    level: RuleLevel;
-    message: string;
-}
-/**
- * Check for layer bypass violations.
- * Returns violations where a connection skips layers (e.g. presentation → data).
- */
-export declare function checkNoLayerBypass(arch: Architecture, realNodes: ArchNode[], nodeMap: Map<string, ArchNode>, level: RuleLevel): Violation[];
-/**
- * Check for nodes exceeding the max connection threshold.
- */
-export declare function checkMaxConnections(arch: Architecture, realNodes: ArchNode[], level: RuleLevel, threshold: number): Violation[];
-/**
- * Check for orphan nodes (no connections).
- */
-export declare function checkNoOrphans(arch: Architecture, realNodes: ArchNode[], level: RuleLevel): Violation[];
-/**
- * Check for circular dependencies.
- */
-export declare function checkCircularDeps(arch: Architecture, realNodes: ArchNode[], nodeMap: Map<string, ArchNode>, level: RuleLevel): Violation[];
-/**
- * Check if a node matches a custom rule matcher.
- */
-export declare function matchesNode(node: ArchNode, matcher: CustomRuleMatcher): boolean;
-/**
- * Evaluate custom rules against the architecture.
- */
-export declare function evaluateCustomRules(arch: Architecture, realNodes: ArchNode[], nodeMap: Map<string, ArchNode>, customRules: CustomRule[]): Violation[];
-interface ValidationResult {
-    violations: Violation[];
-    errors: number;
-    warnings: number;
-    totalNodes: number;
-    totalEdges: number;
-}
-/**
- * Core validation logic — runs all rules and returns results without side effects.
- */
-export declare function runValidation(options: ValidateOptions): ValidationResult;
-/**
- * Run architecture fitness function validation.
- */
-export declare function handleValidate(options: ValidateOptions): Promise<void>;
-export {};