@usejarvis/brain 0.1.0

package/src/config/types.ts

@@ -0,0 +1,260 @@
+export type HeartbeatConfig = {
+  interval_minutes: number;
+  active_hours: { start: number; end: number };
+  aggressiveness: 'passive' | 'moderate' | 'aggressive';
+};
+
+export type GoogleConfig = {
+  client_id: string;
+  client_secret: string;
+};
+
+export type ChannelConfig = {
+  telegram?: {
+    enabled: boolean;
+    bot_token: string;
+    allowed_users: number[];  // Telegram user IDs
+  };
+  discord?: {
+    enabled: boolean;
+    bot_token: string;
+    allowed_users: string[];  // Discord user IDs
+    guild_id?: string;        // restrict to single guild
+  };
+};
+
+export type STTConfig = {
+  provider: 'openai' | 'groq' | 'local';
+  openai?: { api_key: string; model?: string };
+  groq?: { api_key: string; model?: string };
+  local?: { endpoint: string; model?: string };
+};
+
+export type TTSConfig = {
+  enabled: boolean;
+  provider?: 'edge' | 'elevenlabs';  // default: 'edge'
+  voice?: string;       // e.g. 'en-US-AriaNeural' (edge)
+  rate?: string;        // e.g. '+0%', '+10%' (edge)
+  volume?: string;      // e.g. '+0%' (edge)
+  elevenlabs?: {
+    api_key: string;
+    voice_id?: string;
+    model?: string;           // 'eleven_flash_v2_5' | 'eleven_multilingual_v2'
+    stability?: number;       // 0-1
+    similarity_boost?: number; // 0-1
+  };
+};
+
+export type DesktopConfig = {
+  enabled: boolean;
+  sidecar_port: number;
+  sidecar_path?: string;
+  auto_launch: boolean;
+  tree_depth: number;
+  snapshot_max_elements: number;
+};
+
+export type AwarenessConfig = {
+  enabled: boolean;
+  capture_interval_ms: number;
+  min_change_threshold: number;       // 0.0-1.0 pixel diff percentage
+  cloud_vision_enabled: boolean;
+  cloud_vision_cooldown_ms: number;
+  stuck_threshold_ms: number;
+  struggle_grace_ms: number;          // min time before struggle fires
+  struggle_cooldown_ms: number;       // min gap between struggle detections
+  suggestion_rate_limit_ms: number;
+  overlay_autolaunch: boolean;        // auto-open floating overlay widget on start
+  retention: {
+    full_hours: number;
+    key_moment_hours: number;
+  };
+  capture_dir: string;
+};
+
+export type PerActionOverride = {
+  action: string;            // ActionCategory
+  role_id?: string;
+  allowed: boolean;
+  requires_approval?: boolean;
+};
+
+export type ContextRule = {
+  id: string;
+  action: string;            // ActionCategory
+  condition: 'time_range' | 'tool_name' | 'always';
+  params: Record<string, unknown>;
+  effect: 'allow' | 'deny' | 'require_approval';
+  description: string;
+};
+
+export type AuthorityConfig = {
+  default_level: number;
+  governed_categories: string[];       // ActionCategory[]
+  overrides: PerActionOverride[];
+  context_rules: ContextRule[];
+  learning: {
+    enabled: boolean;
+    suggest_threshold: number;
+  };
+  emergency_state: 'normal' | 'paused' | 'killed';
+};
+
+export type WorkflowConfig = {
+  enabled: boolean;
+  maxConcurrentExecutions: number;
+  defaultRetries: number;
+  defaultTimeoutMs: number;
+  selfHealEnabled: boolean;
+  autoSuggestEnabled: boolean;
+};
+
+export type GoalConfig = {
+  enabled: boolean;
+  morning_window: { start: number; end: number };
+  evening_window: { start: number; end: number };
+  accountability_style: 'drill_sergeant' | 'supportive' | 'balanced';
+  escalation_weeks: { pressure: number; root_cause: number; suggest_kill: number };
+  auto_decompose: boolean;
+  calendar_ownership: boolean;
+};
+
+export type AuthConfig = {
+  /** Shared secret token. If unset, auth is disabled (open access). Env: JARVIS_AUTH_TOKEN */
+  token?: string;
+};
+
+export type UserConfig = {
+  name?: string;
+};
+
+export type JarvisConfig = {
+  user?: UserConfig;
+  daemon: {
+    port: number;
+    data_dir: string;
+    db_path: string;
+    /** External domain for the brain (used in sidecar JWT tokens). Env: JARVIS_BRAIN_DOMAIN */
+    brain_domain?: string;
+  };
+  auth?: AuthConfig;
+  google?: GoogleConfig;
+  channels?: ChannelConfig;
+  stt?: STTConfig;
+  tts?: TTSConfig;
+  desktop?: DesktopConfig;
+  awareness?: AwarenessConfig;
+  llm: {
+    primary: string;  // provider name
+    fallback: string[];
+    anthropic?: { api_key: string; model?: string };
+    openai?: { api_key: string; model?: string };
+    gemini?: { api_key: string; model?: string };
+    ollama?: { base_url?: string; model?: string };
+  };
+  personality: {
+    core_traits: string[];
+    assistant_name?: string;
+  };
+  workflows?: WorkflowConfig;
+  goals?: GoalConfig;
+  authority: AuthorityConfig;
+  heartbeat: HeartbeatConfig;
+  active_role: string;  // role file name
+};
+
+export const DEFAULT_CONFIG: JarvisConfig = {
+  user: {
+    name: '',
+  },
+  daemon: {
+    port: 3142,
+    data_dir: '~/.jarvis',
+    db_path: '~/.jarvis/jarvis.db',
+  },
+  channels: {
+    telegram: { enabled: false, bot_token: '', allowed_users: [] },
+    discord: { enabled: false, bot_token: '', allowed_users: [] },
+  },
+  stt: {
+    provider: 'openai',
+  },
+  tts: {
+    enabled: false,
+    provider: 'edge',
+    voice: 'en-US-AriaNeural',
+    rate: '+0%',
+    volume: '+0%',
+  },
+  desktop: {
+    enabled: true,
+    sidecar_port: 9224,
+    auto_launch: true,
+    tree_depth: 5,
+    snapshot_max_elements: 60,
+  },
+  awareness: {
+    enabled: true,
+    capture_interval_ms: 7000,
+    min_change_threshold: 0.02,
+    cloud_vision_enabled: true,
+    cloud_vision_cooldown_ms: 30000,
+    stuck_threshold_ms: 120000,
+    struggle_grace_ms: 45000,
+    struggle_cooldown_ms: 90000,
+    suggestion_rate_limit_ms: 60000,
+    overlay_autolaunch: true,
+    retention: {
+      full_hours: 1,
+      key_moment_hours: 24,
+    },
+    capture_dir: '~/.jarvis/captures',
+  },
+  llm: {
+    primary: 'anthropic',
+    fallback: ['openai', 'ollama'],
+    anthropic: {
+      api_key: '',
+      model: 'claude-sonnet-4-6',
+    },
+    openai: {
+      api_key: '',
+      model: 'gpt-5.4',
+    },
+    gemini: {
+      api_key: '',
+      model: 'gemini-3-flash-preview',
+    },
+    ollama: {
+      base_url: 'http://localhost:11434',
+      model: 'llama3',
+    },
+  },
+  personality: {
+    core_traits: [
+      'loyal',
+      'efficient',
+      'proactive',
+      'respectful',
+      'adaptive',
+    ],
+    assistant_name: 'Jarvis',
+  },
+  authority: {
+    default_level: 3,
+    governed_categories: ['send_email', 'send_message', 'make_payment'],
+    overrides: [],
+    context_rules: [],
+    learning: {
+      enabled: true,
+      suggest_threshold: 5,
+    },
+    emergency_state: 'normal',
+  },
+  heartbeat: {
+    interval_minutes: 15,
+    active_hours: { start: 8, end: 23 },
+    aggressiveness: 'aggressive',
+  },
+  active_role: 'personal-assistant',
+};

package/src/daemon/README.md

@@ -0,0 +1,232 @@
+# J.A.R.V.I.S. Daemon
+
+Core daemon infrastructure for the JARVIS system.
+
+## Overview
+
+The daemon provides:
+- **Service Registry**: Manages lifecycle of all system services (observers, agents, WebSocket server)
+- **Health Monitoring**: Tracks system health, memory usage, database connectivity
+- **Graceful Shutdown**: Handles SIGINT/SIGTERM signals and stops services cleanly
+- **Structured Logging**: Timestamped logs for debugging and monitoring
+
+## Architecture
+
+```
+src/daemon/
+├── index.ts      # Main entry point and CLI
+├── services.ts   # Service registry and lifecycle management
+└── health.ts     # Health monitoring and status reporting
+```
+
+## Usage
+
+### Running the Daemon
+
+```bash
+# Run with defaults (port 3142, ~/.jarvis data directory)
+bun run src/daemon/index.ts
+
+# Run with custom configuration
+bun run src/daemon/index.ts --port 3142 --data-dir ~/my-jarvis-data
+
+# See all options
+bun run src/daemon/index.ts --help
+```
+
+### Programmatic Usage
+
+```typescript
+import { startDaemon } from './src/daemon/index.ts';
+
+await startDaemon({
+  port: 3142,
+  dataDir: '/path/to/data',
+  dbPath: '/path/to/jarvis.db',
+  healthCheckInterval: 30000, // 30 seconds
+});
+```
+
+## Service Registry
+
+Services implement the `Service` interface:
+
+```typescript
+export interface Service {
+  name: string;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  status(): ServiceStatus;
+}
+```
+
+Register services before starting the daemon:
+
+```typescript
+import { ServiceRegistry } from './src/daemon/services.ts';
+
+const registry = new ServiceRegistry();
+
+// Register your service
+registry.register({
+  name: 'my-service',
+  async start() {
+    // Start logic
+  },
+  async stop() {
+    // Stop logic
+  },
+  status() {
+    return 'running';
+  }
+});
+
+// Start all services
+await registry.startAll();
+
+// Stop all services (in reverse order)
+await registry.stopAll();
+```
+
+## Health Monitoring
+
+The health monitor tracks:
+- **Uptime**: Total daemon uptime in seconds
+- **Services**: Status of each registered service
+- **Memory**: Heap usage and RSS
+- **Database**: Connection status and file size
+
+Access health status:
+
+```typescript
+import { HealthMonitor } from './src/daemon/health.ts';
+
+const monitor = new HealthMonitor(registry, dbPath);
+monitor.start(30000); // Check every 30 seconds
+
+const health = monitor.getHealth();
+console.log(health);
+// {
+//   uptime: 120,
+//   services: { core: 'running', observers: 'running' },
+//   memory: { heapUsed: 1048576, heapTotal: 2097152, rss: 45678912 },
+//   database: { connected: true, size: 4096 },
+//   startedAt: 1708644000000
+// }
+
+// Get formatted health report
+console.log(monitor.formatHealth());
+```
+
+## Configuration
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `--port` | 3142 | WebSocket server port |
+| `--data-dir` | `~/.jarvis` | Data directory |
+| `--db-path` | `~/.jarvis/jarvis.db` | Database file path |
+| `--health-interval` | 30000 | Health check interval (ms) |
+
+## Graceful Shutdown
+
+The daemon handles:
+- `SIGINT` (Ctrl+C)
+- `SIGTERM` (kill command)
+- Uncaught exceptions
+- Unhandled promise rejections
+
+Shutdown sequence:
+1. Stop health monitor
+2. Stop all services in reverse order
+3. Close database connection
+4. Exit process
+
+Press Ctrl+C twice for force shutdown.
+
+## Development
+
+### Adding a New Service
+
+1. Implement the `Service` interface
+2. Register the service in `src/daemon/index.ts`
+3. The daemon will handle start/stop lifecycle
+
+Example:
+
+```typescript
+// src/observers/file-observer.ts
+import type { Service, ServiceStatus } from '../daemon/services.ts';
+
+export class FileObserver implements Service {
+  name = 'file-observer';
+  private watcher: FSWatcher | null = null;
+  private _status: ServiceStatus = 'stopped';
+
+  async start(): Promise<void> {
+    this._status = 'starting';
+    // Set up file watching
+    this._status = 'running';
+  }
+
+  async stop(): Promise<void> {
+    this._status = 'stopping';
+    this.watcher?.close();
+    this._status = 'stopped';
+  }
+
+  status(): ServiceStatus {
+    return this._status;
+  }
+}
+
+// Register in src/daemon/index.ts
+import { FileObserver } from '../observers/file-observer.ts';
+
+registry.register(new FileObserver());
+```
+
+## Logging
+
+All logs include timestamps and component prefixes:
+
+```
+[2026-02-22T22:17:03.230Z] Initializing database at /home/user/.jarvis/jarvis.db
+[ServiceRegistry] Starting core...
+[ServiceRegistry] ✓ core started
+[HealthMonitor] Starting health checks (every 30000ms)
+```
+
+## Database
+
+The daemon uses `bun:sqlite` with:
+- **WAL mode**: Better concurrency
+- **Foreign keys**: Enabled
+- **Location**: `~/.jarvis/jarvis.db` (configurable)
+
+Schema is managed by `~/jarvis/src/vault/schema.ts`.
+
+## Testing
+
+Run a quick test:
+
+```bash
+# Start daemon and let it run for 3 seconds
+timeout 3 bun run src/daemon/index.ts --data-dir /tmp/test-jarvis
+```
+
+Expected output:
+- ASCII banner
+- Configuration summary
+- Database initialization
+- Service startup
+- Health status
+- Graceful shutdown on timeout
+
+## Next Steps
+
+Replace placeholder services with real implementations:
+- Observer services (file, window, process, etc.)
+- Agent services (personality, decision-making)
+- WebSocket server for external communication
+- Commitment scheduler
+- Vector embedding service

package/src/daemon/agent-service-interface.ts

@@ -0,0 +1,9 @@
+/**
+ * Common interface for agent services that can handle messages.
+ * Both the main AgentService (user chat) and BackgroundAgentService
+ * (heartbeat/reactions) implement this.
+ */
+export interface IAgentService {
+  handleMessage(text: string, channel?: string): Promise<string>;
+  handleHeartbeat(coalescedEvents?: string): Promise<string | null>;
+}