@timmeck/brain 1.8.5 → 2.0.0

package/src/services/analytics.service.ts

@@ -1,226 +0,0 @@
-import type { ErrorRecord } from '../types/error.types.js';
-import type { ErrorRepository } from '../db/repositories/error.repository.js';
-import type { SolutionRepository } from '../db/repositories/solution.repository.js';
-import type { CodeModuleRepository } from '../db/repositories/code-module.repository.js';
-import type { RuleRepository } from '../db/repositories/rule.repository.js';
-import type { AntipatternRepository } from '../db/repositories/antipattern.repository.js';
-import type { InsightRepository } from '../db/repositories/insight.repository.js';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import type { NetworkStats } from '../types/synapse.types.js';
-
-export interface ProjectSummary {
-  errors: { total: number; unresolved: number; last7d: number };
-  solutions: { total: number };
-  rules: { active: number };
-  antipatterns: { total: number };
-  modules: { total: number };
-  insights: { active: number };
-  healthScore?: number;
-}
-
-export interface NetworkOverview {
-  stats: NetworkStats;
-  strongestSynapses: Array<{
-    id: number;
-    source: string;
-    target: string;
-    type: string;
-    weight: number;
-  }>;
-}
-
-export class AnalyticsService {
-  constructor(
-    private errorRepo: ErrorRepository,
-    private solutionRepo: SolutionRepository,
-    private codeModuleRepo: CodeModuleRepository,
-    private ruleRepo: RuleRepository,
-    private antipatternRepo: AntipatternRepository,
-    private insightRepo: InsightRepository,
-    private synapseManager: SynapseManager,
-  ) {}
-
-  getSummary(projectId?: number): ProjectSummary {
-    const sevenDaysAgo = new Date(Date.now() - 7 * 86400000).toISOString();
-
-    const unresolvedErrors = this.errorRepo.findUnresolved(projectId);
-    const allErrors = projectId ? this.errorRepo.findByProject(projectId) : [];
-    const last7dCount = this.errorRepo.countSince(sevenDaysAgo, projectId);
-
-    const rules = this.ruleRepo.findActive(projectId);
-    const antipatterns = projectId
-      ? this.antipatternRepo.findByProject(projectId)
-      : this.antipatternRepo.findGlobal();
-
-    const moduleCount = projectId
-      ? this.codeModuleRepo.findByProject(projectId).length
-      : this.codeModuleRepo.countAll();
-    const insights = this.insightRepo.findActive(projectId);
-
-    return {
-      errors: {
-        total: allErrors.length,
-        unresolved: unresolvedErrors.length,
-        last7d: last7dCount,
-      },
-      solutions: { total: 0 }, // solutions are global, not per-project
-      rules: { active: rules.length },
-      antipatterns: { total: antipatterns.length },
-      modules: { total: moduleCount },
-      insights: { active: insights.length },
-    };
-  }
-
-  computeHealthScore(projectId?: number): number {
-    const summary = this.getSummary(projectId);
-    const networkStats = this.synapseManager.getNetworkStats();
-
-    let score = 0;
-    let maxScore = 0;
-
-    // Data Volume (30 points)
-    maxScore += 30;
-    const dataVolume = summary.errors.total + (summary.modules.total * 2) + summary.solutions.total;
-    score += Math.min(30, dataVolume * 0.3);
-
-    // Synapse Density (20 points) - more connections = richer network
-    maxScore += 20;
-    const synapseDensity = networkStats.totalSynapses / Math.max(1, networkStats.totalNodes);
-    score += Math.min(20, synapseDensity * 5);
-
-    // Solution Coverage (20 points) - resolved errors vs total
-    maxScore += 20;
-    if (summary.errors.total > 0) {
-      const resolvedRate = 1 - (summary.errors.unresolved / summary.errors.total);
-      score += resolvedRate * 20;
-    } else {
-      score += 10; // No errors = neutral
-    }
-
-    // Learning Activity (15 points) - active rules + insights
-    maxScore += 15;
-    const learningActivity = summary.rules.active + summary.insights.active;
-    score += Math.min(15, learningActivity * 1.5);
-
-    // Error Trend (15 points) - fewer recent errors = better
-    maxScore += 15;
-    if (summary.errors.total > 0) {
-      const recentRatio = summary.errors.last7d / Math.max(1, summary.errors.total);
-      // Low recent ratio = health is good (errors decreasing)
-      score += Math.max(0, 15 - recentRatio * 30);
-    } else {
-      score += 15;
-    }
-
-    return Math.round((score / maxScore) * 100);
-  }
-
-  getTimeSeries(projectId?: number, days: number = 30): Array<{ date: string; errors: number; solutions: number }> {
-    const series: Array<{ date: string; errors: number; solutions: number }> = [];
-
-    for (let i = days - 1; i >= 0; i--) {
-      const dayStart = new Date(Date.now() - (i + 1) * 86400000).toISOString();
-      const dayEnd = new Date(Date.now() - i * 86400000).toISOString();
-
-      const errorsInDay = this.errorRepo.countSince(dayStart, projectId) - this.errorRepo.countSince(dayEnd, projectId);
-
-      series.push({
-        date: dayStart.split('T')[0]!,
-        errors: Math.max(0, errorsInDay),
-        solutions: 0, // Approximation
-      });
-    }
-
-    return series;
-  }
-
-  explainError(errorId: number): {
-    error: ErrorRecord | undefined;
-    solutions: Array<{ id: number; description: string; confidence: number; successRate: number }>;
-    chain: { parents: ErrorRecord[]; children: ErrorRecord[] };
-    relatedErrors: Array<{ id: number; type: string; message: string; similarity: number }>;
-    rules: Array<{ id: number; pattern: string; action: string; confidence: number }>;
-    insights: Array<{ id: number; type: string; title: string }>;
-    synapseConnections: number;
-  } {
-    const error = this.errorRepo.getById(errorId);
-    if (!error) {
-      return {
-        error: undefined, solutions: [], chain: { parents: [], children: [] },
-        relatedErrors: [], rules: [], insights: [], synapseConnections: 0,
-      };
-    }
-
-    // Solutions
-    const solutions = this.solutionRepo.findForError(errorId).map(s => ({
-      id: s.id,
-      description: s.description,
-      confidence: s.confidence,
-      successRate: this.solutionRepo.successRate(s.id),
-    }));
-
-    // Error chain
-    const parents = this.errorRepo.findChainParents(errorId);
-    const children = this.errorRepo.findChainChildren(errorId);
-
-    // Related via synapses
-    const context = this.synapseManager.getErrorContext(errorId);
-    const relatedErrors = context.relatedErrors.map(r => {
-      const e = this.errorRepo.getById(r.node.id);
-      return {
-        id: r.node.id,
-        type: e?.type ?? 'unknown',
-        message: e?.message ?? '',
-        similarity: r.activation,
-      };
-    });
-
-    // Prevention rules
-    const matchedRules = this.ruleRepo.findActive(error.project_id);
-    const rules = matchedRules
-      .filter(r => {
-        try { return new RegExp(r.pattern, 'i').test(`${error.type}: ${error.message}`); }
-        catch { return false; }
-      })
-      .map(r => ({ id: r.id, pattern: r.pattern, action: r.action, confidence: r.confidence }));
-
-    // Related insights
-    const insights = context.insights.map(i => ({
-      id: i.node.id,
-      type: i.node.type,
-      title: `Insight #${i.node.id}`,
-    }));
-
-    // Total synapse connections
-    const allConnections = this.synapseManager.activate({ type: 'error', id: errorId });
-
-    return {
-      error,
-      solutions,
-      chain: { parents, children },
-      relatedErrors,
-      rules,
-      insights,
-      synapseConnections: allConnections.length,
-    };
-  }
-
-  getNetworkOverview(limit: number = 10): NetworkOverview {
-    const stats = this.synapseManager.getNetworkStats();
-    // Use diverse sampling for dashboard (spread across synapse types)
-    const diverse = limit >= 30
-      ? this.synapseManager.getDiverseSynapses(Math.ceil(limit / 3))
-      : this.synapseManager.getStrongestSynapses(limit);
-
-    return {
-      stats,
-      strongestSynapses: diverse.map(s => ({
-        id: s.id,
-        source: `${s.source_type}:${s.source_id}`,
-        target: `${s.target_type}:${s.target_id}`,
-        type: s.synapse_type,
-        weight: s.weight,
-      })),
-    };
-  }
-}

package/src/services/code.service.ts

@@ -1,271 +0,0 @@
-import type { CodeModuleRecord } from '../types/code.types.js';
-import type { CodeModuleRepository } from '../db/repositories/code-module.repository.js';
-import type { ProjectRepository } from '../db/repositories/project.repository.js';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import { analyzeCode } from '../code/analyzer.js';
-import { fingerprintCode } from '../code/fingerprint.js';
-import { computeReusabilityScore } from '../code/scorer.js';
-import { detectGranularity } from '../code/registry.js';
-import { findExactMatches, findSemanticMatches, findStructuralMatches } from '../code/matcher.js';
-import { sha256 } from '../utils/hash.js';
-import { getEventBus } from '../utils/events.js';
-import { getLogger } from '../utils/logger.js';
-import type { EmbeddingEngine } from '../embeddings/engine.js';
-
-export interface AnalyzeInput {
-  project: string;
-  name: string;
-  filePath: string;
-  language: string;
-  source: string;
-  description?: string;
-}
-
-export interface FindReusableInput {
-  query?: string;
-  language?: string;
-  projectId?: number;
-  limit?: number;
-}
-
-export class CodeService {
-  private logger = getLogger();
-  private eventBus = getEventBus();
-  private embeddingEngine: EmbeddingEngine | null = null;
-
-  constructor(
-    private codeModuleRepo: CodeModuleRepository,
-    private projectRepo: ProjectRepository,
-    private synapseManager: SynapseManager,
-  ) {}
-
-  setEmbeddingEngine(engine: EmbeddingEngine): void {
-    this.embeddingEngine = engine;
-  }
-
-  analyzeAndRegister(input: AnalyzeInput): { moduleId: number; isNew: boolean; reusabilityScore: number } {
-    // Ensure project exists
-    let project = this.projectRepo.findByName(input.project);
-    if (!project) {
-      const id = this.projectRepo.create({ name: input.project, path: null, language: input.language, framework: null });
-      project = this.projectRepo.getById(id)!;
-    }
-
-    // Analyze the code
-    const analysis = analyzeCode(input.source, input.language);
-    const fingerprint = fingerprintCode(input.source, input.language);
-    const sourceHash = sha256(input.source);
-
-    // Check if module already exists (by fingerprint)
-    const existing = this.codeModuleRepo.findByFingerprint(fingerprint);
-    if (existing) {
-      // Source Hash Change Detection: compare hash to decide if re-analysis needed
-      if (existing.source_hash === sourceHash) {
-        // Unchanged — skip re-analysis
-        this.logger.debug(`Module ${existing.name} unchanged (hash match), skipping`);
-        this.synapseManager.strengthen(
-          { type: 'code_module', id: existing.id },
-          { type: 'project', id: project.id },
-          'uses_module',
-        );
-        return { moduleId: existing.id, isNew: false, reusabilityScore: existing.reusability_score };
-      }
-
-      // Hash changed — re-analyze
-      this.logger.info(`Module ${existing.name} changed (hash drift), re-analyzing`);
-      const reScore = computeReusabilityScore({
-        source: input.source,
-        filePath: input.filePath,
-        exports: analysis.exports,
-        internalDeps: analysis.internalDeps,
-        hasTypeAnnotations: analysis.hasTypeAnnotations,
-        complexity: analysis.complexity,
-      });
-
-      this.codeModuleRepo.update(existing.id, {
-        source_hash: sourceHash,
-        lines_of_code: analysis.linesOfCode,
-        complexity: analysis.complexity,
-        reusability_score: reScore,
-        updated_at: new Date().toISOString(),
-      });
-
-      // Re-index dependency synapses on change
-      this.indexDependencySynapses(existing.id, analysis.internalDeps, project.id);
-
-      this.synapseManager.strengthen(
-        { type: 'code_module', id: existing.id },
-        { type: 'project', id: project.id },
-        'uses_module',
-      );
-
-      this.eventBus.emit('module:updated', { moduleId: existing.id });
-
-      return { moduleId: existing.id, isNew: false, reusabilityScore: reScore };
-    }
-
-    // Compute reusability score (with complexity)
-    const reusabilityScore = computeReusabilityScore({
-      source: input.source,
-      filePath: input.filePath,
-      exports: analysis.exports,
-      internalDeps: analysis.internalDeps,
-      hasTypeAnnotations: analysis.hasTypeAnnotations,
-      complexity: analysis.complexity,
-    });
-
-    const granularity = detectGranularity(input.source, input.language);
-
-    const moduleId = this.codeModuleRepo.create({
-      project_id: project.id,
-      name: input.name,
-      file_path: input.filePath,
-      language: input.language,
-      fingerprint,
-      description: input.description ?? null,
-      source_hash: sourceHash,
-      lines_of_code: analysis.linesOfCode,
-      complexity: analysis.complexity,
-      reusability_score: reusabilityScore,
-    });
-
-    // Create synapse: module ↔ project
-    this.synapseManager.strengthen(
-      { type: 'code_module', id: moduleId },
-      { type: 'project', id: project.id },
-      'uses_module',
-    );
-
-    // Create dependency synapses for internal imports
-    this.indexDependencySynapses(moduleId, analysis.internalDeps, project.id);
-
-    // Compute and store pairwise module similarities
-    this.computeModuleSimilarities(moduleId, input.source, input.language);
-
-    this.eventBus.emit('module:registered', { moduleId, projectId: project.id });
-    this.logger.info(`Code module registered (id=${moduleId}, name=${input.name}, granularity=${granularity}, score=${reusabilityScore.toFixed(2)})`);
-
-    return { moduleId, isNew: true, reusabilityScore };
-  }
-
-  findReusable(input: FindReusableInput): CodeModuleRecord[] {
-    if (input.query) {
-      return this.codeModuleRepo.search(input.query);
-    }
-    if (input.language) {
-      return this.codeModuleRepo.findByLanguage(input.language, input.limit);
-    }
-    if (input.projectId) {
-      return this.codeModuleRepo.findByProject(input.projectId);
-    }
-    return [];
-  }
-
-  checkSimilarity(source: string, language: string): Array<{ moduleId: number; score: number; matchType: string }> {
-    const fingerprint = fingerprintCode(source, language);
-    const allModules = this.codeModuleRepo.findByLanguage(language);
-
-    const exact = findExactMatches(fingerprint, allModules);
-    if (exact.length > 0) return exact;
-
-    return findSemanticMatches(source, allModules, 0.5);
-  }
-
-  listModules(projectId?: number, language?: string, limit?: number): CodeModuleRecord[] {
-    if (projectId) {
-      return this.codeModuleRepo.findByProject(projectId);
-    }
-    if (language) {
-      return this.codeModuleRepo.findByLanguage(language, limit);
-    }
-    return this.codeModuleRepo.findAll(limit);
-  }
-
-  getById(id: number): CodeModuleRecord | undefined {
-    return this.codeModuleRepo.getById(id);
-  }
-
-  private computeModuleSimilarities(moduleId: number, source: string, language: string): void {
-    const allModules = this.codeModuleRepo.findByLanguage(language, 100);
-    const candidates = allModules.filter(m => m.id !== moduleId);
-    if (candidates.length === 0) return;
-
-    const matches = findStructuralMatches(source, language, candidates, 0.3);
-
-    // Get vector similarity scores if embedding engine is ready
-    const vectorScores = this.embeddingEngine?.isReady()
-      ? this.embeddingEngine.computeModuleVectorScores(moduleId, language)
-      : undefined;
-
-    // Merge structural matches with vector boost
-    const scoreMap = new Map<number, number>();
-    for (const match of matches) {
-      if (match.score >= 0.3 && match.moduleId !== moduleId) {
-        scoreMap.set(match.moduleId, match.score);
-      }
-    }
-
-    // Add vector-only matches that structural search missed
-    if (vectorScores) {
-      for (const [candId, vecScore] of vectorScores) {
-        if (vecScore >= 0.5 && candId !== moduleId) {
-          const existing = scoreMap.get(candId);
-          if (existing) {
-            // Boost structural score with vector similarity
-            scoreMap.set(candId, Math.min(1.0, existing + vecScore * 0.15));
-          } else {
-            // Vector-only match
-            scoreMap.set(candId, vecScore * 0.8);
-          }
-        }
-      }
-    }
-
-    for (const [candId, score] of scoreMap) {
-      this.codeModuleRepo.upsertSimilarity(moduleId, candId, score);
-
-      // High similarity → create synapse
-      if (score >= 0.7) {
-        this.synapseManager.strengthen(
-          { type: 'code_module', id: moduleId },
-          { type: 'code_module', id: candId },
-          'similar_to',
-        );
-      }
-    }
-  }
-
-  private indexDependencySynapses(moduleId: number, internalDeps: string[], projectId: number): void {
-    const projectModules = this.codeModuleRepo.findByProject(projectId);
-
-    for (const dep of internalDeps) {
-      // Normalize the dep path to match against registered modules
-      const depName = dep.replace(/^\.\//, '').replace(/\.\w+$/, '');
-
-      const target = projectModules.find(m => {
-        const modulePath = m.file_path.replace(/\\/g, '/').replace(/\.\w+$/, '');
-        return modulePath.endsWith(depName) || m.name === depName;
-      });
-
-      if (target && target.id !== moduleId) {
-        this.synapseManager.strengthen(
-          { type: 'code_module', id: moduleId },
-          { type: 'code_module', id: target.id },
-          'depends_on',
-        );
-      }
-    }
-  }
-
-  listProjects(): Array<{ id: number; name: string; path: string | null; language: string | null; framework: string | null; moduleCount: number }> {
-    const projects = this.projectRepo.getAll();
-    return projects.map(p => ({
-      id: p.id,
-      name: p.name,
-      path: p.path,
-      language: p.language,
-      framework: p.framework,
-      moduleCount: this.codeModuleRepo.findByProject(p.id).length,
-    }));
-  }
-}