@monodog/backend 1.0.0

package/.eslintrc.cjs

@@ -0,0 +1,15 @@
+module.exports = {
+  root: true,
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint'],
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+  ],
+  rules: {
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    "@typescript-eslint/no-unused-vars": "off",
+  },
+  ignorePatterns: ['dist', 'node_modules', '**/*.js'],
+};

package/dist/cli.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * CLI Entry Point for the Monorepo Analysis Engine.
+ * * This script is executed when a user runs the `monodog-cli` command
+ * in their project. It handles command-line arguments to determine
+ * whether to:
+ * 1. Start the API server for the dashboard.
+ * 2. Run a one-off analysis command. (Future functionality)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const index_1 = require("./index"); // Assume index.ts exports this function
+// --- Argument Parsing ---
+// 1. Get arguments excluding the node executable and script name
+const args = process.argv.slice(2);
+// Default settings
+let serve = false;
+let rootPath = process.cwd(); // Default to the current working directory
+// Simple argument parsing loop
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--serve') {
+        serve = true;
+    }
+    else if (arg === '--root') {
+        // Look at the next argument for the path
+        if (i + 1 < args.length) {
+            rootPath = path.resolve(args[i + 1]);
+            i++; // Skip the next argument since we've consumed it
+        }
+        else {
+            console.error('Error: --root requires a path argument.');
+            process.exit(1);
+        }
+    }
+    else if (arg === '-h' || arg === '--help') {
+        console.log(`
+Monodog CLI - Monorepo Analysis Engine
+
+Usage:
+  monodog-cli [options]
+
+Options:
+  --serve            Start the Monorepo Dashboard API server (default: off).
+  --root <path>      Specify the root directory of the monorepo to analyze (default: current working directory).
+  -h, --help         Show this help message.
+
+Example:
+  monodog-cli --serve --root /path/to/my/monorepo
+        `);
+        process.exit(0);
+    }
+}
+// --- Execution Logic ---
+if (serve) {
+    console.log(`Starting Monodog API server...`);
+    console.log(`Analyzing monorepo at root: ${rootPath}`);
+    // Start the Express server and begin analysis
+    (0, index_1.startServer)(rootPath);
+}
+else {
+    // Default mode: print usage or run a default report if no command is specified
+    console.log(`Monodog CLI: No operation specified. Use --serve to start the API or -h for help.`);
+}

package/dist/gitService.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * GitService.ts
+ *
+ * This service executes native 'git' commands using Node.js's child_process
+ * to retrieve the commit history of the local repository.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitService = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const path_1 = __importDefault(require("path"));
+// Promisify the standard 'exec' function for easy async/await usage
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * List of standard Conventional Commit types for validation.
+ * Any extracted type not in this list will be set to 'other'.
+ */
+const VALID_COMMIT_TYPES = [
+    '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?'
+//       );
+//     }
+//   }
+// }
+class GitService {
+    constructor(repoPath = process.cwd()) {
+        this.repoPath = repoPath;
+    }
+    /**
+     * Retrieves commit history for the repository, optionally filtered by a package path.
+     */
+    async getAllCommits(pathFilter) {
+        try {
+            // First, validate we're in a git repo
+            await this.validateGitRepository();
+            let pathArgument = '';
+            if (pathFilter) {
+                // Normalize the path and ensure it's relative to the repo root
+                const normalizedPath = this.normalizePath(pathFilter);
+                pathArgument = ` -- ${normalizedPath}`;
+            }
+            // Use a simpler git log format
+            const command = `git log --pretty=format:"%H|%an|%ad|%s" --date=iso-strict${pathArgument}`;
+            console.log(`🔧 Executing Git command in: ${this.repoPath}`);
+            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 = [];
+            const lines = stdout.trim().split('\n');
+            for (const line of lines) {
+                try {
+                    const [hash, author, date, message] = line.split('|');
+                    const 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) {
+                    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
+     */
+    normalizePath(inputPath) {
+        // If it's an absolute path, make it relative to repo root
+        if (path_1.default.isAbsolute(inputPath)) {
+            return path_1.default.relative(this.repoPath, inputPath);
+        }
+        // If it's already relative, return as-is
+        return inputPath;
+    }
+    /**
+     * Extract commit type from message
+     */
+    extractCommitType(message) {
+        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
+     */
+    async validateGitRepository() {
+        try {
+            await execPromise('git 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)');
+        }
+    }
+}
+exports.GitService = GitService;