@jlongo78/agent-spaces 0.7.5 → 0.7.7

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

@@ -1,75 +1,75 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import path from 'path';
-import fs from 'fs';
-import os from 'os';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { isCortexAvailable, getCortex } from '@/lib/cortex';
-import { importCortexpack } from '@/lib/cortex/portability/importer';
-import { getUserPaths } from '@/lib/config';
-
-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 contentType = request.headers.get('content-type') || '';
-
-    if (contentType.includes('application/json')) {
-      const body = await request.json();
-      const filename = body.marketplace_file;
-      if (!filename) {
-        return NextResponse.json({ error: 'marketplace_file is required' }, { status: 400 });
-      }
-      const safe = path.basename(filename);
-      const { spacesDir } = getUserPaths(user);
-      const packPath = path.join(spacesDir, 'cortex', 'marketplace', safe);
-      if (!fs.existsSync(packPath)) {
-        return NextResponse.json({ error: 'Pack not found' }, { status: 404 });
-      }
-
-      const targetLayer = body.target_layer || 'workspace';
-      const workspaceId = body.workspace_id;
-      const effectiveLayer = targetLayer === 'workspace' && workspaceId
-        ? `workspace/${workspaceId}` : targetLayer;
-
-      importCortexpack(packPath, cortex.store, cortex.embedding, {
-        targetLayer: effectiveLayer,
-        mergeStrategy: (body.merge_strategy || 'merge') as any,
-        reEmbed: body.re_embed ?? false,
-      });
-      return NextResponse.json({ status: 'started' });
-
-    } else {
-      const formData = await request.formData();
-      const file = formData.get('file') as File;
-      if (!file) {
-        return NextResponse.json({ error: 'No file uploaded' }, { status: 400 });
-      }
-
-      const tmpPath = path.join(os.tmpdir(), `cortex-import-${Date.now()}.cortexpack`);
-      const bytes = await file.arrayBuffer();
-      fs.writeFileSync(tmpPath, Buffer.from(bytes));
-
-      const targetLayer = (formData.get('target_layer') as string) || 'workspace';
-      const mergeStrategy = (formData.get('merge_strategy') as string) || 'merge';
-      const reEmbed = formData.get('re_embed') === 'true';
-      const workspaceId = formData.get('workspace_id') as string | null;
-      const effectiveLayer = targetLayer === 'workspace' && workspaceId
-        ? `workspace/${workspaceId}` : targetLayer;
-
-      importCortexpack(tmpPath, cortex.store, cortex.embedding, {
-        targetLayer: effectiveLayer,
-        mergeStrategy: mergeStrategy as any,
-        reEmbed,
-      }).finally(() => {
-        try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
-      });
-      return NextResponse.json({ status: 'started' });
-    }
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { isCortexAvailable, getCortex } from '@/lib/cortex';
+import { importCortexpack } from '@/lib/cortex/portability/importer';
+import { getUserPaths } from '@/lib/config';
+
+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 contentType = request.headers.get('content-type') || '';
+
+    if (contentType.includes('application/json')) {
+      const body = await request.json();
+      const filename = body.marketplace_file;
+      if (!filename) {
+        return NextResponse.json({ error: 'marketplace_file is required' }, { status: 400 });
+      }
+      const safe = path.basename(filename);
+      const { spacesDir } = getUserPaths(user);
+      const packPath = path.join(spacesDir, 'cortex', 'marketplace', safe);
+      if (!fs.existsSync(packPath)) {
+        return NextResponse.json({ error: 'Pack not found' }, { status: 404 });
+      }
+
+      const targetLayer = body.target_layer || 'workspace';
+      const workspaceId = body.workspace_id;
+      const effectiveLayer = targetLayer === 'workspace' && workspaceId
+        ? `workspace/${workspaceId}` : targetLayer;
+
+      importCortexpack(packPath, cortex.store, cortex.embedding, {
+        targetLayer: effectiveLayer,
+        mergeStrategy: (body.merge_strategy || 'merge') as any,
+        reEmbed: body.re_embed ?? false,
+      });
+      return NextResponse.json({ status: 'started' });
+
+    } else {
+      const formData = await request.formData();
+      const file = formData.get('file') as File;
+      if (!file) {
+        return NextResponse.json({ error: 'No file uploaded' }, { status: 400 });
+      }
+
+      const tmpPath = path.join(os.tmpdir(), `cortex-import-${Date.now()}.cortexpack`);
+      const bytes = await file.arrayBuffer();
+      fs.writeFileSync(tmpPath, Buffer.from(bytes));
+
+      const targetLayer = (formData.get('target_layer') as string) || 'workspace';
+      const mergeStrategy = (formData.get('merge_strategy') as string) || 'merge';
+      const reEmbed = formData.get('re_embed') === 'true';
+      const workspaceId = formData.get('workspace_id') as string | null;
+      const effectiveLayer = targetLayer === 'workspace' && workspaceId
+        ? `workspace/${workspaceId}` : targetLayer;
+
+      importCortexpack(tmpPath, cortex.store, cortex.embedding, {
+        targetLayer: effectiveLayer,
+        mergeStrategy: mergeStrategy as any,
+        reEmbed,
+      }).finally(() => {
+        try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+      });
+      return NextResponse.json({ status: 'started' });
+    }
+  });
+}

package/.next/standalone/src/app/api/cortex/import/status/route.ts

@@ -1,15 +1,15 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { isCortexAvailable } from '@/lib/cortex';
-import { getImportProgress } from '@/lib/cortex/portability/importer';
-
-export async function GET(request: NextRequest) {
-  const user = getAuthUser(request);
-  return withUser(user, () => {
-    if (!isCortexAvailable()) {
-      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
-    }
-    return NextResponse.json(getImportProgress());
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { isCortexAvailable } from '@/lib/cortex';
+import { getImportProgress } from '@/lib/cortex/portability/importer';
+
+export async function GET(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, () => {
+    if (!isCortexAvailable()) {
+      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
+    }
+    return NextResponse.json(getImportProgress());
+  });
+}

package/.next/standalone/src/app/api/cortex/ingest/bootstrap/route.ts

@@ -1,29 +1,29 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import path from 'path';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { getUserPaths } from '@/lib/config';
-import { isCortexAvailable, getCortex } from '@/lib/cortex';
-import { runBootstrap } from '@/lib/cortex/ingestion/bootstrap';
-
-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 { spacesDir } = getUserPaths(user);
-    const cortexDir = path.join(spacesDir, 'cortex');
-
-    // Run bootstrap asynchronously
-    runBootstrap(cortex.pipeline, cortexDir).catch(err => {
-      console.error('Bootstrap error:', err);
-    });
-
-    return NextResponse.json({ status: 'started' });
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import path from 'path';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getUserPaths } from '@/lib/config';
+import { isCortexAvailable, getCortex } from '@/lib/cortex';
+import { runBootstrap } from '@/lib/cortex/ingestion/bootstrap';
+
+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 { spacesDir } = getUserPaths(user);
+    const cortexDir = path.join(spacesDir, 'cortex');
+
+    // Run bootstrap asynchronously
+    runBootstrap(cortex.pipeline, cortexDir).catch(err => {
+      console.error('Bootstrap error:', err);
+    });
+
+    return NextResponse.json({ status: 'started' });
+  });
+}

package/.next/standalone/src/app/api/cortex/ingest/status/route.ts

@@ -1,15 +1,15 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { isCortexAvailable } from '@/lib/cortex';
-import { getBootstrapProgress } from '@/lib/cortex/ingestion/bootstrap';
-
-export async function GET(request: NextRequest) {
-  const user = getAuthUser(request);
-  return withUser(user, () => {
-    if (!isCortexAvailable()) {
-      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
-    }
-    return NextResponse.json(getBootstrapProgress());
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { isCortexAvailable } from '@/lib/cortex';
+import { getBootstrapProgress } from '@/lib/cortex/ingestion/bootstrap';
+
+export async function GET(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, () => {
+    if (!isCortexAvailable()) {
+      return NextResponse.json({ error: 'Cortex unavailable' }, { status: 403 });
+    }
+    return NextResponse.json(getBootstrapProgress());
+  });
+}

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

@@ -1,91 +1,91 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { isCortexAvailable, getCortex } 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) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-
-    const { id } = await params;
-
-    for (const layer of ['personal', 'workspace', 'team']) {
-      const results = await cortex.store.search(layer, [], 1, `id = '${id.replace(/'/g, "''")}'`);
-      if (results.length > 0) {
-        return NextResponse.json(results[0]);
-      }
-    }
-
-    return NextResponse.json({ error: 'Not found' }, { status: 404 });
-  });
-}
-
-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) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-
-    const { id } = await params;
-    const updates = await request.json();
-
-    for (const layer of ['personal', 'workspace', 'team']) {
-      const safeId = id.replace(/'/g, "''");
-      const results = await cortex.store.search(layer, [], 1, `id = '${safeId}'`);
-      if (results.length > 0) {
-        const existing = results[0];
-        await cortex.store.delete(layer, id);
-        const merged = {
-          ...existing,
-          ...updates,
-          id,
-        };
-        const targetLayer = merged.layer === 'workspace' && merged.workspace_id
-          ? `workspace/${merged.workspace_id}` : merged.layer;
-        await cortex.store.add(targetLayer, merged);
-        return NextResponse.json({ success: true });
-      }
-    }
-
-    return NextResponse.json({ error: 'Not found' }, { status: 404 });
-  });
-}
-
-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) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
-
-    const { id } = await params;
-
-    for (const layer of ['personal', 'workspace', 'team']) {
-      await cortex.store.delete(layer, id);
-    }
-
-    return NextResponse.json({ success: true });
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { isCortexAvailable, getCortex } 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) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+
+    const { id } = await params;
+
+    for (const layer of ['personal', 'workspace', 'team']) {
+      const results = await cortex.store.search(layer, [], 1, `id = '${id.replace(/'/g, "''")}'`);
+      if (results.length > 0) {
+        return NextResponse.json(results[0]);
+      }
+    }
+
+    return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  });
+}
+
+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) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+
+    const { id } = await params;
+    const updates = await request.json();
+
+    for (const layer of ['personal', 'workspace', 'team']) {
+      const safeId = id.replace(/'/g, "''");
+      const results = await cortex.store.search(layer, [], 1, `id = '${safeId}'`);
+      if (results.length > 0) {
+        const existing = results[0];
+        await cortex.store.delete(layer, id);
+        const merged = {
+          ...existing,
+          ...updates,
+          id,
+        };
+        const targetLayer = merged.layer === 'workspace' && merged.workspace_id
+          ? `workspace/${merged.workspace_id}` : merged.layer;
+        await cortex.store.add(targetLayer, merged);
+        return NextResponse.json({ success: true });
+      }
+    }
+
+    return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  });
+}
+
+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) return NextResponse.json({ error: 'Cortex disabled' }, { status: 503 });
+
+    const { id } = await params;
+
+    for (const layer of ['personal', 'workspace', 'team']) {
+      await cortex.store.delete(layer, id);
+    }
+
+    return NextResponse.json({ success: true });
+  });
+}

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

@@ -1,93 +1,93 @@
-import { NextResponse } from 'next/server';
-import type { NextRequest } from 'next/server';
-import crypto from 'crypto';
-import { getAuthUser, withUser } from '@/lib/auth';
-import { isCortexAvailable, getCortex } from '@/lib/cortex';
-import { isValidKnowledgeType, isValidLayer, getConfidenceBase } from '@/lib/cortex/knowledge/types';
-import { layerToScope, scopeToLayer, scopeToLayerKey } from '@/lib/cortex/knowledge/compat';
-
-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 { text, type, workspace_id } = body;
-    let { layer, scope, sensitivity, origin, entity_links } = body;
-
-    if (!text || !type) {
-      return NextResponse.json({ error: 'text and type are required' }, { status: 400 });
-    }
-    if (!layer && !scope) {
-      return NextResponse.json({ error: 'layer or scope is required' }, { status: 400 });
-    }
-    if (!isValidKnowledgeType(type)) {
-      return NextResponse.json({ error: `Invalid type: ${type}` }, { status: 400 });
-    }
-    if (layer && !isValidLayer(layer)) {
-      return NextResponse.json({ error: `Invalid layer: ${layer}` }, { status: 400 });
-    }
-
-    // Resolve layer ↔ scope
-    if (scope && !layer) {
-      layer = scopeToLayer(scope);
-    } else if (layer && !scope) {
-      scope = layerToScope(layer, workspace_id);
-    }
-
-    const layerKey = scope
-      ? scopeToLayerKey(scope, workspace_id)
-      : (layer === 'workspace' && workspace_id ? `workspace/${workspace_id}` : layer);
-
-    const [vector] = await cortex.embedding.embed([text]);
-    const id = crypto.randomUUID();
-
-    await cortex.store.add(layerKey, {
-      id,
-      vector,
-      text,
-      type,
-      layer,
-      workspace_id: workspace_id || null,
-      session_id: null,
-      agent_type: 'claude',
-      project_path: null,
-      file_refs: [],
-      confidence: 0.95,
-      created: new Date().toISOString(),
-      source_timestamp: new Date().toISOString(),
-      stale_score: 0,
-      access_count: 0,
-      last_accessed: null,
-      metadata: { source: 'user_teach' },
-      scope,
-      entity_links: entity_links ?? [],
-      evidence_score: getConfidenceBase(type),
-      corroborations: 0,
-      contradiction_refs: [],
-      sensitivity: sensitivity ?? 'internal',
-      creator_scope: null,
-      origin: origin ?? { source_type: 'manual', source_ref: '', creator_entity_id: `person-${user}` },
-      propagation_path: [],
-    });
-
-    // Enqueue for distillation if pipeline has it wired
-    if (cortex.pipeline?.distillQueue && cortex.pipeline?.distillScheduler) {
-      cortex.pipeline.distillQueue.enqueue(id, {
-        text,
-        layerKey,
-        workspaceId: workspace_id || null,
-        agentType: 'claude',
-      });
-      cortex.pipeline.distillScheduler.enqueue([id]);
-    }
-
-    console.log(`[Cortex Store] +${type} in ${layerKey}: "${text.slice(0, 60)}..."`);
-    return NextResponse.json({ id, success: true });
-  });
-}
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import crypto from 'crypto';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { isCortexAvailable, getCortex } from '@/lib/cortex';
+import { isValidKnowledgeType, isValidLayer, getConfidenceBase } from '@/lib/cortex/knowledge/types';
+import { layerToScope, scopeToLayer, scopeToLayerKey } from '@/lib/cortex/knowledge/compat';
+
+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 { text, type, workspace_id } = body;
+    let { layer, scope, sensitivity, origin, entity_links } = body;
+
+    if (!text || !type) {
+      return NextResponse.json({ error: 'text and type are required' }, { status: 400 });
+    }
+    if (!layer && !scope) {
+      return NextResponse.json({ error: 'layer or scope is required' }, { status: 400 });
+    }
+    if (!isValidKnowledgeType(type)) {
+      return NextResponse.json({ error: `Invalid type: ${type}` }, { status: 400 });
+    }
+    if (layer && !isValidLayer(layer)) {
+      return NextResponse.json({ error: `Invalid layer: ${layer}` }, { status: 400 });
+    }
+
+    // Resolve layer ↔ scope
+    if (scope && !layer) {
+      layer = scopeToLayer(scope);
+    } else if (layer && !scope) {
+      scope = layerToScope(layer, workspace_id);
+    }
+
+    const layerKey = scope
+      ? scopeToLayerKey(scope, workspace_id)
+      : (layer === 'workspace' && workspace_id ? `workspace/${workspace_id}` : layer);
+
+    const [vector] = await cortex.embedding.embed([text]);
+    const id = crypto.randomUUID();
+
+    await cortex.store.add(layerKey, {
+      id,
+      vector,
+      text,
+      type,
+      layer,
+      workspace_id: workspace_id || null,
+      session_id: null,
+      agent_type: 'claude',
+      project_path: null,
+      file_refs: [],
+      confidence: 0.95,
+      created: new Date().toISOString(),
+      source_timestamp: new Date().toISOString(),
+      stale_score: 0,
+      access_count: 0,
+      last_accessed: null,
+      metadata: { source: 'user_teach' },
+      scope,
+      entity_links: entity_links ?? [],
+      evidence_score: getConfidenceBase(type),
+      corroborations: 0,
+      contradiction_refs: [],
+      sensitivity: sensitivity ?? 'internal',
+      creator_scope: null,
+      origin: origin ?? { source_type: 'manual', source_ref: '', creator_entity_id: `person-${user}` },
+      propagation_path: [],
+    });
+
+    // Enqueue for distillation if pipeline has it wired
+    if (cortex.pipeline?.distillQueue && cortex.pipeline?.distillScheduler) {
+      cortex.pipeline.distillQueue.enqueue(id, {
+        text,
+        layerKey,
+        workspaceId: workspace_id || null,
+        agentType: 'claude',
+      });
+      cortex.pipeline.distillScheduler.enqueue([id]);
+    }
+
+    console.log(`[Cortex Store] +${type} in ${layerKey}: "${text.slice(0, 60)}..."`);
+    return NextResponse.json({ id, success: true });
+  });
+}