@manojkmfsi/monodog 1.0.19 → 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/.turbo/turbo-lint.log

@@ -1,4 +0,0 @@
-
-> @manojkmfsi/monoapp@2.0.1 lint /home/manoj/Documents/mjdog/packages/monoapp
-> eslint .
-