@shykaruu/jarvis-brain 0.4.0

package/src/observers/processes.ts

@@ -0,0 +1,225 @@
+/**
+ * ProcessMonitor - Monitors running processes
+ *
+ * Polls the system process list at regular intervals and detects when processes
+ * start or terminate. Emits events for process lifecycle changes.
+ */
+
+import type { Observer, ObserverEvent, ObserverEventHandler } from './index';
+
+export type ProcessInfo = {
+  pid: number;
+  name: string;
+  cpu: number;
+  memory: number;
+};
+
+export class ProcessMonitor implements Observer {
+  name = 'processes';
+  private interval: Timer | null = null;
+  private knownProcesses: Map<number, string> = new Map();
+  private handler: ObserverEventHandler | null = null;
+  private running = false;
+  private pollMs: number;
+
+  constructor(pollMs: number = 5000) {
+    this.pollMs = pollMs;
+  }
+
+  async start(): Promise<void> {
+    if (this.running) {
+      console.log('[processes] Already running');
+      return;
+    }
+
+    console.log(`[processes] Starting process monitoring (polling every ${this.pollMs}ms)...`);
+
+    // Initialize with current process list
+    try {
+      const processes = await this.getProcessList();
+      for (const proc of processes) {
+        this.knownProcesses.set(proc.pid, proc.name);
+      }
+      console.log(`[processes] Initialized with ${processes.length} processes`);
+    } catch (error) {
+      console.error('[processes] Failed to get initial process list:', error);
+    }
+
+    // Start polling
+    this.interval = setInterval(async () => {
+      try {
+        const processes = await this.getProcessList();
+        const currentPids = new Set<number>();
+
+        // Check for new processes
+        for (const proc of processes) {
+          currentPids.add(proc.pid);
+
+          if (!this.knownProcesses.has(proc.pid)) {
+            // New process detected
+            this.knownProcesses.set(proc.pid, proc.name);
+
+            if (this.handler) {
+              const event: ObserverEvent = {
+                type: 'process_started',
+                data: {
+                  pid: proc.pid,
+                  name: proc.name,
+                  cpu: proc.cpu,
+                  memory: proc.memory,
+                },
+                timestamp: Date.now(),
+              };
+
+              this.handler(event);
+            }
+          }
+        }
+
+        // Check for terminated processes
+        for (const [pid, name] of this.knownProcesses.entries()) {
+          if (!currentPids.has(pid)) {
+            // Process terminated
+            this.knownProcesses.delete(pid);
+
+            if (this.handler) {
+              const event: ObserverEvent = {
+                type: 'process_stopped',
+                data: {
+                  pid,
+                  name,
+                },
+                timestamp: Date.now(),
+              };
+
+              this.handler(event);
+            }
+          }
+        }
+      } catch (error) {
+        console.error('[processes] Failed to monitor processes:', error);
+      }
+    }, this.pollMs);
+
+    this.running = true;
+  }
+
+  async stop(): Promise<void> {
+    if (!this.running) {
+      return;
+    }
+
+    console.log('[processes] Stopping process monitoring...');
+
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+
+    this.knownProcesses.clear();
+    this.running = false;
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  onEvent(handler: ObserverEventHandler): void {
+    this.handler = handler;
+  }
+
+  /**
+   * Get list of running processes
+   */
+  async getProcessList(): Promise<ProcessInfo[]> {
+    const platform = process.platform;
+
+    try {
+      if (platform === 'linux' || platform === 'darwin') {
+        // Use ps command for Unix-like systems
+        const result = await Bun.$`ps aux --no-headers`.quiet();
+        const output = result.stdout.toString();
+
+        return this.parsePS(output);
+      } else if (platform === 'win32') {
+        // Use PowerShell for Windows
+        const result = await Bun.$`powershell.exe -Command "Get-Process | Select-Object Id,Name,CPU,WorkingSet | ConvertTo-Csv -NoTypeInformation"`.quiet();
+        const output = result.stdout.toString();
+
+        return this.parseWindowsPS(output);
+      } else {
+        throw new Error(`Unsupported platform: ${platform}`);
+      }
+    } catch (error) {
+      console.error('[processes] Failed to get process list:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Parse output from Unix ps command
+   */
+  private parsePS(output: string): ProcessInfo[] {
+    const processes: ProcessInfo[] = [];
+    const lines = output.split('\n').filter(line => line.trim());
+
+    for (const line of lines) {
+      // ps aux format: USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
+      const parts = line.trim().split(/\s+/);
+
+      if (parts.length < 11) {
+        continue;
+      }
+
+      const pid = parseInt(parts[1]!, 10);
+      const cpu = parseFloat(parts[2]!);
+      const memory = parseFloat(parts[3]!);
+      const name = parts.slice(10).join(' '); // COMMAND can have spaces
+
+      if (!isNaN(pid)) {
+        processes.push({
+          pid,
+          name,
+          cpu,
+          memory,
+        });
+      }
+    }
+
+    return processes;
+  }
+
+  /**
+   * Parse output from Windows PowerShell Get-Process
+   */
+  private parseWindowsPS(output: string): ProcessInfo[] {
+    const processes: ProcessInfo[] = [];
+    const lines = output.split('\n').filter(line => line.trim());
+
+    // Skip header line
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i]!;
+      const parts = line.split(',').map(p => p.replace(/"/g, '').trim());
+
+      if (parts.length < 4) {
+        continue;
+      }
+
+      const pid = parseInt(parts[0]!, 10);
+      const name: string = parts[1]!;
+      const cpu = parseFloat(parts[2]!) || 0;
+      const memory = parseFloat(parts[3]!) || 0;
+
+      if (!isNaN(pid)) {
+        processes.push({
+          pid,
+          name,
+          cpu,
+          memory,
+        });
+      }
+    }
+
+    return processes;
+  }
+}

package/src/personality/README.md

@@ -0,0 +1,61 @@
+# Personality Engine
+
+An adaptive personality system for J.A.R.V.I.S. that learns user preferences and adapts communication style over time.
+
+## Quick Start
+
+```typescript
+import { initDatabase } from '@/vault/schema';
+import {
+  getPersonality,
+  savePersonality,
+  extractSignals,
+  applySignals,
+  recordInteraction,
+  personalityToPrompt,
+} from '@/personality';
+
+// Initialize database
+initDatabase('./data/jarvis.db');
+
+// Process a user interaction
+let personality = getPersonality();
+const signals = extractSignals("Keep it brief", "Sure!");
+personality = applySignals(personality, signals);
+personality = recordInteraction(personality);
+savePersonality(personality);
+
+// Generate LLM prompt
+const prompt = personalityToPrompt(personality);
+```
+
+## Modules
+
+- **`model.ts`**: Personality state structure and persistence
+- **`learner.ts`**: Signal extraction and learning
+- **`adapter.ts`**: Channel adaptation and prompt generation
+- **`index.ts`**: Public API exports
+
+## Features
+
+✓ Learns from user feedback (verbosity, formality, humor)
+✓ Detects emoji usage preferences
+✓ Adapts to different channels (WhatsApp, Email, Terminal)
+✓ Builds trust over time
+✓ Generates personality-aware LLM prompts
+
+## Documentation
+
+See [docs/PERSONALITY_ENGINE.md](~/jarvis/docs/PERSONALITY_ENGINE.md) for full documentation.
+
+## Testing
+
+```bash
+bun test src/personality/personality.test.ts
+```
+
+## Demo
+
+```bash
+bun run examples/personality-demo.ts
+```

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;
+}