korvet-intellijs 1.0.0

package/README.md

@@ -0,0 +1,3 @@
+# Korvet IntelliJS
+
+Self-debugging and self-optimizing JavaScript execution framework.

package/TODO.md

@@ -0,0 +1,21 @@
+# TODO — Korvet IntelliJS
+
+## Step 1 — Repo alignment (done)
+- Confirm repo is ESM (`type: module`) and fixes are applied via `issue.fix` + `src/fixer.js` called from `bin/kijs.js`.
+- Confirm `src/engine.js` currently runs offline AST rules only.
+
+## Step 2 — Port Step 9 AST self-heal into ESM pipeline (in progress)
+- Update `src/engine.js` to generate additional **fixable issues** from AST:
+  - `var` -> `const` on the declaration line
+  - `==` -> `===` and `!=` -> `!==` on the binary expression line
+  - Remove `console.log/warn/info/debug` lines via `fix: ''`
+  - (Optional) bare `.then()` / `.catch()` heuristic (skip if risky)
+- Ensure `fix` strings are full-line replacements (or empty string for removal) compatible with existing `src/fixer.js`.
+
+
+## Step 3 — Verify fixes
+- Run:
+  - `npm test`
+  - `node bin/kijs.js debug --fix ./test-fixtures/buggy-file.js`
+  - `node bin/kijs.js debug ./test-fixtures/buggy-file.js`
+

package/bin/index.js

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import fs from 'fs-extra';
+import path from 'path';
+import { glob } from 'glob';
+import chalk from 'chalk';
+
+import { loadConfig } from '../src/config.js';
+import { analyzeFile } from '../src/analyzer.js';
+import { debugCode } from '../src/debugger.js';
+import { optimizeCode, applyAutoFixes } from '../src/optimizer.js';
+import { analyzeMemory } from '../src/memory.js';
+import * as reporter from '../src/reporter.js';
+
+const program = new Command();
+
+program
+  .name('kijs')
+  .description('Korvet IntelliJS: AI-powered and AST-driven code intelligence CLI')
+  .version('1.0.0');
+
+// Shared config option
+program.option('-c, --config <path>', 'custom path to korvet.config.js configuration file');
+
+/**
+ * Common helper to gather files to process based on configurations and pattern overrides.
+ */
+async function resolveFiles(config, overridePath = null) {
+  if (overridePath) {
+    const resolved = path.resolve(process.cwd(), overridePath);
+    if (await fs.pathExists(resolved)) {
+      return [path.normalize(resolved)];
+    }
+    
+    // If it is a dynamic path pattern (glob) passed as an override
+    try {
+      const matched = await glob(overridePath, {
+        absolute: true,
+        nodir: true
+      });
+      return matched.map(f => path.normalize(f));
+    } catch (err) {
+      return [];
+    }
+  }
+
+  const include = config.include;
+  const exclude = config.exclude;
+
+  const filesSet = new Set();
+  for (const pattern of include) {
+    try {
+      const matched = await glob(pattern, {
+        ignore: exclude,
+        absolute: true,
+        nodir: true
+      });
+      matched.forEach(f => filesSet.add(path.normalize(f)));
+    } catch (err) {
+      console.error(chalk.red(`[Error] Failed resolving file pattern "${pattern}": ${err.message}`));
+    }
+  }
+  return Array.from(filesSet);
+}
+
+/**
+ * CLI COMMAND: init
+ * Scaffolds a default configuration file if not already present.
+ */
+program
+  .command('init')
+  .description('Initialize default korvet.config.js template in the current directory')
+  .action(async () => {
+    reporter.printHeader();
+    const targetPath = path.resolve(process.cwd(), 'korvet.config.js');
+    
+    if (await fs.pathExists(targetPath)) {
+      console.log(chalk.yellow(`  ⚠ Configuration file already exists at ${targetPath}`));
+      return;
+    }
+
+    const template = `export default {
+  // Gemini API key. If empty, falls back to GEMINI_API_KEY environment variable.
+  apiKey: "",
+
+  // File paths to include in analysis
+  include: ["src/**/*.js", "*.js"],
+
+  // File paths to exclude from analysis
+  exclude: [
+    "node_modules/**",
+    "dist/**",
+    "build/**",
+    "test-fixtures/**",
+    "coverage/**"
+  ],
+
+  // Control module execution
+  modules: {
+    analyzer: true,   // Gemini AI Engine
+    debugger: true,   // Predictive Control-Flow Debugger
+    optimizer: true,  // AST Performance Optimizer
+    memory: true      // AST Memory Leak Check
+  },
+
+  // Minimum reporting severity: "info", "warning", "error"
+  severity: "info"
+};
+`;
+
+    try {
+      await fs.writeFile(targetPath, template, 'utf-8');
+      console.log(chalk.green.bold(`  ✔ Successfully created korvet.config.js default template!`));
+      console.log(chalk.gray(`  Get started by setting your Gemini API key inside it or as an environment variable.`));
+    } catch (err) {
+      console.error(chalk.red(`  ✘ Failed to create configuration template: ${err.message}`));
+    }
+  });
+
+/**
+ * CLI COMMAND: analyze
+ * Runs AI-powered Gemini analysis.
+ */
+program
+  .command('analyze [path]')
+  .description('Execute AI-powered semantic analysis using the Gemini Engine')
+  .action(async (overridePath) => {
+    reporter.printHeader();
+    const options = program.opts();
+    const config = await loadConfig(options.config);
+
+    if (!config.apiKey) {
+      console.log(chalk.red.bold(`  ✘ API Key Missing! Cannot run AI-powered analysis.`));
+      console.log(chalk.gray(`    Define your "apiKey" in korvet.config.js or set a GEMINI_API_KEY env variable.`));
+      process.exit(1);
+    }
+
+    const files = await resolveFiles(config, overridePath);
+    if (files.length === 0) {
+      console.log(chalk.yellow(`  ⚠ No matching files found to analyze.`));
+      return;
+    }
+
+    console.log(chalk.cyan(`  Initiating Gemini Engine for ${files.length} file(s)...`));
+    
+    let totalIssues = [];
+    for (const file of files) {
+      const relative = path.relative(process.cwd(), file);
+      console.log(chalk.gray(`    Scanning ${relative}...`));
+      
+      try {
+        const content = await fs.readFile(file, 'utf-8');
+        const fileIssues = await analyzeFile(relative, content, config.apiKey);
+        
+        // Filter by minimum configured severity
+        const filtered = filterIssues(fileIssues, config.severity);
+        totalIssues.push(...filtered);
+        
+        reporter.reportFileIssues(relative, content, filtered);
+      } catch (err) {
+        console.error(chalk.red(`    ✘ Failed to analyze file ${relative}: ${err.message}`));
+      }
+    }
+
+    reporter.printSummaryDashboard(files.length, totalIssues);
+  });
+
+/**
+ * CLI COMMAND: debug
+ * Runs AST-based control flow predictive debugger.
+ */
+program
+  .command('debug [path]')
+  .description('Perform predictive control-flow and logical bug diagnostics via AST')
+  .action(async (overridePath) => {
+    reporter.printHeader();
+    const options = program.opts();
+    const config = await loadConfig(options.config);
+
+    const files = await resolveFiles(config, overridePath);
+    if (files.length === 0) {
+      console.log(chalk.yellow(`  ⚠ No matching files found to check.`));
+      return;
+    }
+
+    let totalIssues = [];
+    for (const file of files) {
+      const relative = path.relative(process.cwd(), file);
+      try {
+        const content = await fs.readFile(file, 'utf-8');
+        const fileIssues = debugCode(relative, content);
+        const filtered = filterIssues(fileIssues, config.severity);
+        totalIssues.push(...filtered);
+        reporter.reportFileIssues(relative, content, filtered);
+      } catch (err) {
+        console.error(chalk.red(`    ✘ Failed to debug file ${relative}: ${err.message}`));
+      }
+    }
+
+    reporter.printSummaryDashboard(files.length, totalIssues);
+  });
+
+/**
+ * CLI COMMAND: optimize
+ * Runs performance analyzer with optional --fix flag.
+ */
+program
+  .command('optimize [path]')
+  .description('Identify and fix performance bottlenecks, redundant declarations, and unused code')
+  .option('--fix', 'automatically apply clean optimization and variables removals')
+  .action(async (overridePath, cmdOpts) => {
+    reporter.printHeader();
+    const options = program.opts();
+    const config = await loadConfig(options.config);
+
+    const files = await resolveFiles(config, overridePath);
+    if (files.length === 0) {
+      console.log(chalk.yellow(`  ⚠ No matching JS files matched optimization scopes.`));
+      return;
+    }
+
+    let totalIssues = [];
+    for (const file of files) {
+      const relative = path.relative(process.cwd(), file);
+      try {
+        let content = await fs.readFile(file, 'utf-8');
+        const fileIssues = optimizeCode(relative, content);
+        const filtered = filterIssues(fileIssues, config.severity);
+        
+        totalIssues.push(...filtered);
+        reporter.reportFileIssues(relative, content, filtered);
+
+        if (cmdOpts.fix && filtered.length > 0) {
+          console.log(chalk.green(`    Applying auto-fixes for ${relative}...`));
+          await applyAutoFixes(file, content, filtered);
+        }
+      } catch (err) {
+        console.error(chalk.red(`    ✘ Optimization run failed on ${relative}: ${err.message}`));
+      }
+    }
+
+    reporter.printSummaryDashboard(files.length, totalIssues);
+  });
+
+/**
+ * CLI COMMAND: leak-check
+ * Runs memory analyzer.
+ */
+program
+  .command('leak-check [path]')
+  .description('Scan source code to identify memory leaks, uncleaned intervals, and dynamic globals')
+  .action(async (overridePath) => {
+    reporter.printHeader();
+    const options = program.opts();
+    const config = await loadConfig(options.config);
+
+    const files = await resolveFiles(config, overridePath);
+    if (files.length === 0) {
+      console.log(chalk.yellow(`  ⚠ No matching files found to evaluate leaks.`));
+      return;
+    }
+
+    let totalIssues = [];
+    for (const file of files) {
+      const relative = path.relative(process.cwd(), file);
+      try {
+        const content = await fs.readFile(file, 'utf-8');
+        const fileIssues = analyzeMemory(relative, content);
+        const filtered = filterIssues(fileIssues, config.severity);
+        totalIssues.push(...filtered);
+        reporter.reportFileIssues(relative, content, filtered);
+      } catch (err) {
+        console.error(chalk.red(`    ✘ Leak-check execution failed on ${relative}: ${err.message}`));
+      }
+    }
+
+    reporter.printSummaryDashboard(files.length, totalIssues);
+  });
+
+/**
+ * CLI COMMAND: scan
+ * Runs ALL modules sequentially.
+ */
+program
+  .command('scan [path]')
+  .description('Run full analysis suite (AI + AST debugging, optimizations, and leak audits)')
+  .option('--fix', 'auto-fix performance issues, unused codes, and clearable patterns')
+  .action(async (overridePath, cmdOpts) => {
+    reporter.printHeader();
+    const options = program.opts();
+    const config = await loadConfig(options.config);
+
+    const files = await resolveFiles(config, overridePath);
+    if (files.length === 0) {
+      console.log(chalk.yellow(`  ⚠ No matching files found to scan.`));
+      return;
+    }
+
+    // Friendly API Key check to prevent analyzer failures while letting other modules proceed
+    let runAnalyzer = config.modules.analyzer;
+    if (runAnalyzer && !config.apiKey) {
+      console.log(chalk.yellow(`  ⚠ [Config Warning] Gemini API key not found. Skipping AI-powered semantic analysis.\n` + 
+                                `    Set GEMINI_API_KEY inside korvet.config.js or environment to enable AI rules.`));
+      runAnalyzer = false;
+    }
+
+    let totalIssues = [];
+    for (const file of files) {
+      const relative = path.relative(process.cwd(), file);
+      console.log(chalk.cyan(`\n  Scanning ${relative}...`));
+      
+      try {
+        let content = await fs.readFile(file, 'utf-8');
+        let fileIssues = [];
+
+        // 1. Gemini Engine
+        if (runAnalyzer) {
+          try {
+            console.log(chalk.gray(`    - Querying Gemini AI Analyzer...`));
+            const aiIssues = await analyzeFile(relative, content, config.apiKey);
+            fileIssues.push(...aiIssues);
+          } catch (aiErr) {
+            console.warn(chalk.yellow(`    ⚠ AI Analyzer failed on this file: ${aiErr.message}`));
+          }
+        }
+
+        // 2. Control Flow Debugger
+        if (config.modules.debugger) {
+          const debugIssues = debugCode(relative, content);
+          fileIssues.push(...debugIssues);
+        }
+
+        // 3. Performance Optimizer
+        if (config.modules.optimizer) {
+          const optIssues = optimizeCode(relative, content);
+          fileIssues.push(...optIssues);
+        }
+
+        // 4. Memory Leak Auditor
+        if (config.modules.memory) {
+          const memIssues = analyzeMemory(relative, content);
+          fileIssues.push(...memIssues);
+        }
+
+        // Filter and display
+        const filtered = filterIssues(fileIssues, config.severity);
+        totalIssues.push(...filtered);
+        reporter.reportFileIssues(relative, content, filtered);
+
+        // Apply auto-fixes if requested and applicable
+        if (cmdOpts.fix && filtered.length > 0) {
+          console.log(chalk.green(`    Applying auto-fixes for ${relative}...`));
+          const fixedContent = await applyAutoFixes(file, content, filtered);
+          content = fixedContent; // Refresh contents
+        }
+      } catch (err) {
+        console.error(chalk.red(`    ✘ Processing failed on ${relative}: ${err.message}`));
+      }
+    }
+
+    reporter.printSummaryDashboard(files.length, totalIssues);
+  });
+
+/**
+ * Filters issues array based on the configured minimum severity.
+ */
+function filterIssues(issues, minSeverity = 'info') {
+  const levels = { info: 1, warning: 2, error: 3 };
+  const minVal = levels[minSeverity.toLowerCase()] || 1;
+
+  return issues.filter(issue => {
+    const issueVal = levels[(issue.severity || 'info').toLowerCase()] || 1;
+    return issueVal >= minVal;
+  });
+}
+
+// Start processing CLI instructions
+program.parse(process.argv);