neuronlayer 0.1.0

package/src/core/adr-exporter.ts

@@ -0,0 +1,253 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import type { Decision } from '../types/index.js';
+
+export interface ADRExportOptions {
+  outputDir?: string;
+  format?: 'madr' | 'nygard' | 'simple';
+  includeIndex?: boolean;
+}
+
+export class ADRExporter {
+  private projectPath: string;
+
+  constructor(projectPath: string) {
+    this.projectPath = projectPath;
+  }
+
+  // Export a single decision to ADR file
+  exportDecision(decision: Decision, options: ADRExportOptions = {}): string {
+    const outputDir = options.outputDir || join(this.projectPath, 'docs', 'decisions');
+    const format = options.format || 'madr';
+
+    // Ensure output directory exists
+    if (!existsSync(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+
+    // Generate filename
+    const existingFiles = this.getExistingADRFiles(outputDir);
+    const nextNumber = this.getNextADRNumber(existingFiles);
+    const slug = this.slugify(decision.title);
+    const filename = `${String(nextNumber).padStart(4, '0')}-${slug}.md`;
+    const filePath = join(outputDir, filename);
+
+    // Generate content based on format
+    let content: string;
+    switch (format) {
+      case 'madr':
+        content = this.formatMADR(decision, nextNumber);
+        break;
+      case 'nygard':
+        content = this.formatNygard(decision, nextNumber);
+        break;
+      case 'simple':
+      default:
+        content = this.formatSimple(decision, nextNumber);
+        break;
+    }
+
+    // Write file
+    writeFileSync(filePath, content);
+
+    return filePath;
+  }
+
+  // Export all decisions
+  exportAllDecisions(decisions: Decision[], options: ADRExportOptions = {}): string[] {
+    const exportedFiles: string[] = [];
+    const outputDir = options.outputDir || join(this.projectPath, 'docs', 'decisions');
+
+    // Sort by creation date
+    const sorted = [...decisions].sort((a, b) =>
+      a.createdAt.getTime() - b.createdAt.getTime()
+    );
+
+    for (const decision of sorted) {
+      const filePath = this.exportDecision(decision, { ...options, outputDir });
+      exportedFiles.push(filePath);
+    }
+
+    // Generate index if requested
+    if (options.includeIndex !== false) {
+      const indexPath = this.generateIndex(decisions, outputDir);
+      exportedFiles.push(indexPath);
+    }
+
+    return exportedFiles;
+  }
+
+  // Generate index file
+  private generateIndex(decisions: Decision[], outputDir: string): string {
+    const indexPath = join(outputDir, 'README.md');
+
+    const lines: string[] = [
+      '# Architecture Decision Records',
+      '',
+      'This directory contains Architecture Decision Records (ADRs) for this project.',
+      '',
+      '## Decisions',
+      '',
+      '| # | Title | Status | Date |',
+      '|---|-------|--------|------|'
+    ];
+
+    const sorted = [...decisions].sort((a, b) =>
+      a.createdAt.getTime() - b.createdAt.getTime()
+    );
+
+    sorted.forEach((d, i) => {
+      const num = String(i + 1).padStart(4, '0');
+      const slug = this.slugify(d.title);
+      const status = d.status || 'accepted';
+      const date = d.createdAt.toISOString().split('T')[0];
+      lines.push(`| ${num} | [${d.title}](./${num}-${slug}.md) | ${status} | ${date} |`);
+    });
+
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    lines.push('*Generated by MemoryLayer*');
+
+    writeFileSync(indexPath, lines.join('\n'));
+    return indexPath;
+  }
+
+  // MADR format (Markdown Any Decision Records)
+  private formatMADR(decision: Decision, number: number): string {
+    const date = decision.createdAt.toISOString().split('T')[0];
+    const status = decision.status || 'accepted';
+
+    return `# ${decision.title}
+
+* Status: ${status}
+* Date: ${date}
+${decision.author ? `* Author: ${decision.author}` : ''}
+${decision.tags.length > 0 ? `* Tags: ${decision.tags.join(', ')}` : ''}
+
+## Context and Problem Statement
+
+${decision.description}
+
+## Decision Drivers
+
+* [List the main factors that influenced this decision]
+
+## Considered Options
+
+* [Option 1]
+* [Option 2]
+* [Option 3]
+
+## Decision Outcome
+
+Chosen option: "${decision.title}"
+
+### Consequences
+
+* Good, because [positive consequence]
+* Bad, because [negative consequence]
+
+${decision.files.length > 0 ? `## Related Files
+
+${decision.files.map(f => `* \`${f}\``).join('\n')}
+` : ''}
+${decision.supersededBy ? `## Superseded By
+
+This decision has been superseded by [ADR ${decision.supersededBy}](./${decision.supersededBy}.md).
+` : ''}
+---
+*Exported from MemoryLayer*
+`;
+  }
+
+  // Nygard format (original ADR format)
+  private formatNygard(decision: Decision, number: number): string {
+    const date = decision.createdAt.toISOString().split('T')[0];
+    const status = decision.status || 'Accepted';
+
+    return `# ${number}. ${decision.title}
+
+Date: ${date}
+
+## Status
+
+${status.charAt(0).toUpperCase() + status.slice(1)}
+${decision.supersededBy ? `\nSuperseded by [ADR ${decision.supersededBy}](./${decision.supersededBy}.md)` : ''}
+
+## Context
+
+${decision.description}
+
+## Decision
+
+We will ${decision.title.toLowerCase()}.
+
+## Consequences
+
+[Describe the consequences of this decision]
+
+${decision.files.length > 0 ? `## Related Files
+
+${decision.files.map(f => `- ${f}`).join('\n')}
+` : ''}
+---
+*Exported from MemoryLayer*
+`;
+  }
+
+  // Simple format
+  private formatSimple(decision: Decision, number: number): string {
+    const date = decision.createdAt.toISOString().split('T')[0];
+
+    return `# ${decision.title}
+
+**Date:** ${date}
+${decision.author ? `**Author:** ${decision.author}` : ''}
+**Status:** ${decision.status || 'accepted'}
+${decision.tags.length > 0 ? `**Tags:** ${decision.tags.join(', ')}` : ''}
+
+## Description
+
+${decision.description}
+
+${decision.files.length > 0 ? `## Related Files
+
+${decision.files.map(f => `- \`${f}\``).join('\n')}
+` : ''}
+---
+*Exported from MemoryLayer*
+`;
+  }
+
+  private getExistingADRFiles(dir: string): string[] {
+    if (!existsSync(dir)) return [];
+
+    try {
+      const { readdirSync } = require('fs');
+      return readdirSync(dir)
+        .filter((f: string) => /^\d{4}-.*\.md$/.test(f))
+        .sort();
+    } catch {
+      return [];
+    }
+  }
+
+  private getNextADRNumber(existingFiles: string[]): number {
+    if (existingFiles.length === 0) return 1;
+
+    const numbers = existingFiles
+      .map(f => parseInt(f.split('-')[0] || '0', 10))
+      .filter(n => !isNaN(n));
+
+    return Math.max(...numbers, 0) + 1;
+  }
+
+  private slugify(text: string): string {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-|-$/g, '')
+      .slice(0, 50);
+  }
+}

package/src/core/architecture/architecture-enforcement.ts

@@ -0,0 +1,228 @@
+import type Database from 'better-sqlite3';
+import type { Tier2Storage } from '../../storage/tier2.js';
+import type { EmbeddingGenerator } from '../../indexing/embeddings.js';
+import type {
+  Pattern,
+  PatternCategory,
+  PatternValidationResult,
+  ExistingFunction,
+  CodeExample,
+  PatternRule
+} from '../../types/documentation.js';
+import { PatternLibrary } from './pattern-library.js';
+import { PatternLearner } from './pattern-learner.js';
+import { PatternValidator } from './pattern-validator.js';
+import { DuplicateDetector } from './duplicate-detector.js';
+
+export class ArchitectureEnforcement {
+  private patternLibrary: PatternLibrary;
+  private patternLearner: PatternLearner;
+  private patternValidator: PatternValidator;
+  private duplicateDetector: DuplicateDetector;
+  private initialized = false;
+
+  constructor(
+    db: Database.Database,
+    tier2: Tier2Storage,
+    embeddingGenerator: EmbeddingGenerator
+  ) {
+    this.patternLibrary = new PatternLibrary(db);
+    this.duplicateDetector = new DuplicateDetector(tier2, embeddingGenerator);
+    this.patternLearner = new PatternLearner(tier2, this.patternLibrary);
+    this.patternValidator = new PatternValidator(this.patternLibrary, this.duplicateDetector, tier2);
+  }
+
+  // Initialize by learning patterns from codebase
+  initialize(): { patternsLearned: number; examplesAdded: number } {
+    if (this.initialized) return { patternsLearned: 0, examplesAdded: 0 };
+
+    const result = this.patternLearner.learnFromCodebase();
+    this.initialized = true;
+
+    return {
+      patternsLearned: result.patternsLearned,
+      examplesAdded: result.examplesAdded
+    };
+  }
+
+  // Validate code against patterns
+  validatePattern(code: string, type?: PatternCategory | 'auto'): PatternValidationResult {
+    return this.patternValidator.validate(code, type);
+  }
+
+  // Suggest existing functions for an intent
+  suggestExisting(intent: string, limit?: number): ExistingFunction[] {
+    return this.duplicateDetector.suggestExisting(intent, limit);
+  }
+
+  // Learn a new pattern
+  learnPattern(
+    code: string,
+    name: string,
+    description?: string,
+    category?: PatternCategory
+  ): { success: boolean; patternId?: string; message: string } {
+    return this.patternLearner.learnPattern(code, name, description, category);
+  }
+
+  // List all patterns
+  listPatterns(category?: PatternCategory): Pattern[] {
+    if (category) {
+      return this.patternLibrary.getPatternsByCategory(category);
+    }
+    return this.patternLibrary.getAllPatterns();
+  }
+
+  // Get a specific pattern
+  getPattern(id: string): Pattern | null {
+    return this.patternLibrary.getPattern(id);
+  }
+
+  // Add example to existing pattern
+  addExample(patternId: string, code: string, explanation: string, isAntiPattern: boolean = false): boolean {
+    const example: CodeExample = { code, explanation };
+    return this.patternLibrary.addExample(patternId, example, isAntiPattern);
+  }
+
+  // Add rule to existing pattern
+  addRule(patternId: string, rule: string, severity: 'info' | 'warning' | 'critical'): boolean {
+    const patternRule: PatternRule = { rule, severity };
+    return this.patternLibrary.addRule(patternId, patternRule);
+  }
+
+  // Search patterns
+  searchPatterns(query: string): Pattern[] {
+    return this.patternLibrary.searchPatterns(query);
+  }
+
+  // Delete a pattern
+  deletePattern(id: string): boolean {
+    return this.patternLibrary.deletePattern(id);
+  }
+
+  // Refresh duplicate detector index
+  refreshIndex(): void {
+    this.duplicateDetector.refresh();
+  }
+
+  // Get statistics
+  getStats(): {
+    patterns: {
+      total: number;
+      byCategory: Record<string, number>;
+      topPatterns: Array<{ name: string; usageCount: number }>;
+    };
+    functions: {
+      total: number;
+      exported: number;
+      byPurpose: Record<string, number>;
+    };
+  } {
+    return {
+      patterns: this.patternLearner.getStats(),
+      functions: this.duplicateDetector.getStats()
+    };
+  }
+
+  // Format validation result for display
+  static formatValidationResult(result: PatternValidationResult): string {
+    const lines: string[] = [];
+
+    const scoreIcon = result.score >= 80 ? '\u{1F7E2}' :
+                      result.score >= 50 ? '\u{1F7E1}' : '\u{1F534}';
+
+    lines.push(`\u{1F50D} Pattern Validation\n`);
+    lines.push(`${scoreIcon} Score: ${result.score}/100`);
+
+    if (result.matchedPattern) {
+      lines.push(`Matched Pattern: ${result.matchedPattern}`);
+    }
+
+    if (result.violations.length > 0) {
+      lines.push('\n\u274C Violations:');
+      for (const v of result.violations) {
+        const icon = v.severity === 'critical' ? '\u{1F534}' :
+                     v.severity === 'warning' ? '\u{1F7E1}' : '\u{2139}\u{FE0F}';
+        lines.push(`  ${icon} ${v.message}`);
+        if (v.suggestion) {
+          lines.push(`     \u2192 ${v.suggestion}`);
+        }
+      }
+    }
+
+    if (result.existingAlternatives.length > 0) {
+      lines.push('\n\u{1F4A1} Existing Alternatives:');
+      for (const alt of result.existingAlternatives) {
+        lines.push(`  - ${alt.name}() in ${alt.file} (${alt.similarity}% similar)`);
+      }
+    }
+
+    if (result.suggestions.length > 0) {
+      lines.push('\n\u{1F4DD} Suggestions:');
+      for (const s of result.suggestions) {
+        const icon = s.priority === 'high' ? '\u{1F534}' :
+                     s.priority === 'medium' ? '\u{1F7E1}' : '\u{1F7E2}';
+        lines.push(`  ${icon} ${s.description}`);
+        if (s.code) {
+          lines.push(`     ${s.code}`);
+        }
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  // Format pattern list for display
+  static formatPatternList(patterns: Pattern[]): string {
+    if (patterns.length === 0) {
+      return 'No patterns found.';
+    }
+
+    const lines: string[] = [];
+    lines.push(`\u{1F4DA} Patterns (${patterns.length})\n`);
+
+    const byCategory: Record<string, Pattern[]> = {};
+    for (const p of patterns) {
+      if (!byCategory[p.category]) {
+        byCategory[p.category] = [];
+      }
+      byCategory[p.category].push(p);
+    }
+
+    for (const [category, categoryPatterns] of Object.entries(byCategory)) {
+      lines.push(`\n${category.toUpperCase()}:`);
+      for (const p of categoryPatterns) {
+        lines.push(`  \u251C\u2500 ${p.name} (${p.usageCount} uses)`);
+        if (p.description) {
+          lines.push(`  \u2502  ${p.description.slice(0, 50)}...`);
+        }
+        lines.push(`  \u2502  Rules: ${p.rules.length}, Examples: ${p.examples.length}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  // Format existing function suggestions for display
+  static formatSuggestions(suggestions: ExistingFunction[]): string {
+    if (suggestions.length === 0) {
+      return 'No existing functions found for this intent.';
+    }
+
+    const lines: string[] = [];
+    lines.push(`\u{1F4A1} Existing Functions\n`);
+
+    for (const s of suggestions) {
+      lines.push(`\u251C\u2500 ${s.name}()`);
+      lines.push(`\u2502  File: ${s.file}:${s.line}`);
+      lines.push(`\u2502  Signature: ${s.signature}`);
+      lines.push(`\u2502  Used: ${s.usageCount} times, Relevance: ${s.similarity}%`);
+      if (s.description) {
+        lines.push(`\u2502  ${s.description}`);
+      }
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+}