@xortex/xcode 3.0.0

package/utils/suggestions/directoryCompletion.ts

@@ -0,0 +1,263 @@
+import { LRUCache } from 'lru-cache'
+import { basename, dirname, join, sep } from 'path'
+import type { SuggestionItem } from 'src/components/PromptInput/PromptInputFooterSuggestions.js'
+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'
+// Types
+export type DirectoryEntry = {
+  name: string
+  path: string
+  type: 'directory'
+}
+
+export type PathEntry = {
+  name: string
+  path: string
+  type: 'directory' | 'file'
+}
+
+export type CompletionOptions = {
+  basePath?: string
+  maxResults?: number
+}
+
+export type PathCompletionOptions = CompletionOptions & {
+  includeFiles?: boolean
+  includeHidden?: boolean
+}
+
+type ParsedPath = {
+  directory: string
+  prefix: string
+}
+
+// Cache configuration
+const CACHE_SIZE = 500
+const CACHE_TTL = 5 * 60 * 1000 // 5 minutes
+
+// Initialize LRU cache for directory scans
+const directoryCache = new LRUCache<string, DirectoryEntry[]>({
+  max: CACHE_SIZE,
+  ttl: CACHE_TTL,
+})
+
+// Initialize LRU cache for path scans (files and directories)
+const pathCache = new LRUCache<string, PathEntry[]>({
+  max: CACHE_SIZE,
+  ttl: CACHE_TTL,
+})
+
+/**
+ * Parses a partial path into directory and prefix components
+ */
+export function parsePartialPath(
+  partialPath: string,
+  basePath?: string,
+): ParsedPath {
+  // 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: string,
+): Promise<DirectoryEntry[]> {
+  // 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' as const,
+      }))
+      .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: string,
+  options: CompletionOptions = {},
+): Promise<SuggestionItem[]> {
+  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' as const },
+  }))
+}
+
+/**
+ * Clears the directory cache
+ */
+export function clearDirectoryCache(): void {
+  directoryCache.clear()
+}
+
+/**
+ * Checks if a string looks like a path (starts with path-like prefixes)
+ */
+export function isPathLikeToken(token: string): boolean {
+  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: string,
+  includeHidden = false,
+): Promise<PathEntry[]> {
+  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' as const) : ('file' as const),
+      }))
+      .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: string,
+  options: PathCompletionOptions = {},
+): Promise<SuggestionItem[]> {
+  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(): void {
+  directoryCache.clear()
+  pathCache.clear()
+}

package/utils/suggestions/shellHistoryCompletion.ts

@@ -0,0 +1,119 @@
+import { getHistory } from '../../history.js'
+import { logForDebugging } from '../debug.js'
+
+/**
+ * Result of shell history completion lookup
+ */
+export type ShellHistoryMatch = {
+  /** The full command from history */
+  fullCommand: string
+  /** The suffix to display as ghost text (the part after user's input) */
+  suffix: string
+}
+
+// Cache for shell history commands to avoid repeated async reads
+// History only changes when user submits a command, so a long TTL is fine
+let shellHistoryCache: string[] | null = null
+let shellHistoryCacheTimestamp = 0
+const CACHE_TTL_MS = 60000 // 60 seconds - history won't change while typing
+
+/**
+ * Get shell commands from history, with caching
+ */
+async function getShellHistoryCommands(): Promise<string[]> {
+  const now = Date.now()
+
+  // Return cached result if still fresh
+  if (shellHistoryCache && now - shellHistoryCacheTimestamp < CACHE_TTL_MS) {
+    return shellHistoryCache
+  }
+
+  const commands: string[] = []
+  const seen = new Set<string>()
+
+  try {
+    // Read history entries and filter for bash commands
+    for await (const entry of getHistory()) {
+      if (entry.display && entry.display.startsWith('!')) {
+        // Remove the '!' prefix to get the actual command
+        const command = entry.display.slice(1).trim()
+        if (command && !seen.has(command)) {
+          seen.add(command)
+          commands.push(command)
+        }
+      }
+      // Limit to 50 most recent unique commands
+      if (commands.length >= 50) {
+        break
+      }
+    }
+  } catch (error) {
+    logForDebugging(`Failed to read shell history: ${error}`)
+  }
+
+  shellHistoryCache = commands
+  shellHistoryCacheTimestamp = now
+  return commands
+}
+
+/**
+ * Clear the shell history cache (useful when history is updated)
+ */
+export function clearShellHistoryCache(): void {
+  shellHistoryCache = null
+  shellHistoryCacheTimestamp = 0
+}
+
+/**
+ * Add a command to the front of the shell history cache without
+ * flushing the entire cache.  If the command already exists in the
+ * cache it is moved to the front (deduped).  When the cache hasn't
+ * been populated yet this is a no-op – the next lookup will read
+ * the full history which already includes the new command.
+ */
+export function prependToShellHistoryCache(command: string): void {
+  if (!shellHistoryCache) {
+    return
+  }
+  const idx = shellHistoryCache.indexOf(command)
+  if (idx !== -1) {
+    shellHistoryCache.splice(idx, 1)
+  }
+  shellHistoryCache.unshift(command)
+}
+
+/**
+ * Find the best matching shell command from history for the given input
+ *
+ * @param input The current user input (without '!' prefix)
+ * @returns The best match, or null if no match found
+ */
+export async function getShellHistoryCompletion(
+  input: string,
+): Promise<ShellHistoryMatch | null> {
+  // Don't suggest for empty or very short input
+  if (!input || input.length < 2) {
+    return null
+  }
+
+  // Check the trimmed input to make sure there's actual content
+  const trimmedInput = input.trim()
+  if (!trimmedInput) {
+    return null
+  }
+
+  const commands = await getShellHistoryCommands()
+
+  // Find the first command that starts with the EXACT input (including spaces)
+  // This ensures "ls " matches "ls -lah" but "ls  " (2 spaces) does not
+  for (const command of commands) {
+    if (command.startsWith(input) && command !== input) {
+      return {
+        fullCommand: command,
+        suffix: command.slice(input.length),
+      }
+    }
+  }
+
+  return null
+}

package/utils/suggestions/skillUsageTracking.ts

@@ -0,0 +1,55 @@
+import { getGlobalConfig, saveGlobalConfig } from '../config.js'
+
+const SKILL_USAGE_DEBOUNCE_MS = 60_000
+
+// Process-lifetime debounce cache — avoids lock + read + parse on debounced
+// calls. Same pattern as lastConfigStatTime / globalConfigWriteCount in config.ts.
+const lastWriteBySkill = new Map<string, number>()
+
+/**
+ * Records a skill usage for ranking purposes.
+ * Updates both usage count and last used timestamp.
+ */
+export function recordSkillUsage(skillName: string): void {
+  const now = Date.now()
+  const lastWrite = lastWriteBySkill.get(skillName)
+  // The ranking algorithm uses a 7-day half-life, so sub-minute granularity
+  // is irrelevant. Bail out before saveGlobalConfig to avoid lock + file I/O.
+  if (lastWrite !== undefined && 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,
+        },
+      },
+    }
+  })
+}
+
+/**
+ * Calculates a usage score for a skill based on frequency and recency.
+ * Higher scores indicate more frequently and recently used skills.
+ *
+ * The score uses exponential decay with a half-life of 7 days,
+ * meaning usage from 7 days ago is worth half as much as usage today.
+ */
+export function getSkillUsageScore(skillName: string): number {
+  const config = getGlobalConfig()
+  const usage = config.skillUsage?.[skillName]
+  if (!usage) return 0
+
+  // Recency decay: halve score every 7 days
+  const daysSinceUse = (Date.now() - usage.lastUsedAt) / (1000 * 60 * 60 * 24)
+  const recencyFactor = Math.pow(0.5, daysSinceUse / 7)
+
+  // Minimum recency factor of 0.1 to avoid completely dropping old but heavily used skills
+  return usage.usageCount * Math.max(recencyFactor, 0.1)
+}

package/utils/suggestions/slackChannelSuggestions.ts

@@ -0,0 +1,209 @@
+import { z } from 'zod'
+import type { SuggestionItem } from '../../components/PromptInput/PromptInputFooterSuggestions.js'
+import type { MCPServerConnection } from '../../services/mcp/types.js'
+import { logForDebugging } from '../debug.js'
+import { lazySchema } from '../lazySchema.js'
+import { createSignal } from '../signal.js'
+import { jsonParse } from '../slowOperations.js'
+
+const SLACK_SEARCH_TOOL = 'slack_search_channels'
+
+// Plain Map (not LRUCache) — findReusableCacheEntry needs to iterate all
+// entries for prefix matching, which LRUCache doesn't expose cleanly.
+const cache = new Map<string, string[]>()
+// Flat set of every channel name ever returned by MCP — used to gate
+// highlighting so only confirmed-real channels turn blue in the prompt.
+const knownChannels = new Set<string>()
+let knownChannelsVersion = 0
+const knownChannelsChanged = createSignal()
+export const subscribeKnownChannels = knownChannelsChanged.subscribe
+let inflightQuery: string | null = null
+let inflightPromise: Promise<string[]> | null = null
+
+function findSlackClient(
+  clients: MCPServerConnection[],
+): MCPServerConnection | undefined {
+  return clients.find(c => c.type === 'connected' && c.name.includes('slack'))
+}
+
+async function fetchChannels(
+  clients: MCPServerConnection[],
+  query: string,
+): Promise<string[]> {
+  const slackClient = findSlackClient(clients)
+  if (!slackClient || slackClient.type !== 'connected') {
+    return []
+  }
+
+  try {
+    const result = await slackClient.client.callTool(
+      {
+        name: SLACK_SEARCH_TOOL,
+        arguments: {
+          query,
+          limit: 20,
+          channel_types: 'public_channel,private_channel',
+        },
+      },
+      undefined,
+      { timeout: 5000 },
+    )
+
+    const content = result.content
+    if (!Array.isArray(content)) return []
+
+    const rawText = content
+      .filter((c): c is { type: 'text'; text: string } => c.type === 'text')
+      .map(c => c.text)
+      .join('\n')
+
+    return parseChannels(unwrapResults(rawText))
+  } catch (error) {
+    logForDebugging(`Failed to fetch Slack channels: ${error}`)
+    return []
+  }
+}
+
+// The Slack MCP server wraps its markdown in a JSON envelope:
+// {"results":"# Search Results...\nName: #chan\n..."}
+const resultsEnvelopeSchema = lazySchema(() =>
+  z.object({ results: z.string() }),
+)
+
+function unwrapResults(text: string): string {
+  const trimmed = text.trim()
+  if (!trimmed.startsWith('{')) return text
+  try {
+    const parsed = resultsEnvelopeSchema().safeParse(jsonParse(trimmed))
+    if (parsed.success) return parsed.data.results
+  } catch {
+    // jsonParse threw — fall through
+  }
+  return text
+}
+
+// Parse channel names from slack_search_channels text output.
+// The Slack MCP server returns markdown with "Name: #channel-name" lines.
+function parseChannels(text: string): string[] {
+  const channels: string[] = []
+  const seen = new Set<string>()
+
+  for (const line of text.split('\n')) {
+    const m = line.match(/^Name:\s*#?([a-z0-9][a-z0-9_-]{0,79})\s*$/)
+    if (m && !seen.has(m[1]!)) {
+      seen.add(m[1]!)
+      channels.push(m[1]!)
+    }
+  }
+
+  return channels
+}
+
+export function hasSlackMcpServer(clients: MCPServerConnection[]): boolean {
+  return findSlackClient(clients) !== undefined
+}
+
+export function getKnownChannelsVersion(): number {
+  return knownChannelsVersion
+}
+
+export function findSlackChannelPositions(
+  text: string,
+): Array<{ start: number; end: number }> {
+  const positions: Array<{ start: number; end: number }> = []
+  const re = /(^|\s)#([a-z0-9][a-z0-9_-]{0,79})(?=\s|$)/g
+  let m: RegExpExecArray | null
+  while ((m = re.exec(text)) !== null) {
+    if (!knownChannels.has(m[2]!)) continue
+    const start = m.index + m[1]!.length
+    positions.push({ start, end: start + 1 + m[2]!.length })
+  }
+  return positions
+}
+
+// Slack's search tokenizes on hyphens and requires whole-word matches, so
+// "claude-code-team-en" returns 0 results. Strip the trailing partial segment
+// so the MCP query is "claude-code-team" (complete words only), then filter
+// locally. This keeps the query maximally specific (avoiding the 20-result
+// cap) while never sending a partial word that kills the search.
+function mcpQueryFor(searchToken: string): string {
+  const lastSep = Math.max(
+    searchToken.lastIndexOf('-'),
+    searchToken.lastIndexOf('_'),
+  )
+  return lastSep > 0 ? searchToken.slice(0, lastSep) : searchToken
+}
+
+// Find a cached entry whose key is a prefix of mcpQuery and still has
+// matches for searchToken. Lets typing "c"→"cl"→"cla" reuse the "c" cache
+// instead of issuing a new MCP call per keystroke.
+function findReusableCacheEntry(
+  mcpQuery: string,
+  searchToken: string,
+): string[] | undefined {
+  let best: string[] | undefined
+  let bestLen = 0
+  for (const [key, channels] of cache) {
+    if (
+      mcpQuery.startsWith(key) &&
+      key.length > bestLen &&
+      channels.some(c => c.startsWith(searchToken))
+    ) {
+      best = channels
+      bestLen = key.length
+    }
+  }
+  return best
+}
+
+export async function getSlackChannelSuggestions(
+  clients: MCPServerConnection[],
+  searchToken: string,
+): Promise<SuggestionItem[]> {
+  if (!searchToken) return []
+
+  const mcpQuery = mcpQueryFor(searchToken)
+  const lower = searchToken.toLowerCase()
+
+  let channels = cache.get(mcpQuery) ?? findReusableCacheEntry(mcpQuery, lower)
+  if (!channels) {
+    if (inflightQuery === mcpQuery && inflightPromise) {
+      channels = await inflightPromise
+    } else {
+      inflightQuery = mcpQuery
+      inflightPromise = fetchChannels(clients, mcpQuery)
+      channels = await inflightPromise
+      cache.set(mcpQuery, channels)
+      const before = knownChannels.size
+      for (const c of channels) knownChannels.add(c)
+      if (knownChannels.size !== before) {
+        knownChannelsVersion++
+        knownChannelsChanged.emit()
+      }
+      if (cache.size > 50) {
+        cache.delete(cache.keys().next().value!)
+      }
+      if (inflightQuery === mcpQuery) {
+        inflightQuery = null
+        inflightPromise = null
+      }
+    }
+  }
+
+  return channels
+    .filter(c => c.startsWith(lower))
+    .sort()
+    .slice(0, 10)
+    .map(c => ({
+      id: `slack-channel-${c}`,
+      displayText: `#${c}`,
+    }))
+}
+
+export function clearSlackChannelCache(): void {
+  cache.clear()
+  knownChannels.clear()
+  knownChannelsVersion = 0
+  inflightQuery = null
+  inflightPromise = null
+}