bonecode 1.0.0

package/bone/output/agent/src/flows.ts

@@ -0,0 +1,168 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Saga runtime — implements flow declarations with backward compensation.
+//
+// On step failure, executes compensations for ALL completed steps in reverse order.
+
+import { logger } from "./logger";
+import { counter } from "./metrics";
+
+export interface FlowStep {
+  name: string;
+  action: (ctx: any) => Promise<void>;
+  compensation: ((ctx: any) => Promise<void>) | null;
+}
+
+export interface FlowResult {
+  ok: boolean;
+  failed_step?: string;
+  compensated: string[];
+  error?: string;
+}
+
+export async function executeFlow(name: string, steps: FlowStep[], ctx: any): Promise<FlowResult> {
+  const completed: { step: string; compensation: ((c: any) => Promise<void>) | null }[] = [];
+
+  for (const step of steps) {
+    try {
+      logger.info("flow_step_started", { event: name + "." + step.name });
+      await step.action(ctx);
+      completed.push({ step: step.name, compensation: step.compensation });
+      counter("flow.step_completed", { flow: name, step: step.name });
+    } catch (e: any) {
+      logger.error("flow_step_failed", { event: name + "." + step.name, metadata: { error: e.message } });
+      counter("flow.step_failed", { flow: name, step: step.name });
+
+      // Backward compensation in reverse order
+      const compensated: string[] = [];
+      for (const c of [...completed].reverse()) {
+        if (!c.compensation) continue;
+        try {
+          await c.compensation(ctx);
+          compensated.push(c.step);
+          logger.info("flow_compensated", { event: name + "." + c.step });
+        } catch (compErr: any) {
+          logger.error("flow_compensation_failed", { event: name + "." + c.step, metadata: { error: compErr.message } });
+          // Continue with other compensations even if one fails
+        }
+      }
+
+      return { ok: false, failed_step: step.name, compensated, error: e.message };
+    }
+  }
+
+  counter("flow.completed", { flow: name });
+  return { ok: true, compensated: [] };
+}
+
+// Flow: agent_coding_loop
+// ctx must contain: { req, res, auth, client? } for transactional flows
+export async function execute_agent_coding_loop(ctx: { req: any; res: any; auth: any; client?: any }): Promise<FlowResult> {
+  const steps: FlowStep[] = [
+    {
+      name: "plan",
+      action: async (ctx) => {
+        // Calls capability: create_plan(agent, task)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/create-plan`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step plan failed: ${await response.text()}`);
+        ctx.plan_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: abandon_plan(plan)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/abandon-plan`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "edit",
+      action: async (ctx) => {
+        // Calls capability: execute_build_steps(agent, plan)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/execute-build-steps`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step edit failed: ${await response.text()}`);
+        ctx.edit_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: revert_build_steps(agent, plan)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/revert-build-steps`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "test",
+      action: async (ctx) => {
+        // Calls capability: run_tests(agent, session)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/run-tests`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step test failed: ${await response.text()}`);
+        ctx.test_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: skip_tests(agent)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/skip-tests`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "fix",
+      action: async (ctx) => {
+        // Calls capability: fix_test_failures(agent, session)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/fix-test-failures`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step fix failed: ${await response.text()}`);
+        ctx.fix_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: revert_fixes(agent)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/revert-fixes`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "commit",
+      action: async (ctx) => {
+        // Calls capability: commit_changes(agent, session)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/commit-changes`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step commit failed: ${await response.text()}`);
+        ctx.commit_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: revert_commit(agent)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/revert-commit`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+  ];
+  return executeFlow("agent_coding_loop", steps, ctx);
+}

package/bone/output/agent/src/health.ts

@@ -0,0 +1,43 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Implements spec/10 §5 (Health Checks)
+
+import { Router, Request, Response } from "express";
+import { pool } from "./db";
+import { dump as dumpMetrics } from "./metrics";
+
+export const healthRouter = Router();
+
+// Liveness — is the process running?
+healthRouter.get("/live", (_req: Request, res: Response) => {
+  res.json({ status: "ok", timestamp: new Date().toISOString() });
+});
+
+// Readiness — can the service accept requests?
+healthRouter.get("/ready", async (_req: Request, res: Response) => {
+  const checks: Record<string, { ok: boolean; message?: string }> = {};
+
+  // Postgres
+  try {
+    await pool.query("SELECT 1");
+    checks.postgres = { ok: true };
+  } catch (e: any) {
+    checks.postgres = { ok: false, message: e.message };
+  }
+
+  const allOk = Object.values(checks).every(c => c.ok);
+  res.status(allOk ? 200 : 503).json({
+    status: allOk ? "ok" : "degraded",
+    checks,
+    timestamp: new Date().toISOString(),
+  });
+});
+
+// Startup — has initialization completed?
+healthRouter.get("/startup", (_req: Request, res: Response) => {
+  res.json({ status: "ok", uptime: process.uptime() });
+});
+
+// Prometheus-style metrics
+healthRouter.get("/metrics", (_req: Request, res: Response) => {
+  res.type("text/plain").send(dumpMetrics());
+});

package/bone/output/agent/src/index.ts

@@ -0,0 +1,100 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// System: AgentDomain
+require("dotenv").config();
+import express from "express";
+import { createServer } from "http";
+import cors from "cors";
+import helmet from "helmet";
+import rateLimit from "express-rate-limit";
+import { authMiddleware } from "./auth";
+import { healthRouter } from "./health";
+import { logger } from "./logger";
+import { eventBus } from "./events";
+import { pool } from "./db";
+import { setupWebSocketServer } from "./websocket";
+
+import { agentInstancesRouter } from "./routes/agent_instance";
+import { tasksRouter } from "./routes/task";
+import { plansRouter } from "./routes/plan";
+import { buildStepsRouter } from "./routes/build_step";
+import { toolCallsRouter } from "./routes/tool_call";
+
+const app = express();
+const httpServer = createServer(app);
+const PORT = parseInt(process.env.PORT || "3000");
+
+// Middleware
+app.use(helmet());
+// CORS: restrict to ALLOWED_ORIGINS env var (comma-separated). Defaults to same-origin only.
+const __allowedOrigins = (process.env.ALLOWED_ORIGINS || "").split(",").map(s => s.trim()).filter(Boolean);
+app.use(cors({
+  origin: __allowedOrigins.length > 0
+    ? (origin, cb) => { if (!origin || __allowedOrigins.includes(origin)) cb(null, true); else cb(new Error("Not allowed by CORS")); }
+    : false,
+  credentials: true,
+}));
+app.use(express.json({ limit: "1mb" }));
+app.use(express.urlencoded({ extended: false, limit: "1mb" }));
+app.use(authMiddleware);
+app.use(rateLimit({ windowMs: 60000, max: 200 }));
+
+// Request timeout (default 30s, override per-route)
+app.use((req: any, res: any, next: any) => {
+  const timeout = parseInt(process.env.REQUEST_TIMEOUT_MS || "30000");
+  const timer = setTimeout(() => {
+    if (!res.headersSent) {
+      res.status(503).json({ error: { code: "REQUEST_TIMEOUT", message: "Request timed out" } });
+    }
+  }, timeout);
+  res.on("finish", () => clearTimeout(timer));
+  next();
+});
+
+// Health & metrics
+app.use("/health", healthRouter);
+
+// Routes
+app.use("/agent_instances", agentInstancesRouter);
+app.use("/tasks", tasksRouter);
+app.use("/plans", plansRouter);
+app.use("/build_steps", buildStepsRouter);
+app.use("/tool_calls", toolCallsRouter);
+
+// WebSocket
+setupWebSocketServer(httpServer);
+
+// Start
+httpServer.listen(PORT, () => {
+  logger.info("server_started", { event: "startup", metadata: { port: PORT } });
+  // Start durable event worker (no-op in in_process mode)
+  eventBus.startWorker(parseInt(process.env.EVENT_WORKER_INTERVAL_MS || "1000"));
+  console.log(`[AgentDomain] Running on port ${PORT}`);
+  console.log(`  HTTP routes:`);
+  console.log(`    /agent_instances`);
+  console.log(`    /tasks`);
+  console.log(`    /plans`);
+  console.log(`    /build_steps`);
+  console.log(`    /tool_calls`);
+  console.log(`  WebSocket: /ws?channel=<name>&token=<jwt>`);
+  console.log(`  Health: /health/live, /health/ready, /health/metrics`);
+});
+
+// Graceful shutdown
+const shutdown = async (signal: string) => {
+  logger.info("server_stopping", { event: "shutdown", metadata: { signal } });
+  httpServer.close(async () => {
+    try {
+      await pool.end();
+      logger.info("server_stopped", { event: "shutdown", status: "success" });
+    } catch (e: any) {
+      logger.error("shutdown_error", { event: "shutdown", metadata: { error: e.message } });
+    }
+    process.exit(0);
+  });
+  // Force exit after 10s if connections don't drain
+  setTimeout(() => { logger.error("shutdown_timeout", { event: "shutdown" }); process.exit(1); }, 10000);
+};
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
+
+export { app, httpServer };

package/bone/output/agent/src/logger.ts

@@ -0,0 +1,66 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Implements spec/10 §3 (Logging Schema)
+
+import { v4 as uuid } from "uuid";
+
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+export type LogStatus = "success" | "failure" | "timeout" | "rejected";
+
+export interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  service: string;
+  trace_id: string;
+  span_id: string;
+  event: string;
+  duration_ms?: number;
+  status: LogStatus;
+  entity_id?: string;
+  actor_id?: string | null;
+  error_code?: string | null;
+  metadata?: Record<string, unknown>;
+}
+
+class Logger {
+  private service: string;
+
+  constructor(service: string) {
+    this.service = service;
+  }
+
+  emit(entry: Omit<LogEntry, "timestamp" | "service" | "span_id">): void {
+    const full: LogEntry = {
+      timestamp: new Date().toISOString(),
+      service: this.service,
+      span_id: uuid(),
+      ...entry,
+    };
+    // In production: send to log aggregator. In dev: console.
+    const fn = entry.level === "error" || entry.level === "fatal" ? console.error : console.log;
+    fn(JSON.stringify(full));
+  }
+
+  info(event: string, fields: Partial<LogEntry> = {}): void {
+    this.emit({ level: "info", event, status: "success", trace_id: fields.trace_id || "", ...fields });
+  }
+
+  warn(event: string, fields: Partial<LogEntry> = {}): void {
+    this.emit({ level: "warn", event, status: "rejected", trace_id: fields.trace_id || "", ...fields });
+  }
+
+  error(event: string, fields: Partial<LogEntry> = {}): void {
+    this.emit({ level: "error", event, status: "failure", trace_id: fields.trace_id || "", ...fields });
+  }
+
+  debug(event: string, fields: Partial<LogEntry> = {}): void {
+    if (process.env.LOG_LEVEL === "debug") {
+      this.emit({ level: "debug", event, status: "success", trace_id: fields.trace_id || "", ...fields });
+    }
+  }
+}
+
+export function createLogger(service: string): Logger {
+  return new Logger(service);
+}
+
+export const logger = createLogger("AgentDomain");

package/bone/output/agent/src/metrics.ts

@@ -0,0 +1,75 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Implements spec/10 §4 (Telemetry Hooks)
+
+interface Counter {
+  type: "counter";
+  value: number;
+  labels: Record<string, string>;
+}
+
+interface Histogram {
+  type: "histogram";
+  values: number[];
+  labels: Record<string, string>;
+}
+
+interface Gauge {
+  type: "gauge";
+  value: number;
+  labels: Record<string, string>;
+}
+
+type Metric = Counter | Histogram | Gauge;
+
+const metrics: Map<string, Metric> = new Map();
+
+function key(name: string, labels: Record<string, string>): string {
+  const parts = Object.keys(labels).sort().map(k => `${k}="${labels[k]}"`);
+  return parts.length > 0 ? `${name}{${parts.join(",")}}` : name;
+}
+
+export function counter(name: string, labels: Record<string, string> = {}): void {
+  const k = key(name, labels);
+  const existing = metrics.get(k);
+  if (existing && existing.type === "counter") {
+    existing.value++;
+  } else {
+    metrics.set(k, { type: "counter", value: 1, labels });
+  }
+}
+
+export function histogram(name: string, value: number, labels: Record<string, string> = {}): void {
+  const k = key(name, labels);
+  const existing = metrics.get(k);
+  if (existing && existing.type === "histogram") {
+    existing.values.push(value);
+  } else {
+    metrics.set(k, { type: "histogram", values: [value], labels });
+  }
+}
+
+export function gauge(name: string, value: number, labels: Record<string, string> = {}): void {
+  const k = key(name, labels);
+  metrics.set(k, { type: "gauge", value, labels });
+}
+
+export function dump(): string {
+  const lines: string[] = [];
+  for (const [k, m] of metrics.entries()) {
+    if (m.type === "counter" || m.type === "gauge") {
+      lines.push(`${k} ${m.value}`);
+    } else {
+      const sum = m.values.reduce((a, b) => a + b, 0);
+      const count = m.values.length;
+      const avg = count > 0 ? sum / count : 0;
+      lines.push(`${k}_count ${count}`);
+      lines.push(`${k}_sum ${sum}`);
+      lines.push(`${k}_avg ${avg.toFixed(2)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export function reset(): void {
+  metrics.clear();
+}