@tryjourney/architecture 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Journey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# Journey architecture
+
+`@tryjourney/architecture` deterministically scans a repository into a bounded
+architecture graph. It records only derived component, connection, technology,
+and relative-path evidence metadata; it does not include source contents,
+environment values, absolute paths, or file modification times.
+
+It is used by `@tryjourney/cli` to observe project architecture while Journey
+MCP is running.

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+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;
+};
+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

@@ -0,0 +1,81 @@
+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"))
+                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(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"]);
+    }
+    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 });
+    }
+    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("/")) : [];
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@tryjourney/architecture",
+  "version": "0.1.0",
+  "description": "Deterministic, privacy-preserving architecture scanning for Journey",
+  "keywords": [
+    "journey",
+    "architecture",
+    "scanner"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dharunvs/tryjourney.dev.git",
+    "directory": "packages/architecture"
+  },
+  "homepage": "https://tryjourney.dev",
+  "bugs": {
+    "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"
+  }
+}