claude-code-best/src/hooks/useLspPluginRecommendation.tsx

/**
 * Hook for LSP plugin recommendations
 *
 * Detects file edits and recommends LSP plugins when:
 * - File extension matches an LSP plugin
 * - LSP binary is already installed on the system
 * - Plugin is not already installed
 * - User hasn't disabled recommendations
 *
 * Only shows one recommendation per session.
 */

import { extname, join } from 'path';
import * as React from 'react';
import { hasShownLspRecommendationThisSession, setLspRecommendationShownThisSession } from '../bootstrap/state.js';
import { useNotifications } from '../context/notifications.js';
import { useAppState } from '../state/AppState.js';
import { saveGlobalConfig } from '../utils/config.js';
import { logForDebugging } from '../utils/debug.js';
import { logError } from '../utils/log.js';
import { addToNeverSuggest, getMatchingLspPlugins, incrementIgnoredCount } from '../utils/plugins/lspRecommendation.js';
import { cacheAndRegisterPlugin } from '../utils/plugins/pluginInstallationHelpers.js';
import { getSettingsForSource, updateSettingsForSource } from '../utils/settings/settings.js';
import { installPluginAndNotify, usePluginRecommendationBase } from './usePluginRecommendationBase.js';

// Threshold for detecting timeout vs explicit dismiss (ms)
// Menu auto-dismisses at 30s, so anything over 28s is likely timeout
const TIMEOUT_THRESHOLD_MS = 28_000;

export type LspRecommendationState = {
  pluginId: string;
  pluginName: string;
  pluginDescription?: string;
  fileExtension: string;
  shownAt: number; // Timestamp for timeout detection
} | null;

type UseLspPluginRecommendationResult = {
  recommendation: LspRecommendationState;
  handleResponse: (response: 'yes' | 'no' | 'never' | 'disable') => void;
};

export function useLspPluginRecommendation(): UseLspPluginRecommendationResult {
  const trackedFiles = useAppState(s => s.fileHistory.trackedFiles);
  const { addNotification } = useNotifications();
  const checkedFilesRef = React.useRef<Set<string>>(new Set());
  const { recommendation, clearRecommendation, tryResolve } =
    usePluginRecommendationBase<NonNullable<LspRecommendationState>>();

  React.useEffect(() => {
    tryResolve(async () => {
      if (hasShownLspRecommendationThisSession()) return null;

      const newFiles: string[] = [];
      for (const file of trackedFiles) {
        if (!checkedFilesRef.current.has(file)) {
          checkedFilesRef.current.add(file);
          newFiles.push(file);
        }
      }

      for (const filePath of newFiles) {
        try {
          const matches = await getMatchingLspPlugins(filePath);
          const match = matches[0]; // official plugins prioritized
          if (match) {
            logForDebugging(`[useLspPluginRecommendation] Found match: ${match.pluginName} for ${filePath}`);
            setLspRecommendationShownThisSession(true);
            return {
              pluginId: match.pluginId,
              pluginName: match.pluginName,
              pluginDescription: match.description,
              fileExtension: extname(filePath),
              shownAt: Date.now(),
            };
          }
        } catch (error) {
          logError(error);
        }
      }
      return null;
    });
  }, [trackedFiles, tryResolve]);

  const handleResponse = React.useCallback(
    (response: 'yes' | 'no' | 'never' | 'disable') => {
      if (!recommendation) return;

      const { pluginId, pluginName, shownAt } = recommendation;

      logForDebugging(`[useLspPluginRecommendation] User response: ${response} for ${pluginName}`);

      switch (response) {
        case 'yes':
          void installPluginAndNotify(pluginId, pluginName, 'lsp-plugin', addNotification, async pluginData => {
            logForDebugging(`[useLspPluginRecommendation] Installing plugin: ${pluginId}`);
            const localSourcePath =
              typeof pluginData.entry.source === 'string'
                ? join(pluginData.marketplaceInstallLocation, pluginData.entry.source)
                : undefined;
            await cacheAndRegisterPlugin(
              pluginId,
              pluginData.entry,
              'user',
              undefined, // projectPath - not needed for user scope
              localSourcePath,
            );
            // Enable in user settings so it loads on restart
            const settings = getSettingsForSource('userSettings');
            updateSettingsForSource('userSettings', {
              enabledPlugins: {
                ...settings?.enabledPlugins,
                [pluginId]: true,
              },
            });
            logForDebugging(`[useLspPluginRecommendation] Plugin installed: ${pluginId}`);
          });
          break;

        case 'no': {
          const elapsed = Date.now() - shownAt;
          if (elapsed >= TIMEOUT_THRESHOLD_MS) {
            logForDebugging(`[useLspPluginRecommendation] Timeout detected (${elapsed}ms), incrementing ignored count`);
            incrementIgnoredCount();
          }
          break;
        }

        case 'never':
          addToNeverSuggest(pluginId);
          break;

        case 'disable':
          saveGlobalConfig(current => {
            if (current.lspRecommendationDisabled) return current;
            return { ...current, lspRecommendationDisabled: true };
          });
          break;
      }

      clearRecommendation();
    },
    [recommendation, addNotification, clearRecommendation],
  );

  return { recommendation, handleResponse };
}