larkup 0.1.14 → 0.1.21

package/app/api/server/generate/route.ts

@@ -1,10 +1,10 @@
-import { NextResponse } from "next/server"
-import JSZip from "jszip"
-import { readConfig } from "@larkup/core/config-store"
-import { generateServer } from "@larkup/core/generator/generate-server"
-import { getActiveServer } from "@larkup/core/workspace"
+import { NextResponse } from 'next/server';
+import JSZip from 'jszip';
+import { readConfig } from '@larkup/core/config-store';
+import { generateServer } from '@larkup/core/generator/generate-server';
+import { getActiveServer } from '@larkup/core/workspace';
 
-export const dynamic = "force-dynamic"
+export const dynamic = 'force-dynamic';
 
 /**
  * Phase 4 — server generation.
@@ -16,31 +16,31 @@ export const dynamic = "force-dynamic"
  * minimal RAG server tailored to the selected vector store.
  */
 export async function GET(req: Request) {
-  const config = await readConfig()
-  const server = generateServer(config)
-  const activeServer = await getActiveServer()
-  const serverId = activeServer?.id ?? "default"
+  const config = await readConfig();
+  const server = generateServer(config);
+  const activeServer = await getActiveServer();
+  const serverId = activeServer?.id ?? 'default';
 
-  const url = new URL(req.url)
-  if (url.searchParams.get("download") === "1") {
-    const zip = new JSZip()
-    const root = server.projectName || "rag-server"
+  const url = new URL(req.url);
+  if (url.searchParams.get('download') === '1') {
+    const zip = new JSZip();
+    const root = server.projectName || 'rag-server';
     for (const file of server.files) {
-      if (file.encoding === "base64") {
-        zip.file(`${root}/${file.path}`, file.contents, { base64: true })
+      if (file.encoding === 'base64') {
+        zip.file(`${root}/${file.path}`, file.contents, { base64: true });
       } else {
-        zip.file(`${root}/${file.path}`, file.contents)
+        zip.file(`${root}/${file.path}`, file.contents);
       }
     }
-    const buf = await zip.generateAsync({ type: "nodebuffer" })
+    const buf = await zip.generateAsync({ type: 'nodebuffer' });
     return new NextResponse(new Uint8Array(buf), {
       headers: {
-        "Content-Type": "application/zip",
-        "Content-Disposition": `attachment; filename="${root}.zip"`,
-        "Cache-Control": "no-store",
+        'Content-Type': 'application/zip',
+        'Content-Disposition': `attachment; filename="${root}.zip"`,
+        'Cache-Control': 'no-store',
       },
-    })
+    });
   }
 
-  return NextResponse.json({ config, server, serverId })
+  return NextResponse.json({ config, server, serverId });
 }

package/app/api/servers/route.ts

@@ -1,4 +1,4 @@
-import { NextResponse } from "next/server"
+import { NextResponse } from 'next/server';
 import {
   createServer,
   deleteServer,
@@ -10,54 +10,48 @@ import {
   setMode,
   type ServerMeta,
   type WorkspaceMode,
-} from "@larkup/core/workspace"
-import { corpusStats } from "@larkup/core/documents-store"
-import { readRun } from "@larkup/core/index-store"
-import { readServerState } from "@larkup/core/generator/server-runtime"
+} from '@larkup/core/workspace';
+import { corpusStats } from '@larkup/core/documents-store';
+import { readRun } from '@larkup/core/index-store';
+import { readServerState } from '@larkup/core/generator/server-runtime';
 
-export const runtime = "nodejs"
-export const dynamic = "force-dynamic"
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
 
 /** A server entry enriched with lightweight, per-server status for the UI. */
 async function decorate(server: ServerMeta) {
   return runWithServer(server.id, async () => {
-    const [stats, run, state] = await Promise.all([
-      corpusStats(),
-      readRun(),
-      readServerState(),
-    ])
+    const [stats, run, state] = await Promise.all([corpusStats(), readRun(), readServerState()]);
     return {
       ...server,
       docCount: stats.docCount,
-      indexed: run?.status === "completed" && (run.totalChunks ?? 0) > 0,
+      indexed: run?.status === 'completed' && (run.totalChunks ?? 0) > 0,
       running: state.running,
       endpoint: state.endpoint,
-    }
-  })
+    };
+  });
 }
 
 /** GET → the full workspace: username, active server, and decorated servers. */
 export async function GET() {
-  const ws = await getWorkspace()
-  const servers = await Promise.all(ws.servers.map(decorate))
+  const ws = await getWorkspace();
+  const servers = await Promise.all(ws.servers.map(decorate));
   return NextResponse.json({
     username: ws.username,
     activeServerId: ws.activeServerId,
     servers,
     mode: ws.mode,
-  })
+  });
 }
 
 /** POST { name } → create a new server (and make it active). */
 export async function POST(req: Request) {
-  let body: { name?: string } = {}
+  let body: { name?: string } = {};
   try {
-    body = await req.json()
-  } catch {
-    // empty body is fine — server gets a default name
-  }
-  const { server } = await createServer(body.name ?? "Untitled server")
-  return NextResponse.json({ server }, { status: 201 })
+    body = await req.json();
+  } catch {}
+  const { server } = await createServer(body.name ?? 'Untitled server');
+  return NextResponse.json({ server }, { status: 201 });
 }
 
 /**
@@ -66,72 +60,62 @@ export async function POST(req: Request) {
  */
 export async function PATCH(req: Request) {
   let body: {
-    action?: string
-    serverId?: string
-    name?: string
-    username?: string
-    mode?: WorkspaceMode
-  }
+    action?: string;
+    serverId?: string;
+    name?: string;
+    username?: string;
+    mode?: WorkspaceMode;
+  };
   try {
-    body = await req.json()
+    body = await req.json();
   } catch {
-    return NextResponse.json({ error: "Invalid JSON body." }, { status: 400 })
+    return NextResponse.json({ error: 'Invalid JSON body.' }, { status: 400 });
   }
 
   switch (body.action) {
-    case "activate": {
+    case 'activate': {
       if (!body.serverId) {
-        return NextResponse.json(
-          { error: "serverId is required." },
-          { status: 400 },
-        )
+        return NextResponse.json({ error: 'serverId is required.' }, { status: 400 });
       }
-      return NextResponse.json({ workspace: await setActiveServer(body.serverId) })
+      return NextResponse.json({ workspace: await setActiveServer(body.serverId) });
     }
-    case "rename": {
+    case 'rename': {
       if (!body.serverId || !body.name?.trim()) {
-        return NextResponse.json(
-          { error: "serverId and name are required." },
-          { status: 400 },
-        )
+        return NextResponse.json({ error: 'serverId and name are required.' }, { status: 400 });
       }
       return NextResponse.json({
         workspace: await renameServer(body.serverId, body.name),
-      })
+      });
     }
-    case "setUsername": {
+    case 'setUsername': {
       return NextResponse.json({
-        workspace: await setUsername(body.username ?? ""),
-      })
+        workspace: await setUsername(body.username ?? ''),
+      });
     }
-    case "setMode": {
-      if (!body.mode || !(["tech", "simple"] as string[]).includes(body.mode)) {
-        return NextResponse.json(
-          { error: "mode must be 'tech' or 'simple'." },
-          { status: 400 },
-        )
+    case 'setMode': {
+      if (!body.mode || !(['tech', 'simple'] as string[]).includes(body.mode)) {
+        return NextResponse.json({ error: "mode must be 'tech' or 'simple'." }, { status: 400 });
       }
       return NextResponse.json({
         workspace: await setMode(body.mode),
-      })
+      });
     }
     default:
-      return NextResponse.json({ error: "Unknown action." }, { status: 400 })
+      return NextResponse.json({ error: 'Unknown action.' }, { status: 400 });
   }
 }
 
 /** DELETE ?id=<id> — stop the server's instance, then remove all its data. */
 export async function DELETE(req: Request) {
-  const id = new URL(req.url).searchParams.get("id")
+  const id = new URL(req.url).searchParams.get('id');
   if (!id) {
-    return NextResponse.json({ error: "id is required." }, { status: 400 })
+    return NextResponse.json({ error: 'id is required.' }, { status: 400 });
   }
-  // Stop any running instance in the target server's context first.
   try {
-    const { stopServer } = await import("@larkup/core/generator/server-runtime")
-    await runWithServer(id, () => stopServer())
+    const { stopServer } = await import('@larkup/core/generator/server-runtime');
+    await runWithServer(id, () => stopServer());
   } catch {
     // best effort — still remove the data
   }
-  return NextResponse.json({ workspace: await deleteServer(id) })
+  return NextResponse.json({ workspace: await deleteServer(id) });
 }

package/app/api/tabular/query/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from "next/server"
+import { queryTabular } from "@larkup/core/tabular-store"
+import type { TabularQueryRequest } from "@larkup/core/tabular-store"
+
+export const runtime = "nodejs"
+export const dynamic = "force-dynamic"
+
+/** POST /api/tabular/query — Execute a structured query against a tabular dataset. */
+export async function POST(req: Request) {
+  try {
+    const body: TabularQueryRequest = await req.json()
+
+    if (!body.datasetId) {
+      return NextResponse.json(
+        { error: "datasetId is required" },
+        { status: 400 },
+      )
+    }
+
+    const result = await queryTabular(body)
+    return NextResponse.json(result)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Query failed"
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}

package/app/api/tabular/route.ts

@@ -0,0 +1,63 @@
+import { NextResponse } from "next/server"
+import {
+  saveTabularDataset,
+  listTabularDatasets,
+  deleteTabularDataset,
+} from "@larkup/core/tabular-store"
+
+export const runtime = "nodejs"
+export const dynamic = "force-dynamic"
+
+/** GET /api/tabular — List all tabular datasets (metadata only). */
+export async function GET() {
+  try {
+    const datasets = await listTabularDatasets()
+    return NextResponse.json({ datasets })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to list datasets"
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}
+
+/** POST /api/tabular — Save a new tabular dataset. */
+export async function POST(req: Request) {
+  try {
+    const { fileName, rows } = await req.json()
+
+    if (!fileName || !Array.isArray(rows) || rows.length === 0) {
+      return NextResponse.json(
+        { error: "fileName and non-empty rows array required" },
+        { status: 400 },
+      )
+    }
+
+    const dataset = await saveTabularDataset(fileName, rows)
+
+    return NextResponse.json({
+      id: dataset.id,
+      fileName: dataset.fileName,
+      rowCount: dataset.rowCount,
+      columns: dataset.columns,
+      summary: dataset.summary,
+    })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to save dataset"
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}
+
+/** DELETE /api/tabular?id=... — Delete a tabular dataset. */
+export async function DELETE(req: Request) {
+  try {
+    const url = new URL(req.url)
+    const id = url.searchParams.get("id")
+    if (!id) {
+      return NextResponse.json({ error: "id required" }, { status: 400 })
+    }
+    await deleteTabularDataset(id)
+    return NextResponse.json({ ok: true })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to delete dataset"
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}

package/app/api/upload-file/route.ts

@@ -0,0 +1,38 @@
+import { NextResponse } from 'next/server';
+import { randomUUID } from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function POST(req: Request) {
+  try {
+    const formData = await req.formData();
+    const file = formData.get('file') as File | null;
+
+    if (!file) {
+      return NextResponse.json({ error: 'No file provided' }, { status: 400 });
+    }
+
+    const buffer = Buffer.from(await file.arrayBuffer());
+
+    // Create safe filename
+    const ext = file.name.split('.').pop() || '';
+    const safeName = file.name.replace(/[^a-zA-Z0-9.-]/g, '_').substring(0, 50);
+    const filename = `${randomUUID()}-${safeName}`;
+
+    const uploadsDir = path.join(process.cwd(), '.larkup', 'uploads');
+    await fs.mkdir(uploadsDir, { recursive: true });
+
+    const filePath = path.join(uploadsDir, filename);
+    await fs.writeFile(filePath, buffer);
+
+    const url = `/api/uploads/${filename}`;
+
+    return NextResponse.json({ url });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to upload file.';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/app/api/uploads/[...slug]/route.ts

@@ -0,0 +1,90 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: Request, { params }: { params: Promise<{ slug: string[] }> }) {
+  try {
+    const resolvedParams = await params;
+    const slug = resolvedParams.slug;
+    if (!slug || slug.length === 0) {
+      return new NextResponse('File not found', { status: 404 });
+    }
+
+    const filename = slug.join('/');
+    // Prevent directory traversal
+    if (filename.includes('..')) {
+      return new NextResponse('Forbidden', { status: 403 });
+    }
+
+    const uploadsDir = path.join(process.cwd(), '.larkup', 'uploads');
+    const filePath = path.join(uploadsDir, filename);
+
+    if (!fs.existsSync(filePath)) {
+      return new NextResponse('File not found', { status: 404 });
+    }
+
+    const stat = fs.statSync(filePath);
+    const fileStream = fs.createReadStream(filePath) as any;
+
+    // Determine content type based on extension
+    const ext = path.extname(filename).toLowerCase();
+    let contentType = 'application/octet-stream';
+
+    switch (ext) {
+      case '.png':
+        contentType = 'image/png';
+        break;
+      case '.jpg':
+      case '.jpeg':
+        contentType = 'image/jpeg';
+        break;
+      case '.gif':
+        contentType = 'image/gif';
+        break;
+      case '.webp':
+        contentType = 'image/webp';
+        break;
+      case '.svg':
+        contentType = 'image/svg+xml';
+        break;
+      case '.pdf':
+        contentType = 'application/pdf';
+        break;
+      case '.mp4':
+        contentType = 'video/mp4';
+        break;
+      case '.webm':
+        contentType = 'video/webm';
+        break;
+      case '.mp3':
+        contentType = 'audio/mpeg';
+        break;
+      case '.wav':
+        contentType = 'audio/wav';
+        break;
+      case '.csv':
+        contentType = 'text/csv';
+        break;
+      case '.txt':
+        contentType = 'text/plain';
+        break;
+      case '.json':
+        contentType = 'application/json';
+        break;
+    }
+
+    const headers = new Headers();
+    headers.set('Content-Type', contentType);
+    headers.set('Content-Length', stat.size.toString());
+    // Add cache control for better performance (cache for 1 hour)
+    headers.set('Cache-Control', 'public, max-age=3600');
+
+    return new NextResponse(fileStream, { headers });
+  } catch (error) {
+    console.error('Error serving file:', error);
+    return new NextResponse('Internal Server Error', { status: 500 });
+  }
+}

package/app/api/vector-stores/install/route.ts

@@ -1,6 +1,6 @@
-import { NextResponse } from "next/server";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
+import { NextResponse } from 'next/server';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
 
 const execAsync = promisify(exec);
 
@@ -13,8 +13,7 @@ const execAsync = promisify(exec);
  * Body: { "storeId": "chroma" }
  */
 export async function POST(request: Request) {
-  // Block in production — pnpm add can't run on Vercel
-  if (process.env.NODE_ENV === "production") {
+  if (process.env.NODE_ENV === 'production') {
     return NextResponse.json(
       {
         error:
@@ -29,7 +28,7 @@ export async function POST(request: Request) {
 
   // Only Chroma is installable for now
   const INSTALLABLE: Record<string, { pkg: string; version: string }> = {
-    chroma: { pkg: "chromadb", version: "^1.9.0" },
+    chroma: { pkg: 'chromadb', version: '^1.9.0' },
   };
 
   const entry = INSTALLABLE[storeId];

package/app/api/vector-stores/status/route.ts

@@ -1,4 +1,4 @@
-import { NextResponse } from "next/server";
+import { NextResponse } from 'next/server';
 
 /**
  * GET /api/vector-stores/status
@@ -10,13 +10,15 @@ export async function GET() {
   const status: Record<string, { installed: boolean }> = {};
 
   // Check chromadb by reading the vector-stores package.json
-  // Dynamic import caching in Next.js might fail even after installation.
   try {
-    const fs = await import("fs");
-    const path = await import("path");
-    const pkgPath = path.join(process.cwd(), "../../packages/vector-stores/package.json");
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    const hasChroma = pkg.dependencies?.chromadb || pkg.devDependencies?.chromadb || pkg.optionalDependencies?.chromadb;
+    const fs = await import('fs');
+    const path = await import('path');
+    const pkgPath = path.join(process.cwd(), '../../packages/vector-stores/package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const hasChroma =
+      pkg.dependencies?.chromadb ||
+      pkg.devDependencies?.chromadb ||
+      pkg.optionalDependencies?.chromadb;
     status.chroma = { installed: !!hasChroma };
   } catch {
     status.chroma = { installed: false };

package/app/chat/page.tsx

@@ -1,15 +1,11 @@
-import { PageHeader } from "@/components/page-header";
 import { ChatWorkspace } from "@/components/chat/chat-workspace";
 
 export default function ChatPage() {
   return (
-    <div className="flex flex-col overflow-hidden" style={{ height: "100%" }}>
-      <PageHeader
-        eyebrow="Step 6 · Chat"
-        title="Chat with your knowledge base"
-        className="gap-0 pb-0"
-      />
-      <ChatWorkspace />
+    <div className="flex flex-col h-full overflow-hidden">
+      <div className="flex-1 min-h-0 flex flex-col h-full">
+        <ChatWorkspace />
+      </div>
     </div>
   );
 }

package/app/data/page.tsx

@@ -1,15 +1,22 @@
-import { PageHeader } from "@/components/page-header";
+import { Suspense } from "react";
 import { DataWorkspace } from "@/components/data/data-workspace";
 
 export default function DataPage() {
   return (
-    <div className="flex min-h-full flex-col">
-      <PageHeader
-        eyebrow="Step 2 · Data"
-        title="Load &amp; scrape data"
-        description="Manage your corpus and ETL jobs. Load new data via web scraping, pasting, or uploading files."
-      />
-      <DataWorkspace />
+    <div className="flex flex-col h-full">
+      <div className="px-6 pt-6 pb-2 md:px-8">
+        <h1 className="text-xl font-semibold tracking-tight text-foreground">
+          Data
+        </h1>
+        <p className="text-sm text-muted-foreground mt-1">
+          Upload files, scrape the web, or manage your knowledge base.
+        </p>
+      </div>
+      <div className="flex-1 min-h-0 pb-8">
+        <Suspense>
+          <DataWorkspace />
+        </Suspense>
+      </div>
     </div>
   );
 }