bosbun 0.0.1

package/README.md

@@ -0,0 +1,163 @@
+# bunia
+
+The `bunia` package — framework core + CLI.
+
+## Installation
+
+```bash
+bun add bunia
+```
+
+Or scaffold a new project:
+
+```bash
+bunx bunia create my-app
+```
+
+## CLI
+
+```
+bunia <command>
+
+Commands:
+  create <name>       Scaffold a new Bunia project
+  dev                 Start the development server (port 3000)
+  build               Build for production
+  start               Run the production server
+  add <component>     Install a UI component from the registry
+  feat <feature>      Install a feature scaffold from the registry
+```
+
+## Routing Conventions
+
+Files in `src/routes/` map to URLs automatically.
+
+| File | Purpose |
+|------|---------|
+| `+page.svelte` | Page component |
+| `+layout.svelte` | Layout that wraps child pages |
+| `+page.server.ts` | Server loader for a page |
+| `+layout.server.ts` | Server loader for a layout |
+| `+server.ts` | API endpoint (export HTTP verbs) |
+
+### Dynamic Routes
+
+| Pattern | Matches |
+|---------|---------|
+| `[param]` | `/blog/hello` → `params.param = "hello"` |
+| `[...rest]` | `/a/b/c` → `params.rest = "a/b/c"` |
+
+### Route Groups
+
+Wrap a directory in parentheses to share a layout without affecting the URL:
+
+```
+src/routes/
+└── (marketing)/
+    ├── +layout.svelte   # shared layout
+    ├── +page.svelte     # /
+    └── about/
+        └── +page.svelte # /about
+```
+
+## Server Loaders
+
+```typescript
+// src/routes/blog/[slug]/+page.server.ts
+import type { LoadEvent } from "bunia";
+
+export async function load({ params, url, locals, fetch, parent }: LoadEvent) {
+    const parentData = await parent(); // data from layout loaders above
+    return {
+        post: await getPost(params.slug),
+    };
+}
+```
+
+Data returned is passed as the `data` prop to `+page.svelte`:
+
+```svelte
+<script lang="ts">
+    let { data } = $props();
+    // data.post, data.params ...
+</script>
+```
+
+## API Routes
+
+Export named HTTP verb functions from `+server.ts`:
+
+```typescript
+// src/routes/api/items/+server.ts
+import type { RequestEvent } from "bunia";
+
+export function GET({ params, url, locals }: RequestEvent) {
+    return Response.json({ items: [] });
+}
+
+export async function POST({ request }: RequestEvent) {
+    const body = await request.json();
+    return Response.json({ created: body }, { status: 201 });
+}
+```
+
+## Middleware Hooks
+
+Create `src/hooks.server.ts` to intercept every request:
+
+```typescript
+import { sequence } from "bunia";
+import type { Handle } from "bunia";
+
+const authHandle: Handle = async ({ event, resolve }) => {
+    event.locals.user = await getUser(event.request);
+    return resolve(event);
+};
+
+const loggingHandle: Handle = async ({ event, resolve }) => {
+    const res = await resolve(event);
+    console.log(`${event.request.method} ${event.url.pathname} ${res.status}`);
+    return res;
+};
+
+export const handle = sequence(authHandle, loggingHandle);
+```
+
+`locals` set here are available in every loader and API handler.
+
+## Public API
+
+```typescript
+import { cn, sequence } from "bunia";
+import type { RequestEvent, LoadEvent, Handle } from "bunia";
+```
+
+| Export | Description |
+|--------|-------------|
+| `cn(...classes)` | Tailwind class merge utility (clsx + tailwind-merge) |
+| `sequence(...handlers)` | Compose multiple `Handle` middleware functions |
+| `RequestEvent` | Type for API route and hook handlers |
+| `LoadEvent` | Type for `load()` in `+page.server.ts` / `+layout.server.ts` |
+| `Handle` | Type for a middleware function in `hooks.server.ts` |
+
+## Path Alias
+
+`$lib` maps to `src/lib/` out of the box:
+
+```typescript
+import { myUtil } from "$lib/utils";
+```
+
+## Project Structure
+
+```
+my-app/
+├── src/
+│   ├── app.css              # Global styles + Tailwind config
+│   ├── hooks.server.ts      # Optional request middleware
+│   ├── lib/                 # Shared utilities ($lib alias)
+│   └── routes/              # File-based routes
+├── public/                  # Static assets (served as-is)
+├── dist/                    # Build output (git-ignored)
+└── package.json
+```

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "bosbun",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "A minimalist fullstack framework — SSR + Svelte 5 Runes + Bun + ElysiaJS",
+  "keywords": [
+    "bun",
+    "svelte",
+    "ssr",
+    "elysia",
+    "fullstack",
+    "framework"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Jekibus",
+    "url": "https://bosapi.com"
+  },
+  "homepage": "https://github.com/bosapi/bunia#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bosapi/bunia.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bosapi/bunia/issues"
+  },
+  "files": [
+    "src",
+    "templates",
+    "README.md",
+    "package.json"
+  ],
+  "exports": {
+    ".": "./src/lib/index.ts"
+  },
+  "bin": {
+    "bunia": "src/cli/index.ts"
+  },
+  "scripts": {
+    "check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@elysiajs/static": "^1.4.7",
+    "@tailwindcss/cli": "^4.2.1",
+    "bun-plugin-svelte": "^0.0.6",
+    "clsx": "^2.1.1",
+    "elysia": "^1.4.26",
+    "svelte": "^5.53.6",
+    "tailwind-merge": "^3.5.0",
+    "tailwindcss": "^4.2.1"
+  }
+}

package/src/cli/add.ts

@@ -0,0 +1,83 @@
+import { join, dirname } from "path";
+import { mkdirSync, writeFileSync } from "fs";
+import { spawn } from "bun";
+
+// ─── bunia add <component> ────────────────────────────────
+// Fetches a component from the GitHub registry and copies it
+// into the user's src/lib/components/ui/<name>/ directory.
+
+const REGISTRY_BASE = "https://raw.githubusercontent.com/bosapi/bunia/main/registry";
+
+interface ComponentMeta {
+    name: string;
+    description: string;
+    dependencies: string[];   // other bunia components required
+    files: string[];
+    npmDeps: Record<string, string>;
+}
+
+// Track already-installed components within a session to avoid re-running deps
+const installed = new Set<string>();
+
+export async function runAdd(name: string | undefined) {
+    if (!name) {
+        console.error("❌ Please provide a component name.\n   Usage: bunia add <component>");
+        process.exit(1);
+    }
+    await addComponent(name, true);
+}
+
+export async function addComponent(name: string, root = false) {
+    if (installed.has(name)) return;
+    installed.add(name);
+
+    console.log(root ? `🐰 Installing component: ${name}\n` : `   📦 Dependency: ${name}`);
+
+    const meta = await fetchJSON<ComponentMeta>(`${REGISTRY_BASE}/components/${name}/meta.json`);
+
+    // Install component dependencies first (recursive)
+    for (const dep of meta.dependencies) {
+        await addComponent(dep, false);
+    }
+
+    // Download component files into src/lib/components/ui/<name>/
+    const destDir = join(process.cwd(), "src", "lib", "components", "ui", name);
+    mkdirSync(destDir, { recursive: true });
+
+    for (const file of meta.files) {
+        const content = await fetchText(`${REGISTRY_BASE}/components/${name}/${file}`);
+        const dest = join(destDir, file);
+        mkdirSync(dirname(dest), { recursive: true });
+        writeFileSync(dest, content, "utf-8");
+        console.log(`   ✍️  src/lib/components/ui/${name}/${file}`);
+    }
+
+    // Install npm dependencies
+    const npmEntries = Object.entries(meta.npmDeps);
+    if (npmEntries.length > 0) {
+        const packages = npmEntries.map(([pkg, ver]) => (ver ? `${pkg}@${ver}` : pkg));
+        console.log(`   📥 npm: ${packages.join(", ")}`);
+        const proc = spawn(["bun", "add", ...packages], {
+            stdout: "inherit",
+            stderr: "inherit",
+            cwd: process.cwd(),
+        });
+        if ((await proc.exited) !== 0) {
+            console.warn(`   ⚠️  bun add failed for: ${packages.join(", ")}`);
+        }
+    }
+
+    if (root) console.log(`\n✅ ${name} installed at src/lib/components/ui/${name}/`);
+}
+
+async function fetchJSON<T>(url: string): Promise<T> {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Failed to fetch ${url} (${res.status})`);
+    return res.json() as Promise<T>;
+}
+
+async function fetchText(url: string): Promise<string> {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Failed to fetch ${url} (${res.status})`);
+    return res.text();
+}

package/src/cli/build.ts

@@ -0,0 +1,16 @@
+import { spawn } from "bun";
+import { resolve } from "path";
+import { loadEnv } from "../core/env.ts";
+
+export async function runBuild() {
+    loadEnv("production");
+    const buildScript = resolve(import.meta.dir, "../core/build.ts");
+    const proc = spawn(["bun", "run", buildScript], {
+        stdout: "inherit",
+        stderr: "inherit",
+        cwd: process.cwd(),
+        env: { ...process.env, NODE_ENV: process.env.NODE_ENV ?? "production" },
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) process.exit(exitCode ?? 1);
+}

package/src/cli/create.ts

@@ -0,0 +1,54 @@
+import { resolve, join, basename } from "path";
+import { existsSync, mkdirSync, readdirSync, statSync, readFileSync, writeFileSync } from "fs";
+import { spawn } from "bun";
+
+// ─── bunia create <name> ──────────────────────────────────
+
+const TEMPLATE_DIR = resolve(import.meta.dir, "../../templates/default");
+
+export async function runCreate(name: string | undefined) {
+    if (!name) {
+        console.error("❌ Please provide a project name.\n   Usage: bunia create my-app");
+        process.exit(1);
+    }
+
+    const targetDir = resolve(process.cwd(), name);
+
+    if (existsSync(targetDir)) {
+        console.error(`❌ Directory already exists: ${targetDir}`);
+        process.exit(1);
+    }
+
+    console.log(`🐰 Creating Bunia project: ${basename(targetDir)}\n`);
+
+    copyDir(TEMPLATE_DIR, targetDir, name);
+
+    console.log(`✅ Project created at ${targetDir}\n`);
+
+    console.log("Installing dependencies...");
+    const proc = spawn(["bun", "install"], {
+        stdout: "inherit",
+        stderr: "inherit",
+        cwd: targetDir,
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+        console.warn("⚠️  bun install failed — run it manually.");
+    } else {
+        console.log(`\n🎉 Ready!\n\n  cd ${name}\n  bun x bunia dev\n`);
+    }
+}
+
+function copyDir(src: string, dest: string, projectName: string) {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src, { withFileTypes: true })) {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath, projectName);
+        } else {
+            const content = readFileSync(srcPath, "utf-8").replaceAll("{{PROJECT_NAME}}", projectName);
+            writeFileSync(destPath, content, "utf-8");
+        }
+    }
+}

package/src/cli/dev.ts

@@ -0,0 +1,14 @@
+import { spawn } from "bun";
+import { resolve } from "path";
+import { loadEnv } from "../core/env.ts";
+
+export async function runDev() {
+    loadEnv("development");
+    const devScript = resolve(import.meta.dir, "../core/dev.ts");
+    const proc = spawn(["bun", "run", devScript], {
+        stdout: "inherit",
+        stderr: "inherit",
+        cwd: process.cwd(),
+    });
+    await proc.exited;
+}

package/src/cli/feat.ts

@@ -0,0 +1,80 @@
+import { join, dirname } from "path";
+import { mkdirSync, writeFileSync } from "fs";
+import { spawn } from "bun";
+import { addComponent } from "./add.ts";
+
+// ─── bunia feat <feature> ─────────────────────────────────
+// Fetches a feature scaffold from the GitHub registry.
+// Installs required components, copies route/lib files, installs npm deps.
+
+const REGISTRY_BASE = "https://raw.githubusercontent.com/bosapi/bunia/main/registry";
+
+interface FeatureMeta {
+    name: string;
+    description: string;
+    components: string[];              // bunia components to install via `bunia add`
+    files: string[];                   // source filenames in the registry feature dir
+    targets: string[];                 // destination paths relative to project root
+    npmDeps: Record<string, string>;
+}
+
+export async function runFeat(name: string | undefined) {
+    if (!name) {
+        console.error("❌ Please provide a feature name.\n   Usage: bunia feat <feature>");
+        process.exit(1);
+    }
+
+    console.log(`🐰 Installing feature: ${name}\n`);
+
+    const meta = await fetchJSON<FeatureMeta>(`${REGISTRY_BASE}/features/${name}/meta.json`);
+
+    // Install required UI components
+    if (meta.components.length > 0) {
+        console.log("📦 Installing required components...");
+        for (const comp of meta.components) {
+            await addComponent(comp, false);
+        }
+        console.log("");
+    }
+
+    // Copy feature files to their target paths
+    for (let i = 0; i < meta.files.length; i++) {
+        const file = meta.files[i]!;
+        const target = meta.targets[i] ?? file;
+        const content = await fetchText(`${REGISTRY_BASE}/features/${name}/${file}`);
+        const dest = join(process.cwd(), target);
+        mkdirSync(dirname(dest), { recursive: true });
+        writeFileSync(dest, content, "utf-8");
+        console.log(`   ✍️  ${target}`);
+    }
+
+    // Install npm dependencies
+    const npmEntries = Object.entries(meta.npmDeps);
+    if (npmEntries.length > 0) {
+        const packages = npmEntries.map(([pkg, ver]) => (ver ? `${pkg}@${ver}` : pkg));
+        console.log(`\n📥 npm: ${packages.join(", ")}`);
+        const proc = spawn(["bun", "add", ...packages], {
+            stdout: "inherit",
+            stderr: "inherit",
+            cwd: process.cwd(),
+        });
+        if ((await proc.exited) !== 0) {
+            console.warn(`⚠️  bun add failed for: ${packages.join(", ")}`);
+        }
+    }
+
+    console.log(`\n✅ Feature "${name}" scaffolded!`);
+    if (meta.description) console.log(`   ${meta.description}`);
+}
+
+async function fetchJSON<T>(url: string): Promise<T> {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Failed to fetch ${url} (${res.status})`);
+    return res.json() as Promise<T>;
+}
+
+async function fetchText(url: string): Promise<string> {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Failed to fetch ${url} (${res.status})`);
+    return res.text();
+}

package/src/cli/index.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env bun
+// ─── Bunia CLI ────────────────────────────────────────────
+//   bunia create <name>   scaffold a new project
+//   bunia dev             start the development server
+//   bunia build           build for production
+//   bunia start           run the production server
+//   bunia add <name>      add a UI component from the registry
+//   bunia feat <name>     add a feature scaffold from the registry
+
+const [, , command, ...args] = process.argv;
+
+async function main() {
+    switch (command) {
+        case "create": {
+            const { runCreate } = await import("./create.ts");
+            await runCreate(args[0]);
+            break;
+        }
+        case "dev": {
+            const { runDev } = await import("./dev.ts");
+            await runDev();
+            break;
+        }
+        case "build": {
+            const { runBuild } = await import("./build.ts");
+            await runBuild();
+            break;
+        }
+        case "start": {
+            const { runStart } = await import("./start.ts");
+            await runStart();
+            break;
+        }
+        case "add": {
+            const { runAdd } = await import("./add.ts");
+            await runAdd(args[0]);
+            break;
+        }
+        case "feat": {
+            const { runFeat } = await import("./feat.ts");
+            await runFeat(args[0]);
+            break;
+        }
+        default: {
+            console.log(`
+🐰 Bunia
+
+Usage:
+  bunia <command> [options]
+
+Commands:
+  create <name>       Scaffold a new Bunia project
+  dev                 Start the development server
+  build               Build for production
+  start               Run the production server
+  add <component>     Add a UI component from the registry
+  feat <feature>      Add a feature scaffold from the registry
+
+Examples:
+  bunia create my-app
+  bunia dev
+  bunia build
+  bunia start
+  bunia add button
+  bunia feat login
+`);
+            break;
+        }
+    }
+}
+
+main().catch((err) => {
+    console.error("❌", err.message);
+    process.exit(1);
+});

package/src/cli/start.ts

@@ -0,0 +1,28 @@
+import { spawn } from "bun";
+import { join } from "path";
+import { loadEnv } from "../core/env.ts";
+
+const BUNIA_NODE_MODULES = join(import.meta.dir, "..", "..", "node_modules");
+
+export async function runStart() {
+    loadEnv("production");
+
+    let serverEntry = "index.js";
+    try {
+        const manifest = await Bun.file("./dist/manifest.json").json();
+        serverEntry = manifest.serverEntry ?? "index.js";
+    } catch { }
+
+    const proc = spawn(["bun", "run", `dist/server/${serverEntry}`], {
+        stdout: "inherit",
+        stderr: "inherit",
+        cwd: process.cwd(),
+        env: {
+            ...process.env,
+            NODE_ENV: "production",
+            NODE_PATH: BUNIA_NODE_MODULES,
+        },
+    });
+
+    await proc.exited;
+}