@manojkmfsi/monodog 1.0.20 → 1.0.21

package/src/services/gitService.ts

@@ -0,0 +1,165 @@
+/**
+ * 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';
+
+// Promisify the standard 'exec' function for easy async/await usage
+const execPromise = promisify(exec);
+
+/**
+ * Interface representing a single commit object with key metadata.
+ */
+interface GitCommit {
+  hash: string;
+  author: string;
+  packageName: string;
+  date: Date;
+  message: string;
+  type: string;
+}
+/**
+ * List of standard Conventional Commit types for validation.
+ * Any extracted type not in this list will be set to 'other'.
+ */
+const VALID_COMMIT_TYPES: string[] = [
+  'feat', // New feature
+  'fix', // Bug fix
+  'docs', // Documentation changes
+  'style', // Code style changes (formatting, etc)
+  'refactor', // Code refactoring
+  'perf', // Performance improvements
+  'test', // Adding or updating tests
+  'chore', // Maintenance tasks (e.g., build scripts, dependency updates)
+  'ci', // CI/CD changes
+  'build', // Build system changes (e.g., pnpm/npm scripts)
+  'revert', // Reverting changes
+];
+
+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<GitCommit[]> {
+    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);
+
+      console.log(`🔧 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}`);
+
+      const { stdout, stderr } = await execPromise(command, {
+        cwd: this.repoPath,
+        maxBuffer: 1024 * 5000,
+      });
+
+      if (stderr) {
+        console.warn('Git stderr:', stderr);
+      }
+
+      if (!stdout.trim()) {
+        console.log('📭 No commits found for path:', pathFilter);
+        return [];
+      }
+
+      // Parse the output
+      const commits: GitCommit[] = [];
+      const lines = stdout.trim().split('\n');
+
+      for (const line of lines) {
+        try {
+          const [hash, author, date, message] = line.split('|');
+
+          const commit: GitCommit = {
+            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) {
+          console.error('❌ Failed to parse commit line:', line, parseError);
+        }
+      }
+
+      console.log(`✅ Successfully parsed ${commits.length} commits`);
+      return commits;
+    } catch (error) {
+      console.error('💥 Error in getAllCommits:', 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,
+      });
+      console.log('✅ Valid git repository');
+    } catch (error) {
+      throw new Error(
+        'Not a git repository (or any of the parent directories)'
+      );
+    }
+  }
+}

package/src/utils/utilities.ts

@@ -3,6 +3,7 @@ import * as fs from 'fs';
 import path from 'path';
 import { appConfig } from '../config-loader';
 import {calculatePackageHealth} from './health-utils';
+import * as yaml from 'js-yaml';
 
 export {PackageHealth} from './health-utils';
 
@@ -73,30 +74,72 @@ export function resolveWorkspaceGlobs(rootDir: string, globs: string[]): string[
 }
 
 /**
- * Reads the root package.json and extracts the 'workspaces' field (array of globs).
+ * Parses pnpm-workspace.yaml and extracts workspace globs
  */
-export function getWorkspacesFromRoot(rootDir: string): string[] | undefined {
-    const packageJsonPath = path.join(rootDir, 'package.json');
-    if (!fs.existsSync(packageJsonPath)) {
-        console.warn(`\n⚠️ Warning: No package.json found at root directory: ${rootDir}`);
+function getWorkspacesFromPnpmYaml(rootDir: string): string[] | undefined {
+    const workspaceYamlPath = path.join(rootDir, 'pnpm-workspace.yaml');
+    if (!fs.existsSync(workspaceYamlPath)) {
         return undefined;
     }
 
     try {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const yamlContent = fs.readFileSync(workspaceYamlPath, 'utf-8');
+        const yamlData = yaml.load(yamlContent) as { packages?: (string | string[]) };
 
-        // Handle both standard array and object format (used by yarn/pnpm)
-        if (Array.isArray(packageJson.workspaces)) {
-            return packageJson.workspaces;
-        } else if (packageJson.workspaces && Array.isArray(packageJson.workspaces.packages)) {
-            return packageJson.workspaces.packages;
+        if (yamlData && yamlData.packages) {
+            // Filter out exclusion patterns (lines starting with '!')
+            const packages = Array.isArray(yamlData.packages)
+                ? yamlData.packages.filter((pkg) => typeof pkg === 'string' && !pkg.startsWith('!'))
+                : [];
+
+            if (packages.length > 0) {
+                return packages;
+            }
         }
     } catch (e) {
-        console.error(`\n❌ Error parsing package.json at ${packageJsonPath}. Skipping workspace detection.`);
+        console.error(`\n❌ Error parsing pnpm-workspace.yaml at ${workspaceYamlPath}:`, e);
     }
     return undefined;
 }
 
+/**
+ * Reads workspace configuration from package.json or pnpm-workspace.yaml
+ * Priority: package.json (if exists) -> pnpm-workspace.yaml
+ */
+export function getWorkspacesFromRoot(rootDir: string): string[] | undefined {
+    const packageJsonPath = path.join(rootDir, 'package.json');
+
+    // Try package.json first
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+            // Handle both standard array and object format (used by yarn/pnpm)
+            if (Array.isArray(packageJson.workspaces)) {
+                console.log('✅ 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');
+                return packageJson.workspaces.packages;
+            }
+        } catch (e) {
+            console.error(`\n❌ Error parsing package.json at ${packageJsonPath}. Attempting to read pnpm-workspace.yaml...`);
+        }
+    } else {
+        console.warn(`\n⚠️ Warning: 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');
+        return pnpmWorkspaces;
+    }
+
+    console.warn('\n⚠️ No workspace configuration found in package.json or pnpm-workspace.yaml');
+    return undefined;
+}
+
 /**
  * Scans the monorepo and returns information about all packages
  */
@@ -104,7 +147,7 @@ function scanMonorepo(rootDir: string): PackageInfo[] {
   const packages: PackageInfo[] = [];
   console.log('rootDir:', rootDir);
   const workspacesGlobs = appConfig.workspaces;
-  // Use provided workspaces globs if given, otherwise attempt to detect from root package.json
+  // 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) {
@@ -356,6 +399,53 @@ function getPackageSize(packagePath: string): {
   }
 }
 
+/**
+ * Find the monorepo root by looking for package.json with workspaces or pnpm-workspace.yaml
+ */
+function findMonorepoRoot(): string {
+  let currentDir = __dirname;
+
+  while (currentDir !== path.parse(currentDir).root) {
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    const pnpmWorkspacePath = path.join(currentDir, 'pnpm-workspace.yaml');
+
+    // Check if this directory has package.json with workspaces or pnpm-workspace.yaml
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(
+          fs.readFileSync(packageJsonPath, 'utf8')
+        );
+        // If it has workspaces or is the root monorepo package
+        if (packageJson.workspaces || fs.existsSync(pnpmWorkspacePath)) {
+          console.log('✅ Found monorepo root:', currentDir);
+          return currentDir;
+        }
+      } catch (error) {
+        // Continue searching if package.json is invalid
+      }
+    }
+
+    // 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);
+      return currentDir;
+    }
+
+    // Go up one directory
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break; // Prevent infinite loop
+    currentDir = parentDir;
+  }
+
+  // Fallback to process.cwd() if we can't find the root
+  console.log(
+    '⚠️ Could not find monorepo root, using process.cwd():',
+    process.cwd()
+  );
+  return process.cwd();
+}
+
 export {
   scanMonorepo,
   generateMonorepoStats,
@@ -363,5 +453,6 @@ export {
   generateDependencyGraph,
   checkOutdatedDependencies,
   getPackageSize,
-  calculatePackageHealth
+  calculatePackageHealth,
+  findMonorepoRoot,
 };

package/src/gitService.ts

@@ -1,276 +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';
-
-// Promisify the standard 'exec' function for easy async/await usage
-const execPromise = promisify(exec);
-
-/**
- * Interface representing a single commit object with key metadata.
- */
-interface GitCommit {
-  hash: string;
-  author: string;
-  packageName: string;
-  date: Date;
-  message: string;
-  type: string;
-}
-/**
- * List of standard Conventional Commit types for validation.
- * Any extracted type not in this list will be set to 'other'.
- */
-const VALID_COMMIT_TYPES: string[] = [
-  'feat', // New feature
-  'fix', // Bug fix
-  'docs', // Documentation changes
-  'style', // Code style changes (formatting, etc)
-  'refactor', // Code refactoring
-  'perf', // Performance improvements
-  'test', // Adding or updating tests
-  'chore', // Maintenance tasks (e.g., build scripts, dependency updates)
-  'ci', // CI/CD changes
-  'build', // Build system changes (e.g., pnpm/npm scripts)
-  'revert', // Reverting changes
-];
-
-/**
- * The delimiter used to separate individual commit records in the git log output.
- * We use a unique string to ensure reliable splitting.
- */
-// const COMMIT_DELIMITER = '|---COMMIT-END---|';
-
-/**
- * The custom format string passed to 'git log'.
- * It uses JSON structure and our unique delimiter to make parsing consistent.
- * * %H: Commit hash
- * %pn: packageName name
- * %ae: Author email
- * %ad: Author date (ISO 8601 format)
- * %s: Subject (commit message's first line - used for 'message' and 'type' fields)
- */
-// const GIT_LOG_FORMAT = `{"hash": "%H", "author": "%ae", "packageName": "%pn", "date": "%ad", "message": "%s", "type": "%s"}${COMMIT_DELIMITER}`;
-
-// export class GitService {
-//   private repoPath: string;
-
-//   constructor(repoPath: string = process.cwd()) {
-//     // Allows specifying a custom path to the monorepo root
-//     this.repoPath = repoPath;
-//   }
-
-//   /**
-//    * Retrieves commit history for the repository, optionally filtered by a package path.
-//    * @param pathFilter The path to a package directory (e.g., 'packages/server').
-//    * If provided, only commits affecting that path are returned.
-//    * @returns A Promise resolving to an array of GitCommit objects.
-//    */
-//   public async getAllCommits(pathFilter?: string): Promise<GitCommit[]> {
-//     const pathArgument = pathFilter ? ` -- ${pathFilter}` : '';
-
-//     const command = `git log --pretty=format:'${GIT_LOG_FORMAT}' --date=iso-strict${pathArgument}`;
-
-//     try {
-//       console.log(`Executing Git command: ${command}`);
-//       const { stdout } = await execPromise(command, {
-//         cwd: this.repoPath,
-//         maxBuffer: 1024 * 5000,
-//       }); // Increase buffer for large repos
-//       // console.log(stdout)
-//       console.log(stdout, '--', this.repoPath);
-//       const escapedDelimiter = COMMIT_DELIMITER.replace(
-//         /[.*+?^${}()|[\]\\]/g,
-//         '\\$&'
-//       );
-
-//       // 1. Remove the final trailing delimiter, as it creates an empty string at the end of the array
-//       const cleanedOutput = stdout
-//         .trim()
-//         .replace(new RegExp(`${escapedDelimiter}$`), '');
-//       console.log(cleanedOutput);
-
-//       if (!cleanedOutput) {
-//         return [];
-//       }
-//       // 2. Split the output by our custom delimiter to get an array of JSON strings
-//       const jsonStrings = cleanedOutput.split(COMMIT_DELIMITER);
-//       // 3. Parse each string into a GitCommit object
-//       const commits: GitCommit[] = jsonStrings
-//         .map(jsonString => {
-//           try {
-//             // JSON.parse is necessary because the output starts as a string
-//             const commit = JSON.parse(jsonString);
-//             console.log(commit.type, commit['hash']);
-//             try {
-//               // FIX: Updated Regex to handle optional scope (e.g., 'feat(scope):')
-//               // Matches:
-//               // 1. (^(\w+)) - The commit type (e.g., 'feat')
-//               // 2. (\([^)]+\))? - The optional scope (e.g., '(setup)')
-//               // 3. (:|!) - Ends with a colon or an exclamation point (for breaking changes)
-//               const typeMatch = commit.type.match(/^(\w+)(\([^)]+\))?([:!])/);
-//               let extractedType = 'other';
-//               if (typeMatch) {
-//                 const rawType = typeMatch[1];
-//                 // NEW: Validate the extracted type against the list of known types
-//                 if (VALID_COMMIT_TYPES.includes(rawType)) {
-//                   extractedType = rawType;
-//                 }
-//               }
-//               commit.type = extractedType;
-//             } catch (e) {
-//               console.error('Failed to match commit type:', commit, e);
-//               // Skip malformed entries
-//               return null;
-//             }
-//             // // Set type to 'other' if the conventional format is not found
-//             // commit.type = typeMatch ? typeMatch[1] : 'other';
-//             return commit;
-//           } catch (e) {
-//             // console.log(jsonString)
-//             console.error('Failed to parse commit JSON:', jsonString, e);
-//             // Skip malformed entries
-//             return null;
-//           }
-//         })
-//         .filter((commit): commit is GitCommit => commit !== null);
-
-//       return commits;
-//     } catch (error) {
-//       console.error('Error fetching Git history:', error);
-//       // In a real application, you would handle this gracefully (e.g., throwing a custom error)
-//       throw new Error(
-//         'Failed to retrieve Git commit history. Is Git installed and is the path correct?'
-//       );
-//     }
-//   }
-// }
-
-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<GitCommit[]> {
-    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);
-
-      console.log(`🔧 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}`);
-
-      const { stdout, stderr } = await execPromise(command, {
-        cwd: this.repoPath,
-        maxBuffer: 1024 * 5000,
-      });
-
-      if (stderr) {
-        console.warn('Git stderr:', stderr);
-      }
-
-      if (!stdout.trim()) {
-        console.log('📭 No commits found for path:', pathFilter);
-        return [];
-      }
-
-      // Parse the output
-      const commits: GitCommit[] = [];
-      const lines = stdout.trim().split('\n');
-
-      for (const line of lines) {
-        try {
-          const [hash, author, date, message] = line.split('|');
-
-          const commit: GitCommit = {
-            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) {
-          console.error('❌ Failed to parse commit line:', line, parseError);
-        }
-      }
-
-      console.log(`✅ Successfully parsed ${commits.length} commits`);
-      return commits;
-    } catch (error) {
-      console.error('💥 Error in getAllCommits:', 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,
-      });
-      console.log('✅ Valid git repository');
-    } catch (error) {
-      throw new Error(
-        'Not a git repository (or any of the parent directories)'
-      );
-    }
-  }
-}