@arnilo/prism-coding-agent 0.2.4 → 0.2.6

package/dist/repository/indexed-search.js

@@ -0,0 +1,313 @@
+/**
+ * Phase 26 Task 2: host-indexed repository search seam.
+ *
+ * `createIndexedRepositoryOperations` composes a host-owned incremental index
+ * backend with an existing literal `RepositoryOperations` fallback. `repo_search`
+ * stays bounded literal by default; `indexed_literal`/`semantic` modes are
+ * explicit and never fall back silently when the index is missing, stale, or
+ * failed. Index output is untrusted: every hit is containment-checked,
+ * bounded, and labeled `untrusted_index` on the result.
+ */
+import { isAbsolute, join, resolve } from "node:path";
+import { DEFAULT_MAX_INDEX_QUERY_TIMEOUT_MS, DEFAULT_MAX_INDEX_SNIPPET_BYTES, DEFAULT_MAX_INDEX_STALE_MAX_AGE_MS, DEFAULT_MAX_INDEX_UPDATE_BYTES, DEFAULT_MAX_INDEX_UPDATE_FILES, DEFAULT_MAX_REPO_RESULTS, HARD_MAX_INDEX_QUERY_TIMEOUT_MS, HARD_MAX_INDEX_SNIPPET_BYTES, HARD_MAX_INDEX_STALE_MAX_AGE_MS, HARD_MAX_INDEX_UPDATE_BYTES, HARD_MAX_INDEX_UPDATE_FILES, HARD_MAX_REPO_RESULTS, validateCodingLimit, } from "../limits.js";
+import { isPathInsideRoot } from "./path.js";
+export const INDEX_STATES = ["empty", "building", "ready", "stale", "failed"];
+export function resolveIndexLimits(options) {
+    return {
+        maxUpdateFiles: validateCodingLimit("maxUpdateFiles", options?.maxUpdateFiles ?? DEFAULT_MAX_INDEX_UPDATE_FILES, HARD_MAX_INDEX_UPDATE_FILES),
+        maxUpdateBytes: validateCodingLimit("maxUpdateBytes", options?.maxUpdateBytes ?? DEFAULT_MAX_INDEX_UPDATE_BYTES, HARD_MAX_INDEX_UPDATE_BYTES),
+        maxResults: validateCodingLimit("maxResults", options?.maxResults ?? DEFAULT_MAX_REPO_RESULTS, HARD_MAX_REPO_RESULTS),
+        maxSnippetBytes: validateCodingLimit("maxSnippetBytes", options?.maxSnippetBytes ?? DEFAULT_MAX_INDEX_SNIPPET_BYTES, HARD_MAX_INDEX_SNIPPET_BYTES),
+        staleMaxAgeMs: validateCodingLimit("staleMaxAgeMs", options?.staleMaxAgeMs ?? DEFAULT_MAX_INDEX_STALE_MAX_AGE_MS, HARD_MAX_INDEX_STALE_MAX_AGE_MS),
+        queryTimeoutMs: validateCodingLimit("queryTimeoutMs", options?.queryTimeoutMs ?? DEFAULT_MAX_INDEX_QUERY_TIMEOUT_MS, HARD_MAX_INDEX_QUERY_TIMEOUT_MS),
+    };
+}
+export class IndexError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "IndexError";
+    }
+}
+const MAX_IDENTITY_BYTES = 512;
+const MAX_REVISION_BYTES = 4096;
+function assertRelativeRepoPath(path) {
+    if (typeof path !== "string" || path.length === 0) {
+        throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported an invalid path");
+    }
+    if (path.startsWith("/") || path.includes("\\") || isAbsolute(path) || path === ".." || path.startsWith("../") || path.includes("/../")) {
+        throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported a path outside the repository");
+    }
+    return path;
+}
+function assertBoundedIdentity(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || Buffer.byteLength(value, "utf8") > MAX_IDENTITY_BYTES) {
+        throw new IndexError("ERR_PRISM_INDEX_LIMIT", `${label} exceeds the identity bound`);
+    }
+    return value;
+}
+function assertBoundedRevision(value) {
+    if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > MAX_REVISION_BYTES) {
+        throw new IndexError("ERR_PRISM_INDEX_LIMIT", "sourceRevision is required and bounded");
+    }
+    return value;
+}
+function truncateUtf8(value, maxBytes) {
+    if (Buffer.byteLength(value, "utf8") <= maxBytes)
+        return value;
+    let end = 0;
+    let bytes = 0;
+    for (const char of value) {
+        const size = Buffer.byteLength(char, "utf8");
+        if (bytes + size > maxBytes)
+            break;
+        bytes += size;
+        end += char.length;
+    }
+    return value.slice(0, end);
+}
+function isFresh(status, staleMaxAgeMs, requireSourceRevision) {
+    switch (status.state) {
+        case "failed":
+            return new IndexError("ERR_PRISM_INDEX_FAILED", "index is failed; no search is served");
+        case "empty":
+            return new IndexError("ERR_PRISM_INDEX_STALE", "index has no data; update it before querying");
+        case "building":
+            return new IndexError("ERR_PRISM_INDEX_STALE", "index is still building");
+        case "ready":
+        case "stale":
+            break;
+        default:
+            return new IndexError("ERR_PRISM_INDEX_FAILED", "index reported an unknown state");
+    }
+    if (status.updatedAt === undefined) {
+        return new IndexError("ERR_PRISM_INDEX_STALE", "index does not attest a freshness timestamp");
+    }
+    if (Date.now() - status.updatedAt > staleMaxAgeMs) {
+        return new IndexError("ERR_PRISM_INDEX_STALE", "index is stale; refresh it before querying");
+    }
+    if (requireSourceRevision && status.sourceRevision === undefined) {
+        return new IndexError("ERR_PRISM_INDEX_STALE", "index does not attest a source revision");
+    }
+    return null;
+}
+function isIndexMode(mode) {
+    return mode === "indexed_literal" || mode === "semantic";
+}
+/**
+ * Compose a host index with a literal fallback. Mode "literal" is routed to
+ * `fallback` unchanged; indexed modes are served only by the host backend with
+ * freshness checks, result validation, and no silent fallback.
+ */
+export function createIndexedRepositoryOperations(cwd, options) {
+    const allowed = new Set(options.allowedModes ?? ["literal"]);
+    const resolved = resolveIndexLimits(options.limits);
+    const staleMaxAgeMs = options.stale?.maxAgeMs ?? resolved.staleMaxAgeMs;
+    const requireSourceRevision = options.stale?.requireSourceRevision === true;
+    const root = resolve(cwd);
+    const backend = options.index;
+    async function checkFresh() {
+        let status;
+        try {
+            status = await backend.status();
+        }
+        catch {
+            throw new IndexError("ERR_PRISM_INDEX_FAILED", "index status failed");
+        }
+        const stale = isFresh(status, staleMaxAgeMs, requireSourceRevision);
+        if (stale)
+            throw stale;
+        return status;
+    }
+    function validateHit(hit, scope) {
+        const path = assertRelativeRepoPath(hit.path);
+        const absolute = join(root, ...path.split("/"));
+        if (!isPathInsideRoot(root, absolute)) {
+            throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported a path outside the repository root");
+        }
+        if (scope !== undefined && scope !== "." && path !== scope && !path.startsWith(`${scope}/`)) {
+            throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported a result outside the requested path scope");
+        }
+        if (typeof hit.score !== "number" || !Number.isFinite(hit.score) || hit.score < 0 || hit.score > 1) {
+            throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported an invalid score");
+        }
+        const snippet = typeof hit.snippet === "string" ? truncateUtf8(hit.snippet, resolved.maxSnippetBytes) : "";
+        return {
+            path,
+            line: 0,
+            column: 0,
+            text: snippet,
+            before: [],
+            after: [],
+            score: hit.score,
+        };
+    }
+    return {
+        async search(request) {
+            const mode = request.mode ?? "literal";
+            if (!isIndexMode(mode))
+                return options.fallback.search(request);
+            if (!allowed.has(mode)) {
+                throw new IndexError("ERR_PRISM_INDEX_UNSUPPORTED", `search mode ${mode} is not enabled on this composite`);
+            }
+            if (mode === "semantic" && backend.capabilities.semantic !== true) {
+                throw new IndexError("ERR_PRISM_INDEX_UNSUPPORTED", "semantic search is not supported by this index backend");
+            }
+            const status = await checkFresh();
+            let scope;
+            if (request.path !== undefined && request.path !== "" && request.path !== ".") {
+                scope = assertRelativeRepoPath(request.path);
+            }
+            const timeoutMs = Math.min(request.deadlineMs ?? resolved.queryTimeoutMs, resolved.queryTimeoutMs);
+            const deadlineAt = Date.now() + timeoutMs;
+            const maxResults = Math.min(resolved.maxResults, validateCodingLimit("maxMatches", request.maxMatches ?? resolved.maxResults, HARD_MAX_REPO_RESULTS));
+            let queryResult;
+            try {
+                queryResult = await Promise.race([
+                    backend.search({
+                        query: request.query,
+                        mode,
+                        path: scope,
+                        maxResults,
+                        signal: request.signal,
+                        deadlineMs: timeoutMs,
+                    }),
+                    new Promise((_, reject) => {
+                        const timer = setTimeout(() => reject(new IndexError("ERR_PRISM_INDEX_TIMEOUT", "index query timed out")), timeoutMs + 5);
+                        timer.unref();
+                    }),
+                ]);
+            }
+            catch (error) {
+                if (error instanceof IndexError)
+                    throw error;
+                if (request.signal?.aborted)
+                    throw new IndexError("ERR_PRISM_INDEX_TIMEOUT", "index query aborted");
+                throw new IndexError("ERR_PRISM_INDEX_FAILED", "index query failed");
+            }
+            if (Date.now() > deadlineAt) {
+                throw new IndexError("ERR_PRISM_INDEX_TIMEOUT", "index query exceeded the deadline");
+            }
+            const seen = new Set();
+            const matches = [];
+            for (const hit of queryResult.hits) {
+                if (matches.length >= maxResults)
+                    break;
+                const match = validateHit(hit, scope);
+                if (seen.has(match.path))
+                    continue; // duplicate paths: keep first
+                seen.add(match.path);
+                matches.push(match);
+            }
+            return {
+                matches,
+                truncated: queryResult.truncated || queryResult.hits.length > matches.length,
+                truncatedBy: queryResult.truncated || queryResult.hits.length > matches.length ? "index" : null,
+                scannedBytes: 0,
+                scannedFiles: 0,
+                scannedEntries: 0,
+                filesSkippedBinary: 0,
+                filesSkippedOversize: 0,
+                indexed: {
+                    mode,
+                    state: status.state,
+                    sourceRevision: status.sourceRevision,
+                    updatedAt: status.updatedAt,
+                },
+                untrusted_index: true,
+            };
+        },
+        list: (request) => options.fallback.list(request),
+        glob: (request) => options.fallback.glob(request),
+        index: {
+            async update(request) {
+                assertBoundedRevision(request.sourceRevision);
+                assertBoundedIdentity(request.repositoryId, "repositoryId");
+                assertBoundedIdentity(request.worktreeId, "worktreeId");
+                if (!Array.isArray(request.changes) || request.changes.length > resolved.maxUpdateFiles) {
+                    throw new IndexError("ERR_PRISM_INDEX_LIMIT", `update exceeds the ${resolved.maxUpdateFiles} change cap`);
+                }
+                let totalBytes = Buffer.byteLength(request.sourceRevision, "utf8");
+                const updates = [];
+                const removals = [];
+                for (const change of request.changes) {
+                    assertRelativeRepoPath(change.path);
+                    if (change.oldPath !== undefined)
+                        assertRelativeRepoPath(change.oldPath);
+                    if (change.bytes !== undefined && (typeof change.bytes !== "number" || !Number.isFinite(change.bytes) || change.bytes < 0)) {
+                        throw new IndexError("ERR_PRISM_INDEX_LIMIT", "change bytes must be a non-negative finite number");
+                    }
+                    totalBytes += Buffer.byteLength(change.path, "utf8") + (change.oldPath ? Buffer.byteLength(change.oldPath, "utf8") : 0);
+                    if (totalBytes > resolved.maxUpdateBytes) {
+                        throw new IndexError("ERR_PRISM_INDEX_LIMIT", `update exceeds the ${resolved.maxUpdateBytes} byte cap`);
+                    }
+                    if (change.kind === "delete") {
+                        removals.push(change.path);
+                    }
+                    else if (change.kind === "rename") {
+                        removals.push(change.oldPath);
+                        updates.push({ path: change.path, kind: "add", bytes: change.bytes });
+                    }
+                    else {
+                        updates.push(change);
+                    }
+                }
+                try {
+                    if (updates.length > 0)
+                        await backend.update({
+                            repositoryId: request.repositoryId,
+                            worktreeId: request.worktreeId,
+                            sourceRevision: request.sourceRevision,
+                            changes: updates,
+                        });
+                    if (removals.length > 0)
+                        await backend.remove({ paths: removals });
+                }
+                catch {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index update failed");
+                }
+            },
+            async remove(request) {
+                if (!Array.isArray(request.paths) || request.paths.length > resolved.maxUpdateFiles) {
+                    throw new IndexError("ERR_PRISM_INDEX_LIMIT", `remove exceeds the ${resolved.maxUpdateFiles} path cap`);
+                }
+                const paths = request.paths.map((p) => assertRelativeRepoPath(p));
+                try {
+                    await backend.remove({ paths });
+                }
+                catch {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index remove failed");
+                }
+            },
+            async status() {
+                let status;
+                try {
+                    status = await backend.status();
+                }
+                catch {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index status failed");
+                }
+                if (!INDEX_STATES.includes(status.state)) {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index reported an unknown state");
+                }
+                return status;
+            },
+            async dispose() {
+                try {
+                    await backend.dispose();
+                }
+                catch {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index dispose failed");
+                }
+            },
+        },
+    };
+}
+/** Stable repo-relative label used in errors; kept for tests and docs. */
+export function indexErrorCode(error) {
+    return error instanceof IndexError ? error.code : undefined;
+}
+//# sourceMappingURL=indexed-search.js.map

package/dist/repository/list.d.ts

@@ -0,0 +1,3 @@
+import type { RepositoryListRequest, RepositoryListResult, ResolvedRepositoryLimits } from "./types.js";
+import type { RepositoryWalk } from "./walk.js";
+export declare function listLocal(request: RepositoryListRequest, defaults: ResolvedRepositoryLimits, walk: RepositoryWalk): Promise<RepositoryListResult>;

package/dist/repository/list.js

@@ -0,0 +1,119 @@
+/** Repository list family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import { HARD_MAX_REPO_DEPTH, HARD_MAX_REPO_ENTRIES, HARD_MAX_REPO_RESULTS, validateCodingLimit, validateCodingLimitAllowZero, } from "../limits.js";
+import { lstat } from "node:fs/promises";
+import { RepositoryError } from "./types.js";
+import { resolveRepoPath } from "./path.js";
+export async function listLocal(request, defaults, walk) {
+    const resolved = await resolveRepoPath(request.root, request.path);
+    const maxResults = validateCodingLimit("maxResults", request.maxResults ?? defaults.maxResults, HARD_MAX_REPO_RESULTS);
+    const offset = validateCodingLimitAllowZero("offset", request.offset ?? 0, HARD_MAX_REPO_ENTRIES);
+    const maxDepth = validateCodingLimit("maxDepth", request.maxDepth ?? defaults.maxDepth, HARD_MAX_REPO_DEPTH);
+    const exclude = new Set(request.exclude ?? defaults.exclude);
+    const deadlineAt = request.deadlineMs !== undefined ? Date.now() + request.deadlineMs : Date.now() + defaults.maxTimeMs;
+    const collected = [];
+    let scannedEntries = 0;
+    let scannedFiles = 0;
+    let seen = 0;
+    let truncated = false;
+    let truncatedBy = null;
+    // Single-file start: return that entry when it falls within the page window.
+    try {
+        const startStat = await lstat(resolved.absolute);
+        if (!startStat.isDirectory()) {
+            let kind = "other";
+            if (startStat.isSymbolicLink())
+                kind = "symlink";
+            else if (startStat.isFile())
+                kind = "file";
+            const entry = kind === "file" ? { path: resolved.relative, kind, size: startStat.size } : { path: resolved.relative, kind };
+            scannedEntries = 1;
+            scannedFiles = kind === "file" ? 1 : 0;
+            if (offset === 0 && maxResults > 0)
+                collected.push(entry);
+            else if (offset === 0 && maxResults === 0) {
+                truncated = true;
+                truncatedBy = "results";
+            }
+            return {
+                entries: collected,
+                truncated,
+                truncatedBy,
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: undefined,
+            };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new RepositoryError(`cannot open path: ${message}`);
+    }
+    try {
+        for await (const event of walk(resolved.rootReal, resolved.absolute, {
+            maxDepth,
+            maxEntries: defaults.maxEntries,
+            maxFiles: defaults.maxFiles,
+            exclude,
+            includeHidden: request.includeHidden === true,
+            signal: request.signal,
+            deadlineAt,
+        })) {
+            if (event.type === "limit") {
+                truncated = true;
+                truncatedBy = event.truncatedBy;
+                break;
+            }
+            scannedEntries++;
+            if (event.entry.kind === "file")
+                scannedFiles++;
+            if (seen < offset) {
+                seen++;
+                continue;
+            }
+            if (collected.length >= maxResults) {
+                truncated = true;
+                truncatedBy = "results";
+                break;
+            }
+            collected.push(event.entry);
+            seen++;
+        }
+    }
+    catch (error) {
+        if (error instanceof RepositoryError && error.message === "Operation aborted") {
+            return {
+                entries: collected,
+                truncated: true,
+                truncatedBy: "abort",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: collected.length > 0 || offset > 0 ? offset + collected.length : undefined,
+            };
+        }
+        if (error instanceof RepositoryError && error.message === "Repository operation exceeded time limit") {
+            return {
+                entries: collected,
+                truncated: true,
+                truncatedBy: "time",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: offset + collected.length,
+            };
+        }
+        throw error;
+    }
+    return {
+        entries: collected,
+        truncated,
+        truncatedBy,
+        scannedEntries,
+        scannedFiles,
+        offset,
+        nextOffset: truncated ? offset + collected.length : undefined,
+    };
+}
+//# sourceMappingURL=list.js.map

package/dist/repository/operations.d.ts

@@ -0,0 +1,5 @@
+/** Repository operations family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import type { RepositoryLimitOptions, RepositoryOperations } from "./types.js";
+import type { RepositoryWalk } from "./walk.js";
+export declare function createLocalRepositoryOperations(limits?: RepositoryLimitOptions, walk?: RepositoryWalk): RepositoryOperations;

package/dist/repository/operations.js

@@ -0,0 +1,14 @@
+import { resolveRepositoryLimits } from "./types.js";
+import { walkRepository } from "./walk.js";
+import { globLocal } from "./glob.js";
+import { listLocal } from "./list.js";
+import { searchLocal } from "./search.js";
+export function createLocalRepositoryOperations(limits, walk = walkRepository) {
+    const resolved = resolveRepositoryLimits(limits);
+    return {
+        list: (request) => listLocal(request, resolved, walk),
+        search: (request) => searchLocal(request, resolved, walk),
+        glob: (request) => globLocal(request, resolved, walk),
+    };
+}
+//# sourceMappingURL=operations.js.map

package/dist/repository/path.d.ts

@@ -0,0 +1,18 @@
+import type { Dirent } from "node:fs";
+import type { RepoEntryKind } from "./types.js";
+export declare function toRepoRelative(root: string, absolutePath: string): string;
+export declare function isPathInsideRoot(root: string, target: string): boolean;
+/**
+ * Resolve a list/search start path under the workspace root.
+ * Symlink escapes fail closed after realpath when the path exists.
+ */
+export declare function resolveRepoPath(root: string, inputPath: string | undefined): Promise<{
+    absolute: string;
+    relative: string;
+    rootReal: string;
+}>;
+export declare function shouldSkipName(name: string, includeHidden: boolean, exclude: ReadonlySet<string>): boolean;
+export declare function kindFromDirent(dirent: Dirent): RepoEntryKind;
+export declare function assertNotAborted(signal: AbortSignal | undefined): void;
+export declare function assertDeadline(deadlineAt: number | undefined): void;
+export declare function isBinaryBuffer(buffer: Buffer): boolean;

package/dist/repository/path.js

@@ -0,0 +1,91 @@
+/** Repository path family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import { DEFAULT_BINARY_SNIFF_BYTES } from "../limits.js";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { realpath } from "node:fs/promises";
+import { resolveToCwd } from "../path-utils.js";
+import { RepositoryError } from "./types.js";
+export function toRepoRelative(root, absolutePath) {
+    const rel = relative(root, absolutePath);
+    if (rel === "")
+        return ".";
+    return rel.split(sep).join("/");
+}
+export function isPathInsideRoot(root, target) {
+    const from = resolve(root);
+    const to = resolve(target);
+    if (to === from)
+        return true;
+    const rel = relative(from, to);
+    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+/**
+ * Resolve a list/search start path under the workspace root.
+ * Symlink escapes fail closed after realpath when the path exists.
+ */
+export async function resolveRepoPath(root, inputPath) {
+    const rootResolved = resolve(root);
+    let rootReal;
+    try {
+        rootReal = await realpath(rootResolved);
+    }
+    catch {
+        throw new RepositoryError(`workspace root is missing or unreadable: ${rootResolved}`);
+    }
+    if (!inputPath || inputPath === "." || inputPath === "./") {
+        return { absolute: rootReal, relative: ".", rootReal };
+    }
+    const candidate = resolveToCwd(inputPath, rootReal);
+    if (!isPathInsideRoot(rootReal, candidate)) {
+        throw new RepositoryError(`path escapes workspace root: ${inputPath}`);
+    }
+    try {
+        const real = await realpath(candidate);
+        if (!isPathInsideRoot(rootReal, real)) {
+            throw new RepositoryError(`path resolves outside workspace root: ${inputPath}`);
+        }
+        return { absolute: real, relative: toRepoRelative(rootReal, real), rootReal };
+    }
+    catch (error) {
+        if (error instanceof RepositoryError)
+            throw error;
+        // ENOENT: allow listing a missing path to fail later with a clear error.
+        return { absolute: candidate, relative: toRepoRelative(rootReal, candidate), rootReal };
+    }
+}
+export function shouldSkipName(name, includeHidden, exclude) {
+    if (name === "." || name === "..")
+        return true;
+    if (exclude.has(name))
+        return true;
+    if (!includeHidden && name.startsWith("."))
+        return true;
+    return false;
+}
+export function kindFromDirent(dirent) {
+    if (dirent.isSymbolicLink())
+        return "symlink";
+    if (dirent.isDirectory())
+        return "directory";
+    if (dirent.isFile())
+        return "file";
+    return "other";
+}
+export function assertNotAborted(signal) {
+    if (signal?.aborted)
+        throw new RepositoryError("Operation aborted");
+}
+export function assertDeadline(deadlineAt) {
+    if (deadlineAt !== undefined && Date.now() >= deadlineAt) {
+        throw new RepositoryError("Repository operation exceeded time limit");
+    }
+}
+export function isBinaryBuffer(buffer) {
+    const length = Math.min(buffer.length, DEFAULT_BINARY_SNIFF_BYTES);
+    for (let i = 0; i < length; i++) {
+        if (buffer[i] === 0)
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=path.js.map

package/dist/repository/search.d.ts

@@ -0,0 +1,9 @@
+import type { RepositorySearchRequest, RepositorySearchResult, ResolvedRepositoryLimits } from "./types.js";
+import type { RepositoryWalk } from "./walk.js";
+export declare function compileSearchPattern(query: string, caseSensitive: boolean, maxPatternBytes: number): {
+    testLine: (line: string) => {
+        column: number;
+    } | null;
+    patternBytes: number;
+};
+export declare function searchLocal(request: RepositorySearchRequest, defaults: ResolvedRepositoryLimits, walk: RepositoryWalk): Promise<RepositorySearchResult>;