@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/ui/components/FileAutocomplete.js

@@ -1,14 +1,116 @@
 /**
  * FileAutocomplete - Autocomplete component for @ file references
  *
- * Provides file path suggestions when user types @ followed by a partial path.
+ * Provides project-wide fuzzy file suggestions when the user types @ followed
+ * by a partial path.
  * Inspired by Mistral Vibe CLI's file reference feature.
  */
-import React, { useState, useEffect, useMemo } from 'react';
+import React, { useMemo } from 'react';
 import { Box, Text } from 'ink';
-import fs from 'fs';
-import path from 'path';
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import ignore from 'ignore';
 import { useTheme } from '../context/theme-context.js';
+import { fuzzyMatch } from './FuzzyPicker.js';
+const PROJECT_INDEX_CACHE_TTL_MS = 5_000;
+const MAX_PROJECT_SUGGESTIONS = 50;
+const PROJECT_INDEX_IGNORES = [
+    '.git',
+    '.git/**',
+    '**/.git/**',
+    'node_modules',
+    'node_modules/**',
+    '**/node_modules/**',
+];
+const projectIndexCache = new Map();
+/** Clear the short-lived project index cache (primarily useful in tests). */
+export function clearFileSuggestionCache(cwd) {
+    if (cwd) {
+        projectIndexCache.delete(path.resolve(cwd));
+    }
+    else {
+        projectIndexCache.clear();
+    }
+}
+function toPosixPath(filePath) {
+    return filePath.split(path.sep).join('/');
+}
+function isHiddenPath(filePath) {
+    return filePath.split('/').some((segment) => segment.startsWith('.'));
+}
+function queryRequestsHiddenPath(query) {
+    return query.split('/').some((segment) => segment.startsWith('.'));
+}
+function readProjectIndex(cwd) {
+    const projectRoot = path.resolve(cwd);
+    const cached = projectIndexCache.get(projectRoot);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.suggestions;
+    const gitignore = ignore();
+    try {
+        gitignore.add(fs.readFileSync(path.join(projectRoot, '.gitignore'), 'utf8'));
+    }
+    catch {
+        // A project without a readable .gitignore is still safe to index.
+    }
+    const suggestions = [];
+    try {
+        const entries = fg.sync('**/*', {
+            cwd: projectRoot,
+            dot: true,
+            followSymbolicLinks: false,
+            ignore: PROJECT_INDEX_IGNORES,
+            objectMode: true,
+            onlyFiles: false,
+            suppressErrors: true,
+        });
+        for (const entry of entries) {
+            if (entry.dirent.isSymbolicLink())
+                continue;
+            const isDirectory = entry.dirent.isDirectory();
+            if (!isDirectory && !entry.dirent.isFile())
+                continue;
+            const relativePath = toPosixPath(entry.path);
+            try {
+                if (gitignore.ignores(isDirectory ? `${relativePath}/` : relativePath))
+                    continue;
+            }
+            catch {
+                // Malformed ignore rules must not break the input UI.
+            }
+            const name = path.posix.basename(relativePath);
+            const extension = isDirectory ? '' : path.posix.extname(name).toLowerCase();
+            suggestions.push({
+                name,
+                path: relativePath,
+                isDirectory,
+                extension: extension || undefined,
+            });
+        }
+    }
+    catch {
+        // An unreadable project produces no suggestions rather than breaking Ink.
+    }
+    projectIndexCache.set(projectRoot, {
+        expiresAt: Date.now() + PROJECT_INDEX_CACHE_TTL_MS,
+        suggestions,
+    });
+    return suggestions;
+}
+function scoreSuggestion(query, suggestion) {
+    if (!query) {
+        const depth = suggestion.path.split('/').length;
+        return (suggestion.isDirectory ? 500 : 1_000) - depth;
+    }
+    const pathScore = fuzzyMatch(query, suggestion.path);
+    const basenameQuery = query.split('/').pop() ?? query;
+    const nameScore = fuzzyMatch(basenameQuery, suggestion.name);
+    const boostedNameScore = nameScore < 0 ? -1 : nameScore + 75;
+    // Once a directory separator is typed, matching the whole relative path is
+    // required so an unrelated basename cannot jump into another directory.
+    return query.includes('/') ? pathScore : Math.max(pathScore, boostedNameScore);
+}
 /**
  * Extract the @ reference from input
  * Returns the partial path after @ if found
@@ -37,68 +139,32 @@ export function extractFileReference(input) {
  * Get file suggestions based on partial path
  */
 export function getFileSuggestions(partial, cwd = process.cwd()) {
-    const suggestions = [];
-    try {
-        let searchDir;
-        let prefix;
-        if (partial === '' || partial === '.') {
-            // List current directory
-            searchDir = cwd;
-            prefix = '';
-        }
-        else if (partial.startsWith('/')) {
-            // Absolute path
-            const lastSlash = partial.lastIndexOf('/');
-            searchDir = partial.slice(0, lastSlash + 1) || '/';
-            prefix = partial.slice(lastSlash + 1);
-        }
-        else if (partial.includes('/')) {
-            // Relative path with directories
-            const lastSlash = partial.lastIndexOf('/');
-            searchDir = path.join(cwd, partial.slice(0, lastSlash + 1));
-            prefix = partial.slice(lastSlash + 1);
-        }
-        else {
-            // Just a filename prefix in current directory
-            searchDir = cwd;
-            prefix = partial;
+    const normalizedPartial = partial.replace(/\\/g, '/').replace(/^\.\//, '');
+    const pathSegments = normalizedPartial.split('/');
+    if (path.isAbsolute(partial) || /^[a-zA-Z]:[\\/]/.test(partial) || pathSegments.includes('..')) {
+        return [];
+    }
+    const showHidden = queryRequestsHiddenPath(normalizedPartial);
+    return readProjectIndex(cwd)
+        .filter((suggestion) => showHidden || !isHiddenPath(suggestion.path))
+        .map((suggestion) => ({
+        suggestion,
+        score: scoreSuggestion(normalizedPartial, suggestion),
+    }))
+        .filter((candidate) => candidate.score >= 0)
+        .sort((a, b) => {
+        if (a.score !== b.score)
+            return b.score - a.score;
+        if (a.suggestion.isDirectory !== b.suggestion.isDirectory) {
+            return a.suggestion.isDirectory ? -1 : 1;
         }
-        if (!fs.existsSync(searchDir)) {
-            return suggestions;
+        if (a.suggestion.path.length !== b.suggestion.path.length) {
+            return a.suggestion.path.length - b.suggestion.path.length;
         }
-        const entries = fs.readdirSync(searchDir, { withFileTypes: true });
-        const lowerPrefix = prefix.toLowerCase();
-        for (const entry of entries) {
-            // Skip hidden files unless prefix starts with .
-            if (entry.name.startsWith('.') && !prefix.startsWith('.')) {
-                continue;
-            }
-            // Filter by prefix
-            if (!entry.name.toLowerCase().startsWith(lowerPrefix)) {
-                continue;
-            }
-            const fullPath = path.join(searchDir, entry.name);
-            const relativePath = path.relative(cwd, fullPath);
-            const ext = path.extname(entry.name).toLowerCase();
-            suggestions.push({
-                name: entry.name,
-                path: relativePath.startsWith('..') ? fullPath : relativePath,
-                isDirectory: entry.isDirectory(),
-                extension: ext || undefined,
-            });
-        }
-        // Sort: directories first, then by name
-        suggestions.sort((a, b) => {
-            if (a.isDirectory !== b.isDirectory) {
-                return a.isDirectory ? -1 : 1;
-            }
-            return a.name.localeCompare(b.name);
-        });
-    }
-    catch {
-        // Ignore filesystem errors
-    }
-    return suggestions;
+        return a.suggestion.path.localeCompare(b.suggestion.path);
+    })
+        .slice(0, MAX_PROJECT_SUGGESTIONS)
+        .map((candidate) => candidate.suggestion);
 }
 /**
  * Get icon for file type
@@ -132,21 +198,15 @@ function getFileIcon(suggestion) {
 /**
  * FileAutocomplete component
  */
-export const FileAutocomplete = React.memo(function FileAutocomplete({ input, visible, selectedIndex, maxSuggestions = 8, }) {
+export const FileAutocomplete = React.memo(function FileAutocomplete({ input, visible, selectedIndex, suggestions: providedSuggestions, maxSuggestions = 8, }) {
     const { colors } = useTheme();
-    const [suggestions, setSuggestions] = useState([]);
     // Extract file reference from input
     const { found, partial } = useMemo(() => extractFileReference(input), [input]);
-    // Update suggestions when partial changes
-    useEffect(() => {
-        if (found && visible) {
-            const newSuggestions = getFileSuggestions(partial);
-            setSuggestions(newSuggestions.slice(0, maxSuggestions));
-        }
-        else {
-            setSuggestions([]);
-        }
-    }, [found, partial, visible, maxSuggestions]);
+    const suggestions = useMemo(() => {
+        if (!found || !visible)
+            return [];
+        return (providedSuggestions ?? getFileSuggestions(partial)).slice(0, maxSuggestions);
+    }, [found, maxSuggestions, partial, providedSuggestions, visible]);
     if (!visible || !found || suggestions.length === 0) {
         return null;
     }

package/dist/ui/components/FuzzyPicker.d.ts

@@ -29,6 +29,11 @@ interface FuzzyPickerProps {
     highlightColor?: string;
     title?: string;
 }
+/**
+ * Simple fuzzy matching score
+ * Returns -1 if no match, otherwise a score (higher is better)
+ */
+export declare function fuzzyMatch(query: string, text: string): number;
 /**
  * Fuzzy Picker Component
  */

package/dist/ui/components/FuzzyPicker.js

@@ -10,7 +10,7 @@ import { Box, Text, useInput } from "ink";
  * Simple fuzzy matching score
  * Returns -1 if no match, otherwise a score (higher is better)
  */
-function fuzzyMatch(query, text) {
+export function fuzzyMatch(query, text) {
     if (!query)
         return 1; // Empty query matches everything
     const lowerQuery = query.toLowerCase();

package/dist/ui/http-server/server.js

@@ -109,7 +109,7 @@ export class HttpServer {
         try {
             const body = await this.readBody(req);
             const { message } = JSON.parse(body);
-            const entries = await this.agent.processUserMessage(message);
+            const entries = await this.agent.processUserMessage(message, { surface: 'http' });
             this.chatHistory.push(...entries);
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ entries }));
@@ -142,7 +142,7 @@ export class HttpServer {
             this.chatHistory.push(userEntry);
             res.write(`data: ${JSON.stringify({ type: 'user', entry: userEntry })}\n\n`);
             // Stream the response
-            for await (const chunk of this.agent.processUserMessageStream(message)) {
+            for await (const chunk of this.agent.processUserMessageStream(message, { surface: 'http' })) {
                 res.write(`data: ${JSON.stringify(chunk)}\n\n`);
                 if (chunk.type === 'content' && chunk.content) {
                     // Track content for history

package/dist/undo/checkpoint-manager.d.ts

@@ -83,7 +83,10 @@ export declare class CheckpointManager extends TypedEventEmitter<CheckpointEvent
     private workingDirectory;
     private autoCheckpointTimer;
     private dmp;
+    private readonly initialization;
     constructor(workingDirectory: string, config?: Partial<CheckpointConfig>);
+    /** Wait until persisted checkpoints are available to a command handler. */
+    waitUntilReady(): Promise<void>;
     /**
      * Initialize checkpoint manager
      */

package/dist/undo/checkpoint-manager.js

@@ -67,6 +67,7 @@ export class CheckpointManager extends TypedEventEmitter {
     workingDirectory;
     autoCheckpointTimer = null;
     dmp;
+    initialization;
     constructor(workingDirectory, config = {}) {
         super();
         this.config = { ...DEFAULT_CONFIG, ...config };
@@ -74,7 +75,11 @@ export class CheckpointManager extends TypedEventEmitter {
         this.dataDir = path.join(os.homedir(), '.codebuddy', 'checkpoints');
         this.checkpointsDir = path.join(this.dataDir, this.hashPath(workingDirectory));
         this.dmp = new diff_match_patch();
-        this.initialize();
+        this.initialization = this.initialize();
+    }
+    /** Wait until persisted checkpoints are available to a command handler. */
+    async waitUntilReady() {
+        await this.initialization;
     }
     /**
      * Initialize checkpoint manager

package/dist/utils/approval-pattern-tracker.js

@@ -3,9 +3,8 @@
  * After N identical approvals (default 3), auto-approves silently.
  * Persisted to .codebuddy/approval-patterns.json.
  */
-import { readFile, writeFile, mkdir } from 'fs/promises';
 import { join } from 'path';
-import { existsSync } from 'fs';
+import { readJsonAtomic, writeJsonAtomic } from './atomic-write.js';
 import { logger } from './logger.js';
 const DEFAULT_THRESHOLD = 3;
 const PATTERNS_FILE = '.codebuddy/approval-patterns.json';
@@ -93,12 +92,9 @@ export class ApprovalPatternTracker {
         this.loaded = true;
         const filePath = join(this.cwd, PATTERNS_FILE);
         try {
-            if (existsSync(filePath)) {
-                const content = await readFile(filePath, 'utf-8');
-                const data = JSON.parse(content);
-                for (const p of data) {
-                    this.patterns.set(this.getKey(p.tool, p.argsPattern), p);
-                }
+            const data = await readJsonAtomic(filePath, []);
+            for (const p of data) {
+                this.patterns.set(this.getKey(p.tool, p.argsPattern), p);
             }
         }
         catch (err) {
@@ -108,12 +104,8 @@ export class ApprovalPatternTracker {
     async save() {
         const filePath = join(this.cwd, PATTERNS_FILE);
         try {
-            const dir = join(this.cwd, '.codebuddy');
-            if (!existsSync(dir)) {
-                await mkdir(dir, { recursive: true });
-            }
             const data = [...this.patterns.values()];
-            await writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+            await writeJsonAtomic(filePath, data);
         }
         catch (err) {
             logger.debug(`Failed to save approval patterns: ${err instanceof Error ? err.message : String(err)}`);

package/dist/utils/ascii-banner.d.ts

@@ -1,6 +1,6 @@
 /**
  * Simple ASCII Banner Generator
- * MIT Licensed alternative to cfonts (GPL-3.0)
+ * In-house alternative to cfonts (GPL-3.0) — avoids any GPL dependency.
  *
  * Provides basic ASCII art text rendering without GPL license concerns.
  */

package/dist/utils/ascii-banner.js

@@ -1,6 +1,6 @@
 /**
  * Simple ASCII Banner Generator
- * MIT Licensed alternative to cfonts (GPL-3.0)
+ * In-house alternative to cfonts (GPL-3.0) — avoids any GPL dependency.
  *
  * Provides basic ASCII art text rendering without GPL license concerns.
  */

package/dist/utils/atomic-write.d.ts

@@ -0,0 +1,77 @@
+type AtomicData = string | Uint8Array;
+export interface AtomicWriteFileHandle {
+    writeFile(data: AtomicData, options?: {
+        encoding?: BufferEncoding;
+    }): Promise<void>;
+    sync(): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Small injectable filesystem surface. The seam makes interruption tests
+ * deterministic without replacing the process-wide fs implementation.
+ */
+export interface AtomicWriteFileSystem {
+    mkdir(directory: string, options: {
+        recursive?: boolean;
+    }): Promise<void>;
+    open(filePath: string, flags: string, mode: number): Promise<AtomicWriteFileHandle>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(filePath: string): Promise<void>;
+    chmod(filePath: string, mode: number): Promise<void>;
+    readdir(directory: string): Promise<string[]>;
+    stat(filePath: string): Promise<{
+        mtimeMs: number;
+    }>;
+}
+export interface AtomicWriteOptions {
+    /** State files default to owner-only permissions. */
+    mode?: number;
+    fileSystem?: AtomicWriteFileSystem;
+}
+export interface AtomicReadOptions<T> extends AtomicWriteOptions {
+    isValid?: (value: unknown) => value is T;
+}
+/** Write a file through a same-directory temporary file and durable rename. */
+export declare function writeFileAtomic(filePath: string, data: AtomicData, options?: AtomicWriteOptions): Promise<void>;
+export declare function writeJsonAtomic<T>(filePath: string, value: T, options?: AtomicWriteOptions): Promise<void>;
+/** Synchronous counterpart for legacy companion/configuration code paths. */
+export declare function writeFileAtomicSync(filePath: string, data: AtomicData, options?: Pick<AtomicWriteOptions, 'mode'>): void;
+export declare function writeJsonAtomicSync<T>(filePath: string, value: T, options?: Pick<AtomicWriteOptions, 'mode'>): void;
+/** Read JSON state defensively, recovering a valid .bak or temporary file. */
+export declare function readJsonAtomic<T>(filePath: string, fallback: T, options?: AtomicReadOptions<T>): Promise<T>;
+/** Synchronous JSON reader with the same empty/corrupt recovery policy. */
+export declare function readJsonAtomicSync<T>(filePath: string, fallback: T, options?: Pick<AtomicReadOptions<T>, 'mode' | 'isValid'>): T;
+/** Synchronous text reader with the same empty/corrupt recovery policy. */
+export declare function readTextAtomicSync(filePath: string, fallback: string, options?: Pick<AtomicWriteOptions, 'mode'>): string;
+/** Synchronous counterpart for append-only JSONL state files. */
+export declare function readJsonLinesAtomicSync<T>(filePath: string, fallback: T[], isValid: (value: unknown) => value is T): T[];
+/** Read text state defensively, recovering a valid .bak or temporary file. */
+export declare function readTextAtomic(filePath: string, fallback: string, options?: AtomicWriteOptions): Promise<string>;
+/** Read an append-only JSONL state file, skipping a torn/invalid line once. */
+export declare function readJsonLinesAtomic<T>(filePath: string, fallback: T[], isValid: (value: unknown) => value is T): Promise<T[]>;
+/** Reset the process-local warning guard; intended for isolated tests. */
+export declare function resetAtomicReadWarningsForTests(): void;
+export interface CleanupOrphanedTemporariesOptions extends AtomicWriteOptions {
+    /**
+     * A temporary older than this (in ms) is considered orphaned and removed.
+     * Defaults to 5 minutes — comfortably longer than any single write, short
+     * enough to reclaim leaked files left by a process killed mid-write
+     * (e.g. SIGTERM between `open` and `rename`).
+     */
+    maxAgeMs?: number;
+    /** Injectable clock, for deterministic tests. */
+    now?: () => number;
+}
+/**
+ * Remove stale `<filePath>.tmp.*` (and legacy `<filePath>.tmp`) siblings left
+ * behind in the same directory as `filePath` by a writer that never reached
+ * `rename` (killed between `open` and `rename`, or a crash). Never touches
+ * `filePath` itself. Intended to run once at startup for any state file
+ * written through `writeFileAtomic`/`writeJsonAtomic`. Best-effort: read or
+ * unlink failures on individual candidates are swallowed so one bad entry
+ * never blocks the others.
+ */
+export declare function cleanupOrphanedTemporaries(filePath: string, options?: CleanupOrphanedTemporariesOptions): Promise<string[]>;
+/** Reset the process-local cleanup-warning guard; intended for isolated tests. */
+export declare function resetAtomicCleanupWarningsForTests(): void;
+export {};