entkapp 5.4.0 → 5.6.0

package/src/refractor/ImpactAnalyzer.mjs

@@ -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;
+  }
+}

package/src/refractor/SourceRewriter.mjs

@@ -0,0 +1,86 @@
+import ts from 'typescript';
+import fs from 'fs/promises';
+
+/**
+ * Format-Preserving Abstract Syntax Tree Source Mutation Engine
+ * Executes targeted updates using token position logic while preserving trivia (comments/JSDoc).
+ */
+export class SourceRewriter {
+  constructor(context) {
+    this.context = context;
+  }
+
+  /**
+   * Removes a specific named export symbol declaration block from code text.
+   * @param {string} filePath - Absolute path to on-disk code component
+   * @param {string} symbolName - Target export key to prune
+   * @param {Object} exportMeta - Mapped token offset indices (start/end offsets)
+   */
+  async stripNamedExportSignature(filePath, symbolName, exportMeta) {
+    const rawSource = await fs.readFile(filePath, 'utf8');
+    
+    // Case A: Token is grouped inside a multi-export destructured statement block: export { a, b, c };
+    if (exportMeta.type === 'named') {
+      const updatedText = this.pruneFromSharedExportClause(rawSource, symbolName, exportMeta);
+      if (updatedText) return updatedText;
+    }
+
+    // Case B: Isolated node removal. Calculate indices from start to end while preserving comments.
+    const startOffset = exportMeta.start;
+    const endOffset = exportMeta.end;
+
+    // Split source without dropping trailing line structural punctuation or text formatting configurations
+    const prefix = rawSource.slice(0, startOffset);
+    let suffix = rawSource.slice(endOffset);
+
+    // Clean up trailing commas or semicolons to prevent syntax errors
+    if (suffix.startsWith(';') || suffix.startsWith(',')) {
+      suffix = suffix.slice(1);
+    }
+
+    return prefix + suffix;
+  }
+
+  /**
+   * Handles selective pruning of export elements within inline groupings like `export { x, y as z }`.
+   */
+  pruneFromSharedExportClause(sourceText, symbolName, meta) {
+    // Find the enclosing export declaration node using structural boundaries
+    const sourceFile = ts.createSourceFile(
+      'temp.ts',
+      sourceText,
+      ts.ScriptTarget.Latest,
+      true
+    );
+
+    let targetText = null;
+
+    const findAndPrune = (node) => {
+      if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) {
+        const start = node.getStart(sourceFile);
+        const end = node.getEnd();
+
+        // Check if the target node spans the exact offset coordinates of the dead symbol
+        if (meta.start >= start && meta.end <= end) {
+          const activeElements = node.exportClause.elements;
+          const keptSymbols = activeElements
+            .filter(el => el.name.text !== symbolName)
+            .map(el => el.getText(sourceFile));
+
+          if (keptSymbols.length === 0) {
+            // Drop the entire declaration block if no active exports remain inside it
+            targetText = sourceText.slice(0, start) + sourceText.slice(end);
+          } else {
+            // Rewrite the export group inline, preserving formatting and comments
+            const reconstructedClause = `export { ${keptSymbols.join(', ')} };`;
+            targetText = sourceText.slice(0, start) + reconstructedClause + sourceText.slice(end);
+          }
+        }
+      }
+      ts.forEachChild(node, findAndPrune);
+    };
+
+    findAndPrune(sourceFile);
+    return targetText;
+  }
+}

package/src/refractor/TransactionManager.mjs

@@ -0,0 +1,5 @@
+export class TransactionManager {
+  constructor(context) { this.context = context; }
+  async startTransaction() {}
+  async commitTransaction() {}
+}

package/src/refractor/TypeIntegrity.mjs

@@ -0,0 +1,4 @@
+export class TypeIntegrity {
+  constructor(context) { this.context = context; }
+  async check() {}
+}

package/src/resolution/BuildOrchestrator.mjs

@@ -0,0 +1,46 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * ============================================================================
+ * Auto-Build Orchestrator v5.2.0
+ * ============================================================================
+ * Orchestrates the build process based on active frameworks and tools.
+ */
+export class BuildOrchestrator {
+  constructor(context) {
+    this.context = context;
+    this.cwd = context.cwd;
+  }
+
+  async getBuildCommand(activePlugins) {
+    const pluginNames = activePlugins.map(p => p.name);
+    
+    // Priority-based build command detection
+    if (pluginNames.includes('nextjs')) return 'next build';
+    if (pluginNames.includes('nuxt')) return 'nuxt build';
+    if (pluginNames.includes('remix')) return 'remix build';
+    if (pluginNames.includes('astro')) return 'astro build';
+    if (pluginNames.includes('vite')) return 'vite build';
+    if (pluginNames.includes('webpack')) return 'webpack --mode production';
+    if (pluginNames.includes('rollup')) return 'rollup -c';
+    if (pluginNames.includes('esbuild')) return 'esbuild src/index.ts --bundle --outdir=dist';
+    
+    return null;
+  }
+
+  async runBuild(activePlugins) {
+    const command = await this.getBuildCommand(activePlugins);
+    if (!command) {
+      return { success: false, message: 'No suitable build command found for this project setup.' };
+    }
+
+    console.log(`[BuildOrchestrator] Detected Build Command: ${command}`);
+    // In a real scenario, we would execute this via execa.
+    return {
+      success: true,
+      command: command,
+      message: `Project would be built using: ${command}`
+    };
+  }
+}

package/src/resolution/CircularDetector.mjs

@@ -0,0 +1,91 @@
+import path from 'path';
+
+export class CircularDetector {
+  constructor(context) {
+    this.context = context;
+    this.cycles = [];
+  }
+
+  detectCycles(projectGraph) {
+    const stack = [];
+    const onStack = new Set();
+    const indices = new Map();
+    const lowlink = new Map();
+    const sccs = [];
+    let index = 0;
+
+    const strongConnect = (v) => {
+      indices.set(v, index);
+      lowlink.set(v, index);
+      index++;
+      stack.push(v);
+      onStack.add(v);
+
+      const node = projectGraph.get(v);
+      if (node && node.outgoingEdges) {
+        // Ensure outgoingEdges is treated as an array-like structure
+        const edges = Array.isArray(node.outgoingEdges) ? node.outgoingEdges : Array.from(node.outgoingEdges);
+        
+        for (let i = 0; i < edges.length; i++) {
+          const w = edges[i];
+          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 scc = [];
+        let w;
+        do {
+          w = stack.pop();
+          onStack.delete(w);
+          scc.push(w);
+        } while (w !== v);
+
+        if (scc.length > 1) {
+          const cycle = scc.slice().reverse();
+          cycle.push(cycle[0]);
+          sccs.push(cycle);
+        } else if (scc.length === 1) {
+          const singleNode = projectGraph.get(scc[0]);
+          if (singleNode && singleNode.outgoingEdges) {
+            const edges = Array.isArray(singleNode.outgoingEdges) ? singleNode.outgoingEdges : Array.from(singleNode.outgoingEdges);
+            let hasSelfLoop = false;
+            for (let i = 0; i < edges.length; i++) {
+              if (edges[i] === scc[0]) {
+                hasSelfLoop = true;
+                break;
+              }
+            }
+            if (hasSelfLoop) {
+              sccs.push([scc[0], scc[0]]);
+            }
+          }
+        }
+      }
+    };
+
+    const keys = Array.from(projectGraph.keys());
+    for (let i = 0; i < keys.length; i++) {
+      if (!indices.has(keys[i])) {
+        strongConnect(keys[i]);
+      }
+    }
+
+    this.cycles = sccs;
+    return sccs;
+  }
+
+  formatCycles() {
+    return this.cycles.map(cycle => {
+      return cycle.map(p => {
+        const relativePath = path.relative(this.context.cwd, p);
+        return relativePath.replace(/\\/g, '/');
+      }).join(' -> ');
+    });
+  }
+}

package/src/resolution/ConfigGenerator.mjs

@@ -0,0 +1,83 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * ============================================================================
+ * Auto-Config Engine v5.2.0
+ * ============================================================================
+ * Generates and optimizes configuration files based on project structure.
+ */
+export class ConfigGenerator {
+  constructor(context) {
+    this.context = context;
+    this.cwd = context.cwd;
+  }
+
+  /**
+   * Generates missing configurations for active plugins.
+   */
+  async generateMissingConfigs(activePlugins) {
+    const generated = [];
+    const files = await fs.readdir(this.cwd);
+
+    for (const plugin of activePlugins) {
+      const configFiles = plugin.getConfigFiles();
+      const exists = configFiles.some(f => files.includes(f));
+
+      if (!exists && this.templates[plugin.name]) {
+        const template = this.templates[plugin.name]();
+        const fileName = configFiles[0]; // Use the first recommended filename
+        const filePath = path.join(this.cwd, fileName);
+        
+        // In a real scenario, we would write the file here.
+        // For the SDK, we return the plan.
+        generated.push({
+          plugin: plugin.name,
+          file: fileName,
+          content: template
+        });
+      }
+    }
+    return generated;
+  }
+
+  get templates() {
+    return {
+      'tailwind': () => `/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}`,
+      'prettier': () => `{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "es5"
+}`,
+      'eslint': () => `{
+  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint"],
+  "root": true
+}`,
+      'typescript': () => `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}`
+    };
+  }
+}

package/src/resolution/ConfigLoader.js

@@ -3,239 +3,73 @@ import path from 'path';
 
 /**
  * ConfigLoader
- *
- * Loads and merges entkapp configuration from multiple sources.
- * Supports Monorepo detection for pnpm, npm/yarn/bun, Lerna, Turbo, and Nx.
+ * Loads and merges entkapp configuration from multiple sources:
+ * - entkapp/config.json (project config)
+ * - entkapp.config.js / entkapp.config.mjs (JS config)
+ * - package.json "entkapp" key
+ * - CLI flags (passed as overrides)
  */
 export class ConfigLoader {
-  constructor(cwd) {
-    this.cwd = cwd;
+  constructor(cwd) { 
+    this.cwd = cwd; 
   }
 
   async loadConfig(overrides = {}) {
     let config = this._defaultConfig();
 
-    // 1. entkapp/config.json
+    // 1. Try entkapp/config.json
     const jsonConfigPath = path.join(this.cwd, 'entkapp', 'config.json');
     try {
       const raw = await fs.readFile(jsonConfigPath, 'utf8');
+      // Strip comments from JSON (JSONC support)
       const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
-      config = this._merge(config, JSON.parse(stripped));
+      const parsed = JSON.parse(stripped);
+      config = this._merge(config, parsed);
     } catch (e) {}
 
-    // 2. entkapp.config.ts / .mjs / .js / .cjs
-    for (const configFile of ['entkapp.config.ts', 'entkapp.config.mjs', 'entkapp.config.js', 'entkapp.config.cjs']) {
+    // 2. Try entkapp.config.js / entkapp.config.mjs
+    for (const configFile of ['entkapp.config.mjs', 'entkapp.config.js', 'entkapp.config.cjs']) {
       const jsConfigPath = path.join(this.cwd, configFile);
       try {
         const mod = await import(jsConfigPath);
         const jsConfig = mod.default || mod;
-        if (typeof jsConfig === 'object' && jsConfig !== null) {
+        if (typeof jsConfig === 'object') {
           config = this._merge(config, jsConfig);
           break;
         }
       } catch (e) {}
     }
 
-    // 3. package.json "entkapp" key
+    // 3. Try package.json "entkapp" key
+    const pkgPath = path.join(this.cwd, 'package.json');
     try {
-      const pkg = JSON.parse(await fs.readFile(path.join(this.cwd, 'package.json'), 'utf8'));
+      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
       if (pkg.entkapp && typeof pkg.entkapp === 'object') {
         config = this._merge(config, pkg.entkapp);
       }
     } catch (e) {}
 
-    // 4. Workspace / monorepo packages
-    const workspaceData = await this.loadWorkspaceConfigs();
-    if (workspaceData.packages.length > 0) {
-      config.workspace = true;
-      config.workspacePackages = workspaceData.packages;
-      config.workspaceTsConfigs = workspaceData.tsConfigs;
-      config.workspaceConfigFiles = workspaceData.configFiles;
-      config.monorepoConfigs = workspaceData.monorepoConfigs;
-    }
-
-    // 5. CLI overrides
+    // 4. Apply CLI overrides
     config = this._merge(config, overrides);
 
-    // Final sanity check: ensure arrays exist
-    if (!Array.isArray(config.entryPoints)) config.entryPoints = [];
-    if (!Array.isArray(config.workspacePackages)) config.workspacePackages = [];
-    if (!Array.isArray(config.workspaceTsConfigs)) config.workspaceTsConfigs = [];
-    if (!Array.isArray(config.workspaceConfigFiles)) config.workspaceConfigFiles = [];
-
     return config;
   }
 
-  async loadWorkspaceConfigs() {
-    const result = {
-      packages: [],
-      tsConfigs: [],
-      configFiles: [],
-      monorepoConfigs: {}
-    };
-
-    // Load global configs first
-    const globalConfigs = ['turbo.json', 'nx.json', 'lerna.json'];
-    for (const file of globalConfigs) {
-      try {
-        const content = JSON.parse(await fs.readFile(path.join(this.cwd, file), 'utf8'));
-        result.monorepoConfigs[file] = content;
-      } catch (e) {}
-    }
-
-    const patterns = await this._resolveWorkspacePatterns();
-    if (patterns.length === 0) return result;
-
-    for (const pattern of patterns) {
-      const dirs = await this._expandGlob(pattern);
-      for (const dir of dirs) {
-        await this._readPackageDir(dir, result);
-      }
-    }
-
-    return result;
-  }
-
-  async _resolveWorkspacePatterns() {
-    const pnpmPatterns = await this._parseWorkspaceYaml('pnpm-workspace.yaml');
-    if (pnpmPatterns.length > 0) return pnpmPatterns;
-
-    try {
-      const pkg = JSON.parse(await fs.readFile(path.join(this.cwd, 'package.json'), 'utf8'));
-      if (pkg.workspaces) {
-        return Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages || [];
-      }
-    } catch (e) {}
-
-    try {
-      const lerna = JSON.parse(await fs.readFile(path.join(this.cwd, 'lerna.json'), 'utf8'));
-      if (lerna.packages) return lerna.packages;
-    } catch (e) {}
-
-    return this._parseWorkspaceYaml('workspace.yaml');
-  }
-
-  async _parseWorkspaceYaml(fileName) {
-    const filePath = path.join(this.cwd, fileName);
-    try {
-      const raw = await fs.readFile(filePath, 'utf8');
-      const patterns = [];
-      const lines = raw.split('\n');
-      let inPackages = false;
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#')) continue;
-        if (/^packages\s*:/.test(trimmed)) {
-          inPackages = true;
-          const inlineMatch = trimmed.match(/^packages\s*:\s*\[([^\]]*)\]/);
-          if (inlineMatch) {
-            inPackages = false;
-            for (const item of inlineMatch[1].split(',')) {
-              const val = item.trim().replace(/^['"]|['"]$/g, '');
-              if (val) patterns.push(val);
-            }
-          }
-          continue;
-        }
-        if (inPackages) {
-          if (line.match(/^[a-zA-Z0-9_-]/) && trimmed.endsWith(':')) {
-            inPackages = false;
-            continue;
-          }
-          if (trimmed.startsWith('-')) {
-            const val = trimmed.substring(1).trim().replace(/^['"]|['"]$/g, '');
-            if (val) patterns.push(val);
-          }
-        }
-      }
-      return patterns;
-    } catch (e) {
-      return [];
-    }
-  }
-
-  async _readPackageDir(dir, result) {
-    const normalizedDir = dir.replace(/\\/g, '/');
-    let packageName;
-
-    try {
-      const pkg = JSON.parse(await fs.readFile(path.join(dir, 'package.json'), 'utf8'));
-      packageName = pkg.name;
-      result.packages.push({
-        dir: normalizedDir,
-        name: packageName,
-        entkappConfig: (pkg.entkapp && typeof pkg.entkapp === 'object') ? pkg.entkapp : {}
-      });
-    } catch (e) {
-      // If no package.json, skip as requested in WorkSpaceGraph logic
-      return;
-    }
-
-    // tsconfig.json
-    try {
-      const tsconfigRaw = await fs.readFile(path.join(dir, 'tsconfig.json'), 'utf8');
-      const stripped = tsconfigRaw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
-      result.tsConfigs.push({ dir: normalizedDir, name: packageName, tsconfig: JSON.parse(stripped) });
-    } catch (e) {}
-
-    // *.config.ts / .js
-    try {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isFile() || !/\.config\.(ts|js|mjs|cjs)$/.test(entry.name)) continue;
-        const filePath = path.join(dir, entry.name).replace(/\\/g, '/');
-        try {
-          const content = await fs.readFile(filePath, 'utf8');
-          result.configFiles.push({ dir: normalizedDir, name: packageName, fileName: entry.name, filePath, content });
-        } catch (e) {}
-      }
-    } catch (e) {}
-  }
-
-  async _expandGlob(pattern) {
-    const results = [];
-    const cleanPattern = pattern.replace(/\/$/, '');
-    if (cleanPattern.includes('*')) {
-      const parts = cleanPattern.split('/');
-      const wildcardIndex = parts.findIndex(p => p.includes('*'));
-      const baseDir = path.join(this.cwd, ...parts.slice(0, wildcardIndex));
-      try {
-        const entries = await fs.readdir(baseDir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.isDirectory() && !entry.name.startsWith('.')) {
-            const fullPath = path.join(baseDir, entry.name);
-            try {
-              await fs.access(path.join(fullPath, 'package.json'));
-              results.push(fullPath.replace(/\\/g, '/'));
-            } catch (e) {}
-          }
-        }
-      } catch (e) {}
-    } else {
-      const fullPath = path.resolve(this.cwd, cleanPattern);
-      try {
-        const stat = await fs.stat(fullPath);
-        if (stat.isDirectory()) results.push(fullPath.replace(/\\/g, '/'));
-      } catch (e) {}
-    }
-    return results;
-  }
-
   _defaultConfig() {
     return {
       interface: 'CLI',
       useBuiltinPlugins: true,
       useCustomPlugins: true,
-      options: { verbose: false, fastMode: true, selfHealing: true },
+      options: {
+        verbose: false,
+        fastMode: true,
+        selfHealing: true
+      },
       enabledPlugins: [],
       ignoreDependencies: ['entkapp', '@types/*'],
       exclude: ['node_modules', '.git', 'dist', 'build', 'coverage'],
       entryPoints: [],
-      workspace: false,
-      workspacePackages: [],
-      workspaceTsConfigs: [],
-      workspaceConfigFiles: [],
-      monorepoConfigs: {}
+      workspace: false
     };
   }
 
@@ -245,6 +79,8 @@ export class ConfigLoader {
     for (const key of Object.keys(override)) {
       if (key === 'options' && typeof override[key] === 'object') {
         result.options = { ...(base.options || {}), ...override[key] };
+      } else if (Array.isArray(override[key])) {
+        result[key] = override[key];
       } else {
         result[key] = override[key];
       }