archbyte 0.3.5 → 0.4.1

package/dist/agents/runtime/types.js

@@ -2,10 +2,15 @@
 // === Model Routing ===
 export const MODEL_MAP = {
     anthropic: {
-        fast: "claude-haiku-4-5-20251001",
+        fast: "claude-sonnet-4-5-20250929",
         standard: "claude-sonnet-4-5-20250929",
         advanced: "claude-opus-4-6",
     },
+    "claude-sdk": {
+        fast: "sonnet",
+        standard: "sonnet",
+        advanced: "opus",
+    },
     openai: {
         fast: "gpt-5.2",
         standard: "gpt-5.2",

package/dist/agents/static/component-detector.js

@@ -74,15 +74,21 @@ export async function detectComponents(tk, structure) {
     // Strategy 1: Monorepo workspaces
     if (structure.isMonorepo) {
         const components = await detectFromWorkspaces(tk, structure);
-        if (components.length > 0)
+        if (components.length > 0) {
+            await enrichWithFileMetrics(tk, components);
             return { components };
+        }
     }
     // Strategy 2: Scan ALL top-level directories for build configs + conventional names
     const components = await detectAllComponents(tk, structure);
-    if (components.length > 0)
+    if (components.length > 0) {
+        await enrichWithFileMetrics(tk, components);
         return { components };
+    }
     // Strategy 3: Single app fallback
-    return { components: [buildSingleAppComponent(structure)] };
+    const fallback = [buildSingleAppComponent(structure)];
+    await enrichWithFileMetrics(tk, fallback);
+    return { components: fallback };
 }
 async function detectFromWorkspaces(tk, structure) {
     // Collect workspace patterns from package.json OR pnpm-workspace.yaml
@@ -383,6 +389,32 @@ function extractTechStack(pkg) {
 function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
+const CODE_EXTENSIONS = /\.(ts|tsx|js|jsx|py|go|rs|java|kt|rb|cs|php|swift|dart)$/i;
+async function enrichWithFileMetrics(tk, components) {
+    await Promise.all(components.map(async (comp) => {
+        if (comp.path === ".")
+            return;
+        try {
+            const allFiles = await tk.globFiles(`**/*`, comp.path);
+            const codeFiles = allFiles.filter((f) => CODE_EXTENSIONS.test(f));
+            let totalLines = 0;
+            const filesToCount = codeFiles.slice(0, 150);
+            await Promise.all(filesToCount.map(async (file) => {
+                const content = await tk.readFileSafe(file);
+                if (content)
+                    totalLines += content.split("\n").length;
+            }));
+            comp.fileMetrics = {
+                fileCount: allFiles.length,
+                totalLines,
+                codeFileCount: codeFiles.length,
+            };
+        }
+        catch {
+            // skip
+        }
+    }));
+}
 function extractFirstParagraph(readme) {
     const lines = readme.split("\n");
     let capturing = false;

package/dist/agents/static/connection-mapper.d.ts

@@ -1,3 +1,3 @@
 import type { ConnectionResult, StaticComponent, InfraResult, EventResult } from "./types.js";
 import type { StaticToolkit } from "./utils.js";
-export declare function mapConnections(tk: StaticToolkit, components: StaticComponent[], infra: InfraResult, events: EventResult): Promise<ConnectionResult>;
+export declare function mapConnections(tk: StaticToolkit, components: StaticComponent[], infra: InfraResult, events: EventResult, importMap?: Record<string, string[]>): Promise<ConnectionResult>;

package/dist/agents/static/connection-mapper.js

@@ -2,7 +2,7 @@
 // Maps connections between components via imports, Docker, K8s, env vars, known SDKs
 // Only deterministic matches — ambiguous mappings are left as gaps for the LLM
 import { slugify } from "./utils.js";
-export async function mapConnections(tk, components, infra, events) {
+export async function mapConnections(tk, components, infra, events, importMap) {
     const connections = [];
     const componentIds = new Set(components.map((c) => c.id));
     // Run all detection methods in parallel
@@ -10,6 +10,7 @@ export async function mapConnections(tk, components, infra, events) {
         detectDockerDependencies(infra, components, connections),
         detectK8sIngress(infra, components, connections),
         detectImportConnections(tk, components, connections),
+        detectImportMapConnections(components, connections, importMap ?? {}),
         detectDatabaseConnections(tk, components, connections),
         detectServerServesUI(tk, components, connections),
         detectKnownSDKConnections(components, connections),
@@ -225,6 +226,78 @@ async function detectKnownSDKConnections(components, connections) {
         }
     }
 }
+/**
+ * Detect cross-component connections from the code-sampler import map.
+ * Resolves relative imports and workspace package names to component boundaries.
+ */
+async function detectImportMapConnections(components, connections, importMap) {
+    if (Object.keys(importMap).length === 0)
+        return;
+    // Build component path → id lookup, sorted longest-first for greedy matching
+    const compPathEntries = components
+        .filter((c) => c.path !== ".")
+        .map((c) => ({ path: c.path.endsWith("/") ? c.path : c.path + "/", id: c.id }))
+        .sort((a, b) => b.path.length - a.path.length);
+    // Build package name → component id lookup (for monorepo imports)
+    const pkgNameToComp = new Map();
+    for (const comp of components) {
+        pkgNameToComp.set(comp.id, comp.id);
+        pkgNameToComp.set(comp.name, comp.id);
+        // Handle scoped package names: @org/name → name
+        const unscoped = comp.name.replace(/^@[^/]+\//, "");
+        if (unscoped !== comp.name)
+            pkgNameToComp.set(unscoped, comp.id);
+    }
+    const findCompForFile = (filePath) => {
+        for (const entry of compPathEntries) {
+            if (filePath.startsWith(entry.path) || filePath === entry.path.slice(0, -1)) {
+                return entry.id;
+            }
+        }
+        return null;
+    };
+    // Track seen connections to avoid duplicates within this strategy
+    const seen = new Set();
+    for (const [filePath, imports] of Object.entries(importMap)) {
+        const sourceComp = findCompForFile(filePath);
+        if (!sourceComp)
+            continue;
+        for (const imp of imports) {
+            let targetComp = null;
+            if (imp.startsWith(".") || imp.startsWith("/")) {
+                // Relative import — resolve path
+                const fromDir = filePath.substring(0, filePath.lastIndexOf("/"));
+                const parts = fromDir.split("/");
+                for (const seg of imp.split("/")) {
+                    if (seg === "..")
+                        parts.pop();
+                    else if (seg !== ".")
+                        parts.push(seg);
+                }
+                targetComp = findCompForFile(parts.join("/") + "/");
+            }
+            else {
+                // Package/bare import — check if it maps to a workspace component
+                const name = imp.split("/").slice(0, imp.startsWith("@") ? 2 : 1).join("/");
+                targetComp = pkgNameToComp.get(name) ?? pkgNameToComp.get(name.replace(/^@[^/]+\//, "")) ?? null;
+            }
+            if (targetComp && targetComp !== sourceComp) {
+                const key = `${sourceComp}::${targetComp}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                connections.push({
+                    from: sourceComp,
+                    to: targetComp,
+                    type: "import",
+                    description: `Import: ${sourceComp} → ${targetComp}`,
+                    confidence: 85,
+                    async: false,
+                });
+            }
+        }
+    }
+}
 /**
  * Exact match only: id, slug, path, or name must match exactly.
  * No fuzzy matching, synonyms, or partial matches — those are for the LLM.

package/dist/agents/static/index.js

@@ -37,9 +37,12 @@ export async function runStaticAnalysis(projectRoot, onProgress) {
     onProgress?.("Detecting components...");
     const components = await detectComponents(tk, structure);
     onProgress?.(`Found ${components.components.length} component(s)`);
-    // Phase 3: connection mapping (needs components + infra + events)
+    // Phase 2.5: collect import map for enriched connection detection
+    onProgress?.("Building import map...");
+    const codeSamples = await collectCodeSamples(tk);
+    // Phase 3: connection mapping (needs components + infra + events + import map)
     onProgress?.("Mapping connections...");
-    const connections = await mapConnections(tk, components.components, infra, events);
+    const connections = await mapConnections(tk, components.components, infra, events, codeSamples.importMap);
     onProgress?.(`Found ${connections.connections.length} connection(s)`);
     // Assemble result
     const analysis = {

package/dist/agents/static/types.d.ts

@@ -32,6 +32,20 @@ export interface StaticComponent {
     path: string;
     description: string;
     technologies: string[];
+    /** Coupling: count of public exports (from enricher) */
+    interfaceSurface?: number;
+    /** Security: has auth/permission boundary (from enricher) */
+    hasBoundary?: boolean;
+    /** Security: type of boundary e.g. "auth-middleware", "rbac" */
+    boundaryType?: string;
+    /** Key public export names (from enricher) */
+    publicExports?: string[];
+    /** File metrics from static analysis */
+    fileMetrics?: {
+        fileCount: number;
+        totalLines: number;
+        codeFileCount: number;
+    };
 }
 export interface InfraResult {
     docker: {
@@ -90,6 +104,8 @@ export interface StaticConnection {
     description: string;
     confidence: number;
     async: boolean;
+    /** Coupling weight 1-10 (from enricher) */
+    weight?: number;
 }
 export interface ConnectionResult {
     connections: StaticConnection[];
@@ -130,6 +146,16 @@ export interface StaticAnalysisResult {
     validation: ValidationResult;
     /** Gaps the static analysis couldn't resolve — passed to LLM for resolution */
     gaps: AnalysisGap[];
+    /** Free-form architectural observations from enricher */
+    enrichmentInsights?: string[];
+    /** Flow verification results from enricher */
+    flowVerifications?: Array<{
+        flowName: string;
+        verified: boolean;
+        stepsVerified: number;
+        stepsTotal: number;
+        issues?: string[];
+    }>;
 }
 export interface TreeEntry {
     path: string;

package/dist/cli/analyze.js

@@ -72,31 +72,38 @@ export async function handleAnalyze(options) {
     if (options.provider) {
         config = {
             provider: options.provider,
-            apiKey: options.apiKey ?? config?.apiKey ?? "",
+            ...(options.provider !== "claude-sdk" ? { apiKey: options.apiKey ?? config?.apiKey ?? "" } : {}),
         };
     }
     if (options.apiKey && config) {
         config.apiKey = options.apiKey;
     }
     if (!config) {
-        console.error(chalk.red("No model provider configured."));
-        console.error();
-        console.error(chalk.bold("Set up with:"));
-        console.error(chalk.gray("  archbyte config set provider anthropic"));
-        console.error(chalk.gray("  archbyte config set api-key sk-ant-..."));
-        console.error();
-        console.error(chalk.bold("Or use environment variables:"));
-        console.error(chalk.gray("  export ARCHBYTE_PROVIDER=anthropic"));
-        console.error(chalk.gray("  export ARCHBYTE_API_KEY=sk-ant-..."));
-        console.error();
-        console.error(chalk.bold("Or run without a model:"));
-        console.error(chalk.gray("  archbyte analyze --static"));
-        console.error();
-        console.error(chalk.bold("Supported providers:"));
-        console.error(chalk.gray("  anthropic, openai, google"));
-        process.exit(1);
+        const msg = [
+            chalk.red("No model provider configured."),
+            "",
+            chalk.bold("Zero-config (Claude Code users):"),
+            chalk.gray("  Install Claude Code → archbyte analyze just works"),
+            "",
+            chalk.bold("Or set up with:"),
+            chalk.gray("  archbyte config set provider anthropic"),
+            chalk.gray("  archbyte config set api-key sk-ant-..."),
+            "",
+            chalk.bold("Or use environment variables:"),
+            chalk.gray("  export ARCHBYTE_PROVIDER=anthropic"),
+            chalk.gray("  export ARCHBYTE_API_KEY=sk-ant-..."),
+            "",
+            chalk.bold("Or run without a model:"),
+            chalk.gray("  archbyte analyze --static"),
+            "",
+            chalk.bold("Supported providers:"),
+            chalk.gray("  anthropic, openai, google, claude-sdk"),
+        ].join("\n");
+        console.error(msg);
+        throw new Error("No model provider configured");
     }
-    console.log(chalk.gray(`Provider: ${chalk.white(config.provider)}`));
+    const providerLabel = config.provider === "claude-sdk" ? "Claude Code (SDK)" : config.provider;
+    console.log(chalk.gray(`Provider: ${chalk.white(providerLabel)}`));
     console.log(chalk.gray(`Project:  ${chalk.white(path.basename(rootDir))}`));
     console.log();
     // 2. Create provider
@@ -173,6 +180,19 @@ export async function handleAnalyze(options) {
             console.log();
         }
     }
+    // 3b. File-tree drift detection (catches zero-commit and major project growth)
+    if (priorMeta && !options.force && !incrementalContext) {
+        const currentFileCount = countProjectFiles(rootDir);
+        const priorCount = priorMeta.filesScanned ?? 0;
+        if (currentFileCount > 0 && priorCount > 0 && currentFileCount <= priorCount * 1.5) {
+            // File count hasn't grown significantly — skip re-scan
+            console.log(chalk.green("No significant changes detected since last scan. Use --force to re-scan."));
+            return;
+        }
+        if (currentFileCount > priorCount) {
+            console.log(chalk.yellow(`File tree grew from ${priorCount} to ${currentFileCount} files — running full scan.`));
+        }
+    }
     // 4. Run static context collection → LLM pipeline
     const progress = progressBar(7);
     progress.update(0, "Collecting static context...");
@@ -324,6 +344,33 @@ function getGitCommit() {
         return undefined;
     }
 }
+function countProjectFiles(rootDir) {
+    let count = 0;
+    const skip = new Set(["node_modules", ".git", ".archbyte", ".next", "dist", "build", ".cache"]);
+    function walk(dir, depth) {
+        if (depth > 4)
+            return;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith(".") && entry.name !== ".github")
+                    continue;
+                if (skip.has(entry.name))
+                    continue;
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(full, depth + 1);
+                }
+                else if (/\.(ts|tsx|js|jsx|py|go|rs|java|kt|rb|cs|php|swift|dart)$/i.test(entry.name)) {
+                    count++;
+                }
+            }
+        }
+        catch { /* permission errors, etc. */ }
+    }
+    walk(rootDir, 0);
+    return count;
+}
 function writeScanMetadata(rootDir, durationMs, mode, filesScanned, tokenUsage, incrementalMode, skippedAgents) {
     const meta = {
         analyzedAt: new Date().toISOString(),

package/dist/cli/arch-diff.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Architecture diff — computes structural changes between two architecture snapshots.
+ * Used by patrol for change detection and by diff command for comparison.
+ */
+import type { Architecture } from "../server/src/generator/index.js";
+export interface StructuralDiff {
+    addedNodes: Array<{
+        id: string;
+        label: string;
+        type: string;
+        layer: string;
+    }>;
+    removedNodes: Array<{
+        id: string;
+        label: string;
+        type: string;
+        layer: string;
+    }>;
+    modifiedNodes: Array<{
+        id: string;
+        field: string;
+        from: string;
+        to: string;
+    }>;
+    addedEdges: Array<{
+        source: string;
+        target: string;
+        label?: string;
+    }>;
+    removedEdges: Array<{
+        source: string;
+        target: string;
+        label?: string;
+    }>;
+}
+export declare function diffArchitectures(prev: Architecture, curr: Architecture): StructuralDiff;
+export declare function loadArchitectureJSON(rootDir: string): Architecture | null;
+export declare function hasStructuralChanges(diff: StructuralDiff): boolean;

package/dist/cli/arch-diff.js

@@ -0,0 +1,61 @@
+/**
+ * Architecture diff — computes structural changes between two architecture snapshots.
+ * Used by patrol for change detection and by diff command for comparison.
+ */
+import * as fs from "fs";
+import * as path from "path";
+export function diffArchitectures(prev, curr) {
+    const prevNodeMap = new Map();
+    for (const n of prev.nodes)
+        prevNodeMap.set(n.id, n);
+    const currNodeMap = new Map();
+    for (const n of curr.nodes)
+        currNodeMap.set(n.id, n);
+    const prevNodeIds = new Set(prev.nodes.map((n) => n.id));
+    const currNodeIds = new Set(curr.nodes.map((n) => n.id));
+    const addedNodes = curr.nodes
+        .filter((n) => !prevNodeIds.has(n.id))
+        .map((n) => ({ id: n.id, label: n.label, type: n.type, layer: n.layer }));
+    const removedNodes = prev.nodes
+        .filter((n) => !currNodeIds.has(n.id))
+        .map((n) => ({ id: n.id, label: n.label, type: n.type, layer: n.layer }));
+    const modifiedNodes = [];
+    for (const n of curr.nodes) {
+        const old = prevNodeMap.get(n.id);
+        if (!old)
+            continue;
+        for (const field of ["label", "type", "layer"]) {
+            if (old[field] !== n[field]) {
+                modifiedNodes.push({ id: n.id, field, from: old[field], to: n[field] });
+            }
+        }
+    }
+    const edgeKey = (e) => `${e.source}->${e.target}`;
+    const prevEdgeKeys = new Set(prev.edges.map(edgeKey));
+    const currEdgeKeys = new Set(curr.edges.map(edgeKey));
+    const addedEdges = curr.edges
+        .filter((e) => !prevEdgeKeys.has(edgeKey(e)))
+        .map((e) => ({ source: e.source, target: e.target, label: e.label }));
+    const removedEdges = prev.edges
+        .filter((e) => !currEdgeKeys.has(edgeKey(e)))
+        .map((e) => ({ source: e.source, target: e.target, label: e.label }));
+    return { addedNodes, removedNodes, modifiedNodes, addedEdges, removedEdges };
+}
+export function loadArchitectureJSON(rootDir) {
+    const archPath = path.join(rootDir, ".archbyte", "architecture.json");
+    if (!fs.existsSync(archPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(archPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function hasStructuralChanges(diff) {
+    return (diff.addedNodes.length > 0 ||
+        diff.removedNodes.length > 0 ||
+        diff.modifiedNodes.length > 0 ||
+        diff.addedEdges.length > 0 ||
+        diff.removedEdges.length > 0);
+}

package/dist/cli/auth.d.ts

@@ -5,10 +5,16 @@ interface Credentials {
     expiresAt: string;
 }
 export type OAuthProvider = "github" | "google";
-export declare function handleLogin(provider?: OAuthProvider): Promise<void>;
+export type LoginProvider = OAuthProvider | "email";
+export declare function handleLogin(provider?: LoginProvider): Promise<void>;
 export declare function handleLoginWithToken(token: string): Promise<void>;
-export declare function handleLogout(): Promise<void>;
+export declare function handleLogout(options?: {
+    all?: boolean;
+    email?: string;
+}): Promise<void>;
 export declare function handleStatus(): Promise<void>;
+export declare function handleAccounts(): Promise<void>;
+export declare function handleAccountSwitch(email?: string): Promise<void>;
 export declare function loadCredentials(): Credentials | null;
 /**
  * Get the tier from the JWT token payload. NEVER falls back to the