@sesamespace/hivemind 0.2.0 → 0.3.0

package/package.json

@@ -1,28 +1,21 @@
 {
   "name": "@sesamespace/hivemind",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Cognitive architecture for AI agents with multi-layered memory",
-  "type": "module",
-  "bin": {
-    "hivemind": "dist/main.js"
-  },
-  "main": "dist/index.js",
-  "files": [
-    "dist",
-    "config",
-    "README.md"
-  ],
-  "dependencies": {
-    "@iarna/toml": "^2.2.5",
-    "@sesamespace/sdk": "^0.1.6",
-    "ws": "^8.18.0"
+  "scripts": {
+    "build": "pnpm -r build",
+    "typecheck": "pnpm -r typecheck",
+    "lint": "pnpm -r lint",
+    "test": "pnpm -r test"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=20.0.0",
+    "pnpm": ">=9.0.0"
+  },
+  "dependencies": {
+    "@sesamespace/sdk": "^0.1.6"
   },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/baileydavis2026/hivemind"
+  "devDependencies": {
+    "tsup": "^8.5.1"
   }
 }

package/packages/cli/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@hivemind/cli",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "bin": {
+    "hivemind": "dist/main.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsx src/main.ts",
+    "test": "echo \"No tests yet\""
+  },
+  "dependencies": {
+    "@hivemind/runtime": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.0"
+  }
+}

package/{dist/chunk-DVR2KBL7.js → packages/cli/src/commands/fleet.ts}

@@ -1,40 +1,53 @@
-import {
-  FleetManager
-} from "./chunk-NVJ424TB.js";
+/**
+ * CLI commands for fleet management.
+ *
+ * Usage:
+ *   hivemind fleet status                          — Show fleet dashboard
+ *   hivemind fleet add-worker <url>                — Register a worker by URL
+ *   hivemind fleet remove-worker <worker-id>       — Remove a worker from the fleet
+ *   hivemind fleet assign <worker-id> <context>    — Assign a context to a worker
+ *   hivemind fleet migrate <context> <worker-id>   — Migrate a context to another worker
+ *   hivemind fleet discover <url1> [url2] ...      — Probe URLs for workers
+ */
 
-// packages/cli/src/commands/fleet.ts
-function formatUptime(seconds) {
-  if (seconds == null) return "\u2014";
+import { FleetManager } from "@hivemind/runtime";
+import type { FleetDashboard, WorkerSummary } from "@hivemind/runtime";
+
+function formatUptime(seconds: number | null): string {
+  if (seconds == null) return "—";
   if (seconds < 60) return `${seconds}s`;
   if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
   const h = Math.floor(seconds / 3600);
-  const m = Math.floor(seconds % 3600 / 60);
+  const m = Math.floor((seconds % 3600) / 60);
   return `${h}h ${m}m`;
 }
-function formatHealth(status) {
+
+function formatHealth(status: string): string {
   switch (status) {
-    case "healthy":
-      return "OK";
-    case "degraded":
-      return "DEGRADED";
-    case "unreachable":
-      return "DOWN";
-    default:
-      return status.toUpperCase();
+    case "healthy": return "OK";
+    case "degraded": return "DEGRADED";
+    case "unreachable": return "DOWN";
+    default: return status.toUpperCase();
   }
 }
-function printDashboard(dashboard) {
+
+function printDashboard(dashboard: FleetDashboard): void {
   console.log("\n=== Hivemind Fleet ===\n");
   console.log(`Workers: ${dashboard.total_workers}  (${dashboard.healthy} healthy, ${dashboard.degraded} degraded, ${dashboard.unreachable} unreachable)`);
   console.log(`Contexts assigned: ${dashboard.total_contexts}`);
+
   if (dashboard.unassigned_contexts.length > 0) {
     console.log(`Unassigned contexts: ${dashboard.unassigned_contexts.join(", ")}`);
   }
+
   console.log("");
+
   if (dashboard.workers.length === 0) {
     console.log("No workers registered. Use 'fleet add-worker <url>' to add one.");
     return;
   }
+
+  // Table header
   const cols = { id: 12, url: 30, health: 8, activity: 10, contexts: 25, task: 20, uptime: 8 };
   const header = [
     "ID".padEnd(cols.id),
@@ -43,38 +56,44 @@ function printDashboard(dashboard) {
     "ACTIVITY".padEnd(cols.activity),
     "CONTEXTS".padEnd(cols.contexts),
     "TASK".padEnd(cols.task),
-    "UPTIME".padEnd(cols.uptime)
+    "UPTIME".padEnd(cols.uptime),
   ].join("  ");
   console.log(header);
   console.log("-".repeat(header.length));
+
   for (const w of dashboard.workers) {
     const row = [
       w.id.padEnd(cols.id),
       w.url.slice(0, cols.url).padEnd(cols.url),
       formatHealth(w.health).padEnd(cols.health),
       w.activity.padEnd(cols.activity),
-      (w.contexts.join(", ") || "\u2014").slice(0, cols.contexts).padEnd(cols.contexts),
-      (w.current_task ?? "\u2014").slice(0, cols.task).padEnd(cols.task),
-      formatUptime(w.uptime_seconds).padEnd(cols.uptime)
+      (w.contexts.join(", ") || "—").slice(0, cols.contexts).padEnd(cols.contexts),
+      (w.current_task ?? "—").slice(0, cols.task).padEnd(cols.task),
+      formatUptime(w.uptime_seconds).padEnd(cols.uptime),
     ].join("  ");
     console.log(row);
   }
-  console.log(`
-Generated: ${dashboard.generated_at}`);
+
+  console.log(`\nGenerated: ${dashboard.generated_at}`);
 }
-async function runFleetCommand(args) {
+
+export async function runFleetCommand(args: string[]): Promise<void> {
   const subcommand = args[0];
+
   if (!subcommand) {
     printUsage();
     process.exit(1);
   }
+
   const fleet = new FleetManager();
+
   switch (subcommand) {
     case "status": {
       const dashboard = await fleet.getDashboard();
       printDashboard(dashboard);
       break;
     }
+
     case "add-worker": {
       const url = args[1];
       if (!url) {
@@ -95,6 +114,7 @@ async function runFleetCommand(args) {
       }
       break;
     }
+
     case "remove-worker": {
       const workerId = args[1];
       if (!workerId) {
@@ -110,6 +130,7 @@ async function runFleetCommand(args) {
       }
       break;
     }
+
     case "assign": {
       const workerId = args[1];
       const context = args[2];
@@ -126,6 +147,7 @@ async function runFleetCommand(args) {
       }
       break;
     }
+
     case "migrate": {
       const context = args[1];
       const toWorker = args[2];
@@ -142,6 +164,7 @@ async function runFleetCommand(args) {
       }
       break;
     }
+
     case "discover": {
       const urls = args.slice(1);
       if (urls.length === 0) {
@@ -160,13 +183,15 @@ async function runFleetCommand(args) {
       }
       break;
     }
+
     default:
       console.error(`Unknown fleet subcommand: ${subcommand}`);
       printUsage();
       process.exit(1);
   }
 }
-function printUsage() {
+
+function printUsage(): void {
   console.log(`
 Usage: hivemind fleet <command> [args]
 
@@ -179,8 +204,3 @@ Commands:
   discover <url1> [url2] ...    Probe URLs for workers
 `.trim());
 }
-
-export {
-  runFleetCommand
-};
-//# sourceMappingURL=chunk-DVR2KBL7.js.map

package/packages/cli/src/commands/init.ts

@@ -0,0 +1,230 @@
+import { resolve, dirname } from "path";
+import { existsSync, writeFileSync, mkdirSync, readFileSync } from "fs";
+import { createInterface } from "readline";
+import { SesameClient } from "@sesamespace/sdk";
+
+const HIVEMIND_DIR = resolve(process.env.HIVEMIND_HOME || ".");
+const CONFIG_DIR = resolve(HIVEMIND_DIR, "config");
+const WORKSPACE_DIR = resolve(HIVEMIND_DIR, "workspace");
+const ENV_FILE = resolve(HIVEMIND_DIR, ".env");
+const LOCAL_TOML = resolve(CONFIG_DIR, "local.toml");
+
+const VAULT_CONFIG_NAME = "hivemind-config";
+
+interface ProvisioningConfig {
+  agentName: string;
+  agentHandle: string;
+  agentId: string;
+  personality?: string;
+  llmApiKey?: string;
+  llmBaseUrl?: string;
+  llmModel?: string;
+  fleetRole?: string;
+  channels: Array<{ id: string; name: string | null; kind: string }>;
+}
+
+async function prompt(question: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export async function runInitCommand(args: string[]): Promise<void> {
+  const nonInteractive = args.includes("--yes") || args.includes("-y") || args.includes("--non-interactive");
+  const filteredArgs = args.filter((a) => !["--yes", "-y", "--non-interactive", "--help", "-h"].includes(a));
+  let sesameApiKey = filteredArgs[0];
+
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return;
+  }
+
+  console.log(`
+  ╦ ╦╦╦  ╦╔═╗╔╦╗╦╔╗╔╔╦╗
+  ╠═╣║╚╗╔╝║╣ ║║║║║║║ ║║
+  ╩ ╩╩ ╚╝ ╚═╝╩ ╩╩╝╚╝═╩╝
+  Agent Initialization
+`);
+
+  // --- Step 1: Get Sesame API key ---
+  if (!sesameApiKey) {
+    sesameApiKey = await prompt("  Sesame API key: ");
+  }
+  if (!sesameApiKey) {
+    console.error("Error: Sesame API key is required");
+    process.exit(1);
+  }
+
+  // --- Step 2: Connect to Sesame and fetch manifest ---
+  console.log("\n→ Connecting to Sesame...");
+  const sdk = new SesameClient({
+    apiUrl: "https://api.sesame.space",
+    wsUrl: "wss://ws.sesame.space",
+    apiKey: sesameApiKey,
+  });
+
+  let config: ProvisioningConfig;
+  try {
+    const manifest = await sdk.getManifest();
+    console.log(`  ✓ Authenticated as ${manifest.agent.handle} (${manifest.agent.id})`);
+    console.log(`  ✓ Workspace: ${manifest.workspace.name}`);
+    console.log(`  ✓ Channels: ${manifest.channels.length}`);
+    for (const ch of manifest.channels) {
+      console.log(`    - ${ch.name || ch.id} (${ch.kind})`);
+    }
+
+    config = {
+      agentName: manifest.agent.handle,
+      agentHandle: manifest.agent.handle,
+      agentId: manifest.agent.id,
+      channels: manifest.channels.map((ch) => ({
+        id: ch.id,
+        name: ch.name,
+        kind: ch.kind,
+      })),
+    };
+
+    // --- Step 3: Check vault for config ---
+    console.log("\n→ Checking vault for provisioning config...");
+    try {
+      const vaultResp = await sdk.listVaultItems() as any;
+      const items = vaultResp.items || vaultResp.data || [];
+      const configItem = items.find((i: any) => i.name === VAULT_CONFIG_NAME);
+
+      if (configItem) {
+        console.log(`  ✓ Found ${VAULT_CONFIG_NAME} vault item`);
+        const revealResp = await sdk.revealItem(configItem.id) as any;
+        const fields = revealResp.fields || revealResp.data || {};
+
+        config.llmApiKey = fields.llm_api_key || fields.openrouter_api_key;
+        config.llmBaseUrl = fields.llm_base_url;
+        config.llmModel = fields.llm_model;
+        config.personality = fields.agent_personality || fields.personality;
+        config.fleetRole = fields.fleet_role;
+
+        if (config.llmApiKey) console.log("  ✓ LLM API key loaded from vault");
+        if (config.personality) console.log(`  ✓ Personality: ${config.personality.slice(0, 60)}...`);
+        if (config.fleetRole) console.log(`  ✓ Fleet role: ${config.fleetRole}`);
+      } else {
+        console.log("  ! No hivemind-config vault item found");
+        console.log("  ! Will prompt for LLM API key instead");
+      }
+    } catch (err) {
+      console.log(`  ! Could not read vault: ${(err as Error).message}`);
+    }
+  } catch (err) {
+    console.error(`\n  ✗ Failed to connect to Sesame: ${(err as Error).message}`);
+    console.error("  Check your API key and try again.");
+    process.exit(1);
+  } finally {
+    sdk.disconnect();
+  }
+
+  // --- Step 4: Prompt for anything missing (skip in non-interactive mode) ---
+  if (!config.llmApiKey && !nonInteractive) {
+    config.llmApiKey = await prompt("\n  OpenRouter API key: ");
+  } else if (!config.llmApiKey) {
+    console.log("  ! No LLM API key found in vault — set LLM_API_KEY in .env after init");
+  }
+
+  if (!nonInteractive) {
+    const nameOverride = await prompt(`  Agent name [${config.agentName}]: `);
+    if (nameOverride) config.agentName = nameOverride;
+  }
+
+  // --- Step 5: Write config files ---
+  console.log("\n→ Writing configuration...");
+
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  mkdirSync(WORKSPACE_DIR, { recursive: true });
+
+  // Write workspace identity files
+  const soulPath = resolve(WORKSPACE_DIR, "SOUL.md");
+  if (!existsSync(soulPath)) {
+    const personality = config.personality || "A helpful, capable agent.";
+    writeFileSync(soulPath, `# SOUL.md — Who You Are
+
+${personality}
+
+---
+
+_This file defines your personality and values. Edit it to evolve who you are._
+`);
+    console.log(`  ✓ ${soulPath}`);
+  }
+
+  const identityPath = resolve(WORKSPACE_DIR, "IDENTITY.md");
+  if (!existsSync(identityPath)) {
+    writeFileSync(identityPath, `# IDENTITY.md
+
+- **Name:** ${config.agentName}
+- **Handle:** ${config.agentHandle}
+- **Agent ID:** ${config.agentId}
+`);
+    console.log(`  ✓ ${identityPath}`);
+  }
+
+  // Write local.toml (overrides)
+  const localToml = `# Generated by hivemind init — ${new Date().toISOString()}
+# Overrides config/default.toml with agent-specific settings
+
+[agent]
+name = "${config.agentName}"
+${config.personality ? `personality = "${config.personality.replace(/"/g, '\\"')}"` : "# personality = (using default)"}
+workspace = "workspace"
+
+${config.llmModel ? `[llm]\nmodel = "${config.llmModel}"` : "# [llm] using defaults"}
+${config.llmBaseUrl ? `# base_url = "${config.llmBaseUrl}"` : ""}
+`;
+
+  writeFileSync(LOCAL_TOML, localToml);
+  console.log(`  ✓ ${LOCAL_TOML}`);
+
+  // Write .env
+  const envContent = `# Hivemind Agent — ${config.agentName}
+# Generated by hivemind init — ${new Date().toISOString()}
+SESAME_API_KEY=${sesameApiKey}
+LLM_API_KEY=${config.llmApiKey || ""}
+AGENT_NAME=${config.agentName}
+`;
+
+  writeFileSync(ENV_FILE, envContent, { mode: 0o600 });
+  console.log(`  ✓ ${ENV_FILE} (chmod 600)`);
+
+  // --- Done ---
+  console.log(`
+  ✓ Hivemind initialized for ${config.agentName}!
+
+  To start the agent:
+    ./start.sh
+
+  To start in background:
+    nohup ./start.sh > /tmp/hivemind.log 2>&1 &
+
+  Agent ID:   ${config.agentId}
+  Channels:   ${config.channels.map((c) => c.name || c.id).join(", ")}
+  Fleet role: ${config.fleetRole || "standalone"}
+`);
+}
+
+function printHelp(): void {
+  console.log(`hivemind init — Initialize a Hivemind agent from Sesame
+
+Usage: hivemind init [sesame-api-key]
+
+The API key can also be passed as the first argument.
+
+What it does:
+  1. Connects to Sesame and fetches agent identity
+  2. Reads provisioning config from Sesame vault (if available)
+  3. Prompts for any missing configuration
+  4. Writes config/local.toml and .env
+
+Options:
+  -h, --help    Show this help
+`);
+}

package/{dist/chunk-MBS5A6BZ.js → packages/cli/src/commands/service.ts}

@@ -1,15 +1,15 @@
-// packages/cli/src/commands/service.ts
 import { resolve } from "path";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { execSync } from "child_process";
 import { homedir } from "os";
-import { fileURLToPath } from "url";
-import { dirname } from "path";
-var LAUNCH_AGENTS_DIR = resolve(homedir(), "Library/LaunchAgents");
-var AGENT_LABEL = "com.hivemind.agent";
-var MEMORY_LABEL = "com.hivemind.memory";
-async function runServiceCommand(args) {
+
+const LAUNCH_AGENTS_DIR = resolve(homedir(), "Library/LaunchAgents");
+const AGENT_LABEL = "com.hivemind.agent";
+const MEMORY_LABEL = "com.hivemind.memory";
+
+export async function runServiceCommand(args: string[]): Promise<void> {
   const subcommand = args[0];
+
   switch (subcommand) {
     case "install":
       await installServices(args.slice(1));
@@ -32,85 +32,95 @@ async function runServiceCommand(args) {
       break;
   }
 }
-async function installServices(_args) {
+
+async function installServices(_args: string[]): Promise<void> {
   const hivemindHome = process.env.HIVEMIND_HOME || process.cwd();
-  console.log(`
-\u2192 Installing launchd services for ${hivemindHome}
-`);
+
+  console.log(`\n→ Installing launchd services for ${hivemindHome}\n`);
+
   mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
+
+  // Find plist templates
   const scriptDirs = [
     resolve(hivemindHome, "scripts"),
-    resolve(dirname(dirname(dirname(fileURLToPath(import.meta.url)))), "scripts")
+    resolve(dirname(dirname(dirname(fileURLToPath(import.meta.url)))), "scripts"),
   ];
+
   for (const label of [MEMORY_LABEL, AGENT_LABEL]) {
     const plistFile = `${label}.plist`;
     let templatePath = "";
+
     for (const dir of scriptDirs) {
       const p = resolve(dir, plistFile);
-      if (existsSync(p)) {
-        templatePath = p;
-        break;
-      }
+      if (existsSync(p)) { templatePath = p; break; }
     }
+
     if (!templatePath) {
-      console.error(`  \u2717 Template not found: ${plistFile}`);
+      console.error(`  ✗ Template not found: ${plistFile}`);
       continue;
     }
+
     let content = readFileSync(templatePath, "utf-8");
     content = content.replace(/__HIVEMIND_HOME__/g, hivemindHome);
+
     const destPath = resolve(LAUNCH_AGENTS_DIR, plistFile);
     writeFileSync(destPath, content);
-    try {
-      execSync(`launchctl unload ${destPath} 2>/dev/null`);
-    } catch {
-    }
+
+    // Unload if already loaded, then load
+    try { execSync(`launchctl unload ${destPath} 2>/dev/null`); } catch {}
     execSync(`launchctl load ${destPath}`);
-    console.log(`  \u2713 ${label} installed and started`);
+
+    console.log(`  ✓ ${label} installed and started`);
   }
+
   console.log("\n  Services will auto-start on boot.\n");
 }
-async function uninstallServices() {
-  console.log("\n\u2192 Uninstalling launchd services\n");
+
+async function uninstallServices(): Promise<void> {
+  console.log("\n→ Uninstalling launchd services\n");
+
   for (const label of [AGENT_LABEL, MEMORY_LABEL]) {
     const plistPath = resolve(LAUNCH_AGENTS_DIR, `${label}.plist`);
     if (existsSync(plistPath)) {
-      try {
-        execSync(`launchctl unload ${plistPath} 2>/dev/null`);
-      } catch {
-      }
+      try { execSync(`launchctl unload ${plistPath} 2>/dev/null`); } catch {}
       const { unlinkSync } = await import("fs");
       unlinkSync(plistPath);
-      console.log(`  \u2713 ${label} uninstalled`);
+      console.log(`  ✓ ${label} uninstalled`);
     } else {
       console.log(`  - ${label} not installed`);
     }
   }
   console.log("");
 }
-function showStatus() {
-  console.log("\n\u2192 Service status\n");
+
+function showStatus(): void {
+  console.log("\n→ Service status\n");
   for (const label of [MEMORY_LABEL, AGENT_LABEL]) {
     try {
       const out = execSync(`launchctl list ${label} 2>/dev/null`, { encoding: "utf-8" });
       const pidMatch = out.match(/"PID"\s*=\s*(\d+)/);
       const pid = pidMatch ? pidMatch[1] : "unknown";
-      console.log(`  \u2713 ${label}: running (PID ${pid})`);
+      console.log(`  ✓ ${label}: running (PID ${pid})`);
     } catch {
       console.log(`  - ${label}: not running`);
     }
   }
   console.log("");
 }
-function showLogs(which) {
-  const logFile = which === "memory" ? "/tmp/hivemind-memory.log" : "/tmp/hivemind-agent.log";
+
+function showLogs(which?: string): void {
+  const logFile = which === "memory"
+    ? "/tmp/hivemind-memory.log"
+    : "/tmp/hivemind-agent.log";
   try {
     execSync(`tail -30 ${logFile}`, { stdio: "inherit" });
   } catch {
     console.error(`No log file at ${logFile}`);
   }
 }
-function printHelp() {
-  console.log(`hivemind service \u2014 Manage launchd services
+
+function printHelp(): void {
+  console.log(`hivemind service — Manage launchd services
 
 Usage: hivemind service <subcommand>
 
@@ -121,12 +131,11 @@ Subcommands:
   logs [agent|memory]  Show recent logs
 
 Services:
-  com.hivemind.memory  \u2014 Memory daemon (Rust, port 3434)
-  com.hivemind.agent   \u2014 Agent runtime (Node.js, Sesame)
+  com.hivemind.memory  — Memory daemon (Rust, port 3434)
+  com.hivemind.agent   — Agent runtime (Node.js, Sesame)
 `);
 }
 
-export {
-  runServiceCommand
-};
-//# sourceMappingURL=chunk-MBS5A6BZ.js.map
+// Helpers for ESM
+import { fileURLToPath } from "url";
+import { dirname } from "path";

package/{dist/chunk-RNK5Q5GR.js → packages/cli/src/commands/start.ts}

@@ -1,13 +1,13 @@
-import {
-  startPipeline
-} from "./chunk-2I2O6X5D.js";
-
-// packages/cli/src/commands/start.ts
 import { resolve } from "path";
 import { existsSync } from "fs";
-var DEFAULT_CONFIG = "config/default.toml";
-async function runStartCommand(args) {
+import { startPipeline } from "@hivemind/runtime";
+
+const DEFAULT_CONFIG = "config/default.toml";
+
+export async function runStartCommand(args: string[]): Promise<void> {
   let configPath = DEFAULT_CONFIG;
+
+  // Parse args
   for (let i = 0; i < args.length; i++) {
     if ((args[i] === "--config" || args[i] === "-c") && args[i + 1]) {
       configPath = args[++i];
@@ -20,15 +20,18 @@ async function runStartCommand(args) {
       process.exit(1);
     }
   }
+
   const resolved = resolve(configPath);
   if (!existsSync(resolved)) {
     console.error(`Config not found: ${resolved}`);
     process.exit(1);
   }
+
   await startPipeline(resolved);
 }
-function printHelp() {
-  console.log(`hivemind start \u2014 Start the Hivemind agent
+
+function printHelp(): void {
+  console.log(`hivemind start — Start the Hivemind agent
 
 Usage: hivemind start [options]
 
@@ -37,8 +40,3 @@ Options:
   -h, --help            Show this help
 `);
 }
-
-export {
-  runStartCommand
-};
-//# sourceMappingURL=chunk-RNK5Q5GR.js.map