create-featurebased-architecture 1.0.0 → 1.0.1

package/README.md

@@ -1,17 +1,17 @@
-# create-featurebased-architecture-backend
+# create-featurebased-architecture
 
 A CLI tool to scaffold feature-based architecture projects with Bun, Hono, and React.
 
 ## Usage
 
 ```bash
-npx create-featurebased-architecture-backend
+npx create-featurebased-architecture
 ```
 
 Or with bun:
 
 ```bash
-bunx create-featurebased-architecture-backend
+bunx create-featurebased-architecture
 ```
 
 ## Templates
@@ -23,6 +23,8 @@ bunx create-featurebased-architecture-backend
 | **React** | Feature-based React frontend with Vite |
 | **User Management Backend** | Complete CRUD backend for users with NeonDB |
 | **User Management Frontend** | React frontend for user management |
+| **Ollama Chatbot Backend** | AI chatbot backend with @langchain/ollama and NeonDB |
+| **Ollama Chatbot Frontend** | Chat UI with react-icons for the chatbot backend |
 
 ## Feature-Based Architecture
 
@@ -65,6 +67,30 @@ CREATE TRIGGER update_users_updated_at
   EXECUTE FUNCTION update_updated_at_column();
 ```
 
+### Ollama Chatbot Tables
+
+```sql
+-- Conversations table
+CREATE TABLE conversations (
+  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+  title VARCHAR(200) NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Messages table
+CREATE TABLE messages (
+  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+  conversation_id UUID NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+  role VARCHAR(20) NOT NULL CHECK (role IN ('user', 'assistant', 'system')),
+  content TEXT NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_messages_conversation ON messages(conversation_id);
+CREATE INDEX idx_conversations_updated ON conversations(updated_at DESC);
+```
+
 ## Development
 
 ```bash
@@ -78,12 +104,6 @@ bun run dev
 bun run build
 ```
 
-## Publishing
-
-```bash
-npm publish
-```
-
 ## License
 
 MIT

package/dist/index.js

@@ -740,7 +740,9 @@ var TEMPLATES = {
   "blank-hono": "Blank Hono",
   react: "React",
   "user-management-backend": "User Management System Backend",
-  "user-management-frontend": "User Management System Frontend"
+  "user-management-frontend": "User Management System Frontend",
+  "ollama-chatbot-backend": "Ollama Chatbot Backend",
+  "ollama-chatbot-frontend": "Ollama Chatbot Frontend"
 };
 function copyDir(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
@@ -766,7 +768,7 @@ function replaceInFile(filePath, replacements) {
 }
 async function main() {
   console.clear();
-  oe(import_picocolors3.default.bgCyan(import_picocolors3.default.black(" create-featurebased-architecture-backend ")));
+  oe(import_picocolors3.default.bgCyan(import_picocolors3.default.black(" create-featurebased-architecture ")));
   const project = await he({
     name: () => te({
       message: "Project name:",

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "create-featurebased-architecture",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "CLI to scaffold feature-based architecture projects with Bun, Hono, React",
   "type": "module",
   "bin": {
-    "create-featurebased-architecture-backend": "./dist/index.js"
+    "create-featurebased-architecture": "./dist/index.js"
   },
   "files": [
     "dist",

package/templates/ollama-chatbot-backend/.env.example

@@ -0,0 +1,9 @@
+# Environment Variables
+DATABASE_URL=postgresql://user:password@your-neon-host.neon.tech/dbname?sslmode=require
+PORT=3000
+NODE_ENV=development
+
+# Ollama Cloud Configuration
+OLLAMA_API_KEY=your_ollama_api_key_here
+OLLAMA_BASE_URL=https://api.ollama.com
+OLLAMA_MODEL=gemma3:27b-cloud

package/templates/ollama-chatbot-backend/README.md

@@ -0,0 +1,132 @@
+# {{PROJECT_NAME}}
+
+An Ollama Chatbot backend with feature-based architecture using Bun, Hono, LangChain, and NeonDB.
+
+## Project Structure
+
+```
+src/
+├── config/           # Configuration (env, database, ollama)
+├── features/
+│   ├── chat/         # Chat messaging feature
+│   │   ├── routes.ts
+│   │   ├── controller.ts
+│   │   ├── service.ts
+│   │   ├── types.ts
+│   │   └── schema.ts
+│   └── conversations/ # Conversation management
+│       ├── routes.ts
+│       ├── controller.ts
+│       ├── service.ts
+│       ├── repository.ts
+│       ├── types.ts
+│       └── schema.ts
+├── routes/           # Route aggregation
+├── shared/           # Shared utilities
+└── index.ts
+```
+
+## Getting Started
+
+```bash
+# Install dependencies
+bun install
+
+# Copy environment file
+cp .env.example .env
+
+# Update with your credentials
+
+# Run development server
+bun run dev
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `DATABASE_URL` | NeonDB PostgreSQL connection string |
+| `OLLAMA_API_KEY` | Ollama Cloud API key |
+| `OLLAMA_BASE_URL` | Ollama API URL (default: https://api.ollama.com) |
+| `OLLAMA_MODEL` | Default model (default: gemma3:27b-cloud) |
+| `PORT` | Server port (default: 3000) |
+
+## Database Setup (NeonDB)
+
+Run the following SQL in your NeonDB console:
+
+```sql
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+-- Conversations table
+CREATE TABLE conversations (
+  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+  title VARCHAR(200) NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Messages table
+CREATE TABLE messages (
+  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+  conversation_id UUID NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+  role VARCHAR(20) NOT NULL CHECK (role IN ('user', 'assistant', 'system')),
+  content TEXT NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Indexes
+CREATE INDEX idx_messages_conversation ON messages(conversation_id);
+CREATE INDEX idx_conversations_updated ON conversations(updated_at DESC);
+```
+
+## API Endpoints
+
+### Chat
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/chat` | Send message and get response |
+| POST | `/api/chat/stream` | Stream response (SSE) |
+
+### Conversations
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/conversations` | Get all conversations |
+| GET | `/api/conversations/:id` | Get conversation by ID |
+| GET | `/api/conversations/:id/messages` | Get conversation messages |
+| POST | `/api/conversations` | Create conversation |
+| PUT | `/api/conversations/:id` | Update conversation title |
+| DELETE | `/api/conversations/:id` | Delete conversation |
+
+### Request Examples
+
+**Send Message:**
+```bash
+curl -X POST http://localhost:3000/api/chat \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Hello, how are you?"}'
+```
+
+**Send Message with Specific Model:**
+```bash
+curl -X POST http://localhost:3000/api/chat \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Hello", "model": "llama3:70b-cloud"}'
+```
+
+**Continue Conversation:**
+```bash
+curl -X POST http://localhost:3000/api/chat \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Tell me more", "conversationId": "uuid-here"}'
+```
+
+## Changing the Model
+
+The model can be changed in three ways:
+
+1. **Environment variable:** Set `OLLAMA_MODEL` in `.env`
+2. **Per request:** Pass `model` in the request body
+3. **Code:** Modify `src/config/env.ts`

package/templates/ollama-chatbot-backend/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "bun run --watch src/index.ts",
+    "start": "bun run src/index.ts",
+    "build": "bun build src/index.ts --outdir ./dist --target bun"
+  },
+  "dependencies": {
+    "hono": "^4.11.3",
+    "@neondatabase/serverless": "^0.9.0",
+    "@langchain/ollama": "^0.2.0",
+    "@langchain/core": "^0.2.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  }
+}

package/templates/ollama-chatbot-backend/src/config/database.ts

@@ -0,0 +1,4 @@
+import { neon } from "@neondatabase/serverless";
+import { env } from "./env";
+
+export const sql = neon(env.DATABASE_URL);

package/templates/ollama-chatbot-backend/src/config/env.ts

@@ -0,0 +1,8 @@
+export const env = {
+  DATABASE_URL: process.env.DATABASE_URL || "",
+  PORT: Number(process.env.PORT) || 3000,
+  NODE_ENV: process.env.NODE_ENV || "development",
+  OLLAMA_API_KEY: process.env.OLLAMA_API_KEY || "",
+  OLLAMA_BASE_URL: process.env.OLLAMA_BASE_URL || "https://api.ollama.com",
+  OLLAMA_MODEL: process.env.OLLAMA_MODEL || "gemma3:27b-cloud",
+} as const;

package/templates/ollama-chatbot-backend/src/config/index.ts

@@ -0,0 +1,3 @@
+export * from "./env";
+export * from "./database";
+export * from "./ollama";

package/templates/ollama-chatbot-backend/src/config/ollama.ts

@@ -0,0 +1,14 @@
+import { ChatOllama } from "@langchain/ollama";
+import { env } from "./env";
+
+export const createOllamaClient = (model?: string) => {
+  return new ChatOllama({
+    baseUrl: env.OLLAMA_BASE_URL,
+    model: model || env.OLLAMA_MODEL,
+    headers: {
+      Authorization: `Bearer ${env.OLLAMA_API_KEY}`,
+    },
+  });
+};
+
+export const ollamaClient = createOllamaClient();

package/templates/ollama-chatbot-backend/src/features/chat/controller.ts

@@ -0,0 +1,49 @@
+import type { Context } from "hono";
+import { streamSSE } from "hono/streaming";
+import { chatService } from "./service";
+import { chatRequestSchema, streamChatRequestSchema } from "./schema";
+import { successResponse, errorResponse } from "../../shared/utils/response";
+
+export const chatController = {
+  async sendMessage(c: Context) {
+    try {
+      const body = await c.req.json();
+      const validation = chatRequestSchema.safeParse(body);
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const response = await chatService.sendMessage(validation.data);
+      return successResponse(c, response);
+    } catch (error) {
+      console.error("Chat error:", error);
+      return errorResponse(c, "Failed to process message", 500);
+    }
+  },
+
+  async streamMessage(c: Context) {
+    try {
+      const body = await c.req.json();
+      const validation = streamChatRequestSchema.safeParse(body);
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      return streamSSE(c, async (stream) => {
+        try {
+          for await (const chunk of chatService.streamMessage(validation.data)) {
+            await stream.writeSSE({ data: chunk });
+          }
+        } catch (error) {
+          console.error("Stream error:", error);
+          await stream.writeSSE({ data: JSON.stringify({ error: "Stream failed" }) });
+        }
+      });
+    } catch (error) {
+      console.error("Stream setup error:", error);
+      return errorResponse(c, "Failed to setup stream", 500);
+    }
+  },
+};

package/templates/ollama-chatbot-backend/src/features/chat/index.ts

@@ -0,0 +1,5 @@
+export * from "./routes";
+export * from "./controller";
+export * from "./service";
+export * from "./types";
+export * from "./schema";

package/templates/ollama-chatbot-backend/src/features/chat/routes.ts

@@ -0,0 +1,7 @@
+import { Hono } from "hono";
+import { chatController } from "./controller";
+
+export const chatRoutes = new Hono();
+
+chatRoutes.post("/", chatController.sendMessage);
+chatRoutes.post("/stream", chatController.streamMessage);

package/templates/ollama-chatbot-backend/src/features/chat/schema.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const chatRequestSchema = z.object({
+  message: z.string().min(1, "Message is required"),
+  conversationId: z.string().uuid().optional(),
+  model: z.string().optional(),
+});
+
+export const streamChatRequestSchema = z.object({
+  message: z.string().min(1, "Message is required"),
+  conversationId: z.string().uuid().optional(),
+  model: z.string().optional(),
+});

package/templates/ollama-chatbot-backend/src/features/chat/service.ts

@@ -0,0 +1,91 @@
+import { HumanMessage, AIMessage, SystemMessage } from "@langchain/core/messages";
+import { createOllamaClient, ollamaClient } from "../../config/ollama";
+import { conversationRepository } from "../conversations/repository";
+import type { ChatRequest, ChatResponse, ChatMessage } from "./types";
+
+export const chatService = {
+  async sendMessage(request: ChatRequest): Promise<ChatResponse> {
+    const { message, conversationId, model } = request;
+
+    // Get or create conversation
+    let convId = conversationId;
+    if (!convId) {
+      const conversation = await conversationRepository.create({
+        title: message.slice(0, 50) + (message.length > 50 ? "..." : ""),
+      });
+      convId = conversation.id;
+    }
+
+    // Get conversation history
+    const history = await conversationRepository.getMessages(convId);
+
+    // Build message history for context
+    const messages = history.map((msg) => {
+      if (msg.role === "user") return new HumanMessage(msg.content);
+      if (msg.role === "assistant") return new AIMessage(msg.content);
+      return new SystemMessage(msg.content);
+    });
+
+    // Add current message
+    messages.push(new HumanMessage(message));
+
+    // Save user message
+    await conversationRepository.addMessage(convId, { role: "user", content: message });
+
+    // Get response from Ollama
+    const client = model ? createOllamaClient(model) : ollamaClient;
+    const response = await client.invoke(messages);
+    const assistantMessage = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+
+    // Save assistant response
+    await conversationRepository.addMessage(convId, { role: "assistant", content: assistantMessage });
+
+    return {
+      message: assistantMessage,
+      conversationId: convId,
+      model: model || (await import("../../config/env")).env.OLLAMA_MODEL,
+    };
+  },
+
+  async *streamMessage(request: ChatRequest): AsyncGenerator<string> {
+    const { message, conversationId, model } = request;
+
+    // Get or create conversation
+    let convId = conversationId;
+    if (!convId) {
+      const conversation = await conversationRepository.create({
+        title: message.slice(0, 50) + (message.length > 50 ? "..." : ""),
+      });
+      convId = conversation.id;
+    }
+
+    // Get conversation history
+    const history = await conversationRepository.getMessages(convId);
+
+    // Build message history
+    const messages = history.map((msg) => {
+      if (msg.role === "user") return new HumanMessage(msg.content);
+      if (msg.role === "assistant") return new AIMessage(msg.content);
+      return new SystemMessage(msg.content);
+    });
+
+    messages.push(new HumanMessage(message));
+
+    // Save user message
+    await conversationRepository.addMessage(convId, { role: "user", content: message });
+
+    // Stream response
+    const client = model ? createOllamaClient(model) : ollamaClient;
+    const stream = await client.stream(messages);
+
+    let fullResponse = "";
+    for await (const chunk of stream) {
+      const content = typeof chunk.content === "string" ? chunk.content : "";
+      fullResponse += content;
+      yield JSON.stringify({ content, conversationId: convId }) + "\n";
+    }
+
+    // Save complete assistant response
+    await conversationRepository.addMessage(convId, { role: "assistant", content: fullResponse });
+  },
+};

package/templates/ollama-chatbot-backend/src/features/chat/types.ts

@@ -0,0 +1,22 @@
+export interface ChatMessage {
+  role: "user" | "assistant" | "system";
+  content: string;
+}
+
+export interface ChatRequest {
+  message: string;
+  conversationId?: string;
+  model?: string;
+}
+
+export interface ChatResponse {
+  message: string;
+  conversationId: string;
+  model: string;
+}
+
+export interface StreamChatRequest {
+  message: string;
+  conversationId?: string;
+  model?: string;
+}

package/templates/ollama-chatbot-backend/src/features/conversations/controller.ts

@@ -0,0 +1,114 @@
+import type { Context } from "hono";
+import { conversationService } from "./service";
+import { createConversationSchema, conversationIdSchema } from "./schema";
+import { successResponse, errorResponse } from "../../shared/utils/response";
+
+export const conversationController = {
+  async getAll(c: Context) {
+    try {
+      const conversations = await conversationService.getAllConversations();
+      return successResponse(c, conversations);
+    } catch (error) {
+      return errorResponse(c, "Failed to fetch conversations", 500);
+    }
+  },
+
+  async getById(c: Context) {
+    try {
+      const { id } = c.req.param();
+      const validation = conversationIdSchema.safeParse({ id });
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const conversation = await conversationService.getConversationById(id);
+      if (!conversation) {
+        return errorResponse(c, "Conversation not found", 404);
+      }
+
+      return successResponse(c, conversation);
+    } catch (error) {
+      return errorResponse(c, "Failed to fetch conversation", 500);
+    }
+  },
+
+  async getMessages(c: Context) {
+    try {
+      const { id } = c.req.param();
+      const validation = conversationIdSchema.safeParse({ id });
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const messages = await conversationService.getConversationMessages(id);
+      return successResponse(c, messages);
+    } catch (error) {
+      return errorResponse(c, "Failed to fetch messages", 500);
+    }
+  },
+
+  async create(c: Context) {
+    try {
+      const body = await c.req.json();
+      const validation = createConversationSchema.safeParse(body);
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const conversation = await conversationService.createConversation(validation.data);
+      return successResponse(c, conversation, "Conversation created", 201);
+    } catch (error) {
+      return errorResponse(c, "Failed to create conversation", 500);
+    }
+  },
+
+  async updateTitle(c: Context) {
+    try {
+      const { id } = c.req.param();
+      const idValidation = conversationIdSchema.safeParse({ id });
+
+      if (!idValidation.success) {
+        return errorResponse(c, idValidation.error.errors[0].message);
+      }
+
+      const body = await c.req.json();
+      const validation = createConversationSchema.safeParse(body);
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const conversation = await conversationService.updateConversationTitle(id, validation.data.title);
+      if (!conversation) {
+        return errorResponse(c, "Conversation not found", 404);
+      }
+
+      return successResponse(c, conversation, "Conversation updated");
+    } catch (error) {
+      return errorResponse(c, "Failed to update conversation", 500);
+    }
+  },
+
+  async delete(c: Context) {
+    try {
+      const { id } = c.req.param();
+      const validation = conversationIdSchema.safeParse({ id });
+
+      if (!validation.success) {
+        return errorResponse(c, validation.error.errors[0].message);
+      }
+
+      const deleted = await conversationService.deleteConversation(id);
+      if (!deleted) {
+        return errorResponse(c, "Conversation not found", 404);
+      }
+
+      return successResponse(c, null, "Conversation deleted");
+    } catch (error) {
+      return errorResponse(c, "Failed to delete conversation", 500);
+    }
+  },
+};

package/templates/ollama-chatbot-backend/src/features/conversations/index.ts

@@ -0,0 +1,6 @@
+export * from "./routes";
+export * from "./controller";
+export * from "./service";
+export * from "./repository";
+export * from "./types";
+export * from "./schema";

package/templates/ollama-chatbot-backend/src/features/conversations/repository.ts

@@ -0,0 +1,61 @@
+import { sql } from "../../config/database";
+import type { Conversation, Message, CreateConversationDto, AddMessageDto } from "./types";
+
+export const conversationRepository = {
+  async findAll(): Promise<Conversation[]> {
+    const result = await sql`SELECT * FROM conversations ORDER BY updated_at DESC`;
+    return result as Conversation[];
+  },
+
+  async findById(id: string): Promise<Conversation | null> {
+    const result = await sql`SELECT * FROM conversations WHERE id = ${id}`;
+    return (result[0] as Conversation) || null;
+  },
+
+  async create(data: CreateConversationDto): Promise<Conversation> {
+    const result = await sql`
+      INSERT INTO conversations (title)
+      VALUES (${data.title})
+      RETURNING *
+    `;
+    return result[0] as Conversation;
+  },
+
+  async updateTitle(id: string, title: string): Promise<Conversation | null> {
+    const result = await sql`
+      UPDATE conversations
+      SET title = ${title}, updated_at = CURRENT_TIMESTAMP
+      WHERE id = ${id}
+      RETURNING *
+    `;
+    return (result[0] as Conversation) || null;
+  },
+
+  async delete(id: string): Promise<boolean> {
+    // Delete messages first
+    await sql`DELETE FROM messages WHERE conversation_id = ${id}`;
+    const result = await sql`DELETE FROM conversations WHERE id = ${id} RETURNING id`;
+    return result.length > 0;
+  },
+
+  async getMessages(conversationId: string): Promise<Message[]> {
+    const result = await sql`
+      SELECT * FROM messages 
+      WHERE conversation_id = ${conversationId} 
+      ORDER BY created_at ASC
+    `;
+    return result as Message[];
+  },
+
+  async addMessage(conversationId: string, data: AddMessageDto): Promise<Message> {
+    // Update conversation timestamp
+    await sql`UPDATE conversations SET updated_at = CURRENT_TIMESTAMP WHERE id = ${conversationId}`;
+
+    const result = await sql`
+      INSERT INTO messages (conversation_id, role, content)
+      VALUES (${conversationId}, ${data.role}, ${data.content})
+      RETURNING *
+    `;
+    return result[0] as Message;
+  },
+};