@tryjourney/architecture 0.1.0 → 0.2.0

package/README.md

@@ -7,3 +7,10 @@ environment values, absolute paths, or file modification times.
 
 It is used by `@tryjourney/cli` to observe project architecture while Journey
 MCP is running.
+
+The v2 scanner discovers Git-visible files, package boundaries, framework apps,
+public APIs, exported SDKs, independently started workers, Python API processes,
+and runtime use of PostgreSQL, S3-compatible storage, OpenAI, and email providers.
+It follows local imports from API and worker entry points so provider connections
+are attributed to the boundary that actually reaches them. Dependencies, routes,
+scripts, and environment-variable names remain inventory rather than canvas nodes.

package/dist/index.d.ts

@@ -1,37 +1,6 @@
-export type Component = {
-    id: string;
-    name: string;
-    type: string;
-    workspace: string;
-    technology: string[];
-    evidence: {
-        path: string;
-        line: number;
-    }[];
-    confidence: "high" | "medium";
-};
-export type Connection = {
-    id: string;
-    from: string;
-    to: string;
-    type: string;
-    evidence: {
-        path: string;
-        line: number;
-    }[];
-};
-export type Graph = {
-    schema_version: 1;
-    components: Component[];
-    connections: Connection[];
-    coverage: string[];
-};
-export type Change = {
-    type: "added" | "removed" | "changed";
-    entity: "component" | "connection";
-    id: string;
-};
+import type { Change, Graph } from "./types.js";
+export * from "./types.js";
+export declare function readExclusions(root: string): string[];
 export declare function scan(root: string, extraExclusions?: string[]): Graph;
 export declare function fingerprint(graph: Graph): string;
 export declare function diff(before: Graph | null, after: Graph): Change[];
-export declare function readExclusions(root: string): string[];

package/dist/index.js

@@ -1,81 +1,189 @@
 import { createHash } from "node:crypto";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join, relative, sep } from "node:path";
-const excluded = new Set([".git", ".astro", ".next", "dist", ".venv", "__pycache__", "node_modules", ".wrangler", ".codex", ".claude", "coverage"]);
-const recognized = new Set(["package.json", "pnpm-workspace.yaml", "astro.config.mjs", "next.config.ts", "vite.config.ts", "wrangler.jsonc", "pyproject.toml", "requirements.txt", "alembic.ini", "Dockerfile", "main.py", "server.py", "orm.py", "database.py", "index.ts", "mcp.ts", "api.ts"]);
-function digest(value) { return createHash("sha256").update(value).digest("hex"); }
-function safeRelative(root, path) { return relative(root, path).split(sep).join("/"); }
-export function scan(root, extraExclusions = []) {
-    const files = [];
-    const omitted = new Set([...excluded, ...extraExclusions]);
-    function visit(dir) {
-        for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-            if (entry.isSymbolicLink() || omitted.has(entry.name) || entry.name.startsWith(".env") || entry.name.endsWith(".db"))
+import { execFileSync } from "node:child_process";
+import { existsSync, lstatSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, extname, join, relative, resolve, sep } from "node:path";
+export * from "./types.js";
+const VERSION = "2.1.0", MAX_FILES = 20_000, MAX_FILE_SIZE = 512 * 1024;
+const EXCLUDED = new Set([".git", ".astro", ".next", ".turbo", ".vercel", ".wrangler", ".codex", ".claude", ".idea", ".vscode", "node_modules", "dist", "build", "out", "coverage", ".venv", "venv", "__pycache__", "examples", "example", "demo", "fixtures"]);
+const BINARY = /\.(?:map|db|sqlite|png|jpe?g|gif|webp|ico|pdf|zip|gz|woff2?|ttf|mp4|mov)$/i;
+const SOURCE = /\.(?:[cm]?[jt]sx?|py)$/i;
+const TEST_FILE = /(?:^|\/)(?:test|tests|__tests__|fixtures)(?:\/|$)|\.(?:test|spec)\.[^.]+$/i;
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const repoPath = (root, path) => relative(root, path).split(sep).join("/");
+const lineAt = (text, at) => text.slice(0, Math.max(0, at)).split("\n").length;
+const stableId = (...parts) => parts.join(":").toLowerCase().replace(/[^a-z0-9:_-]+/g, "-").replace(/-+/g, "-");
+const unique = (values) => [...new Set(values)];
+function canonical(value) { if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`; if (value && typeof value === "object")
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`; return JSON.stringify(value); }
+function offsets(file, re) { const flags = re.flags.includes("g") ? re.flags : `${re.flags}g`; return [...file.text.matchAll(new RegExp(re.source, flags))].map(match => match.index ?? 0); }
+function ev(file, detector, category, at = 0) { return { path: file.path, line: lineAt(file.text, at), detector, category }; }
+function ignored(path, patterns) { return patterns.some(raw => { const value = raw.trim().replace(/^\/+/, ""); if (!value || value.startsWith("!"))
+    return false; const escaped = value.replace(/[-/\\^$+?.()|[\]{}]/g, "\\$&").replace(/\*\*/g, "§§").replace(/\*/g, "[^/]*").replace(/§§/g, ".*"); return new RegExp(`^${escaped}(?:/.*)?$`).test(path); }); }
+export function readExclusions(root) { const file = join(root, ".journeyignore"); return existsSync(file) ? readFileSync(file, "utf8").split(/\r?\n/).map(value => value.trim()).filter(value => value && !value.startsWith("#")) : []; }
+function discover(root, patterns) {
+    const candidates = [], skipped = [];
+    let gitAvailable = false;
+    try {
+        const output = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        candidates.push(...output.split("\0").filter(Boolean).sort());
+        gitAvailable = true;
+    }
+    catch {
+        const visit = (directory) => { for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            const absolute = join(directory, entry.name), path = repoPath(root, absolute);
+            if (entry.isSymbolicLink() || (entry.isDirectory() && EXCLUDED.has(entry.name)) || ignored(path, patterns)) {
+                skipped.push(path);
                 continue;
-            const path = join(dir, entry.name);
+            }
             if (entry.isDirectory())
-                visit(path);
-            else if (entry.isFile() && recognized.has(entry.name))
-                files.push(safeRelative(root, path));
+                visit(absolute);
+            else if (entry.isFile())
+                candidates.push(path);
+            if (candidates.length >= MAX_FILES)
+                return;
+        } };
+        visit(root);
+    }
+    const files = [];
+    for (const path of unique(candidates).sort()) {
+        if (files.length >= MAX_FILES)
+            break;
+        if (path.split("/").some(part => EXCLUDED.has(part)) || ignored(path, patterns)) {
+            skipped.push(path);
+            continue;
+        }
+        const absolute = join(root, path);
+        try {
+            if (lstatSync(absolute).isSymbolicLink() || !statSync(absolute).isFile() || statSync(absolute).size > MAX_FILE_SIZE || BINARY.test(path) || /(?:^|\/)\.env(?:\.|$)/.test(path)) {
+                skipped.push(path);
+                continue;
+            }
+            files.push({ path, text: readFileSync(absolute, "utf8") });
+        }
+        catch {
+            skipped.push(path);
         }
     }
-    visit(root);
-    const has = (path) => files.includes(path);
-    const components = [];
-    const add = (id, name, type, workspace, technology, evidence) => {
-        const found = evidence.filter(has);
-        if (!found.length)
-            return;
-        components.push({ id, name, type, workspace, technology, evidence: found.map(path => ({ path, line: 1 })), confidence: "high" });
-    };
-    // Manifests and conventional entry points are evidence. No source text or package values leave the machine.
-    add("landing", "Landing site", "web", "apps/landing", ["Astro"], ["apps/landing/astro.config.mjs"]);
-    add("web", "Web app", "web", "apps/web", ["Next.js"], ["apps/web/next.config.ts"]);
-    add("cli", "CLI and MCP gateway", "cli", "packages/cli", ["Node.js", "MCP"], ["packages/cli/src/index.ts", "packages/cli/src/commands/mcp.ts"]);
-    add("api", "API and MCP server", "service", "apps/server", ["Python", "FastAPI", "FastMCP"], ["apps/server/app/main.py", "apps/server/app/mcp/server.py"]);
-    add("persistence", "Persistence", "database", "apps/server", ["SQLAlchemy", "Alembic"], ["apps/server/app/db/orm.py", "apps/server/alembic.ini"]);
-    add("deployment", "Cloudflare deployment", "deployment", "infra/cloudflare", ["Cloudflare"], ["infra/cloudflare/api/wrangler.jsonc", "apps/web/wrangler.jsonc"]);
-    if (!components.length) {
-        if (has("astro.config.mjs"))
-            add("root:astro", "Astro site", "web", ".", ["Astro"], ["astro.config.mjs"]);
-        if (has("next.config.ts"))
-            add("root:next", "Next.js app", "web", ".", ["Next.js"], ["next.config.ts"]);
-        if (has("app/main.py"))
-            add("root:api", "Python API", "service", ".", ["Python", "FastAPI"], ["app/main.py"]);
-        if (has("package.json"))
-            add("root:package", "Node package", "package", ".", ["Node.js"], ["package.json"]);
+    return { files, skipped: unique(skipped).sort(), gitAvailable, truncated: candidates.length >= MAX_FILES };
+}
+function parseManifest(file) { try {
+    const value = JSON.parse(file.text), root = file.path === "package.json" ? "." : dirname(file.path);
+    return { file, root, name: typeof value.name === "string" ? value.name : root.split("/").at(-1) ?? "Application", scripts: typeof value.scripts === "object" && value.scripts ? value.scripts : {}, dependencies: typeof value.dependencies === "object" && value.dependencies ? value.dependencies : {}, devDependencies: typeof value.devDependencies === "object" && value.devDependencies ? value.devDependencies : {}, bin: value.bin, exports: value.exports };
+}
+catch {
+    return null;
+} }
+function scriptEntry(root, command) { const match = command.match(/(?:^|\s)([\w./-]+\.(?:[cm]?[jt]s|py))(?:\s|$)/); if (!match)
+    return null; const candidate = match[1].replace(/^\.\//, ""); return root === "." ? candidate : `${root}/${candidate}`; }
+function resolveImport(from, specifier, fileMap) { if (!specifier.startsWith("."))
+    return null; const base = resolve("/repo", dirname(from), specifier).slice(6).replaceAll("\\", "/"); const candidates = extname(base) ? [base] : [base, ...[".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"].map(ext => `${base}${ext}`), ...[".ts", ".tsx", ".js", ".jsx", ".py"].map(ext => `${base}/index${ext}`)]; return candidates.find(candidate => fileMap.has(candidate)) ?? null; }
+function reachable(entries, fileMap) { const visited = new Set(), queue = entries.filter(entry => fileMap.has(entry)); while (queue.length && visited.size < 2_000) {
+    const path = queue.shift();
+    if (visited.has(path))
+        continue;
+    visited.add(path);
+    const file = fileMap.get(path);
+    for (const match of file.text.matchAll(/(?:import|export)\s+(?:[^"']+?\s+from\s+)?["']([^"']+)["']|require\(\s*["']([^"']+)["']\s*\)|import\(\s*["']([^"']+)["']\s*\)/g)) {
+        const target = resolveImport(path, match[1] ?? match[2] ?? match[3], fileMap);
+        if (target && !visited.has(target))
+            queue.push(target);
+    }
+} return visited; }
+function sortGraph(graph) { const sortEv = (a, b) => a.path.localeCompare(b.path) || a.line - b.line || a.detector.localeCompare(b.detector); for (const component of graph.components) {
+    component.evidence = unique(component.evidence.map(canonical)).map(item => JSON.parse(item)).sort(sortEv).slice(0, 30);
+    component.files = unique(component.files).sort().slice(0, 100);
+    component.technology = unique(component.technology).sort();
+    component.details.sort((a, b) => `${a.kind}:${a.value}`.localeCompare(`${b.kind}:${b.value}`));
+} for (const connection of graph.connections)
+    connection.evidence.sort(sortEv); graph.components.sort((a, b) => a.id.localeCompare(b.id)); graph.connections.sort((a, b) => a.id.localeCompare(b.id)); for (const values of Object.values(graph.inventory))
+    values.splice(0, values.length, ...unique(values).sort().slice(0, 1_000)); return graph; }
+export function scan(root, extraExclusions = []) {
+    const discovery = discover(root, [...readExclusions(root), ...extraExclusions]), files = discovery.files, fileMap = new Map(files.map(file => [file.path, file])), runtimeFiles = files.filter(file => SOURCE.test(file.path) && !TEST_FILE.test(file.path) && !/(?:^|\/)public\//.test(file.path));
+    const manifests = files.filter(file => file.path === "package.json" || file.path.endsWith("/package.json")).map(parseManifest).filter((item) => Boolean(item));
+    const components = [], ownership = new Map();
+    const inventory = { dependencies: [], dev_dependencies: [], frameworks: [], routes: [], scripts: [], environment_variables: [], docker_services: [] };
+    const make = (value, details = []) => ({ ...value, files: value.evidence.map(item => item.path), details });
+    const add = (component, owned = []) => { const current = components.find(item => item.id === component.id); if (current) {
+        current.evidence.push(...component.evidence);
+        current.files.push(...component.files);
+        current.technology.push(...component.technology);
+        current.details.push(...component.details);
+    }
+    else
+        components.push(component); ownership.set(component.id, new Set([...(ownership.get(component.id) ?? []), ...owned])); };
+    for (const manifest of manifests) {
+        const deps = Object.keys(manifest.dependencies), dev = Object.keys(manifest.devDependencies);
+        inventory.dependencies.push(...deps);
+        inventory.dev_dependencies.push(...dev);
+        inventory.scripts.push(...Object.keys(manifest.scripts).map(name => `${manifest.root}:${name}`));
+        const framework = deps.includes("next") ? "Next.js" : deps.includes("astro") ? "Astro" : deps.includes("vite") ? "Vite" : null;
+        if (framework) {
+            inventory.frameworks.push(framework);
+            const owned = runtimeFiles.filter(file => manifest.root === "." || file.path.startsWith(`${manifest.root}/`)).map(file => file.path);
+            add(make({ id: stableId("application", manifest.root), name: /web/i.test(manifest.name) ? "Web App" : manifest.name, kind: "application", boundary: "deployment", workspace: manifest.root, technology: [framework], environment: "both", optional: false, confidence: "high", evidence: [ev(manifest.file, "framework-application", "manifest")] }, Object.keys(manifest.scripts).map(name => ({ kind: "script", value: name, path: manifest.file.path, line: lineAt(manifest.file.text, manifest.file.text.indexOf(`"${name}"`)) }))), owned);
+        }
+        if (manifest.bin || manifest.exports) {
+            const owned = runtimeFiles.filter(file => manifest.root === "." || file.path.startsWith(`${manifest.root}/`)).map(file => file.path), isCli = Boolean(manifest.bin);
+            add(make({ id: stableId(isCli ? "cli" : "sdk", manifest.root), name: isCli ? manifest.name : /sdk/i.test(manifest.name) ? "Browser SDK / Widgets" : manifest.name, kind: isCli ? "cli" : "sdk", boundary: "logical", workspace: manifest.root, technology: ["Node.js"], environment: "both", optional: false, confidence: "high", evidence: [ev(manifest.file, "package-interface", "manifest")] }), owned);
+        }
+        for (const [name, command] of Object.entries(manifest.scripts)) {
+            if (!/worker|jobs?|consumer|cron|scheduler/i.test(name) && !/(?:worker|consumer|scheduler)\.[cm]?[jt]s/.test(command))
+                continue;
+            const entry = scriptEntry(manifest.root, command);
+            if (!entry || !fileMap.has(entry))
+                continue;
+            const owned = reachable([entry], fileMap);
+            add(make({ id: stableId("worker", entry), name: /cron|schedule/i.test(name) ? "Scheduled Job" : "Background Worker", kind: /cron|schedule/i.test(name) ? "job" : "worker", boundary: "runtime", workspace: dirname(entry), technology: [entry.endsWith(".py") ? "Python" : "Node.js"], environment: "both", optional: false, confidence: "high", evidence: [ev(manifest.file, "runtime-script", "entry-point", manifest.file.text.indexOf(`"${name}"`))] }, [{ kind: "entry-point", value: entry, path: manifest.file.path, line: lineAt(manifest.file.text, manifest.file.text.indexOf(command)) }]), owned);
+        }
+    }
+    for (const file of runtimeFiles.filter(item => item.path.endsWith(".py") && /(?:FastAPI|FastMCP)\s*\(/.test(item.text))) {
+        const workspace = dirname(file.path);
+        add(make({ id: stableId("application", workspace), name: "API Service", kind: "application", boundary: "deployment", workspace, technology: ["Python", ...(file.text.includes("FastAPI") ? ["FastAPI"] : []), ...(file.text.includes("FastMCP") ? ["FastMCP"] : [])], environment: "both", optional: false, confidence: "high", evidence: [ev(file, "python-application", "entry-point", file.text.search(/FastAPI|FastMCP/))] }), reachable([file.path], fileMap));
+    }
+    for (const file of runtimeFiles)
+        for (const match of file.text.matchAll(/(?:process\.env\.([A-Z][A-Z0-9_]*)|os\.environ(?:\.get)?\s*(?:\[|\()\s*["']([A-Z][A-Z0-9_]*)|getenv\s*\(\s*["']([A-Z][A-Z0-9_]*))/g))
+            inventory.environment_variables.push(match[1] ?? match[2] ?? match[3]);
+    const routeFiles = runtimeFiles.filter(file => /(?:^|\/)(?:src\/)?app\/api\/(?:.*\/)?route\.[cm]?[jt]sx?$|(?:^|\/)api\/.+\.py$/.test(file.path) && /(?:export\s+(?:async\s+)?function\s+(?:GET|POST|PUT|PATCH|DELETE)|router\.(?:get|post|put|patch|delete))/.test(file.text));
+    inventory.routes.push(...routeFiles.map(file => file.path));
+    if (routeFiles.length) {
+        const owner = components.find(component => component.kind === "application" && component.workspace && routeFiles.some(file => component.workspace === "." || file.path.startsWith(`${component.workspace}/`))), owned = reachable(routeFiles.map(file => file.path), fileMap);
+        add(make({ id: stableId("api", owner?.workspace ?? "."), name: "Public API", kind: "api", boundary: "logical", workspace: owner?.workspace ?? ".", technology: owner?.technology ?? ["HTTP"], environment: "both", optional: false, confidence: "high", evidence: routeFiles.map(file => ev(file, "http-routes", "route", file.text.search(/GET|POST|router\./))).slice(0, 30) }, routeFiles.map(file => ({ kind: "route", value: file.path, path: file.path, line: 1 }))), owned);
+    }
+    const specs = [
+        { name: "PostgreSQL", kind: "database", technology: ["PostgreSQL"], expressions: [/(?:new\s+(?:Pool|Client)|postgres\s*\(|create_engine\s*\(|sqlalchemy|\.(?:query|execute)\s*\()/gi], optional: false },
+        { name: "File Storage", kind: "storage", technology: ["S3-compatible"], expressions: [/(?:new\s+S3Client|PutObjectCommand|GetObjectCommand|DeleteObjectCommand|\.put_object\s*\()/g], optional: true },
+        { name: "OpenAI", kind: "external-service", technology: ["OpenAI"], expressions: [/(?:new\s+OpenAI|OpenAI\s*\(|\.responses\.create|\.embeddings\.create)/g], optional: true },
+        { name: "Email Provider", kind: "external-service", technology: ["Resend", "SMTP"], expressions: [/(?:new\s+Resend|\.emails\.send|\.sendMail\s*\(|createTransport\s*\()/g], optional: true },
+    ];
+    for (const spec of specs) {
+        const hits = runtimeFiles.flatMap(file => spec.expressions.flatMap(expression => offsets(file, expression).map(at => ({ file, at }))));
+        if (hits.length)
+            add(make({ id: stableId(spec.kind, spec.name), name: spec.name, kind: spec.kind, boundary: "external", workspace: null, technology: spec.technology, environment: spec.optional ? "both" : "production", optional: spec.optional, confidence: "high", evidence: hits.map(({ file, at }) => ev(file, "runtime-provider", "runtime-call", at)).slice(0, 30) }, spec.technology.map(value => ({ kind: "provider", value }))));
     }
     const connections = [];
-    const link = (from, to, type, path) => {
-        if (components.some(c => c.id === from) && components.some(c => c.id === to) && has(path))
-            connections.push({ id: `${from}:${to}:${type}`, from, to, type, evidence: [{ path, line: 1 }] });
-    };
-    link("cli", "api", "MCP over HTTPS", "packages/cli/src/commands/mcp.ts");
-    link("web", "api", "HTTP API", "apps/web/lib/api.ts");
-    link("api", "persistence", "SQLAlchemy", "apps/server/app/db/database.py");
-    components.sort((a, b) => a.id.localeCompare(b.id));
-    connections.sort((a, b) => a.id.localeCompare(b.id));
-    return { schema_version: 1, components, connections, coverage: ["Recognized manifests and entry points only; unrecognized runtime relationships may be missing."] };
-}
-function canonical(value) { if (Array.isArray(value))
-    return `[${value.map(canonical).join(",")}]`; if (value && typeof value === "object")
-    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`; return JSON.stringify(value); }
-export function fingerprint(graph) { return digest(canonical(graph)); }
-export function diff(before, after) {
-    const changes = [];
-    for (const entity of ["component", "connection"]) {
-        const previous = new Map((before?.[entity === "component" ? "components" : "connections"] ?? []).map(item => [item.id, JSON.stringify(item)]));
-        const current = new Map(after[entity === "component" ? "components" : "connections"].map(item => [item.id, JSON.stringify(item)]));
-        for (const [id, value] of current)
-            if (!previous.has(id) || previous.get(id) !== value)
-                changes.push({ type: previous.has(id) ? "changed" : "added", entity, id });
-        for (const id of previous.keys())
-            if (!current.has(id))
-                changes.push({ type: "removed", entity, id });
+    const connect = (from, to, kind, label, expressions, optional = false) => { if (!to || from.id === to.id)
+        return; const hits = [...(ownership.get(from.id) ?? [])].map(path => fileMap.get(path)).filter((file) => Boolean(file)).flatMap(file => expressions.flatMap(expression => offsets(file, expression).map(at => ({ file, at })))); if (!hits.length)
+        return; const id = stableId("edge", from.id, to.id, kind); if (!connections.some(item => item.id === id))
+        connections.push({ id, from: from.id, to: to.id, kind, label, runtime: true, optional: optional || to.optional, confidence: "high", evidence: hits.map(({ file, at }) => ev(file, "boundary-connection", "runtime-call", at)).slice(0, 30) }); };
+    const database = components.find(item => item.name === "PostgreSQL"), storage = components.find(item => item.name === "File Storage"), openai = components.find(item => item.name === "OpenAI"), email = components.find(item => item.name === "Email Provider"), api = components.find(item => item.kind === "api");
+    for (const from of components.filter(item => ["api", "worker", "job"].includes(item.kind))) {
+        connect(from, database, "database", from.kind === "worker" ? "claims jobs / reads / writes" : "reads / writes", [/(?:postgres\s*\(|\.(?:query|execute)\s*\(|sql`)/g]);
+        connect(from, storage, "storage", "stores / reads files", [/(?:S3Client|PutObjectCommand|GetObjectCommand|DeleteObjectCommand|\.put_object\s*\()/g]);
+        connect(from, openai, "runtime-call", "calls", [/(?:new\s+OpenAI|responses\.create|embeddings\.create)/g], true);
+        connect(from, email, "runtime-call", "sends email", [/(?:new\s+Resend|emails\.send|sendMail\s*\()/g], true);
     }
-    return changes.sort((a, b) => `${a.entity}:${a.id}`.localeCompare(`${b.entity}:${b.id}`));
-}
-export function readExclusions(root) {
-    const path = join(root, ".journeyignore");
-    return existsSync(path) ? readFileSync(path, "utf8").split(/\r?\n/).map(s => s.trim()).filter(s => s && !s.startsWith("#") && !s.includes("/")) : [];
+    for (const from of components.filter(item => item.kind === "sdk" || item.kind === "application"))
+        connect(from, api, "http", "HTTP requests", [/(?:fetch\s*\(|axios\.|\.request\s*\()/g]);
+    return sortGraph({ schema_version: 2, scanner_version: VERSION, components, connections, inventory, coverage: { languages: unique(files.flatMap(file => file.path.endsWith(".py") ? ["Python"] : SOURCE.test(file.path) ? ["JavaScript/TypeScript"] : [])).sort(), frameworks: unique(inventory.frameworks).sort(), skipped: discovery.skipped, unsupported: [], warnings: components.length ? [] : ["No supported runtime boundary detected."], git_available: discovery.gitAvailable, truncated: discovery.truncated } });
 }
+export function fingerprint(graph) { return hash(canonical({ schema_version: graph.schema_version, scanner_version: graph.scanner_version, components: graph.components, connections: graph.connections })); }
+export function diff(before, after) { const changes = []; for (const [entity, key] of [["component", "components"], ["connection", "connections"]]) {
+    const previous = new Map((before?.[key] ?? []).map(item => [item.id, canonical(item)])), next = new Map(after[key].map(item => [item.id, canonical(item)]));
+    for (const [id, value] of next)
+        if (previous.get(id) !== value)
+            changes.push({ type: previous.has(id) ? "changed" : "added", entity, id });
+    for (const id of previous.keys())
+        if (!next.has(id))
+            changes.push({ type: "removed", entity, id });
+} return changes.sort((a, b) => `${a.entity}:${a.id}`.localeCompare(`${b.entity}:${b.id}`)); }

package/dist/types.d.ts

@@ -0,0 +1,67 @@
+export type ArchitectureEvidenceV2 = {
+    path: string;
+    line: number;
+    detector: string;
+    category: "manifest" | "entry-point" | "route" | "import" | "runtime-call" | "deployment" | "configuration";
+};
+export type ArchitectureDetailV2 = {
+    kind: string;
+    value: string;
+    path?: string;
+    line?: number;
+};
+export type ArchitectureComponentV2 = {
+    id: string;
+    name: string;
+    kind: "application" | "api" | "worker" | "job" | "cli" | "sdk" | "database" | "storage" | "queue" | "cache" | "search" | "external-service";
+    boundary: "deployment" | "runtime" | "logical" | "external";
+    workspace: string | null;
+    technology: string[];
+    environment: "production" | "development" | "both";
+    optional: boolean;
+    confidence: "high" | "medium";
+    evidence: ArchitectureEvidenceV2[];
+    files: string[];
+    details: ArchitectureDetailV2[];
+};
+export type ArchitectureConnectionV2 = {
+    id: string;
+    from: string;
+    to: string;
+    label: string;
+    kind: "http" | "rpc" | "database" | "storage" | "queue" | "cache" | "sdk" | "webhook" | "runtime-call" | "build-time";
+    runtime: boolean;
+    optional: boolean;
+    confidence: "high" | "medium";
+    evidence: ArchitectureEvidenceV2[];
+};
+export type ArchitectureGraphV2 = {
+    schema_version: 2;
+    scanner_version: string;
+    components: ArchitectureComponentV2[];
+    connections: ArchitectureConnectionV2[];
+    inventory: {
+        dependencies: string[];
+        dev_dependencies: string[];
+        frameworks: string[];
+        routes: string[];
+        scripts: string[];
+        environment_variables: string[];
+        docker_services: string[];
+    };
+    coverage: {
+        languages: string[];
+        frameworks: string[];
+        skipped: string[];
+        unsupported: string[];
+        warnings: string[];
+        git_available: boolean;
+        truncated: boolean;
+    };
+};
+export type Graph = ArchitectureGraphV2;
+export type Change = {
+    type: "added" | "removed" | "changed";
+    entity: "component" | "connection";
+    id: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryjourney/architecture",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Deterministic, privacy-preserving architecture scanning for Journey",
   "keywords": [
     "journey",
@@ -28,14 +28,14 @@
     "url": "https://github.com/dharunvs/tryjourney.dev/issues"
   },
   "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^24.0.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.0"
-  },
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "test": "tsx --test test/*.test.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.0"
   }
-}
+}