archsync 1.0.0 → 1.0.2

package/src/__tests__/scan-pipeline.test.js

@@ -1,332 +0,0 @@
-/**
- * Integration tests for the Scan → Push pipeline.
- *
- * Strategy:
- *  - Write real fixture files to a temp directory using os.tmpdir()
- *  - Invoke `parseFile` (used internally by scan) on them
- *  - Run `buildSchema` to build the schema from parsed results
- *  - Assert the schema has the expected nodes and edges
- *  - Mock the `pushSchemaCommit` function and verify it receives the correct schema
- *  - Clean up the temp directory after each test
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { parseFile } from '../parsers/index.js';
-import { buildSchema } from '../core/schemaBuilder.js';
-import { hashSchema } from '../core/hashEngine.js';
-
-// ─── Temp directory helpers ──────────────────────────────────
-
-let tmpDir;
-
-function createTmpDir() {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'archsync-test-'));
-    return tmpDir;
-}
-
-function removeTmpDir() {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-}
-
-function writeTmpFile(relativePath, content) {
-    const fullPath = path.join(tmpDir, relativePath);
-    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-    fs.writeFileSync(fullPath, content, 'utf-8');
-    return fullPath;
-}
-
-// ─── Fixture source code ─────────────────────────────────────
-
-const REACT_PAGE = `
-import React from 'react';
-import Header from './Header';
-
-export default function DashboardPage() {
-    return (
-        <div>
-            <Header />
-        </div>
-    );
-}
-`;
-
-const REACT_COMPONENT = `
-export function Header() {
-    return <header>ArchSync</header>;
-}
-`;
-
-const EXPRESS_ROUTES = `
-const router = require('express').Router();
-router.get('/users', getUsers);
-router.post('/users', createUser);
-router.get('/users/:id', getUserById);
-router.delete('/users/:id', deleteUser);
-module.exports = router;
-`;
-
-const EXPRESS_SERVICE = `
-// /backend/services/userService.js
-export class UserService {
-    async findAll() {}
-    async findById(id) {}
-    async create(data) {}
-}
-`;
-
-const EXPRESS_CONTROLLER = `
-// /backend/controllers/userController.js
-export const getUsers = async (req, res) => res.json([]);
-export const createUser = async (req, res) => res.json({});
-export const getUserById = async (req, res) => res.json({});
-export const deleteUser = async (req, res) => res.status(204).end();
-`;
-
-const MONGOOSE_MODEL = `
-import mongoose from 'mongoose';
-const userSchema = new mongoose.Schema({ name: String, email: String });
-const User = mongoose.model('User', userSchema);
-export default User;
-`;
-
-// ─── Tests ───────────────────────────────────────────────────
-
-describe('scan pipeline — parseFile on fixture files', () => {
-    beforeEach(() => { createTmpDir(); });
-    afterEach(() => { removeTmpDir(); });
-
-    it('parseFile extracts React components from a .jsx page file', () => {
-        const filePath = writeTmpFile('web/pages/DashboardPage.jsx', REACT_PAGE);
-        const result = parseFile(filePath, { framework: 'react' });
-
-        expect(result.entities.length).toBeGreaterThan(0);
-        const comp = result.entities.find(e => e.name === 'DashboardPage');
-        expect(comp).toBeDefined();
-        expect(comp.entityType).toBe('screen');
-    });
-
-    it('parseFile extracts Express routes from a route file', () => {
-        const filePath = writeTmpFile('backend/routes/userRoutes.js', EXPRESS_ROUTES);
-        const result = parseFile(filePath, { framework: 'express' });
-
-        const routes = result.entities.filter(e => e.entityType === 'route');
-        expect(routes.length).toBeGreaterThanOrEqual(4);
-        const methods = routes.map(r => r.data.method);
-        expect(methods).toContain('GET');
-        expect(methods).toContain('POST');
-        expect(methods).toContain('DELETE');
-    });
-
-    it('parseFile extracts service classes from a service file', () => {
-        const filePath = writeTmpFile('backend/services/userService.js', EXPRESS_SERVICE);
-        const result = parseFile(filePath, { framework: 'node' });
-
-        const svc = result.entities.find(e => e.name === 'UserService');
-        expect(svc).toBeDefined();
-        expect(svc.entityType).toBe('service');
-    });
-
-    it('parseFile extracts controller functions from a controller file', () => {
-        const filePath = writeTmpFile('backend/controllers/userController.js', EXPRESS_CONTROLLER);
-        const result = parseFile(filePath, { framework: 'node' });
-
-        const controllers = result.entities.filter(e => e.entityType === 'controller');
-        expect(controllers.length).toBeGreaterThanOrEqual(3);
-    });
-
-    it('parseFile extracts Mongoose model from a model file', () => {
-        const filePath = writeTmpFile('backend/models/User.model.js', MONGOOSE_MODEL);
-        const result = parseFile(filePath, { framework: 'node' });
-
-        const model = result.entities.find(e => e.name === 'User');
-        expect(model).toBeDefined();
-        expect(model.entityType).toBe('model');
-    });
-});
-
-describe('scan pipeline — buildSchema from multiple parsed files', () => {
-    beforeEach(() => { createTmpDir(); });
-    afterEach(() => { removeTmpDir(); });
-
-    it('buildSchema produces a valid schema with nodes and meta', () => {
-        const routesPath = writeTmpFile('backend/routes/userRoutes.js', EXPRESS_ROUTES);
-        const modelPath = writeTmpFile('backend/models/User.model.js', MONGOOSE_MODEL);
-
-        const parsed = [
-            parseFile(routesPath, { framework: 'node' }),
-            parseFile(modelPath, { framework: 'node' }),
-        ];
-
-        const schema = buildSchema(parsed);
-        expect(schema).toHaveProperty('nodes');
-        expect(schema).toHaveProperty('edges');
-        expect(schema).toHaveProperty('meta');
-        expect(schema.nodes.length).toBeGreaterThan(0);
-    });
-
-    it('buildSchema assigns stable (deterministic) IDs to nodes', () => {
-        const filePath = writeTmpFile('backend/routes/userRoutes.js', EXPRESS_ROUTES);
-        const parsed = [parseFile(filePath, { framework: 'node' })];
-
-        const schema1 = buildSchema(parsed);
-        const schema2 = buildSchema(parsed);
-
-        const ids1 = schema1.nodes.map(n => n.id).sort();
-        const ids2 = schema2.nodes.map(n => n.id).sort();
-        expect(ids1).toEqual(ids2);
-    });
-
-    it('buildSchema deduplicates nodes with identical entityType/name/system', () => {
-        const routesPath = writeTmpFile('backend/routes/userRoutes.js', EXPRESS_ROUTES);
-
-        // Parse the same file twice (simulates duplicate detection)
-        const p1 = parseFile(routesPath, { framework: 'node' });
-        const p2 = parseFile(routesPath, { framework: 'node' });
-
-        const schema = buildSchema([p1, p2]);
-        const uniqueIds = new Set(schema.nodes.map(n => n.id));
-        expect(uniqueIds.size).toBe(schema.nodes.length);
-    });
-
-    it('buildSchema meta reflects correct node and file counts', () => {
-        const routesPath = writeTmpFile('backend/routes/userRoutes.js', EXPRESS_ROUTES);
-        const modelPath = writeTmpFile('backend/models/User.model.js', MONGOOSE_MODEL);
-
-        const parsed = [
-            parseFile(routesPath, { framework: 'node' }),
-            parseFile(modelPath, { framework: 'node' }),
-        ];
-
-        const schema = buildSchema(parsed);
-        expect(schema.meta.fileCount).toBe(2);
-        expect(schema.meta.nodeCount).toBe(schema.nodes.length);
-        expect(schema.meta.edgeCount).toBe(schema.edges.length);
-    });
-
-    it('each schema node has required fields: id, entityType, system, text', () => {
-        const filePath = writeTmpFile('backend/routes/userRoutes.js', EXPRESS_ROUTES);
-        const schema = buildSchema([parseFile(filePath, { framework: 'node' })]);
-
-        for (const node of schema.nodes) {
-            expect(node).toHaveProperty('id');
-            expect(node).toHaveProperty('entityType');
-            expect(node).toHaveProperty('system');
-            expect(node).toHaveProperty('text');
-        }
-    });
-
-    it('buildSchema for an empty parsed-files list returns empty schema', () => {
-        const schema = buildSchema([]);
-        expect(schema.nodes).toHaveLength(0);
-        expect(schema.edges).toHaveLength(0);
-    });
-});
-
-describe('scan pipeline — hashSchema', () => {
-    it('produces a consistent hash for the same schema', () => {
-        const schema = {
-            nodes: [
-                { entityType: 'route', system: 'backend', text: 'GET /users', data: {}, metadata: {} },
-            ],
-            edges: [],
-        };
-        expect(hashSchema(schema)).toBe(hashSchema(schema));
-    });
-
-    it('produces different hashes for different schemas', () => {
-        const schema1 = {
-            nodes: [{ entityType: 'route', system: 'backend', text: 'GET /users', data: {}, metadata: {} }],
-            edges: [],
-        };
-        const schema2 = {
-            nodes: [{ entityType: 'service', system: 'backend', text: 'UserService', data: {}, metadata: {} }],
-            edges: [],
-        };
-        expect(hashSchema(schema1)).not.toBe(hashSchema(schema2));
-    });
-
-    it('returns a hex string of length 64 (sha256)', () => {
-        const schema = { nodes: [], edges: [] };
-        const hash = hashSchema(schema);
-        expect(hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-});
-
-describe('scan pipeline — push mock', () => {
-    beforeEach(() => { createTmpDir(); });
-    afterEach(() => { removeTmpDir(); });
-
-    it('mock pushSchemaCommit is called with the built schema', async () => {
-        const filePath = writeTmpFile('backend/routes/userRoutes.js', EXPRESS_ROUTES);
-        const schema = buildSchema([parseFile(filePath, { framework: 'node' })]);
-
-        // Mock the push function
-        const pushMock = vi.fn().mockResolvedValue({ id: 'commit-abc-123', branch: 'main' });
-
-        const result = await pushMock('mock-project-id', 'main', schema, 'Test push');
-
-        expect(pushMock).toHaveBeenCalledTimes(1);
-        expect(pushMock).toHaveBeenCalledWith(
-            'mock-project-id',
-            'main',
-            schema,
-            'Test push'
-        );
-        expect(result.id).toBe('commit-abc-123');
-    });
-
-    it('push receives schema with correct node count for a React + Express project', () => {
-        const reactPath = writeTmpFile('web/pages/DashboardPage.jsx', REACT_PAGE);
-        const routesPath = writeTmpFile('backend/routes/userRoutes.js', EXPRESS_ROUTES);
-        const modelPath = writeTmpFile('backend/models/User.model.js', MONGOOSE_MODEL);
-
-        const parsed = [
-            parseFile(reactPath, { framework: 'react' }),
-            parseFile(routesPath, { framework: 'node' }),
-            parseFile(modelPath, { framework: 'node' }),
-        ];
-
-        const schema = buildSchema(parsed);
-        const pushMock = vi.fn();
-
-        pushMock(schema);
-
-        const receivedSchema = pushMock.mock.calls[0][0];
-        // Should have nodes from React (screen), routes, and model
-        expect(receivedSchema.nodes.length).toBeGreaterThan(3);
-
-        const types = receivedSchema.nodes.map(n => n.entityType);
-        expect(types).toContain('screen');
-        expect(types).toContain('route');
-        expect(types).toContain('model');
-    });
-
-    it('schema passed to push includes a generated hash', () => {
-        const filePath = writeTmpFile('backend/routes/userRoutes.js', EXPRESS_ROUTES);
-        const schema = buildSchema([parseFile(filePath, { framework: 'node' })]);
-        schema.hash = hashSchema(schema);
-
-        const pushMock = vi.fn();
-        pushMock(schema);
-
-        const receivedSchema = pushMock.mock.calls[0][0];
-        expect(receivedSchema.hash).toBeTruthy();
-        expect(receivedSchema.hash).toMatch(/^[a-f0-9]{64}$/);
-    });
-
-    it('push is not called when schema has zero nodes (guard check)', () => {
-        const emptySchema = buildSchema([]);
-        const pushMock = vi.fn();
-
-        if (emptySchema.nodes.length > 0) {
-            pushMock(emptySchema);
-        }
-
-        expect(pushMock).not.toHaveBeenCalled();
-    });
-});

package/src/__tests__/schemaBuilder.test.js

@@ -1,145 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildSchema, diffSchemas } from '../core/schemaBuilder.js';
-
-// ─── Helpers ────────────────────────────────────────────────
-function makeFileResult(filePath, entities = [], relations = []) {
-    return { filePath, entities, relations };
-}
-
-function makeEntity(name, entityType, system = 'backend') {
-    return { name, entityType, system };
-}
-
-// ─── buildSchema ─────────────────────────────────────────────
-describe('buildSchema', () => {
-    it('returns a schema with empty nodes and edges for no parsed files', () => {
-        const schema = buildSchema([]);
-        expect(schema.nodes).toEqual([]);
-        expect(schema.edges).toEqual([]);
-        expect(schema.meta.nodeCount).toBe(0);
-    });
-
-    it('builds the correct node count from parsed files', () => {
-        const files = [
-            makeFileResult('src/auth.js', [
-                makeEntity('AuthService', 'service'),
-                makeEntity('AuthController', 'controller'),
-            ]),
-            makeFileResult('src/user.js', [
-                makeEntity('UserService', 'service'),
-            ]),
-        ];
-        const schema = buildSchema(files);
-        expect(schema.nodes).toHaveLength(3);
-        expect(schema.meta.nodeCount).toBe(3);
-        expect(schema.meta.fileCount).toBe(2);
-    });
-
-    it('deduplicates same-named entities within one file, keeps them distinct across files', () => {
-        const duplicateEntity = makeEntity('SharedService', 'service', 'backend');
-        // Same file → one node
-        const sameFile = buildSchema([
-            makeFileResult('src/a.js', [duplicateEntity, { ...duplicateEntity }]),
-        ]);
-        expect(sameFile.nodes).toHaveLength(1);
-        // Different files → two nodes (two `main.py`/`index.js` files must
-        // never merge into one)
-        const twoFiles = buildSchema([
-            makeFileResult('src/a.js', [duplicateEntity]),
-            makeFileResult('src/b.js', [{ ...duplicateEntity }]),
-        ]);
-        expect(twoFiles.nodes).toHaveLength(2);
-    });
-
-    it('still merges name-identity types (api/route) across files', () => {
-        const apiRef = makeEntity('GET /api/users', 'api', 'backend');
-        const schema = buildSchema([
-            makeFileResult('src/a.js', [apiRef]),
-            makeFileResult('src/b.js', [{ ...apiRef }]),
-        ]);
-        expect(schema.nodes).toHaveLength(1);
-    });
-
-    it('assigns the entity system from the entity data', () => {
-        const files = [
-            makeFileResult('src/app/Screen.jsx', [makeEntity('HomeScreen', 'screen', 'app')]),
-            makeFileResult('src/backend/svc.js', [makeEntity('UserService', 'service', 'backend')]),
-        ];
-        const schema = buildSchema(files);
-        const homeScreen = schema.nodes.find(n => n.text === 'HomeScreen');
-        const userService = schema.nodes.find(n => n.text === 'UserService');
-        expect(homeScreen.system).toBe('app');
-        expect(userService.system).toBe('backend');
-    });
-
-    it('falls back to config.defaultSystem when entity has no system', () => {
-        const files = [
-            makeFileResult('src/x.js', [{ name: 'UnknownService', entityType: 'service' }]),
-        ];
-        const schema = buildSchema(files, { defaultSystem: 'web' });
-        expect(schema.nodes[0].system).toBe('web');
-    });
-
-    it('falls back to "backend" when no system and no config.defaultSystem', () => {
-        const files = [
-            makeFileResult('src/x.js', [{ name: 'GenericService', entityType: 'service' }]),
-        ];
-        const schema = buildSchema(files);
-        expect(schema.nodes[0].system).toBe('backend');
-    });
-
-    it('assigns stable deterministic IDs (same input = same ID)', () => {
-        const files = [makeFileResult('src/svc.js', [makeEntity('MyService', 'service', 'backend')])];
-        const schema1 = buildSchema(files);
-        const schema2 = buildSchema(files);
-        expect(schema1.nodes[0].id).toBe(schema2.nodes[0].id);
-    });
-
-    it('stores the source file path in node metadata', () => {
-        const files = [makeFileResult('src/auth.js', [makeEntity('AuthService', 'service')])];
-        const schema = buildSchema(files);
-        expect(schema.nodes[0].metadata.sourceFile).toBe('src/auth.js');
-    });
-
-    it('includes generated meta fields', () => {
-        const schema = buildSchema([]);
-        expect(schema.meta.generatedAt).toBeDefined();
-        expect(schema.meta.source).toBe('archsync-cli');
-    });
-});
-
-// ─── diffSchemas ─────────────────────────────────────────────
-describe('diffSchemas', () => {
-    it('returns all nodes as added when base is null', () => {
-        const incoming = {
-            nodes: [{ id: 'n1', text: 'A', entityType: 'service', data: {} }],
-        };
-        const diff = diffSchemas(null, incoming);
-        expect(diff.added).toHaveLength(1);
-        expect(diff.added[0].status).toBe('added');
-    });
-
-    it('returns all nodes as deleted when incoming is null', () => {
-        const base = {
-            nodes: [{ id: 'n1', text: 'A', entityType: 'service', data: {} }],
-        };
-        const diff = diffSchemas(base, null);
-        expect(diff.deleted).toHaveLength(1);
-        expect(diff.deleted[0].status).toBe('deleted');
-    });
-
-    it('detects unchanged nodes', () => {
-        const node = { id: 'n1', text: 'A', entityType: 'service', data: {} };
-        const schema = { nodes: [node] };
-        const diff = diffSchemas(schema, schema);
-        expect(diff.unchanged).toHaveLength(1);
-    });
-
-    it('detects modified nodes when text changes', () => {
-        const base = { nodes: [{ id: 'n1', text: 'OldName', entityType: 'service', data: {} }] };
-        const incoming = { nodes: [{ id: 'n1', text: 'NewName', entityType: 'service', data: {} }] };
-        const diff = diffSchemas(base, incoming);
-        expect(diff.modified).toHaveLength(1);
-        expect(diff.modified[0].text).toBe('NewName');
-    });
-});

package/src/__tests__/workspace.test.js

@@ -1,178 +0,0 @@
-/**
- * End-to-end test for multi-project workspace scanning:
- * a Node/Express backend, a Flutter app, and a React admin side-by-side,
- * scanned together and cross-linked by API method+path.
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { detectWorkspaceProjects, detectProjectFramework, includePatternsFor } from '../core/workspaceDetector.js';
-import { parseFile } from '../parsers/index.js';
-import { buildRelationships } from '../core/relationshipEngine.js';
-import { buildSchema } from '../core/schemaBuilder.js';
-
-let root;
-
-function write(rel, content) {
-    const full = path.join(root, rel);
-    fs.mkdirSync(path.dirname(full), { recursive: true });
-    fs.writeFileSync(full, content);
-}
-
-beforeAll(() => {
-    root = fs.mkdtempSync(path.join(os.tmpdir(), 'archsync-ws-'));
-
-    // ── Node/Express backend ──────────────────────────────
-    write('backend/package.json', JSON.stringify({ name: 'be', dependencies: { express: '^4.0.0' } }));
-    write('backend/server.js', `
-const express = require('express');
-const userRoutes = require('./routes/user.routes');
-const app = express();
-app.use('/api/users', userRoutes);
-app.listen(3000);
-`);
-    write('backend/routes/user.routes.js', `
-const express = require('express');
-const { listUsers, getUser } = require('../controllers/user.controller');
-const router = express.Router();
-router.get('/', listUsers);
-router.get('/:id', getUser);
-module.exports = router;
-`);
-    write('backend/controllers/user.controller.js', `
-const UserService = require('../services/user.service');
-async function listUsers(req, res) { res.json(await UserService.findAll()); }
-async function getUser(req, res) { res.json(await UserService.findById(req.params.id)); }
-module.exports = { listUsers, getUser };
-`);
-    write('backend/services/user.service.js', `
-const User = require('../models/user.model');
-class UserService {
-    static findAll() { return User.find({}); }
-    static findById(id) { return User.findById(id); }
-}
-module.exports = UserService;
-`);
-    write('backend/models/user.model.js', `
-const mongoose = require('mongoose');
-module.exports = mongoose.model('User', new mongoose.Schema({ email: String }));
-`);
-
-    // ── Flutter app ───────────────────────────────────────
-    write('mobile_app/pubspec.yaml', 'name: demo_mobile\n');
-    write('mobile_app/lib/screens/profile_screen.dart', `
-import 'package:http/http.dart' as http;
-class ProfileScreen extends StatelessWidget {
-  Future<void> load(String id) async {
-    await http.get(Uri.parse('https://api.example.com/api/users/\$id'));
-  }
-}
-`);
-
-    // ── React admin ───────────────────────────────────────
-    write('admin/package.json', JSON.stringify({ name: 'admin', dependencies: { react: '^18.0.0', axios: '^1.0.0' } }));
-    write('admin/src/pages/UsersPage.jsx', `
-import axios from 'axios';
-export default function UsersPage() {
-    const load = () => axios.get('/api/users');
-    return <div onClick={load}>users</div>;
-}
-`);
-});
-
-afterAll(() => {
-    fs.rmSync(root, { recursive: true, force: true });
-});
-
-describe('workspaceDetector', () => {
-    it('detects all three project types with correct frameworks and systems', () => {
-        const projects = detectWorkspaceProjects(root);
-        const byName = Object.fromEntries(projects.map(p => [p.name, p]));
-
-        expect(byName.backend).toMatchObject({ framework: 'express', system: 'backend' });
-        expect(byName.mobile_app).toMatchObject({ framework: 'flutter', system: 'mobile_app' });
-        expect(byName.admin).toMatchObject({ framework: 'react', system: 'admin' });
-    });
-
-    it('classifies single project dirs', () => {
-        expect(detectProjectFramework(path.join(root, 'backend'))).toBe('express');
-        expect(detectProjectFramework(path.join(root, 'mobile_app'))).toBe('flutter');
-        expect(detectProjectFramework(path.join(root, 'admin'))).toBe('react');
-        expect(detectProjectFramework(root)).toBeNull();
-    });
-
-    it('scopes flutter scans to lib/**.dart', () => {
-        expect(includePatternsFor('flutter')).toEqual(['lib/**/*.dart']);
-    });
-});
-
-describe('workspace scan pipeline', () => {
-    function scanWorkspace() {
-        const projects = detectWorkspaceProjects(root);
-        const allParsed = [];
-        const exts = { express: /\.(js|ts)$/, flutter: /\.dart$/, react: /\.(jsx?|tsx?)$/ };
-
-        for (const project of projects) {
-            const stack = [project.path];
-            while (stack.length) {
-                const dir = stack.pop();
-                for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-                    const full = path.join(dir, entry.name);
-                    if (entry.isDirectory()) { stack.push(full); continue; }
-                    if (!exts[project.framework].test(entry.name)) continue;
-                    const result = parseFile(full, { framework: project.framework });
-                    if (result.entities.length || result.relations.length) {
-                        for (const e of result.entities) e.system = project.system;
-                        allParsed.push(result);
-                    }
-                }
-            }
-        }
-
-        const relations = buildRelationships(allParsed);
-        return buildSchema(allParsed, { defaultSystem: 'backend' }, relations);
-    }
-
-    it('produces a multi-system schema with no dangling edges', () => {
-        const schema = scanWorkspace();
-
-        expect(schema.multiSystem).toBe(true);
-        expect(schema.systems.sort()).toEqual(['admin', 'backend', 'mobile_app']);
-
-        const ids = new Set(schema.nodes.map(n => n.id));
-        for (const edge of schema.edges) {
-            expect(ids.has(edge.source)).toBe(true);
-            expect(ids.has(edge.target)).toBe(true);
-        }
-    });
-
-    it('composes public route paths from app.use() mounts', () => {
-        const schema = scanWorkspace();
-        const routeTexts = schema.nodes.filter(n => n.entityType === 'route').map(n => n.text);
-        expect(routeTexts).toContain('GET /api/users');
-        expect(routeTexts).toContain('GET /api/users/:id');
-    });
-
-    it('cross-links the Flutter app and React admin to backend routes', () => {
-        const schema = scanWorkspace();
-        const byId = new Map(schema.nodes.map(n => [n.id, n]));
-        const cross = schema.edges
-            .filter(e => e.isCrossSystem)
-            .map(e => `${byId.get(e.source).system}:${byId.get(e.source).text} -> ${byId.get(e.target).system}:${byId.get(e.target).text}`);
-
-        expect(cross).toContain('admin:GET /api/users -> backend:GET /api/users');
-        expect(cross.some(c => c.startsWith('mobile_app:GET /api/users/') && c.endsWith('backend:GET /api/users/:id'))).toBe(true);
-    });
-
-    it('keeps the backend chain route → controller → service → model intact', () => {
-        const schema = scanWorkspace();
-        const byId = new Map(schema.nodes.map(n => [n.id, n]));
-        const rels = schema.edges.map(e => `${byId.get(e.source).text} -[${e.relation}]-> ${byId.get(e.target).text}`);
-
-        expect(rels).toContain('GET /api/users -[handles]-> listUsers');
-        expect(rels).toContain('listUsers -[uses]-> UserService');
-        expect(rels).toContain('UserService -[queries]-> User');
-    });
-});