@soleri/forge 5.14.0 → 5.14.1

package/dist/templates/brain.js

@@ -1,478 +0,0 @@
-/**
- * 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

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

package/dist/templates/core-facade.d.ts

@@ -1,6 +0,0 @@
-import type { AgentConfig } from '../types.js';
-/**
- * Generate the core facade that every agent gets — vault stats, search all,
- * health, identity, plus activation system (activate, deactivate, inject_claude_md, setup).
- */
-export declare function generateCoreFacade(config: AgentConfig): string;