@monodog/backend 1.2.6 → 1.2.8

package/dist/cli.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+"use strict";
+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 });
+/**
+ * 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)
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_1 = require("./index"); // Assume index.ts exports this function
+const config_loader_1 = require("./config-loader");
+const appConfig = (0, config_loader_1.loadConfig)();
+// --- Argument Parsing ---
+// 1. Get arguments excluding the node executable and script name
+const args = process.argv.slice(2);
+// Default settings
+const DEFAULT_PORT = 4000;
+let rootPath = path.resolve(appConfig.workspace.root_dir ?? process.cwd()); // Default to the current working directory
+let port = appConfig.server.port ?? DEFAULT_PORT; //Default port
+const host = appConfig.server.host ?? 'localhost'; //Default host
+let serve = false;
+// 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 === '--port') {
+        // Look at the next argument for the port number
+        if (i + 1 < args.length) {
+            const portValue = parseInt(args[i + 1], 10);
+            if (isNaN(portValue) || portValue <= 0 || portValue > 65535) {
+                console.error('Error: --port requires a valid port number (1-65535).');
+                process.exit(1);
+            }
+            port = portValue;
+            i++; // Skip the next argument
+        }
+        else {
+            console.error('Error: --port requires a number 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).
+  --port <number>    Specify the port for the API server (default: 4000).
+  -h, --help         Show this help message.
+
+Example:
+  monodog-cli --serve --root /path/to/my/monorepo
+        `);
+        process.exit(0);
+    }
+}
+// --- Execution Logic ---
+if (serve) {
+    console.log(`\nInitializing Configurations...`);
+    createConfigFileIfMissing(rootPath ?? process.cwd());
+    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, port, host);
+    copyPackageToWorkspace(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. Ex: pnpm monodog-cli @monodog/dashboard --serve --root .`);
+}
+/**
+ * Copies an installed NPM package from node_modules into the local packages/ workspace directory.
+ */
+function copyPackageToWorkspace(rootDir) {
+    // 1. Get package name from arguments
+    // The package name is expected as the first command-line argument (process.argv[2])
+    const packageName = process.argv[2];
+    if (!packageName || packageName.startsWith('--')) {
+        console.error("Error: Please provide the package name as an argument if you want to setup dashboard.");
+        console.log("Usage: pnpm monodog-cli @monodog/dashboard --serve --root .");
+    }
+    if (packageName !== '@monodog/backend') {
+        console.log("\n--- Skipping workspace setup for @monodog/backend to avoid self-copying. ---");
+        return;
+    }
+    // const rootDir = process.cwd();
+    const sourcePath = path.join(rootDir, 'node_modules', packageName);
+    // Convert package name to a valid folder name (e.g., @scope/name -> scope-name)
+    // This is optional but makes file paths cleaner.
+    const folderName = packageName.replace('@', '').replace('/', '-');
+    const destinationPath = path.join(rootDir, 'packages', folderName);
+    console.log(`\n--- Monorepo Workspace Conversion ---`);
+    console.log(`Target Package: ${packageName}`);
+    console.log(`New Workspace:  packages/${folderName}`);
+    console.log(`-----------------------------------`);
+    // 2. Validate Source existence
+    if (!fs.existsSync(sourcePath)) {
+        console.error(`\n❌ Error: Source package not found at ${sourcePath}.`);
+        console.error("Please ensure the package is installed via 'pnpm install <package-name>' first.");
+        process.exit(1);
+    }
+    // 3. Validate Destination existence (prevent accidental overwrite)
+    if (fs.existsSync(destinationPath)) {
+        console.error(`\n❌ Error: Destination directory already exists at ${destinationPath}.`);
+        console.error("Please manually remove it or rename it before running the script.");
+        process.exit(1);
+    }
+    // Ensure the 'packages' directory exists
+    const packagesDir = path.join(rootDir, 'packages');
+    if (!fs.existsSync(packagesDir)) {
+        fs.mkdirSync(packagesDir, { recursive: true });
+        console.log(`Created packages directory: ${packagesDir}`);
+    }
+    // 4. Perform the copy operation
+    try {
+        console.log(`\nCopying files from ${sourcePath} to ${destinationPath}...`);
+        // fs.cpSync provides cross-platform recursive copying (Node 16.7+)
+        fs.cpSync(sourcePath, destinationPath, {
+            recursive: true,
+            dereference: true,
+            // Filter out node_modules inside the package itself to avoid deep recursion
+            // filter: (src: string): boolean => !src.includes('node_modules'),
+        });
+        console.log(`\n✅ Success! Contents of '${packageName}' copied to '${destinationPath}'`);
+        // Post-copy instructions
+        console.log("\n*** IMPORTANT NEXT STEPS (MANDATORY) ***");
+        console.log("1.Migrate Database:");
+        console.log(`   - pnpm prisma migrate --schema ./node_modules/@monodog/backend/prisma/schema.prisma`);
+        console.log("2. Generate Client:");
+        console.log(`   - pnpm exec prisma generate --schema ./node_modules/@monodog/backend/prisma/schema.prisma`);
+        console.log("3. Run Backend app server with dashboard setup");
+        console.log(`   - pnpm monodog-cli @monodog/dashboard --serve --root .`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Failed to copy files: ${message}`);
+        process.exit(1);
+    }
+}
+function createConfigFileIfMissing(rootPath) {
+    // --- CONFIGURATION ---
+    const configFileName = 'monodog-conf.json';
+    const configFilePath = path.resolve(rootPath, configFileName);
+    // The default content for the configuration file
+    const defaultContent = {
+        "workspace": {
+            "root_dir": "./packages/backend"
+        },
+        "database": {
+            "path": "./monodog.db"
+        },
+        "server": {
+            "host": "0.0.0.0",
+            "port": 4000
+        }
+    };
+    const contentString = JSON.stringify(defaultContent, null, 2);
+    // ---------------------
+    console.log(`\n[monodog] Checking for ${configFileName}...`);
+    if (fs.existsSync(configFilePath)) {
+        console.log(`[monodog] ${configFileName} already exists. Skipping creation.`);
+    }
+    else {
+        try {
+            // Write the default content to the file
+            fs.writeFileSync(configFilePath, contentString, 'utf-8');
+            console.log(`[monodog] Successfully generated default ${configFileName} in the workspace root.`);
+            console.log('[monodog] Please review and update settings like "host" and "port".');
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`[monodog Error] Failed to generate ${configFileName}:`, message);
+            process.exit(1);
+        }
+    }
+}

package/dist/config-loader.js

@@ -0,0 +1,97 @@
+"use strict";
+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 });
+exports.loadConfig = loadConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Global variable to hold the loaded config
+let config = null;
+/**
+ * Loads the monodog-conf.json file from the monorepo root.
+ * This should be called only once during application startup.
+ * @returns The application configuration object.
+ */
+function loadConfig() {
+    if (config) {
+        return config; // Return cached config if already loaded
+    }
+    // 1. Determine the path to the config file
+    // We assume the backend package is running from the monorepo root (cwd is root)
+    // or that we can navigate up to the root from the current file's location.
+    const rootPath = path.resolve('../../'); // Adjust based on your workspace folder depth  from root if needed
+    const configPath = path.resolve(rootPath, 'monodog-conf.json');
+    if (!fs.existsSync(configPath)) {
+        console.error(`ERROR: Configuration file not found at ${configPath}`);
+        // A missing config is a critical failure, so we exit
+        process.exit(1);
+    }
+    try {
+        // 2. Read and parse the JSON file
+        const fileContent = fs.readFileSync(configPath, 'utf-8');
+        const parsedConfig = JSON.parse(fileContent);
+        // 3. Optional: Add validation logic here (e.g., check if ports are numbers)
+        // Cache and return
+        config = parsedConfig;
+        process.stderr.write(`[Config] Loaded configuration from: ${configPath}`);
+        return config;
+    }
+    catch (error) {
+        console.error("ERROR: Failed to read or parse monodog-conf.json.");
+        console.error(error);
+        process.exit(1);
+    }
+}
+// --- Example Usage ---
+// In your main application file (e.g., packages/backend/src/index.ts):
+/*
+
+import { loadConfig } from './config-loader';
+
+// Load configuration on startup
+const appConfig = loadConfig();
+
+// Access the variables easily
+const dbHost = appConfig.database.host;
+const serverPort = appConfig.server.port;
+const workspaceRoot = appConfig.workspace.root_dir;
+
+console.log(`\nStarting server on port: ${serverPort}`);
+console.log(`Database connecting to host: ${dbHost}`);
+
+// Example server start logic
+// app.listen(serverPort, appConfig.server.host, () => {
+//   console.log(`Server running at http://${appConfig.server.host}:${serverPort}`);
+// });
+*/

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;