pkg-scaffold 3.2.0 → 3.3.2

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/resolution/CircularDetector.js

@@ -0,0 +1,122 @@
+/**
+ * ============================================================================
+ * 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();
+    const lowlink = new Map();
+    const onStack = new Set();
+
+    const strongconnect = (v) => {
+      indices.set(v, index);
+      lowlink.set(v, index);
+      index++;
+      stack.push(v);
+      onStack.add(v);
+
+      const node = graph.get(v);
+      if (node && node.outgoingEdges) {
+        for (const w of node.outgoingEdges) {
+          if (!indices.has(w)) {
+            strongconnect(w);
+            lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
+          } else if (onStack.has(w)) {
+            lowlink.set(v, Math.min(lowlink.get(v), indices.get(w)));
+          }
+        }
+      }
+
+      if (lowlink.get(v) === indices.get(v)) {
+        const component = [];
+        let w;
+        do {
+          w = stack.pop();
+          onStack.delete(w);
+          component.push(w);
+        } while (w !== v);
+
+        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]);
+          }
+        }
+      }
+    };
+
+    for (const v of graph.keys()) {
+      if (!indices.has(v)) {
+        strongconnect(v);
+      }
+    }
+
+    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;
+        }
+        return rel;
+      });
+      if (cycle.length === 1) return `${paths[0]} -> (self-loop)`;
+      return paths.join(' -> ') + ' -> ' + paths[0];
+    });
+  }
+
+  /**
+   * 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;
+        }
+        return rel;
+      }),
+      length: cycle.length,
+      isSelfLoop: cycle.length === 1
+    }));
+  }
+}
+
+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 {