@soleri/core 2.0.2 → 2.4.0

package/src/control/types.ts

@@ -0,0 +1,102 @@
+/**
+ * Types for Identity Management and Intent Routing.
+ *
+ * Two separate concerns:
+ * - Identity: agent persona CRUD with versioning and guidelines
+ * - Intent Routing: keyword-based intent classification and operational modes
+ */
+
+// ─── Identity Types ──────────────────────────────────────────────────
+
+export type GuidelineCategory = 'behavior' | 'preference' | 'restriction' | 'style';
+
+export interface Guideline {
+  id: string;
+  category: GuidelineCategory;
+  text: string;
+  priority: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AgentIdentity {
+  agentId: string;
+  name: string;
+  role: string;
+  description: string;
+  personality: string[];
+  guidelines: Guideline[];
+  version: number;
+  updatedAt: string;
+}
+
+export interface IdentityVersion {
+  version: number;
+  snapshot: string;
+  changedBy: string;
+  changeReason: string;
+  createdAt: string;
+}
+
+export interface IdentityUpdateInput {
+  name?: string;
+  role?: string;
+  description?: string;
+  personality?: string[];
+  changedBy?: string;
+  changeReason?: string;
+}
+
+export interface GuidelineInput {
+  category: GuidelineCategory;
+  text: string;
+  priority?: number;
+}
+
+// ─── Intent Routing Types ────────────────────────────────────────────
+
+export type IntentType =
+  | 'build'
+  | 'fix'
+  | 'validate'
+  | 'design'
+  | 'improve'
+  | 'deliver'
+  | 'explore'
+  | 'plan'
+  | 'review'
+  | 'general';
+
+export type OperationalMode =
+  | 'BUILD-MODE'
+  | 'FIX-MODE'
+  | 'VALIDATE-MODE'
+  | 'DESIGN-MODE'
+  | 'IMPROVE-MODE'
+  | 'DELIVER-MODE'
+  | 'EXPLORE-MODE'
+  | 'PLAN-MODE'
+  | 'REVIEW-MODE'
+  | 'GENERAL-MODE';
+
+export interface IntentClassification {
+  intent: IntentType;
+  mode: OperationalMode;
+  confidence: number;
+  method: 'keyword';
+  matchedKeywords: string[];
+}
+
+export interface ModeConfig {
+  mode: OperationalMode;
+  intent: IntentType;
+  description: string;
+  behaviorRules: string[];
+  keywords: string[];
+}
+
+export interface MorphResult {
+  previousMode: OperationalMode;
+  currentMode: OperationalMode;
+  behaviorRules: string[];
+}

package/src/curator/curator.ts

@@ -93,6 +93,15 @@ export class Curator {
         created_at INTEGER NOT NULL DEFAULT (unixepoch())
       );
 
+      CREATE TABLE IF NOT EXISTS curator_entry_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        entry_id TEXT NOT NULL,
+        snapshot TEXT NOT NULL,
+        changed_by TEXT DEFAULT 'system',
+        change_reason TEXT,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch())
+      );
+
       CREATE TABLE IF NOT EXISTS curator_contradictions (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         pattern_id TEXT NOT NULL,
@@ -188,7 +197,13 @@ export class Curator {
         JSON.stringify(dedupedTags),
         entryId,
       );
-      this.logChange('normalize_tags', entryId, JSON.stringify(entry.tags), JSON.stringify(dedupedTags), 'Tag normalization');
+      this.logChange(
+        'normalize_tags',
+        entryId,
+        JSON.stringify(entry.tags),
+        JSON.stringify(dedupedTags),
+        'Tag normalization',
+      );
     }
 
     return results;
@@ -245,13 +260,13 @@ export class Curator {
     // Build vectors for all entries
     const vectors = new Map<string, SparseVector>();
     for (const entry of entries) {
-      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');
+      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(
+        ' ',
+      );
       vectors.set(entry.id, calculateTfIdf(tokenize(text), vocabulary));
     }
 
-    const targetEntries = entryId
-      ? entries.filter((e) => e.id === entryId)
-      : entries;
+    const targetEntries = entryId ? entries.filter((e) => e.id === entryId) : entries;
 
     const results: DuplicateDetectionResult[] = [];
 
@@ -428,7 +443,8 @@ export class Curator {
     const dryRun = options?.dryRun ?? true;
     const staleDaysThreshold = options?.staleDaysThreshold ?? DEFAULT_STALE_DAYS;
     const duplicateThreshold = options?.duplicateThreshold ?? DEFAULT_DUPLICATE_THRESHOLD;
-    const contradictionThreshold = options?.contradictionThreshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
+    const contradictionThreshold =
+      options?.contradictionThreshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
 
     // Detect duplicates
     const duplicates = this.detectDuplicates(undefined, duplicateThreshold);
@@ -455,7 +471,13 @@ export class Curator {
            VALUES (?, 'archived', unixepoch())
            ON CONFLICT(entry_id) DO UPDATE SET status = 'archived', last_groomed_at = unixepoch()`,
         ).run(entryId);
-        this.logChange('archive', entryId, 'active', 'archived', 'Stale entry archived during consolidation');
+        this.logChange(
+          'archive',
+          entryId,
+          'active',
+          'archived',
+          'Stale entry archived during consolidation',
+        );
         mutations++;
       }
 
@@ -526,9 +548,21 @@ export class Curator {
     const hasAntiPatterns = typeCount['anti-pattern'] > 0;
     const hasRules = typeCount.rule > 0;
     let coverageScore = 1;
-    if (!hasPatterns) { score -= 10; coverageScore -= 0.33; recommendations.push('No patterns found — add patterns to improve coverage.'); }
-    if (!hasAntiPatterns) { score -= 5; coverageScore -= 0.17; recommendations.push('No anti-patterns found — add anti-patterns to detect contradictions.'); }
-    if (!hasRules) { score -= 5; coverageScore -= 0.17; recommendations.push('No rules found — add rules for completeness.'); }
+    if (!hasPatterns) {
+      score -= 10;
+      coverageScore -= 0.33;
+      recommendations.push('No patterns found — add patterns to improve coverage.');
+    }
+    if (!hasAntiPatterns) {
+      score -= 5;
+      coverageScore -= 0.17;
+      recommendations.push('No anti-patterns found — add anti-patterns to detect contradictions.');
+    }
+    if (!hasRules) {
+      score -= 5;
+      coverageScore -= 0.17;
+      recommendations.push('No rules found — add rules for completeness.');
+    }
     coverageScore = Math.max(0, coverageScore);
 
     // Freshness: penalize stale entries
@@ -536,14 +570,18 @@ export class Curator {
     const now = Math.floor(Date.now() / 1000);
     const staleThreshold = now - DEFAULT_STALE_DAYS * 86400;
     const staleCount = (
-      db.prepare('SELECT COUNT(*) as count FROM entries WHERE updated_at < ?').get(staleThreshold) as { count: number }
+      db
+        .prepare('SELECT COUNT(*) as count FROM entries WHERE updated_at < ?')
+        .get(staleThreshold) as { count: number }
     ).count;
     const staleRatio = staleCount / entries.length;
     const freshnessScore = 1 - staleRatio;
     if (staleRatio > 0.3) {
       const penalty = Math.min(20, Math.round(staleRatio * 30));
       score -= penalty;
-      recommendations.push(`${staleCount} stale entries (${Math.round(staleRatio * 100)}%) — run grooming to update.`);
+      recommendations.push(
+        `${staleCount} stale entries (${Math.round(staleRatio * 100)}%) — run grooming to update.`,
+      );
     }
 
     // Quality: penalize duplicates and contradictions
@@ -571,12 +609,18 @@ export class Curator {
     if (lowTagRatio > 0.3) {
       const penalty = Math.min(10, Math.round(lowTagRatio * 15));
       score -= penalty;
-      recommendations.push(`${lowTagEntries.length} entries have fewer than 2 tags — improve tagging.`);
+      recommendations.push(
+        `${lowTagEntries.length} entries have fewer than 2 tags — improve tagging.`,
+      );
     }
 
     // Penalize ungroomed entries
     const groomedCount = (
-      db.prepare('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL').get() as { count: number }
+      db
+        .prepare(
+          'SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL',
+        )
+        .get() as { count: number }
     ).count;
     if (groomedCount < entries.length) {
       const ungroomed = entries.length - groomedCount;
@@ -603,13 +647,219 @@ export class Curator {
     };
   }
 
+  // ─── Entry History (Version Snapshots) ─────────────────────────
+
+  recordSnapshot(
+    entryId: string,
+    changedBy?: string,
+    changeReason?: string,
+  ): { recorded: boolean; historyId: number } {
+    const entry = this.vault.get(entryId);
+    if (!entry) return { recorded: false, historyId: -1 };
+
+    const db = this.vault.getDb();
+    const result = db
+      .prepare(
+        'INSERT INTO curator_entry_history (entry_id, snapshot, changed_by, change_reason, created_at) VALUES (?, ?, ?, ?, unixepoch())',
+      )
+      .run(entryId, JSON.stringify(entry), changedBy ?? 'system', changeReason ?? null);
+
+    return { recorded: true, historyId: Number(result.lastInsertRowid) };
+  }
+
+  getVersionHistory(
+    entryId: string,
+  ): Array<{
+    historyId: number;
+    entryId: string;
+    snapshot: IntelligenceEntry;
+    changedBy: string;
+    changeReason: string | null;
+    createdAt: number;
+  }> {
+    const db = this.vault.getDb();
+    const rows = db
+      .prepare(
+        'SELECT * FROM curator_entry_history WHERE entry_id = ? ORDER BY created_at ASC, id ASC',
+      )
+      .all(entryId) as Array<Record<string, unknown>>;
+
+    return rows.map((row) => ({
+      historyId: row.id as number,
+      entryId: row.entry_id as string,
+      snapshot: JSON.parse(row.snapshot as string) as IntelligenceEntry,
+      changedBy: row.changed_by as string,
+      changeReason: (row.change_reason as string) ?? null,
+      createdAt: row.created_at as number,
+    }));
+  }
+
+  // ─── Queue Stats ──────────────────────────────────────────────
+
+  getQueueStats(): {
+    totalEntries: number;
+    groomedEntries: number;
+    ungroomedEntries: number;
+    staleEntries: number;
+    freshEntries: number;
+    avgDaysSinceGroom: number;
+  } {
+    const db = this.vault.getDb();
+    const totalEntries = (
+      db.prepare('SELECT COUNT(*) as count FROM entries').get() as { count: number }
+    ).count;
+
+    const groomedEntries = (
+      db
+        .prepare(
+          'SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL',
+        )
+        .get() as { count: number }
+    ).count;
+
+    const ungroomedEntries = totalEntries - groomedEntries;
+
+    const now = Math.floor(Date.now() / 1000);
+    const staleThreshold = now - 30 * 86400;
+    const freshThreshold = now - 7 * 86400;
+
+    const staleEntries = (
+      db
+        .prepare(
+          'SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL AND last_groomed_at < ?',
+        )
+        .get(staleThreshold) as { count: number }
+    ).count;
+
+    const freshEntries = (
+      db
+        .prepare(
+          'SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL AND last_groomed_at >= ?',
+        )
+        .get(freshThreshold) as { count: number }
+    ).count;
+
+    let avgDaysSinceGroom = 0;
+    if (groomedEntries > 0) {
+      const sumRow = db
+        .prepare(
+          'SELECT SUM(? - last_groomed_at) as total FROM curator_entry_state WHERE last_groomed_at IS NOT NULL',
+        )
+        .get(now) as { total: number | null };
+      const totalSeconds = sumRow.total ?? 0;
+      avgDaysSinceGroom = Math.round((totalSeconds / groomedEntries / 86400) * 100) / 100;
+    }
+
+    return {
+      totalEntries,
+      groomedEntries,
+      ungroomedEntries,
+      staleEntries,
+      freshEntries,
+      avgDaysSinceGroom,
+    };
+  }
+
+  // ─── Metadata Enrichment ──────────────────────────────────────
+
+  enrichMetadata(
+    entryId: string,
+  ): { enriched: boolean; changes: Array<{ field: string; before: string; after: string }> } {
+    const entry = this.vault.get(entryId);
+    if (!entry) return { enriched: false, changes: [] };
+
+    const changes: Array<{ field: string; before: string; after: string }> = [];
+    const updates: Partial<
+      Pick<IntelligenceEntry, 'title' | 'description' | 'tags' | 'severity' | 'type'>
+    > = {};
+
+    // Auto-capitalize title
+    if (entry.title.length > 0 && entry.title[0] !== entry.title[0].toUpperCase()) {
+      const capitalized = entry.title[0].toUpperCase() + entry.title.slice(1);
+      changes.push({ field: 'title', before: entry.title, after: capitalized });
+      updates.title = capitalized;
+    }
+
+    // Normalize tags: lowercase, trim, dedup
+    const normalizedTags = [...new Set(entry.tags.map((t) => t.toLowerCase().trim()))];
+    const tagsChanged =
+      normalizedTags.length !== entry.tags.length ||
+      normalizedTags.some((t, i) => t !== entry.tags[i]);
+    if (tagsChanged) {
+      changes.push({
+        field: 'tags',
+        before: JSON.stringify(entry.tags),
+        after: JSON.stringify(normalizedTags),
+      });
+      updates.tags = normalizedTags;
+    }
+
+    // Infer severity from keywords if currently 'suggestion'
+    if (entry.severity === 'suggestion') {
+      const text = (entry.title + ' ' + entry.description).toLowerCase();
+      const criticalKeywords = ['never', 'must not', 'critical', 'security', 'vulnerability'];
+      const warningKeywords = ['avoid', 'should not', 'deprecated', 'careful', 'warning'];
+      if (criticalKeywords.some((k) => text.includes(k))) {
+        changes.push({ field: 'severity', before: entry.severity, after: 'critical' });
+        updates.severity = 'critical';
+      } else if (warningKeywords.some((k) => text.includes(k))) {
+        changes.push({ field: 'severity', before: entry.severity, after: 'warning' });
+        updates.severity = 'warning';
+      }
+    }
+
+    // Infer type from title patterns
+    if (entry.type === 'pattern') {
+      const titleLower = entry.title.toLowerCase();
+      if (
+        titleLower.startsWith('avoid') ||
+        titleLower.startsWith('never') ||
+        titleLower.startsWith("don't") ||
+        titleLower.startsWith('do not')
+      ) {
+        changes.push({ field: 'type', before: entry.type, after: 'anti-pattern' });
+        updates.type = 'anti-pattern';
+      }
+    }
+
+    // Trim whitespace from description
+    const trimmed = entry.description.trim();
+    if (trimmed !== entry.description) {
+      changes.push({ field: 'description', before: entry.description, after: trimmed });
+      updates.description = trimmed;
+    }
+
+    if (changes.length === 0) {
+      return { enriched: false, changes: [] };
+    }
+
+    // Apply updates
+    this.vault.update(entryId, updates);
+
+    // Record snapshot
+    this.recordSnapshot(entryId, 'curator', 'Metadata enrichment');
+
+    // Log change
+    this.logChange(
+      'enrich_metadata',
+      entryId,
+      JSON.stringify(changes.map((c) => c.field)),
+      JSON.stringify(changes.map((c) => c.after)),
+      'Rule-based metadata enrichment',
+    );
+
+    return { enriched: true, changes };
+  }
+
   // ─── Private Helpers ────────────────────────────────────────────
 
   private buildVocabulary(entries: IntelligenceEntry[]): Map<string, number> {
     const docCount = entries.length;
     const termDocFreq = new Map<string, number>();
     for (const entry of entries) {
-      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');
+      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);