pkg-scaffold 3.0.0 → 3.1.1

package/src/plugins/PluginRegistry.js

@@ -0,0 +1,95 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { pathToFileURL } from 'url';
+
+/**
+ * Advanced Plugin Registry supporting Builtin, Custom, and Knip-style plugins.
+ */
+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 };
+    }
+
+    if (this.config.useBuiltinPlugins) {
+      await this.loadBuiltinPlugins();
+    }
+
+    if (this.config.useCustomPlugins) {
+      await this.loadCustomPlugins(projectRoot);
+    }
+
+    if (this.config.supportKnipPlugins) {
+      await this.initKnipAdapter();
+    }
+  }
+
+  async loadBuiltinPlugins() {
+    const { NextJsPlugin } = await import('./ecosystems/NextJsPlugin.js');
+    const { NuxtPlugin, RemixPlugin, SvelteKitPlugin, AstroPlugin } = await import('./ecosystems/GenericPlugins.js');
+
+    const builtins = [
+      new NextJsPlugin(this.context),
+      new NuxtPlugin(this.context),
+      new RemixPlugin(this.context),
+      new SvelteKitPlugin(this.context),
+      new AstroPlugin(this.context)
+    ];
+
+    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;
+          this.register(new PluginClass(this.context));
+        }
+      }
+    } 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;
+  }
+
+  register(plugin) {
+    this.plugins.set(plugin.name, plugin);
+  }
+
+  getPlugins() {
+    return Array.from(this.plugins.values());
+  }
+
+  async getActivePlugins(baseDir) {
+    const active = [];
+    for (const plugin of this.plugins.values()) {
+      if (await plugin.isActive(baseDir)) {
+        active.push(plugin);
+      }
+    }
+    return active;
+  }
+}

package/src/plugins/ecosystems/GenericPlugins.js

@@ -0,0 +1,64 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { BasePlugin } from '../BasePlugin.js';
+
+export class NuxtPlugin extends BasePlugin {
+  get name() { return 'nuxt'; }
+  getConfigFiles() { return ['nuxt.config.js', 'nuxt.config.ts']; }
+  getRoutePatterns() {
+    return [/\/pages\//, /\/server\/(api|routes|middleware)\//, /\/components\/[a-zA-Z0-9_\-\/]+\.vue$/];
+  }
+  getRequiredSystemContracts() { return ['default']; }
+  async isActive(baseDir) {
+    for (const file of this.getConfigFiles()) {
+      try { await fs.access(path.join(baseDir, file)); return true; } catch {}
+    }
+    return false;
+  }
+}
+
+export class RemixPlugin extends BasePlugin {
+  get name() { return 'remix'; }
+  getConfigFiles() { return ['remix.config.js', 'vite.config.js', 'vite.config.ts']; }
+  getRoutePatterns() { return [/\/app\/routes\//, /\/app\/root\.(tsx|jsx)$/]; }
+  getRequiredSystemContracts() { return ['default', 'loader', 'action', 'meta', 'links']; }
+  async isActive(baseDir) {
+    for (const file of this.getConfigFiles()) {
+      try {
+        const content = await fs.readFile(path.join(baseDir, file), 'utf8');
+        if (content.includes('@remix-run/') || content.includes('remix')) return true;
+      } catch {}
+    }
+    return false;
+  }
+}
+
+export class SvelteKitPlugin extends BasePlugin {
+  get name() { return 'sveltekit'; }
+  getConfigFiles() { return ['svelte.config.js', 'vite.config.ts']; }
+  getRoutePatterns() {
+    return [/\+page\.(svelte|ts|js)$/, /\+page\.server\.(ts|js)$/, /\+layout\.(svelte|ts|js)$/, /\+server\.(ts|js)$/];
+  }
+  getRequiredSystemContracts() { return ['load', 'actions', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH']; }
+  async isActive(baseDir) {
+    try {
+      await fs.access(path.join(baseDir, 'svelte.config.js'));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export class AstroPlugin extends BasePlugin {
+  get name() { return 'astro'; }
+  getConfigFiles() { return ['astro.config.mjs', 'astro.config.cjs', 'astro.config.ts']; }
+  getRoutePatterns() { return [/\/src\/pages\/.*\.astro$/, /\/src\/pages\/.*\.(ts|js)$/]; }
+  getRequiredSystemContracts() { return ['default', 'getStaticPaths']; }
+  async isActive(baseDir) {
+    for (const file of this.getConfigFiles()) {
+      try { await fs.access(path.join(baseDir, file)); return true; } catch {}
+    }
+    return false;
+  }
+}

package/src/plugins/ecosystems/NextJsPlugin.js

@@ -0,0 +1,33 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { BasePlugin } from '../BasePlugin.js';
+
+export class NextJsPlugin extends BasePlugin {
+  get name() { return 'nextjs'; }
+
+  getConfigFiles() {
+    return ['next.config.js', 'next.config.mjs', 'next.config.ts'];
+  }
+
+  getRoutePatterns() {
+    return [
+      /\/pages\/api\//,
+      /\/pages\/[a-zA-Z0-9_\-\[\]]+/i,
+      /\/app\/([\w\-\[\]]+\/)+(page|route|layout|loading|error|not-found)\.(ts|tsx|js|jsx)$/
+    ];
+  }
+
+  getRequiredSystemContracts() {
+    return ['default', 'getServerSideProps', 'getStaticProps', 'getStaticPaths', 'generateMetadata', 'middleware'];
+  }
+
+  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/ConfigLoader.js

@@ -0,0 +1,59 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { pathToFileURL } from 'url';
+
+/**
+ * Loads and parses pkg-scaffold configuration files.
+ * Supports scaffold.config.js, .scaffoldrc.json, and .scaffoldrc.
+ */
+export class ConfigLoader {
+  constructor(context) {
+    this.context = context;
+  }
+
+  async loadConfig(projectRoot) {
+    const searchPaths = [
+      'scaffold.config.js',
+      'scaffold.config.mjs',
+      '.scaffoldrc.json',
+      '.scaffoldrc'
+    ];
+
+    for (const fileName of searchPaths) {
+      const fullPath = path.join(projectRoot, fileName);
+      try {
+        await fs.access(fullPath);
+        
+        if (fileName.endsWith('.js') || fileName.endsWith('.mjs')) {
+          const module = await import(pathToFileURL(fullPath).href);
+          return module.default || module;
+        } else {
+          const content = await fs.readFile(fullPath, 'utf8');
+          return JSON.parse(content);
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+
+    return this.getDefaultConfig();
+  }
+
+  getDefaultConfig() {
+    return {
+      entryPoints: ['src/index.ts', 'index.js'],
+      exclude: [
+        'node_modules/**',
+        'dist/**',
+        '**/*.test.ts',
+        '**/*.spec.ts'
+      ],
+      plugins: [],
+      rules: {
+        'no-unused-exports': 'error',
+        'no-unused-vars': 'warn',
+        'no-dead-code': 'error'
+      }
+    };
+  }
+}

package/src/resolution/DependencyProfiler.js

@@ -0,0 +1,90 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Advanced Dependency Profiling Engine.
+ * Traces Peer Dependencies and Implicit Tooling Invocations.
+ */
+export class DependencyProfiler {
+  constructor(context) {
+    this.context = context;
+    this.binaryToPackageMap = {
+      'tsc': 'typescript',
+      'jest': 'jest',
+      'vitest': 'vitest',
+      'eslint': 'eslint',
+      'prettier': 'prettier',
+      'vite': 'vite',
+      'next': 'next',
+      'nuxt': 'nuxt',
+      'astro': 'astro',
+      'playwright': 'playwright',
+      'cypress': 'cypress',
+      'tailwind': 'tailwindcss',
+      'postcss': 'postcss'
+    };
+  }
+
+  /**
+   * Scans package.json scripts and CI files for binary usage.
+   */
+  async traceImplicitInvocations(projectRoot) {
+    const usedPackages = new Set();
+    
+    // 1. Scan package.json scripts
+    try {
+      const pkgJsonPath = path.join(projectRoot, 'package.json');
+      const pkg = JSON.parse(await fs.readFile(pkgJsonPath, 'utf8'));
+      
+      if (pkg.scripts) {
+        for (const script of Object.values(pkg.scripts)) {
+          this.extractPackagesFromScript(script, usedPackages);
+        }
+      }
+    } catch (e) {}
+
+    // 2. Scan CI workflows
+    try {
+      const githubWorkflows = path.join(projectRoot, '.github/workflows');
+      const files = await fs.readdir(githubWorkflows).catch(() => []);
+      for (const file of files) {
+        if (file.endsWith('.yml') || file.endsWith('.yaml')) {
+          const content = await fs.readFile(path.join(githubWorkflows, file), 'utf8');
+          this.extractPackagesFromScript(content, usedPackages);
+        }
+      }
+    } catch (e) {}
+
+    return usedPackages;
+  }
+
+  extractPackagesFromScript(script, collector) {
+    // Basic regex to find binary-like words
+    const words = script.split(/[\s&|;]+/);
+    for (const word of words) {
+      const cleanWord = word.replace(/['"]/g, '');
+      if (this.binaryToPackageMap[cleanWord]) {
+        collector.add(this.binaryToPackageMap[cleanWord]);
+      }
+    }
+  }
+
+  /**
+   * Resolves peer dependencies for a given set of used packages.
+   */
+  async resolvePeerDependencies(usedPackages, projectRoot) {
+    const peerDeps = new Set();
+    const nodeModules = path.join(projectRoot, 'node_modules');
+
+    for (const pkgName of usedPackages) {
+      try {
+        const pkgJsonPath = path.join(nodeModules, pkgName, 'package.json');
+        const pkg = JSON.parse(await fs.readFile(pkgJsonPath, 'utf8'));
+        if (pkg.peerDependencies) {
+          Object.keys(pkg.peerDependencies).forEach(dep => peerDeps.add(dep));
+        }
+      } catch (e) {}
+    }
+    return peerDeps;
+  }
+}