@xmem-ai/memcode 4.0.2

package/dist/utils/suggestions/commandSuggestions.js

@@ -0,0 +1,374 @@
+import Fuse from "fuse.js";
+import {
+  formatDescriptionWithSource,
+  getCommand,
+  getCommandName
+} from "../../commands.js";
+import { getSkillUsageScore } from "./skillUsageTracking.js";
+const SEPARATORS = /[:_-]/g;
+let fuseCache = null;
+function getCommandFuse(commands) {
+  if (fuseCache?.commands === commands) {
+    return fuseCache.fuse;
+  }
+  const commandData = commands.filter((cmd) => !cmd.isHidden).map((cmd) => {
+    const commandName = getCommandName(cmd);
+    const parts = commandName.split(SEPARATORS).filter(Boolean);
+    return {
+      descriptionKey: (cmd.description ?? "").split(" ").map((word) => cleanWord(word)).filter(Boolean),
+      partKey: parts.length > 1 ? parts : void 0,
+      commandName,
+      command: cmd,
+      aliasKey: cmd.aliases
+    };
+  });
+  const fuse = new Fuse(commandData, {
+    includeScore: true,
+    threshold: 0.3,
+    // relatively strict matching
+    location: 0,
+    // prefer matches at the beginning of strings
+    distance: 100,
+    // increased to allow matching in descriptions
+    keys: [
+      {
+        name: "commandName",
+        weight: 3
+        // Highest priority for command names
+      },
+      {
+        name: "partKey",
+        weight: 2
+        // Next highest priority for command parts
+      },
+      {
+        name: "aliasKey",
+        weight: 2
+        // Same high priority for aliases
+      },
+      {
+        name: "descriptionKey",
+        weight: 0.5
+        // Lower priority for descriptions
+      }
+    ]
+  });
+  fuseCache = { commands, fuse };
+  return fuse;
+}
+function isCommandMetadata(metadata) {
+  return typeof metadata === "object" && metadata !== null && "name" in metadata && typeof metadata.name === "string" && "type" in metadata;
+}
+function isCommandSubcommandMetadata(metadata) {
+  return typeof metadata === "object" && metadata !== null && "type" in metadata && metadata.type === "command-subcommand" && "commandName" in metadata && typeof metadata.commandName === "string" && "subcommandName" in metadata && typeof metadata.subcommandName === "string";
+}
+function findMidInputSlashCommand(input, cursorOffset) {
+  if (input.startsWith("/")) {
+    return null;
+  }
+  const beforeCursor = input.slice(0, cursorOffset);
+  const match = beforeCursor.match(/\s\/([a-zA-Z0-9_:-]*)$/);
+  if (!match || match.index === void 0) {
+    return null;
+  }
+  const slashPos = match.index + 1;
+  const textAfterSlash = input.slice(slashPos + 1);
+  const commandMatch = textAfterSlash.match(/^[a-zA-Z0-9_:-]*/);
+  const fullCommand = commandMatch ? commandMatch[0] : "";
+  if (cursorOffset > slashPos + 1 + fullCommand.length) {
+    return null;
+  }
+  return {
+    token: "/" + fullCommand,
+    startPos: slashPos,
+    partialCommand: fullCommand
+  };
+}
+function getBestCommandMatch(partialCommand, commands) {
+  if (!partialCommand) {
+    return null;
+  }
+  const suggestions = generateCommandSuggestions("/" + partialCommand, commands);
+  if (suggestions.length === 0) {
+    return null;
+  }
+  const query = partialCommand.toLowerCase();
+  for (const suggestion of suggestions) {
+    if (!isCommandMetadata(suggestion.metadata)) {
+      continue;
+    }
+    const name = getCommandName(suggestion.metadata);
+    if (name.toLowerCase().startsWith(query)) {
+      const suffix = name.slice(partialCommand.length);
+      if (suffix) {
+        return { suffix, fullCommand: name };
+      }
+    }
+  }
+  return null;
+}
+function isCommandInput(input) {
+  return input.startsWith("/");
+}
+function hasCommandArgs(input) {
+  if (!isCommandInput(input)) return false;
+  if (!input.includes(" ")) return false;
+  if (input.endsWith(" ")) return false;
+  return true;
+}
+function formatCommand(command) {
+  return `/${command} `;
+}
+function getCommandId(cmd) {
+  const commandName = getCommandName(cmd);
+  if (cmd.type === "prompt") {
+    if (cmd.source === "plugin" && cmd.pluginInfo?.repository) {
+      return `${commandName}:${cmd.source}:${cmd.pluginInfo.repository}`;
+    }
+    return `${commandName}:${cmd.source}`;
+  }
+  return `${commandName}:${cmd.type}`;
+}
+function findMatchedAlias(query, aliases) {
+  if (!aliases || aliases.length === 0 || query === "") {
+    return void 0;
+  }
+  return aliases.find((alias) => alias.toLowerCase().startsWith(query));
+}
+function createCommandSuggestionItem(cmd, matchedAlias) {
+  const commandName = getCommandName(cmd);
+  const aliasText = matchedAlias ? ` (${matchedAlias})` : "";
+  const isWorkflow = cmd.type === "prompt" && cmd.kind === "workflow";
+  const fullDescription = (isWorkflow ? cmd.description : formatDescriptionWithSource(cmd)) + (cmd.type === "prompt" && cmd.argNames?.length ? ` (arguments: ${cmd.argNames.join(", ")})` : "");
+  return {
+    id: getCommandId(cmd),
+    displayText: `/${commandName}${aliasText}`,
+    tag: isWorkflow ? "workflow" : void 0,
+    description: fullDescription,
+    metadata: cmd
+  };
+}
+function createSubcommandSuggestionItem(commandName, subcommand) {
+  return {
+    id: `${commandName}:${subcommand.name}:subcommand`,
+    displayText: subcommand.name,
+    tag: commandName,
+    description: subcommand.description,
+    metadata: {
+      type: "command-subcommand",
+      commandName,
+      subcommandName: subcommand.name,
+      argumentHint: subcommand.argumentHint
+    }
+  };
+}
+function generateSubcommandSuggestions(input, commands) {
+  if (!input.includes(" ")) return [];
+  const spaceIndex = input.indexOf(" ");
+  const commandName = input.slice(1, spaceIndex);
+  const command = commands.find(
+    (cmd) => getCommandName(cmd) === commandName || cmd.aliases?.includes(commandName)
+  );
+  if (!command?.subcommands?.length) return [];
+  const displayCommandName = getCommandName(command);
+  const args = input.slice(spaceIndex + 1);
+  const trimmedStart = args.trimStart();
+  if (trimmedStart.includes(" ")) return [];
+  const query = trimmedStart.toLowerCase();
+  return command.subcommands.filter((subcommand) => {
+    if (query === "") return true;
+    if (subcommand.name.toLowerCase().startsWith(query)) return true;
+    return subcommand.aliases?.some(
+      (alias) => alias.toLowerCase().startsWith(query)
+    );
+  }).map((subcommand) => createSubcommandSuggestionItem(displayCommandName, subcommand));
+}
+function generateCommandSuggestions(input, commands) {
+  if (!isCommandInput(input)) {
+    return [];
+  }
+  const subcommandSuggestions = generateSubcommandSuggestions(input, commands);
+  if (subcommandSuggestions.length > 0) {
+    return subcommandSuggestions;
+  }
+  if (hasCommandArgs(input)) {
+    return [];
+  }
+  const query = input.slice(1).toLowerCase().trim();
+  if (query === "") {
+    const visibleCommands = commands.filter((cmd) => !cmd.isHidden);
+    const recentlyUsed = [];
+    const commandsWithScores = visibleCommands.filter((cmd) => cmd.type === "prompt").map((cmd) => ({
+      cmd,
+      score: getSkillUsageScore(getCommandName(cmd))
+    })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
+    for (const item of commandsWithScores.slice(0, 5)) {
+      recentlyUsed.push(item.cmd);
+    }
+    const recentlyUsedIds = new Set(recentlyUsed.map((cmd) => getCommandId(cmd)));
+    const builtinCommands = [];
+    const userCommands = [];
+    const projectCommands = [];
+    const policyCommands = [];
+    const otherCommands = [];
+    visibleCommands.forEach((cmd) => {
+      if (recentlyUsedIds.has(getCommandId(cmd))) {
+        return;
+      }
+      if (cmd.type === "local" || cmd.type === "local-jsx") {
+        builtinCommands.push(cmd);
+      } else if (cmd.type === "prompt" && (cmd.source === "userSettings" || cmd.source === "localSettings")) {
+        userCommands.push(cmd);
+      } else if (cmd.type === "prompt" && cmd.source === "projectSettings") {
+        projectCommands.push(cmd);
+      } else if (cmd.type === "prompt" && cmd.source === "policySettings") {
+        policyCommands.push(cmd);
+      } else {
+        otherCommands.push(cmd);
+      }
+    });
+    const sortAlphabetically = (a, b) => getCommandName(a).localeCompare(getCommandName(b));
+    builtinCommands.sort(sortAlphabetically);
+    userCommands.sort(sortAlphabetically);
+    projectCommands.sort(sortAlphabetically);
+    policyCommands.sort(sortAlphabetically);
+    otherCommands.sort(sortAlphabetically);
+    return [
+      ...recentlyUsed,
+      ...builtinCommands,
+      ...userCommands,
+      ...projectCommands,
+      ...policyCommands,
+      ...otherCommands
+    ].map((cmd) => createCommandSuggestionItem(cmd));
+  }
+  let hiddenExact = commands.find(
+    (cmd) => cmd.isHidden && getCommandName(cmd).toLowerCase() === query
+  );
+  if (hiddenExact && commands.some(
+    (cmd) => !cmd.isHidden && getCommandName(cmd).toLowerCase() === query
+  )) {
+    hiddenExact = void 0;
+  }
+  const fuse = getCommandFuse(commands);
+  const searchResults = fuse.search(query);
+  const withMeta = searchResults.map((r) => {
+    const name = r.item.commandName.toLowerCase();
+    const aliases = r.item.aliasKey?.map((alias) => alias.toLowerCase()) ?? [];
+    const usage = r.item.command.type === "prompt" ? getSkillUsageScore(getCommandName(r.item.command)) : 0;
+    return { r, name, aliases, usage };
+  });
+  const sortedResults = withMeta.sort((a, b) => {
+    const aName = a.name;
+    const bName = b.name;
+    const aAliases = a.aliases;
+    const bAliases = b.aliases;
+    const aExactName = aName === query;
+    const bExactName = bName === query;
+    if (aExactName && !bExactName) return -1;
+    if (bExactName && !aExactName) return 1;
+    const aExactAlias = aAliases.some((alias) => alias === query);
+    const bExactAlias = bAliases.some((alias) => alias === query);
+    if (aExactAlias && !bExactAlias) return -1;
+    if (bExactAlias && !aExactAlias) return 1;
+    const aPrefixName = aName.startsWith(query);
+    const bPrefixName = bName.startsWith(query);
+    if (aPrefixName && !bPrefixName) return -1;
+    if (bPrefixName && !aPrefixName) return 1;
+    if (aPrefixName && bPrefixName && aName.length !== bName.length) {
+      return aName.length - bName.length;
+    }
+    const aPrefixAlias = aAliases.find((alias) => alias.startsWith(query));
+    const bPrefixAlias = bAliases.find((alias) => alias.startsWith(query));
+    if (aPrefixAlias && !bPrefixAlias) return -1;
+    if (bPrefixAlias && !aPrefixAlias) return 1;
+    if (aPrefixAlias && bPrefixAlias && aPrefixAlias.length !== bPrefixAlias.length) {
+      return aPrefixAlias.length - bPrefixAlias.length;
+    }
+    const scoreDiff = (a.r.score ?? 0) - (b.r.score ?? 0);
+    if (Math.abs(scoreDiff) > 0.1) {
+      return scoreDiff;
+    }
+    return b.usage - a.usage;
+  });
+  const fuseSuggestions = sortedResults.map((result) => {
+    const cmd = result.r.item.command;
+    const matchedAlias = findMatchedAlias(query, cmd.aliases);
+    return createCommandSuggestionItem(cmd, matchedAlias);
+  });
+  if (hiddenExact) {
+    const hiddenId = getCommandId(hiddenExact);
+    if (!fuseSuggestions.some((s) => s.id === hiddenId)) {
+      return [createCommandSuggestionItem(hiddenExact), ...fuseSuggestions];
+    }
+  }
+  return fuseSuggestions;
+}
+function applyCommandSuggestion(suggestion, shouldExecute, commands, onInputChange, setCursorOffset, onSubmit) {
+  if (typeof suggestion !== "string" && isCommandSubcommandMetadata(suggestion.metadata)) {
+    const { commandName: commandName2, subcommandName } = suggestion.metadata;
+    const newInput2 = `/${commandName2} ${subcommandName} `;
+    onInputChange(newInput2);
+    setCursorOffset(newInput2.length);
+    if (shouldExecute) {
+      onSubmit(
+        newInput2,
+        /* isSubmittingSlashCommand */
+        true
+      );
+    }
+    return;
+  }
+  let commandName;
+  let commandObj;
+  if (typeof suggestion === "string") {
+    commandName = suggestion;
+    commandObj = shouldExecute ? getCommand(commandName, commands) : void 0;
+  } else {
+    if (!isCommandMetadata(suggestion.metadata)) {
+      return;
+    }
+    commandName = getCommandName(suggestion.metadata);
+    commandObj = suggestion.metadata;
+  }
+  const newInput = formatCommand(commandName);
+  onInputChange(newInput);
+  setCursorOffset(newInput.length);
+  if (commandObj?.subcommands?.length) {
+    return;
+  }
+  if (shouldExecute && commandObj) {
+    if (commandObj.type !== "prompt" || (commandObj.argNames ?? []).length === 0) {
+      onSubmit(
+        newInput,
+        /* isSubmittingSlashCommand */
+        true
+      );
+    }
+  }
+}
+function cleanWord(word) {
+  return word.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function findSlashCommandPositions(text) {
+  const positions = [];
+  const regex = /(^|[\s])(\/[a-zA-Z][a-zA-Z0-9:\-_]*)/g;
+  let match = null;
+  while ((match = regex.exec(text)) !== null) {
+    const precedingChar = match[1] ?? "";
+    const commandName = match[2] ?? "";
+    const start = match.index + precedingChar.length;
+    positions.push({ start, end: start + commandName.length });
+  }
+  return positions;
+}
+export {
+  applyCommandSuggestion,
+  findMidInputSlashCommand,
+  findSlashCommandPositions,
+  formatCommand,
+  generateCommandSuggestions,
+  getBestCommandMatch,
+  hasCommandArgs,
+  isCommandInput
+};

package/dist/utils/suggestions/directoryCompletion.js

@@ -0,0 +1,141 @@
+import { LRUCache } from "lru-cache";
+import { basename, dirname, join, sep } from "path";
+import { getCwd } from "src/utils/cwd.js";
+import { getFsImplementation } from "src/utils/fsOperations.js";
+import { logError } from "src/utils/log.js";
+import { expandPath } from "src/utils/path.js";
+const CACHE_SIZE = 500;
+const CACHE_TTL = 5 * 60 * 1e3;
+const directoryCache = new LRUCache({
+  max: CACHE_SIZE,
+  ttl: CACHE_TTL
+});
+const pathCache = new LRUCache({
+  max: CACHE_SIZE,
+  ttl: CACHE_TTL
+});
+function parsePartialPath(partialPath, basePath) {
+  if (!partialPath) {
+    const directory2 = basePath || getCwd();
+    return { directory: directory2, prefix: "" };
+  }
+  const resolved = expandPath(partialPath, basePath);
+  if (partialPath.endsWith("/") || partialPath.endsWith(sep)) {
+    return { directory: resolved, prefix: "" };
+  }
+  const directory = dirname(resolved);
+  const prefix = basename(partialPath);
+  return { directory, prefix };
+}
+async function scanDirectory(dirPath) {
+  const cached = directoryCache.get(dirPath);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const fs = getFsImplementation();
+    const entries = await fs.readdir(dirPath);
+    const directories = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => ({
+      name: entry.name,
+      path: join(dirPath, entry.name),
+      type: "directory"
+    })).slice(0, 100);
+    directoryCache.set(dirPath, directories);
+    return directories;
+  } catch (error) {
+    logError(error);
+    return [];
+  }
+}
+async function getDirectoryCompletions(partialPath, options = {}) {
+  const { basePath = getCwd(), maxResults = 10 } = options;
+  const { directory, prefix } = parsePartialPath(partialPath, basePath);
+  const entries = await scanDirectory(directory);
+  const prefixLower = prefix.toLowerCase();
+  const matches = entries.filter((entry) => entry.name.toLowerCase().startsWith(prefixLower)).slice(0, maxResults);
+  return matches.map((entry) => ({
+    id: entry.path,
+    displayText: entry.name + "/",
+    description: "directory",
+    metadata: { type: "directory" }
+  }));
+}
+function clearDirectoryCache() {
+  directoryCache.clear();
+}
+function isPathLikeToken(token) {
+  return token.startsWith("~/") || token.startsWith("/") || token.startsWith("./") || token.startsWith("../") || token === "~" || token === "." || token === "..";
+}
+async function scanDirectoryForPaths(dirPath, includeHidden = false) {
+  const cacheKey = `${dirPath}:${includeHidden}`;
+  const cached = pathCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const fs = getFsImplementation();
+    const entries = await fs.readdir(dirPath);
+    const paths = entries.filter((entry) => includeHidden || !entry.name.startsWith(".")).map((entry) => ({
+      name: entry.name,
+      path: join(dirPath, entry.name),
+      type: entry.isDirectory() ? "directory" : "file"
+    })).sort((a, b) => {
+      if (a.type === "directory" && b.type !== "directory") return -1;
+      if (a.type !== "directory" && b.type === "directory") return 1;
+      return a.name.localeCompare(b.name);
+    }).slice(0, 100);
+    pathCache.set(cacheKey, paths);
+    return paths;
+  } catch (error) {
+    logError(error);
+    return [];
+  }
+}
+async function getPathCompletions(partialPath, options = {}) {
+  const {
+    basePath = getCwd(),
+    maxResults = 10,
+    includeFiles = true,
+    includeHidden = false
+  } = options;
+  const { directory, prefix } = parsePartialPath(partialPath, basePath);
+  const entries = await scanDirectoryForPaths(directory, includeHidden);
+  const prefixLower = prefix.toLowerCase();
+  const matches = entries.filter((entry) => {
+    if (!includeFiles && entry.type === "file") return false;
+    return entry.name.toLowerCase().startsWith(prefixLower);
+  }).slice(0, maxResults);
+  const hasSeparator = partialPath.includes("/") || partialPath.includes(sep);
+  let dirPortion = "";
+  if (hasSeparator) {
+    const lastSlash = partialPath.lastIndexOf("/");
+    const lastSep = partialPath.lastIndexOf(sep);
+    const lastSeparatorPos = Math.max(lastSlash, lastSep);
+    dirPortion = partialPath.substring(0, lastSeparatorPos + 1);
+  }
+  if (dirPortion.startsWith("./") || dirPortion.startsWith("." + sep)) {
+    dirPortion = dirPortion.slice(2);
+  }
+  return matches.map((entry) => {
+    const fullPath = dirPortion + entry.name;
+    return {
+      id: fullPath,
+      displayText: entry.type === "directory" ? fullPath + "/" : fullPath,
+      metadata: { type: entry.type }
+    };
+  });
+}
+function clearPathCache() {
+  directoryCache.clear();
+  pathCache.clear();
+}
+export {
+  clearDirectoryCache,
+  clearPathCache,
+  getDirectoryCompletions,
+  getPathCompletions,
+  isPathLikeToken,
+  parsePartialPath,
+  scanDirectory,
+  scanDirectoryForPaths
+};

package/dist/utils/suggestions/shellHistoryCompletion.js

@@ -0,0 +1,70 @@
+import { getHistory } from "../../history.js";
+import { logForDebugging } from "../debug.js";
+let shellHistoryCache = null;
+let shellHistoryCacheTimestamp = 0;
+const CACHE_TTL_MS = 6e4;
+async function getShellHistoryCommands() {
+  const now = Date.now();
+  if (shellHistoryCache && now - shellHistoryCacheTimestamp < CACHE_TTL_MS) {
+    return shellHistoryCache;
+  }
+  const commands = [];
+  const seen = /* @__PURE__ */ new Set();
+  try {
+    for await (const entry of getHistory()) {
+      if (entry.display && entry.display.startsWith("!")) {
+        const command = entry.display.slice(1).trim();
+        if (command && !seen.has(command)) {
+          seen.add(command);
+          commands.push(command);
+        }
+      }
+      if (commands.length >= 50) {
+        break;
+      }
+    }
+  } catch (error) {
+    logForDebugging(`Failed to read shell history: ${error}`);
+  }
+  shellHistoryCache = commands;
+  shellHistoryCacheTimestamp = now;
+  return commands;
+}
+function clearShellHistoryCache() {
+  shellHistoryCache = null;
+  shellHistoryCacheTimestamp = 0;
+}
+function prependToShellHistoryCache(command) {
+  if (!shellHistoryCache) {
+    return;
+  }
+  const idx = shellHistoryCache.indexOf(command);
+  if (idx !== -1) {
+    shellHistoryCache.splice(idx, 1);
+  }
+  shellHistoryCache.unshift(command);
+}
+async function getShellHistoryCompletion(input) {
+  if (!input || input.length < 2) {
+    return null;
+  }
+  const trimmedInput = input.trim();
+  if (!trimmedInput) {
+    return null;
+  }
+  const commands = await getShellHistoryCommands();
+  for (const command of commands) {
+    if (command.startsWith(input) && command !== input) {
+      return {
+        fullCommand: command,
+        suffix: command.slice(input.length)
+      };
+    }
+  }
+  return null;
+}
+export {
+  clearShellHistoryCache,
+  getShellHistoryCompletion,
+  prependToShellHistoryCache
+};

package/dist/utils/suggestions/skillUsageTracking.js

@@ -0,0 +1,36 @@
+import { getGlobalConfig, saveGlobalConfig } from "../config.js";
+const SKILL_USAGE_DEBOUNCE_MS = 6e4;
+const lastWriteBySkill = /* @__PURE__ */ new Map();
+function recordSkillUsage(skillName) {
+  const now = Date.now();
+  const lastWrite = lastWriteBySkill.get(skillName);
+  if (lastWrite !== void 0 && now - lastWrite < SKILL_USAGE_DEBOUNCE_MS) {
+    return;
+  }
+  lastWriteBySkill.set(skillName, now);
+  saveGlobalConfig((current) => {
+    const existing = current.skillUsage?.[skillName];
+    return {
+      ...current,
+      skillUsage: {
+        ...current.skillUsage,
+        [skillName]: {
+          usageCount: (existing?.usageCount ?? 0) + 1,
+          lastUsedAt: now
+        }
+      }
+    };
+  });
+}
+function getSkillUsageScore(skillName) {
+  const config = getGlobalConfig();
+  const usage = config.skillUsage?.[skillName];
+  if (!usage) return 0;
+  const daysSinceUse = (Date.now() - usage.lastUsedAt) / (1e3 * 60 * 60 * 24);
+  const recencyFactor = Math.pow(0.5, daysSinceUse / 7);
+  return usage.usageCount * Math.max(recencyFactor, 0.1);
+}
+export {
+  getSkillUsageScore,
+  recordSkillUsage
+};