@manojkmfsi/monodog 1.1.0 → 1.1.2

package/src/services/commit-service.ts

@@ -1,14 +1,15 @@
 import { GitService } from './git-service';
 import path from 'path';
 import fs from 'fs';
+import { AppLogger } from '../middleware/logger';
 
 export const getCommitsByPathService = async (packagePath: string) => {
 
   // Decode the package path
   const decodedPath = decodeURIComponent(packagePath);
 
-  console.log('Fetching commits for path:', decodedPath);
-  console.log('Current working directory:', process.cwd());
+  AppLogger.debug('Fetching commits for path: ' + decodedPath);
+  AppLogger.debug('Current working directory: ' + process.cwd());
 
   const gitService = new GitService();
 
@@ -19,22 +20,21 @@ export const getCommitsByPathService = async (packagePath: string) => {
   // If it's an absolute path, make it relative to project root
   if (path.isAbsolute(decodedPath)) {
     relativePath = path.relative(projectRoot, decodedPath);
-    console.log('Converted absolute path to relative:', relativePath);
+    AppLogger.debug('Converted absolute path to relative: ' + relativePath);
   }
 
   // Check if the path exists
   try {
     await fs.promises.access(relativePath);
-    console.log('Path exists:', relativePath);
+    AppLogger.debug('Path exists: ' + relativePath);
   } catch (fsError) {
-    console.log('Path does not exist:', relativePath);
     // Try the original path as well
     try {
       await fs.promises.access(decodedPath);
-      console.log('Original path exists:', decodedPath);
+      AppLogger.debug('Original Commit path exists: ' + decodedPath);
       relativePath = decodedPath; // Use original path if it exists
     } catch (secondError) {
-      throw new Error(`Path does not exist: ${decodedPath}`);
+      throw new Error(`Commit Path does not exist: ${decodedPath}`);
     }
   }
 

package/src/services/config-service.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 
+import { AppLogger } from '../middleware/logger';
 import { PackageRepository } from '../repositories';
 
 /**
@@ -91,13 +92,13 @@ async function scanConfigFiles(rootDir: string): Promise<any[]> {
                 hasSecrets: containsSecrets(content, item.name),
               });
             } catch (error) {
-              console.warn(`Could not read file: ${fullPath}`);
+              AppLogger.warn(`Could not read file: ${fullPath}`);
             }
           }
         }
       }
     } catch (error) {
-      console.warn(`Could not scan directory: ${dir}`);
+      AppLogger.warn(`Could not scan directory: ${dir}`);
     }
   }
 
@@ -139,7 +140,7 @@ async function scanConfigFiles(rootDir: string): Promise<any[]> {
     });
   }
 
-  console.log(`Scanning for config files in: ${rootDir}`);
+  AppLogger.info(`Scanning for config files in: ${rootDir}`);
 
   // Start scanning from root
   scanDirectory(rootDir);
@@ -147,16 +148,16 @@ async function scanConfigFiles(rootDir: string): Promise<any[]> {
   // Sort files by path for consistent ordering
   configFiles.sort((a, b) => a.path.localeCompare(b.path));
 
-  console.log(`Found ${configFiles.length} configuration files`);
+  AppLogger.info(`Found ${configFiles.length} configuration files`);
 
   // Log some sample files for debugging
   if (configFiles.length > 0) {
-    console.log('Sample config files found:');
+    AppLogger.info('Sample config files found');
     configFiles.slice(0, 5).forEach(file => {
-      console.log(`  - ${file.path} (${file.type})`);
+      AppLogger.debug(`  - ${file.path} (${file.type})`);
     });
     if (configFiles.length > 5) {
-      console.log(`  ... and ${configFiles.length - 5} more`);
+      AppLogger.debug(`  ... and ${configFiles.length - 5} more`);
     }
   }
 
@@ -244,8 +245,8 @@ export const updateConfigFileService = async (id: string, rootDir: string, conte
     id.startsWith('/') ? id.slice(1) : id
   );
 
-  console.log('Saving file:', filePath);
-  console.log('Root directory:', rootDir);
+  AppLogger.debug('Saving file: ' + filePath);
+  AppLogger.debug('Root directory: ' + rootDir);
 
   // Security check: ensure the file is within the project directory
   if (!filePath.startsWith(rootDir)) {
@@ -289,7 +290,7 @@ export const updatePackageConfigurationService = async (packagePath: string, pac
   try {
     newConfig = JSON.parse(config);
   } catch (error) {
-    console.error('JSON parsing error:', error);
+    AppLogger.error('JSON parsing error', error as Error);
     throw new Error('Invalid JSON format: ' + (error instanceof Error ? error.message : 'Unknown error'));
   }
 
@@ -362,7 +363,7 @@ export const updatePackageConfigurationService = async (packagePath: string, pac
   if (newConfig.peerDependencies)
     updateData.peerDependencies = JSON.stringify(newConfig.peerDependencies);
 
-  console.log('Updating database with:', updateData);
+  AppLogger.debug('Updating database with:', updateData);
 
   const updatedPackage = await PackageRepository.updateConfig(packageName, updateData);
 

package/src/services/git-service.ts

@@ -9,6 +9,7 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import path from 'path';
 
+import { AppLogger } from '../middleware/logger';
 import type { Commit } from '../types';
 import { VALID_COMMIT_TYPES } from '../types';
 
@@ -40,10 +41,10 @@ export class GitService {
       // First, validate we're in a git repo
       await this.validateGitRepository(pathArgument);
 
-      console.log(`Executing Git command in: ${this.repoPath}`);
+      AppLogger.debug(`Executing Git command in: ${this.repoPath}`);
       // Use a simpler git log format
       const command = `git log --pretty=format:"%H|%an|%ad|%s" --date=iso-strict ${pathArgument}`;
-      console.log(`Git command: ${command}`);
+      AppLogger.debug(`Git command: ${command}`);
 
       const { stdout, stderr } = await execPromise(command, {
         cwd: this.repoPath,
@@ -51,11 +52,11 @@ export class GitService {
       });
 
       if (stderr) {
-        console.warn('Git stderr:', stderr);
+        AppLogger.warn('Git stderr: ' + stderr);
       }
 
       if (!stdout.trim()) {
-        console.log('📭 No commits found for path:', pathFilter);
+        AppLogger.debug('No commits found for path: ' + pathFilter);
         return [];
       }
 
@@ -78,14 +79,14 @@ export class GitService {
 
           commits.push(commit);
         } catch (parseError) {
-          console.error('Failed to parse commit line:', line, parseError);
+          AppLogger.error('Failed to parse commit line: ' + line, parseError as Error);
         }
       }
 
-      console.log(`Successfully parsed ${commits.length} commits`);
+      AppLogger.debug(`Successfully parsed ${commits.length} commits`);
       return commits;
     } catch (error) {
-      console.error('Error in getAllCommits:', error);
+      AppLogger.error('Error in getAllCommits', error as Error);
       throw error;
     }
   }
@@ -129,7 +130,7 @@ export class GitService {
       await execPromise('git '+pathArgument+' rev-parse --is-inside-work-tree', {
         cwd: this.repoPath,
       });
-      console.log('Valid git repository');
+      AppLogger.debug('Valid git repository');
     } catch (error) {
       throw new Error(
         'Not a git repository (or any of the parent directories)'

package/src/services/health-service.ts

@@ -9,6 +9,7 @@ import {
   funCheckSecurityAudit,
 } from '../utils/monorepo-scanner';
 
+import { AppLogger } from '../middleware/logger';
 import { PackageHealthRepository, PackageRepository } from '../repositories';
 import type { TransformedPackageHealth, HealthResponse, PackageHealthModel } from '../types/database';
 
@@ -17,7 +18,7 @@ let inFlightHealthRefresh: Promise<HealthResponse> | null = null;
 
 export const getHealthSummaryService = async (): Promise<HealthResponse> => {
   const packageHealthData = await PackageHealthRepository.findAll() as PackageHealthModel[];
-  console.log('packageHealthData -->', packageHealthData.length);
+  AppLogger.debug('packageHealthData count: ' + packageHealthData.length);
 
   // Transform the data to match the expected frontend format
   const packages = packageHealthData.map((pkg: PackageHealthModel) => {
@@ -60,7 +61,7 @@ export const getHealthSummaryService = async (): Promise<HealthResponse> => {
 export const healthRefreshService = async (rootDir: string) => {
   // If a health refresh is already in progress, return the in-flight promise
   if (inFlightHealthRefresh) {
-    console.log('Health refresh already in progress, returning cached promise');
+    AppLogger.info('Health refresh already in progress, returning cached promise');
     return inFlightHealthRefresh;
   }
 
@@ -68,7 +69,7 @@ export const healthRefreshService = async (rootDir: string) => {
   inFlightHealthRefresh = (async () => {
     try {
       const packages = scanMonorepo(rootDir);
-      console.log('packages -->', packages.length);
+      AppLogger.debug('packages count: ' + packages.length);
       const healthMetrics = await Promise.all(
         packages.map(async pkg => {
           try {
@@ -99,7 +100,7 @@ export const healthRefreshService = async (rootDir: string) => {
                   ? 'warning'
                   : 'error';
 
-            console.log(pkg.name, '-->', health, packageStatus);
+            AppLogger.debug(`${pkg.name}: ${packageStatus}`, health);
 
             await PackageHealthRepository.upsert({
               packageName: pkg.name,

package/src/services/package-service.ts

@@ -1,6 +1,7 @@
 import { scanMonorepo } from '../utils/utilities';
 import { generateReports } from '../utils/monorepo-scanner';
 import { ciStatusManager } from '../utils/ci-status';
+import { AppLogger } from '../middleware/logger';
 import { PackageRepository, CommitRepository, DependencyRepository } from '../repositories';
 import type { PackageInfo, DependencyInfo, PackageReport } from '../types';
 import { getCommitsByPathService } from './commit-service';
@@ -98,7 +99,7 @@ async function storePackage(pkg: PackageInfo): Promise<void> {
       await DependencyRepository.storeMany(pkg.name, dependenciesInfo);
     }
   } catch (error) {
-    console.warn(` Failed to store report for ${pkg.name}:`, error);
+    AppLogger.warn(`Failed to store report for ${pkg.name}`);
   }
 }
 
@@ -107,9 +108,9 @@ export const getPackagesService = async (rootPath: string) => {
   if (!dbPackages.length) {
     try {
       const rootDir = rootPath;
-      console.log('rootDir -->', rootDir);
+      AppLogger.debug('rootDir: ' + rootDir);
       const packages = scanMonorepo(rootDir);
-      console.log('packages --> scan', packages.length);
+      AppLogger.debug('packages scanned: ' + packages.length);
       for (const pkg of packages) {
         await storePackage(pkg);
       }
@@ -155,7 +156,7 @@ export const refreshPackagesService = async (rootPath: string) => {
   const rootDir = rootPath;
   const packages = scanMonorepo(rootDir);
 
-  console.log('packages -->', packages.length);
+  AppLogger.debug('packages count: ' + packages.length);
   for (const pkg of packages) {
     await storePackage(pkg);
   }

package/src/utils/ci-status.ts

@@ -1,3 +1,4 @@
+import { AppLogger } from '../middleware/logger';
 import type { PackageInfo } from './utilities';
 import type {
   CIProvider,
@@ -130,7 +131,7 @@ export class CIStatusManager {
       this.setCache(cacheKey, status);
       return status;
     } catch (error) {
-      console.error(`Error fetching CI status for ${packageName}:`, error);
+      AppLogger.error(`Error fetching CI status for ${packageName}`, error as Error);
       return null;
     }
   }
@@ -468,7 +469,7 @@ export class CIStatusManager {
       // Mock implementation
       const buildId = `build-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 
-      console.log(
+      AppLogger.info(
         `Triggering build for ${packageName} on ${branch} via ${providerName}`
       );
 

package/src/utils/db-utils.ts

@@ -0,0 +1,92 @@
+import type { PackageInfo, DependencyInfo, Commit } from '../types';
+import { AppLogger } from '../middleware/logger';
+import { CommitRepository, DependencyRepository, PackageRepository } from '../repositories';
+import { appConfig } from '../config-loader';
+
+// Default settings
+const DEFAULT_PORT = 4000;
+const port = appConfig.server.port ?? DEFAULT_PORT; //Default port
+const host = appConfig.server.host ?? 'localhost'; //Default host
+
+const API_BASE = `http://${host}:${port}/api`;
+
+async function getCommits(path: string): Promise<Commit[]> {
+  const res = await fetch(API_BASE + `/commits/` + encodeURIComponent(path));
+  if (!res.ok) throw new Error('Failed to fetch commits');
+  return (await res.json()) as Commit[];
+}
+
+/**
+ * Get package dependencies
+ */
+function getPackageDependenciesInfo(pkg: PackageInfo): DependencyInfo[] {
+  const allDeps: DependencyInfo[] = [];
+  Object.keys(pkg.dependencies || {}).forEach(depName => {
+    allDeps.push({
+      name: depName,
+      version: pkg.dependencies[depName],
+      type: 'dependency',
+      latest: '',
+      outdated: false,
+    });
+  });
+  Object.keys(pkg.devDependencies || {}).forEach(depName => {
+    allDeps.push({
+      name: depName,
+      version: pkg.devDependencies[depName],
+      type: 'devDependency',
+      latest: '',
+      outdated: false,
+    });
+  });
+  Object.keys(pkg.peerDependencies || {}).forEach(depName => {
+    allDeps.push({
+      name: depName,
+      version: pkg.peerDependencies[depName]!,
+      type: 'peerDependency',
+      latest: '',
+      outdated: false,
+    });
+  });
+  return allDeps;
+}
+
+/**
+ * Store packages in database using repository pattern
+ */
+async function storePackage(pkg: PackageInfo): Promise<void> {
+  try {
+    // Create or update package using repository
+    await PackageRepository.upsert({
+      name: pkg.name,
+      version: pkg.version,
+      type: pkg.type,
+      path: pkg.path,
+      description: pkg.description,
+      license: pkg.license,
+      repository: pkg.repository,
+      scripts: pkg.scripts,
+      dependencies: pkg.dependencies,
+      devDependencies: pkg.devDependencies,
+      peerDependencies: pkg.peerDependencies,
+      maintainers: pkg.maintainers.join(','),
+      status: '',
+    });
+
+    // Store commits using repository
+    const commits = await getCommits(pkg.path ?? '');
+    if (commits.length) {
+      await CommitRepository.storeMany(pkg.name, commits);
+    }
+
+    // Store dependencies using repository
+    const dependenciesInfo = getPackageDependenciesInfo(pkg);
+    if (dependenciesInfo.length) {
+      await DependencyRepository.storeMany(pkg.name, dependenciesInfo);
+    }
+  } catch (error) {
+    AppLogger.warn(`Failed to store report for ${pkg.name}`);
+  }
+}
+
+export { storePackage };

package/src/utils/monorepo-scanner.ts

@@ -2,6 +2,7 @@
 import fs from 'fs';
 import path from 'path';
 import { execSync } from 'child_process';
+import { AppLogger } from '../middleware/logger';
 import type {
   PackageInfo,
   DependencyInfo,
@@ -43,11 +44,11 @@ export class MonorepoScanner {
         return cached;
       }
 
-      console.log('Starting monorepo scan...');
+      AppLogger.debug('Starting monorepo scan...');
 
       // Scan all packages
       const packages = scanMonorepo(this.rootDir);
-      console.log(`📦 Found ${packages.length} packages`);
+      AppLogger.debug(`Found ${packages.length} packages`);
 
       // Generate statistics
       const stats = generateMonorepoStats(packages);
@@ -74,10 +75,10 @@ export class MonorepoScanner {
       // Cache the result
       this.setCache(cacheKey, result);
 
-      console.log(`Scan completed in ${result.scanDuration}ms`);
+      AppLogger.debug(`Scan completed in ${result.scanDuration}ms`);
       return result;
     } catch (error) {
-      console.error('Error during scan:', error);
+      AppLogger.error('Error during scan', error as Error);
       throw error;
     }
   }
@@ -94,7 +95,7 @@ export class MonorepoScanner {
         const report = await this.generatePackageReport(pkg);
         reports.push(report);
       } catch (error) {
-        console.error(`Error generating report for ${pkg.name}:`, error);
+        AppLogger.error(`Error generating report for ${pkg.name}`, error as Error);
       }
     }
 
@@ -206,10 +207,7 @@ export class MonorepoScanner {
                 0
               );
             } catch (error) {
-              console.warn(
-                `Error parsing coverage file for ${pkg.name}:`,
-                error
-              );
+              AppLogger.warn(`Error parsing coverage file for ${pkg.name}`);
             }
           }
           // If we find any coverage file but can't parse it, assume coverage exists
@@ -232,7 +230,7 @@ export class MonorepoScanner {
 
       return 0;
     } catch (error) {
-      console.warn(`Error checking coverage for ${pkg.name}:`, error);
+      AppLogger.warn(`Error checking coverage for ${pkg.name}`);
       return 0;
     }
   }

package/src/utils/utilities.ts

@@ -2,6 +2,7 @@
 import * as fs from 'fs';
 import path from 'path';
 import { appConfig } from '../config-loader';
+import { AppLogger } from '../middleware/logger';
 import {calculatePackageHealth} from './health-utils';
 import * as yaml from 'js-yaml';
 
@@ -64,7 +65,7 @@ function getWorkspacesFromPnpmYaml(rootDir: string): string[] | undefined {
             }
         }
     } catch (e) {
-        console.error(`\nError parsing pnpm-workspace.yaml at ${workspaceYamlPath}:`, e);
+        AppLogger.error(`Error parsing pnpm-workspace.yaml at ${workspaceYamlPath}:`, e as Error);
     }
     return undefined;
 }
@@ -83,27 +84,27 @@ export function getWorkspacesFromRoot(rootDir: string): string[] | undefined {
 
             // Handle both standard array and object format (used by yarn/pnpm)
             if (Array.isArray(packageJson.workspaces)) {
-                console.log('Workspace configuration found in package.json');
+                AppLogger.info('Workspace configuration found in package.json');
                 return packageJson.workspaces;
             } else if (packageJson.workspaces && Array.isArray(packageJson.workspaces.packages)) {
-                console.log('Workspace configuration found in package.json');
+                AppLogger.info('Workspace configuration found in package.json');
                 return packageJson.workspaces.packages;
             }
         } catch (e) {
-            console.error(`\nError parsing package.json at ${packageJsonPath}. Attempting to read pnpm-workspace.yaml...`);
+            AppLogger.error(`Error parsing package.json at ${packageJsonPath}. Attempting to read pnpm-workspace.yaml...`, e as Error);
         }
     } else {
-        console.warn(`\nWarning: No package.json found at root directory: ${rootDir}`);
+        AppLogger.warn(`No package.json found at root directory: ${rootDir}`);
     }
 
     // Fallback to pnpm-workspace.yaml
     const pnpmWorkspaces = getWorkspacesFromPnpmYaml(rootDir);
     if (pnpmWorkspaces && pnpmWorkspaces.length > 0) {
-        console.log('Workspace configuration found in pnpm-workspace.yaml');
+        AppLogger.info('Workspace configuration found in pnpm-workspace.yaml');
         return pnpmWorkspaces;
     }
 
-    console.warn('\nNo workspace configuration found in package.json or pnpm-workspace.yaml');
+    AppLogger.warn('No workspace configuration found in package.json or pnpm-workspace.yaml');
     return undefined;
 }
 
@@ -112,22 +113,24 @@ export function getWorkspacesFromRoot(rootDir: string): string[] | undefined {
  */
 function scanMonorepo(rootDir: string): PackageInfo[] {
   const packages: PackageInfo[] = [];
-  console.log('rootDir:', rootDir);
+  AppLogger.debug('rootDir: ' + rootDir);
   const workspacesGlobs = appConfig.workspaces;
   // Use provided workspaces globs if given, otherwise attempt to detect from root package.json or pnpm-workspace.yaml
   const detectedWorkspacesGlobs = workspacesGlobs.length > 0 ? workspacesGlobs : getWorkspacesFromRoot(rootDir);
   if (detectedWorkspacesGlobs && detectedWorkspacesGlobs.length > 0) {
     if (workspacesGlobs.length) {
-      console.log(`\nUsing provided workspaces globs: ${detectedWorkspacesGlobs.join(', ')}`);
+      AppLogger.info(`Using provided workspaces globs: ${detectedWorkspacesGlobs.join(', ')}`);
     } else {
-      console.log(`\nDetected Monorepo Workspaces Globs: ${detectedWorkspacesGlobs.join(', ')}`);
+      AppLogger.info(`Detected Monorepo Workspaces Globs: ${detectedWorkspacesGlobs.join(', ')}`);
     }
 
     // 1. Resolve the globs into concrete package directory paths
     const resolvedPackagePaths = resolveWorkspaceGlobs(rootDir, detectedWorkspacesGlobs);
 
-    console.log(`[DEBUG] Resolved package directories (Total ${resolvedPackagePaths.length}):`);
-    console.warn(resolvedPackagePaths.length < workspacesGlobs.length ? 'Some workspaces globs provided are invalid.' : '');
+    AppLogger.debug(`Resolved package directories (Total ${resolvedPackagePaths.length})`);
+    if (resolvedPackagePaths.length < workspacesGlobs.length) {
+      AppLogger.warn('Some workspaces globs provided are invalid.');
+    }
 
     // 2. Integration of the requested loop structure for package scanning
     for (const workspacePath of resolvedPackagePaths) {
@@ -135,7 +138,7 @@ function scanMonorepo(rootDir: string): PackageInfo[] {
       // The package name would be read from the package.json inside this path
       const packageName = path.basename(fullPackagePath);
 
-      console.log(`- Scanning path: ${workspacePath} (Package: ${packageName})`);
+      AppLogger.debug(`- Scanning path: ${workspacePath} (Package: ${packageName})`);
 
       const packageInfo = parsePackageInfo(fullPackagePath, packageName);
       if (packageInfo) {
@@ -143,7 +146,7 @@ function scanMonorepo(rootDir: string): PackageInfo[] {
       }
     }
   } else {
-    console.warn('\nNo workspace globs provided or detected. Returning empty package list.');
+    AppLogger.warn('No workspace globs provided or detected. Returning empty package list.');
   }
 
   return packages;
@@ -189,7 +192,7 @@ export function parsePackageInfo(
       repository: packageJson.repository || {},
     };
   } catch (error) {
-    console.error(`Error parsing package.json for ${packageName}:`, error);
+    AppLogger.error(`Error parsing package.json for ${packageName}`, error as Error);
     return null;
   }
 }
@@ -384,7 +387,7 @@ function findMonorepoRoot(): string {
         );
         // If it has workspaces or is the root monorepo package
         if (packageJson.workspaces || fs.existsSync(pnpmWorkspacePath)) {
-          console.log('Found monorepo root:', currentDir);
+          AppLogger.debug('Found monorepo root: ' + currentDir);
           return currentDir;
         }
       } catch (error) {
@@ -395,7 +398,7 @@ function findMonorepoRoot(): string {
     // Check if we're at the git root
     const gitPath = path.join(currentDir, '.git');
     if (fs.existsSync(gitPath)) {
-      console.log('Found git root (likely monorepo root):', currentDir);
+      AppLogger.debug('Found git root (likely monorepo root): ' + currentDir);
       return currentDir;
     }
 
@@ -406,9 +409,8 @@ function findMonorepoRoot(): string {
   }
 
   // Fallback to process.cwd() if we can't find the root
-  console.log(
-    'Could not find monorepo root, using process.cwd():',
-    process.cwd()
+  AppLogger.warn(
+    'Could not find monorepo root, using process.cwd(): ' + process.cwd()
   );
   return process.cwd();
 }