bonecode 1.0.0

package/bone/output/session/src/events.ts

@@ -0,0 +1,270 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Durable event bus with transactional outbox pattern.
+// Set EVENT_MODE=durable in .env to enable.
+
+import { Pool, PoolClient } from "pg";
+import { v4 as uuid } from "uuid";
+import { pool } from "./db";
+import { logger } from "./logger";
+import { counter } from "./metrics";
+
+export type EventDeliveryMode = "in_process" | "durable";
+
+const MODE: EventDeliveryMode =
+  (process.env.EVENT_MODE as EventDeliveryMode) || "in_process";
+
+// Events requiring exactly_once delivery (deduplicated)
+const EXACTLY_ONCE_EVENTS = new Set<string>(["SessionCompacted"]);
+
+// Events requiring at_least_once delivery (retried until ack)
+const AT_LEAST_ONCE_EVENTS = new Set<string>(["SessionCreated", "SessionStateChanged", "MessageAdded", "PartUpdated"]);
+
+export interface EventMetadata {
+  source: string;
+  timestamp: Date;
+  correlation_id: string;
+  causation_id: string;
+}
+
+export interface SystemEvent {
+  type: string;
+  payload: Record<string, unknown>;
+  metadata: EventMetadata;
+}
+
+type Handler = (event: SystemEvent) => Promise<void>;
+
+// ─── In-Process Bus ──────────────────────────────────────────────────────────
+
+class InProcessBus {
+  private handlers: Map<string, Handler[]> = new Map();
+
+  subscribe(type: string, handler: Handler): void {
+    const existing = this.handlers.get(type) || [];
+    existing.push(handler);
+    this.handlers.set(type, existing);
+  }
+
+  unsubscribe(type: string, handler: Handler): void {
+    const existing = this.handlers.get(type);
+    if (!existing) return;
+    const filtered = existing.filter(h => h !== handler);
+    if (filtered.length === 0) {
+      this.handlers.delete(type);
+    } else {
+      this.handlers.set(type, filtered);
+    }
+  }
+
+  async publish(type: string, payload: Record<string, unknown>, source: string, correlationId?: string): Promise<void> {
+    const event: SystemEvent = {
+      type,
+      payload,
+      metadata: {
+        source,
+        timestamp: new Date(),
+        correlation_id: correlationId || uuid(),
+        causation_id: uuid(),
+      },
+    };
+    counter("event.published", { type, mode: "in_process" });
+    const handlers = this.handlers.get(type) || [];
+    for (const handler of handlers) {
+      try {
+        await handler(event);
+        counter("event.delivered", { type, mode: "in_process" });
+      } catch (e: any) {
+        counter("event.delivery_failed", { type, mode: "in_process" });
+        logger.error("event_handler_failed", { event: type, metadata: { error: e.message } });
+      }
+    }
+  }
+}
+
+// ─── Durable Bus (Transactional Outbox) ──────────────────────────────────────
+
+class DurableBus {
+  private handlers: Map<string, Handler[]> = new Map();
+
+  subscribe(type: string, handler: Handler): void {
+    const existing = this.handlers.get(type) || [];
+    existing.push(handler);
+    this.handlers.set(type, existing);
+  }
+
+  unsubscribe(type: string, handler: Handler): void {
+    const existing = this.handlers.get(type);
+    if (!existing) return;
+    const filtered = existing.filter(h => h !== handler);
+    if (filtered.length === 0) {
+      this.handlers.delete(type);
+    } else {
+      this.handlers.set(type, filtered);
+    }
+  }
+
+  // Write event to outbox within the current transaction (or a new one)
+  async publish(
+    type: string,
+    payload: Record<string, unknown>,
+    source: string,
+    correlationId?: string,
+    client?: PoolClient
+  ): Promise<void> {
+    const eventId = uuid();
+    const corrId = correlationId || uuid();
+    const sql = `
+      INSERT INTO event_outbox (id, event_type, payload, source, correlation_id)
+      VALUES ($1, $2, $3, $4, $5)
+    `;
+    const params = [eventId, type, JSON.stringify({ ...payload, _event_id: eventId }), source, corrId];
+
+    if (client) {
+      // Write within caller's transaction — atomicity guaranteed
+      await client.query(sql, params);
+    } else {
+      await pool.query(sql, params);
+    }
+    counter("event.outboxed", { type });
+  }
+
+  // Called by the background worker
+  async flush(): Promise<void> {
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+
+      // Fetch pending events (lock rows to prevent concurrent processing)
+      const { rows } = await client.query(`
+        SELECT id, event_type, payload, source, correlation_id, attempts
+        FROM event_outbox
+        WHERE status = 'pending' AND scheduled_at <= NOW()
+        ORDER BY scheduled_at ASC
+        LIMIT 50
+        FOR UPDATE SKIP LOCKED
+      `);
+
+      for (const row of rows) {
+        try {
+          // exactly_once: check deduplication table
+          if (EXACTLY_ONCE_EVENTS.has(row.event_type)) {
+            const { rows: dup } = await client.query(
+              "SELECT 1 FROM event_processed WHERE event_id = $1",
+              [row.payload._event_id || row.id]
+            );
+            if (dup.length > 0) {
+              await client.query(
+                "UPDATE event_outbox SET status = 'delivered', delivered_at = NOW() WHERE id = $1",
+                [row.id]
+              );
+              continue;
+            }
+          }
+
+          const event: SystemEvent = {
+            type: row.event_type,
+            payload: row.payload,
+            metadata: {
+              source: row.source,
+              timestamp: new Date(),
+              correlation_id: row.correlation_id,
+              causation_id: uuid(),
+            },
+          };
+
+          const handlers = this.handlers.get(row.event_type) || [];
+          for (const handler of handlers) {
+            await handler(event);
+          }
+
+          // Mark delivered
+          await client.query(
+            "UPDATE event_outbox SET status = 'delivered', delivered_at = NOW(), attempts = attempts + 1 WHERE id = $1",
+            [row.id]
+          );
+
+          // Record for exactly_once deduplication
+          if (EXACTLY_ONCE_EVENTS.has(row.event_type)) {
+            await client.query(
+              "INSERT INTO event_processed (event_id, event_type) VALUES ($1, $2) ON CONFLICT DO NOTHING",
+              [row.payload._event_id || row.id, row.event_type]
+            );
+          }
+
+          counter("event.delivered", { type: row.event_type, mode: "durable" });
+        } catch (e: any) {
+          const maxAttempts = AT_LEAST_ONCE_EVENTS.has(row.event_type) ? 10 : 3;
+          const newAttempts = row.attempts + 1;
+          const status = newAttempts >= maxAttempts ? "dead_letter" : "pending";
+          const backoffMs = Math.min(1000 * Math.pow(2, newAttempts), 300000);
+          await client.query(
+            `UPDATE event_outbox
+             SET attempts = $1, last_error = $2, status = $3,
+                 scheduled_at = NOW() + ($4 || ' milliseconds')::interval
+             WHERE id = $5`,
+            [newAttempts, e.message, status, backoffMs, row.id]
+          );
+          counter("event.delivery_failed", { type: row.event_type, mode: "durable" });
+          logger.error("event_delivery_failed", { event: row.event_type, metadata: { error: e.message, attempts: newAttempts } });
+        }
+      }
+
+      await client.query("COMMIT");
+    } catch (e) {
+      await client.query("ROLLBACK");
+      throw e;
+    } finally {
+      client.release();
+    }
+  }
+
+  // Start background worker
+  startWorker(intervalMs: number = 1000): NodeJS.Timeout {
+    logger.info("event_worker_started", { event: "startup", metadata: { interval_ms: intervalMs } });
+    return setInterval(async () => {
+      try {
+        await this.flush();
+      } catch (e: any) {
+        logger.error("event_worker_error", { event: "flush_failed", metadata: { error: e.message } });
+      }
+    }, intervalMs);
+  }
+}
+
+// ─── Unified Interface ────────────────────────────────────────────────────────
+
+const inProcess = new InProcessBus();
+const durable = new DurableBus();
+
+export const eventBus = {
+  subscribe(type: string, handler: Handler): void {
+    inProcess.subscribe(type, handler);
+    durable.subscribe(type, handler);
+  },
+
+  unsubscribe(type: string, handler: Handler): void {
+    inProcess.unsubscribe(type, handler);
+    durable.unsubscribe(type, handler);
+  },
+
+  async publish(
+    type: string,
+    payload: Record<string, unknown>,
+    source: string,
+    correlationId?: string,
+    client?: PoolClient
+  ): Promise<void> {
+    if (MODE === "durable") {
+      await durable.publish(type, payload, source, correlationId, client);
+    } else {
+      await inProcess.publish(type, payload, source, correlationId);
+    }
+  },
+
+  startWorker(intervalMs?: number): NodeJS.Timeout | null {
+    if (MODE === "durable") {
+      return durable.startWorker(intervalMs);
+    }
+    return null;
+  },
+};

package/bone/output/session/src/extensions.ts

@@ -0,0 +1,215 @@
+// Generated by BoneScript compiler.
+// Extension points: implement the functions below.
+// Code between sentinel comments is preserved on recompile.
+// DO NOT remove the sentinel comments.
+
+import { query, queryOne, pool } from "./db";
+import { eventBus } from "./events";
+import { logger } from "./logger";
+import { counter } from "./metrics";
+import { broadcastToChannel } from "./websocket";
+
+// ─── LLM helpers ─────────────────────────────────────────────────────────────
+
+function llmFetch(body: object): Promise<Response> {
+  const baseUrl = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+  const apiKey = process.env.OPENAI_API_KEY || "not-needed";
+  return fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify(body),
+  });
+}
+
+/**
+ * Extension point: activate_session
+ * STABLE: implementation required.
+ */
+export async function activate_session(session_id: string): Promise<boolean> {
+  // <bonescript:ext:activate_session:begin>
+  const row = await queryOne<{ state: string }>("SELECT state FROM sessions WHERE id = $1", [session_id]);
+  if (!row) return false;
+  if (row.state === "active" || row.state === "busy") return true;
+  if (!["created", "compacting", "archived"].includes(row.state)) return false;
+  await query("UPDATE sessions SET state = 'active', updated_at = NOW() WHERE id = $1", [session_id]);
+  return true;
+  // <bonescript:ext:activate_session:end>
+}
+
+/**
+ * Extension point: deactivate_session
+ * Optional.
+ */
+export async function deactivate_session(session_id: string): Promise<void> {
+  // <bonescript:ext:deactivate_session:begin>
+  await query("UPDATE sessions SET state = 'active', updated_at = NOW() WHERE id = $1 AND state = 'busy'", [session_id]);
+  // <bonescript:ext:deactivate_session:end>
+}
+
+/**
+ * Extension point: send_prompt_to_llm
+ * STABLE: implementation required.
+ */
+export async function send_prompt_to_llm(session_id: string, message_id: string): Promise<Record<string, unknown>> {
+  // <bonescript:ext:send_prompt_to_llm:begin>
+  // Load agent config
+  const agentRow = await queryOne<any>(
+    "SELECT * FROM agent_instances WHERE session_id = $1 AND state IN ('running','waiting_for_tool') ORDER BY created_at DESC LIMIT 1",
+    [session_id]
+  );
+  if (!agentRow) throw new Error(`No active agent for session ${session_id}`);
+
+  // Load message history with parts
+  const messages = await query<any>(
+    `SELECT m.id, m.role, m.model_id, m.provider_id,
+            json_agg(p.* ORDER BY p.order_index) FILTER (WHERE p.id IS NOT NULL) AS parts
+     FROM messages m
+     LEFT JOIN parts p ON p.message_id = m.id
+     WHERE m.session_id = $1
+     GROUP BY m.id ORDER BY m.created_at ASC`,
+    [session_id]
+  );
+
+  // Build AI SDK message array
+  const aiMessages = messages.map((m: any) => {
+    const parts = m.parts || [];
+    if (m.role === "user") {
+      return { role: "user" as const, content: parts.filter((p: any) => p.part_type === "text").map((p: any) => ({ type: "text", text: p.data?.text || "" })) };
+    }
+    if (m.role === "assistant") {
+      const content: any[] = [];
+      for (const p of parts) {
+        if (p.part_type === "text") content.push({ type: "text", text: p.data?.text || "" });
+        else if (p.part_type === "tool_invocation") content.push({ type: "tool-call", toolCallId: p.data?.tool_call_id, toolName: p.data?.tool_name, args: p.data?.args });
+      }
+      return { role: "assistant" as const, content };
+    }
+    if (m.role === "tool") {
+      return { role: "tool" as const, content: parts.filter((p: any) => p.part_type === "tool_result").map((p: any) => ({ type: "tool-result", toolCallId: p.data?.tool_call_id, toolName: p.data?.tool_name, result: p.data?.result })) };
+    }
+    return { role: m.role, content: "" };
+  });
+
+  // Inject codebase context using no-embedding strategies
+  // (FTS, git recency, session history, import graph, instruction files)
+  let systemPrompt = agentRow.config?.system_prompt || agentRow.system_prompt || "";
+  try {
+    const lastUserMsg = messages.filter((m: any) => m.role === "user").slice(-1)[0];
+    const userText = (lastUserMsg?.parts || []).filter((p: any) => p.part_type === "text").map((p: any) => p.data?.text || "").join(" ");
+
+    if (userText) {
+      // Get project + worktree for this session
+      const sessionRow = await queryOne<any>(
+        `SELECT s.project_id, p.worktree FROM sessions s JOIN projects p ON p.id = s.project_id WHERE s.id = $1`,
+        [session_id]
+      );
+
+      if (sessionRow?.worktree) {
+        const { buildContext, formatContextForPrompt } = await import("../../../../src/context_builder");
+        const ctxResult = await buildContext({
+          session_id,
+          project_id: sessionRow.project_id,
+          worktree: sessionRow.worktree,
+          query: userText,
+          max_chunks: 10,
+          max_chars: 10_000,
+        });
+
+        const ctxText = formatContextForPrompt(ctxResult, sessionRow.worktree);
+        if (ctxText) {
+          systemPrompt += `\n\n${ctxText}`;
+          logger.info("context_injected", { event: "context", metadata: { summary: ctxResult.summary } });
+        }
+      }
+    }
+  } catch (e: any) {
+    logger.error("context_build_failed", { event: "context", metadata: { error: e.message } });
+  }
+
+  // Call the LLM
+  const model = agentRow.model_id || process.env.DEFAULT_MODEL || "local-model";
+  const r = await llmFetch({
+    model,
+    messages: aiMessages,
+    system: systemPrompt || undefined,
+    temperature: agentRow.temperature ?? 0.7,
+    max_tokens: agentRow.max_tokens ?? 2048,
+  });
+  if (!r.ok) throw new Error(`LLM API error ${r.status}: ${await r.text()}`);
+  const data = await r.json() as any;
+
+  const msg = data.choices?.[0]?.message;
+  const text = msg?.content || msg?.reasoning_content || "";
+  const toolCalls = msg?.tool_calls || [];
+  const usage = data.usage || {};
+
+  // Update agent token/cost counters
+  await query(
+    "UPDATE agent_instances SET total_tokens_in = total_tokens_in + $2, total_tokens_out = total_tokens_out + $3, context_window_used = context_window_used + $4, updated_at = NOW() WHERE id = $1",
+    [agentRow.id, usage.prompt_tokens || 0, usage.completion_tokens || 0, (usage.prompt_tokens || 0) + (usage.completion_tokens || 0)]
+  );
+
+  // Broadcast text delta to WebSocket part_stream channel
+  if (text) {
+    broadcastToChannel("part_stream", { type: "part.delta", session_id, message_id, delta: { type: "text", text } });
+  }
+
+  counter("llm.request.completed", { model, finish_reason: data.choices?.[0]?.finish_reason || "unknown" });
+
+  return {
+    text,
+    tool_calls: toolCalls,
+    usage: { input_tokens: usage.prompt_tokens || 0, output_tokens: usage.completion_tokens || 0 },
+    finish_reason: data.choices?.[0]?.finish_reason,
+  };
+  // <bonescript:ext:send_prompt_to_llm:end>
+}
+
+/**
+ * Extension point: cancel_llm_request
+ * Optional.
+ */
+export async function cancel_llm_request(session_id: string): Promise<void> {
+  // <bonescript:ext:cancel_llm_request:begin>
+  // In-flight requests tracked by AbortController — signal abort
+  const controller = activeRequests.get(session_id);
+  if (controller) { controller.abort(); activeRequests.delete(session_id); }
+  // <bonescript:ext:cancel_llm_request:end>
+}
+
+const activeRequests = new Map<string, AbortController>();
+
+/**
+ * Extension point: execute_tool_calls
+ * STABLE: implementation required.
+ */
+export async function execute_tool_calls(
+  session_id: string,
+  tool_calls: Array<{ id: string; tool_name: string; tool_input: Record<string, unknown> }>
+): Promise<Array<{ id: string; result: { success: boolean; output?: string; error?: string } }>> {
+  // <bonescript:ext:execute_tool_calls:begin>
+  const { execute_tool_calls: execTools } = await import("../../../../extensions/tool_executor");
+  return execTools(session_id, tool_calls);
+  // <bonescript:ext:execute_tool_calls:end>
+}
+
+/**
+ * Extension point: revert_tool_effects
+ * Optional.
+ */
+export async function revert_tool_effects(session_id: string): Promise<void> {
+  // <bonescript:ext:revert_tool_effects:begin>
+  const snapshotRow = await queryOne<any>(
+    "SELECT git_hash FROM snapshots WHERE session_id = $1 AND state = 'committed' ORDER BY created_at DESC LIMIT 1",
+    [session_id]
+  );
+  if (!snapshotRow) return;
+  const wsRow = await queryOne<any>(
+    "SELECT w.id FROM workspaces w JOIN sessions s ON s.project_id = w.project_id WHERE s.id = $1 LIMIT 1",
+    [session_id]
+  );
+  if (!wsRow) return;
+  const { git_revert } = await import("../../../../extensions/snapshot");
+  await git_revert(wsRow.id, snapshotRow.git_hash);
+  // <bonescript:ext:revert_tool_effects:end>
+}