feat(compilers): add getInheritedFileScope to resolve include/exclude via extends chain

Introduce getInheritedFileScope which traverses the tsconfig extends chain to
find include and exclude patterns independently, respecting TypeScript's overwrite
(not merge) semantics. This replaces the previous approach of reading only the
raw JSON of the immediate tsconfig file, which missed patterns inherited from
ancestor configs (e.g. tsconfig.vue.json → tsconfig.json → tsconfig.build.json).

Update getTsIncludeFiles and getTsExcludeFiles to use getInheritedFileScope,
removing the fileNames absolute-path fallback which was semantically inconsistent
with the glob-pattern contract expected by IncludeContainer. Fix createBuildOptions
to pass projectFilePath (tsconfig file path) and the correct projectDirPath
(directory, not file path) to both functions.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: imjuni

examples/tsconfig.inherit.array-extends.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["./tsconfig.inherit.base.json"]
+}

examples/tsconfig.inherit.base.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "strict": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.vue"],
+  "exclude": ["dist/**", "node_modules/**"]
+}

examples/tsconfig.inherit.invalid-extends.json

@@ -0,0 +1,4 @@
+{
+  "extends": [123],
+  "include": ["src/**/*.ts"]
+}

examples/tsconfig.inherit.leaf.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig.inherit.mid.json"
+}

examples/tsconfig.inherit.mid.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.inherit.base.json",
+  "exclude": ["dist/**", "node_modules/**", "**/*.test.ts"]
+}

examples/tsconfig.inherit.no-ext.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig.inherit.base"
+}

examples/tsconfig.inherit.no-include.json

@@ -0,0 +1,6 @@
+{
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["dist/**"]
+}

examples/tsconfig.inherit.override.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.inherit.base.json",
+  "include": ["src/**/*.ts"]
+}

src/compilers/__tests__/get.inherited.file.scope.test.ts

@@ -0,0 +1,94 @@
+import { getInheritedFileScope } from '#/compilers/getInheritedFileScope';
+import { posixJoin } from '#/modules/path/modules/posixJoin';
+import { describe, expect, it } from 'vitest';
+
+const examplesDir = posixJoin(process.cwd(), 'examples');
+
+describe('getInheritedFileScope', () => {
+  it('returns include and exclude directly declared in the file', () => {
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.inherit.base.json');
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result.include).toEqual(['src/**/*.ts', 'src/**/*.vue']);
+    expect(result.exclude).toEqual(['dist/**', 'node_modules/**']);
+  });
+
+  it('inherits include from base when child has no include', () => {
+    // tsconfig.inherit.mid.json extends base and has only exclude
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.inherit.mid.json');
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result.include).toEqual(['src/**/*.ts', 'src/**/*.vue']);
+    expect(result.exclude).toEqual(['dist/**', 'node_modules/**', '**/*.test.ts']);
+  });
+
+  it('traverses two levels to find include', () => {
+    // tsconfig.inherit.leaf.json → mid (no include) → base (has include)
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.inherit.leaf.json');
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result.include).toEqual(['src/**/*.ts', 'src/**/*.vue']);
+    expect(result.exclude).toEqual(['dist/**', 'node_modules/**', '**/*.test.ts']);
+  });
+
+  it('child include overrides base include', () => {
+    // tsconfig.inherit.override.json extends base but declares its own include
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.inherit.override.json');
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result.include).toEqual(['src/**/*.ts']);
+    expect(result.exclude).toEqual(['dist/**', 'node_modules/**']);
+  });
+
+  it('returns empty arrays when no include or exclude found in chain', () => {
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.empty.json');
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result.include).toEqual([]);
+    expect(result.exclude).toEqual([]);
+  });
+
+  it('returns only exclude when chain has no include', () => {
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.inherit.no-include.json');
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result.include).toEqual([]);
+    expect(result.exclude).toEqual(['dist/**']);
+  });
+
+  it('does not loop infinitely on a non-existent extends target', () => {
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.inherit.base.json');
+    // base has no extends, so traversal stops after one file
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result).toBeDefined();
+  });
+
+  it('handles array extends (TypeScript 5.0+) and inherits include from the first entry', () => {
+    // tsconfig.inherit.array-extends.json: { "extends": ["./tsconfig.inherit.base.json"] }
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.inherit.array-extends.json');
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result.include).toEqual(['src/**/*.ts', 'src/**/*.vue']);
+    expect(result.exclude).toEqual(['dist/**', 'node_modules/**']);
+  });
+
+  it('resolves extends path that omits the .json extension', () => {
+    // tsconfig.inherit.no-ext.json: { "extends": "./tsconfig.inherit.base" }
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.inherit.no-ext.json');
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result.include).toEqual(['src/**/*.ts', 'src/**/*.vue']);
+    expect(result.exclude).toEqual(['dist/**', 'node_modules/**']);
+  });
+
+  it('stops traversal when extends array contains a non-string entry', () => {
+    // tsconfig.inherit.invalid-extends.json: { "extends": [123], "include": [...] }
+    // has its own include, but extends[0] is a number → traversal stops before following parent
+    const tsconfigPath = posixJoin(examplesDir, 'tsconfig.inherit.invalid-extends.json');
+    const result = getInheritedFileScope(tsconfigPath);
+
+    expect(result.include).toEqual(['src/**/*.ts']);
+    expect(result.exclude).toEqual([]);
+  });
+});

src/compilers/getInheritedFileScope.ts

@@ -0,0 +1,60 @@
+import { getFileScope } from '#/compilers/getFileScope';
+import path from 'node:path';
+import * as tsm from 'ts-morph';
+
+interface IFileScope {
+  include: string[];
+  exclude: string[];
+}
+
+/**
+ * Traverse the tsconfig extends chain and collect include/exclude patterns.
+ *
+ * TypeScript's extends is an overwrite (not merge): the most-derived config wins.
+ * include and exclude are resolved independently — each comes from the first file
+ * in the chain that explicitly declares it.
+ *
+ * @param tsconfigPath - absolute path to the tsconfig file
+ */
+export function getInheritedFileScope(tsconfigPath: string): IFileScope {
+  const visited = new Set<string>();
+  let currentPath = path.resolve(tsconfigPath);
+  let foundInclude: string[] | null = null;
+  let foundExclude: string[] | null = null;
+
+  while (!visited.has(currentPath)) {
+    visited.add(currentPath);
+
+    const configFile = tsm.ts.readConfigFile(currentPath, tsm.ts.sys.readFile.bind(tsm.ts));
+    if (configFile.error != null) break;
+
+    const { include, exclude } = getFileScope(configFile.config);
+
+    if (foundInclude == null && include.length > 0) {
+      foundInclude = include;
+    }
+
+    if (foundExclude == null && exclude.length > 0) {
+      foundExclude = exclude;
+    }
+
+    if (foundInclude != null && foundExclude != null) break;
+
+    const raw = configFile.config as { extends?: unknown };
+    const extendsValue: unknown = raw.extends;
+    if (extendsValue == null) break;
+
+    // TypeScript 5.0+ supports array extends; earlier versions use a string
+    const extendsEntries: unknown[] = Array.isArray(extendsValue) ? extendsValue : [extendsValue];
+    const firstExtends: unknown = extendsEntries[0];
+    if (typeof firstExtends !== 'string') break;
+
+    const resolved = path.resolve(path.dirname(currentPath), firstExtends);
+    currentPath = resolved.endsWith('.json') ? resolved : `${resolved}.json`;
+  }
+
+  return {
+    include: foundInclude ?? [],
+    exclude: foundExclude ?? [],
+  };
+}