@monodog/utils 1.0.1 → 1.0.3

package/helpers.js

@@ -5,93 +5,90 @@ import path from 'path';
  * Scans the monorepo and returns information about all packages
  */
 function scanMonorepo(rootDir) {
-    const packages = [];
-    console.log('rootDir', rootDir);
-    // Scan packages directory
-    const packagesDir = path.join(rootDir, 'packages');
-    if (fs.existsSync(packagesDir)) {
-        const packageDirs = fs
-            .readdirSync(packagesDir, { withFileTypes: true })
-            .filter(dirent => dirent.isDirectory())
-            .map(dirent => dirent.name);
-        for (const packageName of packageDirs) {
-            const packagePath = path.join(packagesDir, packageName);
-            const packageInfo = parsePackageInfo(packagePath, packageName);
-            if (packageInfo) {
-                packages.push(packageInfo);
-            }
-        }
+  const packages = [];
+  console.log('rootDir', rootDir);
+  // Scan packages directory
+  const packagesDir = path.join(rootDir, 'packages');
+  if (fs.existsSync(packagesDir)) {
+    const packageDirs = fs
+      .readdirSync(packagesDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+    for (const packageName of packageDirs) {
+      const packagePath = path.join(packagesDir, packageName);
+      const packageInfo = parsePackageInfo(packagePath, packageName);
+      if (packageInfo) {
+        packages.push(packageInfo);
+      }
     }
-    // Scan apps directory
-    const appsDir = path.join(rootDir, 'apps');
-    if (fs.existsSync(appsDir)) {
-        const appDirs = fs
-            .readdirSync(appsDir, { withFileTypes: true })
-            .filter(dirent => dirent.isDirectory())
-            .map(dirent => dirent.name);
-        for (const appName of appDirs) {
-            const appPath = path.join(appsDir, appName);
-            const appInfo = parsePackageInfo(appPath, appName, 'app');
-            if (appInfo) {
-                packages.push(appInfo);
-            }
-        }
+  }
+  // Scan apps directory
+  const appsDir = path.join(rootDir, 'apps');
+  if (fs.existsSync(appsDir)) {
+    const appDirs = fs
+      .readdirSync(appsDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+    for (const appName of appDirs) {
+      const appPath = path.join(appsDir, appName);
+      const appInfo = parsePackageInfo(appPath, appName, 'app');
+      if (appInfo) {
+        packages.push(appInfo);
+      }
     }
-    // Scan libs directory
-    const libsDir = path.join(rootDir, 'libs');
-    if (fs.existsSync(libsDir)) {
-        const libDirs = fs
-            .readdirSync(libsDir, { withFileTypes: true })
-            .filter(dirent => dirent.isDirectory())
-            .map(dirent => dirent.name);
-        for (const libName of libDirs) {
-            const libPath = path.join(libsDir, libName);
-            const libInfo = parsePackageInfo(libPath, libName, 'lib');
-            if (libInfo) {
-                packages.push(libInfo);
-            }
-        }
+  }
+  // Scan libs directory
+  const libsDir = path.join(rootDir, 'libs');
+  if (fs.existsSync(libsDir)) {
+    const libDirs = fs
+      .readdirSync(libsDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+    for (const libName of libDirs) {
+      const libPath = path.join(libsDir, libName);
+      const libInfo = parsePackageInfo(libPath, libName, 'lib');
+      if (libInfo) {
+        packages.push(libInfo);
+      }
     }
-    return packages;
+  }
+  return packages;
 }
 /*** Parses package.json and determines package type */
 function parsePackageInfo(packagePath, packageName, forcedType) {
-    const packageJsonPath = path.join(packagePath, 'package.json');
-    if (!fs.existsSync(packageJsonPath)) {
-        return null;
-    }
-    try {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        // Determine package type
-        let packageType = 'lib';
-        if (forcedType) {
-            packageType = forcedType;
-        }
-        else if (packageJson.scripts && packageJson.scripts.start) {
-            packageType = 'app';
-        }
-        else if (packageJson.keywords && packageJson.keywords.includes('tool')) {
-            packageType = 'tool';
-        }
-        return {
-            name: packageJson.name || packageName,
-            version: packageJson.version || '0.0.0',
-            type: packageType,
-            path: packagePath,
-            dependencies: packageJson.dependencies || {},
-            devDependencies: packageJson.devDependencies || {},
-            peerDependencies: packageJson.peerDependencies || {},
-            scripts: packageJson.scripts || {},
-            maintainers: packageJson.maintainers || [],
-            description: packageJson.description,
-            license: packageJson.license,
-            repository: packageJson.repository || {},
-        };
-    }
-    catch (error) {
-        console.error(`Error parsing package.json for ${packageName}:`, error);
-        return null;
+  const packageJsonPath = path.join(packagePath, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    // Determine package type
+    let packageType = 'lib';
+    if (forcedType) {
+      packageType = forcedType;
+    } else if (packageJson.scripts && packageJson.scripts.start) {
+      packageType = 'app';
+    } else if (packageJson.keywords && packageJson.keywords.includes('tool')) {
+      packageType = 'tool';
     }
+    return {
+      name: packageJson.name || packageName,
+      version: packageJson.version || '0.0.0',
+      type: packageType,
+      path: packagePath,
+      dependencies: packageJson.dependencies || {},
+      devDependencies: packageJson.devDependencies || {},
+      peerDependencies: packageJson.peerDependencies || {},
+      scripts: packageJson.scripts || {},
+      maintainers: packageJson.maintainers || [],
+      description: packageJson.description,
+      license: packageJson.license,
+      repository: packageJson.repository || {},
+    };
+  } catch (error) {
+    console.error(`Error parsing package.json for ${packageName}:`, error);
+    return null;
+  }
 }
 /**
  * Analyzes dependencies and determines their status
@@ -110,161 +107,166 @@ function parsePackageInfo(packagePath, packageName, forcedType) {
 /**
  * Calculates package health score based on various metrics
  */
-function calculatePackageHealth(buildStatus, testCoverage, lintStatus, securityAudit) {
-    let score = 0;
-    // Build status (30 points)
-    switch (buildStatus) {
-        case 'success':
-            score += 30;
-            break;
-        case 'running':
-            score += 15;
-            break;
-        case 'failed':
-            score += 0;
-            break;
-        default:
-            score += 10;
-    }
-    // Test coverage (25 points)
-    score += Math.min(25, (testCoverage / 100) * 25);
-    // Lint status (25 points)
-    switch (lintStatus) {
-        case 'pass':
-            score += 25;
-            break;
-        case 'fail':
-            score += 0;
-            break;
-        default:
-            score += 10;
-    }
-    // Security audit (20 points)
-    switch (securityAudit) {
-        case 'pass':
-            score += 20;
-            break;
-        case 'fail':
-            score += 0;
-            break;
-        default:
-            score += 10;
-    }
-    return {
-        buildStatus,
-        testCoverage,
-        lintStatus,
-        securityAudit,
-        overallScore: Math.round(score),
-    };
+function calculatePackageHealth(
+  buildStatus,
+  testCoverage,
+  lintStatus,
+  securityAudit
+) {
+  let score = 0;
+  // Build status (30 points)
+  switch (buildStatus) {
+    case 'success':
+      score += 30;
+      break;
+    case 'running':
+      score += 15;
+      break;
+    case 'failed':
+      score += 0;
+      break;
+    default:
+      score += 10;
+  }
+  // Test coverage (25 points)
+  score += Math.min(25, (testCoverage / 100) * 25);
+  // Lint status (25 points)
+  switch (lintStatus) {
+    case 'pass':
+      score += 25;
+      break;
+    case 'fail':
+      score += 0;
+      break;
+    default:
+      score += 10;
+  }
+  // Security audit (20 points)
+  switch (securityAudit) {
+    case 'pass':
+      score += 20;
+      break;
+    case 'fail':
+      score += 0;
+      break;
+    default:
+      score += 10;
+  }
+  return {
+    buildStatus,
+    testCoverage,
+    lintStatus,
+    securityAudit,
+    overallScore: Math.round(score),
+  };
 }
 /**
  * Generates comprehensive monorepo statistics
  */
 function generateMonorepoStats(packages) {
-    const stats = {
-        totalPackages: packages.length,
-        apps: packages.filter(p => p.type === 'app').length,
-        libraries: packages.filter(p => p.type === 'lib').length,
-        tools: packages.filter(p => p.type === 'tool').length,
-        healthyPackages: 0,
-        warningPackages: 0,
-        errorPackages: 0,
-        outdatedDependencies: 0,
-        totalDependencies: 0,
-    };
-    // Calculate dependency counts
-    packages.forEach(pkg => {
-        stats.totalDependencies += Object.keys(pkg.dependencies).length;
-        stats.totalDependencies += Object.keys(pkg.devDependencies).length;
-        stats.totalDependencies += Object.keys(pkg.peerDependencies ?? {}).length;
-    });
-    return stats;
+  const stats = {
+    totalPackages: packages.length,
+    apps: packages.filter(p => p.type === 'app').length,
+    libraries: packages.filter(p => p.type === 'lib').length,
+    tools: packages.filter(p => p.type === 'tool').length,
+    healthyPackages: 0,
+    warningPackages: 0,
+    errorPackages: 0,
+    outdatedDependencies: 0,
+    totalDependencies: 0,
+  };
+  // Calculate dependency counts
+  packages.forEach(pkg => {
+    stats.totalDependencies += Object.keys(pkg.dependencies).length;
+    stats.totalDependencies += Object.keys(pkg.devDependencies).length;
+    stats.totalDependencies += Object.keys(pkg.peerDependencies ?? {}).length;
+  });
+  return stats;
 }
 /**
  * Finds circular dependencies in the monorepo
  */
 function findCircularDependencies(packages) {
-    const graph = new Map();
-    const visited = new Set();
-    const recursionStack = new Set();
-    const circularDeps = [];
-    // Build dependency graph
-    packages.forEach(pkg => {
-        graph.set(pkg.name, Object.keys(pkg.dependencies));
-    });
-    function dfs(node, path) {
-        if (recursionStack.has(node)) {
-            const cycleStart = path.indexOf(node);
-            circularDeps.push(path.slice(cycleStart));
-            return;
-        }
-        if (visited.has(node)) {
-            return;
-        }
-        visited.add(node);
-        recursionStack.add(node);
-        path.push(node);
-        const dependencies = graph.get(node) || [];
-        for (const dep of dependencies) {
-            if (graph.has(dep)) {
-                dfs(dep, [...path]);
-            }
-        }
-        recursionStack.delete(node);
+  const graph = new Map();
+  const visited = new Set();
+  const recursionStack = new Set();
+  const circularDeps = [];
+  // Build dependency graph
+  packages.forEach(pkg => {
+    graph.set(pkg.name, Object.keys(pkg.dependencies));
+  });
+  function dfs(node, path) {
+    if (recursionStack.has(node)) {
+      const cycleStart = path.indexOf(node);
+      circularDeps.push(path.slice(cycleStart));
+      return;
     }
-    for (const node of graph.keys()) {
-        if (!visited.has(node)) {
-            dfs(node, []);
-        }
+    if (visited.has(node)) {
+      return;
+    }
+    visited.add(node);
+    recursionStack.add(node);
+    path.push(node);
+    const dependencies = graph.get(node) || [];
+    for (const dep of dependencies) {
+      if (graph.has(dep)) {
+        dfs(dep, [...path]);
+      }
     }
-    return circularDeps;
+    recursionStack.delete(node);
+  }
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node, []);
+    }
+  }
+  return circularDeps;
 }
 /**
  * Generates a dependency graph for visualization
  */
 function generateDependencyGraph(packages) {
-    const nodes = packages.map(pkg => ({
-        // id: pkg.name,
-        label: pkg.name,
-        type: pkg.type,
-        version: pkg.version,
-        dependencies: Object.keys(pkg.dependencies).length,
-    }));
-    const edges = [];
-    packages.forEach(pkg => {
-        Object.keys(pkg.dependencies).forEach(depName => {
-            // Only include internal dependencies
-            if (packages.some(p => p.name === depName)) {
-                edges.push({
-                    from: pkg.name,
-                    to: depName,
-                    type: 'internal',
-                });
-            }
+  const nodes = packages.map(pkg => ({
+    // id: pkg.name,
+    label: pkg.name,
+    type: pkg.type,
+    version: pkg.version,
+    dependencies: Object.keys(pkg.dependencies).length,
+  }));
+  const edges = [];
+  packages.forEach(pkg => {
+    Object.keys(pkg.dependencies).forEach(depName => {
+      // Only include internal dependencies
+      if (packages.some(p => p.name === depName)) {
+        edges.push({
+          from: pkg.name,
+          to: depName,
+          type: 'internal',
         });
+      }
     });
-    return { nodes, edges };
+  });
+  return { nodes, edges };
 }
 /**
  * Checks if a package has outdated dependencies
  */
 function checkOutdatedDependencies(packageInfo) {
-    const outdated = [];
-    // This would typically involve checking against npm registry
-    // For now, we'll simulate with some basic checks
-    Object.entries(packageInfo.dependencies).forEach(([name, version]) => {
-        if (version.startsWith('^') || version.startsWith('~')) {
-            // Could be outdated, would need registry check
-            outdated.push({
-                name,
-                version: version,
-                status: 'unknown',
-                type: 'dependency',
-            });
-        }
-    });
-    return outdated;
+  const outdated = [];
+  // This would typically involve checking against npm registry
+  // For now, we'll simulate with some basic checks
+  Object.entries(packageInfo.dependencies).forEach(([name, version]) => {
+    if (version.startsWith('^') || version.startsWith('~')) {
+      // Could be outdated, would need registry check
+      outdated.push({
+        name,
+        version: version,
+        status: 'unknown',
+        type: 'dependency',
+      });
+    }
+  });
+  return outdated;
 }
 /**
  * Formats version numbers for comparison
@@ -293,41 +295,45 @@ function checkOutdatedDependencies(packageInfo) {
  * Gets package size information
  */
 function getPackageSize(packagePath) {
-    try {
-        let totalSize = 0;
-        let fileCount = 0;
-        const calculateSize = (dirPath) => {
-            const items = fs.readdirSync(dirPath, { withFileTypes: true });
-            for (const item of items) {
-                const fullPath = path.join(dirPath, item.name);
-                if (item.isDirectory()) {
-                    // Skip node_modules and other build artifacts
-                    if (!['node_modules', 'dist', 'build', '.git'].includes(item.name)) {
-                        calculateSize(fullPath);
-                    }
-                }
-                else {
-                    try {
-                        const stats = fs.statSync(fullPath);
-                        totalSize += stats.size;
-                        fileCount++;
-                    }
-                    catch (error) {
-                        // Skip files we can't read
-                    }
-                }
-            }
-        };
-        calculateSize(packagePath);
-        return {
-            size: totalSize,
-            files: fileCount,
-        };
-    }
-    catch (error) {
-        return { size: 0, files: 0 };
-    }
+  try {
+    let totalSize = 0;
+    let fileCount = 0;
+    const calculateSize = dirPath => {
+      const items = fs.readdirSync(dirPath, { withFileTypes: true });
+      for (const item of items) {
+        const fullPath = path.join(dirPath, item.name);
+        if (item.isDirectory()) {
+          // Skip node_modules and other build artifacts
+          if (!['node_modules', 'dist', 'build', '.git'].includes(item.name)) {
+            calculateSize(fullPath);
+          }
+        } else {
+          try {
+            const stats = fs.statSync(fullPath);
+            totalSize += stats.size;
+            fileCount++;
+          } catch (error) {
+            // Skip files we can't read
+          }
+        }
+      }
+    };
+    calculateSize(packagePath);
+    return {
+      size: totalSize,
+      files: fileCount,
+    };
+  } catch (error) {
+    return { size: 0, files: 0 };
+  }
 }
-export { scanMonorepo, generateMonorepoStats, findCircularDependencies, generateDependencyGraph, checkOutdatedDependencies, getPackageSize,
-// analyzeDependencies,
-calculatePackageHealth, };
+export {
+  scanMonorepo,
+  generateMonorepoStats,
+  findCircularDependencies,
+  generateDependencyGraph,
+  checkOutdatedDependencies,
+  getPackageSize,
+  // analyzeDependencies,
+  calculatePackageHealth,
+};

package/helpers.ts

@@ -420,7 +420,7 @@ function getPackageSize(packagePath: string): {
           }
         }
       }
-    }
+    };
 
     calculateSize(packagePath);
 

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@monodog/utils",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Shared utility functions for monodog monorepo dashboard",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
-  "scripts": {
-    "build": "tsc --build",
-    "test": "jest",
-    "clean": "rm -rf dist node_modules/.cache"
-  },
   "devDependencies": {
     "@types/node": "^20.10.0",
     "typescript": "^5.2.2"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "clean": "rm -rf dist node_modules/.cache"
   }
-}
+}

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   // Extends the shared Node configuration for server/utility environments
-  "extends": "@lakinmindfire/tsconfig/node.json",
+//   "extends": "@manojk/tsconfig/node.json",
 
   "compilerOptions": {
     // Output compilation results to the 'dist' directory
@@ -11,7 +11,7 @@
     "module": "CommonJS",
     "moduleResolution": "node",
     "verbatimModuleSyntax": false,
-    "downlevelIteration": true,
+    "downlevelIteration": true
   },
 
   // Include all TypeScript files in the 'src' folder