devintelligence 0.0.0-stage → 1.0.1

package/bin/devintelligence.ts

@@ -0,0 +1,416 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import {
+  getAllProjectReports,
+  getProjectReportById,
+  registerLocalProject,
+  applyAllSafeRepairsOnDisk,
+  MCP_TOOLS_CATALOG,
+  executeMcpToolCall,
+} from '../src/engine/repairEngine.ts';
+import {
+  inspectHostEnvironment,
+  PRESET_ERROR_LOGS,
+} from '../src/engine/analyzerEngine.ts';
+import {
+  diagnoseRawErrorLogWithAi,
+  generateProjectAiAdvice,
+  askDevIntelligenceAi,
+  getGroqApiKey,
+} from '../src/engine/aiEngine.ts';
+
+// Load environment variables (.env in cwd or root)
+try {
+  if (typeof process.loadEnvFile === 'function') {
+    const cwdEnv = path.join(process.cwd(), '.env');
+    if (fs.existsSync(cwdEnv)) {
+      process.loadEnvFile(cwdEnv);
+    } else {
+      process.loadEnvFile();
+    }
+  }
+} catch {}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootWorkspaceDir = path.resolve(__dirname, '..');
+
+// Terminal ANSI Styling Helpers
+const isColorSupported =
+  !process.env.NO_COLOR &&
+  (Boolean(process.stdout?.isTTY) || process.env.FORCE_COLOR !== undefined);
+
+const c = {
+  reset: (s: string | number) => (isColorSupported ? `\x1b[0m${s}\x1b[0m` : String(s)),
+  bold: (s: string | number) => (isColorSupported ? `\x1b[1m${s}\x1b[22m` : String(s)),
+  dim: (s: string | number) => (isColorSupported ? `\x1b[2m${s}\x1b[22m` : String(s)),
+  cyan: (s: string | number) => (isColorSupported ? `\x1b[36m${s}\x1b[39m` : String(s)),
+  blue: (s: string | number) => (isColorSupported ? `\x1b[34m${s}\x1b[39m` : String(s)),
+  green: (s: string | number) => (isColorSupported ? `\x1b[32m${s}\x1b[39m` : String(s)),
+  yellow: (s: string | number) => (isColorSupported ? `\x1b[33m${s}\x1b[39m` : String(s)),
+  red: (s: string | number) => (isColorSupported ? `\x1b[31m${s}\x1b[39m` : String(s)),
+  magenta: (s: string | number) => (isColorSupported ? `\x1b[35m${s}\x1b[39m` : String(s)),
+  gray: (s: string | number) => (isColorSupported ? `\x1b[90m${s}\x1b[39m` : String(s)),
+  bgBlue: (s: string | number) => (isColorSupported ? `\x1b[44m\x1b[37m ${s} \x1b[49m\x1b[39m` : `[${s}]`),
+  bgCyan: (s: string | number) => (isColorSupported ? `\x1b[46m\x1b[30m ${s} \x1b[49m\x1b[39m` : `[${s}]`),
+  bgGreen: (s: string | number) => (isColorSupported ? `\x1b[42m\x1b[30m ${s} \x1b[49m\x1b[39m` : `[${s}]`),
+  bgRed: (s: string | number) => (isColorSupported ? `\x1b[41m\x1b[37m ${s} \x1b[49m\x1b[39m` : `[${s}]`),
+  bgMagenta: (s: string | number) => (isColorSupported ? `\x1b[45m\x1b[37m ${s} \x1b[49m\x1b[39m` : `[${s}]`),
+};
+
+function formatScore(score: number): string {
+  if (score >= 80) return c.green(c.bold(`${score}/100`));
+  if (score >= 60) return c.yellow(c.bold(`${score}/100`));
+  return c.red(c.bold(`${score}/100`));
+}
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let data = '';
+    const timer = setTimeout(() => {
+      process.stdin.pause();
+      resolve(data.trim());
+    }, 300);
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      resolve(data.trim());
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timer);
+      resolve(data.trim());
+    });
+  });
+}
+
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+
+// Extract target project or path:
+// 1. --project=<id_or_path>
+// 2. positional argument after command (e.g. `devintelligence scan .` or `devintelligence scan /path`)
+// 3. Defaults to current working directory (process.cwd())!
+const explicitProject =
+  args.find((a) => a.startsWith('--project='))?.split('=')[1] ||
+  args.find((a) => !a.startsWith('-') && a !== command);
+
+const projectArg = explicitProject || process.cwd();
+const isCi = args.includes('--ci');
+
+async function runCli() {
+  switch (command) {
+    case 'init': {
+      const cwd = process.cwd();
+      const projectName = path.basename(cwd);
+      console.log(`\n${c.bgCyan(' DEVINTELLIGENCE INITIALIZATION ')}`);
+      console.log(`${c.dim('Initializing workspace configuration in:')} ${c.bold(cwd)}`);
+
+      const report = registerLocalProject({
+        name: projectName,
+        rootPath: cwd,
+        baseWorkspaceDir: rootWorkspaceDir,
+      });
+
+      console.log(`\n${c.green(c.bold('✔ [SUCCESS] Project Registered:'))} ${c.bold(report.name)}`);
+      console.log(`  ${c.cyan('Ecosystem:')} ${report.ecosystem} | ${c.cyan('Framework:')} ${report.launchDoctor.frameworkName}`);
+      console.log(`  ${c.cyan('Package Manager:')} ${report.launchDoctor.packageManager} | ${c.cyan('Workflow:')} ${report.launchDoctor.workflowType}`);
+      console.log(`  ${c.cyan('Files Analyzed:')} ${report.filesAnalyzed.length}`);
+      console.log(`  ${c.cyan('Health Scores:')} Overall ${formatScore(report.scores.overall)} | Quality ${formatScore(report.scores.codeQuality)} | Security ${formatScore(report.scores.security)}`);
+      console.log(`  ${c.cyan('Issues Found:')} ${report.issues.length} (${report.issues.filter((i) => i.repairTier === 'SAFE').length} SAFE auto-repairable)`);
+      console.log(`  ${c.cyan('Recommended Launch:')} ${c.bold(report.launchDoctor.recommendedStartCommand)}`);
+      console.log(`\nRun ${c.cyan('devintelligence scan')} or ${c.cyan('devintelligence fix')} to inspect and auto-repair.`);
+      break;
+    }
+
+    case 'doctor': {
+      console.log(`\n${c.bgBlue(' DEVINTELLIGENCE ENVIRONMENT DOCTOR ')}`);
+      console.log(`${c.dim('Inspecting Node, Package Managers, React Native, Android & iOS Native Runtimes...\n')}`);
+      const checks = inspectHostEnvironment(true);
+      for (const ch of checks) {
+        let tag = c.green(c.bold('✔ [WORKING]      '));
+        if (ch.status === 'not_installed') tag = c.red(c.bold('✖ [MISSING]      '));
+        if (ch.status === 'incompatible') tag = c.red(c.bold('✖ [INCOMPATIBLE] '));
+        if (ch.status === 'misconfigured') tag = c.yellow(c.bold('⚠ [MISCONFIGURED]'));
+        if (ch.status === 'os_unsupported') tag = c.gray('• [OS UNSUPPORTED]');
+
+        const nameCol = ch.name.padEnd(30);
+        const verCol = ch.detectedVersion || 'Not found';
+        console.log(`${tag} ${c.bold(nameCol)} ${verCol} ${c.dim(`(Req: ${ch.requiredVersion})`)}`);
+        if (ch.status !== 'working' && ch.remediationCommand) {
+          console.log(`  ${c.cyan('➜ Fix Command:')} ${c.bold(ch.remediationCommand)}`);
+        }
+      }
+      break;
+    }
+
+    case 'scan': {
+      const report = getProjectReportById(projectArg, true, rootWorkspaceDir);
+      console.log(`\n${c.bgCyan(` DEVINTELLIGENCE SCAN: ${report.name} `)}`);
+      console.log(`${c.cyan('Root Path:')} ${c.dim(report.rootPath)}`);
+      console.log(`${c.cyan('Ecosystem:')} ${report.ecosystem} | ${c.cyan('Framework:')} ${report.launchDoctor.frameworkName}`);
+      console.log(`${c.cyan('Files Analyzed:')} ${report.filesAnalyzed.length} | ${c.cyan('Scan Time:')} ${report.scanDurationMs}ms`);
+
+      console.log(`\n${c.bold('Scores:')}`);
+      console.log(`  - Overall Health:  ${formatScore(report.scores.overall)}`);
+      console.log(`  - React Native:    ${formatScore(report.scores.reactNative)}`);
+      console.log(`  - Code Quality:    ${formatScore(report.scores.codeQuality)}`);
+      console.log(`  - Design Tokens:   ${formatScore(report.scores.designQuality)}`);
+      console.log(`  - Performance:     ${formatScore(report.scores.performance)}`);
+      console.log(`  - Security Audit:  ${formatScore(report.scores.security)}`);
+
+      const safeIssues = report.issues.filter((i) => i.repairTier === 'SAFE');
+      const reviewIssues = report.issues.filter((i) => i.repairTier === 'REVIEW_REQUIRED');
+      const criticalIssues = report.issues.filter((i) => i.severity === 'critical');
+
+      console.log(`\n${c.bold('Issues Summary:')} ${report.issues.length} detected`);
+      console.log(`  - Critical:        ${criticalIssues.length > 0 ? c.red(c.bold(criticalIssues.length)) : c.green(0)}`);
+      console.log(`  - SAFE Auto-Fix:   ${safeIssues.length > 0 ? c.yellow(c.bold(safeIssues.length)) : 0}`);
+      console.log(`  - Review Required: ${reviewIssues.length}`);
+
+      if (report.issues.length > 0) {
+        console.log(`\n${c.bold('Top Findings:')}`);
+        report.issues.slice(0, 5).forEach((issue, idx) => {
+          const sevColor = issue.severity === 'critical' ? c.red : issue.severity === 'high' ? c.yellow : c.cyan;
+          console.log(`  ${idx + 1}. [${sevColor(issue.severity.toUpperCase())}] ${c.bold(issue.title)}`);
+          console.log(`     File: ${c.dim(`${issue.filePath}:${issue.line}`)} (${issue.repairTier === 'SAFE' ? c.green('SAFE Auto-Repair') : c.yellow('Review Required')})`);
+        });
+      }
+
+      const gatePass = report.qualityGateEvaluation.passed;
+      console.log(`\n${c.bold('Quality Gate:')} ${gatePass ? c.bgGreen(' PASSED ✅ ') : c.bgRed(' FAILED ❌ ')}`);
+      if (!gatePass) {
+        const failedChecks = (report.qualityGateEvaluation.checks || [])
+          .filter((ch) => !ch.passed)
+          .map((ch) => `${ch.name} (Actual: ${ch.actual} vs Required: ${ch.threshold})`);
+        console.log(`  ${c.red('Violations:')} ${failedChecks.join('; ')}`);
+      }
+
+      if (isCi) {
+        process.exit(report.qualityGateEvaluation.exitCode);
+      }
+      break;
+    }
+
+    case 'diagnose': {
+      let customLog = '';
+
+      // 1. Check for --file=<path> or positional string arguments first
+      const fileFlag = args.find((a) => a.startsWith('--file='))?.split('=')[1];
+      const positionalWords = args.slice(1).filter((a) => !a.startsWith('-'));
+      const candidate = fileFlag || (positionalWords.length > 0 ? positionalWords.join(' ') : '');
+
+      if (candidate) {
+        const candidatePath = path.resolve(process.cwd(), candidate);
+        if (fs.existsSync(candidatePath) && fs.statSync(candidatePath).isFile()) {
+          try {
+            customLog = fs.readFileSync(candidatePath, 'utf8');
+            console.log(`${c.dim('[Reading error log from file:]')} ${c.bold(candidatePath)}`);
+          } catch {}
+        } else {
+          customLog = candidate;
+        }
+      }
+
+      // 2. Check if input is piped into stdin (only if no arguments were passed)
+      if (!customLog && !process.stdin.isTTY) {
+        try {
+          customLog = await readStdin();
+        } catch {}
+      }
+
+      // 3. Auto-detect recent project error logs
+      if (!customLog) {
+        const commonLogFiles = ['npm-debug.log', 'yarn-error.log', 'metro.log', 'error.log', 'build.log'];
+        for (const logFile of commonLogFiles) {
+          const fullPath = path.join(process.cwd(), logFile);
+          if (fs.existsSync(fullPath)) {
+            try {
+              const content = fs.readFileSync(fullPath, 'utf8').trim();
+              if (content.length > 20) {
+                console.log(`${c.cyan(`[Auto-Detected Log File: ${logFile}]`)}`);
+                customLog = content;
+                break;
+              }
+            } catch {}
+          }
+        }
+      }
+
+      const isPresetDemo = !customLog;
+      if (isPresetDemo) {
+        customLog = PRESET_ERROR_LOGS[0].rawLog;
+        console.log(`\n${c.yellow(c.bold('ℹ [NOTICE]'))} No error trace provided via argument, file, or stdin pipe.`);
+        console.log(`${c.dim('To diagnose real errors in your project:')}`);
+        console.log(`  ${c.cyan('devintelligence diagnose "Error: <your stack trace>"')}`);
+        console.log(`  ${c.cyan('devintelligence diagnose ./error.log')}`);
+        console.log(`  ${c.cyan('npm test 2>&1 | devintelligence diagnose')}\n`);
+        console.log(`${c.dim('--- Running diagnosis on sample preset error log for demonstration ---')}`);
+      }
+
+      console.log(`\n${c.bgMagenta(' DEVINTELLIGENCE ERROR DIAGNOSTICS ')}`);
+      const apiKey = getGroqApiKey();
+      if (!apiKey) {
+        console.log(`${c.dim('[AI Engine Note: Set GROQ_API_KEY environment variable to enable Qwen-27B cloud acceleration. Using local zero-downtime heuristic rule engine.]')}\n`);
+      } else {
+        console.log(`${c.dim('Analyzing error trace with Groq AI (with zero-downtime heuristic shield)...\n')}`);
+      }
+
+      const diag = await diagnoseRawErrorLogWithAi(customLog);
+
+      if (diag.aiPowered) {
+        console.log(`${c.magenta(c.bold(`[AI-Powered: Groq ${diag.aiModel || 'Qwen 27B'}]`))} Confidence: ${c.bold(`${diag.confidence}%`)}`);
+      } else {
+        console.log(`${c.blue(c.bold('[Local Rule Engine - Zero Downtime Fallback]'))} Confidence: ${c.bold(`${diag.confidence}%`)}`);
+        if (diag.fallbackReason) {
+          console.log(`Note: ${c.dim(diag.fallbackReason)}`);
+        }
+      }
+
+      console.log(`Category:        ${c.bold(diag.category)}`);
+      console.log(`Severity:        ${diag.severity === 'critical' ? c.red(c.bold('CRITICAL')) : c.yellow(diag.severity.toUpperCase())}`);
+      console.log(`Summary:         ${c.bold(diag.summary)}`);
+      console.log(`Root Cause:      ${diag.rootCause}`);
+      console.log(`Responsible:     ${c.cyan(diag.responsibleFile)}${diag.line ? `:${diag.line}` : ''}`);
+
+      if (diag.safeRepairSteps?.length) {
+        console.log(`\n${c.bold('Recommended Safe Repair Steps:')}`);
+        diag.safeRepairSteps.forEach((s, idx) => console.log(`  ${idx + 1}. ${s}`));
+      }
+
+      if (diag.terminalCommands?.length) {
+        console.log(`\n${c.bold('Exact Terminal Commands:')}`);
+        diag.terminalCommands.forEach((cmd) => console.log(`  $ ${c.cyan(c.bold(cmd))}`));
+      }
+
+      if (diag.codePatchSuggestion) {
+        console.log(`\n${c.bold('Suggested Configuration / Code Patch:')}`);
+        console.log(c.dim(diag.codePatchSuggestion));
+      }
+      break;
+    }
+
+    case 'fix': {
+      console.log(`\n${c.bgGreen(' DEVINTELLIGENCE AUTO-REPAIR CENTER ')}`);
+      console.log(`Applying validated SAFE fixes on project '${c.bold(projectArg)}'...`);
+      const res = applyAllSafeRepairsOnDisk(projectArg, rootWorkspaceDir);
+      console.log(`\n${c.green(c.bold(`[COMPLETED] Applied ${res.appliedRepairs.length} SAFE repair(s).`))}`);
+      res.appliedRepairs.forEach((r, idx) => {
+        console.log(`  ${idx + 1}. Fixed: ${c.bold(r.issueTitle)}`);
+        console.log(`     Target: ${c.dim(r.filePath)} (Backup saved in .devintelligence/backups/)`);
+      });
+      console.log(`\n${c.bold('Post-Repair Re-Scan:')}`);
+      console.log(`  Overall Score: ${formatScore(res.updatedReport.scores.overall)}`);
+      console.log(`  Remaining Issues: ${res.updatedReport.issues.length}`);
+      break;
+    }
+
+    case 'dashboard':
+    case 'ui': {
+      console.log(`\n${c.bgCyan(' LAUNCHING DEVINTELLIGENCE WORKSTATION ')}`);
+      console.log(`Starting local server at ${c.bold('http://localhost:3000')} ...`);
+      const serverScript = path.join(rootWorkspaceDir, 'server.ts');
+      const child = spawn(process.execPath, [serverScript], {
+        cwd: rootWorkspaceDir,
+        stdio: 'inherit',
+      });
+      child.on('error', (err) => {
+        console.error('Failed to start workstation server:', err);
+      });
+      break;
+    }
+
+    case 'advice': {
+      const report = getProjectReportById(projectArg, false, rootWorkspaceDir);
+      console.log(`\nGenerating AI Executive Advice for '${c.bold(report.name)}'...`);
+      const res = await generateProjectAiAdvice(report);
+      console.log(`\n${c.bgBlue(' DEVINTELLIGENCE EXECUTIVE ADVICE ')}`);
+      console.log(res.aiPowered ? c.magenta(`[Powered by Groq AI - ${res.model || 'Qwen 27B'}]`) : c.blue(`[Local Rule Fallback]`));
+      console.log(res.advice);
+      break;
+    }
+
+    case 'ai': {
+      const query = args.slice(1).join(' ');
+      if (!query) {
+        console.log(`Usage: ${c.cyan('devintelligence ai "your question or build error here"')}`);
+        break;
+      }
+      console.log(`\nAsking DEVINTELLIGENCE AI: "${c.bold(query)}"...`);
+      const res = await askDevIntelligenceAi(query);
+      console.log(`\n${c.bgMagenta(' AI ASSISTANT ANSWER ')}`);
+      console.log(res.answer);
+      break;
+    }
+
+    case 'test': {
+      console.log(`\n${c.bgCyan(' RUNNING DEVINTELLIGENCE SELF-TESTING SUITE ')}`);
+      const child = spawn(process.execPath, ['--test', 'src/engine/analyzerEngine.test.ts', 'src/engine/aiEngine.test.ts'], {
+        cwd: rootWorkspaceDir,
+        stdio: 'inherit',
+      });
+      child.on('exit', (code) => {
+        process.exit(code ?? 0);
+      });
+      break;
+    }
+
+    case 'report': {
+      const report = getProjectReportById(projectArg, false, rootWorkspaceDir);
+      console.log(JSON.stringify(report, null, 2));
+      break;
+    }
+
+    case 'mcp': {
+      console.log(
+        JSON.stringify(
+          {
+            status: 'online',
+            server: 'DEVINTELLIGENCE Local MCP Server',
+            tools: MCP_TOOLS_CATALOG,
+          },
+          null,
+          2
+        )
+      );
+      break;
+    }
+
+    default:
+      console.log(`
+${c.cyan(c.bold('DEVINTELLIGENCE'))} — Personal Software Engineering Intelligence System
+${c.dim('Understand. Diagnose. Repair. Optimize.')}
+
+${c.bold('Usage:')} ${c.cyan('devintelligence <command> [options]')}
+
+${c.bold('Commands:')}
+  ${c.cyan('init')}                     Register and initialize current directory as a project
+  ${c.cyan('doctor')}                   Audit host runtimes (Node, Expo, Android SDK, Gradle, CocoaPods, Xcode)
+  ${c.cyan('scan')} [path]              Deep AST code audit, quality scores & Quality Gate check (default: current dir)
+  ${c.cyan('diagnose')} [log|file]      AI-first error trace diagnosis with guaranteed rule fallback
+  ${c.cyan('fix')} [path]               Apply all validated SAFE auto-repairs on disk with backup
+  ${c.cyan('dashboard')}                Launch desktop engineering workstation on http://localhost:3000
+  ${c.cyan('advice')} [path]            Generate AI executive engineering brief & prioritized action plan
+  ${c.cyan('ai')} "<question>"          Ask AI assistant technical questions about code or native builds
+  ${c.cyan('report')} [path]            Output full machine-readable JSON project report
+  ${c.cyan('test')}                     Run multi-ecosystem verification test suite
+  ${c.cyan('mcp')}                      Inspect available Model Context Protocol tools
+
+${c.bold('Options:')}
+  ${c.cyan('--project=<path|id>')}      Specify target project directory or ID (default: current directory)
+  ${c.cyan('--file=<path>')}            Specify file path to read error log from in diagnose
+  ${c.cyan('--ci')}                     Return proper exit code based on Quality Gate (0 for pass, 1 for fail)
+`);
+  }
+}
+
+runCli().catch((err) => {
+  console.error('Fatal CLI Error:', err);
+  process.exit(1);
+});

package/dist/App.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare function App(): React.JSX.Element;
+export default App;