@xortex/xcode 3.0.0

package/utils/memoize.ts

@@ -0,0 +1,269 @@
+import { LRUCache } from 'lru-cache'
+import { logError } from './log.js'
+import { jsonStringify } from './slowOperations.js'
+
+type CacheEntry<T> = {
+  value: T
+  timestamp: number
+  refreshing: boolean
+}
+
+type MemoizedFunction<Args extends unknown[], Result> = {
+  (...args: Args): Result
+  cache: {
+    clear: () => void
+  }
+}
+
+type LRUMemoizedFunction<Args extends unknown[], Result> = {
+  (...args: Args): Result
+  cache: {
+    clear: () => void
+    size: () => number
+    delete: (key: string) => boolean
+    get: (key: string) => Result | undefined
+    has: (key: string) => boolean
+  }
+}
+
+/**
+ * Creates a memoized function that returns cached values while refreshing in parallel.
+ * This implements a write-through cache pattern:
+ * - If cache is fresh, return immediately
+ * - If cache is stale, return the stale value but refresh it in the background
+ * - If no cache exists, block and compute the value
+ *
+ * @param f The function to memoize
+ * @param cacheLifetimeMs The lifetime of cached values in milliseconds
+ * @returns A memoized version of the function
+ */
+export function memoizeWithTTL<Args extends unknown[], Result>(
+  f: (...args: Args) => Result,
+  cacheLifetimeMs: number = 5 * 60 * 1000, // Default 5 minutes
+): MemoizedFunction<Args, Result> {
+  const cache = new Map<string, CacheEntry<Result>>()
+
+  const memoized = (...args: Args): Result => {
+    const key = jsonStringify(args)
+    const cached = cache.get(key)
+    const now = Date.now()
+
+    // Populate cache
+    if (!cached) {
+      const value = f(...args)
+      cache.set(key, {
+        value,
+        timestamp: now,
+        refreshing: false,
+      })
+      return value
+    }
+
+    // If we have a stale cache entry and it's not already refreshing
+    if (
+      cached &&
+      now - cached.timestamp > cacheLifetimeMs &&
+      !cached.refreshing
+    ) {
+      // Mark as refreshing to prevent multiple parallel refreshes
+      cached.refreshing = true
+
+      // Schedule async refresh (non-blocking). Both .then and .catch are
+      // identity-guarded: a concurrent cache.clear() + cold-miss stores a
+      // newer entry while this microtask is queued. .then overwriting with
+      // the stale refresh's result is worse than .catch deleting (persists
+      // wrong data for full TTL vs. self-correcting on next call).
+      Promise.resolve()
+        .then(() => {
+          const newValue = f(...args)
+          if (cache.get(key) === cached) {
+            cache.set(key, {
+              value: newValue,
+              timestamp: Date.now(),
+              refreshing: false,
+            })
+          }
+        })
+        .catch(e => {
+          logError(e)
+          if (cache.get(key) === cached) {
+            cache.delete(key)
+          }
+        })
+
+      // Return the stale value immediately
+      return cached.value
+    }
+
+    return cache.get(key)!.value
+  }
+
+  // Add cache clear method
+  memoized.cache = {
+    clear: () => cache.clear(),
+  }
+
+  return memoized
+}
+
+/**
+ * Creates a memoized async function that returns cached values while refreshing in parallel.
+ * This implements a write-through cache pattern for async functions:
+ * - If cache is fresh, return immediately
+ * - If cache is stale, return the stale value but refresh it in the background
+ * - If no cache exists, block and compute the value
+ *
+ * @param f The async function to memoize
+ * @param cacheLifetimeMs The lifetime of cached values in milliseconds
+ * @returns A memoized version of the async function
+ */
+export function memoizeWithTTLAsync<Args extends unknown[], Result>(
+  f: (...args: Args) => Promise<Result>,
+  cacheLifetimeMs: number = 5 * 60 * 1000, // Default 5 minutes
+): ((...args: Args) => Promise<Result>) & { cache: { clear: () => void } } {
+  const cache = new Map<string, CacheEntry<Result>>()
+  // In-flight cold-miss dedup. The old memoizeWithTTL (sync) accidentally
+  // provided this: it stored the Promise synchronously before the first
+  // await, so concurrent callers shared one f() invocation. This async
+  // variant awaits before cache.set, so concurrent cold-miss callers would
+  // each invoke f() independently without this map. For
+  // refreshAndGetAwsCredentials that means N concurrent `aws sso login`
+  // spawns. Same pattern as pending401Handlers in auth.ts:1171.
+  const inFlight = new Map<string, Promise<Result>>()
+
+  const memoized = async (...args: Args): Promise<Result> => {
+    const key = jsonStringify(args)
+    const cached = cache.get(key)
+    const now = Date.now()
+
+    // Populate cache - if this throws, nothing gets cached
+    if (!cached) {
+      const pending = inFlight.get(key)
+      if (pending) return pending
+      const promise = f(...args)
+      inFlight.set(key, promise)
+      try {
+        const result = await promise
+        // Identity-guard: cache.clear() during the await should discard this
+        // result (clear intent is to invalidate). If we're still in-flight,
+        // store it. clear() wipes inFlight too, so this check catches that.
+        if (inFlight.get(key) === promise) {
+          cache.set(key, {
+            value: result,
+            timestamp: now,
+            refreshing: false,
+          })
+        }
+        return result
+      } finally {
+        if (inFlight.get(key) === promise) {
+          inFlight.delete(key)
+        }
+      }
+    }
+
+    // If we have a stale cache entry and it's not already refreshing
+    if (
+      cached &&
+      now - cached.timestamp > cacheLifetimeMs &&
+      !cached.refreshing
+    ) {
+      // Mark as refreshing to prevent multiple parallel refreshes
+      cached.refreshing = true
+
+      // Schedule async refresh (non-blocking). Both .then and .catch are
+      // identity-guarded against a concurrent cache.clear() + cold-miss
+      // storing a newer entry while this refresh is in flight. .then
+      // overwriting with the stale refresh's result is worse than .catch
+      // deleting - wrong data persists for full TTL (e.g. credentials from
+      // the old awsAuthRefresh command after a settings change).
+      const staleEntry = cached
+      f(...args)
+        .then(newValue => {
+          if (cache.get(key) === staleEntry) {
+            cache.set(key, {
+              value: newValue,
+              timestamp: Date.now(),
+              refreshing: false,
+            })
+          }
+        })
+        .catch(e => {
+          logError(e)
+          if (cache.get(key) === staleEntry) {
+            cache.delete(key)
+          }
+        })
+
+      // Return the stale value immediately
+      return cached.value
+    }
+
+    return cache.get(key)!.value
+  }
+
+  // Add cache clear method. Also clear inFlight: clear() during a cold-miss
+  // await should not let the stale in-flight promise be returned to the next
+  // caller (defeats the purpose of clear). The try/finally above
+  // identity-guards inFlight.delete so the stale promise doesn't delete a
+  // fresh one if clear+cold-miss happens before the finally fires.
+  memoized.cache = {
+    clear: () => {
+      cache.clear()
+      inFlight.clear()
+    },
+  }
+
+  return memoized as ((...args: Args) => Promise<Result>) & {
+    cache: { clear: () => void }
+  }
+}
+
+/**
+ * Creates a memoized function with LRU (Least Recently Used) eviction policy.
+ * This prevents unbounded memory growth by evicting the least recently used entries
+ * when the cache reaches its maximum size.
+ *
+ * Note: Cache size for memoized message processing functions
+ * Chosen to prevent unbounded memory growth (was 300MB+ with lodash memoize)
+ * while maintaining good cache hit rates for typical conversations.
+ *
+ * @param f The function to memoize
+ * @returns A memoized version of the function with cache management methods
+ */
+export function memoizeWithLRU<
+  Args extends unknown[],
+  Result extends NonNullable<unknown>,
+>(
+  f: (...args: Args) => Result,
+  cacheFn: (...args: Args) => string,
+  maxCacheSize: number = 100,
+): LRUMemoizedFunction<Args, Result> {
+  const cache = new LRUCache<string, Result>({
+    max: maxCacheSize,
+  })
+
+  const memoized = (...args: Args): Result => {
+    const key = cacheFn(...args)
+    const cached = cache.get(key)
+    if (cached !== undefined) {
+      return cached
+    }
+
+    const result = f(...args)
+    cache.set(key, result)
+    return result
+  }
+
+  // Add cache management methods
+  memoized.cache = {
+    clear: () => cache.clear(),
+    size: () => cache.size,
+    delete: (key: string) => cache.delete(key),
+    // peek() avoids updating recency — we only want to observe, not promote
+    get: (key: string) => cache.peek(key),
+    has: (key: string) => cache.has(key),
+  }
+
+  return memoized
+}

package/utils/memory/types.ts

@@ -0,0 +1,12 @@
+import { feature } from 'bun:bundle'
+
+export const MEMORY_TYPE_VALUES = [
+  'User',
+  'Project',
+  'Local',
+  'Managed',
+  'AutoMem',
+  ...(feature('TEAMMEM') ? (['TeamMem'] as const) : []),
+] as const
+
+export type MemoryType = (typeof MEMORY_TYPE_VALUES)[number]

package/utils/memory/versions.ts

@@ -0,0 +1,8 @@
+import { findGitRoot } from '../git.js'
+
+// Note: This is used to check git repo status synchronously
+// Uses findGitRoot which walks the filesystem (no subprocess)
+// Prefer `dirIsInGitRepo()` for async checks
+export function projectIsInGitRepo(cwd: string): boolean {
+  return findGitRoot(cwd) !== null
+}

package/utils/memoryFileDetection.ts

@@ -0,0 +1,289 @@
+import { feature } from 'bun:bundle'
+import { normalize, posix, win32 } from 'path'
+import {
+  getAutoMemPath,
+  getMemoryBaseDir,
+  isAutoMemoryEnabled,
+  isAutoMemPath,
+} from '../memdir/paths.js'
+import { isAgentMemoryPath } from '../tools/AgentTool/agentMemory.js'
+import { getClaudeConfigHomeDir } from './envUtils.js'
+import {
+  posixPathToWindowsPath,
+  windowsPathToPosixPath,
+} from './windowsPaths.js'
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+const teamMemPaths = feature('TEAMMEM')
+  ? (require('../memdir/teamMemPaths.js') as typeof import('../memdir/teamMemPaths.js'))
+  : null
+/* eslint-enable @typescript-eslint/no-require-imports */
+
+const IS_WINDOWS = process.platform === 'win32'
+
+// Normalize path separators to posix (/). Does NOT translate drive encoding.
+function toPosix(p: string): string {
+  return p.split(win32.sep).join(posix.sep)
+}
+
+// Convert a path to a stable string-comparable form: forward-slash separated,
+// and on Windows, lowercased (Windows filesystems are case-insensitive).
+function toComparable(p: string): string {
+  const posixForm = toPosix(p)
+  return IS_WINDOWS ? posixForm.toLowerCase() : posixForm
+}
+
+/**
+ * Detects if a file path is a session-related file under ~/.claude.
+ * Returns the type of session file or null if not a session file.
+ */
+export function detectSessionFileType(
+  filePath: string,
+): 'session_memory' | 'session_transcript' | null {
+  const configDir = getClaudeConfigHomeDir()
+  // Compare in forward-slash form; on Windows also case-fold. The caller
+  // (isShellCommandTargetingMemory) converts MinGW /c/... → native before
+  // reaching here, so we only need separator + case normalization.
+  const normalized = toComparable(filePath)
+  const configDirCmp = toComparable(configDir)
+  if (!normalized.startsWith(configDirCmp)) {
+    return null
+  }
+  if (normalized.includes('/session-memory/') && normalized.endsWith('.md')) {
+    return 'session_memory'
+  }
+  if (normalized.includes('/projects/') && normalized.endsWith('.jsonl')) {
+    return 'session_transcript'
+  }
+  return null
+}
+
+/**
+ * Checks if a glob/pattern string indicates session file access intent.
+ * Used for Grep/Glob tools where we check patterns, not actual file paths.
+ */
+export function detectSessionPatternType(
+  pattern: string,
+): 'session_memory' | 'session_transcript' | null {
+  const normalized = pattern.split(win32.sep).join(posix.sep)
+  if (
+    normalized.includes('session-memory') &&
+    (normalized.includes('.md') || normalized.endsWith('*'))
+  ) {
+    return 'session_memory'
+  }
+  if (
+    normalized.includes('.jsonl') ||
+    (normalized.includes('projects') && normalized.includes('*.jsonl'))
+  ) {
+    return 'session_transcript'
+  }
+  return null
+}
+
+/**
+ * Check if a file path is within the memdir directory.
+ */
+export function isAutoMemFile(filePath: string): boolean {
+  if (isAutoMemoryEnabled()) {
+    return isAutoMemPath(filePath)
+  }
+  return false
+}
+
+export type MemoryScope = 'personal' | 'team'
+
+/**
+ * Determine which memory store (if any) a path belongs to.
+ *
+ * Team dir is a subdirectory of memdir (getTeamMemPath = join(getAutoMemPath, 'team')),
+ * so a team path matches both isTeamMemFile and isAutoMemFile. Check team first.
+ *
+ * Use this for scope-keyed telemetry where a single event name distinguishes
+ * by scope field — the existing tengu_memdir_* / tengu_team_mem_* event-name
+ * hierarchy handles the overlap differently (team writes intentionally fire both).
+ */
+export function memoryScopeForPath(filePath: string): MemoryScope | null {
+  if (feature('TEAMMEM') && teamMemPaths!.isTeamMemFile(filePath)) {
+    return 'team'
+  }
+  if (isAutoMemFile(filePath)) {
+    return 'personal'
+  }
+  return null
+}
+
+/**
+ * Check if a file path is within an agent memory directory.
+ */
+function isAgentMemFile(filePath: string): boolean {
+  if (isAutoMemoryEnabled()) {
+    return isAgentMemoryPath(filePath)
+  }
+  return false
+}
+
+/**
+ * Check if a file is a Claude-managed memory file (NOT user-managed instruction files).
+ * Includes: auto-memory (memdir), agent memory, session memory/transcripts.
+ * Excludes: CLAUDE.md, CLAUDE.local.md, .claude/rules/*.md (user-managed).
+ *
+ * Use this for collapse/badge logic where user-managed files should show full diffs.
+ */
+export function isAutoManagedMemoryFile(filePath: string): boolean {
+  if (isAutoMemFile(filePath)) {
+    return true
+  }
+  if (feature('TEAMMEM') && teamMemPaths!.isTeamMemFile(filePath)) {
+    return true
+  }
+  if (detectSessionFileType(filePath) !== null) {
+    return true
+  }
+  if (isAgentMemFile(filePath)) {
+    return true
+  }
+  return false
+}
+
+// Check if a directory path is a memory-related directory.
+// Used by Grep/Glob which take a directory `path` rather than a specific file.
+// Checks both configDir and memoryBaseDir to handle custom memory dir paths.
+export function isMemoryDirectory(dirPath: string): boolean {
+  // SECURITY: Normalize to prevent path traversal bypasses via .. segments.
+  // On Windows this produces backslashes; toComparable flips them back for
+  // string matching. MinGW /c/... paths are converted to native before
+  // reaching here (extraction-time in isShellCommandTargetingMemory), so
+  // normalize() never sees them.
+  const normalizedPath = normalize(dirPath)
+  const normalizedCmp = toComparable(normalizedPath)
+  // Agent memory directories can be under cwd (project scope), configDir, or memoryBaseDir
+  if (
+    isAutoMemoryEnabled() &&
+    (normalizedCmp.includes('/agent-memory/') ||
+      normalizedCmp.includes('/agent-memory-local/'))
+  ) {
+    return true
+  }
+  // Team memory directories live under <autoMemPath>/team/
+  if (
+    feature('TEAMMEM') &&
+    teamMemPaths!.isTeamMemoryEnabled() &&
+    teamMemPaths!.isTeamMemPath(normalizedPath)
+  ) {
+    return true
+  }
+  // Check the auto-memory path override (CLAUDE_COWORK_MEMORY_PATH_OVERRIDE)
+  if (isAutoMemoryEnabled()) {
+    const autoMemPath = getAutoMemPath()
+    const autoMemDirCmp = toComparable(autoMemPath.replace(/[/\\]+$/, ''))
+    const autoMemPathCmp = toComparable(autoMemPath)
+    if (
+      normalizedCmp === autoMemDirCmp ||
+      normalizedCmp.startsWith(autoMemPathCmp)
+    ) {
+      return true
+    }
+  }
+
+  const configDirCmp = toComparable(getClaudeConfigHomeDir())
+  const memoryBaseCmp = toComparable(getMemoryBaseDir())
+  const underConfig = normalizedCmp.startsWith(configDirCmp)
+  const underMemoryBase = normalizedCmp.startsWith(memoryBaseCmp)
+
+  if (!underConfig && !underMemoryBase) {
+    return false
+  }
+  if (normalizedCmp.includes('/session-memory/')) {
+    return true
+  }
+  if (underConfig && normalizedCmp.includes('/projects/')) {
+    return true
+  }
+  if (isAutoMemoryEnabled() && normalizedCmp.includes('/memory/')) {
+    return true
+  }
+  return false
+}
+
+/**
+ * Check if a shell command string (Bash or PowerShell) targets memory files
+ * by extracting absolute path tokens and checking them against memory
+ * detection functions. Used for Bash/PowerShell grep/search commands in the
+ * collapse logic.
+ */
+export function isShellCommandTargetingMemory(command: string): boolean {
+  const configDir = getClaudeConfigHomeDir()
+  const memoryBase = getMemoryBaseDir()
+  const autoMemDir = isAutoMemoryEnabled()
+    ? getAutoMemPath().replace(/[/\\]+$/, '')
+    : ''
+
+  // Quick check: does the command mention the config, memory base, or
+  // auto-mem directory? Compare in forward-slash form (PowerShell on Windows
+  // may use either separator while configDir uses the platform-native one).
+  // On Windows also check the MinGW form (/c/...) since BashTool runs under
+  // Git Bash which emits that encoding. On Linux/Mac, configDir is already
+  // posix so only one form to check — and crucially, windowsPathToPosixPath
+  // is NOT called, so Linux paths like /m/foo aren't misinterpreted as MinGW.
+  const commandCmp = toComparable(command)
+  const dirs = [configDir, memoryBase, autoMemDir].filter(Boolean)
+  const matchesAnyDir = dirs.some(d => {
+    if (commandCmp.includes(toComparable(d))) return true
+    if (IS_WINDOWS) {
+      // BashTool on Windows (Git Bash) emits /c/Users/... — check MinGW form too
+      return commandCmp.includes(windowsPathToPosixPath(d).toLowerCase())
+    }
+    return false
+  })
+  if (!matchesAnyDir) {
+    return false
+  }
+
+  // Extract absolute path-like tokens. Matches Unix absolute paths (/foo/bar),
+  // Windows drive-letter paths (C:\foo, C:/foo), and MinGW paths (/c/foo —
+  // they're /-prefixed so the regex already captures them). Bare backslash
+  // tokens (\foo) are intentionally excluded — they appear in regex/grep
+  // patterns and would cause false-positive memory classification after
+  // normalization flips backslashes to forward slashes.
+  const matches = command.match(/(?:[A-Za-z]:[/\\]|\/)[^\s'"]+/g)
+  if (!matches) {
+    return false
+  }
+
+  for (const match of matches) {
+    // Strip trailing shell metacharacters that could be adjacent to a path
+    const cleanPath = match.replace(/[,;|&>]+$/, '')
+    // On Windows, convert MinGW /c/... → native C:\... at this single
+    // point. Downstream predicates (isAutoManagedMemoryFile, isMemoryDirectory,
+    // isAutoMemPath, isAgentMemoryPath) then receive native paths and only
+    // need toComparable() for matching. On other platforms, paths are already
+    // native — no conversion, so /m/foo etc. pass through unmodified.
+    const nativePath = IS_WINDOWS
+      ? posixPathToWindowsPath(cleanPath)
+      : cleanPath
+    if (isAutoManagedMemoryFile(nativePath) || isMemoryDirectory(nativePath)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+// Check if a glob/pattern targets auto-managed memory files only.
+// Excludes CLAUDE.md, CLAUDE.local.md, .claude/rules/ (user-managed).
+// Used for collapse badge logic where user-managed files should not be
+// counted as "memory" operations.
+export function isAutoManagedMemoryPattern(pattern: string): boolean {
+  if (detectSessionPatternType(pattern) !== null) {
+    return true
+  }
+  if (
+    isAutoMemoryEnabled() &&
+    (pattern.replace(/\\/g, '/').includes('agent-memory/') ||
+      pattern.replace(/\\/g, '/').includes('agent-memory-local/'))
+  ) {
+    return true
+  }
+  return false
+}

package/utils/messagePredicates.ts

@@ -0,0 +1,8 @@
+import type { Message, UserMessage } from '../types/message.js'
+
+// tool_result messages share type:'user' with human turns; the discriminant
+// is the optional toolUseResult field. Four PRs (#23977, #24016, #24022,
+// #24025) independently fixed miscounts from checking type==='user' alone.
+export function isHumanTurn(m: Message): m is UserMessage {
+  return m.type === 'user' && !m.isMeta && m.toolUseResult === undefined
+}