@oscharko-dev/keiko-workspace 0.2.0

package/dist/repoSearch.js

@@ -0,0 +1,350 @@
+// Governed, deterministic, audit-friendly repository search facade (Epic #177, Issue #179).
+// Composes the existing workspace primitives — discovery, deny policy, realpath gate,
+// readWorkspaceFile, plus the new binaryDetect and stableId modules — into three public
+// APIs that emit normalized EvidenceAtom output: searchText, findFiles, readExcerpt.
+// Pure JS (no subprocess, no ripgrep — deferred). Every fs touch goes through the
+// WorkspaceFs port. Stable IDs are reproducible across runs given the same inputs.
+import { isValidScopePath, validateRetrievalQuery, } from "@oscharko-dev/keiko-contracts/connected-context";
+import { readWorkspaceFile } from "./discovery.js";
+import { RepoSearchInvalidQueryError, RepoSearchInvalidRangeError, RepoSearchUnsupportedFileError, } from "./errors.js";
+import { nodeWorkspaceFs } from "./fs.js";
+import { isDenied } from "./ignore.js";
+import { resolveWithinWorkspace } from "./paths.js";
+import { containedRealPathInfo } from "./realpath.js";
+import { buildMatcher, compileGlob, fingerprintFor } from "./repoSearchMatchers.js";
+import { buildAtom, buildCandidate, elapsed, gatherCandidates, hitLimit, isImageScopePath, isIoError, probeBinary, scanFile, } from "./repoSearchScan.js";
+import { policyOmissionReason, resolveSearchPolicy, } from "./repoSearchPolicy.js";
+export const DEFAULT_SEARCH_LIMITS = {
+    maxFilesScanned: 2_000,
+    maxMatchesReturned: 200,
+    maxBytesPerFileScanned: 524_288,
+    elapsedMsMax: 5_000,
+};
+// Upper bound (2 MiB) on how many bytes of a file readExcerpt will load to reach a requested line
+// window. The returned excerpt content is still clamped to the caller's request.maxBytes; this cap
+// only governs how deep into a file we can slice. Decoupling it from request.maxBytes lets excerpts
+// be read from files far larger than a single excerpt budget (a 16 KiB doc was previously unreadable
+// and crashed the grounded request — Epic #177). Kept in step with the planner's 2 MiB scan cap so
+// any file the search can match can also be excerpted. Files larger than this raise
+// FileTooLargeError, which callers handle as a graceful omission.
+const MAX_EXCERPT_FILE_BYTES = 2_097_152;
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+function clampToBytes(text, maxBytes) {
+    if (maxBytes <= 0) {
+        return { excerpt: "", truncated: true };
+    }
+    const encoded = new TextEncoder().encode(text);
+    if (encoded.length <= maxBytes) {
+        return { excerpt: text, truncated: false };
+    }
+    const buffer = encoded.subarray(0, maxBytes);
+    const excerpt = new TextDecoder("utf-8", { fatal: false }).decode(buffer).replace(/�+$/u, "");
+    return { excerpt, truncated: true };
+}
+function assertQuery(query) {
+    const result = validateRetrievalQuery(query);
+    if (!result.ok) {
+        throw new RepoSearchInvalidQueryError(`query invalid: ${result.reasons.join(", ")}`);
+    }
+}
+function assertWorkspaceRoot(workspace) {
+    if (workspace.root.length === 0) {
+        throw new RepoSearchInvalidQueryError("scope.workspace.root is empty");
+    }
+}
+function isAborted(signal) {
+    return signal?.aborted === true;
+}
+function abortedSearchResult(elapsedMs) {
+    return {
+        atoms: [],
+        candidates: [],
+        filesScanned: 0,
+        elapsedMs,
+        truncated: true,
+        diagnostics: undefined,
+    };
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+// Yields to the event loop every SCAN_YIELD_INTERVAL files so a large cold NFS/SMB workspace
+// cannot block the event loop for multiple seconds. discoverFiles() itself remains synchronous
+// (sync walk is load-bearing for importGraph/testSourcePairing callers); the yield here covers
+// the already-async per-file scan pass where the loop overhead is measurable.
+const SCAN_YIELD_INTERVAL = 64;
+function buildSearchTextRunner(scope, query, limits, deps) {
+    return {
+        scope,
+        limits: {
+            ...limits,
+            maxMatchesReturned: Math.min(limits.maxMatchesReturned, query.maxResults),
+        },
+        fs: deps.fs,
+        nowMs: deps.nowMs,
+        startMs: deps.nowMs(),
+        signal: deps.signal,
+        matcher: buildMatcher(query),
+        fingerprint: fingerprintFor(query),
+        policy: resolveSearchPolicy(scope.relativePaths.length > 0, deps.searchHints),
+        query,
+    };
+}
+async function runScanLoop(runner, candidateSet, state, atoms, candidates) {
+    let loopIndex = 0;
+    for (const file of candidateSet.files) {
+        if (hitLimit(runner, state)) {
+            break;
+        }
+        loopIndex += 1;
+        if (loopIndex % SCAN_YIELD_INTERVAL === 0) {
+            await new Promise((resolve) => {
+                setImmediate(resolve);
+            });
+            if (hitLimit(runner, state)) {
+                break;
+            }
+        }
+        await scanFile(runner, file, state, atoms, candidates);
+    }
+}
+export async function searchText(scope, query, limits = DEFAULT_SEARCH_LIMITS, deps = {}) {
+    assertWorkspaceRoot(scope.workspace);
+    assertQuery(query);
+    if (query.kind === "file-pattern") {
+        throw new RepoSearchInvalidQueryError("searchText does not accept file-pattern queries");
+    }
+    const fs = deps.fs ?? nodeWorkspaceFs;
+    const nowMs = deps.nowMs ?? Date.now;
+    const runner = buildSearchTextRunner(scope, query, limits, {
+        fs,
+        nowMs,
+        ...(deps.searchHints !== undefined ? { searchHints: deps.searchHints } : {}),
+        ...(deps.signal !== undefined ? { signal: deps.signal } : {}),
+    });
+    if (isAborted(deps.signal)) {
+        return abortedSearchResult(elapsed(runner));
+    }
+    const candidateSet = gatherCandidates(scope, query, limits, fs, runner.policy);
+    if (isAborted(deps.signal)) {
+        return { ...abortedSearchResult(elapsed(runner)), diagnostics: candidateSet.diagnostics };
+    }
+    const atoms = [];
+    const candidates = [];
+    // Seed truncated from candidate gathering so a scope.relativePaths cap is preserved.
+    const state = {
+        filesScanned: 0,
+        matchesReturned: 0,
+        truncated: candidateSet.truncated,
+    };
+    await runScanLoop(runner, candidateSet, state, atoms, candidates);
+    return {
+        atoms,
+        candidates,
+        filesScanned: state.filesScanned,
+        elapsedMs: elapsed(runner),
+        truncated: state.truncated,
+        diagnostics: candidateSet.diagnostics,
+    };
+}
+function emitFileListing(ctx, relativePath, atoms) {
+    atoms.push(buildAtom({
+        scopeId: ctx.scope.scopeId,
+        scopePath: relativePath,
+        lineRange: undefined,
+        provenanceKind: "file-listing",
+        tool: "repo.findFiles",
+        queryFingerprint: ctx.fingerprint,
+        score: 1,
+        emittedAtMs: ctx.nowMs(),
+    }));
+}
+function hitFileListingLimit(state, maxMatches, startMs, nowMs, limits, signal) {
+    return (isAborted(signal) ||
+        state.atoms.length >= maxMatches ||
+        nowMs() - startMs > limits.elapsedMsMax);
+}
+function collectFileListings(ctx, candidateSet, policy, inputs) {
+    const state = {
+        atoms: [],
+        candidates: [],
+        filesScanned: 0,
+        truncated: candidateSet.truncated,
+    };
+    for (const file of candidateSet.files) {
+        if (hitFileListingLimit(state, inputs.maxMatches, inputs.startMs, ctx.nowMs, inputs.limits, inputs.signal)) {
+            state.truncated = true;
+            break;
+        }
+        if (isDenied(file.relativePath)) {
+            state.candidates.push(buildCandidate(file.relativePath, "ignored"));
+            continue;
+        }
+        const omitted = policyOmissionReason(file.relativePath, policy);
+        if (omitted !== undefined) {
+            state.candidates.push(buildCandidate(file.relativePath, omitted));
+            continue;
+        }
+        state.filesScanned += 1;
+        if (ctx.regex.test(file.relativePath)) {
+            emitFileListing(ctx, file.relativePath, state.atoms);
+        }
+    }
+    return state;
+}
+function findFilesSync(scope, query, limits, fs, nowMs, hints, signal) {
+    const startMs = nowMs();
+    if (isAborted(signal)) {
+        return abortedSearchResult(0);
+    }
+    // Honor the per-query cap alongside the global limit (Finding 2).
+    const effectiveMaxMatches = Math.min(limits.maxMatchesReturned, query.maxResults);
+    const ctx = {
+        scope,
+        regex: compileGlob(query.text, query.caseSensitive),
+        fingerprint: fingerprintFor(query),
+        nowMs,
+    };
+    const policy = resolveSearchPolicy(scope.relativePaths.length > 0, hints);
+    const candidateSet = gatherCandidates(scope, query, limits, fs, policy);
+    if (isAborted(signal)) {
+        return { ...abortedSearchResult(nowMs() - startMs), diagnostics: candidateSet.diagnostics };
+    }
+    const state = collectFileListings(ctx, candidateSet, policy, {
+        limits,
+        maxMatches: effectiveMaxMatches,
+        startMs,
+        ...(signal !== undefined ? { signal } : {}),
+    });
+    return {
+        atoms: state.atoms,
+        candidates: state.candidates,
+        filesScanned: state.filesScanned,
+        elapsedMs: nowMs() - startMs,
+        truncated: state.truncated,
+        diagnostics: candidateSet.diagnostics,
+    };
+}
+export async function findFiles(scope, query, limits = DEFAULT_SEARCH_LIMITS, deps = {}) {
+    assertWorkspaceRoot(scope.workspace);
+    assertQuery(query);
+    if (query.kind !== "file-pattern") {
+        throw new RepoSearchInvalidQueryError("findFiles requires a file-pattern query");
+    }
+    const fs = deps.fs ?? nodeWorkspaceFs;
+    const nowMs = deps.nowMs ?? Date.now;
+    return await Promise.resolve(findFilesSync(scope, query, limits, fs, nowMs, deps.searchHints, deps.signal));
+}
+function buildExcerptFingerprint(request) {
+    return fingerprintFor({
+        kind: "natural-language",
+        text: `${request.scopePath}:${request.startLine.toString()}-${request.endLine.toString()}`,
+        caseSensitive: false,
+        maxResults: 1,
+        emittedAtMs: 0,
+    });
+}
+function isWithinSelectedScope(scope, scopePath) {
+    if (scope.relativePaths.length === 0) {
+        return true;
+    }
+    return scope.relativePaths.some((selectedPath) => scopePath === selectedPath || scopePath.startsWith(`${selectedPath}/`));
+}
+function normalizeScopePath(scopePath) {
+    return scopePath.split("\\").join("/");
+}
+function assertExcerptWithinSelectedScope(scope, scopePath) {
+    if (isWithinSelectedScope(scope, scopePath)) {
+        return;
+    }
+    throw new RepoSearchUnsupportedFileError(`cannot read excerpt outside selected scope: ${scopePath}`, "outside-scope");
+}
+function resolveExcerptTarget(scope, scopePath, fs) {
+    const abs = resolveWithinWorkspace(scope.workspace.root, scopePath);
+    const contained = containedRealPathInfo(fs, scope.workspace.root, abs);
+    const realScopePath = normalizeScopePath(contained.realRelative);
+    return { path: contained.path, realScopePath };
+}
+function assertExcerptReadableByPolicy(requestPath, realScopePath) {
+    // Deny gates must fire BEFORE any byte read (incl. the binary probe) so that a denied path such
+    // as .env is never read at all, including through an in-workspace symlink. .gitignore is not a
+    // context policy boundary; safe ignored/dot files remain readable when the user scopes them in.
+    if (isDenied(requestPath) || isDenied(realScopePath)) {
+        throw new RepoSearchUnsupportedFileError(`cannot read excerpt of denied path: ${requestPath}`, "denied");
+    }
+}
+function assertExcerptRange(request) {
+    if (!Number.isInteger(request.startLine) ||
+        !Number.isInteger(request.endLine) ||
+        request.startLine < 1 ||
+        request.endLine < request.startLine) {
+        throw new RepoSearchInvalidRangeError(`invalid line range: ${request.startLine.toString()}-${request.endLine.toString()}`);
+    }
+    if (!Number.isFinite(request.maxBytes) ||
+        !Number.isInteger(request.maxBytes) ||
+        request.maxBytes < 0) {
+        throw new RepoSearchInvalidRangeError(`invalid maxBytes: ${String(request.maxBytes)} (must be a finite non-negative integer)`);
+    }
+    if (!isValidScopePath(request.scopePath, { mustBeRelative: true })) {
+        throw new RepoSearchInvalidRangeError(`invalid scopePath: ${request.scopePath}`);
+    }
+}
+// Probes for binary content and throws RepoSearchUnsupportedFileError on both binary detection
+// and IO errors (EACCES, ENOENT, …) so the caller can treat both as a graceful skip.
+async function assertExcerptNotBinary(fs, absolutePath, size, scopePath) {
+    let isBinary;
+    try {
+        isBinary = await probeBinary(fs, absolutePath, size);
+    }
+    catch (err) {
+        // TOCTOU: permissions or availability may change between stat and probe (EACCES, ENOENT, …).
+        // Re-classify as an unsupported-file skip so readKeptExcerpts degrades gracefully instead
+        // of crashing the whole grounded answer (the comment at grounded-orchestrator readKeptExcerpts
+        // explicitly promises this invariant).
+        if (isIoError(err)) {
+            throw new RepoSearchUnsupportedFileError(`cannot read excerpt of unreadable file: ${scopePath}`, "io-error");
+        }
+        throw err;
+    }
+    if (isBinary) {
+        throw new RepoSearchUnsupportedFileError(`cannot read excerpt of binary file: ${scopePath}`, "binary");
+    }
+}
+export async function readExcerpt(scope, request, deps = {}) {
+    if (isAborted(deps.signal)) {
+        throw new RepoSearchUnsupportedFileError("repo-search operation aborted", "aborted");
+    }
+    assertExcerptRange(request);
+    assertWorkspaceRoot(scope.workspace);
+    assertExcerptWithinSelectedScope(scope, request.scopePath);
+    if (isImageScopePath(request.scopePath)) {
+        throw new RepoSearchUnsupportedFileError(`cannot read excerpt of image file: ${request.scopePath}`, "binary");
+    }
+    const fs = deps.fs ?? nodeWorkspaceFs;
+    const nowMs = deps.nowMs ?? Date.now;
+    const target = resolveExcerptTarget(scope, request.scopePath, fs);
+    assertExcerptReadableByPolicy(request.scopePath, target.realScopePath);
+    assertExcerptWithinSelectedScope(scope, target.realScopePath);
+    const stat = fs.stat(target.path);
+    await assertExcerptNotBinary(fs, target.path, stat.size, request.scopePath);
+    if (isAborted(deps.signal)) {
+        throw new RepoSearchUnsupportedFileError("repo-search operation aborted", "aborted");
+    }
+    // Read enough of the file to reach the requested line window (bounded by MAX_EXCERPT_FILE_BYTES),
+    // then clamp the returned content to the caller's request.maxBytes budget. The read cap is
+    // intentionally larger than request.maxBytes so a window deep in a multi-kibibyte file is still
+    // reachable instead of the whole file being rejected.
+    const content = readWorkspaceFile(scope.workspace, request.scopePath, { maxBytes: MAX_EXCERPT_FILE_BYTES }, fs);
+    const allLines = content.text.split("\n");
+    const slice = allLines.slice(request.startLine - 1, request.endLine).join("\n");
+    const clamped = clampToBytes(slice, request.maxBytes);
+    const atom = buildAtom({
+        scopeId: scope.scopeId,
+        scopePath: request.scopePath,
+        lineRange: { startLine: request.startLine, endLine: request.endLine },
+        provenanceKind: "excerpt-read",
+        tool: "repo.readExcerpt",
+        queryFingerprint: buildExcerptFingerprint(request),
+        score: 1,
+        emittedAtMs: nowMs(),
+    });
+    return { atom, content: clamped.excerpt, truncated: clamped.truncated };
+}

package/dist/repoSearchEntries.d.ts

@@ -0,0 +1,15 @@
+import type { WorkspaceFs } from "./fs.js";
+import type { DiscoveredFile, WorkspaceInfo } from "./types.js";
+interface ScopeShape {
+    readonly workspace: WorkspaceInfo;
+    readonly relativePaths: readonly string[];
+}
+interface LimitsShape {
+    readonly maxFilesScanned: number;
+}
+export declare function collectFromEntries(scope: ScopeShape, limits: LimitsShape, fs: WorkspaceFs): {
+    files: readonly DiscoveredFile[];
+    truncated: boolean;
+};
+export {};
+//# sourceMappingURL=repoSearchEntries.d.ts.map

package/dist/repoSearchEntries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repoSearchEntries.d.ts","sourceRoot":"","sources":["../src/repoSearchEntries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,WAAW,EAAE,MAAM,SAAS,CAAC;AAI9D,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhE,UAAU,UAAU;IAClB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAiHD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,WAAW,EACnB,EAAE,EAAE,WAAW,GACd;IAAE,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAgB1D"}

package/dist/repoSearchEntries.js

@@ -0,0 +1,106 @@
+import { isDenied } from "./ignore.js";
+import { resolveWithinWorkspace } from "./paths.js";
+import { containedRealPathInfo } from "./realpath.js";
+import { RepoSearchInvalidQueryError } from "./errors.js";
+function normalizeScopePath(scopePath) {
+    return scopePath.split("\\").join("/");
+}
+function readDirSorted(fs, absoluteDir) {
+    try {
+        return [...fs.readDir(absoluteDir)].sort((a, b) => (a.name < b.name ? -1 : 1));
+    }
+    catch {
+        return [];
+    }
+}
+function pushAllowedFile(walk, relPath, absPath) {
+    if (walk.files.length > walk.limits.maxFilesScanned) {
+        return;
+    }
+    const stat = walk.fs.stat(absPath);
+    if (!stat.isFile) {
+        return;
+    }
+    walk.files.push({ relativePath: relPath, sizeBytes: stat.size });
+    if (walk.files.length > walk.limits.maxFilesScanned) {
+        walk.truncated = true;
+    }
+}
+function allowedByFilters(relPath) {
+    return !isDenied(relPath);
+}
+function handleDirectoryEntry(walk, absoluteDir, dirRel, entry, depth) {
+    if (entry.isSymbolicLink) {
+        return;
+    }
+    const root = walk.scope.workspace.root;
+    const childRel = dirRel.length === 0 ? entry.name : `${dirRel}/${entry.name}`;
+    if (!allowedByFilters(childRel)) {
+        return;
+    }
+    const childAbs = resolveWithinWorkspace(root, childRel);
+    const contained = containedRealPathInfo(walk.fs, root, childAbs);
+    const realRel = normalizeScopePath(contained.realRelative);
+    if (!allowedByFilters(realRel)) {
+        return;
+    }
+    if (entry.isDirectory) {
+        walkEntryDirectory(walk, contained.path, realRel, depth + 1);
+        return;
+    }
+    pushAllowedFile(walk, realRel, contained.path);
+}
+function walkEntryDirectory(walk, absoluteDir, dirRel, depth) {
+    if (depth > 12 || walk.truncated) {
+        return;
+    }
+    for (const entry of readDirSorted(walk.fs, absoluteDir)) {
+        if (walk.files.length > walk.limits.maxFilesScanned) {
+            walk.truncated = true;
+            return;
+        }
+        handleDirectoryEntry(walk, absoluteDir, dirRel, entry, depth);
+    }
+}
+function handleScopeEntry(walk, entry) {
+    const root = walk.scope.workspace.root;
+    const abs = resolveWithinWorkspace(root, entry);
+    const contained = containedRealPathInfo(walk.fs, root, abs);
+    const entryRel = normalizeScopePath(entry);
+    const realRel = normalizeScopePath(contained.realRelative);
+    if (isDenied(entryRel) || isDenied(realRel)) {
+        return;
+    }
+    let stat;
+    try {
+        stat = walk.fs.stat(contained.path);
+    }
+    catch {
+        throw new RepoSearchInvalidQueryError("Connected scope path is not accessible from the selected project.");
+    }
+    if (!allowedByFilters(entryRel) || !allowedByFilters(realRel)) {
+        return;
+    }
+    if (stat.isDirectory) {
+        walkEntryDirectory(walk, contained.path, realRel, 1);
+        return;
+    }
+    pushAllowedFile(walk, realRel, contained.path);
+}
+export function collectFromEntries(scope, limits, fs) {
+    const out = [];
+    const walk = {
+        scope,
+        limits,
+        fs,
+        files: out,
+        truncated: false,
+    };
+    for (const entry of scope.relativePaths) {
+        if (walk.truncated) {
+            break;
+        }
+        handleScopeEntry(walk, entry);
+    }
+    return { files: out.slice(0, limits.maxFilesScanned), truncated: walk.truncated };
+}

package/dist/repoSearchLineSelection.d.ts

@@ -0,0 +1,18 @@
+import type { LineMatcher } from "./repoSearchMatchers.js";
+export interface LineSelectionRunner {
+    readonly limits: {
+        readonly elapsedMsMax: number;
+    };
+    readonly matcher: LineMatcher;
+    readonly nowMs: () => number;
+    readonly startMs: number;
+}
+export interface LineSelectionState {
+    truncated: boolean;
+}
+export interface ScoredLine {
+    readonly line: number;
+    readonly score: number;
+}
+export declare function collectBestLines(runner: LineSelectionRunner, text: string, state: LineSelectionState): readonly ScoredLine[];
+//# sourceMappingURL=repoSearchLineSelection.d.ts.map

package/dist/repoSearchLineSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repoSearchLineSelection.d.ts","sourceRoot":"","sources":["../src/repoSearchLineSelection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAQ3D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AA6BD,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,kBAAkB,GACxB,SAAS,UAAU,EAAE,CAmBvB"}

package/dist/repoSearchLineSelection.js

@@ -0,0 +1,43 @@
+// Per-file cap on emitted lexical matches (Epic #177 retrieval fix). A connected-scope question
+// carries several content tokens, so a prose-heavy file can match many low-signal lines. Keeping
+// only each file's best lines makes the evidence diverse across the scope.
+const MAX_MATCHES_PER_FILE = 3;
+const LINE_TIMEOUT_CHECK_INTERVAL = 256;
+function elapsed(runner) {
+    return runner.nowMs() - runner.startMs;
+}
+function timedOut(runner, state, lineIndex) {
+    if (lineIndex % LINE_TIMEOUT_CHECK_INTERVAL !== 0 ||
+        elapsed(runner) <= runner.limits.elapsedMsMax) {
+        return false;
+    }
+    state.truncated = true;
+    return true;
+}
+function insertBestLine(best, candidate) {
+    best.push(candidate);
+    best.sort((a, b) => (b.score !== a.score ? b.score - a.score : a.line - b.line));
+    if (best.length > MAX_MATCHES_PER_FILE) {
+        best.pop();
+    }
+}
+export function collectBestLines(runner, text, state) {
+    const best = [];
+    let lineStart = 0;
+    let lineNumber = 1;
+    for (let i = 0; i <= text.length; i += 1) {
+        if (i < text.length && text.charCodeAt(i) !== 10 /* \n */) {
+            continue;
+        }
+        if (timedOut(runner, state, lineNumber - 1)) {
+            break;
+        }
+        const score = runner.matcher.match(text.slice(lineStart, i));
+        if (score > 0) {
+            insertBestLine(best, { line: lineNumber, score });
+        }
+        lineStart = i + 1;
+        lineNumber += 1;
+    }
+    return best.sort((a, b) => a.line - b.line);
+}

package/dist/repoSearchMatchers.d.ts

@@ -0,0 +1,8 @@
+import type { RetrievalQuery } from "@oscharko-dev/keiko-contracts/connected-context";
+export interface LineMatcher {
+    readonly match: (line: string) => number;
+}
+export declare function fingerprintFor(query: RetrievalQuery): string;
+export declare function buildMatcher(query: RetrievalQuery): LineMatcher;
+export declare function compileGlob(pattern: string, caseSensitive?: boolean): RegExp;
+//# sourceMappingURL=repoSearchMatchers.d.ts.map

package/dist/repoSearchMatchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repoSearchMatchers.d.ts","sourceRoot":"","sources":["../src/repoSearchMatchers.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AAItF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CAC1C;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAQ5D;AAoaD,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,WAAW,CAW/D;AAID,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,UAAO,GAAG,MAAM,CAsBzE"}