uilint 0.2.145 → 0.2.147

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getDashboardStore
-} from "./chunk-ZOLQHFVQ.js";
+} from "./chunk-JEYSQ5KF.js";
 import {
   detectCoverageSetup,
   detectNextAppRouter,
@@ -16,7 +16,7 @@ import {
 import {
   discoverPlugins,
   loadPluginESLintRules
-} from "./chunk-WG2WZTB2.js";
+} from "./chunk-5QUW7BNW.js";
 import {
   createSpinner,
   intro,
@@ -1508,6 +1508,19 @@ function logVisionDone(route, issueCount, elapsedMs) {
 function logVisionCheck(requestId) {
   logActivity("vision:check", requestId ? `(req ${requestId})` : "");
 }
+function logSemanticAnalyze(filePath, requestId) {
+  const msg = filePath + (requestId ? ` (req ${requestId})` : "");
+  logActivity("semantic:analyze", msg);
+}
+function logSemanticDone(filePath, issueCount, elapsedMs) {
+  logActivity(
+    "semantic:done",
+    `${filePath} \u2192 ${issueCount} issue(s) (${elapsedMs}ms)`
+  );
+}
+function logSemanticSkipped(filePath, reason) {
+  logActivity("semantic:skip", `${filePath} \u2014 ${reason}`);
+}
 function logConfigSet(key, value) {
   logActivity("config:set", `${key} = ${JSON.stringify(value)}`);
 }
@@ -1635,6 +1648,40 @@ function completeBackgroundTask(id, successMessage, error) {
 function logRuleInternalError(ruleId, filePath, detail) {
   logActivity("error", `Rule error [${ruleId}] ${filePath}`, detail, true);
 }
+function registerPlugin(id, name, model) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.registerPlugin(id, name, model);
+  } else {
+    consoleInfo(`Plugin registered: ${name} (${model})`);
+  }
+}
+function setPluginStatus(id, status, message) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.setPluginState(id, {
+      status,
+      message,
+      error: status === "error" ? message : void 0,
+      // Clear progress on terminal states
+      ...status === "idle" || status === "complete" || status === "error" ? { progress: void 0, current: void 0, total: void 0 } : {}
+    });
+  } else if (status === "error") {
+    consoleError(`Plugin ${id}: ${message}`);
+  }
+}
+function updatePluginProgress(id, progress, current, total, message) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.setPluginState(id, { progress, current, total, message });
+  }
+}
+function setPluginModel(id, model) {
+  if (useDashboard) {
+    const store = getDashboardStore();
+    store.setPluginState(id, { model });
+  }
+}
 
 // src/commands/serve.ts
 import { ruleRegistry } from "uilint-eslint";
@@ -2302,13 +2349,58 @@ async function getVisionAnalyzerInstance() {
   return visionAnalyzer;
 }
 var ollamaMutexPromise = Promise.resolve();
-function acquireOllamaMutex() {
+var ollamaMutexHolder = null;
+var ollamaMutexQueue = [];
+function acquireOllamaMutex(pluginId) {
   let release;
   const prev = ollamaMutexPromise;
   ollamaMutexPromise = new Promise((resolve11) => {
     release = resolve11;
   });
-  return prev.then(() => release);
+  ollamaMutexQueue.push(pluginId);
+  setPluginStatus(pluginId, "waiting-for-ollama", "Queued for Ollama...");
+  return prev.then(() => {
+    const idx = ollamaMutexQueue.indexOf(pluginId);
+    if (idx !== -1) ollamaMutexQueue.splice(idx, 1);
+    ollamaMutexHolder = pluginId;
+    setPluginStatus(pluginId, "using-ollama", "Using Ollama...");
+    return () => {
+      if (ollamaMutexHolder === pluginId) {
+        ollamaMutexHolder = null;
+      }
+      release();
+    };
+  });
+}
+var semanticFilesRequested = 0;
+var semanticFilesCompleted = 0;
+var semanticIdleResetTimer = null;
+function updateSemanticBatchProgress(message) {
+  const progress = semanticFilesRequested > 0 ? Math.round(semanticFilesCompleted / semanticFilesRequested * 100) : 0;
+  updatePluginProgress(
+    "semantic",
+    progress,
+    semanticFilesCompleted,
+    semanticFilesRequested,
+    message
+  );
+}
+function completeSemanticFile(terminalStatus, message) {
+  semanticFilesCompleted++;
+  if (semanticFilesCompleted >= semanticFilesRequested) {
+    const summary = terminalStatus === "complete" ? `Done: ${semanticFilesCompleted} file(s) analyzed` : message;
+    setPluginStatus("semantic", terminalStatus, summary);
+    semanticIdleResetTimer = setTimeout(() => {
+      setPluginStatus("semantic", "idle");
+      semanticFilesRequested = 0;
+      semanticFilesCompleted = 0;
+      semanticIdleResetTimer = null;
+    }, 3e3);
+  } else {
+    updateSemanticBatchProgress(
+      `${semanticFilesCompleted}/${semanticFilesRequested} files analyzed`
+    );
+  }
 }
 var serverAppRootForVision = process.cwd();
 function isValidScreenshotFilename(filename) {
@@ -2454,23 +2546,6 @@ function resolveRequestedFilePath(filePath) {
   resolvedPathCache.set(filePath, fromCwd);
   return fromCwd;
 }
-async function getESLintForProject2(projectCwd) {
-  const cached = eslintInstances2.get(projectCwd);
-  if (cached) return cached;
-  try {
-    const req = createRequire3(join3(projectCwd, "package.json"));
-    const mod = req("eslint");
-    const modDefault = mod?.default;
-    const ESLintCtor = mod?.ESLint ?? modDefault?.ESLint ?? mod?.default ?? mod;
-    if (!ESLintCtor) return null;
-    const Ctor = ESLintCtor;
-    const eslint = new Ctor({ cwd: projectCwd });
-    eslintInstances2.set(projectCwd, eslint);
-    return eslint;
-  } catch {
-    return null;
-  }
-}
 async function getESLintWithOverrides(projectCwd, overrideRules, instanceCache) {
   const cacheKey = `${projectCwd}::${JSON.stringify(overrideRules)}`;
   const cached = instanceCache.get(cacheKey);
@@ -2597,39 +2672,329 @@ async function lintFileFast(filePath, onProgress) {
     return [];
   }
 }
-async function lintFileSemantic(filePath, onProgress) {
+async function runSemanticAnalysisAsync(filePath, ws, requestId) {
+  const startTime = Date.now();
+  logSemanticAnalyze(filePath, requestId);
   const absolutePath = resolveRequestedFilePath(filePath);
-  if (!existsSync5(absolutePath)) return [];
-  const mtimeMs = (() => {
-    try {
-      return statSync2(absolutePath).mtimeMs;
-    } catch {
-      return 0;
-    }
-  })();
-  const cached = semanticCache.get(absolutePath);
-  if (cached && cached.mtimeMs === mtimeMs) {
-    onProgress("Semantic cache hit (unchanged)");
-    return cached.issues;
+  if (!existsSync5(absolutePath)) {
+    logSemanticSkipped(filePath, "file not found");
+    return;
   }
+  const eslintConfigPath = findEslintConfigFile(serverAppRootForVision);
+  const ruleConfigs = eslintConfigPath ? readRuleConfigsFromConfig(eslintConfigPath) : /* @__PURE__ */ new Map();
+  const semanticConfig = ruleConfigs.get("semantic");
+  const model = semanticConfig?.options?.model || "qwen3-vl:8b-instruct";
+  const styleguidePath = semanticConfig?.options?.styleguidePath || void 0;
+  setPluginModel("semantic", model);
+  const { getStyleguide, hashContentSync, setCacheEntry, getCacheEntry } = await import("uilint-eslint");
   const fileDir = dirname5(absolutePath);
-  const projectCwd = findESLintCwd2(fileDir);
-  const eslint = await getESLintForProject2(projectCwd);
-  if (!eslint) return [];
+  const { content: styleguide } = getStyleguide(fileDir, styleguidePath);
+  if (!styleguide) {
+    logSemanticSkipped(filePath, "no styleguide found");
+    return;
+  }
+  let fileContent;
   try {
-    onProgress("Running semantic analysis...");
-    const results = await eslint.lintFiles([absolutePath]);
-    const messages = Array.isArray(results) && results.length > 0 ? results[0].messages || [] : [];
-    const semanticMessages = messages.filter(
-      (m) => m.ruleId === "uilint/semantic"
+    fileContent = readFileSync2(absolutePath, "utf-8");
+  } catch {
+    logSemanticSkipped(filePath, "file read error");
+    return;
+  }
+  const fileHash = hashContentSync(fileContent);
+  const styleguideHash = hashContentSync(styleguide);
+  const projectRoot = findWorkspaceRoot4(fileDir) || fileDir;
+  const relativeFilePath = relative2(projectRoot, absolutePath);
+  const cached = getCacheEntry(projectRoot, relativeFilePath, fileHash, styleguideHash);
+  if (cached) {
+    logSemanticSkipped(filePath, "cache fresh");
+    return;
+  }
+  if (semanticIdleResetTimer) {
+    clearTimeout(semanticIdleResetTimer);
+    semanticIdleResetTimer = null;
+  }
+  semanticFilesRequested++;
+  updateSemanticBatchProgress(
+    `Queued ${relative2(serverAppRootForVision, absolutePath)}...`
+  );
+  sendMessage(ws, {
+    type: "lint:progress",
+    filePath,
+    requestId,
+    phase: "Running semantic analysis (async)..."
+  });
+  startBackgroundTask("semantic-analysis", "Semantic Analysis", `Analyzing ${filePath}...`);
+  broadcast({
+    type: "plugin:operation:start",
+    pluginId: "semantic",
+    operationName: "analysis",
+    message: `Analyzing ${relative2(serverAppRootForVision, absolutePath)}...`
+  });
+  const release = await acquireOllamaMutex("semantic");
+  try {
+    const { OllamaClient: OllamaClient2, buildSourceScanPrompt: buildSourceScanPrompt2 } = await import("uilint-core/node");
+    const client = new OllamaClient2({ model });
+    const ok = await client.isAvailable();
+    if (!ok) {
+      logServerWarning("Semantic analysis: Ollama not available");
+      updateBackgroundTaskProgress("semantic-analysis", 0, 0, 0, "Ollama not available");
+      completeBackgroundTask("semantic-analysis", void 0, "Ollama not available");
+      broadcast({
+        type: "plugin:operation:error",
+        pluginId: "semantic",
+        operationName: "analysis",
+        error: "Ollama not available"
+      });
+      completeSemanticFile("error", "Ollama not available");
+      return;
+    }
+    updateBackgroundTaskProgress("semantic-analysis", 50, 0, 0, "Waiting for LLM response...");
+    updateSemanticBatchProgress(
+      `Analyzing ${relative2(serverAppRootForVision, absolutePath)}...`
     );
-    if (semanticMessages.length === 0) return [];
-    const issues = processLintResults(absolutePath, projectCwd, semanticMessages, onProgress);
-    semanticCache.set(absolutePath, { issues, mtimeMs, timestamp: Date.now() });
-    return issues;
+    broadcast({
+      type: "plugin:operation:progress",
+      pluginId: "semantic",
+      operationName: "analysis",
+      message: "Waiting for LLM response..."
+    });
+    const prompt = buildSourceScanPrompt2(fileContent, styleguide, {
+      filePath: relative2(serverAppRootForVision, absolutePath)
+    });
+    const responseText = await client.complete(prompt, { json: true });
+    const parsed = JSON.parse(responseText);
+    const issues = (parsed.issues || []).map((issue) => ({
+      line: issue.line || 1,
+      column: issue.column,
+      message: issue.message || "Semantic issue detected",
+      ruleId: "uilint/semantic",
+      severity: 1
+    }));
+    setCacheEntry(projectRoot, relativeFilePath, {
+      fileHash,
+      styleguideHash,
+      issues,
+      timestamp: Date.now()
+    });
+    const fileDir2 = dirname5(absolutePath);
+    const projectCwd = findESLintCwd2(fileDir2);
+    const dataLocFile = normalizeDataLocFilePath2(absolutePath, projectCwd);
+    const lintIssues = issues.map((issue) => ({
+      ruleId: "uilint/semantic",
+      severity: issue.severity,
+      message: issue.message,
+      line: issue.line,
+      column: issue.column || 0,
+      nodeType: null,
+      source: null,
+      dataLoc: `${dataLocFile}:${issue.line}:${issue.column || 0}`
+    }));
+    sendMessage(ws, {
+      type: "lint:result",
+      filePath,
+      requestId,
+      issues: lintIssues
+    });
+    const elapsed = Date.now() - startTime;
+    const msg = `${issues.length} issue(s) found`;
+    logSemanticDone(filePath, issues.length, elapsed);
+    completeBackgroundTask("semantic-analysis", msg);
+    completeSemanticFile("complete", msg);
+    broadcast({
+      type: "plugin:operation:complete",
+      pluginId: "semantic",
+      operationName: "analysis",
+      message: msg
+    });
+    sendMessage(ws, {
+      type: "lint:progress",
+      filePath,
+      requestId,
+      phase: `Done (semantic: ${issues.length} issues)`
+    });
   } catch (error) {
-    logServerError("Semantic pass failed", error instanceof Error ? error.message : String(error));
-    return [];
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logServerError("Async semantic analysis failed", errorMessage);
+    completeBackgroundTask("semantic-analysis", void 0, errorMessage);
+    completeSemanticFile("error", errorMessage);
+    broadcast({
+      type: "plugin:operation:error",
+      pluginId: "semantic",
+      operationName: "analysis",
+      error: errorMessage
+    });
+  } finally {
+    release();
+  }
+}
+async function runVisionAnalysisInBackground(ws, message) {
+  const { route, timestamp, screenshot, screenshotFile, manifest, requestId } = message;
+  setPluginStatus("vision", "processing", `Analyzing ${route}...`);
+  startBackgroundTask("vision-analysis", "Vision Analysis", `Analyzing ${route}...`);
+  broadcast({
+    type: "plugin:operation:start",
+    pluginId: "vision",
+    operationName: "analysis",
+    message: `Analyzing ${route}...`
+  });
+  const visionMod = await getVisionModule();
+  if (!visionMod) {
+    sendMessage(ws, {
+      type: "vision:result",
+      route,
+      issues: [],
+      analysisTime: 0,
+      error: "uilint-vision is not installed",
+      requestId
+    });
+    completeBackgroundTask("vision-analysis", void 0, "uilint-vision not installed");
+    setPluginStatus("vision", "error", "uilint-vision not installed");
+    setTimeout(() => setPluginStatus("vision", "idle"), 3e3);
+    broadcast({
+      type: "plugin:operation:error",
+      pluginId: "vision",
+      operationName: "analysis",
+      error: "uilint-vision not installed"
+    });
+    return;
+  }
+  sendMessage(ws, {
+    type: "vision:progress",
+    route,
+    requestId,
+    phase: "Starting vision analysis..."
+  });
+  const startedAt = Date.now();
+  const analyzer = await getVisionAnalyzerInstance();
+  updateBackgroundTaskProgress("vision-analysis", 10, 0, 0, "Waiting for Ollama...");
+  const releaseOllama = await acquireOllamaMutex("vision");
+  try {
+    const analyzerObj = analyzer;
+    const analyzerModel = typeof analyzerObj?.getModel === "function" ? analyzerObj.getModel() : void 0;
+    const analyzerBaseUrl = typeof analyzerObj?.getBaseUrl === "function" ? analyzerObj.getBaseUrl() : void 0;
+    if (analyzerModel) {
+      setPluginModel("vision", analyzerModel);
+    }
+    if (!screenshot) {
+      sendMessage(ws, {
+        type: "vision:result",
+        route,
+        issues: [],
+        analysisTime: Date.now() - startedAt,
+        error: "No screenshot provided for vision analysis",
+        requestId
+      });
+      completeBackgroundTask("vision-analysis", void 0, "No screenshot provided");
+      setPluginStatus("vision", "error", "No screenshot provided");
+      setTimeout(() => setPluginStatus("vision", "idle"), 3e3);
+      broadcast({
+        type: "plugin:operation:error",
+        pluginId: "vision",
+        operationName: "analysis",
+        error: "No screenshot provided"
+      });
+      return;
+    }
+    updateBackgroundTaskProgress("vision-analysis", 30, 0, 0, "Running vision analysis...");
+    broadcast({
+      type: "plugin:operation:progress",
+      pluginId: "vision",
+      operationName: "analysis",
+      message: "Running vision analysis..."
+    });
+    const result = await visionMod.runVisionAnalysis({
+      imageBase64: screenshot,
+      manifest,
+      projectPath: serverAppRootForVision,
+      baseUrl: analyzerBaseUrl,
+      model: analyzerModel,
+      analyzer,
+      onPhase: (phase) => {
+        sendMessage(ws, {
+          type: "vision:progress",
+          route,
+          requestId,
+          phase
+        });
+        updateBackgroundTaskProgress("vision-analysis", 50, 0, 0, phase);
+      },
+      pathResolver: resolvePathSpecifier
+    });
+    if (typeof screenshotFile === "string" && screenshotFile.length > 0) {
+      if (isValidScreenshotFilename(screenshotFile)) {
+        const screenshotsDir = join3(serverAppRootForVision, ".uilint", "screenshots");
+        const imagePath = join3(screenshotsDir, screenshotFile);
+        try {
+          if (existsSync5(imagePath)) {
+            const report = visionMod.writeVisionMarkdownReport({
+              imagePath,
+              route,
+              timestamp,
+              visionModel: result.visionModel,
+              baseUrl: result.baseUrl,
+              analysisTimeMs: result.analysisTime,
+              prompt: result.prompt ?? null,
+              rawResponse: result.rawResponse ?? null,
+              metadata: {
+                screenshotFile: parse(imagePath).base,
+                appRoot: serverAppRootForVision,
+                manifestElements: manifest.length,
+                requestId: requestId ?? null
+              }
+            });
+            logServerInfo(`Wrote vision report`, report.outPath);
+          }
+        } catch (e) {
+          logServerWarning(
+            `Failed to write vision report for ${screenshotFile}`,
+            e instanceof Error ? e.message : String(e)
+          );
+        }
+      }
+    }
+    const elapsed = Date.now() - startedAt;
+    const resultIssues = result.issues;
+    logVisionDone(route, resultIssues.length, elapsed);
+    sendMessage(ws, {
+      type: "vision:result",
+      route,
+      issues: resultIssues,
+      analysisTime: result.analysisTime,
+      requestId
+    });
+    const msg = `${resultIssues.length} issue(s) in ${(elapsed / 1e3).toFixed(1)}s`;
+    completeBackgroundTask("vision-analysis", msg);
+    setPluginStatus("vision", "complete", msg);
+    setTimeout(() => setPluginStatus("vision", "idle"), 3e3);
+    broadcast({
+      type: "plugin:operation:complete",
+      pluginId: "vision",
+      operationName: "analysis",
+      message: msg
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const elapsed = Date.now() - startedAt;
+    logServerError(`Vision analysis failed for ${route}`, errorMessage);
+    sendMessage(ws, {
+      type: "vision:result",
+      route,
+      issues: [],
+      analysisTime: elapsed,
+      error: errorMessage,
+      requestId
+    });
+    completeBackgroundTask("vision-analysis", void 0, errorMessage);
+    setPluginStatus("vision", "error", errorMessage);
+    setTimeout(() => setPluginStatus("vision", "idle"), 3e3);
+    broadcast({
+      type: "plugin:operation:error",
+      pluginId: "vision",
+      operationName: "analysis",
+      error: errorMessage
+    });
+  } finally {
+    releaseOllama();
   }
 }
 function sendMessage(ws, message) {
@@ -2690,52 +3055,18 @@ async function handleMessage(ws, data) {
       logLintDone(filePath, fastClientIssues.length, fastElapsed);
       updateCacheCount(fastCache.size + semanticCache.size);
       sendMessage(ws, { type: "lint:result", filePath, requestId, issues: fastClientIssues });
+      sendMessage(ws, {
+        type: "lint:progress",
+        filePath,
+        requestId,
+        phase: `Done (${fastClientIssues.length} issues, ${fastElapsed}ms)`
+      });
       if (isSemanticRuleEnabled()) {
-        sendMessage(ws, {
-          type: "lint:progress",
-          filePath,
-          requestId,
-          phase: `Fast lint done (${fastClientIssues.length} issues, ${fastElapsed}ms). Running semantic...`
-        });
-        setImmediate(async () => {
-          try {
-            const _semanticStart = Date.now();
-            const semanticIssues = await lintFileSemantic(filePath, (phase) => {
-              sendMessage(ws, { type: "lint:progress", filePath, requestId, phase });
-            });
-            const semanticSentinels = semanticIssues.filter(isSentinelIssue);
-            for (const se of semanticSentinels) {
-              logRuleInternalError(se.ruleId ?? "unknown", filePath, se.message);
-            }
-            const semanticClientIssues = semanticIssues.filter((i) => !isSentinelIssue(i));
-            const totalElapsed = Date.now() - startedAt;
-            const totalIssues = fastClientIssues.length + semanticClientIssues.length;
-            if (semanticClientIssues.length > 0) {
-              sendMessage(ws, { type: "lint:result", filePath, requestId, issues: semanticClientIssues });
-            }
-            sendMessage(ws, {
-              type: "lint:progress",
-              filePath,
-              requestId,
-              phase: `Done (${totalIssues} issues, ${totalElapsed}ms)`
-            });
-          } catch (error) {
-            logServerError("Semantic pass failed", error instanceof Error ? error.message : String(error));
-            sendMessage(ws, {
-              type: "lint:progress",
-              filePath,
-              requestId,
-              phase: `Done (${fastClientIssues.length} issues, ${Date.now() - startedAt}ms)`
-            });
-          }
+        runSemanticAnalysisAsync(filePath, ws, requestId).catch((err) => {
+          logServerError("Async semantic analysis failed", err instanceof Error ? err.message : String(err));
         });
       } else {
-        sendMessage(ws, {
-          type: "lint:progress",
-          filePath,
-          requestId,
-          phase: `Done (${fastClientIssues.length} issues, ${fastElapsed}ms)`
-        });
+        logSemanticSkipped(filePath, "rule not enabled");
       }
       break;
     }
@@ -2757,39 +3088,7 @@ async function handleMessage(ws, data) {
       }
       const fastFiltered = fastIssues.filter((i) => !isSentinelIssue(i)).filter((issue) => issue.dataLoc === dataLoc);
       sendMessage(ws, { type: "lint:result", filePath, requestId, issues: fastFiltered });
-      if (isSemanticRuleEnabled()) {
-        setImmediate(async () => {
-          try {
-            const semanticIssues = await lintFileSemantic(filePath, (phase) => {
-              sendMessage(ws, { type: "lint:progress", filePath, requestId, phase });
-            });
-            const semanticSentinels = semanticIssues.filter(isSentinelIssue);
-            for (const se of semanticSentinels) {
-              logRuleInternalError(se.ruleId ?? "unknown", filePath, se.message);
-            }
-            const semanticFiltered = semanticIssues.filter((i) => !isSentinelIssue(i)).filter((issue) => issue.dataLoc === dataLoc);
-            const totalFiltered = fastFiltered.length + semanticFiltered.length;
-            const elapsed = Date.now() - startedAt;
-            if (semanticFiltered.length > 0) {
-              sendMessage(ws, { type: "lint:result", filePath, requestId, issues: semanticFiltered });
-            }
-            sendMessage(ws, {
-              type: "lint:progress",
-              filePath,
-              requestId,
-              phase: `Done (${totalFiltered} issues, ${elapsed}ms)`
-            });
-          } catch (error) {
-            logServerError("Semantic pass failed", error instanceof Error ? error.message : String(error));
-            sendMessage(ws, {
-              type: "lint:progress",
-              filePath,
-              requestId,
-              phase: `Done (${fastFiltered.length} issues, ${Date.now() - startedAt}ms)`
-            });
-          }
-        });
-      } else {
+      {
         const elapsed = Date.now() - startedAt;
         sendMessage(ws, {
           type: "lint:progress",
@@ -2798,6 +3097,13 @@ async function handleMessage(ws, data) {
           phase: `Done (${fastFiltered.length} issues, ${elapsed}ms)`
         });
       }
+      if (isSemanticRuleEnabled()) {
+        runSemanticAnalysisAsync(filePath, ws, requestId).catch((err) => {
+          logServerError("Async semantic analysis failed", err instanceof Error ? err.message : String(err));
+        });
+      } else {
+        logSemanticSkipped(filePath, "rule not enabled");
+      }
       break;
     }
     case "subscribe:file": {
@@ -2831,125 +3137,11 @@ async function handleMessage(ws, data) {
       break;
     }
     case "vision:analyze": {
-      const {
-        route,
-        timestamp,
-        screenshot,
-        screenshotFile,
-        manifest,
-        requestId
-      } = message;
-      logVisionAnalyze(route, requestId);
-      const visionMod = await getVisionModule();
-      if (!visionMod) {
-        sendMessage(ws, {
-          type: "vision:result",
-          route,
-          issues: [],
-          analysisTime: 0,
-          error: "uilint-vision is not installed",
-          requestId
-        });
-        break;
-      }
-      sendMessage(ws, {
-        type: "vision:progress",
-        route,
-        requestId,
-        phase: "Starting vision analysis..."
+      const visionMsg = message;
+      logVisionAnalyze(visionMsg.route, visionMsg.requestId);
+      runVisionAnalysisInBackground(ws, visionMsg).catch((err) => {
+        logServerError("Vision analysis failed", err instanceof Error ? err.message : String(err));
       });
-      const startedAt = Date.now();
-      const analyzer = await getVisionAnalyzerInstance();
-      const releaseOllama = await acquireOllamaMutex();
-      try {
-        const analyzerObj = analyzer;
-        const analyzerModel = typeof analyzerObj?.getModel === "function" ? analyzerObj.getModel() : void 0;
-        const analyzerBaseUrl = typeof analyzerObj?.getBaseUrl === "function" ? analyzerObj.getBaseUrl() : void 0;
-        if (!screenshot) {
-          sendMessage(ws, {
-            type: "vision:result",
-            route,
-            issues: [],
-            analysisTime: Date.now() - startedAt,
-            error: "No screenshot provided for vision analysis",
-            requestId
-          });
-          break;
-        }
-        const result = await visionMod.runVisionAnalysis({
-          imageBase64: screenshot,
-          manifest,
-          projectPath: serverAppRootForVision,
-          baseUrl: analyzerBaseUrl,
-          model: analyzerModel,
-          analyzer,
-          onPhase: (phase) => {
-            sendMessage(ws, {
-              type: "vision:progress",
-              route,
-              requestId,
-              phase
-            });
-          },
-          pathResolver: resolvePathSpecifier
-        });
-        if (typeof screenshotFile === "string" && screenshotFile.length > 0) {
-          if (isValidScreenshotFilename(screenshotFile)) {
-            const screenshotsDir = join3(serverAppRootForVision, ".uilint", "screenshots");
-            const imagePath = join3(screenshotsDir, screenshotFile);
-            try {
-              if (existsSync5(imagePath)) {
-                const report = visionMod.writeVisionMarkdownReport({
-                  imagePath,
-                  route,
-                  timestamp,
-                  visionModel: result.visionModel,
-                  baseUrl: result.baseUrl,
-                  analysisTimeMs: result.analysisTime,
-                  prompt: result.prompt ?? null,
-                  rawResponse: result.rawResponse ?? null,
-                  metadata: {
-                    screenshotFile: parse(imagePath).base,
-                    appRoot: serverAppRootForVision,
-                    manifestElements: manifest.length,
-                    requestId: requestId ?? null
-                  }
-                });
-                logServerInfo(`Wrote vision report`, report.outPath);
-              }
-            } catch (e) {
-              logServerWarning(
-                `Failed to write vision report for ${screenshotFile}`,
-                e instanceof Error ? e.message : String(e)
-              );
-            }
-          }
-        }
-        const elapsed = Date.now() - startedAt;
-        const resultIssues = result.issues;
-        logVisionDone(route, resultIssues.length, elapsed);
-        sendMessage(ws, {
-          type: "vision:result",
-          route,
-          issues: resultIssues,
-          analysisTime: result.analysisTime,
-          requestId
-        });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const elapsed = Date.now() - startedAt;
-        logServerError(`Vision analysis failed for ${route}`, errorMessage);
-        sendMessage(ws, {
-          type: "vision:result",
-          route,
-          issues: [],
-          analysisTime: elapsed,
-          error: errorMessage,
-          requestId
-        });
-      } finally {
-        releaseOllama();
-      }
       break;
     }
     case "vision:check": {
@@ -3204,13 +3396,20 @@ async function buildDuplicatesIndex(appRoot) {
     return;
   }
   isIndexing = true;
+  setPluginStatus("duplicates", "processing", "Preparing index...");
   startBackgroundTask(
     "duplicates-index",
     "Duplicates Index",
     "Waiting for Ollama..."
   );
-  const release = await acquireOllamaMutex();
+  const release = await acquireOllamaMutex("duplicates");
   broadcast({ type: "duplicates:indexing:start" });
+  broadcast({
+    type: "plugin:operation:start",
+    pluginId: "duplicates",
+    operationName: "indexing",
+    message: "Building duplicates index..."
+  });
   try {
     const { indexDirectory } = await import("uilint-duplicates");
     const result = await indexDirectory(appRoot, {
@@ -3223,16 +3422,27 @@ async function buildDuplicatesIndex(appRoot) {
           total,
           message
         );
+        updatePluginProgress("duplicates", progress, current, total, message);
         broadcast({
           type: "duplicates:indexing:progress",
           message,
           current,
           total
         });
+        broadcast({
+          type: "plugin:operation:progress",
+          pluginId: "duplicates",
+          operationName: "indexing",
+          current,
+          total,
+          message
+        });
       }
     });
     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}`);
+    setPluginStatus("duplicates", "complete", successMsg);
+    setTimeout(() => setPluginStatus("duplicates", "idle"), 3e3);
     broadcast({
       type: "duplicates:indexing:complete",
       added: result.added,
@@ -3241,10 +3451,24 @@ async function buildDuplicatesIndex(appRoot) {
       totalChunks: result.totalChunks,
       duration: result.duration
     });
+    broadcast({
+      type: "plugin:operation:complete",
+      pluginId: "duplicates",
+      operationName: "indexing",
+      message: successMsg
+    });
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     completeBackgroundTask("duplicates-index", void 0, msg);
+    setPluginStatus("duplicates", "error", msg);
+    setTimeout(() => setPluginStatus("duplicates", "idle"), 3e3);
     broadcast({ type: "duplicates:indexing:error", error: msg });
+    broadcast({
+      type: "plugin:operation:error",
+      pluginId: "duplicates",
+      operationName: "indexing",
+      error: msg
+    });
   } finally {
     release();
     isIndexing = false;
@@ -3392,6 +3616,9 @@ async function serve(options) {
   const useDashboardUI = process.stdout.isTTY && !options.noDashboard;
   if (useDashboardUI) {
     enableDashboard();
+    registerPlugin("semantic", "Semantic", "qwen3-vl:8b-instruct");
+    registerPlugin("vision", "Vision", "gemma3:4b");
+    registerPlugin("duplicates", "Duplicates", "nomic-embed-text");
   } else {
     disableDashboard();
   }
@@ -3561,7 +3788,7 @@ async function serve(options) {
   });
   setServerRunning(port);
   if (useDashboardUI) {
-    const { renderDashboard } = await import("./render-43OMCORR.js");
+    const { renderDashboard } = await import("./render-2P4YWHXV.js");
     const { waitUntilExit } = renderDashboard({
       onQuit: () => {
         clearInterval(pingInterval);
@@ -5704,7 +5931,7 @@ program.command("update").description("Update existing style guide with new styl
 });
 var initCommand = program.command("init").description("Initialize UILint integration").option("--force", "Overwrite existing configuration files").option("--react", "Install React DevTool (non-interactive)").option("--eslint", "Install ESLint rules (non-interactive)").option("--genstyleguide", "Generate styleguide (non-interactive)").option("--skill", "Install Claude skill (non-interactive)");
 program.command("remove").description("Remove UILint components from your project").option("--dry-run", "Preview changes without removing anything").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
-  const { removeUI } = await import("./remove-ui-ZHW4GUFL.js");
+  const { removeUI } = await import("./remove-ui-GZRFA2AC.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").option("--no-dashboard", "Disable dashboard UI (use simple logging)").action(async (options) => {
@@ -5756,7 +5983,7 @@ program.addCommand(createDuplicatesCommand());
 program.addCommand(createManifestCommand());
 program.addCommand(createSocketCommand());
 program.command("upgrade").description("Update installed ESLint rules to latest versions").option("--check", "Show available updates without applying").option("-y, --yes", "Auto-confirm all updates").option("--dry-run", "Show what would change without modifying files").option("--rule <id>", "Upgrade only a specific rule").action(async (options) => {
-  const { upgrade } = await import("./upgrade-TPZ62BT2.js");
+  const { upgrade } = await import("./upgrade-2UKW3SIQ.js");
   await upgrade({
     check: options.check,
     yes: options.yes,
@@ -5765,14 +5992,14 @@ program.command("upgrade").description("Update installed ESLint rules to latest
   });
 });
 async function main() {
-  const { discoverPlugins: discoverPlugins2 } = await import("./plugin-loader-O6PNFN6D.js");
+  const { discoverPlugins: discoverPlugins2 } = await import("./plugin-loader-LUIV7MLR.js");
   const pluginManifests = await discoverPlugins2();
   for (const manifest of pluginManifests) {
     initCommand.option(`--${manifest.cliFlag}`, manifest.cliDescription);
   }
   initCommand.action(async (options) => {
     const plugins = pluginManifests.filter((m) => options[m.cliFlag]).map((m) => m.cliFlag);
-    const { initUI } = await import("./init-ui-KJYYI5DH.js");
+    const { initUI } = await import("./init-ui-QQXIZSKI.js");
     await initUI({
       force: options.force,
       react: options.react,