archbyte 0.4.0 → 0.4.2

package/dist/cli/analyze.js

@@ -79,25 +79,28 @@ export async function handleAnalyze(options) {
         config.apiKey = options.apiKey;
     }
     if (!config) {
-        console.error(chalk.red("No model provider configured."));
-        console.error();
-        console.error(chalk.bold("Zero-config (Claude Code users):"));
-        console.error(chalk.gray("  Install Claude Code → archbyte analyze just works"));
-        console.error();
-        console.error(chalk.bold("Or 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, claude-sdk"));
-        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");
     }
     const providerLabel = config.provider === "claude-sdk" ? "Claude Code (SDK)" : config.provider;
     console.log(chalk.gray(`Provider: ${chalk.white(providerLabel)}`));
@@ -177,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...");
@@ -328,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/patrol.d.ts

@@ -4,13 +4,15 @@ interface PatrolOptions {
     interval?: string;
     onViolation?: string;
     daemon?: boolean;
+    once?: boolean;
+    watch?: boolean;
     history?: boolean;
-    rescan?: boolean;
 }
 /**
  * Run the architecture patrol daemon.
- * Inspired by Gastown's patrol loop pattern — cyclic monitoring
- * that detects drift and reports violations.
+ * Each cycle: snapshot → analyze (incremental) → generate → validate → diff
+ *
+ * --once: run a single cycle then exit (used by UI "Run Now")
  */
 export declare function handlePatrol(options: PatrolOptions): Promise<void>;
 export {};