@manojkmfsi/monodog 1.1.6 → 1.1.8

package/src/services/config-service.ts

@@ -1,391 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-import { AppLogger } from '../middleware/logger';
-import { PackageRepository } from '../repositories';
-
-/**
- * Configuration file interface
- */
-interface ConfigFile {
-  id: string;
-  name: string;
-  path: string;
-  type: string;
-  content: string;
-  size: number;
-  lastModified: string;
-  hasSecrets: boolean;
-}
-
-interface TransformedConfigFile extends ConfigFile {
-  isEditable: boolean;
-}
-
-// Helper function to scan for configuration files
-async function scanConfigFiles(rootDir: string): Promise<any[]> {
-  const configPatterns = [
-    // Root level config files
-    'package.json',
-    'pnpm-workspace.yaml',
-    'pnpm-lock.yaml',
-    'turbo.json',
-    'tsconfig.json',
-    '.eslintrc.*',
-    '.prettierrc',
-    '.prettierignore',
-    '.editorconfig',
-    '.nvmrc',
-    '.gitignore',
-    'commitlint.config.js',
-    '.releaserc.json',
-    'env.example',
-
-    // App-specific config files
-    'vite.config.*',
-    'tailwind.config.*',
-    'postcss.config.*',
-    'components.json',
-
-    // Package-specific config files
-    'jest.config.*',
-    '.env*',
-    'dockerfile*',
-  ];
-
-  const configFiles: ConfigFile[] = [];
-  const scannedPaths = new Set();
-
-  function scanDirectory(dir: string, depth = 0) {
-    if (scannedPaths.has(dir) || depth > 8) return; // Limit depth for safety
-    scannedPaths.add(dir);
-
-    try {
-      const items = fs.readdirSync(dir, { withFileTypes: true });
-
-      for (const item of items) {
-        const fullPath = path.join(dir, item.name);
-
-        if (item.isDirectory()) {
-          // Skip node_modules and other non-source directories
-          if (!shouldSkipDirectory(item.name, depth)) {
-            scanDirectory(fullPath, depth + 1);
-          }
-        } else {
-          // Check if file matches config patterns
-          if (isConfigFile(item.name)) {
-            try {
-              const stats = fs.statSync(fullPath);
-              const content = fs.readFileSync(fullPath, 'utf8');
-              const relativePath =
-                fullPath.replace(rootDir, '').replace(/\\/g, '/') ||
-                `/${item.name}`;
-
-              configFiles.push({
-                id: relativePath,
-                name: item.name,
-                path: relativePath,
-                type: getFileType(item.name),
-                content: content,
-                size: stats.size,
-                lastModified: stats.mtime.toISOString(),
-                hasSecrets: containsSecrets(content, item.name),
-              });
-            } catch (error) {
-              AppLogger.warn(`Could not read file: ${fullPath}`);
-            }
-          }
-        }
-      }
-    } catch (error) {
-      AppLogger.warn(`Could not scan directory: ${dir}`);
-    }
-  }
-
-  function shouldSkipDirectory(dirName: string, depth: number): boolean {
-    const skipDirs = [
-      'node_modules',
-      'dist',
-      'build',
-      '.git',
-      '.next',
-      '.vscode',
-      '.turbo',
-      '.husky',
-      '.github',
-      '.vite',
-      'migrations',
-      'coverage',
-      '.cache',
-      'tmp',
-      'temp',
-    ];
-
-    // At root level, be more permissive
-    if (depth === 0) {
-      return skipDirs.includes(dirName);
-    }
-
-    // Deeper levels, skip more directories
-    return skipDirs.includes(dirName) || dirName.startsWith('.');
-  }
-
-  function isConfigFile(filename: string): boolean {
-    return configPatterns.some(pattern => {
-      if (pattern.includes('*')) {
-        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-        return regex.test(filename.toLowerCase());
-      }
-      return filename.toLowerCase() === pattern.toLowerCase();
-    });
-  }
-
-  AppLogger.info(`Scanning for config files in: ${rootDir}`);
-
-  // Start scanning from root
-  scanDirectory(rootDir);
-
-  // Sort files by path for consistent ordering
-  configFiles.sort((a, b) => a.path.localeCompare(b.path));
-
-  AppLogger.info(`Found ${configFiles.length} configuration files`);
-
-  // Log some sample files for debugging
-  if (configFiles.length > 0) {
-    AppLogger.info('Sample config files found');
-    configFiles.slice(0, 5).forEach(file => {
-      AppLogger.debug(`  - ${file.path} (${file.type})`);
-    });
-    if (configFiles.length > 5) {
-      AppLogger.debug(`  ... and ${configFiles.length - 5} more`);
-    }
-  }
-
-  return configFiles;
-}
-
-function containsSecrets(content: string, filename: string): boolean {
-  // Only check .env files and files that might contain secrets
-  if (!filename.includes('.env') && !filename.includes('config')) {
-    return false;
-  }
-
-  const secretPatterns = [
-    /password\s*=\s*[^\s]/i,
-    /secret\s*=\s*[^\s]/i,
-    /key\s*=\s*[^\s]/i,
-    /token\s*=\s*[^\s]/i,
-    /auth\s*=\s*[^\s]/i,
-    /credential\s*=\s*[^\s]/i,
-    /api_key\s*=\s*[^\s]/i,
-    /private_key\s*=\s*[^\s]/i,
-    /DATABASE_URL/i,
-    /JWT_SECRET/i,
-    /GITHUB_TOKEN/i,
-  ];
-
-  return secretPatterns.some(pattern => pattern.test(content));
-}
-
-function getFileType(filename: string): string {
-  const extension = filename.split('.').pop()?.toLowerCase();
-  switch (extension) {
-    case 'json':
-      return 'json';
-    case 'yaml':
-    case 'yml':
-      return 'yaml';
-    case 'js':
-      return 'javascript';
-    case 'ts':
-      return 'typescript';
-    case 'env':
-      return 'env';
-    case 'md':
-      return 'markdown';
-    case 'cjs':
-      return 'javascript';
-    case 'config':
-      return 'text';
-    case 'example':
-      return filename.includes('.env') ? 'env' : 'text';
-    default:
-      return 'text';
-  }
-}
-
-export const getConfigurationFilesService = async (rootDir: string) => {
-
-  const configFiles = await scanConfigFiles(rootDir);
-
-  // Transform to match frontend ConfigFile interface
-  const transformedFiles = configFiles.map(file => ({
-    id: file.id,
-    name: file.name,
-    path: file.path,
-    type: file.type,
-    content: file.content,
-    size: file.size,
-    lastModified: file.lastModified,
-    hasSecrets: file.hasSecrets,
-    isEditable: true,
-  }));
-
-  return {
-    success: true,
-    files: transformedFiles,
-    total: transformedFiles.length,
-    timestamp: Date.now(),
-  };
-}
-
-export const updateConfigFileService = async (id: string, rootDir: string, content: string) => {
-  const filePath = path.join(
-    rootDir,
-    id.startsWith('/') ? id.slice(1) : id
-  );
-
-  AppLogger.debug('Saving file: ' + filePath);
-  AppLogger.debug('Root directory: ' + rootDir);
-
-  // Security check: ensure the file is within the project directory
-  if (!filePath.startsWith(rootDir)) {
-    throw new Error('Invalid file path');
-  }
-
-  // Check if file exists and is writable
-  try {
-    await fs.promises.access(filePath, fs.constants.W_OK);
-  } catch (error) {
-    throw new Error('File is not writable or does not exist ' + filePath);
-  }
-  // Write the new content
-  await fs.promises.writeFile(filePath, content, 'utf8');
-
-  // Get file stats for updated information
-  const stats = await fs.promises.stat(filePath);
-  const filename = path.basename(filePath);
-
-  const updatedFile = {
-    id: id,
-    name: filename,
-    path: id,
-    type: getFileType(filename),
-    content: content,
-    size: stats.size,
-    lastModified: stats.mtime.toISOString(),
-    hasSecrets: containsSecrets(content, filename),
-    isEditable: true,
-  };
-
-  return {
-    success: true,
-    file: updatedFile,
-    message: 'File saved successfully',
-  };
-}
-
-export const updatePackageConfigurationService = async (packagePath: string, packageName: string, config: string) => {
-  let newConfig;
-  try {
-    newConfig = JSON.parse(config);
-  } catch (error) {
-    AppLogger.error('JSON parsing error', error as Error);
-    throw new Error('Invalid JSON format: ' + (error instanceof Error ? error.message : 'Unknown error'));
-  }
-
-  const packageJsonPath = path.join(packagePath, 'package.json');
-
-  // Security check: ensure the path is valid
-  if (!fs.existsSync(packagePath)) {
-    throw new Error('Package directory not found: ' + packagePath);
-  }
-
-  // Check if package.json exists
-  if (!fs.existsSync(packageJsonPath)) {
-    throw new Error('package.json not found in directory: ' + packageJsonPath);
-  }
-
-  // Read the existing package.json to preserve all fields
-  const existingContent = await fs.promises.readFile(packageJsonPath, 'utf8');
-  let existingConfig;
-  try {
-    existingConfig = JSON.parse(existingContent);
-  } catch (error) {
-    throw new Error('Failed to parse existing package.json: ' + (error instanceof Error ? error.message : 'Invalid JSON'));
-  }
-
-  // Merge the new configuration with existing configuration
-  const mergedConfig = {
-    ...existingConfig,
-    name: newConfig.name || existingConfig.name,
-    version: newConfig.version || existingConfig.version,
-    description:
-      newConfig.description !== undefined
-        ? newConfig.description
-        : existingConfig.description,
-    license:
-      newConfig.license !== undefined
-        ? newConfig.license
-        : existingConfig.license,
-    repository: newConfig.repository || existingConfig.repository,
-    scripts: newConfig.scripts || existingConfig.scripts,
-    dependencies: newConfig.dependencies || existingConfig.dependencies,
-    devDependencies:
-      newConfig.devDependencies || existingConfig.devDependencies,
-    peerDependencies:
-      newConfig.peerDependencies || existingConfig.peerDependencies,
-  };
-
-  // Write the merged configuration back
-  const formattedConfig = JSON.stringify(mergedConfig, null, 2);
-  await fs.promises.writeFile(packageJsonPath, formattedConfig, 'utf8');
-
-  // Update the package in the database - use correct field names based on your Prisma schema
-  const updateData: Record<string, unknown> = {
-    lastUpdated: new Date(),
-  };
-
-  // Only update fields that exist in your Prisma schema
-  if (newConfig.version) updateData.version = newConfig.version;
-  if (newConfig.description !== undefined)
-    updateData.description = newConfig.description || '';
-  if (newConfig.license !== undefined)
-    updateData.license = newConfig.license || '';
-  if (newConfig.scripts)
-    updateData.scripts = JSON.stringify(newConfig.scripts);
-  if (newConfig.repository)
-    updateData.repository = JSON.stringify(newConfig.repository);
-  if (newConfig.dependencies)
-    updateData.dependencies = JSON.stringify(newConfig.dependencies);
-  if (newConfig.devDependencies)
-    updateData.devDependencies = JSON.stringify(newConfig.devDependencies);
-  if (newConfig.peerDependencies)
-    updateData.peerDependencies = JSON.stringify(newConfig.peerDependencies);
-
-  AppLogger.debug('Updating database with:', updateData);
-
-  const updatedPackage = await PackageRepository.updateConfig(packageName, updateData);
-
-  // Transform the response
-  const transformedPackage = {
-    ...updatedPackage,
-    maintainers: updatedPackage.maintainers
-      ? JSON.parse(updatedPackage.maintainers)
-      : [],
-    scripts: updatedPackage.scripts ? JSON.parse(updatedPackage.scripts) : {},
-    repository: updatedPackage.repository
-      ? JSON.parse(updatedPackage.repository)
-      : {},
-    dependencies: updatedPackage.dependencies
-      ? JSON.parse(updatedPackage.dependencies)
-      : {},
-    devDependencies: updatedPackage.devDependencies
-      ? JSON.parse(updatedPackage.devDependencies)
-      : {},
-    peerDependencies: updatedPackage.peerDependencies
-      ? JSON.parse(updatedPackage.peerDependencies)
-      : {},
-  };
-  return transformedPackage;
-}

package/src/services/git-service.ts

@@ -1,140 +0,0 @@
-/**
- * GitService.ts
- *
- * This service executes native 'git' commands using Node.js's child_process
- * to retrieve the commit history of the local repository.
- */
-
-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';
-
-// Promisify the standard 'exec' function for easy async/await usage
-const execPromise = promisify(exec);
-
-export class GitService {
-  private repoPath: string;
-
-  constructor(repoPath: string = process.cwd()) {
-    this.repoPath = repoPath;
-  }
-
-  /**
-   * Retrieves commit history for the repository, optionally filtered by a package path.
-   */
-  public async getAllCommits(pathFilter?: string): Promise<Commit[]> {
-    try {
-
-      let pathArgument = '';
-      if (pathFilter) {
-        // Normalize the path and ensure it's relative to the repo root
-        const normalizedPath = this.normalizePath(pathFilter);
-        if (normalizedPath) {
-          pathArgument = ` -C ${normalizedPath}`;
-        }
-      }
-
-      // First, validate we're in a git repo
-      await this.validateGitRepository(pathArgument);
-
-      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}`;
-      AppLogger.debug(`Git command: ${command}`);
-
-      const { stdout, stderr } = await execPromise(command, {
-        cwd: this.repoPath,
-        maxBuffer: 1024 * 5000,
-      });
-
-      if (stderr) {
-        AppLogger.warn('Git stderr: ' + stderr);
-      }
-
-      if (!stdout.trim()) {
-        AppLogger.debug('No commits found for path: ' + pathFilter);
-        return [];
-      }
-
-      // Parse the output
-      const commits: Commit[] = [];
-      const lines = stdout.trim().split('\n');
-
-      for (const line of lines) {
-        try {
-          const [hash, author, date, message] = line.split('|');
-
-          const commit: Commit = {
-            hash: hash.trim(),
-            author: author.trim(),
-            packageName: pathFilter || 'root',
-            date: new Date(date.trim()),
-            message: message.trim(),
-            type: this.extractCommitType(message.trim()),
-          };
-
-          commits.push(commit);
-        } catch (parseError) {
-          AppLogger.error('Failed to parse commit line: ' + line, parseError as Error);
-        }
-      }
-
-      AppLogger.debug(`Successfully parsed ${commits.length} commits`);
-      return commits;
-    } catch (error) {
-      AppLogger.error('Error in getAllCommits', error as Error);
-      throw error;
-    }
-  }
-
-  /**
-   * Normalize path to be relative to git repo root
-   */
-  private normalizePath(inputPath: string): string {
-    // If it's an absolute path, make it relative to repo root
-    if (path.isAbsolute(inputPath)) {
-      return path.relative(this.repoPath, inputPath);
-    }
-
-    // If it's already relative, return as-is
-    return inputPath;
-  }
-
-  /**
-   * Extract commit type from message
-   */
-  private extractCommitType(message: string): string {
-    try {
-      const typeMatch = message.match(/^(\w+)(\([^)]+\))?!?:/);
-      if (typeMatch) {
-        const rawType = typeMatch[1].toLowerCase();
-        if (VALID_COMMIT_TYPES.includes(rawType)) {
-          return rawType;
-        }
-      }
-      return 'other';
-    } catch (error) {
-      return 'other';
-    }
-  }
-
-  /**
-   * Validate that we're in a git repository
-   */
-  private async validateGitRepository(pathArgument: string): Promise<void> {
-    try {
-      await execPromise('git '+pathArgument+' rev-parse --is-inside-work-tree', {
-        cwd: this.repoPath,
-      });
-      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

@@ -1,162 +0,0 @@
-import {
-  scanMonorepo,
-  calculatePackageHealth,
-} from '../utils/utilities';
-
-import {
-  funCheckBuildStatus,
-  funCheckLintStatus,
-  funCheckSecurityAudit,
-} from '../utils/monorepo-scanner';
-
-import { AppLogger } from '../middleware/logger';
-import { PackageHealthRepository, PackageRepository } from '../repositories';
-import type { TransformedPackageHealth, HealthResponse, PackageHealthModel } from '../types/database';
-
-// Track in-flight health refresh requests to prevent duplicates
-let inFlightHealthRefresh: Promise<HealthResponse> | null = null;
-
-export const getHealthSummaryService = async (): Promise<HealthResponse> => {
-  const packageHealthData = await PackageHealthRepository.findAll() as PackageHealthModel[];
-  AppLogger.debug('packageHealthData count: ' + packageHealthData.length);
-
-  // Transform the data to match the expected frontend format
-  const packages = packageHealthData.map((pkg: PackageHealthModel) => {
-    const health = {
-      buildStatus: pkg.packageBuildStatus,
-      testCoverage: pkg.packageTestCoverage,
-      lintStatus: pkg.packageLintStatus,
-      securityAudit: pkg.packageSecurity,
-      overallScore: pkg.packageOverallScore,
-    };
-
-    return {
-      packageName: pkg.packageName,
-      health: health,
-      isHealthy: pkg.packageOverallScore >= 80,
-    };
-  });
-
-  // Calculate summary statistics
-  const total = packages.length;
-  const healthy = packages.filter((pkg: TransformedPackageHealth) => pkg.isHealthy).length;
-  const unhealthy = packages.filter((pkg: TransformedPackageHealth) => !pkg.isHealthy).length;
-  const averageScore =
-    packages.length > 0
-      ? packages.reduce((sum: number, pkg: TransformedPackageHealth) => sum + pkg.health.overallScore, 0) /
-      packages.length
-      : 0;
-
-  return {
-    packages: packages,
-    summary: {
-      total: total,
-      healthy: healthy,
-      unhealthy: unhealthy,
-      averageScore: averageScore,
-    },
-  };
-}
-
-export const healthRefreshService = async (rootDir: string) => {
-  // If a health refresh is already in progress, return the in-flight promise
-  if (inFlightHealthRefresh) {
-    AppLogger.info('Health refresh already in progress, returning cached promise');
-    return inFlightHealthRefresh;
-  }
-
-  // Create and store the health refresh promise
-  inFlightHealthRefresh = (async () => {
-    try {
-      const packages = scanMonorepo(rootDir);
-      AppLogger.debug('packages count: ' + packages.length);
-      const healthMetrics = await Promise.all(
-        packages.map(async pkg => {
-          try {
-            // Await each health check function since they return promises
-            const buildStatus = await funCheckBuildStatus(pkg);
-            const testCoverage = 0; //await funCheckTestCoverage(pkg); // skip test coverage for now
-            const lintStatus = await funCheckLintStatus(pkg);
-            const securityAudit = await funCheckSecurityAudit(pkg);
-            // Calculate overall health score
-            const overallScore = calculatePackageHealth(
-              buildStatus,
-              testCoverage,
-              lintStatus,
-              securityAudit
-            );
-
-            const health = {
-              buildStatus: buildStatus,
-              testCoverage: testCoverage,
-              lintStatus: lintStatus,
-              securityAudit: securityAudit,
-              overallScore: overallScore.overallScore,
-            };
-            const packageStatus =
-              health.overallScore >= 80
-                ? 'healthy'
-                : health.overallScore >= 60 && health.overallScore < 80
-                  ? 'warning'
-                  : 'error';
-
-            AppLogger.debug(`${pkg.name}: ${packageStatus}`, health);
-
-            await PackageHealthRepository.upsert({
-              packageName: pkg.name,
-              packageOverallScore: overallScore.overallScore,
-              packageBuildStatus: buildStatus,
-              packageTestCoverage: testCoverage,
-              packageLintStatus: lintStatus,
-              packageSecurity: securityAudit,
-              packageDependencies: '',
-            });
-            // update related package status as well
-            await PackageRepository.updateStatus(pkg.name, packageStatus);
-            return {
-              packageName: pkg.name,
-              health,
-              isHealthy: health.overallScore >= 80,
-            };
-          } catch (error) {
-            return {
-              packageName: pkg.name,
-              health: {
-                "buildStatus": "",
-                "testCoverage": 0,
-                "lintStatus": "",
-                "securityAudit": "",
-                "overallScore": 0
-              },
-              isHealthy: false,
-              error: 'Failed to fetch health metrics1',
-            };
-          }
-        })
-      );
-
-      const result: HealthResponse = {
-        packages: healthMetrics.filter(h => !h.error),
-        summary: {
-          total: packages.length,
-          healthy: healthMetrics.filter(h => h.isHealthy).length,
-          unhealthy: healthMetrics.filter(h => !h.isHealthy).length,
-          averageScore:
-            healthMetrics.filter(h => h.health).length > 0
-              ? healthMetrics
-                  .filter(h => h.health)
-                  .reduce((sum, h) => sum + h.health!.overallScore, 0) /
-                healthMetrics.filter(h => h.health).length
-              : 0,
-        },
-      };
-
-      return result;
-    } finally {
-      // Clear the in-flight promise after completion
-      inFlightHealthRefresh = null;
-    }
-  })();
-
-  return inFlightHealthRefresh;
-}