donna-komilion-bot 0.1.0

package/bin/donna.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js'

package/dist/agent.js

@@ -0,0 +1,100 @@
+/**
+ * Donna Agent — Komilion API Client
+ *
+ * Routes via komilion.com/api/v1 — no local scoring engine.
+ * Model selection is handled server-side by the Komilion Oracle.
+ * Policy maps directly to neo:frugal / neo:balanced / neo:premium.
+ */
+import { appendTurn, getTurns, createSession } from './memory.js';
+const KOMILION_BASE = 'https://www.komilion.com/api/v1';
+// ============================================================================
+// KOMILION API CALL
+// ============================================================================
+async function callKomilion(policy, messages, maxTokens = 4000) {
+    const apiKey = process.env.KOMILION_API_KEY;
+    if (!apiKey)
+        throw new Error('KOMILION_API_KEY not set');
+    const startMs = Date.now();
+    const res = await fetch(`${KOMILION_BASE}/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            model: `komilion-${policy}`,
+            messages,
+            max_tokens: maxTokens,
+        }),
+    });
+    const latencyMs = Date.now() - startMs;
+    if (!res.ok) {
+        const txt = await res.text();
+        throw new Error(`Komilion API ${res.status}: ${txt.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    const content = data.choices?.[0]?.message?.content ?? '';
+    const usage = data.usage ?? {};
+    return {
+        content,
+        inputTokens: usage.prompt_tokens ?? 0,
+        outputTokens: usage.completion_tokens ?? 0,
+        latencyMs,
+        modelId: data.model ?? `neo:${policy}`,
+    };
+}
+export async function getWallet() {
+    const apiKey = process.env.KOMILION_API_KEY;
+    if (!apiKey)
+        throw new Error('KOMILION_API_KEY not set');
+    const res = await fetch('https://www.komilion.com/api/wallet/balance', {
+        headers: { 'Authorization': `Bearer ${apiKey}` },
+    });
+    if (!res.ok) {
+        const txt = await res.text();
+        throw new Error(`Komilion wallet ${res.status}: ${txt.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return {
+        balance: data.total_available ?? 0,
+        walletBalance: data.wallet_balance ?? 0,
+        trialCredits: data.trial_credits ?? 0,
+        currency: data.currency ?? 'USD',
+        isLowBalance: data.is_low_balance ?? false,
+        message: data.message ?? '',
+        topUpUrl: 'https://www.komilion.com/billing',
+    };
+}
+// ============================================================================
+// DONNA AGENT TURN
+// ============================================================================
+export async function runTurn(sessionId, userMessage, policy = 'balanced') {
+    // Ensure session exists
+    createSession(sessionId, policy);
+    // Build messages from memory
+    const history = getTurns(sessionId, 20);
+    const messages = [
+        { role: 'system', content: 'You are Donna, a highly capable AI assistant. You help with coding, analysis, research, and creative tasks.' },
+        ...history.map(t => ({ role: t.role, content: t.content })),
+        { role: 'user', content: userMessage },
+    ];
+    // Route via Komilion Oracle
+    const result = await callKomilion(policy, messages, 4000);
+    // Store in memory
+    appendTurn(sessionId, 'user', userMessage);
+    appendTurn(sessionId, 'assistant', result.content, {
+        model: result.modelId,
+        costUsd: 0, // komilion.com tracks spend server-side
+        tokensIn: result.inputTokens,
+        tokensOut: result.outputTokens,
+    });
+    return {
+        content: result.content,
+        modelId: result.modelId,
+        latencyMs: result.latencyMs,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        costUsd: 0,
+        policy,
+    };
+}

package/dist/hermione.js

@@ -0,0 +1,113 @@
+/**
+ * Hermione — Benchmark Judge
+ *
+ * Ported from komilion/lib/hermione.ts
+ * Evaluates two AI responses side-by-side.
+ */
+const OPENROUTER_BASE = 'https://openrouter.ai/api/v1';
+export const HERMIONE_MODEL = 'anthropic/claude-sonnet-4-6';
+const SYSTEM_PROMPT = `You are Hermione, an expert AI benchmark judge.
+Evaluate two AI responses to the same prompt and score them fairly.
+
+Respond ONLY with JSON — no preamble, no markdown outside JSON.
+
+Required format:
+{
+  "a_score": <integer 1-10>,
+  "b_score": <integer 1-10>,
+  "winner": "a" | "b" | "tie",
+  "a_verdict": "<1-2 sentences>",
+  "b_verdict": "<1-2 sentences>",
+  "summary": "<1 sentence takeaway>"
+}
+
+Scoring rubric:
+- 9-10: Exceptional — production-ready, handles edge cases
+- 7-8: Good — correct and useful, minor improvements possible
+- 5-6: Acceptable — works but misses nuance
+- 3-4: Weak — partially correct or verbose without value
+- 1-2: Poor — incorrect or unhelpful
+
+Focus on correctness first, then completeness, then clarity.`;
+export async function judgeWithHermione(prompt, a, b) {
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    if (!apiKey)
+        throw new Error('OPENROUTER_API_KEY not set');
+    const judgePrompt = `Evaluate these two responses to the same prompt.
+
+USER PROMPT:
+${prompt}
+
+---
+
+RESPONSE A (${a.modelId}):
+${a.response}
+
+---
+
+RESPONSE B (${b.modelId}):
+${b.response}
+
+---
+
+Performance context (for summary only — do NOT affect quality scores):
+Latency: A=${a.latencyMs}ms, B=${b.latencyMs}ms
+Cost: A=$${a.costUsd.toFixed(5)}, B=$${b.costUsd.toFixed(5)}
+
+Score quality only (1-10 each). Declare winner based on quality alone.`;
+    try {
+        const res = await fetch(`${OPENROUTER_BASE}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+                'HTTP-Referer': 'https://www.komilion.com',
+                'X-Title': 'Donna Hermione Judge',
+            },
+            body: JSON.stringify({
+                model: HERMIONE_MODEL,
+                messages: [
+                    { role: 'system', content: SYSTEM_PROMPT },
+                    { role: 'user', content: judgePrompt },
+                ],
+                temperature: 0.1,
+                max_tokens: 500,
+            }),
+        });
+        if (!res.ok)
+            throw new Error(`Hermione API error: ${res.status}`);
+        const data = await res.json();
+        const raw = data.choices?.[0]?.message?.content ?? '';
+        const jsonStr = raw.replace(/^```json\s*/i, '').replace(/\s*```$/, '').trim();
+        const parsed = JSON.parse(jsonStr);
+        const aScore = Math.min(10, Math.max(1, Math.round(Number(parsed.a_score) || 5)));
+        const bScore = Math.min(10, Math.max(1, Math.round(Number(parsed.b_score) || 5)));
+        let winner = 'tie';
+        const raw_winner = String(parsed.winner || '').toLowerCase();
+        if (raw_winner === 'a')
+            winner = 'a';
+        else if (raw_winner === 'b')
+            winner = 'b';
+        else if (aScore > bScore)
+            winner = 'a';
+        else if (bScore > aScore)
+            winner = 'b';
+        return {
+            aScore, bScore, winner,
+            aVerdict: String(parsed.a_verdict || 'No verdict.'),
+            bVerdict: String(parsed.b_verdict || 'No verdict.'),
+            summary: String(parsed.summary || ''),
+            judgeModel: HERMIONE_MODEL,
+        };
+    }
+    catch (err) {
+        console.error('[Hermione] Judge failed, returning fallback:', err);
+        return {
+            aScore: 5, bScore: 5, winner: 'tie',
+            aVerdict: 'Hermione judgment unavailable.',
+            bVerdict: 'Hermione judgment unavailable.',
+            summary: 'Judgment failed. Compare responses manually.',
+            judgeModel: HERMIONE_MODEL,
+        };
+    }
+}

package/dist/index.js

@@ -0,0 +1,146 @@
+/**
+ * Donna Komilion Bot — Main Entry Point
+ *
+ * Interactive REPL: send prompt → komilion.com Oracle routes → SQLite memory
+ * Set KOMILION_API_KEY in .env to authenticate.
+ */
+import 'dotenv/config';
+import * as readline from 'readline';
+import { randomUUID } from 'crypto';
+import { runTurn, getWallet } from './agent.js';
+import { getTurns, searchMemory, listSessions, getSessionStats } from './memory.js';
+import { spawnAll, killAll } from './tmux.js';
+// ============================================================================
+// CLI REPL
+// ============================================================================
+async function main() {
+    const args = process.argv.slice(2);
+    // Commands
+    if (args[0] === 'spawn') {
+        spawnAll();
+        return;
+    }
+    if (args[0] === 'kill') {
+        killAll();
+        return;
+    }
+    if (args[0] === 'sessions') {
+        console.log(listSessions());
+        return;
+    }
+    if (args[0] === 'search' && args[1]) {
+        const hits = searchMemory(args.slice(1).join(' '));
+        hits.forEach(h => console.log(`[${h.sessionId}/${h.role}] ${h.snippet}`));
+        return;
+    }
+    if (args[0] === 'credits') {
+        const w = await getWallet();
+        console.log(`  Balance:  $${w.balance.toFixed(4)} ${w.currency}`);
+        console.log(`  Wallet:   $${w.walletBalance.toFixed(4)}`);
+        console.log(`  Trial:    $${w.trialCredits.toFixed(4)}`);
+        if (w.isLowBalance)
+            console.log(`  ⚠️  Low balance — top up at: ${w.topUpUrl}`);
+        return;
+    }
+    // Interactive REPL
+    const sessionId = args[0] ?? randomUUID().slice(0, 8);
+    const policy = args[1] ?? 'balanced';
+    console.log(`\n🤖 Donna Komilion Bot`);
+    console.log(`   Session: ${sessionId} | Policy: ${policy}`);
+    console.log(`   Type /help for commands, Ctrl+C to exit\n`);
+    const stats = getSessionStats(sessionId);
+    if (stats) {
+        console.log(`   Resuming: ${stats.turnCount} turns, last active ${stats.lastActive}\n`);
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.on('close', () => { console.log('\nBye.'); process.exit(0); });
+    const prompt = () => {
+        rl.question('you> ', async (input) => {
+            const line = input.trim();
+            if (!line) {
+                prompt();
+                return;
+            }
+            // Slash commands
+            if (line === '/help') {
+                console.log('  /history [n]  — show last n turns');
+                console.log('  /search <q>   — FTS5 search memory');
+                console.log('  /stats        — session stats');
+                console.log('  /sessions     — list all sessions');
+                console.log('  /credits      — show komilion.com wallet balance');
+                console.log('  /top-up       — show billing URL to add credits');
+                console.log('  /clear        — clear this session history');
+                console.log('  /exit         — quit');
+                prompt();
+                return;
+            }
+            if (line === '/exit') {
+                rl.close();
+                return;
+            }
+            if (line.startsWith('/history')) {
+                const n = parseInt(line.split(' ')[1] ?? '10');
+                const turns = getTurns(sessionId, n);
+                turns.forEach(t => console.log(`  [${t.role}] ${t.content.slice(0, 120)}`));
+                prompt();
+                return;
+            }
+            if (line.startsWith('/search ')) {
+                const q = line.slice(8);
+                const hits = searchMemory(q);
+                if (!hits.length)
+                    console.log('  No results.');
+                hits.forEach(h => console.log(`  [${h.createdAt}/${h.role}] ${h.snippet}`));
+                prompt();
+                return;
+            }
+            if (line === '/stats') {
+                const s = getSessionStats(sessionId);
+                if (s)
+                    console.log(`  turns=${s.turnCount} lastActive=${s.lastActive}`);
+                else
+                    console.log('  No stats yet.');
+                prompt();
+                return;
+            }
+            if (line === '/sessions') {
+                listSessions().forEach(s => console.log(`  ${s.id} | ${s.policy} | ${s.turnCount} turns`));
+                prompt();
+                return;
+            }
+            if (line === '/credits') {
+                try {
+                    const w = await getWallet();
+                    console.log(`  Balance:  $${w.balance.toFixed(4)} ${w.currency}`);
+                    console.log(`  Wallet:   $${w.walletBalance.toFixed(4)}`);
+                    console.log(`  Trial:    $${w.trialCredits.toFixed(4)}`);
+                    if (w.isLowBalance)
+                        console.log(`  ⚠️  Low balance — top up: ${w.topUpUrl}`);
+                }
+                catch (err) {
+                    console.error(`  ❌ ${err.message}`);
+                }
+                prompt();
+                return;
+            }
+            if (line === '/top-up') {
+                console.log('  Add credits at: https://www.komilion.com/billing');
+                prompt();
+                return;
+            }
+            // Agent turn
+            try {
+                process.stdout.write('donna> ');
+                const result = await runTurn(sessionId, line, policy);
+                console.log(result.content);
+                console.log(`\n  ↳ ${result.modelId} | komilion-${result.policy} | ${result.latencyMs}ms\n`);
+            }
+            catch (err) {
+                console.error(`  ❌ Error: ${err.message}`);
+            }
+            prompt();
+        });
+    };
+    prompt();
+}
+main().catch(console.error);

package/dist/memory.js

@@ -0,0 +1,182 @@
+/**
+ * SQLite + FTS5 Local Memory Store
+ *
+ * Stores conversation turns, searchable via full-text index.
+ * Uses better-sqlite3 (synchronous, perfect for CLI bot).
+ */
+import Database from 'better-sqlite3';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { mkdirSync } from 'fs';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DB_DIR = process.env.DONNA_DB_DIR ?? join(__dirname, '..', 'data');
+const DB_PATH = join(DB_DIR, 'donna.db');
+let _db = null;
+function getDb() {
+    if (_db)
+        return _db;
+    mkdirSync(DB_DIR, { recursive: true });
+    _db = new Database(DB_PATH);
+    _db.pragma('journal_mode = WAL');
+    _db.pragma('foreign_keys = ON');
+    initSchema(_db);
+    return _db;
+}
+function initSchema(db) {
+    // Turns table
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS turns (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id  TEXT    NOT NULL,
+      role        TEXT    NOT NULL CHECK(role IN ('user','assistant','system')),
+      content     TEXT    NOT NULL,
+      model       TEXT,
+      cost_usd    REAL,
+      tokens_in   INTEGER,
+      tokens_out  INTEGER,
+      created_at  TEXT    NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_turns_session ON turns(session_id, id);
+  `);
+    // FTS5 virtual table for full-text search
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS turns_fts USING fts5(
+      content,
+      session_id UNINDEXED,
+      role UNINDEXED,
+      turn_id UNINDEXED,
+      tokenize = 'porter ascii'
+    );
+  `);
+    // Keep FTS in sync via triggers
+    db.exec(`
+    CREATE TRIGGER IF NOT EXISTS turns_ai AFTER INSERT ON turns BEGIN
+      INSERT INTO turns_fts(content, session_id, role, turn_id)
+      VALUES (new.content, new.session_id, new.role, new.id);
+    END;
+    CREATE TRIGGER IF NOT EXISTS turns_ad AFTER DELETE ON turns BEGIN
+      DELETE FROM turns_fts WHERE turn_id = old.id;
+    END;
+  `);
+    // Sessions table (metadata)
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id          TEXT PRIMARY KEY,
+      policy      TEXT NOT NULL DEFAULT 'balanced',
+      created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      last_active TEXT NOT NULL DEFAULT (datetime('now')),
+      total_cost  REAL NOT NULL DEFAULT 0
+    );
+  `);
+}
+// ============================================================================
+// API
+// ============================================================================
+export function createSession(id, policy = 'balanced') {
+    const db = getDb();
+    db.prepare(`
+    INSERT OR IGNORE INTO sessions (id, policy) VALUES (?, ?)
+  `).run(id, policy);
+}
+export function appendTurn(sessionId, role, content, meta) {
+    const db = getDb();
+    // Ensure session exists
+    createSession(sessionId);
+    const result = db.prepare(`
+    INSERT INTO turns (session_id, role, content, model, cost_usd, tokens_in, tokens_out)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(sessionId, role, content, meta?.model ?? null, meta?.costUsd ?? null, meta?.tokensIn ?? null, meta?.tokensOut ?? null);
+    // Update session last_active + total_cost
+    if (meta?.costUsd) {
+        db.prepare(`
+      UPDATE sessions SET last_active = datetime('now'), total_cost = total_cost + ?
+      WHERE id = ?
+    `).run(meta.costUsd, sessionId);
+    }
+    else {
+        db.prepare(`UPDATE sessions SET last_active = datetime('now') WHERE id = ?`).run(sessionId);
+    }
+    return result.lastInsertRowid;
+}
+export function getTurns(sessionId, limit = 50) {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT id, session_id, role, content, model, cost_usd, tokens_in, tokens_out, created_at
+    FROM turns WHERE session_id = ? ORDER BY id DESC LIMIT ?
+  `).all(sessionId, limit);
+    return rows.reverse().map(r => ({
+        id: r.id,
+        sessionId: r.session_id,
+        role: r.role,
+        content: r.content,
+        model: r.model ?? undefined,
+        costUsd: r.cost_usd ?? undefined,
+        tokensIn: r.tokens_in ?? undefined,
+        tokensOut: r.tokens_out ?? undefined,
+        createdAt: r.created_at,
+    }));
+}
+export function searchMemory(query, limit = 10) {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT t.id, t.session_id, t.role, t.content, t.model, t.cost_usd, t.tokens_in, t.tokens_out, t.created_at,
+           snippet(turns_fts, 0, '**', '**', '…', 20) AS snippet
+    FROM turns_fts
+    JOIN turns t ON t.id = turns_fts.turn_id
+    WHERE turns_fts MATCH ?
+    ORDER BY turns_fts.rank
+    LIMIT ?
+  `).all(query, limit);
+    return rows.map(r => ({
+        id: r.id,
+        sessionId: r.session_id,
+        role: r.role,
+        content: r.content,
+        model: r.model ?? undefined,
+        costUsd: r.cost_usd ?? undefined,
+        tokensIn: r.tokens_in ?? undefined,
+        tokensOut: r.tokens_out ?? undefined,
+        createdAt: r.created_at,
+        snippet: r.snippet,
+    }));
+}
+export function getSessionStats(sessionId) {
+    const db = getDb();
+    const session = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(sessionId);
+    if (!session)
+        return null;
+    const count = db.prepare(`SELECT COUNT(*) as n FROM turns WHERE session_id = ?`).get(sessionId);
+    return {
+        turnCount: count.n,
+        totalCost: session.total_cost,
+        lastActive: session.last_active,
+    };
+}
+export function listSessions() {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT s.id, s.policy, s.total_cost, s.last_active,
+           COUNT(t.id) as turn_count
+    FROM sessions s
+    LEFT JOIN turns t ON t.session_id = s.id
+    GROUP BY s.id
+    ORDER BY s.last_active DESC
+  `).all();
+    return rows.map(r => ({
+        id: r.id,
+        policy: r.policy,
+        turnCount: r.turn_count,
+        totalCost: r.total_cost,
+        lastActive: r.last_active,
+    }));
+}
+export function clearSession(sessionId) {
+    const db = getDb();
+    db.prepare(`DELETE FROM turns WHERE session_id = ?`).run(sessionId);
+}
+export function closeDb() {
+    if (_db) {
+        _db.close();
+        _db = null;
+    }
+}

package/dist/tmux.js

@@ -0,0 +1,127 @@
+/**
+ * tmux Agent Spawning
+ *
+ * Spawns and manages Donna (Sonnet 4.6 orchestrator) and
+ * Hermione (judge) as separate tmux sessions.
+ *
+ * MCP server: PAUSED pending Harvey's explanation.
+ */
+import { execSync, exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export const DONNA_SESSION = 'donna';
+export const HERMIONE_SESSION = 'hermione';
+function tmux(cmd) {
+    return execSync(`tmux ${cmd}`, { encoding: 'utf8' }).trim();
+}
+async function tmuxAsync(cmd) {
+    const { stdout } = await execAsync(`tmux ${cmd}`);
+    return stdout.trim();
+}
+function sessionExists(name) {
+    try {
+        execSync(`tmux has-session -t ${name} 2>/dev/null`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// SESSION MANAGEMENT
+// ============================================================================
+/**
+ * Create a new tmux session (detached) if it doesn't exist.
+ * Returns true if created, false if already exists.
+ */
+export function ensureSession(name, startCmd) {
+    if (sessionExists(name)) {
+        console.log(`[tmux] Session '${name}' already exists`);
+        return false;
+    }
+    const cmd = startCmd ? `-d -s ${name} ${startCmd}` : `-d -s ${name}`;
+    tmux(`new-session ${cmd}`);
+    console.log(`[tmux] Created session '${name}'`);
+    return true;
+}
+/**
+ * Kill a tmux session.
+ */
+export function killSession(name) {
+    if (!sessionExists(name))
+        return;
+    tmux(`kill-session -t ${name}`);
+    console.log(`[tmux] Killed session '${name}'`);
+}
+/**
+ * Send keys to a tmux session (e.g. a command to run).
+ */
+export function sendKeys(session, keys, enter = true) {
+    const escaped = keys.replace(/'/g, "'\\''");
+    tmux(`send-keys -t ${session} '${escaped}' ${enter ? 'Enter' : ''}`);
+}
+/**
+ * Capture the visible output of a tmux pane.
+ */
+export function capturePane(session, lines = 50) {
+    try {
+        return tmux(`capture-pane -t ${session} -p -S -${lines}`);
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * List all active tmux sessions.
+ */
+export function listSessions() {
+    try {
+        const out = tmux(`list-sessions -F '#{session_name}'`);
+        return out.split('\n').filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================================================
+// DONNA + HERMIONE LAUNCH
+// ============================================================================
+/**
+ * Spawn the Donna orchestrator session.
+ * Runs the donna CLI in an interactive tmux window.
+ */
+export function spawnDonna(donnaCmd = 'node dist/index.js') {
+    if (sessionExists(DONNA_SESSION)) {
+        console.log(`[tmux] Donna session already running. Attaching: tmux attach -t ${DONNA_SESSION}`);
+        return;
+    }
+    ensureSession(DONNA_SESSION, `-- bash -c '${donnaCmd}; exec bash'`);
+    console.log(`✅ [tmux] Donna spawned. Attach with: tmux attach -t ${DONNA_SESSION}`);
+}
+/**
+ * Spawn the Hermione judge session.
+ * Separate window for judge runs — keeps Donna's output clean.
+ */
+export function spawnHermione(hermioneCmd = 'node dist/hermione-cli.js') {
+    if (sessionExists(HERMIONE_SESSION)) {
+        console.log(`[tmux] Hermione session already running.`);
+        return;
+    }
+    ensureSession(HERMIONE_SESSION, `-- bash -c '${hermioneCmd}; exec bash'`);
+    console.log(`✅ [tmux] Hermione spawned. Attach with: tmux attach -t ${HERMIONE_SESSION}`);
+}
+/**
+ * Spawn both Donna and Hermione.
+ */
+export function spawnAll() {
+    spawnDonna();
+    spawnHermione();
+    console.log('\n[tmux] Active sessions:', listSessions().join(', '));
+}
+/**
+ * Kill all bot sessions.
+ */
+export function killAll() {
+    killSession(DONNA_SESSION);
+    killSession(HERMIONE_SESSION);
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared types for Donna Komilion Bot
+ */
+export {};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "donna-komilion-bot",
+  "version": "0.1.0",
+  "description": "Donna orchestrator bot — routes via komilion.com, SQLite memory, tmux agent spawning",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "donna": "bin/donna.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "keywords": [
+    "komilion",
+    "openrouter",
+    "ai",
+    "routing",
+    "claude",
+    "llm",
+    "donna"
+  ],
+  "homepage": "https://www.komilion.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hshahrokni2/donna-komilion-bot"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "better-sqlite3": "^9.4.3",
+    "dotenv": "^16.4.5"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.8",
+    "@types/node": "^20.14.0",
+    "tsx": "^4.15.6",
+    "typescript": "^5.5.2"
+  }
+}