ts-axi 0.1.2 → 0.1.4

package/dist/src/project.js

@@ -1,13 +1,16 @@
 // Project discovery and the two engine paths (ADR 0001): a syntactic index
 // over `ts.createSourceFile`, and a LanguageService for semantic queries.
-import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import ts from "typescript";
 import { usageError } from "./errors.js";
 import { classifyReferenceGroups } from "./references.js";
 import { collectDeclarations } from "./symbols.js";
+import { byDepthThenPath, listFiles } from "./walk.js";
+import { detectWorkspace, hasMultiProjectSignal, isMultiProject } from "./workspace.js";
 export const SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
-const SKIP_DIRS = new Set(["node_modules", "dist", "build", ".git"]);
+/** An implicit project above this many files is analysed by importer subgraph, not as a whole. */
+export const IMPLICIT_SCOPE_THRESHOLD = 3_000;
 export const IMPLICIT_WARNING = "no tsconfig.json found - implicit project";
 function real(path) {
     try {
@@ -65,29 +68,9 @@ export function discoverTsconfig(startDir, options = {}) {
 function isSourceFile(name) {
     return SOURCE_EXTENSIONS.some((ext) => name.endsWith(ext)) && !/\.d\.[mc]?ts$/.test(name);
 }
-/** Every source file below `root`, minus node_modules/dist/build/.git and `.d.ts`. */
+/** Every source file below `root` from the shared listing (`src/walk.ts`: git, else fs walk), minus `.d.ts`. */
 export function walkSourceFiles(root) {
-    const files = [];
-    const visit = (dir) => {
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                if (!SKIP_DIRS.has(entry.name))
-                    visit(join(dir, entry.name));
-            }
-            else if (entry.isFile() && isSourceFile(entry.name)) {
-                files.push(join(dir, entry.name));
-            }
-        }
-    };
-    visit(root);
-    return files.sort();
+    return listFiles(root, isSourceFile).files;
 }
 export const IMPLICIT_COMPILER_OPTIONS = {
     allowJs: true,
@@ -101,6 +84,52 @@ export const IMPLICIT_COMPILER_OPTIONS = {
     jsx: ts.JsxEmit.Preserve,
     resolveJsonModule: true,
 };
+function readTsconfig(path) {
+    const read = ts.readConfigFile(path, ts.sys.readFile);
+    if (read.error)
+        return undefined;
+    return ts.parseJsonConfigFileContent(read.config, ts.sys, dirname(path), undefined, path);
+}
+function sourceNames(parsed) {
+    return parsed.fileNames
+        .map((f) => resolve(f))
+        .filter((f) => !f.split(sep).includes("node_modules") && SOURCE_EXTENSIONS.some((ext) => f.endsWith(ext)));
+}
+/**
+ * The configs a tsconfig stands for: itself, or - when it has `references` and no files of its
+ * own (an Nx project shell) - its referenced configs, recursively and deduplicated.
+ */
+export function expandTsconfig(path) {
+    const result = [];
+    const seen = new Set();
+    const visit = (file) => {
+        const abs = real(file);
+        if (seen.has(abs))
+            return;
+        seen.add(abs);
+        const parsed = readTsconfig(abs);
+        if (!parsed)
+            return;
+        const fileNames = sourceNames(parsed);
+        const refs = parsed.projectReferences ?? [];
+        if (fileNames.length === 0 && refs.length > 0) {
+            for (const ref of refs) {
+                const target = ts.resolveProjectReferencePath(ref);
+                if (existsSync(target))
+                    visit(target);
+            }
+            return;
+        }
+        result.push({ path: abs, fileNames, options: parsed.options });
+    };
+    visit(path);
+    return result;
+}
+/** One config's options for a union: the first config's, with every config's `types` merged. */
+function unionOptions(configs) {
+    const types = configs.some((c) => c.options.types === undefined) ? undefined : [...new Set(configs.flatMap((c) => c.options.types ?? []))];
+    return { ...configs[0].options, ...(types ? { types } : {}) };
+}
 /** Resolve the Project's file list and compiler options. Cheap: reads directories, parses no source. */
 export function loadProject(root, location) {
     if (!location.path) {
@@ -110,11 +139,14 @@ export function loadProject(root, location) {
     if (read.error) {
         throw usageError(`cannot read ${location.path} - ${ts.flattenDiagnosticMessageText(read.error.messageText, " ")}`);
     }
-    const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, dirname(location.path), undefined, location.path);
-    const fileNames = parsed.fileNames
-        .map((f) => resolve(f))
-        .filter((f) => !f.split(sep).includes("node_modules") && SOURCE_EXTENSIONS.some((ext) => f.endsWith(ext)));
-    return { root, tsconfig: location.path, implicit: false, fileNames, options: { ...parsed.options, noEmit: true } };
+    const configs = expandTsconfig(location.path);
+    const self = configs.length === 1 && configs[0].path === real(location.path);
+    if (self || configs.length === 0) {
+        const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, dirname(location.path), undefined, location.path);
+        return { root, tsconfig: location.path, implicit: false, fileNames: sourceNames(parsed), options: { ...parsed.options, noEmit: true } };
+    }
+    const fileNames = [...new Set(configs.flatMap((c) => c.fileNames))].sort();
+    return { root, tsconfig: location.path, implicit: false, fileNames, options: { ...unionOptions(configs), noEmit: true }, referenced: configs.length };
 }
 function scriptKind(file) {
     if (file.endsWith(".tsx"))
@@ -148,47 +180,25 @@ const OUTSIDE_WALK_CAP = 20_000;
 const OUTSIDE_WALK_MS = 600;
 /**
  * Declarations matching `query` in source files below the repo root that are not in the Project
- * (syntactic, bounded by file count and time; stops after `max` hits).
+ * (syntactic; the fs fallback is bounded by file count and time; at most `max` hits, shallowest paths first).
  */
 export function findOutsideProject(index, query, max = 3) {
     const inProject = new Set(index.files);
-    const deadline = Date.now() + OUTSIDE_WALK_MS;
+    const { files } = listFiles(index.root, isSourceFile, { maxFiles: OUTSIDE_WALK_CAP, deadline: Date.now() + OUTSIDE_WALK_MS });
     const hits = [];
-    const stack = [index.root];
-    let visited = 0;
-    while (stack.length > 0 && hits.length < max && visited < OUTSIDE_WALK_CAP && Date.now() <= deadline) {
-        const dir = stack.pop();
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
+    for (const path of files.sort((a, b) => byDepthThenPath(index.rel(a), index.rel(b)))) {
+        if (inProject.has(path))
             continue;
-        }
-        for (const entry of entries.sort((a, b) => b.name.localeCompare(a.name))) {
-            const path = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (!SKIP_DIRS.has(entry.name))
-                    stack.push(path);
-                continue;
-            }
-            if (!entry.isFile() || !isSourceFile(entry.name) || inProject.has(path))
-                continue;
-            visited++;
-            const text = index.text(path);
-            if (text === undefined || !text.includes(query.name))
-                continue;
-            for (const decl of index.declarations(path)) {
-                if (declMatches(decl, query))
-                    hits.push(decl);
-                if (hits.length >= max)
-                    break;
-            }
-            if (hits.length >= max)
-                break;
-        }
+        const text = index.text(path);
+        if (text === undefined || !text.includes(query.name))
+            continue;
+        for (const decl of index.declarations(path))
+            if (declMatches(decl, query))
+                hits.push(decl);
+        if (hits.length >= max)
+            break;
     }
-    return hits.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+    return hits.slice(0, max).sort((a, b) => byDepthThenPath(a.file, b.file) || a.line - b.line);
 }
 /** Nearest `tsconfig.json` from the directory of `abs` up to `root` (inclusive). */
 export function nearestTsconfig(abs, root) {
@@ -268,19 +278,21 @@ export function createSyntacticIndex(root, project) {
     return index;
 }
 const FULL_DIAGNOSTICS_LIMIT = 300;
-export function createSemanticProject(index) {
+export function createSemanticProject(index, scope) {
     const started = performance.now();
     const { project } = index;
-    const fileNames = project.fileNames;
+    const fileNames = scope?.rootNames ?? project.fileNames;
+    const options = scope?.options ?? project.options;
     const snapshots = new Map();
-    const currentDirectory = project.tsconfig ? dirname(project.tsconfig) : index.root;
+    const currentDirectory = scope?.currentDirectory ?? (project.tsconfig ? dirname(project.tsconfig) : index.root);
+    const indexed = new Set(index.files);
     const host = {
-        getCompilationSettings: () => project.options,
+        getCompilationSettings: () => options,
         getScriptFileNames: () => fileNames,
         getScriptVersion: () => "1",
         getScriptSnapshot(file) {
             if (!snapshots.has(file)) {
-                const text = index.files.includes(file) ? index.text(file) : ts.sys.readFile(file);
+                const text = indexed.has(file) ? index.text(file) : ts.sys.readFile(file);
                 snapshots.set(file, text === undefined ? undefined : ts.ScriptSnapshot.fromString(text));
             }
             return snapshots.get(file);
@@ -513,7 +525,8 @@ export function createSemanticProject(index) {
             return service.getQuickInfoAtPosition(absFile, pos);
         },
         diagnosticsCount(touched = []) {
-            const files = projectFiles.length <= FULL_DIAGNOSTICS_LIMIT ? projectFiles : touched.map((f) => index.abs(f));
+            // A subgraph program mixes projects under one set of options: count the touched files only.
+            const files = !scope && projectFiles.length <= FULL_DIAGNOSTICS_LIMIT ? projectFiles : touched.map((f) => index.abs(f));
             let count = 0;
             for (const file of files) {
                 const sf = program.getSourceFile(file);
@@ -526,7 +539,21 @@ export function createSemanticProject(index) {
         elapsedMs: () => Math.round(performance.now() - started),
     };
 }
-/** Repo root + tsconfig discovery + syntactic index in one call. */
+/** The workspace as one file set; each semantic command scopes its own program from it. */
+function scopedProject(root, workspace, implicit) {
+    return {
+        root,
+        tsconfig: null,
+        implicit,
+        fileNames: workspace.sourceFiles,
+        options: IMPLICIT_COMPILER_OPTIONS,
+        scope: { workspace, kind: implicit ? "implicit" : workspace.kind },
+    };
+}
+/**
+ * Repo root + tsconfig discovery + syntactic index in one call. Without `-P` / `.ts-axi.json`
+ * `project`, a multi-project workspace (or a large implicit project) becomes one scoped file set.
+ */
 export function openProject(cwd, options = {}) {
     const root = findRepoRoot(cwd);
     const location = discoverTsconfig(options.startDir ?? cwd, {
@@ -536,6 +563,16 @@ export function openProject(cwd, options = {}) {
         settingsRoot: options.settingsRoot ?? root,
         ...(existsSync(join(root, ".git")) ? { stopAt: root } : {}),
     });
-    const index = createSyntacticIndex(root, loadProject(root, location));
-    return { cwd, root, location, index, ...(location.implicit ? { warning: IMPLICIT_WARNING } : {}) };
+    const explicit = options.override !== undefined || options.settingsProject !== undefined;
+    let project;
+    if (!explicit && (location.implicit || hasMultiProjectSignal(root))) {
+        const workspace = detectWorkspace(root);
+        if (isMultiProject(workspace.kind))
+            project = scopedProject(root, workspace, false);
+        else if (location.implicit && workspace.sourceFiles.length > IMPLICIT_SCOPE_THRESHOLD)
+            project = scopedProject(root, workspace, true);
+    }
+    project ??= loadProject(root, location);
+    const index = createSyntacticIndex(root, project);
+    return { cwd, root, location, index, ...(project.implicit ? { warning: IMPLICIT_WARNING } : {}) };
 }

package/dist/src/scope.js

@@ -0,0 +1,119 @@
+// Scoped program for semantic commands in a workspace: seed files + their importers (syntactic
+// importer index), compiled with the seed's own tsconfig plus the workspace `paths`.
+import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
+import ts from "typescript";
+import { buildImporterIndex, createResolver, importerClosure } from "./importers.js";
+import { createSemanticProject, expandTsconfig, IMPLICIT_COMPILER_OPTIONS, nearestTsconfig, } from "./project.js";
+import { IMPORTER_MAX_FILES, IMPORTER_MAX_MS } from "./importers.js";
+import { kindLabel, readJsonc } from "./workspace.js";
+/** Importer hops: refs/callers need the declaring file's importers (barrels free), impact two levels. */
+export const REFS_HOPS = 1;
+export const IMPACT_HOPS = 2;
+const indexes = new WeakMap();
+/** The workspace importer index (in memory for this process only); `extra` = paths that resolve although absent (deleted files). */
+export function importerIndexFor(index, workspace, extra = []) {
+    const key = [...extra].sort().join("\n");
+    let byKey = indexes.get(workspace);
+    if (!byKey)
+        indexes.set(workspace, (byKey = new Map()));
+    let built = byKey.get(key);
+    if (!built) {
+        const resolveSpec = createResolver(workspace, new Set([...workspace.sourceFiles, ...extra]));
+        built = buildImporterIndex(workspace.sourceFiles, (f) => index.text(f), resolveSpec, { maxFiles: IMPORTER_MAX_FILES, maxMs: IMPORTER_MAX_MS });
+        byKey.set(key, built);
+    }
+    return built;
+}
+/** Options that would make a subgraph program error on files outside one project's layout. */
+const DROPPED_OPTIONS = ["composite", "incremental", "tsBuildInfoFile", "rootDir", "rootDirs", "outDir", "outFile", "declaration", "declarationMap", "emitDeclarationOnly", "sourceMap"];
+/** The seed's nearest tsconfig (its referenced config that includes the seed, for a references-only shell) + workspace `paths`. */
+export function compilerOptionsFor(seed, workspace) {
+    let options;
+    const tsconfig = nearestTsconfig(seed, workspace.root);
+    if (tsconfig) {
+        const configs = expandTsconfig(tsconfig);
+        const picked = (configs.find((c) => c.fileNames.includes(seed)) ?? configs[0])?.options;
+        // Importers include spec files: give them the spec config's globals too.
+        const types = configs.some((c) => c.options.types === undefined) ? undefined : [...new Set(configs.flatMap((c) => c.options.types ?? []))];
+        options = picked && types ? { ...picked, types } : picked;
+    }
+    if (!options) {
+        const base = join(workspace.root, "tsconfig.base.json");
+        const raw = existsSync(base) ? readJsonc(base)?.["compilerOptions"] : undefined;
+        options = raw ? { ...IMPLICIT_COMPILER_OPTIONS, ...ts.convertCompilerOptionsFromJson(raw, dirname(base), base).options } : { ...IMPLICIT_COMPILER_OPTIONS };
+    }
+    const merged = { ...options, noEmit: true, skipLibCheck: true };
+    for (const key of DROPPED_OPTIONS)
+        delete merged[key];
+    if (!merged.paths && workspace.paths) {
+        merged.paths = workspace.paths.paths;
+        // Internal option TypeScript sets from the tsconfig that declares `paths`; avoids the deprecated baseUrl.
+        merged["pathsBasePath"] = workspace.paths.base;
+    }
+    // Workspace packages resolve to their sources, not to a built `dist` behind a node_modules link.
+    const resolveSpec = createResolver({ packages: workspace.packages }, new Set(workspace.sourceFiles));
+    const packagePaths = {};
+    for (const pkg of workspace.packages) {
+        for (const sub of Object.keys(pkg.exports)) {
+            if (sub.includes("*"))
+                continue;
+            const spec = sub === "." ? pkg.name : `${pkg.name}/${sub.slice(2)}`;
+            if (merged.paths?.[spec])
+                continue;
+            const target = resolveSpec(spec, workspace.root);
+            if (target)
+                packagePaths[spec] = [target];
+        }
+    }
+    if (Object.keys(packagePaths).length > 0) {
+        if (!merged.paths)
+            merged["pathsBasePath"] = workspace.root;
+        merged.paths = { ...packagePaths, ...merged.paths };
+    }
+    return merged;
+}
+/** Root files and options of the subgraph program around `seeds`. */
+export function planScope(index, seeds, hops, extra = []) {
+    const scope = index.project.scope;
+    const { workspace } = scope;
+    const importers = hops > 0 ? importerIndexFor(index, workspace, extra) : undefined;
+    const closure = importers ? importerClosure(importers, [...seeds, ...extra], hops) : { importers: [], barrels: [] };
+    const seedFiles = seeds.filter((s) => existsSync(s));
+    const rootNames = [...new Set([...seedFiles, ...closure.importers])];
+    const options = compilerOptionsFor(seedFiles[0] ?? seeds[0] ?? join(workspace.root, "index.ts"), workspace);
+    if (rootNames.some((f) => /\.[mc]?jsx?$/.test(f))) {
+        options.allowJs = true;
+        options.checkJs = false;
+    }
+    return {
+        program: { rootNames, options, currentDirectory: workspace.root },
+        info: {
+            line: `${kindLabel(scope.kind)} - ${rootNames.length} of ${workspace.sourceFiles.length} files (seeds ${seedFiles.length}; importers ${closure.importers.length})`,
+            partial: importers?.partial ?? false,
+            scanned: importers?.scanned ?? 0,
+            total: workspace.sourceFiles.length,
+        },
+    };
+}
+/** A LanguageService over the Project, or over the importer subgraph of `seeds` when the Project is scoped. */
+export function semanticFor(ctx, seeds, hops, extra = []) {
+    if (!ctx.index.project.scope)
+        return { semantic: createSemanticProject(ctx.index) };
+    const { program, info } = planScope(ctx.index, seeds, hops, extra);
+    return { semantic: createSemanticProject(ctx.index, program), scope: info };
+}
+/** `scope` / `scope_partial` fields for a semantic command's output. */
+export function scopeFields(scope) {
+    if (!scope)
+        return {};
+    return { scope: scope.line, ...(scope.partial ? { scope_partial: true } : {}) };
+}
+/** Help line when the importer scan stopped early. */
+export function scopeHelp(scope) {
+    if (!scope?.partial)
+        return [];
+    return [
+        `Importer scan stopped after ${scope.scanned} of ${scope.total} files (cap ${IMPORTER_MAX_FILES} files or ${IMPORTER_MAX_MS / 1000} s) - importers in the rest are missing; run with -P <tsconfig> for one whole project`,
+    ];
+}