@castlemilk/omega 0.6.11 → 0.6.13

package/dist/server/node_modules/protobufjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobufjs",
-  "version": "7.6.4",
+  "version": "7.6.5",
   "versionScheme": "~",
   "description": "Protocol Buffers for JavaScript (& TypeScript).",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",

package/dist/server/node_modules/protobufjs/src/parse.js

@@ -678,6 +678,9 @@ function parse(source, root, options) {
             }
 
             while (token !== "=") {
+                if (token === null) {
+                    throw illegal(token, "end of input");
+                }
                 if (token === "(") {
                     var parensValue = next();
                     skip(")");

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

@@ -1,7 +1,7 @@
 -42
 /pglite/data
-1783054560
+1783128417
 5432
 
 
-695229449         1
+699617753         1

package/dist/server/src/app.ts

@@ -6,6 +6,7 @@ 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';
 
 export const app: express.Express = express();
 
@@ -17,6 +18,7 @@ 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((err: unknown, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
   console.error(err);

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

@@ -41,6 +41,7 @@ export async function runTask(prisma: PrismaClient, taskId: string) {
       projectPath: task.project.path,
       projectName: task.project.name,
       autoPublish: tags.includes('publish'),
+      maxSteps: tags.includes('self-improve') ? 60 : 30,
     });
     return agentResult.task;
   }
@@ -80,12 +81,12 @@ export async function runTask(prisma: PrismaClient, taskId: string) {
   const prompt = [task.title, task.description].filter(Boolean).join('\n\n');
 
   try {
-    const result = await provider.send(prompt, { model: modelName });
+    const response = await provider.send(prompt, { model: modelName });
     const updated = await prisma.task.update({
       where: { id: taskId },
       data: {
         status: 'done',
-        result,
+        result: response.content,
         provider: providerName,
         model: modelName,
         error: null,

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

@@ -9,6 +9,27 @@ const __filename = fileURLToPath(import.meta.url);
 const root = path.resolve(__filename, '..', '..', '..', '..');
 const reportsDir = path.join(root, '.omega', 'reports');
 
+async function listReports(pattern: RegExp): Promise<{ file: string; modifiedAt: string }[]> {
+  try {
+    const files = await fs.readdir(reportsDir);
+    const matches = files.filter((f) => pattern.test(f)).sort().reverse();
+    const results: { file: string; modifiedAt: string }[] = [];
+    for (const file of matches) {
+      const stat = await fs.stat(path.join(reportsDir, file));
+      results.push({ file, modifiedAt: stat.mtime.toISOString() });
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+async function readReport(file: string): Promise<unknown> {
+  const raw = await fs.readFile(path.join(reportsDir, file), 'utf-8');
+  if (file.endsWith('.json')) return JSON.parse(raw) as unknown;
+  return raw;
+}
+
 async function latestReport(pattern: RegExp): Promise<{ file: string; data: unknown } | undefined> {
   try {
     const files = await fs.readdir(reportsDir);
@@ -18,8 +39,7 @@ async function latestReport(pattern: RegExp): Promise<{ file: string; data: unkn
       .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;
+    const data = await readReport(latest);
     return { file: latest, data };
   } catch {
     return undefined;
@@ -78,6 +98,8 @@ export function metricsRoutes(prisma: PrismaClient): Router {
           )
         : 0;
 
+    const totalTokens = agentRuns.reduce((sum, r) => sum + (r.totalTokens ?? 0), 0);
+
     const recentRuns = agentRuns.map((r) => ({
       id: r.id,
       taskId: r.taskId,
@@ -88,11 +110,15 @@ export function metricsRoutes(prisma: PrismaClient): Router {
       validationSummary: r.validationSummary,
       publishedVersion: r.publishedVersion,
       durationMs: durationMs(r.createdAt, r.updatedAt),
+      promptTokens: r.promptTokens,
+      completionTokens: r.completionTokens,
+      totalTokens: r.totalTokens,
       createdAt: r.createdAt,
     }));
 
     const e2eReport = await latestReport(/^e2e-raw-/);
     const benchmarkReport = await latestReport(/^benchmark-/);
+    const abReport = await latestReport(/^ab-/);
 
     res.json({
       taskCounts,
@@ -100,13 +126,66 @@ export function metricsRoutes(prisma: PrismaClient): Router {
       providerUsage,
       modelUsage,
       avgDurationMs,
+      totalTokens,
       recentRuns,
       latestReports: {
         e2e: e2eReport,
         benchmark: benchmarkReport,
+        ab: abReport,
       },
     });
   }));
 
+  r.get('/reports', asyncHandler(async (_req, res) => {
+    const e2e = await listReports(/^e2e-raw-/);
+    const benchmark = await listReports(/^benchmark-/);
+    res.json({ e2e, benchmark });
+  }));
+
+  r.get('/reports/benchmark', asyncHandler(async (_req, res) => {
+    const reports = await listReports(/^benchmark-/);
+    res.json(reports);
+  }));
+
+  r.get('/reports/benchmark/:file', asyncHandler(async (req, res) => {
+    const file = path.basename(req.params.file);
+    if (!file.startsWith('benchmark-')) {
+      res.status(400).json({ error: 'Invalid benchmark report filename' });
+      return;
+    }
+    try {
+      const data = await readReport(file);
+      res.json(data);
+    } catch {
+      res.status(404).json({ error: 'Report not found' });
+    }
+  }));
+
+  r.get('/reports/ab', asyncHandler(async (_req, res) => {
+    const reports = await listReports(/^ab-/);
+    res.json(reports);
+  }));
+
+  r.get('/reports/ab/:file', asyncHandler(async (req, res) => {
+    const file = path.basename(req.params.file);
+    if (!file.startsWith('ab-')) {
+      res.status(400).json({ error: 'Invalid A/B report filename' });
+      return;
+    }
+    try {
+      const data = await readReport(file);
+      res.json(data);
+    } catch {
+      res.status(404).json({ error: 'Report not found' });
+    }
+  }));
+
+  r.get('/reports/latest', asyncHandler(async (_req, res) => {
+    const e2eReport = await latestReport(/^e2e-raw-/);
+    const benchmarkReport = await latestReport(/^benchmark-/);
+    const abReport = await latestReport(/^ab-/);
+    res.json({ e2e: e2eReport, benchmark: benchmarkReport, ab: abReport });
+  }));
+
   return r;
 }

package/dist/server/src/routes/prompt-versions.ts

@@ -0,0 +1,46 @@
+import { Router } from 'express';
+import type { PrismaClient } from '@omega/db';
+import { z } from 'zod';
+import { asyncHandler } from '../lib/async-handler.js';
+import { createPromptVersionRepository } from '@omega/db';
+
+const createSchema = z.object({
+  name: z.string().min(1),
+  sourcePath: z.string().min(1),
+  systemPrompt: z.string(),
+  textToolsPrompt: z.string(),
+  hash: z.string().min(1),
+  metadata: z.record(z.unknown()).optional(),
+});
+
+export function promptVersionRoutes(prisma: PrismaClient): Router {
+  const repo = createPromptVersionRepository(prisma);
+  const r = Router();
+
+  r.get('/', asyncHandler(async (_req, res) => {
+    const versions = await repo.list();
+    res.json(versions);
+  }));
+
+  r.get('/:id', asyncHandler(async (req, res) => {
+    const version = await repo.findById(req.params.id);
+    if (!version) {
+      res.status(404).json({ error: 'Prompt version not found' });
+      return;
+    }
+    res.json(version);
+  }));
+
+  r.post('/', asyncHandler(async (req, res) => {
+    const body = createSchema.parse(req.body);
+    const existing = await repo.findByHash(body.hash);
+    if (existing) {
+      res.status(200).json(existing);
+      return;
+    }
+    const version = await repo.create(body);
+    res.status(201).json(version);
+  }));
+
+  return r;
+}

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

@@ -10,6 +10,8 @@ const createSchema = z.object({
   description: z.string().optional(),
   complexity: z.enum(['simple', 'medium', 'complex']).default('simple'),
   tags: z.array(z.string()).default([]),
+  provider: z.string().optional(),
+  model: z.string().optional(),
 });
 
 const updateSchema = z.object({
@@ -50,6 +52,8 @@ export function taskRoutes(prisma: PrismaClient): Router {
         description: body.description,
         complexity: body.complexity,
         tags: JSON.stringify(body.tags),
+        provider: body.provider,
+        model: body.model,
       },
     });
     res.status(201).json(task);
@@ -135,8 +139,8 @@ export function taskRoutes(prisma: PrismaClient): Router {
       const children = byParent[key] ?? [];
       return children.map((s) => ({
         ...s,
-        attributes: s.attributes ? JSON.parse(s.attributes) : undefined,
-        events: s.events ? JSON.parse(s.events) : undefined,
+        attributes: s.attributes ? (JSON.parse(s.attributes) as Record<string, unknown>) : undefined,
+        events: s.events ? (JSON.parse(s.events) as unknown[]) : undefined,
         children: buildTree(s.spanId),
       }));
     }