lean-claudient-core 0.1.0

package/src/repair/errorDiagnostics.ts

@@ -0,0 +1,198 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export type ErrorCategory = 'typescript' | 'io' | 'validation' | 'git' | 'unknown';
+
+export interface DiagnosisResult {
+  errorType: string;
+  category: ErrorCategory;
+  rootCause: string;
+  affectedFile?: string;
+  lineNumber?: number;
+  suggestions: string[];
+}
+
+export interface RecoverySuggestion {
+  action: string;
+  command?: string;
+  priority: 'critical' | 'high' | 'medium' | 'low';
+}
+
+export class ErrorDiagnostics {
+  private workingDir: string;
+  private progressFile: string;
+
+  constructor(workingDir: string) {
+    this.workingDir = workingDir;
+    this.progressFile = path.join(workingDir, 'progress.md');
+  }
+
+  diagnoseError(error: Error | string, context: string): DiagnosisResult {
+    const errorMessage = typeof error === 'string' ? error : error.message;
+    const errorType = this.extractErrorType(errorMessage);
+    const category = this.categorizeError(error);
+    const rootCause = this.extractRootCause(errorMessage, category);
+    const { file, line } = this.extractFileInfo(errorMessage);
+    const suggestions = this.generateSuggestions(category, errorMessage, rootCause);
+
+    const diagnosis: DiagnosisResult = {
+      errorType,
+      category,
+      rootCause,
+      affectedFile: file,
+      lineNumber: line,
+      suggestions
+    };
+
+    this.logError(error, context);
+
+    return diagnosis;
+  }
+
+  categorizeError(error: Error | string): ErrorCategory {
+    const message = typeof error === 'string' ? error : error.message;
+
+    if (message.includes('syntax') || message.includes('SyntaxError') || message.includes('TS')) {
+      return 'typescript';
+    }
+    if (message.includes('ENOENT') || message.includes('EACCES') || message.includes('no such file')) {
+      return 'io';
+    }
+    if (message.includes('validation') || message.includes('ValidationError')) {
+      return 'validation';
+    }
+    if (message.includes('fatal') || message.includes('git')) {
+      return 'git';
+    }
+
+    return 'unknown';
+  }
+
+  suggestRecovery(diagnosis: DiagnosisResult): RecoverySuggestion {
+    const categoryRecovery: Record<ErrorCategory, RecoverySuggestion> = {
+      typescript: {
+        action: 'Fix TypeScript syntax error',
+        command: 'npx tsc --noEmit',
+        priority: 'critical'
+      },
+      io: {
+        action: 'Verify file path and permissions',
+        command: 'ls -la ' + (diagnosis.affectedFile || '.'),
+        priority: 'high'
+      },
+      validation: {
+        action: 'Validate input data against schema',
+        command: 'npm run validate',
+        priority: 'high'
+      },
+      git: {
+        action: 'Check git repository status',
+        command: 'git status',
+        priority: 'medium'
+      },
+      unknown: {
+        action: 'Review error logs and context',
+        priority: 'medium'
+      }
+    };
+
+    return categoryRecovery[diagnosis.category] || categoryRecovery.unknown;
+  }
+
+  logError(error: Error | string, context: string): void {
+    const timestamp = new Date().toISOString();
+    const errorMessage = typeof error === 'string' ? error : error.message;
+    const category = this.categorizeError(error);
+    const errorType = this.extractErrorType(errorMessage);
+
+    const logEntry = `### ERROR: ${errorType} at ${timestamp}\n**Context**: ${context}\n**Category**: ${category}\n**Message**: ${errorMessage}\n\n`;
+
+    try {
+      if (!fs.existsSync(this.progressFile)) {
+        fs.writeFileSync(this.progressFile, '# Progress Log\n\n');
+      }
+      const currentContent = fs.readFileSync(this.progressFile, 'utf-8');
+      fs.writeFileSync(this.progressFile, logEntry + currentContent);
+    } catch (err) {
+      console.error('Failed to log error to progress.md:', err);
+    }
+  }
+
+  private extractErrorType(message: string): string {
+    const typeMatch = message.match(/^([A-Z][a-zA-Z]*Error)/);
+    if (typeMatch) {
+      return typeMatch[1];
+    }
+
+    if (message.includes('syntax')) return 'SyntaxError';
+    if (message.includes('ENOENT')) return 'FileNotFoundError';
+    if (message.includes('EACCES')) return 'PermissionError';
+    if (message.includes('validation')) return 'ValidationError';
+
+    return 'UnknownError';
+  }
+
+  private extractRootCause(message: string, category: ErrorCategory): string {
+    switch (category) {
+      case 'typescript':
+        return message.includes('cannot find') ? 'Missing type definition or import' : 'Invalid TypeScript syntax';
+      case 'io':
+        return message.includes('ENOENT') ? 'File or directory does not exist' : 'File access denied';
+      case 'validation':
+        return 'Input validation failed - data does not match expected schema';
+      case 'git':
+        return 'Git operation failed - check repository state';
+      default:
+        return 'Unknown error - check logs for details';
+    }
+  }
+
+  private extractFileInfo(message: string): { file?: string; line?: number } {
+    const fileMatch = message.match(/(?:file|path|at\s+)['"]?([^\s'"]+\.(?:ts|js|json))['"]?/i);
+    const lineMatch = message.match(/(?:line|:)[\s:]?(\d+)/i);
+
+    return {
+      file: fileMatch ? fileMatch[1] : undefined,
+      line: lineMatch ? parseInt(lineMatch[1], 10) : undefined
+    };
+  }
+
+  private generateSuggestions(
+    category: ErrorCategory,
+    message: string,
+    rootCause: string
+  ): string[] {
+    const suggestions: string[] = [];
+
+    switch (category) {
+      case 'typescript':
+        suggestions.push('Check for missing imports or type definitions');
+        suggestions.push('Verify variable and function names are spelled correctly');
+        suggestions.push('Run npm run type-check to identify all TypeScript errors');
+        if (message.includes('cannot find')) {
+          suggestions.push('Install missing dependencies with npm install');
+        }
+        break;
+      case 'io':
+        suggestions.push('Verify the file path is correct and exists');
+        suggestions.push('Check file permissions');
+        suggestions.push('Ensure the directory structure is properly created');
+        break;
+      case 'validation':
+        suggestions.push('Review the input data format');
+        suggestions.push('Check against the expected schema');
+        suggestions.push('Validate all required fields are present');
+        break;
+      case 'git':
+        suggestions.push('Run git status to check repository state');
+        suggestions.push('Verify branch is up to date');
+        suggestions.push('Check for uncommitted changes');
+        break;
+      default:
+        suggestions.push('Review the full error message and stack trace');
+        suggestions.push('Check the affected file and surrounding code');
+    }
+
+    return suggestions;
+  }
+}

package/src/repair/skillCapture.ts

@@ -0,0 +1,157 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface SkillData {
+  label: string;
+  rootCause: string;
+  solution: string;
+  timestamp: string;
+  usageCount: number;
+}
+
+export class SkillCapture {
+  private skillsDir: string;
+
+  constructor(skillsDir: string) {
+    this.skillsDir = skillsDir;
+    this.ensureDirectory();
+  }
+
+  private ensureDirectory(): void {
+    if (!fs.existsSync(this.skillsDir)) {
+      fs.mkdirSync(this.skillsDir, { recursive: true });
+    }
+  }
+
+  private slugify(label: string): string {
+    return label
+      .toLowerCase()
+      .trim()
+      .replace(/[^\w\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-');
+  }
+
+  private getFilePath(label: string): string {
+    return path.join(this.skillsDir, `${this.slugify(label)}.md`);
+  }
+
+  captureSkill(label: string, rootCause: string, solution: string): string {
+    const filename = `${this.slugify(label)}.md`;
+    const filePath = this.getFilePath(label);
+    const timestamp = new Date().toISOString();
+
+    const content = `# ${label}
+
+**Root Cause**: ${rootCause}
+
+**Solution**: ${solution}
+
+**Captured**: ${timestamp}
+**Usage Count**: 0`;
+
+    fs.writeFileSync(filePath, content, 'utf8');
+    return filename;
+  }
+
+  loadSkill(label: string): SkillData | null {
+    const filePath = this.getFilePath(label);
+
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const skillData = this.parseSkillFile(content, label);
+
+    if (skillData) {
+      skillData.usageCount += 1;
+      this.saveSkill(filePath, skillData);
+    }
+
+    return skillData;
+  }
+
+  private parseSkillFile(content: string, label: string): SkillData | null {
+    const rootCauseMatch = content.match(/\*\*Root Cause\*\*:\s*(.+?)(?=\n\n|\n\*\*)/s);
+    const solutionMatch = content.match(/\*\*Solution\*\*:\s*(.+?)(?=\n\n|\n\*\*)/s);
+    const timestampMatch = content.match(/\*\*Captured\*\*:\s*(.+?)(?=\n|\r)/);
+    const usageCountMatch = content.match(/\*\*Usage Count\*\*:\s*(\d+)/);
+
+    if (!rootCauseMatch || !solutionMatch || !timestampMatch) {
+      return null;
+    }
+
+    return {
+      label,
+      rootCause: rootCauseMatch[1].trim(),
+      solution: solutionMatch[1].trim(),
+      timestamp: timestampMatch[1].trim(),
+      usageCount: parseInt(usageCountMatch?.[1] || '0', 10),
+    };
+  }
+
+  private saveSkill(filePath: string, skillData: SkillData): void {
+    const content = `# ${skillData.label}
+
+**Root Cause**: ${skillData.rootCause}
+
+**Solution**: ${skillData.solution}
+
+**Captured**: ${skillData.timestamp}
+**Usage Count**: ${skillData.usageCount}`;
+
+    fs.writeFileSync(filePath, content, 'utf8');
+  }
+
+  searchSkills(keyword: string): SkillData[] {
+    const keyword_lower = keyword.toLowerCase();
+    const files = this.getSkillFiles();
+    const results: SkillData[] = [];
+
+    for (const file of files) {
+      const content = fs.readFileSync(file, 'utf8');
+      const filename = path.basename(file, '.md');
+      const skillData = this.parseSkillFile(content, filename);
+
+      if (
+        skillData &&
+        (skillData.label.toLowerCase().includes(keyword_lower) ||
+          skillData.rootCause.toLowerCase().includes(keyword_lower) ||
+          skillData.solution.toLowerCase().includes(keyword_lower))
+      ) {
+        results.push(skillData);
+      }
+    }
+
+    return results;
+  }
+
+  listSkills(): SkillData[] {
+    const files = this.getSkillFiles();
+    const skills: SkillData[] = [];
+
+    for (const file of files) {
+      const content = fs.readFileSync(file, 'utf8');
+      const filename = path.basename(file, '.md');
+      const skillData = this.parseSkillFile(content, filename);
+
+      if (skillData) {
+        skills.push(skillData);
+      }
+    }
+
+    return skills.sort((a, b) => b.usageCount - a.usageCount);
+  }
+
+  private getSkillFiles(): string[] {
+    if (!fs.existsSync(this.skillsDir)) {
+      return [];
+    }
+
+    return fs
+      .readdirSync(this.skillsDir)
+      .filter((file) => file.endsWith('.md'))
+      .map((file) => path.join(this.skillsDir, file));
+  }
+}