@shareai-lab/kode 1.2.0 → 2.0.2

package/dist/hooks/useUnifiedCompletion.js

@@ -1,929 +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";
-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
-      };
-    }
-    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([]);
-    }
-  }, []);
-  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 generateSuggestions = useCallback((context) => {
-    switch (context.type) {
-      case "command":
-        return generateCommandSuggestions(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, generateMentionSuggestions, generateFileSuggestions, generateUnixCommandSuggestions, generateSmartMentionSuggestions]);
-  const completeWith = useCallback((suggestion, context) => {
-    let completion;
-    if (context.type === "command") {
-      completion = `/${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))) && 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 "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