archbyte 0.2.2 → 0.2.3

package/dist/cli/constants.js

@@ -0,0 +1,20 @@
+// Shared constants for the ArchByte CLI.
+// Single source of truth for URLs, ports, paths, and timeouts.
+import * as path from "path";
+// ─── API ───
+export const API_BASE = process.env.ARCHBYTE_API_URL ?? "https://api.heartbyte.io";
+export const SITE_URL = "https://archbyte.heartbyte.io";
+// ─── Ports ───
+export const DEFAULT_PORT = 3847;
+export const CLI_CALLBACK_PORT = 19274;
+// ─── Paths ───
+export const CONFIG_DIR = path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".archbyte");
+export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+export const CREDENTIALS_PATH = path.join(CONFIG_DIR, "credentials.json");
+/** Project-local .archbyte directory name */
+export const PROJECT_DIR = ".archbyte";
+// ─── Timeouts ───
+/** Timeout for non-critical network checks (license, version, gate) */
+export const NETWORK_TIMEOUT_MS = 5000;
+/** Timeout for OAuth callback server */
+export const OAUTH_TIMEOUT_MS = 60_000;

package/dist/cli/gate.js

@@ -1,5 +1,5 @@
 import { loadCredentials, cacheVerifiedTier, resetOfflineActions, checkOfflineAction } from "./auth.js";
-const API_BASE = process.env.ARCHBYTE_API_URL ?? "https://api.heartbyte.io";
+import { API_BASE, NETWORK_TIMEOUT_MS } from "./constants.js";
 /**
  * Auth gate command for Claude Code integration.
  *
@@ -48,7 +48,7 @@ async function checkGate(action) {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({ action }),
-            signal: AbortSignal.timeout(5000),
+            signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
         });
         if (res.status === 401) {
             const result = {
@@ -120,7 +120,7 @@ async function recordScan() {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({}),
-            signal: AbortSignal.timeout(5000),
+            signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
         });
         console.log(JSON.stringify({ recorded: true }));
     }

package/dist/cli/generate.js

@@ -4,6 +4,7 @@ import chalk from "chalk";
 import { generateArchitecture } from "../server/src/generator/index.js";
 import { loadSpec, specToAnalysis } from "./yaml-io.js";
 import { spinner } from "./ui.js";
+import { DEFAULT_PORT } from "./constants.js";
 /**
  * Generate excalidraw diagram from analysis JSON
  */
@@ -233,7 +234,7 @@ export async function handleGenerate(options) {
         console.log();
         console.log(chalk.bold("Next steps:"));
         console.log(chalk.gray(`  1. Run ${chalk.cyan("archbyte serve")} to start the visualization server`));
-        console.log(chalk.gray(`  2. Open ${chalk.cyan("http://localhost:3847")} to view and adjust the diagram`));
+        console.log(chalk.gray(`  2. Open ${chalk.cyan(`http://localhost:${DEFAULT_PORT}`)} to view and adjust the diagram`));
         console.log();
     }
     catch (error) {

package/dist/cli/license-gate.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { loadCredentials, cacheVerifiedTier, resetOfflineActions, checkOfflineAction } from "./auth.js";
-const API_BASE = process.env.ARCHBYTE_API_URL ?? "https://api.heartbyte.io";
+import { API_BASE, NETWORK_TIMEOUT_MS } from "./constants.js";
 /**
  * Pre-flight license check. Must be called before scan/analyze/generate.
  *
@@ -44,7 +44,7 @@ export async function requireLicense(action) {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({ action }),
-            signal: AbortSignal.timeout(5000),
+            signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
         });
         if (res.status === 401) {
             console.error();
@@ -112,7 +112,7 @@ export async function recordUsage(meta) {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify(meta),
-            signal: AbortSignal.timeout(5000),
+            signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
         });
     }
     catch {

package/dist/cli/run.d.ts

@@ -7,6 +7,7 @@ interface RunOptions {
     verbose?: boolean;
     force?: boolean;
     dryRun?: boolean;
+    dir?: string;
 }
 export declare function handleRun(options: RunOptions): Promise<void>;
 export {};

package/dist/cli/run.js

@@ -1,11 +1,8 @@
-import chalk from "chalk";
 import { handleAnalyze } from "./analyze.js";
 import { handleServe } from "./serve.js";
+import { DEFAULT_PORT } from "./constants.js";
 export async function handleRun(options) {
-    const port = options.port || 3847;
-    console.log();
-    console.log(chalk.bold.cyan("  ArchByte Run"));
-    console.log();
+    const port = options.port || DEFAULT_PORT;
     // 1. Analyze (includes auto-generate)
     await handleAnalyze({
         verbose: options.verbose,
@@ -15,11 +12,10 @@ export async function handleRun(options) {
         apiKey: options.apiKey,
         force: options.force,
         dryRun: options.dryRun,
+        dir: options.dir,
     });
     if (options.dryRun)
         return;
     // 2. Serve the UI
-    console.log(chalk.bold.cyan("  Starting UI..."));
-    console.log();
     await handleServe({ port });
 }

package/dist/cli/serve.js

@@ -1,12 +1,13 @@
 import * as path from "path";
 import * as fs from "fs";
 import chalk from "chalk";
+import { DEFAULT_PORT } from "./constants.js";
 /**
  * Start the ArchByte UI server
  */
 export async function handleServe(options) {
     const rootDir = process.cwd();
-    const port = options.port || 3847;
+    const port = options.port || DEFAULT_PORT;
     const diagramPath = options.diagram
         ? path.resolve(rootDir, options.diagram)
         : path.join(rootDir, ".archbyte", "architecture.json");
@@ -22,7 +23,7 @@ export async function handleServe(options) {
             // ignore
         }
     }
-    console.log(chalk.cyan(`🏗️  ArchByte - ${projectName}`));
+    console.log(chalk.cyan(`🏗️  ArchByte - See what agents build. As they build it.`));
     console.log(chalk.gray(`Diagram: ${path.relative(rootDir, diagramPath)}`));
     console.log(chalk.gray(`Port: ${port}`));
     console.log();

package/dist/cli/setup.js

@@ -5,16 +5,33 @@ import chalk from "chalk";
 import { resolveModel } from "../agents/runtime/types.js";
 import { createProvider } from "../agents/providers/router.js";
 import { select, spinner, confirm } from "./ui.js";
+import { CONFIG_DIR, CONFIG_PATH } from "./constants.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: "anthropic", label: "Anthropic", hint: "Claude Sonnet / Opus" },
+    { name: "openai", label: "OpenAI", hint: "Codex / GPT-5.2" },
     { name: "google", label: "Google", hint: "Gemini Flash / Pro" },
-    { name: "ollama", label: "Ollama", hint: "Local models (no key needed)" },
 ];
+const PROVIDER_MODELS = {
+    anthropic: [
+        { id: "", label: "Default (recommended)", hint: "Haiku for fast agents, Sonnet for connections" },
+        { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5", hint: "Fastest, cheapest" },
+        { id: "claude-sonnet-4-5-20250929", label: "Claude Sonnet 4.5", hint: "Balanced, great quality" },
+        { id: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "Most capable" },
+    ],
+    openai: [
+        { id: "", label: "Default (recommended)", hint: "Codex for fast agents, GPT-5.2 for connections" },
+        { id: "gpt-5.2-codex", label: "GPT-5.2 Codex", hint: "Fast, coding-optimized" },
+        { id: "gpt-5.2", label: "GPT-5.2", hint: "General purpose, thinking model" },
+        { id: "o3", label: "o3", hint: "Reasoning model" },
+    ],
+    google: [
+        { id: "", label: "Default (recommended)", hint: "Flash for fast agents, Pro for connections" },
+        { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash", hint: "Fastest, cheapest" },
+        { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro", hint: "Most capable" },
+    ],
+};
 function loadConfig() {
     try {
         if (fs.existsSync(CONFIG_PATH)) {
@@ -75,40 +92,8 @@ function askHidden(prompt) {
         stdin.on("data", onData);
     });
 }
-async function fetchOllamaModels(baseUrl) {
+async function validateProviderSilent(providerName, apiKey) {
     try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 5000);
-        const res = await fetch(`${baseUrl}/api/tags`, { signal: controller.signal });
-        clearTimeout(timeout);
-        if (!res.ok)
-            return [];
-        const data = await res.json();
-        return (data.models ?? []).map((m) => m.name);
-    }
-    catch {
-        return [];
-    }
-}
-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;
-                // Model listing happens in setup flow, not here
-                return true;
-            }
-            catch {
-                clearTimeout(timeout);
-                return false;
-            }
-        }
         const provider = createProvider({ provider: providerName, apiKey });
         const model = resolveModel(providerName, "fast");
         await provider.chat({
@@ -123,61 +108,113 @@ async function validateProviderSilent(providerName, apiKey, ollamaBaseUrl) {
         return false;
     }
 }
+function getProfiles(config) {
+    return config.profiles ?? {};
+}
 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)}`));
+    const profiles = getProfiles(config);
+    // Migrate legacy flat config → profiles
+    if (!config.profiles && config.provider && config.apiKey) {
+        const legacy = config.provider;
+        const validNames = PROVIDERS.map((p) => p.name);
+        if (validNames.includes(legacy)) {
+            // Known provider — migrate to profile
+            profiles[legacy] = { apiKey: config.apiKey };
+            if (config.model)
+                profiles[legacy].model = config.model;
+            config.profiles = profiles;
+        }
+        // Clean up legacy flat keys regardless
+        delete config.apiKey;
+        delete config.model;
+        delete config.ollamaBaseUrl;
+        if (!validNames.includes(legacy)) {
+            delete config.provider;
+        }
+    }
+    // Show current config + configured profiles
+    const configured = Object.keys(profiles).filter((p) => profiles[p]?.apiKey);
+    if (configured.length > 0) {
+        console.log(chalk.gray(`  Active provider: ${config.provider ?? "none"}`));
+        for (const p of configured) {
+            const active = p === config.provider ? chalk.green(" (active)") : "";
+            const model = profiles[p].model ? chalk.gray(` model: ${profiles[p].model}`) : "";
+            console.log(chalk.gray(`  ${p}: ${maskKey(profiles[p].apiKey)}${model}${active}`));
         }
         console.log();
     }
-    // Step 1: Choose provider with arrow-key selection
+    // Step 1: Choose provider
     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 active = config.provider === p.name ? chalk.green(" (active)") : "";
+        const hasKey = profiles[p.name]?.apiKey ? chalk.cyan(" ✓ configured") : "";
+        return `${p.label} ${chalk.gray("— " + p.hint)}${hasKey}${active}`;
     }));
     const provider = PROVIDERS[idx].name;
     config.provider = provider;
     const selected = PROVIDERS[idx];
     console.log(chalk.green(`\n  ✓ Provider: ${selected.label}`));
-    // Step 2: API key / model selection
-    if (provider === "ollama") {
-        config.ollamaBaseUrl = config.ollamaBaseUrl ?? "http://localhost:11434";
-        console.log(chalk.gray(`  Ollama URL: ${config.ollamaBaseUrl}`));
-        // Let user pick from installed models
-        const models = await fetchOllamaModels(config.ollamaBaseUrl);
-        if (models.length > 0) {
-            const modelIdx = await select("\n  Choose a model:", models.map((m) => m));
-            config.model = models[modelIdx];
-            console.log(chalk.green(`  ✓ Model: ${config.model}`));
+    // Step 2: API key (show existing if profile exists)
+    const existing = profiles[provider];
+    let apiKey;
+    if (existing?.apiKey) {
+        console.log(chalk.gray(`\n  Existing key: ${maskKey(existing.apiKey)}`));
+        const keepIdx = await select("  Update API key?", [
+            `Keep existing ${chalk.gray("— " + maskKey(existing.apiKey))}`,
+            "Enter new key",
+        ]);
+        if (keepIdx === 0) {
+            apiKey = existing.apiKey;
+            console.log(chalk.green(`  ✓ API key: ${maskKey(apiKey)} (kept)`));
         }
         else {
-            console.log(chalk.yellow(`  Warning: no models installed.`));
-            console.log(chalk.gray(`  Run: ollama pull <model-name>`));
+            console.log();
+            apiKey = await askHidden(chalk.bold("  API key: "));
+            if (!apiKey) {
+                console.log(chalk.red("  No API key entered. Setup cancelled."));
+                process.exit(1);
+            }
+            console.log(chalk.green(`  ✓ API key: ${maskKey(apiKey)}`));
         }
     }
     else {
-        // Clear Ollama model override — model names are provider-specific
-        if (config.model) {
-            delete config.model;
-        }
         console.log();
-        const apiKey = await askHidden(chalk.bold("  API key: "));
+        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)}`));
     }
+    // Save to profile
+    if (!profiles[provider])
+        profiles[provider] = { apiKey: "" };
+    profiles[provider].apiKey = apiKey;
+    // Step 3: Model selection
+    const models = PROVIDER_MODELS[provider];
+    if (models) {
+        const currentModel = profiles[provider].model;
+        const modelIdx = await select("\n  Choose a model:", models.map((m) => {
+            const current = currentModel === m.id && m.id ? chalk.green(" (current)") : "";
+            return `${m.label} ${chalk.gray("— " + m.hint)}${current}`;
+        }));
+        const chosen = models[modelIdx];
+        if (chosen.id) {
+            profiles[provider].model = chosen.id;
+            console.log(chalk.green(`  ✓ Model: ${chosen.label}`));
+        }
+        else {
+            delete profiles[provider].model;
+            console.log(chalk.green(`  ✓ Model: Default (auto per agent tier)`));
+        }
+    }
+    config.profiles = profiles;
     // Validate provider with spinner
     const s = spinner("Validating credentials");
-    let isValid = await validateProviderSilent(provider, config.apiKey ?? "", config.ollamaBaseUrl);
+    let isValid = await validateProviderSilent(provider, apiKey);
     s.stop(isValid ? "valid" : "invalid", isValid ? "green" : "red");
     // Retry loop on failure
     if (!isValid) {
@@ -186,21 +223,23 @@ export async function handleSetup() {
             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 newKey = await askHidden(chalk.bold("  API key: "));
+            if (newKey) {
+                profiles[provider].apiKey = newKey;
+                console.log(chalk.green(`  ✓ API key: ${maskKey(newKey)}`));
             }
             const s2 = spinner("Validating credentials");
-            isValid = await validateProviderSilent(provider, config.apiKey ?? "", config.ollamaBaseUrl);
+            isValid = await validateProviderSilent(provider, profiles[provider].apiKey);
             s2.stop(isValid ? "valid" : "invalid", isValid ? "green" : "red");
         }
         if (!isValid) {
             console.log(chalk.yellow("  Warning: credentials unverified. Saving anyway."));
         }
     }
+    // Clean up legacy top-level keys
+    delete config.apiKey;
+    delete config.model;
+    delete config.ollamaBaseUrl;
     // Save config
     saveConfig(config);
     console.log(chalk.gray(`\n  Config saved to ${CONFIG_PATH}`));
@@ -236,5 +275,6 @@ export async function handleSetup() {
     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(chalk.gray("        Run from your project root, or use ") + chalk.cyan("archbyte run -d /path/to/project"));
     console.log();
 }

package/dist/cli/version.d.ts

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

package/dist/cli/version.js

@@ -0,0 +1,84 @@
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import { execSync } from "child_process";
+import { NETWORK_TIMEOUT_MS } from "./constants.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function getLocalVersion() {
+    const pkgPath = path.resolve(__dirname, "../../package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    return pkg.version;
+}
+export async function handleVersion() {
+    const version = getLocalVersion();
+    console.log();
+    console.log(chalk.bold.cyan("ArchByte") + chalk.gray(` v${version}`));
+    console.log();
+    console.log(`  ${chalk.bold("version")}:  ${version}`);
+    console.log(`  ${chalk.bold("node")}:     ${process.versions.node}`);
+    console.log(`  ${chalk.bold("platform")}: ${process.platform} ${process.arch}`);
+    // Show install path
+    try {
+        const which = execSync("which archbyte", { encoding: "utf-8" }).trim();
+        console.log(`  ${chalk.bold("binary")}:   ${which}`);
+    }
+    catch {
+        // not globally installed or `which` not available
+    }
+    console.log();
+}
+async function fetchLatestVersion() {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), NETWORK_TIMEOUT_MS);
+        const res = await fetch("https://registry.npmjs.org/archbyte/latest", {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleUpdate() {
+    const current = getLocalVersion();
+    console.log();
+    console.log(chalk.bold.cyan("ArchByte Update"));
+    console.log(chalk.gray(`  Current version: ${current}`));
+    console.log(chalk.gray("  Checking for updates..."));
+    const latest = await fetchLatestVersion();
+    if (!latest) {
+        console.log(chalk.yellow("  Could not reach npm registry. Update manually:"));
+        console.log(chalk.cyan("  npm install -g archbyte@latest"));
+        console.log();
+        return;
+    }
+    if (latest === current) {
+        console.log(chalk.green(`  You're on the latest version (${current}).`));
+        console.log();
+        return;
+    }
+    console.log(chalk.yellow(`  New version available: ${current} → ${chalk.bold(latest)}`));
+    console.log();
+    // Run the update
+    console.log(chalk.gray("  Updating..."));
+    try {
+        execSync("npm install -g archbyte@latest", {
+            stdio: "inherit",
+        });
+        console.log();
+        console.log(chalk.green(`  Updated to v${latest}`));
+    }
+    catch {
+        console.log();
+        console.log(chalk.red("  Update failed. Try manually:"));
+        console.log(chalk.cyan("  npm install -g archbyte@latest"));
+    }
+    console.log();
+}

package/dist/server/src/index.js

@@ -135,6 +135,46 @@ function createHttpServer() {
             res.end(JSON.stringify(currentArchitecture || { nodes: [], edges: [] }));
             return;
         }
+        // API: Update node positions (save layout changes)
+        if (url === "/api/update-positions" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const { updates } = JSON.parse(body);
+                    if (!updates || !Array.isArray(updates)) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Missing updates array" }));
+                        return;
+                    }
+                    // Read current architecture file
+                    const content = await readFile(config.diagramPath, "utf-8");
+                    const arch = JSON.parse(content);
+                    // Apply position/dimension updates
+                    for (const update of updates) {
+                        const node = arch.nodes.find((n) => n.id === update.id);
+                        if (node) {
+                            node.x = update.x;
+                            node.y = update.y;
+                            node.width = update.width;
+                            node.height = update.height;
+                        }
+                    }
+                    // Mark layout as user-saved so UI uses these positions
+                    arch.layoutSaved = true;
+                    // Write back
+                    await writeFile(config.diagramPath, JSON.stringify(arch, null, 2), "utf-8");
+                    currentArchitecture = arch;
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, updated: updates.length }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Failed to save positions" }));
+                }
+            });
+            return;
+        }
         // API: Health
         if (url === "/health") {
             res.writeHead(200, { "Content-Type": "application/json" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archbyte",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "ArchByte - See what agents build. As they build it.",
   "type": "module",
   "bin": {