ts-axi 0.1.2 → 0.1.4

package/README.md

@@ -75,6 +75,20 @@ npx skills add cmosgh/ts-axi --skill ts-axi
 
 <!-- TODO(phase 4): paste real examples for def / refs / outline / config from the fixture project. -->
 
+## Monorepos
+
+No configuration and no new files in your repo: ts-axi detects the layout from what is already there - `nx.json` (projects = `project.json` dirs, or a legacy `workspace.json`), `pnpm-workspace.yaml`, `package.json` `workspaces`, or a root `tsconfig.json` that only holds `references`. The home view prints `workspace: nx (14 projects)`.
+
+Without `-P`, `refs`, `callers` and `impact` do not type-check the whole repo. They build the program from a subgraph: the declaring file (for `impact`, the touched files) plus every file that imports it, found by a fast text scan of import specifiers that follows `tsconfig.base.json` `paths`, workspace package names and `export * from` barrels. A caller in another project is found; the cost tracks the subgraph, not the repo. Each result says what was analysed:
+
+```
+scope: nx workspace - 30 of 5433 files (seeds 1; importers 29)
+```
+
+`scope_partial: true` means the importer scan stopped at its cap (50k files or 3 s); the help line says what is missing. `-P <tsconfig>` still analyses exactly one project; when it finds nothing, `found_outside_project` lists the importers outside it. A `-P` tsconfig that only holds `references` (an Nx project's `tsconfig.json`) is expanded to the configs it references: `tsconfig: libs/shared/tsconfig.json (2 referenced configs)`.
+
+Files are listed with `git ls-files` (tracked plus untracked, gitignore applied), so nested worktrees and ignored copies are never analysed. Outside git, a directory walk skips `node_modules`, build output, `.claude`, `.cursor`, `.idea`, `.vscode` and any nested checkout.
+
 ## Test files
 
 A file counts as a test by path pattern. Defaults: `**/*.test.*`, `**/*.spec.*`, `**/__tests__/**`, `**/test/**`, `**/tests/**`, `**/e2e/**`. The home view shows `test_globs` and `test_files` so a wrong rule is visible.
@@ -100,8 +114,9 @@ Any other key is a `VALIDATION_ERROR` naming the valid ones. `--test-glob <glob>
 One dependency: the `typescript` compiler API (ADR in `docs/adr/0001-typescript-language-service-engine.md`).
 
 - `outline`, `def` and the home view only parse files (`ts.createSourceFile`): no tsconfig needed, well under a second.
-- `refs`, `callers` and `impact` build a `LanguageService` over the nearest `tsconfig.json` (or an implicit project of every source file when none exists, with a warning) and ask it for references and call hierarchy. Symbol identity comes from the checker, so `user.save` resolves to `User.save` through imports and re-exports.
+- `refs`, `callers` and `impact` build a `LanguageService` over the nearest `tsconfig.json` (or an implicit project of every source file when none exists, with a warning; in a monorepo or an implicit project of more than 3000 files, over the importer subgraph described above) and ask it for references and call hierarchy. Symbol identity comes from the checker, so `user.save` resolves to `User.save` through imports and re-exports.
 - `impact` reads the "before" version of touched files with `git show` and compares signatures to classify each change (`added`, `removed`, `signature`, `body`, `type`, `modified`). Uses it cannot follow (access through `any`, dynamic string keys) are reported as `blind_spots`, never silently dropped.
+- Script-style JavaScript (AngularJS registrations, Meteor methods and helpers, `module.exports` objects, prototype methods, IIFE helpers) gets nested declarations with qualified names, so `outline` lists them and `impact` names the function an edit touches instead of a file-level change.
 - Type errors in the analysed project never block anything; they are reported as a `diagnostics` count.
 
 Every semantic command starts cold and prints `elapsed_ms`.

package/dist/src/commands/common.js

@@ -8,6 +8,7 @@ import { usageError } from "../errors.js";
 import { hasGlobMagic, matchesGlob } from "../glob.js";
 import { openProject } from "../project.js";
 import { loadSettings } from "../settings.js";
+import { byDepthThenPath } from "../walk.js";
 import { clip, didYouMean, groupSymbols, KINDS, kindOf, signatureOf, } from "../symbols.js";
 export const BODY_LINES = 60;
 export const CONTEXT_MAX = 100;
@@ -71,7 +72,15 @@ export function resolveNameTarget(ctx, target, f) {
         ...(target.member !== undefined ? { member: target.member } : {}),
         fuzzy: f.fuzzy,
     });
-    return groupSymbols(applyFilters(ctx, found, f));
+    // Shallowest path first: the canonical copy before nested duplicates.
+    return groupSymbols(applyFilters(ctx, found, f)).sort((a, b) => byDepthThenPath(a.primary.file, b.primary.file) || a.decls[0].nameLine - b.decls[0].nameLine);
+}
+/** `tsconfig: x (n referenced configs)` when a references-only tsconfig was expanded. */
+export function projectFields(ctx) {
+    const { tsconfig, referenced } = ctx.index.project;
+    if (!tsconfig || referenced === undefined)
+        return {};
+    return { tsconfig: `${relative(ctx.cwd, tsconfig).split(sep).join("/")} (${referenced} referenced configs)` };
 }
 export function suggestions(ctx, target) {
     const names = [...ctx.index.allNames()].filter((n) => (target.member === undefined ? !n.includes(".") : n.includes(".")));
@@ -87,35 +96,89 @@ export function positionOf(group) {
     const d = group.decls[0];
     return `${d.file}:${d.nameLine}`;
 }
+/** Ambiguity lists stop here; the narrowing hints cover the rest. */
+export const MATCH_ROWS = 20;
+/** `matches` (first MATCH_ROWS, shallowest first) plus `matches_total` / `truncated` past that. */
 export function matchRows(groups) {
-    return groups.map((g) => ({
+    const rows = groups.slice(0, MATCH_ROWS).map((g) => ({
         file: g.primary.file,
         line: g.decls[0].nameLine,
         kind: g.primary.kind,
         exported: g.primary.exported,
         signature: g.decls[0].signature,
     }));
+    return { matches: rows, ...(groups.length > MATCH_ROWS ? { matches_total: groups.length, truncated: true } : {}) };
+}
+function countBy(items, key) {
+    const counts = new Map();
+    for (const item of items) {
+        const k = key(item);
+        if (k !== undefined)
+            counts.set(k, (counts.get(k) ?? 0) + 1);
+    }
+    return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+}
+/** Longest common directory of `files` ('' when they share none). */
+function commonDir(files) {
+    const split = files.map((f) => posix.dirname(f).split("/").filter((p) => p !== "" && p !== "."));
+    const first = split[0] ?? [];
+    let n = 0;
+    while (n < first.length && split.every((parts) => parts[n] === first[n]))
+        n++;
+    return first.slice(0, n).join("/");
+}
+const IDENT_PART = /^[A-Za-z_$][\w$]*$/;
+/** Root-relative path → the form `--in` expects (relative to cwd). */
+function cwdGlob(ctx, rootRel) {
+    const prefix = relative(ctx.root, ctx.cwd).split(sep).join("/");
+    if (!prefix || prefix.startsWith(".."))
+        return rootRel;
+    return posix.relative(prefix, rootRel) || ".";
 }
-/** Concrete hints that narrow an ambiguous name to one Symbol. */
-export function narrowHints(command, groups, f, label) {
+/** Concrete hints that narrow an ambiguous name, computed from the matches themselves. */
+export function narrowHints(ctx, command, groups, f, label, target) {
+    const total = groups.length;
     const hints = groups.slice(0, 2).map((g) => `Run \`ts-axi ${command} ${positionOf(g)}\` for the one in ${g.primary.file}`);
-    const first = groups[0].primary;
-    const dirs = new Set(groups.map((g) => posix.dirname(g.primary.file)));
-    const dir = posix.dirname(first.file);
-    if (dirs.size > 1 && [...dirs].filter((d) => d === dir || d.startsWith(`${dir}/`)).length === 1) {
-        hints.push(`Run \`ts-axi ${command} ${label} --in ${dir}\` to keep matches below ${dir}`);
+    const files = groups.map((g) => g.primary.file);
+    // --in: the subtrees right below the common directory, largest first.
+    const prefix = commonDir(files);
+    const below = countBy(files, (file) => {
+        const rest = (prefix ? file.slice(prefix.length + 1) : file).split("/");
+        return rest.length > 1 ? posix.join(prefix, rest[0]) : file;
+    });
+    if (below.length > 1) {
+        for (const [dir, n] of below.slice(0, 2))
+            hints.push(`Run \`ts-axi ${command} ${label} --in ${cwdGlob(ctx, dir)}\` to keep ${n} of ${total}`);
+    }
+    else if (prefix) {
+        hints.push(`Run \`ts-axi ${command} ${label} --in ${cwdGlob(ctx, prefix)}\` - all ${total} are below ${prefix}`);
     }
-    else {
-        hints.push(`Run \`ts-axi ${command} ${label} --in ${first.file}\` to keep matches in one file`);
+    if (!f.kind) {
+        const kinds = countBy(groups, (g) => g.primary.kind);
+        if (kinds.length > 1)
+            for (const [kind, n] of kinds.slice(0, 3))
+                hints.push(`Run \`ts-axi ${command} ${label} --kind ${kind}\` to keep ${n} of ${total}`);
     }
-    const kinds = new Set(groups.map((g) => g.primary.kind));
-    if (kinds.size > 1 && !f.kind)
-        hints.push(`Run \`ts-axi ${command} ${label} --kind ${first.kind}\` to keep one kind`);
-    if (!f.exported && groups.some((g) => g.primary.exported) && groups.some((g) => !g.primary.exported)) {
-        hints.push(`Run \`ts-axi ${command} ${label} --exported\` to keep exported Declarations`);
+    if (target && target.member === undefined) {
+        const parents = countBy(groups, (g) => g.primary.parentName?.split(".").pop());
+        const distinct = parents.length > 1 || (parents.length === 1 && groups.some((g) => g.primary.parentName === undefined));
+        if (distinct) {
+            for (const [parent, n] of parents.filter(([p]) => IDENT_PART.test(p)).slice(0, 2)) {
+                hints.push(`Run \`ts-axi ${command} ${parent}.${target.name}${filterSuffixOf(label, target)}\` to keep ${n} of ${total}`);
+            }
+        }
+    }
+    const exported = groups.filter((g) => g.primary.exported).length;
+    if (!f.exported && exported > 0 && exported < total) {
+        hints.push(`Run \`ts-axi ${command} ${label} --exported\` to keep ${exported} of ${total}`);
     }
     return hints;
 }
+/** The flags part of a hint label (`label` = target + filter suffix). */
+function filterSuffixOf(label, target) {
+    const bare = target.member ? `${target.name}.${target.member}` : target.name;
+    return label.startsWith(bare) ? label.slice(bare.length) : "";
+}
 export function resolvePositionFile(cwd, file) {
     const abs = resolve(cwd, file);
     if (!existsSync(abs)) {
@@ -167,6 +230,10 @@ export function resolvePosition(index, cwd, target) {
         const hit = onLine.find((id) => id.getStart(sf) <= offset && offset <= id.end) ?? onLine.find((id) => id.getStart(sf) >= offset);
         return hit ? pick(hit) : { kind: "none", abs, file, reason: `no identifier at ${file}:${target.line}:${target.col}` };
     }
+    // A string-registered name has no identifier: its line stands for it.
+    const nameless = decls.find((d) => d.nameless && d.nameLine === target.line);
+    if (nameless)
+        return { kind: "decl", decl: nameless, abs };
     if (onLine.length === 0)
         return { kind: "none", abs, file, reason: `no identifier on ${file}:${target.line}` };
     const constructorDecl = decls.find((d) => d.nameLine === target.line && d.name === "constructor");

package/dist/src/commands/def.js

@@ -1,14 +1,14 @@
 import { bool, expectPositionals, flag, parseArgs } from "../args.js";
-import { createSemanticProject } from "../project.js";
+import { semanticFor } from "../scope.js";
 import { block, fenced, helpBlock, out } from "../render.js";
 import { isFunctionLike, kindFromScriptElement, parseTarget } from "../symbols.js";
-import { BODY_LINES, declarationAt, filterSuffix, matchRows, narrowHints, numberedLines, open, positionStartDir, resolveNameTarget, resolvePosition, suggestions, TARGET_FLAGS, targetLabel, readFilters, } from "./common.js";
+import { BODY_LINES, declarationAt, filterSuffix, MATCH_ROWS, matchRows, narrowHints, numberedLines, open, positionStartDir, resolveNameTarget, resolvePosition, suggestions, TARGET_FLAGS, targetLabel, readFilters, } from "./common.js";
 export const DEF_HELP = `usage: ts-axi def <name | Class.member | path:line[:col]> [flags]
 flags[7]:
   --kind <function|class|method|property|variable|interface|type|enum|enum-member|namespace>, --in <dir|glob> (repeatable; restrict to files), --exported, --fuzzy (substring, case-insensitive), --full (whole body; default first ${BODY_LINES} lines), -P <tsconfig>, --json
 output:
   1 match = file, line, kind, exported, signature + body fenced with file line numbers
-  several = matches[n]{file,line,kind,exported,signature} + how to narrow
+  several = matches[n]{file,line,kind,exported,signature} (at most ${MATCH_ROWS}; matches_total + truncated past that) + the narrowing forms (--in, --kind, Class.member, --exported) with how many each keeps
   none = matches: 0 + did_you_mean
 examples[5]:
   ts-axi def User
@@ -63,7 +63,7 @@ export async function defCommand(args, ctx) {
             return out(block({ position: label, identifiers: at.candidates }), helpBlock(at.candidates.slice(0, 3).map((c) => `Run \`ts-axi def ${at.file}:${c.line}:${c.col}\` for ${c.name}`)));
         }
         // A reference, not a Declaration: ask the checker where it is declared.
-        const semantic = createSemanticProject(opened.index);
+        const { semantic } = semanticFor(opened, [at.abs], 0);
         const def = semantic.definitionAt(at.abs, at.pos);
         const decl = def && def.line > 0 ? declarationAt(opened.index, def.absFile, def.pos, kindFromScriptElement(def.kind)) : undefined;
         if (!decl) {
@@ -91,6 +91,6 @@ export async function defCommand(args, ctx) {
     return out(block({
         ...(opened.warning ? { warning: opened.warning } : {}),
         symbol: label,
-        matches: matchRows(groups),
-    }), helpBlock(narrowHints("def", groups, f, `${label}${filterSuffix(f, project)}`)));
+        ...matchRows(groups),
+    }), helpBlock(narrowHints(opened, "def", groups, f, `${label}${filterSuffix(f, project)}`, target)));
 }

package/dist/src/commands/home.js

@@ -5,8 +5,9 @@ import { usageError } from "../errors.js";
 import { currentBranch, dirtyFileCount, isGitRepo } from "../git.js";
 import { block, helpBlock, out } from "../render.js";
 import { SETTINGS_FILE, isTestFile, loadSettings, readSettingsFile } from "../settings.js";
+import { listFiles, skipDir } from "../walk.js";
+import { detectWorkspace, hasMultiProjectSignal, isMultiProject } from "../workspace.js";
 const SOURCE_EXT = /\.(?:[cm]?[jt]s|[jt]sx)$/;
-const SKIP_DIRS = new Set(["node_modules", "dist", "build", ".git"]);
 /** The view runs at session start: bound the file walk by count and time. */
 const WALK_CAP = 20_000;
 const WALK_DEADLINE_MS = 600;
@@ -15,8 +16,8 @@ const HOME_SPECS = [
     { name: "--test-glob", repeatable: true },
     { name: "--project", alias: "-P" },
 ];
-/** Does `dir` hold a TS/JS source within `depth` levels (node_modules skipped)? */
-function hasSources(dir, depth) {
+/** Does `dir` hold a TS/JS source within `depth` levels (shared skip rule)? */
+function hasSources(dir, depth, root = dir) {
     let entries;
     try {
         entries = readdirSync(dir, { withFileTypes: true });
@@ -30,36 +31,11 @@ function hasSources(dir, depth) {
     }
     if (depth === 0)
         return false;
-    return entries.some((e) => e.isDirectory() && e.name !== "node_modules" && e.name !== ".git" && hasSources(join(dir, e.name), depth - 1));
+    return entries.some((e) => e.isDirectory() && !skipDir(e.name, join(dir, e.name), root) && hasSources(join(dir, e.name), depth - 1, root));
 }
-/** Implicit project: every source below `root`, minus node_modules, dist, build, .git. */
+/** Implicit project: every source below `root` from the shared listing (git, else a bounded fs walk). */
 function walkSources(root) {
-    const files = [];
-    const deadline = Date.now() + WALK_DEADLINE_MS;
-    let capped = false;
-    const stack = [root];
-    while (stack.length > 0 && !capped) {
-        const dir = stack.pop();
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                if (!SKIP_DIRS.has(entry.name))
-                    stack.push(join(dir, entry.name));
-            }
-            else if (entry.isFile() && SOURCE_EXT.test(entry.name)) {
-                files.push(join(dir, entry.name));
-            }
-        }
-        if (files.length >= WALK_CAP || Date.now() > deadline)
-            capped = true;
-    }
-    return { files, capped };
+    return listFiles(root, (name) => SOURCE_EXT.test(name) && !/\.d\.[mc]?ts$/.test(name), { maxFiles: WALK_CAP, deadline: Date.now() + WALK_DEADLINE_MS });
 }
 function findTsconfig(cwd) {
     let dir = cwd;
@@ -73,14 +49,16 @@ function findTsconfig(cwd) {
         dir = parent;
     }
 }
-async function tsconfigFiles(tsconfig) {
-    const ts = (await import("typescript")).default;
-    const read = ts.readConfigFile(tsconfig, ts.sys.readFile);
-    if (read.error)
+async function tsconfigFiles(tsconfig, root) {
+    // Loaded lazily: the TypeScript module is only needed when a tsconfig exists.
+    const { loadProject } = await import("../project.js");
+    try {
+        const project = loadProject(root, { path: tsconfig, implicit: false });
+        return { files: project.fileNames, capped: false, ...(project.referenced !== undefined ? { referenced: project.referenced } : {}) };
+    }
+    catch {
         return { files: [], capped: false };
-    const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, dirname(tsconfig), undefined, tsconfig);
-    const files = parsed.fileNames.filter((f) => !f.split(/[\\/]/).includes("node_modules"));
-    return { files, capped: false };
+    }
 }
 function rel(root, path) {
     return relative(root, path).split(sep).join("/") || ".";
@@ -112,17 +90,24 @@ function resolveTsconfig(cwd, settings) {
     }
     return findTsconfig(cwd);
 }
-export async function homeCommand(args) {
+export async function homeCommand(args, ctx) {
     const parsed = parseArgs(args, HOME_SPECS, "ts-axi");
     expectPositionals(parsed, 0, "ts-axi [-P <tsconfig>] [--test-glob <glob>]");
-    const cwd = process.cwd();
+    const cwd = ctx?.cwd ?? process.cwd();
     const project = flag(parsed, "--project");
     const settings = loadSettings(cwd, {
         testGlobs: flags(parsed, "--test-glob"),
         ...(project !== undefined ? { project } : {}),
     });
     const tsconfig = resolveTsconfig(cwd, settings);
-    if (tsconfig === undefined && !hasSources(cwd, PROBE_DEPTH)) {
+    // Same rule as the semantic commands: no explicit project + a multi-project workspace = workspace scope.
+    let workspace;
+    if (settings.project === undefined && (tsconfig === undefined || hasMultiProjectSignal(settings.root))) {
+        const detected = detectWorkspace(settings.root);
+        if (isMultiProject(detected.kind))
+            workspace = detected;
+    }
+    if (tsconfig === undefined && workspace === undefined && !hasSources(cwd, PROBE_DEPTH)) {
         return out(block({ project: "none" }), helpBlock([
             "Run `ts-axi outline <file>` on any .ts/.js file; it needs no project",
             "Run `ts-axi --help` for all commands",
@@ -130,7 +115,9 @@ export async function homeCommand(args) {
     }
     const [git, counted] = await Promise.all([
         gitSummary(cwd),
-        tsconfig !== undefined ? tsconfigFiles(tsconfig) : Promise.resolve(walkSources(settings.root)),
+        workspace
+            ? Promise.resolve({ files: workspace.sourceFiles, capped: false })
+            : tsconfig !== undefined ? tsconfigFiles(tsconfig, settings.root) : Promise.resolve(walkSources(settings.root)),
     ]);
     const testFiles = counted.files.filter((f) => isTestFile(rel(settings.root, f), settings)).length;
     const plus = counted.capped ? "+" : "";
@@ -143,7 +130,12 @@ export async function homeCommand(args) {
     help.push("Run `ts-axi outline <file>` to list the declarations in a file", "Run `ts-axi def <name>` to find where a symbol is declared", "Run `ts-axi config` to see or change the test-file globs", "Run `ts-axi --help` for all commands");
     return out(block({
         root: settings.root,
-        tsconfig: tsconfig === undefined ? "implicit" : rel(settings.root, tsconfig),
+        ...(workspace ? { workspace: `${workspace.kind} (${workspace.projects.length} projects)` } : {}),
+        tsconfig: workspace
+            ? "nearest per file - workspace scope"
+            : tsconfig === undefined
+                ? "implicit"
+                : `${rel(settings.root, tsconfig)}${counted.referenced !== undefined ? ` (${counted.referenced} referenced configs)` : ""}`,
         source_files: counted.capped ? `${counted.files.length}${plus}` : counted.files.length,
         test_globs: settings.testGlobs.length,
         test_files: counted.capped ? `${testFiles}${plus}` : testFiles,

package/dist/src/commands/impact.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join, relative, sep } from "node:path";
 import ts from "typescript";
 import { bool, intFlag, parseArgs, flag } from "../args.js";
@@ -6,17 +6,18 @@ import { changedRanges, parseUnifiedDiff } from "../diff.js";
 import { AxiError, usageError } from "../errors.js";
 import { diffNameStatus, diffUnified, isGitRepo, resolveBaseRev, showFile, untrackedFiles } from "../git.js";
 import { allocateBudget, classifyFile, compareChanges, formatRanges, inRanges, localOnlyLine, matchKey, reverseApply, wordMatches, } from "../impact.js";
-import { createSemanticProject, loadProject, SOURCE_EXTENSIONS } from "../project.js";
+import { loadProject, SOURCE_EXTENSIONS } from "../project.js";
 import { block, helpBlock, out } from "../render.js";
 import { isTestFile } from "../settings.js";
 import { isFunctionLike } from "../symbols.js";
-import { contextOf, lineOf, open } from "./common.js";
+import { IMPACT_HOPS, scopeFields, scopeHelp, semanticFor } from "../scope.js";
+import { walkFiles } from "../walk.js";
+import { contextOf, lineOf, open, projectFields } from "./common.js";
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 500;
 const SIDE_ROWS = 20;
 /** Non-TS files `--grep` also searches: templates that use TS exports the checker never sees. */
 const GREP_EXTRA = [".astro", ".vue", ".svelte", ".mdx", ".html"];
-const SKIP_DIRS = new Set(["node_modules", "dist", "build", "coverage"]);
 export const IMPACT_HELP = `usage: ts-axi impact [<git-range> | -] [flags]
 input:
   (none) = working tree vs HEAD (staged + unstaged + untracked); --staged = index vs HEAD
@@ -34,6 +35,7 @@ output:
   blind_spots[n]{symbol,file,line,reason} = uses the checker cannot follow (any; string keys; unresolved export *)
   skipped[n]{file,reason} = files in the diff that were not analysed (.astro, .json, outside the Project)
   tests: 0 on an exported signature or body change = no Test file references it
+  scope = in a monorepo without -P the program is the touched files + two levels of importers (scope_partial: true when capped)
 examples[5]:
   ts-axi impact
   ts-axi impact --staged
@@ -223,24 +225,10 @@ function blindSpots(semantic, names, changeSet) {
     return spots;
 }
 function walkExtra(dir, outFiles) {
-    let entries;
-    try {
-        entries = readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith("."))
-                walkExtra(join(dir, entry.name), outFiles);
-        }
-        else if (GREP_EXTRA.some((ext) => entry.name.endsWith(ext))) {
-            outFiles.push(join(dir, entry.name));
-        }
-    }
+    outFiles.push(...walkFiles(dir, { accept: (name) => GREP_EXTRA.some((ext) => name.endsWith(ext)) }).files);
 }
-function textualMatches(opened, semantic, names, known, skipLines, changeSet) {
+/** Whole-word matches of `names` in Project files and templates that are not `known` References. */
+export function textualMatches(opened, semantic, names, known, skipLines, changeSet) {
     const files = [...semantic.projectFiles];
     const projectSet = new Set(files);
     walkExtra(opened.root, files);
@@ -324,7 +312,7 @@ function rerun(arg, parsed, extra) {
  * them): name the sibling tsconfig that includes them so tests get counted.
  */
 function specFilesHint(cwd, opened, skipped, noTests) {
-    const tsconfig = opened.location.path;
+    const tsconfig = opened.index.project.tsconfig;
     if (!tsconfig)
         return undefined;
     const outside = skipped.filter((s) => s.reason === "not in the Project");
@@ -410,6 +398,7 @@ export async function impactCommand(args, ctx) {
     const total = declChanges.length + fileLevel.length;
     const header = {
         ...(warnings.length > 0 ? { warning: warnings.join("; ") } : {}),
+        ...projectFields(opened),
         base: input.base,
         head: input.head,
         changes: total,
@@ -432,7 +421,8 @@ export async function impactCommand(args, ctx) {
         }), helpBlock(help));
     }
     // --- References (semantic, on the checkout) ---
-    const semantic = createSemanticProject(opened.index);
+    // Scoped workspace: touched files + two levels of importers; deleted or renamed-away paths still resolve so their importers count.
+    const { semantic, scope } = semanticFor(opened, analysed.filter((f) => f.status !== "deleted").map((f) => opened.index.abs(f.path)), IMPACT_HOPS, analysed.flatMap((f) => (f.status === "deleted" ? [f.path] : f.oldPath ? [f.oldPath] : [])).map((p) => opened.index.abs(p)));
     const rows = declChanges.map((change) => {
         const source = change.after ?? change.before;
         const live = change.after ? opened.index.declarations(opened.index.abs(change.file)).find((d) => matchKey(d) === change.key) : undefined;
@@ -536,6 +526,7 @@ export async function impactCommand(args, ctx) {
     const specHint = specFilesHint(ctx.cwd, opened, skipped, listed.every((r) => fileCounts(r).tests === 0));
     if (specHint)
         help.push(specHint);
+    help.push(...scopeHelp(scope));
     const notes = rows
         .filter((r) => r.change.change === "signature" && r.bases.length > 0)
         .map((r) => ({ symbol: r.symbol, note: `implements ${r.bases.join(" and ")}` }));
@@ -565,6 +556,7 @@ export async function impactCommand(args, ctx) {
         ...(grep ? capped("unresolved", unresolved) : {}),
         ...depthLevels(semantic, rows, depth),
         ...skippedBlock,
+        ...scopeFields(scope),
         elapsed_ms: Math.round(performance.now() - started),
         ...(diagnostics > 0 ? { diagnostics } : {}),
     }), helpBlock(help));