prodex 2.0.0 → 2.1.0

package/dist/output/produce-output.js

@@ -12,13 +12,12 @@ const render_constants_1 = require("./render-constants");
 const markdown_1 = require("./markdown");
 const text_1 = require("./text");
 const path_2 = require("../filesystem/path");
-async function produceOutput({ name, files, cfg }) {
-    const { output: { format, versioned, dir }, } = cfg;
+async function produceOutput({ name, payload, format, dir, versioned, }) {
     let outputBase = (0, path_2.sanitizeFileName)(name || "combined");
     outputBase = `${outputBase}-${render_constants_1.SUFFIX}`;
     if (versioned)
         outputBase = `${outputBase}_${(0, naming_1.shortTimestamp)()}`;
-    const outputDir = path_1.default.isAbsolute(dir) ? dir : path_1.default.join(cfg.root, dir);
+    const outputDir = path_1.default.isAbsolute(dir) ? dir : path_1.default.join(payload.root, dir);
     try {
         fs_1.default.mkdirSync(outputDir, { recursive: true });
     }
@@ -26,10 +25,10 @@ async function produceOutput({ name, files, cfg }) {
         logger_1.logger.warn("Could not create output directory:", outputDir);
     }
     const outputPath = path_1.default.join(outputDir, `${outputBase}.${format}`);
-    const sorted = [...files].sort((a, b) => a.localeCompare(b));
     const content = format === "txt"
-        ? [(0, text_1.tocTxt)(sorted, cfg.root), ...sorted.map((file) => (0, text_1.renderTxt)(file, cfg.root))].join("")
-        : (0, markdown_1.renderTraceMd)(sorted, cfg.root).content;
+        ? (0, text_1.renderTxt)(payload)
+        : (0, markdown_1.renderTraceMd)(payload).content;
     fs_1.default.writeFileSync(outputPath, content, "utf8");
-    return outputPath;
+    const outputSizeBytes = Buffer.byteLength(content, "utf8");
+    return { outputPath, outputSizeBytes };
 }

package/dist/output/render-helpers.d.ts

@@ -0,0 +1,4 @@
+import type { LayoutOrder } from "../types";
+export declare function getLayoutOrder(commandKind?: string): LayoutOrder;
+export declare function formatExitCode(code: number | null): string;
+export declare function formatTimeout(timedOut: boolean): string;

package/dist/output/render-helpers.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLayoutOrder = getLayoutOrder;
+exports.formatExitCode = formatExitCode;
+exports.formatTimeout = formatTimeout;
+function getLayoutOrder(commandKind) {
+    return commandKind === "git" ? "sections-first" : "files-first";
+}
+function formatExitCode(code) {
+    return code !== null ? String(code) : "null";
+}
+function formatTimeout(timedOut) {
+    return timedOut ? "yes" : "no";
+}

package/dist/output/text.d.ts

@@ -1,2 +1,2 @@
-export declare function tocTxt(files: string[], root?: string): string;
-export declare function renderTxt(filePath: string, root?: string): string;
+import type { ArtifactPayload } from "../types";
+export declare function renderTxt(payload: ArtifactPayload): string;

package/dist/output/text.js

@@ -1,14 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tocTxt = tocTxt;
 exports.renderTxt = renderTxt;
 const read_file_1 = require("../filesystem/read-file");
-function tocTxt(files, root = process.cwd()) {
-    const sorted = [...files].sort((a, b) => a.localeCompare(b));
-    return ["##==== Combined Scope ====", ...sorted.map((file) => "## - " + (0, read_file_1.rel)(file, root))].join("\n") + "\n\n";
+const render_helpers_1 = require("./render-helpers");
+function renderTxt(payload) {
+    const root = payload.root;
+    const sorted = [...payload.files].sort((a, b) => a.path.localeCompare(b.path));
+    const contextLines = [];
+    if (payload.metadata?.commandKind === "trace" && payload.metadata.targets && payload.metadata.targets.length > 0) {
+        const relativeEntries = payload.metadata.entries.map(e => (0, read_file_1.rel)(e, root));
+        contextLines.push("##==== Trace Target Context ====", `## - Requested Target(s): ${payload.metadata.targets.join(", ")}`, `## - Resolved Starting Point(s): ${relativeEntries.join(", ") || "none"}`, `## - Traversal Depth: ${payload.metadata.depth !== undefined ? payload.metadata.depth : "none"}`, "");
+    }
+    const layoutOrder = (0, render_helpers_1.getLayoutOrder)(payload.metadata?.commandKind);
+    const isFileFirst = layoutOrder === "files-first";
+    const sectionToc = (payload.sections ?? []).map((sec) => "## - Section: " + sec.title);
+    const fileToc = sorted.map((file) => "## - File: " + (0, read_file_1.rel)(file.path, root));
+    const tocParts = isFileFirst ? [...fileToc, ...sectionToc] : [...sectionToc, ...fileToc];
+    const toc = ["##==== Combined Scope ====", ...contextLines, ...tocParts].join("\n") + "\n\n";
+    const genericSections = (payload.sections ?? [])
+        .map((sec) => {
+        return ["##==== section: " + sec.title + " ====", "##region " + sec.title, sec.content, "##endregion", ""].join("\n");
+    })
+        .join("");
+    const fileSections = sorted
+        .map((file) => {
+        const relativePath = (0, read_file_1.rel)(file.path, root);
+        const code = file.readError ? `Error reading file: ${file.readError}` : file.content;
+        return ["##==== path: " + relativePath + " ====", "##region " + relativePath, code, "##endregion", ""].join("\n");
+    })
+        .join("");
+    const cmdAttachments = renderTxtCmdResults(payload.commandOutputs, root);
+    const bodyParts = isFileFirst
+        ? [toc, fileSections, cmdAttachments, genericSections]
+        : [toc, genericSections, fileSections, cmdAttachments];
+    return bodyParts.join("");
 }
-function renderTxt(filePath, root = process.cwd()) {
-    const relativePath = (0, read_file_1.rel)(filePath, root);
-    const code = (0, read_file_1.readFileSafe)(filePath);
-    return ["##==== path: " + relativePath + " ====", "##region " + relativePath, code, "##endregion", ""].join("\n");
+function renderTxtCmdResults(cmdResults, root = process.cwd()) {
+    if (!cmdResults || cmdResults.length === 0)
+        return "";
+    const lines = ["\n##==== Command Attachments ===="];
+    for (let i = 0; i < cmdResults.length; i++) {
+        const res = cmdResults[i];
+        const statusStr = res.status;
+        lines.push(`## Command ${i + 1}`, `## - Command: ${res.command}`, `## - Directory: ${(0, read_file_1.rel)(res.cwd, root) || "."}`, `## - Status: ${statusStr}`, `## - Exit Code: ${(0, render_helpers_1.formatExitCode)(res.exitCode)}`, `## - Duration: ${res.durationMs}ms`, `## - Timeout State: ${res.timedOut ? "Yes" : "No"}`, `## - Output:`);
+        if (res.errorMessage) {
+            lines.push(`## - Error Message: ${res.errorMessage}`);
+        }
+        lines.push(res.combinedOutput);
+    }
+    lines.push("##==== End Command Attachments ====\n");
+    return lines.join("\n");
 }

package/dist/resolvers/js/resolve-alias.js

@@ -5,48 +5,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAliasPath = resolveAliasPath;
 const path_1 = __importDefault(require("path"));
-const cache_manager_1 = require("../../cache/cache-manager");
-const cache_keys_1 = require("../../cache/cache-keys");
-const glob_scan_1 = require("../../filesystem/glob-scan");
-const read_file_1 = require("../../filesystem/read-file");
-const path_2 = require("../../filesystem/path");
 async function resolveAliasPath(specifier, root, cfg) {
-    if (!specifier.includes("/"))
-        return null;
-    const [aliasName, ...rest] = specifier.split("/");
-    const remainder = rest.join("/");
-    const knownAliases = cfg.resolve.aliases || {};
-    const aliasKey = aliasName.startsWith("@") ? aliasName : `@${aliasName}`;
-    // 1️⃣ Check config-defined aliases
-    if (knownAliases[aliasKey]) {
-        const relPart = remainder.replace(/^\/+/, "");
-        return path_1.default.resolve(root, knownAliases[aliasKey], relPart);
-    }
-    // 2️⃣ Check cached aliases
-    const cached = cache_manager_1.CacheManager.get(cache_keys_1.CACHE_KEYS.ALIASES, aliasKey);
-    if (cached) {
-        const relPart = remainder.replace(/^\/+/, "");
-        return path_1.default.resolve(root, cached, relPart);
-    }
-    // 3️⃣ Fallback discovery with Fast-Glob
-    const stripped = remainder;
-    const hasExt = /\.[a-z0-9]+$/i.test(stripped);
-    const patterns = hasExt ? [`**/${stripped}`] : [`**/${stripped}.*`, `**/${stripped}/index.*`];
-    const { files: matches } = await (0, glob_scan_1.globScan)(patterns, { cwd: root });
-    if (matches.length) {
-        const resolvedMatch = resolveMatches(matches, remainder);
-        if (!resolvedMatch)
-            return null;
-        const relPath = (0, read_file_1.rel)(resolvedMatch, cfg.root);
-        cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.ALIASES, aliasKey, relPath);
-        return relPath;
+    const knownAliases = cfg.aliases || {};
+    const aliasKeys = Object.keys(knownAliases).sort((a, b) => b.length - a.length);
+    for (const aliasKey of aliasKeys) {
+        if (specifier === aliasKey) {
+            return path_1.default.resolve(root, knownAliases[aliasKey]);
+        }
+        if (specifier.startsWith(aliasKey + "/")) {
+            const remainder = specifier.slice(aliasKey.length + 1);
+            return path_1.default.resolve(root, knownAliases[aliasKey], remainder);
+        }
     }
     return null;
 }
-function resolveMatches(matches, remainder) {
-    const foundFile = (0, path_2.normalizePath)(matches[0]);
-    const dSplit = foundFile.split(remainder);
-    if (dSplit.length < 2)
-        return "";
-    return (0, path_2.normalizePath)(dSplit[0]);
-}

package/dist/resolvers/php/bindings.js

@@ -41,14 +41,14 @@ function loadLaravelBindings(root) {
             const short = fqcn.split("\\").pop();
             importMap[short] = fqcn;
         }
-        // 2️⃣ Extract bindings (short class names only)
-        const bindRe = /\$this->app->(?:bind|singleton)\s*\(\s*([A-Za-z0-9_]+)::class\s*,\s*([A-Za-z0-9_]+)::class/g;
+        // 2️⃣ Extract bindings
+        const bindRe = /\$this->app->(?:bind|singleton)\s*\(\s*\\?([A-Za-z0-9_\\]+)::class\s*,\s*\\?([A-Za-z0-9_\\]+)::class/g;
         let m;
         while ((m = bindRe.exec(code))) {
-            const ifaceShort = m[1];
-            const implShort = m[2];
-            const ifaceFull = importMap[ifaceShort] || ifaceShort;
-            const implFull = importMap[implShort] || implShort;
+            const ifaceRaw = m[1].replace(/^\\+/, "");
+            const implRaw = m[2].replace(/^\\+/, "");
+            const ifaceFull = importMap[ifaceRaw] || ifaceRaw;
+            const implFull = importMap[implRaw] || implRaw;
             logger_1.logger.debug(`[laravel-bindings] ${file} => ${ifaceFull} => ${implFull}`);
             bindings[ifaceFull] = implFull;
         }

package/dist/resolvers/php/extract-imports.d.ts

@@ -1,13 +1,25 @@
+import type { PhpResolverCtx } from "../../types";
 /**
- * Extracts import-like references from PHP code.
- * Supports:
- *  - require/include/require_once/include_once
- *  - use statements (including grouped imports like `use App\Models\{User, Team};`)
+ * Extracts PHP use statements and builds an alias/ShortName to FQCN mapping.
+ * Handles:
+ *  - use Foo\Bar; => { Bar: "Foo\\Bar" }
+ *  - use Foo\Bar as Baz; => { Baz: "Foo\\Bar" }
+ *  - use App\Models\{User, Team as Group}; => { User: "App\\Models\\User", Group: "App\\Models\\Team" }
  */
-export declare function extractPhpImports(code: string): Set<string>;
+export declare function extractPhpUseMap(code: string): Record<string, string>;
+/**
+ * Extracts class references, type hints, static calls, and require/include paths.
+ */
+export declare function extractPhpReferences(code: string): Set<string>;
 /**
  * Expands grouped `use` imports into individual fully qualified names.
- * Example:
- *   "App\\Models\\{User, Team}" to ["App\\Models\\User", "App\\Models\\Team"]
  */
 export declare function expandGroupedUses(raw: Set<string>): Set<string>;
+/**
+ * Resolves a raw PHP reference to a fully qualified class name or path.
+ */
+export declare function resolvePhpReference(reference: string, currentNamespace: string | null, useMap: Record<string, string>, ctx: PhpResolverCtx): string | null;
+/**
+ * Backward-compatible wrapper for extracting raw PHP imports.
+ */
+export declare function extractPhpImports(code: string): Set<string>;

package/dist/resolvers/php/extract-imports.js

@@ -1,47 +1,122 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractPhpImports = extractPhpImports;
+exports.extractPhpUseMap = extractPhpUseMap;
+exports.extractPhpReferences = extractPhpReferences;
 exports.expandGroupedUses = expandGroupedUses;
+exports.resolvePhpReference = resolvePhpReference;
+exports.extractPhpImports = extractPhpImports;
 /**
- * Extracts import-like references from PHP code.
- * Supports:
- *  - require/include/require_once/include_once
- *  - use statements (including grouped imports like `use App\Models\{User, Team};`)
+ * Extracts PHP use statements and builds an alias/ShortName to FQCN mapping.
+ * Handles:
+ *  - use Foo\Bar; => { Bar: "Foo\\Bar" }
+ *  - use Foo\Bar as Baz; => { Baz: "Foo\\Bar" }
+ *  - use App\Models\{User, Team as Group}; => { User: "App\\Models\\User", Group: "App\\Models\\Team" }
  */
-function extractPhpImports(code) {
+function extractPhpUseMap(code) {
+    const useMap = {};
+    // Match statements like: use App\Models\User; or use App\Models\{User, Team as Group};
+    // Skip "use function" or "use const"
+    const useStmtRe = /\buse\s+(?!(?:function|const)\s+)([^;]+);/g;
+    let match;
+    while ((match = useStmtRe.exec(code))) {
+        const block = match[1].trim();
+        // Check if it's a grouped use statement
+        const groupMatch = block.match(/^(.+?)\s*{([^}]+)}/);
+        if (groupMatch) {
+            const base = groupMatch[1].trim().replace(/\\+$/, "");
+            const items = groupMatch[2].split(",").map((i) => i.trim()).filter(Boolean);
+            for (const item of items) {
+                const asMatch = item.match(/^(.+?)\s+as\s+(.+)$/i);
+                if (asMatch) {
+                    const fqcn = `${base}\\${asMatch[1].trim()}`;
+                    const alias = asMatch[2].trim();
+                    useMap[alias] = fqcn;
+                }
+                else {
+                    const fqcn = `${base}\\${item}`;
+                    const shortName = item.split("\\").pop();
+                    useMap[shortName] = fqcn;
+                }
+            }
+        }
+        else {
+            // Single or comma-separated use statements (e.g. "Foo\Bar, Foo\Baz")
+            const parts = block.split(",").map((p) => p.trim()).filter(Boolean);
+            for (const part of parts) {
+                const asMatch = part.match(/^(.+?)\s+as\s+(.+)$/i);
+                if (asMatch) {
+                    const fqcn = asMatch[1].trim();
+                    const alias = asMatch[2].trim();
+                    useMap[alias] = fqcn;
+                }
+                else {
+                    const fqcn = part;
+                    const shortName = part.split("\\").pop();
+                    useMap[shortName] = fqcn;
+                }
+            }
+        }
+    }
+    return useMap;
+}
+/**
+ * Extracts class references, type hints, static calls, and require/include paths.
+ */
+function extractPhpReferences(code) {
     const out = new Set();
-    const patterns = [/\b(?:require|include|require_once|include_once)\s*\(?['"]([^'"]+)['"]\)?/g, /\buse\s+([A-Z][\w\\]+(?:\s*{[^}]+})?)/g];
-    for (const r of patterns) {
-        let m;
+    // require/include patterns
+    const requireRe = /\b(?:require|include|require_once|include_once)\s*\(?['"]([^'"]+)['"]\)?/g;
+    let m;
+    while ((m = requireRe.exec(code))) {
+        const val = m[1];
+        if (val)
+            out.add(val);
+    }
+    // Detect class references (e.g. new User(), User::class, User::method())
+    const classPatterns = [
+        /\bnew\s+([A-Za-z0-9_\\]+)\b/g,
+        /\b([A-Za-z0-9_\\]+)::class\b/g,
+        /\b([A-Za-z0-9_\\]+)::[A-Za-z_]/g,
+        /:\s*([A-Za-z0-9_\\]+)\b/g
+    ];
+    for (const r of classPatterns) {
         while ((m = r.exec(code))) {
-            const val = m[1];
-            if (val)
-                out.add(val);
+            const className = m[1].trim();
+            if (/^[0-9]+$/.test(className) || ["self", "parent", "static"].includes(className.toLowerCase())) {
+                continue;
+            }
+            out.add(className);
         }
     }
-    // Detect short class names
-    const shortClassPatterns = [/\bnew\s+([A-Z][A-Za-z0-9_]*)\b/g, /\b([A-Z][A-Za-z0-9_]*)::class\b/g, /\b([A-Z][A-Za-z0-9_]*)::[A-Za-z_]/g, /:\s*([A-Z][A-Za-z0-9_]*)\b/g];
-    // Direct matches
-    for (const r of shortClassPatterns) {
-        let m;
-        while ((m = r.exec(code)))
-            out.add(m[1]);
-    }
     // Type-hinted parameters in function signatures
-    let m;
     const paramPattern = /\(([^)]*)\)/g;
     while ((m = paramPattern.exec(code))) {
         const block = m[1];
-        const types = block.match(/\b([A-Z][A-Za-z0-9_]*)\b/g);
-        if (types)
-            types.forEach((t) => out.add(t));
+        const params = block.split(",").map((p) => p.trim()).filter(Boolean);
+        for (const param of params) {
+            const parts = param.split("$");
+            if (parts.length > 1) {
+                const typePart = parts[0].trim();
+                if (typePart) {
+                    const types = typePart.match(/\b([A-Za-z0-9_\\]+)\b/g);
+                    if (types) {
+                        for (const t of types) {
+                            const trimmedT = t.trim();
+                            if (trimmedT &&
+                                !/^[0-9]+$/.test(trimmedT) &&
+                                !["self", "parent", "static", "array", "callable", "string", "int", "bool", "float", "iterable", "object"].includes(trimmedT.toLowerCase())) {
+                                out.add(trimmedT);
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
     return out;
 }
 /**
  * Expands grouped `use` imports into individual fully qualified names.
- * Example:
- *   "App\\Models\\{User, Team}" to ["App\\Models\\User", "App\\Models\\Team"]
  */
 function expandGroupedUses(raw) {
     const out = new Set();
@@ -61,3 +136,48 @@ function expandGroupedUses(raw) {
     }
     return out;
 }
+/**
+ * Resolves a raw PHP reference to a fully qualified class name or path.
+ */
+function resolvePhpReference(reference, currentNamespace, useMap, ctx) {
+    if (!reference || typeof reference !== "string")
+        return null;
+    if (reference.startsWith(".") || reference.includes("/") || reference.endsWith(".php")) {
+        return reference;
+    }
+    const segments = reference.split("\\");
+    const firstSegment = segments[0];
+    if (useMap[firstSegment]) {
+        const remainder = segments.slice(1).join("\\");
+        let resolved = remainder ? `${useMap[firstSegment]}\\${remainder}` : useMap[firstSegment];
+        resolved = resolved.replace(/^\\+/, "");
+        if (ctx.bindings[resolved])
+            resolved = ctx.bindings[resolved];
+        return resolved;
+    }
+    let resolved = reference;
+    const isFullyQualified = resolved.includes("\\") || resolved.startsWith("\\");
+    if (!isFullyQualified && currentNamespace) {
+        resolved = `${currentNamespace}\\${resolved}`;
+    }
+    resolved = resolved.replace(/^\\+/, "");
+    if (ctx.bindings[resolved]) {
+        resolved = ctx.bindings[resolved];
+    }
+    return resolved;
+}
+/**
+ * Backward-compatible wrapper for extracting raw PHP imports.
+ */
+function extractPhpImports(code) {
+    const out = new Set();
+    const useMap = extractPhpUseMap(code);
+    for (const fqcn of Object.values(useMap)) {
+        out.add(fqcn);
+    }
+    const refs = extractPhpReferences(code);
+    for (const ref of refs) {
+        out.add(ref);
+    }
+    return out;
+}

package/dist/resolvers/php/php-resolver.js

@@ -24,13 +24,26 @@ async function resolvePhpImports({ cfg, filePath, ctx }) {
         return (0, resolver_result_1.emptyResolverResult)();
     const currentNamespace = getCurrentNamespace(code);
     const phpCtx = buildPhpCtx(cfg.root, ctx);
-    const imports = (0, extract_imports_1.expandGroupedUses)((0, extract_imports_1.extractPhpImports)(code));
+    const useMap = (0, extract_imports_1.extractPhpUseMap)(code);
+    const rawReferences = (0, extract_imports_1.extractPhpReferences)(code);
+    const candidateImports = new Set();
+    for (const fqcn of Object.values(useMap)) {
+        candidateImports.add(fqcn);
+    }
+    for (const ref of rawReferences) {
+        const resolvedRef = (0, extract_imports_1.resolvePhpReference)(ref, currentNamespace, useMap, phpCtx);
+        if (resolvedRef) {
+            candidateImports.add(resolvedRef);
+        }
+    }
     const stats = (0, resolver_result_1.newResolverStats)();
     const files = [];
-    for (const importName of imports) {
-        const resolvedImport = resolveNamespaceImport(importName, currentNamespace, phpCtx);
-        if (!resolvedImport)
+    for (const resolvedImport of candidateImports) {
+        const isFilePath = resolvedImport.startsWith(".") || resolvedImport.includes("/") || resolvedImport.endsWith(".php");
+        const matchesNamespace = startsWithAnyNamespace(resolvedImport, phpCtx.nsKeys);
+        if (!isFilePath && !matchesNamespace) {
             continue;
+        }
         const resolvedPath = await tryResolvePhpFile(resolvedImport, filePath, phpCtx.psr4);
         stats.expected.add(resolvedImport);
         if (!resolvedPath)
@@ -48,33 +61,50 @@ function getCurrentNamespace(code) {
     const nsMatch = code.match(/\bnamespace\s+([^;]+);/);
     return nsMatch ? nsMatch[1].trim() : null;
 }
-function resolveNamespaceImport(importName, currentNamespace, ctx) {
-    if (!importName || typeof importName !== "string")
-        return null;
-    let resolved = importName;
-    const isFullyQualified = resolved.includes("\\") || resolved.startsWith("\\");
-    if (!isFullyQualified && currentNamespace)
-        resolved = `${currentNamespace}\\${resolved}`;
-    if (ctx.bindings[resolved])
-        resolved = ctx.bindings[resolved];
-    return startsWithAnyNamespace(resolved, ctx.nsKeys) ? resolved : null;
-}
 async function tryResolvePhpFile(imp, fromFile, psr4) {
     const key = `php:${imp}:${fromFile}`;
     const cached = cache_manager_1.CacheManager.get(cache_keys_1.CACHE_KEYS.PHP_FILECACHE, key);
     if (cached !== undefined)
         return cached;
-    const nsKey = Object.keys(psr4).find((candidate) => imp.startsWith(candidate));
+    if (imp.startsWith(".") || imp.includes("/") || imp.endsWith(".php")) {
+        const absolutePath = path_1.default.resolve(path_1.default.dirname(fromFile), imp);
+        try {
+            const stats = await promises_1.default.stat(absolutePath);
+            if (stats.isFile()) {
+                const resolved = path_1.default.resolve(absolutePath);
+                cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_FILECACHE, key, resolved);
+                return resolved;
+            }
+        }
+        catch { }
+        if (!imp.endsWith(".php")) {
+            try {
+                const stats = await promises_1.default.stat(absolutePath + ".php");
+                if (stats.isFile()) {
+                    const resolved = path_1.default.resolve(absolutePath + ".php");
+                    cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_FILECACHE, key, resolved);
+                    return resolved;
+                }
+            }
+            catch { }
+        }
+        cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_FILECACHE, key, null);
+        return null;
+    }
+    const nsKey = Object.keys(psr4).find((candidate) => {
+        return imp === candidate || imp.startsWith(candidate + "\\");
+    });
     if (!nsKey) {
         cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_FILECACHE, key, null);
         return null;
     }
-    const relativeImport = (0, path_2.normalizePath)(imp.replace(nsKey, ""));
-    const candidates = [
-        path_1.default.join(psr4[nsKey], relativeImport),
-        path_1.default.join(psr4[nsKey], relativeImport + ".php"),
-        path_1.default.join(psr4[nsKey], relativeImport, "index.php"),
-    ];
+    const relativeImport = (0, path_2.normalizePath)(imp.slice(nsKey.length).replace(/^\\+/, ""));
+    const mappedDirs = psr4[nsKey];
+    const dirs = Array.isArray(mappedDirs) ? mappedDirs : [mappedDirs];
+    const candidates = [];
+    for (const dir of dirs) {
+        candidates.push(path_1.default.join(dir, relativeImport), path_1.default.join(dir, relativeImport + ".php"), path_1.default.join(dir, relativeImport, "index.php"));
+    }
     const results = await Promise.allSettled(candidates.map(async (candidate) => {
         try {
             const stats = await promises_1.default.stat(candidate);
@@ -97,9 +127,10 @@ function buildPhpCtx(root, prev) {
     return { kind: "php", psr4, nsKeys, bindings };
 }
 function startsWithAnyNamespace(imp, nsKeys) {
-    for (const nsKey of nsKeys)
-        if (imp.startsWith(nsKey))
+    for (const nsKey of nsKeys) {
+        if (imp === nsKey || imp.startsWith(nsKey + "\\"))
             return true;
+    }
     return false;
 }
 function isFulfilledPath(result) {

package/dist/resolvers/php/psr4.d.ts

@@ -2,4 +2,4 @@
  * Builds a PSR-4 namespace to directory map from composer.json.
  * Returns absolute paths in the map values.
  */
-export declare function resolvePsr4(root: string): Record<string, string>;
+export declare function resolvePsr4(root: string): Record<string, string | string[]>;

package/dist/resolvers/php/psr4.js

@@ -27,7 +27,13 @@ function resolvePsr4(root) {
         const map = {};
         for (const ns in src) {
             const cleanNs = ns.replace(/\\+$/, "");
-            map[cleanNs] = path_1.default.resolve(root, src[ns]);
+            const val = src[ns];
+            if (Array.isArray(val)) {
+                map[cleanNs] = val.map((v) => path_1.default.resolve(root, v));
+            }
+            else {
+                map[cleanNs] = path_1.default.resolve(root, val);
+            }
         }
         cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_PSR4, root, map);
         return map;

package/dist/runtime/shell-command-runner.d.ts

@@ -0,0 +1,5 @@
+import type { CommandOutputResult } from "../types";
+/**
+ * Execute a single command sequentially using child_process.spawn.
+ */
+export declare function executeAttachedCommand(command: string, cwd: string, timeoutSeconds: number): Promise<CommandOutputResult>;