@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/utils/suggestions/commandSuggestions.js

@@ -1,458 +0,0 @@
-import Fuse from 'fuse.js';
-import { formatDescriptionWithSource, getCommand, getCommandName, } from '../../commands.js';
-import { getSkillUsageScore } from './skillUsageTracking.js';
-// Treat these characters as word separators for command search
-const SEPARATORS = /[:_-]/g;
-// Cache the Fuse index keyed by the commands array identity. The commands
-// array is stable (memoized in REPL.tsx), so we only rebuild when it changes
-// rather than on every keystroke.
-let fuseCache = null;
-function getCommandFuse(commands) {
-    if (fuseCache?.commands === commands) {
-        return fuseCache.fuse;
-    }
-    const commandData = commands
-        .filter(cmd => cmd && !cmd.isHidden && getCommandName(cmd))
-        .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 : undefined,
-            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;
-}
-/**
- * Type guard to check if a suggestion's metadata is a Command.
- * Commands have a name string and a type property.
- */
-function isCommandMetadata(metadata) {
-    return (typeof metadata === 'object' &&
-        metadata !== null &&
-        'name' in metadata &&
-        typeof metadata.name === 'string' &&
-        'type' in metadata);
-}
-/**
- * Finds a slash command token that appears mid-input (not at position 0).
- * A mid-input slash command is a "/" preceded by whitespace, where the cursor
- * is at or after the "/".
- *
- * @param input The full input string
- * @param cursorOffset The current cursor position
- * @returns The mid-input slash command info, or null if not found
- */
-export function findMidInputSlashCommand(input, cursorOffset) {
-    // If input starts with "/", this is start-of-input case (handled elsewhere)
-    if (input.startsWith('/')) {
-        return null;
-    }
-    // Look backwards from cursor to find a "/" preceded by whitespace
-    const beforeCursor = input.slice(0, cursorOffset);
-    // Find the last "/" in the text before cursor
-    // Pattern: whitespace followed by "/" then optional alphanumeric/dash characters.
-    // Lookbehind (?<=\s) is avoided — it defeats YARR JIT in JSC, and the
-    // interpreter scans O(n) even with the $ anchor. Capture the whitespace
-    // instead and offset match.index by 1.
-    const match = beforeCursor.match(/\s\/([a-zA-Z0-9_:-]*)$/);
-    if (!match || match.index === undefined) {
-        return null;
-    }
-    // Get the full token (may extend past cursor)
-    const slashPos = match.index + 1;
-    const textAfterSlash = input.slice(slashPos + 1);
-    // Extract the command portion (until whitespace or end)
-    const commandMatch = textAfterSlash.match(/^[a-zA-Z0-9_:-]*/);
-    const fullCommand = commandMatch ? commandMatch[0] : '';
-    // If cursor is past the command (after a space), don't show ghost text
-    if (cursorOffset > slashPos + 1 + fullCommand.length) {
-        return null;
-    }
-    return {
-        token: '/' + fullCommand,
-        startPos: slashPos,
-        partialCommand: fullCommand,
-    };
-}
-/**
- * Finds the best matching command for a partial command string.
- * Delegates to generateCommandSuggestions and filters to prefix matches.
- *
- * @param partialCommand The partial command typed by the user (without "/")
- * @param commands Available commands
- * @returns The completion suffix (e.g., "mit" for partial "com" matching "commit"), or null
- */
-export function getBestCommandMatch(partialCommand, commands) {
-    if (!partialCommand) {
-        return null;
-    }
-    // Use existing suggestion logic
-    const suggestions = generateCommandSuggestions('/' + partialCommand, commands);
-    if (suggestions.length === 0) {
-        return null;
-    }
-    // Find first suggestion that is a prefix match (for inline completion)
-    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);
-            // Only return if there's something to complete
-            if (suffix) {
-                return { suffix, fullCommand: name };
-            }
-        }
-    }
-    return null;
-}
-/**
- * Checks if input is a command (starts with slash)
- */
-export function isCommandInput(input) {
-    return input.startsWith('/');
-}
-/**
- * Checks if a command input has arguments
- * A command with just a trailing space is considered to have no arguments
- */
-export function hasCommandArgs(input) {
-    if (!isCommandInput(input))
-        return false;
-    if (!input.includes(' '))
-        return false;
-    if (input.endsWith(' '))
-        return false;
-    return true;
-}
-/**
- * Formats a command with proper notation
- */
-export function formatCommand(command) {
-    return `/${command} `;
-}
-/**
- * Generates a deterministic unique ID for a command suggestion.
- * Commands with the same name from different sources get unique IDs.
- *
- * Only prompt commands can have duplicates (from user settings, project
- * settings, plugins, etc). Built-in commands (local, local-jsx) are
- * defined once in code and can't have duplicates.
- */
-function getCommandId(cmd) {
-    const commandName = getCommandName(cmd);
-    if (cmd.type === 'prompt') {
-        // For plugin commands, include the repository to disambiguate
-        if (cmd.source === 'plugin' && cmd.pluginInfo?.repository) {
-            return `${commandName}:${cmd.source}:${cmd.pluginInfo.repository}`;
-        }
-        return `${commandName}:${cmd.source}`;
-    }
-    // Built-in commands include type as fallback for future-proofing
-    return `${commandName}:${cmd.type}`;
-}
-/**
- * Checks if a query matches any of the command's aliases.
- * Returns the matched alias if found, otherwise undefined.
- */
-function findMatchedAlias(query, aliases) {
-    if (!aliases || aliases.length === 0 || query === '') {
-        return undefined;
-    }
-    // Check if query is a prefix of any alias (case-insensitive)
-    return aliases.find(alias => alias.toLowerCase().startsWith(query));
-}
-/**
- * Creates a suggestion item from a command.
- * Only shows the matched alias in parentheses if the user typed an alias.
- */
-function createCommandSuggestionItem(cmd, matchedAlias) {
-    const commandName = getCommandName(cmd);
-    // Only show the alias if the user typed it
-    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' : undefined,
-        description: fullDescription,
-        metadata: cmd,
-    };
-}
-/**
- * Generate command suggestions based on input
- */
-export function generateCommandSuggestions(input, commands) {
-    // Only process command input
-    if (!isCommandInput(input)) {
-        return [];
-    }
-    // If there are arguments, don't show suggestions
-    if (hasCommandArgs(input)) {
-        return [];
-    }
-    const query = input.slice(1).toLowerCase().trim();
-    // When just typing '/' without additional text
-    if (query === '') {
-        const visibleCommands = commands.filter(cmd => !cmd.isHidden);
-        // Find recently used skills (only prompt commands have usage tracking)
-        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);
-        // Take top 5 recently used skills
-        for (const item of commandsWithScores.slice(0, 5)) {
-            recentlyUsed.push(item.cmd);
-        }
-        // Create a set of recently used command IDs to avoid duplicates
-        const recentlyUsedIds = new Set(recentlyUsed.map(cmd => getCommandId(cmd)));
-        // Categorize remaining commands (excluding recently used)
-        const builtinCommands = [];
-        const userCommands = [];
-        const projectCommands = [];
-        const policyCommands = [];
-        const otherCommands = [];
-        visibleCommands.forEach(cmd => {
-            // Skip if already in recently used
-            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);
-            }
-        });
-        // Sort each category alphabetically
-        const sortAlphabetically = (a, b) => getCommandName(a).localeCompare(getCommandName(b));
-        builtinCommands.sort(sortAlphabetically);
-        userCommands.sort(sortAlphabetically);
-        projectCommands.sort(sortAlphabetically);
-        policyCommands.sort(sortAlphabetically);
-        otherCommands.sort(sortAlphabetically);
-        // Combine with built-in commands prioritized after recently used,
-        // so they remain visible even when many skills are installed
-        return [
-            ...recentlyUsed,
-            ...builtinCommands,
-            ...userCommands,
-            ...projectCommands,
-            ...policyCommands,
-            ...otherCommands,
-        ].map(cmd => createCommandSuggestionItem(cmd));
-    }
-    // The Fuse index filters isHidden at build time and is keyed on the
-    // (memoized) commands array identity, so a command that is hidden when Fuse
-    // first builds stays invisible to Fuse for the whole session. If the user
-    // types the exact name of a currently-hidden command, prepend it to the
-    // Fuse results so exact-name always wins over weak description fuzzy
-    // matches — but only when no visible command shares the name (that would
-    // be the user's explicit override and should win). Prepend rather than
-    // early-return so visible prefix siblings (e.g. /voice-memo) still appear
-    // below, and getBestCommandMatch can still find a non-empty suffix.
-    let hiddenExact = commands.find(cmd => cmd && cmd.isHidden && getCommandName(cmd)?.toLowerCase() === query);
-    if (hiddenExact &&
-        commands.some(cmd => cmd && !cmd.isHidden && getCommandName(cmd)?.toLowerCase() === query)) {
-        hiddenExact = undefined;
-    }
-    const fuse = getCommandFuse(commands);
-    const searchResults = fuse.search(query);
-    // Sort results prioritizing exact/prefix command name matches over fuzzy description matches
-    // Priority order:
-    // 1. Exact name match (highest)
-    // 2. Exact alias match
-    // 3. Prefix name match
-    // 4. Prefix alias match
-    // 5. Fuzzy match (lowest)
-    // Precompute per-item values once to avoid O(n log n) recomputation in comparator
-    const withMeta = searchResults.map(r => {
-        const name = (r.item.commandName || '').toLowerCase();
-        const aliases = r.item.command?.aliases?.map(alias => alias?.toLowerCase()).filter((a) => !!a) ?? [];
-        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;
-        // Check for exact name match (highest priority)
-        const aExactName = aName === query;
-        const bExactName = bName === query;
-        if (aExactName && !bExactName)
-            return -1;
-        if (bExactName && !aExactName)
-            return 1;
-        // Check for exact alias match
-        const aExactAlias = aAliases.some(alias => alias === query);
-        const bExactAlias = bAliases.some(alias => alias === query);
-        if (aExactAlias && !bExactAlias)
-            return -1;
-        if (bExactAlias && !aExactAlias)
-            return 1;
-        // Check for prefix name match
-        const aPrefixName = aName.startsWith(query);
-        const bPrefixName = bName.startsWith(query);
-        if (aPrefixName && !bPrefixName)
-            return -1;
-        if (bPrefixName && !aPrefixName)
-            return 1;
-        // Among prefix name matches, prefer the shorter name (closer to exact)
-        if (aPrefixName && bPrefixName && aName.length !== bName.length) {
-            return aName.length - bName.length;
-        }
-        // Check for prefix alias match
-        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;
-        // Among prefix alias matches, prefer the shorter alias
-        if (aPrefixAlias &&
-            bPrefixAlias &&
-            aPrefixAlias.length !== bPrefixAlias.length) {
-            return aPrefixAlias.length - bPrefixAlias.length;
-        }
-        // For similar match types, use Fuse score with usage as tiebreaker
-        const scoreDiff = (a.r.score ?? 0) - (b.r.score ?? 0);
-        if (Math.abs(scoreDiff) > 0.1) {
-            return scoreDiff;
-        }
-        // For similar Fuse scores, prefer more frequently used skills
-        return b.usage - a.usage;
-    });
-    // Map search results to suggestion items
-    // Note: We intentionally don't deduplicate here because commands with the same name
-    // from different sources (e.g., projectSettings vs userSettings) may have different
-    // implementations and should both be available to the user
-    const fuseSuggestions = sortedResults.map(result => {
-        const cmd = result.r.item.command;
-        // Only show alias in parentheses if the user typed an alias
-        const matchedAlias = findMatchedAlias(query, cmd.aliases);
-        return createCommandSuggestionItem(cmd, matchedAlias);
-    });
-    // Skip the prepend if hiddenExact is already in fuseSuggestions — this
-    // happens when isHidden flips false→true mid-session (OAuth expiry,
-    // GrowthBook kill-switch) and the stale Fuse index still holds the
-    // command. Fuse already sorts exact-name matches first, so no reorder
-    // is needed; we just don't want a duplicate id (duplicate React keys,
-    // both rows rendering as selected).
-    if (hiddenExact) {
-        const hiddenId = getCommandId(hiddenExact);
-        if (!fuseSuggestions.some(s => s.id === hiddenId)) {
-            return [createCommandSuggestionItem(hiddenExact), ...fuseSuggestions];
-        }
-    }
-    return fuseSuggestions;
-}
-/**
- * Apply selected command to input
- */
-export function applyCommandSuggestion(suggestion, shouldExecute, commands, onInputChange, setCursorOffset, onSubmit) {
-    // Extract command name and object from string or SuggestionItem metadata
-    let commandName;
-    let commandObj;
-    if (typeof suggestion === 'string') {
-        commandName = suggestion;
-        commandObj = shouldExecute ? getCommand(commandName, commands) : undefined;
-    }
-    else {
-        if (!isCommandMetadata(suggestion.metadata)) {
-            return; // Invalid suggestion, nothing to apply
-        }
-        commandName = getCommandName(suggestion.metadata);
-        commandObj = suggestion.metadata;
-    }
-    // Format the command input with trailing space
-    const newInput = formatCommand(commandName);
-    onInputChange(newInput);
-    setCursorOffset(newInput.length);
-    // Execute command if requested and it takes no arguments
-    if (shouldExecute && commandObj) {
-        if (commandObj.type !== 'prompt' ||
-            (commandObj.argNames ?? []).length === 0) {
-            onSubmit(newInput, /* isSubmittingSlashCommand */ true);
-        }
-    }
-}
-// Helper function at bottom of file per CLAUDE.md
-function cleanWord(word) {
-    return word.toLowerCase().replace(/[^a-z0-9]/g, '');
-}
-/**
- * Find all /command patterns in text for highlighting.
- * Returns array of {start, end} positions.
- * Requires whitespace or start-of-string before the slash to avoid
- * matching paths like /usr/bin.
- */
-export function findSlashCommandPositions(text) {
-    const positions = [];
-    // Match /command patterns preceded by whitespace or start-of-string
-    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] ?? '';
-        // Start position is after the whitespace (if any)
-        const start = match.index + precedingChar.length;
-        positions.push({ start, end: start + commandName.length });
-    }
-    return positions;
-}

package/dist/src/utils/suggestions/directoryCompletion.js

@@ -1,191 +0,0 @@
-import { LRUCache } from 'lru-cache';
-import { basename, dirname, join, sep } from 'path';
-import { getCwd } from '../cwd.js';
-import { getFsImplementation } from '../fsOperations.js';
-import { logError } from '../log.js';
-import { expandPath } from '../path.js';
-// Cache configuration
-const CACHE_SIZE = 500;
-const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-// Initialize LRU cache for directory scans
-const directoryCache = new LRUCache({
-    max: CACHE_SIZE,
-    ttl: CACHE_TTL,
-});
-// Initialize LRU cache for path scans (files and directories)
-const pathCache = new LRUCache({
-    max: CACHE_SIZE,
-    ttl: CACHE_TTL,
-});
-/**
- * Parses a partial path into directory and prefix components
- */
-export function parsePartialPath(partialPath, basePath) {
-    // Handle empty input
-    if (!partialPath) {
-        const directory = basePath || getCwd();
-        return { directory, prefix: '' };
-    }
-    const resolved = expandPath(partialPath, basePath);
-    // If path ends with separator, treat as directory with no prefix
-    // Handle both forward slash and platform-specific separator
-    if (partialPath.endsWith('/') || partialPath.endsWith(sep)) {
-        return { directory: resolved, prefix: '' };
-    }
-    // Split into directory and prefix
-    const directory = dirname(resolved);
-    const prefix = basename(partialPath);
-    return { directory, prefix };
-}
-/**
- * Scans a directory and returns subdirectories
- * Uses LRU cache to avoid repeated filesystem calls
- */
-export async function scanDirectory(dirPath) {
-    // Check cache first
-    const cached = directoryCache.get(dirPath);
-    if (cached) {
-        return cached;
-    }
-    try {
-        // Read directory contents
-        const fs = getFsImplementation();
-        const entries = await fs.readdir(dirPath);
-        // Filter for directories only, exclude hidden directories
-        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); // Limit results for MVP
-        // Cache the results
-        directoryCache.set(dirPath, directories);
-        return directories;
-    }
-    catch (error) {
-        logError(error);
-        return [];
-    }
-}
-/**
- * Main function to get directory completion suggestions
- */
-export 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' },
-    }));
-}
-/**
- * Clears the directory cache
- */
-export function clearDirectoryCache() {
-    directoryCache.clear();
-}
-/**
- * Checks if a string looks like a path (starts with path-like prefixes)
- */
-export function isPathLikeToken(token) {
-    return (token.startsWith('~/') ||
-        token.startsWith('/') ||
-        token.startsWith('./') ||
-        token.startsWith('../') ||
-        token === '~' ||
-        token === '.' ||
-        token === '..');
-}
-/**
- * Scans a directory and returns both files and subdirectories
- * Uses LRU cache to avoid repeated filesystem calls
- */
-export 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) => {
-            // Sort directories first, then alphabetically
-            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 [];
-    }
-}
-/**
- * Get path completion suggestions for files and directories
- */
-export 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);
-    // Construct relative path based on original partialPath
-    // e.g., if partialPath is "src/c", directory portion is "src/"
-    // Strip leading "./" since it's just used for cwd search
-    // Handle both forward slash and platform separator for Windows compatibility
-    const hasSeparator = partialPath.includes('/') || partialPath.includes(sep);
-    let dirPortion = '';
-    if (hasSeparator) {
-        // Find the last separator (either / or platform-specific)
-        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 },
-        };
-    });
-}
-/**
- * Clears both directory and path caches
- */
-export function clearPathCache() {
-    directoryCache.clear();
-    pathCache.clear();
-}