arcvision 0.1.0

package/jest.config.json

@@ -0,0 +1,6 @@
+{
+  "testEnvironment": "node",
+  "testMatch": [
+    "**/tests/**/*.test.js"
+  ]
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "arcvision",
+  "version": "0.1.0",
+  "description": "Architecture scanner for modern codebases",
+  "bin": {
+    "arcvision": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "esbuild src/index.js --bundle --platform=node --outfile=dist/index.js",
+    "prepublishOnly": "npm run build",
+    "dev": "node src/index.js",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "chalk": "^4.1.2",
+    "glob": "^10.3.10",
+    "@babel/parser": "^7.24.0",
+    "@babel/traverse": "^7.24.0",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "esbuild": "^0.20.0",
+    "jest": "^29.7.0"
+  },
+  "keywords": [
+    "architecture",
+    "visualization",
+    "scanning",
+    "codebase",
+    "dependency",
+    "graph"
+  ],
+  "author": "ArcVision",
+  "license": "MIT"
+}

package/src/core/parser.js

@@ -0,0 +1,73 @@
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const fs = require('fs');
+const path = require('path');
+
+function parseFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const ast = parser.parse(content, {
+        sourceType: 'module',
+        plugins: ['jsx', 'typescript', 'classProperties', 'dynamicImport']
+    });
+
+    const metadata = {
+        id: filePath,
+        imports: [],
+        exports: [],
+        functions: [],
+        apiCalls: []
+    };
+
+    traverse(ast, {
+        ImportDeclaration({ node }) {
+            metadata.imports.push({
+                source: node.source.value,
+                specifiers: node.specifiers.map(s => s.local.name)
+            });
+        },
+        ExportNamedDeclaration({ node }) {
+            if (node.declaration) {
+                if (node.declaration.type === 'FunctionDeclaration') {
+                    metadata.exports.push(node.declaration.id.name);
+                } else if (node.declaration.type === 'VariableDeclaration') {
+                    node.declaration.declarations.forEach(d => {
+                        metadata.exports.push(d.id.name);
+                    });
+                }
+            }
+        },
+        ExportDefaultDeclaration({ node }) {
+            metadata.exports.push('default');
+        },
+        FunctionDeclaration({ node }) {
+            if (node.id) {
+                metadata.functions.push({
+                    name: node.id.name,
+                    params: node.params.map(p => p.name || (p.type === 'ObjectPattern' ? '{}' : '?'))
+                });
+            }
+        },
+        CallExpression({ node }) {
+            if (node.callee.name === 'fetch') {
+                const arg = node.arguments[0];
+                metadata.apiCalls.push({
+                    type: 'fetch',
+                    url: arg.type === 'StringLiteral' ? arg.value : 'dynamic'
+                });
+            }
+            if (node.callee.name === 'require' && node.arguments.length > 0) {
+                const source = node.arguments[0].value;
+                if (source) {
+                    metadata.imports.push({
+                        source: source,
+                        specifiers: []
+                    });
+                }
+            }
+        }
+    });
+
+    return metadata;
+}
+
+module.exports = { parseFile };

package/src/core/scanner.js

@@ -0,0 +1,86 @@
+const { glob } = require('glob');
+const path = require('path');
+const parser = require('./parser');
+const pluginManager = require('../plugins/plugin-manager');
+
+async function scan(directory) {
+    const options = {
+        ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'],
+        cwd: directory,
+        absolute: true
+    };
+
+    try {
+        // Load plugins
+        const pluginDir = path.join(__dirname, '../plugins');
+        pluginManager.loadPluginsFromDirectory(pluginDir);
+
+        const files = await glob('**/*.{js,jsx,ts,tsx}', { ...options, ignore: [...options.ignore, '**/*.d.ts'] });
+
+        const architectureMap = {
+            nodes: [],
+            edges: []
+        };
+
+        const fileMap = new Map();
+
+        // Process files with plugins
+        for (const file of files) {
+            try {
+                let metadata = parser.parseFile(file);
+                const relativePath = path.relative(directory, file);
+
+                // Process with plugins
+                metadata = await pluginManager.processFile(file, metadata);
+
+                const node = {
+                    id: relativePath,
+                    type: 'file',
+                    metadata: metadata
+                };
+
+                architectureMap.nodes.push(node);
+                fileMap.set(relativePath, metadata);
+            } catch (e) {
+                // Non-fatal parse errors (like .d.ts files) are logged but don't stop the scan
+                console.warn(`⚠️  Parse warning for ${file}: ${e.message}`);
+            }
+        }
+
+        // Normalize helper
+        const normalize = p => p.replace(/\\/g, '/');
+
+        const normalizedFileMap = new Set();
+        architectureMap.nodes.forEach(n => normalizedFileMap.add(normalize(n.id)));
+
+        architectureMap.nodes.forEach(node => {
+            node.metadata.imports.forEach(imp => {
+                let target = imp.source;
+                if (target.startsWith('.')) {
+                    const dir = path.dirname(node.id);
+                    let resolved = path.join(dir, target);
+                    const extensions = ['', '.js', '.jsx', '.ts', '.tsx'];
+
+                    for (const ext of extensions) {
+                        const probe = normalize(resolved + ext);
+                        if (normalizedFileMap.has(probe)) {
+                            architectureMap.edges.push({
+                                source: normalize(node.id),
+                                target: probe,
+                                type: 'import'
+                            });
+                            break;
+                        }
+                    }
+                }
+            });
+        });
+
+        return architectureMap;
+
+    } catch (err) {
+        throw err;
+    }
+}
+
+module.exports = { scan };

package/src/core/watcher.js

@@ -0,0 +1,18 @@
+const chokidar = require('chokidar');
+
+function watch(directory, callback) {
+    const watcher = chokidar.watch(directory, {
+        ignored: [/(^|[\/\\])\../, '**/node_modules/**'], // ignore dotfiles
+        persistent: true,
+        ignoreInitial: true
+    });
+
+    watcher
+        .on('add', path => callback('add', path))
+        .on('change', path => callback('change', path))
+        .on('unlink', path => callback('unlink', path));
+
+    return watcher;
+}
+
+module.exports = { watch };

package/src/index.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const scanner = require('./core/scanner');
+
+const CONFIG_FILE = path.join(os.homedir(), '.arcvisionrc');
+const API_URL = process.env.ARCVISION_API_URL || 'https://arcvisiondev.vercel.app';
+
+function saveToken(token) {
+  try {
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ token }));
+    console.log(chalk.green('✅ Token saved successfully!'));
+  } catch (error) {
+    if (error.code === 'EACCES') {
+      console.error(chalk.red('❌ Permission denied: Cannot write to config file.'));
+      console.error(chalk.yellow(`Please ensure you have write permissions for: ${CONFIG_FILE}`));
+    } else {
+      console.error(chalk.red('❌ Failed to save token:'), error.message);
+    }
+    process.exit(1);
+  }
+}
+
+function getToken() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      return config.token;
+    }
+  } catch (error) {
+    console.error(chalk.red('❌ Failed to read token configuration:'), error.message);
+    console.error(chalk.yellow('Token file may be corrupted. Run `arcvision link <TOKEN>` to reset.'));
+    return null;
+  }
+  return null;
+}
+
+// Function to upload JSON to database via Token
+async function uploadToDatabase(jsonData) {
+  const token = getToken();
+  if (!token) {
+    console.log(chalk.red('❌ No upload token found.'));
+    console.log(chalk.yellow('Run `arcvision link <TOKEN>` first to connect to a project.'));
+    process.exit(1);
+  }
+
+  try {
+    console.log(chalk.blue(`Uploading to ${API_URL}/api/upload...`));
+    
+    // Add timeout to fetch request
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
+    
+    const response = await fetch(`${API_URL}/api/upload`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        graph: jsonData
+      }),
+      signal: controller.signal
+    });
+    
+    clearTimeout(timeoutId);
+    
+    if (response.status === 401) {
+      console.error(chalk.red('❌ Invalid or revoked token.'));
+      console.error(chalk.yellow('The token may be invalid, revoked, or the associated project may have been deleted.'));
+      console.log(chalk.yellow('💡 Please create a new project on the dashboard and generate a new token.'));
+      process.exit(1);
+    }
+
+    if (response.status === 404) {
+      console.error(chalk.red('❌ Project not found.'));
+      console.error(chalk.yellow('The project associated with this token may have been deleted.'));
+      console.log(chalk.yellow('💡 Please create a new project on the dashboard and generate a new token.'));
+      process.exit(1);
+    }
+    
+    if (response.status === 429) {
+      console.error(chalk.red('❌ Rate limit exceeded. Please wait before trying again.'));
+      process.exit(1);
+    }
+
+    if (!response.ok) {
+      console.error(chalk.red(`❌ Upload failed: ${response.status} ${response.statusText}`));
+      const text = await response.text();
+      try {
+        const errorJson = JSON.parse(text);
+        if (errorJson.error) console.error(chalk.red(`Server Error: ${errorJson.error}`));
+      } catch (e) {
+        console.error(chalk.red(`Server Error: ${text}`));
+      }
+      process.exit(1);
+    }
+
+    const result = await response.json();
+    if (result.success) {
+      console.log(chalk.green('✅ Graph uploaded successfully!'));
+    } else {
+      console.log(chalk.red('❌ Upload reported failure despite 200 OK.'));
+      if (result.error) {
+        console.error(chalk.red(`Error details: ${result.error}`));
+      }
+    }
+
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      console.error(chalk.red('❌ Upload timeout: Request took too long to complete.'));
+      console.error(chalk.yellow('Check your internet connection and try again.'));
+    } else if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED' || error.code === 'ECONNRESET') {
+      console.error(chalk.red('❌ Network error: Unable to connect to the server.'));
+      console.error(chalk.yellow('Check your internet connection and ensure the API endpoint is accessible.'));
+      console.error(chalk.yellow(`API endpoint: ${API_URL}/api/upload`));
+    } else {
+      console.error(chalk.red('Upload network error:'), error.message);
+      console.error(chalk.yellow('This might be a temporary issue. Please try again later.'));
+    }
+    process.exit(1);
+  }
+}
+
+const program = new Command();
+
+program
+  .name('arcvision')
+  .description(`CLI to visualize codebase architecture
+
+Quick Start:
+  1. Sign up at the ArcVision dashboard
+  2. Create a project and name it
+  3. Generate a CLI token
+  4. Run: arcvision link <token>
+  5. Run: arcvision scan --upload
+  6. Open dashboard to see results
+  `)
+  .version('1.0.0');
+
+program
+  .command('link <token>')
+  .description('Link this CLI to a project via upload token')
+  .action((token) => {
+    try {
+      saveToken(token);
+    } catch (error) {
+      // saveToken already handles its own errors and exits
+      process.exit(1);
+    }
+  });
+
+program
+  .command('scan')
+  .description('Scan the current directory and generate architecture map')
+  .argument('[directory]', 'Directory to scan', '.')
+  .option('-u, --upload', 'Upload to database')
+  .action(async (directory, options) => {
+    const targetDir = path.resolve(directory);
+    console.log(chalk.blue(`Scanning directory: ${targetDir}`));
+    
+    try {
+      const map = await scanner.scan(targetDir);
+      console.log(chalk.green('Scan complete!'));
+
+      // Upload to database if requested
+      if (options.upload) {
+        await uploadToDatabase(map);
+      } else {
+        console.log(JSON.stringify(map, null, 2)); // Print if not uploading
+        console.log(chalk.dim('\nUse --upload to send to dashboard.'));
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        console.error(chalk.red('❌ Directory not found:'), targetDir);
+        console.error(chalk.yellow('Please check the directory path and ensure it exists.'));
+        process.exit(1);
+      } else if (error.code === 'EACCES') {
+        console.error(chalk.red('❌ Permission denied:'), targetDir);
+        console.error(chalk.yellow('Please ensure you have read permissions for the specified directory.'));
+        process.exit(1);
+      } else {
+        console.error(chalk.red('Scan failed:'), error.message);
+        console.error(chalk.yellow('This might be caused by file access issues or unsupported file types.'));
+        
+        // Provide more specific guidance based on common errors
+        if (error.message && error.message.toLowerCase().includes('parse')) {
+          console.error(chalk.yellow('If this is a TypeScript declaration file, note that .d.ts files are now skipped.'));
+        }
+        process.exit(1);
+      }
+    }
+  });
+
+
+
+program.parse();

package/src/plugins/express-plugin.js

@@ -0,0 +1,48 @@
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const fs = require('fs');
+
+module.exports = {
+    name: 'express-route-detector',
+
+    process: async (filePath, metadata) => {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const ast = parser.parse(content, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript']
+            });
+
+            const routes = [];
+
+            traverse(ast, {
+                CallExpression({ node }) {
+                    // Detect Express routes: app.get(), app.post(), router.get(), etc.
+                    if (node.callee.type === 'MemberExpression') {
+                        const obj = node.callee.object.name;
+                        const method = node.callee.property.name;
+
+                        if ((obj === 'app' || obj === 'router') &&
+                            ['get', 'post', 'put', 'delete', 'patch'].includes(method)) {
+                            const pathArg = node.arguments[0];
+                            if (pathArg && pathArg.type === 'StringLiteral') {
+                                routes.push({
+                                    method: method.toUpperCase(),
+                                    path: pathArg.value
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+
+            if (routes.length > 0) {
+                return { expressRoutes: routes };
+            }
+
+            return null;
+        } catch (error) {
+            return null;
+        }
+    }
+};

package/src/plugins/plugin-manager.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+const path = require('path');
+
+class PluginManager {
+    constructor() {
+        this.plugins = [];
+    }
+
+    register(plugin) {
+        if (typeof plugin.name !== 'string') {
+            throw new Error('Plugin must have a name');
+        }
+        if (typeof plugin.process !== 'function') {
+            throw new Error('Plugin must have a process function');
+        }
+        this.plugins.push(plugin);
+        console.log(`Plugin registered: ${plugin.name}`);
+    }
+
+    async processFile(filePath, metadata) {
+        let enhancedMetadata = { ...metadata };
+
+        for (const plugin of this.plugins) {
+            try {
+                const result = await plugin.process(filePath, enhancedMetadata);
+                if (result) {
+                    enhancedMetadata = { ...enhancedMetadata, ...result };
+                }
+            } catch (error) {
+                console.warn(`Plugin ${plugin.name} failed: ${error.message}`);
+            }
+        }
+
+        return enhancedMetadata;
+    }
+
+    loadPluginsFromDirectory(directory) {
+        if (!fs.existsSync(directory)) {
+            return;
+        }
+
+        const files = fs.readdirSync(directory);
+        files.forEach(file => {
+            if (file.endsWith('.js') && file !== 'plugin-manager.js') {
+                try {
+                    const pluginPath = path.join(directory, file);
+                    const plugin = require(pluginPath);
+                    this.register(plugin);
+                } catch (error) {
+                    console.warn(`Failed to load plugin ${file}: ${error.message}`);
+                }
+            }
+        });
+    }
+}
+
+module.exports = new PluginManager();

package/src/plugins/react-plugin.js

@@ -0,0 +1,54 @@
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const fs = require('fs');
+
+module.exports = {
+    name: 'react-component-detector',
+
+    process: async (filePath, metadata) => {
+        if (!filePath.match(/\.(jsx|tsx)$/)) {
+            return null;
+        }
+
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const ast = parser.parse(content, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript']
+            });
+
+            const components = [];
+            const hooks = [];
+
+            traverse(ast, {
+                FunctionDeclaration({ node }) {
+                    // Check if it's a React component (starts with uppercase)
+                    if (node.id && /^[A-Z]/.test(node.id.name)) {
+                        components.push(node.id.name);
+                    }
+                },
+                VariableDeclarator({ node }) {
+                    // Check for arrow function components
+                    if (node.id && /^[A-Z]/.test(node.id.name)) {
+                        if (node.init && (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression')) {
+                            components.push(node.id.name);
+                        }
+                    }
+                },
+                CallExpression({ node }) {
+                    // Detect React hooks
+                    if (node.callee.name && node.callee.name.startsWith('use')) {
+                        hooks.push(node.callee.name);
+                    }
+                }
+            });
+
+            return {
+                reactComponents: [...new Set(components)],
+                reactHooks: [...new Set(hooks)]
+            };
+        } catch (error) {
+            return null;
+        }
+    }
+};

package/tests/plugins.test.js

@@ -0,0 +1,49 @@
+const pluginManager = require('./src/plugins/plugin-manager');
+const path = require('path');
+
+describe('Plugin System', () => {
+    test('should register a plugin', () => {
+        const testPlugin = {
+            name: 'test-plugin',
+            process: async (filePath, metadata) => {
+                return { testField: 'test-value' };
+            }
+        };
+
+        pluginManager.register(testPlugin);
+        expect(pluginManager.plugins.length).toBeGreaterThan(0);
+    });
+
+    test('should process file with plugin', async () => {
+        const testPlugin = {
+            name: 'test-enhancer',
+            process: async (filePath, metadata) => {
+                return { enhanced: true };
+            }
+        };
+
+        pluginManager.register(testPlugin);
+
+        const metadata = { id: 'test.js', imports: [] };
+        const result = await pluginManager.processFile('test.js', metadata);
+
+        expect(result.enhanced).toBe(true);
+    });
+
+    test('should handle plugin errors gracefully', async () => {
+        const faultyPlugin = {
+            name: 'faulty-plugin',
+            process: async () => {
+                throw new Error('Plugin error');
+            }
+        };
+
+        pluginManager.register(faultyPlugin);
+
+        const metadata = { id: 'test.js' };
+        const result = await pluginManager.processFile('test.js', metadata);
+
+        // Should not crash
+        expect(result).toBeDefined();
+    });
+});

package/tests/scanner.test.js

@@ -0,0 +1,52 @@
+const scanner = require('./src/core/scanner');
+const parser = require('./src/core/parser');
+const path = require('path');
+
+describe('ArcVision Scanner', () => {
+    test('should parse a simple JavaScript file', () => {
+        const testFile = path.join(__dirname, '../example-project/utils.js');
+        const metadata = parser.parseFile(testFile);
+
+        expect(metadata).toBeDefined();
+        expect(metadata.exports).toContain('helper');
+        expect(metadata.functions).toBeDefined();
+    });
+
+    test('should scan a directory and return architecture map', async () => {
+        const testDir = path.join(__dirname, '../example-project');
+        const map = await scanner.scan(testDir);
+
+        expect(map).toBeDefined();
+        expect(map.nodes).toBeDefined();
+        expect(map.edges).toBeDefined();
+        expect(map.nodes.length).toBeGreaterThan(0);
+    }, 30000);
+
+    test('should detect imports and create edges', async () => {
+        const testDir = path.join(__dirname, '../example-project');
+        const map = await scanner.scan(testDir);
+
+        expect(map.edges.length).toBeGreaterThan(0);
+        const hasImportEdge = map.edges.some(e => e.type === 'import');
+        expect(hasImportEdge).toBe(true);
+    });
+
+    test('should detect API calls', async () => {
+        const testDir = path.join(__dirname, '../example-project');
+        const map = await scanner.scan(testDir);
+
+        const apiFile = map.nodes.find(n => n.id.includes('api.js'));
+        expect(apiFile).toBeDefined();
+        expect(apiFile.metadata.apiCalls).toBeDefined();
+        expect(apiFile.metadata.apiCalls.length).toBeGreaterThan(0);
+    });
+
+    test('should handle circular dependencies', async () => {
+        // This is a basic test - in real scenarios we'd create files with circular deps
+        const testDir = path.join(__dirname, '../example-project');
+        const map = await scanner.scan(testDir);
+
+        // Should not crash
+        expect(map).toBeDefined();
+    });
+});