entkapp 4.1.0

package/src/plugins/ecosystems/BackendServices.js

@@ -0,0 +1,61 @@
+/**
+ * ============================================================================
+ * Backend Services Plugins for entkapp v4.1.0
+ * ============================================================================
+ * Built-in support for GraphQL, REST APIs, and Databases.
+ */
+
+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'];
+  }
+
+  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;
+    }
+  }
+
+  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/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/ModernFrameworks.js

@@ -0,0 +1,159 @@
+/**
+ * ============================================================================
+ * Modern Frameworks Plugins for entkapp v4.0.0
+ * ============================================================================
+ * Built-in support for React, Vue, Svelte, and Angular.
+ */
+
+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'];
+  }
+
+  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?)$/];
+  }
+
+  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 fs.readFile(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 fs.readFile(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 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;
+    }
+  }
+}

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/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/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/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 entkapp.
+ * 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/refractor/ImpactAnalyzer.js

@@ -0,0 +1,92 @@
+import path from 'path';
+import fs from 'fs/promises';
+
+/**
+ * Cross-Reference Dependency Matrix & Breakage Risk Auditor
+ * Traces dynamic runtime usage patterns to prevent code pruning from breaking downstream systems.
+ */
+export class ImpactAnalyzer {
+  constructor(context) {
+    this.context = context;
+    this.safetyOverlays = [/\.json$/, /\.json5$/, /\.html$/, /\.yaml$/, /\.yml$/];
+  }
+
+  /**
+   * Scans non-code assets and dynamic lookups to check if an unused export is needed elsewhere.
+   * @param {string} originFile - Absolute path of component housing target symbol
+   * @param {string} symbolName - Literal identifier being evaluated for deletion
+   * @param {Map} projectGraph - Full project structural graph representation
+   */
+  async verifyRefactorSafety(originFile, symbolName, projectGraph) {
+    // Avoid dropping generic single letter tokens or framework primitives
+    if (symbolName === 'default' || symbolName.length <= 2) {
+      return { isSafeToPrune: false, blockReason: 'PROTECTED_SYSTEM_CONTRACT_KEYWORD' };
+    }
+
+    // Rule 1: Check across all code files for loose string-based token references
+    for (const [filePath, fileNode] of projectGraph.entries()) {
+      if (filePath === originFile) continue;
+
+      // If the symbol name is explicitly referenced in an element lookup or template slice, flag it as risky
+      if (fileNode.rawStringReferences && fileNode.rawStringReferences.has(symbolName)) {
+        return {
+          isSafeToPrune: false,
+          blockReason: `LOOSE_STRING_ACCESS_MATCH_FOUND_IN: ${path.relative(this.context.cwd, filePath)}`
+        };
+      }
+
+      // Check member property chain lookups: customer.profile.billingAddress
+      if (fileNode.propertyAccessChains) {
+        for (const chain of fileNode.propertyAccessChains) {
+          if (chain.endsWith(`.${symbolName}`) || chain.includes(`.${symbolName}.`)) {
+            return {
+              isSafeToPrune: false,
+              blockReason: `DYNAMIC_PROPERTY_ACCESS_CHAIN_HIT: ${chain}`
+            };
+          }
+        }
+      }
+    }
+
+    // Rule 2: Crawl through external static manifests (JSON metadata, HTML routing templates, workflow files)
+    const configurations = await this.gatherMetadataFiles(this.context.cwd);
+    
+    for (const confPath of configurations) {
+      try {
+        const payload = await fs.readFile(confPath, 'utf8');
+        
+        // Match string references inside configuration boundaries
+        if (payload.includes(`"${symbolName}"`) || payload.includes(`'${symbolName}'`) || payload.includes(`data-${symbolName}`)) {
+          return {
+            isSafeToPrune: false,
+            blockReason: `METADATA_MANIFEST_DEPENDENCY_FOUND_IN: ${path.relative(this.context.cwd, confPath)}`
+          };
+        }
+      } catch {
+        // Read step error; skip unreadable descriptors
+      }
+    }
+
+    return { isSafeToPrune: true, blockReason: null };
+  }
+
+  async gatherMetadataFiles(dir, collected = []) {
+    try {
+      const entities = await fs.readdir(dir, { withFileTypes: true });
+      for (const ent of entities) {
+        const resolutionPath = path.join(dir, ent.name);
+        
+        if (ent.isDirectory()) {
+          if (ent.name === 'node_modules' || ent.name === '.git' || ent.name === '.entkapp-cache' || ent.name === 'dist') continue;
+          await this.gatherMetadataFiles(resolutionPath, collected);
+        } else if (ent.isFile()) {
+          const actsAsMetaAsset = this.safetyOverlays.some(regex => regex.test(ent.name));
+          if (actsAsMetaAsset) {
+            collected.push(resolutionPath);
+          }
+        }
+      }
+    } catch {}
+    return collected;
+  }
+}