@davesheffer/hunch 1.45.2 → 1.46.0

package/dist/core/projectDna.js

@@ -81,7 +81,17 @@ function gitText(root, args) {
 function exactCommit(root, ref) {
     if (!ref.trim() || /[\0\r\n]/.test(ref) || ref.length > 1_024)
         throw new Error("Git revision is invalid");
-    const revision = gitText(root, ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]);
+    let revision;
+    try {
+        revision = gitText(root, ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]);
+    }
+    catch (error) {
+        // Git's own text ("fatal: Needed a single revision") never names the ref (#493);
+        // any other failure keeps its original message.
+        if (!/Needed a single revision|unknown revision|bad revision/i.test(error.message))
+            throw error;
+        throw new Error(`Git revision ${JSON.stringify(ref)} does not name a commit in this repository`);
+    }
     if (!GIT_OBJECT.test(revision))
         throw new Error("Git did not return an exact commit object");
     return revision;

package/dist/core/relativeImports.js

@@ -26,8 +26,12 @@ export function relativeImportCandidates(fromFile, specifier) {
  * indexer compatibility; callers that need ambiguity metadata can inspect the
  * returned matches instead of guessing a different target. */
 export function resolveRelativeImport(fromFile, specifier, availableFiles) {
-    const available = new Set(availableFiles);
-    const matches = relativeImportCandidates(fromFile, specifier).filter((candidate) => available.has(candidate));
+    // Bare/non-relative specifiers have no candidates: skip the O(N) file-set copy.
+    const candidates = relativeImportCandidates(fromFile, specifier);
+    if (candidates.length === 0)
+        return { path: null, matches: [] };
+    const available = availableFiles instanceof Set ? availableFiles : new Set(availableFiles);
+    const matches = candidates.filter((candidate) => available.has(candidate));
     return { path: matches[0] ?? null, matches };
 }
 //# sourceMappingURL=relativeImports.js.map

package/dist/core/taskSelection.js

@@ -190,6 +190,39 @@ function scanIdentifiers(text) {
 export function identifierTokens(text) {
     return new Set(scanIdentifiers(text).keys());
 }
+/** Word -> the `id:` terms of the camel compounds the prompt splits it out of (PowerShell ->
+ *  power, shell; GitHubActions -> git, hub, actions), sorted so prompt word order never matters.
+ *  A word the prompt also uses on its own belongs to no compound. */
+function camelCompoundGroups(text) {
+    const groups = new Map();
+    const compounds = text.match(CAMEL_IDENTIFIER) ?? [];
+    if (!compounds.length)
+        return groups;
+    const standalone = lexicalTokens(text.replace(CAMEL_IDENTIFIER, " "));
+    for (const m of compounds) {
+        const key = ID_PREFIX + m.toLowerCase();
+        for (const word of lexicalTokens(m)) {
+            if (standalone.has(word))
+                continue;
+            const keys = groups.get(word) ?? [];
+            if (!keys.includes(key))
+                keys.push(key);
+            groups.set(word, keys.sort());
+        }
+    }
+    return groups;
+}
+/** A pasted stack frame: `at fn (file:line:col)`, `at file:line:col`, `at X (<anonymous>)`, `at X (node:...)`.
+ *  Prose that merely starts with "at" ("at startup the lock goes stale") has no such tail. */
+const FRAME_LINE = /^\s*at\s+\S+.*(?::\d+:\d+\)?|\(<anonymous>\)|\(node:[^)]*\))\s*$/;
+/** Text whose words count: every line, unless the prompt holds an actual trace (2+ frame
+ *  lines), whose frames name library internals (process, tick, sync), not the task. A Node
+ *  warning's `(node:<pid>)` prefix is noise either way; the words after it stay. */
+function promptWordText(prompt) {
+    const lines = prompt.split(/\r?\n/);
+    const trace = lines.filter((line) => FRAME_LINE.test(line)).length >= 2;
+    return (trace ? lines.filter((line) => !FRAME_LINE.test(line)) : lines).join("\n").replace(/\(node:\d+\)/g, " ");
+}
 const termTokens = (text) => new Set([...lexicalTokens(text), ...identifierTokens(text)]);
 /** Score live records against one prompt. Text fields per kind (title + rationale):
  *  decision title/context/decision; bug title/symptom/root_cause; constraint
@@ -199,9 +232,9 @@ const termTokens = (text) => new Set([...lexicalTokens(text), ...identifierToken
 export function selectForTask(records, promptText, opts = {}) {
     const k = Math.max(0, opts.k ?? DEFAULT_K);
     // Stack-frame lines name library APIs (writeFileSync, processTicksAndRejections), not the task:
-    // keep their words, but extract no identifiers from them.
-    const promptIdentifiers = (promptText ?? "").split(/\r?\n/).filter((line) => !/^\s*at\s+\S/.test(line) && !/node:internal|\(node:/.test(line)).join("\n");
-    const taskTerms = new Set([...lexicalTokens(promptText ?? ""), ...identifierTokens(promptIdentifiers)]);
+    // when the prompt holds a real trace, neither their words nor their identifiers count.
+    const promptIdentifiers = promptWordText(promptText ?? "");
+    const taskTerms = new Set([...lexicalTokens(promptIdentifiers), ...identifierTokens(promptIdentifiers)]);
     // Without an existence check (pure/offline) only a slashed token is trusted as a
     // path: "e.g.", "Node.js" or "v1.2" would otherwise match a broad glob.
     const paths = promptPaths(promptText ?? "", opts.root).filter((p) => opts.pathExists ? opts.pathExists(p) : p.includes("/"));
@@ -230,6 +263,15 @@ export function selectForTask(records, promptText, opts = {}) {
     for (const c of candidates)
         for (const term of c.tokens)
             df.set(term, (df.get(term) ?? 0) + 1);
+    // A camel compound in many records is a brand (GitHub, PowerShell, GitHubActions): in a record
+    // holding it, its parts count as one word. A near-unique one (df <= MIN_DF_CAP, e.g. QuotaReaper)
+    // names this project, and in a record without the compound a part is an ordinary word.
+    const wordGroups = new Map();
+    for (const [word, keys] of camelCompoundGroups(promptIdentifiers)) {
+        const common = keys.filter((key) => (df.get(key) ?? 0) > MIN_DF_CAP);
+        if (common.length)
+            wordGroups.set(word, common);
+    }
     const strongIds = new Set([...scanIdentifiers(promptIdentifiers)].filter(([, strong]) => strong).map(([term]) => term));
     const rareTerms = new Map();
     for (const term of taskTerms) {
@@ -247,7 +289,7 @@ export function selectForTask(records, promptText, opts = {}) {
     }
     const scored = [];
     for (const { tokens, anchors, ...rest } of candidates) {
-        let words = 0;
+        const words = new Set();
         let identifiers = 0;
         let termScore = 0;
         for (const [term, { weight, strong }] of rareTerms) {
@@ -256,12 +298,12 @@ export function selectForTask(records, promptText, opts = {}) {
             if (strong)
                 identifiers++;
             else
-                words++;
+                words.add(wordGroups.get(term)?.find((key) => tokens.has(key)) ?? term);
             termScore += weight;
         }
         const pathHits = paths.filter((p) => anchors.some((anchor) => pathMatchesGlob(p, anchor))).length;
         // One rare identifier alone qualifies (it counts double); a lone rare word does not.
-        if (pathHits > 0 || words + IDENTIFIER_WEIGHT * identifiers >= MIN_DISTINCT_TERMS)
+        if (pathHits > 0 || words.size + IDENTIFIER_WEIGHT * identifiers >= MIN_DISTINCT_TERMS)
             scored.push({ ...rest, pathHits, termScore });
     }
     // A record anchored to more of the files the prompt names outranks one that

package/dist/core/testSelection.d.ts

@@ -0,0 +1,122 @@
+/** One test's coverage record. `complete` = the test file passed (ran to the
+ *  end, so its coverage is whole); `closureHash` = the entry-closure hash at
+ *  refresh time; `commit` = HEAD when this entry was recorded. */
+export interface ImpactEntry {
+    files: string[];
+    complete: boolean;
+    commit: string;
+    closureHash: string;
+}
+export interface ImpactMap {
+    version: number;
+    commit: string;
+    generatedAt?: string;
+    closureHash?: string;
+    /** test file → coverage entry (repo-relative posix). */
+    map: Record<string, ImpactEntry>;
+}
+export interface SelectionInput {
+    changedFiles: string[];
+    allTests: string[];
+    impactMap?: ImpactMap;
+    /** Static dependencies of a test: transitive imports plus the closures of
+     *  repo paths its text names (see `testDependencyModel`). */
+    importGraph: (testFile: string) => Set<string>;
+    fullTriggers?: string[];
+    /** Extra per-test globs: a changed file matching one selects that test. */
+    gateMaps?: Record<string, string[]>;
+    /** Source text of a test (and its non-src helpers), for path/basename mentions. */
+    testText?: (testFile: string) => string;
+    /** Does the test start a child process (directly or through a helper)? */
+    spawning?: (testFile: string) => boolean;
+    /** Every file a spawned child could execute (all src/ plus tooling closures). */
+    wholeProgram?: Iterable<string>;
+    /** Entry-closure hash computed now; a map entry is trusted only if it matches. */
+    closureHash?: string;
+    /** src/ and tooling/ files whose text names a test file by repo path. */
+    testNamers?: (testFile: string) => string[];
+}
+export interface Selection {
+    mode: "selected" | "full" | "none";
+    tests: string[];
+    reasons: Record<string, string[]>;
+    fullReason?: string;
+    unattributed: string[];
+    /** Tests whose impact-map entry attributed a change or narrowed a spawning test. */
+    mapUsed: string[];
+}
+export declare const DEFAULT_FULL_TRIGGERS: readonly string[];
+/** Repo-root markdown (README.md, CHANGELOG.md, ...) is the only non-code change
+ *  that can skip the full suite: it selects tests that mention it, else nothing. */
+export declare function isDocsOnly(file: string): boolean;
+/** Selected tests above this share of the suite run the full suite instead. */
+export declare const MAX_SELECTED_SHARE = 0.6;
+export declare const isMetaTest: (text: string) => boolean;
+/** A map entry may narrow a spawning test only when it is complete and was
+ *  recorded against the same entry closure as now. */
+export declare function entryTrusted(entry: ImpactEntry | undefined, closureHash: string | undefined): boolean;
+export declare function selectTests(input: SelectionInput): Selection;
+/** Tracked + untracked (non-ignored) repo files, repo-relative posix, sorted. */
+export declare function listRepoFiles(root: string): string[];
+export declare function discoverTests(files: string[], glob?: string): string[];
+/** Static imports, re-exports, `import()`/`require()` with literal specifiers. */
+export declare function importSpecifiers(source: string): string[];
+/** Transitive relative-import closure per file, memoized for this call. An
+ *  unresolvable relative specifier (e.g. a deleted file) records every
+ *  candidate path, so the deletion stays attributable to its importers. */
+export declare function buildImportGraph(root: string, files?: string[]): (file: string) => Set<string>;
+/** Entries whose import closure (edges included) keys map-entry trust. */
+export declare const CLOSURE_ROOTS: readonly string[];
+/** String-literal arguments of each `join(`/`resolve(` call, found with a
+ *  balanced-paren scan so nested calls (`join(process.cwd(), "src")`) parse. */
+export declare function joinSegmentRuns(text: string): string[][];
+/** Repo files a test's text names: path-like tokens anywhere (string literals,
+ *  `--eval` import specifiers, template strings) and `join(…, "src", "x.ts")`
+ *  segment runs, resolved against the REPO ROOT (and the test's own dir for
+ *  `./`/`../` tokens), with `.js`→`.ts` mapping. */
+export declare function literalRepoPaths(text: string, fromFile: string, available: Set<string>): string[];
+/** Arguments of each `join(`/`resolve(` call: a plain string literal's value, or
+ *  `null` for anything computed (identifiers, calls, `${}` templates). */
+export declare function joinCallArgs(text: string): (string | null)[][];
+/** Top-level repo dirs a text reaches through a COMPUTED path: `` `../src/${p}` ``,
+ *  `"src/" + p`, `join(root, "src", p)`, or a later use of an alias like
+ *  `const SRC = join(ROOT, "src")`. A test doing that may read any file under
+ *  the dir, so it depends on all of them. A computed segment right after the
+ *  root (`` `../${dir}/x` ``, `"../" + dir`, `resolve(__dirname, "..", dir)`,
+ *  `` `${ROOT}/${dir}` ``) may be ANY top-level dir (fail closed). */
+export declare function templatedRepoDirs(text: string, topDirs: Set<string>): string[];
+export interface TestDependencyModel {
+    /** Static imports ∪ closures of repo paths named in the test or its helpers. */
+    dependencies: (testFile: string) => Set<string>;
+    spawning: (testFile: string) => boolean;
+    /** Text of the test plus its non-src static closure (helpers). */
+    testText: (testFile: string) => string;
+    /** All src/ files plus the closures of every tooling/*.mjs. */
+    wholeProgram: Set<string>;
+    /** Hash of the import closures (edges) of CLOSURE_ROOTS and tooling/*.mjs. */
+    closureHash: string;
+    /** src/ and tooling/ code files whose text names a test file by repo path. */
+    testNamers: (testFile: string) => string[];
+}
+export declare function testDependencyModel(root: string, files: string[], graph?: (file: string) => Set<string>): TestDependencyModel;
+/** Structural hash of the entry closures: every reachable file and its direct
+ *  edges. Content edits don't change it; a new import or file in the closure does. */
+export declare function closureHash(root: string, files: string[], graph?: (file: string) => Set<string>): string;
+/** Repo files with any executed range in V8 coverage reports
+ *  (`NODE_V8_COVERAGE` JSON: `{ result: [{ url, functions: [{ ranges }] }] }`). */
+export declare function coverageFiles(reports: unknown[], root: string, repoFiles: Set<string>): string[];
+export type ChangeMode = {
+    kind: "worktree";
+} | {
+    kind: "staged";
+} | {
+    kind: "base";
+    ref: string;
+};
+/** Changed files for a verify run. `worktree` (default): staged + unstaged +
+ *  untracked; `staged`: the index only; `base`: merge-base(ref, HEAD)..HEAD
+ *  plus the working tree. */
+export declare function changedFiles(root: string, mode?: ChangeMode): string[];
+/** Load an impact map; a missing file is `null`, a malformed one throws. A
+ *  legacy `test: string[]` entry loads as incomplete (never trusted). */
+export declare function loadImpactMap(path: string): ImpactMap | null;