archsync 1.0.0 → 1.0.1

package/src/parsers/astParser.js

@@ -1,274 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import * as babelParser from '@babel/parser';
-import _traverse from '@babel/traverse';
-
-// Handle ESM default import compatibility
-const traverse = _traverse.default || _traverse;
-
-/**
- * AST-based deep parser for JavaScript/TypeScript files.
- * Uses @babel/parser + @babel/traverse for accurate extraction.
- * Extracts: classes, functions, routes, models, API calls, decorators.
- */
-export function parseWithAST(filePath) {
-    const source = fs.readFileSync(filePath, 'utf-8');
-    const ext = path.extname(filePath);
-    const entities = [];
-    const relations = [];
-    const fileName = path.basename(filePath, ext);
-    const dirName = path.basename(path.dirname(filePath));
-
-    // Determine system
-    let system = 'backend';
-    if (/src\/(app|mobile|native)/i.test(filePath)) system = 'app';
-    else if (/src\/(web|frontend|client|pages|components)/i.test(filePath)) system = 'web';
-    else if (/admin/i.test(filePath)) system = 'admin';
-
-    const plugins = ['jsx', 'classProperties', 'decorators-legacy', 'optionalChaining', 'nullishCoalescingOperator'];
-    if (ext === '.ts' || ext === '.tsx') plugins.push('typescript');
-
-    let ast;
-    try {
-        ast = babelParser.parse(source, {
-            sourceType: 'module',
-            plugins,
-            errorRecovery: true,
-        });
-    } catch (err) {
-        // Fallback: file can't be parsed
-        return { filePath, entities: [], relations: [], error: err.message };
-    }
-
-    const importMap = new Map(); // local name → source path
-
-    traverse(ast, {
-        // ─── Track imports ──────────────────────────────────────
-        ImportDeclaration(nodePath) {
-            const source = nodePath.node.source.value;
-            for (const spec of nodePath.node.specifiers) {
-                importMap.set(spec.local.name, source);
-            }
-        },
-
-        // ─── Classes ────────────────────────────────────────────
-        ClassDeclaration(nodePath) {
-            const name = nodePath.node.id?.name;
-            if (!name) return;
-
-            const parent = nodePath.node.superClass?.name || null;
-            let entityType = inferEntityType(name, filePath);
-
-            // Check decorators (NestJS)
-            const decorators = nodePath.node.decorators || [];
-            for (const dec of decorators) {
-                const decName = dec.expression?.callee?.name || dec.expression?.name;
-                if (decName === 'Controller') entityType = 'controller';
-                if (decName === 'Injectable') entityType = 'service';
-                if (decName === 'Module') entityType = 'middleware';
-            }
-
-            // Extract methods
-            const methods = [];
-            for (const member of nodePath.node.body.body) {
-                if (member.type === 'ClassMethod' && member.key?.name) {
-                    const methodDecorators = member.decorators || [];
-                    const httpMethod = methodDecorators.find(d =>
-                        ['Get', 'Post', 'Put', 'Patch', 'Delete'].includes(d.expression?.callee?.name)
-                    );
-
-                    if (httpMethod) {
-                        const method = httpMethod.expression.callee.name.toUpperCase();
-                        const routePath = httpMethod.expression.arguments?.[0]?.value || '/';
-                        entities.push({
-                            entityType: 'route',
-                            name: `${method} ${routePath}`,
-                            system: 'backend',
-                            data: { method, path: routePath, handler: member.key.name },
-                            metadata: { sourceFile: filePath, line: member.loc?.start?.line },
-                        });
-                    }
-
-                    methods.push({
-                        name: member.key.name,
-                        params: member.params.map(p => p.name || p.left?.name || 'arg').filter(Boolean),
-                        isAsync: member.async,
-                    });
-                }
-            }
-
-            entities.push({
-                entityType,
-                name,
-                system,
-                data: { parentClass: parent, methods },
-                metadata: { sourceFile: filePath, line: nodePath.node.loc?.start?.line },
-            });
-
-            if (parent) {
-                relations.push({
-                    source: name, target: parent,
-                    sourceType: entityType, targetType: 'unknown',
-                    relation: 'extends',
-                });
-            }
-        },
-
-        // ─── Arrow/Function Exports ─────────────────────────────
-        ExportNamedDeclaration(nodePath) {
-            const decl = nodePath.node.declaration;
-            if (!decl) return;
-
-            if (decl.type === 'FunctionDeclaration' && decl.id?.name) {
-                const name = decl.id.name;
-                entities.push({
-                    entityType: inferEntityType(name, filePath),
-                    name,
-                    system,
-                    data: {
-                        params: decl.params.map(p => p.name || p.left?.name || 'arg').filter(Boolean),
-                        isAsync: decl.async,
-                    },
-                    metadata: { sourceFile: filePath, line: decl.loc?.start?.line },
-                });
-            }
-
-            if (decl.type === 'VariableDeclaration') {
-                for (const declarator of decl.declarations) {
-                    if (declarator.id?.name && declarator.init) {
-                        const name = declarator.id.name;
-                        // Skip Router vars
-                        if (name === 'router' || name === 'Router') continue;
-
-                        // Infer type from file path + name
-                        let entityType = inferEntityType(name, filePath);
-
-                        // Arrow function exports in controller files → controller entities
-                        if (declarator.init.type === 'ArrowFunctionExpression' || declarator.init.type === 'FunctionExpression') {
-                            // Check if params suggest it's a request handler (req, res)
-                            const params = declarator.init.params?.map(p => p.name || p.left?.name || '').filter(Boolean) || [];
-                            const isHandler = params.some(p => /^(req|request|ctx)$/i.test(p));
-                            if (isHandler && /controller/i.test(filePath)) {
-                                entityType = 'controller';
-                            }
-                        }
-
-                        // Check if it's a React component (starts with uppercase, returns JSX)
-                        if (/^[A-Z]/.test(name) && entityType === 'service') {
-                            entityType = 'screen';
-                        }
-
-                        entities.push({
-                            entityType,
-                            name,
-                            system,
-                            data: { componentType: 'functional' },
-                            metadata: { sourceFile: filePath, line: declarator.loc?.start?.line },
-                        });
-                    }
-                }
-            }
-        },
-
-        // ─── Express Route Calls ────────────────────────────────
-        CallExpression(nodePath) {
-            const callee = nodePath.node.callee;
-
-            // app.get('/path', handler) or router.post('/path', handler)
-            if (callee.type === 'MemberExpression') {
-                const method = callee.property?.name;
-                const obj = callee.object?.name;
-
-                if (['get', 'post', 'put', 'patch', 'delete', 'all'].includes(method) &&
-                    ['app', 'router', 'server'].includes(obj)) {
-                    const args = nodePath.node.arguments;
-                    if (args[0]?.type === 'StringLiteral') {
-                        entities.push({
-                            entityType: 'route',
-                            name: `${method.toUpperCase()} ${args[0].value}`,
-                            system: 'backend',
-                            data: { method: method.toUpperCase(), path: args[0].value },
-                            metadata: { sourceFile: filePath, line: nodePath.node.loc?.start?.line },
-                        });
-                    }
-                }
-
-                // fetch/axios API calls
-                if (['fetch'].includes(obj) || (method && ['get', 'post', 'put', 'delete'].includes(method) && obj === 'axios')) {
-                    const args = nodePath.node.arguments;
-                    if (args[0]?.type === 'StringLiteral') {
-                        entities.push({
-                            entityType: 'api',
-                            name: `${(method || 'GET').toUpperCase()} ${args[0].value}`,
-                            system,
-                            data: { method: (method || 'GET').toUpperCase(), path: args[0].value, scope: 'frontend-ref' },
-                            metadata: { sourceFile: filePath, line: nodePath.node.loc?.start?.line },
-                        });
-                    }
-                }
-            }
-
-            // mongoose.model('Name', schema)
-            if (callee.type === 'MemberExpression' &&
-                callee.property?.name === 'model' &&
-                ['mongoose', 'sequelize'].includes(callee.object?.name)) {
-                const args = nodePath.node.arguments;
-                if (args[0]?.type === 'StringLiteral') {
-                    entities.push({
-                        entityType: 'model',
-                        name: args[0].value,
-                        system: 'backend',
-                        data: { orm: callee.object.name },
-                        metadata: { sourceFile: filePath, line: nodePath.node.loc?.start?.line },
-                    });
-                }
-            }
-
-            // Firestore .collection('name')
-            if (callee.type === 'MemberExpression' &&
-                callee.property?.name === 'collection') {
-                const args = nodePath.node.arguments;
-                if (args[0]?.type === 'StringLiteral') {
-                    const collName = args[0].value;
-                    entities.push({
-                        entityType: 'database',
-                        name: `collection:${collName}`,
-                        system: 'backend',
-                        data: { collection: collName, dbType: 'firestore' },
-                        metadata: { sourceFile: filePath, line: nodePath.node.loc?.start?.line },
-                    });
-                }
-            }
-        },
-    });
-
-    // ─── Infer relations from imports ─────────────────────────
-    for (const [localName, sourcePath] of importMap) {
-        if (sourcePath.startsWith('.') && entities.length > 0) {
-            const importedName = path.basename(sourcePath).replace(/\.[^.]+$/, '');
-            relations.push({
-                source: entities[0].name,
-                target: importedName,
-                sourceType: entities[0].entityType,
-                targetType: 'unknown',
-                relation: 'uses',
-            });
-        }
-    }
-
-    return { filePath, entities, relations };
-}
-
-// Infer entity type from naming conventions
-function inferEntityType(name, filePath) {
-    const combined = `${name} ${filePath}`.toLowerCase();
-    if (/controller/.test(combined)) return 'controller';
-    if (/middleware/.test(combined)) return 'middleware';
-    if (/service/.test(combined)) return 'service';
-    if (/model|schema|entity/.test(combined)) return 'model';
-    if (/worker|job|queue/.test(combined)) return 'worker';
-    if (/route/.test(combined)) return 'route';
-    if (/screen|page|view|layout/.test(combined)) return 'screen';
-    if (/widget|component/.test(combined)) return 'widget';
-    return 'service';
-}

package/src/parsers/configParser.js

@@ -1,49 +0,0 @@
-import path from 'path';
-
-function parsePackageJson(content, filePath) {
-  try {
-    const pkg = JSON.parse(content);
-    return {
-      entities: [{
-        id: `${filePath}::package.json`,
-        name: pkg.name || 'package',
-        type: 'config',
-        filePath,
-        attributes: { scriptsCount: Object.keys(pkg.scripts || {}).length, depsCount: Object.keys(pkg.dependencies || {}).length }
-      }],
-      relations: []
-    };
-  } catch { return { entities: [], relations: [] }; }
-}
-
-function parseDockerCompose(content, filePath) {
-  const entities = [];
-  const serviceRegex = /^  ([a-zA-Z0-9_-]+):\s*$/gm;
-  let m;
-  while ((m = serviceRegex.exec(content)) !== null) {
-    if (!['version', 'services', 'networks', 'volumes'].includes(m[1])) {
-      entities.push({ id: `${filePath}::${m[1]}`, name: m[1], type: 'infrastructure', filePath, attributes: {} });
-    }
-  }
-  return { entities, relations: [] };
-}
-
-function parsePrismaSchema(content, filePath) {
-  const entities = [];
-  const modelRegex = /^model\s+(\w+)\s*\{/gm;
-  let m;
-  while ((m = modelRegex.exec(content)) !== null) {
-    entities.push({ id: `${filePath}::${m[1]}`, name: m[1], type: 'model', filePath, attributes: {} });
-  }
-  return { entities, relations: [] };
-}
-
-function parse(content, filePath) {
-  const base = path.basename(filePath);
-  if (base === 'package.json') return parsePackageJson(content, filePath);
-  if (base === 'docker-compose.yml' || base === 'docker-compose.yaml') return parseDockerCompose(content, filePath);
-  if (base.endsWith('.prisma')) return parsePrismaSchema(content, filePath);
-  return { entities: [], relations: [] };
-}
-
-export { parse, parsePackageJson, parseDockerCompose, parsePrismaSchema };

package/src/parsers/dependencyGraph.js

@@ -1,31 +0,0 @@
-import path from 'path';
-
-function buildDependencyGraph(packageJsonContent, sourceFiles = []) {
-  let pkg;
-  try { pkg = JSON.parse(packageJsonContent); } catch { return { entities: [], relations: [] }; }
-
-  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-  const entities = Object.keys(allDeps).map(name => ({
-    id: `dep::${name}`,
-    name,
-    type: 'dependency',
-    filePath: 'package.json',
-    attributes: { version: allDeps[name], isDev: name in (pkg.devDependencies || {}) }
-  }));
-
-  const relations = [];
-  for (const { content, filePath } of sourceFiles) {
-    const importRegex = /(?:import|require)\s*(?:\(?\s*['"]([^'"]+)['"]|.*from\s+['"]([^'"]+)['"])/g;
-    let m;
-    while ((m = importRegex.exec(content)) !== null) {
-      const dep = m[1] || m[2];
-      if (dep && !dep.startsWith('.') && allDeps[dep]) {
-        relations.push({ from: filePath, to: `dep::${dep}`, type: 'depends_on' });
-      }
-    }
-  }
-
-  return { entities, relations };
-}
-
-export { buildDependencyGraph };

package/src/parsers/flutterParser.js

@@ -1,98 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-/**
- * Flutter / Dart parser — extracts entities from .dart files.
- */
-
-const CLASS_REGEX = /class\s+(\w+)\s*(?:extends\s+(\w+))?\s*(?:with\s+([\w,\s]+))?\s*(?:implements\s+([\w,\s]+))?\s*\{/g;
-const STATEFUL_REGEX = /class\s+(\w+)\s+extends\s+State<(\w+)>/g;
-const ROUTE_REGEX = /['"`]\/([^'"`]+)['"`]\s*:\s*(?:\(.*?\)\s*=>)?\s*(\w+)/g;
-const NAV_REGEX = /Navigator\.\w+\s*\(\s*[^,]*?['"`]\/([^'"`]+)['"`]/g;
-// Matches http.get('…'), dio.post('…'), and the idiomatic
-// http.get(Uri.parse('…')) / Uri.https('host', '/path') forms.
-const HTTP_REGEX = /(?:http|dio|client|_client|_dio)\s*\.\s*(get|post|put|patch|delete)\s*\(\s*(?:Uri\.parse\s*\(\s*)?['"`]([^'"`]+)['"`]/gi;
-const PROVIDER_REGEX = /(?:ChangeNotifier|Provider|Bloc|Cubit)\s*(?:<[^>]+>)?\s*/g;
-
-export function parseFlutterFile(filePath) {
-    const source = fs.readFileSync(filePath, 'utf-8');
-    const entities = [];
-    const relations = [];
-    const fileName = path.basename(filePath, '.dart');
-
-    let system = 'app';
-    if (/admin/i.test(filePath)) system = 'admin';
-    else if (/web/i.test(filePath)) system = 'web';
-
-    let match;
-
-    // ─── Classes → Screens / Widgets / Models ─────────────────
-    CLASS_REGEX.lastIndex = 0;
-    while ((match = CLASS_REGEX.exec(source)) !== null) {
-        const className = match[1];
-        const parent = match[2] || '';
-
-        // Skip State classes (handled by StatefulWidget)
-        if (parent.startsWith('State<')) continue;
-
-        let entityType = 'widget';
-        if (/Screen|Page|View|Layout/i.test(className) || /StatelessWidget|StatefulWidget/.test(parent)) {
-            entityType = /Screen|Page|View/i.test(className) ? 'screen' : 'widget';
-        } else if (/Model|Entity|DTO/i.test(className)) {
-            entityType = 'model';
-        } else if (/Controller|Bloc|Cubit|Provider|Notifier/i.test(className) || /ChangeNotifier|Bloc|Cubit/.test(parent)) {
-            entityType = 'controller';
-        } else if (/Service|Repository|Api|Client/i.test(className)) {
-            entityType = 'service';
-        } else if (/Middleware/i.test(className)) {
-            entityType = 'middleware';
-        }
-
-        entities.push({
-            entityType,
-            name: className,
-            system,
-            data: { parentClass: parent || null },
-            metadata: { sourceFile: filePath },
-        });
-
-        if (parent && parent !== 'StatelessWidget' && parent !== 'StatefulWidget') {
-            relations.push({
-                source: className, target: parent,
-                sourceType: entityType, targetType: 'unknown',
-                relation: 'extends',
-            });
-        }
-    }
-
-    // ─── HTTP Calls ───────────────────────────────────────────
-    HTTP_REGEX.lastIndex = 0;
-    while ((match = HTTP_REGEX.exec(source)) !== null) {
-        // Only the pathname is comparable to backend routes — drop the origin.
-        const apiPath = match[2].replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]+/i, '') || '/';
-        entities.push({
-            entityType: 'api',
-            name: `${match[1].toUpperCase()} ${apiPath}`,
-            system,
-            data: { method: match[1].toUpperCase(), path: apiPath, scope: 'frontend-ref' },
-            metadata: { sourceFile: filePath },
-        });
-    }
-
-    // ─── Navigation Relations ─────────────────────────────────
-    NAV_REGEX.lastIndex = 0;
-    while ((match = NAV_REGEX.exec(source)) !== null) {
-        const route = match[1];
-        if (entities.length > 0) {
-            relations.push({
-                source: entities[0].name,
-                target: route,
-                sourceType: entities[0].entityType,
-                targetType: 'screen',
-                relation: 'navigates',
-            });
-        }
-    }
-
-    return { filePath, entities, relations };
-}

package/src/parsers/goParser.js

@@ -1,99 +0,0 @@
-/**
- * Go parser — extracts backend entities from Go source files.
- * Detects: structs (controller/service/model), HTTP handlers,
- *          Gin routes, and Echo routes.
- */
-
-// type UserHandler struct {
-const STRUCT_REGEX = /^type\s+(\w+)\s+struct\s*\{/gm;
-
-// func (h *SomeHandler) MethodName(w http.ResponseWriter, r *http.Request)
-const HTTP_HANDLER_REGEX = /^func\s+\(\w+\s+\*?(\w+)\)\s+(\w+)\s*\(\s*\w+\s+http\.ResponseWriter\s*,\s*\w+\s+\*http\.Request\s*\)/gm;
-
-// Gin routes: r.GET("/path", handler) / r.POST("/path", handler) etc.
-const GIN_ROUTE_REGEX = /\b\w+\.(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*\(\s*"([^"]+)"\s*,\s*(\w+(?:\.\w+)?)\s*\)/g;
-
-// Echo routes: e.GET("/path", handler)
-const ECHO_ROUTE_REGEX = /\be\.(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*\(\s*"([^"]+)"\s*,\s*(\w+(?:\.\w+)?)\s*\)/g;
-
-function classifyStruct(name) {
-  if (/Handler$/.test(name)) return 'controller';
-  if (/Service$/.test(name)) return 'service';
-  return 'model';
-}
-
-function parse(content, filePath) {
-  const entities = [];
-  const relations = [];
-  let m;
-
-  // ─── Structs ──────────────────────────────────────────────────
-  STRUCT_REGEX.lastIndex = 0;
-  while ((m = STRUCT_REGEX.exec(content)) !== null) {
-    const name = m[1];
-    entities.push({
-      id: `${filePath}::${name}`,
-      name,
-      type: classifyStruct(name),
-      filePath,
-      attributes: {},
-    });
-  }
-
-  // ─── HTTP handler methods ─────────────────────────────────────
-  HTTP_HANDLER_REGEX.lastIndex = 0;
-  while ((m = HTTP_HANDLER_REGEX.exec(content)) !== null) {
-    const receiver = m[1];
-    const methodName = m[2];
-    const name = `${receiver}.${methodName}`;
-    if (!entities.find(e => e.id === `${filePath}::${name}`)) {
-      entities.push({
-        id: `${filePath}::${name}`,
-        name,
-        type: 'api',
-        filePath,
-        attributes: { receiver, method: methodName },
-      });
-    }
-  }
-
-  // ─── Gin routes ───────────────────────────────────────────────
-  GIN_ROUTE_REGEX.lastIndex = 0;
-  while ((m = GIN_ROUTE_REGEX.exec(content)) !== null) {
-    const httpMethod = m[1].toUpperCase();
-    const routePath = m[2];
-    const handler = m[3];
-    const name = `${httpMethod} ${routePath}`;
-    if (!entities.find(e => e.id === `${filePath}::${name}`)) {
-      entities.push({
-        id: `${filePath}::${name}`,
-        name,
-        type: 'api',
-        filePath,
-        attributes: { method: httpMethod, path: routePath, handler, framework: 'gin' },
-      });
-    }
-  }
-
-  // ─── Echo routes ──────────────────────────────────────────────
-  ECHO_ROUTE_REGEX.lastIndex = 0;
-  while ((m = ECHO_ROUTE_REGEX.exec(content)) !== null) {
-    const httpMethod = m[1].toUpperCase();
-    const routePath = m[2];
-    const handler = m[3];
-    const name = `${httpMethod} ${routePath}`;
-    if (!entities.find(e => e.id === `${filePath}::${name}`)) {
-      entities.push({
-        id: `${filePath}::${name}`,
-        name,
-        type: 'api',
-        filePath,
-        attributes: { method: httpMethod, path: routePath, handler, framework: 'echo' },
-      });
-    }
-  }
-
-  return { entities, relations };
-}
-
-export { parse };