entkapp 5.0.0 → 5.2.0

package/src/plugins/ecosystems/BackendServices.js

@@ -1,61 +1,197 @@
 /**
  * ============================================================================
- * Backend Services Plugins for entkapp v4.1.0
+ * Backend Services Plugins for entkapp v5.0.0
  * ============================================================================
- * Built-in support for GraphQL, REST APIs, and Databases.
+ * Built-in support for GraphQL, REST APIs, Databases, and BaaS providers.
+ * v5.0.0: All plugins implement getRequiredPackages() for dependency detection.
  */
-
 import { BasePlugin } from '../BasePlugin.js';
 import fs from 'fs/promises';
 import path from 'path';
 
-/**
- * GraphQL Ecosystem Plugin
- */
 export class GraphQLPlugin extends BasePlugin {
-  get name() {
-    return 'graphql';
-  }
-
-  getConfigFiles() {
-    return ['package.json', 'graphql.config.js', '.graphqlconfig'];
+  get name() { return 'graphql'; }
+  getConfigFiles() { return ['package.json', 'graphql.config.js', 'graphql.config.ts', '.graphqlconfig', 'graphql.config.yml']; }
+  getRequiredPackages() {
+    return [{ name: 'graphql', dev: false }];
   }
-
   async isActive(baseDir) {
     try {
       const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
       return !!(pkgJson.dependencies?.graphql || pkgJson.devDependencies?.graphql || pkgJson.dependencies?.['@apollo/client']);
-    } catch {
-      return false;
-    }
+    } 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;
-    }
+    if (matches.length > 0) node.graphqlQueries = matches;
   }
 }
 
-/**
- * Database Ecosystem Plugin (Prisma, Drizzle, TypeORM)
- */
-export class DatabasePlugin extends BasePlugin {
-  get name() {
-    return 'database';
+export class ApolloPlugin extends BasePlugin {
+  get name() { return 'apollo'; }
+  getConfigFiles() { return ['package.json', 'apollo.config.js', 'apollo.config.ts']; }
+  getRequiredPackages() {
+    return [
+      { name: '@apollo/client', dev: false },
+      { name: '@apollo/server', dev: false, optional: true },
+    ];
   }
-
-  getConfigFiles() {
-    return ['package.json', 'prisma/schema.prisma', 'drizzle.config.ts', 'ormconfig.json'];
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@apollo/client'] || pkgJson.dependencies?.['@apollo/server'] ||
+               pkgJson.devDependencies?.['@apollo/client'] || pkgJson.devDependencies?.['@apollo/server']);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('ApolloClient') || node.rawCode?.includes('ApolloServer')) node.isEntry = true;
   }
+}
 
+export class DatabasePlugin extends BasePlugin {
+  get name() { return 'database'; }
+  getConfigFiles() { return ['package.json', 'prisma/schema.prisma', 'drizzle.config.ts', 'drizzle.config.js', 'ormconfig.json']; }
+  getRequiredPackages() {
+    return [
+      { name: '@prisma/client', dev: false, optional: true },
+      { name: 'drizzle-orm', dev: false, optional: true },
+      { name: 'typeorm', dev: false, optional: true },
+    ];
+  }
   async analyze(node, filePath) {
-    // Detect DB usage
-    if (node.explicitImports.has('@prisma/client') || node.explicitImports.has('drizzle-orm')) {
+    if (node.explicitImports?.has('@prisma/client') || node.explicitImports?.has('drizzle-orm'))
       node.usesDatabase = true;
+  }
+}
+
+export class PrismaPlugin extends BasePlugin {
+  get name() { return 'prisma'; }
+  getConfigFiles() { return ['prisma/schema.prisma', 'schema.prisma']; }
+  getRequiredPackages() {
+    return [
+      { name: '@prisma/client', dev: false },
+      { name: 'prisma', dev: true },
+    ];
+  }
+  async isActive(baseDir) {
+    for (const f of this.getConfigFiles()) {
+      try { await fs.access(path.join(baseDir, f)); return true; } catch {}
+    }
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@prisma/client'] || pkgJson.devDependencies?.prisma);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('new PrismaClient()')) node.isEntry = true;
+  }
+}
+
+export class DrizzlePlugin extends BasePlugin {
+  get name() { return 'drizzle'; }
+  getConfigFiles() { return ['drizzle.config.ts', 'drizzle.config.js', 'drizzle.config.mjs']; }
+  getRequiredPackages() {
+    return [
+      { name: 'drizzle-orm', dev: false },
+      { name: 'drizzle-kit', dev: true },
+    ];
+  }
+  async isActive(baseDir) {
+    for (const f of this.getConfigFiles()) {
+      try { await fs.access(path.join(baseDir, f)); return true; } catch {}
+    }
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['drizzle-orm'] || pkgJson.devDependencies?.['drizzle-orm']);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('drizzle(')) node.isEntry = true;
+  }
+}
+
+export class MongoosePlugin extends BasePlugin {
+  get name() { return 'mongoose'; }
+  getConfigFiles() { return ['package.json']; }
+  getRequiredPackages() {
+    return [{ name: 'mongoose', dev: false }];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.mongoose || pkgJson.devDependencies?.mongoose);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('mongoose.model(')) node.isEntry = true;
+  }
+}
+
+export class SupabasePlugin extends BasePlugin {
+  get name() { return 'supabase'; }
+  getConfigFiles() { return ['supabase/config.toml', '.env', '.env.local', 'package.json']; }
+  getRequiredPackages() {
+    return [{ name: '@supabase/supabase-js', dev: false }];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@supabase/supabase-js'] || pkgJson.devDependencies?.['@supabase/supabase-js']);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('createClient') && node.rawCode?.includes('supabase')) node.isEntry = true;
+  }
+}
+
+export class FirebasePlugin extends BasePlugin {
+  get name() { return 'firebase'; }
+  getConfigFiles() { return ['firebase.json', '.firebaserc', 'package.json']; }
+  getRequiredPackages() {
+    return [{ name: 'firebase', dev: false }];
+  }
+  async isActive(baseDir) {
+    for (const f of ['firebase.json', '.firebaserc']) {
+      try { await fs.access(path.join(baseDir, f)); return true; } catch {}
     }
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.firebase || pkgJson.devDependencies?.firebase);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('initializeApp') && node.rawCode?.includes('firebase')) node.isEntry = true;
+  }
+}
+
+export class ClerkPlugin extends BasePlugin {
+  get name() { return 'clerk'; }
+  getConfigFiles() { return ['package.json', '.env', '.env.local']; }
+  getRequiredPackages() {
+    return [{ name: '@clerk/nextjs', dev: false, optional: true }, { name: '@clerk/clerk-react', dev: false, optional: true }];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      const allDeps = { ...(pkgJson.dependencies || {}), ...(pkgJson.devDependencies || {}) };
+      return Object.keys(allDeps).some(k => k.startsWith('@clerk/'));
+    } catch { return false; }
+  }
+}
+
+export class TRPCPlugin extends BasePlugin {
+  get name() { return 'trpc'; }
+  getConfigFiles() { return ['package.json']; }
+  getRequiredPackages() {
+    return [{ name: '@trpc/server', dev: false }, { name: '@trpc/client', dev: false }];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      const allDeps = { ...(pkgJson.dependencies || {}), ...(pkgJson.devDependencies || {}) };
+      return Object.keys(allDeps).some(k => k.startsWith('@trpc/'));
+    } catch { return false; }
   }
+  getRequiredSystemContracts() { return ['router', 'procedure', 'createTRPCRouter']; }
 }

package/src/plugins/ecosystems/GenericPlugins.js

@@ -1,3 +1,10 @@
+/**
+ * ============================================================================
+ * Generic Ecosystem Plugins for entkapp v5.0.0
+ * ============================================================================
+ * Nuxt, Remix, SvelteKit, Astro, VitePress, and more.
+ * v5.0.0: All plugins implement getRequiredPackages() for dependency detection.
+ */
 import path from 'path';
 import fs from 'fs/promises';
 import { BasePlugin } from '../BasePlugin.js';
@@ -5,6 +12,7 @@ import { BasePlugin } from '../BasePlugin.js';
 export class NuxtPlugin extends BasePlugin {
   get name() { return 'nuxt'; }
   getConfigFiles() { return ['nuxt.config.js', 'nuxt.config.ts']; }
+  getRequiredPackages() { return [{ name: 'nuxt', dev: false }]; }
   getRoutePatterns() {
     return [/\/pages\//, /\/server\/(api|routes|middleware)\//, /\/components\/[a-zA-Z0-9_\-\/]+\.vue$/];
   }
@@ -20,6 +28,12 @@ export class NuxtPlugin extends BasePlugin {
 export class RemixPlugin extends BasePlugin {
   get name() { return 'remix'; }
   getConfigFiles() { return ['remix.config.js', 'vite.config.js', 'vite.config.ts']; }
+  getRequiredPackages() {
+    return [
+      { name: '@remix-run/react', dev: false },
+      { name: '@remix-run/node', dev: false, optional: true },
+    ];
+  }
   getRoutePatterns() { return [/\/app\/routes\//, /\/app\/root\.(tsx|jsx)$/]; }
   getRequiredSystemContracts() { return ['default', 'loader', 'action', 'meta', 'links']; }
   async isActive(baseDir) {
@@ -36,23 +50,25 @@ export class RemixPlugin extends BasePlugin {
 export class SvelteKitPlugin extends BasePlugin {
   get name() { return 'sveltekit'; }
   getConfigFiles() { return ['svelte.config.js', 'vite.config.ts']; }
+  getRequiredPackages() {
+    return [
+      { name: '@sveltejs/kit', dev: false },
+      { name: 'svelte', dev: false },
+    ];
+  }
   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;
-    }
+    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']; }
+  getRequiredPackages() { return [{ name: 'astro', dev: false }]; }
   getRoutePatterns() { return [/\/src\/pages\/.*\.astro$/, /\/src\/pages\/.*\.(ts|js)$/]; }
   getRequiredSystemContracts() { return ['default', 'getStaticPaths']; }
   async isActive(baseDir) {
@@ -63,63 +79,64 @@ export class AstroPlugin extends BasePlugin {
   }
 }
 
-/**
- * Vitepress Ecosystem Plugin
- */
 export class VitepressPlugin extends BasePlugin {
-  get name() {
-    return 'vitepress';
-  }
-
-  getConfigFiles() {
-    return ['package.json'];
-  }
-
+  get name() { return 'vitepress'; }
+  getConfigFiles() { return ['package.json']; }
+  getRequiredPackages() { return [{ name: 'vitepress', dev: true }]; }
   async isActive(baseDir) {
-    // Vitepress is active if it's in package.json OR if .vitepress folder exists
     try {
       const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
       const hasDep = !!(pkgJson.dependencies?.vitepress || pkgJson.devDependencies?.vitepress);
-      
-      // Also check for .vitepress folder existence in common locations
       const possibleDirs = ['.vitepress', 'docs/.vitepress', '.docs/.vitepress'];
       for (const d of possibleDirs) {
-        try {
-          await fs.access(path.join(baseDir, d));
-          return true;
-        } catch {}
+        try { await fs.access(path.join(baseDir, d)); return true; } catch {}
       }
-      
       return hasDep;
-    } catch {
-      return false;
-    }
+    } catch { return false; }
   }
-
   async onDiscovery({ pkgDir, data, reachableFiles, queue, projectGraph, context }) {
     const hasVitepressDir = Array.from(projectGraph.keys()).some(f => f.includes('/.vitepress/'));
     const hasVitepressDep = !!(data.devDependencies?.vitepress || data.dependencies?.vitepress);
-
     if (hasVitepressDir && hasVitepressDep) {
-      // Legitimate usage: Mark .vitepress files as reachable
       for (const [filePath, _] of projectGraph.entries()) {
         if (filePath.includes('/.vitepress/') && !reachableFiles.has(filePath)) {
           reachableFiles.add(filePath);
           queue.push(filePath);
         }
       }
-      // Mark vue as used since it's required by vitepress
       if (!context.consumedRootPackages) context.consumedRootPackages = new Set();
       context.consumedRootPackages.add('vitepress');
       context.consumedRootPackages.add('vue');
     } else if (hasVitepressDir && !hasVitepressDep) {
-      // Missing dependency case
       if (!context.unlistedDependencies) context.unlistedDependencies = [];
       context.unlistedDependencies.push({
         name: 'vitepress',
         reason: 'Found .vitepress configuration directory but package is not in package.json'
       });
     }
-    // If hasVitepressDep but !hasVitepressDir, it remains "unused" by default logic
   }
 }
+
+export class GatsbyPlugin extends BasePlugin {
+  get name() { return 'gatsby'; }
+  getConfigFiles() { return ['gatsby-config.js', 'gatsby-config.ts', 'gatsby-node.js', 'gatsby-node.ts']; }
+  getRequiredPackages() { return [{ name: 'gatsby', dev: false }]; }
+  getRoutePatterns() { return [/\/src\/pages\//, /\/src\/templates\//]; }
+  getRequiredSystemContracts() { return ['default', 'getServerData', 'config']; }
+  async isActive(baseDir) {
+    for (const file of this.getConfigFiles()) {
+      try { await fs.access(path.join(baseDir, file)); return true; } catch {}
+    }
+    return false;
+  }
+}
+
+export class RedwoodPlugin extends BasePlugin {
+  get name() { return 'redwood'; }
+  getConfigFiles() { return ['redwood.toml']; }
+  getRequiredPackages() { return [{ name: '@redwoodjs/core', dev: true }]; }
+  async isActive(baseDir) {
+    try { await fs.access(path.join(baseDir, 'redwood.toml')); return true; } catch { return false; }
+  }
+  getRoutePatterns() { return [/\/web\/src\/pages\//, /\/api\/src\/functions\//]; }
+}

package/src/plugins/ecosystems/ModernFrameworks.js

@@ -1,159 +1,162 @@
 /**
  * ============================================================================
- * Modern Frameworks Plugins for entkapp v4.0.0
+ * Modern Frameworks Plugins for entkapp v5.0.0
  * ============================================================================
- * Built-in support for React, Vue, Svelte, and Angular.
+ * Built-in support for React, Vue, Svelte, Angular, Preact, Solid, Qwik, Lit.
+ * v5.0.0: All plugins now implement getRequiredPackages() for dependency detection.
  */
-
 import { BasePlugin } from '../BasePlugin.js';
 import fs from 'fs/promises';
 import path from 'path';
 
-/**
- * React Ecosystem Plugin
- */
 export class ReactPlugin extends BasePlugin {
-  get name() {
-    return 'react';
-  }
-
-  getConfigFiles() {
-    return ['package.json'];
+  get name() { return 'react'; }
+  getConfigFiles() { return ['package.json']; }
+  getRequiredPackages() {
+    return [
+      { name: 'react', dev: false },
+      { name: 'react-dom', dev: false },
+    ];
   }
-
   async isActive(baseDir) {
     try {
       const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
       return !!(pkgJson.dependencies?.react || pkgJson.devDependencies?.react);
-    } catch {
-      return false;
-    }
-  }
-
-  getRoutePatterns() {
-    return [/\.(tsx?|jsx?)$/];
+    } catch { return false; }
   }
-
+  getRoutePatterns() { return [/\.(tsx?|jsx?)$/]; }
   getRequiredSystemContracts() {
-    return ['default', 'Component', 'PureComponent', 'Fragment', 'useEffect', 'useState', 'useContext', 'useReducer', 'useCallback', 'useMemo', 'useRef', 'useImperativeHandle', 'useLayoutEffect', 'useDebugValue'];
+    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
+    if (node.explicitImports?.has('react')) node.isReactComponent = true;
+    if (node.rawCode && (node.rawCode.includes('</') || node.rawCode.includes('/>'))) node.hasJSX = true;
     const hookMatches = node.rawCode?.match(/use[A-Z]\w+/g) || [];
-    if (hookMatches.length > 0) {
-      node.reactHooks = new Set(hookMatches);
-    }
+    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'];
+  get name() { return 'vue'; }
+  getConfigFiles() { return ['package.json', 'vue.config.js', 'vite.config.ts', 'vite.config.js']; }
+  getRequiredPackages() {
+    return [{ name: 'vue', dev: false }];
   }
-
   async isActive(baseDir) {
     try {
       const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
       return !!(pkgJson.dependencies?.vue || pkgJson.devDependencies?.vue);
-    } catch {
-      return false;
-    }
-  }
-
-  getRoutePatterns() {
-    return [/\.vue$/, /\.(tsx?|jsx?)$/];
+    } 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'];
+  get name() { return 'svelte'; }
+  getConfigFiles() { return ['package.json', 'svelte.config.js']; }
+  getRequiredPackages() {
+    return [{ name: 'svelte', dev: false }];
   }
-
   async isActive(baseDir) {
     try {
       const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
       return !!(pkgJson.dependencies?.svelte || pkgJson.devDependencies?.svelte);
-    } catch {
-      return false;
-    }
-  }
-
-  getRoutePatterns() {
-    return [/\.svelte$/, /\.(tsx?|jsx?)$/];
+    } catch { return false; }
   }
-
+  getRoutePatterns() { return [/\.svelte$/, /\.(tsx?|jsx?)$/]; }
   async analyze(node, filePath) {
-    if (filePath.endsWith('.svelte')) {
-      node.isSvelteComponent = true;
-    }
+    if (filePath.endsWith('.svelte')) node.isSvelteComponent = true;
   }
 }
 
-/**
- * Angular Ecosystem Plugin
- */
 export class AngularPlugin extends BasePlugin {
-  get name() {
-    return 'angular';
+  get name() { return 'angular'; }
+  getConfigFiles() { return ['package.json', 'angular.json']; }
+  getRequiredPackages() {
+    return [
+      { name: '@angular/core', dev: false },
+      { name: '@angular/common', dev: false },
+      { name: '@angular/cli', dev: true, optional: true },
+    ];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(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;
   }
+}
 
-  getConfigFiles() {
-    return ['package.json', 'angular.json'];
+export class PreactPlugin extends BasePlugin {
+  get name() { return 'preact'; }
+  getConfigFiles() { return ['package.json']; }
+  getRequiredPackages() { return [{ name: 'preact', dev: false }]; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.preact || pkgJson.devDependencies?.preact);
+    } catch { return false; }
   }
+  getRoutePatterns() { return [/\.(tsx?|jsx?)$/]; }
+  async analyze(node) {
+    if (node.rawCode?.includes('render(') && node.rawCode?.includes('preact')) node.isEntry = true;
+  }
+}
 
+export class SolidPlugin extends BasePlugin {
+  get name() { return 'solid'; }
+  getConfigFiles() { return ['package.json', 'vite.config.ts', 'vite.config.js']; }
+  getRequiredPackages() { return [{ name: 'solid-js', dev: false }]; }
   async isActive(baseDir) {
     try {
       const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
-      return !!(pkgJson.dependencies?.['@angular/core'] || pkgJson.devDependencies?.['@angular/core']);
-    } catch {
-      return false;
-    }
+      return !!(pkgJson.dependencies?.['solid-js'] || pkgJson.devDependencies?.['solid-js']);
+    } catch { return false; }
   }
+  getRoutePatterns() { return [/\.(tsx?|jsx?)$/]; }
+  getRequiredSystemContracts() { return ['default', 'createSignal', 'createEffect', 'createMemo', 'createResource']; }
+}
 
-  getRoutePatterns() {
-    return [/\.ts$/];
+export class QwikPlugin extends BasePlugin {
+  get name() { return 'qwik'; }
+  getConfigFiles() { return ['package.json', 'vite.config.ts']; }
+  getRequiredPackages() { return [{ name: '@builder.io/qwik', dev: false }]; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@builder.io/qwik'] || pkgJson.devDependencies?.['@builder.io/qwik']);
+    } catch { return false; }
   }
+  getRoutePatterns() { return [/\.(tsx?|jsx?)$/]; }
+  getRequiredSystemContracts() { return ['default', 'component$', 'useSignal', 'useStore', 'useTask$']; }
+}
 
-  async analyze(node, filePath) {
-    if (node.rawCode?.includes('@Component') || node.rawCode?.includes('@Injectable') || node.rawCode?.includes('@NgModule')) {
-      node.isAngularEntity = true;
-    }
+export class LitPlugin extends BasePlugin {
+  get name() { return 'lit'; }
+  getConfigFiles() { return ['package.json']; }
+  getRequiredPackages() { return [{ name: 'lit', dev: false }]; }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.lit || pkgJson.devDependencies?.lit);
+    } catch { return false; }
   }
+  getRoutePatterns() { return [/\.(ts|js)$/]; }
+  getRequiredSystemContracts() { return ['default', 'LitElement', 'html', 'css']; }
 }