@otto-code/server 0.5.0

package/dist/server/server/file-explorer/code-index.d.ts

@@ -0,0 +1,28 @@
+import { type CodeSymbol } from "@otto-code/highlight";
+export interface CodeSymbolLocation extends CodeSymbol {
+    path: string;
+}
+export declare function listWorkspaceFiles(root: string): Promise<{
+    files: string[];
+    truncated: boolean;
+}>;
+/**
+ * Outline for one file: parse the current buffer and extract definitions.
+ * Cheap enough to run per-request; no caching needed.
+ */
+export declare function getFileOutline(root: string, relativePath: string): Promise<CodeSymbolLocation[]>;
+/**
+ * Per-workspace symbol index. Lazily built and cached with a short TTL; an
+ * explicit `invalidate(root)` (fired on writes into that workspace) forces the
+ * next lookup to rebuild. A full rebuild is a bounded gitignore-aware walk —
+ * acceptable for v1 since lookups are user-initiated, not per-keystroke.
+ */
+export declare class WorkspaceSymbolIndex {
+    private readonly caches;
+    private readonly generations;
+    invalidate(root: string): void;
+    findSymbol(root: string, name: string): Promise<CodeSymbolLocation[]>;
+    private ensureIndex;
+    private buildIndex;
+}
+//# sourceMappingURL=code-index.d.ts.map

package/dist/server/server/file-explorer/code-index.js

@@ -0,0 +1,127 @@
+import { promises as fs } from "node:fs";
+import { extractSymbols, getParserForFile } from "@otto-code/highlight";
+import { readExplorerFile } from "./service.js";
+import { walkWorkspaceFiles } from "./gitignore.js";
+import { expandUserPath } from "../path-utils.js";
+// ctags-style navigation index. Two daemon-side services:
+//   - a gitignore-aware file listing for the fuzzy finder (client-side match);
+//   - a name → definition-locations map built by walking the same Lezer trees
+//     the highlighter uses, cached per workspace and rebuilt on demand.
+// Honest and name-based: no type resolution, so multiple hits are a picker,
+// not a guess.
+const MAX_LISTED_FILES = 20000;
+const MAX_INDEXED_FILES = 5000;
+const MAX_INDEXED_FILE_BYTES = 1000000;
+const INDEX_TTL_MS = 30000;
+export async function listWorkspaceFiles(root) {
+    const files = [];
+    const truncated = await walkWorkspaceFiles(expandUserPath(root), {
+        fileLimit: MAX_LISTED_FILES,
+        onFile: ({ relPath }) => {
+            files.push(relPath);
+        },
+    });
+    files.sort();
+    return { files, truncated };
+}
+/**
+ * Outline for one file: parse the current buffer and extract definitions.
+ * Cheap enough to run per-request; no caching needed.
+ */
+export async function getFileOutline(root, relativePath) {
+    const file = await readExplorerFile({ root, relativePath });
+    if (file.kind !== "text" || typeof file.content !== "string") {
+        return [];
+    }
+    return extractSymbols(file.content, file.path).map((symbol) => ({
+        name: symbol.name,
+        kind: symbol.kind,
+        line: symbol.line,
+        column: symbol.column,
+        path: file.path,
+    }));
+}
+/**
+ * Per-workspace symbol index. Lazily built and cached with a short TTL; an
+ * explicit `invalidate(root)` (fired on writes into that workspace) forces the
+ * next lookup to rebuild. A full rebuild is a bounded gitignore-aware walk —
+ * acceptable for v1 since lookups are user-initiated, not per-keystroke.
+ */
+export class WorkspaceSymbolIndex {
+    constructor() {
+        this.caches = new Map();
+        // Bumped by every invalidate; a build stamps the generation it started under
+        // and refuses to cache if an invalidation raced it, so a write during an
+        // in-flight build is never lost to a stale rebuild.
+        this.generations = new Map();
+    }
+    invalidate(root) {
+        const key = expandUserPath(root);
+        this.caches.delete(key);
+        this.generations.set(key, (this.generations.get(key) ?? 0) + 1);
+    }
+    async findSymbol(root, name) {
+        const index = await this.ensureIndex(expandUserPath(root));
+        return index.get(name) ?? [];
+    }
+    async ensureIndex(root) {
+        const cached = this.caches.get(root);
+        const now = Date.now();
+        if (cached && !cached.building && now - cached.builtAt < INDEX_TTL_MS) {
+            return cached.byName;
+        }
+        if (cached?.building) {
+            return cached.building;
+        }
+        const generation = this.generations.get(root) ?? 0;
+        const building = this.buildIndex(root);
+        this.caches.set(root, {
+            builtAt: now,
+            building,
+            byName: cached?.byName ?? new Map(),
+        });
+        const byName = await building;
+        // Only cache the result if no invalidation landed while we were building;
+        // otherwise the map reflects pre-write disk state and must not stick (a
+        // racing invalidate already dropped the cache entry, so the next lookup
+        // rebuilds against fresh disk state).
+        if ((this.generations.get(root) ?? 0) === generation) {
+            this.caches.set(root, { builtAt: Date.now(), building: null, byName });
+        }
+        return byName;
+    }
+    async buildIndex(root) {
+        const byName = new Map();
+        await walkWorkspaceFiles(root, {
+            fileLimit: MAX_INDEXED_FILES,
+            onFile: async ({ absPath, relPath }) => {
+                if (!getParserForFile(relPath)) {
+                    return;
+                }
+                let content;
+                try {
+                    const stats = await fs.stat(absPath);
+                    if (stats.size > MAX_INDEXED_FILE_BYTES) {
+                        return;
+                    }
+                    content = await fs.readFile(absPath, "utf-8");
+                }
+                catch {
+                    return;
+                }
+                for (const symbol of extractSymbols(content, relPath)) {
+                    const location = { ...symbol, path: relPath };
+                    const existing = byName.get(symbol.name);
+                    if (existing) {
+                        existing.push(location);
+                    }
+                    else {
+                        byName.set(symbol.name, [location]);
+                    }
+                }
+            },
+        });
+        return byName;
+    }
+}
+//# sourceMappingURL=code-index.js.map

package/dist/server/server/file-explorer/file-search.d.ts

@@ -0,0 +1,72 @@
+import type { FileSearchMatch } from "../messages.js";
+export interface FileSearchFileResult {
+    path: string;
+    hash: string;
+    matches: FileSearchMatch[];
+}
+export interface SearchWorkspaceOptions {
+    root: string;
+    query: string;
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+    regexp?: boolean;
+    include?: string;
+    exclude?: string;
+    onFileResult: (result: FileSearchFileResult) => void;
+    /** Flipped by the session when a newer search supersedes this one. */
+    signal: {
+        superseded: boolean;
+    };
+}
+export interface SearchWorkspaceOutcome {
+    status: "completed" | "truncated" | "superseded";
+    fileCount: number;
+    matchCount: number;
+}
+export declare class InvalidSearchQueryError extends Error {
+    constructor(message: string);
+}
+export declare function buildSearchRegex(options: {
+    query: string;
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+    regexp?: boolean;
+}): RegExp;
+export declare function searchWorkspaceFiles(options: SearchWorkspaceOptions): Promise<SearchWorkspaceOutcome>;
+export interface ReplaceFileInput {
+    path: string;
+    expectedHash: string;
+    matches: Array<{
+        line: number;
+        column: number;
+        length: number;
+    }>;
+}
+export type ReplaceFileOutcome = {
+    status: "ok";
+    path: string;
+    replacedCount: number;
+    modifiedAt: string;
+    hash: string;
+} | {
+    status: "skipped";
+    path: string;
+    reason: string;
+} | {
+    status: "error";
+    path: string;
+    message: string;
+};
+/**
+ * Applies preview-approved replacements. Every file preconditions on the hash
+ * the preview was built against — a changed file is skipped, never corrupted.
+ * Matches are applied bottom-up so coordinates stay valid, and the whole file
+ * goes through the same conditional-write path as editor saves (containment,
+ * EOL preservation, atomic replace).
+ */
+export declare function replaceInWorkspaceFiles(options: {
+    root: string;
+    replacement: string;
+    files: ReplaceFileInput[];
+}): Promise<ReplaceFileOutcome[]>;
+//# sourceMappingURL=file-search.d.ts.map

package/dist/server/server/file-explorer/file-search.js

@@ -0,0 +1,297 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { GitignoreStack, parseGitignore, readGitignoreRules, } from "./gitignore.js";
+import { readExplorerFile, writeExplorerFile } from "./service.js";
+import { expandUserPath } from "../path-utils.js";
+// Pure-JS project search: .gitignore-aware, size-capped, binary-sniffing,
+// yielding to the event loop between batches. Deliberately no ripgrep — the
+// constraint is nothing spawned; revisit only with performance evidence.
+const MAX_FILE_SIZE_BYTES = 1000000;
+const MAX_MATCHES_PER_FILE = 200;
+const MAX_TOTAL_MATCHES = 2000;
+const MAX_SCANNED_LINE_LENGTH = 10000;
+const PREVIEW_LENGTH = 240;
+const YIELD_EVERY_FILES = 25;
+export class InvalidSearchQueryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidSearchQueryError";
+    }
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function buildSearchRegex(options) {
+    const body = options.regexp ? options.query : escapeRegExp(options.query);
+    const wrapped = options.wholeWord ? `(?<!\\w)(?:${body})(?!\\w)` : body;
+    const flags = options.caseSensitive ? "g" : "gi";
+    try {
+        return new RegExp(wrapped, flags);
+    }
+    catch (error) {
+        throw new InvalidSearchQueryError(error instanceof Error ? error.message : "Invalid search pattern");
+    }
+}
+// Include/exclude globs reuse the gitignore pattern grammar; a slash-less
+// pattern matches basenames at any depth, exactly like a .gitignore line.
+function buildFilterRule(pattern) {
+    return parseGitignore(pattern, "");
+}
+function matchesFilter(rules, relPath) {
+    let matched = false;
+    for (const rule of rules) {
+        if (rule.regex.test(relPath)) {
+            matched = !rule.negated;
+        }
+    }
+    return matched;
+}
+function sha256Hex(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function isLikelyBinary(buffer) {
+    const sample = buffer.subarray(0, 8192);
+    if (sample.length === 0) {
+        return false;
+    }
+    let suspicious = 0;
+    for (let idx = 0; idx < sample.length; idx += 1) {
+        const byte = sample[idx];
+        if (byte === 0) {
+            return true;
+        }
+        if ((byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) || byte === 127) {
+            suspicious += 1;
+        }
+    }
+    return suspicious / sample.length > 0.3;
+}
+function buildPreview(line, matchIndex) {
+    if (line.length <= PREVIEW_LENGTH) {
+        return { lineText: line, previewStart: matchIndex };
+    }
+    const start = Math.max(0, Math.min(matchIndex - 60, line.length - PREVIEW_LENGTH));
+    return { lineText: line.slice(start, start + PREVIEW_LENGTH), previewStart: matchIndex - start };
+}
+function collectLineMatches(line, lineNumber, regex) {
+    const matches = [];
+    regex.lastIndex = 0;
+    for (let hit = regex.exec(line); hit !== null; hit = regex.exec(line)) {
+        const preview = buildPreview(line, hit.index);
+        matches.push({
+            line: lineNumber,
+            column: hit.index + 1,
+            length: hit[0].length,
+            lineText: preview.lineText,
+            previewStart: preview.previewStart,
+        });
+        if (hit[0].length === 0) {
+            // Zero-length matches (e.g. `a*`) would loop forever.
+            regex.lastIndex += 1;
+        }
+        if (matches.length >= MAX_MATCHES_PER_FILE) {
+            break;
+        }
+    }
+    return matches;
+}
+export async function searchWorkspaceFiles(options) {
+    const regex = buildSearchRegex(options);
+    const includeRules = options.include?.trim() ? buildFilterRule(options.include.trim()) : null;
+    const excludeRules = options.exclude?.trim() ? buildFilterRule(options.exclude.trim()) : null;
+    const root = await fs.realpath(expandUserPath(options.root));
+    const ignore = new GitignoreStack();
+    let fileCount = 0;
+    let matchCount = 0;
+    let scannedSinceYield = 0;
+    let truncated = false;
+    async function walk(frame) {
+        if (truncated || options.signal.superseded) {
+            return;
+        }
+        ignore.pushFrame(await readGitignoreRules(frame.absDir, frame.relDir));
+        try {
+            let dirents;
+            try {
+                dirents = await fs.readdir(frame.absDir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            // Files first so shallow matches stream before deep directories.
+            dirents.sort((a, b) => Number(a.isDirectory()) - Number(b.isDirectory()));
+            for (const dirent of dirents) {
+                if (truncated || options.signal.superseded) {
+                    return;
+                }
+                const relPath = frame.relDir ? `${frame.relDir}/${dirent.name}` : dirent.name;
+                if (dirent.isDirectory()) {
+                    if (dirent.name === ".git" || ignore.isIgnored(relPath, true)) {
+                        continue;
+                    }
+                    if (excludeRules && matchesFilter(excludeRules, relPath)) {
+                        continue;
+                    }
+                    await walk({ absDir: path.join(frame.absDir, dirent.name), relDir: relPath });
+                    continue;
+                }
+                if (!dirent.isFile()) {
+                    continue;
+                }
+                if (ignore.isIgnored(relPath, false)) {
+                    continue;
+                }
+                if (excludeRules && matchesFilter(excludeRules, relPath)) {
+                    continue;
+                }
+                if (includeRules && !matchesFilter(includeRules, relPath)) {
+                    continue;
+                }
+                scannedSinceYield += 1;
+                if (scannedSinceYield >= YIELD_EVERY_FILES) {
+                    scannedSinceYield = 0;
+                    await new Promise((resolve) => setImmediate(resolve));
+                }
+                await scanFile(path.join(frame.absDir, dirent.name), relPath);
+            }
+        }
+        finally {
+            ignore.popFrame();
+        }
+    }
+    async function scanFile(absPath, relPath) {
+        let bytes;
+        try {
+            const stats = await fs.stat(absPath);
+            if (!stats.isFile() || stats.size > MAX_FILE_SIZE_BYTES) {
+                return;
+            }
+            bytes = await fs.readFile(absPath);
+        }
+        catch {
+            return;
+        }
+        if (isLikelyBinary(bytes)) {
+            return;
+        }
+        const lines = bytes.toString("utf-8").split(/\r\n|\r|\n/);
+        const matches = [];
+        for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+            const line = lines[lineIndex];
+            if (line.length === 0 || line.length > MAX_SCANNED_LINE_LENGTH) {
+                continue;
+            }
+            matches.push(...collectLineMatches(line, lineIndex + 1, regex));
+            if (matches.length >= MAX_MATCHES_PER_FILE) {
+                break;
+            }
+        }
+        if (matches.length === 0) {
+            return;
+        }
+        const capped = matches.slice(0, Math.min(matches.length, MAX_TOTAL_MATCHES - matchCount));
+        if (capped.length === 0) {
+            truncated = true;
+            return;
+        }
+        fileCount += 1;
+        matchCount += capped.length;
+        options.onFileResult({ path: relPath, hash: sha256Hex(bytes), matches: capped });
+        if (matchCount >= MAX_TOTAL_MATCHES) {
+            truncated = true;
+        }
+    }
+    await walk({ absDir: root, relDir: "" });
+    if (options.signal.superseded) {
+        return { status: "superseded", fileCount, matchCount };
+    }
+    return { status: truncated ? "truncated" : "completed", fileCount, matchCount };
+}
+/**
+ * Applies preview-approved replacements. Every file preconditions on the hash
+ * the preview was built against — a changed file is skipped, never corrupted.
+ * Matches are applied bottom-up so coordinates stay valid, and the whole file
+ * goes through the same conditional-write path as editor saves (containment,
+ * EOL preservation, atomic replace).
+ */
+export async function replaceInWorkspaceFiles(options) {
+    const results = [];
+    for (const file of options.files) {
+        results.push(await replaceInFile(options.root, options.replacement, file));
+    }
+    return results;
+}
+async function replaceInFile(root, replacement, file) {
+    let text;
+    let modifiedAt;
+    try {
+        const readResult = await readTextForReplace(root, file);
+        if ("outcome" in readResult) {
+            return readResult.outcome;
+        }
+        text = readResult.text;
+        modifiedAt = readResult.modifiedAt;
+    }
+    catch (error) {
+        return {
+            status: "error",
+            path: file.path,
+            message: error instanceof Error ? error.message : "Failed to read file",
+        };
+    }
+    const lines = text.replace(/\r\n?/g, "\n").split("\n");
+    const ordered = [...file.matches].sort((a, b) => b.line - a.line || b.column - a.column);
+    for (const match of ordered) {
+        const line = lines[match.line - 1];
+        if (line === undefined || match.column - 1 + match.length > line.length) {
+            return {
+                status: "error",
+                path: file.path,
+                message: "Replacement coordinates no longer match the file",
+            };
+        }
+        lines[match.line - 1] =
+            line.slice(0, match.column - 1) + replacement + line.slice(match.column - 1 + match.length);
+    }
+    const outcome = await writeExplorerFile({
+        root,
+        relativePath: file.path,
+        content: lines.join("\n"),
+        expectedModifiedAt: modifiedAt,
+        expectedHash: file.expectedHash,
+    });
+    return mapWriteOutcome(file, outcome);
+}
+async function readTextForReplace(root, file) {
+    const read = await readExplorerFile({ root, relativePath: file.path });
+    if (read.kind !== "text" || typeof read.content !== "string") {
+        return {
+            outcome: { status: "skipped", path: file.path, reason: "Not a text file" },
+        };
+    }
+    if (read.hash !== file.expectedHash) {
+        return {
+            outcome: {
+                status: "skipped",
+                path: file.path,
+                reason: "File changed since the preview",
+            },
+        };
+    }
+    return { text: read.content, modifiedAt: read.modifiedAt };
+}
+function mapWriteOutcome(file, outcome) {
+    if (outcome.status === "ok") {
+        return {
+            status: "ok",
+            path: file.path,
+            replacedCount: file.matches.length,
+            modifiedAt: outcome.modifiedAt,
+            hash: outcome.hash,
+        };
+    }
+    // A write conflict here means the file changed between our read and write.
+    return { status: "skipped", path: file.path, reason: "File changed since the preview" };
+}
+//# sourceMappingURL=file-search.js.map

package/dist/server/server/file-explorer/file-watcher.d.ts

@@ -0,0 +1,40 @@
+import type pino from "pino";
+export interface FileWatchChange {
+    cwd: string;
+    path: string;
+    change: "changed" | "deleted" | "recreated";
+    modifiedAt: string | null;
+    hash: string | null;
+    size: number | null;
+}
+export interface SessionFileWatcherOptions {
+    emitEvent: (event: FileWatchChange) => void;
+    logger: pino.Logger;
+    pollIntervalMs?: number;
+    debounceMs?: number;
+}
+export declare class SessionFileWatcher {
+    private readonly emitEvent;
+    private readonly logger;
+    private readonly pollIntervalMs;
+    private readonly debounceMs;
+    private readonly entries;
+    private pollTimer;
+    constructor(options: SessionFileWatcherOptions);
+    /** Idempotent per (cwd, path). Throws on containment violations. */
+    subscribe(input: {
+        cwd: string;
+        path: string;
+    }): Promise<void>;
+    unsubscribe(input: {
+        cwd: string;
+        path: string;
+    }): void;
+    dispose(): void;
+    private cleanupEntry;
+    private startPolling;
+    private stopPolling;
+    private scheduleCheck;
+    private check;
+}
+//# sourceMappingURL=file-watcher.d.ts.map

package/dist/server/server/file-explorer/gitignore.d.ts

@@ -0,0 +1,39 @@
+export interface GitignoreRule {
+    regex: RegExp;
+    negated: boolean;
+    dirOnly: boolean;
+    /** POSIX dir (relative to the walk root, "" for root) the rule applies under. */
+    baseDir: string;
+}
+export declare function parseGitignore(content: string, baseDir: string): GitignoreRule[];
+/**
+ * Rule stack for a depth-first walk: rules from parent directories apply to
+ * everything beneath them, and the closest-then-latest matching rule wins.
+ */
+export declare class GitignoreStack {
+    private readonly rules;
+    private readonly frameSizes;
+    pushFrame(rules: GitignoreRule[]): void;
+    popFrame(): void;
+    /** `relPath` is POSIX, relative to the walk root, no leading slash. */
+    isIgnored(relPath: string, isDirectory: boolean): boolean;
+}
+export declare function readGitignoreRules(directory: string, baseDir: string): Promise<GitignoreRule[]>;
+export interface WalkWorkspaceOptions {
+    /** Called with each non-ignored file's absolute + workspace-relative path. */
+    onFile: (file: {
+        absPath: string;
+        relPath: string;
+    }) => Promise<void> | void;
+    /** Stop the walk early once this many files have been visited. */
+    fileLimit?: number;
+    /** Yield to the event loop every N files so a big tree can't block. */
+    yieldEvery?: number;
+}
+/**
+ * Depth-first, .gitignore-aware file walk shared by project search and the
+ * code index. Skips `.git`, applies parent-to-child gitignore precedence, and
+ * yields periodically. Returns true if the walk was truncated by `fileLimit`.
+ */
+export declare function walkWorkspaceFiles(root: string, options: WalkWorkspaceOptions): Promise<boolean>;
+//# sourceMappingURL=gitignore.d.ts.map