@soulcraft/brainy 3.0.0 → 3.0.1

package/dist/augmentations/display/fieldPatterns.js

@@ -0,0 +1,393 @@
+/**
+ * Universal Display Augmentation - Smart Field Patterns
+ *
+ * Intelligent field detection patterns for mapping user data to display fields
+ * Uses semantic understanding and common naming conventions
+ */
+import { NounType } from '../../types/graphTypes.js';
+/**
+ * Universal field patterns that work across all data types
+ * Ordered by confidence level (highest first)
+ */
+export const UNIVERSAL_FIELD_PATTERNS = [
+    // Title/Name Patterns (Highest Priority)
+    {
+        fields: ['name', 'title', 'displayName', 'label', 'heading'],
+        displayField: 'title',
+        confidence: 0.95
+    },
+    {
+        fields: ['firstName', 'lastName', 'fullName', 'realName'],
+        displayField: 'title',
+        confidence: 0.9,
+        applicableTypes: [NounType.Person, NounType.User],
+        transform: (value, context) => {
+            const { metadata } = context;
+            if (metadata.firstName && metadata.lastName) {
+                return `${metadata.firstName} ${metadata.lastName}`.trim();
+            }
+            return String(value || '');
+        }
+    },
+    {
+        fields: ['companyName', 'organizationName', 'orgName', 'businessName'],
+        displayField: 'title',
+        confidence: 0.9,
+        applicableTypes: [NounType.Organization]
+    },
+    {
+        fields: ['filename', 'fileName', 'documentTitle', 'docName'],
+        displayField: 'title',
+        confidence: 0.85,
+        applicableTypes: [NounType.Document, NounType.File, NounType.Media]
+    },
+    {
+        fields: ['projectName', 'projectTitle', 'initiative'],
+        displayField: 'title',
+        confidence: 0.9,
+        applicableTypes: [NounType.Project]
+    },
+    {
+        fields: ['taskName', 'taskTitle', 'action', 'todo'],
+        displayField: 'title',
+        confidence: 0.85,
+        applicableTypes: [NounType.Task]
+    },
+    {
+        fields: ['subject', 'topic', 'headline', 'caption'],
+        displayField: 'title',
+        confidence: 0.8
+    },
+    // Description Patterns (High Priority)
+    {
+        fields: ['description', 'summary', 'overview', 'details'],
+        displayField: 'description',
+        confidence: 0.9
+    },
+    {
+        fields: ['bio', 'biography', 'profile', 'about'],
+        displayField: 'description',
+        confidence: 0.85,
+        applicableTypes: [NounType.Person, NounType.User]
+    },
+    {
+        fields: ['content', 'text', 'body', 'message'],
+        displayField: 'description',
+        confidence: 0.8
+    },
+    {
+        fields: ['abstract', 'excerpt', 'snippet', 'preview'],
+        displayField: 'description',
+        confidence: 0.75
+    },
+    {
+        fields: ['notes', 'comments', 'remarks', 'observations'],
+        displayField: 'description',
+        confidence: 0.7
+    },
+    // Type Patterns (Medium Priority)
+    {
+        fields: ['type', 'category', 'classification', 'kind'],
+        displayField: 'type',
+        confidence: 0.9
+    },
+    {
+        fields: ['nounType', 'entityType', 'objectType'],
+        displayField: 'type',
+        confidence: 0.95
+    },
+    {
+        fields: ['role', 'position', 'jobTitle', 'occupation'],
+        displayField: 'type',
+        confidence: 0.8,
+        applicableTypes: [NounType.Person, NounType.User],
+        transform: (value) => String(value || 'Person')
+    },
+    {
+        fields: ['industry', 'sector', 'domain', 'field'],
+        displayField: 'type',
+        confidence: 0.7,
+        applicableTypes: [NounType.Organization]
+    },
+    // Tag Patterns (Medium Priority)
+    {
+        fields: ['tags', 'keywords', 'labels', 'categories'],
+        displayField: 'tags',
+        confidence: 0.85
+    },
+    {
+        fields: ['topics', 'subjects', 'themes'],
+        displayField: 'tags',
+        confidence: 0.8
+    }
+];
+/**
+ * Type-specific field patterns for enhanced detection
+ * Used when we know the specific type of the entity
+ */
+export const TYPE_SPECIFIC_PATTERNS = {
+    [NounType.Person]: [
+        {
+            fields: ['email', 'emailAddress', 'contactEmail'],
+            displayField: 'description',
+            confidence: 0.7,
+            transform: (value, context) => {
+                const { metadata } = context;
+                const role = metadata.role || metadata.jobTitle || metadata.position;
+                const company = metadata.company || metadata.organization || metadata.employer;
+                const parts = [];
+                if (role)
+                    parts.push(role);
+                if (company)
+                    parts.push(`at ${company}`);
+                if (parts.length === 0 && value)
+                    parts.push(`Contact: ${value}`);
+                return parts.join(' ') || 'Person';
+            }
+        },
+        {
+            fields: ['phone', 'phoneNumber', 'mobile', 'cell'],
+            displayField: 'tags',
+            confidence: 0.6
+        }
+    ],
+    [NounType.Organization]: [
+        {
+            fields: ['website', 'url', 'homepage', 'domain'],
+            displayField: 'description',
+            confidence: 0.7,
+            transform: (value, context) => {
+                const { metadata } = context;
+                const industry = metadata.industry || metadata.sector;
+                const location = metadata.location || metadata.city || metadata.country;
+                const parts = [];
+                if (industry)
+                    parts.push(industry);
+                parts.push('organization');
+                if (location)
+                    parts.push(`in ${location}`);
+                return parts.join(' ');
+            }
+        },
+        {
+            fields: ['employees', 'size', 'headcount'],
+            displayField: 'tags',
+            confidence: 0.6
+        }
+    ],
+    [NounType.Project]: [
+        {
+            fields: ['status', 'phase', 'stage', 'state'],
+            displayField: 'description',
+            confidence: 0.8,
+            transform: (value, context) => {
+                const { metadata } = context;
+                const status = String(value || 'active').toLowerCase();
+                const budget = metadata.budget || metadata.cost;
+                const lead = metadata.lead || metadata.manager || metadata.owner;
+                const parts = [];
+                parts.push(status.charAt(0).toUpperCase() + status.slice(1));
+                if (metadata.description)
+                    parts.push('project');
+                if (lead)
+                    parts.push(`led by ${lead}`);
+                if (budget)
+                    parts.push(`($${parseInt(String(budget)).toLocaleString()} budget)`);
+                return parts.join(' ');
+            }
+        }
+    ],
+    [NounType.Document]: [
+        {
+            fields: ['author', 'creator', 'writer'],
+            displayField: 'description',
+            confidence: 0.7,
+            transform: (value, context) => {
+                const { metadata } = context;
+                const docType = metadata.type || metadata.category || 'document';
+                const date = metadata.date || metadata.created || metadata.published;
+                const parts = [];
+                if (docType)
+                    parts.push(docType);
+                if (value)
+                    parts.push(`by ${value}`);
+                if (date) {
+                    const dateStr = new Date(date).toLocaleDateString();
+                    parts.push(`(${dateStr})`);
+                }
+                return parts.join(' ');
+            }
+        }
+    ],
+    [NounType.Task]: [
+        {
+            fields: ['priority', 'urgency', 'importance'],
+            displayField: 'tags',
+            confidence: 0.7
+        }
+    ]
+};
+/**
+ * Get field patterns for a specific entity type
+ * @param entityType The type of entity (noun or verb)
+ * @param specificType Optional specific noun/verb type
+ * @returns Array of applicable field patterns
+ */
+export function getFieldPatterns(entityType, specificType) {
+    const patterns = [...UNIVERSAL_FIELD_PATTERNS];
+    if (entityType === 'noun' && specificType && TYPE_SPECIFIC_PATTERNS[specificType]) {
+        patterns.unshift(...TYPE_SPECIFIC_PATTERNS[specificType]);
+    }
+    return patterns.sort((a, b) => b.confidence - a.confidence);
+}
+/**
+ * Priority fields for different entity types (for AI analysis)
+ * Used by the BrainyTypes and neural processing
+ */
+export const TYPE_PRIORITY_FIELDS = {
+    [NounType.Person]: [
+        'name', 'firstName', 'lastName', 'fullName', 'displayName',
+        'email', 'role', 'jobTitle', 'position', 'title',
+        'bio', 'description', 'about', 'profile',
+        'company', 'organization', 'employer'
+    ],
+    [NounType.Organization]: [
+        'name', 'companyName', 'organizationName', 'title',
+        'industry', 'sector', 'domain', 'type',
+        'description', 'about', 'summary',
+        'location', 'city', 'country', 'headquarters',
+        'website', 'url'
+    ],
+    [NounType.Project]: [
+        'name', 'projectName', 'title', 'projectTitle',
+        'description', 'summary', 'overview', 'goal',
+        'status', 'phase', 'stage', 'state',
+        'lead', 'manager', 'owner', 'team',
+        'budget', 'timeline', 'deadline'
+    ],
+    [NounType.Document]: [
+        'title', 'filename', 'name', 'subject',
+        'content', 'text', 'body', 'summary',
+        'author', 'creator', 'writer',
+        'type', 'category', 'format',
+        'date', 'created', 'published'
+    ],
+    [NounType.Task]: [
+        'title', 'name', 'taskName', 'action',
+        'description', 'details', 'notes',
+        'status', 'state', 'priority',
+        'assignee', 'owner', 'responsible',
+        'due', 'deadline', 'dueDate'
+    ],
+    [NounType.Event]: [
+        'name', 'title', 'eventName',
+        'description', 'details', 'summary',
+        'startDate', 'endDate', 'date', 'time',
+        'location', 'venue', 'address',
+        'organizer', 'host', 'creator'
+    ],
+    [NounType.Product]: [
+        'name', 'productName', 'title',
+        'description', 'summary', 'features',
+        'price', 'cost', 'value',
+        'category', 'type', 'brand',
+        'manufacturer', 'vendor'
+    ]
+};
+/**
+ * Get priority fields for intelligent analysis
+ * @param entityType The type of entity
+ * @param specificType Optional specific type
+ * @returns Array of priority field names
+ */
+export function getPriorityFields(entityType, specificType) {
+    if (entityType === 'noun' && specificType && TYPE_PRIORITY_FIELDS[specificType]) {
+        return TYPE_PRIORITY_FIELDS[specificType];
+    }
+    // Default priority fields for any entity
+    return [
+        'name', 'title', 'label', 'displayName',
+        'description', 'summary', 'about', 'details',
+        'type', 'category', 'kind', 'classification',
+        'tags', 'keywords', 'labels'
+    ];
+}
+/**
+ * Smart field value extraction with type-aware processing
+ * @param data The data object to extract from
+ * @param pattern The field pattern to apply
+ * @param context The computation context
+ * @returns The extracted and processed field value
+ */
+export function extractFieldValue(data, pattern, context) {
+    // Find the first matching field
+    let value = null;
+    let matchedField = null;
+    for (const field of pattern.fields) {
+        if (data[field] !== undefined && data[field] !== null && data[field] !== '') {
+            value = data[field];
+            matchedField = field;
+            break;
+        }
+    }
+    if (value === null)
+        return null;
+    // Apply transformation if provided
+    if (pattern.transform) {
+        try {
+            return pattern.transform(value, context);
+        }
+        catch (error) {
+            console.warn(`Field transformation error for ${matchedField}:`, error);
+            return String(value);
+        }
+    }
+    // Default processing based on display field type
+    switch (pattern.displayField) {
+        case 'title':
+        case 'description':
+        case 'type':
+            return String(value);
+        case 'tags':
+            if (Array.isArray(value))
+                return value;
+            if (typeof value === 'string') {
+                return value.split(/[,;]\s*|\s+/).filter(Boolean);
+            }
+            return [String(value)];
+        default:
+            return value;
+    }
+}
+/**
+ * Calculate confidence score for field detection
+ * @param pattern The field pattern
+ * @param context The computation context
+ * @param value The extracted value
+ * @returns Confidence score (0-1)
+ */
+export function calculateFieldConfidence(pattern, context, value) {
+    let confidence = pattern.confidence;
+    // Boost confidence if type matches
+    if (pattern.applicableTypes && context.typeResult) {
+        if (pattern.applicableTypes.includes(context.typeResult.type)) {
+            confidence = Math.min(1.0, confidence + 0.1);
+        }
+    }
+    // Reduce confidence for empty or very short values
+    if (typeof value === 'string') {
+        if (value.length < 2) {
+            confidence *= 0.5;
+        }
+        else if (value.length < 5) {
+            confidence *= 0.8;
+        }
+    }
+    // Reduce confidence for generic values
+    const genericValues = ['unknown', 'n/a', 'null', 'undefined', 'default'];
+    if (typeof value === 'string' && genericValues.includes(value.toLowerCase())) {
+        confidence *= 0.3;
+    }
+    return Math.max(0, Math.min(1, confidence));
+}
+//# sourceMappingURL=fieldPatterns.js.map

package/dist/augmentations/display/iconMappings.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Universal Display Augmentation - Clean Display
+ *
+ * Simple, clean display without icons - focusing on AI-powered
+ * titles, descriptions, and smart formatting that matches
+ * Soulcraft's minimal aesthetic
+ */
+/**
+ * No icon mappings - clean, minimal approach
+ * The real value is in AI-generated titles and enhanced descriptions,
+ * not visual clutter that doesn't align with professional aesthetics
+ */
+export declare const NOUN_TYPE_ICONS: Record<string, string>;
+/**
+ * No icon mappings for verbs either - focus on clear relationship descriptions
+ * Human-readable relationship text is more valuable than symbolic representations
+ */
+export declare const VERB_TYPE_ICONS: Record<string, string>;
+/**
+ * Get icon for a noun type (returns empty string for clean display)
+ * @param type The noun type
+ * @returns Empty string (no icons)
+ */
+export declare function getNounIcon(type: string): string;
+/**
+ * Get icon for a verb type (returns empty string for clean display)
+ * @param type The verb type
+ * @returns Empty string (no icons)
+ */
+export declare function getVerbIcon(type: string): string;
+/**
+ * Get coverage statistics (for backwards compatibility)
+ * @returns Coverage info showing clean approach
+ */
+export declare function getIconCoverage(): {
+    nounTypes: {
+        total: string;
+        covered: string;
+    };
+    verbTypes: {
+        total: string;
+        covered: string;
+    };
+};
+/**
+ * Check if an icon exists for a type (always false for clean display)
+ * @param type The type to check
+ * @param entityType Whether it's a noun or verb
+ * @returns Always false (no icons)
+ */
+export declare function hasIcon(type: string, entityType?: 'noun' | 'verb'): boolean;
+/**
+ * Get fallback icon (returns empty string for clean display)
+ * @param entityType The entity type
+ * @returns Empty string (no fallback icons)
+ */
+export declare function getFallbackIcon(entityType?: 'noun' | 'verb'): string;

package/dist/augmentations/display/iconMappings.js

@@ -0,0 +1,68 @@
+/**
+ * Universal Display Augmentation - Clean Display
+ *
+ * Simple, clean display without icons - focusing on AI-powered
+ * titles, descriptions, and smart formatting that matches
+ * Soulcraft's minimal aesthetic
+ */
+/**
+ * No icon mappings - clean, minimal approach
+ * The real value is in AI-generated titles and enhanced descriptions,
+ * not visual clutter that doesn't align with professional aesthetics
+ */
+export const NOUN_TYPE_ICONS = {};
+/**
+ * No icon mappings for verbs either - focus on clear relationship descriptions
+ * Human-readable relationship text is more valuable than symbolic representations
+ */
+export const VERB_TYPE_ICONS = {};
+/**
+ * Get icon for a noun type (returns empty string for clean display)
+ * @param type The noun type
+ * @returns Empty string (no icons)
+ */
+export function getNounIcon(type) {
+    return ''; // Clean, no icons
+}
+/**
+ * Get icon for a verb type (returns empty string for clean display)
+ * @param type The verb type
+ * @returns Empty string (no icons)
+ */
+export function getVerbIcon(type) {
+    return ''; // Clean, no icons
+}
+/**
+ * Get coverage statistics (for backwards compatibility)
+ * @returns Coverage info showing clean approach
+ */
+export function getIconCoverage() {
+    return {
+        nounTypes: {
+            total: 'Clean display - no icons needed',
+            covered: 'Focus on AI-powered content'
+        },
+        verbTypes: {
+            total: 'Clean display - no icons needed',
+            covered: 'Focus on relationship descriptions'
+        }
+    };
+}
+/**
+ * Check if an icon exists for a type (always false for clean display)
+ * @param type The type to check
+ * @param entityType Whether it's a noun or verb
+ * @returns Always false (no icons)
+ */
+export function hasIcon(type, entityType = 'noun') {
+    return false; // Clean approach - no icons
+}
+/**
+ * Get fallback icon (returns empty string for clean display)
+ * @param entityType The entity type
+ * @returns Empty string (no fallback icons)
+ */
+export function getFallbackIcon(entityType = 'noun') {
+    return ''; // Clean, minimal display
+}
+//# sourceMappingURL=iconMappings.js.map

package/dist/augmentations/display/intelligentComputation.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Universal Display Augmentation - Intelligent Computation Engine
+ *
+ * Leverages existing Brainy AI infrastructure for intelligent field computation:
+ * - BrainyTypes for semantic type detection
+ * - Neural Import patterns for field analysis
+ * - JSON processing utilities for field extraction
+ * - Existing NounType/VerbType taxonomy (31+40 types)
+ */
+import type { ComputedDisplayFields, DisplayConfig } from './types.js';
+import type { GraphVerb } from '../../coreTypes.js';
+/**
+ * Intelligent field computation engine
+ * Coordinates AI-powered analysis with fallback heuristics
+ */
+export declare class IntelligentComputationEngine {
+    private typeMatcher;
+    protected config: DisplayConfig;
+    private initialized;
+    constructor(config: DisplayConfig);
+    /**
+     * Initialize the computation engine with AI components
+     */
+    initialize(): Promise<void>;
+    /**
+     * Compute display fields for a noun using AI-first approach
+     * @param data The noun data/metadata
+     * @param id Optional noun ID
+     * @returns Computed display fields
+     */
+    computeNounDisplay(data: any, id?: string): Promise<ComputedDisplayFields>;
+    /**
+     * Compute display fields for a verb using AI-first approach
+     * @param verb The verb/relationship data
+     * @returns Computed display fields
+     */
+    computeVerbDisplay(verb: GraphVerb): Promise<ComputedDisplayFields>;
+    /**
+     * AI-powered computation using your existing BrainyTypes
+     * @param data Entity data/metadata
+     * @param entityType Type of entity (noun/verb)
+     * @param options Additional options
+     * @returns AI-computed display fields
+     */
+    private computeWithAI;
+    /**
+     * AI-powered verb computation using relationship analysis
+     * @param verb The verb/relationship
+     * @returns AI-computed display fields
+     */
+    private computeVerbWithAI;
+    /**
+     * Heuristic computation when AI is unavailable
+     * @param data Entity data
+     * @param entityType Type of entity
+     * @param options Additional options
+     * @returns Heuristically computed display fields
+     */
+    private computeWithHeuristics;
+    /**
+     * Compute intelligent title using AI insights and your field extraction
+     * @param context Computation context with AI results
+     * @returns Computed title
+     */
+    private computeIntelligentTitle;
+    /**
+     * Compute intelligent description using AI insights and context
+     * @param context Computation context
+     * @returns Enhanced description
+     */
+    private computeIntelligentDescription;
+    /**
+     * Compute intelligent tags using type analysis
+     * @param context Computation context
+     * @returns Generated tags array
+     */
+    private computeIntelligentTags;
+    /**
+     * Compute verb title (relationship summary)
+     * @param context Verb computation context
+     * @returns Verb title
+     */
+    private computeVerbTitle;
+    /**
+     * Create minimal display for error cases
+     * @param data Entity data
+     * @param entityType Entity type
+     * @returns Minimal display fields
+     */
+    private createMinimalDisplay;
+    private computePersonTitle;
+    private computeOrganizationTitle;
+    private computeProjectTitle;
+    private computeDocumentTitle;
+    private extractBestTitle;
+    private createContextAwareDescription;
+    private extractExplicitTags;
+    private generateSemanticTags;
+    private getReadableVerbPhrase;
+    private computeVerbDescription;
+    private computeVerbTags;
+    private computeHumanReadableRelationship;
+    private detectTypeHeuristically;
+    private extractFieldWithPatterns;
+    /**
+     * Shutdown the computation engine
+     */
+    shutdown(): Promise<void>;
+}