archsync 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "archsync",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "ArchSync CLI — Sync codebase to architecture graph",
     "type": "module",
     "license": "Apache-2.0",
@@ -23,20 +23,24 @@
         "archsync"
     ],
     "bin": {
-        "archsync": "./bin/cli.js"
+        "archsync": "dist/archsync.cjs"
     },
     "files": [
-        "bin",
-        "src"
+        "dist",
+        "README.md"
     ],
     "scripts": {
         "start": "node bin/cli.js",
         "dev": "node bin/cli.js",
+        "build": "node build.mjs",
+        "prepublishOnly": "npm run build",
         "test": "vitest",
         "test:run": "vitest run",
         "coverage": "vitest run --coverage"
     },
     "devDependencies": {
+        "esbuild": "^0.24.0",
+        "javascript-obfuscator": "^4.1.1",
         "vitest": "^3.2.0",
         "@vitest/coverage-v8": "^3.2.0"
     },

package/bin/cli.js

@@ -1,91 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { initCommand } from '../src/commands/init.js';
-import { scanCommand } from '../src/commands/scan.js';
-import { pushCommand } from '../src/commands/push.js';
-import { diffCommand } from '../src/commands/diff.js';
-import { watchCommand } from '../src/commands/watch.js';
-import { statusCommand } from '../src/commands/status.js';
-import { serveCommand } from '../src/commands/serve.js';
-
-const program = new Command();
-
-program
-    .name('archsync')
-    .description(chalk.bold.blue('ArchSync CLI') + ' — Sync codebase to architecture graph')
-    .version('1.0.0');
-
-program
-    .command('serve')
-    .description('Start the localhost-only code bridge so the canvas can show live source code')
-    .option('-d, --dir <path>', 'Project directory (must contain .archsync-schema.json)', '.')
-    .option('-p, --port <port>', 'Port to bind on 127.0.0.1', '4317')
-    .action(serveCommand);
-
-program
-    .command('init')
-    .description('Initialize ArchSync in the current project')
-    .option('-p, --project <id>', 'Supabase project ID to link')
-    .option('-f, --framework <type>', 'Framework: node, flutter, react, express, nestjs, nextjs')
-    .option('-s, --system <label>', 'System label for cross-system merging: backend, mobile, web, admin (overrides the framework default)')
-    .action(initCommand);
-
-program
-    .command('scan')
-    .description('Scan codebase and build schema from source')
-    .option('-d, --dir <path>', 'Directory to scan', '.')
-    .option('--include <patterns>', 'Glob patterns to include', '**/*.{js,ts,jsx,tsx,dart,py,go,java,kt}')
-    .option('--exclude <patterns>', 'Glob patterns to exclude', '**/node_modules/**')
-    .option('--ast', 'Use AST parsing (slower, more accurate)', false)
-    .option('--debug', 'Show detailed debug output (entity sources, relation tracing)', false)
-    .option('-w, --workspace', 'Scan a multi-project workspace (e.g. backend + flutter app + react admin) and cross-link systems', false)
-    .action(scanCommand);
-
-program
-    .command('push')
-    .description('Push local schema to Supabase')
-    .option('-b, --branch <name>', 'Branch name', 'main')
-    .option('-m, --message <msg>', 'Commit message')
-    .option('--dry-run', 'Show what would be pushed without pushing')
-    .action(pushCommand);
-
-program
-    .command('diff')
-    .description('Show diff between local and remote schema')
-    .option('-b, --branch <name>', 'Branch to compare against', 'main')
-    .option('--json', 'Output as JSON')
-    .action(diffCommand);
-
-program
-    .command('watch')
-    .description('Watch for file changes and auto-sync')
-    .option('-d, --dir <path>', 'Directory to watch', '.')
-    .option('--debounce <ms>', 'Debounce interval in ms', '2000')
-    .action(watchCommand);
-
-program
-    .command('status')
-    .description('Show current sync status')
-    .action(statusCommand);
-
-// Don't exit with code 1 when no command is provided — just show help
-program.exitOverride();
-try {
-    if (!process.argv.slice(2).length) {
-        program.outputHelp();
-    } else {
-        program.parse();
-    }
-} catch (err) {
-    // Commander throws on --help / --version — treat as clean exits
-    const cleanCodes = ['commander.help', 'commander.helpDisplayed', 'commander.version'];
-    if (cleanCodes.includes(err.code)) {
-        process.exit(0);
-    }
-    if (err.code === 'commander.unknownCommand') {
-        console.error(chalk.red(`Unknown command. Run 'archsync --help' to see available commands.`));
-        process.exit(1);
-    }
-    throw err;
-}

package/src/__tests__/e2e-workflow.test.js

@@ -1,66 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-let tmpDir;
-
-beforeAll(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'archsync-e2e-'));
-  // Create fixture files
-  fs.writeFileSync(path.join(tmpDir, 'App.jsx'), `
-    import React from 'react';
-    import UserService from './UserService';
-    export default function App() { return <div>Hello</div>; }
-  `);
-  fs.writeFileSync(path.join(tmpDir, 'UserService.js'), `
-    const db = require('./db');
-    class UserService {
-      async getUser(id) { return db.users.findById(id); }
-    }
-    module.exports = UserService;
-  `);
-  fs.writeFileSync(path.join(tmpDir, 'server.js'), `
-    const express = require('express');
-    const app = express();
-    app.get('/api/users', (req, res) => res.json([]));
-    app.post('/api/users', (req, res) => res.json({}));
-    module.exports = app;
-  `);
-});
-
-afterAll(() => {
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-});
-
-describe('CLI Scan → Build Pipeline E2E', () => {
-  it('scans fixture directory and produces schema', async () => {
-    // Import parsers
-    const { parseFile } = await import('../../src/parsers/index.js');
-    const { buildSchema } = await import('../../src/core/schemaBuilder.js');
-
-    const files = fs.readdirSync(tmpDir).map(f => path.join(tmpDir, f));
-    const parsed = files.flatMap(f => {
-      try {
-        const content = fs.readFileSync(f, 'utf8');
-        const result = parseFile(f, content);
-        return result ? [result] : [];
-      } catch { return []; }
-    });
-
-    const schema = buildSchema(parsed, tmpDir);
-    expect(schema).toBeDefined();
-    expect(schema.nodes).toBeDefined();
-    expect(Array.isArray(schema.nodes)).toBe(true);
-  });
-
-  it('produces deterministic schema hash', async () => {
-    const { hashSchema } = await import('../../src/core/hashEngine.js');
-    const schema = { nodes: [{ id: '1', name: 'Test', type: 'service' }], edges: [] };
-    const hash1 = hashSchema(schema);
-    const hash2 = hashSchema(schema);
-    expect(hash1).toBe(hash2);
-    expect(typeof hash1).toBe('string');
-    expect(hash1.length).toBeGreaterThan(0);
-  });
-});

package/src/__tests__/hashEngine.test.js

@@ -1,109 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { hashNode, hashSchema, schemasEqual } from '../core/hashEngine.js';
-
-// ─── hashNode ────────────────────────────────────────────────
-describe('hashNode', () => {
-    it('produces a 16-character hex string', () => {
-        const node = { entityType: 'service', system: 'backend', text: 'AuthService', data: {}, metadata: {} };
-        const hash = hashNode(node);
-        expect(typeof hash).toBe('string');
-        expect(hash).toHaveLength(16);
-        expect(hash).toMatch(/^[0-9a-f]+$/);
-    });
-
-    it('identical nodes produce the same hash', () => {
-        const node = { entityType: 'service', system: 'backend', text: 'AuthService', data: {}, metadata: {} };
-        expect(hashNode(node)).toBe(hashNode(node));
-    });
-
-    it('different nodes produce different hashes', () => {
-        const a = { entityType: 'service', system: 'backend', text: 'AuthService', data: {}, metadata: {} };
-        const b = { entityType: 'service', system: 'backend', text: 'PaymentService', data: {}, metadata: {} };
-        expect(hashNode(a)).not.toBe(hashNode(b));
-    });
-
-    it('missing data/metadata defaults to empty objects and still hashes', () => {
-        const node = { entityType: 'model', system: 'backend', text: 'User' };
-        expect(() => hashNode(node)).not.toThrow();
-    });
-});
-
-// ─── hashSchema ──────────────────────────────────────────────
-describe('hashSchema', () => {
-    const baseSchema = {
-        nodes: [
-            { entityType: 'service', system: 'backend', text: 'AuthService', data: {}, metadata: {} },
-        ],
-        edges: [
-            { source: 'n1', relation: 'calls', target: 'n2' },
-        ],
-    };
-
-    it('identical schemas produce the same hash', () => {
-        const hash1 = hashSchema(baseSchema);
-        const hash2 = hashSchema(baseSchema);
-        expect(hash1).toBe(hash2);
-    });
-
-    it('adding a node changes the schema hash', () => {
-        const extended = {
-            ...baseSchema,
-            nodes: [
-                ...baseSchema.nodes,
-                { entityType: 'model', system: 'backend', text: 'UserModel', data: {}, metadata: {} },
-            ],
-        };
-        expect(hashSchema(baseSchema)).not.toBe(hashSchema(extended));
-    });
-
-    it('hash is stable regardless of node property insertion order', () => {
-        const schema1 = {
-            nodes: [{ entityType: 'service', system: 'backend', text: 'A', data: {}, metadata: {} }],
-            edges: [],
-        };
-        // Same logical content, different property order when serialised
-        const schema2 = {
-            nodes: [{ text: 'A', entityType: 'service', system: 'backend', metadata: {}, data: {} }],
-            edges: [],
-        };
-        // hashNode uses JSON.stringify with fixed key order — both schemas are equivalent
-        expect(hashSchema(schema1)).toBe(hashSchema(schema2));
-    });
-
-    it('produces a non-empty string for an empty schema', () => {
-        const hash = hashSchema({ nodes: [], edges: [] });
-        expect(typeof hash).toBe('string');
-        expect(hash.length).toBeGreaterThan(0);
-    });
-
-    it('handles schema without edges gracefully', () => {
-        const schema = { nodes: [{ entityType: 'service', system: 'backend', text: 'X', data: {}, metadata: {} }] };
-        expect(() => hashSchema(schema)).not.toThrow();
-    });
-});
-
-// ─── schemasEqual ────────────────────────────────────────────
-describe('schemasEqual', () => {
-    it('two null schemas are equal', () => {
-        expect(schemasEqual(null, null)).toBe(true);
-    });
-
-    it('null vs non-null schema is not equal', () => {
-        expect(schemasEqual(null, { nodes: [], edges: [] })).toBe(false);
-        expect(schemasEqual({ nodes: [], edges: [] }, null)).toBe(false);
-    });
-
-    it('identical schemas are equal', () => {
-        const schema = {
-            nodes: [{ entityType: 'service', system: 'backend', text: 'Svc', data: {}, metadata: {} }],
-            edges: [],
-        };
-        expect(schemasEqual(schema, schema)).toBe(true);
-    });
-
-    it('schemas with different nodes are not equal', () => {
-        const a = { nodes: [{ entityType: 'service', system: 'backend', text: 'A', data: {}, metadata: {} }], edges: [] };
-        const b = { nodes: [{ entityType: 'service', system: 'backend', text: 'B', data: {}, metadata: {} }], edges: [] };
-        expect(schemasEqual(a, b)).toBe(false);
-    });
-});

package/src/__tests__/impact.test.js

@@ -1,137 +0,0 @@
-/**
- * Tests for the impact engine: breaking-change classification and
- * transitive, cross-system dependent discovery.
- */
-
-import { describe, it, expect } from 'vitest';
-import { analyzeImpact, findDependents, embedWarnings } from '../core/impactEngine.js';
-
-// screen(app) → api(app) → route(backend) → controller(backend)
-//                                service(backend) → model(backend)
-function makeSchema() {
-    const nodes = [
-        { id: 'screen1', entityType: 'screen', system: 'app', text: 'LoginScreen', data: {} },
-        { id: 'api1', entityType: 'api', system: 'app', text: 'POST /api/login', data: { method: 'POST', path: '/api/login' } },
-        { id: 'route1', entityType: 'route', system: 'backend', text: 'POST /api/login', data: { method: 'POST', path: '/login', fullPath: '/api/login' } },
-        { id: 'ctrl1', entityType: 'controller', system: 'backend', text: 'login', data: {} },
-        { id: 'svc1', entityType: 'service', system: 'backend', text: 'UserService', data: {} },
-        { id: 'model1', entityType: 'model', system: 'backend', text: 'User', data: {} },
-    ];
-    const edges = [
-        { id: 'e1', source: 'screen1', target: 'api1', relation: 'consumes' },
-        { id: 'e2', source: 'api1', target: 'route1', relation: 'calls' },
-        { id: 'e3', source: 'route1', target: 'ctrl1', relation: 'handles' },
-        { id: 'e4', source: 'ctrl1', target: 'svc1', relation: 'uses' },
-        { id: 'e5', source: 'svc1', target: 'model1', relation: 'queries' },
-    ];
-    return { system: 'backend', nodes, edges };
-}
-
-function withoutNode(schema, id) {
-    return {
-        ...schema,
-        nodes: schema.nodes.filter(n => n.id !== id),
-        edges: schema.edges.filter(e => e.source !== id && e.target !== id),
-    };
-}
-
-describe('findDependents', () => {
-    it('walks the dependency graph transitively across systems', () => {
-        const schema = makeSchema();
-        const deps = findDependents(schema, 'model1');
-        const ids = deps.map(d => d.id);
-        // model ← service ← controller ← route ← api ← screen
-        expect(ids).toEqual(['svc1', 'ctrl1', 'route1', 'api1', 'screen1']);
-        expect(deps.find(d => d.id === 'svc1').depth).toBe(1);
-        expect(deps.find(d => d.id === 'screen1').depth).toBe(5);
-        expect(deps.find(d => d.id === 'screen1').system).toBe('app');
-    });
-
-    it('returns nothing for a leaf with no dependents', () => {
-        expect(findDependents(makeSchema(), 'screen1')).toEqual([]);
-    });
-});
-
-describe('analyzeImpact', () => {
-    it('returns no warnings without a previous snapshot', () => {
-        expect(analyzeImpact(null, makeSchema())).toEqual([]);
-    });
-
-    it('flags a removed route as breaking and lists cross-system dependents', () => {
-        const oldSchema = makeSchema();
-        const newSchema = withoutNode(oldSchema, 'route1');
-
-        const warnings = analyzeImpact(oldSchema, newSchema);
-        expect(warnings).toHaveLength(1);
-
-        const w = warnings[0];
-        expect(w.severity).toBe('breaking');
-        expect(w.changeKind).toBe('removed');
-        expect(w.nodeText).toBe('POST /api/login');
-        expect(w.affected.map(a => a.id)).toEqual(['api1', 'screen1']);
-        expect(w.affectedSystems).toEqual(['app']);
-        expect(w.affectedByType).toEqual({ api: 1, screen: 1 });
-    });
-
-    it('flags a contract change (path) on a node with dependents', () => {
-        const oldSchema = makeSchema();
-        const newSchema = makeSchema();
-        const route = newSchema.nodes.find(n => n.id === 'route1');
-        route.data = { ...route.data, fullPath: '/api/v2/login' };
-
-        const warnings = analyzeImpact(oldSchema, newSchema);
-        expect(warnings).toHaveLength(1);
-        expect(warnings[0].changeKind).toBe('modified');
-        expect(warnings[0].message).toContain('fullPath');
-        expect(warnings[0].severity).toBe('breaking');
-    });
-
-    it('ignores cosmetic changes (position, metadata)', () => {
-        const oldSchema = makeSchema();
-        const newSchema = makeSchema();
-        const route = newSchema.nodes.find(n => n.id === 'route1');
-        route.x = 999;
-        route.metadata = { parsedAt: 'now' };
-
-        expect(analyzeImpact(oldSchema, newSchema)).toEqual([]);
-    });
-
-    it('skips modified nodes nobody depends on', () => {
-        const oldSchema = makeSchema();
-        const newSchema = makeSchema();
-        const screen = newSchema.nodes.find(n => n.id === 'screen1');
-        screen.data = { parentClass: 'HookWidget' };
-
-        expect(analyzeImpact(oldSchema, newSchema)).toEqual([]);
-    });
-});
-
-describe('embedWarnings', () => {
-    it('attaches schema-level warnings and node-level flags', () => {
-        const oldSchema = makeSchema();
-        const newSchema = withoutNode(oldSchema, 'route1');
-        const warnings = analyzeImpact(oldSchema, newSchema);
-
-        embedWarnings(newSchema, warnings);
-
-        expect(newSchema.warnings).toHaveLength(1);
-        const api = newSchema.nodes.find(n => n.id === 'api1');
-        const screen = newSchema.nodes.find(n => n.id === 'screen1');
-        expect(api.impactedBy).toEqual(['route1']);
-        expect(screen.impactedBy).toEqual(['route1']);
-        // the removed node is gone — survivors only carry impactedBy
-        expect(newSchema.nodes.every(n => !n.warning)).toBe(true);
-    });
-
-    it('flags the changed node itself when it survives', () => {
-        const oldSchema = makeSchema();
-        const newSchema = makeSchema();
-        const route = newSchema.nodes.find(n => n.id === 'route1');
-        route.data = { ...route.data, fullPath: '/api/v2/login' };
-
-        const warnings = analyzeImpact(oldSchema, newSchema);
-        embedWarnings(newSchema, warnings);
-
-        expect(newSchema.nodes.find(n => n.id === 'route1').warning).toMatchObject({ severity: 'breaking' });
-    });
-});