lua-cli 3.12.1 → 3.13.0

package/dist/compiler/utils/common.js

@@ -2,6 +2,7 @@
  * Common utility functions for the compiler.
  */
 import crypto from 'crypto';
+import path from 'path';
 // =============================================================================
 // HASHING
 // =============================================================================
@@ -53,6 +54,43 @@ export function shouldSkipDirectory(name) {
 // =============================================================================
 // FORMATTING
 // =============================================================================
+// =============================================================================
+// PATHS
+// =============================================================================
+/**
+ * Return `true` when `child` is contained in `parent` (or is `parent` itself).
+ * Uses normalized absolute paths so trailing slashes, `..` segments, and mixed
+ * separators don't cause false negatives.
+ *
+ * Naive separator-boundary checks like `child.startsWith(parent)` are avoided
+ * because they would treat `/foo/bar-baz` as a child of `/foo/bar`.
+ */
+export function isInside(child, parent) {
+    const resolvedChild = path.resolve(child);
+    const resolvedParent = path.resolve(parent);
+    if (resolvedChild === resolvedParent)
+        return true;
+    const rel = path.relative(resolvedParent, resolvedChild);
+    return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+/**
+ * Classify a project file by its name so the backup manifest knows whether
+ * it's a source file, a config file, or something else.
+ */
+export function classifyProjectFile(name) {
+    if (name.endsWith('.ts') || name.endsWith('.tsx') || name.endsWith('.js')) {
+        return 'source';
+    }
+    if (name === 'package.json' ||
+        name === 'tsconfig.json' ||
+        name === 'lua.skill.yaml' ||
+        name.endsWith('.yaml') ||
+        name.endsWith('.yml') ||
+        name.endsWith('.json')) {
+        return 'config';
+    }
+    return 'other';
+}
 /**
  * Format file size in human-readable format.
  */

package/dist/compiler/utils/common.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/compiler/utils/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,gFAAgF;AAChF,UAAU;AACV,gFAAgF;AAEhF;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,OAAO,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAChF,CAAC;AAED,gFAAgF;AAChF,iBAAiB;AACjB,gFAAgF;AAEhF;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,cAAsB;IACnD,OAAO,CACL,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC;QACvC,cAAc,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACjC,cAAc,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACjC,cAAc,CAAC,QAAQ,CAAC,WAAW,CAAC;QACpC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC;QAChC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC;QAC/B,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC;QAC9B,cAAc,KAAK,mBAAmB;QACtC,cAAc,KAAK,WAAW;QAC9B,cAAc,KAAK,gBAAgB,CACpC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,MAAM,QAAQ,GAAG;QACf,cAAc;QACd,MAAM;QACN,SAAS;QACT,MAAM;QACN,MAAM;QACN,OAAO;QACP,UAAU;QACV,OAAO;QACP,QAAQ;KACT,CAAC;IACF,OAAO,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAED,gFAAgF;AAChF,aAAa;AACb,gFAAgF;AAEhF;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,IAAI,KAAK,GAAG,IAAI;QAAE,OAAO,GAAG,KAAK,GAAG,CAAC;IACrC,IAAI,KAAK,GAAG,IAAI,GAAG,IAAI;QAAE,OAAO,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;IACjE,OAAO,GAAG,CAAC,KAAK,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;AACjD,CAAC"}
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/compiler/utils/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,gFAAgF;AAChF,UAAU;AACV,gFAAgF;AAEhF;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,OAAO,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAChF,CAAC;AAED,gFAAgF;AAChF,iBAAiB;AACjB,gFAAgF;AAEhF;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,cAAsB;IACnD,OAAO,CACL,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC;QACvC,cAAc,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACjC,cAAc,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACjC,cAAc,CAAC,QAAQ,CAAC,WAAW,CAAC;QACpC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC;QAChC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC;QAC/B,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC;QAC9B,cAAc,KAAK,mBAAmB;QACtC,cAAc,KAAK,WAAW;QAC9B,cAAc,KAAK,gBAAgB,CACpC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,MAAM,QAAQ,GAAG;QACf,cAAc;QACd,MAAM;QACN,SAAS;QACT,MAAM;QACN,MAAM;QACN,OAAO;QACP,UAAU;QACV,OAAO;QACP,QAAQ;KACT,CAAC;IACF,OAAO,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAED,gFAAgF;AAChF,aAAa;AACb,gFAAgF;AAEhF,gFAAgF;AAChF,QAAQ;AACR,gFAAgF;AAEhF;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAa,EAAE,MAAc;IACpD,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,aAAa,KAAK,cAAc;QAAE,OAAO,IAAI,CAAC;IAClD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC;IACzD,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AACjE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1E,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,IACE,IAAI,KAAK,cAAc;QACvB,IAAI,KAAK,eAAe;QACxB,IAAI,KAAK,gBAAgB;QACzB,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;QACtB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EACtB,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,IAAI,KAAK,GAAG,IAAI;QAAE,OAAO,GAAG,KAAK,GAAG,CAAC;IACrC,IAAI,KAAK,GAAG,IAAI,GAAG,IAAI;QAAE,OAAO,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;IACjE,OAAO,GAAG,CAAC,KAAK,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;AACjD,CAAC"}

package/dist/compiler/utils/path-resolver.d.ts

@@ -1,26 +1,83 @@
 /**
  * Path Resolver Utilities
  *
- * Resolves TypeScript path aliases (e.g., @/, ~/) from tsconfig.json.
- * Enables the compiler to follow imports that use path aliases.
+ * Resolves TypeScript path aliases (e.g., @/, ~/) from a project's
+ * tsconfig.json and resolves relative/aliased module specifiers to
+ * absolute file paths.
+ *
+ * Design notes:
+ * - Every entry point that reads a tsconfig is keyed by `rootDir`. A
+ *   single Node process can compile multiple projects (tests do this,
+ *   and future "Compiler as library" consumers will too); the earlier
+ *   implementation cached mappings in module scope and mixed aliases
+ *   across projects. That's fixed here — the cache is a `Map<rootDir,
+ *   mappings | null>`.
+ * - `resolveModuleSpecifier` is the single source of truth for
+ *   "specifier → absolute path". Previously the resolver and the agent
+ *   traverser each reimplemented the same logic; now both go through
+ *   this one helper.
+ * - A `registerProjectRootDir(project, rootDir)` side-channel lets
+ *   downstream code (plugins, resolver) recover the correct rootDir
+ *   from a ts-morph Project without threading it through every call
+ *   signature. The Compiler sets it once in its constructor.
  */
+import type { Project } from 'ts-morph';
 interface PathMappings {
+    /** The tsconfig's `baseUrl` (falls back to `.`). */
     baseUrl: string;
+    /** Raw `paths` mapping from the tsconfig. */
     paths: Record<string, string[]>;
+    /** Absolute rootDir the tsconfig was loaded from. */
+    rootDir: string;
 }
 /**
- * Reads TypeScript path alias mappings from tsconfig.json.
- * Results are cached for the process lifetime.
+ * Read the tsconfig at `<rootDir>/tsconfig.json` and extract its
+ * `paths` mappings. Returns null when no paths are configured or the
+ * tsconfig is missing/unreadable. Result is cached keyed by the
+ * normalized rootDir.
+ */
+export declare function getTsConfigPathMappings(rootDir: string): PathMappings | null;
+/**
+ * Resolve a TypeScript path alias (e.g. `@/tools/MyTool`) to an
+ * absolute path. Returns null if no alias matches.
  *
- * @returns Path mappings or null if no paths configured
+ * `rootDir` is required — it's the project's root, the directory that
+ * contains the tsconfig.json whose `paths` we're consulting.
  */
-export declare function getTsConfigPathMappings(): PathMappings | null;
+export declare function resolvePathAlias(specifier: string, rootDir: string): string | null;
 /**
- * Resolves a path alias to an absolute path using tsconfig.json mappings.
+ * Resolve a module specifier (`./foo`, `../bar`, `@/tools/Xyz`) to an
+ * absolute file path, trying each of our supported extensions.
  *
- * @param specifier - The import specifier (e.g., '@/tools/MyTool')
- * @returns Resolved absolute path or null if no alias matched
+ * This is the single consolidated helper that replaces:
+ * - `reference-resolver.ts::resolveSpecifierToPath`
+ * - `agent-traverser.ts::resolveImportPath`
+ *
+ * Both previously duplicated this logic; drift between them was a real
+ * bug surface. Returns undefined when nothing resolves — callers
+ * interpret that as a deopt or a warning depending on context.
+ */
+export declare function resolveModuleSpecifier(specifier: string, fromFile: string, rootDir: string): string | undefined;
+/**
+ * Associate a ts-morph Project with its source `rootDir`. Called once
+ * by the Compiler constructor. Downstream code that only has a
+ * SourceFile can recover the rootDir via `getProjectRootDir`.
+ */
+export declare function registerProjectRootDir(project: Project, rootDir: string): void;
+/**
+ * Look up the registered rootDir for a project, or `undefined` if the
+ * project wasn't registered. Callers that need a rootDir but can't
+ * tolerate undefined should fall back to a sensible default (e.g.
+ * process.cwd() for standalone tooling, or a field on the plugin
+ * context for in-compiler use).
+ */
+export declare function getProjectRootDir(project: Project): string | undefined;
+/**
+ * Test-only: clear the path-alias cache. Tests that compile multiple
+ * projects back-to-back in the same process should call this between
+ * compilations to avoid stale aliases; the Compiler itself doesn't
+ * need to call this because the cache is keyed by rootDir.
  */
-export declare function resolvePathAlias(specifier: string): string | null;
+export declare function clearPathResolverCacheForTests(): void;
 export {};
 //# sourceMappingURL=path-resolver.d.ts.map

package/dist/compiler/utils/path-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-resolver.d.ts","sourceRoot":"","sources":["../../../src/compiler/utils/path-resolver.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,UAAU,YAAY;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACjC;AAID;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI,YAAY,GAAG,IAAI,CA4B7D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAwBjE"}
+{"version":3,"file":"path-resolver.d.ts","sourceRoot":"","sources":["../../../src/compiler/utils/path-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExC,UAAU,YAAY;IACpB,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAChC,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;CACjB;AAcD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAgC5E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyBlF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,SAAS,CAoBpB;AAUD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE9E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}

package/dist/compiler/utils/path-resolver.js

@@ -1,24 +1,51 @@
 /**
  * Path Resolver Utilities
  *
- * Resolves TypeScript path aliases (e.g., @/, ~/) from tsconfig.json.
- * Enables the compiler to follow imports that use path aliases.
+ * Resolves TypeScript path aliases (e.g., @/, ~/) from a project's
+ * tsconfig.json and resolves relative/aliased module specifiers to
+ * absolute file paths.
+ *
+ * Design notes:
+ * - Every entry point that reads a tsconfig is keyed by `rootDir`. A
+ *   single Node process can compile multiple projects (tests do this,
+ *   and future "Compiler as library" consumers will too); the earlier
+ *   implementation cached mappings in module scope and mixed aliases
+ *   across projects. That's fixed here — the cache is a `Map<rootDir,
+ *   mappings | null>`.
+ * - `resolveModuleSpecifier` is the single source of truth for
+ *   "specifier → absolute path". Previously the resolver and the agent
+ *   traverser each reimplemented the same logic; now both go through
+ *   this one helper.
+ * - A `registerProjectRootDir(project, rootDir)` side-channel lets
+ *   downstream code (plugins, resolver) recover the correct rootDir
+ *   from a ts-morph Project without threading it through every call
+ *   signature. The Compiler sets it once in its constructor.
  */
 import * as fs from 'fs';
 import * as path from 'path';
-let cachedMappings;
+// Per-rootDir cache. `null` means "tsconfig exists but has no paths" or
+// "tsconfig unreadable"; both cases still benefit from caching so we
+// don't hit the filesystem repeatedly.
+const mappingsCache = new Map();
+// ts-morph Project → rootDir. Populated by the Compiler constructor.
+// Lets plugin code that only has a SourceFile/Project in hand recover
+// the correct rootDir without changing every plugin API signature.
+const projectRootDirs = new WeakMap();
+const MODULE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js'];
 /**
- * Reads TypeScript path alias mappings from tsconfig.json.
- * Results are cached for the process lifetime.
- *
- * @returns Path mappings or null if no paths configured
+ * Read the tsconfig at `<rootDir>/tsconfig.json` and extract its
+ * `paths` mappings. Returns null when no paths are configured or the
+ * tsconfig is missing/unreadable. Result is cached keyed by the
+ * normalized rootDir.
  */
-export function getTsConfigPathMappings() {
-    if (cachedMappings !== undefined)
-        return cachedMappings;
-    const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+export function getTsConfigPathMappings(rootDir) {
+    const resolvedRoot = path.resolve(rootDir);
+    if (mappingsCache.has(resolvedRoot)) {
+        return mappingsCache.get(resolvedRoot) ?? null;
+    }
+    const tsconfigPath = path.join(resolvedRoot, 'tsconfig.json');
     if (!fs.existsSync(tsconfigPath)) {
-        cachedMappings = null;
+        mappingsCache.set(resolvedRoot, null);
         return null;
     }
     try {
@@ -26,41 +53,110 @@ export function getTsConfigPathMappings() {
         const tsconfig = JSON.parse(tsconfigContent);
         const compilerOptions = tsconfig.compilerOptions || {};
         if (compilerOptions.paths) {
-            cachedMappings = {
+            const mappings = {
                 baseUrl: compilerOptions.baseUrl || '.',
                 paths: compilerOptions.paths,
+                rootDir: resolvedRoot,
             };
-            return cachedMappings;
+            mappingsCache.set(resolvedRoot, mappings);
+            return mappings;
         }
     }
     catch {
-        // Ignore parsing errors
+        // Ignore parsing errors — treat as "no paths configured".
     }
-    cachedMappings = null;
+    mappingsCache.set(resolvedRoot, null);
     return null;
 }
 /**
- * Resolves a path alias to an absolute path using tsconfig.json mappings.
+ * Resolve a TypeScript path alias (e.g. `@/tools/MyTool`) to an
+ * absolute path. Returns null if no alias matches.
  *
- * @param specifier - The import specifier (e.g., '@/tools/MyTool')
- * @returns Resolved absolute path or null if no alias matched
+ * `rootDir` is required — it's the project's root, the directory that
+ * contains the tsconfig.json whose `paths` we're consulting.
  */
-export function resolvePathAlias(specifier) {
-    const mappings = getTsConfigPathMappings();
+export function resolvePathAlias(specifier, rootDir) {
+    const mappings = getTsConfigPathMappings(rootDir);
     if (!mappings)
         return null;
-    // Sort patterns by specificity (longest first) to match TypeScript's behavior
+    // Sort patterns by specificity (longest first) — mirrors TypeScript's
+    // own order-of-precedence for overlapping patterns.
     const sortedPatterns = Object.entries(mappings.paths).sort(([a], [b]) => b.length - a.length);
     for (const [pattern, targets] of sortedPatterns) {
-        // Convert TypeScript path pattern to regex (e.g., "@/*" -> /^@\/(.*)$/)
+        // Convert a TS path pattern to regex: `@/*` → /^@\/(.*)$/
         const patternRegex = new RegExp('^' + pattern.replace(/\*/g, '(.*)').replace(/\//g, '\\/') + '$');
         const match = specifier.match(patternRegex);
         if (match) {
             const captured = match[1] || '';
             const targetPath = targets[0].replace('*', captured);
-            return path.join(process.cwd(), mappings.baseUrl, targetPath);
+            return path.join(mappings.rootDir, mappings.baseUrl, targetPath);
         }
     }
     return null;
 }
+/**
+ * Resolve a module specifier (`./foo`, `../bar`, `@/tools/Xyz`) to an
+ * absolute file path, trying each of our supported extensions.
+ *
+ * This is the single consolidated helper that replaces:
+ * - `reference-resolver.ts::resolveSpecifierToPath`
+ * - `agent-traverser.ts::resolveImportPath`
+ *
+ * Both previously duplicated this logic; drift between them was a real
+ * bug surface. Returns undefined when nothing resolves — callers
+ * interpret that as a deopt or a warning depending on context.
+ */
+export function resolveModuleSpecifier(specifier, fromFile, rootDir) {
+    // Strip trailing `.js` which NodeNext users write for runtime
+    // compatibility (`import foo from './foo.js'` refers to `foo.ts`
+    // during compilation).
+    const normalized = specifier.endsWith('.js') ? specifier.slice(0, -3) : specifier;
+    // Path alias wins when configured — matches TypeScript's resolver order.
+    const aliasResolved = resolvePathAlias(normalized, rootDir);
+    if (aliasResolved) {
+        return tryExtensions(aliasResolved);
+    }
+    if (normalized.startsWith('./') || normalized.startsWith('../')) {
+        const basePath = path.resolve(path.dirname(fromFile), normalized);
+        return tryExtensions(basePath);
+    }
+    // Bare specifiers (npm packages) aren't resolved here — they're
+    // someone else's responsibility.
+    return undefined;
+}
+function tryExtensions(basePath) {
+    for (const ext of MODULE_EXTENSIONS) {
+        const full = ext.startsWith('/') ? path.join(basePath, ext) : basePath + ext;
+        if (fs.existsSync(full))
+            return full;
+    }
+    return undefined;
+}
+/**
+ * Associate a ts-morph Project with its source `rootDir`. Called once
+ * by the Compiler constructor. Downstream code that only has a
+ * SourceFile can recover the rootDir via `getProjectRootDir`.
+ */
+export function registerProjectRootDir(project, rootDir) {
+    projectRootDirs.set(project, path.resolve(rootDir));
+}
+/**
+ * Look up the registered rootDir for a project, or `undefined` if the
+ * project wasn't registered. Callers that need a rootDir but can't
+ * tolerate undefined should fall back to a sensible default (e.g.
+ * process.cwd() for standalone tooling, or a field on the plugin
+ * context for in-compiler use).
+ */
+export function getProjectRootDir(project) {
+    return projectRootDirs.get(project);
+}
+/**
+ * Test-only: clear the path-alias cache. Tests that compile multiple
+ * projects back-to-back in the same process should call this between
+ * compilations to avoid stale aliases; the Compiler itself doesn't
+ * need to call this because the cache is keyed by rootDir.
+ */
+export function clearPathResolverCacheForTests() {
+    mappingsCache.clear();
+}
 //# sourceMappingURL=path-resolver.js.map

package/dist/compiler/utils/path-resolver.js.map

@@ -1 +1 @@
-{"version":3,"file":"path-resolver.js","sourceRoot":"","sources":["../../../src/compiler/utils/path-resolver.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAO7B,IAAI,cAA+C,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB;IACrC,IAAI,cAAc,KAAK,SAAS;QAAE,OAAO,cAAc,CAAC;IAExD,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,eAAe,CAAC,CAAC;IAE/D,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;QACjC,cAAc,GAAG,IAAI,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC;QACH,MAAM,eAAe,GAAG,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;QAC7C,MAAM,eAAe,GAAG,QAAQ,CAAC,eAAe,IAAI,EAAE,CAAC;QAEvD,IAAI,eAAe,CAAC,KAAK,EAAE,CAAC;YAC1B,cAAc,GAAG;gBACf,OAAO,EAAE,eAAe,CAAC,OAAO,IAAI,GAAG;gBACvC,KAAK,EAAE,eAAe,CAAC,KAAK;aAC7B,CAAC;YACF,OAAO,cAAc,CAAC;QACxB,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,wBAAwB;IAC1B,CAAC;IAED,cAAc,GAAG,IAAI,CAAC;IACtB,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,SAAiB;IAChD,MAAM,QAAQ,GAAG,uBAAuB,EAAE,CAAC;IAC3C,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IAE3B,8EAA8E;IAC9E,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CACxD,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAClC,CAAC;IAEF,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,cAAc,EAAE,CAAC;QAChD,wEAAwE;QACxE,MAAM,YAAY,GAAG,IAAI,MAAM,CAC7B,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,GAAG,CACjE,CAAC;QAEF,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC5C,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAChC,MAAM,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;YACrD,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"path-resolver.js","sourceRoot":"","sources":["../../../src/compiler/utils/path-resolver.ts"],"names":[],"mappings":"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"}

package/dist/compiler/utils/reference-resolver.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Primitive Reference Resolver
+ *
+ * Statically resolves a TypeScript expression that is expected to yield an
+ * array of primitive instances (e.g. `mcpServers: [luaDocsMcpServer, ...more]`)
+ * into a list of named references (`ResolvedRef[]`), without executing user
+ * code.
+ *
+ * ## Supported expression shapes
+ *
+ * - Inline:         `[new LuaMCPServer({...}), foo]`
+ * - Variable ref:   `const servers = [...]; mcpServers: servers`
+ * - Spread:         `[...base, new LuaMCPServer({...})]`
+ * - Cross-file:     `import servers from './servers'; mcpServers: servers`
+ * - Re-export:      `export { servers } from './impl'`
+ * - Barrel chains:  `export * from './servers'` + same-name imports
+ * - Path aliases:   `@shared/tools`, `~/lib/tools`, etc. (via tsconfig paths)
+ * - Property read:  `const all = { mcp: [...] }; mcpServers: all.mcp`
+ * - Identifier chains: `const a = inner; const b = a; mcpServers: b`
+ *
+ * ## Result shape (Babel's `path.evaluate()` convention)
+ *
+ *     { confident: true; value: ResolvedRef[] }
+ *   | { confident: false; value: ResolvedRef[]; deopt: Node; reason: string;
+ *       ruleId: 'lua/unresolved-primitive-ref' }
+ *
+ * The `deopt` field pinpoints the AST node that defeated resolution so the
+ * compiler can emit an actionable `file:line:col` diagnostic. Partial results
+ * (`value`) are returned even on deopt so the compiler can emit whatever was
+ * resolvable up to the unknown shape.
+ *
+ * ## Resolution strategy
+ *
+ * 1. **AST fast path** (primary). Traverse ArrayLiteralExpression, follow
+ *    Identifiers to their VariableDeclaration (same-file or via ImportDeclaration
+ *    → getModuleSpecifierSourceFile()), recursively expand spreads. This is
+ *    the idiomatic ts-morph pattern (see ts-morph issue #644 — manual iteration
+ *    is ~1000x faster than getExportedDeclarations() because it doesn't trigger
+ *    full symbol binding). Files are added to the project on demand via
+ *    `addSourceFileAtPath()` as the walk discovers them.
+ * 2. **Symbol fallback** (only when fast path exhausts). Uses
+ *    `getAliasedSymbol()` + `symbol.getDeclarations()[0]` to handle exotic
+ *    re-export chains the manual walk can't follow.
+ *
+ * ## Escape hatch
+ *
+ * A leading `/* @lua-ignore-ref *\/` comment on the expression silences the
+ * deopt diagnostic for users who intentionally construct the array dynamically.
+ *
+ * ## Why we don't evaluate code
+ *
+ * Earlier iterations used `ts-evaluator` to sandbox-evaluate array expressions.
+ * That path loses the link to the compile-time identifier (it yields runtime
+ * `.name` strings, not the class/variable name needed for import resolution)
+ * and adds a sandboxed-RCE surface (cf. CVE-2023-45133 in Babel). The AST
+ * approach covers every case the evaluator did, cheaper and safer.
+ */
+import { Node, Project, SourceFile, VariableDeclaration, ClassDeclaration, FunctionDeclaration, NewExpression } from 'ts-morph';
+/**
+ * A resolved primitive reference.
+ *
+ * Carries enough information for downstream consumers (AgentTraverser,
+ * SkillPlugin) to locate both the identifier name and the source file
+ * where the primitive is declared — no second pass through `findImportSource`
+ * needed.
+ */
+export interface ResolvedRef {
+    /**
+     * The identifier name as written in user code (`luaDocsMcpServer`,
+     * `MyToolClass`, `default`). Used for plugin detect() matching and
+     * manifest lookup.
+     */
+    identifierName: string;
+    /**
+     * The source file containing the ultimate declaration. May be different
+     * from the agent's source file when the ref came from an import or
+     * re-export chain.
+     */
+    sourceFile: SourceFile;
+    /**
+     * The underlying declaration node. For `new LuaMCPServer({...})` assigned
+     * to a `const`, this is the VariableDeclaration. For a bare `new X()` inline
+     * element, this is undefined and `newExpression` carries the node.
+     */
+    declaration?: VariableDeclaration | ClassDeclaration | FunctionDeclaration;
+    /**
+     * For inline `new X({...})` elements that aren't bound to a variable,
+     * this is the NewExpression itself. Lets the agent traverser report
+     * them with a synthetic name (`__inline_<n>`) rather than dropping them.
+     */
+    newExpression?: NewExpression;
+    /**
+     * True when the ref reached this source file through a default import
+     * (`import x from './target'`). Downstream detect-match logic uses this
+     * to prefer the target file's default export over a name-based match,
+     * because the local binding name (`x`) is chosen by the consumer and
+     * is unrelated to any exportName on the target side.
+     */
+    viaDefaultImport?: boolean;
+}
+/**
+ * Babel-style evaluation result. `confident: true` means the resolver is
+ * certain it saw every ref in the expression. `confident: false` means the
+ * walk hit something it couldn't statically understand — `value` holds what
+ * was resolvable up to that point.
+ */
+export type EvaluationResult = {
+    confident: true;
+    value: ResolvedRef[];
+} | {
+    confident: false;
+    value: ResolvedRef[];
+    deopt: Node;
+    reason: string;
+    ruleId: 'lua/unresolved-primitive-ref';
+};
+/**
+ * Shared state for a single `resolveArrayRefs()` invocation: carries the
+ * ts-morph project for on-demand file loading, a cycle-detection set, and
+ * an optional debug logger.
+ */
+export interface ResolverContext {
+    /** ts-morph project — resolver may call addSourceFileAtPath() on it. */
+    project: Project;
+    /**
+     * Project rootDir used for resolving tsconfig `paths` aliases and
+     * relative imports. When omitted, the resolver falls back to
+     * `getProjectRootDir(project)` — which the Compiler populates in its
+     * constructor. Tests or direct callers can pass it explicitly.
+     */
+    rootDir?: string;
+    /**
+     * Set of `<absolutePath>#<identifier>` pairs we've already visited in this
+     * walk, used to break cycles (A imports B, B re-exports A, etc.).
+     */
+    visited?: Set<string>;
+    /** Optional debug logger. */
+    log?: (message: string) => void;
+}
+/**
+ * Resolve an expression node that represents an array of primitive references.
+ *
+ * Typical usage from a plugin/traverser:
+ *
+ *     const prop = configObj.getProperty('mcpServers');
+ *     const init = (prop as PropertyAssignment).getInitializer();
+ *     const result = resolveArrayRefs(init, { project });
+ *     if (!result.confident) { log.warn(reportDeopt(result, 'mcpServers')); }
+ *     const refs = result.value;
+ *
+ * @param expression - The expression node whose value is expected to be an
+ *   array of primitive instances. Typically the initializer of a
+ *   `skills` / `tools` / `mcpServers` property.
+ * @param ctx - Resolver context carrying the project and optional logger.
+ * @returns An `EvaluationResult` — confident + full value on success,
+ *   confident:false + partial value + deopt node on unknown shapes.
+ */
+export declare function resolveArrayRefs(expression: Node | undefined, ctx: ResolverContext): EvaluationResult;
+/**
+ * Format an `EvaluationResult.deopt` as a SARIF-style diagnostic string
+ * for `log.warn()`. Includes the rule id, file:line:col, reason, and a
+ * remediation hint pointing the user at the escape hatch.
+ *
+ * Call sites log this rather than constructing the string inline so every
+ * resolver deopt surfaces with the same shape.
+ */
+export declare function reportDeopt(result: Extract<EvaluationResult, {
+    confident: false;
+}>, propertyName: string): string;
+/**
+ * Rule IDs used by resolver/traverser diagnostics. SARIF requires every
+ * issued warning to carry a stable, human-meaningful id so tools
+ * (CI, editor integrations) can filter or suppress them individually.
+ * Keep this list small and descriptive — new rules should follow the
+ * `lua/<kebab-case-category>` naming convention.
+ */
+export type DiagnosticRuleId = 'lua/unresolved-primitive-ref' | 'lua/missing-primitive-declaration' | 'lua/missing-tool-import';
+/**
+ * Format a SARIF-style diagnostic that isn't anchored on an AST node we
+ * parsed directly (e.g. "tried to find a tool in this file and the
+ * plugin returned nothing"). For node-anchored deopts, use
+ * `reportDeopt()` instead — it produces richer output.
+ *
+ * All resolver/traverser warnings should flow through either this
+ * helper or `reportDeopt`, so every line the user sees has a rule id
+ * and follows the same shape.
+ */
+export declare function formatSarifWarning(args: {
+    ruleId: DiagnosticRuleId;
+    filePath: string;
+    line?: number;
+    column?: number;
+    message: string;
+    hint?: string;
+}): string;
+//# sourceMappingURL=reference-resolver.d.ts.map

package/dist/compiler/utils/reference-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-resolver.d.ts","sourceRoot":"","sources":["../../../src/compiler/utils/reference-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH,OAAO,EACL,IAAI,EACJ,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,EAId,MAAM,UAAU,CAAC;AAUlB;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,UAAU,EAAE,UAAU,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;IAC3E;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,WAAW,EAAE,CAAA;CAAE,GACzC;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,KAAK,EAAE,IAAI,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,8BAA8B,CAAC;CACxC,CAAC;AAEN;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,wEAAwE;IACxE,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,6BAA6B;IAC7B,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAwBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,IAAI,GAAG,SAAS,EAC5B,GAAG,EAAE,eAAe,GACnB,gBAAgB,CAoDlB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,OAAO,CAAC,gBAAgB,EAAE;IAAE,SAAS,EAAE,KAAK,CAAA;CAAE,CAAC,EACvD,YAAY,EAAE,MAAM,GACnB,MAAM,CAcR;AAED;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GACxB,8BAA8B,GAC9B,mCAAmC,GACnC,yBAAyB,CAAC;AAE9B;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAOT"}