@norrix/cli 0.0.24 → 0.0.26

package/dist/lib/workspace.js

@@ -0,0 +1,826 @@
+/**
+ * Nx Workspace Detection and Integration
+ *
+ * Provides utilities for detecting Nx workspaces, querying project dependencies,
+ * and managing workspace-aware builds for monorepo setups.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+/**
+ * Detect the workspace context from the current working directory.
+ * Walks up the directory tree looking for nx.json to identify Nx workspaces.
+ */
+export function detectWorkspaceContext(appRoot) {
+    const currentAppRoot = appRoot || process.cwd();
+    // Walk up the directory tree looking for workspace markers
+    let dir = currentAppRoot;
+    while (dir !== path.dirname(dir)) {
+        const nxJsonPath = path.join(dir, 'nx.json');
+        if (fs.existsSync(nxJsonPath)) {
+            const relativeAppPath = path.relative(dir, currentAppRoot);
+            // Only treat as Nx workspace if app is nested (not at root)
+            if (relativeAppPath && relativeAppPath !== '.') {
+                const projectName = detectProjectName(currentAppRoot);
+                const pathMappings = loadPathMappings(dir);
+                return {
+                    type: 'nx',
+                    workspaceRoot: dir,
+                    appRoot: currentAppRoot,
+                    relativeAppPath,
+                    projectName,
+                    pathMappings,
+                };
+            }
+        }
+        dir = path.dirname(dir);
+    }
+    // Standalone project (no Nx workspace found or app is at workspace root)
+    return {
+        type: 'standalone',
+        workspaceRoot: currentAppRoot,
+        appRoot: currentAppRoot,
+        relativeAppPath: '.',
+    };
+}
+/**
+ * Detect the Nx project name from project.json
+ */
+function detectProjectName(appRoot) {
+    const projectJsonPath = path.join(appRoot, 'project.json');
+    if (fs.existsSync(projectJsonPath)) {
+        try {
+            const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf8'));
+            return projectJson.name;
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    return undefined;
+}
+/**
+ * Detect available Nx build configurations from project.json.
+ * Reads the 'build' target's configurations to find options like 'prod', 'stg', 'dev'.
+ */
+export function detectNxBuildConfigurations(appRoot) {
+    const projectJsonPath = path.join(appRoot, 'project.json');
+    if (!fs.existsSync(projectJsonPath)) {
+        return undefined;
+    }
+    try {
+        const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf8'));
+        const buildTarget = projectJson.targets?.build;
+        if (!buildTarget || !buildTarget.configurations) {
+            return undefined;
+        }
+        const configurations = Object.keys(buildTarget.configurations);
+        if (configurations.length === 0) {
+            return undefined;
+        }
+        return {
+            configurations,
+            defaultConfiguration: buildTarget.defaultConfiguration,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Load TypeScript path mappings from tsconfig.base.json
+ */
+function loadPathMappings(workspaceRoot) {
+    const tsconfigPath = path.join(workspaceRoot, 'tsconfig.base.json');
+    if (!fs.existsSync(tsconfigPath)) {
+        return undefined;
+    }
+    try {
+        const content = fs.readFileSync(tsconfigPath, 'utf8');
+        // Remove comments for JSON parsing
+        const jsonContent = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
+        const tsconfig = JSON.parse(jsonContent);
+        return tsconfig.compilerOptions?.paths;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Query Nx for the project dependency graph.
+ * Returns the list of lib paths that the specified project depends on.
+ * Also supplements with webpack alias detection for SCSS and other non-TS dependencies.
+ */
+export function getNxProjectDependencies(projectName, workspaceRoot, verbose = false, appRoot) {
+    try {
+        // Check if nx is available
+        execSync('npx nx --version', {
+            cwd: workspaceRoot,
+            encoding: 'utf8',
+            stdio: 'pipe',
+        });
+        // Get the project graph as JSON
+        const graphOutput = execSync('npx nx graph --file=stdout', {
+            cwd: workspaceRoot,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large workspaces
+        });
+        const graph = JSON.parse(graphOutput);
+        // Extract all dependencies for the project (recursive)
+        const allDeps = collectAllDependencies(projectName, graph);
+        if (verbose) {
+            console.log(`[workspace] Nx graph found ${allDeps.size} dependencies for ${projectName}`);
+        }
+        // Convert to paths
+        const libPaths = new Set();
+        for (const depName of allDeps) {
+            const node = graph.graph.nodes[depName];
+            if (node && node.data.root) {
+                libPaths.add(node.data.root);
+            }
+        }
+        // Supplement with webpack alias detection (catches SCSS and other non-TS dependencies)
+        // The Nx graph may miss webpack-only aliases that aren't in tsconfig
+        if (appRoot) {
+            const webpackRefs = parseWebpackReferences(appRoot, workspaceRoot, verbose);
+            for (const ref of webpackRefs) {
+                if (!libPaths.has(ref)) {
+                    libPaths.add(ref);
+                    if (verbose) {
+                        console.log(`[workspace] Added webpack alias dependency: ${ref}`);
+                    }
+                }
+            }
+        }
+        // Scan package.json for local file dependencies
+        const localFileDeps = scanLocalFileDependencies(workspaceRoot, verbose);
+        return {
+            libPaths: Array.from(libPaths),
+            rootConfigs: [
+                'nx.json',
+                'tsconfig.base.json',
+                'package.json',
+                'package-lock.json',
+                '.npmrc',
+                'references.d.ts', // NativeScript global type definitions
+            ],
+            toolPaths: ['tools/'],
+            assetPaths: ['libs/assets/', 'packages/assets/'],
+            localFileDeps,
+        };
+    }
+    catch (error) {
+        if (verbose) {
+            console.log(`[workspace] Failed to query Nx graph: ${error?.message}`);
+        }
+        return undefined;
+    }
+}
+/**
+ * Recursively collect all dependencies for a project
+ */
+function collectAllDependencies(projectName, graph, visited = new Set()) {
+    if (visited.has(projectName)) {
+        return visited;
+    }
+    const deps = graph.graph.dependencies[projectName] || [];
+    for (const dep of deps) {
+        if (!visited.has(dep.target) && dep.target !== projectName) {
+            visited.add(dep.target);
+            collectAllDependencies(dep.target, graph, visited);
+        }
+    }
+    return visited;
+}
+/**
+ * Get project info using nx show project command
+ */
+export function getNxProjectInfo(projectName, workspaceRoot, verbose = false) {
+    try {
+        const output = execSync(`npx nx show project ${projectName} --json`, {
+            cwd: workspaceRoot,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return JSON.parse(output);
+    }
+    catch (error) {
+        if (verbose) {
+            console.log(`[workspace] Failed to get project info: ${error?.message}`);
+        }
+        return undefined;
+    }
+}
+/**
+ * Fallback: Parse tsconfig.base.json paths and scan source files
+ * to determine which libs are actually used.
+ */
+export function getWorkspaceDependenciesFallback(workspaceCtx, verbose = false) {
+    const libPaths = new Set();
+    // 1. Parse path mappings and find which ones are used
+    if (workspaceCtx.pathMappings) {
+        const usedAliases = scanForUsedPathAliases(workspaceCtx.appRoot, Object.keys(workspaceCtx.pathMappings), verbose);
+        for (const alias of usedAliases) {
+            const paths = workspaceCtx.pathMappings[alias];
+            if (paths && paths.length > 0) {
+                // Convert path like "libs/xplat/core/src/index.ts" to "libs/xplat/core"
+                const libPath = extractLibPath(paths[0]);
+                if (libPath) {
+                    libPaths.add(libPath);
+                }
+            }
+        }
+    }
+    // 2. Parse webpack.config.js for additional references (includes SCSS aliases)
+    const webpackRefs = parseWebpackReferences(workspaceCtx.appRoot, workspaceCtx.workspaceRoot, verbose);
+    for (const ref of webpackRefs) {
+        libPaths.add(ref);
+    }
+    // 3. Parse nativescript.config.ts for hook references
+    const hookRefs = parseNativeScriptHooks(workspaceCtx.appRoot, workspaceCtx.workspaceRoot);
+    for (const ref of hookRefs) {
+        libPaths.add(ref);
+    }
+    // 4. Parse project.json for implicit dependencies
+    const implicitDeps = parseImplicitDependencies(workspaceCtx.appRoot, workspaceCtx.workspaceRoot, verbose);
+    for (const dep of implicitDeps) {
+        libPaths.add(dep);
+    }
+    // 5. Recursively scan lib dependencies to find transitive deps
+    if (workspaceCtx.pathMappings) {
+        const initialLibCount = libPaths.size;
+        scanTransitiveLibDependencies(Array.from(libPaths), workspaceCtx.workspaceRoot, workspaceCtx.pathMappings, libPaths, verbose);
+        if (verbose && libPaths.size > initialLibCount) {
+            console.log(`[workspace] Found ${libPaths.size - initialLibCount} transitive lib dependencies`);
+        }
+    }
+    if (verbose) {
+        console.log(`[workspace] Fallback found ${libPaths.size} total lib dependencies`);
+    }
+    // 6. Scan package.json for local file dependencies
+    const allLocalFileDeps = scanLocalFileDependencies(workspaceCtx.workspaceRoot, verbose);
+    // Filter out local file deps that are already covered by libPaths to avoid duplicates
+    const libPathsArray = Array.from(libPaths);
+    const localFileDeps = allLocalFileDeps.filter(localDep => {
+        for (const libPath of libPathsArray) {
+            // Skip if local dep is inside a lib path or vice versa
+            if (localDep.startsWith(libPath + '/') || localDep === libPath ||
+                libPath.startsWith(localDep + '/')) {
+                if (verbose) {
+                    console.log(`[workspace] Filtering redundant local dep: ${localDep} (covered by ${libPath})`);
+                }
+                return false;
+            }
+        }
+        return true;
+    });
+    return {
+        libPaths: libPathsArray,
+        rootConfigs: [
+            'nx.json',
+            'tsconfig.base.json',
+            'package.json',
+            'package-lock.json',
+            '.npmrc',
+            'references.d.ts', // NativeScript global type definitions
+        ],
+        toolPaths: ['tools/'],
+        assetPaths: ['libs/assets/', 'packages/assets/'],
+        localFileDeps,
+    };
+}
+/**
+ * Parse project.json for implicit dependencies.
+ * These are libs explicitly declared as dependencies in the Nx project config.
+ */
+function parseImplicitDependencies(appRoot, workspaceRoot, verbose = false) {
+    const deps = [];
+    const projectJsonPath = path.join(appRoot, 'project.json');
+    if (!fs.existsSync(projectJsonPath)) {
+        return deps;
+    }
+    try {
+        const content = fs.readFileSync(projectJsonPath, 'utf8');
+        const projectJson = JSON.parse(content);
+        const implicitDeps = projectJson.implicitDependencies;
+        if (Array.isArray(implicitDeps)) {
+            for (const depName of implicitDeps) {
+                // Try to find the lib path by scanning for project.json with this name
+                const libPath = findLibPathByProjectName(depName, workspaceRoot);
+                if (libPath) {
+                    deps.push(libPath);
+                    if (verbose) {
+                        console.log(`[workspace] Found implicit dependency: ${depName} -> ${libPath}`);
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return deps;
+}
+/**
+ * Find a lib's path by its Nx project name.
+ * Scans libs/ and packages/ directories for project.json files with matching name.
+ */
+function findLibPathByProjectName(projectName, workspaceRoot) {
+    // Cache of project name -> lib path mappings (built on first call)
+    const projectNameCache = buildProjectNameCache(workspaceRoot);
+    return projectNameCache.get(projectName);
+}
+// Module-level cache for project name mappings
+let _projectNameCache;
+let _projectNameCacheRoot;
+function buildProjectNameCache(workspaceRoot) {
+    // Return cached version if same workspace
+    if (_projectNameCache && _projectNameCacheRoot === workspaceRoot) {
+        return _projectNameCache;
+    }
+    const cache = new Map();
+    // Scan both libs/ and packages/ directories (common Nx workspace layouts)
+    const sharedDirs = ['libs', 'packages'];
+    for (const dir of sharedDirs) {
+        const sharedPath = path.join(workspaceRoot, dir);
+        if (fs.existsSync(sharedPath)) {
+            scanForProjectJsonFiles(sharedPath, workspaceRoot, cache);
+        }
+    }
+    _projectNameCache = cache;
+    _projectNameCacheRoot = workspaceRoot;
+    return cache;
+}
+function scanForProjectJsonFiles(dir, workspaceRoot, cache) {
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                continue;
+            }
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Check for project.json in this directory
+                const projectJsonPath = path.join(fullPath, 'project.json');
+                if (fs.existsSync(projectJsonPath)) {
+                    try {
+                        const content = fs.readFileSync(projectJsonPath, 'utf8');
+                        const projectJson = JSON.parse(content);
+                        if (projectJson.name) {
+                            const relativePath = path.relative(workspaceRoot, fullPath);
+                            cache.set(projectJson.name, relativePath);
+                        }
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                }
+                // Continue scanning subdirectories
+                scanForProjectJsonFiles(fullPath, workspaceRoot, cache);
+            }
+        }
+    }
+    catch {
+        // Ignore directory read errors
+    }
+}
+/**
+ * Recursively scan libs for their dependencies on other libs.
+ * This finds transitive dependencies that the app doesn't directly import.
+ */
+function scanTransitiveLibDependencies(initialLibPaths, workspaceRoot, pathMappings, allLibPaths, verbose = false) {
+    const toScan = [...initialLibPaths];
+    const scanned = new Set();
+    while (toScan.length > 0) {
+        const libPath = toScan.pop();
+        if (scanned.has(libPath)) {
+            continue;
+        }
+        scanned.add(libPath);
+        const absoluteLibPath = path.join(workspaceRoot, libPath);
+        if (!fs.existsSync(absoluteLibPath)) {
+            continue;
+        }
+        // Scan this lib's source files for imports of other path aliases
+        const usedAliases = scanForUsedPathAliases(absoluteLibPath, Object.keys(pathMappings), false // Don't verbose for recursive scans
+        );
+        for (const alias of usedAliases) {
+            const paths = pathMappings[alias];
+            if (paths && paths.length > 0) {
+                const depLibPath = extractLibPath(paths[0]);
+                if (depLibPath && !allLibPaths.has(depLibPath)) {
+                    allLibPaths.add(depLibPath);
+                    toScan.push(depLibPath);
+                    if (verbose) {
+                        console.log(`[workspace] Found transitive dependency: ${libPath} -> ${depLibPath}`);
+                    }
+                }
+            }
+        }
+        // Also check the lib's project.json for implicit dependencies
+        const implicitDeps = parseImplicitDependencies(absoluteLibPath, workspaceRoot, false);
+        for (const dep of implicitDeps) {
+            if (!allLibPaths.has(dep)) {
+                allLibPaths.add(dep);
+                toScan.push(dep);
+                if (verbose) {
+                    console.log(`[workspace] Found transitive implicit dependency: ${libPath} -> ${dep}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Scan source files for path alias imports
+ */
+function scanForUsedPathAliases(appRoot, aliases, verbose = false) {
+    const usedAliases = new Set();
+    // Build regex to match import statements with these aliases
+    const aliasPatterns = aliases.map((a) => a.replace(/\*/g, '').replace(/\//g, '\\/'));
+    const walk = (dir) => {
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                    continue;
+                }
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath);
+                }
+                else if (entry.isFile() && /\.(ts|js|tsx|jsx|scss|css)$/.test(entry.name)) {
+                    try {
+                        const content = fs.readFileSync(fullPath, 'utf8');
+                        for (const alias of aliases) {
+                            const baseAlias = alias.replace(/\/\*$/, '');
+                            // Match imports like: from '@ups/xplat/core' or import('@ups/xplat/features')
+                            const importRegex = new RegExp(`['"\`]${baseAlias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[/'"\`]`, 'g');
+                            if (importRegex.test(content)) {
+                                usedAliases.add(alias);
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore file read errors
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore directory read errors
+        }
+    };
+    walk(appRoot);
+    if (verbose) {
+        console.log(`[workspace] Found ${usedAliases.size} used path aliases`);
+    }
+    return usedAliases;
+}
+/**
+ * Extract lib directory path from tsconfig path mapping
+ */
+function extractLibPath(mappingPath) {
+    // e.g., "libs/xplat/core/src/index.ts" -> "libs/xplat/core"
+    // e.g., "packages/shared/utils/src/index.ts" -> "packages/shared/utils"
+    // e.g., "libs/xplat/core/src/lib/*" -> "libs/xplat/core"
+    const match = mappingPath.match(/^((?:libs|packages)\/[^/]+(?:\/[^/]+)*?)\/src/);
+    if (match) {
+        return match[1];
+    }
+    // Try simpler pattern
+    const simpleMatch = mappingPath.match(/^((?:libs|packages)\/[^/]+(?:\/[^/]+)*)/);
+    if (simpleMatch) {
+        return simpleMatch[1];
+    }
+    return undefined;
+}
+/**
+ * Parse webpack.config.js for references to workspace paths.
+ * Handles both relative path references and resolve.alias configurations.
+ */
+function parseWebpackReferences(appRoot, workspaceRoot, verbose = false) {
+    const refs = [];
+    const webpackPath = path.join(appRoot, 'webpack.config.js');
+    if (!fs.existsSync(webpackPath)) {
+        return refs;
+    }
+    try {
+        const content = fs.readFileSync(webpackPath, 'utf8');
+        // Look for patterns like '../../../libs/...' or '../../../packages/...' or 'tools/...'
+        const relativePathRegex = /['"`](\.\.\/)+([^'"`]+)['"`]/g;
+        let match;
+        while ((match = relativePathRegex.exec(content)) !== null) {
+            const relativePath = match[0].replace(/['"`]/g, '');
+            const absolutePath = path.resolve(appRoot, relativePath);
+            const relativeToWorkspace = path.relative(workspaceRoot, absolutePath);
+            if (relativeToWorkspace.startsWith('libs/') ||
+                relativeToWorkspace.startsWith('packages/') ||
+                relativeToWorkspace.startsWith('tools/')) {
+                // Extract the lib directory - need to handle deep paths like libs/xplat/nativescript/scss/src
+                const libPath = extractLibPathFromRelative(relativeToWorkspace);
+                if (libPath) {
+                    refs.push(libPath);
+                    if (verbose) {
+                        console.log(`[webpack] Found lib reference: ${libPath}`);
+                    }
+                }
+            }
+        }
+        // Look for CopyRule patterns
+        const copyRuleRegex = /from:\s*['"`]([^'"`]+)['"`]/g;
+        while ((match = copyRuleRegex.exec(content)) !== null) {
+            const fromPath = match[1];
+            if (fromPath.includes('libs/') || fromPath.includes('packages/')) {
+                const libMatch = fromPath.match(/((?:libs|packages)\/[^/]+(?:\/[^/]+)*)/);
+                if (libMatch) {
+                    const libPath = extractLibPathFromRelative(libMatch[1]);
+                    if (libPath) {
+                        refs.push(libPath);
+                    }
+                }
+            }
+        }
+        // Look for webpack resolve.alias patterns like:
+        // config.resolve.alias.set('@ups/xplat-scss', resolve(__dirname, '../../../libs/xplat/scss/src/'))
+        // or: alias: { '@ups/xplat-scss': path.resolve(...) }
+        const aliasSetRegex = /\.alias\.set\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*(?:resolve|path\.resolve)\s*\([^,]+,\s*['"`]([^'"`]+)['"`]\s*\)/g;
+        while ((match = aliasSetRegex.exec(content)) !== null) {
+            const aliasPath = match[2];
+            const absolutePath = path.resolve(appRoot, aliasPath);
+            const relativeToWorkspace = path.relative(workspaceRoot, absolutePath);
+            if (relativeToWorkspace.startsWith('libs/') || relativeToWorkspace.startsWith('packages/')) {
+                const libPath = extractLibPathFromRelative(relativeToWorkspace);
+                if (libPath) {
+                    refs.push(libPath);
+                    if (verbose) {
+                        console.log(`[webpack] Found alias reference: ${match[1]} -> ${libPath}`);
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return [...new Set(refs)];
+}
+/**
+ * Extract the lib directory from a relative path.
+ * Handles paths like:
+ * - libs/xplat/scss/src -> libs/xplat/scss
+ * - packages/shared/utils/src -> packages/shared/utils
+ * - libs/xplat/nativescript/scss/src/ -> libs/xplat/nativescript/scss
+ * - libs/assets/mobile/fonts -> libs/assets
+ */
+function extractLibPathFromRelative(relativePath) {
+    // Remove trailing slash
+    const cleanPath = relativePath.replace(/\/+$/, '');
+    // Handle /src or /src/... suffix - find the lib root
+    const srcMatch = cleanPath.match(/^((?:libs|packages)\/(?:[^/]+\/)*[^/]+)\/src(?:\/|$)/);
+    if (srcMatch) {
+        return srcMatch[1];
+    }
+    // For paths without /src, extract based on common patterns
+    // libs/assets -> libs/assets
+    // libs/xplat/core -> libs/xplat/core
+    // packages/shared -> packages/shared
+    if (cleanPath.startsWith('libs/') || cleanPath.startsWith('packages/')) {
+        const parts = cleanPath.split('/');
+        // Check if this path has a project.json to determine lib boundary
+        // For now, use heuristics: assets are at libs/assets, others are deeper
+        if (parts[1] === 'assets') {
+            return `${parts[0]}/${parts[1]}`;
+        }
+        // For xplat and other nested structures, typically 3 levels: libs/xplat/core
+        // But can be deeper: libs/xplat/nativescript/scss
+        // Try to find project.json to determine the actual lib root
+        let testPath = '';
+        for (let i = 0; i < parts.length; i++) {
+            testPath += (i > 0 ? '/' : '') + parts[i];
+            // We'll return the deepest valid lib path that's not a 'src' dir
+            if (parts[i] === 'src') {
+                return parts.slice(0, i).join('/');
+            }
+        }
+        // If no /src found, return up to 4 levels or the full path
+        return parts.slice(0, Math.min(parts.length, 4)).join('/');
+    }
+    return undefined;
+}
+/**
+ * Parse nativescript.config.ts for hook script references
+ */
+function parseNativeScriptHooks(appRoot, workspaceRoot) {
+    const refs = [];
+    const configPath = path.join(appRoot, 'nativescript.config.ts');
+    if (!fs.existsSync(configPath)) {
+        return refs;
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        // Look for hook script paths
+        const scriptRegex = /script:\s*['"`](\.\.\/)+([^'"`]+)['"`]/g;
+        let match;
+        while ((match = scriptRegex.exec(content)) !== null) {
+            const scriptPath = match[0].match(/['"`]([^'"`]+)['"`]/)?.[1];
+            if (scriptPath) {
+                const absolutePath = path.resolve(appRoot, scriptPath);
+                const relativeToWorkspace = path.relative(workspaceRoot, absolutePath);
+                if (!relativeToWorkspace.startsWith('..')) {
+                    // Get the directory containing the script
+                    const scriptDir = path.dirname(relativeToWorkspace);
+                    refs.push(scriptDir);
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return [...new Set(refs)];
+}
+/**
+ * Scan package.json for local file dependencies (file: protocol).
+ * Returns an array of relative paths (files or directories) that need to be included in the bundle.
+ */
+function scanLocalFileDependencies(workspaceRoot, verbose = false) {
+    const localDeps = new Set();
+    const packageJsonPath = path.join(workspaceRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        return [];
+    }
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        // Scan dependencies, devDependencies, and overrides for file: protocol
+        const sections = [
+            packageJson.dependencies,
+            packageJson.devDependencies,
+            packageJson.optionalDependencies,
+            packageJson.overrides,
+        ];
+        for (const section of sections) {
+            if (!section || typeof section !== 'object')
+                continue;
+            for (const [name, value] of Object.entries(section)) {
+                if (typeof value !== 'string')
+                    continue;
+                // Match file: protocol (e.g., "file:libs/xplat/web/plugins/util-0.12.5.tgz")
+                if (value.startsWith('file:')) {
+                    const relativePath = value.slice(5); // Remove 'file:' prefix
+                    const absolutePath = path.resolve(workspaceRoot, relativePath);
+                    // Verify the path exists
+                    if (fs.existsSync(absolutePath)) {
+                        // If it's a file (like a .tgz), include the directory containing it
+                        const stat = fs.statSync(absolutePath);
+                        if (stat.isFile()) {
+                            // Include the specific file
+                            localDeps.add(relativePath);
+                            if (verbose) {
+                                console.log(`[workspace] Found local file dependency: ${relativePath}`);
+                            }
+                        }
+                        else if (stat.isDirectory()) {
+                            // Include the directory
+                            localDeps.add(relativePath);
+                            if (verbose) {
+                                console.log(`[workspace] Found local directory dependency: ${relativePath}`);
+                            }
+                        }
+                    }
+                    else if (verbose) {
+                        console.log(`[workspace] Warning: Local dependency not found: ${relativePath}`);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            console.log(`[workspace] Error scanning package.json for local deps: ${error?.message}`);
+        }
+    }
+    if (verbose && localDeps.size > 0) {
+        console.log(`[workspace] Found ${localDeps.size} local file dependencies`);
+    }
+    return Array.from(localDeps);
+}
+export function createWorkspaceManifest(workspaceCtx, deps) {
+    return {
+        version: '1.0',
+        createdAt: new Date().toISOString(),
+        workspaceType: workspaceCtx.type,
+        appPath: workspaceCtx.relativeAppPath,
+        projectName: workspaceCtx.projectName,
+        dependencies: deps,
+    };
+}
+/**
+ * Log workspace context information
+ */
+export function logWorkspaceContext(ctx, verbose = false) {
+    if (ctx.type === 'nx') {
+        console.log(`Detected Nx workspace at: ${ctx.workspaceRoot}`);
+        console.log(`App path: ${ctx.relativeAppPath}`);
+        if (ctx.projectName) {
+            console.log(`Project name: ${ctx.projectName}`);
+        }
+        if (verbose && ctx.pathMappings) {
+            console.log(`Path mappings: ${Object.keys(ctx.pathMappings).length} aliases configured`);
+        }
+    }
+    else {
+        console.log('Standalone NativeScript project detected');
+    }
+}
+/**
+ * Check if the current directory is at the root of an Nx workspace
+ * (has nx.json but no nativescript.config.ts)
+ */
+export function isAtWorkspaceRoot() {
+    const cwd = process.cwd();
+    const hasNxJson = fs.existsSync(path.join(cwd, 'nx.json'));
+    const hasNsConfig = fs.existsSync(path.join(cwd, 'nativescript.config.ts')) ||
+        fs.existsSync(path.join(cwd, 'nativescript.config.js'));
+    return hasNxJson && !hasNsConfig;
+}
+/**
+ * Discover all NativeScript apps within an Nx workspace.
+ * Looks for directories containing nativescript.config.ts files.
+ */
+export function discoverNativeScriptApps(workspaceRoot) {
+    const root = workspaceRoot || process.cwd();
+    const apps = [];
+    // Common locations to search for apps in Nx workspaces
+    const searchDirs = ['apps', 'packages'];
+    for (const searchDir of searchDirs) {
+        const searchPath = path.join(root, searchDir);
+        if (!fs.existsSync(searchPath))
+            continue;
+        // Recursively find nativescript.config.ts files
+        findNativeScriptApps(searchPath, root, apps);
+    }
+    return apps;
+}
+/**
+ * Recursively search for NativeScript apps
+ */
+function findNativeScriptApps(dir, workspaceRoot, apps) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    // Check if this directory is a NativeScript app
+    const hasNsConfig = entries.some((e) => e.isFile() && (e.name === 'nativescript.config.ts' || e.name === 'nativescript.config.js'));
+    if (hasNsConfig) {
+        const relativePath = path.relative(workspaceRoot, dir);
+        const projectName = detectProjectName(dir) || path.basename(dir);
+        apps.push({
+            name: projectName,
+            path: relativePath,
+            absolutePath: dir,
+        });
+        // Don't recurse further into this directory
+        return;
+    }
+    // Recurse into subdirectories
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        // Skip common non-app directories
+        if (['node_modules', '.git', 'dist', 'platforms', '.nx', '.cache'].includes(entry.name)) {
+            continue;
+        }
+        findNativeScriptApps(path.join(dir, entry.name), workspaceRoot, apps);
+    }
+}
+/**
+ * Get workspace context for a specific app by project name or path.
+ * Used when user specifies --project from workspace root.
+ */
+export function getWorkspaceContextForApp(projectNameOrPath, workspaceRoot) {
+    const root = workspaceRoot || process.cwd();
+    const apps = discoverNativeScriptApps(root);
+    // Try to find by project name first
+    let app = apps.find((a) => a.name === projectNameOrPath);
+    // If not found, try by path
+    if (!app) {
+        app = apps.find((a) => a.path === projectNameOrPath || a.path.endsWith(projectNameOrPath));
+    }
+    if (!app) {
+        return undefined;
+    }
+    const pathMappings = loadPathMappings(root);
+    return {
+        type: 'nx',
+        workspaceRoot: root,
+        appRoot: app.absolutePath,
+        relativeAppPath: app.path,
+        projectName: app.name,
+        pathMappings,
+    };
+}
+//# sourceMappingURL=workspace.js.map