@monodog/backend 1.0.0

package/prisma/migrations/20251027140546_init_packages/migration.sql

@@ -0,0 +1,16 @@
+-- CreateTable
+CREATE TABLE "package_health" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "packageName" TEXT NOT NULL,
+    "packageOverallScore" REAL NOT NULL,
+    "packageBuildStatus" TEXT NOT NULL,
+    "packageTestCoverage" REAL,
+    "packageLintStatus" TEXT NOT NULL,
+    "packageSecurity" TEXT NOT NULL,
+    "packageDependencies" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "package_health_packageName_key" ON "package_health"("packageName");

package/prisma/migrations/20251029073436_added_package_heath_key/migration.sql

@@ -0,0 +1,34 @@
+/*
+  Warnings:
+
+  - Added the required column `packageHealthId` to the `Package` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- RedefineTables
+PRAGMA defer_foreign_keys=ON;
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Package" (
+    "name" TEXT NOT NULL PRIMARY KEY,
+    "version" TEXT NOT NULL,
+    "type" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "lastUpdated" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "dependencies" TEXT,
+    "maintainers" TEXT NOT NULL,
+    "path" TEXT NOT NULL,
+    "description" TEXT NOT NULL,
+    "license" TEXT NOT NULL,
+    "repository" TEXT,
+    "scripts" TEXT,
+    "status" TEXT NOT NULL DEFAULT '',
+    "devDependencies" TEXT,
+    "peerDependencies" TEXT,
+    "packageHealthId" INTEGER NOT NULL,
+    CONSTRAINT "Package_packageHealthId_fkey" FOREIGN KEY ("packageHealthId") REFERENCES "package_health" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_Package" ("createdAt", "dependencies", "description", "devDependencies", "lastUpdated", "license", "maintainers", "name", "path", "peerDependencies", "repository", "scripts", "status", "type", "version") SELECT "createdAt", "dependencies", "description", "devDependencies", "lastUpdated", "license", "maintainers", "name", "path", "peerDependencies", "repository", "scripts", "status", "type", "version" FROM "Package";
+DROP TABLE "Package";
+ALTER TABLE "new_Package" RENAME TO "Package";
+CREATE UNIQUE INDEX "Package_name_key" ON "Package"("name");
+PRAGMA foreign_keys=ON;
+PRAGMA defer_foreign_keys=OFF;

package/prisma/migrations/20251029073830_added_package_health_key/migration.sql

@@ -0,0 +1,49 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `packageHealthId` on the `Package` table. All the data in the column will be lost.
+
+*/
+-- RedefineTables
+PRAGMA defer_foreign_keys=ON;
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Package" (
+    "name" TEXT NOT NULL PRIMARY KEY,
+    "version" TEXT NOT NULL,
+    "type" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "lastUpdated" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "dependencies" TEXT,
+    "maintainers" TEXT NOT NULL,
+    "path" TEXT NOT NULL,
+    "description" TEXT NOT NULL,
+    "license" TEXT NOT NULL,
+    "repository" TEXT,
+    "scripts" TEXT,
+    "status" TEXT NOT NULL DEFAULT '',
+    "devDependencies" TEXT,
+    "peerDependencies" TEXT
+);
+INSERT INTO "new_Package" ("createdAt", "dependencies", "description", "devDependencies", "lastUpdated", "license", "maintainers", "name", "path", "peerDependencies", "repository", "scripts", "status", "type", "version") SELECT "createdAt", "dependencies", "description", "devDependencies", "lastUpdated", "license", "maintainers", "name", "path", "peerDependencies", "repository", "scripts", "status", "type", "version" FROM "Package";
+DROP TABLE "Package";
+ALTER TABLE "new_Package" RENAME TO "Package";
+CREATE UNIQUE INDEX "Package_name_key" ON "Package"("name");
+CREATE TABLE "new_package_health" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "packageName" TEXT NOT NULL,
+    "packageOverallScore" REAL NOT NULL,
+    "packageBuildStatus" TEXT NOT NULL,
+    "packageTestCoverage" REAL,
+    "packageLintStatus" TEXT NOT NULL,
+    "packageSecurity" TEXT NOT NULL,
+    "packageDependencies" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "package_health_packageName_fkey" FOREIGN KEY ("packageName") REFERENCES "Package" ("name") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_package_health" ("createdAt", "id", "packageBuildStatus", "packageDependencies", "packageLintStatus", "packageName", "packageOverallScore", "packageSecurity", "packageTestCoverage", "updatedAt") SELECT "createdAt", "id", "packageBuildStatus", "packageDependencies", "packageLintStatus", "packageName", "packageOverallScore", "packageSecurity", "packageTestCoverage", "updatedAt" FROM "package_health";
+DROP TABLE "package_health";
+ALTER TABLE "new_package_health" RENAME TO "package_health";
+CREATE UNIQUE INDEX "package_health_packageName_key" ON "package_health"("packageName");
+PRAGMA foreign_keys=ON;
+PRAGMA defer_foreign_keys=OFF;

package/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (i.e. Git)
+provider = "sqlite"

package/prisma/schema.prisma

@@ -0,0 +1,130 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id    Int    @id @default(autoincrement())
+  name  String
+  email String @unique
+  posts Post[]
+}
+
+model Post {
+  id        Int     @id @default(autoincrement())
+  title     String
+  content   String?
+  published Boolean @default(false)
+  authorId  Int
+  author    User    @relation(fields: [authorId], references: [id])
+}
+
+// --- MONOREPO DATA MODEL ---
+
+/// Represents a single package within the monorepo, based on the pnpm/package.json data.
+model Package {
+  // Primary Key and Identity Field (using the package name as the unique ID)
+  // Example: '@monodog/dashboard'
+  name String @id @unique
+
+  // Core Package Metadata
+  version String
+  type    String // e.g., 'app', 'package'
+
+  // Timestamps
+  createdAt   DateTime @default(now())
+  lastUpdated DateTime @default(now())
+
+  // Key Metrics and Relationships
+  dependencies String? // The total number of direct dependencies
+  // Manual Serialization Required: Stores a JSON array string of maintainers, e.g., '["team-frontend"]'
+  maintainers  String
+  // Manual Serialization Required: Stores a JSON array string of tags, e.g., '["core", "ui"]'
+  path         String // The relative path in the file system, e.g., 'apps/dashboard'
+
+  // Descriptions and Configuration
+  description String
+  license     String
+  repository  String?
+
+  // Manual Serialization Required: Stores the scripts object as a JSON string
+  // Example: '{"dev": "vite", "build": "tsc && vite build"}'
+  scripts String?
+  status  String  @default("")
+
+  devDependencies  String?
+  peerDependencies String?
+  dependenciesInfo DependencyInfo[]
+  commits          Commit[]
+  packageHealth    PackageHealth?
+}
+
+model DependencyInfo {
+  name        String
+  packageName String
+  version     String
+  type        String  @default("")
+  status      String  @default("")
+  latest      String?
+  outdated    Boolean @default(false)
+  package     Package @relation(fields: [packageName], references: [name])
+
+  @@unique([name, packageName]) // Composite unique constraint
+}
+
+model Commit {
+  hash        String    @id
+  message     String
+  author      String
+  date        DateTime?
+  type        String
+  packageName String
+  package     Package   @relation(fields: [packageName], references: [name])
+}
+
+model HealthStatus {
+  id        Int     @id @default(autoincrement())
+
+  // Package reference (without formal relation)
+  packageName String @unique
+  // package     Package @relation(fields: [packageName], references: [name], onDelete: Cascade)
+
+  // Health Metrics
+  overallScore   Float   // Overall health score (0-100)
+  buildStatus    String  // e.g., "passing", "failing", "unknown"
+  testCoverage   Float   // Test coverage percentage (0-100)
+  lintStatus     String  // e.g., "passing", "warning", "failing"
+  security       String  // e.g., "secure", "vulnerabilities", "unknown"
+  dependencies   String  // e.g., "up-to-date", "outdated", "vulnerable"
+  // Timestamps
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("health_status") // Optional: to specify the table name
+}
+model PackageHealth {
+  id                   Int      @id @default(autoincrement())
+  packageName          String   @unique
+  packageOverallScore  Float
+  packageBuildStatus   String
+  packageTestCoverage  Float?
+  packageLintStatus    String
+  packageSecurity      String    // Changed from securityAudit to packageSecurity
+  packageDependencies  String    // Changed from dependencies to packageDependencies
+  createdAt            DateTime @default(now())
+  updatedAt            DateTime @updatedAt
+  package              Package   @relation(fields: [packageName], references: [name])
+
+  @@map("package_health")
+}
+

package/src/cli.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+/**
+ * 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)
+ */
+
+import * as path from 'path';
+import { startServer } from './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
+    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/src/gitService.ts

@@ -0,0 +1,274 @@
+/**
+ * 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 {
+      // 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: 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(): Promise<void> {
+    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)'
+      );
+    }
+  }
+}