bosia 0.0.0 → 0.1.1

package/README.md

@@ -1,15 +1,181 @@
-# asbun
+# Bosia
 
-To install dependencies:
+> Full documentation: [bosia.bosapi.com](https://bosia.bosapi.com)
+
+A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS.
+
+File-based routing inspired by SvelteKit, built on top of the Bun runtime and ElysiaJS HTTP server. No Node.js, no Vite, no adapters.
+
+## Features
+
+- **File-based routing** — `+page.svelte`, `+layout.svelte`, `+server.ts`, route groups, dynamic segments, catch-all routes
+- **Server-side rendering** — every page is rendered on the server with full hydration
+- **Server loaders** — `+page.server.ts` and `+layout.server.ts` with `parent()` data threading
+- **API routes** — `+server.ts` exports HTTP verbs (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`, `OPTIONS`)
+- **Middleware hooks** — `hooks.server.ts` with `sequence()` for auth, logging, locals
+- **Dev server with HMR** — file watcher + SSE browser reload, no page blink
+- **Tailwind CSS v4** — compiled at build time, shadcn-inspired design tokens out of the box
+- **CLI** — `bosia create`, `bosia dev`, `bosia build`, `bosia add`, `bosia feat`
+
+## Quick Start
 
 ```bash
-bun install
+# Scaffold a new project
+bun x bosia create my-app
+cd my-app
+
+# Start development
+bun run dev
+
+# Build for production
+bun run build
+bun run start
 ```
 
-To run:
+## Tech Stack
 
-```bash
-bun run index.ts
+| Layer | Technology |
+|-------|------------|
+| Runtime | [Bun](https://bun.sh) |
+| HTTP Server | [ElysiaJS](https://elysiajs.com) |
+| UI | [Svelte 5](https://svelte.dev) (Runes) |
+| CSS | [Tailwind CSS v4](https://tailwindcss.com) |
+| Bundler | Bun.build |
+
+## 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
 ```
 
-This project was created using `bun init` in bun v1.3.0. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
+## Server Loaders
+
+```typescript
+// src/routes/blog/[slug]/+page.server.ts
+import type { LoadEvent } from "bosia";
+
+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 "bosia";
+
+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 "bosia";
+import type { Handle } from "bosia";
+
+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 "bosia";
+import type { RequestEvent, LoadEvent, Handle } from "bosia";
+```
+
+| 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
+```
+
+## License
+
+MIT

package/package.json

@@ -1,12 +1,56 @@
 {
   "name": "bosia",
-  "version": "0.0.0",
-  "module": "index.ts",
+  "version": "0.1.1",
   "type": "module",
-  "devDependencies": {
-    "@types/bun": "latest"
+  "description": "A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS. File-based routing inspired by SvelteKit. No Node.js, no Vite, no adapters.",
+  "keywords": [
+    "bun",
+    "svelte",
+    "ssr",
+    "elysia",
+    "fullstack",
+    "framework"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Jekibus",
+    "url": "https://github.com/jekibus"
+  },
+  "homepage": "https://github.com/bosapi/bosia#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bosapi/bosia.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bosapi/bosia/issues"
+  },
+  "files": [
+    "src",
+    "templates",
+    "README.md",
+    "package.json"
+  ],
+  "exports": {
+    ".": "./src/lib/index.ts"
   },
-  "peerDependencies": {
+  "bin": {
+    "bosia": "src/cli/index.ts"
+  },
+  "scripts": {
+    "check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
     "typescript": "^5"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "@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,151 @@
+import { join, dirname } from "path";
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from "fs";
+import { spawn } from "bun";
+
+// ─── bosia add <component> ────────────────────────────────
+// Fetches a component from the GitHub registry (or local registry
+// with --local) and copies it into src/lib/components/ui/<name>/.
+
+const REMOTE_BASE = "https://raw.githubusercontent.com/bosapi/bosia/main/registry";
+
+interface ComponentMeta {
+    name: string;
+    description: string;
+    dependencies: string[];   // other bosia 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>();
+
+// Resolved once in runAdd, used by addComponent
+let registryRoot: string | null = null;
+
+export async function runAdd(name: string | undefined, flags: string[] = []) {
+    if (!name) {
+        console.error("❌ Please provide a component name.\n   Usage: bosia add <component> [--local]");
+        process.exit(1);
+    }
+
+    if (flags.includes("--local")) {
+        // Walk up from this file to find the repo's registry/ directory
+        registryRoot = resolveLocalRegistry();
+        console.log(`⬡ Using local registry: ${registryRoot}\n`);
+    }
+
+    ensureUtils();
+    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 readMeta(name);
+
+    // Install component dependencies first (recursive)
+    for (const dep of meta.dependencies) {
+        await addComponent(dep, false);
+    }
+
+    // Download/copy 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 readFile(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}/`);
+}
+
+// ─── Ensure $lib/utils.ts exists ─────────────────────────────
+
+const UTILS_CONTENT = `import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+    return twMerge(clsx(inputs));
+}
+`;
+
+function ensureUtils() {
+    const utilsPath = join(process.cwd(), "src", "lib", "utils.ts");
+    if (!existsSync(utilsPath)) {
+        mkdirSync(dirname(utilsPath), { recursive: true });
+        writeFileSync(utilsPath, UTILS_CONTENT, "utf-8");
+        console.log("   ✍️  src/lib/utils.ts (cn utility)\n");
+    }
+}
+
+// ─── Registry resolvers ──────────────────────────────────────
+
+function resolveLocalRegistry(): string {
+    // Walk up from this file's directory to find registry/
+    let dir = dirname(new URL(import.meta.url).pathname);
+    for (let i = 0; i < 10; i++) {
+        const candidate = join(dir, "registry");
+        if (existsSync(join(candidate, "index.json"))) return candidate;
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    console.error("❌ Could not find local registry/ directory.");
+    process.exit(1);
+}
+
+async function readMeta(name: string): Promise<ComponentMeta> {
+    if (registryRoot) {
+        const path = join(registryRoot, "components", name, "meta.json");
+        if (!existsSync(path)) {
+            throw new Error(`Component "${name}" not found in local registry`);
+        }
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    return fetchJSON<ComponentMeta>(`${REMOTE_BASE}/components/${name}/meta.json`);
+}
+
+async function readFile(name: string, file: string): Promise<string> {
+    if (registryRoot) {
+        const path = join(registryRoot, "components", name, file);
+        if (!existsSync(path)) {
+            throw new Error(`File "${file}" not found for component "${name}" in local registry`);
+        }
+        return readFileSync(path, "utf-8");
+    }
+    return fetchText(`${REMOTE_BASE}/components/${name}/${file}`);
+}
+
+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,113 @@
+import { resolve, join, basename } from "path";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { spawn } from "bun";
+import * as p from "@clack/prompts";
+
+// ─── bosia create <name> [--template <name>] ──────────────
+
+const TEMPLATES_DIR = resolve(import.meta.dir, "../../templates");
+const BOSIA_PKG = JSON.parse(readFileSync(resolve(import.meta.dir, "../../package.json"), "utf-8"));
+const BOSIA_VERSION: string = BOSIA_PKG.version;
+
+const TEMPLATE_DESCRIPTIONS: Record<string, string> = {
+    default: "Minimal starter with routing and Tailwind",
+    demo: "Full-featured demo with hooks, API routes, form actions, and more",
+};
+
+export async function runCreate(name: string | undefined, args: string[] = []) {
+    if (!name) {
+        console.error("❌ Please provide a project name.\n   Usage: bosia create my-app");
+        process.exit(1);
+    }
+
+    const targetDir = resolve(process.cwd(), name);
+
+    if (existsSync(targetDir)) {
+        console.error(`❌ Directory already exists: ${targetDir}`);
+        process.exit(1);
+    }
+
+    // Parse --template flag
+    let template: string | undefined;
+    const templateIdx = args.indexOf("--template");
+    if (templateIdx !== -1 && args[templateIdx + 1]) {
+        template = args[templateIdx + 1];
+    }
+
+    // If no --template flag, prompt interactively
+    if (!template) {
+        template = await promptTemplate();
+    }
+
+    // Validate template exists
+    const templateDir = resolve(TEMPLATES_DIR, template);
+    if (!existsSync(templateDir)) {
+        const available = getAvailableTemplates().join(", ");
+        console.error(`❌ Unknown template: "${template}"\n   Available: ${available}`);
+        process.exit(1);
+    }
+
+    console.log(`\n⬡ Creating Bosia project: ${basename(targetDir)} (template: ${template})\n`);
+
+    copyDir(templateDir, 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 bosia dev\n`);
+    }
+}
+
+function getAvailableTemplates(): string[] {
+    return readdirSync(TEMPLATES_DIR, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+        .sort((a, b) => (a === "default" ? -1 : b === "default" ? 1 : a.localeCompare(b)));
+}
+
+async function promptTemplate(): Promise<string> {
+    const templates = getAvailableTemplates();
+
+    if (templates.length === 1) return templates[0];
+
+    const selected = await p.select({
+        message: "Which template?",
+        options: templates.map((t) => ({
+            value: t,
+            label: t,
+            hint: TEMPLATE_DESCRIPTIONS[t],
+        })),
+    });
+
+    if (p.isCancel(selected)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+    }
+
+    return selected as string;
+}
+
+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)
+                .replaceAll("{{BOSIA_VERSION}}", BOSIA_VERSION);
+            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";
+
+// ─── bosia 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/bosia/main/registry";
+
+interface FeatureMeta {
+    name: string;
+    description: string;
+    components: string[];              // bosia components to install via `bosia 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: bosia 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();
+}