@usejarvis/brain 0.1.0

package/src/personality/adapter.ts

@@ -0,0 +1,196 @@
+import type { PersonalityModel } from './model.ts';
+
+/**
+ * Channel-specific personality defaults
+ */
+const CHANNEL_DEFAULTS: Record<string, Partial<PersonalityModel>> = {
+  whatsapp: {
+    learned_preferences: {
+      verbosity: 4,
+      formality: 3,
+      humor_level: 5,
+      emoji_usage: true,
+      preferred_format: 'lists',
+    },
+  },
+  telegram: {
+    learned_preferences: {
+      verbosity: 4,
+      formality: 3,
+      humor_level: 5,
+      emoji_usage: true,
+      preferred_format: 'lists',
+    },
+  },
+  email: {
+    learned_preferences: {
+      verbosity: 7,
+      formality: 8,
+      humor_level: 2,
+      emoji_usage: false,
+      preferred_format: 'prose',
+    },
+  },
+  terminal: {
+    learned_preferences: {
+      verbosity: 5,
+      formality: 5,
+      humor_level: 3,
+      emoji_usage: false,
+      preferred_format: 'adaptive',
+    },
+  },
+  websocket: {
+    learned_preferences: {
+      verbosity: 5,
+      formality: 5,
+      humor_level: 3,
+      emoji_usage: false,
+      preferred_format: 'adaptive',
+    },
+  },
+  discord: {
+    learned_preferences: {
+      verbosity: 4,
+      formality: 3,
+      humor_level: 5,
+      emoji_usage: true,
+      preferred_format: 'lists',
+    },
+  },
+};
+
+/**
+ * Deep merge helper for personality overrides
+ */
+function mergePersonality(
+  base: PersonalityModel,
+  override: Partial<PersonalityModel>
+): PersonalityModel {
+  return {
+    ...base,
+    core_traits: override.core_traits ?? base.core_traits,
+    learned_preferences: {
+      ...base.learned_preferences,
+      ...override.learned_preferences,
+    },
+    relationship: {
+      ...base.relationship,
+      ...override.relationship,
+    },
+    channel_overrides: {
+      ...base.channel_overrides,
+      ...override.channel_overrides,
+    },
+  };
+}
+
+/**
+ * Get personality adapted for a specific channel
+ */
+export function getChannelPersonality(personality: PersonalityModel, channel: string): PersonalityModel {
+  // First, apply channel-specific overrides from stored personality
+  let adapted = personality;
+  if (personality.channel_overrides[channel]) {
+    adapted = mergePersonality(personality, personality.channel_overrides[channel]);
+  }
+
+  // Then, apply default channel adaptations if no stored override exists
+  if (!personality.channel_overrides[channel] && CHANNEL_DEFAULTS[channel]) {
+    adapted = mergePersonality(adapted, CHANNEL_DEFAULTS[channel]);
+  }
+
+  return adapted;
+}
+
+/**
+ * Generate personality instructions for the LLM system prompt
+ */
+export function personalityToPrompt(personality: PersonalityModel): string {
+  const { core_traits, learned_preferences, relationship } = personality;
+
+  const lines: string[] = ['## Personality'];
+
+  // Core traits
+  if (core_traits.length > 0) {
+    lines.push(`Core traits: ${core_traits.join(', ')}`);
+  }
+
+  // Communication style
+  const verbosityDesc = getVerbosityDescription(learned_preferences.verbosity);
+  const formalityDesc = getFormalityDescription(learned_preferences.formality);
+  const humorDesc = getHumorDescription(learned_preferences.humor_level);
+
+  lines.push(
+    `Communication: ${verbosityDesc} verbosity (${learned_preferences.verbosity}/10), ${formalityDesc} formality (${learned_preferences.formality}/10), ${humorDesc} humor`
+  );
+
+  // Format preference
+  lines.push(`Format preference: ${learned_preferences.preferred_format}`);
+
+  // Emoji usage
+  if (learned_preferences.emoji_usage) {
+    lines.push('Emoji usage: Enabled');
+  }
+
+  // Relationship context
+  const daysSinceFirst = Math.floor(
+    (Date.now() - relationship.first_interaction) / (1000 * 60 * 60 * 24)
+  );
+  const trustDesc = getTrustDescription(relationship.trust_level);
+
+  lines.push(
+    `Relationship: ${relationship.message_count} interactions over ${daysSinceFirst} days, ${trustDesc} trust level (${relationship.trust_level}/10)`
+  );
+
+  // Shared references
+  if (relationship.shared_references.length > 0) {
+    lines.push(`Shared references: ${relationship.shared_references.join(', ')}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Helper: Convert verbosity number to description
+ */
+function getVerbosityDescription(level: number): string {
+  if (level <= 2) return 'Very brief';
+  if (level <= 4) return 'Concise';
+  if (level <= 6) return 'Moderate';
+  if (level <= 8) return 'Detailed';
+  return 'Very detailed';
+}
+
+/**
+ * Helper: Convert formality number to description
+ */
+function getFormalityDescription(level: number): string {
+  if (level <= 2) return 'Very casual';
+  if (level <= 4) return 'Casual';
+  if (level <= 6) return 'Moderate';
+  if (level <= 8) return 'Formal';
+  return 'Very formal';
+}
+
+/**
+ * Helper: Convert humor level to description
+ */
+function getHumorDescription(level: number): string {
+  if (level <= 2) return 'minimal';
+  if (level <= 4) return 'light';
+  if (level <= 6) return 'moderate';
+  if (level <= 8) return 'frequent';
+  return 'heavy';
+}
+
+/**
+ * Helper: Convert trust level to description
+ */
+function getTrustDescription(level: number): string {
+  if (level <= 2) return 'low';
+  if (level <= 4) return 'developing';
+  if (level <= 6) return 'moderate';
+  if (level <= 8) return 'high';
+  return 'very high';
+}

package/src/personality/index.ts

@@ -0,0 +1,20 @@
+// Re-export all personality engine modules
+export type { PersonalityModel } from './model.ts';
+export {
+  loadPersonality,
+  savePersonality,
+  getPersonality,
+  updatePersonality,
+} from './model.ts';
+
+export type { InteractionSignal } from './learner.ts';
+export {
+  extractSignals,
+  applySignals,
+  recordInteraction,
+} from './learner.ts';
+
+export {
+  getChannelPersonality,
+  personalityToPrompt,
+} from './adapter.ts';

package/src/personality/learner.ts

@@ -0,0 +1,209 @@
+import type { PersonalityModel } from './model.ts';
+
+export type InteractionSignal = {
+  type: 'user_feedback' | 'message_style' | 'explicit_preference';
+  data: Record<string, unknown>;
+};
+
+/**
+ * Clamp a number to a range
+ */
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}
+
+/**
+ * Analyze a user message for preference signals
+ */
+export function extractSignals(userMessage: string, assistantResponse: string): InteractionSignal[] {
+  const signals: InteractionSignal[] = [];
+  const lowerMessage = userMessage.toLowerCase();
+
+  // Verbosity signals
+  if (
+    lowerMessage.includes('shorter') ||
+    lowerMessage.includes('brief') ||
+    lowerMessage.includes('tldr') ||
+    lowerMessage.includes('too long') ||
+    lowerMessage.includes('concise') ||
+    lowerMessage.includes('summarize')
+  ) {
+    signals.push({
+      type: 'user_feedback',
+      data: { preference: 'verbosity', direction: -1 },
+    });
+  }
+
+  if (
+    lowerMessage.includes('more detail') ||
+    lowerMessage.includes('explain') ||
+    lowerMessage.includes('elaborate') ||
+    lowerMessage.includes('tell me more') ||
+    lowerMessage.includes('expand on')
+  ) {
+    signals.push({
+      type: 'user_feedback',
+      data: { preference: 'verbosity', direction: 1 },
+    });
+  }
+
+  // Formality signals
+  if (
+    lowerMessage.includes('be more casual') ||
+    lowerMessage.includes('less formal') ||
+    lowerMessage.includes('relax') ||
+    lowerMessage.includes('informal')
+  ) {
+    signals.push({
+      type: 'explicit_preference',
+      data: { preference: 'formality', direction: -1 },
+    });
+  }
+
+  if (
+    lowerMessage.includes('be more formal') ||
+    lowerMessage.includes('professional') ||
+    lowerMessage.includes('polite')
+  ) {
+    signals.push({
+      type: 'explicit_preference',
+      data: { preference: 'formality', direction: 1 },
+    });
+  }
+
+  // Humor signals
+  if (
+    lowerMessage.includes('funny') ||
+    lowerMessage.includes('joke') ||
+    lowerMessage.includes('humorous') ||
+    lowerMessage.includes('make me laugh')
+  ) {
+    signals.push({
+      type: 'explicit_preference',
+      data: { preference: 'humor_level', direction: 1 },
+    });
+  }
+
+  if (
+    lowerMessage.includes('serious') ||
+    lowerMessage.includes('no jokes') ||
+    lowerMessage.includes('be serious')
+  ) {
+    signals.push({
+      type: 'explicit_preference',
+      data: { preference: 'humor_level', direction: -1 },
+    });
+  }
+
+  // Emoji usage detection (if user uses emojis, they probably like them)
+  const emojiRegex = /[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu;
+  if (emojiRegex.test(userMessage)) {
+    signals.push({
+      type: 'message_style',
+      data: { preference: 'emoji_usage', value: true },
+    });
+  }
+
+  // Format preference signals
+  if (
+    lowerMessage.includes('bullet points') ||
+    lowerMessage.includes('list format') ||
+    lowerMessage.includes('as a list')
+  ) {
+    signals.push({
+      type: 'explicit_preference',
+      data: { preference: 'preferred_format', value: 'lists' },
+    });
+  }
+
+  if (
+    lowerMessage.includes('table') ||
+    lowerMessage.includes('tabular format')
+  ) {
+    signals.push({
+      type: 'explicit_preference',
+      data: { preference: 'preferred_format', value: 'tables' },
+    });
+  }
+
+  if (
+    lowerMessage.includes('paragraph') ||
+    lowerMessage.includes('prose') ||
+    lowerMessage.includes('written out')
+  ) {
+    signals.push({
+      type: 'explicit_preference',
+      data: { preference: 'preferred_format', value: 'prose' },
+    });
+  }
+
+  return signals;
+}
+
+/**
+ * Apply signals to update personality
+ */
+export function applySignals(personality: PersonalityModel, signals: InteractionSignal[]): PersonalityModel {
+  const updated = { ...personality };
+
+  for (const signal of signals) {
+    const { preference, direction, value } = signal.data as {
+      preference?: string;
+      direction?: number;
+      value?: any;
+    };
+
+    if (!preference) continue;
+
+    // Handle numeric preferences (verbosity, formality, humor_level)
+    if (
+      preference === 'verbosity' ||
+      preference === 'formality' ||
+      preference === 'humor_level'
+    ) {
+      const currentValue = updated.learned_preferences[preference as keyof typeof updated.learned_preferences] as number;
+      const adjustment = direction ?? 0;
+      const newValue = clamp(currentValue + adjustment, 0, 10);
+      (updated.learned_preferences as any)[preference] = newValue;
+    }
+
+    // Handle boolean preferences
+    if (preference === 'emoji_usage' && typeof value === 'boolean') {
+      updated.learned_preferences.emoji_usage = value;
+    }
+
+    // Handle enum preferences
+    if (preference === 'preferred_format' && typeof value === 'string') {
+      const validFormats: Array<PersonalityModel['learned_preferences']['preferred_format']> = [
+        'lists',
+        'prose',
+        'tables',
+        'adaptive',
+      ];
+      if (validFormats.includes(value as any)) {
+        updated.learned_preferences.preferred_format = value as any;
+      }
+    }
+  }
+
+  return updated;
+}
+
+/**
+ * Increment message count and adjust trust
+ */
+export function recordInteraction(personality: PersonalityModel): PersonalityModel {
+  const updated = { ...personality };
+  updated.relationship.message_count += 1;
+
+  // Trust grows slowly over time, caps at 10
+  // Every 10 messages = +1 trust (up to max of 10)
+  const trustFromInteractions = Math.min(
+    10,
+    3 + Math.floor(updated.relationship.message_count / 10)
+  );
+
+  updated.relationship.trust_level = clamp(trustFromInteractions, 0, 10);
+
+  return updated;
+}

package/src/personality/model.ts

@@ -0,0 +1,132 @@
+import { getDb } from '../vault/schema.ts';
+
+export type PersonalityModel = {
+  core_traits: string[];
+  learned_preferences: {
+    verbosity: number;        // 0-10
+    formality: number;        // 0-10
+    humor_level: number;      // 0-10
+    emoji_usage: boolean;
+    preferred_format: 'lists' | 'prose' | 'tables' | 'adaptive';
+  };
+  relationship: {
+    first_interaction: number;
+    message_count: number;
+    trust_level: number;      // 0-10, grows over time
+    shared_references: string[];
+  };
+  channel_overrides: Record<string, Partial<PersonalityModel>>;
+};
+
+const DEFAULT_PERSONALITY: PersonalityModel = {
+  core_traits: ['direct', 'strategic', 'resourceful'],
+  learned_preferences: {
+    verbosity: 5,
+    formality: 5,
+    humor_level: 3,
+    emoji_usage: false,
+    preferred_format: 'adaptive',
+  },
+  relationship: {
+    first_interaction: Date.now(),
+    message_count: 0,
+    trust_level: 3,
+    shared_references: [],
+  },
+  channel_overrides: {},
+};
+
+type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]
+};
+
+type PersonalityStateRow = {
+  id: string;
+  data: string;
+  updated_at: number;
+};
+
+/**
+ * Load personality from DB (personality_state table, id='default')
+ */
+export function loadPersonality(): PersonalityModel {
+  const db = getDb();
+  const stmt = db.prepare('SELECT * FROM personality_state WHERE id = ?');
+  const row = stmt.get('default') as PersonalityStateRow | null;
+
+  if (!row) {
+    return DEFAULT_PERSONALITY;
+  }
+
+  try {
+    return JSON.parse(row.data) as PersonalityModel;
+  } catch (error) {
+    console.error('Failed to parse personality data:', error);
+    return DEFAULT_PERSONALITY;
+  }
+}
+
+/**
+ * Save personality to DB
+ */
+export function savePersonality(model: PersonalityModel): void {
+  const db = getDb();
+  const now = Date.now();
+  const data = JSON.stringify(model);
+
+  const stmt = db.prepare(`
+    INSERT INTO personality_state (id, data, updated_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET data = ?, updated_at = ?
+  `);
+
+  stmt.run('default', data, now, data, now);
+}
+
+/**
+ * Get current personality (loads from DB, falls back to default)
+ */
+export function getPersonality(): PersonalityModel {
+  return loadPersonality();
+}
+
+/**
+ * Deep merge helper for nested objects
+ */
+function deepMerge<T extends Record<string, any>>(target: T, source: DeepPartial<T>): T {
+  const result = { ...target };
+
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+
+    if (sourceValue === undefined) {
+      continue;
+    }
+
+    if (
+      sourceValue !== null &&
+      typeof sourceValue === 'object' &&
+      !Array.isArray(sourceValue) &&
+      targetValue !== null &&
+      typeof targetValue === 'object' &&
+      !Array.isArray(targetValue)
+    ) {
+      result[key] = deepMerge(targetValue as any, sourceValue as any);
+    } else {
+      result[key] = sourceValue as any;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Update specific fields (deep merge)
+ */
+export function updatePersonality(updates: DeepPartial<PersonalityModel>): PersonalityModel {
+  const current = getPersonality();
+  const updated = deepMerge(current, updates);
+  savePersonality(updated);
+  return updated;
+}