gitnexus 1.6.12-rc.21 → 1.6.12-rc.23

package/dist/core/ingestion/languages/typescript/tsconfig.d.ts

@@ -19,6 +19,7 @@
  * So this module answers the question TypeScript actually asks: for THIS file,
  * what are `baseUrl` and `paths`?
  */
+import path from 'path';
 /** One `paths` entry, pattern and targets kept in declaration order. */
 export interface TsPathMapping {
     /** The pattern as written, e.g. `@/*`, `@app/*`, `exact`. */
@@ -57,3 +58,17 @@ export interface TsconfigIndex {
 export declare function tsconfigFor(index: TsconfigIndex | null, filePath: string): TsconfigScope | null;
 /** Load every tsconfig in the repo, resolving `extends` chains. */
 export declare function loadTsconfigIndex(repoRoot: string): Promise<TsconfigIndex | null>;
+/**
+ * A `paths` target rebased to repo-relative, keeping any trailing `*`.
+ *
+ * `path.resolve` swallows the wildcard into a path segment, so it is stripped
+ * before resolving and re-appended after — the `*` is a substitution marker,
+ * not a directory named `*`.
+ *
+ * `pathApi` is injectable so the win32 separator branch is unit-testable from a
+ * POSIX runner; production callers always use the platform-bound `path`.
+ */
+declare function rebaseTarget(repoRoot: string, absTarget: string, pathApi?: typeof path): string;
+/** Test seam for {@link rebaseTarget} (see `test/unit/tsconfig-rebase-target.test.ts`). */
+export declare const _rebaseTargetForTests: typeof rebaseTarget;
+export {};

package/dist/core/ingestion/languages/typescript/tsconfig.js

@@ -273,8 +273,8 @@ function parseJsonc(raw) {
         .replace(/,(\s*[}\]])/g, '$1');
     return JSON.parse(withoutComments);
 }
-function repoRelative(repoRoot, absDir) {
-    const rel = path.relative(repoRoot, absDir).split(path.sep).join('/');
+function repoRelative(repoRoot, absDir, pathApi = path) {
+    const rel = pathApi.relative(repoRoot, absDir).split(pathApi.sep).join('/');
     return rel === '.' || rel === '' ? '' : rel;
 }
 /**
@@ -283,11 +283,34 @@ function repoRelative(repoRoot, absDir) {
  * `path.resolve` swallows the wildcard into a path segment, so it is stripped
  * before resolving and re-appended after — the `*` is a substitution marker,
  * not a directory named `*`.
+ *
+ * `pathApi` is injectable so the win32 separator branch is unit-testable from a
+ * POSIX runner; production callers always use the platform-bound `path`.
  */
-function rebaseTarget(repoRoot, absTarget) {
+function rebaseTarget(repoRoot, absTarget, pathApi = path) {
     // `/repo/src/*` must come back as `src/*`, not `src*`: stripping only the
     // star leaves a trailing slash that `path.relative` then eats.
-    const suffix = absTarget.endsWith('/*') ? '/*' : absTarget.endsWith('*') ? '*' : '';
-    const base = suffix === '' ? absTarget : absTarget.slice(0, -suffix.length);
-    return `${repoRelative(repoRoot, base)}${suffix}`;
+    //
+    // The target arrives from `path.resolve`, so on Windows it is `C:\repo\src\*`
+    // and an `endsWith('/*')` check never matches. It fell through to the bare
+    // `*` branch, `path.relative` ate the trailing backslash, and every alias
+    // target came back as `src*` — which `substituteStar` turns into `srclib/x`,
+    // so nothing an alias reached was ever resolved on Windows. Normalise the
+    // separator before looking at the suffix.
+    const normalized = absTarget.split(pathApi.sep).join('/');
+    const suffix = normalized.endsWith('/*') ? '/*' : normalized.endsWith('*') ? '*' : '';
+    const base = suffix === '' ? normalized : normalized.slice(0, -suffix.length);
+    const prefix = repoRelative(repoRoot, base, pathApi);
+    // A target naming the repo ROOT (`"*": ["./*"]` under `baseUrl: "."`) leaves
+    // an empty prefix, and `${''}${'/*'}` is `/*`. `substituteStar` turns that
+    // into `/lib/date`, but `resolveFile` matches repo-relative keys and never
+    // strips a leading slash, so `lib/date.ts` misses and the alias goes
+    // external. The bare `*` is the encoding that substitutes correctly — and it
+    // is what the pre-#3203 Windows path emitted by accident, so this keeps the
+    // separator fix from narrowing what already resolved there.
+    if (prefix === '' && suffix === '/*')
+        return '*';
+    return `${prefix}${suffix}`;
 }
+/** Test seam for {@link rebaseTarget} (see `test/unit/tsconfig-rebase-target.test.ts`). */
+export const _rebaseTargetForTests = rebaseTarget;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.12-rc.21",
+  "version": "1.6.12-rc.23",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",

package/scripts/cross-platform-tests.ts

@@ -36,6 +36,18 @@ const PLATFORM_LOGIC = [
   // must exercise the Windows backslash branch, so run it on the OS matrix (#2394).
   'test/unit/cli-entry.test.ts',
   'test/unit/platform-capabilities.test.ts',
+  // The tsconfig loader rebases `paths` targets through `path.resolve`, so the
+  // wildcard suffix it must recognise is `/*` on POSIX and `\*` on Windows. It
+  // only looked for `/*`, and every alias target came back as `src*` on
+  // Windows while the Ubuntu run stayed green — so this file has to run where
+  // the separator differs.
+  'test/unit/tsconfig-index.test.ts',
+  // The unit half of the same rebasing rule. Fixture-free and pathApi-injectable
+  // (every separator assertion passes an explicit `path.win32` / `path.posix`),
+  // so unlike the fixture suite above it fails on EVERY runner when the
+  // normalisation is removed rather than only on windows-latest. Registered
+  // beside its fixture sibling so the two halves stay discoverable as one group.
+  'test/unit/tsconfig-rebase-target.test.ts',
   // The gitnexus-plan safe writer resolves every name through a per-platform
   // backend: Linux anchors through /proc/self/fd, macOS resolves lexically and
   // verifies each step against descriptors it holds open. Publication is link(2)