@sibyllinesoft/arbiter 0.1.0

package/dist/templates/plopfiles/_modules/composer.js

@@ -0,0 +1,180 @@
+/**
+ * Module Composer
+ *
+ * Dynamically loads and composes template modules based on selections.
+ * Used by the full-stack plopfile and can be used programmatically.
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathExists } from "fs-extra";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Load a template module by category and name
+ *
+ * @param {string} category - backends, frontends, databases, or infra
+ * @param {string} name - module name (e.g., "node-hono", "react-vite")
+ * @returns {Promise<import('./types').TemplateModule>}
+ */
+export async function loadModule(category, name) {
+  const modulePath = resolve(__dirname, category, name, "module.js");
+
+  if (!(await pathExists(modulePath))) {
+    throw new Error(`Module not found: ${category}/${name} (looked in ${modulePath})`);
+  }
+
+  return import(modulePath);
+}
+
+/**
+ * List available modules in a category
+ *
+ * @param {string} category
+ * @returns {Promise<string[]>}
+ */
+export async function listModules(category) {
+  const { readdir } = await import("fs/promises");
+  const categoryPath = resolve(__dirname, category);
+
+  try {
+    const entries = await readdir(categoryPath, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_")).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Compose multiple modules into a single manifest
+ *
+ * @param {object} selections - { backend, frontend, database, desktop, mobile, infra[], cloud[], build[] }
+ * @param {import('./types').ModuleContext} context
+ * @returns {Promise<{ actions: any[], manifest: import('./types').ComposedManifest }>}
+ */
+export async function composeModules(selections, context) {
+  const actions = [];
+  const manifest = {
+    name: context.name,
+    modules: [],
+    dependencies: {},
+    devDependencies: {},
+    scripts: {},
+    envVars: {},
+  };
+
+  // Helper to merge module into manifest
+  const mergeModule = (mod, name) => {
+    manifest.modules.push(name);
+    Object.assign(manifest.dependencies, mod.dependencies || {});
+    Object.assign(manifest.devDependencies, mod.devDependencies || {});
+    Object.assign(manifest.scripts, mod.scripts || {});
+    Object.assign(manifest.envVars, mod.envVars || {});
+  };
+
+  // Load backend
+  if (selections.backend && selections.backend !== "none") {
+    const mod = await loadModule("backends", selections.backend);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `backends/${selections.backend}`);
+  }
+
+  // Load frontend
+  if (selections.frontend && selections.frontend !== "none") {
+    const mod = await loadModule("frontends", selections.frontend);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `frontends/${selections.frontend}`);
+  }
+
+  // Load database
+  if (selections.database && selections.database !== "none") {
+    const mod = await loadModule("databases", selections.database);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `databases/${selections.database}`);
+  }
+
+  // Load desktop module
+  if (selections.desktop && selections.desktop !== "none") {
+    const mod = await loadModule("desktop", selections.desktop);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `desktop/${selections.desktop}`);
+  }
+
+  // Load mobile module
+  if (selections.mobile && selections.mobile !== "none") {
+    const mod = await loadModule("mobile", selections.mobile);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `mobile/${selections.mobile}`);
+  }
+
+  // Load infra modules
+  for (const infraName of selections.infra || []) {
+    const mod = await loadModule("infra", infraName);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `infra/${infraName}`);
+  }
+
+  // Load cloud modules
+  for (const cloudName of selections.cloud || []) {
+    const mod = await loadModule("cloud", cloudName);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `cloud/${cloudName}`);
+  }
+
+  // Load build system modules
+  for (const buildName of selections.build || []) {
+    const mod = await loadModule("build", buildName);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `build/${buildName}`);
+  }
+
+  // Load docs modules
+  for (const docsName of selections.docs || []) {
+    const mod = await loadModule("docs", docsName);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `docs/${docsName}`);
+  }
+
+  // Load quality/linting modules
+  for (const qualityName of selections.quality || []) {
+    const mod = await loadModule("quality", qualityName);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `quality/${qualityName}`);
+  }
+
+  // Load storybook modules
+  for (const storybookName of selections.storybook || []) {
+    const mod = await loadModule("storybook", storybookName);
+    actions.push(...mod.default(context));
+    mergeModule(mod, `storybook/${storybookName}`);
+  }
+
+  return { actions, manifest };
+}
+
+/**
+ * Get all available module choices for prompts
+ */
+export async function getModuleChoices() {
+  return {
+    backends: await listModules("backends"),
+    frontends: ["none", ...(await listModules("frontends"))],
+    databases: ["none", ...(await listModules("databases"))],
+    desktop: ["none", ...(await listModules("desktop"))],
+    mobile: ["none", ...(await listModules("mobile"))],
+    infra: await listModules("infra"),
+    cloud: await listModules("cloud"),
+    build: await listModules("build"),
+    docs: await listModules("docs"),
+    quality: await listModules("quality"),
+    storybook: await listModules("storybook"),
+  };
+}
+
+export default {
+  loadModule,
+  listModules,
+  composeModules,
+  getModuleChoices,
+};

package/dist/templates/plopfiles/_modules/databases/postgres-drizzle/drizzle.config.ts.hbs

@@ -0,0 +1,10 @@
+import type { Config } from "drizzle-kit";
+
+export default {
+  schema: "./{{backendDir}}/src/db/schema.ts",
+  out: "./{{backendDir}}/drizzle",
+  driver: "pg",
+  dbCredentials: {
+    connectionString: process.env.DATABASE_URL!,
+  },
+} satisfies Config;

package/dist/templates/plopfiles/_modules/databases/postgres-drizzle/module.js

@@ -0,0 +1,53 @@
+/**
+ * PostgreSQL + Drizzle ORM 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}/src/db`,
+      base: templatesDir,
+      templateFiles: `${templatesDir}/**/*.hbs`,
+      stripExtensions: ["hbs"],
+      data,
+    },
+    // Add drizzle config to backend root
+    {
+      type: "add",
+      path: `{{projectDir}}/${backendDir}/drizzle.config.ts`,
+      templateFile: `${templatesDir}/../drizzle.config.ts.hbs`,
+    },
+  ];
+}
+
+export const description = "PostgreSQL database with Drizzle ORM";
+
+export const dependencies = {
+  "drizzle-orm": "^0.29.0",
+  postgres: "^3.4.0",
+};
+
+export const devDependencies = {
+  "drizzle-kit": "^0.20.0",
+};
+
+export const scripts = {
+  "db:generate": "drizzle-kit generate:pg --config backend/drizzle.config.ts",
+  "db:push": "drizzle-kit push:pg --config backend/drizzle.config.ts",
+  "db:studio": "drizzle-kit studio --config backend/drizzle.config.ts",
+};
+
+export const envVars = {
+  DATABASE_URL: "postgres://postgres:postgres@localhost:5432/{{snakeCase name}}",
+};
+
+export const requires = ["backends/*"];

package/dist/templates/plopfiles/_modules/databases/postgres-drizzle/templates/index.ts.hbs

@@ -0,0 +1,15 @@
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as schema from "./schema";
+
+const connectionString = process.env.DATABASE_URL!;
+
+if (!connectionString) {
+  throw new Error("DATABASE_URL environment variable is not set");
+}
+
+const client = postgres(connectionString);
+
+export const db = drizzle(client, { schema });
+
+export * from "./schema";

package/dist/templates/plopfiles/_modules/databases/postgres-drizzle/templates/schema.ts.hbs

@@ -0,0 +1,21 @@
+import { pgTable, serial, text, timestamp, boolean, integer } from "drizzle-orm/pg-core";
+
+// Example: Users table
+export const users = pgTable("users", {
+  id: serial("id").primaryKey(),
+  email: text("email").notNull().unique(),
+  name: text("name"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});
+
+// Add your schema definitions here
+// Example:
+// export const posts = pgTable("posts", {
+//   id: serial("id").primaryKey(),
+//   title: text("title").notNull(),
+//   content: text("content"),
+//   authorId: integer("author_id").references(() => users.id),
+//   published: boolean("published").default(false),
+//   createdAt: timestamp("created_at").defaultNow().notNull(),
+// });

package/dist/templates/plopfiles/_modules/desktop/electron/module.js

@@ -0,0 +1,51 @@
+/**
+ * Electron Desktop 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 desktopDir = data.desktopDir || "desktop";
+
+  return [
+    {
+      type: "addMany",
+      destination: `{{projectDir}}/${desktopDir}`,
+      base: templatesDir,
+      templateFiles: `${templatesDir}/**/*.hbs`,
+      stripExtensions: ["hbs"],
+      data,
+    },
+  ];
+}
+
+export const description = "Electron desktop application with TypeScript";
+
+export const dependencies = {
+  electron: "^28.0.0",
+};
+
+export const devDependencies = {
+  "@electron-forge/cli": "^7.2.0",
+  "@electron-forge/maker-deb": "^7.2.0",
+  "@electron-forge/maker-rpm": "^7.2.0",
+  "@electron-forge/maker-squirrel": "^7.2.0",
+  "@electron-forge/maker-zip": "^7.2.0",
+  "@electron-forge/plugin-auto-unpack-natives": "^7.2.0",
+  "@electron-forge/plugin-vite": "^7.2.0",
+  typescript: "^5.3.0",
+};
+
+export const scripts = {
+  "dev:desktop": "cd desktop && electron-forge start",
+  "build:desktop": "cd desktop && electron-forge make",
+  "package:desktop": "cd desktop && electron-forge package",
+};
+
+export const envVars = {
+  ELECTRON_IS_DEV: "1",
+};

package/dist/templates/plopfiles/_modules/desktop/electron/templates/forge.config.ts.hbs

@@ -0,0 +1,38 @@
+import type { ForgeConfig } from "@electron-forge/shared-types";
+import { MakerSquirrel } from "@electron-forge/maker-squirrel";
+import { MakerZIP } from "@electron-forge/maker-zip";
+import { MakerDeb } from "@electron-forge/maker-deb";
+import { MakerRpm } from "@electron-forge/maker-rpm";
+import { VitePlugin } from "@electron-forge/plugin-vite";
+import { AutoUnpackNativesPlugin } from "@electron-forge/plugin-auto-unpack-natives";
+
+const config: ForgeConfig = {
+  packagerConfig: {
+    asar: true,
+  },
+  rebuildConfig: {},
+  makers: [
+    new MakerSquirrel({}),
+    new MakerZIP({}, ["darwin"]),
+    new MakerRpm({}),
+    new MakerDeb({}),
+  ],
+  plugins: [
+    new AutoUnpackNativesPlugin({}),
+    new VitePlugin({
+      build: [
+        {
+          entry: "src/main.ts",
+          config: "vite.main.config.ts",
+        },
+        {
+          entry: "src/preload.ts",
+          config: "vite.preload.config.ts",
+        },
+      ],
+      renderer: [],
+    }),
+  ],
+};
+
+export default config;

package/dist/templates/plopfiles/_modules/desktop/electron/templates/package.json.hbs

@@ -0,0 +1,22 @@
+{
+  "name": "{{kebabCase name}}-desktop",
+  "version": "0.1.0",
+  "description": "{{titleCase name}} desktop application",
+  "main": "dist/main.js",
+  "scripts": {
+    "start": "electron-forge start",
+    "package": "electron-forge package",
+    "make": "electron-forge make"
+  },
+  "devDependencies": {
+    "@electron-forge/cli": "^7.2.0",
+    "@electron-forge/maker-deb": "^7.2.0",
+    "@electron-forge/maker-rpm": "^7.2.0",
+    "@electron-forge/maker-squirrel": "^7.2.0",
+    "@electron-forge/maker-zip": "^7.2.0",
+    "@electron-forge/plugin-auto-unpack-natives": "^7.2.0",
+    "@electron-forge/plugin-vite": "^7.2.0",
+    "electron": "^28.0.0",
+    "typescript": "^5.3.0"
+  }
+}

package/dist/templates/plopfiles/_modules/desktop/electron/templates/src/main.ts.hbs

@@ -0,0 +1,48 @@
+import { app, BrowserWindow, ipcMain } from "electron";
+import path from "path";
+
+const isDev = process.env.ELECTRON_IS_DEV === "1";
+
+function createWindow() {
+  const mainWindow = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    webPreferences: {
+      preload: path.join(__dirname, "preload.js"),
+      nodeIntegration: false,
+      contextIsolation: true,
+    },
+  });
+
+  if (isDev) {
+    // Load from Vite dev server
+    mainWindow.loadURL("http://localhost:5173");
+    mainWindow.webContents.openDevTools();
+  } else {
+    // Load built frontend
+    mainWindow.loadFile(path.join(__dirname, "../frontend/dist/index.html"));
+  }
+
+  return mainWindow;
+}
+
+app.whenReady().then(() => {
+  createWindow();
+
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
+      createWindow();
+    }
+  });
+});
+
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});
+
+// IPC handlers
+ipcMain.handle("app:version", () => {
+  return app.getVersion();
+});

package/dist/templates/plopfiles/_modules/desktop/electron/templates/src/preload.ts.hbs

@@ -0,0 +1,18 @@
+import { contextBridge, ipcRenderer } from "electron";
+
+// Expose protected methods that allow the renderer process to use
+// the ipcRenderer without exposing the entire object
+contextBridge.exposeInMainWorld("electronAPI", {
+  getVersion: () => ipcRenderer.invoke("app:version"),
+  platform: process.platform,
+});
+
+// Type declarations for the renderer
+declare global {
+  interface Window {
+    electronAPI: {
+      getVersion: () => Promise<string>;
+      platform: NodeJS.Platform;
+    };
+  }
+}

package/dist/templates/plopfiles/_modules/desktop/electron/templates/tsconfig.json.hbs

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

package/dist/templates/plopfiles/_modules/desktop/tauri/module.js

@@ -0,0 +1,38 @@
+/**
+ * Tauri Desktop 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) {
+  return [
+    {
+      type: "addMany",
+      destination: "{{projectDir}}",
+      base: templatesDir,
+      templateFiles: `${templatesDir}/**/*.hbs`,
+      stripExtensions: ["hbs"],
+      data,
+    },
+  ];
+}
+
+export const description = "Tauri desktop application (Rust + Web frontend)";
+
+export const devDependencies = {
+  "@tauri-apps/cli": "^1.5.0",
+  "@tauri-apps/api": "^1.5.0",
+};
+
+export const scripts = {
+  "dev:desktop": "tauri dev",
+  "build:desktop": "tauri build",
+};
+
+export const envVars = {
+  TAURI_DEBUG: "1",
+};

package/dist/templates/plopfiles/_modules/desktop/tauri/templates/src-tauri/Cargo.toml.hbs

@@ -0,0 +1,20 @@
+[package]
+name = "{{snakeCase name}}"
+version = "0.1.0"
+description = "{{titleCase name}} desktop application"
+authors = ["you"]
+license = ""
+repository = ""
+edition = "2021"
+
+[build-dependencies]
+tauri-build = { version = "1.5", features = [] }
+
+[dependencies]
+tauri = { version = "1.5", features = ["shell-open"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+[features]
+default = ["custom-protocol"]
+custom-protocol = ["tauri/custom-protocol"]

package/dist/templates/plopfiles/_modules/desktop/tauri/templates/src-tauri/build.rs.hbs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

package/dist/templates/plopfiles/_modules/desktop/tauri/templates/src-tauri/src/main.rs.hbs

@@ -0,0 +1,30 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use tauri::Manager;
+
+// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command
+#[tauri::command]
+fn greet(name: &str) -> String {
+    format!("Hello, {}! You've been greeted from Rust!", name)
+}
+
+#[tauri::command]
+fn get_app_version(app: tauri::AppHandle) -> String {
+    app.package_info().version.to_string()
+}
+
+fn main() {
+    tauri::Builder::default()
+        .setup(|app| {
+            #[cfg(debug_assertions)]
+            {
+                let window = app.get_window("main").unwrap();
+                window.open_devtools();
+            }
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![greet, get_app_version])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}

package/dist/templates/plopfiles/_modules/desktop/tauri/templates/src-tauri/tauri.conf.json.hbs

@@ -0,0 +1,44 @@
+{
+  "build": {
+    "beforeDevCommand": "npm run dev:frontend",
+    "beforeBuildCommand": "npm run build:frontend",
+    "devPath": "http://localhost:5173",
+    "distDir": "../frontend/dist"
+  },
+  "package": {
+    "productName": "{{titleCase name}}",
+    "version": "0.1.0"
+  },
+  "tauri": {
+    "allowlist": {
+      "all": false,
+      "shell": {
+        "open": true
+      }
+    },
+    "bundle": {
+      "active": true,
+      "targets": "all",
+      "identifier": "com.{{snakeCase name}}.app",
+      "icon": [
+        "icons/32x32.png",
+        "icons/128x128.png",
+        "icons/128x128@2x.png",
+        "icons/icon.icns",
+        "icons/icon.ico"
+      ]
+    },
+    "security": {
+      "csp": null
+    },
+    "windows": [
+      {
+        "fullscreen": false,
+        "resizable": true,
+        "title": "{{titleCase name}}",
+        "width": 1200,
+        "height": 800
+      }
+    ]
+  }
+}

package/dist/templates/plopfiles/_modules/docs/mkdocs/module.js

@@ -0,0 +1,61 @@
+/**
+ * MkDocs Documentation Module
+ *
+ * Sets up MkDocs with Material theme for monorepo documentation.
+ * Automatically aggregates docs from subprojects into a unified site.
+ */
+
+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 docsDir = data.docsDir || "docs";
+
+  return [
+    {
+      type: "addMany",
+      destination: `{{projectDir}}`,
+      base: templatesDir,
+      templateFiles: `${templatesDir}/**/*.hbs`,
+      stripExtensions: ["hbs"],
+      data: {
+        ...data,
+        docsDir,
+        // Collect subprojects for nav aggregation
+        subprojects: data.modules || [],
+      },
+    },
+  ];
+}
+
+export const description = "MkDocs documentation with Material theme and monorepo aggregation";
+
+export const dependencies = {};
+
+export const devDependencies = {};
+
+export const scripts = {
+  "docs:serve": "mkdocs serve",
+  "docs:build": "mkdocs build",
+  "docs:deploy": "mkdocs gh-deploy",
+  "docs:aggregate": "node scripts/aggregate-docs.mjs",
+};
+
+export const envVars = {};
+
+// Python requirements for mkdocs
+export const pythonRequirements = [
+  "mkdocs>=1.5.0",
+  "mkdocs-material>=9.5.0",
+  "mkdocs-monorepo-plugin>=1.0.0",
+  "mkdocs-awesome-pages-plugin>=2.9.0",
+  "mkdocs-git-revision-date-localized-plugin>=1.2.0",
+  "mkdocs-minify-plugin>=0.7.0",
+  "mkdocstrings[python]>=0.24.0",
+  "mkdocs-gen-files>=0.5.0",
+  "mkdocs-literate-nav>=0.6.0",
+  "mkdocs-section-index>=0.3.0",
+];