lavina 1.0.0

package/README.md

@@ -0,0 +1 @@
+# lavina

package/cli.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import Logger from './src/cli/components/consoleLogger.js';
+import scanDirForProjects from './src/cli/helpers/scanDirForProjects.js';
+import mapDependencies from './src/cli/helpers/mapDependencies.js';
+import { COLORS } from './src/constants.js';
+import saveDependencies from './src/cli/helpers/saveDependencies.js';
+import { spawn } from 'child_process';
+import { getLibDirName } from './src/cli/helpers/getLibDirName.js';
+import open from 'open';
+
+const program = new Command();
+
+program
+  .name('lavina')
+  .description('lavina - automated dependency propagation tool')
+  .version('0.1.0');
+
+program
+  .command('scan')
+  .description('Scan and build dependency graph')
+  .option('--verbose', 'Enable verbose logging')
+  .action(async (opts) => {
+    Logger.setVerbose(opts.verbose);
+    const scannedProjets = await scanDirForProjects(process.cwd());
+    Logger.color('green').log(`Found ${scannedProjets.length} projects:`, true);
+
+    const mappedProjects = mapDependencies(scannedProjets);
+
+    const outputPath = saveDependencies(mappedProjects);
+
+    mappedProjects.map((project) => {
+      Logger.color(COLORS.YELLOW).log(
+        `\n- ${project.displayName}: ${project.version}`,
+        true,
+      );
+      if (project.projectDependencies) {
+        Logger.log(
+          `Dependencies: \n${Object.entries(project.projectDependencies)
+            .map(([dependency, version]) => `${dependency}: ${version}`)
+            .join('\n')}`,
+          true,
+        );
+      }
+    });
+
+    Logger.color(COLORS.GREEN).log(
+      `\nDependency map saved to: ${outputPath}\n`,
+      true,
+    );
+  });
+
+program
+  .command('ui')
+  .description('Show dependency graph in a web UI')
+  .action(async () => {
+    const { __dirname } = getLibDirName(import.meta.url);
+    const uiPath = `${__dirname}/lavina-ui`;
+    Logger.color(COLORS.GREEN).log(
+      `Launching Lavina UI from ${uiPath}...`,
+      true,
+    );
+
+    const standaloneServer = path.join(
+      uiPath,
+      '.next',
+      'standalone',
+      'server.js',
+    );
+
+    const isBuilt = fs.existsSync(standaloneServer);
+
+    if (isBuilt) {
+      // published package
+      spawn('node', ['server.js'], {
+        cwd: path.dirname(standaloneServer),
+        env: commonEnv,
+      });
+    } else {
+      // local development
+      spawn('npm', ['run', 'dev'], {
+        cwd: uiPath,
+        shell: true,
+        env: commonEnv,
+      });
+    }
+
+    let isOpened = false;
+    nextProcess.stdout?.on('data', (data) => {
+      process.stderr.write(data);
+
+      if (isOpened) return;
+      if (data.toString().indexOf('Ready') > -1) {
+        open('http://localhost:3000');
+        isOpened = true;
+      }
+    });
+
+    nextProcess.stderr?.on('data', (data) => {
+      process.stderr.write(data);
+    });
+
+    nextProcess.on('close', (code) => {
+      Logger.color(COLORS.RED).log(`UI process exited with code ${code}`, true);
+    });
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "lavina",
+  "version": "1.0.0",
+  "description": "Lavina is an automated dependency propagation tool designed to scan microservice architectures and build dependency graphs between internal projects.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "npm unlink -g lavina && npm link"
+  },
+  "files": [
+    "cli.js",
+    "src"
+  ],
+  "author": "Elena Kikiova",
+  "license": "ISC",
+  "dependencies": {
+    "@radix-ui/themes": "^3.3.0",
+    "@tanstack/react-table": "^8.21.3",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "cytoscape": "^3.33.3",
+    "cytoscape-elk": "^2.3.0",
+    "elkjs": "^0.11.1",
+    "jsonc-parser": "^3.3.1",
+    "open": "^11.0.0",
+    "react-icons": "^5.6.0"
+  },
+  "bin": {
+    "lavina": "cli.js"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.5.0",
+    "prettier": "^3.6.2"
+  }
+}

package/src/cli/components/ConsoleLogger.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { COLORS } from '../../constants.js';
+const { WHITE, RED } = COLORS;
+
+class ConsoleLogger {
+  isVerbose = false;
+  logColor = WHITE;
+  setVerbose(verbose) {
+    this.verbose = verbose;
+  }
+  color(messageColor) {
+    this.logColor = messageColor;
+    return this;
+  }
+  resetLogColor() {
+    this.logColor = WHITE;
+  }
+  log(message, isEssentialMessage = false) {
+    // if verbose flag is on, log all messages
+    // otherwise, log only messages that are RED (error) or flagged as non-verbose
+    let shouldLog = true;
+    if (!this.isVerbose) {
+      shouldLog = this.logColor === RED || isEssentialMessage;
+    }
+    shouldLog ? console.log(chalk[this.logColor](message)) : null;
+    this.resetLogColor();
+  }
+}
+
+const Logger = new ConsoleLogger();
+
+export default Logger;

package/src/cli/helpers/getLibDirName.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+export const getLibDirName = (url) => {
+  const __filename = fileURLToPath(url); // get the resolved path to the file
+  const __dirname = path.dirname(__filename);
+  return { __filename, __dirname };
+};

package/src/cli/helpers/mapDependencies.js

@@ -0,0 +1,56 @@
+const mapDependencies = (projects) => {
+  const originalToDisplayNameMap = {};
+  projects.forEach((project) => {
+    if (project.originalName) {
+      originalToDisplayNameMap[project.originalName] = project.displayName;
+    }
+  });
+
+  const projectOriginalNames = new Set(projects.map((p) => p.originalName));
+
+  const usedByCount = {};
+  projects.forEach((project) => {
+    if (project.dependencies) {
+      Object.keys(project.dependencies).forEach((dep) => {
+        if (projectOriginalNames.has(dep)) {
+          const displayName = originalToDisplayNameMap[dep];
+          usedByCount[displayName] = (usedByCount[displayName] || 0) + 1;
+        }
+      });
+    }
+  });
+
+  const projectsWithFilteredDependencies = projects.map((project) => {
+    const { displayName, dependencies } = project;
+
+    const projectDependencies = dependencies
+      ? Object.entries(dependencies)
+          .filter(([dep]) => projectOriginalNames.has(dep))
+          .map(([dep, version]) => [originalToDisplayNameMap[dep], version])
+      : [];
+
+    const hasDeps = projectDependencies.length > 0;
+    const isDependedOn = usedByCount[displayName] > 0;
+
+    let category = 'application';
+    if (!hasDeps && !isDependedOn) {
+      category = 'standalone';
+    } else if (isDependedOn) {
+      category = 'library';
+    }
+
+    let modifiedProject = {
+      ...project,
+      projectDependencies: Object.fromEntries(projectDependencies),
+      category,
+    };
+
+    delete modifiedProject.dependencies;
+
+    return modifiedProject;
+  });
+
+  return projectsWithFilteredDependencies;
+};
+
+export default mapDependencies;

package/src/cli/helpers/readProject.js

@@ -0,0 +1,74 @@
+import { readFile } from 'fs/promises';
+import { COLORS, PACKAGE_FILES, PROJECT_TYPES } from '../../constants.js';
+import Logger from '../components/consoleLogger.js';
+
+export const readProject = async (currentDir, dirContent, path, root) => {
+  const { JS, PHP } = PROJECT_TYPES;
+  const { PACKAGE_JSON_FILE, COMPOSER_JSON_FILE } = PACKAGE_FILES;
+
+  let packageInfo = {};
+  // Check if current directory contains package.json or composer.json
+  const names = new Set(dirContent.map((e) => e.name));
+
+  const packageFiles = dirContent.filter(
+    (e) =>
+      e.isFile() &&
+      (e.name === PACKAGE_JSON_FILE || e.name === COMPOSER_JSON_FILE),
+  );
+
+  if (packageFiles.length === 0) return;
+
+  let version = null;
+  let dependencies = {};
+  let name;
+  let type;
+  let packageFileNames = [];
+
+  // If there is a composer file, it's php
+  if (names.has(COMPOSER_JSON_FILE)) type = PHP;
+  else type = JS;
+
+  // Read and parse each package file and check if there is a version (indicating it's a project)
+  for (let file of packageFiles) {
+    let content = await readFile(path.join(currentDir, file.name), 'utf-8');
+    try {
+      let json = JSON.parse(content);
+      version = json.version;
+      packageFileNames.push(file.name);
+
+      if (version) {
+        if (file.name === PACKAGE_JSON_FILE) {
+          if (type == JS) name = json.name;
+          dependencies =
+            {
+              ...dependencies,
+              ...json.dependencies,
+              ...json.peerDependencies,
+            } || {};
+        } else if (file.name === COMPOSER_JSON_FILE) {
+          name = json.name;
+
+          dependencies = { ...dependencies, ...json.require } || {};
+        }
+      }
+    } catch (err) {
+      Logger.log(`Error parsing JSON in ${file.name}: ${err}`, COLORS.RED);
+    }
+  }
+  if (version && name) {
+    packageInfo = {
+      displayName: `${name} (${type})`,
+      originalName: name,
+      version,
+      dependencies,
+      path: currentDir,
+      packageFileNames,
+      type,
+    };
+
+    // Do not recurse into this directory any further (treat it as a project root).
+    return packageInfo;
+  }
+};
+
+export default readProject;

package/src/cli/helpers/saveDependencies.js

@@ -0,0 +1,14 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
+
+const saveDependencies = (mappedProjects) => {
+  const outputPath = path.resolve(process.cwd(), '.lavina', 'deps.json');
+
+  // Make sure /data directory exists
+  mkdirSync(path.dirname(outputPath), { recursive: true });
+
+  writeFileSync(outputPath, JSON.stringify(mappedProjects, null, 2), 'utf-8');
+  return outputPath;
+};
+
+export default saveDependencies;

package/src/cli/helpers/scanDirForProjects.js

@@ -0,0 +1,44 @@
+const IGNORED_DIRS = new Set([
+  'node_modules',
+  'vendor',
+  '.git',
+  'dist',
+  'build',
+]);
+import path from 'path';
+import { readdir } from 'fs/promises';
+import { readProject } from './readProject.js';
+import { COLORS } from '../../constants.js';
+import Logger from '../components/consoleLogger.js';
+
+const scanDirForProjects = async (rootDir) => {
+  const root = path.resolve(rootDir);
+  let projects = [];
+
+  async function walk(currentDir) {
+    Logger.log(`Scanning ${currentDir}`, COLORS.WHITE);
+    let dirContent;
+    try {
+      dirContent = await readdir(currentDir, { withFileTypes: true });
+    } catch (err) {
+      Logger.log(`Directory not readable: ${err}`, COLORS.RED);
+      return;
+    }
+    const packageInfo = await readProject(currentDir, dirContent, path, root);
+    if (packageInfo) {
+      projects.push(packageInfo);
+    } else {
+      // Otherwise recurse into subdirectories (skipping ignored ones)
+      for (const entry of dirContent) {
+        if (!entry.isDirectory() || entry.name.indexOf('.') == 0) continue;
+        if (IGNORED_DIRS.has(entry.name)) continue;
+        await walk(path.join(currentDir, entry.name));
+      }
+    }
+  }
+
+  await walk(root);
+  return projects;
+};
+
+export default scanDirForProjects;

package/src/constants.js

@@ -0,0 +1,23 @@
+export const COLORS = {
+  WHITE: 'white',
+  GREEN: 'green',
+  RED: 'red',
+  YELLOW: 'yellow',
+};
+
+export const PROJECT_TYPES = {
+  JS: 'js',
+  PHP: 'php',
+};
+
+export const PACKAGE_FILES = {
+  COMPOSER_JSON_FILE: 'composer.json',
+  PACKAGE_JSON_FILE: 'package.json',
+};
+
+export const SUPPORTED_PROJECT_TYPES = [PROJECT_TYPES.JS, PROJECT_TYPES.PHP];
+
+export const PACKAGE_DEPENDENCY_FIELDS = {
+  PACKAGE_JSON_FILE: 'dependencies',
+  COMPOSER_JSON_FILE: 'require',
+};