docs: replace README with Next.js boilerplate template

Updated README.md from a detailed OllaHub project description to the standard Next.js getting started template, likely to initialize or reset the project as a Next.js application.

app/api/ollama/chat/route.ts

@@ -0,0 +1,62 @@
+import { NextRequest } from "next/server";
+import { chatWithStream } from "@/lib/ollama";
+import { convertToOllamaMessages } from "@/lib/chat";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(req: NextRequest) {
+  try {
+    const { model, messages, options, system } = await req.json();
+
+    if (!model || !messages?.length) {
+      return new Response("Missing model or messages", { status: 400 });
+    }
+
+    const stream = new ReadableStream({
+      async start(controller) {
+        try {
+          const ollamaMessages = convertToOllamaMessages(messages);
+          const response = await chatWithStream(
+            model,
+            ollamaMessages,
+            options,
+            system
+          );
+
+          for await (const chunk of response) {
+            const token = chunk.message?.content || "";
+            if (token) {
+              controller.enqueue(
+                new TextEncoder().encode(JSON.stringify({ token }) + "\n")
+              );
+            }
+          }
+
+          controller.enqueue(
+            new TextEncoder().encode(JSON.stringify({ done: true }) + "\n")
+          );
+          controller.close();
+        } catch (error) {
+          console.error("Chat streaming error:", error);
+          controller.enqueue(
+            new TextEncoder().encode(
+              JSON.stringify({ error: "Failed to generate response" }) + "\n"
+            )
+          );
+          controller.close();
+        }
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  } catch (error) {
+    console.error("Chat API error:", error);
+    return new Response("Internal server error", { status: 500 });
+  }
+}

app/api/ollama/health/route.ts

@@ -0,0 +1,18 @@
+import { NextResponse } from "next/server";
+import { listModelsViaSdk, listModelsViaHttp } from "@/lib/ollama";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  try {
+    try {
+      await listModelsViaSdk();
+      return NextResponse.json({ ok: true });
+    } catch {
+      await listModelsViaHttp();
+      return NextResponse.json({ ok: true });
+    }
+  } catch {
+    return NextResponse.json({ ok: false });
+  }
+}

app/api/ollama/models/route.ts

@@ -0,0 +1,44 @@
+import { NextResponse } from "next/server";
+import { listModelsViaSdk, listModelsViaHttp } from "@/lib/ollama";
+import {
+  estimateCpuVram,
+  inferDevice,
+  inferQuantization,
+  mockModels,
+  type ModelInfo,
+} from "@/lib/models";
+
+export const dynamic = "force-dynamic";
+
+function normalizeModel(model: any): ModelInfo {
+  const name: string = model?.model || model?.name || "unknown";
+  const sizeBytes: number = model?.size || 0;
+  const sizeGB = Number(Math.max(0.1, sizeBytes / 1024 ** 3).toFixed(2));
+  const quantization = inferQuantization(name);
+  const device = inferDevice(model?.details || name);
+  const { cpuPct, vramGB } = estimateCpuVram({ sizeGB, quantization, device });
+  return {
+    id: name,
+    name,
+    sizeGB,
+    quantization,
+    device,
+    estCpuUsagePct: cpuPct,
+    estVramGB: vramGB,
+  };
+}
+
+export async function GET() {
+  try {
+    let models: any[] = [];
+    try {
+      models = await listModelsViaSdk();
+    } catch {
+      models = await listModelsViaHttp();
+    }
+    const normalized = models.map((m) => normalizeModel(m));
+    return NextResponse.json({ offline: false, models: normalized });
+  } catch (e) {
+    return NextResponse.json({ offline: true, models: mockModels });
+  }
+}

app/api/ollama/pull/route.ts

@@ -0,0 +1,54 @@
+import { NextRequest } from "next/server";
+import { pullModel } from "@/lib/ollama";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(req: NextRequest) {
+  try {
+    const { model } = await req.json();
+
+    if (!model) {
+      return new Response("Missing model", { status: 400 });
+    }
+
+    const stream = new ReadableStream({
+      async start(controller) {
+        try {
+          const response = await pullModel(model);
+
+          for await (const chunk of response) {
+            controller.enqueue(
+              new TextEncoder().encode(JSON.stringify(chunk) + "\n"),
+            );
+          }
+
+          controller.enqueue(
+            new TextEncoder().encode(
+              JSON.stringify({ status: "success" }) + "\n",
+            ),
+          );
+          controller.close();
+        } catch (error) {
+          console.error("Pull streaming error:", error);
+          controller.enqueue(
+            new TextEncoder().encode(
+              JSON.stringify({ error: "Failed to pull model" }) + "\n",
+            ),
+          );
+          controller.close();
+        }
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  } catch (error) {
+    console.error("Pull API error:", error);
+    return new Response("Internal server error", { status: 500 });
+  }
+}

app/globals.css

@@ -0,0 +1,33 @@
+@import "tailwindcss";
+
+:root {
+  --background: #ffffff;
+  --foreground: #0b0c0f;
+  --accent: #2563eb; /* blue-600 */
+  --accent-foreground: #ffffff;
+  --border: #e5e7ef;
+  --surface: #f6f7fb;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-accent: var(--accent);
+  --color-border: var(--border);
+  --font-sans: var(--font-inter);
+}
+
+.dark {
+  --background: #0b0c0f;
+  --foreground: #e6e8ef;
+  --accent: #3b82f6; /* blue-500 */
+  --accent-foreground: #0b0c0f;
+  --border: #2a2f3a;
+  --surface: #12141a;
+}
+
+body {
+  background: var(--background);
+  color: var(--foreground);
+  font-family: var(--font-inter), ui-sans-serif, system-ui;
+}

app/layout.tsx

@@ -0,0 +1,25 @@
+import type { Metadata } from "next";
+import { Inter } from "next/font/google";
+import "./globals.css";
+import { ThemeProvider } from "../components/theme-provider";
+
+const inter = Inter({ subsets: ["latin"], variable: "--font-inter" });
+
+export const metadata: Metadata = {
+  title: "Create Next App",
+  description: "Generated by create next app",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <body className={`${inter.variable} antialiased`}>
+        <ThemeProvider>{children}</ThemeProvider>
+      </body>
+    </html>
+  );
+}

app/page.tsx

@@ -0,0 +1,21 @@
+import { ModeToggle } from "@/components/mode-toggle";
+import { ChatContainer } from "@/components/chat/ChatContainer";
+import { ClientHome } from "@/components/ClientHome";
+
+async function fetchModels() {
+  try {
+    const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000";
+    const res = await fetch(`${baseUrl}/api/ollama/models`, {
+      cache: "no-store",
+    });
+    if (!res.ok) return { offline: true, models: [] };
+    return res.json();
+  } catch {
+    return { offline: true, models: [] };
+  }
+}
+
+export default async function Home() {
+  const { offline, models } = await fetchModels();
+  return <ClientHome offline={offline} models={models} />;
+}