devintelligence 1.0.0 → 1.0.1

package/src/engine/repairEngine.ts

@@ -1,545 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import type {
-  DiagnosticIssue,
-  ProjectIntelligenceReport,
-  QualityGateConfig,
-  RepairRecord,
-  ScanSnapshot,
-} from '../types/devintelligence.ts';
-import {
-  analyzeProjectDirectory,
-  diagnoseRawErrorLog,
-  inspectHostEnvironment,
-} from './analyzerEngine.ts';
-
-interface WorkspaceProjectMeta {
-  id: string;
-  name: string;
-  rootPath: string;
-  qualityGateConfig: QualityGateConfig;
-  repairHistory: RepairRecord[];
-  scanHistory: ScanSnapshot[];
-}
-
-const DEFAULT_GATE_CONFIG: QualityGateConfig = {
-  minCodeQuality: 80,
-  minDesignQuality: 80,
-  minPerformanceScore: 80,
-  maxCriticalIssues: 0,
-  maxSecurityIssues: 0,
-  requireBuildVerification: true,
-};
-
-const WORKSPACE_PROJECTS = new Map<string, WorkspaceProjectMeta>();
-const CACHED_REPORTS = new Map<string, ProjectIntelligenceReport>();
-
-export function initializeWorkspaceRegistry(baseWorkspaceDir = process.cwd()): void {
-  if (WORKSPACE_PROJECTS.size > 0) return;
-
-  const initialFixtures: { id: string; name: string; relPath: string }[] = [
-    {
-      id: 'rn-expo-commerce',
-      name: 'ExpoCommerceMobile (React Native + Expo SDK 52)',
-      relPath: 'fixtures/rn-expo-commerce',
-    },
-    {
-      id: 'rn-bare-fitness',
-      name: 'BareFitnessPro (Bare React Native 0.74 CLI)',
-      relPath: 'fixtures/rn-bare-fitness',
-    },
-    {
-      id: 'nextjs-saas-portal',
-      name: 'NextJS Billing Portal (Next.js 14 App Router)',
-      relPath: 'fixtures/nextjs-saas-portal',
-    },
-    {
-      id: 'express-api-gateway',
-      name: 'Express API Gateway (Node.js + PostgreSQL)',
-      relPath: 'fixtures/express-api-gateway',
-    },
-    {
-      id: 'django-analytics-service',
-      name: 'Django Analytics Service (Python + DRF)',
-      relPath: 'fixtures/django-analytics-service',
-    },
-  ];
-
-  for (const item of initialFixtures) {
-    const absPath = path.resolve(baseWorkspaceDir, item.relPath);
-    if (fs.existsSync(absPath)) {
-      WORKSPACE_PROJECTS.set(item.id, {
-        id: item.id,
-        name: item.name,
-        rootPath: absPath,
-        qualityGateConfig: { ...DEFAULT_GATE_CONFIG },
-        repairHistory: [],
-        scanHistory: [],
-      });
-    }
-  }
-}
-
-export function getAllProjectReports(baseWorkspaceDir = process.cwd()): ProjectIntelligenceReport[] {
-  initializeWorkspaceRegistry(baseWorkspaceDir);
-  const reports: ProjectIntelligenceReport[] = [];
-  for (const meta of WORKSPACE_PROJECTS.values()) {
-    let report = CACHED_REPORTS.get(meta.id);
-    if (!report) {
-      report = analyzeProjectDirectory(
-        meta.id,
-        meta.name,
-        meta.rootPath,
-        meta.qualityGateConfig,
-        meta.repairHistory,
-        meta.scanHistory
-      );
-      meta.scanHistory = report.scanHistory;
-      CACHED_REPORTS.set(meta.id, report);
-    }
-    reports.push(report);
-  }
-  return reports;
-}
-
-export function getProjectReportById(
-  projectId: string,
-  forceRescan = false,
-  baseWorkspaceDir = process.cwd()
-): ProjectIntelligenceReport {
-  initializeWorkspaceRegistry(baseWorkspaceDir);
-  const meta = WORKSPACE_PROJECTS.get(projectId) || Array.from(WORKSPACE_PROJECTS.values())[0];
-  if (!meta) {
-    throw new Error(`Project "${projectId}" not found in workspace registry.`);
-  }
-
-  if (forceRescan || !CACHED_REPORTS.has(meta.id)) {
-    const fresh = analyzeProjectDirectory(
-      meta.id,
-      meta.name,
-      meta.rootPath,
-      meta.qualityGateConfig,
-      meta.repairHistory,
-      meta.scanHistory
-    );
-    meta.scanHistory = fresh.scanHistory;
-    CACHED_REPORTS.set(meta.id, fresh);
-    return fresh;
-  }
-
-  return CACHED_REPORTS.get(meta.id)!;
-}
-
-export function registerLocalProject(params: {
-  name: string;
-  rootPath: string;
-  baseWorkspaceDir?: string;
-}): ProjectIntelligenceReport {
-  const baseDir = params.baseWorkspaceDir || process.cwd();
-  initializeWorkspaceRegistry(baseDir);
-
-  const resolvedPath = path.isAbsolute(params.rootPath)
-    ? params.rootPath
-    : path.resolve(baseDir, params.rootPath);
-
-  if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) {
-    throw new Error(`Directory does not exist on local filesystem: ${resolvedPath}`);
-  }
-
-  const slug = params.name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-|-$/g, '') || `project-${Date.now()}`;
-
-  const meta: WorkspaceProjectMeta = {
-    id: slug,
-    name: params.name.trim(),
-    rootPath: resolvedPath,
-    qualityGateConfig: { ...DEFAULT_GATE_CONFIG },
-    repairHistory: [],
-    scanHistory: [],
-  };
-
-  WORKSPACE_PROJECTS.set(slug, meta);
-  return getProjectReportById(slug, true, baseDir);
-}
-
-export function updateProjectQualityGate(
-  projectId: string,
-  newConfig: Partial<QualityGateConfig>,
-  baseWorkspaceDir = process.cwd()
-): ProjectIntelligenceReport {
-  initializeWorkspaceRegistry(baseWorkspaceDir);
-  const meta = WORKSPACE_PROJECTS.get(projectId);
-  if (!meta) {
-    throw new Error(`Project "${projectId}" not found.`);
-  }
-
-  meta.qualityGateConfig = {
-    ...meta.qualityGateConfig,
-    ...newConfig,
-  };
-
-  return getProjectReportById(projectId, true, baseWorkspaceDir);
-}
-
-export function applyIssueRepairOnDisk(params: {
-  projectId: string;
-  issueId: string;
-  allowReviewTier?: boolean;
-  baseWorkspaceDir?: string;
-}): {
-  repairRecord: RepairRecord;
-  updatedReport: ProjectIntelligenceReport;
-} {
-  const baseDir = params.baseWorkspaceDir || process.cwd();
-  const report = getProjectReportById(params.projectId, true, baseDir);
-  const meta = WORKSPACE_PROJECTS.get(report.id)!;
-
-  const issue = report.issues.find((i) => i.id === params.issueId);
-  if (!issue) {
-    throw new Error(`Issue "${params.issueId}" not found or already resolved.`);
-  }
-  if (!issue.fixAvailable) {
-    throw new Error(`Issue "${issue.title}" requires manual architectural intervention and cannot be auto-patched.`);
-  }
-  if (issue.repairTier !== 'SAFE' && !params.allowReviewTier) {
-    throw new Error(
-      `Issue "${issue.title}" has tier ${issue.repairTier}. Explicit developer approval (allowReviewTier) is required.`
-    );
-  }
-
-  const targetFullPath = path.join(meta.rootPath, issue.filePath);
-  if (!fs.existsSync(targetFullPath)) {
-    throw new Error(`Target file not found on disk: ${targetFullPath}`);
-  }
-
-  const originalContent = fs.readFileSync(targetFullPath, 'utf8');
-  if (!originalContent.includes(issue.beforeSnippet)) {
-    throw new Error(
-      `Target code snippet in ${issue.filePath} has diverged from scan state. Re-scan project before repairing.`
-    );
-  }
-
-  // Create real backup snapshot on disk
-  const backupDir = path.join(baseDir, '.devintelligence', 'backups', meta.id);
-  fs.mkdirSync(backupDir, { recursive: true });
-  const repairId = `repair-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-  const backupPath = path.join(backupDir, `${repairId}.bak`);
-  fs.writeFileSync(backupPath, originalContent, 'utf8');
-
-  // Apply safe transformation
-  const updatedContent = originalContent.replace(issue.beforeSnippet, issue.afterSnippet);
-  fs.writeFileSync(targetFullPath, updatedContent, 'utf8');
-
-  const record: RepairRecord = {
-    id: repairId,
-    projectId: meta.id,
-    issueId: issue.id,
-    issueTitle: issue.title,
-    filePath: issue.filePath,
-    repairTier: issue.repairTier,
-    appliedAt: new Date().toISOString(),
-    backupPath,
-    rolledBack: false,
-    verifiedAfterFix: true,
-    unifiedDiff: issue.unifiedDiff,
-  };
-
-  meta.repairHistory = [record, ...meta.repairHistory];
-
-  // Re-scan project after repair to verify fix
-  const updatedReport = getProjectReportById(meta.id, true, baseDir);
-  const stillPresent = updatedReport.issues.some((i) => i.id === issue.id);
-  record.verifiedAfterFix = !stillPresent;
-
-  return {
-    repairRecord: record,
-    updatedReport,
-  };
-}
-
-export function applyAllSafeRepairsOnDisk(
-  projectId: string,
-  baseWorkspaceDir = process.cwd()
-): {
-  appliedRepairs: RepairRecord[];
-  updatedReport: ProjectIntelligenceReport;
-} {
-  let currentReport = getProjectReportById(projectId, true, baseWorkspaceDir);
-  const safeIssues = currentReport.issues.filter(
-    (i: DiagnosticIssue) => i.fixAvailable && i.repairTier === 'SAFE'
-  );
-
-  const appliedRepairs: RepairRecord[] = [];
-  for (const issue of safeIssues) {
-    try {
-      const res = applyIssueRepairOnDisk({
-        projectId,
-        issueId: issue.id,
-        allowReviewTier: false,
-        baseWorkspaceDir,
-      });
-      appliedRepairs.push(res.repairRecord);
-      currentReport = res.updatedReport;
-    } catch {
-      // continue if two patches touch overlapping lines
-    }
-  }
-
-  return {
-    appliedRepairs,
-    updatedReport: getProjectReportById(projectId, true, baseWorkspaceDir),
-  };
-}
-
-export function rollbackRepairOnDisk(params: {
-  projectId: string;
-  repairId: string;
-  baseWorkspaceDir?: string;
-}): {
-  restoredRecord: RepairRecord;
-  updatedReport: ProjectIntelligenceReport;
-} {
-  const baseDir = params.baseWorkspaceDir || process.cwd();
-  initializeWorkspaceRegistry(baseDir);
-  const meta = WORKSPACE_PROJECTS.get(params.projectId);
-  if (!meta) {
-    throw new Error(`Project "${params.projectId}" not found.`);
-  }
-
-  const record = meta.repairHistory.find((r) => r.id === params.repairId);
-  if (!record) {
-    throw new Error(`Repair record "${params.repairId}" not found.`);
-  }
-  if (record.rolledBack) {
-    throw new Error(`Repair "${params.repairId}" has already been rolled back.`);
-  }
-  if (!fs.existsSync(record.backupPath)) {
-    throw new Error(`Backup snapshot file missing at ${record.backupPath}`);
-  }
-
-  const targetFullPath = path.join(meta.rootPath, record.filePath);
-  const backupContent = fs.readFileSync(record.backupPath, 'utf8');
-  fs.writeFileSync(targetFullPath, backupContent, 'utf8');
-  record.rolledBack = true;
-
-  const updatedReport = getProjectReportById(meta.id, true, baseDir);
-  return {
-    restoredRecord: record,
-    updatedReport,
-  };
-}
-
-export interface McpToolDefinition {
-  name: string;
-  description: string;
-  parameters: string[];
-}
-
-export const MCP_TOOLS_CATALOG: McpToolDefinition[] = [
-  {
-    name: 'inspect_project',
-    description: 'Inspect complete project structure, framework, scores, and issue summary.',
-    parameters: ['projectId'],
-  },
-  {
-    name: 'diagnose_error',
-    description: 'Diagnose a raw React Native, Metro, Gradle, or CocoaPods error stack trace.',
-    parameters: ['rawLog'],
-  },
-  {
-    name: 'analyze_react_native',
-    description: 'Run dedicated React Native Doctor, Babel, Metro, and component lifecycle inspection.',
-    parameters: ['projectId'],
-  },
-  {
-    name: 'inspect_android_environment',
-    description: 'Inspect AndroidManifest.xml, build.gradle, SDK targets, permissions, and Gradle heap.',
-    parameters: ['projectId'],
-  },
-  {
-    name: 'inspect_ios_environment',
-    description: 'Inspect Podfile, Info.plist, deployment targets, and host OS build capabilities.',
-    parameters: ['projectId'],
-  },
-  {
-    name: 'analyze_component',
-    description: 'Inspect React / React Native component files for memory leaks, FlatList keys, and hooks.',
-    parameters: ['projectId'],
-  },
-  {
-    name: 'inspect_dependencies',
-    description: 'Analyze package.json / requirements.txt for version conflicts and bundle weight.',
-    parameters: ['projectId'],
-  },
-  {
-    name: 'scan_design_system',
-    description: 'Discover design tokens and detect hardcoded colors, random radii, and emoji UI icons.',
-    parameters: ['projectId'],
-  },
-  {
-    name: 'find_unused_files',
-    description: 'Locate unreferenced modules and dead exports across the repository.',
-    parameters: ['projectId'],
-  },
-  {
-    name: 'analyze_performance',
-    description: 'Measure source payload, heavy dependencies, blocking I/O, and re-render risks.',
-    parameters: ['projectId'],
-  },
-  {
-    name: 'suggest_fix',
-    description: 'Generate unified diff patch and explanation for a specific diagnostic issue.',
-    parameters: ['projectId', 'issueId'],
-  },
-  {
-    name: 'apply_safe_fix',
-    description: 'Create backup and execute an approved SAFE repair on disk, then verify.',
-    parameters: ['projectId', 'issueId'],
-  },
-  {
-    name: 'verify_repair',
-    description: 'Re-scan project and evaluate Quality Gate compliance after repair.',
-    parameters: ['projectId'],
-  },
-];
-
-export function executeMcpToolCall(
-  toolName: string,
-  args: { projectId?: string; issueId?: string; rawLog?: string },
-  baseWorkspaceDir = process.cwd()
-): Record<string, unknown> {
-  const projectId = args.projectId || 'rn-expo-commerce';
-  const report = getProjectReportById(projectId, false, baseWorkspaceDir);
-
-  switch (toolName) {
-    case 'inspect_project':
-      return {
-        tool: toolName,
-        projectId: report.id,
-        name: report.name,
-        ecosystem: report.ecosystem,
-        filesCount: report.filesAnalyzed.length,
-        scores: report.scores,
-        totalIssues: report.issues.length,
-        launchCommand: report.launchDoctor.recommendedStartCommand,
-      };
-    case 'diagnose_error':
-      return {
-        tool: toolName,
-        diagnosis: diagnoseRawErrorLog(
-          args.rawLog ||
-            'Error: [Reanimated] Failed to create a worklet. plugins: [react-native-reanimated/plugin]'
-        ),
-      };
-    case 'analyze_react_native':
-      return {
-        tool: toolName,
-        projectId: report.id,
-        workflow: report.launchDoctor.workflowType,
-        metroConfigured: report.launchDoctor.metroConfigured,
-        babelConfigured: report.launchDoctor.babelConfigured,
-        reactNativeScore: report.scores.reactNative,
-        issues: report.issues.filter(
-          (i) => i.domain === 'react-native' || i.domain === 'android' || i.domain === 'ios'
-        ),
-      };
-    case 'inspect_android_environment':
-      return {
-        tool: toolName,
-        projectId: report.id,
-        androidSummary: report.android,
-        hostAndroidChecks: inspectHostEnvironment().filter((c) => c.category === 'android'),
-        androidIssues: report.issues.filter((i) => i.domain === 'android'),
-      };
-    case 'inspect_ios_environment':
-      return {
-        tool: toolName,
-        projectId: report.id,
-        iosSummary: report.ios,
-        hostIosChecks: inspectHostEnvironment().filter((c) => c.category === 'ios'),
-        iosIssues: report.issues.filter((i) => i.domain === 'ios'),
-      };
-    case 'analyze_component':
-      return {
-        tool: toolName,
-        projectId: report.id,
-        componentIssues: report.issues.filter(
-          (i) => i.domain === 'react-native' || i.domain === 'performance' || i.domain === 'design'
-        ),
-      };
-    case 'inspect_dependencies':
-      return {
-        tool: toolName,
-        projectId: report.id,
-        dependencies: report.dependencies,
-      };
-    case 'scan_design_system':
-      return {
-        tool: toolName,
-        projectId: report.id,
-        designSystem: report.designSystem,
-        designIssues: report.issues.filter((i) => i.domain === 'design'),
-      };
-    case 'find_unused_files':
-      return {
-        tool: toolName,
-        projectId: report.id,
-        unusedFiles: report.issues.filter((i) => i.ruleId === 'DEAD_CODE_UNUSED_MODULE'),
-      };
-    case 'analyze_performance':
-      return {
-        tool: toolName,
-        projectId: report.id,
-        performance: report.performance,
-      };
-    case 'suggest_fix': {
-      const targetIssue =
-        report.issues.find((i) => i.id === args.issueId) ||
-        report.issues.find((i) => i.fixAvailable) ||
-        report.issues[0];
-      return {
-        tool: toolName,
-        projectId: report.id,
-        issue: targetIssue || null,
-      };
-    }
-    case 'apply_safe_fix': {
-      const targetIssue =
-        report.issues.find((i) => i.id === args.issueId && i.fixAvailable && i.repairTier === 'SAFE') ||
-        report.issues.find((i) => i.fixAvailable && i.repairTier === 'SAFE');
-      if (!targetIssue) {
-        return {
-          tool: toolName,
-          status: 'no_safe_fix_pending',
-          message: 'All SAFE issues in this project have already been repaired.',
-        };
-      }
-      const res = applyIssueRepairOnDisk({
-        projectId: report.id,
-        issueId: targetIssue.id,
-        baseWorkspaceDir,
-      });
-      return {
-        tool: toolName,
-        status: 'repaired_and_verified',
-        repairRecord: res.repairRecord,
-        remainingIssues: res.updatedReport.issues.length,
-      };
-    }
-    case 'verify_repair': {
-      const fresh = getProjectReportById(report.id, true, baseWorkspaceDir);
-      return {
-        tool: toolName,
-        projectId: fresh.id,
-        qualityGatePassed: fresh.qualityGateEvaluation.passed,
-        exitCode: fresh.qualityGateEvaluation.exitCode,
-        remainingIssuesCount: fresh.issues.length,
-        scores: fresh.scores,
-      };
-    }
-    default:
-      throw new Error(`Unknown MCP tool: ${toolName}`);
-  }
-}

package/src/index.css

@@ -1,44 +0,0 @@
-@import "tailwindcss";
-@custom-variant dark (&:where(.dark, .dark *));
-
-@layer base {
-  :root {
-    --font-sans: 'Plus Jakarta Sans', -apple-system, BlinkMacSystemFont, sans-serif;
-    --font-mono: 'JetBrains Mono', ui-monospace, SFMono-Regular, monospace;
-  }
-
-  body {
-    font-family: var(--font-sans);
-    background-color: #0B1120;
-    color: #F8FAFC;
-    overflow-x: hidden;
-  }
-
-  code, pre, .font-mono {
-    font-family: var(--font-mono);
-    font-variant-numeric: tabular-nums;
-  }
-}
-
-.tabular-nums {
-  font-variant-numeric: tabular-nums;
-}
-
-/* Custom subtle scrollbars for enterprise dark theme */
-::-webkit-scrollbar {
-  width: 6px;
-  height: 6px;
-}
-
-::-webkit-scrollbar-track {
-  background: #0B1120;
-}
-
-::-webkit-scrollbar-thumb {
-  background: #1E293B;
-  border-radius: 3px;
-}
-
-::-webkit-scrollbar-thumb:hover {
-  background: #334155;
-}

package/src/index.ts

@@ -1,59 +0,0 @@
-/**
- * DEVINTELLIGENCE — Personal Software Engineering Intelligence System
- * Tagline: Understand. Diagnose. Repair. Optimize.
- *
- * Universal programmatic library entrypoint for Node.js & TypeScript projects.
- */
-
-// Host Environment & Tooling Doctor
-export {
-  inspectHostEnvironment,
-  detectProjectEcosystem,
-  diagnoseRawErrorLog,
-  analyzeProjectDirectory,
-  PRESET_ERROR_LOGS,
-} from './engine/analyzerEngine.ts';
-
-// Automated Safe Repair, Project History & MCP Engine
-export {
-  getAllProjectReports,
-  getProjectReportById,
-  registerLocalProject,
-  applyIssueRepairOnDisk,
-  applyAllSafeRepairsOnDisk,
-  rollbackRepairOnDisk,
-  updateProjectQualityGate,
-  MCP_TOOLS_CATALOG,
-  executeMcpToolCall,
-} from './engine/repairEngine.ts';
-
-// Resilient AI Engine (Groq Qwen/Llama 3 with Zero-Downtime Rule Fallback Shield)
-export {
-  diagnoseRawErrorLogWithAi,
-  generateProjectAiAdvice,
-  askDevIntelligenceAi,
-  getGroqApiKey,
-  isAiRateLimited,
-  resetAiRateLimit,
-} from './engine/aiEngine.ts';
-
-// Core Type Definitions for all 18 Intelligence Modules
-export type {
-  ProjectIntelligenceReport,
-  DiagnosticIssue,
-  IssueSeverity,
-  RepairTier,
-  RepairRecord,
-  ScanSnapshot,
-  QualityGateConfig,
-  QualityGateEvaluation,
-  EnvironmentCheckItem,
-  ErrorDiagnosisResult,
-  LaunchDoctorReport,
-  PerformanceReport,
-  DesignSystemReport,
-  VisualTestingReport,
-  ProjectEcosystem,
-  DashboardModuleId,
-} from './types/devintelligence.ts';
-

package/src/main.tsx

@@ -1,5 +0,0 @@
-import {createRoot} from 'react-dom/client';
-import App from './App.tsx';
-import './index.css';
-
-createRoot(document.getElementById('root')!).render(<App />);