@weave_protocol/domere 1.0.0

package/src/language/semantic.ts

@@ -0,0 +1,385 @@
+/**
+ * Dōmere - The Judge Protocol
+ * Semantic Analysis
+ */
+
+import type {
+  SemanticAnalysis,
+  ExtractedEntity,
+  EntityType,
+  IntentClassification,
+} from '../types.js';
+import { INTENT_KEYWORDS, ENTITY_PATTERNS } from '../constants.js';
+
+// ============================================================================
+// Semantic Analyzer
+// ============================================================================
+
+export class SemanticAnalyzer {
+  /**
+   * Perform semantic analysis on content
+   */
+  analyze(content: string): SemanticAnalysis {
+    return {
+      intent_classification: this.classifyIntent(content),
+      entities: this.extractEntities(content),
+      actions_implied: this.extractImpliedActions(content),
+      topics: this.extractTopics(content),
+      sentiment: this.analyzeSentiment(content),
+      formality: this.analyzeFormality(content),
+      urgency: this.analyzeUrgency(content),
+    };
+  }
+  
+  /**
+   * Classify the intent of the content
+   */
+  classifyIntent(content: string): IntentClassification {
+    const contentLower = content.toLowerCase();
+    const scores: Record<IntentClassification, number> = {
+      query: 0,
+      mutation: 0,
+      deletion: 0,
+      execution: 0,
+      communication: 0,
+      analysis: 0,
+      generation: 0,
+      unknown: 0,
+    };
+    
+    // Score based on keywords
+    for (const [intent, keywords] of Object.entries(INTENT_KEYWORDS)) {
+      for (const keyword of keywords) {
+        const regex = new RegExp(`\\b${keyword}\\b`, 'gi');
+        const matches = contentLower.match(regex);
+        if (matches) {
+          scores[intent as IntentClassification] += matches.length;
+        }
+      }
+    }
+    
+    // Find highest scoring intent
+    let maxIntent: IntentClassification = 'unknown';
+    let maxScore = 0;
+    
+    for (const [intent, score] of Object.entries(scores)) {
+      if (score > maxScore) {
+        maxScore = score;
+        maxIntent = intent as IntentClassification;
+      }
+    }
+    
+    // If no strong signal, check question patterns
+    if (maxScore < 2) {
+      if (/^(what|where|who|when|how|why|which|is|are|do|does|can|could|would|should)\b/i.test(content.trim())) {
+        return 'query';
+      }
+    }
+    
+    return maxIntent;
+  }
+  
+  /**
+   * Extract entities from content
+   */
+  extractEntities(content: string): ExtractedEntity[] {
+    const entities: ExtractedEntity[] = [];
+    
+    // Extract using patterns
+    for (const [type, pattern] of Object.entries(ENTITY_PATTERNS)) {
+      const regex = new RegExp(pattern.source, pattern.flags);
+      let match;
+      
+      while ((match = regex.exec(content)) !== null) {
+        entities.push({
+          type: type as EntityType,
+          value: match[0],
+          confidence: 0.9,
+          position: { start: match.index, end: match.index + match[0].length },
+        });
+      }
+    }
+    
+    // Extract potential names (capitalized words not at start of sentence)
+    const namePattern = /(?<![.!?]\s)(?<!\n)\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b/g;
+    let match;
+    while ((match = namePattern.exec(content)) !== null) {
+      const value = match[1];
+      if (!this.isCommonPhrase(value)) {
+        entities.push({
+          type: 'person',
+          value,
+          confidence: 0.6,
+          position: { start: match.index, end: match.index + match[0].length },
+        });
+      }
+    }
+    
+    // Extract database/table references
+    const dbPattern = /\b(database|table|collection|schema|db)\s*[`'"]?(\w+)[`'"]?/gi;
+    while ((match = dbPattern.exec(content)) !== null) {
+      entities.push({
+        type: match[1].toLowerCase() === 'table' ? 'table' : 'database',
+        value: match[2],
+        confidence: 0.85,
+        position: { start: match.index, end: match.index + match[0].length },
+      });
+    }
+    
+    // Extract API endpoints
+    const apiPattern = /(?:api|endpoint|route):\s*([^\s,]+)|\/api\/[\w/]+/gi;
+    while ((match = apiPattern.exec(content)) !== null) {
+      entities.push({
+        type: 'api_endpoint',
+        value: match[1] || match[0],
+        confidence: 0.8,
+        position: { start: match.index, end: match.index + match[0].length },
+      });
+    }
+    
+    // Remove duplicates
+    return this.deduplicateEntities(entities);
+  }
+  
+  /**
+   * Extract implied actions from content
+   */
+  extractImpliedActions(content: string): string[] {
+    const actions: string[] = [];
+    const contentLower = content.toLowerCase();
+    
+    // Look for verb phrases
+    const verbPatterns = [
+      /\b(will|should|must|need to|want to|going to|have to)\s+(\w+(?:\s+\w+)?)/gi,
+      /\b(please|kindly)?\s*(get|fetch|create|update|delete|send|run|execute|analyze|generate)\s+/gi,
+      /\b(i want|i need|i'd like)\s+(?:to\s+)?(\w+)/gi,
+    ];
+    
+    for (const pattern of verbPatterns) {
+      let match;
+      while ((match = pattern.exec(contentLower)) !== null) {
+        const action = match[0].trim().replace(/^(please|kindly)\s*/i, '');
+        if (action.length > 3 && !actions.includes(action)) {
+          actions.push(action);
+        }
+      }
+    }
+    
+    // Infer from intent keywords
+    for (const [intent, keywords] of Object.entries(INTENT_KEYWORDS)) {
+      for (const keyword of keywords) {
+        if (contentLower.includes(keyword) && !actions.some(a => a.includes(keyword))) {
+          actions.push(`${keyword} data/content`);
+          break;
+        }
+      }
+    }
+    
+    return actions.slice(0, 10);
+  }
+  
+  /**
+   * Extract topics from content
+   */
+  extractTopics(content: string): string[] {
+    const topics: string[] = [];
+    const contentLower = content.toLowerCase();
+    
+    // Domain-specific topic detection
+    const topicPatterns: Record<string, RegExp[]> = {
+      'sales': [/\b(sales|revenue|quota|deal|pipeline|forecast)\b/gi],
+      'customer': [/\b(customer|client|account|user|subscriber)\b/gi],
+      'finance': [/\b(finance|budget|expense|cost|profit|invoice|payment)\b/gi],
+      'hr': [/\b(employee|staff|hire|recruit|payroll|benefits|performance)\b/gi],
+      'marketing': [/\b(marketing|campaign|lead|conversion|engagement|brand)\b/gi],
+      'product': [/\b(product|feature|release|roadmap|backlog|sprint)\b/gi],
+      'engineering': [/\b(code|deploy|bug|fix|release|infrastructure|api)\b/gi],
+      'security': [/\b(security|password|auth|permission|access|credential)\b/gi],
+      'data': [/\b(data|database|query|report|analytics|metrics)\b/gi],
+      'support': [/\b(support|ticket|issue|help|resolve|escalat)\b/gi],
+    };
+    
+    for (const [topic, patterns] of Object.entries(topicPatterns)) {
+      for (const pattern of patterns) {
+        if (pattern.test(contentLower)) {
+          if (!topics.includes(topic)) {
+            topics.push(topic);
+          }
+          break;
+        }
+      }
+    }
+    
+    return topics;
+  }
+  
+  /**
+   * Analyze sentiment (-1 to 1)
+   */
+  analyzeSentiment(content: string): number {
+    const contentLower = content.toLowerCase();
+    
+    const positiveWords = [
+      'good', 'great', 'excellent', 'amazing', 'wonderful', 'fantastic', 'love',
+      'like', 'happy', 'pleased', 'thank', 'thanks', 'appreciate', 'helpful',
+      'perfect', 'awesome', 'brilliant', 'success', 'successful', 'best',
+    ];
+    
+    const negativeWords = [
+      'bad', 'terrible', 'awful', 'horrible', 'hate', 'dislike', 'angry',
+      'frustrated', 'annoyed', 'disappointed', 'fail', 'failed', 'failure',
+      'wrong', 'error', 'problem', 'issue', 'bug', 'broken', 'worst',
+    ];
+    
+    let positiveCount = 0;
+    let negativeCount = 0;
+    
+    for (const word of positiveWords) {
+      const regex = new RegExp(`\\b${word}\\b`, 'gi');
+      const matches = contentLower.match(regex);
+      if (matches) positiveCount += matches.length;
+    }
+    
+    for (const word of negativeWords) {
+      const regex = new RegExp(`\\b${word}\\b`, 'gi');
+      const matches = contentLower.match(regex);
+      if (matches) negativeCount += matches.length;
+    }
+    
+    // Check for negation
+    const negationPattern = /\b(not|no|never|don't|doesn't|didn't|won't|wouldn't|can't|couldn't)\s+\w+/gi;
+    const negations = contentLower.match(negationPattern)?.length || 0;
+    
+    const total = positiveCount + negativeCount;
+    if (total === 0) return 0;
+    
+    let sentiment = (positiveCount - negativeCount) / total;
+    
+    // Adjust for negations
+    if (negations > 0) {
+      sentiment *= 0.5;
+    }
+    
+    return Math.max(-1, Math.min(1, sentiment));
+  }
+  
+  /**
+   * Analyze formality (0 to 1)
+   */
+  analyzeFormality(content: string): number {
+    const contentLower = content.toLowerCase();
+    
+    // Informal indicators
+    const informalPatterns = [
+      /\b(gonna|wanna|gotta|kinda|sorta|y'all|ain't)\b/gi,
+      /\b(lol|lmao|omg|wtf|btw|fyi|imo|imho)\b/gi,
+      /!{2,}/g,
+      /\?{2,}/g,
+      /\.{3,}/g,
+      /\b(hey|hi|yo|sup)\b/gi,
+    ];
+    
+    // Formal indicators
+    const formalPatterns = [
+      /\b(hereby|therefore|whereas|pursuant|accordingly)\b/gi,
+      /\b(please|kindly|respectfully|sincerely)\b/gi,
+      /\b(regarding|concerning|pertaining|with respect to)\b/gi,
+      /\b(Dear|Sir|Madam|Mr\.|Mrs\.|Ms\.|Dr\.)\b/g,
+    ];
+    
+    let informalCount = 0;
+    let formalCount = 0;
+    
+    for (const pattern of informalPatterns) {
+      const matches = contentLower.match(pattern);
+      if (matches) informalCount += matches.length;
+    }
+    
+    for (const pattern of formalPatterns) {
+      const matches = content.match(pattern);
+      if (matches) formalCount += matches.length;
+    }
+    
+    // Calculate average sentence length (longer = more formal)
+    const sentences = content.split(/[.!?]+/).filter(s => s.trim().length > 0);
+    const avgSentenceLength = sentences.length > 0
+      ? sentences.reduce((sum, s) => sum + s.split(/\s+/).length, 0) / sentences.length
+      : 0;
+    
+    // Normalize
+    let formality = 0.5;
+    
+    if (formalCount > 0 || informalCount > 0) {
+      formality += (formalCount - informalCount) * 0.1;
+    }
+    
+    if (avgSentenceLength > 15) {
+      formality += 0.1;
+    } else if (avgSentenceLength < 8) {
+      formality -= 0.1;
+    }
+    
+    return Math.max(0, Math.min(1, formality));
+  }
+  
+  /**
+   * Analyze urgency (0 to 1)
+   */
+  analyzeUrgency(content: string): number {
+    const contentLower = content.toLowerCase();
+    
+    const urgentPatterns = [
+      { pattern: /\b(urgent|asap|immediately|right now|right away)\b/gi, weight: 0.3 },
+      { pattern: /\b(critical|emergency|priority|important)\b/gi, weight: 0.2 },
+      { pattern: /\b(deadline|due|by end of day|eod|cob)\b/gi, weight: 0.15 },
+      { pattern: /\b(need|must|have to|required)\b/gi, weight: 0.1 },
+      { pattern: /!+/g, weight: 0.05 },
+      { pattern: /\b(please|help)\b/gi, weight: 0.05 },
+    ];
+    
+    let urgency = 0;
+    
+    for (const { pattern, weight } of urgentPatterns) {
+      const matches = contentLower.match(pattern);
+      if (matches) {
+        urgency += matches.length * weight;
+      }
+    }
+    
+    return Math.min(1, urgency);
+  }
+  
+  /**
+   * Check if a phrase is a common non-name phrase
+   */
+  private isCommonPhrase(phrase: string): boolean {
+    const commonPhrases = [
+      'The', 'This', 'That', 'These', 'Those', 'What', 'When', 'Where', 'How',
+      'New York', 'Los Angeles', 'San Francisco', 'United States', 'United Kingdom',
+      'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday',
+      'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
+      'September', 'October', 'November', 'December',
+      'First', 'Second', 'Third', 'Last', 'Next', 'Previous',
+    ];
+    
+    return commonPhrases.some(p => phrase.toLowerCase() === p.toLowerCase());
+  }
+  
+  /**
+   * Deduplicate entities
+   */
+  private deduplicateEntities(entities: ExtractedEntity[]): ExtractedEntity[] {
+    const seen = new Set<string>();
+    const unique: ExtractedEntity[] = [];
+    
+    for (const entity of entities) {
+      const key = `${entity.type}:${entity.value.toLowerCase()}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push(entity);
+      }
+    }
+    
+    return unique;
+  }
+}

package/src/storage/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Dōmere - The Judge Protocol
+ * Storage Module
+ */
+
+export { MemoryStorage, createStorage } from './memory.js';

package/src/storage/memory.ts

@@ -0,0 +1,271 @@
+/**
+ * Dōmere - The Judge Protocol
+ * Memory Storage Implementation
+ */
+
+import type {
+  IDomereStorage,
+  Thread,
+  ThreadHop,
+  ThreadFilters,
+  ComplianceResult,
+  CompliancePolicy,
+  AnchorReference,
+  ArbitrationCase,
+  ArbitrationEvidence,
+  CaseFilters,
+} from '../types.js';
+
+// ============================================================================
+// Memory Storage
+// ============================================================================
+
+export class MemoryStorage implements IDomereStorage {
+  private threads: Map<string, Thread> = new Map();
+  private hops: Map<string, ThreadHop[]> = new Map();
+  private complianceResults: Map<string, ComplianceResult[]> = new Map();
+  private policies: Map<string, CompliancePolicy> = new Map();
+  private anchors: Map<string, AnchorReference[]> = new Map();
+  private cases: Map<string, ArbitrationCase> = new Map();
+  private evidence: Map<string, ArbitrationEvidence[]> = new Map();
+  
+  // ============================================================================
+  // Thread Operations
+  // ============================================================================
+  
+  async saveThread(thread: Thread): Promise<void> {
+    this.threads.set(thread.id, { ...thread });
+    this.hops.set(thread.id, [...thread.hops]);
+  }
+  
+  async getThread(id: string): Promise<Thread | null> {
+    const thread = this.threads.get(id);
+    if (!thread) return null;
+    
+    return {
+      ...thread,
+      hops: this.hops.get(id) || [],
+    };
+  }
+  
+  async updateThread(thread: Thread): Promise<void> {
+    this.threads.set(thread.id, { ...thread });
+    this.hops.set(thread.id, [...thread.hops]);
+  }
+  
+  async listThreads(filters?: ThreadFilters): Promise<Thread[]> {
+    let threads = Array.from(this.threads.values());
+    
+    if (filters) {
+      if (filters.status) {
+        threads = threads.filter(t => t.status === filters.status);
+      }
+      if (filters.origin_type) {
+        threads = threads.filter(t => t.origin.type === filters.origin_type);
+      }
+      if (filters.origin_identity) {
+        threads = threads.filter(t => t.origin.identity === filters.origin_identity);
+      }
+      if (filters.since) {
+        threads = threads.filter(t => t.created_at >= filters.since!);
+      }
+      if (filters.until) {
+        threads = threads.filter(t => t.created_at <= filters.until!);
+      }
+    }
+    
+    // Sort by creation date (newest first)
+    threads.sort((a, b) => b.created_at.getTime() - a.created_at.getTime());
+    
+    // Apply pagination
+    const offset = filters?.offset ?? 0;
+    const limit = filters?.limit ?? 100;
+    
+    return threads.slice(offset, offset + limit).map(t => ({
+      ...t,
+      hops: this.hops.get(t.id) || [],
+    }));
+  }
+  
+  // ============================================================================
+  // Hop Operations
+  // ============================================================================
+  
+  async addHop(threadId: string, hop: ThreadHop): Promise<void> {
+    const hops = this.hops.get(threadId) || [];
+    hops.push({ ...hop });
+    this.hops.set(threadId, hops);
+  }
+  
+  async getHops(threadId: string): Promise<ThreadHop[]> {
+    return [...(this.hops.get(threadId) || [])];
+  }
+  
+  // ============================================================================
+  // Compliance Operations
+  // ============================================================================
+  
+  async saveComplianceResult(result: ComplianceResult): Promise<void> {
+    const results = this.complianceResults.get(result.thread_id) || [];
+    results.push({ ...result });
+    this.complianceResults.set(result.thread_id, results);
+  }
+  
+  async getComplianceResults(threadId: string): Promise<ComplianceResult[]> {
+    return [...(this.complianceResults.get(threadId) || [])];
+  }
+  
+  // ============================================================================
+  // Policy Operations
+  // ============================================================================
+  
+  async savePolicy(policy: CompliancePolicy): Promise<void> {
+    this.policies.set(policy.id, { ...policy });
+  }
+  
+  async getPolicy(id: string): Promise<CompliancePolicy | null> {
+    const policy = this.policies.get(id);
+    return policy ? { ...policy } : null;
+  }
+  
+  async listPolicies(): Promise<CompliancePolicy[]> {
+    return Array.from(this.policies.values()).map(p => ({ ...p }));
+  }
+  
+  // ============================================================================
+  // Anchor Operations
+  // ============================================================================
+  
+  async saveAnchor(threadId: string, anchor: AnchorReference): Promise<void> {
+    const anchors = this.anchors.get(threadId) || [];
+    anchors.push({ ...anchor });
+    this.anchors.set(threadId, anchors);
+  }
+  
+  async getAnchors(threadId: string): Promise<AnchorReference[]> {
+    return [...(this.anchors.get(threadId) || [])];
+  }
+  
+  // ============================================================================
+  // Arbitration Operations
+  // ============================================================================
+  
+  async saveCase(case_: ArbitrationCase): Promise<void> {
+    this.cases.set(case_.id, { ...case_ });
+  }
+  
+  async getCase(id: string): Promise<ArbitrationCase | null> {
+    const case_ = this.cases.get(id);
+    if (!case_) return null;
+    
+    return {
+      ...case_,
+      evidence: this.evidence.get(id) || [],
+    };
+  }
+  
+  async listCases(filters?: CaseFilters): Promise<ArbitrationCase[]> {
+    let cases = Array.from(this.cases.values());
+    
+    if (filters) {
+      if (filters.status) {
+        cases = cases.filter(c => c.status === filters.status);
+      }
+      if (filters.dispute_type) {
+        cases = cases.filter(c => c.dispute.type === filters.dispute_type);
+      }
+      if (filters.thread_id) {
+        cases = cases.filter(c => c.thread_id === filters.thread_id);
+      }
+    }
+    
+    // Sort by creation date (newest first)
+    cases.sort((a, b) => b.created_at.getTime() - a.created_at.getTime());
+    
+    // Apply pagination
+    const offset = filters?.offset ?? 0;
+    const limit = filters?.limit ?? 100;
+    
+    return cases.slice(offset, offset + limit).map(c => ({
+      ...c,
+      evidence: this.evidence.get(c.id) || [],
+    }));
+  }
+  
+  // ============================================================================
+  // Evidence Operations
+  // ============================================================================
+  
+  async saveEvidence(evidence: ArbitrationEvidence): Promise<void> {
+    const evidenceList = this.evidence.get(evidence.case_id) || [];
+    evidenceList.push({ ...evidence });
+    this.evidence.set(evidence.case_id, evidenceList);
+  }
+  
+  async getEvidence(caseId: string): Promise<ArbitrationEvidence[]> {
+    return [...(this.evidence.get(caseId) || [])];
+  }
+  
+  // ============================================================================
+  // Utility Operations
+  // ============================================================================
+  
+  /**
+   * Clear all data
+   */
+  clear(): void {
+    this.threads.clear();
+    this.hops.clear();
+    this.complianceResults.clear();
+    this.policies.clear();
+    this.anchors.clear();
+    this.cases.clear();
+    this.evidence.clear();
+  }
+  
+  /**
+   * Get statistics
+   */
+  getStats(): {
+    threads: number;
+    hops: number;
+    policies: number;
+    anchors: number;
+    cases: number;
+  } {
+    let totalHops = 0;
+    for (const hops of this.hops.values()) {
+      totalHops += hops.length;
+    }
+    
+    let totalAnchors = 0;
+    for (const anchors of this.anchors.values()) {
+      totalAnchors += anchors.length;
+    }
+    
+    return {
+      threads: this.threads.size,
+      hops: totalHops,
+      policies: this.policies.size,
+      anchors: totalAnchors,
+      cases: this.cases.size,
+    };
+  }
+}
+
+// ============================================================================
+// Storage Factory
+// ============================================================================
+
+export function createStorage(type: 'memory' | 'sqlite' = 'memory'): IDomereStorage {
+  switch (type) {
+    case 'memory':
+      return new MemoryStorage();
+    case 'sqlite':
+      // TODO: Implement SQLite storage
+      console.warn('SQLite storage not implemented, falling back to memory');
+      return new MemoryStorage();
+    default:
+      return new MemoryStorage();
+  }
+}