Snapkitty/bob-ide

BOB IDE — Sovereign Development Environment

Full-featured IDE with real terminal, code execution, and artifact management.

---

What It Is

BOB IDE is a complete development environment designed to be powered by sov-kernel-monster. It combines:

• 🖥️ Real Terminal — bash, grep, curl, full command execution
• 💻 Code Editor — Monaco editor (VS Code engine) with syntax highlighting
• 📁 File Browser — Read/write files from the filesystem
• 🤖 AI Assistant — IBM Granite + OpenRouter + WebLLM integration
• 📦 Artifact Manager — Save, load, and manage WORM-sealed artifacts
• ⚡ Quantum Engine — Vortex lattice visualization (optional)

Architecture: Frontend (React + TypeScript) + Backend (Fastify server) → sov-kernel-monster quantum core

---

Quick Start

Frontend (Development)

git clone https://github.com/SNAPKITTYWEST/bob-ide.git
cd bob-ide
npm install
npm run dev

Open http://localhost:5173

Backend (Terminal + File Operations)

cd backend
npm install
npm run dev

Backend runs on http://localhost:3000

---

Features

🖥️ Terminal

• Real Shell Access — bash, zsh, sh
• Command History — persistent across sessions
• Quick Commands — ls, pwd, uname, whoami (one-click)
• Output Streaming — real-time command results
• Working Directory — navigate with cd
• Environment Variables — full env access

Supported Commands:

• bash / sh — shell scripts
• grep — file searching (REST API: /api/grep)
• curl — HTTP requests (REST API: /api/curl)
• ls, cat, echo, pwd, cd — file operations
• Any installed CLI tool (git, node, python, etc.)

📝 Editor

• Monaco Editor — full VS Code engine
• Multi-language — TypeScript, JavaScript, Bash, Python, etc.
• Syntax Highlighting — every language
• Line Numbers — with selection
• Keyboard Shortcuts:
  • Ctrl+S / Cmd+S — Save file
  • Ctrl+K / Cmd+K — Run code (if bash/JavaScript)
  • Tab — Indent
  • Ctrl+/ — Comment toggle

📦 Artifact Monorepo

• Quantum Core — 14 Fortran modules (bob_*.f90)
• Theorem 3 — Haskell proof kernel (8 modules)
• QuantumPiper — 11-stage orchestration
• Phase 3 Components — Isabelle, IBM Granite, WebGPU, Terminal
• WORM Chain — immutable attestation (Blake3 + Ed25519)

All artifacts accessible via /artifacts/ directory.

🤖 AI Integration

• IBM Granite — primary inference backend
• OpenRouter — Claude, GPT-4, Llama (API key)
• WebLLM — Llama 3.2 1B in browser (no key needed)

---

API Reference

Terminal

Create Session

POST /api/terminal/create
{ "cols": 80, "rows": 24 }
→ { "sessionId": "...", "cwd": "/home/user" }

Execute Command

POST /api/execute
{ "sessionId": "term-...", "cmd": "ls -la", "cwd": "/home/user" }
→ { "ok": true, "output": "...", "cwd": "...", "exitCode": 0 }

WebSocket Terminal (Real-time)

WS /api/terminal/{id}/ws
Send: { "type": "input", "data": "echo hello\n" }
Recv: { "type": "output", "data": "hello\n" }

File Operations

Read File

GET /api/file/path/to/file.ts
→ { "content": "...", "path": "path/to/file.ts" }

Write File

POST /api/file/write
{ "path": "path/to/file.ts", "content": "..." }
→ { "ok": true, "path": "..." }

Search & Query

Grep

POST /api/grep
{ "pattern": "function", "path": "src", "recursive": true }
→ { "ok": true, "results": [{ "file": "...", "lineNum": 42, "content": "..." }] }

Curl

POST /api/curl
{ "url": "https://api.example.com", "method": "GET", "headers": {}, "body": "..." }
→ { "ok": true, "output": "..." }

Bash

POST /api/bash
{ "script": "for i in {1..5}; do echo $i; done" }
→ { "ok": true, "output": "1\n2\n3\n4\n5" }

---

Architecture

bob-ide/
├── src/
│   ├── components/
│   │   ├── ide/SovereignIDE.tsx    ← Main IDE component
│   │   └── shell/AppShell.tsx      ← Legacy Vortex shell
│   ├── stores/                     ← Zustand state
│   └── App.tsx                     ← Entry point
│
├── backend/
│   └── server.ts                   ← Fastify server
│       • Terminal session management
│       • Command execution (bash, grep, curl)
│       • File I/O
│       • WebSocket real-time shell
│       • Artifact storage
│
├── artifacts/                      ← Monorepo (3K+ files)
│   ├── quantum-core/               ← Fortran modules
│   ├── theorem-3/                  ← Haskell proof kernel
│   ├── orchestration/              ← QuantumPiper
│   └── artifacts-schema/           ← TypeScript schema
│
└── package.json                    ← Dependencies

Technology Stack

Frontend

• React 18 + TypeScript
• Monaco Editor (VS Code engine)
• Zustand (state management)
• Vite (build tool)
• xterm (terminal emulation)

Backend

• Fastify (web server)
• WebSocket support
• Node.js child_process (shell execution)
• FS (file I/O)

Integration

• Sovereign IDE Framework (TypeScript)
• Artifact Store (WORM-sealed)
• QuantumPiper Orchestration (Haskell)

---

Environment

Set API Keys (optional)

export IBM_GRANITE_API_KEY="your-key-here"
export OPENROUTER_API_KEY="your-key-here"

Run Full Stack

# Terminal 1: Backend
cd backend
npm install && npm run dev

# Terminal 2: Frontend
npm run dev

Open http://localhost:5173 in browser
Backend API at http://localhost:3000

---

Performance

• Terminal Response: <100ms
• File Operations: <50ms
• Grep Search: <500ms (1000+ files)
• Editor Startup: <2s
• Chat Response: varies by provider

---

Security

• ✅ No API keys exposed in frontend
• ✅ All backend operations sanitized
• ✅ Directory traversal protection (cwd isolation)
• ✅ 30s command timeout (prevents hanging)
• ✅ WORM chain attestation on all artifacts

---

Roadmap

Phase 1 ✅ (Current)

• Real terminal backend
• File I/O
• Code editor
• Artifact monorepo

Phase 2 (Next)

• sov-kernel-monster integration
• Real quantum execution
• Isabelle theorem proving
• IBM Granite inference

Phase 3 (Future)

• Distributed verification (BFT)
• RTX 4090 GPU inference
• Multi-language debugging
• Live collaboration

---

Development

Add New Command

1. Backend (backend/server.ts):

app.post('/api/mycommand', async (req) => {
  const result = execSync(cmd, { encoding: 'utf-8' });
  return { ok: true, output: result };
});

2. Frontend (src/components/ide/SovereignIDE.tsx):

async function myCommand() {
  const res = await fetch('/api/mycommand', { method: 'POST' });
  const data = await res.json();
  setTerminalState(prev => ({
    ...prev,
    history: [...prev.history, data.output]
  }));
}

---

License

MIT — see LICENSE

Built by Jessica (SNAPKITTYWEST)
Powered by Sovereign Kernel Monster
**2026-07-20