archsync 1.0.0 → 1.0.2

package/src/commands/scan.js

@@ -1,498 +0,0 @@
-import chalk from 'chalk';
-import ora from 'ora';
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-import { glob } from 'glob';
-import { readConfig } from '../core/supabaseClient.js';
-import { parseFile, moduleFallbackEntity } from '../parsers/index.js';
-import { buildSchema } from '../core/schemaBuilder.js';
-import { buildRelationships } from '../core/relationshipEngine.js';
-import { hashSchema } from '../core/hashEngine.js';
-import {
-    detectWorkspaceProjects,
-    includePatternsFor,
-    WORKSPACE_EXCLUDES,
-} from '../core/workspaceDetector.js';
-import { analyzeImpact, embedWarnings } from '../core/impactEngine.js';
-import { printImpactWarnings } from './impactReport.js';
-
-const LOCAL_SCHEMA_FILE = '.archsync-schema.json';
-
-/**
- * Run `git diff --name-only HEAD~1` in cwd and return absolute paths of changed files.
- * Returns null if git is unavailable or there is no history.
- */
-function getGitChangedFiles(cwd) {
-    try {
-        const output = execSync('git diff --name-only HEAD~1', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
-        return output
-            .split('\n')
-            .map(f => f.trim())
-            .filter(Boolean)
-            .map(f => path.resolve(cwd, f));
-    } catch {
-        // No git history or git not available
-        return null;
-    }
-}
-
-export async function scanCommand(options) {
-    const debug = options.debug || false;
-    const incremental = options.incremental || false;
-
-    console.log(chalk.blue.bold('\n🔍 ArchSync CLI — Scanning Codebase\n'));
-
-    if (options.workspace) {
-        return workspaceScan(options);
-    }
-
-    const config = readConfig(options.dir);
-    if (!config) {
-        // No project config — if this directory holds several projects
-        // (backend + app + admin …), fall through to workspace mode instead
-        // of demanding an init nobody ran yet.
-        const projects = detectWorkspaceProjects(path.resolve(options.dir || '.'));
-        if (projects.length >= 2) {
-            console.log(chalk.cyan('No .archsync.json found, but this looks like a multi-project workspace:'));
-            for (const p of projects) {
-                console.log(chalk.gray(`  • ${p.name} (${p.framework}) → system "${p.system}"`));
-            }
-            console.log(chalk.cyan('Running workspace scan. Use `archsync scan --workspace` to do this explicitly.\n'));
-            return workspaceScan(options);
-        }
-        console.log(chalk.red('❌ No .archsync.json found. Run `archsync init` first.'));
-        process.exit(1);
-    }
-
-    const cwd = path.resolve(options.dir || '.');
-    const schemaPath = path.resolve(cwd, LOCAL_SCHEMA_FILE);
-    const spinner = ora('Discovering files...').start();
-
-    const includePatterns = config.scan?.include || [options.include || '**/*.{js,ts,jsx,tsx,dart,py,go,java,kt}'];
-    const excludePatterns = config.scan?.exclude || [options.exclude || '**/node_modules/**'];
-
-    // ─── Incremental mode ─────────────────────────────────────
-    let incrementalMode = false;
-    let cachedSchema = null;
-    let changedFiles = null;
-
-    if (incremental) {
-        changedFiles = getGitChangedFiles(cwd);
-        if (!changedFiles) {
-            spinner.warn('No git history found — falling back to full scan.');
-        } else if (changedFiles.length === 0) {
-            spinner.info('No changed files since last commit. Schema is up to date.');
-            return;
-        } else if (fs.existsSync(schemaPath)) {
-            try {
-                cachedSchema = JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
-                incrementalMode = true;
-                spinner.text = `Incremental: scanning ${changedFiles.length} changed file(s)...`;
-            } catch {
-                spinner.warn('Cached schema unreadable — falling back to full scan.');
-            }
-        } else {
-            spinner.warn('No cached schema found — falling back to full scan.');
-        }
-    }
-
-    // ─── File discovery ────────────────────────────────────────
-    let files = [];
-
-    if (incrementalMode) {
-        // Only scan the git-changed files that match include patterns
-        const includeExts = /\.(js|ts|jsx|tsx|dart|prisma)$/;
-        files = changedFiles.filter(f => {
-            if (!includeExts.test(f)) return false;
-            // Apply exclude patterns
-            const rel = path.relative(cwd, f);
-            const isExcluded = rel.includes('node_modules') || rel.includes('dist') || rel.includes('build');
-            return !isExcluded;
-        }).filter(f => fs.existsSync(f));
-    } else {
-        for (const pattern of includePatterns) {
-            const matched = await glob(pattern, {
-                cwd,
-                ignore: excludePatterns,
-                absolute: true,
-            });
-            files.push(...matched);
-        }
-        files = [...new Set(files)];
-    }
-
-    spinner.text = `Parsing ${files.length} files${incrementalMode ? ' (incremental)' : ''}...`;
-
-    const parsedFiles = [];
-    let errorCount = 0;
-    const errorFiles = [];
-
-    for (const file of files) {
-        try {
-            const result = parseFile(file, {
-                ast: options.ast || config.scan?.ast,
-                framework: config.framework,
-            });
-            // CodeSee-style: a source file with no recognised entities still
-            // becomes a `module` node so import arrows can reach it.
-            if (result.entities.length === 0) {
-                const fallback = moduleFallbackEntity(file, config.defaultSystem);
-                if (fallback) result.entities.push(fallback);
-            }
-            // `--system <label>` from init is AUTHORITATIVE for this project.
-            // Parsers guess systems from path heuristics ('app', 'web', …) and
-            // would otherwise scatter one project across several systems.
-            // Genuine backend entities (route handlers, cloud functions) keep
-            // their label so cross-system API matching still works.
-            if (config.defaultSystem) {
-                for (const entity of result.entities) {
-                    if (entity.system !== 'backend' || config.defaultSystem === 'backend') {
-                        entity.system = config.defaultSystem;
-                    }
-                }
-            }
-            if (result.entities.length > 0 || result.relations.length > 0) {
-                parsedFiles.push(result);
-            }
-        } catch (err) {
-            errorCount++;
-            errorFiles.push({ file, error: err.message });
-        }
-    }
-
-    spinner.text = 'Building schema & relationships...';
-
-    let schema;
-
-    if (incrementalMode && cachedSchema) {
-        // Merge: remove stale entries from changed files, then add freshly parsed ones
-        const changedFileSet = new Set(changedFiles.map(f => f.replace(/\\/g, '/')));
-
-        const staleNodeIds = new Set(
-            (cachedSchema.nodes || [])
-                .filter(n => {
-                    const src = n.metadata?.sourceFile || '';
-                    return changedFileSet.has(src.replace(/\\/g, '/'));
-                })
-                .map(n => n.id)
-        );
-
-        const survivingNodes = (cachedSchema.nodes || []).filter(n => !staleNodeIds.has(n.id));
-        const survivingEdges = (cachedSchema.edges || []).filter(
-            e => !staleNodeIds.has(e.source) && !staleNodeIds.has(e.target)
-        );
-
-        // Build a mini-schema from only the changed files. Cross-file
-        // relations are resolved inside buildSchema against the fresh nodes.
-        const freshRelations = buildRelationships(parsedFiles, debug);
-        const freshSchema = buildSchema(parsedFiles, { ...config, debug }, freshRelations);
-
-        schema = {
-            ...cachedSchema,
-            nodes: [...survivingNodes, ...freshSchema.nodes],
-            edges: [...survivingEdges, ...freshSchema.edges],
-            meta: {
-                ...cachedSchema.meta,
-                nodeCount: survivingNodes.length + freshSchema.nodes.length,
-                edgeCount: survivingEdges.length + freshSchema.edges.length,
-                incrementalAt: new Date().toISOString(),
-            },
-        };
-    } else {
-        // Infer cross-file relationships (route→controller→service→model)
-        // first — PASS 0 composes public route paths that the schema builder
-        // must see — then resolve every relation to node ids in buildSchema.
-        const inferredRelations = buildRelationships(parsedFiles, debug);
-        schema = buildSchema(parsedFiles, { ...config, debug }, inferredRelations);
-    }
-
-    schema.hash = hashSchema(schema);
-
-    // Impact analysis against the previous snapshot. Warnings are embedded
-    // AFTER hashing so an unchanged architecture keeps a stable hash.
-    let previousSchema = null;
-    if (fs.existsSync(schemaPath)) {
-        try { previousSchema = JSON.parse(fs.readFileSync(schemaPath, 'utf-8')); } catch { /* corrupt cache — skip */ }
-    }
-    const impactWarnings = analyzeImpact(previousSchema, schema);
-    embedWarnings(schema, impactWarnings);
-
-    // Save locally
-    fs.writeFileSync(schemaPath, JSON.stringify(schema, null, 2));
-
-    spinner.succeed(`Scan complete!${incrementalMode ? chalk.gray(' (incremental)') : ''}`);
-
-    // ─── Summary Report ──────────────────────────────────────
-    console.log(chalk.gray('\n╔══════════════════════════════════════╗'));
-    console.log(chalk.gray('║') + chalk.white.bold('       Scan Results Summary           ') + chalk.gray('║'));
-    console.log(chalk.gray('╠══════════════════════════════════════╣'));
-    console.log(chalk.gray('║') + chalk.white(`  Files scanned:  ${chalk.bold(String(files.length).padStart(6))}            `) + chalk.gray('║'));
-    console.log(chalk.gray('║') + chalk.white(`  Files parsed:   ${chalk.bold(String(parsedFiles.length).padStart(6))}            `) + chalk.gray('║'));
-    console.log(chalk.gray('║') + chalk.green(`  Entities found: ${chalk.bold(String(schema.nodes.length).padStart(6))}            `) + chalk.gray('║'));
-    console.log(chalk.gray('║') + chalk.blue(`  Relations:      ${chalk.bold(String(schema.edges.length).padStart(6))}            `) + chalk.gray('║'));
-    if (incrementalMode) {
-        console.log(chalk.gray('║') + chalk.cyan(`  Mode:            incremental         `) + chalk.gray('║'));
-    }
-    if (errorCount > 0) {
-        console.log(chalk.gray('║') + chalk.yellow(`  Parse errors:   ${chalk.bold(String(errorCount).padStart(6))}            `) + chalk.gray('║'));
-    }
-    console.log(chalk.gray('╚══════════════════════════════════════╝'));
-
-    // Entity breakdown by type
-    const typeCounts = {};
-    for (const node of schema.nodes) {
-        typeCounts[node.entityType] = (typeCounts[node.entityType] || 0) + 1;
-    }
-    console.log(chalk.gray('\n─── Entity Breakdown ───────────────'));
-    const typeIcons = {
-        route: '🛣 ', controller: '🎮', service: '⚙️ ', model: '📦', database: '🗄 ',
-        middleware: '🛡 ', mount: '📌', screen: '📱', widget: '🧩', api: '🌐',
-        worker: '👷', trigger: '⚡', config: '🔧', module: '📂',
-    };
-    for (const [type, count] of Object.entries(typeCounts).sort((a, b) => b[1] - a[1])) {
-        const icon = typeIcons[type] || '  ';
-        console.log(chalk.white(`  ${icon} ${type.padEnd(15)} ${chalk.bold(count)}`));
-    }
-
-    // Relation breakdown by type
-    const relCounts = {};
-    for (const edge of schema.edges) {
-        relCounts[edge.relation] = (relCounts[edge.relation] || 0) + 1;
-    }
-    if (Object.keys(relCounts).length > 0) {
-        console.log(chalk.gray('\n─── Relation Breakdown ─────────────'));
-        const relIcons = {
-            handles: '→ ', uses: '↗ ', queries: '⇢ ', extends: '⊃ ',
-            protected_by: '🛡 ', calls: '📡', consumes: '↓ ', stored_in: '💾',
-        };
-        for (const [rel, count] of Object.entries(relCounts).sort((a, b) => b[1] - a[1])) {
-            const icon = relIcons[rel] || '  ';
-            console.log(chalk.white(`  ${icon} ${rel.padEnd(15)} ${chalk.bold(count)}`));
-        }
-    }
-
-    // Entity by system
-    const sysCounts = {};
-    for (const node of schema.nodes) {
-        sysCounts[node.system] = (sysCounts[node.system] || 0) + 1;
-    }
-    if (Object.keys(sysCounts).length > 1) {
-        console.log(chalk.gray('\n─── Entities by System ─────────────'));
-        for (const [sys, count] of Object.entries(sysCounts).sort((a, b) => b[1] - a[1])) {
-            console.log(chalk.white(`  ${sys.padEnd(15)} ${chalk.bold(count)}`));
-        }
-    }
-
-    // Debug output
-    if (debug) {
-        console.log(chalk.gray('\n─── Debug: Parse Errors ────────────'));
-        if (errorFiles.length > 0) {
-            for (const { file, error } of errorFiles) {
-                console.log(chalk.red(`  ✗ ${path.relative('.', file)}: ${error}`));
-            }
-        } else {
-            console.log(chalk.green('  No parse errors'));
-        }
-
-        console.log(chalk.gray('\n─── Debug: Files with Entities ─────'));
-        for (const pf of parsedFiles.slice(0, 50)) {
-            const entTypes = [...new Set((pf.entities || []).map(e => e.entityType))].join(', ');
-            console.log(chalk.gray(`  ${path.relative('.', pf.filePath)} → ${chalk.white(entTypes)} (${pf.entities.length})`));
-        }
-        if (parsedFiles.length > 50) {
-            console.log(chalk.gray(`  ... and ${parsedFiles.length - 50} more files`));
-        }
-
-        console.log(chalk.gray('\n─── Debug: Sample Relations ────────'));
-        for (const edge of schema.edges.slice(0, 30)) {
-            const src = schema.nodes.find(n => n.id === edge.source);
-            const tgt = schema.nodes.find(n => n.id === edge.target);
-            console.log(chalk.gray(`  ${src?.text || '?'} → ${tgt?.text || '?'} [${edge.relation}]`));
-        }
-        if (schema.edges.length > 30) {
-            console.log(chalk.gray(`  ... and ${schema.edges.length - 30} more edges`));
-        }
-    }
-
-    printImpactWarnings(impactWarnings, { heading: 'Impact since last scan' });
-
-    console.log(chalk.gray(`\n  Schema saved to: ${schemaPath}`));
-    console.log(chalk.gray(`  Hash: ${schema.hash}`));
-
-    if (schema.edges.length === 0) {
-        console.log(chalk.yellow('\n⚠  No relations detected. Try running with --debug for details.'));
-    }
-
-    console.log(chalk.blue('\nNext: ') + chalk.gray('archsync push -b main'));
-}
-
-// ════════════════════════════════════════════════════════════════════
-// WORKSPACE SCAN — scan several sibling projects (Node backend, Flutter
-// app, React admin, …) in one pass and cross-link them.
-// ════════════════════════════════════════════════════════════════════
-async function workspaceScan(options) {
-    const debug = options.debug || false;
-    const cwd = path.resolve(options.dir || '.');
-
-    const projects = detectWorkspaceProjects(cwd);
-    if (projects.length === 0) {
-        console.log(chalk.red('❌ No projects found in this workspace.'));
-        console.log(chalk.gray('   A project is a folder with a package.json or pubspec.yaml.'));
-        process.exit(1);
-    }
-
-    console.log(chalk.white.bold('Workspace projects:'));
-    for (const p of projects) {
-        console.log(chalk.white(`  📁 ${p.name.padEnd(20)} ${chalk.gray(p.framework.padEnd(8))} → system ${chalk.cyan(p.system)}`));
-    }
-
-    const spinner = ora('Scanning projects...').start();
-    const allParsed = [];
-    let totalFiles = 0;
-    let errorCount = 0;
-    const errorFiles = [];
-
-    for (const project of projects) {
-        spinner.text = `Scanning ${project.name} (${project.framework})...`;
-
-        let files = [];
-        for (const pattern of includePatternsFor(project.framework)) {
-            const matched = await glob(pattern, {
-                cwd: project.path,
-                ignore: WORKSPACE_EXCLUDES,
-                absolute: true,
-            });
-            files.push(...matched);
-        }
-        files = [...new Set(files)];
-        totalFiles += files.length;
-
-        for (const file of files) {
-            try {
-                const result = parseFile(file, {
-                    ast: options.ast,
-                    framework: project.framework,
-                });
-                // CodeSee-style: every source file becomes at least a `module` node
-                if (result.entities.length === 0) {
-                    const fallback = moduleFallbackEntity(file, project.system);
-                    if (fallback) result.entities.push(fallback);
-                }
-                if (result.entities.length > 0 || result.relations.length > 0) {
-                    // The workspace layout is authoritative for system labels —
-                    // path heuristics inside parsers can't know that ./admin is
-                    // the React admin and ./mobile_app the Flutter app.
-                    for (const entity of result.entities) entity.system = project.system;
-                    allParsed.push(result);
-                }
-            } catch (err) {
-                errorCount++;
-                errorFiles.push({ file, error: err.message });
-            }
-        }
-    }
-
-    spinner.text = 'Linking systems...';
-    const relations = buildRelationships(allParsed, debug);
-    const schema = buildSchema(allParsed, { defaultSystem: 'backend', debug }, relations);
-    schema.meta.workspace = {
-        root: cwd,
-        projects: projects.map(p => ({ name: p.name, framework: p.framework, system: p.system })),
-    };
-    schema.hash = hashSchema(schema);
-
-    // Impact analysis against the previous combined snapshot (embedded after
-    // hashing so an unchanged architecture keeps a stable hash). Because the
-    // workspace graph spans systems, a removed backend route flags the
-    // Flutter screens and React pages that call it.
-    const combinedPath = path.join(cwd, LOCAL_SCHEMA_FILE);
-    let previousSchema = null;
-    if (fs.existsSync(combinedPath)) {
-        try { previousSchema = JSON.parse(fs.readFileSync(combinedPath, 'utf-8')); } catch { /* corrupt cache — skip */ }
-    }
-    const impactWarnings = analyzeImpact(previousSchema, schema);
-    embedWarnings(schema, impactWarnings);
-
-    // Combined schema (multiSystem: true → canvas honours per-node systems)
-    fs.writeFileSync(combinedPath, JSON.stringify(schema, null, 2));
-
-    // Per-system schemas for the canvas's multi-file workspace import
-    const perSystemPaths = [];
-    for (const system of schema.systems) {
-        const sysNodes = schema.nodes.filter(n => n.system === system);
-        const nodeIds = new Set(sysNodes.map(n => n.id));
-        const sysEdges = schema.edges.filter(e => nodeIds.has(e.source) && nodeIds.has(e.target));
-        const sysSchema = {
-            system,
-            generatedBy: schema.meta?.source || 'archsync-cli',
-            nodes: sysNodes,
-            edges: sysEdges,
-            // Warnings that originate in or impact this system, so a
-            // single-system import still shows them in the right place.
-            warnings: (schema.warnings || []).filter(
-                w => w.system === system || (w.affectedSystems || []).includes(system)
-            ),
-        };
-        const sysPath = path.join(cwd, `${system}.archsync-schema.json`);
-        fs.writeFileSync(sysPath, JSON.stringify(sysSchema, null, 2));
-        perSystemPaths.push(sysPath);
-    }
-
-    spinner.succeed('Workspace scan complete!');
-
-    const crossEdges = schema.edges.filter(e => e.isCrossSystem);
-
-    console.log(chalk.gray('\n╔══════════════════════════════════════╗'));
-    console.log(chalk.gray('║') + chalk.white.bold('     Workspace Scan Summary           ') + chalk.gray('║'));
-    console.log(chalk.gray('╠══════════════════════════════════════╣'));
-    console.log(chalk.gray('║') + chalk.white(`  Projects:        ${chalk.bold(String(projects.length).padStart(5))}            `) + chalk.gray('║'));
-    console.log(chalk.gray('║') + chalk.white(`  Files scanned:   ${chalk.bold(String(totalFiles).padStart(5))}            `) + chalk.gray('║'));
-    console.log(chalk.gray('║') + chalk.green(`  Entities found:  ${chalk.bold(String(schema.nodes.length).padStart(5))}            `) + chalk.gray('║'));
-    console.log(chalk.gray('║') + chalk.blue(`  Relations:       ${chalk.bold(String(schema.edges.length).padStart(5))}            `) + chalk.gray('║'));
-    console.log(chalk.gray('║') + chalk.magenta(`  Cross-system:    ${chalk.bold(String(crossEdges.length).padStart(5))}            `) + chalk.gray('║'));
-    if (errorCount > 0) {
-        console.log(chalk.gray('║') + chalk.yellow(`  Parse errors:    ${chalk.bold(String(errorCount).padStart(5))}            `) + chalk.gray('║'));
-    }
-    console.log(chalk.gray('╚══════════════════════════════════════╝'));
-
-    // Per-system entity counts
-    console.log(chalk.gray('\n─── Entities by System ─────────────'));
-    for (const system of schema.systems) {
-        const count = schema.nodes.filter(n => n.system === system).length;
-        console.log(chalk.white(`  ${system.padEnd(15)} ${chalk.bold(count)}`));
-    }
-
-    // Cross-system links are the headline feature — always show them
-    if (crossEdges.length > 0) {
-        console.log(chalk.gray('\n─── Cross-System Links ─────────────'));
-        const nodeById = new Map(schema.nodes.map(n => [n.id, n]));
-        for (const edge of crossEdges.slice(0, 20)) {
-            const src = nodeById.get(edge.source);
-            const tgt = nodeById.get(edge.target);
-            console.log(chalk.magenta(`  ${src?.system}:${src?.text} → ${tgt?.system}:${tgt?.text} [${edge.relation}]`));
-        }
-        if (crossEdges.length > 20) {
-            console.log(chalk.gray(`  ... and ${crossEdges.length - 20} more`));
-        }
-    } else {
-        console.log(chalk.yellow('\n⚠  No cross-system links found. Frontend API calls may not match any backend route.'));
-        console.log(chalk.gray('   Run with --debug to trace endpoint matching.'));
-    }
-
-    printImpactWarnings(impactWarnings, { heading: 'Impact since last scan' });
-
-    if (debug && errorFiles.length > 0) {
-        console.log(chalk.gray('\n─── Debug: Parse Errors ────────────'));
-        for (const { file, error } of errorFiles) {
-            console.log(chalk.red(`  ✗ ${path.relative(cwd, file)}: ${error}`));
-        }
-    }
-
-    console.log(chalk.gray(`\n  Combined schema:   ${combinedPath}`));
-    for (const p of perSystemPaths) {
-        console.log(chalk.gray(`  Per-system schema: ${p}`));
-    }
-    console.log(chalk.gray(`  Hash: ${schema.hash}`));
-    console.log(chalk.blue('\nNext: ') + chalk.gray('open the ArchSync canvas and import the schema file(s), or `archsync push`.'));
-}

package/src/commands/serve.js

@@ -1,133 +0,0 @@
-import http from 'http';
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-
-const LOCAL_SCHEMA_FILE = '.archsync-schema.json';
-const DEFAULT_PORT = 4317;
-
-/**
- * archsync serve — the localhost code bridge.
- *
- * Lets the ArchSync canvas show REAL code for any scanned member without the
- * source ever leaving this machine:
- *
- *   GET /v1/health                          → { ok, root }
- *   GET /v1/schema                          → the local .archsync-schema.json
- *   GET /v1/file?path=<abs>&from=<n>&to=<n> → { path, from, to, total, code }
- *
- * Security model (zero-trust by construction):
- *   • Binds strictly to 127.0.0.1 — never reachable from another machine.
- *   • Only serves files that appear in the scanned schema (allowlist),
- *     so even local callers can't read arbitrary paths.
- *   • Read-only: no mutation endpoints exist.
- *   • CORS restricted to localhost origins (the canvas dev/prod ports).
- */
-export async function serveCommand(options) {
-    const dir = path.resolve(options.dir || '.');
-    const port = parseInt(options.port || DEFAULT_PORT, 10);
-
-    // ── Build the file allowlist from the scanned schema ──────────────
-    const schemaPath = path.join(dir, LOCAL_SCHEMA_FILE);
-    let schema = null;
-    const allowedFiles = new Set();
-
-    const loadSchema = () => {
-        try {
-            schema = JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
-            allowedFiles.clear();
-            for (const n of schema.nodes || []) {
-                const sf = n.metadata?.sourceFile;
-                if (sf) allowedFiles.add(path.resolve(sf));
-            }
-            return true;
-        } catch {
-            return false;
-        }
-    };
-
-    if (!loadSchema()) {
-        console.log(chalk.red(`\n✖ No ${LOCAL_SCHEMA_FILE} found in ${dir}`));
-        console.log(chalk.gray('  Run `archsync scan` first.\n'));
-        process.exitCode = 1;
-        return;
-    }
-
-    // Re-read the schema when it changes (after a re-scan)
-    fs.watchFile(schemaPath, { interval: 2000 }, () => {
-        if (loadSchema()) console.log(chalk.gray('  schema reloaded'));
-    });
-
-    const isLocalOrigin = (origin) =>
-        !origin || /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin);
-
-    const server = http.createServer((req, res) => {
-        const origin = req.headers.origin;
-        // CORS — localhost origins only
-        if (isLocalOrigin(origin)) {
-            res.setHeader('Access-Control-Allow-Origin', origin || '*');
-            res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-        }
-        if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
-        if (req.method !== 'GET') { res.writeHead(405); res.end(); return; }
-
-        const url = new URL(req.url, `http://127.0.0.1:${port}`);
-        const json = (status, body) => {
-            res.writeHead(status, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(body));
-        };
-
-        if (url.pathname === '/v1/health') {
-            return json(200, { ok: true, root: dir, files: allowedFiles.size });
-        }
-
-        if (url.pathname === '/v1/schema') {
-            return json(200, schema);
-        }
-
-        if (url.pathname === '/v1/file') {
-            const reqPath = url.searchParams.get('path') || '';
-            const resolved = path.resolve(reqPath);
-            // Allowlist check — only scanned files, nothing else, ever.
-            if (!allowedFiles.has(resolved)) {
-                return json(403, { error: 'File is not part of the scanned schema' });
-            }
-            let source;
-            try { source = fs.readFileSync(resolved, 'utf-8'); }
-            catch { return json(404, { error: 'File not readable' }); }
-
-            const lines = source.split('\n');
-            const from = Math.max(1, parseInt(url.searchParams.get('from') || '1', 10));
-            const to = Math.min(lines.length, parseInt(url.searchParams.get('to') || String(from + 30), 10));
-            return json(200, {
-                path: resolved,
-                from,
-                to,
-                total: lines.length,
-                code: lines.slice(from - 1, to).join('\n'),
-            });
-        }
-
-        json(404, { error: 'Not found' });
-    });
-
-    // Strictly localhost — reject everything else by construction
-    server.listen(port, '127.0.0.1', () => {
-        console.log(chalk.blue.bold('\n🔌 ArchSync local code bridge\n'));
-        console.log(`  Listening on   ${chalk.white(`http://127.0.0.1:${port}`)}  ${chalk.gray('(localhost only)')}`);
-        console.log(`  Serving        ${chalk.white(allowedFiles.size)} scanned files ${chalk.gray('(allowlisted, read-only)')}`);
-        console.log(`  Schema         ${chalk.gray(schemaPath)}`);
-        console.log(chalk.gray('\n  The canvas at localhost:5173 will now show live code.'));
-        console.log(chalk.gray('  Press Ctrl+C to stop.\n'));
-    });
-
-    server.on('error', (err) => {
-        if (err.code === 'EADDRINUSE') {
-            console.log(chalk.yellow(`\n⚠ Port ${port} is in use — is another serve running? Try --port ${port + 1}\n`));
-        } else {
-            console.log(chalk.red(`\n✖ ${err.message}\n`));
-        }
-        process.exitCode = 1;
-    });
-}