@hiai-gg/hiai-docs 0.0.1

package/frontend/src/lib/api/client.ts

@@ -0,0 +1,57 @@
+interface FetchOptions extends RequestInit {
+	timeout?: number;
+}
+
+export class ApiError extends Error {
+	status: number;
+	constructor(message: string, status: number) {
+		super(message);
+		this.name = "ApiError";
+		this.status = status;
+	}
+}
+
+export async function apiFetch<T>(
+	path: string,
+	options: FetchOptions = {},
+	// Optional fetcher — pass SvelteKit's `load`/`fetch` to inherit cookies
+	// and bypass the `window.fetch` warning. Falls back to the global
+	// `fetch` when called from the browser outside SvelteKit.
+	fetcher: typeof fetch = fetch,
+): Promise<T> {
+	const { timeout = 10000, body, ...fetchOptions } = options;
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+	const headers: Record<string, string> = {};
+	if (body && !(body instanceof FormData)) {
+		headers["Content-Type"] = "application/json";
+	}
+
+	try {
+		const response = await fetcher(path, {
+			...fetchOptions,
+			body,
+			signal: controller.signal,
+			headers: {
+				...headers,
+				...fetchOptions.headers,
+			},
+			credentials: "include",
+		});
+
+		if (!response.ok) {
+			const error = await response
+				.json()
+				.catch(() => ({ error: response.statusText }));
+			throw new ApiError(
+				error.error ?? `HTTP ${response.status}`,
+				response.status,
+			);
+		}
+
+		return response.json() as Promise<T>;
+	} finally {
+		clearTimeout(timeoutId);
+	}
+}

package/frontend/src/lib/api/documents.ts

@@ -0,0 +1,83 @@
+import { apiFetch } from "./client";
+
+export interface Document {
+	id: string;
+	title: string;
+	content: string;
+	contentJson?: unknown;
+	folderId?: string | null;
+	folderName?: string;
+	tags?: Array<{ id: string; name: string; color: string }>;
+	excerpt?: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface DocumentListResponse {
+	items: Document[];
+	total: number;
+	page: number;
+	limit: number;
+}
+
+export function listDocuments(params?: {
+	folderId?: string;
+	tag?: string;
+	page?: number;
+	limit?: number;
+}): Promise<DocumentListResponse> {
+	const searchParams = new URLSearchParams();
+	if (params?.folderId) searchParams.set("folderId", params.folderId);
+	if (params?.tag) searchParams.set("tag", params.tag);
+	if (params?.page) searchParams.set("page", String(params.page));
+	if (params?.limit) searchParams.set("limit", String(params.limit));
+	const qs = searchParams.toString();
+	return apiFetch(`/api/documents${qs ? `?${qs}` : ""}`);
+}
+
+export function getDocument(
+	id: string,
+	fetcher?: typeof fetch,
+): Promise<Document> {
+	return apiFetch(`/api/documents/${id}`, {}, fetcher);
+}
+
+export function createDocument(data: {
+	title: string;
+	content?: string;
+	folderId?: string;
+}): Promise<Document> {
+	return apiFetch("/api/documents", {
+		method: "POST",
+		body: JSON.stringify(data),
+	});
+}
+
+export function updateDocument(
+	id: string,
+	data: {
+		title?: string;
+		content?: string;
+		folderId?: string | null;
+		contentJson?: unknown;
+	},
+): Promise<Document> {
+	return apiFetch(`/api/documents/${id}`, {
+		method: "PATCH",
+		body: JSON.stringify(data),
+	});
+}
+
+export function deleteDocument(id: string): Promise<void> {
+	return apiFetch(`/api/documents/${id}`, { method: "DELETE" });
+}
+
+export function importDocument(
+	file: File,
+	folderId?: string,
+): Promise<Document> {
+	const formData = new FormData();
+	formData.append("file", file);
+	if (folderId) formData.append("folderId", folderId);
+	return apiFetch("/api/documents/import", { method: "POST", body: formData });
+}

package/frontend/src/lib/api/folders.ts

@@ -0,0 +1,180 @@
+import type {
+	CreateFolderData,
+	Document,
+	Folder,
+	UpdateFolderData,
+} from "$lib/types.js";
+import { apiFetch } from "./client";
+
+interface FolderWire {
+	id: string;
+	name: string;
+	parentId: string | null;
+	ownerId?: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+interface DocumentWire {
+	id: string;
+	title: string;
+	content?: string;
+	contentJson?: unknown;
+	metadata?: unknown;
+	folderId: string | null;
+	createdAt: string;
+	updatedAt: string;
+}
+
+function toFolder(f: FolderWire): Folder {
+	return {
+		id: f.id,
+		name: f.name,
+		parentId: f.parentId,
+		documentCount: 0,
+		children: [],
+		documents: [],
+		createdAt: f.createdAt,
+		updatedAt: f.updatedAt,
+	};
+}
+
+function toDocument(d: DocumentWire, folderName = ""): Document {
+	const content = d.content ?? "";
+	return {
+		id: d.id,
+		title: d.title,
+		content,
+		folderId: d.folderId,
+		folderName,
+		tags: [],
+		createdAt: d.createdAt,
+		updatedAt: d.updatedAt,
+		excerpt: content.length > 200 ? `${content.slice(0, 200)}…` : content,
+	};
+}
+
+/** Get a single folder by ID. Backend: `GET /api/folders/:id`. */
+export async function getFolder(id: string): Promise<Folder> {
+	const row: FolderWire = await apiFetch<FolderWire>(
+		`/api/folders/${encodeURIComponent(id)}`,
+	);
+	return toFolder(row);
+}
+
+/**
+ * List folders under a given parent.
+ *
+ * - `listFolders(null)` returns a single-element array whose first element is a
+ *   synthetic root folder whose `children` are the user's top-level folders.
+ *   This matches the contract that `FolderTree.svelte` depends on
+ *   (`result[0].children`).
+ * - `listFolders(parentId)` returns the flat immediate children of `parentId`.
+ *
+ * The backend returns flat rows keyed by `parentId`; the tree shape is
+ * composed client-side.
+ */
+export async function listFolders(
+	parentId: string | null = null,
+): Promise<Folder[]> {
+	const qs = parentId ? `?parentId=${encodeURIComponent(parentId)}` : "";
+	const rows: FolderWire[] = await apiFetch<FolderWire[]>(`/api/folders${qs}`);
+	const folders = rows.map(toFolder);
+
+	if (parentId === null) {
+		const now = new Date().toISOString();
+		return [
+			{
+				id: "root",
+				name: "Workspace",
+				parentId: null,
+				documentCount: 0,
+				children: folders,
+				documents: [],
+				createdAt: now,
+				updatedAt: now,
+			},
+		];
+	}
+
+	return folders;
+}
+
+/**
+ * Get the breadcrumb path from the workspace root down to the given folder.
+ *
+ * Walks up the parent chain via repeated `GET /api/folders/:id` calls and
+ * reverses the collected ancestors so the returned array is ordered
+ * root-first. Includes a cycle guard so a malformed parent chain cannot loop
+ * forever.
+ */
+export async function getFolderPath(
+	folderId: string,
+): Promise<Array<{ id: string; name: string }>> {
+	const path: Array<{ id: string; name: string }> = [];
+	const visited = new Set<string>();
+	let currentId: string | null = folderId;
+
+	while (currentId && !visited.has(currentId)) {
+		visited.add(currentId);
+		const folder: FolderWire = await apiFetch<FolderWire>(
+			`/api/folders/${encodeURIComponent(currentId)}`,
+		);
+		path.unshift({ id: folder.id, name: folder.name });
+		currentId = folder.parentId;
+	}
+
+	return path;
+}
+
+/** Create a new folder. Backend: `POST /api/folders`. */
+export async function createFolder(data: CreateFolderData): Promise<Folder> {
+	const created: FolderWire = await apiFetch<FolderWire>("/api/folders", {
+		method: "POST",
+		body: JSON.stringify(data),
+	});
+	return toFolder(created);
+}
+
+/** Update a folder (rename or move). Backend: `PATCH /api/folders/:id`. */
+export async function updateFolder(
+	id: string,
+	data: UpdateFolderData,
+): Promise<Folder> {
+	const updated: FolderWire = await apiFetch<FolderWire>(
+		`/api/folders/${encodeURIComponent(id)}`,
+		{
+			method: "PATCH",
+			body: JSON.stringify(data),
+		},
+	);
+	return toFolder(updated);
+}
+
+/** Delete a folder. Backend: `DELETE /api/folders/:id`. */
+export async function deleteFolder(id: string): Promise<void> {
+	await apiFetch(`/api/folders/${encodeURIComponent(id)}`, {
+		method: "DELETE",
+	});
+}
+
+/**
+ * Duplicate a document. The new copy is suffixed with ` (Copy)` on the title.
+ * Backend: `POST /api/documents/:id/duplicate`.
+ */
+export async function duplicateDocument(docId: string): Promise<Document> {
+	const created: DocumentWire = await apiFetch<DocumentWire>(
+		`/api/documents/${encodeURIComponent(docId)}/duplicate`,
+		{
+			method: "POST",
+		},
+	);
+	return toDocument(created);
+}
+
+/** Delete a document. Backend: `DELETE /api/documents/:id`. */
+export async function deleteDocument(docId: string): Promise<void> {
+	await apiFetch(`/api/documents/${encodeURIComponent(docId)}`, {
+		method: "DELETE",
+	});
+}

package/frontend/src/lib/api/search.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import { highlightTerms, stripMarks } from "./search";
+
+describe("search helpers", () => {
+	describe("stripMarks", () => {
+		test("removes <mark> tags", () => {
+			expect(stripMarks("hello <mark>world</mark>")).toBe("hello world");
+		});
+
+		test("removes multiple <mark> tags", () => {
+			expect(stripMarks("<mark>a</mark> and <mark>b</mark>")).toBe("a and b");
+		});
+
+		test("returns plain text unchanged", () => {
+			expect(stripMarks("no marks here")).toBe("no marks here");
+		});
+
+		test("handles empty string", () => {
+			expect(stripMarks("")).toBe("");
+		});
+	});
+
+	describe("highlightTerms", () => {
+		test("wraps matching terms in <mark> tags", () => {
+			const result = highlightTerms("Hello world", "Hello");
+			expect(result).toBe("<mark>Hello</mark> world");
+		});
+
+		test("is case-insensitive", () => {
+			const result = highlightTerms("Hello HELLO hello", "hello");
+			expect(result).toContain("<mark>Hello</mark>");
+			expect(result).toContain("<mark>HELLO</mark>");
+			expect(result).toContain("<mark>hello</mark>");
+		});
+
+		test("handles multiple search terms", () => {
+			const result = highlightTerms("foo bar baz", "foo baz");
+			expect(result).toContain("<mark>foo</mark>");
+			expect(result).toContain("<mark>baz</mark>");
+		});
+
+		test("escapes regex special characters", () => {
+			const result = highlightTerms("price is $100 (USD)", "$100");
+			expect(result).toContain("<mark>$100</mark>");
+		});
+
+		test("returns original text for empty query", () => {
+			expect(highlightTerms("hello", "")).toBe("hello");
+			expect(highlightTerms("hello", "   ")).toBe("hello");
+		});
+	});
+});

package/frontend/src/lib/api/search.ts

@@ -0,0 +1,128 @@
+import { apiFetch } from "$lib/api/client";
+
+// --- Types -------------------------------------------------------------------
+
+export interface SearchResult {
+	id: string;
+	title: string;
+	snippet: string;
+	score: number;
+	folder_id: string | null;
+	folder_name?: string | null;
+	created_at: string;
+	updated_at: string;
+	tags?: Array<{ id: string; name: string; color: string | null }>;
+}
+
+export interface SearchResponse {
+	items: SearchResult[];
+	total: number;
+	page: number;
+	limit: number;
+}
+
+export interface SearchSuggestion {
+	id: string;
+	title: string;
+	score: number;
+}
+
+export interface FilterOptions {
+	folders: string[];
+	tags: Array<{ id: string; name: string; color: string | null }>;
+}
+
+// --- Public API --------------------------------------------------------------
+
+export type SearchSort =
+	| "relevance"
+	| "date_desc"
+	| "date_asc"
+	| "name_asc"
+	| "name_desc";
+
+/**
+ * Full hybrid search (text + semantic).
+ */
+export async function search(
+	query: string,
+	page = 1,
+	limit = 20,
+	sort: SearchSort = "relevance",
+	filters?: {
+		folder?: string;
+		tags?: string[];
+		dateFrom?: string;
+		dateTo?: string;
+	},
+): Promise<SearchResponse> {
+	if (!query.trim()) {
+		return { items: [], total: 0, page: 1, limit };
+	}
+	const params = new URLSearchParams({
+		q: query,
+		page: String(page),
+		limit: String(limit),
+	});
+	if (sort !== "relevance") params.set("sort", sort);
+	if (filters?.folder) params.set("folder", filters.folder);
+	if (filters?.tags && filters.tags.length > 0)
+		params.set("tags", filters.tags.join(","));
+	if (filters?.dateFrom) params.set("dateFrom", filters.dateFrom);
+	if (filters?.dateTo) params.set("dateTo", filters.dateTo);
+	return apiFetch(`/api/search?${params}`);
+}
+
+/**
+ * Quick title-only search for autocomplete / suggestions.
+ * Returns top 5 matches.
+ */
+export async function searchSuggest(
+	query: string,
+): Promise<SearchSuggestion[]> {
+	if (!query.trim()) return [];
+	const params = new URLSearchParams({ q: query });
+	return apiFetch(`/api/search/suggest?${params}`);
+}
+
+/**
+ * Get available filter options (folders and tags for the current user).
+ */
+export async function getFilterOptions(): Promise<FilterOptions> {
+	try {
+		const [folders, tags] = await Promise.all([
+			apiFetch<Array<{ id: string; name: string }>>("/api/folders"),
+			apiFetch<Array<{ id: string; name: string; color: string | null }>>(
+				"/api/tags",
+			),
+		]);
+		return {
+			folders: folders.map((f) => f.name),
+			tags,
+		};
+	} catch {
+		return { folders: [], tags: [] };
+	}
+}
+
+// --- Text helpers (exported for component use) ------------------------------
+
+/** Strip existing <mark> tags from a string. */
+export function stripMarks(html: string): string {
+	return html.replace(/<\/?mark>/g, "");
+}
+
+/** Wrap occurrences of query terms in <mark> tags. */
+export function highlightTerms(text: string, query: string): string {
+	if (!query.trim()) return text;
+
+	const terms = query
+		.split(/\s+/)
+		.filter(Boolean)
+		.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+
+	if (terms.length === 0) return text;
+
+	const regex = new RegExp(`(${terms.join("|")})`, "gi");
+	return text.replace(regex, "<mark>$1</mark>");
+}

package/frontend/src/lib/api/settings.ts

@@ -0,0 +1,95 @@
+import { authClient } from "$lib/auth-client";
+import { apiFetch } from "./client.js";
+
+export interface UserProfile {
+	id: string;
+	name: string;
+	email: string;
+	avatar: string | null;
+}
+
+export interface EmbeddingConfig {
+	provider: "ollama" | "openrouter" | "voyage";
+	model: string;
+	fallbackProvider: string | null;
+	fallbackModel: string | null;
+}
+
+// --- Profile (uses Better Auth session) ---
+
+export async function getProfile(): Promise<UserProfile> {
+	try {
+		const session = await apiFetch<{ user?: UserProfile }>(
+			"/api/auth/get-session",
+		);
+		if (session.user?.name || session.user?.email) {
+			return session.user;
+		}
+	} catch {
+		/* fall through */
+	}
+
+	// Fallback: try client-side getSession (works even when server-side
+	// /api/auth/session returns empty, e.g. for newly registered users).
+	const { data } = await authClient.getSession();
+	if (data?.user) {
+		return {
+			id: data.user.id ?? "",
+			name: data.user.name ?? "User",
+			email: data.user.email ?? "",
+			avatar: null,
+		};
+	}
+	return { id: "", name: "User", email: "", avatar: null };
+}
+
+export async function updateProfile(data: {
+	name?: string;
+}): Promise<UserProfile> {
+	return apiFetch("/api/auth/update-user", {
+		method: "POST",
+		body: JSON.stringify({ name: data.name }),
+	});
+}
+
+// --- Embedding Config (stored in localStorage for OSS simplicity) ---
+
+const EMBEDDING_KEY = "hiai-docs:embedding-config";
+
+export function getEmbeddingConfig(): EmbeddingConfig {
+	if (typeof window === "undefined") {
+		return {
+			provider: "ollama",
+			model: "nomic-embed-text",
+			fallbackProvider: "openrouter",
+			fallbackModel: "openai/text-embedding-3-small",
+		};
+	}
+	try {
+		const stored = localStorage.getItem(EMBEDDING_KEY);
+		if (stored) return JSON.parse(stored);
+	} catch {
+		/* ignore */
+	}
+	return {
+		provider: "ollama",
+		model: "nomic-embed-text",
+		fallbackProvider: "openrouter",
+		fallbackModel: "openai/text-embedding-3-small",
+	};
+}
+
+export function updateEmbeddingConfig(
+	data: Partial<EmbeddingConfig>,
+): EmbeddingConfig {
+	const current = getEmbeddingConfig();
+	const updated = { ...current, ...data };
+	localStorage.setItem(EMBEDDING_KEY, JSON.stringify(updated));
+	return updated;
+}
+
+// --- Delete Account ---
+
+export async function deleteAccount(): Promise<void> {
+	await apiFetch("/api/auth/delete-user", { method: "POST" });
+}

package/frontend/src/lib/api/share.ts

@@ -0,0 +1,71 @@
+import { apiFetch } from "./client.js";
+
+export interface ShareLink {
+	id: string;
+	token: string;
+	documentId?: string;
+	folderId?: string;
+	hasPassword: boolean;
+	expiresAt?: string | null;
+	createdAt: string;
+	title?: string;
+	type?: "document" | "folder";
+	guestEmails: string[];
+}
+
+export interface ShareContent {
+	type: "document" | "folder";
+	data: unknown;
+}
+
+export interface CreateShareLinkInput {
+	documentId?: string;
+	folderId?: string;
+	password?: string;
+	expiresIn?: "1h" | "1d" | "7d" | "30d" | "never";
+	guestEmails?: string[];
+}
+
+// --- Share Links ---
+
+export function createShareLink(
+	data: CreateShareLinkInput,
+): Promise<ShareLink> {
+	if (!data.documentId) {
+		return Promise.reject(new Error("createShareLink: documentId is required"));
+	}
+	return apiFetch("/api/share", { method: "POST", body: JSON.stringify(data) });
+}
+
+export function listShareLinks(params?: { documentId?: string }): Promise<{
+	links: ShareLink[];
+}> {
+	const qs = params?.documentId ? `?documentId=${params.documentId}` : "";
+	return apiFetch(`/api/share${qs}`);
+}
+
+export function getShareLink(token: string): Promise<ShareContent> {
+	if (!token) {
+		return Promise.reject(new Error("getShareLink: token is required"));
+	}
+	return apiFetch(`/api/share/${token}`);
+}
+
+export function revokeShareLink(id: string): Promise<void> {
+	return apiFetch(`/api/share/${id}`, { method: "DELETE" });
+}
+
+// --- Guests ---
+
+export function addGuest(linkId: string, email: string): Promise<ShareLink> {
+	return apiFetch(`/api/share/${linkId}/guests`, {
+		method: "POST",
+		body: JSON.stringify({ email }),
+	});
+}
+
+export function removeGuest(linkId: string, email: string): Promise<ShareLink> {
+	return apiFetch(`/api/share/${linkId}/guests/${encodeURIComponent(email)}`, {
+		method: "DELETE",
+	});
+}