openwork-agent 1.0.0

package/src/templates/rust/basic/src/handlers/user.rs.hbs

@@ -0,0 +1,130 @@
+use actix_web::{web, HttpResponse, Result};
+use diesel::prelude::*;
+use uuid::Uuid;
+use chrono::Utc;
+
+use crate::models::{User, NewUser, UpdateUser, ApiResponse, CreateUserRequest, UpdateUserRequest};
+use crate::schema::users;
+use crate::DbPool;
+
+pub async fn get_users(pool: web::Data<DbPool>) -> Result<HttpResponse> {
+    let mut conn = pool.get().expect("Failed to get connection");
+    
+    let users = web::block(move || {
+        users::table
+            .select(User::as_select())
+            .load::<User>(&mut conn)
+    })
+    .await
+    .expect("Failed to execute query");
+
+    Ok(HttpResponse::Ok().json(ApiResponse::success(users)))
+}
+
+pub async fn get_user(
+    path: web::Path<Uuid>,
+    pool: web::Data<DbPool>
+) -> Result<HttpResponse> {
+    let user_id = path.into_inner();
+    let mut conn = pool.get().expect("Failed to get connection");
+
+    let user = web::block(move || {
+        users::table
+            .filter(users::id.eq(user_id))
+            .select(User::as_select())
+            .first::<User>(&mut conn)
+            .optional()
+    })
+    .await
+    .expect("Failed to execute query");
+
+    match user {
+        Some(user) => Ok(HttpResponse::Ok().json(ApiResponse::success(user))),
+        None => Ok(HttpResponse::NotFound().json(ApiResponse::<User>::error(
+            "User not found".to_string()
+        ))),
+    }
+}
+
+pub async fn create_user(
+    user_data: web::Json<CreateUserRequest>,
+    pool: web::Data<DbPool>
+) -> Result<HttpResponse> {
+    let new_user = NewUser {
+        name: user_data.name.clone(),
+        email: user_data.email.clone(),
+        age: user_data.age,
+    };
+
+    let mut conn = pool.get().expect("Failed to get connection");
+
+    let user = web::block(move || {
+        diesel::insert_into(users::table)
+            .values(&new_user)
+            .returning(User::as_returning())
+            .get_result::<User>(&mut conn)
+    })
+    .await
+    .expect("Failed to execute query");
+
+    Ok(HttpResponse::Created().json(ApiResponse::success(user)))
+}
+
+pub async fn update_user(
+    path: web::Path<Uuid>,
+    user_data: web::Json<UpdateUserRequest>,
+    pool: web::Data<DbPool>
+) -> Result<HttpResponse> {
+    let user_id = path.into_inner();
+    let update_data = UpdateUser {
+        name: user_data.name.clone(),
+        email: user_data.email.clone(),
+        age: user_data.age,
+        updated_at: Utc::now(),
+    };
+
+    let mut conn = pool.get().expect("Failed to get connection");
+
+    let user = web::block(move || {
+        diesel::update(users::table.filter(users::id.eq(user_id)))
+            .set(&update_data)
+            .returning(User::as_returning())
+            .get_result::<User>(&mut conn)
+            .optional()
+    })
+    .await
+    .expect("Failed to execute query");
+
+    match user {
+        Some(user) => Ok(HttpResponse::Ok().json(ApiResponse::success(user))),
+        None => Ok(HttpResponse::NotFound().json(ApiResponse::<User>::error(
+            "User not found".to_string()
+        ))),
+    }
+}
+
+pub async fn delete_user(
+    path: web::Path<Uuid>,
+    pool: web::Data<DbPool>
+) -> Result<HttpResponse> {
+    let user_id = path.into_inner();
+    let mut conn = pool.get().expect("Failed to get connection");
+
+    let rows_affected = web::block(move || {
+        diesel::delete(users::table.filter(users::id.eq(user_id)))
+            .execute(&mut conn)
+    })
+    .await
+    .expect("Failed to execute query");
+
+    if rows_affected > 0 {
+        Ok(HttpResponse::Ok().json(ApiResponse::<()>::success_with_message(
+            (),
+            "User deleted successfully".to_string()
+        )))
+    } else {
+        Ok(HttpResponse::NotFound().json(ApiResponse::<()>::error(
+            "User not found".to_string()
+        )))
+    }
+}

package/src/templates/rust/basic/src/handlers/user_routes.rs.hbs

@@ -0,0 +1,15 @@
+use actix_web::{web, Scope};
+use uuid::Uuid;
+
+use super::user;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::scope("/users")
+            .route("", web::get().to(user::get_users))
+            .route("/{id}", web::get().to(user::get_user))
+            .route("", web::post().to(user::create_user))
+            .route("/{id}", web::put().to(user::update_user))
+            .route("/{id}", web::delete().to(user::delete_user))
+    );
+}

package/src/templates/rust/basic/src/main.rs.hbs

@@ -0,0 +1,53 @@
+use actix_web::{web, App, HttpServer, middleware::Logger};
+use actix_cors::Cors;
+use diesel::prelude::*;
+use diesel::r2d2::{self, ConnectionManager};
+use std::env;
+
+mod config;
+mod models;
+mod schema;
+mod handlers;
+mod services;
+
+use config::database::establish_connection;
+use handlers::user_routes;
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    env_logger::init();
+    dotenv::dotenv().ok();
+
+    // Database connection
+    let conn_spec = establish_connection();
+    
+    println!("🚀 {{pascalCase projectName}} server starting on 0.0.0.0:8080");
+
+    HttpServer::new(move || {
+        let cors = Cors::default()
+            .allow_any_origin()
+            .allow_any_method()
+            .allow_any_header()
+            .max_age(3600);
+
+        App::new()
+            .app_data(web::Data::new(conn_spec.clone()))
+            .wrap(cors)
+            .wrap(Logger::default())
+            .service(
+                web::scope("/api")
+                    .configure(user_routes::config)
+            )
+            .route("/health", web::get().to(health_check))
+    })
+    .bind("0.0.0.0:8080")?
+    .run()
+    .await
+}
+
+async fn health_check() -> impl actix_web::Responder {
+    actix_web::HttpResponse::Ok().json(serde_json::json!({
+        "status": "OK",
+        "timestamp": "2024-01-01T00:00:00Z"
+    }))
+}

package/src/templates/rust/basic/src/models/mod.rs.hbs

@@ -0,0 +1,79 @@
+use serde::{Deserialize, Serialize};
+use chrono::{DateTime, Utc};
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Queryable, Selectable, Serialize)]
+#[diesel(table_name = crate::schema::users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct User {
+    pub id: Uuid,
+    pub name: String,
+    pub email: String,
+    pub age: Option<i32>,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Insertable, Serialize, Deserialize)]
+#[diesel(table_name = crate::schema::users)]
+pub struct NewUser {
+    pub name: String,
+    pub email: String,
+    pub age: Option<i32>,
+}
+
+#[derive(Debug, AsChangeset, Deserialize)]
+#[diesel(table_name = crate::schema::users)]
+pub struct UpdateUser {
+    pub name: Option<String>,
+    pub email: Option<String>,
+    pub age: Option<i32>,
+    pub updated_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ApiResponse<T> {
+    pub success: bool,
+    pub data: Option<T>,
+    pub message: Option<String>,
+}
+
+impl<T> ApiResponse<T> {
+    pub fn success(data: T) -> Self {
+        Self {
+            success: true,
+            data: Some(data),
+            message: None,
+        }
+    }
+
+    pub fn success_with_message(data: T, message: String) -> Self {
+        Self {
+            success: true,
+            data: Some(data),
+            message: Some(message),
+        }
+    }
+
+    pub fn error(message: String) -> Self {
+        Self {
+            success: false,
+            data: None,
+            message: Some(message),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CreateUserRequest {
+    pub name: String,
+    pub email: String,
+    pub age: Option<i32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct UpdateUserRequest {
+    pub name: Option<String>,
+    pub email: Option<String>,
+    pub age: Option<i32>,
+}

package/src/templates/rust/basic/src/schema.rs.hbs

@@ -0,0 +1,10 @@
+diesel::table! {
+    users (id) {
+        id -> Uuid,
+        name -> Varchar,
+        email -> Varchar,
+        age -> Nullable<Integer>,
+        created_at -> Timestamp,
+        updated_at -> Timestamp,
+    }
+}

package/src/utils/FileManager.js

@@ -0,0 +1,186 @@
+const fs = require('fs-extra');
+const path = require('path');
+const Handlebars = require('handlebars');
+
+class FileManager {
+  constructor() {
+    this.registerHandlebarsHelpers();
+  }
+
+  registerHandlebarsHelpers() {
+    Handlebars.registerHelper('camelCase', (str) => {
+      return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
+        return index === 0 ? word.toLowerCase() : word.toUpperCase();
+      }).replace(/\s+/g, '');
+    });
+
+    Handlebars.registerHelper('pascalCase', (str) => {
+      return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => {
+        return word.toUpperCase();
+      }).replace(/\s+/g, '');
+    });
+
+    Handlebars.registerHelper('kebabCase', (str) => {
+      return str.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/\s+/g, '-').toLowerCase();
+    });
+
+    Handlebars.registerHelper('snakeCase', (str) => {
+      return str.replace(/([a-z])([A-Z])/g, '$1_$2').replace(/\s+/g, '_').toLowerCase();
+    });
+
+    Handlebars.registerHelper('upperCase', (str) => {
+      return str.toUpperCase();
+    });
+
+    Handlebars.registerHelper('lowerCase', (str) => {
+      return str.toLowerCase();
+    });
+
+    // Common conditional helpers
+    Handlebars.registerHelper('eq', (a, b) => {
+      return a === b;
+    });
+
+    Handlebars.registerHelper('ne', (a, b) => {
+      return a !== b;
+    });
+
+    Handlebars.registerHelper('gt', (a, b) => {
+      return a > b;
+    });
+
+    Handlebars.registerHelper('lt', (a, b) => {
+      return a < b;
+    });
+
+    Handlebars.registerHelper('and', (...args) => {
+      return args.slice(0, -1).every(Boolean);
+    });
+
+    Handlebars.registerHelper('or', (...args) => {
+      return args.slice(0, -1).some(Boolean);
+    });
+
+    Handlebars.registerHelper('not', (value) => {
+      return !value;
+    });
+  }
+
+  async copyDirectory(src, dest, config = {}) {
+    const items = await fs.readdir(src);
+
+    for (const item of items) {
+      const srcPath = path.join(src, item);
+      const destPath = path.join(dest, item);
+      const stat = await fs.stat(srcPath);
+
+      if (stat.isDirectory()) {
+        await fs.ensureDir(destPath);
+        await this.copyDirectory(srcPath, destPath, config);
+      } else {
+        if (this.shouldProcessFile(item)) {
+          await this.processTemplate(srcPath, destPath, config);
+        } else {
+          await fs.copy(srcPath, destPath);
+        }
+      }
+    }
+  }
+
+  shouldProcessFile(filename) {
+    const processableExtensions = ['.hbs', '.handlebars', '.txt', '.js', '.ts', '.py', '.java', '.go', '.rs', '.php', '.html', '.md'];
+    return processableExtensions.some(ext => filename.endsWith(ext));
+  }
+
+  async processTemplate(srcPath, destPath, config) {
+    try {
+      const content = await fs.readFile(srcPath, 'utf8');
+      const template = Handlebars.compile(content);
+      const processed = template(config);
+      
+      // Remove .hbs extension if present
+      const finalDestPath = destPath.endsWith('.hbs') ? destPath.slice(0, -4) : destPath;
+      
+      await fs.writeFile(finalDestPath, processed);
+    } catch (error) {
+      // If template processing fails, copy the file as-is
+      await fs.copy(srcPath, destPath);
+    }
+  }
+
+  async writeFileWithTemplate(templatePath, destPath, config) {
+    if (await fs.pathExists(templatePath)) {
+      await this.processTemplate(templatePath, destPath, config);
+    } else {
+      throw new Error(`Template file not found: ${templatePath}`);
+    }
+  }
+
+  async ensureDir(dirPath) {
+    await fs.ensureDir(dirPath);
+  }
+
+  async copyFile(src, dest) {
+    await fs.copy(src, dest);
+  }
+
+  async writeFile(filePath, content) {
+    await fs.writeFile(filePath, content);
+  }
+
+  async readFile(filePath) {
+    return await fs.readFile(filePath, 'utf8');
+  }
+
+  async pathExists(filePath) {
+    return await fs.pathExists(filePath);
+  }
+
+  async readdir(dirPath) {
+    return await fs.readdir(dirPath);
+  }
+
+  async stat(filePath) {
+    return await fs.stat(filePath);
+  }
+
+  createDirectoryStructure(basePath, structure) {
+    return Promise.all(
+      Object.entries(structure).map(async ([path, content]) => {
+        const fullPath = this.resolvePath(basePath, path);
+        
+        if (typeof content === 'object' && !Array.isArray(content)) {
+          await fs.ensureDir(fullPath);
+          return this.createDirectoryStructure(fullPath, content);
+        } else if (Array.isArray(content)) {
+          await fs.ensureDir(fullPath);
+          return Promise.all(
+            content.map(item => this.createDirectoryStructure(fullPath, item))
+          );
+        } else {
+          await fs.ensureDir(path.dirname(fullPath));
+          return fs.writeFile(fullPath, content || '');
+        }
+      })
+    );
+  }
+
+  resolvePath(base, relativePath) {
+    return path.resolve(base, relativePath);
+  }
+
+  getFileExtension(filename) {
+    return path.extname(filename);
+  }
+
+  getFileName(filename) {
+    return path.basename(filename, path.extname(filename));
+  }
+
+  formatTemplate(template, data) {
+    const compiled = Handlebars.compile(template);
+    return compiled(data);
+  }
+}
+
+module.exports = FileManager;

package/src/utils/Templates.js

@@ -0,0 +1,231 @@
+// Common template files
+exports.generateGitignore = function(config) {
+  const gitignoreContent = `
+# Dependencies
+node_modules/
+__pycache__/
+target/
+build/
+dist/
+vendor/
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# next.js build output
+.next
+
+# nuxt.js build output
+.nuxt
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Docker
+.dockerignore
+
+# Go
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+*.test
+*.out
+
+# Rust
+/target/
+**/*.rs.bk
+Cargo.lock
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.idea/
+.vscode/
+
+# Java
+*.class
+*.log
+*.jar
+*.war
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# IDE files
+.metadata/
+.recommenders/
+.settings/
+.loadpath
+.factorypath
+.project
+.classpath
+.c9/
+.launch/
+.settings/
+.springBeans
+.sts4-cache/
+
+# Temporary files
+*.tmp
+*.temp
+`;
+  
+  return gitignoreContent;
+};
+
+exports.generateEnvExample = function(config) {
+  const commonEnv = `# Server Configuration
+PORT=3000
+NODE_ENV=development
+
+# Database Configuration
+DATABASE_URL=mongodb://localhost:27017/${config.projectName}
+DB_NAME=${config.projectName}
+
+# JWT Configuration
+JWT_SECRET=your-super-secret-jwt-key
+JWT_EXPIRES_IN=7d
+
+# CORS Configuration
+ALLOWED_ORIGINS=http://localhost:3000,http://localhost:3001
+
+# Logging
+LOG_LEVEL=info
+
+# External Services
+REDIS_URL=redis://localhost:6379
+SMTP_HOST=smtp.gmail.com
+SMTP_PORT=587
+SMTP_USER=your-email@gmail.com
+SMTP_PASS=your-app-password
+
+# File Upload
+MAX_FILE_SIZE=10485760
+UPLOAD_PATH=./uploads
+`;
+
+  // Add technology-specific env variables
+  const techSpecific = {
+    python: `
+# Python Specific
+PYTHONPATH=.
+DEBUG=True
+CORS_ORIGINS=http://localhost:3000`,
+    
+    java: `
+# Java Specific
+SPRING_PROFILES_ACTIVE=dev
+SERVER_PORT=8080`,
+    
+    go: `
+# Go Specific
+GIN_MODE=debug`,
+    
+    rust: `
+# Rust Specific
+RUST_LOG=debug`,
+    
+    php: `
+# PHP Specific
+APP_ENV=local
+APP_DEBUG=true
+APP_KEY=base64:your-app-key`
+  };
+
+  const specificEnv = techSpecific[config.technology] || '';
+  
+  return commonEnv + specificEnv;
+};