@castlemilk/omega 0.6.19 → 0.6.20

package/dist/server/pglite-data/postmaster.pid

@@ -1,7 +0,0 @@
--42
-/pglite/data
-1783158585
-5432
-
-
-699617753         1

package/dist/server/src/app.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import request from 'supertest';
-import { app } from './app.js';
-import { prisma, applyMigrations, seedDefaults } from '@omega/db';
-
-describe('API', () => {
-  beforeAll(async () => {
-    await applyMigrations();
-    await seedDefaults();
-    await prisma.task.deleteMany();
-    await prisma.project.deleteMany();
-  });
-
-  afterAll(async () => {
-    await prisma.$disconnect();
-  });
-
-  it('creates a project', async () => {
-    const res = await request(app).post('/projects').send({ name: 'demo', path: '/tmp/demo' });
-    expect(res.status).toBe(201);
-    expect(res.body.name).toBe('demo');
-  });
-
-  it('lists projects', async () => {
-    const res = await request(app).get('/projects');
-    expect(res.status).toBe(200);
-    expect(res.body.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('creates a task and selects a provider', async () => {
-    const projects = await request(app).get('/projects');
-    const projectId = projects.body[0].id;
-    const taskRes = await request(app)
-      .post('/tasks')
-      .send({ projectId, title: 'summarize', complexity: 'simple', tags: [] });
-    expect(taskRes.status).toBe(201);
-
-    const selectRes = await request(app)
-      .post('/router/select')
-      .send({ title: 'summarize', complexity: 'simple', tags: [] });
-    expect(selectRes.status).toBe(200);
-    expect(selectRes.body.provider).toBeDefined();
-    expect(selectRes.body.model).toBeDefined();
-  });
-});

package/dist/server/src/app.ts

@@ -1,29 +0,0 @@
-import express from 'express';
-import cors from 'cors';
-import { prisma } from '@omega/db';
-import { projectRoutes } from './routes/projects.js';
-import { taskRoutes } from './routes/tasks.js';
-import { providerRoutes } from './routes/providers.js';
-import { routerRoutes } from './routes/router.js';
-import { metricsRoutes } from './routes/metrics.js';
-import { promptVersionRoutes } from './routes/prompt-versions.js';
-import { benchmarkRoutes } from './routes/benchmarks.js';
-
-export const app: express.Express = express();
-
-app.use(cors());
-app.use(express.json());
-
-app.use('/projects', projectRoutes(prisma));
-app.use('/tasks', taskRoutes(prisma));
-app.use('/providers', providerRoutes(prisma));
-app.use('/router', routerRoutes(prisma));
-app.use('/metrics', metricsRoutes(prisma));
-app.use('/prompt-versions', promptVersionRoutes(prisma));
-app.use('/benchmarks', benchmarkRoutes(prisma));
-
-app.use((err: unknown, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
-  console.error(err);
-  const message = err instanceof Error ? err.message : 'Internal error';
-  res.status(500).json({ error: message });
-});

package/dist/server/src/grpc.ts

@@ -1,170 +0,0 @@
-import fs from 'node:fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import * as grpc from '@grpc/grpc-js';
-import * as protoLoader from '@grpc/proto-loader';
-import type { PrismaClient } from '@omega/db';
-import { runTask } from './lib/run-task.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-function resolveProtoPath(): string {
-  const candidates = [
-    process.env.OMEGA_PROTO_PATH,
-    path.resolve(__dirname, '../../../proto/tasks.proto'),
-    path.resolve(__dirname, '../../proto/tasks.proto'),
-    path.resolve(__dirname, '../proto/tasks.proto'),
-    path.resolve(process.cwd(), 'proto/tasks.proto'),
-  ].filter(Boolean) as string[];
-
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) return candidate;
-  }
-  return candidates[0] ?? path.resolve(__dirname, '../../../proto/tasks.proto');
-}
-
-const PROTO_PATH = resolveProtoPath();
-
-const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
-  keepCase: true,
-  longs: String,
-  enums: String,
-  defaults: true,
-  oneofs: true,
-});
-
-const proto = grpc.loadPackageDefinition(packageDefinition) as unknown as {
-  omega: {
-    TaskIngestion: grpc.ServiceClientConstructor;
-  };
-};
-
-interface SubmitTaskRequest {
-  project_id: string;
-  title: string;
-  description?: string;
-  complexity?: string;
-  tags?: string[];
-  auto_run?: boolean;
-}
-
-interface StreamTasksRequest {
-  project_id?: string;
-}
-
-function isValidComplexity(value: string): value is 'simple' | 'medium' | 'complex' {
-  return ['simple', 'medium', 'complex'].includes(value);
-}
-
-function parseRequest(req: unknown): SubmitTaskRequest {
-  const r = req as Record<string, unknown>;
-  return {
-    project_id: typeof r.project_id === 'string' ? r.project_id : '',
-    title: typeof r.title === 'string' ? r.title : '',
-    description: typeof r.description === 'string' ? r.description : undefined,
-    complexity: typeof r.complexity === 'string' ? r.complexity : undefined,
-    tags: Array.isArray(r.tags) ? r.tags.filter((t): t is string => typeof t === 'string') : undefined,
-    auto_run: typeof r.auto_run === 'boolean' ? r.auto_run : undefined,
-  };
-}
-
-export function startGrpcServer(prisma: PrismaClient, port = 50051): grpc.Server {
-  const server = new grpc.Server();
-
-  server.addService(proto.omega.TaskIngestion.service, {
-    submitTask: (call: grpc.ServerUnaryCall<unknown, unknown>, callback: grpc.sendUnaryData<unknown>) => {
-      void (async () => {
-        try {
-          const req = parseRequest(call.request);
-          if (!req.project_id || !req.title) {
-            callback(
-              { code: grpc.status.INVALID_ARGUMENT, message: 'project_id and title are required' },
-              null
-            );
-            return;
-          }
-
-          const complexity = isValidComplexity(req.complexity ?? '') ? req.complexity : 'simple';
-
-          const task = await prisma.task.create({
-            data: {
-              projectId: req.project_id,
-              title: req.title,
-              description: req.description ?? null,
-              complexity,
-              tags: JSON.stringify(req.tags ?? []),
-            },
-          });
-
-          if (req.auto_run) {
-            await runTask(prisma, task.id);
-          }
-
-          const updated = await prisma.task.findUnique({ where: { id: task.id } });
-          callback(null, {
-            id: updated?.id ?? task.id,
-            status: updated?.status ?? task.status,
-            error: updated?.error ?? '',
-          });
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          callback({ code: grpc.status.INTERNAL, message }, null);
-        }
-      })();
-    },
-
-    streamTasks: (call: grpc.ServerWritableStream<unknown, unknown>) => {
-      const req = call.request as StreamTasksRequest;
-      const projectId = req.project_id;
-      let cancelled = false;
-
-      const interval = setInterval(() => {
-        if (cancelled) return;
-        void (async () => {
-          try {
-            const tasks = await prisma.task.findMany({
-              where: projectId ? { projectId } : undefined,
-              orderBy: { updatedAt: 'desc' },
-              take: 20,
-            });
-            for (const task of tasks) {
-              call.write({
-                id: task.id,
-                title: task.title,
-                status: task.status,
-                provider: task.provider ?? '',
-                model: task.model ?? '',
-                result: task.result ?? '',
-                error: task.error ?? '',
-              });
-            }
-          } catch (err: unknown) {
-            const message = err instanceof Error ? err.message : String(err);
-            call.write({ id: '', title: '', status: 'error', error: message });
-          }
-        })();
-      }, 1000);
-
-      call.on('cancelled', () => {
-        cancelled = true;
-        clearInterval(interval);
-      });
-
-      call.on('error', () => {
-        cancelled = true;
-        clearInterval(interval);
-      });
-    },
-  });
-
-  server.bindAsync(`0.0.0.0:${port.toString()}`, grpc.ServerCredentials.createInsecure(), (err) => {
-    if (err) {
-      console.error('gRPC server failed to start:', err);
-      return;
-    }
-    console.log(`gRPC task ingestion on 0.0.0.0:${port.toString()}`);
-  });
-
-  return server;
-}

package/dist/server/src/index.ts

@@ -1,23 +0,0 @@
-import { app } from './app.js';
-import { prisma, applyMigrations, seedDefaults } from '@omega/db';
-import { startGrpcServer } from './grpc.js';
-
-const PORT = Number(process.env.PORT ?? 4000);
-const GRPC_PORT = Number(process.env.GRPC_PORT ?? 50051);
-
-async function bootstrap(): Promise<void> {
-  await applyMigrations();
-  await seedDefaults();
-
-  app.listen(PORT, () => {
-    console.log(`Omega harness server on http://localhost:${PORT.toString()}`);
-  });
-
-  startGrpcServer(prisma, GRPC_PORT);
-}
-
-bootstrap().catch((err: unknown) => {
-  console.error(err);
-  process.exit(1);
-});
-

package/dist/server/src/lib/async-handler.ts

@@ -1,9 +0,0 @@
-import type { Request, Response, NextFunction, RequestHandler } from 'express';
-
-export function asyncHandler(
-  fn: (req: Request, res: Response, next: NextFunction) => Promise<void>
-): RequestHandler {
-  return (req, res, next) => {
-    Promise.resolve(fn(req, res, next)).catch(next);
-  };
-}

package/dist/server/src/lib/run-task.ts

@@ -1,108 +0,0 @@
-import { createProvider } from '@omega/providers';
-import { selectProvider } from '@omega/router';
-import { runAgentTask } from '@omega/agent';
-import type { PrismaClient } from '@omega/db';
-import type { ProviderConfig as CoreProviderConfig, Task } from '@omega/core';
-
-function toCoreConfig(row: {
-  id: string;
-  name: string;
-  kind: string;
-  baseUrl: string | null;
-  apiKey: string | null;
-  defaultModel: string;
-  capabilities: string;
-  enabled: boolean;
-}): CoreProviderConfig {
-  return {
-    id: row.id,
-    name: row.name,
-    kind: row.kind as CoreProviderConfig['kind'],
-    baseUrl: row.baseUrl ?? undefined,
-    apiKey: row.apiKey ?? undefined,
-    defaultModel: row.defaultModel,
-    capabilities: JSON.parse(row.capabilities) as CoreProviderConfig['capabilities'],
-    enabled: row.enabled,
-  };
-}
-
-export async function runTask(prisma: PrismaClient, taskId: string) {
-  const task = await prisma.task.findUnique({ where: { id: taskId }, include: { project: true } });
-  if (!task) throw new Error('Task not found');
-
-  await prisma.task.update({
-    where: { id: taskId },
-    data: { status: 'in_progress', error: null, result: null },
-  });
-
-  const tags: string[] = task.tags ? (JSON.parse(task.tags) as string[]) : [];
-  if (tags.includes('agent') || tags.includes('self-improve')) {
-    const agentResult = await runAgentTask(prisma, taskId, {
-      projectPath: task.project.path,
-      projectName: task.project.name,
-      autoPublish: tags.includes('publish'),
-    });
-    return agentResult.task;
-  }
-
-  const configs = await prisma.providerConfig.findMany();
-  const coreConfigs = configs.map(toCoreConfig);
-
-  const taskForRouter: Task = {
-    id: task.id,
-    projectId: task.projectId,
-    title: task.title,
-    description: task.description ?? undefined,
-    status: task.status as Task['status'],
-    complexity: task.complexity as Task['complexity'],
-    tags: task.tags ? (JSON.parse(task.tags) as Task['tags']) : [],
-    assignedModel:
-      task.provider && task.model ? { provider: task.provider, model: task.model } : undefined,
-    result: task.result ?? undefined,
-    error: task.error ?? undefined,
-    createdAt: task.createdAt,
-    updatedAt: task.updatedAt,
-  };
-
-  const selection = selectProvider(coreConfigs, [], taskForRouter);
-  if (!selection) {
-    await prisma.task.update({
-      where: { id: taskId },
-      data: { status: 'failed', error: 'No provider available for this task' },
-    });
-    return { status: 'failed', error: 'No provider available' };
-  }
-
-  const config = selection.provider;
-  const providerName = config.name;
-  const modelName = selection.model;
-  const provider = createProvider(config);
-  const prompt = [task.title, task.description].filter(Boolean).join('\n\n');
-
-  try {
-    const result = await provider.send(prompt, { model: modelName });
-    const updated = await prisma.task.update({
-      where: { id: taskId },
-      data: {
-        status: 'done',
-        result,
-        provider: providerName,
-        model: modelName,
-        error: null,
-      },
-    });
-    return updated;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const updated = await prisma.task.update({
-      where: { id: taskId },
-      data: {
-        status: 'failed',
-        error: message,
-        provider: providerName,
-        model: modelName,
-      },
-    });
-    return updated;
-  }
-}

package/dist/server/src/routes/benchmarks.ts

@@ -1,150 +0,0 @@
-import { Router } from 'express';
-import type { PrismaClient } from '@omega/db';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { z } from 'zod';
-import { asyncHandler } from '../lib/async-handler.js';
-
-const root = process.cwd();
-const reportsDir = path.join(root, '.omega', 'reports');
-const statusFile = path.join(root, '.omega', 'bench-run-status.json');
-
-const runSchema = z.object({
-  suite: z.enum(['synthetic', 'deep-swe']).optional(),
-  nTasks: z.number().int().positive().optional(),
-  provider: z.string().optional(),
-  model: z.string().optional(),
-  timeout: z.number().int().positive().optional(),
-});
-
-interface RunStatus {
-  running: boolean;
-  pid?: number;
-  output?: string;
-}
-
-async function readStatus(): Promise<RunStatus> {
-  try {
-    const raw = await fs.readFile(statusFile, 'utf-8');
-    return JSON.parse(raw) as RunStatus;
-  } catch {
-    return { running: false };
-  }
-}
-
-async function writeStatus(status: RunStatus): Promise<void> {
-  await fs.mkdir(path.dirname(statusFile), { recursive: true });
-  await fs.writeFile(statusFile, JSON.stringify(status, null, 2), 'utf-8');
-}
-
-function isReportFile(name: string, prefix: string): boolean {
-  return name.startsWith(prefix) && name.endsWith('.json');
-}
-
-async function listReports(prefix: string): Promise<string[]> {
-  try {
-    const files = await fs.readdir(reportsDir);
-    return files
-      .filter((f) => isReportFile(f, prefix))
-      .sort()
-      .reverse();
-  } catch {
-    return [];
-  }
-}
-
-export function benchmarkRoutes(_prisma: PrismaClient): Router {
-  const r = Router();
-
-  r.get('/reports', asyncHandler(async (_req, res) => {
-    const [benchmark, ab] = await Promise.all([
-      listReports('benchmark-'),
-      listReports('ab-'),
-    ]);
-    res.json({ benchmark, ab });
-  }));
-
-  r.get('/reports/:file', asyncHandler(async (req, res) => {
-    const file = req.params.file;
-    if (!isReportFile(file, 'benchmark-') && !isReportFile(file, 'ab-')) {
-      res.status(400).json({ error: 'Invalid report file' });
-      return;
-    }
-    const filePath = path.join(reportsDir, file);
-    const resolved = path.resolve(filePath);
-    const resolvedReportsDir = path.resolve(reportsDir);
-    if (!resolved.startsWith(resolvedReportsDir + path.sep) && resolved !== resolvedReportsDir) {
-      res.status(400).json({ error: 'Invalid report path' });
-      return;
-    }
-    try {
-      const raw = await fs.readFile(filePath, 'utf-8');
-      const data = JSON.parse(raw) as unknown;
-      res.json(data);
-    } catch {
-      res.status(404).json({ error: 'Report not found' });
-    }
-  }));
-
-  r.post('/run', asyncHandler(async (req, res) => {
-    const body = runSchema.parse(req.body);
-    const status = await readStatus();
-    if (status.running) {
-      res.status(409).json({ error: 'Benchmark run already in progress', pid: status.pid });
-      return;
-    }
-
-    const args = ['apps/cli/dist/index.js', 'bench', 'run'];
-    if (body.suite) {
-      args.push('--suite', body.suite);
-    }
-    if (body.nTasks) {
-      args.push('--n-tasks', String(body.nTasks));
-    }
-    if (body.timeout) {
-      args.push('--timeout', String(body.timeout));
-    }
-    if (body.provider) {
-      args.push('--provider', body.provider);
-    }
-    if (body.model) {
-      args.push('--model', body.model);
-    }
-
-    const child = spawn('node', args, {
-      cwd: root,
-      detached: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    let output = '';
-    child.stdout.on('data', (chunk: Buffer) => {
-      output += chunk.toString();
-    });
-    child.stderr.on('data', (chunk: Buffer) => {
-      output += chunk.toString();
-    });
-
-    child.on('exit', () => {
-      void (async () => {
-        const current = await readStatus();
-        if (current.pid === child.pid) {
-          await writeStatus({ running: false, output });
-        }
-      })();
-    });
-
-    child.unref();
-
-    await writeStatus({ running: true, pid: child.pid, output: '' });
-    res.status(202).json({ pid: child.pid, status: 'started' });
-  }));
-
-  r.get('/run-status', asyncHandler(async (_req, res) => {
-    const status = await readStatus();
-    res.json(status);
-  }));
-
-  return r;
-}

package/dist/server/src/routes/metrics.ts

@@ -1,110 +0,0 @@
-import { Router } from 'express';
-import type { PrismaClient } from '@omega/db';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { asyncHandler } from '../lib/async-handler.js';
-
-const root = process.cwd();
-const reportsDir = path.join(root, '.omega', 'reports');
-
-async function latestReport(pattern: RegExp): Promise<{ file: string; data: unknown } | undefined> {
-  try {
-    const files = await fs.readdir(reportsDir);
-    const matches = files
-      .filter((f) => pattern.test(f))
-      .sort()
-      .reverse();
-    const latest = matches[0];
-    if (!latest) return undefined;
-    const raw = await fs.readFile(path.join(reportsDir, latest), 'utf-8');
-    const data = latest.endsWith('.json') ? (JSON.parse(raw) as unknown) : raw;
-    return { file: latest, data };
-  } catch {
-    return undefined;
-  }
-}
-
-function durationMs(start: Date, end: Date | null): number | undefined {
-  if (!end) return undefined;
-  return end.getTime() - start.getTime();
-}
-
-export function metricsRoutes(prisma: PrismaClient): Router {
-  const r = Router();
-
-  r.get('/', asyncHandler(async (_req, res) => {
-    const [
-      tasks,
-      agentRuns,
-    ] = await Promise.all([
-      prisma.task.findMany({
-        select: { status: true, provider: true, model: true },
-      }),
-      prisma.agentRun.findMany({
-        take: 10,
-        orderBy: { createdAt: 'desc' },
-        include: { task: { select: { title: true } } },
-      }),
-    ]);
-
-    const taskCounts = {
-      todo: 0,
-      in_progress: 0,
-      done: 0,
-      failed: 0,
-    };
-    const providerUsage: Record<string, number> = {};
-    const modelUsage: Record<string, number> = {};
-
-    for (const task of tasks) {
-      taskCounts[task.status as keyof typeof taskCounts]++;
-      if (task.provider && task.model) {
-        const key = `${task.provider}/${task.model}`;
-        providerUsage[key] = (providerUsage[key] ?? 0) + 1;
-      }
-      if (task.model) {
-        modelUsage[task.model] = (modelUsage[task.model] ?? 0) + 1;
-      }
-    }
-
-    const completedRuns = agentRuns.filter((r) => r.resultStatus !== 'running');
-    const avgDurationMs =
-      completedRuns.length > 0
-        ? Math.round(
-            completedRuns.reduce((sum, r) => sum + (durationMs(r.createdAt, r.updatedAt) ?? 0), 0) /
-              completedRuns.length
-          )
-        : 0;
-
-    const recentRuns = agentRuns.map((r) => ({
-      id: r.id,
-      taskId: r.taskId,
-      title: r.task.title,
-      branch: r.branch,
-      resultStatus: r.resultStatus,
-      baseCommit: r.baseCommit,
-      validationSummary: r.validationSummary,
-      publishedVersion: r.publishedVersion,
-      durationMs: durationMs(r.createdAt, r.updatedAt),
-      createdAt: r.createdAt,
-    }));
-
-    const e2eReport = await latestReport(/^e2e-raw-/);
-    const benchmarkReport = await latestReport(/^benchmark-/);
-
-    res.json({
-      taskCounts,
-      totalTasks: tasks.length,
-      providerUsage,
-      modelUsage,
-      avgDurationMs,
-      recentRuns,
-      latestReports: {
-        e2e: e2eReport,
-        benchmark: benchmarkReport,
-      },
-    });
-  }));
-
-  return r;
-}