@jlongo78/agent-spaces 0.7.5 → 0.7.7

package/.next/standalone/src/app/api/cortex/federation/search/route.ts

@@ -1,35 +1,35 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { getCortex } from '@/lib/cortex';
-import { IS_FEDERATION } from '@/lib/tier';
-
-export async function GET(request: NextRequest) {
-  const user = getAuthUser(request);
-  return withUser(user, async () => {
-    // Federation tier gate
-    if (!IS_FEDERATION) {
-      return NextResponse.json({ error: 'Federation not available' }, { status: 403 });
-    }
-
-    const cortex = await getCortex();
-    if (!cortex) return NextResponse.json({ results: [] });
-
-    const url = new URL(request.url);
-    const query = url.searchParams.get('q') || '';
-    const limit = parseInt(url.searchParams.get('limit') || '5', 10);
-
-    if (!query) return NextResponse.json({ results: [] });
-
-    const [queryVector] = await cortex.embedding.embed([query]);
-
-    // Only search team and collaborative workspace layers — never personal
-    const results = await cortex.search.search(queryVector, {
-      workspaceId: null,
-      limit,
-      excludeLayers: ['personal'],
-    });
-
-    return NextResponse.json({ results });
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getCortex } from '@/lib/cortex';
+import { IS_FEDERATION } from '@/lib/tier';
+
+export async function GET(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    // Federation tier gate
+    if (!IS_FEDERATION) {
+      return NextResponse.json({ error: 'Federation not available' }, { status: 403 });
+    }
+
+    const cortex = await getCortex();
+    if (!cortex) return NextResponse.json({ results: [] });
+
+    const url = new URL(request.url);
+    const query = url.searchParams.get('q') || '';
+    const limit = parseInt(url.searchParams.get('limit') || '5', 10);
+
+    if (!query) return NextResponse.json({ results: [] });
+
+    const [queryVector] = await cortex.embedding.embed([query]);
+
+    // Only search team and collaborative workspace layers — never personal
+    const results = await cortex.search.search(queryVector, {
+      workspaceId: null,
+      limit,
+      excludeLayers: ['personal'],
+    });
+
+    return NextResponse.json({ results });
+  });
+}

package/.next/standalone/src/app/api/cortex/federation/teach/route.ts

@@ -1,76 +1,76 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import crypto from 'crypto';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { getCortex } from '@/lib/cortex';
-import { cosineSimilarity, detectContradictions } from '@/lib/cortex/knowledge/contradiction';
-
-const CONFIDENCE_DECAY_PER_HOP = 0.8;
-const MAX_HOPS = 3;
-const DEDUP_THRESHOLD = 0.95;
-
-export async function POST(request: NextRequest) {
-  const user = getAuthUser(request);
-  return withUser(user, async () => {
-    const cortex = await getCortex();
-    if (!cortex) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-
-    const body = await request.json();
-    const { knowledge, provenance } = body;
-
-    if (!knowledge?.text || !provenance) {
-      return NextResponse.json({ error: 'knowledge and provenance required' }, { status: 400 });
-    }
-
-    if (provenance.hops && provenance.hops.length >= MAX_HOPS) {
-      return NextResponse.json({ status: 'rejected', reason: 'max_hops_exceeded' });
-    }
-
-    const [vector] = await cortex.embedding.embed([knowledge.text]);
-
-    const existing = await cortex.store.search('team', vector, 5);
-    const isDuplicate = existing.some(
-      (e: any) => cosineSimilarity(vector, e.vector) > DEDUP_THRESHOLD
-    );
-    if (isDuplicate) {
-      return NextResponse.json({ status: 'skipped', reason: 'duplicate' });
-    }
-
-    const hopCount = (provenance.hops?.length || 0) + 1;
-    const adjustedConfidence = knowledge.confidence * Math.pow(CONFIDENCE_DECAY_PER_HOP, hopCount);
-
-    const contradictions = detectContradictions(
-      { ...knowledge, vector, id: 'incoming' },
-      existing,
-      0.85,
-    );
-
-    if (contradictions.length > 0) {
-      await cortex.store.add('team', {
-        ...knowledge,
-        id: crypto.randomUUID(),
-        vector,
-        layer: 'team',
-        confidence: adjustedConfidence,
-        metadata: {
-          ...knowledge.metadata,
-          provenance,
-          status: 'pending_review',
-          contradicts: contradictions.map(c => c.existingId),
-        },
-      });
-      return NextResponse.json({ status: 'pending_review', contradictions: contradictions.length });
-    }
-
-    await cortex.store.add('team', {
-      ...knowledge,
-      id: crypto.randomUUID(),
-      vector,
-      layer: 'team',
-      confidence: adjustedConfidence,
-      metadata: { ...knowledge.metadata, provenance, source: 'federation_teach' },
-    });
-
-    return NextResponse.json({ status: 'accepted' });
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import crypto from 'crypto';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getCortex } from '@/lib/cortex';
+import { cosineSimilarity, detectContradictions } from '@/lib/cortex/knowledge/contradiction';
+
+const CONFIDENCE_DECAY_PER_HOP = 0.8;
+const MAX_HOPS = 3;
+const DEDUP_THRESHOLD = 0.95;
+
+export async function POST(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    const cortex = await getCortex();
+    if (!cortex) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+
+    const body = await request.json();
+    const { knowledge, provenance } = body;
+
+    if (!knowledge?.text || !provenance) {
+      return NextResponse.json({ error: 'knowledge and provenance required' }, { status: 400 });
+    }
+
+    if (provenance.hops && provenance.hops.length >= MAX_HOPS) {
+      return NextResponse.json({ status: 'rejected', reason: 'max_hops_exceeded' });
+    }
+
+    const [vector] = await cortex.embedding.embed([knowledge.text]);
+
+    const existing = await cortex.store.search('team', vector, 5);
+    const isDuplicate = existing.some(
+      (e: any) => cosineSimilarity(vector, e.vector) > DEDUP_THRESHOLD
+    );
+    if (isDuplicate) {
+      return NextResponse.json({ status: 'skipped', reason: 'duplicate' });
+    }
+
+    const hopCount = (provenance.hops?.length || 0) + 1;
+    const adjustedConfidence = knowledge.confidence * Math.pow(CONFIDENCE_DECAY_PER_HOP, hopCount);
+
+    const contradictions = detectContradictions(
+      { ...knowledge, vector, id: 'incoming' },
+      existing,
+      0.85,
+    );
+
+    if (contradictions.length > 0) {
+      await cortex.store.add('team', {
+        ...knowledge,
+        id: crypto.randomUUID(),
+        vector,
+        layer: 'team',
+        confidence: adjustedConfidence,
+        metadata: {
+          ...knowledge.metadata,
+          provenance,
+          status: 'pending_review',
+          contradicts: contradictions.map(c => c.existingId),
+        },
+      });
+      return NextResponse.json({ status: 'pending_review', contradictions: contradictions.length });
+    }
+
+    await cortex.store.add('team', {
+      ...knowledge,
+      id: crypto.randomUUID(),
+      vector,
+      layer: 'team',
+      confidence: adjustedConfidence,
+      metadata: { ...knowledge.metadata, provenance, source: 'federation_teach' },
+    });
+
+    return NextResponse.json({ status: 'accepted' });
+  });
+}

package/.next/standalone/src/app/api/cortex/graph/edges/route.ts

@@ -1,112 +1,112 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { getCortex, isCortexAvailable } from '@/lib/cortex';
-import { isValidEdgeRelation } from '@/lib/cortex/graph/types';
-import type { EdgeRelation } from '@/lib/cortex/graph/types';
-
-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?.graph) return NextResponse.json({ edges: [] });
-
-    const url = new URL(request.url);
-    const all = url.searchParams.get('all');
-    if (all === 'true') {
-      const edges = cortex.graph.listAllEdges();
-      return NextResponse.json({ edges });
-    }
-
-    const from = url.searchParams.get('from') ?? undefined;
-    const to = url.searchParams.get('to') ?? undefined;
-    const relationParam = url.searchParams.get('relation') ?? undefined;
-
-    if (!from && !to) {
-      return NextResponse.json({ error: 'from or to query param is required' }, { status: 400 });
-    }
-
-    if (relationParam !== undefined && !isValidEdgeRelation(relationParam)) {
-      return NextResponse.json({ error: `Invalid relation: ${relationParam}` }, { status: 400 });
-    }
-
-    const relation = relationParam as EdgeRelation | undefined;
-
-    const edges = from
-      ? cortex.graph.getEdgesFrom(from, relation)
-      : cortex.graph.getEdgesTo(to!, relation);
-
-    return NextResponse.json({ edges });
-  });
-}
-
-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?.graph) {
-      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-    }
-
-    const body = await request.json();
-    const { source_id, target_id, relation, weight, metadata } = body as {
-      source_id?: string;
-      target_id?: string;
-      relation?: string;
-      weight?: number;
-      metadata?: Record<string, unknown>;
-    };
-
-    if (!source_id || !target_id || !relation) {
-      return NextResponse.json(
-        { error: 'source_id, target_id, and relation are required' },
-        { status: 400 },
-      );
-    }
-
-    if (!isValidEdgeRelation(relation)) {
-      return NextResponse.json({ error: `Invalid relation: ${relation}` }, { status: 400 });
-    }
-
-    const edge = cortex.graph.createEdge({ source_id, target_id, relation, weight, metadata });
-    return NextResponse.json({ edge }, { status: 201 });
-  });
-}
-
-export async function DELETE(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?.graph) {
-      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-    }
-
-    const url = new URL(request.url);
-    const source_id = url.searchParams.get('source_id');
-    const target_id = url.searchParams.get('target_id');
-    const relation = url.searchParams.get('relation');
-
-    if (!source_id || !target_id || !relation) {
-      return NextResponse.json(
-        { error: 'source_id, target_id, and relation query params are required' },
-        { status: 400 },
-      );
-    }
-
-    if (!isValidEdgeRelation(relation)) {
-      return NextResponse.json({ error: `Invalid relation: ${relation}` }, { status: 400 });
-    }
-
-    cortex.graph.deleteEdge(source_id, target_id, relation as EdgeRelation);
-    return NextResponse.json({ deleted: true });
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getCortex, isCortexAvailable } from '@/lib/cortex';
+import { isValidEdgeRelation } from '@/lib/cortex/graph/types';
+import type { EdgeRelation } from '@/lib/cortex/graph/types';
+
+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?.graph) return NextResponse.json({ edges: [] });
+
+    const url = new URL(request.url);
+    const all = url.searchParams.get('all');
+    if (all === 'true') {
+      const edges = cortex.graph.listAllEdges();
+      return NextResponse.json({ edges });
+    }
+
+    const from = url.searchParams.get('from') ?? undefined;
+    const to = url.searchParams.get('to') ?? undefined;
+    const relationParam = url.searchParams.get('relation') ?? undefined;
+
+    if (!from && !to) {
+      return NextResponse.json({ error: 'from or to query param is required' }, { status: 400 });
+    }
+
+    if (relationParam !== undefined && !isValidEdgeRelation(relationParam)) {
+      return NextResponse.json({ error: `Invalid relation: ${relationParam}` }, { status: 400 });
+    }
+
+    const relation = relationParam as EdgeRelation | undefined;
+
+    const edges = from
+      ? cortex.graph.getEdgesFrom(from, relation)
+      : cortex.graph.getEdgesTo(to!, relation);
+
+    return NextResponse.json({ edges });
+  });
+}
+
+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?.graph) {
+      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+    }
+
+    const body = await request.json();
+    const { source_id, target_id, relation, weight, metadata } = body as {
+      source_id?: string;
+      target_id?: string;
+      relation?: string;
+      weight?: number;
+      metadata?: Record<string, unknown>;
+    };
+
+    if (!source_id || !target_id || !relation) {
+      return NextResponse.json(
+        { error: 'source_id, target_id, and relation are required' },
+        { status: 400 },
+      );
+    }
+
+    if (!isValidEdgeRelation(relation)) {
+      return NextResponse.json({ error: `Invalid relation: ${relation}` }, { status: 400 });
+    }
+
+    const edge = cortex.graph.createEdge({ source_id, target_id, relation, weight, metadata });
+    return NextResponse.json({ edge }, { status: 201 });
+  });
+}
+
+export async function DELETE(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?.graph) {
+      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+    }
+
+    const url = new URL(request.url);
+    const source_id = url.searchParams.get('source_id');
+    const target_id = url.searchParams.get('target_id');
+    const relation = url.searchParams.get('relation');
+
+    if (!source_id || !target_id || !relation) {
+      return NextResponse.json(
+        { error: 'source_id, target_id, and relation query params are required' },
+        { status: 400 },
+      );
+    }
+
+    if (!isValidEdgeRelation(relation)) {
+      return NextResponse.json({ error: `Invalid relation: ${relation}` }, { status: 400 });
+    }
+
+    cortex.graph.deleteEdge(source_id, target_id, relation as EdgeRelation);
+    return NextResponse.json({ deleted: true });
+  });
+}

package/.next/standalone/src/app/api/cortex/graph/entities/[id]/route.ts

@@ -1,73 +1,73 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { getCortex, isCortexAvailable } from '@/lib/cortex';
-
-export async function GET(
-  request: NextRequest,
-  { params }: { params: Promise<{ id: string }> },
-) {
-  const user = getAuthUser(request);
-  return withUser(user, async () => {
-    if (!isCortexAvailable()) {
-      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
-    }
-    const cortex = await getCortex();
-    if (!cortex?.graph) {
-      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-    }
-
-    const { id } = await params;
-    const entity = cortex.graph.getEntity(id);
-    if (!entity) {
-      return NextResponse.json({ error: 'Not found' }, { status: 404 });
-    }
-    return NextResponse.json({ entity });
-  });
-}
-
-export async function PATCH(
-  request: NextRequest,
-  { params }: { params: Promise<{ id: string }> },
-) {
-  const user = getAuthUser(request);
-  return withUser(user, async () => {
-    if (!isCortexAvailable()) {
-      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
-    }
-    const cortex = await getCortex();
-    if (!cortex?.graph) {
-      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-    }
-
-    const { id } = await params;
-    const body = await request.json();
-    const { name, metadata } = body as { name?: string; metadata?: Record<string, unknown> };
-
-    const entity = cortex.graph.updateEntity(id, { name, metadata });
-    if (!entity) {
-      return NextResponse.json({ error: 'Not found' }, { status: 404 });
-    }
-    return NextResponse.json({ entity });
-  });
-}
-
-export async function DELETE(
-  request: NextRequest,
-  { params }: { params: Promise<{ id: string }> },
-) {
-  const user = getAuthUser(request);
-  return withUser(user, async () => {
-    if (!isCortexAvailable()) {
-      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
-    }
-    const cortex = await getCortex();
-    if (!cortex?.graph) {
-      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-    }
-
-    const { id } = await params;
-    cortex.graph.deleteEntity(id);
-    return NextResponse.json({ deleted: true });
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getCortex, isCortexAvailable } from '@/lib/cortex';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    if (!isCortexAvailable()) {
+      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
+    }
+    const cortex = await getCortex();
+    if (!cortex?.graph) {
+      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+    }
+
+    const { id } = await params;
+    const entity = cortex.graph.getEntity(id);
+    if (!entity) {
+      return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    }
+    return NextResponse.json({ entity });
+  });
+}
+
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    if (!isCortexAvailable()) {
+      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
+    }
+    const cortex = await getCortex();
+    if (!cortex?.graph) {
+      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+    }
+
+    const { id } = await params;
+    const body = await request.json();
+    const { name, metadata } = body as { name?: string; metadata?: Record<string, unknown> };
+
+    const entity = cortex.graph.updateEntity(id, { name, metadata });
+    if (!entity) {
+      return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    }
+    return NextResponse.json({ entity });
+  });
+}
+
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    if (!isCortexAvailable()) {
+      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
+    }
+    const cortex = await getCortex();
+    if (!cortex?.graph) {
+      return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+    }
+
+    const { id } = await params;
+    cortex.graph.deleteEntity(id);
+    return NextResponse.json({ deleted: true });
+  });
+}