@sibyllinesoft/arbiter 0.1.0

package/dist/templates/plopfiles/_modules/backends/kotlin-ktor/templates/src/main/resources/logback.xml.hbs

@@ -0,0 +1,11 @@
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+    <root level="INFO">
+        <appender-ref ref="STDOUT"/>
+    </root>
+    <logger name="io.ktor" level="INFO"/>
+</configuration>

package/dist/templates/plopfiles/_modules/backends/node-express/module.js

@@ -0,0 +1,54 @@
+/**
+ * Node.js + Express Backend Module
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const templatesDir = resolve(__dirname, "templates");
+
+export default function (data) {
+  const backendDir = data.backendDir || "backend";
+
+  return [
+    {
+      type: "addMany",
+      destination: `{{projectDir}}/${backendDir}`,
+      base: templatesDir,
+      templateFiles: `${templatesDir}/**/*.hbs`,
+      stripExtensions: ["hbs"],
+      data,
+    },
+  ];
+}
+
+export const description = "Node.js backend with Express and TypeScript";
+
+export const dependencies = {
+  express: "^4.18.0",
+  cors: "^2.8.5",
+  dotenv: "^16.3.0",
+  helmet: "^7.1.0",
+  "express-rate-limit": "^7.1.0",
+};
+
+export const devDependencies = {
+  "@types/express": "^4.17.0",
+  "@types/cors": "^2.8.0",
+  "@types/node": "^20.10.0",
+  typescript: "^5.3.0",
+  "ts-node": "^10.9.0",
+  nodemon: "^3.0.0",
+};
+
+export const scripts = {
+  "dev:backend": "nodemon --exec ts-node backend/src/index.ts",
+  "build:backend": "tsc -p backend/tsconfig.json",
+  "start:backend": "node backend/dist/index.js",
+};
+
+export const envVars = {
+  PORT: "3000",
+  NODE_ENV: "development",
+};

package/dist/templates/plopfiles/_modules/backends/node-express/templates/src/index.ts.hbs

@@ -0,0 +1,37 @@
+import express from "express";
+import cors from "cors";
+import helmet from "helmet";
+import rateLimit from "express-rate-limit";
+import { config } from "dotenv";
+
+import { healthRouter } from "./routes/health";
+
+config();
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+// Middleware
+app.use(helmet());
+app.use(cors());
+app.use(express.json());
+
+// Rate limiting
+const limiter = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 100, // Limit each IP to 100 requests per windowMs
+});
+app.use(limiter);
+
+// Routes
+app.use("/health", healthRouter);
+
+// Error handler
+app.use((err: Error, req: express.Request, res: express.Response, next: express.NextFunction) => {
+  console.error(err.stack);
+  res.status(500).json({ error: "Something went wrong!" });
+});
+
+app.listen(port, () => {
+  console.log(`{{titleCase name}} backend listening on port ${port}`);
+});

package/dist/templates/plopfiles/_modules/backends/node-express/templates/src/routes/health.ts.hbs

@@ -0,0 +1,21 @@
+import { Router } from "express";
+
+export const healthRouter = Router();
+
+healthRouter.get("/", (req, res) => {
+  res.json({
+    status: "ok",
+    timestamp: new Date().toISOString(),
+    service: "{{kebabCase name}}-backend",
+    uptime: process.uptime(),
+  });
+});
+
+healthRouter.get("/ready", (req, res) => {
+  // Add readiness checks here (database, external services, etc.)
+  res.json({ ready: true });
+});
+
+healthRouter.get("/live", (req, res) => {
+  res.json({ alive: true });
+});

package/dist/templates/plopfiles/_modules/backends/node-express/templates/tsconfig.json.hbs

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/templates/plopfiles/_modules/backends/node-hono/module.js

@@ -0,0 +1,56 @@
+/**
+ * Node.js + Hono Backend Module
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const templatesDir = resolve(__dirname, "templates");
+
+export default function (data) {
+  const backendDir = data.backendDir || "backend";
+
+  return [
+    {
+      type: "addMany",
+      destination: `{{projectDir}}/${backendDir}`,
+      base: templatesDir,
+      templateFiles: `${templatesDir}/**/*.hbs`,
+      stripExtensions: ["hbs"],
+      data,
+    },
+  ];
+}
+
+export const description = "Node.js backend with Hono framework and Bun runtime";
+
+export const dependencies = {
+  hono: "^4.0.0",
+  "@hono/node-server": "^1.8.0",
+  "@hono/zod-validator": "^0.2.0",
+  zod: "^3.22.0",
+};
+
+export const devDependencies = {
+  "@types/bun": "latest",
+  typescript: "^5.3.0",
+  "@biomejs/biome": "^1.9.0",
+  typedoc: "^0.27.0",
+  "typedoc-plugin-markdown": "^4.2.0",
+};
+
+export const scripts = {
+  "dev:backend": "bun run --watch backend/src/index.ts",
+  "build:backend": "bun build backend/src/index.ts --outdir dist/backend --target node",
+  "start:backend": "bun run dist/backend/index.js",
+  "test:backend": "bun test backend",
+  "lint:backend": "biome check backend",
+  "lint:backend:fix": "biome check --write backend",
+  "docs:backend": "typedoc --out docs/api/backend backend/src",
+};
+
+export const envVars = {
+  PORT: "3000",
+  NODE_ENV: "development",
+};

package/dist/templates/plopfiles/_modules/backends/node-hono/templates/src/index.ts.hbs

@@ -0,0 +1,30 @@
+/**
+ * {{pascalCase name}} Backend
+ */
+
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { logger } from "hono/logger";
+import { cors } from "hono/cors";
+import { routes } from "./routes/index.js";
+{{#if database}}
+import { db } from "./db/index.js";
+{{/if}}
+
+const app = new Hono();
+
+// Middleware
+app.use("*", logger());
+app.use("*", cors());
+
+// Routes
+app.route("/", routes);
+
+// Start server
+const port = parseInt(process.env.PORT ?? "3000", 10);
+
+serve({ fetch: app.fetch, port }, (info) => {
+  console.log(`🚀 {{pascalCase name}} backend running on http://localhost:${info.port}`);
+});
+
+export default app;

package/dist/templates/plopfiles/_modules/backends/node-hono/templates/src/routes/health.ts.hbs

@@ -0,0 +1,64 @@
+/**
+ * @module routes/health
+ * @description Health check endpoints for monitoring and orchestration.
+ *
+ * Provides Kubernetes-compatible health probes:
+ * - `/health` - General health status
+ * - `/health/ready` - Readiness probe (dependencies ready)
+ * - `/health/live` - Liveness probe (process alive)
+ */
+
+import { Hono } from "hono";
+
+/**
+ * Health check router.
+ */
+export const health = new Hono();
+
+/**
+ * General health status endpoint.
+ *
+ * @description Returns the overall health of the service including
+ * service name and current timestamp.
+ *
+ * @returns Health status object.
+ *
+ * @example
+ * ```bash
+ * curl http://localhost:3000/health
+ * # { "status": "ok", "service": "my-app", "timestamp": "2024-..." }
+ * ```
+ */
+health.get("/", (c) => {
+  return c.json({
+    status: "ok",
+    service: "{{kebabCase name}}",
+    timestamp: new Date().toISOString(),
+  });
+});
+
+/**
+ * Kubernetes readiness probe.
+ *
+ * @description Indicates whether the service is ready to accept traffic.
+ * Returns `ready: true` when all dependencies (database, cache, etc.)
+ * are available and the service can handle requests.
+ *
+ * @returns Readiness status.
+ */
+health.get("/ready", (c) => {
+  // TODO: Add actual readiness checks (db, cache, external services)
+  return c.json({ ready: true });
+});
+
+/**
+ * Kubernetes liveness probe.
+ *
+ * @description Indicates whether the service process is running.
+ * If this fails, the container should be restarted.
+ *
+ * @returns Liveness status.
+ */
+health.get("/live", (c) => {
+  return c.json({ live: true });
+});

package/dist/templates/plopfiles/_modules/backends/node-hono/templates/src/routes/index.ts.hbs

@@ -0,0 +1,38 @@
+/**
+ * @module routes
+ * @description API route definitions for {{pascalCase name}} backend.
+ *
+ * All routes are organized under this module and mounted on the main app.
+ */
+
+import { Hono } from "hono";
+import { health } from "./health.js";
+
+/**
+ * Main router instance.
+ *
+ * Aggregates all sub-routes and provides the base routing structure.
+ *
+ * @example
+ * ```typescript
+ * import { routes } from "./routes/index.js";
+ * app.route("/", routes);
+ * ```
+ */
+export const routes = new Hono();
+
+// Health check endpoints
+routes.route("/health", health);
+
+/**
+ * Root endpoint.
+ *
+ * @returns Welcome message with API version.
+ */
+routes.get("/", (c) => {
+  return c.json({
+    name: "{{pascalCase name}} API",
+    version: "1.0.0",
+    docs: "/docs",
+  });
+});

package/dist/templates/plopfiles/_modules/backends/node-hono/templates/tsconfig.json.hbs

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "../dist/backend",
+    "rootDir": "./src",
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}

package/dist/templates/plopfiles/_modules/backends/node-hono/templates/typedoc.json.hbs

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["src/index.ts"],
+  "out": "../docs/api/backend",
+  "plugin": ["typedoc-plugin-markdown"],
+  "readme": "README.md",
+  "name": "{{pascalCase name}} Backend API",
+  "includeVersion": true,
+  "excludePrivate": true,
+  "excludeProtected": true,
+  "excludeExternals": true,
+  "excludeInternal": true,
+  "hideGenerator": true,
+  "navigation": {
+    "includeCategories": true,
+    "includeGroups": true
+  },
+  "categorizeByGroup": true,
+  "sort": ["source-order"],
+  "validation": {
+    "notExported": true,
+    "invalidLink": true,
+    "notDocumented": false
+  }
+}

package/dist/templates/plopfiles/_modules/backends/python-fastapi/module.js

@@ -0,0 +1,65 @@
+/**
+ * Python + FastAPI Backend Module
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const templatesDir = resolve(__dirname, "templates");
+
+export default function (data) {
+  const backendDir = data.backendDir || "backend";
+
+  return [
+    {
+      type: "addMany",
+      destination: `{{projectDir}}/${backendDir}`,
+      base: templatesDir,
+      templateFiles: `${templatesDir}/**/*.hbs`,
+      stripExtensions: ["hbs"],
+      data,
+    },
+  ];
+}
+
+export const description = "Python backend with FastAPI and async support";
+
+export const dependencies = {};
+
+export const devDependencies = {};
+
+export const scripts = {
+  "dev:backend": "cd backend && uvicorn app.main:app --reload --port 3000",
+  "start:backend": "cd backend && uvicorn app.main:app --host 0.0.0.0 --port 3000",
+  "test:backend": "cd backend && pytest",
+  "lint:backend": "cd backend && ruff check .",
+  "lint:backend:fix": "cd backend && ruff check --fix .",
+  "format:backend": "cd backend && ruff format .",
+  "typecheck:backend": "cd backend && mypy app",
+  "docs:backend": "cd backend && pdoc --html --output-dir ../docs/api/backend app",
+};
+
+export const envVars = {
+  PORT: "3000",
+  DATABASE_URL: "postgresql://postgres:postgres@localhost:5432/{{snakeCase name}}",
+  SECRET_KEY: "change-me-in-production",
+};
+
+export const pythonDependencies = {
+  fastapi: "^0.109.0",
+  uvicorn: "^0.27.0",
+  pydantic: "^2.5.0",
+  "pydantic-settings": "^2.1.0",
+  "python-dotenv": "^1.0.0",
+  httpx: "^0.26.0",
+};
+
+export const pythonDevDependencies = {
+  pytest: "^8.3.0",
+  "pytest-asyncio": "^0.24.0",
+  "pytest-cov": "^6.0.0",
+  ruff: "^0.8.0",
+  mypy: "^1.13.0",
+  pdoc: "^15.0.0",
+};

package/dist/templates/plopfiles/_modules/backends/python-fastapi/templates/app/__init__.py.hbs

@@ -0,0 +1 @@
+# {{titleCase name}} Backend

package/dist/templates/plopfiles/_modules/backends/python-fastapi/templates/app/config.py.hbs

@@ -0,0 +1,28 @@
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+
+class Settings(BaseSettings):
+    app_name: str = "{{titleCase name}}"
+    debug: bool = False
+
+    # Database
+    database_url: str = "postgresql://postgres:postgres@localhost:5432/{{snakeCase name}}"
+
+    # Security
+    secret_key: str = "change-me-in-production"
+
+    # CORS
+    cors_origins: list[str] = ["http://localhost:5173", "http://localhost:3000"]
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()
+
+
+settings = get_settings()

package/dist/templates/plopfiles/_modules/backends/python-fastapi/templates/app/main.py.hbs

@@ -0,0 +1,40 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.routers import health
+from app.config import settings
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    print(f"Starting {{titleCase name}} API...")
+    yield
+    # Shutdown
+    print("Shutting down...")
+
+
+app = FastAPI(
+    title="{{titleCase name}} API",
+    description="{{titleCase name}} backend service",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(health.router, prefix="/health", tags=["health"])
+
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to {{titleCase name}} API"}

package/dist/templates/plopfiles/_modules/backends/python-fastapi/templates/app/routers/__init__.py.hbs

@@ -0,0 +1 @@
+# Routers

package/dist/templates/plopfiles/_modules/backends/python-fastapi/templates/app/routers/health.py.hbs

@@ -0,0 +1,24 @@
+from datetime import datetime
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/")
+async def health_check():
+    return {
+        "status": "ok",
+        "timestamp": datetime.utcnow().isoformat(),
+        "service": "{{kebabCase name}}-backend",
+    }
+
+
+@router.get("/ready")
+async def readiness_check():
+    # Add database/service checks here
+    return {"ready": True}
+
+
+@router.get("/live")
+async def liveness_check():
+    return {"alive": True}

package/dist/templates/plopfiles/_modules/backends/python-fastapi/templates/pyproject.toml.hbs

@@ -0,0 +1,40 @@
+[project]
+name = "{{kebabCase name}}-backend"
+version = "0.1.0"
+description = "{{titleCase name}} backend service"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.109.0",
+    "uvicorn[standard]>=0.27.0",
+    "pydantic>=2.5.0",
+    "pydantic-settings>=2.1.0",
+    "python-dotenv>=1.0.0",
+    "httpx>=0.26.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.23.0",
+    "ruff>=0.1.0",
+    "mypy>=1.8.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

package/dist/templates/plopfiles/_modules/backends/python-fastapi/templates/requirements.txt.hbs

@@ -0,0 +1,6 @@
+fastapi>=0.109.0
+uvicorn[standard]>=0.27.0
+pydantic>=2.5.0
+pydantic-settings>=2.1.0
+python-dotenv>=1.0.0
+httpx>=0.26.0

package/dist/templates/plopfiles/_modules/backends/rust-axum/module.js

@@ -0,0 +1,44 @@
+/**
+ * Rust + Axum Backend Module
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const templatesDir = resolve(__dirname, "templates");
+
+export default function (data) {
+  const backendDir = data.backendDir || "backend";
+
+  return [
+    {
+      type: "addMany",
+      destination: `{{projectDir}}/${backendDir}`,
+      base: templatesDir,
+      templateFiles: `${templatesDir}/**/*.hbs`,
+      stripExtensions: ["hbs"],
+      data,
+    },
+  ];
+}
+
+export const description = "Rust backend with Axum web framework";
+
+export const scripts = {
+  "dev:backend": "cd backend && cargo watch -x run",
+  "build:backend": "cd backend && cargo build --release",
+  "start:backend": "cd backend && ./target/release/{{snakeCase name}}",
+  "test:backend": "cd backend && cargo test",
+  "lint:backend": "cd backend && cargo clippy --all-targets --all-features -- -D warnings",
+  "lint:backend:fix": "cd backend && cargo clippy --fix --allow-dirty --allow-staged",
+  "format:backend": "cd backend && cargo fmt",
+  "format:backend:check": "cd backend && cargo fmt -- --check",
+  "docs:backend": "cd backend && cargo doc --no-deps --open",
+};
+
+export const envVars = {
+  PORT: "3000",
+  DATABASE_URL: "postgresql://postgres:postgres@localhost:5432/{{snakeCase name}}",
+  RUST_LOG: "info,{{snakeCase name}}=debug",
+};

package/dist/templates/plopfiles/_modules/backends/rust-axum/templates/Cargo.toml.hbs

@@ -0,0 +1,23 @@
+[package]
+name = "{{snakeCase name}}"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+axum = "0.7"
+tokio = { version = "1", features = ["full"] }
+tower = "0.4"
+tower-http = { version = "0.5", features = ["cors", "trace"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+dotenvy = "0.15"
+thiserror = "1"
+anyhow = "1"
+
+# Database (optional)
+# sqlx = { version = "0.7", features = ["runtime-tokio", "postgres"] }
+
+[dev-dependencies]
+reqwest = { version = "0.11", features = ["json"] }