@sibyllinesoft/arbiter 0.1.0

package/dist/templates/plopfiles/__tests__/templates.test.ts

@@ -0,0 +1,341 @@
+/**
+ * Template File Validation Tests
+ *
+ * Validates that all template files are valid Handlebars templates
+ * and don't have obvious issues.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { readFile, readdir, stat } from "fs/promises";
+import Handlebars from "handlebars";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MODULES_DIR = join(__dirname, "..", "_modules");
+
+// Register common helpers used in templates
+Handlebars.registerHelper(
+  "kebabCase",
+  (str: string) =>
+    str
+      ?.toLowerCase()
+      .replace(/\s+/g, "-")
+      .replace(/[^a-z0-9-]/g, "") || "",
+);
+Handlebars.registerHelper(
+  "snakeCase",
+  (str: string) =>
+    str
+      ?.toLowerCase()
+      .replace(/\s+/g, "_")
+      .replace(/[^a-z0-9_]/g, "") || "",
+);
+Handlebars.registerHelper("camelCase", (str: string) => {
+  if (!str) return "";
+  return str.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase());
+});
+Handlebars.registerHelper("pascalCase", (str: string) => {
+  if (!str) return "";
+  const camel = str.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase());
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+});
+Handlebars.registerHelper(
+  "titleCase",
+  (str: string) => str?.replace(/\b\w/g, (char) => char.toUpperCase()) || "",
+);
+Handlebars.registerHelper("eq", (a: unknown, b: unknown) => a === b);
+Handlebars.registerHelper("ne", (a: unknown, b: unknown) => a !== b);
+Handlebars.registerHelper("json", (obj: unknown) => JSON.stringify(obj, null, 2));
+Handlebars.registerHelper(
+  "has",
+  (arr: unknown[] | undefined, value: unknown) => Array.isArray(arr) && arr.includes(value),
+);
+
+// Recursively find all .hbs files
+async function findTemplateFiles(dir: string): Promise<string[]> {
+  const files: string[] = [];
+
+  async function walk(currentDir: string) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.name.endsWith(".hbs")) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  await walk(dir);
+  return files;
+}
+
+// Test context for template rendering
+const testContext = {
+  name: "test-app",
+  projectDir: "/tmp/test",
+  backendDir: "backend",
+  frontendDir: "frontend",
+  desktopDir: "desktop",
+  mobileDir: "mobile",
+  backend: "node-hono",
+  frontend: "react-vite",
+  database: "postgres-drizzle",
+  environment: "development",
+  infra: ["docker-compose", "kubernetes"],
+  build: ["bazel", "nx"],
+  manifest: {
+    dependencies: { test: "^1.0.0" },
+    devDependencies: { "test-dev": "^1.0.0" },
+    scripts: { test: "echo test" },
+    envVars: { TEST: "value" },
+  },
+};
+
+describe("Template Validation", () => {
+  test("all .hbs files are valid Handlebars templates", async () => {
+    const templateFiles = await findTemplateFiles(MODULES_DIR);
+    const errors: string[] = [];
+
+    for (const file of templateFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        // Try to compile the template
+        Handlebars.compile(content);
+      } catch (error) {
+        errors.push(`${file}: ${error}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      console.error("Template compilation errors:");
+      errors.forEach((e) => console.error(`  - ${e}`));
+    }
+
+    expect(errors).toHaveLength(0);
+  });
+
+  test("all .hbs files render without errors", async () => {
+    const templateFiles = await findTemplateFiles(MODULES_DIR);
+    const errors: string[] = [];
+
+    for (const file of templateFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const template = Handlebars.compile(content);
+        const rendered = template(testContext);
+
+        // Check for unrendered Handlebars template syntax
+        // But exclude other template syntaxes that look similar:
+        // - Vue/Angular: {{ expression }}
+        // - GitHub Actions: ${{ expression }}
+        // - React Native/JSX: ={{ ... }}
+        // - Kotlin string templates: ${ }
+        if (rendered.includes("{{") && rendered.includes("}}")) {
+          const match = rendered.match(/\{\{[^}]+\}\}/g);
+          if (match) {
+            const unintentional = match.filter((m) => {
+              // Skip GitHub Actions syntax
+              if (m.includes("${{")) return false;
+              // Skip escaped Handlebars
+              if (m.includes("\\{{")) return false;
+              // Skip Handlebars block syntax in output
+              if (m.includes("{{#") || m.includes("{{/") || m.includes("{{>")) return false;
+              // Skip Vue/Angular template expressions (typically in .vue files)
+              if (file.endsWith(".vue.hbs")) return false;
+              // Skip JSX attribute syntax like ={{ }}
+              if (m.match(/^=\{\{/)) return false;
+
+              // Check if it looks like a JavaScript expression (Vue/Angular)
+              // These typically have spaces around content or JS operators
+              const inner = m.slice(2, -2).trim();
+              if (
+                inner.includes("JSON.") ||
+                inner.includes(".toString") ||
+                inner.match(/^\s*\w+\s*$/) || // Simple variable like {{ health }}
+                inner.includes(":") // Object literal like {{ title: "..." }}
+              ) {
+                return false;
+              }
+
+              return true;
+            });
+            if (unintentional.length > 0) {
+              errors.push(`${file}: Unrendered template syntax: ${unintentional.join(", ")}`);
+            }
+          }
+        }
+      } catch (error) {
+        errors.push(`${file}: ${error}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      console.error("Template rendering errors:");
+      errors.forEach((e) => console.error(`  - ${e}`));
+    }
+
+    expect(errors).toHaveLength(0);
+  });
+
+  test("JSON template files produce valid JSON", async () => {
+    const templateFiles = await findTemplateFiles(MODULES_DIR);
+    const jsonFiles = templateFiles.filter(
+      (f) => f.endsWith(".json.hbs") || f.endsWith("package.json.hbs"),
+    );
+    const errors: string[] = [];
+
+    for (const file of jsonFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const template = Handlebars.compile(content);
+        const rendered = template(testContext);
+        JSON.parse(rendered);
+      } catch (error) {
+        errors.push(`${file}: ${error}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      console.error("JSON validation errors:");
+      errors.forEach((e) => console.error(`  - ${e}`));
+    }
+
+    expect(errors).toHaveLength(0);
+  });
+
+  test("YAML template files don't have obvious syntax errors", async () => {
+    const templateFiles = await findTemplateFiles(MODULES_DIR);
+    const yamlFiles = templateFiles.filter(
+      (f) => f.endsWith(".yaml.hbs") || f.endsWith(".yml.hbs"),
+    );
+    const errors: string[] = [];
+
+    for (const file of yamlFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const template = Handlebars.compile(content);
+        const rendered = template(testContext);
+
+        // Basic YAML checks
+        const lines = rendered.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          // Check for tabs (YAML doesn't allow tabs for indentation)
+          if (line.match(/^\t/)) {
+            errors.push(`${file}:${i + 1}: Tab character used for indentation`);
+          }
+          // Check for obviously broken indentation
+          if (line.match(/^(\s*)(\S+):\s*$/) && i + 1 < lines.length) {
+            const currentIndent = line.match(/^(\s*)/)?.[1]?.length || 0;
+            const nextLine = lines[i + 1];
+            const nextIndent = nextLine.match(/^(\s*)/)?.[1]?.length || 0;
+            if (
+              nextLine.trim() &&
+              nextIndent <= currentIndent &&
+              !nextLine.trim().startsWith("#")
+            ) {
+              // This might be intentional for empty values, so just warn
+            }
+          }
+        }
+      } catch (error) {
+        errors.push(`${file}: ${error}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      console.error("YAML validation warnings:");
+      errors.forEach((e) => console.error(`  - ${e}`));
+    }
+
+    // YAML warnings shouldn't fail the test, just report
+    expect(true).toBe(true);
+  });
+
+  test("TypeScript template files don't have unrendered variables", async () => {
+    const templateFiles = await findTemplateFiles(MODULES_DIR);
+    const tsFiles = templateFiles.filter((f) => f.endsWith(".ts.hbs") || f.endsWith(".tsx.hbs"));
+    const errors: string[] = [];
+
+    for (const file of tsFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const template = Handlebars.compile(content);
+        const rendered = template(testContext);
+
+        // Check for undefined values that slipped through template rendering
+        // But allow valid JS patterns like ternary expressions: `x ? y : undefined`
+        const lines = rendered.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          // Check for assignment to undefined (likely template error)
+          if (line.match(/\w+\s*=\s*undefined\s*;?\s*$/)) {
+            errors.push(`${file}:${i + 1}: Direct assignment to undefined: ${line.trim()}`);
+          }
+          // Check for property set to undefined (likely template error)
+          if (line.match(/:\s*undefined\s*,?\s*$/) && !line.includes("?")) {
+            errors.push(`${file}:${i + 1}: Property set to undefined: ${line.trim()}`);
+          }
+        }
+
+        // Check for unrendered Handlebars variables (shows as empty or malformed)
+        // Look for patterns that suggest template variables weren't rendered
+        if (rendered.match(/\{\{\s*\}\}/)) {
+          errors.push(`${file}: Contains empty template expression {{}}`);
+        }
+      } catch (error) {
+        errors.push(`${file}: ${error}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      console.error("TypeScript template errors:");
+      errors.forEach((e) => console.error(`  - ${e}`));
+    }
+
+    expect(errors).toHaveLength(0);
+  });
+});
+
+describe("Module Structure Validation", () => {
+  const categories = ["backends", "frontends", "databases", "desktop", "mobile", "infra", "cloud"];
+
+  for (const category of categories) {
+    test(`${category} modules have required structure`, async () => {
+      const categoryPath = join(MODULES_DIR, category);
+
+      try {
+        const entries = await readdir(categoryPath, { withFileTypes: true });
+        const modules = entries.filter((e) => e.isDirectory() && !e.name.startsWith("_"));
+
+        for (const mod of modules) {
+          const modulePath = join(categoryPath, mod.name);
+          const moduleJsPath = join(modulePath, "module.js");
+
+          // Check module.js exists
+          const moduleJsExists = await stat(moduleJsPath)
+            .then(() => true)
+            .catch(() => false);
+          expect(moduleJsExists).toBe(true);
+
+          // Check templates directory exists (optional for some modules)
+          const templatesPath = join(modulePath, "templates");
+          const templatesExist = await stat(templatesPath)
+            .then((s) => s.isDirectory())
+            .catch(() => false);
+
+          // Most modules should have templates
+          if (!templatesExist) {
+            console.warn(`Warning: ${category}/${mod.name} has no templates directory`);
+          }
+        }
+      } catch {
+        // Category might not exist
+        console.warn(`Warning: Category ${category} not found`);
+      }
+    });
+  }
+});

package/dist/templates/plopfiles/_modules/backends/go-chi/module.js

@@ -0,0 +1,43 @@
+/**
+ * Go + Chi 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 = "Go backend with Chi router";
+
+export const scripts = {
+  "dev:backend": "cd backend && air",
+  "build:backend": "cd backend && go build -o bin/server ./cmd/server",
+  "start:backend": "cd backend && ./bin/server",
+  "test:backend": "cd backend && go test ./...",
+  "lint:backend": "cd backend && golangci-lint run",
+  "lint:backend:fix": "cd backend && golangci-lint run --fix",
+  "format:backend": "cd backend && gofmt -s -w .",
+  "docs:backend": "cd backend && godoc -http=:6060",
+};
+
+export const envVars = {
+  PORT: "3000",
+  DATABASE_URL: "postgresql://postgres:postgres@localhost:5432/{{snakeCase name}}",
+  GO_ENV: "development",
+};

package/dist/templates/plopfiles/_modules/backends/go-chi/templates/.air.toml.hbs

@@ -0,0 +1,30 @@
+root = "."
+tmp_dir = "tmp"
+
+[build]
+  cmd = "go build -o ./tmp/main ./cmd/server"
+  bin = "./tmp/main"
+  delay = 1000
+  exclude_dir = ["assets", "tmp", "vendor", "node_modules"]
+  exclude_file = []
+  exclude_regex = ["_test.go"]
+  exclude_unchanged = false
+  follow_symlink = false
+  include_ext = ["go", "tpl", "tmpl", "html"]
+  kill_delay = "0s"
+  log = "build-errors.log"
+  send_interrupt = false
+  stop_on_error = true
+
+[color]
+  app = ""
+  build = "yellow"
+  main = "magenta"
+  runner = "green"
+  watcher = "cyan"
+
+[log]
+  time = false
+
+[misc]
+  clean_on_exit = false

package/dist/templates/plopfiles/_modules/backends/go-chi/templates/cmd/server/main.go.hbs

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/go-chi/cors"
+	"github.com/joho/godotenv"
+
+	"{{kebabCase name}}/internal/handlers"
+)
+
+func main() {
+	// Load .env file
+	godotenv.Load()
+
+	port := os.Getenv("PORT")
+	if port == "" {
+		port = "3000"
+	}
+
+	r := chi.NewRouter()
+
+	// Middleware
+	r.Use(middleware.Logger)
+	r.Use(middleware.Recoverer)
+	r.Use(middleware.RequestID)
+	r.Use(cors.Handler(cors.Options{
+		AllowedOrigins:   []string{"*"},
+		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type"},
+		AllowCredentials: true,
+	}))
+
+	// Routes
+	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+		json.NewEncoder(w).Encode(map[string]string{
+			"message": "Welcome to {{titleCase name}} API",
+		})
+	})
+
+	r.Mount("/health", handlers.HealthRouter())
+
+	log.Printf("{{titleCase name}} listening on port %s", port)
+	http.ListenAndServe(":"+port, r)
+}

package/dist/templates/plopfiles/_modules/backends/go-chi/templates/go.mod.hbs

@@ -0,0 +1,9 @@
+module {{kebabCase name}}
+
+go 1.21
+
+require (
+	github.com/go-chi/chi/v5 v5.0.11
+	github.com/go-chi/cors v1.2.1
+	github.com/joho/godotenv v1.5.1
+)

package/dist/templates/plopfiles/_modules/backends/go-chi/templates/internal/handlers/health.go.hbs

@@ -0,0 +1,51 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type HealthResponse struct {
+	Status    string `json:"status"`
+	Timestamp string `json:"timestamp"`
+	Service   string `json:"service"`
+}
+
+type ReadyResponse struct {
+	Ready bool `json:"ready"`
+}
+
+type LiveResponse struct {
+	Alive bool `json:"alive"`
+}
+
+func HealthRouter() chi.Router {
+	r := chi.NewRouter()
+	r.Get("/", healthCheck)
+	r.Get("/ready", readinessCheck)
+	r.Get("/live", livenessCheck)
+	return r
+}
+
+func healthCheck(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(HealthResponse{
+		Status:    "ok",
+		Timestamp: time.Now().UTC().Format(time.RFC3339),
+		Service:   "{{kebabCase name}}-backend",
+	})
+}
+
+func readinessCheck(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	// Add database/service checks here
+	json.NewEncoder(w).Encode(ReadyResponse{Ready: true})
+}
+
+func livenessCheck(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(LiveResponse{Alive: true})
+}

package/dist/templates/plopfiles/_modules/backends/kotlin-ktor/module.js

@@ -0,0 +1,38 @@
+/**
+ * Kotlin + Ktor 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 = "Kotlin backend with Ktor framework";
+
+export const scripts = {
+  "dev:backend": "cd backend && ./gradlew run --continuous",
+  "build:backend": "cd backend && ./gradlew build",
+  "start:backend": "cd backend && ./gradlew run",
+  "test:backend": "cd backend && ./gradlew test",
+};
+
+export const envVars = {
+  PORT: "3000",
+  DATABASE_URL: "postgresql://postgres:postgres@localhost:5432/{{snakeCase name}}",
+};

package/dist/templates/plopfiles/_modules/backends/kotlin-ktor/templates/build.gradle.kts.hbs

@@ -0,0 +1,37 @@
+plugins {
+    kotlin("jvm") version "1.9.22"
+    kotlin("plugin.serialization") version "1.9.22"
+    id("io.ktor.plugin") version "2.3.7"
+}
+
+group = "com.{{snakeCase name}}"
+version = "0.1.0"
+
+application {
+    mainClass.set("com.{{snakeCase name}}.ApplicationKt")
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    // Ktor server
+    implementation("io.ktor:ktor-server-core-jvm")
+    implementation("io.ktor:ktor-server-netty-jvm")
+    implementation("io.ktor:ktor-server-content-negotiation-jvm")
+    implementation("io.ktor:ktor-serialization-kotlinx-json-jvm")
+    implementation("io.ktor:ktor-server-cors-jvm")
+    implementation("io.ktor:ktor-server-call-logging-jvm")
+    implementation("io.ktor:ktor-server-status-pages-jvm")
+
+    // Logging
+    implementation("ch.qos.logback:logback-classic:1.4.14")
+
+    // Config
+    implementation("io.github.cdimascio:dotenv-kotlin:6.4.1")
+
+    // Testing
+    testImplementation("io.ktor:ktor-server-tests-jvm")
+    testImplementation("org.jetbrains.kotlin:kotlin-test-junit:1.9.22")
+}

package/dist/templates/plopfiles/_modules/backends/kotlin-ktor/templates/settings.gradle.kts.hbs

@@ -0,0 +1 @@
+rootProject.name = "{{kebabCase name}}"

package/dist/templates/plopfiles/_modules/backends/kotlin-ktor/templates/src/main/kotlin/Application.kt.hbs

@@ -0,0 +1,44 @@
+package com.{{snakeCase name}}
+
+import io.github.cdimascio.dotenv.dotenv
+import io.ktor.serialization.kotlinx.json.*
+import io.ktor.server.application.*
+import io.ktor.server.engine.*
+import io.ktor.server.netty.*
+import io.ktor.server.plugins.contentnegotiation.*
+import io.ktor.server.plugins.cors.routing.*
+import io.ktor.server.plugins.calllogging.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import kotlinx.serialization.Serializable
+import com.{{snakeCase name}}.routes.healthRoutes
+
+val dotenv = dotenv {
+    ignoreIfMissing = true
+}
+
+@Serializable
+data class Message(val message: String)
+
+fun main() {
+    val port = dotenv["PORT"]?.toIntOrNull() ?: 3000
+
+    embeddedServer(Netty, port = port) {
+        install(ContentNegotiation) {
+            json()
+        }
+        install(CORS) {
+            anyHost()
+            allowHeader("Content-Type")
+            allowHeader("Authorization")
+        }
+        install(CallLogging)
+
+        routing {
+            get("/") {
+                call.respond(Message("Welcome to {{titleCase name}} API"))
+            }
+            healthRoutes()
+        }
+    }.start(wait = true)
+}

package/dist/templates/plopfiles/_modules/backends/kotlin-ktor/templates/src/main/kotlin/routes/Health.kt.hbs

@@ -0,0 +1,41 @@
+package com.{{snakeCase name}}.routes
+
+import io.ktor.server.application.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import kotlinx.serialization.Serializable
+import java.time.Instant
+
+@Serializable
+data class HealthResponse(
+    val status: String,
+    val timestamp: String,
+    val service: String
+)
+
+@Serializable
+data class ReadyResponse(val ready: Boolean)
+
+@Serializable
+data class LiveResponse(val alive: Boolean)
+
+fun Route.healthRoutes() {
+    route("/health") {
+        get {
+            call.respond(HealthResponse(
+                status = "ok",
+                timestamp = Instant.now().toString(),
+                service = "{{kebabCase name}}-backend"
+            ))
+        }
+
+        get("/ready") {
+            // Add database/service checks here
+            call.respond(ReadyResponse(ready = true))
+        }
+
+        get("/live") {
+            call.respond(LiveResponse(alive = true))
+        }
+    }
+}