@johpaz/hive-core 0.1.1

package/src/agent/index.ts

@@ -0,0 +1,67 @@
+import type { Config } from "../config/loader.ts";
+import { loadSoul } from "./soul.ts";
+import { loadUser } from "./user.ts";
+import { buildSystemPrompt } from "./context.ts";
+import { logger } from "../utils/logger.ts";
+import * as path from "node:path";
+
+export interface AgentOptions {
+  agentId: string;
+  config: Config;
+  workspacePath: string;
+}
+
+export class Agent {
+  readonly agentId: string;
+  readonly workspacePath: string;
+  private config: Config;
+  private log = logger.child("agent");
+
+  constructor(options: AgentOptions) {
+    this.agentId = options.agentId;
+    this.workspacePath = options.workspacePath;
+    this.config = options.config;
+  }
+
+  async initialize(): Promise<void> {
+    this.log.info(`Initializing agent: ${this.agentId}`);
+    
+    const soul = loadSoul(path.join(this.workspacePath, "SOUL.md"));
+    const user = loadUser(path.join(this.workspacePath, "USER.md"));
+
+    if (soul) {
+      this.log.debug(`Loaded SOUL.md for agent ${this.agentId}`);
+    }
+    if (user) {
+      this.log.debug(`Loaded USER.md for agent ${this.agentId}`);
+    }
+  }
+
+  buildPrompt(): string {
+    const soul = loadSoul(path.join(this.workspacePath, "SOUL.md"));
+    const user = loadUser(path.join(this.workspacePath, "USER.md"));
+
+    return buildSystemPrompt({
+      soul: soul ?? {
+        identity: "",
+        personality: "",
+        boundaries: "",
+        instructions: "",
+        capabilities: [],
+        raw: "",
+      },
+      user,
+      skills: [],
+      memory: [],
+      maxTokens: this.config.agent?.context?.maxTokens ?? 128000,
+    });
+  }
+
+  getConfig(): Config {
+    return this.config;
+  }
+
+  getWorkspacePath(): string {
+    return this.workspacePath;
+  }
+}

package/src/agent/providers/index.ts

@@ -0,0 +1,278 @@
+import { generateText, streamText } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import type { Config, ProviderConfig } from "../../config/loader.ts";
+import { logger } from "../../utils/logger.ts";
+
+export type Provider = "openai" | "anthropic" | "gemini" | "kimi" | "ollama" | "openrouter" | "deepseek";
+
+export interface ModelOptions {
+  provider?: Provider;
+  model?: string;
+  maxTokens?: number;
+  temperature?: number;
+  system?: string;
+  messages: Array<{ role: string; content: string }>;
+  onToken?: (token: string) => void;
+}
+
+export interface ModelResponse {
+  content: string;
+  toolCalls?: Array<{
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+  }>;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+  finishReason?: string;
+}
+
+interface ProviderState {
+  rateLimited: boolean;
+  rateLimitReset: number;
+  requestCount: number;
+}
+
+type LanguageModel = ReturnType<ReturnType<typeof createOpenAI>>;
+
+const DEFAULT_MODELS: Record<Provider, string> = {
+  openai: "gpt-5.2",
+  anthropic: "claude-sonnet-4-6-20250514",
+  gemini: "gemini-2.5-flash",
+  kimi: "kimi-k2.5",
+  ollama: "llama4-maverick",
+  openrouter: "anthropic/claude-sonnet-4.6",
+  deepseek: "deepseek-v3.2",
+};
+
+export class ModelResolver {
+  private config: Config;
+  private providers: Map<Provider, ProviderState> = new Map();
+  private log = logger.child("model");
+
+  constructor(config: Config) {
+    this.config = config;
+    for (const p of Object.keys(DEFAULT_MODELS) as Provider[]) {
+      this.providers.set(p, { rateLimited: false, rateLimitReset: 0, requestCount: 0 });
+    }
+  }
+
+  private createOpenAIProvider(provConfig?: ProviderConfig) {
+    const apiKey = provConfig?.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) return null;
+    return createOpenAI({ apiKey, baseURL: provConfig?.baseUrl });
+  }
+
+  private createAnthropicProvider(provConfig?: ProviderConfig) {
+    const apiKey = provConfig?.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) return null;
+    return createAnthropic({ apiKey, baseURL: provConfig?.baseUrl });
+  }
+
+  private createGeminiProvider(provConfig?: ProviderConfig) {
+    const apiKey = provConfig?.apiKey ?? process.env.GOOGLE_GENERATIVE_AI_API_KEY ?? process.env.GEMINI_API_KEY;
+    if (!apiKey) return null;
+    return createGoogleGenerativeAI({ apiKey, baseURL: provConfig?.baseUrl });
+  }
+
+  private createKimiProvider(provConfig?: ProviderConfig) {
+    const apiKey = provConfig?.apiKey ?? process.env.MOONSHOT_API_KEY ?? process.env.KIMI_API_KEY;
+    if (!apiKey) return null;
+    return createOpenAI({ 
+      apiKey, 
+      baseURL: provConfig?.baseUrl ?? "https://api.moonshot.ai/v1" 
+    });
+  }
+
+  private createOllamaProvider(provConfig?: ProviderConfig) {
+    const baseUrl = provConfig?.baseUrl ?? "http://localhost:11434";
+    return createOpenAI({ apiKey: "ollama", baseURL: `${baseUrl}/v1` });
+  }
+
+  private createOpenRouterProvider(provConfig?: ProviderConfig) {
+    const apiKey = provConfig?.apiKey ?? process.env.OPENROUTER_API_KEY;
+    if (!apiKey) return null;
+    return createOpenAI({ apiKey, baseURL: provConfig?.baseUrl ?? "https://openrouter.ai/api/v1" });
+  }
+
+  private createDeepSeekProvider(provConfig?: ProviderConfig) {
+    const apiKey = provConfig?.apiKey ?? process.env.DEEPSEEK_API_KEY;
+    if (!apiKey) return null;
+    return createOpenAI({ apiKey, baseURL: provConfig?.baseUrl ?? "https://api.deepseek.com/v1" });
+  }
+
+  resolve(provider: Provider): { model: LanguageModel; name: string } | null {
+    const state = this.providers.get(provider);
+    if (!state) return null;
+
+    if (state.rateLimited && Date.now() < state.rateLimitReset) {
+      this.log.warn(`Provider ${provider} is rate limited`);
+      return null;
+    }
+
+    if (state.rateLimited && Date.now() >= state.rateLimitReset) {
+      state.rateLimited = false;
+      this.log.info(`Rate limit reset for ${provider}`);
+    }
+
+    const provConfig = this.config.models?.providers?.[provider];
+    const defaultModel = this.config.models?.defaults?.[provider] ?? DEFAULT_MODELS[provider];
+
+    let client: ReturnType<typeof createOpenAI> | ReturnType<typeof createAnthropic> | ReturnType<typeof createGoogleGenerativeAI> | null = null;
+
+    switch (provider) {
+      case "openai":
+        client = this.createOpenAIProvider(provConfig);
+        break;
+      case "anthropic":
+        client = this.createAnthropicProvider(provConfig);
+        break;
+      case "gemini":
+        client = this.createGeminiProvider(provConfig);
+        break;
+      case "kimi":
+        client = this.createKimiProvider(provConfig);
+        break;
+      case "ollama":
+        client = this.createOllamaProvider(provConfig);
+        break;
+      case "openrouter":
+        client = this.createOpenRouterProvider(provConfig);
+        break;
+      case "deepseek":
+        client = this.createDeepSeekProvider(provConfig);
+        break;
+    }
+
+    if (!client) {
+      this.log.warn(`Could not initialize provider ${provider}`);
+      return null;
+    }
+
+    state.requestCount++;
+    return { model: client(defaultModel) as LanguageModel, name: defaultModel };
+  }
+
+  markRateLimited(provider: Provider, resetAfterMs: number): void {
+    const state = this.providers.get(provider);
+    if (state) {
+      state.rateLimited = true;
+      state.rateLimitReset = Date.now() + resetAfterMs;
+      this.log.warn(`Rate limited ${provider} for ${resetAfterMs}ms`);
+    }
+  }
+
+  getAvailableProvider(): Provider | null {
+    const preferred = this.config.models?.defaultProvider ?? "gemini";
+    if (this.resolve(preferred)) return preferred;
+
+    for (const p of Object.keys(DEFAULT_MODELS) as Provider[]) {
+      if (p !== preferred && this.resolve(p)) return p;
+    }
+    return null;
+  }
+}
+
+export class AgentRunner {
+  private config: Config;
+  private resolver: ModelResolver;
+  private log = logger.child("runner");
+
+  constructor(config: Config) {
+    this.config = config;
+    this.resolver = new ModelResolver(config);
+  }
+
+  async generate(options: ModelOptions): Promise<ModelResponse> {
+    const provider = options.provider ?? this.config.models?.defaultProvider ?? "gemini";
+    const resolved = this.resolver.resolve(provider);
+
+    if (!resolved) {
+      throw new Error(`No available provider: ${provider}`);
+    }
+
+    this.log.debug(`Generating with ${provider}/${resolved.name}`);
+
+    const messages = options.messages.map((m) => ({
+      role: m.role as "user" | "assistant" | "system",
+      content: m.content,
+    }));
+
+    try {
+      if (options.onToken) {
+        const stream = await streamText({
+          model: resolved.model,
+          system: options.system,
+          messages,
+          temperature: options.temperature ?? 0.7,
+        });
+
+        let fullText = "";
+        for await (const chunk of stream.textStream) {
+          fullText += chunk;
+          options.onToken(chunk);
+        }
+
+        return {
+          content: fullText,
+          usage: {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+          },
+          finishReason: await stream.finishReason,
+        };
+      }
+
+      const result = await generateText({
+        model: resolved.model,
+        system: options.system,
+        messages,
+        temperature: options.temperature ?? 0.7,
+      });
+
+      const toolCalls = result.toolCalls?.map((tc) => {
+        const t = tc as unknown as { toolCallId: string; toolName: string; input: Record<string, unknown> };
+        return {
+          id: t.toolCallId,
+          name: t.toolName,
+          args: t.input,
+        };
+      });
+
+      return {
+        content: result.text,
+        toolCalls,
+        usage: {
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0,
+        },
+        finishReason: result.finishReason,
+      };
+    } catch (error) {
+      const err = error as Error & { statusCode?: number };
+      
+      if (err.statusCode === 429 || err.message.includes("rate limit")) {
+        this.resolver.markRateLimited(provider, 60000);
+        throw new Error(`Rate limited on ${provider}, try another provider`);
+      }
+
+      this.log.error(`Generation failed: ${err.message}`);
+      throw error;
+    }
+  }
+
+  getResolver(): ModelResolver {
+    return this.resolver;
+  }
+}
+
+export function createAgentRunner(config: Config): AgentRunner {
+  return new AgentRunner(config);
+}

package/src/agent/providers.ts

@@ -0,0 +1 @@
+export * from "./providers/index.ts";

package/src/agent/soul.ts

@@ -0,0 +1,89 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logger } from "../utils/logger.ts";
+
+export interface SoulConfig {
+  identity: string;
+  personality: string;
+  boundaries: string;
+  instructions: string;
+  capabilities: string[];
+  raw: string;
+}
+
+function extractSection(content: string, sectionName: string): string {
+  const regex = new RegExp(`## ${sectionName}[\\s\\S]*?(?=## |$)`, "i");
+  const match = content.match(regex);
+  if (!match) return "";
+  return match[0]
+    .replace(new RegExp(`## ${sectionName}`, "i"), "")
+    .trim();
+}
+
+export function loadSoul(soulPath: string): SoulConfig | null {
+  try {
+    if (!fs.existsSync(soulPath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(soulPath, "utf-8");
+    
+    return {
+      identity: extractSection(content, "Identity"),
+      personality: extractSection(content, "Personality"),
+      boundaries: extractSection(content, "Boundaries"),
+      instructions: extractSection(content, "Instructions"),
+      capabilities: [],
+      raw: content,
+    };
+  } catch (error) {
+    logger.error(`Failed to load SOUL.md: ${(error as Error).message}`);
+    return null;
+  }
+}
+
+export function soulExpandPath(p: string): string {
+  if (p.startsWith("~")) {
+    return path.join(process.env.HOME ?? "", p.slice(1));
+  }
+  return p;
+}
+
+export function watchSoul(
+  soulPath: string,
+  onChange: (soul: SoulConfig) => void
+): () => void {
+  const expandedPath = soulExpandPath(soulPath);
+  let lastContent = "";
+
+  try {
+    if (fs.existsSync(expandedPath)) {
+      lastContent = fs.readFileSync(expandedPath, "utf-8");
+    }
+  } catch {
+    // Ignore initial read errors
+  }
+
+  const watcher = fs.watch(
+    path.dirname(expandedPath),
+    (eventType, filename) => {
+      if (filename !== path.basename(expandedPath)) return;
+      if (eventType !== "change") return;
+
+      try {
+        const newContent = fs.readFileSync(expandedPath, "utf-8");
+        if (newContent !== lastContent) {
+          lastContent = newContent;
+          const soul = loadSoul(expandedPath);
+          if (soul) {
+            onChange(soul);
+          }
+        }
+      } catch (error) {
+        logger.error(`Error watching SOUL.md: ${(error as Error).message}`);
+      }
+    }
+  );
+
+  return () => watcher.close();
+}

package/src/agent/stuck-loop.ts

@@ -0,0 +1,133 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+import { hashObject } from "../utils/crypto.ts";
+
+interface ToolCallRecord {
+  toolName: string;
+  argsHash: string;
+  errorMessage?: string;
+  timestamp: number;
+}
+
+interface StuckLoopState {
+  detected: boolean;
+  toolName: string;
+  count: number;
+  lastError?: string;
+}
+
+export class StuckLoopDetector {
+  private log = logger.child("stuck-loop");
+  private history: Map<string, ToolCallRecord[]> = new Map();
+  private readonly maxHistoryPerSession = 50;
+  private readonly triggerThreshold = 3;
+
+  constructor(_config: Config) {}
+
+  recordToolCall(
+    sessionId: string,
+    toolName: string,
+    args: Record<string, unknown>,
+    error?: string
+  ): void {
+    let sessionHistory = this.history.get(sessionId);
+    if (!sessionHistory) {
+      sessionHistory = [];
+      this.history.set(sessionId, sessionHistory);
+    }
+
+    const record: ToolCallRecord = {
+      toolName,
+      argsHash: hashObject(args),
+      errorMessage: error,
+      timestamp: Date.now(),
+    };
+
+    sessionHistory.push(record);
+
+    if (sessionHistory.length > this.maxHistoryPerSession) {
+      sessionHistory.shift();
+    }
+
+    this.log.debug(`Recorded tool call: ${toolName} for session ${sessionId}`);
+  }
+
+  check(sessionId: string): StuckLoopState {
+    const sessionHistory = this.history.get(sessionId) ?? [];
+    
+    if (sessionHistory.length < this.triggerThreshold) {
+      return { detected: false, toolName: "", count: 0 };
+    }
+
+    const recent = sessionHistory.slice(-10);
+    const counts = new Map<string, { count: number; error?: string }>();
+
+    for (const record of recent) {
+      const key = `${record.toolName}:${record.argsHash}`;
+      const existing = counts.get(key);
+      
+      if (existing) {
+        existing.count++;
+        if (record.errorMessage) {
+          existing.error = record.errorMessage;
+        }
+      } else {
+        counts.set(key, { count: 1, error: record.errorMessage });
+      }
+    }
+
+    for (const [key, data] of counts) {
+      if (data.count >= this.triggerThreshold && data.error) {
+        const toolName = key.split(":")[0] ?? "unknown";
+        
+        this.log.warn(`Stuck loop detected: ${toolName} called ${data.count} times with same args and error`);
+        
+        return {
+          detected: true,
+          toolName,
+          count: data.count,
+          lastError: data.error,
+        };
+      }
+    }
+
+    return { detected: false, toolName: "", count: 0 };
+  }
+
+  getInterventionMessage(state: StuckLoopState): string | null {
+    if (!state.detected) return null;
+
+    if (state.count >= this.triggerThreshold + 1) {
+      return `CRITICAL: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing with: "${state.lastError}". The user has been notified. You MUST try a completely different approach or ask the user for guidance.`;
+    }
+
+    return `WARNING: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing. You MUST try a completely different approach instead of repeating the same action.`;
+  }
+
+  clear(sessionId: string): void {
+    this.history.delete(sessionId);
+    this.log.debug(`Cleared stuck loop history for session ${sessionId}`);
+  }
+
+  prune(maxAgeMs: number = 30 * 60 * 1000): number {
+    const now = Date.now();
+    let pruned = 0;
+
+    for (const [sessionId, history] of this.history) {
+      const filtered = history.filter(r => now - r.timestamp < maxAgeMs);
+      
+      if (filtered.length === 0) {
+        this.history.delete(sessionId);
+        pruned++;
+      } else if (filtered.length !== history.length) {
+        this.history.set(sessionId, filtered);
+      }
+    }
+
+    return pruned;
+  }
+}
+
+export function createStuckLoopDetector(config: Config): StuckLoopDetector {
+  return new StuckLoopDetector(config);
+}

package/src/agent/user.ts

@@ -0,0 +1,86 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logger } from "../utils/logger.ts";
+
+export interface UserConfig {
+  name: string;
+  language: string;
+  timezone: string;
+  activeProjects: string[];
+  preferences: Record<string, unknown>;
+  raw: string;
+}
+
+function extractFieldValue(content: string, fieldName: string): string {
+  const regex = new RegExp(`${fieldName}:\\s*(.+)`, "i");
+  const match = content.match(regex);
+  return match?.[1]?.trim() ?? "";
+}
+
+export function loadUser(userPath: string): UserConfig | null {
+  try {
+    if (!fs.existsSync(userPath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(userPath, "utf-8");
+    
+    return {
+      name: extractFieldValue(content, "name") || "User",
+      language: extractFieldValue(content, "language") || "English",
+      timezone: extractFieldValue(content, "timezone") || "UTC",
+      activeProjects: [],
+      preferences: {},
+      raw: content,
+    };
+  } catch (error) {
+    logger.error(`Failed to load USER.md: ${(error as Error).message}`);
+    return null;
+  }
+}
+
+export function userExpandPath(p: string): string {
+  if (p.startsWith("~")) {
+    return path.join(process.env.HOME ?? "", p.slice(1));
+  }
+  return p;
+}
+
+export function watchUser(
+  userPath: string,
+  onChange: (user: UserConfig) => void
+): () => void {
+  const expandedPath = userExpandPath(userPath);
+  let lastContent = "";
+
+  try {
+    if (fs.existsSync(expandedPath)) {
+      lastContent = fs.readFileSync(expandedPath, "utf-8");
+    }
+  } catch {
+    // Ignore initial read errors
+  }
+
+  const watcher = fs.watch(
+    path.dirname(expandedPath),
+    (eventType, filename) => {
+      if (filename !== path.basename(expandedPath)) return;
+      if (eventType !== "change") return;
+
+      try {
+        const newContent = fs.readFileSync(expandedPath, "utf-8");
+        if (newContent !== lastContent) {
+          lastContent = newContent;
+          const user = loadUser(expandedPath);
+          if (user) {
+            onChange(user);
+          }
+        }
+      } catch (error) {
+        logger.error(`Error watching USER.md: ${(error as Error).message}`);
+      }
+    }
+  );
+
+  return () => watcher.close();
+}