@within-7/minto 0.4.1 → 0.4.3

package/dist/hooks/useUnifiedCompletion.js

@@ -1,1098 +0,0 @@
-import { useState, useCallback, useEffect, useRef } from "react";
-import { useInput } from "ink";
-import { existsSync, statSync, readdirSync } from "fs";
-import { join, dirname, basename, resolve } from "path";
-import { getCwd } from "../utils/state.js";
-import { getActiveAgents } from "../utils/agentLoader.js";
-import { getModelManager } from "../utils/model.js";
-import { matchCommands } from "../utils/fuzzyMatcher.js";
-import {
-  getCommonSystemCommands,
-  getCommandPriority,
-  getEssentialCommands,
-  getMinimalFallbackCommands
-} from "../utils/commonUnixCommands.js";
-import { listMCPResources } from "../services/mcpClient.js";
-const INITIAL_STATE = {
-  suggestions: [],
-  selectedIndex: 0,
-  isActive: false,
-  context: null,
-  preview: null,
-  emptyDirMessage: "",
-  suppressUntil: 0
-};
-function useUnifiedCompletion({
-  input,
-  cursorOffset,
-  onInputChange,
-  setCursorOffset,
-  commands,
-  onSubmit
-}) {
-  const [state, setState] = useState(INITIAL_STATE);
-  const updateState = useCallback((updates) => {
-    setState((prev) => ({ ...prev, ...updates }));
-  }, []);
-  const resetCompletion = useCallback(() => {
-    setState((prev) => ({
-      ...prev,
-      suggestions: [],
-      selectedIndex: 0,
-      isActive: false,
-      context: null,
-      preview: null,
-      emptyDirMessage: ""
-    }));
-  }, []);
-  const activateCompletion = useCallback(
-    (suggestions2, context) => {
-      setState((prev) => ({
-        ...prev,
-        suggestions: suggestions2,
-        // Keep the order from generateSuggestions (already sorted with weights)
-        selectedIndex: 0,
-        isActive: true,
-        context,
-        preview: null
-      }));
-    },
-    []
-  );
-  const { suggestions, selectedIndex, isActive, emptyDirMessage } = state;
-  const findCommonPrefix = useCallback(
-    (suggestions2) => {
-      if (suggestions2.length === 0) return "";
-      if (suggestions2.length === 1) return suggestions2[0].value;
-      let prefix = suggestions2[0].value;
-      for (let i = 1; i < suggestions2.length; i++) {
-        const str = suggestions2[i].value;
-        let j = 0;
-        while (j < prefix.length && j < str.length && prefix[j] === str[j]) {
-          j++;
-        }
-        prefix = prefix.slice(0, j);
-        if (prefix.length === 0) return "";
-      }
-      return prefix;
-    },
-    []
-  );
-  const getWordAtCursor = useCallback(() => {
-    if (!input) return null;
-    let start = cursorOffset;
-    while (start > 0) {
-      const char = input[start - 1];
-      if (/\s/.test(char)) break;
-      if (char === "@" && start < cursorOffset) {
-        start--;
-        break;
-      }
-      if (char === "/") {
-        const collectedSoFar = input.slice(start, cursorOffset);
-        if (collectedSoFar.includes("/") || collectedSoFar.includes(".")) {
-          start--;
-          continue;
-        }
-        if (start > 1) {
-          const prevChar = input[start - 2];
-          if (prevChar === "." || prevChar === "~") {
-            start--;
-            continue;
-          }
-        }
-        if (start === 1 || start > 1 && /\s/.test(input[start - 2])) {
-          start--;
-          break;
-        }
-        start--;
-        continue;
-      }
-      if (char === "." && start > 0) {
-        const nextChar = start < input.length ? input[start] : "";
-        if (nextChar === "/" || nextChar === ".") {
-          start--;
-          continue;
-        }
-      }
-      start--;
-    }
-    const word = input.slice(start, cursorOffset);
-    if (!word) return null;
-    if (word.startsWith("/")) {
-      const beforeWord = input.slice(0, start).trim();
-      const isCommand = beforeWord === "" && !word.includes("/", 1);
-      return {
-        type: isCommand ? "command" : "file",
-        prefix: isCommand ? word.slice(1) : word,
-        startPos: start,
-        endPos: cursorOffset
-        // Use cursor position as end
-      };
-    }
-    if (word.startsWith("@")) {
-      const content = word.slice(1);
-      if (word.includes("@", 1)) {
-        return null;
-      }
-      return {
-        type: "agent",
-        // This will trigger mixed agent+file completion
-        prefix: content,
-        startPos: start,
-        endPos: cursorOffset
-        // Use cursor position as end
-      };
-    }
-    if (word.startsWith("mcp:") || word.includes("mcp:")) {
-      const mcpPrefix = word.includes("mcp:") ? word.slice(word.indexOf("mcp:") + 4) : "";
-      return {
-        type: "mcp",
-        prefix: mcpPrefix,
-        startPos: start,
-        endPos: cursorOffset
-      };
-    }
-    return {
-      type: "file",
-      prefix: word,
-      startPos: start,
-      endPos: cursorOffset
-      // Use cursor position as end
-    };
-  }, [input, cursorOffset]);
-  const [systemCommands, setSystemCommands] = useState([]);
-  const [isLoadingCommands, setIsLoadingCommands] = useState(false);
-  const classifyCommand = useCallback(
-    (cmd) => {
-      const lowerCmd = cmd.toLowerCase();
-      let score = 0;
-      if (cmd.length <= 4) score += 40;
-      else if (cmd.length <= 6) score += 20;
-      else if (cmd.length <= 8) score += 10;
-      else if (cmd.length > 15) score -= 30;
-      if (/^[a-z]+$/.test(lowerCmd)) score += 30;
-      if (/[A-Z]/.test(cmd)) score -= 15;
-      if (/\d/.test(cmd)) score -= 20;
-      if (cmd.includes(".")) score -= 25;
-      if (cmd.includes("-")) score -= 10;
-      if (cmd.includes("_")) score -= 15;
-      const commonWords = [
-        "list",
-        "copy",
-        "move",
-        "find",
-        "print",
-        "show",
-        "edit",
-        "view"
-      ];
-      if (commonWords.some((word) => lowerCmd.includes(word.slice(0, 3))))
-        score += 25;
-      const devPrefixes = ["git", "npm", "node", "py", "docker", "kubectl"];
-      if (devPrefixes.some((prefix) => lowerCmd.startsWith(prefix))) score += 15;
-      const systemIndicators = [
-        "daemon",
-        "helper",
-        "responder",
-        "service",
-        "d$",
-        "ctl$"
-      ];
-      if (systemIndicators.some(
-        (indicator) => indicator.endsWith("$") ? lowerCmd.endsWith(indicator.slice(0, -1)) : lowerCmd.includes(indicator)
-      ))
-        score -= 40;
-      if (/\.(pl|py|sh|rb|js)$/.test(lowerCmd)) score -= 35;
-      const buildToolPatterns = [
-        "bindep",
-        "render",
-        "mako",
-        "webpack",
-        "babel",
-        "eslint"
-      ];
-      if (buildToolPatterns.some((pattern) => lowerCmd.includes(pattern)))
-        score -= 25;
-      const vowelRatio = (lowerCmd.match(/[aeiou]/g) || []).length / lowerCmd.length;
-      if (vowelRatio < 0.2) score += 15;
-      if (vowelRatio > 0.5) score -= 10;
-      if (score >= 50) return "core";
-      if (score >= 20) return "common";
-      if (score >= -10) return "dev";
-      return "system";
-    },
-    []
-  );
-  const loadSystemCommands = useCallback(async () => {
-    if (systemCommands.length > 0 || isLoadingCommands) return;
-    setIsLoadingCommands(true);
-    try {
-      const { readdirSync: readdirSync2, statSync: statSync2 } = await import("fs");
-      const pathDirs = (process.env.PATH || "").split(":").filter(Boolean);
-      const commandSet = /* @__PURE__ */ new Set();
-      const essentialCommands = getEssentialCommands();
-      essentialCommands.forEach((cmd) => commandSet.add(cmd));
-      for (const dir of pathDirs) {
-        try {
-          if (readdirSync2 && statSync2) {
-            const entries = readdirSync2(dir);
-            for (const entry of entries) {
-              try {
-                const fullPath = `${dir}/${entry}`;
-                const stats = statSync2(fullPath);
-                if (stats.isFile() && (stats.mode & 73) !== 0) {
-                  commandSet.add(entry);
-                }
-              } catch {
-              }
-            }
-          }
-        } catch {
-        }
-      }
-      const commands2 = Array.from(commandSet).sort();
-      setSystemCommands(commands2);
-    } catch (error) {
-      console.warn("Failed to load system commands, using fallback:", error);
-      setSystemCommands(getMinimalFallbackCommands());
-    } finally {
-      setIsLoadingCommands(false);
-    }
-  }, [systemCommands.length, isLoadingCommands]);
-  useEffect(() => {
-    loadSystemCommands();
-  }, [loadSystemCommands]);
-  const generateCommandSuggestions = useCallback(
-    (prefix) => {
-      const filteredCommands = commands.filter((cmd) => !cmd.isHidden);
-      if (!prefix) {
-        return filteredCommands.map((cmd) => ({
-          value: cmd.userFacingName(),
-          displayValue: `/${cmd.userFacingName()}`,
-          type: "command",
-          score: 100
-        }));
-      }
-      return filteredCommands.filter((cmd) => {
-        const names = [cmd.userFacingName(), ...cmd.aliases || []];
-        return names.some(
-          (name) => name.toLowerCase().startsWith(prefix.toLowerCase())
-        );
-      }).map((cmd) => ({
-        value: cmd.userFacingName(),
-        displayValue: `/${cmd.userFacingName()}`,
-        type: "command",
-        score: 100 - prefix.length + (cmd.userFacingName().startsWith(prefix) ? 10 : 0)
-      }));
-    },
-    [commands]
-  );
-  const calculateUnixCommandScore = useCallback(
-    (cmd, prefix) => {
-      const result = matchCommands([cmd], prefix);
-      return result.length > 0 ? result[0].score : 0;
-    },
-    []
-  );
-  const generateUnixCommandSuggestions = useCallback(
-    (prefix) => {
-      if (!prefix) return [];
-      if (isLoadingCommands) {
-        return [
-          {
-            value: "loading...",
-            displayValue: `\u23F3 Loading system commands...`,
-            type: "file",
-            score: 0,
-            metadata: { isLoading: true }
-          }
-        ];
-      }
-      const commonCommands = getCommonSystemCommands(systemCommands);
-      const uniqueCommands = Array.from(new Set(commonCommands));
-      const matches = matchCommands(uniqueCommands, prefix);
-      const boostedMatches = matches.map((match) => {
-        const priority = getCommandPriority(match.command);
-        return {
-          ...match,
-          score: match.score + priority * 0.5
-          // Add priority boost
-        };
-      }).sort((a, b) => b.score - a.score);
-      let results = boostedMatches.slice(0, 8);
-      const perfectMatches = boostedMatches.filter((m) => m.score >= 900);
-      if (perfectMatches.length > 0 && perfectMatches.length <= 3) {
-        results = perfectMatches;
-      } else if (boostedMatches.length > 8) {
-        const goodMatches = boostedMatches.filter((m) => m.score >= 100);
-        if (goodMatches.length <= 5) {
-          results = goodMatches;
-        }
-      }
-      return results.map((item) => ({
-        value: item.command,
-        displayValue: `$ ${item.command}`,
-        type: "command",
-        score: item.score,
-        metadata: { isUnixCommand: true }
-      }));
-    },
-    [systemCommands, isLoadingCommands]
-  );
-  const [agentSuggestions, setAgentSuggestions] = useState(
-    []
-  );
-  const [modelSuggestions, setModelSuggestions] = useState(
-    []
-  );
-  useEffect(() => {
-    try {
-      const modelManager = getModelManager();
-      const allModels = modelManager.getAllAvailableModelNames();
-      const suggestions2 = allModels.map((modelId) => {
-        return {
-          value: `ask-${modelId}`,
-          displayValue: `\u{1F99C} ask-${modelId} :: Consult ${modelId} for expert opinion and specialized analysis`,
-          type: "ask",
-          score: 90,
-          // Higher than agents - put ask-models on top
-          metadata: { modelId }
-        };
-      });
-      setModelSuggestions(suggestions2);
-    } catch (error) {
-      console.warn("[useUnifiedCompletion] Failed to load models:", error);
-      setModelSuggestions([]);
-    }
-  }, []);
-  const [mcpResourceSuggestions, setMcpResourceSuggestions] = useState([]);
-  useEffect(() => {
-    listMCPResources().then((resources) => {
-      const suggestions2 = resources.map((resource) => ({
-        // Use @server:uri format for CC-compatible resource references
-        value: `@${resource.serverName}:${resource.uri}`,
-        displayValue: `\u{1F50C} ${resource.serverName}:${resource.name} :: ${resource.description || resource.uri}`,
-        type: "mcp-resource",
-        score: 80,
-        metadata: {
-          uri: resource.uri,
-          serverName: resource.serverName,
-          mimeType: resource.mimeType
-        }
-      }));
-      setMcpResourceSuggestions(suggestions2);
-    }).catch((error) => {
-      console.warn(
-        "[useUnifiedCompletion] MCP resources not available:",
-        error
-      );
-      setMcpResourceSuggestions([]);
-    });
-  }, []);
-  useEffect(() => {
-    getActiveAgents().then((agents) => {
-      const suggestions2 = agents.map((config) => {
-        let shortDesc = config.whenToUse;
-        const prefixPatterns = [
-          /^Use this agent when you need (assistance with: )?/i,
-          /^Use PROACTIVELY (when|to) /i,
-          /^Specialized in /i,
-          /^Implementation specialist for /i,
-          /^Design validation specialist\.? Use PROACTIVELY to /i,
-          /^Task validation specialist\.? Use PROACTIVELY to /i,
-          /^Requirements validation specialist\.? Use PROACTIVELY to /i
-        ];
-        for (const pattern of prefixPatterns) {
-          shortDesc = shortDesc.replace(pattern, "");
-        }
-        const findSmartBreak = (text, maxLength) => {
-          if (text.length <= maxLength) return text;
-          const sentenceEndings = /[.!。！]/;
-          const firstSentenceMatch = text.search(sentenceEndings);
-          if (firstSentenceMatch !== -1) {
-            const firstSentence = text.slice(0, firstSentenceMatch).trim();
-            if (firstSentence.length >= 5) {
-              return firstSentence;
-            }
-          }
-          if (text.length > maxLength) {
-            const commaEndings = /[,，]/;
-            const commas = [];
-            let match;
-            const regex = new RegExp(commaEndings, "g");
-            while ((match = regex.exec(text)) !== null) {
-              commas.push(match.index);
-            }
-            for (let i = commas.length - 1; i >= 0; i--) {
-              const commaPos = commas[i];
-              if (commaPos < maxLength) {
-                const clause = text.slice(0, commaPos).trim();
-                if (clause.length >= 5) {
-                  return clause;
-                }
-              }
-            }
-          }
-          return text.slice(0, maxLength) + "...";
-        };
-        shortDesc = findSmartBreak(shortDesc.trim(), 80);
-        if (!shortDesc || shortDesc.length < 5) {
-          shortDesc = findSmartBreak(config.whenToUse, 80);
-        }
-        return {
-          value: `run-agent-${config.agentType}`,
-          displayValue: `\u{1F464} run-agent-${config.agentType} :: ${shortDesc}`,
-          // 人类图标 + run-agent前缀 + 简洁描述
-          type: "agent",
-          score: 85,
-          // Lower than ask-models
-          metadata: config
-        };
-      });
-      setAgentSuggestions(suggestions2);
-    }).catch((error) => {
-      console.warn("[useUnifiedCompletion] Failed to load agents:", error);
-      setAgentSuggestions([]);
-    });
-  }, []);
-  const generateMentionSuggestions = useCallback(
-    (prefix) => {
-      const allSuggestions = [...agentSuggestions, ...modelSuggestions];
-      if (!prefix) {
-        return allSuggestions.sort((a, b) => {
-          if (a.type === "ask" && b.type === "agent") return -1;
-          if (a.type === "agent" && b.type === "ask") return 1;
-          return b.score - a.score;
-        });
-      }
-      const candidates = allSuggestions.map((s) => s.value);
-      const matches = matchCommands(candidates, prefix);
-      const fuzzyResults = matches.map((match) => {
-        const suggestion = allSuggestions.find(
-          (s) => s.value === match.command
-        );
-        return {
-          ...suggestion,
-          score: match.score
-          // Use fuzzy match score instead of simple scoring
-        };
-      }).sort((a, b) => {
-        if (a.type === "ask" && b.type === "agent") return -1;
-        if (a.type === "agent" && b.type === "ask") return 1;
-        return b.score - a.score;
-      });
-      return fuzzyResults;
-    },
-    [agentSuggestions, modelSuggestions]
-  );
-  const generateFileSuggestions = useCallback(
-    (prefix, isAtReference = false) => {
-      try {
-        const cwd = getCwd();
-        const userPath = prefix || ".";
-        const isAbsolutePath = userPath.startsWith("/");
-        const isHomePath = userPath.startsWith("~");
-        let searchPath;
-        if (isHomePath) {
-          searchPath = userPath.replace("~", process.env.HOME || "");
-        } else if (isAbsolutePath) {
-          searchPath = userPath;
-        } else {
-          searchPath = resolve(cwd, userPath);
-        }
-        const endsWithSlash = userPath.endsWith("/");
-        const searchStat = existsSync(searchPath) ? statSync(searchPath) : null;
-        let searchDir;
-        let nameFilter;
-        if (endsWithSlash || searchStat?.isDirectory()) {
-          searchDir = searchPath;
-          nameFilter = "";
-        } else {
-          searchDir = dirname(searchPath);
-          nameFilter = basename(searchPath);
-        }
-        if (!existsSync(searchDir)) return [];
-        const showHidden = nameFilter.startsWith(".") || userPath.includes("/.");
-        const entries = readdirSync(searchDir).filter((entry) => {
-          if (!showHidden && entry.startsWith(".")) return false;
-          if (nameFilter && !entry.toLowerCase().startsWith(nameFilter.toLowerCase()))
-            return false;
-          return true;
-        }).sort((a, b) => {
-          const aPath = join(searchDir, a);
-          const bPath = join(searchDir, b);
-          const aIsDir = statSync(aPath).isDirectory();
-          const bIsDir = statSync(bPath).isDirectory();
-          if (aIsDir && !bIsDir) return -1;
-          if (!aIsDir && bIsDir) return 1;
-          return a.toLowerCase().localeCompare(b.toLowerCase());
-        }).slice(0, 25);
-        return entries.map((entry) => {
-          const entryPath = join(searchDir, entry);
-          const isDir = statSync(entryPath).isDirectory();
-          const icon = isDir ? "\u{1F4C1}" : "\u{1F4C4}";
-          let value;
-          if (userPath.includes("/")) {
-            if (endsWithSlash) {
-              value = userPath + entry + (isDir ? "/" : "");
-            } else if (searchStat?.isDirectory()) {
-              value = userPath + "/" + entry + (isDir ? "/" : "");
-            } else {
-              const userDir = userPath.includes("/") ? userPath.substring(0, userPath.lastIndexOf("/")) : "";
-              value = userDir ? userDir + "/" + entry + (isDir ? "/" : "") : entry + (isDir ? "/" : "");
-            }
-          } else {
-            if (searchStat?.isDirectory()) {
-              value = userPath + "/" + entry + (isDir ? "/" : "");
-            } else {
-              value = entry + (isDir ? "/" : "");
-            }
-          }
-          return {
-            value,
-            displayValue: `${icon} ${entry}${isDir ? "/" : ""}`,
-            type: "file",
-            score: isDir ? 80 : 70
-          };
-        });
-      } catch {
-        return [];
-      }
-    },
-    []
-  );
-  const calculateMatchScore = useCallback(
-    (suggestion, prefix) => {
-      const lowerPrefix = prefix.toLowerCase();
-      const value = suggestion.value.toLowerCase();
-      const displayValue = suggestion.displayValue.toLowerCase();
-      let matchFound = false;
-      let score = 0;
-      if (value.startsWith(lowerPrefix)) {
-        matchFound = true;
-        score = 100;
-      } else if (value.includes(lowerPrefix)) {
-        matchFound = true;
-        score = 95;
-      } else if (displayValue.includes(lowerPrefix)) {
-        matchFound = true;
-        score = 90;
-      } else {
-        const words = value.split(/[-_]/);
-        if (words.some((word) => word.startsWith(lowerPrefix))) {
-          matchFound = true;
-          score = 93;
-        } else {
-          const acronym = words.map((word) => word[0]).join("");
-          if (acronym.startsWith(lowerPrefix)) {
-            matchFound = true;
-            score = 88;
-          }
-        }
-      }
-      if (!matchFound) return 0;
-      if (suggestion.type === "ask") score += 2;
-      if (suggestion.type === "agent") score += 1;
-      return score;
-    },
-    []
-  );
-  const generateSmartMentionSuggestions = useCallback(
-    (prefix, sourceContext = "file") => {
-      if (!prefix || prefix.length < 2) return [];
-      const allSuggestions = [...agentSuggestions, ...modelSuggestions];
-      return allSuggestions.map((suggestion) => {
-        const matchScore = calculateMatchScore(suggestion, prefix);
-        if (matchScore === 0) return null;
-        return {
-          ...suggestion,
-          score: matchScore,
-          isSmartMatch: true,
-          originalContext: sourceContext,
-          // Only modify display for clarity, keep value clean
-          displayValue: `\u{1F3AF} ${suggestion.displayValue}`
-        };
-      }).filter(Boolean).sort((a, b) => b.score - a.score).slice(0, 5);
-    },
-    [agentSuggestions, modelSuggestions, calculateMatchScore]
-  );
-  const generateMcpResourceSuggestions = useCallback(
-    (prefix) => {
-      if (mcpResourceSuggestions.length === 0) {
-        return [
-          {
-            value: "",
-            displayValue: "\u26A0\uFE0F No MCP resources available",
-            type: "mcp-resource",
-            score: 0,
-            metadata: { isPlaceholder: true }
-          }
-        ];
-      }
-      if (!prefix) {
-        return mcpResourceSuggestions;
-      }
-      const lowerPrefix = prefix.toLowerCase();
-      return mcpResourceSuggestions.filter((s) => {
-        const uri = s.value.toLowerCase();
-        const name = s.metadata?.uri?.toLowerCase() || "";
-        const server = s.metadata?.serverName?.toLowerCase() || "";
-        return uri.includes(lowerPrefix) || name.includes(lowerPrefix) || server.includes(lowerPrefix);
-      }).map((s) => ({
-        ...s,
-        score: s.value.toLowerCase().startsWith(lowerPrefix) ? 100 : 80
-      })).sort((a, b) => b.score - a.score);
-    },
-    [mcpResourceSuggestions]
-  );
-  const generateSuggestions = useCallback(
-    (context) => {
-      switch (context.type) {
-        case "command":
-          return generateCommandSuggestions(context.prefix);
-        case "mcp":
-          return generateMcpResourceSuggestions(context.prefix);
-        case "agent": {
-          const mentionSuggestions = generateMentionSuggestions(context.prefix);
-          const fileSuggestions = generateFileSuggestions(context.prefix, true);
-          const weightedSuggestions = [
-            ...mentionSuggestions.map((s) => ({
-              ...s,
-              // In @ context, agents/models get high priority
-              weightedScore: s.score + 150
-            })),
-            ...fileSuggestions.map((s) => ({
-              ...s,
-              // Files get lower priority but still visible
-              weightedScore: s.score + 10
-              // Small boost to ensure visibility
-            }))
-          ];
-          return weightedSuggestions.sort((a, b) => b.weightedScore - a.weightedScore).map(({ weightedScore, ...suggestion }) => suggestion);
-        }
-        case "file": {
-          const fileSuggestions = generateFileSuggestions(context.prefix, false);
-          const unixSuggestions = generateUnixCommandSuggestions(context.prefix);
-          const mentionMatches = generateMentionSuggestions(context.prefix).map(
-            (s) => ({
-              ...s,
-              isSmartMatch: true,
-              // Show that @ will be added when selected
-              displayValue: `\u2192 ${s.displayValue}`
-              // Arrow to indicate it will transform
-            })
-          );
-          const weightedSuggestions = [
-            ...unixSuggestions.map((s) => ({
-              ...s,
-              // Unix commands get boost, but exact matches get huge boost
-              sourceWeight: s.score >= 1e4 ? 5e3 : 200,
-              // Exact match gets massive boost
-              weightedScore: s.score >= 1e4 ? s.score + 5e3 : s.score + 200
-            })),
-            ...mentionMatches.map((s) => ({
-              ...s,
-              // Agents/models get medium priority boost (but less to avoid overriding exact Unix)
-              sourceWeight: 50,
-              weightedScore: s.score + 50
-            })),
-            ...fileSuggestions.map((s) => ({
-              ...s,
-              // Files get no boost (baseline)
-              sourceWeight: 0,
-              weightedScore: s.score
-            }))
-          ];
-          const seen = /* @__PURE__ */ new Set();
-          const deduplicatedResults = weightedSuggestions.sort((a, b) => b.weightedScore - a.weightedScore).filter((item) => {
-            if (seen.has(item.value)) return false;
-            seen.add(item.value);
-            return true;
-          }).map(({ weightedScore, sourceWeight, ...suggestion }) => suggestion);
-          return deduplicatedResults;
-        }
-        default:
-          return [];
-      }
-    },
-    [
-      generateCommandSuggestions,
-      generateMcpResourceSuggestions,
-      generateMentionSuggestions,
-      generateFileSuggestions,
-      generateUnixCommandSuggestions,
-      generateSmartMentionSuggestions
-    ]
-  );
-  const completeWith = useCallback(
-    (suggestion, context) => {
-      let completion;
-      if (context.type === "command") {
-        completion = `/${suggestion.value} `;
-      } else if (context.type === "mcp") {
-        completion = `mcp:${suggestion.value} `;
-      } else if (context.type === "agent") {
-        if (suggestion.type === "agent") {
-          completion = `@${suggestion.value} `;
-        } else if (suggestion.type === "ask") {
-          completion = `@${suggestion.value} `;
-        } else {
-          const isDirectory = suggestion.value.endsWith("/");
-          completion = `@${suggestion.value}${isDirectory ? "" : " "}`;
-        }
-      } else {
-        if (suggestion.isSmartMatch) {
-          completion = `@${suggestion.value} `;
-        } else {
-          const isDirectory = suggestion.value.endsWith("/");
-          completion = suggestion.value + (isDirectory ? "" : " ");
-        }
-      }
-      let actualEndPos;
-      if (context.type === "file" && suggestion.value.startsWith("/") && !suggestion.isSmartMatch) {
-        let end = context.startPos;
-        while (end < input.length && input[end] !== " " && input[end] !== "\n") {
-          end++;
-        }
-        actualEndPos = end;
-      } else {
-        const currentWord = input.slice(context.startPos);
-        const nextSpaceIndex = currentWord.indexOf(" ");
-        actualEndPos = nextSpaceIndex === -1 ? input.length : context.startPos + nextSpaceIndex;
-      }
-      const newInput = input.slice(0, context.startPos) + completion + input.slice(actualEndPos);
-      onInputChange(newInput);
-      setCursorOffset(context.startPos + completion.length);
-    },
-    [input, onInputChange, setCursorOffset, onSubmit, commands]
-  );
-  const partialComplete = useCallback(
-    (prefix, context) => {
-      const completion = context.type === "command" ? `/${prefix}` : context.type === "agent" ? `@${prefix}` : prefix;
-      const newInput = input.slice(0, context.startPos) + completion + input.slice(context.endPos);
-      onInputChange(newInput);
-      setCursorOffset(context.startPos + completion.length);
-    },
-    [input, onInputChange, setCursorOffset]
-  );
-  useInput((input_str, key) => {
-    if (!key.tab) return false;
-    if (key.shift) return false;
-    const context = getWordAtCursor();
-    if (!context) return false;
-    if (state.isActive && state.suggestions.length > 0) {
-      const nextIndex = (state.selectedIndex + 1) % state.suggestions.length;
-      const nextSuggestion = state.suggestions[nextIndex];
-      if (state.context) {
-        const currentWord = input.slice(state.context.startPos);
-        const wordEnd = currentWord.search(/\s/);
-        const actualEndPos = wordEnd === -1 ? input.length : state.context.startPos + wordEnd;
-        let preview;
-        if (state.context.type === "command") {
-          preview = `/${nextSuggestion.value}`;
-        } else if (state.context.type === "agent") {
-          preview = `@${nextSuggestion.value}`;
-        } else if (nextSuggestion.isSmartMatch) {
-          preview = `@${nextSuggestion.value}`;
-        } else {
-          preview = nextSuggestion.value;
-        }
-        const newInput = input.slice(0, state.context.startPos) + preview + input.slice(actualEndPos);
-        onInputChange(newInput);
-        setCursorOffset(state.context.startPos + preview.length);
-        updateState({
-          selectedIndex: nextIndex,
-          preview: {
-            isActive: true,
-            originalInput: input,
-            wordRange: [
-              state.context.startPos,
-              state.context.startPos + preview.length
-            ]
-          }
-        });
-      }
-      return true;
-    }
-    const currentSuggestions = generateSuggestions(context);
-    if (currentSuggestions.length === 0) {
-      return false;
-    } else if (currentSuggestions.length === 1) {
-      completeWith(currentSuggestions[0], context);
-      return true;
-    } else {
-      activateCompletion(currentSuggestions, context);
-      const firstSuggestion = currentSuggestions[0];
-      const currentWord = input.slice(context.startPos);
-      const wordEnd = currentWord.search(/\s/);
-      const actualEndPos = wordEnd === -1 ? input.length : context.startPos + wordEnd;
-      let preview;
-      if (context.type === "command") {
-        preview = `/${firstSuggestion.value}`;
-      } else if (context.type === "agent") {
-        preview = `@${firstSuggestion.value}`;
-      } else if (firstSuggestion.isSmartMatch) {
-        preview = `@${firstSuggestion.value}`;
-      } else {
-        preview = firstSuggestion.value;
-      }
-      const newInput = input.slice(0, context.startPos) + preview + input.slice(actualEndPos);
-      onInputChange(newInput);
-      setCursorOffset(context.startPos + preview.length);
-      updateState({
-        preview: {
-          isActive: true,
-          originalInput: input,
-          wordRange: [context.startPos, context.startPos + preview.length]
-        }
-      });
-      return true;
-    }
-  });
-  useInput((inputChar, key) => {
-    if (key.return && state.isActive && state.suggestions.length > 0) {
-      const selectedSuggestion = state.suggestions[state.selectedIndex];
-      if (selectedSuggestion && state.context) {
-        let completion;
-        if (state.context.type === "command") {
-          completion = `/${selectedSuggestion.value} `;
-        } else if (state.context.type === "agent") {
-          if (selectedSuggestion.type === "agent") {
-            completion = `@${selectedSuggestion.value} `;
-          } else if (selectedSuggestion.type === "ask") {
-            completion = `@${selectedSuggestion.value} `;
-          } else {
-            completion = `@${selectedSuggestion.value} `;
-          }
-        } else if (selectedSuggestion.isSmartMatch) {
-          completion = `@${selectedSuggestion.value} `;
-        } else {
-          completion = selectedSuggestion.value + " ";
-        }
-        const currentWord = input.slice(state.context.startPos);
-        const nextSpaceIndex = currentWord.indexOf(" ");
-        const actualEndPos = nextSpaceIndex === -1 ? input.length : state.context.startPos + nextSpaceIndex;
-        const newInput = input.slice(0, state.context.startPos) + completion + input.slice(actualEndPos);
-        onInputChange(newInput);
-        setCursorOffset(state.context.startPos + completion.length);
-      }
-      resetCompletion();
-      return true;
-    }
-    if (!state.isActive || state.suggestions.length === 0) return false;
-    const handleNavigation = (newIndex) => {
-      const preview = state.suggestions[newIndex].value;
-      if (state.preview?.isActive && state.context) {
-        const newInput = input.slice(0, state.context.startPos) + preview + input.slice(state.preview.wordRange[1]);
-        onInputChange(newInput);
-        setCursorOffset(state.context.startPos + preview.length);
-        updateState({
-          selectedIndex: newIndex,
-          preview: {
-            ...state.preview,
-            wordRange: [
-              state.context.startPos,
-              state.context.startPos + preview.length
-            ]
-          }
-        });
-      } else {
-        updateState({ selectedIndex: newIndex });
-      }
-    };
-    if (key.downArrow) {
-      const nextIndex = (state.selectedIndex + 1) % state.suggestions.length;
-      handleNavigation(nextIndex);
-      return true;
-    }
-    if (key.upArrow) {
-      const nextIndex = state.selectedIndex === 0 ? state.suggestions.length - 1 : state.selectedIndex - 1;
-      handleNavigation(nextIndex);
-      return true;
-    }
-    if (inputChar === " " && state.isActive && state.suggestions.length > 0) {
-      const selectedSuggestion = state.suggestions[state.selectedIndex];
-      const isDirectory = selectedSuggestion.value.endsWith("/");
-      if (!state.context) return false;
-      const currentWordAtContext = input.slice(
-        state.context.startPos,
-        state.context.startPos + selectedSuggestion.value.length
-      );
-      if (currentWordAtContext !== selectedSuggestion.value) {
-        completeWith(selectedSuggestion, state.context);
-      }
-      resetCompletion();
-      if (isDirectory) {
-        setTimeout(() => {
-          const newContext = {
-            ...state.context,
-            prefix: selectedSuggestion.value,
-            endPos: state.context.startPos + selectedSuggestion.value.length
-          };
-          const newSuggestions = generateSuggestions(newContext);
-          if (newSuggestions.length > 0) {
-            activateCompletion(newSuggestions, newContext);
-          } else {
-            updateState({
-              emptyDirMessage: `Directory is empty: ${selectedSuggestion.value}`
-            });
-            setTimeout(() => updateState({ emptyDirMessage: "" }), 3e3);
-          }
-        }, 50);
-      }
-      return true;
-    }
-    if (key.rightArrow) {
-      const selectedSuggestion = state.suggestions[state.selectedIndex];
-      const isDirectory = selectedSuggestion.value.endsWith("/");
-      if (!state.context) return false;
-      const currentWordAtContext = input.slice(
-        state.context.startPos,
-        state.context.startPos + selectedSuggestion.value.length
-      );
-      if (currentWordAtContext !== selectedSuggestion.value) {
-        completeWith(selectedSuggestion, state.context);
-      }
-      resetCompletion();
-      if (isDirectory) {
-        setTimeout(() => {
-          const newContext = {
-            ...state.context,
-            prefix: selectedSuggestion.value,
-            endPos: state.context.startPos + selectedSuggestion.value.length
-          };
-          const newSuggestions = generateSuggestions(newContext);
-          if (newSuggestions.length > 0) {
-            activateCompletion(newSuggestions, newContext);
-          } else {
-            updateState({
-              emptyDirMessage: `Directory is empty: ${selectedSuggestion.value}`
-            });
-            setTimeout(() => updateState({ emptyDirMessage: "" }), 3e3);
-          }
-        }, 50);
-      }
-      return true;
-    }
-    if (key.escape) {
-      if (state.preview?.isActive && state.context) {
-        onInputChange(state.preview.originalInput);
-        setCursorOffset(state.context.startPos + state.context.prefix.length);
-      }
-      resetCompletion();
-      return true;
-    }
-    return false;
-  });
-  useInput((input_str, key) => {
-    if (key.backspace || key.delete) {
-      if (state.isActive) {
-        resetCompletion();
-        const suppressionTime = input.length > 10 ? 200 : 100;
-        updateState({
-          suppressUntil: Date.now() + suppressionTime
-        });
-        return true;
-      }
-    }
-    return false;
-  });
-  const lastInputRef = useRef("");
-  useEffect(() => {
-    if (lastInputRef.current === input) return;
-    const inputLengthChange = Math.abs(
-      input.length - lastInputRef.current.length
-    );
-    const isHistoryNavigation = (inputLengthChange > 10 || // Large content change
-    inputLengthChange > 5 && !input.includes(lastInputRef.current.slice(-5))) && // Different content
-    input !== lastInputRef.current;
-    lastInputRef.current = input;
-    if (state.preview?.isActive || Date.now() < state.suppressUntil) {
-      return;
-    }
-    if (isHistoryNavigation && state.isActive) {
-      resetCompletion();
-      return;
-    }
-    const context = getWordAtCursor();
-    if (context && shouldAutoTrigger(context)) {
-      const newSuggestions = generateSuggestions(context);
-      if (newSuggestions.length === 0) {
-        resetCompletion();
-      } else if (newSuggestions.length === 1 && shouldAutoHideSingleMatch(newSuggestions[0], context)) {
-        resetCompletion();
-      } else {
-        activateCompletion(newSuggestions, context);
-      }
-    } else if (state.context) {
-      const contextChanged = !context || state.context.type !== context.type || state.context.startPos !== context.startPos || !context.prefix.startsWith(state.context.prefix);
-      if (contextChanged) {
-        resetCompletion();
-      }
-    }
-  }, [input, cursorOffset]);
-  const shouldAutoTrigger = useCallback(
-    (context) => {
-      switch (context.type) {
-        case "command":
-          return true;
-        case "agent":
-          return true;
-        case "mcp":
-          return true;
-        case "file":
-          const prefix = context.prefix;
-          if (prefix.startsWith("./") || prefix.startsWith("../") || prefix.startsWith("/") || prefix.startsWith("~") || prefix.includes("/")) {
-            return true;
-          }
-          if (prefix.startsWith(".") && prefix.length >= 2) {
-            return true;
-          }
-          return false;
-        default:
-          return false;
-      }
-    },
-    []
-  );
-  const shouldAutoHideSingleMatch = useCallback(
-    (suggestion, context) => {
-      const currentInput = input.slice(context.startPos, context.endPos);
-      if (context.type === "file") {
-        if (suggestion.value.endsWith("/")) {
-          return false;
-        }
-        if (currentInput === suggestion.value) {
-          return true;
-        }
-        if (currentInput.endsWith("/" + suggestion.value) || currentInput.endsWith(suggestion.value)) {
-          return true;
-        }
-        return false;
-      }
-      if (context.type === "command") {
-        const fullCommand = `/${suggestion.value}`;
-        const matches = currentInput === fullCommand;
-        return matches;
-      }
-      if (context.type === "agent") {
-        const fullAgent = `@${suggestion.value}`;
-        const matches = currentInput === fullAgent;
-        return matches;
-      }
-      return false;
-    },
-    [input]
-  );
-  return {
-    suggestions,
-    selectedIndex,
-    isActive,
-    emptyDirMessage
-  };
-}
-export {
-  useUnifiedCompletion
-};
-//# sourceMappingURL=useUnifiedCompletion.js.map