@manojkmfsi/monodog 1.0.1

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/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @manojkmfsi/monodog@1.0.1 build /home/runner/work/monodog/monodog/packages/monoapp
+> rm -rf dist && tsc -p tsconfig.json
+

package/CHANGELOG.md

@@ -0,0 +1,79 @@
+# @manojkmfsi/monoapp
+
+## 1.0.1
+
+### Patch Changes
+
+- updated pkg name
+
+## 3.1.1
+
+### Patch Changes
+
+- updated org
+
+## 3.1.0
+
+### Minor Changes
+
+- 76
+
+## 3.0.0
+
+### Major Changes
+
+- 75
+
+## 2.1.0
+
+### Minor Changes
+
+- 74
+
+## 2.0.2
+
+### Patch Changes
+
+- 73
+
+## 2.0.1
+
+### Patch Changes
+
+- 72
+
+## 2.0.0
+
+### Major Changes
+
+- 71
+
+## 1.1.0
+
+### Minor Changes
+
+- 67
+
+## 1.0.6
+
+### Patch Changes
+
+- 66
+
+## 1.0.5
+
+### Patch Changes
+
+- 40
+
+## 1.0.4
+
+### Patch Changes
+
+- 39
+
+## 1.0.3
+
+### Patch Changes
+
+- 35

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mindfire Digital LLP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# Monodog: Monorepo Analytics and Health API
+
+## 🎯 Overview
+
+The dashboard will provide visual management and monitoring capabilities for packages in monorepos using pnpm, turbo, or Nx. It will be distributed as an npm package installable in any monorepo to auto-generate a web UI for package oversight.
+
+This service is typically run locally or on a central server and power a dedicated frontend dashboard.
+
+---
+
+## 🛠 Technology Stack
+
+| Component     | Technology           | Description                                                                               |
+| ------------- | -------------------- | ----------------------------------------------------------------------------------------- |
+| **Language**  | TypeScript & Node.js | Core language for runtime execution.                                                      |
+| **Framework** | Express.js, React    | Express Handles all API routing and middleware and React for building the user interface. |
+| **Styling**   | Tailwind CSS         | Utility-first framework for responsive, modern, and aesthetic design.                     |
+| **ORM**       | Prisma               | Database layer for managing package and health status records.                            |
+| **Scanning**  | monorepo-scanner     | Core logic for file system scanning and package metadata extraction.                      |
+| **VCS**       | GitService           | Used to fetch and analyze commit history per package path.                                |
+
+---
+
+## ⚙️ Prerequisites
+
+You must have the following installed to run the service:
+
+- **Node.js:** Version 18+ recommended
+- **Package Manager:** `pnpm` or `npm` (use the one your monorepo uses)
+
+---
+
+## 🚀 Getting Started
+
+### Install Package in Monorepo
+
+Install monoapp in a monorepo workspace root:
+
+    pnpm install --save-dev @manojkmfsi/monoapp -w
+
+Run app using serve script:
+
+    npm --workspace @manojkmfsi/monoapp run serve
+
+### Key API Endpoints
+
+| Method  | Route                       | Purpose                                                                                 | Persistence         |
+| ------- | --------------------------- | --------------------------------------------------------------------------------------- | ------------------- |
+| **GET** | `/api/packages`             | Retrieve all package metadata from the database.                                        | Cached / Persistent |
+| **GET** | `/api/packages/refresh`     | Trigger a full file scan of the monorepo and update/sync the database.                  | Triggers write      |
+| **GET** | `/api/packages/:name`       | Get detailed info, reports, and CI status for a package.                                | Cached / Persistent |
+| **GET** | `/api/health/packages`      | Fetch the latest health metrics (score, build status) for all packages.                 | Persistent          |
+| **GET** | `/api/health/refresh`       | Recalculate all package health metrics (tests, lint, security) and update the database. | Triggers write      |
+| **GET** | `/api/commits/:packagePath` | Fetch Git commit history for a specific package directory.                              | Generated runtime   |
+| **GET** | `/api/config/files`         | Scan the monorepo for essential configuration files (e.g., `tsconfig`, `.eslintrc`).    | Generated runtime   |

package/dist/config-loader.js

@@ -0,0 +1,116 @@
+"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.appConfig = void 0;
+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(process.cwd()); // Adjust based on your workspace folder depth  from root if needed
+    const configPath = path.resolve(rootPath, 'monodog-conf.json');
+    createConfigFileIfMissing(rootPath);
+    if (!fs.existsSync(configPath)) {
+        console.error(`ERROR1: Configuration file not found at ${configPath}`);
+        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: ...\n');
+        return config;
+    }
+    catch (error) {
+        console.error('ERROR: Failed to read or parse monodog-conf.json.');
+        console.error(error);
+        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 = {
+        workspaces: [],
+        database: {
+            path: 'file:./monodog.db', // SQLite database file path, relative to prisma schema location
+        },
+        dashboard: {
+            host: '0.0.0.0',
+            port: '3010',
+        },
+        server: {
+            host: '0.0.0.0', // Default host for the API server
+            port: 8999, // Default port for the API server
+        },
+    };
+    const contentString = JSON.stringify(defaultContent, null, 2);
+    // ---------------------
+    process.stderr.write(`\n[monodog] Checking for ${configFileName}...`);
+    if (fs.existsSync(configFilePath)) {
+        process.stderr.write(`[monodog] ${configFileName} already exists at ${configFilePath}. Skipping creation.`);
+    }
+    else {
+        try {
+            // Write the default content to the file
+            fs.writeFileSync(configFilePath, contentString, 'utf-8');
+            process.stderr.write(`[monodog] Successfully generated default ${configFileName} in the workspace root.`);
+            process.stderr.write('[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);
+        }
+    }
+}
+const appConfig = loadConfig();
+exports.appConfig = appConfig;

package/dist/get-db-url.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_loader_1 = require("./config-loader");
+function generateUrl() {
+    // const appConfig = loadConfig();
+    const DATABASE_URL = `${config_loader_1.appConfig.database.path}`;
+    process.env.DATABASE_URL = DATABASE_URL;
+    process.stdout.write(DATABASE_URL);
+}
+generateUrl();

package/dist/gitService.js

@@ -0,0 +1,242 @@
+"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 {
+            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);
+            // Use a simpler git log format
+            const command = `git ${pathArgument} log --pretty=format:"%H|%an|%ad|%s" --date=iso-strict`;
+            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(pathArgument) {
+        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)');
+        }
+    }
+}
+exports.GitService = GitService;