@usejarvis/brain 0.1.0

package/src/observers/notifications.ts

@@ -0,0 +1,197 @@
+/**
+ * NotificationListener — D-Bus Notification Monitor (Linux/WSL2)
+ *
+ * Monitors system notifications by watching D-Bus for
+ * org.freedesktop.Notifications.Notify method calls.
+ * Parses notification fields: app_name, summary, body, urgency.
+ *
+ * Graceful: if dbus-monitor is not found, logs warning and stays no-op.
+ */
+
+import type { Observer, ObserverEventHandler } from './index';
+import type { Subprocess } from 'bun';
+
+type NotificationData = {
+  app: string;
+  title: string;
+  body: string;
+  urgency: string;
+};
+
+export class NotificationListener implements Observer {
+  name = 'notifications';
+  private running = false;
+  private handler: ObserverEventHandler | null = null;
+  private process: Subprocess | null = null;
+  private available = false;
+
+  async start(): Promise<void> {
+    this.running = true;
+
+    // Check if dbus-monitor exists
+    try {
+      const check = Bun.spawnSync(['which', 'dbus-monitor']);
+      if (check.exitCode !== 0) {
+        console.log('[notifications] dbus-monitor not found — notification monitoring disabled');
+        return;
+      }
+      this.available = true;
+    } catch {
+      console.log('[notifications] Cannot check for dbus-monitor — notification monitoring disabled');
+      return;
+    }
+
+    // Spawn dbus-monitor watching for Notify signals
+    try {
+      this.process = Bun.spawn(
+        [
+          'dbus-monitor',
+          '--session',
+          "interface='org.freedesktop.Notifications',member='Notify'",
+        ],
+        {
+          stdout: 'pipe',
+          stderr: 'ignore',
+        }
+      );
+
+      console.log('[notifications] Observer started — monitoring D-Bus notifications');
+
+      // Parse stdout in background
+      this.readOutput();
+    } catch (err) {
+      console.error('[notifications] Failed to start dbus-monitor:', err);
+      this.available = false;
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+
+    if (this.process) {
+      try {
+        this.process.kill();
+      } catch {
+        // Ignore
+      }
+      this.process = null;
+    }
+
+    console.log('[notifications] Observer stopped');
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  onEvent(handler: ObserverEventHandler): void {
+    this.handler = handler;
+  }
+
+  /**
+   * Read dbus-monitor output and parse notification blocks.
+   *
+   * D-Bus notification format (method_call):
+   *   method call ... dest=org.freedesktop.Notifications ... member=Notify
+   *   string "app_name"
+   *   uint32 ...
+   *   string "icon"
+   *   string "summary"
+   *   string "body"
+   *   array [ ... ]
+   *   ...
+   */
+  private async readOutput(): Promise<void> {
+    if (!this.process?.stdout) return;
+
+    const reader = (this.process.stdout as ReadableStream<Uint8Array>).getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    // State machine for parsing method_call blocks
+    let inMethodCall = false;
+    let stringIndex = 0;
+    let currentNotification: Partial<NotificationData> = {};
+
+    try {
+      while (this.running) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+
+          // Detect start of a new method call
+          if (trimmed.startsWith('method call') && trimmed.includes('member=Notify')) {
+            inMethodCall = true;
+            stringIndex = 0;
+            currentNotification = {};
+            continue;
+          }
+
+          // Detect start of next method/signal (end of current block)
+          if (inMethodCall && (trimmed.startsWith('method call') || trimmed.startsWith('signal') || trimmed.startsWith('method return'))) {
+            // Emit the notification if we got enough data
+            this.emitNotification(currentNotification);
+            inMethodCall = trimmed.startsWith('method call') && trimmed.includes('member=Notify');
+            stringIndex = 0;
+            currentNotification = {};
+            continue;
+          }
+
+          if (!inMethodCall) continue;
+
+          // Parse string values — the Notify method has these string args in order:
+          // 0: app_name, 1: (replaces_id is uint32, skip), 2: icon, 3: summary, 4: body
+          const stringMatch = trimmed.match(/^string\s+"(.*)"/);
+          if (stringMatch) {
+            const val = stringMatch[1];
+            switch (stringIndex) {
+              case 0: currentNotification.app = val; break;
+              // index 1 is icon (we skip)
+              case 1: break; // icon
+              case 2: currentNotification.title = val; break;
+              case 3: currentNotification.body = val; break;
+            }
+            stringIndex++;
+            continue;
+          }
+
+          // Parse urgency from hints dict (byte value)
+          const urgencyMatch = trimmed.match(/byte\s+(\d+)/);
+          if (urgencyMatch) {
+            const urgencyLevel = parseInt(urgencyMatch[1]!);
+            currentNotification.urgency =
+              urgencyLevel === 2 ? 'critical' :
+              urgencyLevel === 1 ? 'normal' :
+              'low';
+          }
+        }
+      }
+    } catch (err) {
+      if (this.running) {
+        console.error('[notifications] Read error:', err);
+      }
+    }
+  }
+
+  private emitNotification(data: Partial<NotificationData>): void {
+    if (!data.title && !data.body) return;
+    if (!this.handler) return;
+
+    this.handler({
+      type: 'notification',
+      data: {
+        app: data.app ?? 'unknown',
+        title: data.title ?? '',
+        body: data.body ?? '',
+        urgency: data.urgency ?? 'normal',
+      },
+      timestamp: Date.now(),
+    });
+  }
+}

package/src/observers/observers.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Tests for Observer Layer
+ */
+
+import { test, expect, describe, beforeAll, afterAll } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  ObserverManager,
+  FileWatcher,
+  ClipboardMonitor,
+  ProcessMonitor,
+  NotificationListener,
+  CalendarSync,
+  EmailSync,
+  type ObserverEvent,
+} from './index';
+
+// Use an isolated temp dir instead of /tmp to avoid slow recursive watches on CI
+let testDir: string;
+beforeAll(() => {
+  testDir = mkdtempSync(join(tmpdir(), 'jarvis-test-'));
+});
+afterAll(() => {
+  try { rmSync(testDir, { recursive: true }); } catch {}
+});
+
+describe('ObserverManager', () => {
+  test('registers observers', () => {
+    const manager = new ObserverManager();
+    const watcher = new FileWatcher([testDir]);
+
+    manager.register(watcher);
+
+    expect(manager.listObservers()).toEqual(['file-watcher']);
+  });
+
+  test('propagates event handler to observers', () => {
+    const manager = new ObserverManager();
+    const watcher = new FileWatcher([testDir]);
+
+    manager.register(watcher);
+
+    let handlerCalled = false;
+    manager.setEventHandler(() => {
+      handlerCalled = true;
+    });
+
+    // Handler should be set on the observer
+    expect(handlerCalled).toBe(false); // Not called yet, just registered
+  });
+
+  test('starts and stops all observers', async () => {
+    const manager = new ObserverManager();
+    const watcher = new FileWatcher([testDir]);
+    const clipboard = new ClipboardMonitor(5000);
+
+    manager.register(watcher);
+    manager.register(clipboard);
+
+    await manager.startAll();
+
+    const status = manager.getStatus();
+    expect(status['file-watcher']).toBe(true);
+    expect(status['clipboard']).toBe(true);
+
+    await manager.stopAll();
+
+    const statusAfter = manager.getStatus();
+    expect(statusAfter['file-watcher']).toBe(false);
+    expect(statusAfter['clipboard']).toBe(false);
+  });
+
+  test('starts and stops individual observers', async () => {
+    const manager = new ObserverManager();
+    const watcher = new FileWatcher([testDir]);
+
+    manager.register(watcher);
+
+    await manager.startObserver('file-watcher');
+    expect(manager.getStatus()['file-watcher']).toBe(true);
+
+    await manager.stopObserver('file-watcher');
+    expect(manager.getStatus()['file-watcher']).toBe(false);
+  });
+});
+
+describe('FileWatcher', () => {
+  test('starts and stops', async () => {
+    const watcher = new FileWatcher([testDir]);
+
+    expect(watcher.isRunning()).toBe(false);
+
+    await watcher.start();
+    expect(watcher.isRunning()).toBe(true);
+
+    await watcher.stop();
+    expect(watcher.isRunning()).toBe(false);
+  });
+
+  test('prevents double start', async () => {
+    const watcher = new FileWatcher([testDir]);
+
+    await watcher.start();
+    await watcher.start(); // Should not throw
+
+    expect(watcher.isRunning()).toBe(true);
+
+    await watcher.stop();
+  });
+});
+
+describe('ClipboardMonitor', () => {
+  test('starts and stops', async () => {
+    const clipboard = new ClipboardMonitor(5000);
+
+    expect(clipboard.isRunning()).toBe(false);
+
+    await clipboard.start();
+    expect(clipboard.isRunning()).toBe(true);
+
+    await clipboard.stop();
+    expect(clipboard.isRunning()).toBe(false);
+  });
+
+  test('uses custom poll interval', async () => {
+    const clipboard = new ClipboardMonitor(10000);
+
+    await clipboard.start();
+    expect(clipboard.isRunning()).toBe(true);
+
+    await clipboard.stop();
+  });
+});
+
+describe('ProcessMonitor', () => {
+  test('starts and stops', async () => {
+    const monitor = new ProcessMonitor(10000);
+
+    expect(monitor.isRunning()).toBe(false);
+
+    await monitor.start();
+    expect(monitor.isRunning()).toBe(true);
+
+    await monitor.stop();
+    expect(monitor.isRunning()).toBe(false);
+  });
+
+  test('gets process list', async () => {
+    const monitor = new ProcessMonitor(10000);
+
+    const processes = await monitor.getProcessList();
+
+    expect(Array.isArray(processes)).toBe(true);
+    expect(processes.length).toBeGreaterThan(0);
+
+    // Check structure of first process
+    const proc = processes[0];
+    expect(proc).toHaveProperty('pid');
+    expect(proc).toHaveProperty('name');
+    expect(proc).toHaveProperty('cpu');
+    expect(proc).toHaveProperty('memory');
+  });
+});
+
+describe('Stub Observers', () => {
+  test('NotificationListener starts and stops', async () => {
+    const listener = new NotificationListener();
+
+    expect(listener.isRunning()).toBe(false);
+
+    await listener.start();
+    expect(listener.isRunning()).toBe(true);
+
+    await listener.stop();
+    expect(listener.isRunning()).toBe(false);
+  });
+
+  test('CalendarSync starts and stops', async () => {
+    const sync = new CalendarSync();
+
+    expect(sync.isRunning()).toBe(false);
+
+    await sync.start();
+    expect(sync.isRunning()).toBe(true);
+
+    await sync.stop();
+    expect(sync.isRunning()).toBe(false);
+  });
+
+  test('EmailSync starts and stops', async () => {
+    const sync = new EmailSync();
+
+    expect(sync.isRunning()).toBe(false);
+
+    await sync.start();
+    expect(sync.isRunning()).toBe(true);
+
+    await sync.stop();
+    expect(sync.isRunning()).toBe(false);
+  });
+});

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 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
+```