@jlongo78/agent-spaces 0.7.7 → 0.8.0

package/.next/standalone/src/app/api/benchmark/run/route.ts

@@ -0,0 +1,92 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import { getBenchmarkProcess, setBenchmarkProcess } from '@/lib/cortex/benchmark';
+
+export async function POST(request: NextRequest) {
+  const user = getAuthUser(request);
+  const body = await request.json();
+
+  return withUser(user, async () => {
+    // Check if already running
+    const existing = getBenchmarkProcess();
+    if (existing && !existing.process.killed && existing.process.exitCode === null) {
+      return NextResponse.json({ error: 'A benchmark is already running' }, { status: 409 });
+    }
+
+    const {
+      preset = 'quick',
+      categories,
+      noJudge = false,
+      model = 'claude-haiku-4-5',
+    } = body;
+
+    // Build args for the benchmark CLI
+    const args = ['tests/benchmark/index.ts'];
+    args.push('--preset', preset);
+    if (categories) args.push('--category', categories);
+    if (noJudge) args.push('--no-judge');
+    args.push('--models', model);
+
+    // Find the cortex repo
+    const cortexDir = findCortexDir();
+    if (!cortexDir) {
+      return NextResponse.json({ error: 'Could not find @spaces/cortex directory' }, { status: 500 });
+    }
+
+    // Spawn the benchmark process
+    const child = spawn('npx', ['tsx', ...args], {
+      cwd: cortexDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: true,
+      detached: false,
+    });
+
+    let output = '';
+    let errorOutput = '';
+    child.stdout?.on('data', (data: Buffer) => { output += data.toString(); });
+    child.stderr?.on('data', (data: Buffer) => { errorOutput += data.toString(); });
+
+    setBenchmarkProcess({
+      process: child,
+      pid: child.pid ?? 0,
+      startedAt: new Date().toISOString(),
+      preset,
+      categories: categories || 'all',
+      model,
+      noJudge,
+      getOutput: () => output,
+      getErrors: () => errorOutput,
+    });
+
+    child.on('close', () => {
+      // Process finished — exitCode will be set on the child object
+    });
+
+    return NextResponse.json({
+      started: true,
+      pid: child.pid,
+      preset,
+      categories: categories || 'all',
+      model,
+    });
+  });
+}
+
+function findCortexDir(): string | null {
+  const candidates = [
+    path.resolve(process.cwd(), '../spaces-cortex'),
+    path.resolve(process.cwd(), '../../spaces-cortex'),
+    'C:\\projects\\spaces-cortex',
+    '/c/projects/spaces-cortex',
+  ];
+  for (const dir of candidates) {
+    if (fs.existsSync(path.join(dir, 'tests', 'benchmark', 'index.ts'))) {
+      return dir;
+    }
+  }
+  return null;
+}

package/.next/standalone/src/app/api/benchmark/runs/[id]/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getBenchmarkAccess } from '@/lib/cortex/benchmark';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const user = getAuthUser(request);
+  const { id } = await params;
+  return withUser(user, async () => {
+    const access = getBenchmarkAccess();
+    if (!access) {
+      return NextResponse.json({ error: 'Benchmark data not available' }, { status: 404 });
+    }
+    const run = access.getRun(id);
+    if (!run) {
+      return NextResponse.json({ error: 'Run not found' }, { status: 404 });
+    }
+    const summary = access.getRunSummary(id);
+    const categories = access.getCategoryBreakdown(id);
+    const results = access.getTaskResults(id);
+    return NextResponse.json({ run, summary, categories, results });
+  });
+}

package/.next/standalone/src/app/api/benchmark/runs/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getBenchmarkAccess } from '@/lib/cortex/benchmark';
+
+export async function GET(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    const access = getBenchmarkAccess();
+    if (!access) {
+      return NextResponse.json({ error: 'Benchmark data not available' }, { status: 404 });
+    }
+    const runs = access.listRuns();
+    return NextResponse.json({ runs });
+  });
+}

package/.next/standalone/src/app/api/benchmark/status/route.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getBenchmarkProcess } from '@/lib/cortex/benchmark';
+
+export async function GET(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    const bp = getBenchmarkProcess();
+    if (!bp) {
+      return NextResponse.json({ running: false });
+    }
+
+    const running = !bp.process.killed && bp.process.exitCode === null;
+    const output = bp.getOutput();
+
+    // Parse progress from output (look for [N/M] pattern)
+    const progressMatches = [...output.matchAll(/\[(\d+)\/(\d+)\]/g)];
+    const lastMatch = progressMatches[progressMatches.length - 1];
+    const current = lastMatch ? parseInt(lastMatch[1]) : 0;
+    const total = lastMatch ? parseInt(lastMatch[2]) : 0;
+
+    return NextResponse.json({
+      running,
+      pid: bp.pid,
+      startedAt: bp.startedAt,
+      preset: bp.preset,
+      categories: bp.categories,
+      model: bp.model,
+      progress: { current, total },
+      output: output.slice(-2000), // Last 2000 chars
+      exitCode: bp.process.exitCode,
+    });
+  });
+}

package/.next/standalone/src/app/api/bulk/route.ts

@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { ensureInitialized } from '@/lib/db/init';
+import { bulkAddTag, bulkAddToWorkspace, bulkStar } from '@/lib/db/queries';
+
+export async function POST(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+    const body = await request.json();
+    const { sessionIds, action } = body;
+
+    if (!Array.isArray(sessionIds) || sessionIds.length === 0) {
+      return NextResponse.json({ error: 'No sessions selected' }, { status: 400 });
+    }
+
+    switch (action) {
+      case 'tag':
+        bulkAddTag(sessionIds, body.tagName);
+        return NextResponse.json({ success: true, count: sessionIds.length });
+      case 'workspace':
+        bulkAddToWorkspace(sessionIds, body.workspaceId);
+        return NextResponse.json({ success: true, count: sessionIds.length });
+      case 'star':
+        bulkStar(sessionIds, true);
+        return NextResponse.json({ success: true, count: sessionIds.length });
+      case 'unstar':
+        bulkStar(sessionIds, false);
+        return NextResponse.json({ success: true, count: sessionIds.length });
+      default:
+        return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
+    }
+  });
+}

package/.next/standalone/src/app/api/chat/route.ts

@@ -0,0 +1,85 @@
+import { NextRequest } from 'next/server';
+import { spawn } from 'child_process';
+import { getAuthUser } from '@/lib/auth';
+
+export const dynamic = 'force-dynamic';
+
+// Start a new agent session (not resuming an existing one)
+export async function POST(request: NextRequest) {
+  const user = getAuthUser(request);
+  const body = await request.json();
+  const { message, cwd } = body;
+
+  if (!message || typeof message !== 'string') {
+    return new Response(JSON.stringify({ error: 'Message is required' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const workDir = cwd || require('os').homedir();
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    start(controller) {
+      const args = [
+        '-p', message,
+        '--output-format', 'stream-json',
+        '--verbose',
+      ];
+
+      const env = { ...process.env };
+      delete env.CLAUDECODE;
+
+      const child = spawn('claude', args, {
+        cwd: workDir,
+        env,
+      });
+
+      let buffer = '';
+
+      child.stdout.on('data', (chunk: Buffer) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+          } catch {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'text', text: line })}\n\n`));
+          }
+        }
+      });
+
+      child.stderr.on('data', (chunk: Buffer) => {
+        const text = chunk.toString();
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', text })}\n\n`));
+      });
+
+      child.on('close', (code) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: code })}\n\n`));
+        controller.close();
+      });
+
+      child.on('error', (err) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', text: err.message })}\n\n`));
+        controller.close();
+      });
+
+      request.signal.addEventListener('abort', () => {
+        child.kill('SIGTERM');
+      });
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    },
+  });
+}

package/.next/standalone/src/app/api/config/route.ts

@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { readConfig, writeConfig } from '@/lib/config';
+
+export async function GET(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, () => {
+    const config = readConfig(user);
+    return NextResponse.json(config);
+  });
+}
+
+export async function PUT(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    const body = await request.json();
+    const updates: Record<string, unknown> = {};
+    if (typeof body.telemetryOptOut === 'boolean') {
+      updates.telemetryOptOut = body.telemetryOptOut;
+    }
+    if (Array.isArray(body.devDirectories)) {
+      const { isAbsolute, resolve } = require('path');
+      updates.devDirectories = body.devDirectories
+        .filter((d: unknown) => typeof d === 'string' && isAbsolute(d))
+        .map((d: string) => resolve(d));
+    }
+    const config = writeConfig(user, updates);
+    return NextResponse.json(config);
+  });
+}

package/.next/standalone/src/app/api/cortex/context/route.ts

@@ -1,78 +1,78 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { getCortex, isCortexAvailable } from '@/lib/cortex';
-import { ContextEngine } from '@/lib/cortex/retrieval/context-engine';
-import { EntityResolver } from '@/lib/cortex/graph/resolver';
-import { slugify } from '@/lib/cortex/graph/types';
-import { getDb } from '@/lib/db/schema';
-import { parseLobeConfig } from '@/lib/cortex/lobes/config';
-import { resolveLobes } from '@/lib/cortex/lobes/resolver';
-
-export async function GET(request: NextRequest) {
-  const user = getAuthUser(request);
-  return withUser(user, async () => {
-    if (!isCortexAvailable()) {
-      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
-    }
-    const cortex = await getCortex();
-    if (!cortex) return NextResponse.json({ results: [], context: '' });
-
-    const url = new URL(request.url);
-    const query = url.searchParams.get('q') || '';
-    const limit = parseInt(url.searchParams.get('limit') || '5', 10);
-    const workspaceId = url.searchParams.get('workspace_id');
-    const maxTokens = parseInt(url.searchParams.get('max_tokens') || '1500', 10);
-
-    if (!query || query.length < 3) {
-      return NextResponse.json({ results: [], context: '' });
-    }
-
-    const resolver = new EntityResolver(cortex.graph);
-    const requesterId = `person-${slugify(user)}`;
-
-    // Resolve which lobes this workspace has access to
-    let resolvedLobes;
-    if (workspaceId) {
-      const db = getDb();
-      const allWs = (db.prepare('SELECT id, name, lobe_config FROM workspaces').all() as any[]).map(ws => ({
-        id: ws.id,
-        name: ws.name,
-        lobeConfig: parseLobeConfig(ws.lobe_config),
-      }));
-      resolvedLobes = resolveLobes({
-        workspaceId: parseInt(workspaceId, 10),
-        allWorkspaces: allWs,
-        userId: requesterId,
-      });
-    }
-
-    const engine = new ContextEngine({
-      store: cortex.store,
-      graph: cortex.graph,
-      resolver,
-      embedding: cortex.embedding,
-      requesterId,
-      resolvedLobes,
-    });
-
-    const result = await engine.assemble(query, {
-      limit,
-      workspaceId: workspaceId ? parseInt(workspaceId, 10) : null,
-      maxTokens,
-    });
-
-    const lobeNames = resolvedLobes?.map(l => l.label).join(', ') || 'all';
-    console.log(`[Cortex Context] q="${query.slice(0, 60)}" → ${result.results?.length ?? 0} results from [${lobeNames}] (${result.timing?.totalMs ?? '?'}ms)`);
-
-    return NextResponse.json({
-      results: (result.results ?? []).map((r: any) => ({ ...r, vector: undefined })),
-      context: result.context ?? '',
-      intent: result.intent ?? null,
-      conflicts: result.conflicts ?? [],
-      entities: result.entities ?? [],
-      sourceWeights: result.sourceWeights ?? [],
-      timing: result.timing,
-    });
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getCortex, isCortexAvailable } from '@/lib/cortex';
+import { ContextEngine } from '@/lib/cortex/retrieval/context-engine';
+import { EntityResolver } from '@/lib/cortex/graph/resolver';
+import { slugify } from '@/lib/cortex/graph/types';
+import { getDb } from '@/lib/db/schema';
+import { parseLobeConfig } from '@/lib/cortex/lobes/config';
+import { resolveLobes } from '@/lib/cortex/lobes/resolver';
+
+export async function GET(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    if (!isCortexAvailable()) {
+      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
+    }
+    const cortex = await getCortex();
+    if (!cortex) return NextResponse.json({ results: [], context: '' });
+
+    const url = new URL(request.url);
+    const query = url.searchParams.get('q') || '';
+    const limit = parseInt(url.searchParams.get('limit') || '5', 10);
+    const workspaceId = url.searchParams.get('workspace_id');
+    const maxTokens = parseInt(url.searchParams.get('max_tokens') || '1500', 10);
+
+    if (!query || query.length < 3) {
+      return NextResponse.json({ results: [], context: '' });
+    }
+
+    const resolver = new EntityResolver(cortex.graph);
+    const requesterId = `person-${slugify(user)}`;
+
+    // Resolve which lobes this workspace has access to
+    let resolvedLobes;
+    if (workspaceId) {
+      const db = getDb();
+      const allWs = (db.prepare('SELECT id, name, lobe_config FROM workspaces').all() as any[]).map(ws => ({
+        id: ws.id,
+        name: ws.name,
+        lobeConfig: parseLobeConfig(ws.lobe_config),
+      }));
+      resolvedLobes = resolveLobes({
+        workspaceId: parseInt(workspaceId, 10),
+        allWorkspaces: allWs,
+        userId: requesterId,
+      });
+    }
+
+    const engine = new ContextEngine({
+      store: cortex.store,
+      graph: cortex.graph,
+      resolver,
+      embedding: cortex.embedding,
+      requesterId,
+      resolvedLobes,
+    });
+
+    const result = await engine.assemble(query, {
+      limit,
+      workspaceId: workspaceId ? parseInt(workspaceId, 10) : null,
+      maxTokens,
+    });
+
+    const lobeNames = resolvedLobes?.map(l => l.label).join(', ') || 'all';
+    console.log(`[Cortex Context] q="${query.slice(0, 60)}" → ${result.results?.length ?? 0} results from [${lobeNames}] (${result.timing?.totalMs ?? '?'}ms)`);
+
+    return NextResponse.json({
+      results: (result.results ?? []).map((r: any) => ({ ...r, vector: undefined })),
+      context: result.context ?? '',
+      intent: result.intent ?? null,
+      conflicts: result.conflicts ?? [],
+      entities: result.entities ?? [],
+      sourceWeights: result.sourceWeights ?? [],
+      timing: result.timing,
+    });
+  });
+}

package/.next/standalone/src/app/api/cortex/curation/assess/route.ts

@@ -1,27 +1,27 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { isCortexAvailable, getCortex } from '@/lib/cortex';
-import { handleToolCall } from '@/lib/cortex/mcp/server';
-
-export async function GET(request: NextRequest) {
-  const user = getAuthUser(request);
-  return withUser(user, async () => {
-    if (!isCortexAvailable()) {
-      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
-    }
-    const cortex = await getCortex();
-    if (!cortex) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-
-    const url = new URL(request.url);
-    const workspace_id = parseInt(url.searchParams.get('workspace_id') || '0', 10);
-    if (!workspace_id) {
-      return NextResponse.json({ error: 'workspace_id is required' }, { status: 400 });
-    }
-    const result = await handleToolCall('cortex_assess', { workspace_id }, cortex);
-    if (result.isError) {
-      return NextResponse.json({ error: JSON.parse(result.content[0].text) }, { status: 400 });
-    }
-    return NextResponse.json(JSON.parse(result.content[0].text));
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { isCortexAvailable, getCortex } from '@/lib/cortex';
+import { handleToolCall } from '@/lib/cortex/mcp/server';
+
+export async function GET(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    if (!isCortexAvailable()) {
+      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
+    }
+    const cortex = await getCortex();
+    if (!cortex) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+
+    const url = new URL(request.url);
+    const workspace_id = parseInt(url.searchParams.get('workspace_id') || '0', 10);
+    if (!workspace_id) {
+      return NextResponse.json({ error: 'workspace_id is required' }, { status: 400 });
+    }
+    const result = await handleToolCall('cortex_assess', { workspace_id }, cortex);
+    if (result.isError) {
+      return NextResponse.json({ error: JSON.parse(result.content[0].text) }, { status: 400 });
+    }
+    return NextResponse.json(JSON.parse(result.content[0].text));
+  });
+}

package/.next/standalone/src/app/api/cortex/curation/publish/route.ts

@@ -1,23 +1,23 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { isCortexAvailable, getCortex } from '@/lib/cortex';
-import { handleToolCall } from '@/lib/cortex/mcp/server';
-
-export async function POST(request: NextRequest) {
-  const user = getAuthUser(request);
-  return withUser(user, async () => {
-    if (!isCortexAvailable()) {
-      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
-    }
-    const cortex = await getCortex();
-    if (!cortex) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-
-    const body = await request.json();
-    const result = await handleToolCall('cortex_publish', body, cortex);
-    if (result.isError) {
-      return NextResponse.json({ error: JSON.parse(result.content[0].text) }, { status: 400 });
-    }
-    return NextResponse.json(JSON.parse(result.content[0].text));
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { isCortexAvailable, getCortex } from '@/lib/cortex';
+import { handleToolCall } from '@/lib/cortex/mcp/server';
+
+export async function POST(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    if (!isCortexAvailable()) {
+      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
+    }
+    const cortex = await getCortex();
+    if (!cortex) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+
+    const body = await request.json();
+    const result = await handleToolCall('cortex_publish', body, cortex);
+    if (result.isError) {
+      return NextResponse.json({ error: JSON.parse(result.content[0].text) }, { status: 400 });
+    }
+    return NextResponse.json(JSON.parse(result.content[0].text));
+  });
+}

package/.next/standalone/src/app/api/cortex/curation/refine/route.ts

@@ -1,23 +1,23 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { isCortexAvailable, getCortex } from '@/lib/cortex';
-import { handleToolCall } from '@/lib/cortex/mcp/server';
-
-export async function POST(request: NextRequest) {
-  const user = getAuthUser(request);
-  return withUser(user, async () => {
-    if (!isCortexAvailable()) {
-      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
-    }
-    const cortex = await getCortex();
-    if (!cortex) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-
-    const body = await request.json();
-    const result = await handleToolCall('cortex_refine', body, cortex);
-    if (result.isError) {
-      return NextResponse.json({ error: JSON.parse(result.content[0].text) }, { status: 400 });
-    }
-    return NextResponse.json(JSON.parse(result.content[0].text));
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { isCortexAvailable, getCortex } from '@/lib/cortex';
+import { handleToolCall } from '@/lib/cortex/mcp/server';
+
+export async function POST(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    if (!isCortexAvailable()) {
+      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
+    }
+    const cortex = await getCortex();
+    if (!cortex) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+
+    const body = await request.json();
+    const result = await handleToolCall('cortex_refine', body, cortex);
+    if (result.isError) {
+      return NextResponse.json({ error: JSON.parse(result.content[0].text) }, { status: 400 });
+    }
+    return NextResponse.json(JSON.parse(result.content[0].text));
+  });
+}