openwork-agent 1.0.0

package/src/templates/java/basic/src/main/java/com/{{snakeCase projectName}}/{{projectName}}/{{pascalCase projectName}}Application.java.hbs

@@ -0,0 +1,16 @@
+package com.{{snakeCase projectName}}.{{projectName}};
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
+
+@SpringBootApplication
+@EnableMongoRepositories
+public class {{pascalCase projectName}}Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run({{pascalCase projectName}}Application.class, args);
+        System.out.println("🚀 " + "{{pascalCase projectName}}" + " application started successfully!");
+    }
+
+}

package/src/templates/node/basic/src/config/database.ts.hbs

@@ -0,0 +1,18 @@
+import mongoose from 'mongoose';
+
+export async function connectDatabase(): Promise<void> {
+  const mongoUri = process.env.MONGODB_URI || 'mongodb://localhost:27017/{{projectName}}';
+  
+  try {
+    await mongoose.connect(mongoUri);
+    console.log('✅ Connected to MongoDB');
+  } catch (error) {
+    console.error('❌ MongoDB connection error:', error);
+    throw error;
+  }
+}
+
+export const disconnectDatabase = (): void => {
+  mongoose.connection.close();
+  console.log('🔌 Disconnected from MongoDB');
+};

package/src/templates/node/basic/src/controllers/UserController.ts.hbs

@@ -0,0 +1,98 @@
+import { Request, Response } from 'express';
+
+export class UserController {
+  async getUsers(req: Request, res: Response) {
+    try {
+      // TODO: Implement user retrieval logic
+      const users = [];
+      res.json({
+        success: true,
+        data: users
+      });
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: 'Failed to fetch users'
+      });
+    }
+  }
+
+  async getUser(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      // TODO: Implement user retrieval by ID
+      const user = null;
+      
+      if (!user) {
+        return res.status(404).json({
+          success: false,
+          message: 'User not found'
+        });
+      }
+
+      res.json({
+        success: true,
+        data: user
+      });
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: 'Failed to fetch user'
+      });
+    }
+  }
+
+  async createUser(req: Request, res: Response) {
+    try {
+      const userData = req.body;
+      // TODO: Implement user creation logic
+      const newUser = { id: 1, ...userData };
+      
+      res.status(201).json({
+        success: true,
+        data: newUser
+      });
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: 'Failed to create user'
+      });
+    }
+  }
+
+  async updateUser(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      const userData = req.body;
+      // TODO: Implement user update logic
+      const updatedUser = { id, ...userData };
+      
+      res.json({
+        success: true,
+        data: updatedUser
+      });
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: 'Failed to update user'
+      });
+    }
+  }
+
+  async deleteUser(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      // TODO: Implement user deletion logic
+      
+      res.json({
+        success: true,
+        message: 'User deleted successfully'
+      });
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        message: 'Failed to delete user'
+      });
+    }
+  }
+}

package/src/templates/node/basic/src/index.ts.hbs

@@ -0,0 +1,45 @@
+import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import dotenv from 'dotenv';
+
+import { connectDatabase } from './config/database';
+import { errorHandler } from './middleware/errorHandler';
+import routes from './routes';
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// Middleware
+app.use(helmet());
+app.use(cors());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Routes
+app.use('/api', routes);
+
+// Health check
+app.get('/health', (req, res) => {
+  res.json({ status: 'OK', timestamp: new Date().toISOString() });
+});
+
+// Error handling
+app.use(errorHandler);
+
+// Database connection and server start
+async function startServer() {
+  try {
+    await connectDatabase();
+    app.listen(PORT, () => {
+      console.log(`🚀 Server running on port ${PORT}`);
+    });
+  } catch (error) {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+  }
+}
+
+startServer();

package/src/templates/node/basic/src/middleware/errorHandler.ts.hbs

@@ -0,0 +1,33 @@
+import { Request, Response, NextFunction } from 'express';
+
+export interface ApiError extends Error {
+  statusCode?: number;
+  isOperational?: boolean;
+}
+
+export const createError = (message: string, statusCode: number): ApiError => {
+  const error = new Error(message) as ApiError;
+  error.statusCode = statusCode;
+  error.isOperational = true;
+  return error;
+};
+
+export const errorHandler = (
+  error: ApiError,
+  req: Request,
+  res: Response,
+  next: NextFunction
+): void => {
+  const statusCode = error.statusCode || 500;
+  const message = error.message || 'Internal Server Error';
+
+  console.error('Error:', error);
+
+  res.status(statusCode).json({
+    success: false,
+    error: {
+      message,
+      ...(process.env.NODE_ENV === 'development' && { stack: error.stack })
+    }
+  });
+};

package/src/templates/node/basic/src/routes/index.ts.hbs

@@ -0,0 +1,42 @@
+import { Router } from 'express';
+import { UserController } from '../controllers/UserController';
+
+const router = Router();
+const userController = new UserController();
+
+/**
+ * @route   GET /api/users
+ * @desc    Get all users
+ * @access  Public
+ */
+router.get('/users', userController.getUsers);
+
+/**
+ * @route   GET /api/users/:id
+ * @desc    Get user by ID
+ * @access  Public
+ */
+router.get('/users/:id', userController.getUser);
+
+/**
+ * @route   POST /api/users
+ * @desc    Create a new user
+ * @access  Public
+ */
+router.post('/users', userController.createUser);
+
+/**
+ * @route   PUT /api/users/:id
+ * @desc    Update user by ID
+ * @access  Public
+ */
+router.put('/users/:id', userController.updateUser);
+
+/**
+ * @route   DELETE /api/users/:id
+ * @desc    Delete user by ID
+ * @access  Public
+ */
+router.delete('/users/:id', userController.deleteUser);
+
+export default router;

package/src/templates/node/basic/src/types/index.ts.hbs

@@ -0,0 +1,18 @@
+export interface User {
+  _id?: string;
+  name: string;
+  email: string;
+  age?: number;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export interface ApiResponse<T = any> {
+  success: boolean;
+  data?: T;
+  message?: string;
+  error?: {
+    message: string;
+    stack?: string;
+  };
+}

package/src/templates/python/basic/config/database.py.hbs

@@ -0,0 +1,36 @@
+from motor.motor_asyncio import AsyncIOMotorClient
+from pymongo.errors import ConnectionFailure
+import os
+from typing import Optional
+
+client: Optional[AsyncIOMotorClient] = None
+database = None
+
+async def connect_database():
+    """Connect to MongoDB database"""
+    global client, database
+    
+    try:
+        mongo_uri = os.getenv("MONGODB_URI", "mongodb://localhost:27017/{{projectName}}")
+        client = AsyncIOMotorClient(mongo_uri)
+        
+        # Test the connection
+        await client.admin.command('ping')
+        
+        database = client[os.getenv("DB_NAME", "{{projectName}}")]
+        print("✅ Connected to MongoDB")
+        
+    except ConnectionFailure as e:
+        print(f"❌ MongoDB connection error: {e}")
+        raise
+
+async def disconnect_database():
+    """Disconnect from MongoDB"""
+    global client
+    if client:
+        client.close()
+        print("🔌 Disconnected from MongoDB")
+
+async def get_database():
+    """Get database instance"""
+    return database

package/src/templates/python/basic/main.py.hbs

@@ -0,0 +1,58 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import uvicorn
+import os
+from dotenv import load_dotenv
+
+from config.database import connect_database
+from routes import api_router
+from middleware.error_handler import global_exception_handler
+
+load_dotenv()
+
+app = FastAPI(
+    title="{{pascalCase projectName}} API",
+    description="{{description}}",
+    version="1.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global exception handler
+app.exception_handler(Exception)(global_exception_handler)
+
+# Include routes
+app.include_router(api_router, prefix="/api")
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "OK",
+        "timestamp": "2024-01-01T00:00:00Z"
+    }
+
+@app.on_event("startup")
+async def startup_event():
+    await connect_database()
+    print("🚀 Server started successfully")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    print("🔌 Server shutting down")
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 8000))
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=port,
+        reload=True
+    )

package/src/templates/python/basic/middleware/error_handler.py.hbs

@@ -0,0 +1,41 @@
+from fastapi import Request, HTTPException
+from fastapi.responses import JSONResponse
+import logging
+
+logger = logging.getLogger(__name__)
+
+async def global_exception_handler(request: Request, exc: Exception):
+    """Global exception handler for FastAPI"""
+    
+    logger.error(f"Unhandled exception: {str(exc)}")
+    
+    return JSONResponse(
+        status_code=500,
+        content={
+            "success": False,
+            "error": {
+                "message": "Internal server error",
+                "type": type(exc).__name__
+            }
+        }
+    )
+
+class APIException(Exception):
+    """Custom API exception"""
+    def __init__(self, message: str, status_code: int = 400):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(self.message)
+
+async def api_exception_handler(request: Request, exc: APIException):
+    """Handler for custom API exceptions"""
+    
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={
+            "success": False,
+            "error": {
+                "message": exc.message
+            }
+        }
+    )

package/src/templates/python/basic/models/user.py.hbs

@@ -0,0 +1,40 @@
+from pydantic import BaseModel, EmailStr
+from typing import Optional
+from datetime import datetime
+from bson import ObjectId
+
+class PyObjectId(ObjectId):
+    """Custom ObjectId class for Pydantic"""
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, v):
+        if not ObjectId.is_valid(v):
+            raise ValueError("Invalid objectid")
+        return ObjectId(v)
+
+class UserBase(BaseModel):
+    name: str
+    email: EmailStr
+    age: Optional[int] = None
+
+class UserCreate(UserBase):
+    pass
+
+class UserUpdate(BaseModel):
+    name: Optional[str] = None
+    email: Optional[EmailStr] = None
+    age: Optional[int] = None
+
+class User(UserBase):
+    id: Optional[PyObjectId] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        arbitrary_types_allowed = True
+        json_encoders = {
+            ObjectId: str
+        }

package/src/templates/python/basic/routes/__init__.py.hbs

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+from routes import users
+
+api_router = APIRouter()
+
+api_router.include_router(users.router)
+
+@app.get("/")
+async def root():
+    return {"message": "{{pascalCase projectName}} API is running"}
+
+__all__ = ["api_router"]

package/src/templates/python/basic/routes/users.py.hbs

@@ -0,0 +1,64 @@
+from fastapi import APIRouter, HTTPException, Depends
+from typing import List, Optional
+from models.user import User, UserCreate, UserUpdate
+from services.user_service import UserService
+
+router = APIRouter()
+user_service = UserService()
+
+@router.get("/users", response_model=List[User])
+async def get_users():
+    """Get all users"""
+    try:
+        users = await user_service.get_all_users()
+        return users
+    except Exception as e:
+        raise HTTPException(status_code=500, detail="Failed to fetch users")
+
+@router.get("/users/{user_id}", response_model=User)
+async def get_user(user_id: str):
+    """Get user by ID"""
+    try:
+        user = await user_service.get_user_by_id(user_id)
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+        return user
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail="Failed to fetch user")
+
+@router.post("/users", response_model=User, status_code=201)
+async def create_user(user_data: UserCreate):
+    """Create a new user"""
+    try:
+        user = await user_service.create_user(user_data)
+        return user
+    except Exception as e:
+        raise HTTPException(status_code=500, detail="Failed to create user")
+
+@router.put("/users/{user_id}", response_model=User)
+async def update_user(user_id: str, user_data: UserUpdate):
+    """Update user by ID"""
+    try:
+        user = await user_service.update_user(user_id, user_data)
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+        return user
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail="Failed to update user")
+
+@router.delete("/users/{user_id}")
+async def delete_user(user_id: str):
+    """Delete user by ID"""
+    try:
+        success = await user_service.delete_user(user_id)
+        if not success:
+            raise HTTPException(status_code=404, detail="User not found")
+        return {"success": True, "message": "User deleted successfully"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail="Failed to delete user")

package/src/templates/rust/basic/Cargo.toml.hbs

@@ -0,0 +1,39 @@
+[package]
+name = "{{projectName}}"
+version = "0.1.0"
+edition = "2021"
+authors = ["{{author}}"]
+description = "{{description}}"
+
+[dependencies]
+# Web framework
+actix-web = "4.4"
+actix-cors = "0.7"
+
+# Database
+diesel = { version = "2.1", features = ["postgres", "uuid", "chrono", "r2d2"] }
+diesel_migrations = "2.1"
+
+# Serialization
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# UUID
+uuid = { version = "1.5", features = ["v4", "serde"] }
+
+# Date/Time
+chrono = { version = "0.4", features = ["serde"] }
+
+# Environment
+dotenv = "0.15"
+
+# Logging
+log = "0.4"
+env_logger = "0.10"
+
+# Async
+tokio = { version = "1.32", features = ["full"] }
+
+# Error handling
+anyhow = "1.0"
+thiserror = "1.0"

package/src/templates/rust/basic/src/config/database.rs.hbs

@@ -0,0 +1,27 @@
+use diesel::prelude::*;
+use diesel::r2d2::{self, ConnectionManager};
+use std::env;
+
+pub type DbPool = r2d2::Pool<ConnectionManager<PgConnection>>;
+
+pub fn establish_connection() -> DbPool {
+    dotenv::dotenv().ok();
+    
+    let database_url = env::var("DATABASE_URL")
+        .expect("DATABASE_URL must be set");
+    
+    let manager = ConnectionManager::<PgConnection>::new(database_url);
+    r2d2::Pool::builder()
+        .build(manager)
+        .expect("Failed to create pool.")
+}
+
+pub fn run_migrations(pool: &DbPool) {
+    use diesel_migrations::{embed_migrations, EmbeddedMigrations, MigrationHarness};
+
+    const MIGRATIONS: EmbeddedMigrations = embed_migrations!();
+
+    let mut conn = pool.get().expect("Failed to get connection");
+    conn.run_pending_migrations(MIGRATIONS)
+        .expect("Failed to run migrations");
+}