pkg-scaffold 3.3.3 → 3.3.5

package/src/ast/DeadCodeDetector.js

@@ -0,0 +1,73 @@
+export class DeadCodeDetector {
+  constructor(context) {
+    this.context = context;
+  }
+
+  detectDeadCode(graph) {
+    const deadFiles = [];
+    const deadExports = [];
+    
+    // Find all entry points
+    const entryPoints = new Set();
+    for (const [filePath, node] of graph.entries()) {
+      if (node.isEntry || node.isNextJsRoute || node.isSvelteComponent || node.isAstroPage) {
+        entryPoints.add(filePath);
+      }
+    }
+
+    // Traverse from entry points to find used files
+    const usedFiles = new Set();
+    const queue = Array.from(entryPoints);
+    
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!usedFiles.has(current)) {
+        usedFiles.add(current);
+        const node = graph.get(current);
+        if (node && node.outgoingEdges) {
+          for (const edge of node.outgoingEdges) {
+            queue.push(edge);
+          }
+        }
+      }
+    }
+
+    // Identify dead files
+    for (const filePath of graph.keys()) {
+      if (!usedFiles.has(filePath)) {
+        deadFiles.push(filePath);
+      }
+    }
+
+    // Identify dead exports in used files
+    for (const filePath of usedFiles) {
+      const node = graph.get(filePath);
+      if (!node) continue;
+      
+      // If it's an entry point, we consider its exports used (unless strictly configured otherwise)
+      if (node.isEntry) continue;
+
+      for (const [exportName, exportInfo] of node.internalExports.entries()) {
+        if (exportName === '*' || exportName === 'default') continue; // Skip wildcards for now
+        
+        let isUsed = false;
+        // Check incoming edges if they import this specific symbol
+        for (const [otherPath, otherNode] of graph.entries()) {
+          if (otherNode.outgoingEdges.has(filePath)) {
+            if (otherNode.importedSymbols.has(`${filePath}:${exportName}`) || 
+                otherNode.importedSymbols.has(`${filePath}:*`)) {
+              isUsed = true;
+              break;
+            }
+          }
+        }
+
+        if (!isUsed) {
+          deadExports.push({ file: filePath, symbol: exportName, line: exportInfo.start });
+        }
+      }
+    }
+
+    return { deadFiles, deadExports };
+  }
+}

package/src/ast/MagicDetector.js

@@ -6,6 +6,15 @@ import { PluginRegistry } from '../plugins/PluginRegistry.js';
  * Ecosystem Entry Point Manifest & Dynamic Framework Router Heuristic Validator
  * Intercepts implicit conventions to handle cases where direct import statements are absent.
  * Now refactored to use a pluggable architecture.
+ *
+ * Improvements over v1:
+ * - Extended config-file detection list (Biome, Oxlint, tsup, unbuild, etc.)
+ * - Next.js App Router conventions (page.tsx, layout.tsx, loading.tsx, error.tsx, etc.)
+ * - Remix conventions (route files under app/routes/)
+ * - SvelteKit conventions (+page.svelte, +layout.svelte, etc.)
+ * - Astro page/layout conventions
+ * - Common entry-point patterns (bin/, cli.ts, server.ts, main.ts, app.ts)
+ * - Test file patterns extended to cover Vitest workspace files
  */
 export class MagicDetector {
   constructor(context) {
@@ -60,18 +69,109 @@ export class MagicDetector {
   }
 
   isCoreToolingSuiteElement(normalizedPath) {
-    // Testing and execution matrices rules configuration keys
-    if (/\.(test|spec|e2e|cy)\.(js|ts|tsx|jsx|stories\.tsx|stories\.ts)$/i.test(normalizedPath)) return true;
-    
-    // Testing tools and structural environment frameworks configuration keys
-    const testEnvironments = [
-      'jest.config.', 'vitest.config.', 'playwright.config.', 'cypress.config.',
-      'webpack.config.', 'vite.config.', 'rollup.config.', 'tailwind.config.',
-      '.eslintrc.', 'prettier.config.', '.postcssrc.', 'postcss.config.',
-      'bin/cli.js', 'index.js', 'WorkerTaskRunner.js'
+    // ── Test / spec files ──────────────────────────────────────────────────────
+    if (/\.(test|spec|e2e|cy)\.(js|ts|tsx|jsx)$/i.test(normalizedPath)) return true;
+    if (/\.stories\.(js|ts|tsx|jsx)$/i.test(normalizedPath)) return true;
+
+    // ── Build / bundler config files ───────────────────────────────────────────
+    const configFragments = [
+      // Test runners
+      'jest.config.', 'vitest.config.', 'vitest.workspace.',
+      'playwright.config.', 'cypress.config.',
+      // Bundlers
+      'webpack.config.', 'vite.config.', 'rollup.config.',
+      'esbuild.config.', 'parcel.config.',
+      'tsup.config.', 'unbuild.config.', 'pkgroll.config.',
+      // CSS / styling
+      'tailwind.config.', 'postcss.config.', '.postcssrc.',
+      // Linters / formatters
+      '.eslintrc.', 'eslint.config.', 'prettier.config.', '.prettierrc.',
+      '.stylelintrc.', 'stylelint.config.',
+      'biome.json', '.oxlintrc.',
+      // Babel / transpilation
+      '.babelrc.', 'babel.config.',
+      // Commit / git hooks
+      '.commitlintrc.', 'commitlint.config.',
+      '.lintstagedrc.', 'lint-staged.config.',
+      // Documentation
+      'typedoc.config.', 'typedoc.json',
+      // Monorepo tools
+      'turbo.json', 'nx.json', 'lerna.json',
+      // Misc tooling
+      'knip.config.', 'knip.json',
+      'syncpack.config.',
+      // Internal worker
+      'WorkerTaskRunner.js'
     ];
-    
-    return testEnvironments.some(matchPattern => normalizedPath.includes(matchPattern));
+    if (configFragments.some(f => normalizedPath.includes(f))) return true;
+
+    // ── Common application entry points ───────────────────────────────────────
+    const entryPatterns = [
+      // CLI binaries
+      '/bin/cli.js', '/bin/cli.ts', '/bin/cli.mjs',
+      '/bin/index.js', '/bin/index.ts',
+      // Server / app entry points
+      '/src/server.ts', '/src/server.js',
+      '/src/main.ts', '/src/main.js',
+      '/src/app.ts', '/src/app.js',
+      '/src/index.ts', '/src/index.tsx',
+      '/src/index.js', '/src/index.jsx',
+      '/server.ts', '/server.js',
+      '/main.ts', '/main.js',
+      '/app.ts', '/app.js',
+      '/index.ts', '/index.tsx',
+      '/index.js', '/index.jsx',
+    ];
+    if (entryPatterns.some(p => normalizedPath.endsWith(p))) return true;
+
+    // ── Next.js App Router conventions ────────────────────────────────────────
+    // Files under app/ directory with Next.js special names
+    if (/\/app\/(page|layout|loading|error|not-found|template|default|route|middleware)\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    // Next.js Pages Router
+    if (/\/pages\/.*\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    // Next.js API routes
+    if (/\/pages\/api\/.*\.(js|ts)$/.test(normalizedPath)) return true;
+    // Next.js middleware
+    if (/\/middleware\.(js|ts)$/.test(normalizedPath)) return true;
+    // Next.js config
+    if (/\/next\.config\.(js|ts|mjs|cjs)$/.test(normalizedPath)) return true;
+
+    // ── Remix conventions ─────────────────────────────────────────────────────
+    if (/\/app\/routes\/.*\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    if (/\/app\/root\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    if (/\/app\/entry\.(client|server)\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+
+    // ── SvelteKit conventions ─────────────────────────────────────────────────
+    if (/\/\+page(\.(server|client))?\.(svelte|js|ts)$/.test(normalizedPath)) return true;
+    if (/\/\+layout(\.(server|client))?\.(svelte|js|ts)$/.test(normalizedPath)) return true;
+    if (/\/\+error\.(svelte|js|ts)$/.test(normalizedPath)) return true;
+    if (/\/\+server\.(js|ts)$/.test(normalizedPath)) return true;
+    if (/\/svelte\.config\.(js|ts|mjs)$/.test(normalizedPath)) return true;
+
+    // ── Astro conventions ─────────────────────────────────────────────────────
+    if (/\/src\/pages\/.*\.astro$/.test(normalizedPath)) return true;
+    if (/\/src\/layouts\/.*\.astro$/.test(normalizedPath)) return true;
+    if (/\/astro\.config\.(mjs|js|ts)$/.test(normalizedPath)) return true;
+
+    // ── Nuxt conventions ──────────────────────────────────────────────────────
+    if (/\/pages\/.*\.vue$/.test(normalizedPath)) return true;
+    if (/\/layouts\/.*\.vue$/.test(normalizedPath)) return true;
+    if (/\/server\/api\/.*\.(js|ts)$/.test(normalizedPath)) return true;
+    if (/\/nuxt\.config\.(js|ts|mjs)$/.test(normalizedPath)) return true;
+
+    // ── React / Vite entry points ─────────────────────────────────────────────
+    if (/\/vite\.config\.(js|ts|mjs)$/.test(normalizedPath)) return true;
+
+    // ── Angular conventions ───────────────────────────────────────────────────
+    if (/\/main\.(ts|js)$/.test(normalizedPath)) return true;
+    if (/\/app\.module\.(ts|js)$/.test(normalizedPath)) return true;
+    if (/\/angular\.json$/.test(normalizedPath)) return true;
+
+    // ── Expo / React Native ───────────────────────────────────────────────────
+    if (/\/app\/_layout\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    if (/\/app\/index\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+
+    return false;
   }
 
   /**

package/src/ast/OxcAnalyzer.js

@@ -1,124 +1,295 @@
-let oxcParser;
-try {
-  oxcParser = await import('oxc-parser');
-} catch (e) {
-  // OXC is optional; will fall back to TypeScript in ASTAnalyzer
-}
-
-import fs from 'fs/promises';
-
-/**
- * High-Performance AST Analyzer using OXC (Rust-based)
- * Designed to outpace Knip v6 by utilizing the fastest parser in the JS ecosystem.
- * Includes automatic fallback if OXC is not available in the environment.
- */
 export class OxcAnalyzer {
   constructor(context) {
     this.context = context;
-    this.isAvailable = !!oxcParser;
-  }
-
-  async processFile(filePath, fileNode) {
-    if (!this.isAvailable) {
+    try {
+      this.oxc = require("oxc-parser");
+      this.isAvailable = true;
+    } catch (e) {
+      this.isAvailable = false;
       if (this.context.verbose) {
-        console.warn(`[OXC] Library not available, skipping fast-scan for: ${filePath}`);
+        console.warn("[OxcAnalyzer] oxc-parser not found, falling back to TypeScript compiler API.");
       }
-      return false;
     }
+  }
+
+  parseFile(filePath, content, fileNode) {
+    if (!this.isAvailable) return false;
 
     try {
-      const sourceText = await fs.readFile(filePath, 'utf8');
-      
-      const { program } = oxcParser.parseSync(sourceText, {
+      if (this.context.verbose) {
+        console.log(`[OXC] Fast-parsing: ${filePath}`);
+      }
+
+      const ast = this.oxc.parseSync(content, {
+        sourceType: "module",
         sourceFilename: filePath,
-        sourceType: filePath.endsWith('.ts') || filePath.endsWith('.tsx') ? 'typescript' : 'script'
+        ecmaVersion: "latest",
       });
 
-      this.walkOxcNode(program, fileNode);
+      // Initialize new properties for JSX and Decorator analysis
+      fileNode.jsxComponents = new Set();
+      fileNode.jsxProps = new Set();
+      fileNode.decorators = new Set();
+
+      this.walkOxcAst(ast.program, fileNode, content);
       return true;
-    } catch (err) {
+    } catch (e) {
       if (this.context.verbose) {
-        console.error(`[OXC Error] Failed parsing: ${filePath}. Reason: ${err.message}`);
+        console.warn(`[OXC] Failed to parse ${filePath}: ${e.message}`);
       }
       return false;
     }
   }
 
-  walkOxcNode(node, fileNode) {
+  walkOxcAst(node, fileNode, content) {
     if (!node) return;
 
-    if (node.type === 'ImportDeclaration') {
-      const specifier = node.source.value;
-      fileNode.explicitImports.add(specifier);
-      node.specifiers.forEach(s => {
-        if (s.type === 'ImportSpecifier') {
-          fileNode.importedSymbols.add(`${specifier}:${s.imported.name}`);
-        } else if (s.type === 'ImportDefaultSpecifier') {
+    switch (node.type) {
+      case "ImportDeclaration":
+        this.handleImportDeclaration(node, fileNode);
+        break;
+      case "ExportNamedDeclaration":
+      case "ExportDefaultDeclaration":
+      case "ExportAllDeclaration":
+        this.handleExportDeclaration(node, fileNode, content);
+        break;
+      case "CallExpression":
+        this.handleCallExpression(node, fileNode);
+        break;
+      case "JSXElement":
+      case "JSXFragment": // Consider fragments as well
+        this.handleJsxElement(node, fileNode);
+        break;
+      case "Decorator":
+        this.handleDecorator(node, fileNode);
+        break;
+    }
+
+    // Traverse children
+    for (const key in node) {
+      if (node[key] && typeof node[key] === "object") {
+        if (Array.isArray(node[key])) {
+          node[key].forEach((child) => this.walkOxcAst(child, fileNode, content));
+        } else {
+          this.walkOxcAst(node[key], fileNode, content);
+        }
+      }
+    }
+  }
+
+  handleImportDeclaration(node, fileNode) {
+    const specifier = node.source.value;
+    fileNode.explicitImports.add(specifier);
+
+    // Track external package usage for dependency analysis
+    if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+      fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+    }
+
+    if (node.specifiers) {
+      node.specifiers.forEach((spec) => {
+        if (spec.type === "ImportSpecifier") {
+          const importedName = spec.imported.name;
+          fileNode.importedSymbols.add(`${specifier}:${importedName}`);
+        } else if (spec.type === "ImportDefaultSpecifier") {
           fileNode.importedSymbols.add(`${specifier}:default`);
-        } else if (s.type === 'ImportNamespaceSpecifier') {
+        } else if (spec.type === "ImportNamespaceSpecifier") {
           fileNode.importedSymbols.add(`${specifier}:*`);
         }
       });
     }
+  }
+
+  handleExportDeclaration(node, fileNode, content) {
+    if (node.type === "ExportDefaultDeclaration") {
+      fileNode.internalExports.set("default", { type: "default", start: node.start, end: node.end });
+      return;
+    }
+
+    if (node.type === "ExportAllDeclaration") {
+      const sourceSpecifier = node.source ? node.source.value : null;
+      if (sourceSpecifier) {
+        // FIX: Register re-export source as an explicit import so the graph linker
+        // creates an incomingEdge on the re-exported file.
+        fileNode.explicitImports.add(sourceSpecifier);
 
-    if (node.type === 'ExportNamedDeclaration') {
-      if (node.declaration) {
-        this.handleOxcDeclaration(node.declaration, fileNode);
+        // Track external package usage from re-exports
+        if (!sourceSpecifier.startsWith('.') && !sourceSpecifier.startsWith('/')) {
+          fileNode.externalPackageUsage.add(this._extractPackageName(sourceSpecifier));
+        }
+
+        if (node.exported) {
+          // export * as name from 'module'
+          const name = node.exported.name || (node.exported.type === "Identifier" ? node.exported.name : null);
+          if (name) {
+            fileNode.internalExports.set(name, { type: "re-export-namespace", source: sourceSpecifier, originalName: "*", start: node.start, end: node.end });
+            fileNode.importedSymbols.add(`${sourceSpecifier}:*`);
+          }
+        } else {
+          // export * from 'module'
+          fileNode.internalExports.set("*", { type: "re-export-all", source: sourceSpecifier });
+          // FIX: Register as wildcard importedSymbol so graph linker creates incomingEdge
+          fileNode.importedSymbols.add(`${sourceSpecifier}:*`);
+        }
       }
+      return;
+    }
+
+    if (node.source) {
+      // Re-export with source: export { x } from 'module'
+      const specifier = node.source.value;
+      // FIX: Register re-export source as an explicit import
+      fileNode.explicitImports.add(specifier);
+
+      // Track external package usage from re-exports
+      if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+        fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+      }
+
       if (node.specifiers) {
-        node.specifiers.forEach(s => {
-          fileNode.internalExports.set(s.exported.name, { type: 'export-specifier' });
+        node.specifiers.forEach((spec) => {
+          const exportedName = spec.exported.name;
+          const localName = spec.local.name;
+          fileNode.internalExports.set(exportedName, {
+            type: "re-export",
+            source: specifier,
+            originalName: localName,
+            start: node.start,
+            end: node.end,
+          });
+          // FIX: Register as importedSymbol so barrel-tracer can resolve origin file
+          fileNode.importedSymbols.add(`${specifier}:${localName}`);
         });
       }
+    } else if (node.declaration) {
+      // Direct export
+      const decl = node.declaration;
+      if (decl.type === "VariableDeclaration") {
+        decl.declarations.forEach((d) => {
+          if (d.id.type === "Identifier") {
+            fileNode.internalExports.set(d.id.name, { type: "variable", start: d.start, end: d.end });
+          } else if (d.id.type === "ObjectPattern") {
+            d.id.properties.forEach((p) => {
+              if (p.type === "Property" && p.value.type === "Identifier") {
+                fileNode.internalExports.set(p.value.name, { type: "variable", start: p.start, end: p.end });
+              }
+            });
+          } else if (d.id.type === "ArrayPattern") {
+            d.id.elements.forEach((e) => {
+              if (e && e.type === "Identifier") {
+                fileNode.internalExports.set(e.name, { type: "variable", start: e.start, end: e.end });
+              }
+            });
+          }
+        });
+      } else if (decl.id && decl.id.name) {
+        let type = "unknown";
+        if (decl.type === "FunctionDeclaration") type = "function";
+        else if (decl.type === "ClassDeclaration") type = "class";
+        else if (decl.type === "TSEnumDeclaration") type = "enum";
+        else if (decl.type === "TSInterfaceDeclaration") type = "interface";
+        else if (decl.type === "TSTypeAliasDeclaration") type = "type";
+        else if (decl.type === "TSModuleDeclaration") type = "namespace";
+
+        const exportInfo = { type, start: decl.start, end: decl.end };
+        fileNode.internalExports.set(decl.id.name, exportInfo);
+
+        if (decl.type === "TSEnumDeclaration") {
+          exportInfo.members = decl.members.map((m) => m.id.name || (m.id.type === "Identifier" ? m.id.name : ""));
+        } else if (decl.type === "TSInterfaceDeclaration" || decl.type === "ClassDeclaration") {
+          exportInfo.members = decl.body.body.filter((m) => m.key && m.key.name).map((m) => m.key.name);
+        }
+      }
+    } else if (node.specifiers) {
+      node.specifiers.forEach((spec) => {
+        const exportedName = spec.exported.name;
+        const localName = spec.local.name;
+        fileNode.internalExports.set(exportedName, {
+          type: "export",
+          originalName: localName,
+          start: node.start,
+          end: node.end,
+        });
+      });
     }
+  }
 
-    if (node.type === 'ExportDefaultDeclaration') {
-      fileNode.internalExports.set('default', { type: 'default-export' });
+  handleCallExpression(node, fileNode) {
+    // Dynamic import(): import('./module')
+    if (node.callee.type === "Import" && node.arguments.length > 0) {
+      const arg = node.arguments[0];
+      if (arg.type === "StringLiteral") {
+        const specifier = arg.value;
+        fileNode.explicitImports.add(specifier);
+        fileNode.dynamicImports.add(specifier);
+        if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+          fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+        }
+      } else {
+        // Non-literal dynamic import: record as calculated
+        if (fileNode.calculatedDynamicImports) {
+          fileNode.calculatedDynamicImports.push({ kind: arg.type, start: arg.start });
+        }
+      }
+    } else if (node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length > 0 && node.arguments[0].type === "StringLiteral") {
+      const specifier = node.arguments[0].value;
+      fileNode.explicitImports.add(specifier);
+      if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+        fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+      }
     }
+  }
+
+  handleJsxElement(node, fileNode) {
+    const getElementName = (nameNode) => {
+      if (nameNode.type === "JSXIdentifier") return nameNode.name;
+      if (nameNode.type === "JSXMemberExpression") return `${getElementName(nameNode.object)}.${nameNode.property.name}`;
+      return "unknown";
+    };
 
-    if (node.type === 'TSModuleDeclaration' && node.id.type === 'Identifier') {
-      const namespaceName = node.id.name;
-      if (node.body && node.body.type === 'TSModuleBlock') {
-        node.body.body.forEach(innerNode => {
-          if (innerNode.type === 'ExportNamedDeclaration' && innerNode.declaration) {
-             const decl = innerNode.declaration;
-             let memberName;
-             if (decl.type === 'VariableDeclaration') {
-               memberName = decl.declarations[0].id.name;
-             } else if (decl.id) {
-               memberName = decl.id.name;
-             }
-             if (memberName) {
-               fileNode.namespaceMembers = fileNode.namespaceMembers || new Set();
-               fileNode.namespaceMembers.add(`${namespaceName}.${memberName}`);
-             }
+    if (node.openingElement) {
+      const tagName = getElementName(node.openingElement.name);
+      fileNode.jsxComponents.add(tagName);
+
+      if (node.openingElement.attributes) {
+        node.openingElement.attributes.forEach(attr => {
+          if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier") {
+            fileNode.jsxProps.add(`${tagName}:${attr.name.name}`);
           }
         });
       }
     }
+  }
 
-    for (const key in node) {
-      const child = node[key];
-      if (child && typeof child === 'object') {
-        if (Array.isArray(child)) {
-          child.forEach(c => this.walkOxcNode(c, fileNode));
-        } else {
-          this.walkOxcNode(child, fileNode);
-        }
-      }
+  handleDecorator(node, fileNode) {
+    const getDecoratorName = (expr) => {
+      if (expr.type === "Identifier") return expr.name;
+      if (expr.type === "CallExpression" && expr.callee.type === "Identifier") return expr.callee.name;
+      if (expr.type === "CallExpression" && expr.callee.type === "MemberExpression" && expr.callee.property.type === "Identifier") return expr.callee.property.name;
+      return "unknown";
+    };
+
+    const decoratorName = getDecoratorName(node.expression);
+    fileNode.decorators.add(decoratorName);
+
+    // Optionally, extract decorator arguments
+    if (node.expression.type === "CallExpression") {
+      node.expression.arguments.forEach(arg => {
+        // Further analysis of arguments can be done here if needed
+        // e.g., if (arg.type === "StringLiteral") fileNode.decoratorArgs.add(`${decoratorName}:${arg.value}`);
+      });
     }
   }
 
-  handleOxcDeclaration(decl, fileNode) {
-    let name;
-    if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration' || decl.type === 'TSEnumDeclaration' || decl.type === 'TSInterfaceDeclaration' || decl.type === 'TSTypeAliasDeclaration') {
-      name = decl.id?.name;
-    } else if (decl.type === 'VariableDeclaration') {
-      name = decl.declarations[0].id.name;
-    }
-    
-    if (name) {
-      fileNode.internalExports.set(name, { type: decl.type.toLowerCase() });
+  /**
+   * Extracts the root npm package name from an import specifier.
+   * Handles scoped packages (@scope/pkg) and subpath imports (pkg/utils, @scope/pkg/utils).
+   */
+  _extractPackageName(specifier) {
+    if (specifier.startsWith('@')) {
+      const parts = specifier.split('/');
+      return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
     }
+    return specifier.split('/')[0];
   }
 }