archbyte 0.1.0

package/dist/cli/serve.js

@@ -0,0 +1,65 @@
+import * as path from "path";
+import * as fs from "fs";
+import chalk from "chalk";
+/**
+ * Start the ArchByte UI server
+ */
+export async function handleServe(options) {
+    const rootDir = process.cwd();
+    const port = options.port || 3847;
+    const diagramPath = options.diagram
+        ? path.resolve(rootDir, options.diagram)
+        : path.join(rootDir, ".archbyte", "architecture.json");
+    // Auto-detect project name from package.json or folder
+    let projectName = path.basename(rootDir);
+    const packageJsonPath = path.join(rootDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+            projectName = pkg.name || projectName;
+        }
+        catch {
+            // ignore
+        }
+    }
+    console.log(chalk.cyan(`🏗️  ArchByte - ${projectName}`));
+    console.log(chalk.gray(`Diagram: ${path.relative(rootDir, diagramPath)}`));
+    console.log(chalk.gray(`Port: ${port}`));
+    console.log();
+    // Check if diagram exists
+    if (!fs.existsSync(diagramPath)) {
+        console.log(chalk.yellow("No architecture diagram found."));
+        console.log(chalk.gray("Run 'archbyte analyze' or 'archbyte run' to generate one."));
+        console.log();
+    }
+    const { startServer } = await import("../server/src/index.js");
+    const maxRetries = 10;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        const tryPort = port + attempt;
+        try {
+            if (attempt > 0) {
+                console.log(chalk.gray(`Port ${tryPort - 1} in use, trying ${tryPort}...`));
+            }
+            console.log(chalk.green(`UI: http://localhost:${tryPort}`));
+            console.log();
+            await startServer({
+                name: projectName,
+                diagramPath,
+                workspaceRoot: rootDir,
+                port: tryPort,
+            });
+            return;
+        }
+        catch (error) {
+            if (error instanceof Error && error.code === "EADDRINUSE") {
+                continue;
+            }
+            if (error instanceof Error) {
+                console.error(chalk.red(`Error: ${error.message}`));
+            }
+            process.exit(1);
+        }
+    }
+    console.error(chalk.red(`All ports ${port}-${port + maxRetries - 1} are in use.`));
+    process.exit(1);
+}

package/dist/cli/setup.d.ts

@@ -0,0 +1 @@
+export declare function handleSetup(): Promise<void>;

package/dist/cli/setup.js

@@ -0,0 +1,233 @@
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import { resolveModel, MODEL_MAP } from "../agents/runtime/types.js";
+import { createProvider } from "../agents/providers/router.js";
+import { select, spinner, confirm } from "./ui.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CONFIG_DIR = path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".archbyte");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+const PROVIDERS = [
+    { name: "anthropic", label: "Anthropic", hint: "Claude Opus / Sonnet" },
+    { name: "openai", label: "OpenAI", hint: "GPT-4o / o1" },
+    { name: "google", label: "Google", hint: "Gemini Flash / Pro" },
+    { name: "ollama", label: "Ollama", hint: "Local models (no key needed)" },
+];
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_PATH)) {
+            return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+        }
+    }
+    catch {
+        // ignore
+    }
+    return {};
+}
+function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+function maskKey(key) {
+    if (key.length <= 8)
+        return "****";
+    return key.slice(0, 6) + "..." + key.slice(-4);
+}
+function askHidden(prompt) {
+    return new Promise((resolve) => {
+        process.stdout.write(prompt);
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+        let input = "";
+        const onData = (data) => {
+            for (const ch of data) {
+                if (ch === "\n" || ch === "\r" || ch === "\u0004") {
+                    stdin.setRawMode(wasRaw ?? false);
+                    stdin.pause();
+                    stdin.removeListener("data", onData);
+                    process.stdout.write("\n");
+                    resolve(input);
+                    return;
+                }
+                else if (ch === "\u0003") {
+                    process.stdout.write("\n");
+                    process.exit(0);
+                }
+                else if (ch === "\u007F" || ch === "\b") {
+                    if (input.length > 0) {
+                        input = input.slice(0, -1);
+                        process.stdout.write("\b \b");
+                    }
+                }
+                else {
+                    input += ch;
+                    process.stdout.write("*");
+                }
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
+async function validateProviderSilent(providerName, apiKey, ollamaBaseUrl) {
+    try {
+        if (providerName === "ollama") {
+            const url = ollamaBaseUrl ?? "http://localhost:11434";
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
+            try {
+                const res = await fetch(url, { signal: controller.signal });
+                clearTimeout(timeout);
+                if (!res.ok)
+                    return false;
+                // Check installed models
+                try {
+                    const tagsController = new AbortController();
+                    const tagsTimeout = setTimeout(() => tagsController.abort(), 5000);
+                    const tagsRes = await fetch(`${url}/api/tags`, { signal: tagsController.signal });
+                    clearTimeout(tagsTimeout);
+                    if (tagsRes.ok) {
+                        const data = await tagsRes.json();
+                        const installedModels = (data.models ?? []).map((m) => m.name.split(":")[0]);
+                        const requiredModels = Object.values(MODEL_MAP.ollama);
+                        const uniqueRequired = [...new Set(requiredModels)];
+                        const compatible = uniqueRequired.filter((m) => installedModels.some((installed) => installed === m));
+                        if (compatible.length > 0) {
+                            console.log(chalk.gray(`  Compatible models: ${compatible.join(", ")}`));
+                        }
+                        else {
+                            console.log(chalk.yellow(`  Warning: no compatible models found.`));
+                            console.log(chalk.gray(`  Run: ollama pull ${uniqueRequired[0]}`));
+                        }
+                    }
+                }
+                catch {
+                    // Model check is best-effort
+                }
+                return true;
+            }
+            catch {
+                clearTimeout(timeout);
+                return false;
+            }
+        }
+        const provider = createProvider({ provider: providerName, apiKey });
+        const model = resolveModel(providerName, "fast");
+        await provider.chat({
+            model,
+            system: "Reply with 'ok'.",
+            messages: [{ role: "user", content: "ping" }],
+            maxTokens: 8,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function handleSetup() {
+    console.log();
+    console.log(chalk.bold.cyan("ArchByte Setup"));
+    console.log(chalk.gray("Configure your model provider and API key.\n"));
+    const config = loadConfig();
+    // Show current config if exists
+    if (config.provider) {
+        console.log(chalk.gray(`  Current provider: ${config.provider}`));
+        if (config.apiKey) {
+            console.log(chalk.gray(`  Current API key:  ${maskKey(config.apiKey)}`));
+        }
+        console.log();
+    }
+    // Step 1: Choose provider with arrow-key selection
+    const idx = await select("Choose your model provider:", PROVIDERS.map((p) => {
+        const current = config.provider === p.name ? chalk.green(" (current)") : "";
+        return `${p.label} ${chalk.gray("— " + p.hint)}${current}`;
+    }));
+    const provider = PROVIDERS[idx].name;
+    config.provider = provider;
+    const selected = PROVIDERS[idx];
+    console.log(chalk.green(`\n  ✓ Provider: ${selected.label}`));
+    // Step 2: API key (skip for Ollama)
+    if (provider === "ollama") {
+        config.ollamaBaseUrl = config.ollamaBaseUrl ?? "http://localhost:11434";
+        console.log(chalk.gray(`  Ollama URL: ${config.ollamaBaseUrl}`));
+    }
+    else {
+        console.log();
+        const apiKey = await askHidden(chalk.bold("  API key: "));
+        if (!apiKey) {
+            console.log(chalk.red("  No API key entered. Setup cancelled."));
+            process.exit(1);
+        }
+        config.apiKey = apiKey;
+        console.log(chalk.green(`  ✓ API key: ${maskKey(apiKey)}`));
+    }
+    // Validate provider with spinner
+    const s = spinner("Validating credentials");
+    let isValid = await validateProviderSilent(provider, config.apiKey ?? "", config.ollamaBaseUrl);
+    s.stop(isValid ? "valid" : "invalid", isValid ? "green" : "red");
+    // Retry loop on failure
+    if (!isValid) {
+        let retries = 0;
+        while (!isValid && retries < 2) {
+            if (!await confirm("  Retry?"))
+                break;
+            retries++;
+            if (provider !== "ollama") {
+                const newKey = await askHidden(chalk.bold("  API key: "));
+                if (newKey) {
+                    config.apiKey = newKey;
+                    console.log(chalk.green(`  ✓ API key: ${maskKey(newKey)}`));
+                }
+            }
+            const s2 = spinner("Validating credentials");
+            isValid = await validateProviderSilent(provider, config.apiKey ?? "", config.ollamaBaseUrl);
+            s2.stop(isValid ? "valid" : "invalid", isValid ? "green" : "red");
+        }
+        if (!isValid) {
+            console.log(chalk.yellow("  Warning: credentials unverified. Saving anyway."));
+        }
+    }
+    // Save config
+    saveConfig(config);
+    console.log(chalk.gray(`\n  Config saved to ${CONFIG_PATH}`));
+    // Generate archbyte.yaml in .archbyte/ if it doesn't exist
+    const projectDir = process.cwd();
+    const archbyteDir = path.join(projectDir, ".archbyte");
+    const yamlPath = path.join(archbyteDir, "archbyte.yaml");
+    if (!fs.existsSync(yamlPath)) {
+        if (!fs.existsSync(archbyteDir)) {
+            fs.mkdirSync(archbyteDir, { recursive: true });
+        }
+        // Detect project name
+        let projectName = path.basename(projectDir);
+        const pkgPath = path.join(projectDir, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                if (pkg.name)
+                    projectName = pkg.name;
+            }
+            catch { /* ignore */ }
+        }
+        const templatePath = path.resolve(__dirname, "../../templates/archbyte.yaml");
+        let template = fs.readFileSync(templatePath, "utf-8");
+        template = template.replace('name: "My Project"', `name: "${projectName}"`);
+        fs.writeFileSync(yamlPath, template, "utf-8");
+        console.log(chalk.green(`  Created .archbyte/archbyte.yaml`));
+    }
+    else {
+        console.log(chalk.gray(`  .archbyte/archbyte.yaml already exists`));
+    }
+    console.log();
+    console.log(chalk.green("  Setup complete!"));
+    console.log();
+    console.log(chalk.bold("  Next: ") + chalk.cyan("archbyte run") + chalk.bold(" to analyze your codebase."));
+    console.log();
+}

package/dist/cli/shared.d.ts

@@ -0,0 +1,68 @@
+import type { Architecture } from "../server/src/generator/index.js";
+export interface DiagramOptions {
+    diagram?: string;
+}
+export type RuleLevel = "error" | "warn" | "off";
+export interface RuleConfig {
+    "no-layer-bypass"?: RuleLevel | {
+        level: RuleLevel;
+    };
+    "max-connections"?: RuleLevel | {
+        level: RuleLevel;
+        threshold?: number;
+    };
+    "no-orphans"?: RuleLevel | {
+        level: RuleLevel;
+    };
+    "no-circular-deps"?: RuleLevel | {
+        level: RuleLevel;
+    };
+}
+export interface CustomRuleMatcher {
+    type?: string;
+    layer?: string;
+    id?: string;
+    not?: boolean;
+}
+export interface CustomRule {
+    name: string;
+    from: CustomRuleMatcher;
+    to: CustomRuleMatcher;
+    level: RuleLevel;
+}
+/**
+ * Resolve the path to the architecture JSON file from CLI options or defaults.
+ */
+export declare function resolveArchitecturePath(options: DiagramOptions): string;
+/**
+ * Load and parse the architecture JSON file.
+ * Exits with an error message if the file is missing or invalid.
+ */
+export declare function loadArchitectureFile(filePath: string): Architecture;
+/**
+ * Load rules configuration from archbyte.yaml.
+ */
+export declare function loadRulesConfig(configPath?: string): RuleConfig;
+/**
+ * Minimal YAML parser for the rules section only.
+ * Handles:
+ *   rules:
+ *     rule-name: error
+ *     rule-name:
+ *       level: warn
+ *       threshold: 6
+ */
+export declare function parseRulesFromYaml(content: string): RuleConfig;
+/**
+ * Parse custom rules from the YAML config file.
+ * Handles:
+ *   rules:
+ *     custom:
+ *       - name: "rule-name"
+ *         from: { type: "component", layer: "presentation" }
+ *         to: { type: "database" }
+ *         level: error
+ */
+export declare function parseCustomRulesFromYaml(content: string): CustomRule[];
+export declare function getRuleLevel(config: RuleConfig, rule: keyof RuleConfig, defaultLevel: RuleLevel): RuleLevel;
+export declare function getThreshold(config: RuleConfig, rule: "max-connections", defaultVal: number): number;

package/dist/cli/shared.js

@@ -0,0 +1,275 @@
+import * as path from "path";
+import * as fs from "fs";
+import chalk from "chalk";
+/**
+ * Resolve the path to the architecture JSON file from CLI options or defaults.
+ */
+export function resolveArchitecturePath(options) {
+    const rootDir = process.cwd();
+    return options.diagram
+        ? path.resolve(rootDir, options.diagram)
+        : path.join(rootDir, ".archbyte", "architecture.json");
+}
+/**
+ * Load and parse the architecture JSON file.
+ * Exits with an error message if the file is missing or invalid.
+ */
+export function loadArchitectureFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        console.error(chalk.red(`Architecture file not found: ${filePath}`));
+        console.error(chalk.gray("Run archbyte generate first, or provide --diagram <path>"));
+        process.exit(1);
+    }
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        console.error(chalk.red(`Failed to parse architecture file: ${filePath}`));
+        process.exit(1);
+    }
+}
+/**
+ * Load rules configuration from archbyte.yaml.
+ */
+export function loadRulesConfig(configPath) {
+    const rootDir = process.cwd();
+    const yamlPath = configPath
+        ? path.resolve(rootDir, configPath)
+        : path.join(rootDir, ".archbyte", "archbyte.yaml");
+    if (!fs.existsSync(yamlPath)) {
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(yamlPath, "utf-8");
+        // Simple YAML parser for the rules section — avoids adding a dependency
+        return parseRulesFromYaml(content);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Minimal YAML parser for the rules section only.
+ * Handles:
+ *   rules:
+ *     rule-name: error
+ *     rule-name:
+ *       level: warn
+ *       threshold: 6
+ */
+export function parseRulesFromYaml(content) {
+    const lines = content.split("\n");
+    const rules = {};
+    let inRules = false;
+    let currentRule = null;
+    let currentObj = {};
+    for (const line of lines) {
+        const trimmed = line.trimEnd();
+        // Detect start of rules section
+        if (/^rules:\s*$/.test(trimmed)) {
+            inRules = true;
+            continue;
+        }
+        // Detect start of another top-level section (end of rules)
+        if (inRules && /^\S/.test(trimmed) && !trimmed.startsWith("#")) {
+            // Flush current rule
+            if (currentRule && Object.keys(currentObj).length > 0) {
+                rules[currentRule] = currentObj;
+            }
+            inRules = false;
+            currentRule = null;
+            continue;
+        }
+        if (!inRules)
+            continue;
+        // Skip empty lines and comments
+        if (trimmed === "" || trimmed.trim().startsWith("#"))
+            continue;
+        // Indented rule entry: "  rule-name: value" or "  rule-name:"
+        const ruleMatch = trimmed.match(/^ {2}(\S[\w-]+):\s*(.*)$/);
+        if (ruleMatch) {
+            // Flush previous rule object
+            if (currentRule && Object.keys(currentObj).length > 0) {
+                rules[currentRule] = currentObj;
+            }
+            const [, name, value] = ruleMatch;
+            if (value && value.trim() !== "") {
+                // Simple value: "rule-name: error"
+                rules[name] = value.trim();
+                currentRule = null;
+                currentObj = {};
+            }
+            else {
+                // Block value — will have sub-keys
+                currentRule = name;
+                currentObj = {};
+            }
+            continue;
+        }
+        // Sub-key: "    level: warn" or "    threshold: 6"
+        const subMatch = trimmed.match(/^ {4,}(\w+):\s*(.+)$/);
+        if (subMatch && currentRule) {
+            const [, key, val] = subMatch;
+            const numVal = Number(val);
+            currentObj[key] = isNaN(numVal) ? val.trim() : numVal;
+        }
+    }
+    // Flush last rule
+    if (currentRule && Object.keys(currentObj).length > 0) {
+        rules[currentRule] = currentObj;
+    }
+    return rules;
+}
+/**
+ * Parse custom rules from the YAML config file.
+ * Handles:
+ *   rules:
+ *     custom:
+ *       - name: "rule-name"
+ *         from: { type: "component", layer: "presentation" }
+ *         to: { type: "database" }
+ *         level: error
+ */
+export function parseCustomRulesFromYaml(content) {
+    const rules = [];
+    const lines = content.split("\n");
+    let inRules = false;
+    let inCustom = false;
+    let inItem = false;
+    let currentItem = {};
+    let currentFrom = {};
+    let currentTo = {};
+    let inFrom = false;
+    let inTo = false;
+    const flushItem = () => {
+        if (currentItem.name && Object.keys(currentFrom).length > 0 && Object.keys(currentTo).length > 0) {
+            const fromMatcher = {};
+            if (currentFrom.type)
+                fromMatcher.type = currentFrom.type;
+            if (currentFrom.layer)
+                fromMatcher.layer = currentFrom.layer;
+            if (currentFrom.id)
+                fromMatcher.id = currentFrom.id;
+            if (currentFrom.not === "true")
+                fromMatcher.not = true;
+            const toMatcher = {};
+            if (currentTo.type)
+                toMatcher.type = currentTo.type;
+            if (currentTo.layer)
+                toMatcher.layer = currentTo.layer;
+            if (currentTo.id)
+                toMatcher.id = currentTo.id;
+            if (currentTo.not === "true")
+                toMatcher.not = true;
+            rules.push({
+                name: currentItem.name,
+                from: fromMatcher,
+                to: toMatcher,
+                level: currentItem.level || "error",
+            });
+        }
+        currentItem = {};
+        currentFrom = {};
+        currentTo = {};
+        inFrom = false;
+        inTo = false;
+        inItem = false;
+    };
+    for (const line of lines) {
+        const trimmed = line.trimEnd();
+        if (/^rules:\s*$/.test(trimmed)) {
+            inRules = true;
+            continue;
+        }
+        if (inRules && /^\S/.test(trimmed) && !trimmed.startsWith("#")) {
+            if (inItem)
+                flushItem();
+            inRules = false;
+            inCustom = false;
+            continue;
+        }
+        if (!inRules)
+            continue;
+        if (trimmed === "" || trimmed.trim().startsWith("#"))
+            continue;
+        // Detect "  custom:" section
+        if (/^ {2}custom:\s*$/.test(trimmed)) {
+            inCustom = true;
+            continue;
+        }
+        // If we hit another 2-space rule name, leave custom
+        if (inCustom && /^ {2}[a-zA-Z]/.test(trimmed) && !/^ {2}custom:/.test(trimmed) && !trimmed.trim().startsWith("-")) {
+            if (inItem)
+                flushItem();
+            inCustom = false;
+            continue;
+        }
+        if (!inCustom)
+            continue;
+        // New list item: "    - name: ..."
+        const listItemMatch = trimmed.match(/^ {4}- name:\s*"?([^"]+)"?\s*$/);
+        if (listItemMatch) {
+            if (inItem)
+                flushItem();
+            inItem = true;
+            currentItem.name = listItemMatch[1].trim();
+            continue;
+        }
+        if (!inItem)
+            continue;
+        // Inline from/to: "      from: { type: "component", layer: "presentation" }"
+        const inlineMatch = trimmed.match(/^ {6}(from|to):\s*\{(.+)\}\s*$/);
+        if (inlineMatch) {
+            const target = inlineMatch[1] === "from" ? currentFrom : currentTo;
+            const pairs = inlineMatch[2].split(",");
+            for (const pair of pairs) {
+                const kv = pair.match(/(\w+):\s*"?([^",]+)"?/);
+                if (kv)
+                    target[kv[1].trim()] = kv[2].trim();
+            }
+            inFrom = false;
+            inTo = false;
+            continue;
+        }
+        // Block from/to start: "      from:" or "      to:"
+        const blockMatch = trimmed.match(/^ {6}(from|to):\s*$/);
+        if (blockMatch) {
+            inFrom = blockMatch[1] === "from";
+            inTo = blockMatch[1] === "to";
+            continue;
+        }
+        // Sub-keys under from/to: "        type: component"
+        const subKeyMatch = trimmed.match(/^ {8}(\w+):\s*"?([^"]+)"?\s*$/);
+        if (subKeyMatch) {
+            const target = inFrom ? currentFrom : inTo ? currentTo : null;
+            if (target)
+                target[subKeyMatch[1].trim()] = subKeyMatch[2].trim();
+            continue;
+        }
+        // Top-level item property: "      level: error"
+        const propMatch = trimmed.match(/^ {6}(\w+):\s*"?([^"{]+)"?\s*$/);
+        if (propMatch && propMatch[1] !== "from" && propMatch[1] !== "to") {
+            currentItem[propMatch[1].trim()] = propMatch[2].trim();
+            inFrom = false;
+            inTo = false;
+        }
+    }
+    if (inItem)
+        flushItem();
+    return rules;
+}
+export function getRuleLevel(config, rule, defaultLevel) {
+    const entry = config[rule];
+    if (!entry)
+        return defaultLevel;
+    if (typeof entry === "string")
+        return entry;
+    return entry.level ?? defaultLevel;
+}
+export function getThreshold(config, rule, defaultVal) {
+    const entry = config[rule];
+    if (!entry || typeof entry === "string")
+        return defaultVal;
+    return entry.threshold ?? defaultVal;
+}

package/dist/cli/stats.d.ts

@@ -0,0 +1,9 @@
+interface StatsOptions {
+    diagram?: string;
+    config?: string;
+}
+/**
+ * Print an architecture health dashboard to the terminal.
+ */
+export declare function handleStats(options: StatsOptions): Promise<void>;
+export {};