Add logging functionality and improve configuration handling

Author: habedi

package.json

@@ -40,6 +40,7 @@
     "ollama-ai-provider-v2": "^1.1.1",
     "react": "^19.1.1",
     "simple-git": "^3.28.0",
+    "winston": "^3.17.0",
     "zod": "^4.0.17",
     "zustand": "^5.0.7"
   },

src/cli.ts

@@ -2,5 +2,8 @@
 import React from "react";
 import { render } from "ink";
 import App from "./ui/App.js";
+import logger from "./logger.js";
+
+logger.info("Tobi application started.");
 
 render(React.createElement(App));

src/config.ts

@@ -4,7 +4,7 @@ import fs from "fs/promises";
 import path from "path";
 import os from "os";
 import json5 from "json5";
-
+import logger from "./logger.js";
 const modelSchema = z.object({
     name: z.string().describe("A user-friendly nickname for the model."),
     provider: z
@@ -81,37 +81,50 @@ const defaultConfig: Config = {
     mcpServers: {},
 };
 
-export const CONFIG_DIR = path.join(os.homedir(), ".config", "tobi");
-export const HISTORY_PATH = path.join(CONFIG_DIR, "history");
-const CONFIG_PATH = path.join(CONFIG_DIR, "config.json5");
+export function getConfigDir(): string {
+    return path.join(os.homedir(), ".config", "tobi");
+}
+export const HISTORY_PATH = path.join(getConfigDir(), "history");
+const CONFIG_PATH = path.join(getConfigDir(), "config.json5");
 
 export async function loadConfig(): Promise<Config> {
+    logger.debug("Attempting to load configuration.");
     try {
         const configContent = await fs.readFile(CONFIG_PATH, "utf-8");
         const parsedConfig = json5.parse(configContent);
 
         // Merge user's config over defaults. This makes adding new keys in updates non-breaking.
         const mergedConfig = { ...defaultConfig, ...parsedConfig };
-        return configSchema.parse(mergedConfig);
+        const finalConfig = configSchema.parse(mergedConfig);
+        logger.info("Configuration loaded successfully.");
+        return finalConfig;
     } catch (error: unknown) {
         if (error instanceof Error && (error as NodeJS.ErrnoException).code === "ENOENT") {
+            logger.warn(`Configuration file not found. Creating a default one at: ${CONFIG_PATH}`);
             console.warn(`Configuration file not found. Creating a default one at: ${CONFIG_PATH}`);
             console.warn(
                 `Please open this file and update your environment variables (.env) with your API keys.`,
             );
-            await fs.mkdir(CONFIG_DIR, { recursive: true });
+            await fs.mkdir(getConfigDir(), { recursive: true });
+            // Also create the logs directory
+            const LOGS_DIR = path.join(getConfigDir(), "logs");
+            await fs.mkdir(LOGS_DIR, { recursive: true });
             await fs.writeFile(CONFIG_PATH, json5.stringify(defaultConfig, null, 2));
+            logger.info("Default configuration file created.");
             return defaultConfig;
         } else if (error instanceof z.ZodError) {
+            logger.error("Configuration file is invalid:", { error: error.issues });
             console.error("Configuration file is invalid:", error.issues);
         } else {
+            logger.error("Failed to load configuration:", { error });
             console.error("Failed to load configuration:", error);
         }
         process.exit(1);
     }
 }
 
 export async function saveConfig(config: Config): Promise<void> {
+    logger.debug("Attempting to save configuration.");
     try {
         // We only want to save the fields that are user-configurable, not the derived ones.
         const configToSave: Partial<Config> = {
@@ -123,7 +136,9 @@ export async function saveConfig(config: Config): Promise<void> {
             mcpServers: config.mcpServers,
         };
         await fs.writeFile(CONFIG_PATH, json5.stringify(configToSave, null, 2));
+        logger.info("Configuration saved successfully.");
     } catch (error) {
+        logger.error("Failed to save configuration:", { error });
         console.error("Failed to save configuration:", error);
         // We don't want to exit the app if saving fails, but we should let the user know.
     }

src/logger.ts

@@ -0,0 +1,54 @@
+import winston from "winston";
+import path from "path";
+
+import { getConfigDir } from "./config.js";
+
+let logger: winston.Logger | null = null;
+
+function getLogger(): winston.Logger {
+    if (logger) {
+        return logger;
+    }
+
+    const LOGS_DIR = path.join(getConfigDir(), "logs");
+
+    const isLoggingEnabled = process.env.DEBUG_TOBI !== undefined;
+
+    if (isLoggingEnabled) {
+        logger = winston.createLogger({
+            level: "debug",
+            format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
+            transports: [
+                new winston.transports.File({
+                    filename: path.join(LOGS_DIR, `tobi-${new Date().toISOString()}.log`),
+                    maxsize: 1024 * 1024 * 5, // 5MB
+                    maxFiles: 5,
+                    tailable: true,
+                    zippedArchive: true,
+                }),
+            ],
+        });
+    } else {
+        logger = winston.createLogger({
+            transports: [new winston.transports.Console()],
+            silent: true,
+        });
+    }
+
+    return logger;
+}
+
+// Use a proxy to lazily initialize the logger on first access.
+const loggerProxy = new Proxy(
+    {},
+    {
+        get(_, prop) {
+            const loggerInstance = getLogger();
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            return loggerInstance[prop];
+        },
+    },
+) as winston.Logger;
+
+export default loggerProxy;