archsync 1.0.0 → 1.0.2

package/src/core/hashEngine.js

@@ -1,34 +0,0 @@
-import crypto from 'crypto';
-
-// Create a deterministic hash of a node's meaningful content
-export function hashNode(node) {
-    const content = JSON.stringify({
-        entityType: node.entityType,
-        system: node.system,
-        text: node.text,
-        data: node.data || {},
-        metadata: node.metadata || {},
-    });
-    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
-}
-
-// Create hash for full schema
-export function hashSchema(schema) {
-    const nodeHashes = (schema.nodes || []).map(n => hashNode(n)).sort();
-    const edgeHashes = (schema.edges || []).map(e => {
-        return crypto.createHash('sha256')
-            .update(`${e.source}-${e.relation}-${e.target}`)
-            .digest('hex').slice(0, 16);
-    }).sort();
-
-    return crypto.createHash('sha256')
-        .update(JSON.stringify({ nodeHashes, edgeHashes }))
-        .digest('hex');
-}
-
-// Check if two schemas are identical
-export function schemasEqual(a, b) {
-    if (!a && !b) return true;
-    if (!a || !b) return false;
-    return hashSchema(a) === hashSchema(b);
-}

package/src/core/impactEngine.js

@@ -1,192 +0,0 @@
-/**
- * Impact Engine — breaking-change detection and dependency impact analysis.
- *
- * Given two schema snapshots (before / after), it:
- *   1. Diffs nodes and classifies changes as breaking or non-breaking.
- *      A change is breaking when other entities depend on the changed node:
- *      removing a route someone calls, changing its method/path, removing a
- *      model a service queries, etc.
- *   2. Walks the dependency graph BACKWARDS (who depends on me?) to find
- *      every transitively affected node — across systems, so deleting a
- *      backend route flags the Flutter screen that calls it.
- *
- * Nothing here is entity-type- or system-name-specific: dependents are
- * derived purely from the edges in the schema, so any project shape works.
- *
- * The output is embedded into the schema (`schema.warnings`) on push so the
- * canvas can show the same warnings in the affected areas.
- */
-
-// Fields inside node.data whose change breaks the node's public contract.
-// Everything else in data (positions, parse metadata, …) is cosmetic.
-const CONTRACT_FIELDS = ['method', 'path', 'fullPath', 'prefix', 'parentClass', 'orm', 'kind'];
-
-function contractOf(node) {
-    const data = node.data || {};
-    const picked = {};
-    for (const f of CONTRACT_FIELDS) {
-        if (data[f] !== undefined) picked[f] = data[f];
-    }
-    return JSON.stringify({ text: node.text, entityType: node.entityType, ...picked });
-}
-
-/** Build reverse adjacency: nodeId → [{ sourceId, relation }] of nodes that depend on it. */
-function buildReverseIndex(schema) {
-    const incoming = new Map();
-    for (const edge of schema.edges || []) {
-        if (!incoming.has(edge.target)) incoming.set(edge.target, []);
-        incoming.get(edge.target).push({ sourceId: edge.source, relation: edge.relation });
-    }
-    return incoming;
-}
-
-/**
- * All transitive dependents of `nodeId`, breadth-first, with the dependency
- * depth (1 = direct caller) and the relation that links each hop.
- */
-export function findDependents(schema, nodeId, { maxDepth = 10 } = {}) {
-    const incoming = buildReverseIndex(schema);
-    const byId = new Map((schema.nodes || []).map(n => [n.id, n]));
-    const visited = new Set([nodeId]);
-    const result = [];
-
-    let frontier = [nodeId];
-    for (let depth = 1; depth <= maxDepth && frontier.length; depth++) {
-        const next = [];
-        for (const id of frontier) {
-            for (const { sourceId, relation } of incoming.get(id) || []) {
-                if (visited.has(sourceId)) continue;
-                visited.add(sourceId);
-                const node = byId.get(sourceId);
-                if (!node) continue;
-                result.push({
-                    id: node.id,
-                    text: node.text,
-                    entityType: node.entityType,
-                    system: node.system,
-                    relation,
-                    depth,
-                });
-                next.push(sourceId);
-            }
-        }
-        frontier = next;
-    }
-    return result;
-}
-
-/**
- * Compare two schemas and produce structured warnings for changes that
- * affect dependents.
- *
- * @param  {object|null} oldSchema — previous snapshot (local cache or remote)
- * @param  {object}      newSchema — freshly scanned schema
- * @return {Array} warnings:
- *   { severity: 'breaking'|'warning',
- *     changeKind: 'removed'|'modified',
- *     nodeId, nodeText, entityType, system,
- *     message,
- *     affected: [{ id, text, entityType, system, relation, depth }],
- *     affectedSystems: string[],
- *     affectedByType: { [entityType]: count } }
- */
-export function analyzeImpact(oldSchema, newSchema) {
-    if (!oldSchema || !Array.isArray(oldSchema.nodes)) return [];
-
-    const oldById = new Map(oldSchema.nodes.map(n => [n.id, n]));
-    const newById = new Map((newSchema.nodes || []).map(n => [n.id, n]));
-    const warnings = [];
-
-    const pushWarning = (changeKind, oldNode, detail) => {
-        // Dependents are computed on the OLD graph — that's where the
-        // relationships to the removed/changed node still exist.
-        const affected = findDependents(oldSchema, oldNode.id);
-        if (affected.length === 0 && changeKind === 'modified') return; // nobody cares
-        const affectedSystems = [...new Set(affected.map(a => a.system).filter(Boolean))];
-        const affectedByType = {};
-        for (const a of affected) {
-            affectedByType[a.entityType] = (affectedByType[a.entityType] || 0) + 1;
-        }
-        warnings.push({
-            severity: affected.length > 0 ? 'breaking' : 'warning',
-            changeKind,
-            nodeId: oldNode.id,
-            nodeText: oldNode.text,
-            entityType: oldNode.entityType,
-            system: oldNode.system,
-            message: detail,
-            affected,
-            affectedSystems,
-            affectedByType,
-        });
-    };
-
-    for (const [id, oldNode] of oldById) {
-        const newNode = newById.get(id);
-        if (!newNode) {
-            pushWarning('removed', oldNode, `${oldNode.entityType} "${oldNode.text}" was removed`);
-            continue;
-        }
-        if (contractOf(oldNode) !== contractOf(newNode)) {
-            const oldC = JSON.parse(contractOf(oldNode));
-            const newC = JSON.parse(contractOf(newNode));
-            const changedFields = Object.keys({ ...oldC, ...newC })
-                .filter(k => JSON.stringify(oldC[k]) !== JSON.stringify(newC[k]));
-            pushWarning(
-                'modified',
-                oldNode,
-                `${oldNode.entityType} "${oldNode.text}" changed: ${changedFields.join(', ')}`
-            );
-        }
-    }
-
-    // Most impactful first
-    warnings.sort((a, b) => b.affected.length - a.affected.length);
-    return warnings;
-}
-
-/**
- * Attach warnings to a schema (mutates and returns it). Node-level flags let
- * renderers badge the exact entities involved without re-deriving anything:
- *   - the changed node's survivors get `warning`
- *   - every dependent gets `impactedBy` (list of warning node ids)
- */
-export function embedWarnings(schema, warnings) {
-    schema.warnings = warnings;
-    if (!warnings.length) return schema;
-
-    const impactedBy = new Map(); // nodeId → [changed nodeIds]
-    const changed = new Map();    // nodeId → warning
-
-    for (const w of warnings) {
-        changed.set(w.nodeId, w);
-        for (const a of w.affected) {
-            if (!impactedBy.has(a.id)) impactedBy.set(a.id, []);
-            impactedBy.get(a.id).push(w.nodeId);
-        }
-    }
-
-    for (const node of schema.nodes || []) {
-        const w = changed.get(node.id);
-        if (w) {
-            node.warning = { severity: w.severity, message: w.message };
-        }
-        const sources = impactedBy.get(node.id);
-        if (sources) {
-            node.impactedBy = sources;
-        }
-    }
-    return schema;
-}
-
-/** Compact, colour-free summary lines for CI/JSON consumers. */
-export function summarizeWarnings(warnings) {
-    return warnings.map(w => ({
-        severity: w.severity,
-        change: w.message,
-        system: w.system,
-        affectedCount: w.affected.length,
-        affectedSystems: w.affectedSystems,
-        affectedByType: w.affectedByType,
-    }));
-}

package/src/core/monorepoDetector.js

@@ -1,41 +0,0 @@
-// Monorepo Support - Task 120
-const fs = require('fs');
-const path = require('path');
-
-function detectMonorepo(rootDir) {
-  const indicators = [
-    { file: 'turbo.json', type: 'turborepo' },
-    { file: 'nx.json', type: 'nx' },
-    { file: 'lerna.json', type: 'lerna' },
-    { file: 'pnpm-workspace.yaml', type: 'pnpm' },
-  ];
-  for (const { file, type } of indicators) {
-    if (fs.existsSync(path.join(rootDir, file))) return type;
-  }
-  const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8') || '{}');
-  if (pkg.workspaces) return 'npm-workspaces';
-  return null;
-}
-
-function getWorkspacePackages(rootDir) {
-  const pkgPath = path.join(rootDir, 'package.json');
-  if (!fs.existsSync(pkgPath)) return [];
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-  const workspaces = pkg.workspaces || [];
-  const patterns = Array.isArray(workspaces) ? workspaces : (workspaces.packages || []);
-  const packages = [];
-  for (const pattern of patterns) {
-    const globbed = pattern.replace(/\*$/, '');
-    const base = path.join(rootDir, globbed.replace(/\*/g, ''));
-    if (fs.existsSync(base)) {
-      const dirs = fs.readdirSync(path.dirname(base)).filter(d => {
-        const full = path.join(path.dirname(base), d);
-        return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, 'package.json'));
-      });
-      dirs.forEach(d => packages.push({ name: d, path: path.join(path.dirname(base), d) }));
-    }
-  }
-  return packages;
-}
-
-module.exports = { detectMonorepo, getWorkspacePackages };

package/src/core/pluginManager.js

@@ -1,40 +0,0 @@
-// CLI Plugin System - Task 24
-const path = require('path');
-const fs = require('fs');
-const { execSync } = require('child_process');
-
-const PLUGINS_DIR = path.join(require('os').homedir(), '.archsync', 'plugins');
-
-function ensurePluginsDir() {
-  if (!fs.existsSync(PLUGINS_DIR)) fs.mkdirSync(PLUGINS_DIR, { recursive: true });
-}
-
-function loadPlugin(name) {
-  const pluginPath = path.join(PLUGINS_DIR, 'node_modules', name);
-  if (!fs.existsSync(pluginPath)) throw new Error(`Plugin ${name} not installed. Run: archsync plugin:add ${name}`);
-  const plugin = require(pluginPath);
-  if (typeof plugin.parse !== 'function') throw new Error(`Plugin ${name} must export a parse(filePath, options) function`);
-  return plugin;
-}
-
-function listPlugins() {
-  ensurePluginsDir();
-  const pkgPath = path.join(PLUGINS_DIR, 'package.json');
-  if (!fs.existsSync(pkgPath)) return [];
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-  return Object.keys(pkg.dependencies || {});
-}
-
-function installPlugin(name) {
-  ensurePluginsDir();
-  const pkgPath = path.join(PLUGINS_DIR, 'package.json');
-  if (!fs.existsSync(pkgPath)) fs.writeFileSync(pkgPath, JSON.stringify({ name: 'archsync-plugins', private: true, dependencies: {} }));
-  execSync(`npm install ${name}`, { cwd: PLUGINS_DIR, stdio: 'inherit' });
-}
-
-function uninstallPlugin(name) {
-  ensurePluginsDir();
-  execSync(`npm uninstall ${name}`, { cwd: PLUGINS_DIR, stdio: 'inherit' });
-}
-
-module.exports = { loadPlugin, listPlugins, installPlugin, uninstallPlugin };