@oscharko-dev/keiko-workspace 0.2.0

package/dist/repoSearchPolicy.js

@@ -0,0 +1,342 @@
+const METADATA_FILENAMES = new Set([
+    "package.json",
+    "tsconfig.json",
+    "tsconfig.base.json",
+    "tsconfig.build.json",
+    "vite.config.ts",
+    "vite.config.js",
+    "vitest.config.ts",
+    "vitest.config.js",
+    "jest.config.ts",
+    "jest.config.js",
+    "playwright.config.ts",
+    "playwright.config.js",
+    "next.config.ts",
+    "next.config.js",
+    "eslint.config.ts",
+    "eslint.config.js",
+]);
+const OVERVIEW_FILENAMES = new Set([
+    "readme.md",
+    "agents.md",
+    "contributing.md",
+    "architecture.md",
+    "docs/architecture.md",
+    "docs/overview.md",
+    "docs/readme.md",
+]);
+const LOCKFILE_FILENAMES = new Set([
+    "bun.lock",
+    "bun.lockb",
+    "cargo.lock",
+    "composer.lock",
+    "gemfile.lock",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+]);
+const LOW_VALUE_SEGMENTS = new Set([
+    ".parcel-cache",
+    ".svelte-kit",
+    ".vercel",
+    "coverage",
+    "dist",
+    "generated",
+    "storybook-static",
+    "tmp",
+]);
+const LOW_VALUE_IGNORE_LINES = Object.freeze([
+    ".parcel-cache/",
+    ".svelte-kit/",
+    ".vercel/",
+    "coverage/",
+    "dist/",
+    "generated/",
+    "storybook-static/",
+    "tmp/",
+    "bun.lock",
+    "bun.lockb",
+    "cargo.lock",
+    "composer.lock",
+    "Gemfile.lock",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+]);
+const SOURCE_EXTENSIONS = new Set([
+    "cjs",
+    "cts",
+    "go",
+    "java",
+    "js",
+    "jsx",
+    "mjs",
+    "mts",
+    "py",
+    "rs",
+    "ts",
+    "tsx",
+    "vue",
+]);
+const DOC_EXTENSIONS = new Set(["adoc", "md", "mdx", "rst", "txt"]);
+const TEST_FILE_RE = /(?:^|[./_-])(?:test|spec|fixture|mock)s?(?:[./_-]|$)/iu;
+// Identifier tokens with a SINGLE greedy quantifier — no two overlapping `[A-Za-z0-9_$]*` runs
+// around `[A-Z]`, which is a polynomial-ReDoS shape on uncontrolled query text (CodeQL). The
+// camelCase test (an uppercase at position >= 1) is applied separately as a constant-width probe.
+const IDENTIFIER_TOKEN_RE = /\b[A-Za-z_$][A-Za-z0-9_$]*\b/gu;
+const HAS_INNER_UPPERCASE_RE = /[A-Za-z0-9_$][A-Z]/u;
+const TOKEN_RE = /[A-Za-z0-9_.-]{3,}/gu;
+function emptyBucketCounts() {
+    return {
+        "canonical-metadata": 0,
+        "overview-doc": 0,
+        "exact-path": 0,
+        "symbol-source": 0,
+        source: 0,
+        test: 0,
+        docs: 0,
+        lockfile: 0,
+        "low-value": 0,
+        other: 0,
+    };
+}
+function basename(scopePath) {
+    const index = scopePath.lastIndexOf("/");
+    return index >= 0 ? scopePath.slice(index + 1) : scopePath;
+}
+function extension(scopePath) {
+    const name = basename(scopePath).toLowerCase();
+    const dot = name.lastIndexOf(".");
+    return dot < 0 ? "" : name.slice(dot + 1);
+}
+function normalizedPath(scopePath) {
+    return scopePath.split("\\").join("/").toLowerCase();
+}
+function pathSegments(scopePath) {
+    return normalizedPath(scopePath)
+        .split("/")
+        .filter((segment) => segment.length > 0);
+}
+function isLockfile(scopePath) {
+    return LOCKFILE_FILENAMES.has(basename(scopePath).toLowerCase());
+}
+function hasLowValueSegment(scopePath) {
+    return pathSegments(scopePath).some((segment) => LOW_VALUE_SEGMENTS.has(segment));
+}
+function normalizedQueryTerms(query) {
+    const terms = new Set();
+    for (const match of query.text.matchAll(TOKEN_RE)) {
+        terms.add(match[0].toLowerCase());
+    }
+    for (const match of query.text.matchAll(IDENTIFIER_TOKEN_RE)) {
+        if (HAS_INNER_UPPERCASE_RE.test(match[0])) {
+            terms.add(match[0].toLowerCase());
+        }
+    }
+    return [...terms];
+}
+function bucketByPath(scopePath) {
+    const path = normalizedPath(scopePath);
+    const name = basename(path);
+    const ext = extension(path);
+    if (METADATA_FILENAMES.has(name)) {
+        return "canonical-metadata";
+    }
+    if (OVERVIEW_FILENAMES.has(path) || OVERVIEW_FILENAMES.has(name)) {
+        return "overview-doc";
+    }
+    if (isLockfile(path)) {
+        return "lockfile";
+    }
+    if (hasLowValueSegment(path)) {
+        return "low-value";
+    }
+    if (TEST_FILE_RE.test(path)) {
+        return "test";
+    }
+    if (SOURCE_EXTENSIONS.has(ext)) {
+        return "source";
+    }
+    if (DOC_EXTENSIONS.has(ext)) {
+        return "docs";
+    }
+    return "other";
+}
+function bucketScore(bucket, intent) {
+    if (intent === "project-metadata") {
+        return metadataBucketScore(bucket);
+    }
+    if (intent === "repository-overview") {
+        return overviewBucketScore(bucket);
+    }
+    if (intent === "targeted-code-search" || intent === "diagnostic-search") {
+        return targetedBucketScore(bucket);
+    }
+    return genericBucketScore(bucket);
+}
+function metadataBucketScore(bucket) {
+    const scores = {
+        "canonical-metadata": 100,
+        "overview-doc": 70,
+        "exact-path": 95,
+        "symbol-source": 80,
+        source: 45,
+        test: 40,
+        docs: 55,
+        lockfile: 15,
+        "low-value": 5,
+        other: 20,
+    };
+    return scores[bucket];
+}
+function overviewBucketScore(bucket) {
+    const scores = {
+        "canonical-metadata": 75,
+        "overview-doc": 100,
+        "exact-path": 95,
+        "symbol-source": 80,
+        source: 50,
+        test: 35,
+        docs: 70,
+        lockfile: 5,
+        "low-value": 5,
+        other: 20,
+    };
+    return scores[bucket];
+}
+function targetedBucketScore(bucket) {
+    const scores = {
+        "canonical-metadata": 65,
+        "overview-doc": 35,
+        "exact-path": 100,
+        "symbol-source": 95,
+        source: 80,
+        test: 55,
+        docs: 25,
+        lockfile: 5,
+        "low-value": 5,
+        other: 20,
+    };
+    return scores[bucket];
+}
+function genericBucketScore(bucket) {
+    const scores = {
+        "canonical-metadata": 80,
+        "overview-doc": 65,
+        "exact-path": 90,
+        "symbol-source": 85,
+        source: 60,
+        test: 45,
+        docs: 50,
+        lockfile: 5,
+        "low-value": 5,
+        other: 20,
+    };
+    return scores[bucket];
+}
+function pathTermBonus(scopePath, terms) {
+    const path = normalizedPath(scopePath);
+    const name = basename(path);
+    let score = 0;
+    for (const term of terms) {
+        if (name === term || name.startsWith(`${term}.`)) {
+            score = Math.max(score, 25);
+        }
+        else if (path.includes(term)) {
+            score = Math.max(score, 12);
+        }
+    }
+    return score;
+}
+function depthPenalty(scopePath) {
+    return Math.min(pathSegments(scopePath).length, 12);
+}
+function priorityForFile(file, terms, policy) {
+    return (bucketScore(bucketByPath(file.relativePath), policy.intent) +
+        pathTermBonus(file.relativePath, terms) -
+        depthPenalty(file.relativePath));
+}
+function bucketCounts(files) {
+    const counts = emptyBucketCounts();
+    for (const file of files) {
+        counts[bucketByPath(file.relativePath)] += 1;
+    }
+    return counts;
+}
+function sortFiles(files, query, policy) {
+    // Score each file ONCE (query tokenization + path bucketing are O(path) and were previously
+    // recomputed twice per comparison — O(n log n) blocking work on the 2000-file candidate cap).
+    // Tie-break on raw code-point order, not localeCompare, so evidence ordering is reproducible
+    // across locales/ICU builds (regulated-delivery determinism).
+    const terms = normalizedQueryTerms(query);
+    const scored = files.map((file) => ({ file, score: priorityForFile(file, terms, policy) }));
+    scored.sort((a, b) => {
+        if (a.score !== b.score)
+            return b.score - a.score;
+        if (a.file.relativePath < b.file.relativePath)
+            return -1;
+        return a.file.relativePath > b.file.relativePath ? 1 : 0;
+    });
+    return scored.map((entry) => entry.file);
+}
+export function resolveSearchPolicy(hasExplicitRelativePaths, hints) {
+    const mode = hasExplicitRelativePaths ? "explicit-scope" : "workspace-root-default";
+    const intent = hints?.retrievalIntent ?? "generic";
+    return {
+        mode,
+        intent,
+        applyGitignore: mode === "workspace-root-default",
+        omitLowValueWorkspaceFiles: mode === "workspace-root-default",
+    };
+}
+// The legacy `gatherCandidates(scope, limits, fs)` overload predates the search-policy work and is
+// still used by importGraph / testSourcePairing, which expect FULL-tree discovery (no .gitignore
+// subset, no low-value omission) — that was the hardcoded `applyGitignore: false` behavior before
+// this change. Resolving the default workspace-root policy for them would silently start dropping
+// gitignored / low-value files from those callers, so they get this neutral policy instead.
+export function legacyDiscoveryPolicy(hasExplicitRelativePaths) {
+    return {
+        mode: hasExplicitRelativePaths ? "explicit-scope" : "workspace-root-default",
+        intent: "generic",
+        applyGitignore: false,
+        omitLowValueWorkspaceFiles: false,
+    };
+}
+export function policyOmissionReason(scopePath, policy) {
+    if (!policy.omitLowValueWorkspaceFiles) {
+        return undefined;
+    }
+    if (isLockfile(scopePath) && policy.intent !== "project-metadata") {
+        return "generated";
+    }
+    return hasLowValueSegment(scopePath) ? "generated" : undefined;
+}
+export function extraIgnoreLinesForSearch(policy) {
+    return policy.omitLowValueWorkspaceFiles ? LOW_VALUE_IGNORE_LINES : [];
+}
+export function orderCandidatesForSearch(files, query, policy, ignoredByDiscovery, deniedByDiscovery) {
+    const ordered = sortFiles(files, query, policy);
+    return {
+        files: ordered,
+        diagnostics: {
+            policyMode: policy.mode,
+            intent: policy.intent,
+            filesDiscovered: files.length,
+            filesAfterPolicy: ordered.length,
+            ignoredByDiscovery,
+            deniedByDiscovery,
+            candidateBuckets: bucketCounts(ordered),
+        },
+    };
+}
+export function shouldScoreContent(query, text, policy) {
+    if (query.kind !== "natural-language" && query.kind !== "exact-symbol") {
+        return true;
+    }
+    if (policy.intent === "repository-overview" || policy.intent === "project-metadata") {
+        return true;
+    }
+    const haystack = query.caseSensitive ? text : text.toLowerCase();
+    const terms = normalizedQueryTerms(query).filter((term) => term.length >= 4);
+    return terms.length === 0 || terms.some((term) => haystack.includes(term));
+}

package/dist/repoSearchRegexSafety.d.ts

@@ -0,0 +1,2 @@
+export declare function regexSafetyIssue(source: string): string | undefined;
+//# sourceMappingURL=repoSearchRegexSafety.d.ts.map

package/dist/repoSearchRegexSafety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repoSearchRegexSafety.d.ts","sourceRoot":"","sources":["../src/repoSearchRegexSafety.ts"],"names":[],"mappings":"AAKA,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWnE"}

package/dist/repoSearchRegexSafety.js

@@ -0,0 +1,15 @@
+const MAX_REGEX_LENGTH = 200;
+const DANGEROUS_GROUP_OR_CLASS_REPETITION = /\([^)]*\)[+*{]|\[[^\]]*\][+*{]/;
+const ADJACENT_QUANTIFIED_ATOMS = /(?:\\.|[^\\()[\]{}+*?|])(?:[+*]|\{\d+(?:,\d*)?\})(?:\\.|[^\\()[\]{}+*?|])(?:[+*]|\{\d+(?:,\d*)?\})/;
+export function regexSafetyIssue(source) {
+    if (source.length > MAX_REGEX_LENGTH) {
+        return `regex too long: ${String(source.length)} > ${String(MAX_REGEX_LENGTH)}`;
+    }
+    if (DANGEROUS_GROUP_OR_CLASS_REPETITION.test(source)) {
+        return "regex contains repetition over a group or character class (potential catastrophic backtracking)";
+    }
+    if (ADJACENT_QUANTIFIED_ATOMS.test(source)) {
+        return "regex contains adjacent quantified atoms (potential catastrophic backtracking)";
+    }
+    return undefined;
+}

package/dist/repoSearchScan.d.ts

@@ -0,0 +1,62 @@
+import type { CandidateFile, CandidateOmissionReason, EvidenceAtom, EvidenceAtomProvenanceKind, RetrievalQuery } from "@oscharko-dev/keiko-contracts/connected-context";
+import type { WorkspaceFs } from "./fs.js";
+import type { LineMatcher } from "./repoSearchMatchers.js";
+import { type SearchDiagnostics, type SearchPolicy } from "./repoSearchPolicy.js";
+import type { DiscoveredFile, WorkspaceInfo } from "./types.js";
+export declare function isImageScopePath(scopePath: string): boolean;
+export interface ScopeShape {
+    readonly workspace: WorkspaceInfo;
+    readonly scopeId: string;
+    readonly relativePaths: readonly string[];
+}
+export interface LimitsShape {
+    readonly maxFilesScanned: number;
+    readonly maxMatchesReturned: number;
+    readonly maxBytesPerFileScanned: number;
+    readonly elapsedMsMax: number;
+}
+export interface AtomShape {
+    readonly scopeId: string;
+    readonly scopePath: string;
+    readonly lineRange: {
+        readonly startLine: number;
+        readonly endLine: number;
+    } | undefined;
+    readonly provenanceKind: EvidenceAtomProvenanceKind;
+    readonly tool: string;
+    readonly queryFingerprint: string;
+    readonly score: number;
+    readonly emittedAtMs: number;
+}
+export declare function buildAtom(shape: AtomShape): EvidenceAtom;
+export declare function buildCandidate(scopePath: string, omitted: CandidateOmissionReason | undefined): CandidateFile;
+export interface CandidateSet {
+    readonly files: readonly DiscoveredFile[];
+    readonly truncated: boolean;
+    readonly diagnostics: SearchDiagnostics;
+}
+export declare function gatherCandidates(scope: ScopeShape, limits: LimitsShape, fs: WorkspaceFs): CandidateSet;
+export declare function gatherCandidates(scope: ScopeShape, query: RetrievalQuery, limits: LimitsShape, fs: WorkspaceFs, policy: SearchPolicy): CandidateSet;
+export declare function probeBinary(fs: WorkspaceFs, abs: string, size: number): Promise<boolean>;
+export interface SearchTextRunner {
+    readonly scope: ScopeShape;
+    readonly limits: LimitsShape;
+    readonly fs: WorkspaceFs;
+    readonly nowMs: () => number;
+    readonly startMs: number;
+    readonly signal?: AbortSignal | undefined;
+    readonly matcher: LineMatcher;
+    readonly fingerprint: string;
+    readonly policy: SearchPolicy;
+    readonly query: RetrievalQuery;
+}
+export interface RunState {
+    filesScanned: number;
+    matchesReturned: number;
+    truncated: boolean;
+}
+export declare function elapsed(runner: SearchTextRunner): number;
+export declare function hitLimit(runner: SearchTextRunner, state: RunState): boolean;
+export declare function isIoError(err: unknown): boolean;
+export declare function scanFile(runner: SearchTextRunner, file: DiscoveredFile, state: RunState, atoms: EvidenceAtom[], candidates: CandidateFile[]): Promise<void>;
+//# sourceMappingURL=repoSearchScan.d.ts.map

package/dist/repoSearchScan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repoSearchScan.d.ts","sourceRoot":"","sources":["../src/repoSearchScan.ts"],"names":[],"mappings":"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"}