@soleri/forge 4.2.2 → 5.0.0

package/dist/templates/brain.js

@@ -0,0 +1,478 @@
+/**
+ * Generates the brain.ts source file for a new agent.
+ * The Brain provides a local, zero-dependency intelligence layer:
+ * TF-IDF scoring, auto-tagging, duplicate detection, and search feedback.
+ */
+export function generateBrain() {
+    return BRAIN_TEMPLATE;
+}
+const BRAIN_TEMPLATE = [
+    "import type { Vault } from '../vault/vault.js';",
+    "import type { SearchResult } from '../vault/vault.js';",
+    "import type { IntelligenceEntry } from '../intelligence/types.js';",
+    '',
+    '// ─── Types ───────────────────────────────────────────────────────────',
+    '',
+    'export interface ScoringWeights {',
+    '  semantic: number;',
+    '  severity: number;',
+    '  recency: number;',
+    '  tagOverlap: number;',
+    '  domainMatch: number;',
+    '}',
+    '',
+    'export interface ScoreBreakdown {',
+    '  semantic: number;',
+    '  severity: number;',
+    '  recency: number;',
+    '  tagOverlap: number;',
+    '  domainMatch: number;',
+    '  total: number;',
+    '}',
+    '',
+    'export interface RankedResult {',
+    '  entry: IntelligenceEntry;',
+    '  score: number;',
+    '  breakdown: ScoreBreakdown;',
+    '}',
+    '',
+    'export interface SearchOptions {',
+    '  domain?: string;',
+    '  type?: string;',
+    '  severity?: string;',
+    '  limit?: number;',
+    '  tags?: string[];',
+    '}',
+    '',
+    'export interface CaptureResult {',
+    '  captured: boolean;',
+    '  id: string;',
+    '  autoTags: string[];',
+    '  duplicate?: { id: string; similarity: number };',
+    '  blocked?: boolean;',
+    '}',
+    '',
+    'export interface BrainStats {',
+    '  vocabularySize: number;',
+    '  feedbackCount: number;',
+    '  weights: ScoringWeights;',
+    '}',
+    '',
+    'export interface QueryContext {',
+    '  query: string;',
+    '  domain?: string;',
+    '  tags?: string[];',
+    '}',
+    '',
+    'type SparseVector = Map<string, number>;',
+    '',
+    '// ─── Stopwords ─────────────────────────────────────────────────────',
+    '',
+    'const STOPWORDS = new Set([',
+    "  'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',",
+    "  'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'been',",
+    "  'be', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',",
+    "  'should', 'may', 'might', 'shall', 'can', 'need', 'must', 'it', 'its',",
+    "  'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'we', 'they',",
+    "  'me', 'him', 'her', 'us', 'them', 'my', 'your', 'his', 'our', 'their',",
+    "  'what', 'which', 'who', 'whom', 'when', 'where', 'why', 'how', 'all',",
+    "  'each', 'every', 'both', 'few', 'more', 'most', 'other', 'some', 'such',",
+    "  'no', 'not', 'only', 'same', 'so', 'than', 'too', 'very', 'just',",
+    "  'because', 'if', 'then', 'else', 'about', 'up', 'out', 'into',",
+    ']);',
+    '',
+    '// ─── Text Processing (pure functions) ────────────────────────────',
+    '',
+    'function tokenize(text: string): string[] {',
+    '  return text',
+    '    .toLowerCase()',
+    "    .replace(/[^a-z0-9\\s-]/g, ' ')",
+    '    .split(/\\s+/)',
+    '    .filter((t) => t.length > 2 && !STOPWORDS.has(t));',
+    '}',
+    '',
+    'function calculateTf(tokens: string[]): SparseVector {',
+    '  const tf: SparseVector = new Map();',
+    '  for (const token of tokens) {',
+    '    tf.set(token, (tf.get(token) ?? 0) + 1);',
+    '  }',
+    '  // Normalize by document length',
+    '  const len = tokens.length || 1;',
+    '  for (const [term, count] of tf) {',
+    '    tf.set(term, count / len);',
+    '  }',
+    '  return tf;',
+    '}',
+    '',
+    'function calculateTfIdf(tokens: string[], vocabulary: Map<string, number>): SparseVector {',
+    '  const tf = calculateTf(tokens);',
+    '  const tfidf: SparseVector = new Map();',
+    '  for (const [term, tfValue] of tf) {',
+    '    const idf = vocabulary.get(term) ?? 0;',
+    '    if (idf > 0) {',
+    '      tfidf.set(term, tfValue * idf);',
+    '    }',
+    '  }',
+    '  return tfidf;',
+    '}',
+    '',
+    'function cosineSimilarity(a: SparseVector, b: SparseVector): number {',
+    '  let dot = 0;',
+    '  let normA = 0;',
+    '  let normB = 0;',
+    '  for (const [term, valA] of a) {',
+    '    normA += valA * valA;',
+    '    const valB = b.get(term);',
+    '    if (valB !== undefined) {',
+    '      dot += valA * valB;',
+    '    }',
+    '  }',
+    '  for (const [, valB] of b) {',
+    '    normB += valB * valB;',
+    '  }',
+    '  const denom = Math.sqrt(normA) * Math.sqrt(normB);',
+    '  return denom === 0 ? 0 : dot / denom;',
+    '}',
+    '',
+    'function jaccardSimilarity(a: string[], b: string[]): number {',
+    '  if (a.length === 0 && b.length === 0) return 0;',
+    '  const setA = new Set(a);',
+    '  const setB = new Set(b);',
+    '  let intersection = 0;',
+    '  for (const item of setA) {',
+    '    if (setB.has(item)) intersection++;',
+    '  }',
+    '  const union = new Set([...a, ...b]).size;',
+    '  return union === 0 ? 0 : intersection / union;',
+    '}',
+    '',
+    '// ─── Severity scoring ──────────────────────────────────────────────',
+    '',
+    'const SEVERITY_SCORES: Record<string, number> = {',
+    '  critical: 1.0,',
+    '  warning: 0.7,',
+    '  suggestion: 0.4,',
+    '};',
+    '',
+    '// ─── Brain Class ─────────────────────────────────────────────────',
+    '',
+    'const DEFAULT_WEIGHTS: ScoringWeights = {',
+    '  semantic: 0.40,',
+    '  severity: 0.15,',
+    '  recency: 0.15,',
+    '  tagOverlap: 0.15,',
+    '  domainMatch: 0.15,',
+    '};',
+    '',
+    'const WEIGHT_BOUND = 0.15;',
+    'const FEEDBACK_THRESHOLD = 30;',
+    'const DUPLICATE_BLOCK_THRESHOLD = 0.8;',
+    'const DUPLICATE_WARN_THRESHOLD = 0.6;',
+    'const RECENCY_HALF_LIFE_DAYS = 365;',
+    '',
+    'export class Brain {',
+    '  private vault: Vault;',
+    '  private vocabulary: Map<string, number> = new Map();',
+    '  private weights: ScoringWeights = { ...DEFAULT_WEIGHTS };',
+    '',
+    '  constructor(vault: Vault) {',
+    '    this.vault = vault;',
+    '    this.rebuildVocabulary();',
+    '    this.recomputeWeights();',
+    '  }',
+    '',
+    '  intelligentSearch(query: string, options?: SearchOptions): RankedResult[] {',
+    '    const limit = options?.limit ?? 10;',
+    '    // Get raw FTS5 results with higher limit for re-ranking',
+    '    const rawResults = this.vault.search(query, {',
+    '      domain: options?.domain,',
+    '      type: options?.type,',
+    '      severity: options?.severity,',
+    '      limit: Math.max(limit * 3, 30),',
+    '    });',
+    '',
+    '    if (rawResults.length === 0) return [];',
+    '',
+    '    const queryTokens = tokenize(query);',
+    '    const queryTags = options?.tags ?? [];',
+    '    const queryDomain = options?.domain;',
+    '    const now = Math.floor(Date.now() / 1000);',
+    '',
+    '    const ranked = rawResults.map((result) => {',
+    '      const entry = result.entry;',
+    '      const breakdown = this.scoreEntry(entry, queryTokens, queryTags, queryDomain, now);',
+    '      return { entry, score: breakdown.total, breakdown };',
+    '    });',
+    '',
+    '    ranked.sort((a, b) => b.score - a.score);',
+    '    return ranked.slice(0, limit);',
+    '  }',
+    '',
+    "  enrichAndCapture(entry: Partial<IntelligenceEntry> & { id: string; type: IntelligenceEntry['type']; domain: string; title: string; severity: IntelligenceEntry['severity']; description: string }): CaptureResult {",
+    '    // Auto-tag',
+    '    const autoTags = this.generateTags(entry.title, entry.description, entry.context);',
+    '    const mergedTags = Array.from(new Set([...(entry.tags ?? []), ...autoTags]));',
+    '',
+    '    // Duplicate detection: compare against top 50 FTS5 matches for the title',
+    '    const duplicate = this.detectDuplicate(entry.title, entry.domain);',
+    '',
+    '    if (duplicate && duplicate.similarity >= DUPLICATE_BLOCK_THRESHOLD) {',
+    '      return {',
+    '        captured: false,',
+    '        id: entry.id,',
+    '        autoTags,',
+    '        duplicate,',
+    '        blocked: true,',
+    '      };',
+    '    }',
+    '',
+    '    // Proceed with capture',
+    '    const fullEntry: IntelligenceEntry = {',
+    '      id: entry.id,',
+    '      type: entry.type,',
+    '      domain: entry.domain,',
+    '      title: entry.title,',
+    '      severity: entry.severity,',
+    '      description: entry.description,',
+    '      context: entry.context,',
+    '      example: entry.example,',
+    '      counterExample: entry.counterExample,',
+    '      why: entry.why,',
+    '      tags: mergedTags,',
+    '      appliesTo: entry.appliesTo,',
+    '    };',
+    '',
+    '    this.vault.add(fullEntry);',
+    '    this.updateVocabularyIncremental(fullEntry);',
+    '',
+    '    const result: CaptureResult = {',
+    '      captured: true,',
+    '      id: entry.id,',
+    '      autoTags,',
+    '    };',
+    '',
+    '    if (duplicate && duplicate.similarity >= DUPLICATE_WARN_THRESHOLD) {',
+    '      result.duplicate = duplicate;',
+    '    }',
+    '',
+    '    return result;',
+    '  }',
+    '',
+    "  recordFeedback(query: string, entryId: string, action: 'accepted' | 'dismissed'): void {",
+    '    const db = this.vault.getDb();',
+    "    db.prepare('INSERT INTO brain_feedback (query, entry_id, action) VALUES (?, ?, ?)').run(query, entryId, action);",
+    '    this.recomputeWeights();',
+    '  }',
+    '',
+    '  getRelevantPatterns(context: QueryContext): RankedResult[] {',
+    '    return this.intelligentSearch(context.query, {',
+    '      domain: context.domain,',
+    '      tags: context.tags,',
+    '    });',
+    '  }',
+    '',
+    '  rebuildVocabulary(): void {',
+    '    const entries = this.vault.list({ limit: 100000 });',
+    '    const docCount = entries.length;',
+    '    if (docCount === 0) {',
+    '      this.vocabulary.clear();',
+    '      this.persistVocabulary();',
+    '      return;',
+    '    }',
+    '',
+    '    const termDocFreq = new Map<string, number>();',
+    '    for (const entry of entries) {',
+    "      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');",
+    '      const tokens = new Set(tokenize(text));',
+    '      for (const token of tokens) {',
+    '        termDocFreq.set(token, (termDocFreq.get(token) ?? 0) + 1);',
+    '      }',
+    '    }',
+    '',
+    '    this.vocabulary.clear();',
+    '    for (const [term, df] of termDocFreq) {',
+    '      const idf = Math.log((docCount + 1) / (df + 1)) + 1;',
+    '      this.vocabulary.set(term, idf);',
+    '    }',
+    '',
+    '    this.persistVocabulary();',
+    '  }',
+    '',
+    '  getStats(): BrainStats {',
+    '    const db = this.vault.getDb();',
+    "    const feedbackCount = (db.prepare('SELECT COUNT(*) as count FROM brain_feedback').get() as { count: number }).count;",
+    '    return {',
+    '      vocabularySize: this.vocabulary.size,',
+    '      feedbackCount,',
+    '      weights: { ...this.weights },',
+    '    };',
+    '  }',
+    '',
+    '  getVocabularySize(): number {',
+    '    return this.vocabulary.size;',
+    '  }',
+    '',
+    '  // ─── Private methods ─────────────────────────────────────────────',
+    '',
+    '  private scoreEntry(',
+    '    entry: IntelligenceEntry,',
+    '    queryTokens: string[],',
+    '    queryTags: string[],',
+    '    queryDomain: string | undefined,',
+    '    now: number',
+    '  ): ScoreBreakdown {',
+    '    // 1. Semantic (TF-IDF cosine similarity)',
+    '    let semantic = 0;',
+    '    if (this.vocabulary.size > 0 && queryTokens.length > 0) {',
+    "      const entryText = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');",
+    '      const entryTokens = tokenize(entryText);',
+    '      const queryVec = calculateTfIdf(queryTokens, this.vocabulary);',
+    '      const entryVec = calculateTfIdf(entryTokens, this.vocabulary);',
+    '      semantic = cosineSimilarity(queryVec, entryVec);',
+    '    }',
+    '',
+    '    // 2. Severity',
+    '    const severity = SEVERITY_SCORES[entry.severity] ?? 0.4;',
+    '',
+    '    // 3. Recency (exponential decay over 1 year)',
+    '    const entryAge = now - (entry as unknown as { created_at?: number }).created_at!;',
+    '    const halfLifeSeconds = RECENCY_HALF_LIFE_DAYS * 86400;',
+    '    const recency = entryAge > 0 ? Math.exp(-0.693 * entryAge / halfLifeSeconds) : 1;',
+    '',
+    '    // 4. Tag overlap (Jaccard)',
+    '    const tagOverlap = queryTags.length > 0 ? jaccardSimilarity(queryTags, entry.tags) : 0;',
+    '',
+    '    // 5. Domain match',
+    '    const domainMatch = queryDomain && entry.domain === queryDomain ? 1.0 : 0;',
+    '',
+    '    const total =',
+    '      this.weights.semantic * semantic +',
+    '      this.weights.severity * severity +',
+    '      this.weights.recency * recency +',
+    '      this.weights.tagOverlap * tagOverlap +',
+    '      this.weights.domainMatch * domainMatch;',
+    '',
+    '    return { semantic, severity, recency, tagOverlap, domainMatch, total };',
+    '  }',
+    '',
+    '  private generateTags(title: string, description: string, context?: string): string[] {',
+    "    const text = [title, description, context ?? ''].join(' ');",
+    '    const tokens = tokenize(text);',
+    '    if (tokens.length === 0) return [];',
+    '',
+    '    // Score tokens by TF-IDF',
+    '    const tf = calculateTf(tokens);',
+    '    const scored: Array<[string, number]> = [];',
+    '    for (const [term, tfValue] of tf) {',
+    '      const idf = this.vocabulary.get(term) ?? 1;',
+    '      scored.push([term, tfValue * idf]);',
+    '    }',
+    '',
+    '    scored.sort((a, b) => b[1] - a[1]);',
+    '    return scored.slice(0, 5).map(([term]) => term);',
+    '  }',
+    '',
+    '  private detectDuplicate(title: string, domain: string): { id: string; similarity: number } | null {',
+    '    let candidates: SearchResult[];',
+    '    try {',
+    '      candidates = this.vault.search(title, { domain, limit: 50 });',
+    '    } catch {',
+    '      return null;',
+    '    }',
+    '    if (candidates.length === 0) return null;',
+    '',
+    '    const titleTokens = tokenize(title);',
+    '    if (titleTokens.length === 0) return null;',
+    '    const titleVec = calculateTfIdf(titleTokens, this.vocabulary);',
+    '    if (titleVec.size === 0) {',
+    '      // Fallback: use raw TF for comparison when vocabulary is empty',
+    '      const titleTf = calculateTf(titleTokens);',
+    '      let bestMatch: { id: string; similarity: number } | null = null;',
+    '      for (const candidate of candidates) {',
+    '        const candidateTokens = tokenize(candidate.entry.title);',
+    '        const candidateTf = calculateTf(candidateTokens);',
+    '        const sim = cosineSimilarity(titleTf, candidateTf);',
+    '        if (!bestMatch || sim > bestMatch.similarity) {',
+    '          bestMatch = { id: candidate.entry.id, similarity: sim };',
+    '        }',
+    '      }',
+    '      return bestMatch;',
+    '    }',
+    '',
+    '    let bestMatch: { id: string; similarity: number } | null = null;',
+    '    for (const candidate of candidates) {',
+    "      const candidateText = [candidate.entry.title, candidate.entry.description].join(' ');",
+    '      const candidateTokens = tokenize(candidateText);',
+    '      const candidateVec = calculateTfIdf(candidateTokens, this.vocabulary);',
+    '      const sim = cosineSimilarity(titleVec, candidateVec);',
+    '      if (!bestMatch || sim > bestMatch.similarity) {',
+    '        bestMatch = { id: candidate.entry.id, similarity: sim };',
+    '      }',
+    '    }',
+    '    return bestMatch;',
+    '  }',
+    '',
+    '  private updateVocabularyIncremental(entry: IntelligenceEntry): void {',
+    "    const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');",
+    '    const tokens = new Set(tokenize(text));',
+    '    const totalDocs = this.vault.stats().totalEntries;',
+    '',
+    '    for (const token of tokens) {',
+    '      const currentDocCount = (this.vocabulary.has(token)) ? Math.round((totalDocs) / Math.exp(this.vocabulary.get(token)! - 1)) + 1 : 1;',
+    '      const newIdf = Math.log((totalDocs + 1) / (currentDocCount + 1)) + 1;',
+    '      this.vocabulary.set(token, newIdf);',
+    '    }',
+    '',
+    '    this.persistVocabulary();',
+    '  }',
+    '',
+    '  private persistVocabulary(): void {',
+    '    const db = this.vault.getDb();',
+    "    db.exec('DELETE FROM brain_vocabulary');",
+    '    if (this.vocabulary.size === 0) return;',
+    "    const insert = db.prepare('INSERT INTO brain_vocabulary (term, idf, doc_count) VALUES (?, ?, ?)');",
+    '    const tx = db.transaction(() => {',
+    '      for (const [term, idf] of this.vocabulary) {',
+    '        insert.run(term, idf, 1);',
+    '      }',
+    '    });',
+    '    tx();',
+    '  }',
+    '',
+    '  private recomputeWeights(): void {',
+    '    const db = this.vault.getDb();',
+    "    const feedbackCount = (db.prepare('SELECT COUNT(*) as count FROM brain_feedback').get() as { count: number }).count;",
+    '    if (feedbackCount < FEEDBACK_THRESHOLD) {',
+    '      this.weights = { ...DEFAULT_WEIGHTS };',
+    '      return;',
+    '    }',
+    '',
+    '    // Count accepted vs dismissed feedback',
+    '    const accepted = (db.prepare("SELECT COUNT(*) as count FROM brain_feedback WHERE action = \'accepted\'").get() as { count: number }).count;',
+    '    const acceptRate = feedbackCount > 0 ? accepted / feedbackCount : 0.5;',
+    '',
+    '    // High accept rate -> increase semantic weight, decrease others',
+    '    // Low accept rate -> decrease semantic weight, increase others',
+    '    const semanticDelta = (acceptRate - 0.5) * WEIGHT_BOUND * 2;',
+    '',
+    '    const newWeights = { ...DEFAULT_WEIGHTS };',
+    '    newWeights.semantic = clamp(DEFAULT_WEIGHTS.semantic + semanticDelta, DEFAULT_WEIGHTS.semantic - WEIGHT_BOUND, DEFAULT_WEIGHTS.semantic + WEIGHT_BOUND);',
+    '',
+    '    // Redistribute remaining weight evenly across other dimensions',
+    '    const remaining = 1.0 - newWeights.semantic;',
+    '    const otherSum = DEFAULT_WEIGHTS.severity + DEFAULT_WEIGHTS.recency + DEFAULT_WEIGHTS.tagOverlap + DEFAULT_WEIGHTS.domainMatch;',
+    '    const scale = remaining / otherSum;',
+    '    newWeights.severity = DEFAULT_WEIGHTS.severity * scale;',
+    '    newWeights.recency = DEFAULT_WEIGHTS.recency * scale;',
+    '    newWeights.tagOverlap = DEFAULT_WEIGHTS.tagOverlap * scale;',
+    '    newWeights.domainMatch = DEFAULT_WEIGHTS.domainMatch * scale;',
+    '',
+    '    this.weights = newWeights;',
+    '  }',
+    '}',
+    '',
+    'function clamp(value: number, min: number, max: number): number {',
+    '  return Math.max(min, Math.min(max, value));',
+    '}',
+].join('\n');
+//# sourceMappingURL=brain.js.map

package/dist/templates/brain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain.js","sourceRoot":"","sources":["../../src/templates/brain.ts"],"names":[],"mappings":"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"}