feat: implement log level control via CLI flags

Introduces a log level system (ERROR, WARN, INFO, DEBUG) to control application logging verbosity.

- Added `LogLevel` enum and `setLogLevel` function to `src/utils/logger.ts`.
- Modified logger methods to respect the current log level.
- Added global `--verbose` (DEBUG level) and `--silent` (ERROR level) flags to the CLI (`src/cli.ts`).
- Used the `preAction` hook in `commander` to set the log level based on CLI flags before command execution.
- Set the default log level for the MCP server (`src/mcp/index.ts`) to `ERROR`.

Author: arabold

src/cli.ts

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import "dotenv/config";
 import { Command } from "commander";
-import { PipelineManager } from "./pipeline/PipelineManager"; // Import PipelineManager
+import packageJson from "../package.json";
+import { PipelineManager } from "./pipeline/PipelineManager";
 import { DocumentManagementService } from "./store/DocumentManagementService";
 import { FindVersionTool, ListLibrariesTool, ScrapeTool, SearchTool } from "./tools";
+import { LogLevel, setLogLevel } from "./utils/logger";
 
 const formatOutput = (data: unknown) => JSON.stringify(data, null, 2);
 
@@ -39,7 +41,10 @@ async function main() {
     program
       .name("docs-mcp")
       .description("CLI for managing documentation vector store")
-      .version("1.0.0");
+      .version(packageJson.version)
+      // Add global options for logging level
+      .option("--verbose", "Enable verbose (debug) logging", false)
+      .option("--silent", "Disable all logging except errors", false);
 
     program
       .command("scrape <library> <url>") // Remove <version> as positional
@@ -160,6 +165,19 @@ async function main() {
         }
       });
 
+    // Hook to set log level after parsing global options but before executing command action
+    program.hook("preAction", (thisCommand) => {
+      // Global options are attached to the program (thisCommand)
+      const options = thisCommand.opts();
+      if (options.silent) {
+        // If silent is true, it overrides verbose
+        setLogLevel(LogLevel.ERROR);
+      } else if (options.verbose) {
+        setLogLevel(LogLevel.DEBUG);
+      }
+      // Otherwise, the default LogLevel.INFO remains set from logger.ts
+    });
+
     await program.parseAsync();
   } catch (error) {
     console.error("Error:", error instanceof Error ? error.message : String(error));

src/mcp/index.ts

@@ -17,14 +17,12 @@ import {
   SearchTool,
   VersionNotFoundError,
 } from "../tools";
-import { logger } from "../utils/logger";
+import { LogLevel, logger, setLogLevel } from "../utils/logger"; // Import LogLevel and setLogLevel
 import { createError, createResponse } from "./utils";
 
 export async function startServer() {
-  // Disable debug logs
-  // FIXME: This is a temporary fix. We should use a proper logging library with levels.
-  logger.debug = () => {};
-  logger.info = () => {};
+  // Set the default log level for the server to ERROR
+  setLogLevel(LogLevel.ERROR);
 
   const docService = new DocumentManagementService();
 

src/utils/logger.ts

@@ -1,6 +1,61 @@
+/**
+ * Defines the available log levels.
+ */
+export enum LogLevel {
+  ERROR = 0,
+  WARN = 1,
+  INFO = 2,
+  DEBUG = 3,
+}
+
+let currentLogLevel: LogLevel = LogLevel.INFO; // Default level
+
+/**
+ * Sets the current logging level for the application.
+ * @param level - The desired log level.
+ */
+export function setLogLevel(level: LogLevel): void {
+  currentLogLevel = level;
+}
+
+/**
+ * Provides logging functionalities with level control.
+ */
 export const logger = {
-  debug: (message: string) => console.debug(message),
-  info: (message: string) => console.log(message),
-  warn: (message: string) => console.warn(message),
-  error: (message: string) => console.error(message),
+  /**
+   * Logs a debug message if the current log level is DEBUG or higher.
+   * @param message - The message to log.
+   */
+  debug: (message: string) => {
+    if (currentLogLevel >= LogLevel.DEBUG) {
+      console.debug(message);
+    }
+  },
+  /**
+   * Logs an info message if the current log level is INFO or higher.
+   * @param message - The message to log.
+   */
+  info: (message: string) => {
+    if (currentLogLevel >= LogLevel.INFO) {
+      console.log(message); // Using console.log for INFO
+    }
+  },
+  /**
+   * Logs a warning message if the current log level is WARN or higher.
+   * @param message - The message to log.
+   */
+  warn: (message: string) => {
+    if (currentLogLevel >= LogLevel.WARN) {
+      console.warn(message);
+    }
+  },
+  /**
+   * Logs an error message if the current log level is ERROR or higher (always logs).
+   * @param message - The message to log.
+   */
+  error: (message: string) => {
+    if (currentLogLevel >= LogLevel.ERROR) {
+      console.error(message);
+    }
+  },
 };