uilint 0.2.108 → 0.2.110

package/dist/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  getDashboardStore
+} from "./chunk-6CC356LV.js";
 import {
   detectCoverageSetup,
   detectNextAppRouter,
@@ -1604,6 +1607,190 @@ function writeVisionMarkdownReport(args) {
   return { outPath, content };
 }
 
+// src/commands/serve/dashboard/logger.ts
+import pc2 from "picocolors";
+function consoleInfo(message) {
+  console.log(pc2.blue("i") + " " + message);
+}
+function consoleSuccess(message) {
+  console.log(pc2.green("\u2713") + " " + message);
+}
+function consoleWarning(message) {
+  console.log(pc2.yellow("\u26A0") + " " + message);
+}
+function consoleError(message) {
+  console.log(pc2.red("\u2717") + " " + message);
+}
+var useDashboard = false;
+function enableDashboard() {
+  useDashboard = true;
+}
+function disableDashboard() {
+  useDashboard = false;
+}
+function isDashboardEnabled() {
+  return useDashboard;
+}
+function logActivity(type, message, detail, isError, isWarning) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.addActivity({ type, message, detail, isError, isWarning });
+  } else {
+    const prefix = `${pc2.dim("[ws]")} `;
+    if (isError) {
+      consoleError(prefix + message + (detail ? `
+  ${detail}` : ""));
+    } else if (isWarning) {
+      consoleWarning(prefix + message + (detail ? `
+  ${detail}` : ""));
+    } else {
+      consoleInfo(prefix + message + (detail ? `
+  ${detail}` : ""));
+    }
+  }
+}
+function logLint(filePath, requestId) {
+  const msg = filePath + (requestId ? ` (req ${requestId})` : "");
+  logActivity("lint:file", msg);
+}
+function logLintDone(filePath, issueCount, elapsedMs) {
+  logActivity("lint:done", `${filePath} \u2192 ${issueCount} issue(s) (${elapsedMs}ms)`);
+}
+function logSubscribe(filePath) {
+  logActivity("subscribe", filePath);
+}
+function logCacheInvalidate(filePath) {
+  logActivity("cache:invalidate", filePath ?? "(all)");
+}
+function logVisionAnalyze(route, requestId) {
+  const msg = route + (requestId ? ` (req ${requestId})` : "");
+  logActivity("vision:analyze", msg);
+}
+function logVisionDone(route, issueCount, elapsedMs) {
+  logActivity("vision:done", `${route} \u2192 ${issueCount} issue(s) (${elapsedMs}ms)`);
+}
+function logVisionCheck(requestId) {
+  logActivity("vision:check", requestId ? `(req ${requestId})` : "");
+}
+function logConfigSet(key, value) {
+  logActivity("config:set", `${key} = ${JSON.stringify(value)}`);
+}
+function logRuleConfigSet(ruleId, severity, hasOptions) {
+  logActivity(
+    "rule:config:set",
+    `${ruleId} \u2192 ${severity}${hasOptions ? " (with options)" : ""}`
+  );
+}
+function logScreenshotSave(route, requestId) {
+  const msg = route + (requestId ? ` (req ${requestId})` : "");
+  logActivity("screenshot:save", msg);
+}
+function logScreenshotSaved(filename, sizeKb) {
+  logActivity("screenshot:saved", `${filename} (${sizeKb}kb)`);
+}
+function logCoverageResult(fileCount) {
+  logActivity("coverage:result", `${fileCount} files`);
+}
+function logClientConnect(totalClients) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.incrementClients();
+    store.addActivity({ type: "client:connect", message: `(${totalClients} total)` });
+  } else {
+    consoleInfo(`Client connected (${totalClients} total)`);
+  }
+}
+function logClientDisconnect(totalClients) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.decrementClients();
+    store.addActivity({ type: "client:disconnect", message: `(${totalClients} total)` });
+  } else {
+    consoleInfo(`Client disconnected (${totalClients} total)`);
+  }
+}
+function logServerError(message, detail) {
+  logActivity("error", message, detail, true);
+}
+function logServerWarning(message, detail) {
+  logActivity("warning", message, detail, false, true);
+}
+function logServerInfo(message, detail) {
+  logActivity("info", message, detail);
+}
+function setWorkspaceInfo(workspaceRoot, appRoot, serverCwd) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.setWorkspace({ workspaceRoot, appRoot, serverCwd });
+  } else {
+    consoleInfo(`Workspace root: ${pc2.dim(workspaceRoot)}`);
+    consoleInfo(`App root:       ${pc2.dim(appRoot)}`);
+    consoleInfo(`Server cwd:     ${pc2.dim(serverCwd)}`);
+  }
+}
+function setServerRunning(port) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.setPort(port);
+    store.setRunning(true);
+  } else {
+    consoleSuccess(
+      `UILint WebSocket server running on ${pc2.cyan(`ws://localhost:${port}`)}`
+    );
+    consoleInfo("Press Ctrl+C to stop");
+  }
+}
+function updateSubscriptionCount(count) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.updateStats({ subscriptions: count });
+  }
+}
+function updateCacheCount(count) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.setCacheEntries(count);
+  }
+}
+function startBackgroundTask(id, name, message) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.setBackgroundTask({
+      id,
+      name,
+      status: "running",
+      progress: 0,
+      message
+    });
+  } else {
+    consoleInfo(`${pc2.blue(name)}...`);
+  }
+}
+function updateBackgroundTaskProgress(id, progress, current, total, message) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.updateBackgroundTaskProgress(id, progress, current, total, message);
+  } else if (message) {
+    if (current !== void 0 && total !== void 0) {
+      consoleInfo(`  ${message} (${current}/${total})`);
+    } else {
+      consoleInfo(`  ${message}`);
+    }
+  }
+}
+function completeBackgroundTask(id, successMessage, error) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.completeBackgroundTask(id, error);
+  } else {
+    if (error) {
+      consoleError(`Failed: ${error}`);
+    } else if (successMessage) {
+      consoleSuccess(successMessage);
+    }
+  }
+}
+
 // src/commands/serve.ts
 import { ruleRegistry } from "uilint-eslint";
 function pickAppRoot(params) {
@@ -1916,25 +2103,17 @@ async function handleMessage(ws, data) {
   if (message.type === "lint:file" || message.type === "lint:element") {
     const fp = message.filePath;
     const rid = message.requestId;
-    logInfo(
-      `${pc.dim("[ws]")} ${pc.bold(message.type)} ${pc.dim(fp ?? "")}${rid ? ` ${pc.dim(`(req ${rid})`)}` : ""}`
-    );
+    logLint(fp ?? "", rid);
   } else if (message.type === "subscribe:file") {
-    logInfo(`${pc.dim("[ws]")} subscribe:file ${pc.dim(message.filePath)}`);
+    logSubscribe(message.filePath);
   } else if (message.type === "cache:invalidate") {
-    logInfo(
-      `${pc.dim("[ws]")} cache:invalidate ${pc.dim(
-        message.filePath ?? "(all)"
-      )}`
-    );
+    logCacheInvalidate(message.filePath);
   } else if (message.type === "vision:analyze") {
   } else if (message.type === "vision:check") {
   } else if (message.type === "config:set") {
   } else if (message.type === "screenshot:save") {
     const rid = message.requestId;
-    logInfo(
-      `${pc.dim("[ws]")} ${pc.bold("screenshot:save")} ${pc.dim(message.route)}${rid ? ` ${pc.dim(`(req ${rid})`)}` : ""}`
-    );
+    logScreenshotSave(message.route, rid);
   }
   switch (message.type) {
     case "lint:file": {
@@ -1950,28 +2129,17 @@ async function handleMessage(ws, data) {
       if (!existsSync5(resolved)) {
         const cwd = process.cwd();
         const wsRoot = findWorkspaceRoot4(cwd);
-        logWarning(
-          [
-            `${pc.dim("[ws]")} File not found for request`,
-            `  filePath: ${pc.dim(filePath)}`,
-            `  resolved: ${pc.dim(resolved)}`,
-            `  cwd:      ${pc.dim(cwd)}`,
-            `  wsRoot:   ${pc.dim(wsRoot)}`,
-            `  hint: In monorepos, ensure paths like ${pc.dim(
-              "app/page.tsx"
-            )} exist under ${pc.dim("apps/*/")} or use absolute paths.`
-          ].join("\n")
+        logServerWarning(
+          `File not found: ${filePath}`,
+          `resolved: ${resolved}, cwd: ${cwd}, wsRoot: ${wsRoot}`
         );
       }
       const issues = await lintFile(filePath, (phase) => {
         sendMessage(ws, { type: "lint:progress", filePath, requestId, phase });
       });
       const elapsed = Date.now() - startedAt;
-      logInfo(
-        `${pc.dim("[ws]")} lint:file done ${pc.dim(filePath)} \u2192 ${pc.bold(
-          `${issues.length}`
-        )} issue(s) ${pc.dim(`(${elapsed}ms)`)}`
-      );
+      logLintDone(filePath, issues.length, elapsed);
+      updateCacheCount(cache.size);
       sendMessage(ws, {
         type: "lint:progress",
         filePath,
@@ -2023,6 +2191,7 @@ async function handleMessage(ws, data) {
         }
       }
       subscribers.add({ ws, clientFilePath: filePath });
+      updateSubscriptionCount(subscriptions.size);
       break;
     }
     case "cache:invalidate": {
@@ -2033,6 +2202,7 @@ async function handleMessage(ws, data) {
       } else {
         cache.clear();
       }
+      updateCacheCount(cache.size);
       break;
     }
     case "vision:analyze": {
@@ -2044,9 +2214,7 @@ async function handleMessage(ws, data) {
         manifest,
         requestId
       } = message;
-      logInfo(
-        `${pc.dim("[ws]")} ${pc.bold("vision:analyze")} ${pc.dim(route)}${requestId ? ` ${pc.dim(`(req ${requestId})`)}` : ""}`
-      );
+      logVisionAnalyze(route, requestId);
       sendMessage(ws, {
         type: "vision:progress",
         route,
@@ -2059,20 +2227,22 @@ async function handleMessage(ws, data) {
         const screenshotBytes = typeof screenshot === "string" ? Buffer.byteLength(screenshot) : 0;
         const analyzerModel = typeof analyzer.getModel === "function" ? analyzer.getModel() : void 0;
         const analyzerBaseUrl = typeof analyzer.getBaseUrl === "function" ? analyzer.getBaseUrl() : void 0;
-        logInfo(
-          [
-            `${pc.dim("[ws]")} ${pc.dim("vision")} details`,
-            `  route:        ${pc.dim(route)}`,
-            `  requestId:    ${pc.dim(requestId ?? "(none)")}`,
-            `  manifest:     ${pc.dim(String(manifest.length))} element(s)`,
-            `  screenshot:   ${pc.dim(
-              screenshot ? `${Math.round(screenshotBytes / 1024)}kb` : "none"
-            )}`,
-            `  screenshotFile: ${pc.dim(screenshotFile ?? "(none)")}`,
-            `  ollamaUrl:    ${pc.dim(analyzerBaseUrl ?? "(default)")}`,
-            `  visionModel:  ${pc.dim(analyzerModel ?? "(default)")}`
-          ].join("\n")
-        );
+        if (!isDashboardEnabled()) {
+          logInfo(
+            [
+              `${pc.dim("[ws]")} ${pc.dim("vision")} details`,
+              `  route:        ${pc.dim(route)}`,
+              `  requestId:    ${pc.dim(requestId ?? "(none)")}`,
+              `  manifest:     ${pc.dim(String(manifest.length))} element(s)`,
+              `  screenshot:   ${pc.dim(
+                screenshot ? `${Math.round(screenshotBytes / 1024)}kb` : "none"
+              )}`,
+              `  screenshotFile: ${pc.dim(screenshotFile ?? "(none)")}`,
+              `  ollamaUrl:    ${pc.dim(analyzerBaseUrl ?? "(default)")}`,
+              `  visionModel:  ${pc.dim(analyzerModel ?? "(default)")}`
+            ].join("\n")
+          );
+        }
         if (!screenshot) {
           sendMessage(ws, {
             type: "vision:result",
@@ -2103,10 +2273,9 @@ async function handleMessage(ws, data) {
         });
         if (typeof screenshotFile === "string" && screenshotFile.length > 0) {
           if (!isValidScreenshotFilename(screenshotFile)) {
-            logWarning(
-              `Skipping vision report write: invalid screenshotFile ${pc.dim(
-                screenshotFile
-              )}`
+            logServerWarning(
+              `Skipping vision report write: invalid screenshotFile`,
+              screenshotFile
             );
           } else {
             const screenshotsDir = join3(
@@ -2117,10 +2286,9 @@ async function handleMessage(ws, data) {
             const imagePath = join3(screenshotsDir, screenshotFile);
             try {
               if (!existsSync5(imagePath)) {
-                logWarning(
-                  `Skipping vision report write: screenshot file not found ${pc.dim(
-                    imagePath
-                  )}`
+                logServerWarning(
+                  `Skipping vision report write: screenshot file not found`,
+                  imagePath
                 );
               } else {
                 const report = writeVisionMarkdownReport({
@@ -2139,32 +2307,18 @@ async function handleMessage(ws, data) {
                     requestId: requestId ?? null
                   }
                 });
-                logInfo(
-                  `${pc.dim("[ws]")} wrote vision report ${pc.dim(
-                    report.outPath
-                  )}`
-                );
+                logServerInfo(`Wrote vision report`, report.outPath);
               }
             } catch (e) {
-              logWarning(
-                `Failed to write vision report for ${pc.dim(screenshotFile)}: ${e instanceof Error ? e.message : String(e)}`
+              logServerWarning(
+                `Failed to write vision report for ${screenshotFile}`,
+                e instanceof Error ? e.message : String(e)
               );
             }
           }
         }
         const elapsed = Date.now() - startedAt;
-        logInfo(
-          `${pc.dim("[ws]")} vision:analyze done ${pc.dim(route)} \u2192 ${pc.bold(
-            `${result.issues.length}`
-          )} issue(s) ${pc.dim(`(${elapsed}ms)`)}`
-        );
-        if (result.rawResponse) {
-          logInfo(
-            `${pc.dim("[ws]")} vision rawResponse ${pc.dim(
-              `${result.rawResponse.length} chars`
-            )}`
-          );
-        }
+        logVisionDone(route, result.issues.length, elapsed);
         sendMessage(ws, {
           type: "vision:result",
           route,
@@ -2174,16 +2328,9 @@ async function handleMessage(ws, data) {
         });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        const stack = error instanceof Error ? error.stack : void 0;
-        logError(
-          [
-            `Vision analysis failed`,
-            `  route:     ${route}`,
-            `  requestId: ${requestId ?? "(none)"}`,
-            `  error:     ${errorMessage}`,
-            stack ? `  stack:
-${stack}` : ""
-          ].filter(Boolean).join("\n")
+        logServerError(
+          `Vision analysis failed for ${route}`,
+          errorMessage
         );
         sendMessage(ws, {
           type: "vision:result",
@@ -2198,9 +2345,7 @@ ${stack}` : ""
     }
     case "vision:check": {
       const { requestId } = message;
-      logInfo(
-        `${pc.dim("[ws]")} ${pc.bold("vision:check")}${requestId ? ` ${pc.dim(`(req ${requestId})`)}` : ""}`
-      );
+      logVisionCheck(requestId);
       try {
         const analyzer = getVisionAnalyzerInstance();
         const model = typeof analyzer.getModel === "function" ? analyzer.getModel() : void 0;
@@ -2276,7 +2421,7 @@ ${stack}` : ""
           break;
         }
         const coverageData = JSON.parse(readFileSync(coveragePath, "utf-8"));
-        logInfo(`${pc.dim("[ws]")} coverage:result ${pc.dim(`${Object.keys(coverageData).length} files`)}`);
+        logCoverageResult(Object.keys(coverageData).length);
         sendMessage(ws, {
           type: "coverage:result",
           coverage: coverageData,
@@ -2285,7 +2430,7 @@ ${stack}` : ""
         });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`${pc.dim("[ws]")} coverage:error ${errorMessage}`);
+        logServerError(`coverage:error`, errorMessage);
         sendMessage(ws, {
           type: "coverage:error",
           error: errorMessage,
@@ -2341,11 +2486,7 @@ ${stack}` : ""
           savedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         writeFileSync4(sidecarPath, JSON.stringify(sidecarData, null, 2));
-        logInfo(
-          `${pc.dim("[ws]")} screenshot:saved ${pc.dim(filename)} ${pc.dim(
-            `(${Math.round(imageBuffer.length / 1024)}kb)`
-          )}`
-        );
+        logScreenshotSaved(filename, Math.round(imageBuffer.length / 1024));
         sendMessage(ws, {
           type: "screenshot:saved",
           filename,
@@ -2354,7 +2495,7 @@ ${stack}` : ""
         });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`${pc.dim("[ws]")} screenshot:error ${errorMessage}`);
+        logServerError(`screenshot:error`, errorMessage);
         sendMessage(ws, {
           type: "screenshot:error",
           error: errorMessage,
@@ -2379,6 +2520,7 @@ function handleDisconnect(ws) {
       }
     }
   }
+  updateSubscriptionCount(subscriptions.size);
 }
 function handleFileChange(filePath) {
   const subscribers = subscriptions.get(filePath);
@@ -2391,7 +2533,7 @@ function handleFileChange(filePath) {
 function handleCoverageFileChange(filePath) {
   try {
     const coverageData = JSON.parse(readFileSync(filePath, "utf-8"));
-    logInfo(`${pc.dim("[ws]")} coverage:changed ${pc.dim(`${Object.keys(coverageData).length} files`)}`);
+    logCoverageResult(Object.keys(coverageData).length);
     broadcast({
       type: "coverage:result",
       coverage: coverageData,
@@ -2399,7 +2541,7 @@ function handleCoverageFileChange(filePath) {
     });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    logError(`${pc.dim("[ws]")} Failed to read coverage data: ${errorMessage}`);
+    logServerError(`Failed to read coverage data`, errorMessage);
     broadcast({
       type: "coverage:error",
       error: `Failed to read coverage: ${errorMessage}`
@@ -2416,7 +2558,7 @@ function broadcastConfigUpdate(key, value) {
 }
 function handleConfigSet(key, value) {
   configStore.set(key, value);
-  logInfo(`${pc.dim("[ws]")} config:set ${pc.bold(key)} = ${pc.dim(JSON.stringify(value))}`);
+  logConfigSet(key, value);
   broadcastConfigUpdate(key, value);
 }
 function broadcastRuleConfigChange(ruleId, severity, options) {
@@ -2443,17 +2585,14 @@ async function buildDuplicatesIndex(appRoot) {
     return;
   }
   isIndexing = true;
-  logInfo(`${pc.blue("Building duplicates index...")}`);
+  startBackgroundTask("duplicates-index", "Duplicates Index", "Starting...");
   broadcast({ type: "duplicates:indexing:start" });
   try {
     const { indexDirectory } = await import("uilint-duplicates");
     const result = await indexDirectory(appRoot, {
       onProgress: (message, current, total) => {
-        if (current !== void 0 && total !== void 0) {
-          logInfo(`  ${message} (${current}/${total})`);
-        } else {
-          logInfo(`  ${message}`);
-        }
+        const progress = total && total > 0 ? Math.round((current || 0) / total * 100) : 0;
+        updateBackgroundTaskProgress("duplicates-index", progress, current, total, message);
         broadcast({
           type: "duplicates:indexing:progress",
           message,
@@ -2462,9 +2601,8 @@ async function buildDuplicatesIndex(appRoot) {
         });
       }
     });
-    logSuccess(
-      `${pc.green("Index complete:")} ${result.totalChunks} chunks (${result.added} added, ${result.modified} modified, ${result.deleted} deleted) in ${(result.duration / 1e3).toFixed(1)}s`
-    );
+    const successMsg = `${result.totalChunks} chunks (${result.added} added, ${result.modified} modified, ${result.deleted} deleted) in ${(result.duration / 1e3).toFixed(1)}s`;
+    completeBackgroundTask("duplicates-index", `Index complete: ${successMsg}`);
     broadcast({
       type: "duplicates:indexing:complete",
       added: result.added,
@@ -2475,7 +2613,7 @@ async function buildDuplicatesIndex(appRoot) {
     });
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    logError(`Index failed: ${msg}`);
+    completeBackgroundTask("duplicates-index", void 0, msg);
     broadcast({ type: "duplicates:indexing:error", error: msg });
   } finally {
     isIndexing = false;
@@ -2488,7 +2626,7 @@ function scheduleReindex(appRoot, filePath) {
   reindexTimeout = setTimeout(async () => {
     const count = pendingIndexChanges.size;
     pendingIndexChanges.clear();
-    logInfo(`${pc.dim(`[index] ${count} file(s) changed, updating index...`)}`);
+    logServerInfo(`${count} file(s) changed, updating index...`);
     await buildDuplicatesIndex(appRoot);
   }, 2e3);
 }
@@ -2506,15 +2644,15 @@ async function buildCoverageData(appRoot) {
   isPreparingCoverage = true;
   try {
     if (!isCoverageRuleEnabled(appRoot)) {
-      logInfo(`${pc.dim("Coverage rule not enabled, skipping preparation")}`);
+      logServerInfo("Coverage rule not enabled, skipping preparation");
       return;
     }
     const setup = detectCoverageSetup(appRoot);
     if (!needsCoveragePreparation(setup)) {
-      logInfo(`${pc.dim("Coverage data is up-to-date")}`);
+      logServerInfo("Coverage data is up-to-date");
       return;
     }
-    logInfo(`${pc.blue("Preparing coverage data...")}`);
+    startBackgroundTask("coverage-prep", "Coverage Prep", "Starting...");
     broadcast({ type: "coverage:setup:start" });
     const skipPackageInstall = process.env.UILINT_SKIP_COVERAGE_INSTALL === "1";
     const skipTests = process.env.UILINT_SKIP_COVERAGE_TESTS === "1";
@@ -2523,20 +2661,21 @@ async function buildCoverageData(appRoot) {
       skipPackageInstall,
       skipTests,
       onProgress: (message, phase) => {
-        logInfo(`  ${message}`);
+        updateBackgroundTaskProgress("coverage-prep", 50, void 0, void 0, message);
         broadcast({ type: "coverage:setup:progress", message, phase });
       }
     });
     if (result.error) {
-      logWarning(`Coverage preparation completed with errors: ${result.error}`);
+      completeBackgroundTask("coverage-prep", void 0, result.error);
     } else {
       const parts = [];
       if (result.packageAdded) parts.push("package installed");
       if (result.configModified) parts.push("config modified");
       if (result.testsRan) parts.push("tests ran");
       if (result.coverageGenerated) parts.push("coverage generated");
-      logSuccess(
-        `${pc.green("Coverage prepared:")} ${parts.join(", ")} in ${(result.duration / 1e3).toFixed(1)}s`
+      completeBackgroundTask(
+        "coverage-prep",
+        `Coverage prepared: ${parts.join(", ")} in ${(result.duration / 1e3).toFixed(1)}s`
       );
     }
     broadcast({
@@ -2545,20 +2684,18 @@ async function buildCoverageData(appRoot) {
     });
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    logError(`Coverage preparation failed: ${msg}`);
+    completeBackgroundTask("coverage-prep", void 0, msg);
     broadcast({ type: "coverage:setup:error", error: msg });
   } finally {
     isPreparingCoverage = false;
   }
 }
 function handleRuleConfigSet(ws, ruleId, severity, options, requestId) {
-  logInfo(
-    `${pc.dim("[ws]")} rule:config:set ${pc.bold(ruleId)} -> ${pc.dim(severity)}${options ? ` with options` : ""}`
-  );
+  logRuleConfigSet(ruleId, severity, !!options);
   const configPath = findEslintConfigFile(serverAppRootForVision);
   if (!configPath) {
     const error = `No ESLint config file found in ${serverAppRootForVision}`;
-    logError(`${pc.dim("[ws]")} ${error}`);
+    logServerError(error);
     sendMessage(ws, {
       type: "rule:config:result",
       ruleId,
@@ -2577,11 +2714,10 @@ function handleRuleConfigSet(ws, ruleId, severity, options, requestId) {
     result = updateRuleSeverityInConfig(configPath, ruleId, severity);
   }
   if (result.success) {
-    logSuccess(
-      `${pc.dim("[ws]")} Updated ${pc.bold(`uilint/${ruleId}`)} -> ${pc.dim(severity)}`
-    );
+    logServerInfo(`Updated uilint/${ruleId} -> ${severity}`);
     eslintInstances.clear();
     cache.clear();
+    updateCacheCount(0);
     sendMessage(ws, {
       type: "rule:config:result",
       ruleId,
@@ -2592,7 +2728,7 @@ function handleRuleConfigSet(ws, ruleId, severity, options, requestId) {
     });
     broadcastRuleConfigChange(ruleId, severity, options);
   } else {
-    logError(`${pc.dim("[ws]")} Failed to update rule: ${result.error}`);
+    logServerError(`Failed to update rule: ${result.error}`);
     sendMessage(ws, {
       type: "rule:config:result",
       ruleId,
@@ -2606,13 +2742,17 @@ function handleRuleConfigSet(ws, ruleId, severity, options, requestId) {
 }
 async function serve(options) {
   const port = options.port || 9234;
+  const useDashboardUI = process.stdout.isTTY && !options.noDashboard;
+  if (useDashboardUI) {
+    enableDashboard();
+  } else {
+    disableDashboard();
+  }
   const cwd = process.cwd();
   const wsRoot = findWorkspaceRoot4(cwd);
   const appRoot = pickAppRoot({ cwd, workspaceRoot: wsRoot });
   serverAppRootForVision = appRoot;
-  logInfo(`Workspace root: ${pc.dim(wsRoot)}`);
-  logInfo(`App root:        ${pc.dim(appRoot)}`);
-  logInfo(`Server cwd:     ${pc.dim(cwd)}`);
+  setWorkspaceInfo(wsRoot, appRoot, cwd);
   fileWatcher = watch([], {
     persistent: true,
     ignoreInitial: true
@@ -2629,19 +2769,19 @@ async function serve(options) {
   const coveragePath = join3(appRoot, "coverage", "coverage-final.json");
   if (existsSync5(coveragePath)) {
     fileWatcher.add(coveragePath);
-    logInfo(`Watching coverage: ${pc.dim(coveragePath)}`);
+    logServerInfo(`Watching coverage`, coveragePath);
   }
   const wss = new WebSocketServer({ port });
   buildDuplicatesIndex(appRoot).catch((err) => {
-    logError(`Failed to build duplicates index: ${err.message}`);
+    logServerError(`Failed to build duplicates index`, err.message);
   });
   buildCoverageData(appRoot).catch((err) => {
-    logWarning(`Failed to prepare coverage: ${err.message}`);
+    logServerWarning(`Failed to prepare coverage`, err.message);
   });
   wss.on("connection", (ws) => {
     connectedClients += 1;
     connectedClientsSet.add(ws);
-    logInfo(`Client connected (${connectedClients} total)`);
+    logClientConnect(connectedClients);
     sendMessage(ws, {
       type: "workspace:info",
       appRoot,
@@ -2654,7 +2794,7 @@ async function serve(options) {
       postToolUseHook: hookInfo
     });
     if (hookInfo.enabled) {
-      logInfo(`${pc.dim("[ws]")} Post-tool-use hook detected: ${pc.bold(hookInfo.provider)}`);
+      logServerInfo(`Post-tool-use hook detected: ${hookInfo.provider}`);
     }
     const eslintConfigPath = findEslintConfigFile(appRoot);
     const currentRuleConfigs = eslintConfigPath ? readRuleConfigsFromConfig(eslintConfigPath) : /* @__PURE__ */ new Map();
@@ -2685,28 +2825,39 @@ async function serve(options) {
     ws.on("close", () => {
       connectedClients = Math.max(0, connectedClients - 1);
       connectedClientsSet.delete(ws);
-      logInfo(`Client disconnected (${connectedClients} total)`);
+      logClientDisconnect(connectedClients);
       handleDisconnect(ws);
     });
     ws.on("error", (error) => {
-      logError(`WebSocket error: ${error.message}`);
+      logServerError(`WebSocket error`, error.message);
     });
   });
   wss.on("error", (error) => {
-    logError(`Server error: ${error.message}`);
+    logServerError(`Server error`, error.message);
   });
-  logSuccess(
-    `UILint WebSocket server running on ${pc.cyan(`ws://localhost:${port}`)}`
-  );
-  logInfo("Press Ctrl+C to stop");
-  await new Promise((resolve11) => {
-    process.on("SIGINT", () => {
-      logInfo("Shutting down...");
-      wss.close();
-      fileWatcher?.close();
-      resolve11();
+  setServerRunning(port);
+  if (useDashboardUI) {
+    const { renderDashboard } = await import("./render-KO44SVF3.js");
+    const { waitUntilExit } = renderDashboard({
+      onQuit: () => {
+        wss.close();
+        fileWatcher?.close();
+      },
+      onRebuildIndex: () => {
+        buildDuplicatesIndex(appRoot);
+      }
     });
-  });
+    await waitUntilExit();
+  } else {
+    await new Promise((resolve11) => {
+      process.on("SIGINT", () => {
+        logServerInfo("Shutting down...");
+        wss.close();
+        fileWatcher?.close();
+        resolve11();
+      });
+    });
+  }
 }
 
 // src/commands/vision.ts
@@ -4977,9 +5128,10 @@ program.command("remove").description("Remove UILint components from your projec
   const { removeUI } = await import("./remove-ui-O4B6EYSF.js");
   await removeUI({ dryRun: options.dryRun, yes: options.yes });
 });
-program.command("serve").description("Start WebSocket server for real-time UI linting").option("-p, --port <number>", "Port to listen on", "9234").action(async (options) => {
+program.command("serve").description("Start WebSocket server for real-time UI linting").option("-p, --port <number>", "Port to listen on", "9234").option("--no-dashboard", "Disable dashboard UI (use simple logging)").action(async (options) => {
   await serve({
-    port: parseInt(options.port, 10)
+    port: parseInt(options.port, 10),
+    noDashboard: !options.dashboard
   });
 });
 program.command("vision").description("Analyze a screenshot with Ollama vision models (requires a manifest)").option("--list", "List available .uilint/screenshots sidecars and exit").option(