pkg-scaffold 3.1.3 → 3.3.0

package/src/plugins/PluginRegistry.js

@@ -1,95 +1,128 @@
 import path from 'path';
 import fs from 'fs/promises';
 import { pathToFileURL } from 'url';
+import { KnipAdapter } from './KnipAdapter.js';
 
 /**
  * Advanced Plugin Registry supporting Builtin, Custom, and Knip-style plugins.
+ * Version 4.0.0: Enhanced with Modern Frameworks, Backend Services, and Standalone Knip Integration.
  */
 export class PluginRegistry {
-  constructor(context) {
-    this.context = context;
-    this.plugins = new Map();
-    this.config = null;
-  }
-
-  async init(projectRoot) {
-    const configPath = path.join(projectRoot, 'pkg-scaffold', 'config.json');
-    try {
-      const configRaw = await fs.readFile(configPath, 'utf8');
-      this.config = JSON.parse(configRaw);
-    } catch (e) {
-      this.config = { useBuiltinPlugins: true, useCustomPlugins: true, supportKnipPlugins: true };
+    constructor(context) {
+        this.context = context;
+        this.plugins = new Map();
+        this.config = null;
+        this.knipAdapter = new KnipAdapter(context);
     }
 
-    if (this.config.useBuiltinPlugins) {
-      await this.loadBuiltinPlugins();
-    }
+    async init(projectRoot) {
+        const configPath = path.join(projectRoot, 'pkg-scaffold', 'config.json');
+        try {
+            const configRaw = await fs.readFile(configPath, 'utf8');
+            this.config = JSON.parse(configRaw);
+        } catch (e) {
+            this.config = {
+                useBuiltinPlugins: true,
+                useCustomPlugins: true,
+                supportKnipPlugins: true
+            };
+        }
 
-    if (this.config.useCustomPlugins) {
-      await this.loadCustomPlugins(projectRoot);
-    }
+        if (this.config.useBuiltinPlugins) {
+            await this.loadBuiltinPlugins();
+        }
+
+        if (this.config.useCustomPlugins) {
+            await this.loadCustomPlugins(projectRoot);
+        }
 
-    if (this.config.supportKnipPlugins) {
-      await this.initKnipAdapter();
+        if (this.config.supportKnipPlugins) {
+            await this.initKnipAdapter(projectRoot);
+        }
     }
-  }
 
-  async loadBuiltinPlugins() {
-    const { NextJsPlugin } = await import('./ecosystems/NextJsPlugin.js');
-    const { NuxtPlugin, RemixPlugin, SvelteKitPlugin, AstroPlugin } = await import('./ecosystems/GenericPlugins.js');
+    async loadBuiltinPlugins() {
+        // Core Ecosystems
+        const { NextJsPlugin } = await import('./ecosystems/NextJsPlugin.js');
+        const { NuxtPlugin, RemixPlugin, SvelteKitPlugin, AstroPlugin } = await import('./ecosystems/GenericPlugins.js');
+        const { TypeScriptPlugin } = await import('./ecosystems/TypeScriptPlugin.js');
+        
+        // Modern Frameworks (New in v4.0)
+        const { ReactPlugin, VuePlugin, SveltePlugin, AngularPlugin } = await import('./ecosystems/ModernFrameworks.js');
+        
+        // Backend Services (New in v4.0)
+        const { GraphQLPlugin, DatabasePlugin } = await import('./ecosystems/BackendServices.js');
 
-    const builtins = [
-      new NextJsPlugin(this.context),
-      new NuxtPlugin(this.context),
-      new RemixPlugin(this.context),
-      new SvelteKitPlugin(this.context),
-      new AstroPlugin(this.context)
-    ];
+        const builtins = [
+            new NextJsPlugin(this.context),
+            new NuxtPlugin(this.context),
+            new RemixPlugin(this.context),
+            new SvelteKitPlugin(this.context),
+            new AstroPlugin(this.context),
+            new TypeScriptPlugin(this.context),
+            new ReactPlugin(this.context),
+            new VuePlugin(this.context),
+            new SveltePlugin(this.context),
+            new AngularPlugin(this.context),
+            new GraphQLPlugin(this.context),
+            new DatabasePlugin(this.context)
+        ];
 
-    builtins.forEach(p => {
-      if (!this.config.enabledPlugins || this.config.enabledPlugins.includes(p.name)) {
-        this.register(p);
-      }
-    });
-  }
+        builtins.forEach(p => {
+            if (!this.config.enabledPlugins || this.config.enabledPlugins.includes(p.name)) {
+                this.register(p);
+            }
+        });
+    }
+
+    async loadCustomPlugins(projectRoot) {
+        const pluginsDir = path.join(projectRoot, 'pkg-scaffold', 'plugins');
+        try {
+            const files = await fs.readdir(pluginsDir);
+            for (const file of files) {
+                if (file.endsWith('.js') || file.endsWith('.mjs')) {
+                    const pluginModule = await import(pathToFileURL(path.join(pluginsDir, file)).href);
+                    const PluginClass = pluginModule.default || pluginModule;
+                    const pluginInstance = new PluginClass(this.context);
 
-  async loadCustomPlugins(projectRoot) {
-    const pluginsDir = path.join(projectRoot, 'pkg-scaffold', 'plugins');
-    try {
-      const files = await fs.readdir(pluginsDir);
-      for (const file of files) {
-        if (file.endsWith('.js') || file.endsWith('.mjs')) {
-          const pluginModule = await import(pathToFileURL(path.join(pluginsDir, file)).href);
-          const PluginClass = pluginModule.default || pluginModule;
-          this.register(new PluginClass(this.context));
+                    const version = pluginInstance.get('version');
+                    if (version && this.context.verbose) {
+                        console.log(`[PluginRegistry] Loaded ${pluginInstance.name} v${version}`);
+                    }
+                    this.register(pluginInstance);
+                }
+            }
+        } catch (e) {
+            // No custom plugins or dir missing
         }
-      }
-    } catch (e) {
-      // No custom plugins or dir missing
     }
-  }
 
-  async initKnipAdapter() {
-    // This adapter allows running Knip-style plugins by wrapping them
-    // In a real scenario, this would interface with knip's plugin API
-    this.context.knipCompatible = true;
-  }
+    async initKnipAdapter(projectRoot) {
+        this.context.knipCompatible = true;
+        await this.knipAdapter.discoverPlugins(projectRoot);
+        const knipPlugins = this.knipAdapter.getPlugins();
+        knipPlugins.forEach(p => this.register(p));
+    }
+
+    register(plugin) {
+        this.plugins.set(plugin.name, plugin);
+    }
 
-  register(plugin) {
-    this.plugins.set(plugin.name, plugin);
-  }
+    getPlugins() {
+        return Array.from(this.plugins.values());
+    }
 
-  getPlugins() {
-    return Array.from(this.plugins.values());
-  }
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
 
-  async getActivePlugins(baseDir) {
-    const active = [];
-    for (const plugin of this.plugins.values()) {
-      if (await plugin.isActive(baseDir)) {
-        active.push(plugin);
-      }
+    async getActivePlugins(baseDir) {
+        const active = [];
+        for (const plugin of this.plugins.values()) {
+            if (await plugin.isActive(baseDir)) {
+                active.push(plugin);
+            }
+        }
+        return active;
     }
-    return active;
-  }
 }

package/src/plugins/ecosystems/BackendServices.js

@@ -0,0 +1,59 @@
+/**
+ * ============================================================================
+ * Backend Services Plugins for pkg-scaffold v4.0.0
+ * ============================================================================
+ * Built-in support for GraphQL, REST APIs, and Databases.
+ */
+
+import { BasePlugin } from '../BasePlugin.js';
+
+/**
+ * GraphQL Ecosystem Plugin
+ */
+export class GraphQLPlugin extends BasePlugin {
+  get name() {
+    return 'graphql';
+  }
+
+  getConfigFiles() {
+    return ['package.json', 'graphql.config.js', '.graphqlconfig'];
+  }
+
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await require('fs').promises.readFile(require('path').join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.graphql || pkgJson.devDependencies?.graphql || pkgJson.dependencies?.['@apollo/client']);
+    } catch {
+      return false;
+    }
+  }
+
+  async analyze(node, filePath) {
+    // Detect GraphQL tagged templates
+    const gqlPattern = /gql\s*`([\s\S]*?)`/g;
+    const matches = node.rawCode?.match(gqlPattern) || [];
+    if (matches.length > 0) {
+      node.graphqlQueries = matches;
+    }
+  }
+}
+
+/**
+ * Database Ecosystem Plugin (Prisma, Drizzle, TypeORM)
+ */
+export class DatabasePlugin extends BasePlugin {
+  get name() {
+    return 'database';
+  }
+
+  getConfigFiles() {
+    return ['package.json', 'prisma/schema.prisma', 'drizzle.config.ts', 'ormconfig.json'];
+  }
+
+  async analyze(node, filePath) {
+    // Detect DB usage
+    if (node.explicitImports.has('@prisma/client') || node.explicitImports.has('drizzle-orm')) {
+      node.usesDatabase = true;
+    }
+  }
+}

package/src/plugins/ecosystems/ModernFrameworks.js

@@ -0,0 +1,157 @@
+/**
+ * ============================================================================
+ * Modern Frameworks Plugins for pkg-scaffold v4.0.0
+ * ============================================================================
+ * Built-in support for React, Vue, Svelte, and Angular.
+ */
+
+import { BasePlugin } from '../BasePlugin.js';
+
+/**
+ * React Ecosystem Plugin
+ */
+export class ReactPlugin extends BasePlugin {
+  get name() {
+    return 'react';
+  }
+
+  getConfigFiles() {
+    return ['package.json'];
+  }
+
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await require('fs').promises.readFile(require('path').join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.react || pkgJson.devDependencies?.react);
+    } catch {
+      return false;
+    }
+  }
+
+  getRoutePatterns() {
+    return [/\.(tsx?|jsx?)$/];
+  }
+
+  getRequiredSystemContracts() {
+    return ['default', 'Component', 'PureComponent', 'Fragment', 'useEffect', 'useState', 'useContext', 'useReducer', 'useCallback', 'useMemo', 'useRef', 'useImperativeHandle', 'useLayoutEffect', 'useDebugValue'];
+  }
+
+  async analyze(node, filePath) {
+    if (node.explicitImports.has('react')) {
+      node.isReactComponent = true;
+    }
+    
+    // Detect JSX
+    if (node.rawCode && (node.rawCode.includes('</') || node.rawCode.includes('/>'))) {
+      node.hasJSX = true;
+    }
+
+    // Detect Hooks
+    const hookMatches = node.rawCode?.match(/use[A-Z]\w+/g) || [];
+    if (hookMatches.length > 0) {
+      node.reactHooks = new Set(hookMatches);
+    }
+  }
+}
+
+/**
+ * Vue Ecosystem Plugin
+ */
+export class VuePlugin extends BasePlugin {
+  get name() {
+    return 'vue';
+  }
+
+  getConfigFiles() {
+    return ['package.json', 'vue.config.js', 'vite.config.ts', 'vite.config.js'];
+  }
+
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await require('fs').promises.readFile(require('path').join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.vue || pkgJson.devDependencies?.vue);
+    } catch {
+      return false;
+    }
+  }
+
+  getRoutePatterns() {
+    return [/\.vue$/, /\.(tsx?|jsx?)$/];
+  }
+
+  async analyze(node, filePath) {
+    if (filePath.endsWith('.vue')) {
+      node.isVueSFC = true;
+      // Extract template/script/style sections
+      const templateMatch = node.rawCode?.match(/<template>([\s\S]*)<\/template>/);
+      if (templateMatch) node.vueTemplate = templateMatch[1];
+      
+      const scriptMatch = node.rawCode?.match(/<script(?: setup)?(?: lang=['"]\w+['"])?>([\s\S]*)<\/script>/);
+      if (scriptMatch) node.vueScript = scriptMatch[1];
+    }
+  }
+}
+
+/**
+ * Svelte Ecosystem Plugin
+ */
+export class SveltePlugin extends BasePlugin {
+  get name() {
+    return 'svelte';
+  }
+
+  getConfigFiles() {
+    return ['package.json', 'svelte.config.js'];
+  }
+
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await require('fs').promises.readFile(require('path').join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.svelte || pkgJson.devDependencies?.svelte);
+    } catch {
+      return false;
+    }
+  }
+
+  getRoutePatterns() {
+    return [/\.svelte$/, /\.(tsx?|jsx?)$/];
+  }
+
+  async analyze(node, filePath) {
+    if (filePath.endsWith('.svelte')) {
+      node.isSvelteComponent = true;
+    }
+  }
+}
+
+/**
+ * Angular Ecosystem Plugin
+ */
+export class AngularPlugin extends BasePlugin {
+  get name() {
+    return 'angular';
+  }
+
+  getConfigFiles() {
+    return ['package.json', 'angular.json'];
+  }
+
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await require('fs').promises.readFile(require('path').join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@angular/core'] || pkgJson.devDependencies?.['@angular/core']);
+    } catch {
+      return false;
+    }
+  }
+
+  getRoutePatterns() {
+    return [/\.ts$/];
+  }
+
+  async analyze(node, filePath) {
+    if (node.rawCode?.includes('@Component') || node.rawCode?.includes('@Injectable') || node.rawCode?.includes('@NgModule')) {
+      node.isAngularEntity = true;
+    }
+  }
+}

package/src/plugins/ecosystems/TypeScriptPlugin.js

@@ -0,0 +1,56 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { BasePlugin } from '../BasePlugin.js';
+
+/**
+ * TypeScript Plugin for pkg-scaffold.
+ * Handles tsconfig.json detection and TypeScript-specific entry points.
+ */
+export class TypeScriptPlugin extends BasePlugin {
+    get name() {
+        return 'typescript';
+    }
+
+    getConfigFiles() {
+        return ['tsconfig.json', 'tsconfig.base.json', 'tsconfig.eslint.json'];
+    }
+
+    getRoutePatterns() {
+        // Common TypeScript entry points and declaration files
+        return [
+            /src\/index\.ts$/,
+            /src\/main\.ts$/,
+            /src\/lib\.ts$/,
+            /.*\.d\.ts$/
+        ];
+    }
+
+    getRequiredSystemContracts() {
+        // TypeScript specific implicit exports or requirements
+        return ['default'];
+    }
+
+    /**
+     * Custom Getter for v3.2.0: Get the compiler version from the project.
+     */
+    async getCompilerVersion() {
+        try {
+            const packageJsonPath = path.join(this.context.cwd, 'package.json');
+            const content = await fs.readFile(packageJsonPath, 'utf8');
+            const pkg = JSON.parse(content);
+            return pkg.devDependencies?.typescript || pkg.dependencies?.typescript || 'unknown';
+        } catch {
+            return 'not installed';
+        }
+    }
+
+    async isActive(baseDir) {
+        for (const file of this.getConfigFiles()) {
+            try {
+                await fs.access(path.join(baseDir, file));
+                return true;
+            } catch {}
+        }
+        return false;
+    }
+}

package/src/resolution/CircularDetector.js

@@ -0,0 +1,71 @@
+/**
+ * ============================================================================
+ * 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 from the lovely DreamLong"
+ * ============================================================================
+ * Implements a high-performance Tarjan-based or DFS-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
+   * @param {Map} graph - The codebase dependency graph
+   * @returns {Array} List of detected cycles
+   */
+  detectCycles(graph) {
+    this.cycles = [];
+    const visited = new Set();
+    const stack = new Set();
+    const path = [];
+
+    for (const filePath of graph.keys()) {
+      if (!visited.has(filePath)) {
+        this.dfs(filePath, graph, visited, stack, path);
+      }
+    }
+
+    return this.cycles;
+  }
+
+  dfs(node, graph, visited, stack, path) {
+    visited.add(node);
+    stack.add(node);
+    path.push(node);
+
+    const edges = graph.get(node)?.outgoingEdges || [];
+    for (const neighbor of edges) {
+      if (stack.has(neighbor)) {
+        // Cycle detected
+        const cycleStartIndex = path.indexOf(neighbor);
+        const cycle = path.slice(cycleStartIndex);
+        this.cycles.push(cycle);
+      } else if (!visited.has(neighbor)) {
+        this.dfs(neighbor, graph, visited, stack, path);
+      }
+    }
+
+    stack.delete(node);
+    path.pop();
+  }
+
+  /**
+   * Formats cycles for reporting
+   */
+  formatCycles() {
+    return this.cycles.map(cycle => {
+      return cycle.join(' -> ') + ' -> ' + cycle[0];
+    });
+  }
+}
+
+export default CircularDetector;

package/src/resolution/PathMapper.js

@@ -25,15 +25,25 @@ export class PathMapper {
       const rawText = await fs.readFile(configPath, 'utf8');
       
       // Strip inline single-line and block comments before parsing
-      const jsonCleanText = rawText.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '$1');
+      // Improved regex to handle more edge cases in tsconfig comments
+      const jsonCleanText = rawText
+        .replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '$1')
+        .replace(/,(\s*[\]}])/g, '$1'); // Remove trailing commas
+        
       const tsconfig = JSON.parse(jsonCleanText);
 
       if (!tsconfig.compilerOptions) return;
 
       const opts = tsconfig.compilerOptions;
+      
+      // v6 Path Resolution Fix (Knip Issue #1794)
+      // Ensure baseUrl is correctly resolved relative to the tsconfig file location
+      const configDir = path.dirname(configPath);
       if (opts.baseUrl) {
         this.baseUrl = opts.baseUrl;
-        this.absoluteBaseUrl = path.resolve(this.context.cwd, this.baseUrl);
+        this.absoluteBaseUrl = path.resolve(configDir, this.baseUrl);
+      } else {
+        this.absoluteBaseUrl = configDir;
       }
 
       if (opts.paths) {

package/src/resolution/WorkSpaceGraph.js

@@ -21,6 +21,16 @@ export class WorkspaceGraph {
     const pnpmWorkspacePath = path.join(this.context.cwd, 'pnpm-workspace.yaml');
     
     let workspaceGlobs = [];
+    this.hoistedDependencies = new Set();
+
+    // Load hoisted dependencies from root package.json (Knip Issue #1792 fix)
+    try {
+      const rootPkg = JSON.parse(await fs.readFile(rootPackageJsonPath, 'utf8'));
+      const deps = { ...rootPkg.dependencies, ...rootPkg.devDependencies };
+      Object.keys(deps).forEach(d => this.hoistedDependencies.add(d));
+    } catch (e) {
+      // No root package.json or unreadable
+    }
 
     // Protocol A: Check for pnpm workspace configurations
     try {