archbyte 0.2.8 → 0.3.0

package/dist/agents/runtime/types.js

@@ -7,9 +7,9 @@ export const MODEL_MAP = {
         advanced: "claude-opus-4-6",
     },
     openai: {
-        fast: "gpt-5.2-codex",
+        fast: "gpt-5.2",
         standard: "gpt-5.2",
-        advanced: "o3",
+        advanced: "gpt-5.2",
     },
     google: {
         fast: "gemini-2.5-flash",

package/dist/cli/analyze.js

@@ -5,7 +5,7 @@ import chalk from "chalk";
 import { resolveConfig } from "./config.js";
 import { recordUsage } from "./license-gate.js";
 import { staticResultToSpec, writeSpec, writeMetadata, loadSpec, loadMetadata } from "./yaml-io.js";
-import { getChangedFiles, mapFilesToComponents, shouldRunAgents, isGitAvailable } from "./incremental.js";
+import { getChangedFiles, mapFilesToComponents, shouldRunAgents, isGitAvailable, categorizeChanges, computeNeighbors, getCommitCount } from "./incremental.js";
 import { progressBar } from "./ui.js";
 export async function handleAnalyze(options) {
     const rootDir = options.dir ? path.resolve(options.dir) : process.cwd();
@@ -115,30 +115,63 @@ export async function handleAnalyze(options) {
     const priorSpec = loadSpec(rootDir);
     const priorMeta = loadMetadata(rootDir);
     if (priorSpec && !options.force && isGitAvailable(rootDir) && priorMeta?.lastCommit) {
-        const changedFiles = getChangedFiles(rootDir, priorMeta.lastCommit);
-        if (changedFiles.length === 0) {
-            console.log(chalk.green("No changes detected since last scan. Use --force to re-scan."));
+        // Staleness detection: force full scan after 20+ commits
+        const commitsSinceScan = getCommitCount(rootDir, priorMeta.lastCommit);
+        if (commitsSinceScan >= 20) {
+            console.log(chalk.yellow(`${commitsSinceScan} commits since last scan — forcing full re-scan for accuracy.`));
             console.log();
-            return;
         }
-        const { affected, unmapped } = mapFilesToComponents(changedFiles, priorSpec);
-        if (!shouldRunAgents(affected, unmapped)) {
-            console.log(chalk.green("Only config changes detected. No re-scan needed. Use --force to re-scan."));
+        else {
+            const changedFiles = getChangedFiles(rootDir, priorMeta.lastCommit);
+            if (changedFiles.length === 0) {
+                console.log(chalk.green("No changes detected since last scan. Use --force to re-scan."));
+                console.log();
+                return;
+            }
+            const { affected, unmapped } = mapFilesToComponents(changedFiles, priorSpec);
+            if (!shouldRunAgents(affected, unmapped)) {
+                console.log(chalk.green("Only config changes detected. No re-scan needed. Use --force to re-scan."));
+                console.log();
+                return;
+            }
+            const categories = categorizeChanges(changedFiles);
+            const neighborComponents = computeNeighbors(affected, priorSpec);
+            incrementalContext = {
+                existingSpec: priorSpec,
+                changedFiles,
+                affectedComponents: [...affected],
+                categories,
+                neighborComponents,
+                hasUnmappedFiles: unmapped.length > 0,
+            };
+            console.log(chalk.bold("Incremental scan:"));
+            console.log(chalk.gray(`  Changed files: ${changedFiles.length}`));
+            console.log(chalk.gray(`  Affected components: ${affected.size > 0 ? [...affected].join(", ") : "none (new files)"}`));
+            if (neighborComponents.length > 0) {
+                console.log(chalk.gray(`  Neighbor components: ${neighborComponents.join(", ")}`));
+            }
+            if (unmapped.length > 0) {
+                console.log(chalk.gray(`  Unmapped files: ${unmapped.length} (potential new components — all agents will run)`));
+            }
+            // Summarize categorized changes
+            const catSummary = [];
+            if (categories.entryPoints.length)
+                catSummary.push(`${categories.entryPoints.length} entry`);
+            if (categories.routeFiles.length)
+                catSummary.push(`${categories.routeFiles.length} route`);
+            if (categories.infraFiles.length)
+                catSummary.push(`${categories.infraFiles.length} infra`);
+            if (categories.configFiles.length)
+                catSummary.push(`${categories.configFiles.length} config`);
+            if (categories.eventFiles.length)
+                catSummary.push(`${categories.eventFiles.length} event`);
+            if (categories.sourceFiles.length)
+                catSummary.push(`${categories.sourceFiles.length} source`);
+            if (catSummary.length > 0) {
+                console.log(chalk.gray(`  Categories: ${catSummary.join(", ")}`));
+            }
             console.log();
-            return;
         }
-        incrementalContext = {
-            existingSpec: priorSpec,
-            changedFiles,
-            affectedComponents: [...affected],
-        };
-        console.log(chalk.bold("Incremental scan:"));
-        console.log(chalk.gray(`  Changed files: ${changedFiles.length}`));
-        console.log(chalk.gray(`  Affected components: ${affected.size > 0 ? [...affected].join(", ") : "none (new files)"}`));
-        if (unmapped.length > 0) {
-            console.log(chalk.gray(`  Unmapped files: ${unmapped.length} (potential new components)`));
-        }
-        console.log();
     }
     // 4. Run static context collection → LLM pipeline
     const progress = progressBar(7);
@@ -235,13 +268,21 @@ export async function handleAnalyze(options) {
     if (result.tokenUsage) {
         meta.tokenUsage = { input: result.tokenUsage.input, output: result.tokenUsage.output };
     }
+    if (incrementalContext) {
+        meta.incrementalMode = true;
+        meta.changedFiles = incrementalContext.changedFiles.length;
+        meta.affectedComponents = incrementalContext.affectedComponents;
+    }
+    if (result.skippedAgents && result.skippedAgents.length > 0) {
+        meta.skippedAgents = result.skippedAgents;
+    }
     writeAnalysis(rootDir, analysis);
     writeAnalysisStatus(rootDir, "success");
     // Dual-write: archbyte.yaml + metadata.json
     const existingSpec = loadSpec(rootDir);
     const spec = staticResultToSpec(result, rootDir, existingSpec?.rules);
     writeSpec(rootDir, spec);
-    writeScanMetadata(rootDir, duration, "pipeline", ctx.fileTree.totalFiles, result.tokenUsage);
+    writeScanMetadata(rootDir, duration, "pipeline", ctx.fileTree.totalFiles, result.tokenUsage, incrementalContext ? true : undefined, result.skippedAgents);
     progress.update(6, "Generating diagram...");
     await autoGenerate(rootDir, options);
     progress.done("Analysis complete");
@@ -283,7 +324,7 @@ function getGitCommit() {
         return undefined;
     }
 }
-function writeScanMetadata(rootDir, durationMs, mode, filesScanned, tokenUsage) {
+function writeScanMetadata(rootDir, durationMs, mode, filesScanned, tokenUsage, incrementalMode, skippedAgents) {
     const meta = {
         analyzedAt: new Date().toISOString(),
         durationMs,
@@ -294,6 +335,10 @@ function writeScanMetadata(rootDir, durationMs, mode, filesScanned, tokenUsage)
         meta.filesScanned = filesScanned;
     if (tokenUsage)
         meta.tokenUsage = tokenUsage;
+    if (incrementalMode)
+        meta.incrementalMode = true;
+    if (skippedAgents && skippedAgents.length > 0)
+        meta.skippedAgents = skippedAgents;
     writeMetadata(rootDir, meta);
 }
 async function autoGenerate(rootDir, options) {

package/dist/cli/auth.js

@@ -46,8 +46,8 @@ export async function handleLogin(provider) {
         console.log(chalk.green(`Logged in as ${chalk.bold(credentials.email)} (${credentials.tier} tier)`));
         console.log(chalk.gray(`Credentials saved to ${CREDENTIALS_PATH}`));
         console.log();
-        console.log(chalk.gray("Your credentials and API keys are stored locally on your machine."));
-        console.log(chalk.gray("ArchByte never transmits or stores your model provider keys."));
+        console.log(chalk.gray("Login credentials are stored in ~/.archbyte/ (global) — never inside your project."));
+        console.log(chalk.gray("Your API keys and credentials never leave this machine."));
     }
     catch (err) {
         console.error(chalk.red(`Login failed: ${err instanceof Error ? err.message : "Unknown error"}`));

package/dist/cli/incremental.d.ts

@@ -21,3 +21,24 @@ export declare function shouldRunAgents(affected: Set<string>, unmapped: string[
  * Check if git is available and this is a git repo.
  */
 export declare function isGitAvailable(rootDir: string): boolean;
+/**
+ * Categorize changed files by domain relevance for agent filtering.
+ */
+export interface CategorizedChanges {
+    entryPoints: string[];
+    routeFiles: string[];
+    configFiles: string[];
+    infraFiles: string[];
+    eventFiles: string[];
+    sourceFiles: string[];
+}
+export declare function categorizeChanges(changedFiles: string[]): CategorizedChanges;
+/**
+ * Find 1-layer neighbor components: components connected to affected components.
+ * Ensures cross-component connections aren't missed during incremental scans.
+ */
+export declare function computeNeighbors(affectedComponents: Set<string>, spec: ArchbyteSpec): string[];
+/**
+ * Count commits since a given commit hash. Used for staleness detection.
+ */
+export declare function getCommitCount(rootDir: string, sinceCommit: string): number;

package/dist/cli/incremental.js

@@ -9,7 +9,7 @@ export function getChangedFiles(rootDir, sinceCommit) {
     try {
         const files = [];
         if (sinceCommit) {
-            // Changed files since last scan commit
+            // Changed files since last scan commit (committed changes)
             const diff = execSync(`git diff --name-only ${sinceCommit}..HEAD`, {
                 cwd: rootDir,
                 encoding: "utf-8",
@@ -19,6 +19,30 @@ export function getChangedFiles(rootDir, sinceCommit) {
                 files.push(...diff.split("\n").filter(Boolean));
             }
         }
+        // Include unstaged modifications to tracked files
+        const modified = execSync("git diff --name-only", {
+            cwd: rootDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        if (modified) {
+            for (const f of modified.split("\n").filter(Boolean)) {
+                if (!files.includes(f))
+                    files.push(f);
+            }
+        }
+        // Include staged but uncommitted changes
+        const staged = execSync("git diff --name-only --cached", {
+            cwd: rootDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        if (staged) {
+            for (const f of staged.split("\n").filter(Boolean)) {
+                if (!files.includes(f))
+                    files.push(f);
+            }
+        }
         // Also include untracked files
         const untracked = execSync("git ls-files --others --exclude-standard", {
             cwd: rootDir,
@@ -100,6 +124,72 @@ export function isGitAvailable(rootDir) {
         return false;
     }
 }
+export function categorizeChanges(changedFiles) {
+    const categories = {
+        entryPoints: [],
+        routeFiles: [],
+        configFiles: [],
+        infraFiles: [],
+        eventFiles: [],
+        sourceFiles: [],
+    };
+    for (const file of changedFiles) {
+        const name = file.split("/").pop() ?? "";
+        const lower = file.toLowerCase();
+        if (isInfraFile(lower, name)) {
+            categories.infraFiles.push(file);
+        }
+        else if (isConfigFile(name)) {
+            categories.configFiles.push(file);
+        }
+        else if (isEntryPoint(name)) {
+            categories.entryPoints.push(file);
+        }
+        else if (isRouteFile(lower, name)) {
+            categories.routeFiles.push(file);
+        }
+        else if (isEventFile(lower, name)) {
+            categories.eventFiles.push(file);
+        }
+        else if (isSourceFile(name)) {
+            categories.sourceFiles.push(file);
+        }
+        // else: non-code file (docs, images, etc.) — ignored
+    }
+    return categories;
+}
+/**
+ * Find 1-layer neighbor components: components connected to affected components.
+ * Ensures cross-component connections aren't missed during incremental scans.
+ */
+export function computeNeighbors(affectedComponents, spec) {
+    const neighbors = new Set();
+    for (const conn of spec.connections) {
+        if (affectedComponents.has(conn.from) && !affectedComponents.has(conn.to)) {
+            neighbors.add(conn.to);
+        }
+        if (affectedComponents.has(conn.to) && !affectedComponents.has(conn.from)) {
+            neighbors.add(conn.from);
+        }
+    }
+    return [...neighbors];
+}
+/**
+ * Count commits since a given commit hash. Used for staleness detection.
+ */
+export function getCommitCount(rootDir, sinceCommit) {
+    try {
+        const output = execSync(`git rev-list --count ${sinceCommit}..HEAD`, {
+            cwd: rootDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        return parseInt(output, 10) || 0;
+    }
+    catch {
+        return 0;
+    }
+}
 // Helpers
 function normalizePath(p) {
     // Remove trailing slashes, normalize
@@ -109,3 +199,29 @@ function isConfigOnly(filePath) {
     const name = filePath.split("/").pop() ?? "";
     return /^(\.gitignore|\.eslintrc|\.prettierrc|tsconfig|package\.json|package-lock|yarn\.lock|pnpm-lock|archbyte\.yaml|README|LICENSE|CHANGELOG|\.env)/i.test(name);
 }
+function isInfraFile(lower, name) {
+    return /dockerfile|docker-compose|compose\.ya?ml|\.dockerignore/i.test(name) ||
+        lower.includes("k8s/") || lower.includes("kubernetes/") ||
+        lower.includes("terraform/") || lower.includes("helm/") ||
+        /\.(tf|hcl)$/.test(name);
+}
+function isConfigFile(name) {
+    return /^(package\.json|tsconfig|\.env|\.eslintrc|\.prettierrc|pyproject\.toml|Cargo\.toml|go\.mod|archbyte\.yaml)/i.test(name);
+}
+function isEntryPoint(name) {
+    return /^(index|main|app|server|entry)\.(ts|js|tsx|jsx|py|go|rs)$/i.test(name);
+}
+function isRouteFile(lower, name) {
+    return lower.includes("route") || lower.includes("router") ||
+        lower.includes("controller") || lower.includes("handler") ||
+        /\.(routes|controller|handler)\.(ts|js)$/i.test(name);
+}
+function isEventFile(lower, name) {
+    return lower.includes("event") || lower.includes("listener") ||
+        lower.includes("subscriber") || lower.includes("consumer") ||
+        lower.includes("producer") || lower.includes("queue") ||
+        /\.(events?|listener|subscriber|consumer|producer)\.(ts|js)$/i.test(name);
+}
+function isSourceFile(name) {
+    return /\.(ts|tsx|js|jsx|py|go|rs|java|kt|rb|cs|php|swift|dart)$/i.test(name);
+}

package/dist/cli/serve.js

@@ -2,12 +2,51 @@ import * as path from "path";
 import * as fs from "fs";
 import chalk from "chalk";
 import { DEFAULT_PORT } from "./constants.js";
+import { select } from "./ui.js";
+function askPort(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 if (ch >= "0" && ch <= "9") {
+                    input += ch;
+                    process.stdout.write(ch);
+                }
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
 /**
  * Start the ArchByte UI server
  */
 export async function handleServe(options) {
     const rootDir = process.cwd();
-    const port = options.port || DEFAULT_PORT;
+    let port = options.port || DEFAULT_PORT;
     const diagramPath = options.diagram
         ? path.resolve(rootDir, options.diagram)
         : path.join(rootDir, ".archbyte", "architecture.json");
@@ -25,7 +64,6 @@ export async function handleServe(options) {
     }
     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();
     // Check if diagram exists
     if (!fs.existsSync(diagramPath)) {
@@ -34,26 +72,66 @@ export async function handleServe(options) {
         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 to start, handle port conflicts interactively
+    while (true) {
         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(chalk.green(`UI: http://localhost:${port}`));
             console.log();
             await startServer({
                 name: projectName,
                 diagramPath,
                 workspaceRoot: rootDir,
-                port: tryPort,
+                port,
             });
             return;
         }
         catch (error) {
             if (error instanceof Error && error.code === "EADDRINUSE") {
-                continue;
+                console.log(chalk.yellow(`  Port ${port} is already in use.`));
+                console.log();
+                if (!process.stdin.isTTY) {
+                    // Non-interactive — just try next port
+                    port++;
+                    continue;
+                }
+                const nextPort = port + 1;
+                const choice = await select("  What would you like to do?", [
+                    `Use next available port (${nextPort})`,
+                    "Enter a custom port",
+                    "Kill the process on this port and retry",
+                    "Exit",
+                ]);
+                if (choice === 0) {
+                    port = nextPort;
+                    continue;
+                }
+                else if (choice === 1) {
+                    const input = await askPort(chalk.bold("  Port: "));
+                    const parsed = parseInt(input, 10);
+                    if (!parsed || parsed < 1 || parsed > 65535) {
+                        console.log(chalk.red("  Invalid port number."));
+                        continue;
+                    }
+                    port = parsed;
+                    continue;
+                }
+                else if (choice === 2) {
+                    try {
+                        const { execSync } = await import("child_process");
+                        execSync(`lsof -ti:${port} | xargs kill -9`, { stdio: "ignore" });
+                        console.log(chalk.green(`  Killed process on port ${port}.`));
+                        // Small delay for OS to release the port
+                        await new Promise((r) => setTimeout(r, 500));
+                        continue;
+                    }
+                    catch {
+                        console.log(chalk.red(`  Could not kill process on port ${port}. Try manually: lsof -ti:${port} | xargs kill -9`));
+                        continue;
+                    }
+                }
+                else {
+                    process.exit(0);
+                }
             }
             if (error instanceof Error) {
                 console.error(chalk.red(`Error: ${error.message}`));
@@ -61,6 +139,4 @@ export async function handleServe(options) {
             process.exit(1);
         }
     }
-    console.error(chalk.red(`All ports ${port}-${port + maxRetries - 1} are in use.`));
-    process.exit(1);
 }