archbyte 0.7.1 → 0.7.3

package/README.md

@@ -47,11 +47,8 @@ Run `/archbyte-help` in Claude Code to see all commands.
 | `/archbyte-analyze` | Scans your codebase and generates `.archbyte/analysis.json` |
 | `/archbyte-generate` | Converts analysis into `.archbyte/architecture.json` with positioned nodes |
 | `/archbyte-serve` | Opens interactive diagram UI at http://localhost:3847 |
-| `/archbyte-validate` | Runs fitness rules against your architecture |
 | `/archbyte-stats` | Shows architecture health dashboard |
 | `/archbyte-export` | Exports diagram to Mermaid, Markdown, or other formats |
-| `/archbyte-diff` | Compares architecture snapshots to detect drift |
-| `/archbyte-patrol` | Starts continuous architecture health monitoring |
 | `/archbyte-workflow` | Runs composable multi-step architecture pipelines |
 | `/archbyte-init` | Initializes `archbyte.yaml` config for your project |
 | `/archbyte-help` | Shows this command reference |
@@ -153,46 +150,6 @@ Features: real-time SSE updates, drag-and-drop nodes, environment filtering, flo
 >
 > *Example:* During an incident review, run `npx archbyte serve` and drag the failing service to the center. Click it to highlight all upstream dependencies — now the whole team can see which services are affected and trace the blast radius visually instead of grep-ing through YAML manifests.
 
-### `archbyte validate`
-
-Run architecture fitness function rules.
-
-```bash
-npx archbyte validate
-npx archbyte validate --ci       # JSON output, exit code 1 on errors
-npx archbyte validate --watch    # re-validate on file changes
-```
-
-**Built-in rules:**
-
-| Rule | Default | Description |
-|------|---------|-------------|
-| `no-layer-bypass` | error | Connections that skip layers (e.g. presentation -> data) |
-| `max-connections` | warn (6) | Nodes exceeding connection threshold |
-| `no-orphans` | warn | Nodes with zero connections |
-| `no-circular-deps` | error | Cycles in the dependency graph |
-
-Configure in `archbyte.yaml`:
-
-```yaml
-rules:
-  no-layer-bypass: error
-  max-connections:
-    level: warn
-    threshold: 8
-  no-orphans: off
-  no-circular-deps: error
-  custom:
-    - name: "no-direct-db-from-frontend"
-      from: { layer: "presentation" }
-      to: { type: "database" }
-      level: error
-```
-
-> **Why this matters:** Code review catches syntax and logic bugs, but architectural violations slip through because no human reviewer holds the entire dependency graph in their head. Validate acts as an automated architect that never misses a rule.
->
-> *Example:* A junior developer adds a direct import from a React component to a Postgres client library. `npx archbyte validate --ci` in your GitHub Actions pipeline catches the layer bypass (`presentation -> data`) and fails the build *before* the PR is merged — no manual review needed.
-
 ### `archbyte stats`
 
 Architecture health dashboard.
@@ -225,51 +182,17 @@ npx archbyte export --output docs/architecture.mmd
 >
 > *Example:* Before each release, you run `npx archbyte export --format mermaid --output docs/architecture.mmd` and commit it. GitHub renders the Mermaid diagram inline in your repo — anyone browsing the codebase sees an always-current architecture map without installing anything.
 
-### `archbyte diff`
+### `archbyte mcp`
 
-Compare architecture snapshots and detect drift.
+Start the MCP (Model Context Protocol) server for AI agent integration.
 
 ```bash
-npx archbyte diff --baseline .archbyte/baseline.json
-npx archbyte diff --baseline old.json --current new.json
+npx archbyte mcp                          # start MCP server on stdio
 ```
 
-Reports added/removed components, added/removed connections, density change, new/resolved violations. Exit code 1 on new errors.
-
-> **Why this matters:** Architecture erosion happens one commit at a time. By the time someone notices, the codebase has drifted far from its intended design. Diff catches drift early by comparing snapshots and surfacing exactly what changed.
->
-> *Example:* You save a baseline after your v2.0 release with `cp .archbyte/architecture.json .archbyte/baseline.json`. Two months later, run `npx archbyte diff --baseline .archbyte/baseline.json` and discover 3 new circular dependencies and a removed service boundary. You can now decide whether to accept the drift or fix it — before it compounds further.
-
-### `archbyte patrol`
+Exposes ArchByte tools (analyze, status, export, stats, validate) and resources to any MCP-compatible client (Claude Code, VS Code, etc.).
 
-Continuous architecture health monitoring — runs the validation pipeline on a repeating interval, diffs each cycle to detect new and resolved violations, and maintains a persistent health history.
-
-Inspired by [Gastown's](https://github.com/steveyegge/gastown) patrol loop pattern.
-
-```bash
-npx archbyte patrol                       # default 5m interval
-npx archbyte patrol --interval 30s        # 30 second cycles
-npx archbyte patrol --interval 1h         # hourly
-npx archbyte patrol --on-violation json   # JSON output for piping
-npx archbyte patrol --history             # view patrol history dashboard
-```
-
-**Options:**
-
-| Flag | Default | Description |
-|------|---------|-------------|
-| `--interval <duration>` | `5m` | Cycle interval: `30s`, `5m`, `1h` |
-| `--on-violation <action>` | `log` | Action on new violations: `log` or `json` |
-| `--history` | — | Show health sparkline, history table, health rate |
-
-The patrol daemon:
-- Reports **new** violations and **resolved** ones each cycle
-- Persists history to `.archbyte/patrols/history.jsonl`
-- `--history` shows a sparkline health chart and stats
-
-> **Why this matters:** Validate catches violations at a point in time; Patrol catches them *over time*. Running continuously, it detects the moment a violation appears and tells you when violations get resolved — giving you a living health timeline for your architecture.
->
-> *Example:* You start `npx archbyte patrol --interval 5m` in a tmux session during a refactoring sprint. Mid-afternoon, it flags a new circular dependency introduced in the latest commit. You fix it immediately instead of discovering it three weeks later in a failing CI pipeline. At the end of the sprint, `npx archbyte patrol --history` shows the team a sparkline proving architecture health improved from 72% to 95%.
+> **Why this matters:** MCP lets AI agents call ArchByte tools directly without going through the CLI. This enables seamless integration where Claude Code can analyze your architecture, check stats, and export diagrams as part of a larger agentic workflow.
 
 ### `archbyte workflow`
 
@@ -322,6 +245,22 @@ Workflows **resume on failure** — completed steps are skipped when you re-run.
 >
 > *Example:* You add a `ci-check` workflow to your GitHub Actions. On every PR, it runs `npx archbyte workflow --run ci-check`, which validates architecture rules in CI mode and exits non-zero on violations. No manual steps, no forgotten checks. For bigger releases, `npx archbyte workflow --run full-analysis` runs the entire generate-validate-stats-export pipeline in one command and produces a Mermaid diagram committed to `docs/`.
 
+## Global Flags
+
+These flags work with any command:
+
+| Flag | Description |
+|------|-------------|
+| `--json` | Output structured JSON instead of human-readable text |
+| `--quiet` | Suppress all non-essential output (spinners, progress bars) |
+
+```bash
+npx archbyte status --json          # machine-readable status
+npx archbyte stats --json           # structured stats output
+npx archbyte export --json          # JSON envelope around export
+npx archbyte analyze --quiet        # suppress progress output
+```
+
 ## Keyboard Shortcuts (UI)
 
 | Key | Action |

package/bin/archbyte.js

@@ -21,6 +21,7 @@ import { handleSetup } from '../dist/cli/setup.js';
 import { handleVersion, handleUpdate } from '../dist/cli/version.js';
 import { requireLicense } from '../dist/cli/license-gate.js';
 import { DEFAULT_PORT } from '../dist/cli/constants.js';
+import { setOutputMode, handleError, isJsonMode } from '../dist/cli/output.js';
 
 // When spawned by `archbyte serve` (internal), skip interactive license checks.
 // The user already authenticated when they started the server.
@@ -36,6 +37,8 @@ program
   .name('archbyte')
   .description('ArchByte - AI architecture analysis with an interactive diagram UI')
   .version(PKG_VERSION, '-v, --version', 'Show version number')
+  .option('--json', 'Output structured JSON (for agents and scripts)')
+  .option('--quiet', 'Suppress non-essential output')
   .addHelpText('after', `
   Quick start:
     $ archbyte run            Analyze + open diagram (auto-configures on first run)
@@ -49,6 +52,17 @@ program
   https://archbyte.heartbyte.io
 `);
 
+// Set output mode before every command
+program.hook('preAction', (thisCommand, actionCommand) => {
+  const opts = program.opts();
+  setOutputMode({
+    json: opts.json ?? false,
+    quiet: opts.quiet ?? false,
+    command: actionCommand.name(),
+    version: PKG_VERSION,
+  });
+});
+
 // — Getting started —
 
 program
@@ -229,6 +243,16 @@ program
     await handleUpdate();
   });
 
+// — Agent integration —
+
+program
+  .command('mcp')
+  .description('Start MCP server (stdio transport) for AI agent integration')
+  .action(async () => {
+    const { startMcpServer } = await import('../dist/mcp/server.js');
+    await startMcpServer(PKG_VERSION);
+  });
+
 // Default: show help
 program
   .action(() => {
@@ -240,4 +264,6 @@ program.on('command:*', () => {
   program.help();
 });
 
-program.parse();
+program.parseAsync().catch((err) => {
+  handleError(err);
+});

package/dist/cli/analyze.js

@@ -4,6 +4,7 @@ import { execSync } from "child_process";
 import chalk from "chalk";
 import { resolveConfig } from "./config.js";
 import { recordUsage } from "./license-gate.js";
+import { isJsonMode, outputSuccess, ArchByteError, EXIT } from "./output.js";
 import { staticResultToSpec, writeSpec, writeMetadata, loadSpec, loadMetadata, resolvePrivacy } from "./yaml-io.js";
 import { getChangedFiles, mapFilesToComponents, shouldRunAgents, isGitAvailable, categorizeChanges, computeNeighbors, getCommitCount } from "./incremental.js";
 import { progressBar, confirm } from "./ui.js";
@@ -122,8 +123,7 @@ export async function handleAnalyze(options) {
         provider = createProvider(config);
     }
     catch (err) {
-        console.error(chalk.red(`Failed to create ${config.provider} provider: ${err instanceof Error ? err.message : err}`));
-        process.exit(1);
+        throw new ArchByteError("PROVIDER_ERROR", `Failed to create ${config.provider} provider: ${err instanceof Error ? err.message : err}`, EXIT.PROVIDER_ERROR);
     }
     // 3. Incremental detection
     const startTime = Date.now();
@@ -290,8 +290,7 @@ export async function handleAnalyze(options) {
             printSummary(analysis, duration, "static", { skipServeHint: options.skipServeHint });
         }
         catch (fallbackErr) {
-            console.error(chalk.red(`  Static fallback also failed: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`));
-            process.exit(1);
+            throw new ArchByteError("ANALYSIS_FAILED", `Static fallback also failed: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`, EXIT.ANALYSIS_FAILED);
         }
         return;
     }
@@ -517,6 +516,16 @@ async function autoGenerate(rootDir, options) {
 function printSummary(analysis, durationMs, mode, options) {
     const components = analysis.components ?? [];
     const connections = analysis.connections ?? [];
+    if (isJsonMode()) {
+        outputSuccess({
+            outputPath: options?.outputPath ?? ".archbyte/analysis.json",
+            components: components.length,
+            connections: connections.length,
+            duration: durationMs,
+            mode,
+        });
+        return;
+    }
     console.log();
     console.log(chalk.bold.green("Analysis complete!"));
     console.log(chalk.gray(`  Mode:        ${mode === "pipeline" ? "static + agents" : "static"}`));

package/dist/cli/auth.d.ts

@@ -12,7 +12,33 @@ export declare function handleLogout(options?: {
     all?: boolean;
     email?: string;
 }): Promise<void>;
+export interface AccountStatusData {
+    email: string;
+    tier: string;
+    expiresAt: string;
+    expired: boolean;
+    scans?: {
+        used: number;
+        allowed: number;
+    };
+}
+/**
+ * Get account status as structured data. Returns null if not logged in.
+ */
+export declare function getAccountStatus(): Promise<AccountStatusData | null>;
 export declare function handleStatus(): Promise<void>;
+export interface AccountsListData {
+    active: string;
+    accounts: Array<{
+        email: string;
+        tier: string;
+        expired: boolean;
+    }>;
+}
+/**
+ * Get the list of logged-in accounts as structured data.
+ */
+export declare function getAccountsList(): AccountsListData | null;
 export declare function handleAccounts(): Promise<void>;
 export declare function handleAccountSwitch(email?: string): Promise<void>;
 export declare function loadCredentials(): Credentials | null;

package/dist/cli/auth.js

@@ -5,6 +5,7 @@ import { spawn } from "child_process";
 import chalk from "chalk";
 import { CONFIG_DIR, CREDENTIALS_PATH, API_BASE, CLI_CALLBACK_PORT, OAUTH_TIMEOUT_MS, } from "./constants.js";
 import { confirm, select, textInput } from "./ui.js";
+import { isJsonMode, outputSuccess, outputError, EXIT, ArchByteError } from "./output.js";
 export async function handleLogin(provider) {
     console.log();
     console.log(chalk.bold.cyan("ArchByte Login"));
@@ -60,8 +61,7 @@ export async function handleLogin(provider) {
             console.log(chalk.gray(`Credentials saved to ${CREDENTIALS_PATH}`));
         }
         catch (err) {
-            console.error(chalk.red(`Login failed: ${err instanceof Error ? err.message : "Unknown error"}`));
-            process.exit(1);
+            throw new ArchByteError("AUTH_INVALID", `Login failed: ${err instanceof Error ? err.message : "Unknown error"}`, EXIT.AUTH_INVALID);
         }
         return;
     }
@@ -87,7 +87,7 @@ export async function handleLogin(provider) {
         console.log(chalk.gray("  1. Visit https://archbyte.heartbyte.io"));
         console.log(chalk.gray("  2. Sign in and copy your token from the dashboard"));
         console.log(chalk.gray("  3. Run: archbyte login --token <your-token>"));
-        process.exit(1);
+        throw new ArchByteError("AUTH_INVALID", `Login failed: ${err instanceof Error ? err.message : "Unknown error"}`, EXIT.AUTH_INVALID);
     }
 }
 export async function handleLoginWithToken(token) {
@@ -99,8 +99,7 @@ export async function handleLoginWithToken(token) {
             headers: { Authorization: `Bearer ${token}` },
         });
         if (!res.ok) {
-            console.error(chalk.red("Invalid token."));
-            process.exit(1);
+            throw new ArchByteError("AUTH_INVALID", "Invalid token.", EXIT.AUTH_INVALID);
         }
         const { user } = (await res.json());
         const payload = parseJWTPayload(token);
@@ -117,8 +116,9 @@ export async function handleLoginWithToken(token) {
         console.log(chalk.green(`Logged in as ${chalk.bold(user.email)} (${user.tier} tier)`));
     }
     catch (err) {
-        console.error(chalk.red(`Login failed: ${err instanceof Error ? err.message : "Unknown error"}`));
-        process.exit(1);
+        if (err instanceof ArchByteError)
+            throw err;
+        throw new ArchByteError("AUTH_INVALID", `Login failed: ${err instanceof Error ? err.message : "Unknown error"}`, EXIT.AUTH_INVALID);
     }
 }
 // === Logout ===
@@ -174,54 +174,105 @@ export async function handleLogout(options) {
     }
     console.log(chalk.green(`Logged out (was ${targetEmail}).`));
 }
-// === Status ===
+/**
+ * Get account status as structured data. Returns null if not logged in.
+ */
+export async function getAccountStatus() {
+    const creds = loadCredentials();
+    if (!creds)
+        return null;
+    const expired = isExpired(creds);
+    const result = {
+        email: creds.email,
+        tier: creds.tier,
+        expiresAt: creds.expiresAt,
+        expired,
+    };
+    if (!expired) {
+        try {
+            const res = await fetch(`${API_BASE}/api/v1/scans/count`, {
+                headers: { Authorization: `Bearer ${creds.token}` },
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                result.scans = { used: data.scansUsed, allowed: data.scansAllowed };
+            }
+        }
+        catch {
+            // Offline — no scan data
+        }
+    }
+    return result;
+}
 export async function handleStatus() {
+    const status = await getAccountStatus();
+    if (isJsonMode()) {
+        if (!status) {
+            outputError("AUTH_REQUIRED", "Not logged in", EXIT.AUTH_REQUIRED);
+        }
+        if (status.expired) {
+            outputError("AUTH_EXPIRED", "Session expired", EXIT.AUTH_EXPIRED);
+        }
+        outputSuccess(status);
+        return;
+    }
     console.log();
     console.log(chalk.bold.cyan("ArchByte Account"));
     console.log();
-    const creds = loadCredentials();
-    if (!creds) {
+    if (!status) {
         console.log(chalk.yellow("Not logged in. Run `archbyte login` to sign in."));
         return;
     }
-    if (isExpired(creds)) {
+    if (status.expired) {
         console.log(chalk.yellow("Session expired. Run `archbyte login` to refresh."));
         return;
     }
-    console.log(`  ${chalk.bold("Email")}: ${creds.email}`);
-    console.log(`  ${chalk.bold("Tier")}:  ${creds.tier === "premium" ? chalk.green("Pro") : "Basic"}`);
-    console.log(`  ${chalk.bold("Expires")}: ${new Date(creds.expiresAt).toLocaleDateString()}`);
-    // Fetch live usage from server
-    try {
-        const res = await fetch(`${API_BASE}/api/v1/scans/count`, {
-            headers: { Authorization: `Bearer ${creds.token}` },
-        });
-        if (res.ok) {
-            const data = (await res.json());
-            console.log(`  ${chalk.bold("Scans")}: ${data.scansUsed}${data.scansAllowed === -1 ? " (unlimited)" : `/${data.scansAllowed}`}`);
-        }
-    }
-    catch {
-        // Offline — show cached info only
+    console.log(`  ${chalk.bold("Email")}: ${status.email}`);
+    console.log(`  ${chalk.bold("Tier")}:  ${status.tier === "premium" ? chalk.green("Pro") : "Basic"}`);
+    console.log(`  ${chalk.bold("Expires")}: ${new Date(status.expiresAt).toLocaleDateString()}`);
+    if (status.scans) {
+        console.log(`  ${chalk.bold("Scans")}: ${status.scans.used}${status.scans.allowed === -1 ? " (unlimited)" : `/${status.scans.allowed}`}`);
     }
     console.log();
 }
-// === Accounts ===
+/**
+ * Get the list of logged-in accounts as structured data.
+ */
+export function getAccountsList() {
+    const store = loadStore();
+    if (!store || Object.keys(store.accounts).length === 0)
+        return null;
+    return {
+        active: store.active,
+        accounts: Object.entries(store.accounts).map(([email, creds]) => ({
+            email,
+            tier: creds.tier,
+            expired: isExpired(creds),
+        })),
+    };
+}
 export async function handleAccounts() {
+    const data = getAccountsList();
+    if (isJsonMode()) {
+        if (!data) {
+            outputError("AUTH_REQUIRED", "No accounts", EXIT.AUTH_REQUIRED);
+        }
+        outputSuccess(data);
+        return;
+    }
     console.log();
     console.log(chalk.bold.cyan("ArchByte Accounts"));
     console.log();
-    const store = loadStore();
-    if (!store || Object.keys(store.accounts).length === 0) {
+    if (!data) {
         console.log(chalk.yellow("No accounts. Run `archbyte login` to sign in."));
         return;
     }
-    for (const [email, creds] of Object.entries(store.accounts)) {
-        const isActive = email === store.active;
+    for (const acct of data.accounts) {
+        const isActive = acct.email === data.active;
         const marker = isActive ? chalk.green("*") : " ";
-        const tier = creds.tier === "premium" ? chalk.green("Pro") : "Basic";
-        const expired = isExpired(creds) ? chalk.red(" (expired)") : "";
-        console.log(`  ${marker} ${chalk.bold(email)}  ${tier}${expired}`);
+        const tier = acct.tier === "premium" ? chalk.green("Pro") : "Basic";
+        const expired = acct.expired ? chalk.red(" (expired)") : "";
+        console.log(`  ${marker} ${chalk.bold(acct.email)}  ${tier}${expired}`);
     }
     console.log();
     console.log(chalk.gray("* = active account"));

package/dist/cli/config.js

@@ -3,26 +3,35 @@ import { execSync } from "child_process";
 import chalk from "chalk";
 import { CONFIG_DIR, CONFIG_PATH } from "./constants.js";
 import { maskKey } from "./utils.js";
+import { isJsonMode, outputSuccess, ArchByteError, EXIT } from "./output.js";
 const VALID_PROVIDERS = ["anthropic", "openai", "google", "claude-sdk"];
 export async function handleConfig(options) {
     const [action, key, value] = options.args;
     if (!action || action === "show") {
+        if (isJsonMode()) {
+            const config = loadConfig();
+            const profiles = (config.profiles ?? {});
+            const active = config.provider;
+            outputSuccess({
+                provider: config.provider ?? null,
+                model: active ? profiles[active]?.model ?? config.model ?? null : config.model ?? null,
+                hasApiKey: active ? !!profiles[active]?.apiKey : !!config.apiKey,
+            });
+            return;
+        }
         showConfig();
         return;
     }
     if (action === "set") {
         if (!key || !value) {
-            console.error(chalk.red("Usage: archbyte config set <key> <value>"));
-            console.error(chalk.gray("  Keys: provider, api-key, model"));
-            process.exit(1);
+            throw new ArchByteError("CONFIG_INVALID", "Usage: archbyte config set <key> <value>. Keys: provider, api-key, model", EXIT.CONFIG_INVALID);
         }
         setConfig(key, value);
         return;
     }
     if (action === "get") {
         if (!key) {
-            console.error(chalk.red("Usage: archbyte config get <key>"));
-            process.exit(1);
+            throw new ArchByteError("CONFIG_INVALID", "Usage: archbyte config get <key>", EXIT.CONFIG_INVALID);
         }
         getConfig(key, options.raw);
         return;
@@ -31,12 +40,7 @@ export async function handleConfig(options) {
         console.log(CONFIG_PATH);
         return;
     }
-    console.error(chalk.red(`Unknown action: ${action}`));
-    console.error(chalk.gray("  archbyte config show          show current config"));
-    console.error(chalk.gray("  archbyte config set <k> <v>   set a config value"));
-    console.error(chalk.gray("  archbyte config get <k>       get a config value"));
-    console.error(chalk.gray("  archbyte config path          show config file path"));
-    process.exit(1);
+    throw new ArchByteError("CONFIG_INVALID", `Unknown action: ${action}. Valid: show, set, get, path`, EXIT.CONFIG_INVALID);
 }
 function loadConfig() {
     try {
@@ -114,8 +118,7 @@ function setConfig(key, value) {
     switch (key) {
         case "provider": {
             if (!VALID_PROVIDERS.includes(value)) {
-                console.error(chalk.red(`Invalid provider: ${value}. Must be: ${VALID_PROVIDERS.join(", ")}`));
-                process.exit(1);
+                throw new ArchByteError("CONFIG_INVALID", `Invalid provider: ${value}. Must be: ${VALID_PROVIDERS.join(", ")}`, EXIT.CONFIG_INVALID);
             }
             config.provider = value;
             if (value === "claude-sdk") {
@@ -134,8 +137,7 @@ function setConfig(key, value) {
         case "key": {
             const activeProvider = config.provider;
             if (!activeProvider) {
-                console.error(chalk.red("Set a provider first: archbyte config set provider <name>"));
-                process.exit(1);
+                throw new ArchByteError("CONFIG_MISSING", "Set a provider first: archbyte config set provider <name>", EXIT.CONFIG_MISSING);
             }
             if (!profiles[activeProvider])
                 profiles[activeProvider] = {};
@@ -145,8 +147,7 @@ function setConfig(key, value) {
         case "model": {
             const activeProvider2 = config.provider;
             if (!activeProvider2) {
-                console.error(chalk.red("Set a provider first: archbyte config set provider <name>"));
-                process.exit(1);
+                throw new ArchByteError("CONFIG_MISSING", "Set a provider first: archbyte config set provider <name>", EXIT.CONFIG_MISSING);
             }
             if (!profiles[activeProvider2])
                 profiles[activeProvider2] = {};
@@ -166,9 +167,7 @@ function setConfig(key, value) {
             break;
         }
         default:
-            console.error(chalk.red(`Unknown config key: ${key}`));
-            console.error(chalk.gray("  Valid keys: provider, api-key, model, sessions-path"));
-            process.exit(1);
+            throw new ArchByteError("CONFIG_INVALID", `Unknown config key: ${key}. Valid keys: provider, api-key, model, sessions-path`, EXIT.CONFIG_INVALID);
     }
     saveConfig(config);
     if (key !== "provider") {
@@ -203,8 +202,7 @@ function getConfig(key, raw = false) {
             break;
         }
         default:
-            console.error(chalk.red(`Unknown config key: ${key}`));
-            process.exit(1);
+            throw new ArchByteError("CONFIG_INVALID", `Unknown config key: ${key}`, EXIT.CONFIG_INVALID);
     }
 }
 /**

package/dist/cli/export.d.ts

@@ -3,6 +3,16 @@ interface ExportOptions {
     format?: string;
     output?: string;
 }
+export interface ExportResult {
+    format: string;
+    content: string;
+    outputPath?: string;
+}
+/**
+ * Generate export content as structured data.
+ * Pure function — no console output, no process.exit().
+ */
+export declare function generateExport(options: ExportOptions): Promise<ExportResult>;
 /**
  * Export architecture diagram to Mermaid, Markdown, or JSON format.
  */