feat: Integrate ai sdk

.gitignore

@@ -9,7 +9,6 @@ wheels/
 # Virtual environments
 .venv
 slack_stuff/
-data/
 secret/
 .env
 .bernd_history

.vscode/settings.json

@@ -0,0 +1,27 @@
+{
+  "biome.lsp.bin": "./ui/node_modules/@biomejs/biome/bin/biome",
+  "biome.configurationPath": "./ui/biome.json",
+  "[javascript]": {
+    "editor.defaultFormatter": "biomejs.biome"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "biomejs.biome"
+  },
+  "[jsonc]": {
+    "editor.defaultFormatter": "biomejs.biome"
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "biomejs.biome"
+  },
+  "[typescriptreact]": {
+    "editor.defaultFormatter": "biomejs.biome"
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.biome": "explicit"
+  },
+  "editor.defaultFormatter": "biomejs.biome",
+  "editor.formatOnPaste": true,
+  "editor.formatOnSave": true,
+  "typescript.tsdk": "ui/node_modules/typescript/lib",
+  "prettier.enable": false
+}

ui/actions/chats.ts

@@ -0,0 +1,21 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { redirect } from "next/navigation";
+import { PATHS } from "@/lib/constants";
+import { getFS } from "@/lib/context";
+
+export async function deleteChatAction(id: string, isActive?: boolean) {
+  const fs = await getFS();
+
+  await Promise.all([
+    fs.delete(`${PATHS.CHATS}/${id}.json`),
+    fs.clearPrefix(`${PATHS.CHAT_ASSETS}/${id}/`),
+  ]);
+
+  revalidatePath("/chat");
+
+  if (isActive) {
+    redirect("/chat");
+  }
+}

ui/actions/files.ts

@@ -0,0 +1,203 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { PATHS } from "@/lib/constants";
+import { getFS } from "@/lib/context";
+import type { FileItem } from "@/types";
+import {
+  type FileUploadMetadata,
+  type FolderMarkerMetadata,
+  isFileUploadMetadata,
+} from "@/types";
+
+export async function listFilesAction(path: string): Promise<FileItem[]> {
+  const fs = await getFS();
+  const files = await fs.list(path, 100);
+  const basePath = path.endsWith("/") ? path : `${path}/`;
+
+  const seen = new Set<string>();
+  const items: FileItem[] = [];
+
+  for (const file of files) {
+    const relativePath = file.path.replace(basePath, "").replace(/^\//, "");
+    const parts = relativePath.split("/");
+    const name = parts[0];
+    const isFolder = parts.length > 1;
+
+    // Skip folder marker files
+    if (name === "folder_meta.json") continue;
+
+    if (isFolder) {
+      if (seen.has(name)) continue;
+      seen.add(name);
+      items.push({
+        name,
+        path: `${path}/${name}`,
+        type: "folder",
+      });
+    } else {
+      const meta = file.metadata;
+      items.push({
+        name,
+        path: file.path,
+        type: "file",
+        size: isFileUploadMetadata(meta) ? meta.size : undefined,
+        mime_type: isFileUploadMetadata(meta) ? meta.mime_type : undefined,
+        created_at: meta.created_at ?? undefined,
+      });
+    }
+  }
+
+  items.sort((a, b) => {
+    if (a.type !== b.type) {
+      return a.type === "folder" ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+
+  return items;
+}
+
+export async function downloadFileAction(
+  path: string,
+): Promise<{ content: string; mimeType: string }> {
+  if (!path.startsWith(PATHS.FILES)) {
+    throw new Error("Can only download files under /files/");
+  }
+  const fs = await getFS();
+  const result = await fs.read(path);
+
+  const meta = result.metadata;
+  return {
+    content: result.content,
+    mimeType: isFileUploadMetadata(meta) ? meta.mime_type : "text/plain",
+  };
+}
+
+export async function downloadBinaryFileAction(
+  path: string,
+): Promise<{ data: number[]; mimeType: string }> {
+  if (!path.startsWith(PATHS.FILES)) {
+    throw new Error("Can only download files under /files/");
+  }
+  const fs = await getFS();
+  const result = await fs.readBinary(path);
+
+  // Convert ArrayBuffer to array of numbers for serialization
+  const data = Array.from(new Uint8Array(result.data));
+
+  const meta = result.metadata;
+  return {
+    data,
+    mimeType: isFileUploadMetadata(meta)
+      ? meta.mime_type
+      : "application/octet-stream",
+  };
+}
+
+export async function uploadFileAction(
+  path: string,
+  content: string,
+  metadata?: Record<string, unknown>,
+) {
+  const fs = await getFS();
+
+  // Ensure path starts with /files/
+  const fullPath = path.startsWith(PATHS.FILES)
+    ? path
+    : `${PATHS.FILES}${path}`;
+  const filename = fullPath.split("/").pop() ?? "unnamed";
+
+  const fileMetadata: Omit<
+    FileUploadMetadata,
+    "path" | "created_at" | "updated_at"
+  > = {
+    type: "file",
+    mime_type: (metadata?.mime_type as string) ?? "text/plain",
+    size: (metadata?.size as number) ?? content.length,
+    is_base64: false,
+    original_name: (metadata?.original_name as string) ?? filename,
+  };
+  await fs.write(fullPath, content, fileMetadata);
+
+  revalidatePath("/files");
+}
+
+export async function uploadBinaryFileAction(
+  path: string,
+  data: ArrayBuffer,
+  mimeType: string,
+  metadata?: Record<string, unknown>,
+) {
+  const fs = await getFS();
+
+  // Ensure path starts with /files/
+  const fullPath = path.startsWith(PATHS.FILES)
+    ? path
+    : `${PATHS.FILES}${path}`;
+  const filename = fullPath.split("/").pop() ?? "unnamed";
+
+  const fileMetadata: Omit<
+    FileUploadMetadata,
+    "path" | "created_at" | "updated_at"
+  > = {
+    type: "file",
+    mime_type: mimeType,
+    size: (metadata?.size as number) ?? data.byteLength,
+    is_base64: true,
+    original_name: (metadata?.original_name as string) ?? filename,
+  };
+  await fs.writeBinary(fullPath, data, mimeType, fileMetadata);
+
+  revalidatePath("/files");
+}
+
+export async function createFolderAction(path: string) {
+  const fs = await getFS();
+
+  // Ensure path starts with /files/
+  const fullPath = path.startsWith(PATHS.FILES)
+    ? path
+    : `${PATHS.FILES}${path}`;
+  const folderName = fullPath.split("/").pop() ?? "folder";
+  const createdAt = new Date().toISOString();
+
+  const content = JSON.stringify({
+    type: "folder",
+    name: folderName,
+    created_at: createdAt,
+  });
+
+  const folderMetadata: Omit<
+    FolderMarkerMetadata,
+    "path" | "created_at" | "updated_at"
+  > = {
+    type: "folder_marker",
+  };
+  await fs.write(`${fullPath}/folder_meta.json`, content, folderMetadata);
+
+  revalidatePath("/files");
+}
+
+export async function deleteFileAction(path: string) {
+  if (!path.startsWith(PATHS.FILES)) {
+    throw new Error("Can only delete files under /files/");
+  }
+  const fs = await getFS();
+
+  await fs.delete(path);
+
+  revalidatePath("/files");
+}
+
+export async function deleteFolderAction(path: string) {
+  if (!path.startsWith(PATHS.FILES)) {
+    throw new Error("Can only delete folders under /files/");
+  }
+  const fs = await getFS();
+
+  const prefix = path.endsWith("/") ? path : `${path}/`;
+  await fs.clearPrefix(prefix);
+
+  revalidatePath("/files");
+}

ui/actions/google-auth.ts

@@ -0,0 +1,52 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { PATHS } from "@/lib/constants";
+import { getFS } from "@/lib/context";
+import { encrypt } from "@/lib/crypto";
+
+export async function getGoogleStatusAction(): Promise<{
+  connected: boolean;
+  connected_at?: string;
+}> {
+  try {
+    const fs = await getFS();
+    const result = await fs.read(PATHS.GOOGLE_AUTH);
+    const tokens = JSON.parse(result.content);
+    const connected = !!(tokens?.access_token && tokens?.refresh_token);
+    return {
+      connected,
+      connected_at: connected ? result.metadata.created_at : undefined,
+    };
+  } catch {
+    return { connected: false };
+  }
+}
+
+export async function disconnectGoogleAction() {
+  const fs = await getFS();
+
+  await fs.delete(PATHS.GOOGLE_AUTH);
+
+  revalidatePath("/settings");
+}
+
+export async function saveGoogleTokensAction(tokens: {
+  access_token: string;
+  refresh_token: string;
+  expiry?: string;
+}) {
+  const fs = await getFS();
+
+  const encryptedTokens = {
+    ...tokens,
+    access_token: encrypt(tokens.access_token),
+    refresh_token: encrypt(tokens.refresh_token),
+  };
+
+  await fs.write(PATHS.GOOGLE_AUTH, JSON.stringify(encryptedTokens, null, 2), {
+    type: "auth",
+  });
+
+  revalidatePath("/settings");
+}

ui/actions/notes.ts

@@ -0,0 +1,51 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { redirect } from "next/navigation";
+import { PATHS } from "@/lib/constants";
+import { getFS } from "@/lib/context";
+import { generateTimestamp } from "@/lib/utils";
+import type { NoteCreate, NoteMetadata, NoteUpdate } from "@/types";
+
+function generateNoteId(): string {
+  const ts = generateTimestamp();
+  return `${ts.slice(0, 8)}_${ts.slice(8)}`;
+}
+
+export async function createNoteAction(data: NoteCreate) {
+  const fs = await getFS();
+
+  const noteId = generateNoteId();
+  const content = data.content || " ";
+
+  const metadata: Omit<NoteMetadata, "path" | "created_at" | "updated_at"> = {
+    type: "note",
+    title: data.title,
+  };
+  await fs.write(`${PATHS.NOTES}/${noteId}.md`, content, metadata);
+
+  revalidatePath("/notes");
+  redirect(`/notes/${noteId}`);
+}
+
+export async function updateNoteAction(id: string, data: NoteUpdate) {
+  const fs = await getFS();
+
+  const content = data.content || " ";
+
+  const metadata: Omit<NoteMetadata, "path" | "created_at" | "updated_at"> = {
+    type: "note",
+    title: data.title ?? "",
+  };
+  await fs.write(`${PATHS.NOTES}/${id}.md`, content, metadata);
+
+  revalidatePath("/notes");
+}
+
+export async function deleteNoteAction(id: string) {
+  const fs = await getFS();
+
+  await fs.delete(`${PATHS.NOTES}/${id}.md`);
+
+  revalidatePath("/notes");
+}

ui/actions/search.ts

@@ -0,0 +1,16 @@
+"use server";
+
+import { getFS } from "@/lib/context";
+import { type SearchAllResult, searchAll } from "@/lib/data/search";
+
+export async function searchAction(
+  query: string,
+  topK = 20,
+): Promise<SearchAllResult[]> {
+  if (!query.trim()) {
+    return [];
+  }
+
+  const fs = await getFS();
+  return searchAll(fs, query, topK);
+}