minovative-mind-cli 1.5.1 → 2.1.0

package/dist/services/workspaceRegistry.js

@@ -0,0 +1,270 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { debugLog } from '../utils/logger.js';
+/** Regex for valid alias names: lowercase alphanumeric, hyphens, underscores, 1–30 chars. */
+const ALIAS_PATTERN = /^[a-z0-9][a-z0-9_-]{0,29}$/;
+/** Global config directory for cross-project persistence. */
+const GLOBAL_CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.minovative-mind-cli');
+/** Path to the global workspace registry file. */
+const REGISTRY_FILE = path.join(GLOBAL_CONFIG_DIR, 'workspaces.json');
+/**
+ * Service that manages a global registry of external workspace roots.
+ *
+ * Workspaces are registered with short aliases (e.g., "backend") and referenced
+ * in file paths using the `@alias/path` prefix syntax. The registry is persisted
+ * globally at `~/.minovative-mind-cli/workspaces.json` so registrations carry
+ * across different primary workspaces.
+ *
+ * @remarks
+ * This is a singleton — use the exported `workspaceRegistry` instance.
+ * All filesystem access goes through this service to maintain the security
+ * boundary: the agent can only touch the primary workspace and explicitly
+ * registered secondary workspaces.
+ */
+class WorkspaceRegistry {
+    /** In-memory map of alias → registered workspace. */
+    workspaces = new Map();
+    /** Whether the registry has been loaded from disk. */
+    initialized = false;
+    /**
+     * Initializes the registry by loading persisted workspace entries from disk.
+     * Safe to call multiple times — subsequent calls are no-ops.
+     */
+    init() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        this.loadFromDisk();
+    }
+    /**
+     * Registers a new external workspace root with the given alias.
+     *
+     * @param alias - Short identifier for the workspace (e.g., "backend").
+     *   Must be lowercase alphanumeric with hyphens/underscores, 1–30 chars.
+     * @param absolutePath - Absolute path to the workspace root directory.
+     *   Must exist on disk and be a directory.
+     * @returns The created `RegisteredWorkspace`, or throws on validation failure.
+     * @throws Error if the alias is invalid, the path doesn't exist, or the alias is already taken.
+     */
+    register(alias, absolutePath) {
+        const normalizedAlias = alias.toLowerCase().trim();
+        // Validate alias format
+        if (!ALIAS_PATTERN.test(normalizedAlias)) {
+            throw new Error(`Invalid workspace alias "${normalizedAlias}". Must be 1-30 characters, ` +
+                `lowercase alphanumeric, hyphens, or underscores, starting with a letter or digit.`);
+        }
+        // Check for duplicate aliases
+        if (this.workspaces.has(normalizedAlias)) {
+            throw new Error(`Workspace alias "${normalizedAlias}" is already registered ` +
+                `(→ ${this.workspaces.get(normalizedAlias).absolutePath}). ` +
+                `Remove it first with /workspaces → Remove.`);
+        }
+        // Normalize and validate the path
+        const normalizedPath = path.resolve(absolutePath);
+        if (!fs.existsSync(normalizedPath)) {
+            throw new Error(`Path does not exist: "${normalizedPath}"`);
+        }
+        const stats = fs.statSync(normalizedPath);
+        if (!stats.isDirectory()) {
+            throw new Error(`Path is not a directory: "${normalizedPath}"`);
+        }
+        // Prevent registering sensitive system directories
+        const blockedRoots = ['/', '/etc', '/usr', '/bin', '/sbin', '/var', '/tmp', '/System', '/Library'];
+        if (blockedRoots.includes(normalizedPath) || normalizedPath === path.parse(normalizedPath).root) {
+            throw new Error(`Cannot register system root directory "${normalizedPath}". ` +
+                `Only project directories are allowed.`);
+        }
+        // Prevent duplicate paths under different aliases
+        for (const [existingAlias, existing] of this.workspaces) {
+            if (existing.absolutePath === normalizedPath) {
+                throw new Error(`This path is already registered under alias "${existingAlias}". ` +
+                    `Remove it first if you want to re-register with a different alias.`);
+            }
+        }
+        const workspace = {
+            alias: normalizedAlias,
+            absolutePath: normalizedPath,
+            registeredAt: Date.now(),
+        };
+        this.workspaces.set(normalizedAlias, workspace);
+        this.saveToDisk();
+        debugLog(`Registered workspace: @${normalizedAlias} → ${normalizedPath}`);
+        return workspace;
+    }
+    /**
+     * Removes a registered workspace by alias.
+     *
+     * @param alias - The alias to unregister.
+     * @returns `true` if the workspace was found and removed, `false` otherwise.
+     */
+    unregister(alias) {
+        const normalizedAlias = alias.toLowerCase().trim();
+        const existed = this.workspaces.delete(normalizedAlias);
+        if (existed) {
+            this.saveToDisk();
+            debugLog(`Unregistered workspace: @${normalizedAlias}`);
+        }
+        return existed;
+    }
+    /**
+     * Returns all registered workspaces as an array, sorted by alias.
+     */
+    list() {
+        return Array.from(this.workspaces.values()).sort((a, b) => a.alias.localeCompare(b.alias));
+    }
+    /**
+     * Returns the number of registered workspaces.
+     */
+    get size() {
+        return this.workspaces.size;
+    }
+    /**
+     * Checks whether any external workspaces are registered.
+     */
+    hasWorkspaces() {
+        return this.workspaces.size > 0;
+    }
+    /**
+     * Looks up a workspace by alias.
+     *
+     * @param alias - The alias to find (without the `@` prefix).
+     * @returns The registered workspace, or `undefined` if not found.
+     */
+    get(alias) {
+        return this.workspaces.get(alias.toLowerCase().trim());
+    }
+    /**
+     * Returns all workspace roots (primary + registered secondaries).
+     *
+     * @param primaryRoot - The primary workspace root (from `process.cwd()`).
+     * @returns An array of `{ alias: string | null, root: string }` entries.
+     *   The primary workspace has `alias: null`.
+     */
+    getAllRoots(primaryRoot) {
+        const roots = [{ alias: null, root: primaryRoot }];
+        for (const ws of this.workspaces.values()) {
+            // Skip if a registered workspace happens to be the same as the primary
+            if (ws.absolutePath !== path.resolve(primaryRoot)) {
+                roots.push({ alias: ws.alias, root: ws.absolutePath });
+            }
+        }
+        return roots;
+    }
+    /**
+     * Resolves an `@alias/relative/path` string into its constituent parts.
+     *
+     * @param filePath - A file path that may or may not start with `@alias/`.
+     * @returns A `ResolvedWorkspacePath` if the path has a valid `@alias/` prefix
+     *   and the alias is registered, or `null` if the path is a standard
+     *   workspace-relative path (no `@` prefix or unrecognized alias).
+     * @throws Error if the path has an `@` prefix but the alias is not registered.
+     */
+    resolve(filePath) {
+        if (!filePath.startsWith('@')) {
+            return null;
+        }
+        // Extract alias and relative path from "@alias/relative/path"
+        const withoutAt = filePath.substring(1);
+        const slashIndex = withoutAt.indexOf('/');
+        const alias = slashIndex === -1 ? withoutAt : withoutAt.substring(0, slashIndex);
+        const relativePath = slashIndex === -1 ? '.' : withoutAt.substring(slashIndex + 1);
+        const workspace = this.workspaces.get(alias.toLowerCase());
+        if (!workspace) {
+            throw new Error(`Unknown workspace alias "@${alias}". ` +
+                `Registered workspaces: ${this.list().map((w) => `@${w.alias}`).join(', ') || '(none)'}. ` +
+                `Use /workspaces to add one.`);
+        }
+        const absolutePath = path.resolve(workspace.absolutePath, relativePath);
+        return {
+            alias: workspace.alias,
+            workspaceRoot: workspace.absolutePath,
+            relativePath,
+            absolutePath,
+        };
+    }
+    /**
+     * Checks if a given file path uses the `@alias/` prefix syntax.
+     *
+     * @param filePath - The path to check.
+     * @returns `true` if the path starts with `@`.
+     */
+    isAliasedPath(filePath) {
+        return filePath.startsWith('@');
+    }
+    /**
+     * Builds a formatted summary of all registered workspaces for system prompt injection.
+     *
+     * @returns A human-readable string listing all aliases and their paths,
+     *   or an empty string if no workspaces are registered.
+     */
+    buildPromptSummary() {
+        if (this.workspaces.size === 0)
+            return '';
+        const lines = this.list().map((ws) => `- @${ws.alias} → ${ws.absolutePath}`);
+        return lines.join('\n');
+    }
+    // ─── Persistence ───────────────────────────────────────────────────
+    /**
+     * Loads the workspace registry from the global config file.
+     * Silently handles missing or corrupted files.
+     */
+    loadFromDisk() {
+        try {
+            if (!fs.existsSync(REGISTRY_FILE)) {
+                debugLog('Workspace registry file not found, starting fresh.');
+                return;
+            }
+            const raw = fs.readFileSync(REGISTRY_FILE, 'utf-8');
+            const data = JSON.parse(raw);
+            if (!Array.isArray(data)) {
+                debugLog('Workspace registry file has invalid format, starting fresh.');
+                return;
+            }
+            // Validate each entry and skip invalid ones
+            for (const entry of data) {
+                if (typeof entry.alias === 'string' &&
+                    typeof entry.absolutePath === 'string' &&
+                    ALIAS_PATTERN.test(entry.alias)) {
+                    // Only load if the directory still exists
+                    if (fs.existsSync(entry.absolutePath)) {
+                        this.workspaces.set(entry.alias, entry);
+                    }
+                    else {
+                        debugLog(`Skipping stale workspace @${entry.alias} — path no longer exists: ${entry.absolutePath}`);
+                    }
+                }
+            }
+            debugLog(`Loaded ${this.workspaces.size} workspace(s) from global registry.`);
+        }
+        catch (err) {
+            debugLog(`Failed to load workspace registry: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Persists the current workspace registry to the global config file.
+     * Creates the config directory if it doesn't exist.
+     */
+    saveToDisk() {
+        try {
+            // Ensure the global config directory exists
+            if (!fs.existsSync(GLOBAL_CONFIG_DIR)) {
+                fs.mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+            }
+            const data = Array.from(this.workspaces.values());
+            const tempPath = `${REGISTRY_FILE}.${Date.now()}.tmp`;
+            fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), 'utf-8');
+            // Atomic rename to prevent corruption
+            fs.renameSync(tempPath, REGISTRY_FILE);
+            debugLog(`Saved ${data.length} workspace(s) to global registry.`);
+        }
+        catch (err) {
+            debugLog(`Failed to save workspace registry: ${err instanceof Error ? err.message : String(err)}`);
+            // Non-fatal: the in-memory state is still correct
+        }
+    }
+}
+/**
+ * Singleton instance of the WorkspaceRegistry service.
+ * Initialize with `workspaceRegistry.init()` during CLI startup.
+ */
+export const workspaceRegistry = new WorkspaceRegistry();

package/dist/utils/asyncContext.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Runs a callback within the context of a specific agent/thread ID.
+ * All downstream async operations will be able to access this ID.
+ *
+ * @param agentId The ID of the agent/thread to track.
+ * @param callback The function to execute.
+ * @returns The result of the callback.
+ */
+export declare function runWithAgentId<T>(agentId: string, callback: () => T): T;
+/**
+ * Retrieves the ID of the currently active agent/thread from the async context.
+ * Returns 'main' if no context is active (e.g., fallback for single-agent or orchestrator).
+ *
+ * @returns The current agent ID, or 'main' as fallback.
+ */
+export declare function getCurrentAgentId(): string;

package/dist/utils/asyncContext.js

@@ -0,0 +1,25 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * AsyncLocalStorage instance to track the current active agent/thread ID.
+ */
+const agentContext = new AsyncLocalStorage();
+/**
+ * Runs a callback within the context of a specific agent/thread ID.
+ * All downstream async operations will be able to access this ID.
+ *
+ * @param agentId The ID of the agent/thread to track.
+ * @param callback The function to execute.
+ * @returns The result of the callback.
+ */
+export function runWithAgentId(agentId, callback) {
+    return agentContext.run(agentId, callback);
+}
+/**
+ * Retrieves the ID of the currently active agent/thread from the async context.
+ * Returns 'main' if no context is active (e.g., fallback for single-agent or orchestrator).
+ *
+ * @returns The current agent ID, or 'main' as fallback.
+ */
+export function getCurrentAgentId() {
+    return agentContext.getStore() || 'main';
+}

package/dist/utils/config.d.ts

@@ -17,6 +17,8 @@ export declare const GEMINI_MODELS: {
     readonly PRO_3_1: "gemini-3.1-pro-preview";
     readonly FLASH_3_5: "gemini-3.5-flash";
     readonly FLASH_LITE_3_1: "gemini-3.1-flash-lite";
+    readonly EMBEDDING: "text-embedding-004";
+    readonly AUTO: "auto";
 };
 /**
  * Supported Anthropic Claude models.
@@ -26,6 +28,6 @@ export declare const CLAUDE_MODELS: {
     readonly SONNET: "claude-sonnet-4-6";
 };
 /** Default Gemini model for the coding agent. */
-export declare const DEFAULT_MODEL: "gemini-3.5-flash";
+export declare const DEFAULT_MODEL: "auto";
 /** Maximum tokens the model can output per response. */
 export declare const MAX_OUTPUT_TOKENS = 60000;

package/dist/utils/config.js

@@ -17,6 +17,8 @@ export const GEMINI_MODELS = {
     PRO_3_1: 'gemini-3.1-pro-preview',
     FLASH_3_5: 'gemini-3.5-flash',
     FLASH_LITE_3_1: 'gemini-3.1-flash-lite',
+    EMBEDDING: 'text-embedding-004',
+    AUTO: 'auto',
 };
 /**
  * Supported Anthropic Claude models.
@@ -26,6 +28,6 @@ export const CLAUDE_MODELS = {
     SONNET: 'claude-sonnet-4-6',
 };
 /** Default Gemini model for the coding agent. */
-export const DEFAULT_MODEL = GEMINI_MODELS.FLASH_3_5;
+export const DEFAULT_MODEL = GEMINI_MODELS.AUTO;
 /** Maximum tokens the model can output per response. */
 export const MAX_OUTPUT_TOKENS = 60_000;

package/dist/utils/contextPrompts.js

@@ -41,10 +41,17 @@ ${context.webSearchSummary}
     }
     if (context.relevantFiles.size > 0) {
         injection += `\n## Relevant File Contents\n`;
-        for (const [filePath, content] of context.relevantFiles.entries()) {
-            injection += `<workspace_file path="${filePath}">
+        for (const [filePath, contentObj] of context.relevantFiles.entries()) {
+            const contentText = contentObj.text;
+            let aliasAttr = '';
+            if (filePath.startsWith('@')) {
+                const slashIndex = filePath.indexOf('/');
+                const alias = slashIndex === -1 ? filePath.substring(1) : filePath.substring(1, slashIndex);
+                aliasAttr = ` workspace="${alias}"`;
+            }
+            injection += `<workspace_file path="${filePath}"${aliasAttr}>
 <content_data><![CDATA[
-${sanitizeForCDATA(content)}
+${sanitizeForCDATA(contentText)}
 ]]\\u200B></content_data>
 </workspace_file>\n`;
         }

package/dist/utils/dependencyTracer/modules/api.d.ts

@@ -0,0 +1,9 @@
+export interface FindDependenciesResult {
+    filePath: string;
+    forwardDeps: string[];
+    reverseDeps: string[];
+    forwardTree: string[];
+    reverseTree: string[];
+}
+export declare function extractImports(content: string, ext: string): string[];
+export declare function resolveImportPath(workspaceRoot: string, sourceFile: string, specifier: string): Promise<string | null>;

package/dist/utils/dependencyTracer/modules/api.js

@@ -0,0 +1,62 @@
+import { PROFILE_BY_EXT } from './profiles.js';
+import { loadPathAliases } from './resolver.js';
+import { probeFilePath } from './walker.js';
+import path from 'node:path';
+export function extractImports(content, ext) {
+    const profiles = PROFILE_BY_EXT.get(ext);
+    if (!profiles || profiles.length === 0)
+        return [];
+    const specifiers = new Set();
+    for (const profile of profiles) {
+        for (const pattern of profile.patterns) {
+            pattern.lastIndex = 0;
+            for (const match of content.matchAll(pattern)) {
+                const raw = match.groups?.specifier;
+                if (raw && raw.trim().length > 0) {
+                    const normalized = profile.normalizeSpecifier ? profile.normalizeSpecifier(raw.trim(), '') : raw.trim();
+                    specifiers.add(normalized);
+                }
+            }
+        }
+    }
+    return Array.from(specifiers);
+}
+export async function resolveImportPath(workspaceRoot, sourceFile, specifier) {
+    if (specifier.startsWith('node:') ||
+        specifier.startsWith('bun:') ||
+        specifier.startsWith('deno:') ||
+        specifier.startsWith('package:') ||
+        specifier.startsWith('dart:') ||
+        specifier.startsWith('http://') ||
+        specifier.startsWith('https://')) {
+        return null;
+    }
+    const isRelative = specifier.startsWith('.') || specifier.startsWith('/');
+    if (!isRelative) {
+        const aliases = await loadPathAliases(workspaceRoot);
+        for (const alias of aliases) {
+            if (specifier.startsWith(alias.prefix)) {
+                const remainder = specifier.slice(alias.prefix.length);
+                for (const target of alias.targets) {
+                    const candidate = path.join(workspaceRoot, target, remainder);
+                    const resolved = await probeFilePath(candidate);
+                    if (resolved)
+                        return path.relative(workspaceRoot, resolved).replace(/\\/g, '/');
+                }
+            }
+        }
+        const fromRoot = path.join(workspaceRoot, specifier);
+        const rootResolved = await probeFilePath(fromRoot);
+        if (rootResolved)
+            return path.relative(workspaceRoot, rootResolved).replace(/\\/g, '/');
+        return null;
+    }
+    const sourceDir = path.dirname(path.join(workspaceRoot, sourceFile));
+    const absoluteCandidate = path.resolve(sourceDir, specifier);
+    if (!absoluteCandidate.startsWith(workspaceRoot))
+        return null;
+    const resolved = await probeFilePath(absoluteCandidate);
+    if (resolved)
+        return path.relative(workspaceRoot, resolved).replace(/\\/g, '/');
+    return null;
+}

package/dist/utils/dependencyTracer/modules/graph.d.ts

@@ -0,0 +1,9 @@
+import { DependencyNode } from './types.js';
+export interface DependencyGraph {
+    getImports(filePath: string): string[];
+    getImportedBy(filePath: string): string[];
+    getReverseDependencyTree(filePath: string, maxDepth?: number): string[];
+    getForwardDependencyTree(filePath: string, maxDepth?: number): string[];
+    readonly nodes: ReadonlyMap<string, DependencyNode>;
+}
+export declare function bfsTraverse(nodes: Map<string, DependencyNode>, startFile: string, direction: 'imports' | 'importedBy', maxDepth: number): string[];

package/dist/utils/dependencyTracer/modules/graph.js

@@ -0,0 +1,23 @@
+export function bfsTraverse(nodes, startFile, direction, maxDepth) {
+    const visited = new Set();
+    visited.add(startFile);
+    const queue = [{ file: startFile, depth: 0 }];
+    const result = [];
+    while (queue.length > 0) {
+        const { file, depth } = queue.shift();
+        if (depth >= maxDepth)
+            continue;
+        const node = nodes.get(file);
+        if (!node)
+            continue;
+        const neighbors = node[direction];
+        for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+                visited.add(neighbor);
+                result.push(neighbor);
+                queue.push({ file: neighbor, depth: depth + 1 });
+            }
+        }
+    }
+    return result;
+}

package/dist/utils/dependencyTracer/modules/profiles.d.ts

@@ -0,0 +1,7 @@
+export interface LanguageProfile {
+    extensions: string[];
+    patterns: RegExp[];
+    normalizeSpecifier?: (specifier: string, sourceFile: string) => string;
+}
+export declare const LANGUAGE_PROFILES: LanguageProfile[];
+export declare const PROFILE_BY_EXT: Map<string, LanguageProfile[]>;

package/dist/utils/dependencyTracer/modules/profiles.js

@@ -0,0 +1,120 @@
+export const LANGUAGE_PROFILES = [
+    {
+        extensions: ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.mts', '.cts'],
+        patterns: [
+            /import\s+(?:[\s\S]*?\s+from\s+)?['"](?<specifier>[^'"]+)['"]/gm,
+            /import\s*\(\s*['"](?<specifier>[^'"]+)['"]\s*\)/gm,
+            /require\s*\(\s*['"](?<specifier>[^'"]+)['"]\s*\)/gm,
+            /export\s+(?:[\s\S]*?\s+from\s+)['"](?<specifier>[^'"]+)['"]/gm,
+        ],
+    },
+    {
+        extensions: ['.py'],
+        patterns: [
+            /^from\s+(?<specifier>[^\s]+)\s+import\s/gm,
+            /^import\s+(?!.*\sfrom\s)(?<specifier>[^\s,]+)/gm,
+        ],
+        normalizeSpecifier: (spec) => {
+            if (spec.startsWith('.')) {
+                const dots = spec.match(/^\.+/)[0];
+                const rest = spec.slice(dots.length);
+                const prefix = dots.length === 1 ? './' : '../'.repeat(dots.length - 1);
+                return rest ? `${prefix}${rest.replace(/\./g, '/')}.py` : prefix.slice(0, -1);
+            }
+            return spec.replace(/\./g, '/') + '.py';
+        },
+    },
+    {
+        extensions: ['.rs'],
+        patterns: [
+            /use\s+(?<specifier>(?:crate|self|super)(?:::[a-zA-Z_][a-zA-Z0-9_]*)+)/gm,
+            /mod\s+(?<specifier>[a-zA-Z_][a-zA-Z0-9_]*)\s*;/gm,
+        ],
+        normalizeSpecifier: (spec) => {
+            if (!spec.includes('::')) {
+                return spec + '.rs';
+            }
+            const parts = spec
+                .replace(/^crate::/, '')
+                .replace(/^(self|super)::/, '')
+                .split('::');
+            return parts.join('/') + '.rs';
+        },
+    },
+    {
+        extensions: ['.go'],
+        patterns: [
+            /import\s+(?:[a-zA-Z_][a-zA-Z0-9_]*\s+)?["'](?<specifier>[^"']+)["']/gm,
+            /^\s*(?:[a-zA-Z_][a-zA-Z0-9_]*\s+)?["'](?<specifier>[^"']+)["']\s*$/gm,
+        ],
+    },
+    {
+        extensions: ['.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hh', '.hxx'],
+        patterns: [
+            /^\s*#\s*include\s+"(?<specifier>[^"]+)"/gm,
+            /^\s*#\s*include\s+<(?<specifier>[^>]+)>/gm,
+        ],
+    },
+    {
+        extensions: ['.java', '.kt', '.kts'],
+        patterns: [
+            /^import\s+(?:static\s+)?(?<specifier>[a-zA-Z_][a-zA-Z0-9_.]*\.[a-zA-Z_][a-zA-Z0-9_]*)/gm,
+        ],
+        normalizeSpecifier: (spec) => {
+            return spec.replace(/\./g, '/') + '.java';
+        },
+    },
+    {
+        extensions: ['.css', '.scss', '.sass', '.less', '.styl'],
+        patterns: [
+            /@import\s+(?:url\s*\(\s*)?['"](?<specifier>[^'"]+)['"]/gm,
+            /@use\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /@forward\s+['"](?<specifier>[^'"]+)['"]/gm,
+        ],
+    },
+    {
+        extensions: ['.rb'],
+        patterns: [
+            /require\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /require_relative\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /load\s+['"](?<specifier>[^'"]+)['"]/gm,
+        ],
+    },
+    {
+        extensions: ['.php'],
+        patterns: [
+            /use\s+(?<specifier>[A-Z][a-zA-Z0-9_\\]+)/gm,
+            /(?:include|require)(?:_once)?\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /(?:include|require)(?:_once)?\s*\(\s*['"](?<specifier>[^'"]+)['"]\s*\)/gm,
+        ],
+        normalizeSpecifier: (spec) => {
+            if (spec.includes('\\')) {
+                return spec.replace(/\\/g, '/') + '.php';
+            }
+            return spec;
+        },
+    },
+    {
+        extensions: ['.swift'],
+        patterns: [
+            /^import\s+(?:class\s+|struct\s+|enum\s+|protocol\s+|typealias\s+|func\s+|var\s+|let\s+)?(?<specifier>[a-zA-Z_][a-zA-Z0-9_.]*)/gm,
+        ],
+    },
+    {
+        extensions: ['.dart'],
+        patterns: [
+            /import\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /export\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /part\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /part\s+of\s+['"](?<specifier>[^'"]+)['"]/gm,
+        ],
+    },
+];
+export const PROFILE_BY_EXT = new Map();
+for (const profile of LANGUAGE_PROFILES) {
+    for (const ext of profile.extensions) {
+        const existing = PROFILE_BY_EXT.get(ext) || [];
+        existing.push(profile);
+        PROFILE_BY_EXT.set(ext, existing);
+    }
+}

package/dist/utils/dependencyTracer/modules/resolver.d.ts

@@ -0,0 +1,7 @@
+export interface AliasMapping {
+    prefix: string;
+    targets: string[];
+}
+export declare function loadPathAliases(workspaceRoot: string): Promise<AliasMapping[]>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function normalizeSlashes(p: string): string;

package/dist/utils/dependencyTracer/modules/resolver.js

@@ -0,0 +1,51 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+let cachedAliases = null;
+let cachedAliasRoot = null;
+export async function loadPathAliases(workspaceRoot) {
+    if (cachedAliasRoot === workspaceRoot && cachedAliases !== null) {
+        return cachedAliases;
+    }
+    const aliases = [];
+    for (const configName of ['tsconfig.json', 'jsconfig.json']) {
+        try {
+            const configPath = path.join(workspaceRoot, configName);
+            const raw = await fs.readFile(configPath, 'utf-8');
+            const cleaned = raw.replace(/\/\/.*$/gm, '').replace(/,\s*([\]}])/g, '');
+            const config = JSON.parse(cleaned);
+            const paths = config?.compilerOptions?.paths;
+            const baseUrl = config?.compilerOptions?.baseUrl || '.';
+            if (paths && typeof paths === 'object') {
+                for (const [pattern, targets] of Object.entries(paths)) {
+                    if (!Array.isArray(targets))
+                        continue;
+                    const prefix = pattern.replace(/\*$/, '');
+                    const resolvedTargets = targets.map((t) => {
+                        const targetBase = t.replace(/\*$/, '');
+                        return path.join(baseUrl, targetBase);
+                    });
+                    aliases.push({ prefix, targets: resolvedTargets });
+                }
+            }
+            break;
+        }
+        catch {
+            // Config doesn't exist or is invalid — try the next one
+        }
+    }
+    cachedAliases = aliases;
+    cachedAliasRoot = workspaceRoot;
+    return aliases;
+}
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function normalizeSlashes(p) {
+    return p.replace(/\\/g, '/');
+}

package/dist/utils/dependencyTracer/modules/types.d.ts

@@ -0,0 +1,4 @@
+export interface DependencyNode {
+    imports: Set<string>;
+    importedBy: Set<string>;
+}