memorylink 1.0.0

package/src/utils/team-patterns.ts

@@ -0,0 +1,499 @@
+/**
+ * MemoryLink - Team Pattern Detection Utilities
+ * Analyze learnings.log to detect team coding patterns
+ * 
+ * v1.3: Team Pattern Detection feature
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { getFilePath, readJsonlEntries, findRoot } from '../utils.js';
+import type { LearningEntry } from '../types.js';
+
+// ============================================
+// TYPES
+// ============================================
+
+export interface TeamPattern {
+  pattern_name: string;
+  category: 'error_handling' | 'testing' | 'styling' | 'architecture' | 'api' | 'database' | 'other';
+  description: string;
+  code_example?: string;
+  adoption_rate: number; // 0-1
+  adopted_by: string[]; // Agent names
+  exceptions: TeamMemberException[];
+  success_rate: number; // 0-1
+  last_used: string; // ISO timestamp
+  evidence: string[]; // Learning IDs that support this pattern
+}
+
+export interface TeamMemberException {
+  name: string;
+  preferred_alternative: string;
+  reason?: string;
+  evidence: string[]; // Learning IDs
+}
+
+export interface TeamPatternsReport {
+  detectedAt: string;
+  problemPatterns: TeamPattern[];
+  stylePatterns: TeamPattern[];
+  teamConsensus: number; // 0-1 overall consensus score
+  recommendations: string[];
+}
+
+// ============================================
+// PATTERN DETECTION
+// ============================================
+
+/**
+ * Detect team patterns from learnings.log
+ */
+export function detectTeamPatterns(rootDir: string): TeamPatternsReport {
+  const learningsPath = getFilePath('LEARNINGS', rootDir);
+  
+  if (!fs.existsSync(learningsPath)) {
+    return {
+      detectedAt: new Date().toISOString(),
+      problemPatterns: [],
+      stylePatterns: [],
+      teamConsensus: 0,
+      recommendations: ['No learnings found. Start logging solutions to detect patterns.'],
+    };
+  }
+  
+  const learnings = readJsonlEntries<LearningEntry>(learningsPath)
+    .filter(e => e.status === 'ACTIVE');
+  
+  if (learnings.length === 0) {
+    return {
+      detectedAt: new Date().toISOString(),
+      problemPatterns: [],
+      stylePatterns: [],
+      teamConsensus: 0,
+      recommendations: ['No active learnings found. Log successful solutions to detect patterns.'],
+    };
+  }
+  
+  // Group learnings by problem type and solution
+  const problemPatterns = groupByProblemSolution(learnings);
+  
+  // Detect coding style preferences
+  const stylePatterns = detectCodingStyles(learnings);
+  
+  // Calculate team consensus
+  const teamConsensus = calculateConsensus(problemPatterns, stylePatterns);
+  
+  // Generate recommendations
+  const recommendations = generateRecommendations(problemPatterns, stylePatterns, teamConsensus);
+  
+  return {
+    detectedAt: new Date().toISOString(),
+    problemPatterns,
+    stylePatterns,
+    teamConsensus,
+    recommendations,
+  };
+}
+
+/**
+ * Group learnings by problem type and solution
+ */
+function groupByProblemSolution(learnings: LearningEntry[]): TeamPattern[] {
+  const patterns = new Map<string, {
+    learnings: LearningEntry[];
+    category: TeamPattern['category'];
+  }>();
+  
+  for (const learning of learnings) {
+    // Normalize problem and solution for grouping
+    const normalizedProblem = normalizeText(learning.problem);
+    const normalizedSolution = normalizeText(learning.solution);
+    
+    // Categorize based on keywords
+    const category = categorizeLearning(learning);
+    
+    // Create pattern key
+    const patternKey = `${category}:${normalizedProblem.substring(0, 50)}`;
+    
+    if (!patterns.has(patternKey)) {
+      patterns.set(patternKey, {
+        learnings: [],
+        category,
+      });
+    }
+    
+    patterns.get(patternKey)!.learnings.push(learning);
+  }
+  
+  // Convert to TeamPattern objects
+  const teamPatterns: TeamPattern[] = [];
+  
+  for (const [key, data] of patterns.entries()) {
+    const learnings = data.learnings;
+    
+    // Only consider patterns with multiple occurrences or high success rate
+    if (learnings.length < 2 && learnings.filter(l => l.outcome === 'SUCCESS').length < 2) {
+      continue;
+    }
+    
+    // Calculate adoption rate
+    const uniqueAgents = new Set(learnings.map(l => l.agent));
+    const adoptionRate = uniqueAgents.size / Math.max(5, learnings.length); // Normalize
+    
+    // Calculate success rate
+    const successCount = learnings.filter(l => l.outcome === 'SUCCESS').length;
+    const successRate = successCount / learnings.length;
+    
+    // Find exceptions (agents who use different solutions)
+    const exceptions = findExceptions(learnings);
+    
+    // Get most recent usage
+    const lastUsed = learnings
+      .map(l => l.ts)
+      .sort()
+      .reverse()[0];
+    
+    // Extract pattern name from problem
+    const patternName = extractPatternName(learnings[0].problem);
+    
+    teamPatterns.push({
+      pattern_name: patternName,
+      category: data.category,
+      description: learnings[0].problem,
+      code_example: extractCodeExample(learnings[0].solution),
+      adoption_rate: Math.min(1, adoptionRate),
+      adopted_by: Array.from(uniqueAgents),
+      exceptions,
+      success_rate: successRate,
+      last_used: lastUsed,
+      evidence: learnings.map(l => l.id),
+    });
+  }
+  
+  // Sort by adoption rate and success rate
+  teamPatterns.sort((a, b) => {
+    const scoreA = a.adoption_rate * 0.6 + a.success_rate * 0.4;
+    const scoreB = b.adoption_rate * 0.6 + b.success_rate * 0.4;
+    return scoreB - scoreA;
+  });
+  
+  return teamPatterns;
+}
+
+/**
+ * Detect coding style preferences
+ */
+function detectCodingStyles(learnings: LearningEntry[]): TeamPattern[] {
+  const stylePatterns: TeamPattern[] = [];
+  
+  // Look for style-related keywords in solutions
+  const styleKeywords = {
+    error_handling: ['try-catch', 'try catch', 'error handling', 'exception', 'throw', 'catch'],
+    testing: ['test', 'describe', 'it(', 'expect', 'assert', 'mock', 'stub'],
+    styling: ['format', 'lint', 'prettier', 'eslint', 'style', 'indent'],
+    api: ['api', 'endpoint', 'route', 'request', 'response', 'status code'],
+    database: ['database', 'db', 'query', 'sql', 'migration', 'schema'],
+  };
+  
+  for (const [category, keywords] of Object.entries(styleKeywords)) {
+    const matchingLearnings = learnings.filter(l => {
+      const solutionLower = l.solution.toLowerCase();
+      return keywords.some(keyword => solutionLower.includes(keyword));
+    });
+    
+    if (matchingLearnings.length >= 2) {
+      const uniqueAgents = new Set(matchingLearnings.map(l => l.agent));
+      const successCount = matchingLearnings.filter(l => l.outcome === 'SUCCESS').length;
+      
+      stylePatterns.push({
+        pattern_name: `${category} style`,
+        category: category as TeamPattern['category'],
+        description: `Team prefers ${category} approach`,
+        adoption_rate: uniqueAgents.size / Math.max(5, matchingLearnings.length),
+        adopted_by: Array.from(uniqueAgents),
+        exceptions: [],
+        success_rate: successCount / matchingLearnings.length,
+        last_used: matchingLearnings
+          .map(l => l.ts)
+          .sort()
+          .reverse()[0],
+        evidence: matchingLearnings.map(l => l.id),
+      });
+    }
+  }
+  
+  return stylePatterns;
+}
+
+/**
+ * Categorize learning based on content
+ */
+function categorizeLearning(learning: LearningEntry): TeamPattern['category'] {
+  const problemLower = learning.problem.toLowerCase();
+  const solutionLower = learning.solution.toLowerCase();
+  
+  if (problemLower.includes('error') || problemLower.includes('exception') || solutionLower.includes('try-catch')) {
+    return 'error_handling';
+  }
+  if (problemLower.includes('test') || solutionLower.includes('test') || solutionLower.includes('describe')) {
+    return 'testing';
+  }
+  if (problemLower.includes('api') || problemLower.includes('endpoint') || solutionLower.includes('route')) {
+    return 'api';
+  }
+  if (problemLower.includes('database') || problemLower.includes('db') || solutionLower.includes('query')) {
+    return 'database';
+  }
+  if (problemLower.includes('style') || problemLower.includes('format') || solutionLower.includes('prettier')) {
+    return 'styling';
+  }
+  if (problemLower.includes('architecture') || problemLower.includes('structure') || problemLower.includes('design')) {
+    return 'architecture';
+  }
+  
+  return 'other';
+}
+
+/**
+ * Find exceptions (team members who use different solutions)
+ */
+function findExceptions(learnings: LearningEntry[]): TeamMemberException[] {
+  const exceptions: TeamMemberException[] = [];
+  
+  // Group by agent
+  const byAgent = new Map<string, LearningEntry[]>();
+  for (const learning of learnings) {
+    if (!byAgent.has(learning.agent)) {
+      byAgent.set(learning.agent, []);
+    }
+    byAgent.get(learning.agent)!.push(learning);
+  }
+  
+  // Find agents with different solutions
+  const mostCommonSolution = getMostCommonSolution(learnings);
+  
+  for (const [agent, agentLearnings] of byAgent.entries()) {
+    const agentSolution = getMostCommonSolution(agentLearnings);
+    
+    if (agentSolution !== mostCommonSolution && agentLearnings.length > 0) {
+      exceptions.push({
+        name: agent,
+        preferred_alternative: agentSolution,
+        evidence: agentLearnings.map(l => l.id),
+      });
+    }
+  }
+  
+  return exceptions;
+}
+
+/**
+ * Get most common solution from learnings
+ */
+function getMostCommonSolution(learnings: LearningEntry[]): string {
+  const solutionCounts = new Map<string, number>();
+  
+  for (const learning of learnings) {
+    const normalized = normalizeText(learning.solution);
+    solutionCounts.set(normalized, (solutionCounts.get(normalized) || 0) + 1);
+  }
+  
+  let maxCount = 0;
+  let mostCommon = '';
+  
+  for (const [solution, count] of solutionCounts.entries()) {
+    if (count > maxCount) {
+      maxCount = count;
+      mostCommon = solution;
+    }
+  }
+  
+  return mostCommon;
+}
+
+/**
+ * Calculate team consensus score
+ */
+function calculateConsensus(
+  problemPatterns: TeamPattern[],
+  stylePatterns: TeamPattern[]
+): number {
+  if (problemPatterns.length === 0 && stylePatterns.length === 0) {
+    return 0;
+  }
+  
+  const allPatterns = [...problemPatterns, ...stylePatterns];
+  const avgAdoption = allPatterns.reduce((sum, p) => sum + p.adoption_rate, 0) / allPatterns.length;
+  const avgSuccess = allPatterns.reduce((sum, p) => sum + p.success_rate, 0) / allPatterns.length;
+  
+  // Consensus is weighted average of adoption and success
+  return (avgAdoption * 0.7 + avgSuccess * 0.3);
+}
+
+/**
+ * Generate recommendations based on patterns
+ */
+function generateRecommendations(
+  problemPatterns: TeamPattern[],
+  stylePatterns: TeamPattern[],
+  consensus: number
+): string[] {
+  const recommendations: string[] = [];
+  
+  if (consensus < 0.5) {
+    recommendations.push('⚠️  Low team consensus detected. Consider standardizing approaches.');
+  }
+  
+  // High adoption patterns
+  const highAdoption = [...problemPatterns, ...stylePatterns]
+    .filter(p => p.adoption_rate > 0.8 && p.success_rate > 0.8);
+  
+  if (highAdoption.length > 0) {
+    recommendations.push(`✅ ${highAdoption.length} strong pattern(s) detected with high adoption and success rates.`);
+  }
+  
+  // Patterns with exceptions
+  const withExceptions = [...problemPatterns, ...stylePatterns]
+    .filter(p => p.exceptions.length > 0);
+  
+  if (withExceptions.length > 0) {
+    recommendations.push(`⚠️  ${withExceptions.length} pattern(s) have team member exceptions. Consider discussing standardization.`);
+  }
+  
+  // Low success patterns
+  const lowSuccess = [...problemPatterns, ...stylePatterns]
+    .filter(p => p.success_rate < 0.5 && p.adoption_rate > 0.5);
+  
+  if (lowSuccess.length > 0) {
+    recommendations.push(`❌ ${lowSuccess.length} pattern(s) have low success rates despite high adoption. Consider alternative approaches.`);
+  }
+  
+  if (recommendations.length === 0) {
+    recommendations.push('✅ Team patterns look good! Continue logging learnings to refine patterns.');
+  }
+  
+  return recommendations;
+}
+
+/**
+ * Suggest patterns for a given context
+ */
+export function suggestPatterns(
+  context: string,
+  rootDir: string
+): TeamPattern[] {
+  const report = detectTeamPatterns(rootDir);
+  const allPatterns = [...report.problemPatterns, ...report.stylePatterns];
+  
+  const contextLower = context.toLowerCase();
+  
+  // Filter patterns that match context
+  const matchingPatterns = allPatterns.filter(pattern => {
+    const patternLower = pattern.description.toLowerCase();
+    const categoryLower = pattern.category.toLowerCase();
+    
+    return contextLower.includes(categoryLower) ||
+           patternLower.includes(contextLower) ||
+           contextLower.includes(patternLower);
+  });
+  
+  // Sort by relevance (adoption rate + success rate)
+  matchingPatterns.sort((a, b) => {
+    const scoreA = a.adoption_rate * 0.6 + a.success_rate * 0.4;
+    const scoreB = b.adoption_rate * 0.6 + b.success_rate * 0.4;
+    return scoreB - scoreA;
+  });
+  
+  return matchingPatterns.slice(0, 5); // Top 5 suggestions
+}
+
+// ============================================
+// HELPER FUNCTIONS
+// ============================================
+
+/**
+ * Normalize text for comparison
+ */
+function normalizeText(text: string): string {
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, ' ')
+    .substring(0, 100); // Limit length
+}
+
+/**
+ * Extract pattern name from problem description
+ */
+function extractPatternName(problem: string): string {
+  // Try to extract a short name from the problem
+  const words = problem.split(/\s+/);
+  if (words.length <= 5) {
+    return problem.substring(0, 50);
+  }
+  
+  // Take first few words
+  return words.slice(0, 4).join(' ') + '...';
+}
+
+/**
+ * Extract code example from solution
+ */
+function extractCodeExample(solution: string): string | undefined {
+  // Look for code blocks or code-like patterns
+  const codeBlockRegex = /```[\s\S]*?```/;
+  const match = solution.match(codeBlockRegex);
+  if (match) {
+    return match[0];
+  }
+  
+  // Look for function calls or code patterns
+  const codePatterns = [
+    /function\s+\w+/,
+    /const\s+\w+\s*=/,
+    /class\s+\w+/,
+    /\w+\([^)]*\)/,
+  ];
+  
+  for (const pattern of codePatterns) {
+    const match = solution.match(pattern);
+    if (match) {
+      return match[0];
+    }
+  }
+  
+  return undefined;
+}
+
+// ============================================
+// STORAGE
+// ============================================
+
+/**
+ * Save team patterns report to JSON file
+ */
+export function saveTeamPatterns(report: TeamPatternsReport, rootDir: string): void {
+  const patternsFile = path.join(rootDir, '.memorylink', 'team-patterns.json');
+  fs.writeFileSync(patternsFile, JSON.stringify(report, null, 2));
+}
+
+/**
+ * Load team patterns report from JSON file
+ */
+export function loadTeamPatterns(rootDir: string): TeamPatternsReport | null {
+  const patternsFile = path.join(rootDir, '.memorylink', 'team-patterns.json');
+  
+  try {
+    if (!fs.existsSync(patternsFile)) {
+      return null;
+    }
+    
+    const content = fs.readFileSync(patternsFile, 'utf-8');
+    return JSON.parse(content) as TeamPatternsReport;
+  } catch (error) {
+    console.error(`Error loading team patterns: ${error}`);
+    return null;
+  }
+}
+

package/src/utils/templates.ts

@@ -0,0 +1,181 @@
+/**
+ * MemoryLink - Templates System
+ * Quick templates for common memory/learning patterns
+ * 
+ * v1.3: Week 6 - Enhanced Auto-Capture
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { findRoot, isInitialized } from '../utils.js';
+
+export interface Template {
+  name: string;
+  description: string;
+  type: 'memory' | 'learning';
+  fields: {
+    [key: string]: string; // Field name -> default value or prompt
+  };
+  tags?: string[];
+}
+
+/**
+ * Default templates
+ */
+const DEFAULT_TEMPLATES: Template[] = [
+  {
+    name: 'bugfix',
+    description: 'Bug fix learning template',
+    type: 'learning',
+    fields: {
+      problem: 'Describe the bug...',
+      solution: 'Describe the fix...',
+      outcome: 'SUCCESS',
+    },
+    tags: ['bugfix', 'fix'],
+  },
+  {
+    name: 'decision',
+    description: 'Architectural or design decision',
+    type: 'memory',
+    fields: {
+      details: 'Describe the decision and rationale...',
+      type: 'decision',
+    },
+    tags: ['decision', 'architecture'],
+  },
+  {
+    name: 'experiment',
+    description: 'Experiment or trial learning',
+    type: 'learning',
+    fields: {
+      problem: 'What were you trying to achieve?',
+      solution: 'What did you try?',
+      outcome: 'SUCCESS', // or FAILED
+    },
+    tags: ['experiment', 'trial'],
+  },
+  {
+    name: 'refactor',
+    description: 'Code refactoring learning',
+    type: 'learning',
+    fields: {
+      problem: 'What needed refactoring?',
+      solution: 'How did you refactor it?',
+      outcome: 'SUCCESS',
+    },
+    tags: ['refactor', 'code-quality'],
+  },
+  {
+    name: 'rule',
+    description: 'Project rule or guideline',
+    type: 'memory',
+    fields: {
+      details: 'Describe the rule...',
+      type: 'rule',
+    },
+    tags: ['rule', 'guideline'],
+  },
+];
+
+/**
+ * Get templates directory
+ */
+function getTemplatesDir(root?: string): string {
+  const projectRoot = root || findRoot();
+  if (!projectRoot || !isInitialized(projectRoot)) {
+    throw new Error('MemoryLink is not initialized. Run: memorylink init');
+  }
+  return path.join(projectRoot, '.memorylink', 'templates');
+}
+
+/**
+ * Ensure templates directory exists
+ */
+function ensureTemplatesDir(root?: string): string {
+  const templatesDir = getTemplatesDir(root);
+  if (!fs.existsSync(templatesDir)) {
+    fs.mkdirSync(templatesDir, { recursive: true });
+  }
+  return templatesDir;
+}
+
+/**
+ * Get all templates (default + custom)
+ */
+export function getAllTemplates(root?: string): Template[] {
+  const templates: Template[] = [...DEFAULT_TEMPLATES];
+  const templatesDir = getTemplatesDir(root);
+
+  // Load custom templates
+  if (fs.existsSync(templatesDir)) {
+    const files = fs.readdirSync(templatesDir);
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        try {
+          const templatePath = path.join(templatesDir, file);
+          const templateData = JSON.parse(fs.readFileSync(templatePath, 'utf-8'));
+          templates.push(templateData as Template);
+        } catch {
+          // Skip invalid template files
+        }
+      }
+    }
+  }
+
+  return templates;
+}
+
+/**
+ * Get a specific template by name
+ */
+export function getTemplate(name: string, root?: string): Template | null {
+  const templates = getAllTemplates(root);
+  return templates.find(t => t.name === name) || null;
+}
+
+/**
+ * Save a custom template
+ */
+export function saveTemplate(template: Template, root?: string): void {
+  const templatesDir = ensureTemplatesDir(root);
+  const templatePath = path.join(templatesDir, `${template.name}.json`);
+  fs.writeFileSync(templatePath, JSON.stringify(template, null, 2));
+}
+
+/**
+ * Delete a custom template
+ */
+export function deleteTemplate(name: string, root?: string): void {
+  const templatesDir = getTemplatesDir(root);
+  const templatePath = path.join(templatesDir, `${name}.json`);
+
+  // Don't allow deleting default templates
+  if (DEFAULT_TEMPLATES.some(t => t.name === name)) {
+    throw new Error(`Cannot delete default template: ${name}`);
+  }
+
+  if (fs.existsSync(templatePath)) {
+    fs.unlinkSync(templatePath);
+  } else {
+    throw new Error(`Template not found: ${name}`);
+  }
+}
+
+/**
+ * Format template for display
+ */
+export function formatTemplate(template: Template): string {
+  let output = `Template: ${template.name}\n`;
+  output += `Description: ${template.description}\n`;
+  output += `Type: ${template.type}\n`;
+  output += `Fields:\n`;
+  Object.entries(template.fields).forEach(([key, value]) => {
+    output += `  ${key}: ${value}\n`;
+  });
+  if (template.tags && template.tags.length > 0) {
+    output += `Tags: ${template.tags.join(', ')}\n`;
+  }
+  return output;
+}
+