archbyte 0.5.1 → 0.5.2

package/bin/archbyte.js

@@ -22,6 +22,11 @@ import { handleVersion, handleUpdate } from '../dist/cli/version.js';
 import { requireLicense } from '../dist/cli/license-gate.js';
 import { DEFAULT_PORT } from '../dist/cli/constants.js';
 
+// When spawned by `archbyte serve` (internal), skip interactive license checks.
+// The user already authenticated when they started the server.
+const isInternal = process.env.ARCHBYTE_INTERNAL === '1';
+const gate = isInternal ? async () => {} : requireLicense;
+
 const require = createRequire(import.meta.url);
 const { version: PKG_VERSION } = require('../package.json');
 
@@ -111,7 +116,7 @@ program
   .option('--force', 'Force full re-scan (skip incremental detection)')
   .option('--dry-run', 'Preview without running')
   .action(async (options) => {
-    await requireLicense('analyze');
+    await gate('analyze');
     await handleAnalyze(options);
   });
 
@@ -122,7 +127,7 @@ program
   .option('-o, --output <path>', 'Output diagram (default: .archbyte/architecture.json)')
   .option('-v, --verbose', 'Show detailed output')
   .action(async (options) => {
-    await requireLicense('generate');
+    await gate('generate');
     await handleGenerate(options);
   });
 

package/dist/agents/pipeline/agents/service-describer.js

@@ -33,13 +33,13 @@ export const serviceDescriber = {
         parts.push(`Detected language: ${ctx.structure.language}`);
         parts.push(`Languages: ${ctx.structure.languages.join(", ") || "none"}`);
         parts.push(`Framework: ${ctx.structure.framework ?? "none"}`);
-        // Docs
+        // Docs — only project description, NOT externalDependencies.
+        // Doc-extracted dependency mentions prime the LLM to hallucinate phantom services
+        // (e.g., docs mention "MCP" → LLM creates "MCP Server" component).
+        // The LLM should discover services from actual code evidence only.
         if (ctx.docs.projectDescription) {
             parts.push(`\nFrom docs: ${ctx.docs.projectDescription}`);
         }
-        if (ctx.docs.externalDependencies.length > 0) {
-            parts.push(`\nExternal dependencies mentioned: ${ctx.docs.externalDependencies.join(", ")}`);
-        }
         // Docker services — only include if infra/config files changed (or full scan)
         if (ctx.infra.docker.composeFile && (hasInfraChanges || hasConfigChanges)) {
             const svcInfo = ctx.infra.docker.services.map((s) => {

package/dist/agents/pipeline/merger.js

@@ -1,5 +1,6 @@
 // Pipeline — Merger
 // Assembles all agent outputs into a StaticAnalysisResult
+import { categorizeDep } from "../static/taxonomy.js";
 function sanitize(s) {
     if (!s)
         return s;
@@ -9,21 +10,24 @@ function sanitize(s) {
  * Build a set of "evidence tokens" from the static context — things that concretely
  * exist in the codebase (dependencies, env vars, docker images/services).
  * Used to gate LLM-generated databases/external services against hallucination.
+ *
+ * Uses the package taxonomy to resolve package names to their display names
+ * (e.g., "pg" → also adds "postgresql", "stripe" → also adds "stripe").
+ * This lets the LLM use human-readable names while still requiring code evidence.
  */
 function buildEvidenceTokens(ctx) {
     const tokens = new Set();
+    /** Add a dependency name + its taxonomy display name as tokens. */
+    function addDep(dep) {
+        tokens.add(dep.toLowerCase());
+        const cat = categorizeDep(dep);
+        if (cat)
+            tokens.add(cat.displayName.toLowerCase());
+    }
     // Package dependencies from import map (codeSamples.importMap: file → imported modules)
     for (const imports of Object.values(ctx.codeSamples.importMap)) {
-        for (const imp of imports) {
-            tokens.add(imp.toLowerCase());
-            // Also add short name for scoped packages: @aws-sdk/client-s3 → client-s3, aws-sdk
-            if (imp.startsWith("@")) {
-                const parts = imp.split("/");
-                if (parts[1])
-                    tokens.add(parts[1].toLowerCase());
-                tokens.add(parts[0].slice(1).toLowerCase());
-            }
-        }
+        for (const imp of imports)
+            addDep(imp);
     }
     // Config files may contain dependency info (package.json deps etc.)
     for (const cfg of ctx.codeSamples.configFiles) {
@@ -31,13 +35,7 @@ function buildEvidenceTokens(ctx) {
             try {
                 const pkg = JSON.parse(cfg.content);
                 for (const dep of Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })) {
-                    tokens.add(dep.toLowerCase());
-                    if (dep.startsWith("@")) {
-                        const parts = dep.split("/");
-                        if (parts[1])
-                            tokens.add(parts[1].toLowerCase());
-                        tokens.add(parts[0].slice(1).toLowerCase());
-                    }
+                    addDep(dep);
                 }
             }
             catch { /* ignore parse errors */ }
@@ -59,35 +57,29 @@ function buildEvidenceTokens(ctx) {
     for (const s of ctx.infra.cloud.services) {
         tokens.add(s.toLowerCase());
     }
-    // External dependencies mentioned in docs
-    for (const dep of ctx.docs.externalDependencies) {
-        tokens.add(dep.toLowerCase());
-    }
+    // NOTE: ctx.docs.externalDependencies intentionally excluded.
+    // Doc mentions (from markdown/README) are not concrete code evidence and cause
+    // hallucination — the LLM sees "MCP" in docs and creates phantom components.
+    // Only code-level signals (imports, deps, env vars, Docker, cloud) count.
     return tokens;
 }
 /**
- * Check if a service/database ID and type have concrete evidence in the static context.
- * Uses fuzzy matching: checks if any evidence token contains or is contained by the service keywords.
+ * Check if a service/database has concrete evidence in the static context.
+ * Strict exact-match only — no substring/regex fuzzy matching.
+ * The taxonomy enriches evidence tokens with display names (pg → PostgreSQL)
+ * so the LLM can use human-readable names and still match.
  */
 function hasEvidence(id, name, type, evidenceTokens) {
-    // Build candidate keywords from the service
     const candidates = [
         id.toLowerCase(),
         name.toLowerCase(),
         type.toLowerCase(),
-        // Split hyphenated IDs: "aws-sqs" → ["aws", "sqs"]
+        // Split hyphenated IDs: "aws-sqs" → also check "aws", "sqs"
         ...id.toLowerCase().split("-"),
     ].filter(Boolean);
     for (const candidate of candidates) {
-        for (const token of evidenceTokens) {
-            // Direct match or substring match (in both directions)
-            if (token === candidate)
-                return true;
-            if (token.includes(candidate) && candidate.length >= 3)
-                return true;
-            if (candidate.includes(token) && token.length >= 3)
-                return true;
-        }
+        if (evidenceTokens.has(candidate))
+            return true;
     }
     return false;
 }

package/dist/cli/analyze.js

@@ -50,10 +50,11 @@ export async function handleAnalyze(options) {
         progress.update(1, "Building analysis...");
         const freshAnalysis = buildAnalysisFromStatic(result, rootDir);
         const duration = Date.now() - startTime;
-        // Merge into existing analysis if it was produced by an agentic run,
+        // Merge into existing data if it was produced by an agentic run,
         // preserving LLM-generated components/connections while refreshing
         // static data (environments, metadata, project info).
         const existingAnalysis = loadExistingAnalysis(rootDir);
+        const existingSpec = loadSpec(rootDir);
         const wasAgentic = existingAnalysis && existingAnalysis.metadata?.mode !== "static";
         const analysis = wasAgentic ? mergeStaticIntoExisting(existingAnalysis, freshAnalysis) : freshAnalysis;
         // Stamp scan metadata on analysis.json (backward compat)
@@ -62,10 +63,19 @@ export async function handleAnalyze(options) {
         ameta.mode = wasAgentic ? "static-refresh" : "static";
         writeAnalysis(rootDir, analysis);
         // Dual-write: archbyte.yaml + metadata.json
-        const existingSpec = loadSpec(rootDir);
-        const spec = staticResultToSpec(result, rootDir, existingSpec?.rules);
-        writeSpec(rootDir, spec);
-        writeScanMetadata(rootDir, duration, "static");
+        // When prior data came from an agentic run, only refresh static fields
+        // (project info, environments) — never overwrite LLM components/connections.
+        if (wasAgentic && existingSpec) {
+            const freshSpec = staticResultToSpec(result, rootDir, existingSpec.rules);
+            existingSpec.project = freshSpec.project;
+            existingSpec.environments = freshSpec.environments;
+            writeSpec(rootDir, existingSpec);
+        }
+        else {
+            const spec = staticResultToSpec(result, rootDir, existingSpec?.rules);
+            writeSpec(rootDir, spec);
+        }
+        writeScanMetadata(rootDir, duration, wasAgentic ? "static-refresh" : "static");
         progress.update(2, "Generating diagram...");
         await autoGenerate(rootDir, options);
         progress.done("Analysis complete");

package/dist/server/src/index.js

@@ -138,6 +138,11 @@ function createHttpServer() {
             return;
         }
         const url = req.url || "/";
+        // Log API actions to terminal (skip static files, SSE, health checks)
+        if (url.startsWith("/api/") && url !== "/api/health") {
+            const label = url.replace("/api/", "").split("?")[0];
+            console.error(`[archbyte] ${req.method} ${label}`);
+        }
         // SSE endpoint
         if (url === "/events") {
             res.writeHead(200, {
@@ -1129,7 +1134,7 @@ function createHttpServer() {
             const child = spawn(process.execPath, [bin, "generate"], {
                 cwd: config.workspaceRoot,
                 stdio: ["ignore", "pipe", "pipe"],
-                env: { ...process.env, FORCE_COLOR: "0" },
+                env: { ...process.env, FORCE_COLOR: "0", ARCHBYTE_INTERNAL: "1" },
             });
             runningWorkflows.set("__generate__", child);
             broadcastOpsEvent({ type: "generate:started" });
@@ -1221,7 +1226,7 @@ function createHttpServer() {
             const child = spawn(process.execPath, [bin, "workflow", "--run", id], {
                 cwd: config.workspaceRoot,
                 stdio: ["ignore", "pipe", "pipe"],
-                env: { ...process.env, FORCE_COLOR: "0" },
+                env: { ...process.env, FORCE_COLOR: "0", ARCHBYTE_INTERNAL: "1" },
             });
             runningWorkflows.set(id, child);
             broadcastOpsEvent({ type: "workflow:started", id });
@@ -1452,6 +1457,22 @@ function createHttpServer() {
             }
             return;
         }
+        // API: UI event logging — fire-and-forget from UI to server console
+        if (url === "/api/ui-event" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", () => {
+                try {
+                    const { event, detail } = JSON.parse(body);
+                    const msg = detail ? `${event} — ${detail}` : event;
+                    console.error(`[archbyte] ui: ${msg}`);
+                }
+                catch { }
+                res.writeHead(204);
+                res.end();
+            });
+            return;
+        }
         // API: Telemetry — record agent timing data
         if (url === "/api/telemetry" && req.method === "POST") {
             let body = "";
@@ -1717,7 +1738,7 @@ function runAnalyzePipeline(mode = "static", fileChanges) {
     const analyzeChild = spawn(process.execPath, analyzeArgs, {
         cwd: config.workspaceRoot,
         stdio: ["ignore", "pipe", "pipe"],
-        env: { ...process.env, FORCE_COLOR: "0" },
+        env: { ...process.env, FORCE_COLOR: "0", ARCHBYTE_INTERNAL: "1" },
     });
     let analyzeStderr = "";
     analyzeChild.stdout?.on("data", (d) => process.stderr.write(`[analyze] ${d}`));
@@ -1733,7 +1754,7 @@ function runAnalyzePipeline(mode = "static", fileChanges) {
         const genChild = spawn(process.execPath, [bin, "generate"], {
             cwd: config.workspaceRoot,
             stdio: ["ignore", "pipe", "pipe"],
-            env: { ...process.env, FORCE_COLOR: "0" },
+            env: { ...process.env, FORCE_COLOR: "0", ARCHBYTE_INTERNAL: "1" },
         });
         genChild.stdout?.on("data", (d) => process.stderr.write(`[generate] ${d}`));
         genChild.stderr?.on("data", (d) => process.stderr.write(`[generate] ${d}`));

package/package.json

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