@shykaruu/jarvis-brain 0.4.0

package/bin/jarvis.ts

@@ -0,0 +1,449 @@
+#!/usr/bin/env bun
+/**
+ * J.A.R.V.I.S. CLI Entry Point
+ *
+ * Usage:
+ *   jarvis start [--port N] [-d|--detach]   Start the daemon
+ *   jarvis stop                             Stop the running daemon
+ *   jarvis status                           Show daemon status
+ *   jarvis onboard                          Interactive setup wizard
+ *   jarvis uninstall                        Remove JARVIS from this machine
+ *   jarvis doctor                           Check environment & connectivity
+ *   jarvis version                          Print version
+ *   jarvis help                             Show this help
+ */
+
+import { join } from 'node:path';
+import { readFileSync, existsSync, openSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { acquireLock, releaseLock, isLocked, getLogPath } from '../src/daemon/pid.ts';
+import { c } from '../src/cli/helpers.ts';
+
+const PACKAGE_ROOT = join(import.meta.dir, '..');
+
+function getVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function printHelp(): void {
+  console.log(`
+${c.cyan('J.A.R.V.I.S.')} ${c.dim(`v${getVersion()}`)}
+Just A Rather Very Intelligent System
+
+${c.bold('Usage:')}
+  jarvis <command> [options]
+
+${c.bold('Commands:')}
+  ${c.cyan('start')}     Start the JARVIS daemon
+  ${c.cyan('stop')}      Stop the running daemon
+  ${c.cyan('restart')}   Restart the daemon (stop + start)
+  ${c.cyan('status')}    Show daemon status
+  ${c.cyan('logs')}      Tail the daemon log file
+  ${c.cyan('update')}    Update JARVIS to the latest version
+  ${c.cyan('onboard')}   Interactive first-time setup wizard
+  ${c.cyan('uninstall')} Remove JARVIS and local data from this machine
+  ${c.cyan('doctor')}    Check environment and connectivity
+  ${c.cyan('version')}   Print version number
+  ${c.cyan('help')}      Show this help message
+
+${c.bold('Start options:')}
+  --port <N>        Override daemon port (default: 3142)
+  -d, --detach      Run as background daemon
+  --no-open         Don't auto-open dashboard in browser
+  --data-dir <path> Override data directory (default: ~/.jarvis)
+  --no-local-tools  Disable local tool execution (Docker/headless mode)
+
+${c.bold('Logs options:')}
+  -f, --follow      Follow log output (like tail -f)
+  -n, --lines <N>   Number of lines to show (default: 50)
+
+${c.bold('Examples:')}
+  jarvis start                  Start in foreground
+  jarvis start -d               Start as background daemon
+  jarvis start --port 8080      Start on custom port
+  jarvis restart                Restart with same settings
+  jarvis logs -f                Follow live log output
+  jarvis update                 Update to latest version
+  jarvis onboard                Run the setup wizard
+  jarvis uninstall              Remove JARVIS from this machine
+  jarvis doctor                 Check if everything is working
+`);
+}
+
+function assertSupportedPlatform(): void {
+  if (process.platform !== 'win32') return;
+  console.error(c.red('Native Windows installs are not supported for the JARVIS daemon.'));
+  console.error(c.dim('Use WSL2 for the Bun install, or run JARVIS with Docker on Windows.'));
+  console.error(c.dim('The Windows sidecar is still supported separately.'));
+  process.exit(1);
+}
+
+async function cmdStart(args: string[]): Promise<void> {
+  const detach = args.includes('--detach') || args.includes('-d');
+  const noOpen = args.includes('--no-open');
+  const noLocalTools = args.includes('--no-local-tools');
+
+  // Parse --port
+  let port: number | undefined;
+  const portIdx = args.indexOf('--port');
+  if (portIdx !== -1 && args[portIdx + 1]) {
+    port = parseInt(args[portIdx + 1]!, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+      console.error(c.red('Error: --port requires a number between 1 and 65535'));
+      process.exit(1);
+    }
+  }
+
+  // Parse --data-dir
+  let dataDir: string | undefined;
+  const dataDirIdx = args.indexOf('--data-dir');
+  if (dataDirIdx !== -1 && args[dataDirIdx + 1]) {
+    dataDir = args[dataDirIdx + 1]!;
+  }
+
+  if (!detach) {
+    // Run in foreground — acquire lock atomically (checks + locks in one step)
+    if (!acquireLock(process.pid)) {
+      console.log(c.yellow('JARVIS is already running'));
+      console.log(c.dim('  Stop it first with: jarvis stop'));
+      process.exit(1);
+    }
+    process.on('exit', () => releaseLock());
+    process.on('SIGINT', () => { releaseLock(); process.exit(0); });
+    process.on('SIGTERM', () => { releaseLock(); process.exit(0); });
+
+    const { startDaemon } = await import('../src/daemon/index.ts');
+    await startDaemon({ port, dataDir, noLocalTools });
+
+    if (!noOpen) {
+      openDashboard(port ?? 3142);
+    }
+  } else {
+    // Check if already running before spawning detached child
+    const existingPid = isLocked();
+    if (existingPid) {
+      console.log(c.yellow(`JARVIS is already running (PID ${existingPid})`));
+      console.log(c.dim('  Stop it first with: jarvis stop'));
+      process.exit(1);
+    }
+
+    // Run in background — spawn a detached child process with log file
+    console.log(c.cyan('Starting J.A.R.V.I.S. daemon...'));
+
+    const logPath = getLogPath();
+    const logFile = Bun.file(logPath);
+
+    const daemonArgs = [join(PACKAGE_ROOT, 'bin/jarvis.ts'), 'start', '--no-open'];
+    if (port) daemonArgs.push('--port', String(port));
+
+    const logFd = openSync(logPath, 'a');
+    const child = spawn('bun', daemonArgs, {
+      detached: true,
+      stdio: ['ignore', logFd, logFd],
+      env: { ...process.env },
+    });
+    child.unref();
+
+    // Poll for the daemon to acquire its lock (up to 10s)
+    let runningPid: number | null = null;
+    for (let i = 0; i < 20; i++) {
+      await new Promise(resolve => setTimeout(resolve, 500));
+      runningPid = isLocked();
+      if (runningPid) break;
+    }
+
+    if (runningPid) {
+      console.log(c.green(`✓ JARVIS daemon started (PID ${runningPid})`));
+      console.log(c.dim(`  Dashboard: http://localhost:${port ?? 3142}`));
+      console.log(c.dim(`  Logs:      ${logPath}`));
+      console.log(c.dim(`  Stop with: jarvis stop`));
+
+      if (!noOpen) {
+        openDashboard(port ?? 3142);
+      }
+    } else {
+      console.log(c.red('✗ Failed to start daemon. Check logs:'));
+      console.log(c.dim(`  ${logPath}`));
+      process.exit(1);
+    }
+  }
+}
+
+async function cmdStop(): Promise<void> {
+  const pid = isLocked();
+  if (!pid) {
+    console.log(c.yellow('JARVIS is not running.'));
+    return;
+  }
+
+  console.log(c.cyan(`Stopping JARVIS daemon (PID ${pid})...`));
+  try {
+    process.kill(pid, 'SIGTERM');
+
+    // Wait up to 5s for graceful shutdown, then SIGKILL
+    let alive = true;
+    for (let i = 0; i < 10; i++) {
+      await new Promise(resolve => setTimeout(resolve, 500));
+      try { process.kill(pid, 0); } catch { alive = false; break; }
+    }
+
+    if (alive) {
+      console.log(c.dim('  Process still alive, sending SIGKILL...'));
+      try { process.kill(pid, 'SIGKILL'); } catch { /* already gone */ }
+    }
+
+    releaseLock();
+    console.log(c.green('✓ JARVIS daemon stopped.'));
+  } catch (err) {
+    console.error(c.red(`Failed to stop process ${pid}: ${err}`));
+    releaseLock();
+  }
+}
+
+function cmdStatus(): void {
+  const pid = isLocked();
+  if (pid) {
+    console.log(`${c.green('●')} JARVIS is ${c.green('running')} (PID ${pid})`);
+
+    // Try to read the port from config
+    try {
+      const { homedir } = require('node:os');
+      const configPath = join(homedir(), '.jarvis', 'config.yaml');
+      const YAML = require('yaml');
+      const text = readFileSync(configPath, 'utf-8');
+      const cfg = YAML.parse(text);
+      const port = cfg?.daemon?.port ?? 3142;
+      console.log(c.dim(`  Dashboard: http://localhost:${port}`));
+    } catch {
+      console.log(c.dim(`  Dashboard: http://localhost:3142`));
+    }
+
+    console.log(c.dim(`  Stop with: jarvis stop`));
+  } else {
+    console.log(`${c.red('●')} JARVIS is ${c.red('stopped')}`);
+    console.log(c.dim(`  Start with: jarvis start`));
+  }
+}
+
+async function cmdOnboard(): Promise<void> {
+  const { runOnboard } = await import('../src/cli/onboard.ts');
+  await runOnboard();
+}
+
+async function cmdDoctor(): Promise<void> {
+  const { runDoctor } = await import('../src/cli/doctor.ts');
+  await runDoctor();
+}
+
+async function cmdUninstall(): Promise<void> {
+  const { runUninstallWizard } = await import('../src/cli/uninstall.ts');
+  await runUninstallWizard(PACKAGE_ROOT);
+}
+
+async function cmdRestart(args: string[]): Promise<void> {
+  const pid = isLocked();
+  if (pid) {
+    await cmdStop();
+  }
+
+  console.log('');
+  await cmdStart(args);
+}
+
+function cmdLogs(args: string[]): void {
+  const logPath = getLogPath();
+
+  if (!existsSync(logPath)) {
+    console.log(c.yellow('No log file found. Start the daemon first: jarvis start'));
+    return;
+  }
+
+  const follow = args.includes('-f') || args.includes('--follow');
+
+  // Parse --lines / -n
+  let lines = 50;
+  const nIdx = args.indexOf('-n') !== -1 ? args.indexOf('-n') : args.indexOf('--lines');
+  if (nIdx !== -1 && args[nIdx + 1]) {
+    const n = parseInt(args[nIdx + 1], 10);
+    if (!isNaN(n) && n > 0) lines = n;
+  }
+
+  console.log(c.dim(`Log file: ${logPath}\n`));
+
+  if (follow) {
+    // tail -f equivalent
+    const tailProc = Bun.spawn(['tail', '-f', '-n', String(lines), logPath], {
+      stdio: ['ignore', 'inherit', 'inherit'],
+    });
+
+    process.on('SIGINT', () => {
+      tailProc.kill();
+      process.exit(0);
+    });
+  } else {
+    // Just show last N lines
+    const tailProc = Bun.spawnSync(['tail', '-n', String(lines), logPath]);
+    process.stdout.write(tailProc.stdout);
+  }
+}
+
+async function cmdUpdate(): Promise<void> {
+  console.log(c.cyan('Checking for updates...\n'));
+
+  // Get current version
+  const currentVersion = getVersion();
+  console.log(`  Current version: ${c.bold(currentVersion)}`);
+
+  // Check if daemon is running (we'll restart it after update)
+  const wasRunning = isLocked();
+
+  // Stop daemon if running
+  if (wasRunning) {
+    console.log(c.dim('  Stopping daemon before update...'));
+    try {
+      process.kill(wasRunning, 'SIGTERM');
+      releaseLock();
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    } catch {
+      releaseLock();
+    }
+  }
+
+  // Update via git pull + bun install (not npm — package is not published)
+  console.log('');
+  const gitPull = Bun.spawnSync(['git', 'pull', '--ff-only'], {
+    cwd: PACKAGE_ROOT,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env },
+  });
+
+  if (gitPull.exitCode !== 0) {
+    const stderr = gitPull.stderr.toString();
+    // If not a git repo, try the install dir
+    const installDir = join(require('node:os').homedir(), '.jarvis', 'daemon');
+    const gitPull2 = Bun.spawnSync(['git', 'pull', '--ff-only'], {
+      cwd: installDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    if (gitPull2.exitCode !== 0) {
+      console.log(c.red('✗ Update failed (git pull):'));
+      console.log(c.dim(`  ${gitPull2.stderr.toString().trim() || stderr.trim()}`));
+      if (wasRunning) {
+        console.log(c.dim('\n  Restarting daemon...'));
+        await cmdStart(['--no-open']);
+      }
+      process.exit(1);
+    }
+  }
+
+  // Reinstall dependencies
+  const bunInstall = Bun.spawnSync(['bun', 'install'], {
+    cwd: PACKAGE_ROOT,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env },
+  });
+
+  if (bunInstall.exitCode !== 0) {
+    console.log(c.yellow('! Dependencies may need manual refresh: bun install'));
+  }
+
+  // Get new version
+  const newVersion = getVersion();
+  if (newVersion === currentVersion) {
+    console.log(c.green(`✓ Already on the latest version (${currentVersion})`));
+  } else {
+    console.log(c.green(`✓ Updated: ${currentVersion} → ${newVersion}`));
+  }
+
+  // Restart daemon if it was running
+  if (wasRunning) {
+    console.log(c.dim('\nRestarting daemon...'));
+    await cmdStart(['--no-open']);
+  }
+}
+
+function openDashboard(port: number): void {
+  const url = `http://localhost:${port}`;
+  try {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+      Bun.spawn(['open', url], { stdio: ['ignore', 'ignore', 'ignore'] });
+    } else {
+      // Check WSL first
+      const { readFileSync } = require('node:fs');
+      try {
+        const version = readFileSync('/proc/version', 'utf-8');
+        if (version.toLowerCase().includes('microsoft')) {
+          Bun.spawn(['wslview', url], { stdio: ['ignore', 'ignore', 'ignore'] });
+          return;
+        }
+      } catch {}
+      // Regular Linux
+      Bun.spawn(['xdg-open', url], { stdio: ['ignore', 'ignore', 'ignore'] });
+    }
+  } catch {
+    // Silently fail — user can open manually
+  }
+}
+
+// ── Main ─────────────────────────────────────────────────────────────
+
+assertSupportedPlatform();
+
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+const commandArgs = args.slice(1);
+
+switch (command) {
+  case 'start':
+    await cmdStart(commandArgs);
+    break;
+  case 'stop':
+    await cmdStop();
+    break;
+  case 'restart':
+    await cmdRestart(commandArgs);
+    break;
+  case 'status':
+    cmdStatus();
+    break;
+  case 'logs':
+  case 'log':
+    cmdLogs(commandArgs);
+    break;
+  case 'update':
+  case 'upgrade':
+    await cmdUpdate();
+    break;
+  case 'onboard':
+    await cmdOnboard();
+    break;
+  case 'doctor':
+    await cmdDoctor();
+    break;
+  case 'uninstall':
+  case 'remove':
+    await cmdUninstall();
+    break;
+  case 'version':
+  case '-v':
+  case '--version':
+    console.log(getVersion());
+    break;
+  case 'help':
+  case '-h':
+  case '--help':
+    printHelp();
+    break;
+  default:
+    console.error(c.red(`Unknown command: ${command}`));
+    console.log(c.dim('Run "jarvis help" for usage information.'));
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@shykaruu/jarvis-brain",
+  "version": "0.4.0",
+  "description": "J.A.R.V.I.S. — Just A Rather Very Intelligent System. An always-on autonomous AI daemon.",
+  "module": "src/daemon/index.ts",
+  "type": "module",
+  "bin": {
+    "jarvis": "bin/jarvis.ts"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vierisid/jarvis.git"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "keywords": ["jarvis", "ai", "daemon", "assistant", "cli"],
+  "files": [
+    "bin/",
+    "src/",
+    "roles/",
+    "ui/dist/",
+    "ui/public/",
+    "scripts/ensure-bun.cjs",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "bun run src/daemon/index.ts",
+    "dev": "bun --hot run src/daemon/index.ts",
+    "copy:models": "mkdir -p ui/public/openwakeword/models ui/public/ort && cp node_modules/openwakeword-wasm-browser/models/melspectrogram.onnx node_modules/openwakeword-wasm-browser/models/embedding_model.onnx node_modules/openwakeword-wasm-browser/models/silero_vad.onnx node_modules/openwakeword-wasm-browser/models/hey_jarvis_v0.1.onnx ui/public/openwakeword/models/ && cp node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.jsep.wasm node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.wasm node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.jsep.mjs node_modules/onnxruntime-web/dist/ort-wasm-simd-threaded.mjs ui/public/ort/",
+    "prebuild:ui": "bun run copy:models",
+    "build:ui": "bun build ui/index.html --outdir ui/dist",
+    "test": "bun test",
+    "db:init": "bun run src/vault/schema.ts",
+    "setup": "bun run scripts/setup-config.ts",
+    "test:llm": "bun run src/llm/test.ts",
+    "examples": "bun run examples/llm-integration.ts",
+    "setup:google": "bun run src/scripts/google-setup.ts",
+    "postinstall": "node scripts/ensure-bun.cjs && (bun run copy:models 2>/dev/null || true)",
+    "prepare": "git config core.hooksPath .githooks 2>/dev/null || true",
+    "prepublishOnly": "bun run copy:models && bun run build:ui"
+  },
+  "dependencies": {
+    "@codemirror/lang-css": "^6.3.1",
+    "@codemirror/lang-html": "^6.4.11",
+    "@codemirror/lang-javascript": "^6.2.5",
+    "@codemirror/lang-json": "^6.0.2",
+    "@codemirror/lang-markdown": "^6.5.0",
+    "@codemirror/lang-python": "^6.2.1",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/theme-one-dark": "^6.1.3",
+    "@codemirror/view": "^6.40.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@xyflow/react": "^12.10.1",
+    "codemirror": "^6.0.2",
+    "discord.js": "^14.25.1",
+    "edge-tts-universal": "^1.4.0",
+    "highlight.js": "^11.11.1",
+    "jose": "^6.2.0",
+    "openwakeword-wasm-browser": "^0.1.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "react-markdown": "^10.1.0",
+    "rehype-highlight": "^7.0.2",
+    "remark-gfm": "^4.0.1",
+    "sharp": "^0.34.5",
+    "tailwindcss": "^4.2.1",
+    "tesseract.js": "^7.0.0",
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/roles/activity-observer.yaml

@@ -0,0 +1,60 @@
+id: activity_observer
+name: Activity Observer
+description: A passive monitoring agent that watches user activity, learns patterns, and provides insights without taking actions.
+
+responsibilities:
+  - Monitor user's work patterns and habits
+  - Track application usage and context switches
+  - Identify productivity patterns and bottlenecks
+  - Generate insights about work efficiency
+  - Build a model of user preferences and routines
+
+autonomous_actions:
+  - Log observed activities to the vault
+  - Update user preference models
+  - Generate daily activity summaries
+
+approval_required:
+  - Share observations with other agents
+  - Send notifications or suggestions to the user
+  - Modify any system settings
+  - Access sensitive data sources
+
+kpis:
+  - name: Observation Accuracy
+    metric: Percentage of correctly identified activities
+    target: "> 90%"
+    check_interval: weekly
+  - name: Insight Quality
+    metric: User rating of generated insights
+    target: "> 4.0/5"
+    check_interval: weekly
+  - name: Pattern Detection
+    metric: Number of useful patterns identified
+    target: "> 3 per week"
+    check_interval: weekly
+
+communication_style:
+  tone: Observant and analytical, non-intrusive
+  verbosity: concise
+  formality: casual
+
+heartbeat_instructions: |
+  Every 30 minutes, passively check:
+  1. Active applications and windows
+  2. User's current context (working, browsing, break)
+  3. Time spent on different tasks
+  4. Interruptions and context switches
+
+  Do NOT interrupt the user. Only log observations.
+  At the end of each day, generate a summary of patterns noticed.
+
+sub_roles: []
+
+tools:
+  - window_observer
+  - activity_logger
+  - pattern_analyzer
+  - data_visualizer
+
+authority_level: 2