pkg-scaffold 3.3.2 → 3.3.4

package/src/ast/OxcAnalyzer.js

@@ -1,124 +1,236 @@
-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);
+
+    if (node.specifiers) {
+      node.specifiers.forEach((spec) => {
+        if (spec.type === "ImportSpecifier") {
+          const importedName = spec.imported.name;
+          const localName = spec.local.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 === 'ExportNamedDeclaration') {
-      if (node.declaration) {
-        this.handleOxcDeclaration(node.declaration, fileNode);
+    if (node.type === "ExportAllDeclaration") {
+      if (node.exported && node.exported.type === "ExportNamespaceSpecifier") {
+        // export * as name from 'module'
+        const name = node.exported.name;
+        fileNode.internalExports.set(name, { type: "re-export-namespace", source: node.source.value, originalName: "*", start: node.start, end: node.end });
+      } else {
+        // export * from 'module'
+        fileNode.internalExports.set("*", { type: "re-export-all", source: node.source.value });
       }
+      return;
+    }
+
+    if (node.source) {
+      // Re-export
+      const specifier = node.source.value;
       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,
+          });
+        });
+      }
+    } 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) {
+    if (node.callee.type === "Import" && node.arguments.length > 0 && node.arguments[0].type === "StringLiteral") {
+      const specifier = node.arguments[0].value;
+      fileNode.explicitImports.add(specifier);
+      fileNode.dynamicImports.add(specifier);
+    } else if (node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length > 0 && node.arguments[0].type === "StringLiteral") {
+      fileNode.explicitImports.add(node.arguments[0].value);
     }
+  }
+
+  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);
-        }
-      }
-    }
   }
 
-  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() });
+  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}`);
+      });
     }
   }
 }

package/src/index.js

@@ -1,3 +1,5 @@
+import { DeadCodeDetector } from "./ast/DeadCodeDetector.js";
+import { OxcAnalyzer } from "./ast/OxcAnalyzer.js";
 /**
  * ============================================================================
  * 📦 pkg-scaffold v3.3.2: Unified Architectural Refactoring Orchestrator
@@ -47,6 +49,7 @@ export class RefactoringEngine {
     
     // Stage 3: Wire official AST Syntax parsers and framework processors
     this.analyzer = new ASTAnalyzer(this.context);
+    this.oxcAnalyzer = new OxcAnalyzer(this.context);
     this.barrelParser = new BarrelParser(this.context, this.resolver);
     this.magicDetector = new MagicDetector(this.context);
     
@@ -110,16 +113,7 @@ export class RefactoringEngine {
         }
       }
 
-      // Initialize TypeScript program for AST analysis (required before processFile)
-      if (sourceCodeFilesList.length > 0) {
-        try {
-          this.analyzer.initProgram(sourceCodeFilesList);
-        } catch (e) {
-          if (this.context.verbose) {
-            console.warn('Warning: Failed to initialize TypeScript program:', e.message);
-          }
-        }
-      }
+
 
       // Pass 3: Process source file tokens using high-performance concurrent workers
       let parallelParseCompleted = false;
@@ -139,7 +133,12 @@ export class RefactoringEngine {
           this.hydrateNodeFromCache(node, cacheManifest[filePath]);
         } else if (!parallelParseCompleted) {
           this.context.metrics.cacheMisses++;
-          await this.analyzer.processFile(filePath, node);
+          const fileContent = await fs.readFile(filePath, 'utf8'); // Read file content here
+          if (this.oxcAnalyzer.isAvailable) {
+            this.oxcAnalyzer.parseFile(filePath, fileContent, node);
+          } else {
+            this.analyzer.parseFile(filePath, fileContent, node);
+          }
         }
 
         this.magicDetector.injectVirtualConsumerEdges(filePath, node, activeFrameworkEcosystems);

package/src/plugins/PluginRegistry.js

@@ -1,3 +1,4 @@
+import { loadAdditionalPlugins } from "./ecosystems/PluginLoader.js";
 import path from 'path';
 import fs from 'fs/promises';
 import { pathToFileURL } from 'url';

package/src/plugins/ecosystems/MorePlugins.js

@@ -0,0 +1,184 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { BasePlugin } from '../BasePlugin.js';
+
+export class TailwindPlugin extends BasePlugin {
+  get name() { return 'tailwind'; }
+  getConfigFiles() { return ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.cjs', 'tailwind.config.mjs']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.tailwindcss || pkgJson.devDependencies?.tailwindcss);
+    } catch { return false; }
+  }
+}
+
+export class PostcssPlugin extends BasePlugin {
+  get name() { return 'postcss'; }
+  getConfigFiles() { return ['postcss.config.js', 'postcss.config.cjs', 'postcss.config.mjs']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.postcss || pkgJson.devDependencies?.postcss);
+    } catch { return false; }
+  }
+}
+
+export class JestPlugin extends BasePlugin {
+  get name() { return 'jest'; }
+  getConfigFiles() { return ['jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs', 'package.json']; }
+  getRoutePatterns() { return [/\.(test|spec)\.[jt]sx?$/]; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.jest || pkgJson.devDependencies?.jest);
+    } catch { return false; }
+  }
+}
+
+export class VitestPlugin extends BasePlugin {
+  get name() { return 'vitest'; }
+  getConfigFiles() { return ['vitest.config.ts', 'vitest.config.js', 'vitest.config.mjs', 'vitest.workspace.ts']; }
+  getRoutePatterns() { return [/\.(test|spec)\.[jt]sx?$/]; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.vitest || pkgJson.devDependencies?.vitest);
+    } catch { return false; }
+  }
+}
+
+export class PlaywrightPlugin extends BasePlugin {
+  get name() { return 'playwright'; }
+  getConfigFiles() { return ['playwright.config.ts', 'playwright.config.js']; }
+  getRoutePatterns() { return [/.*\.spec\.[jt]s$/]; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@playwright/test'] || pkgJson.devDependencies?.['@playwright/test']);
+    } catch { return false; }
+  }
+}
+
+export class CypressPlugin extends BasePlugin {
+  get name() { return 'cypress'; }
+  getConfigFiles() { return ['cypress.config.ts', 'cypress.config.js']; }
+  getRoutePatterns() { return [/cypress\/e2e\/.*\.cy\.[jt]s$/]; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.cypress || pkgJson.devDependencies?.cypress);
+    } catch { return false; }
+  }
+}
+
+export class StorybookPlugin extends BasePlugin {
+  get name() { return 'storybook'; }
+  getConfigFiles() { return ['.storybook/main.js', '.storybook/main.ts', '.storybook/preview.js', '.storybook/preview.ts']; }
+  getRoutePatterns() { return [/\.stories\.[jt]sx?$/]; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.storybook || pkgJson.devDependencies?.storybook || pkgJson.devDependencies?.['@storybook/react']);
+    } catch { return false; }
+  }
+}
+
+export class EslintPlugin extends BasePlugin {
+  get name() { return 'eslint'; }
+  getConfigFiles() { return ['.eslintrc', '.eslintrc.js', '.eslintrc.cjs', '.eslintrc.json', 'eslint.config.js', 'eslint.config.mjs']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.eslint || pkgJson.devDependencies?.eslint);
+    } catch { return false; }
+  }
+}
+
+export class PrettierPlugin extends BasePlugin {
+  get name() { return 'prettier'; }
+  getConfigFiles() { return ['.prettierrc', '.prettierrc.js', '.prettierrc.cjs', '.prettierrc.json', 'prettier.config.js']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.prettier || pkgJson.devDependencies?.prettier);
+    } catch { return false; }
+  }
+}
+
+export class HuskyPlugin extends BasePlugin {
+  get name() { return 'husky'; }
+  getConfigFiles() { return ['.husky/pre-commit', '.husky/pre-push']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.husky || pkgJson.devDependencies?.husky);
+    } catch { return false; }
+  }
+}
+
+export class LintStagedPlugin extends BasePlugin {
+  get name() { return 'lint-staged'; }
+  getConfigFiles() { return ['.lintstagedrc', '.lintstagedrc.js', '.lintstagedrc.json', 'lint-staged.config.js', 'package.json']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['lint-staged'] || pkgJson.devDependencies?.['lint-staged']);
+    } catch { return false; }
+  }
+}
+
+export class CommitlintPlugin extends BasePlugin {
+  get name() { return 'commitlint'; }
+  getConfigFiles() { return ['.commitlintrc', '.commitlintrc.js', '.commitlintrc.json', 'commitlint.config.js', 'package.json']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@commitlint/cli'] || pkgJson.devDependencies?.['@commitlint/cli']);
+    } catch { return false; }
+  }
+}
+
+export class BabelPlugin extends BasePlugin {
+  get name() { return 'babel'; }
+  getConfigFiles() { return ['.babelrc', '.babelrc.js', '.babelrc.json', 'babel.config.js', 'babel.config.json', 'package.json']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@babel/core'] || pkgJson.devDependencies?.['@babel/core']);
+    } catch { return false; }
+  }
+}
+
+export class RollupPlugin extends BasePlugin {
+  get name() { return 'rollup'; }
+  getConfigFiles() { return ['rollup.config.js', 'rollup.config.mjs', 'rollup.config.ts']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.rollup || pkgJson.devDependencies?.rollup);
+    } catch { return false; }
+  }
+}
+
+export class WebpackPlugin extends BasePlugin {
+  get name() { return 'webpack'; }
+  getConfigFiles() { return ['webpack.config.js', 'webpack.config.ts', 'webpack.config.mjs', 'webpack.config.cjs']; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.webpack || pkgJson.devDependencies?.webpack);
+    } catch { return false; }
+  }
+}
+
+export class GithubActionsPlugin extends BasePlugin {
+  get name() { return 'github-actions'; }
+  getConfigFiles() { return ['.github/workflows/*.yml', '.github/workflows/*.yaml']; }
+  async isActive(baseDir) {
+    try {
+      await fs.access(path.join(baseDir, '.github/workflows'));
+      return true;
+    } catch { return false; }
+  }
+}

package/src/plugins/ecosystems/PluginLoader.js

@@ -0,0 +1,20 @@
+import { TailwindPlugin, PostcssPlugin, JestPlugin, VitestPlugin, PlaywrightPlugin, CypressPlugin, StorybookPlugin, EslintPlugin, PrettierPlugin, HuskyPlugin, LintStagedPlugin, CommitlintPlugin, BabelPlugin, RollupPlugin, WebpackPlugin, GithubActionsPlugin } from './MorePlugins.js';
+
+export function loadAdditionalPlugins(registry) {
+  registry.register(new TailwindPlugin(registry.context));
+  registry.register(new PostcssPlugin(registry.context));
+  registry.register(new JestPlugin(registry.context));
+  registry.register(new VitestPlugin(registry.context));
+  registry.register(new PlaywrightPlugin(registry.context));
+  registry.register(new CypressPlugin(registry.context));
+  registry.register(new StorybookPlugin(registry.context));
+  registry.register(new EslintPlugin(registry.context));
+  registry.register(new PrettierPlugin(registry.context));
+  registry.register(new HuskyPlugin(registry.context));
+  registry.register(new LintStagedPlugin(registry.context));
+  registry.register(new CommitlintPlugin(registry.context));
+  registry.register(new BabelPlugin(registry.context));
+  registry.register(new RollupPlugin(registry.context));
+  registry.register(new WebpackPlugin(registry.context));
+  registry.register(new GithubActionsPlugin(registry.context));
+}

package/src/resolution/CircularDetector.js

@@ -1,31 +1,14 @@
-/**
- * ============================================================================
- * Circular Dependency Detector for pkg-scaffold v3.3.0
- * 
- * Copyright (C) 2026 DreamLongYT
- * Licensed under the Apache License, Version 2.0.
- * "The Original Code was made by DreamLongYT"
- * ============================================================================
- * Implements a high-performance Tarjan-based algorithm to
- * detect circular dependencies in the codebase graph.
- * Addresses Knip Issue #1734.
- */
-
 export class CircularDetector {
   constructor(context) {
     this.context = context;
     this.cycles = [];
   }
 
-  /**
-   * Detects cycles in the provided dependency graph using Tarjan's SCC algorithm
-   * @param {Map} graph - The codebase dependency graph
-   * @returns {Array} List of detected cycles
-   */
   detectCycles(graph, context = null) {
     if (context) this.context = context;
     this.cwd = context?.cwd || this.context?.cwd || process.cwd();
     this.cycles = [];
+    
     let index = 0;
     const stack = [];
     const indices = new Map();
@@ -63,7 +46,6 @@ export class CircularDetector {
         if (component.length > 1) {
           this.cycles.push(component.reverse());
         } else {
-          // Check for self-loops
           const node = graph.get(v);
           if (node && node.outgoingEdges && node.outgoingEdges.has(v)) {
             this.cycles.push([v]);
@@ -81,18 +63,11 @@ export class CircularDetector {
     return this.cycles;
   }
 
-  /**
-   * Formats cycles for reporting with file paths
-   */
   formatCycles() {
     return this.cycles.map(cycle => {
       const paths = cycle.map(p => {
-        // Extract relative path for readability
         let rel = p.replace(this.context.cwd, '').replace(/^\//, '');
-        // Convert absolute Windows paths
-        if (rel.includes(':\\')) {
-          rel = rel.split(':\\')[1] || rel;
-        }
+        if (rel.includes(':\\')) rel = rel.split(':\\')[1] || rel;
         return rel;
       });
       if (cycle.length === 1) return `${paths[0]} -> (self-loop)`;
@@ -100,17 +75,12 @@ export class CircularDetector {
     });
   }
 
-  /**
-   * Gets detailed cycle information
-   */
   getCycleDetails() {
     return this.cycles.map((cycle, idx) => ({
       cycleId: idx + 1,
       files: cycle.map(p => {
         let rel = p.replace(this.context.cwd, '').replace(/^\//, '');
-        if (rel.includes(':\\')) {
-          rel = rel.split(':\\')[1] || rel;
-        }
+        if (rel.includes(':\\')) rel = rel.split(':\\')[1] || rel;
         return rel;
       }),
       length: cycle.length,
@@ -118,5 +88,4 @@ export class CircularDetector {
     }));
   }
 }
-
 export default CircularDetector;