@lumerahq/cli 0.10.0 → 0.10.1

package/dist/chunk-WTDV3MTG.js

@@ -0,0 +1,104 @@
+// src/lib/templates.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+import { spawnSync } from "child_process";
+var GITHUB_OWNER = "lumerahq";
+var GITHUB_REPO = "app-templates";
+var GITHUB_REF = "main";
+function getCacheDir() {
+  return join(homedir(), ".lumera", "templates");
+}
+function readCacheMeta() {
+  const metaPath = join(getCacheDir(), ".cache-meta.json");
+  if (!existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function fetchLatestSha() {
+  const url = `https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}/commits/${GITHUB_REF}`;
+  const res = await fetch(url, {
+    headers: { Accept: "application/vnd.github.sha" }
+  });
+  if (!res.ok) throw new Error(`GitHub API error: ${res.status}`);
+  return (await res.text()).trim();
+}
+async function downloadAndExtract(commitSha) {
+  const cacheDir = getCacheDir();
+  const tarballUrl = `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/archive/refs/heads/${GITHUB_REF}.tar.gz`;
+  const res = await fetch(tarballUrl);
+  if (!res.ok) throw new Error(`Failed to download templates: ${res.status}`);
+  const tmpFile = join(tmpdir(), `lumera-templates-${Date.now()}.tar.gz`);
+  const buffer = Buffer.from(await res.arrayBuffer());
+  writeFileSync(tmpFile, buffer);
+  mkdirSync(cacheDir, { recursive: true });
+  for (const entry of readdirSync(cacheDir)) {
+    if (entry === ".cache-meta.json") continue;
+    rmSync(join(cacheDir, entry), { recursive: true, force: true });
+  }
+  const result = spawnSync("tar", ["xzf", tmpFile, "-C", cacheDir, "--strip-components=1"], { stdio: "ignore" });
+  if (result.status !== 0) throw new Error("Failed to extract template archive");
+  unlinkSync(tmpFile);
+  const meta = { commitSha, fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  writeFileSync(join(cacheDir, ".cache-meta.json"), JSON.stringify(meta));
+  return cacheDir;
+}
+async function ensureRemoteCache() {
+  const cacheDir = getCacheDir();
+  const cached = readCacheMeta();
+  const latestSha = await fetchLatestSha();
+  if (cached?.commitSha === latestSha && existsSync(cacheDir)) {
+    return cacheDir;
+  }
+  console.log("  Fetching latest templates...");
+  return downloadAndExtract(latestSha);
+}
+function listTemplates(baseDir) {
+  if (!existsSync(baseDir)) return [];
+  const templates = [];
+  for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const metaPath = join(baseDir, entry.name, "template.json");
+    if (!existsSync(metaPath)) continue;
+    try {
+      const raw = JSON.parse(readFileSync(metaPath, "utf-8"));
+      if (!raw.name || !raw.title || !raw.description || !raw.category) {
+        console.warn(`Warning: Skipping template "${entry.name}" \u2014 template.json is missing required fields (name, title, description, category)`);
+        continue;
+      }
+      templates.push(raw);
+    } catch {
+      console.warn(`Warning: Skipping template "${entry.name}" \u2014 invalid template.json`);
+    }
+  }
+  return templates.sort((a, b) => {
+    if (a.name === "default") return -1;
+    if (b.name === "default") return 1;
+    return a.title.localeCompare(b.title);
+  });
+}
+async function resolveTemplate(name) {
+  const cacheDir = await ensureRemoteCache();
+  const dir = join(cacheDir, name);
+  if (!existsSync(dir) || !existsSync(join(dir, "template.json"))) {
+    const available = listTemplates(cacheDir).map((t) => t.name).join(", ");
+    throw new Error(
+      `Template "${name}" not found. Available: ${available || "none"}
+  Cache location: ${cacheDir}
+  Try deleting the cache and retrying: rm -rf ${cacheDir}`
+    );
+  }
+  return dir;
+}
+async function listAllTemplates() {
+  const cacheDir = await ensureRemoteCache();
+  return listTemplates(cacheDir);
+}
+
+export {
+  resolveTemplate,
+  listAllTemplates
+};

package/dist/index.js

@@ -32,6 +32,7 @@ ${pc.dim("Development:")}
 
 ${pc.dim("Project:")}
   ${pc.cyan("init")} [name]              Scaffold a new project
+  ${pc.cyan("templates")}                List available templates
   ${pc.cyan("status")}                   Show project info
   ${pc.cyan("migrate")}                  Upgrade legacy project
 
@@ -118,7 +119,10 @@ async function main() {
         break;
       // Project
       case "init":
-        await import("./init-EDSRR3YM.js").then((m) => m.init(args.slice(1)));
+        await import("./init-OH433IPH.js").then((m) => m.init(args.slice(1)));
+        break;
+      case "templates":
+        await import("./templates-67O6PVFK.js").then((m) => m.templates(args.slice(1)));
         break;
       case "status":
         await import("./status-E4IHEUKO.js").then((m) => m.status(args.slice(1)));

package/dist/{init-EDSRR3YM.js → init-OH433IPH.js}

@@ -2,6 +2,10 @@ import {
   installAllSkills,
   syncClaudeMd
 } from "./chunk-UP3GV4HN.js";
+import {
+  listAllTemplates,
+  resolveTemplate
+} from "./chunk-WTDV3MTG.js";
 import "./chunk-D2BLSEGR.js";
 
 // src/commands/init.ts
@@ -9,51 +13,35 @@ import pc from "picocolors";
 import prompts from "prompts";
 import { execSync } from "child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, rmSync } from "fs";
-import { join, dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-function getTemplatesDir() {
-  const candidates = [
-    // From dist/index.js or dist/commands/init.js
-    resolve(__dirname, "../templates/default"),
-    resolve(__dirname, "../../templates/default"),
-    // From src during development
-    resolve(__dirname, "../../../templates/default")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(`Templates directory not found. Searched: ${candidates.join(", ")}`);
-}
+import { join, resolve } from "path";
 function toTitleCase(str) {
   return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
+var TEMPLATE_DEFAULTS = {
+  projectName: "my-lumera-app",
+  projectTitle: "My Lumera App"
+};
 function processTemplate(content, vars) {
   let result = content;
   for (const [key, value] of Object.entries(vars)) {
-    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+    const defaultValue = TEMPLATE_DEFAULTS[key];
+    if (defaultValue && defaultValue !== value) {
+      result = result.replaceAll(defaultValue, value);
+    }
   }
   return result;
 }
-function copyDir(src, dest, vars) {
+var TEMPLATE_EXCLUDE = /* @__PURE__ */ new Set(["template.json"]);
+function copyDir(src, dest, vars, isRoot = true) {
   if (!existsSync(dest)) {
     mkdirSync(dest, { recursive: true });
   }
   for (const entry of readdirSync(src, { withFileTypes: true })) {
+    if (isRoot && TEMPLATE_EXCLUDE.has(entry.name)) continue;
     const srcPath = join(src, entry.name);
-    let destName = entry.name;
-    if (destName.endsWith(".hbs")) {
-      destName = destName.slice(0, -4);
-    }
-    if (destName === "gitignore") {
-      destName = ".gitignore";
-    }
-    const destPath = join(dest, destName);
+    const destPath = join(dest, entry.name);
     if (entry.isDirectory()) {
-      copyDir(srcPath, destPath, vars);
+      copyDir(srcPath, destPath, vars, false);
     } else {
       const content = readFileSync(srcPath, "utf-8");
       const processed = processTemplate(content, vars);
@@ -122,6 +110,7 @@ function parseArgs(args) {
   const result = {
     projectName: void 0,
     directory: void 0,
+    template: void 0,
     install: false,
     yes: false,
     force: false,
@@ -139,6 +128,8 @@ function parseArgs(args) {
       result.force = true;
     } else if (arg === "--dir" || arg === "-d") {
       result.directory = args[++i];
+    } else if (arg === "--template" || arg === "-t") {
+      result.template = args[++i];
     } else if (!arg.startsWith("-") && !result.projectName) {
       result.projectName = arg;
     }
@@ -151,27 +142,21 @@ ${pc.dim("Usage:")}
   lumera init [name] [options]
 
 ${pc.dim("Description:")}
-  Scaffold a new Lumera project.
+  Scaffold a new Lumera project from a template.
 
 ${pc.dim("Options:")}
-  --yes, -y            Non-interactive mode (requires project name)
-  --dir, -d <path>     Target directory (defaults to project name)
-  --force, -f          Overwrite existing directory without prompting
-  --install, -i        Install dependencies after scaffolding
-  --help, -h           Show this help
-
-${pc.dim("Interactive mode:")}
-  lumera init                     # Prompt for project name and directory
-  lumera init my-project          # Prompt for directory only
-
-${pc.dim("Non-interactive mode:")}
-  lumera init my-project -y              # Create ./my-project
-  lumera init my-project -y -d ./apps    # Create ./apps
-  lumera init my-project -y -f           # Overwrite if exists
-  lumera init my-project -y -i           # Create and install deps
+  --template, -t <name>  Template to use (run ${pc.cyan("lumera templates")} to see options)
+  --yes, -y              Non-interactive mode (requires project name)
+  --dir, -d <path>       Target directory (defaults to project name)
+  --force, -f            Overwrite existing directory without prompting
+  --install, -i          Install dependencies after scaffolding
+  --help, -h             Show this help
 
-${pc.dim("CI/CD example:")}
-  lumera init my-app -y -f -i     # Full non-interactive setup
+${pc.dim("Examples:")}
+  lumera init my-app                              # Interactive mode
+  lumera init my-app -t invoice-processing        # Use a specific template
+  lumera init my-app -y                           # Non-interactive (default template)
+  lumera init my-app -t invoice-processing -y -i  # Full non-interactive setup
 `);
 }
 async function init(args) {
@@ -191,6 +176,35 @@ async function init(args) {
     console.log(pc.dim("  Usage: lumera init <name> -y"));
     process.exit(1);
   }
+  let templateName = opts.template;
+  if (!templateName && !nonInteractive) {
+    try {
+      const available = await listAllTemplates();
+      if (available.length > 1) {
+        const response = await prompts({
+          type: "select",
+          name: "template",
+          message: "Choose a template",
+          choices: available.map((t) => ({
+            title: `${t.title} ${pc.dim(`(${t.name})`)}`,
+            description: t.description,
+            value: t.name
+          })),
+          initial: 0
+        });
+        if (!response.template) {
+          console.log(pc.red("Cancelled"));
+          process.exit(1);
+        }
+        templateName = response.template;
+      }
+    } catch {
+    }
+  }
+  if (!templateName) {
+    templateName = "default";
+  }
+  const templateDir = await resolveTemplate(templateName);
   if (!projectName) {
     const response = await prompts({
       type: "text",
@@ -233,7 +247,6 @@ async function init(args) {
     }
   }
   const projectTitle = toTitleCase(projectName);
-  const projectInitial = projectTitle.charAt(0).toUpperCase();
   const targetDir = resolve(process.cwd(), directory);
   if (existsSync(targetDir)) {
     if (nonInteractive) {
@@ -260,15 +273,17 @@ async function init(args) {
   }
   mkdirSync(targetDir, { recursive: true });
   console.log();
-  console.log(pc.dim(`  Creating ${projectName} in ${directory}...`));
+  if (templateName !== "default") {
+    console.log(pc.dim(`  Creating ${projectName} from template ${pc.cyan(templateName)}...`));
+  } else {
+    console.log(pc.dim(`  Creating ${projectName}...`));
+  }
   console.log();
-  const templatesDir = getTemplatesDir();
   const vars = {
     projectName,
-    projectTitle,
-    projectInitial
+    projectTitle
   };
-  copyDir(templatesDir, targetDir, vars);
+  copyDir(templateDir, targetDir, vars);
   function listFiles(dir, prefix = "") {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const relativePath = prefix + entry.name;
@@ -352,7 +367,9 @@ async function init(args) {
     console.log(pc.cyan("  pnpm install"));
   }
   console.log(pc.cyan("  lumera login"));
-  console.log(pc.cyan("  pnpm dev"));
+  console.log(pc.cyan("  lumera apply"));
+  console.log(pc.cyan("  lumera run scripts/seed-demo.py"));
+  console.log(pc.cyan("  lumera dev"));
   console.log();
 }
 export {

package/dist/templates-67O6PVFK.js

@@ -0,0 +1,70 @@
+import {
+  listAllTemplates
+} from "./chunk-WTDV3MTG.js";
+
+// src/commands/templates.ts
+import pc from "picocolors";
+function showHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera templates [options]
+
+${pc.dim("Description:")}
+  List available project templates.
+
+${pc.dim("Options:")}
+  --verbose, -v          Show full descriptions
+  --help, -h             Show this help
+
+${pc.dim("Examples:")}
+  lumera templates                              # List available templates
+  lumera templates -v                            # Show with descriptions
+  lumera init my-app -t invoice-processing       # Use a template
+`);
+}
+async function templates(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    return;
+  }
+  const verbose = args.includes("--verbose") || args.includes("-v");
+  console.log();
+  console.log(pc.cyan(pc.bold("  Available Templates")));
+  console.log();
+  try {
+    const allTemplates = await listAllTemplates();
+    if (allTemplates.length === 0) {
+      console.log(pc.dim("  No templates available."));
+      console.log();
+      return;
+    }
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const t of allTemplates) {
+      const cat = t.category || "General";
+      if (!byCategory.has(cat)) byCategory.set(cat, []);
+      byCategory.get(cat).push(t);
+    }
+    for (const [category, items] of byCategory) {
+      console.log(pc.bold(`  ${category}`));
+      console.log();
+      for (const t of items) {
+        console.log(`    ${pc.green(t.title)} ${pc.dim(`(${t.name})`)}`);
+        if (verbose) {
+          console.log(`    ${pc.dim(t.description)}`);
+          console.log();
+        }
+      }
+      if (!verbose) console.log();
+    }
+    console.log(pc.dim(`  ${allTemplates.length} template${allTemplates.length === 1 ? "" : "s"} available.`));
+    console.log();
+    console.log(pc.dim("  Usage:"), pc.cyan("lumera init <name> --template <template-name>"));
+    console.log();
+  } catch (err) {
+    console.error(pc.red(`  Error: ${err}`));
+    process.exit(1);
+  }
+}
+export {
+  templates
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumerahq/cli",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "CLI for building and deploying Lumera apps",
   "type": "module",
   "engines": {

package/templates/default/ARCHITECTURE.md

@@ -1,80 +0,0 @@
-# {{projectTitle}} — Architecture
-
-## Overview
-
-{{projectTitle}} is a Lumera embedded app — a React frontend served inside the Lumera platform iframe, backed by collections, hooks, and automations managed through the Lumera CLI.
-
-## System Diagram
-
-```
-┌─────────────────────────────────────────────────┐
-│  Lumera Platform                                │
-│                                                 │
-│  ┌───────────┐   postMessage    ┌────────────┐  │
-│  │  Host UI  │ ◄──────────────► │  App       │  │
-│  │           │   (auth, init)   │  (iframe)  │  │
-│  └─────┬─────┘                  └─────┬──────┘  │
-│        │                              │         │
-│        │  REST API                    │         │
-│        ▼                              ▼         │
-│  ┌──────────────────────────────────────────┐   │
-│  │  Lumera API                              │   │
-│  │  - Collections (CRUD, SQL, search)       │   │
-│  │  - Automations (run, poll, cancel)       │   │
-│  │  - File storage (upload, download)       │   │
-│  └──────────────┬───────────────────────────┘   │
-│                 │                                │
-│                 ▼                                │
-│  ┌──────────────────────────────────────────┐   │
-│  │  Tenant Database (PocketBase/SQLite)     │   │
-│  │  - example_items                         │   │
-│  │  - (add your collections here)           │   │
-│  └──────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────┘
-```
-
-## Frontend (`src/`)
-
-React app using TanStack Router (file-based routing) and TanStack Query for data fetching. Embedded in Lumera via iframe with postMessage bridge for authentication.
-
-| Directory        | Purpose                              |
-|------------------|--------------------------------------|
-| `src/routes/`    | Pages — file names map to URL paths  |
-| `src/components/`| Shared React components              |
-| `src/lib/`       | API helpers, query functions         |
-| `src/main.tsx`   | App entry — auth bridge, router init |
-
-**Key patterns:**
-- Auth context flows from `main.tsx` via `AuthContext`
-- Data fetching uses `pbList`, `pbSql` from `@lumerahq/ui/lib`
-- Styling via Tailwind CSS 4 with theme tokens in `styles.css`
-
-## Platform Resources (`platform/`)
-
-Declarative definitions deployed via `lumera apply`.
-
-| Directory                | Purpose                          |
-|--------------------------|----------------------------------|
-| `platform/collections/`  | Collection schemas (JSON)        |
-| `platform/automations/`  | Background Python scripts        |
-| `platform/hooks/`        | Server-side JS on collection events |
-
-## Scripts (`scripts/`)
-
-Local Python scripts run via `lumera run`. Used for seeding data, migrations, and ad-hoc operations. All scripts should be idempotent.
-
-## Data Flow
-
-1. **User opens app** → Lumera host sends auth payload via postMessage
-2. **App authenticates** → Stores session token in `AuthContext`
-3. **App fetches data** → Calls Lumera API via `@lumerahq/ui/lib` helpers
-4. **Data mutations** → API calls trigger collection hooks if configured
-5. **Background work** → Automations run async via `createRun` / `pollRun`
-
-## Collections
-
-| Collection       | Purpose                    |
-|------------------|----------------------------|
-| `example_items`  | Starter collection (replace with your own) |
-
-_Update this table as you add collections._