@lumerahq/cli 0.10.0 → 0.11.0

package/dist/init-VNJNSU4Q.js

@@ -0,0 +1,440 @@
+import {
+  installAllSkills,
+  syncClaudeMd
+} from "./chunk-UP3GV4HN.js";
+import {
+  listAllTemplates,
+  resolveTemplate
+} from "./chunk-CHRKCAIZ.js";
+import "./chunk-D2BLSEGR.js";
+
+// src/commands/init.ts
+import pc2 from "picocolors";
+import prompts from "prompts";
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, rmSync } from "fs";
+import { join, resolve } from "path";
+
+// src/lib/spinner.ts
+import pc from "picocolors";
+var frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function spinner(message) {
+  if (!process.stdout.isTTY) {
+    process.stdout.write(`  ${message}
+`);
+    return (doneMessage) => {
+      if (doneMessage) {
+        process.stdout.write(`  ${doneMessage}
+`);
+      }
+    };
+  }
+  let i = 0;
+  const interval = setInterval(() => {
+    const frame = frames[i % frames.length];
+    process.stdout.write(`\r  ${pc.cyan(frame)} ${message}`);
+    i++;
+  }, 80);
+  return (doneMessage) => {
+    clearInterval(interval);
+    process.stdout.write(`\r${" ".repeat(message.length + 10)}\r`);
+    if (doneMessage) {
+      process.stdout.write(`  ${doneMessage}
+`);
+    }
+  };
+}
+
+// src/commands/init.ts
+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)) {
+    const defaultValue = TEMPLATE_DEFAULTS[key];
+    if (defaultValue && defaultValue !== value) {
+      result = result.replaceAll(defaultValue, value);
+    }
+  }
+  return result;
+}
+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);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, vars, false);
+    } else {
+      const content = readFileSync(srcPath, "utf-8");
+      const processed = processTemplate(content, vars);
+      writeFileSync(destPath, processed);
+    }
+  }
+}
+function isGitInstalled() {
+  try {
+    execSync("git --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function initGitRepo(targetDir, projectName) {
+  try {
+    execSync("git init", { cwd: targetDir, stdio: "ignore" });
+    execSync("git add -A", { cwd: targetDir, stdio: "ignore" });
+    execSync(`git commit -m "Initial commit: scaffold ${projectName}"`, {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isUvInstalled() {
+  try {
+    execSync("uv --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installUv() {
+  try {
+    try {
+      execSync("curl -LsSf https://astral.sh/uv/install.sh | sh", {
+        stdio: "ignore",
+        shell: "/bin/bash"
+      });
+      return true;
+    } catch {
+      execSync("wget -qO- https://astral.sh/uv/install.sh | sh", {
+        stdio: "ignore",
+        shell: "/bin/bash"
+      });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+function createPythonVenv(targetDir) {
+  try {
+    execSync("uv venv", { cwd: targetDir, stdio: "ignore" });
+    execSync("uv pip install lumera", { cwd: targetDir, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectEditor() {
+  const envEditor = process.env.VISUAL || process.env.EDITOR;
+  if (envEditor) return envEditor;
+  const editors = ["cursor", "code", "zed", "subl"];
+  for (const editor of editors) {
+    try {
+      execSync(`which ${editor}`, { stdio: "ignore" });
+      return editor;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function openInEditor(targetDir) {
+  const editor = detectEditor();
+  if (!editor) {
+    console.log(pc2.yellow("  \u26A0"), pc2.dim("No editor detected. Set VISUAL or EDITOR env var."));
+    return;
+  }
+  try {
+    execSync(`${editor} "${targetDir}"`, { stdio: "ignore" });
+    console.log(pc2.green("  \u2713"), pc2.dim(`Opened in ${editor}`));
+  } catch {
+    console.log(pc2.yellow("  \u26A0"), pc2.dim(`Failed to open in ${editor}`));
+  }
+}
+function parseArgs(args) {
+  const result = {
+    projectName: void 0,
+    directory: void 0,
+    template: void 0,
+    install: true,
+    open: false,
+    yes: false,
+    force: false,
+    help: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else if (arg === "--no-install") {
+      result.install = false;
+    } else if (arg === "--open" || arg === "-o") {
+      result.open = true;
+    } else if (arg === "--yes" || arg === "-y") {
+      result.yes = true;
+    } else if (arg === "--force" || arg === "-f") {
+      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;
+    }
+  }
+  return result;
+}
+function showHelp() {
+  console.log(`
+${pc2.dim("Usage:")}
+  lumera init [name] [options]
+
+${pc2.dim("Description:")}
+  Scaffold a new Lumera project from a template.
+
+${pc2.dim("Options:")}
+  --template, -t <name>  Template to use (run ${pc2.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
+  --no-install           Skip dependency installation
+  --open, -o             Open project in editor after scaffolding
+  --help, -h             Show this help
+
+${pc2.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 -o  # Full non-interactive + open editor
+`);
+}
+async function init(args) {
+  const opts = parseArgs(args);
+  if (opts.help) {
+    showHelp();
+    return;
+  }
+  console.log();
+  console.log(pc2.cyan(pc2.bold("  Create Lumera App")));
+  console.log();
+  let projectName = opts.projectName;
+  let directory = opts.directory;
+  const nonInteractive = opts.yes;
+  if (nonInteractive && !projectName) {
+    console.log(pc2.red("  Error: Project name is required in non-interactive mode"));
+    console.log(pc2.dim("  Usage: lumera init <name> -y"));
+    process.exit(1);
+  }
+  let templateName = opts.template;
+  if (!templateName && !nonInteractive) {
+    try {
+      const stop = spinner("Fetching templates...");
+      const available = await listAllTemplates();
+      stop();
+      if (available.length > 1) {
+        const response = await prompts({
+          type: "select",
+          name: "template",
+          message: "Choose a template",
+          choices: available.map((t) => ({
+            title: `${t.title} ${pc2.dim(`(${t.name})`)}`,
+            description: t.description,
+            value: t.name
+          })),
+          initial: 0
+        });
+        if (!response.template) {
+          console.log(pc2.red("Cancelled"));
+          process.exit(1);
+        }
+        templateName = response.template;
+      }
+    } catch {
+    }
+  }
+  if (!templateName) {
+    templateName = "default";
+  }
+  const stopResolve = spinner("Resolving template...");
+  const templateDir = await resolveTemplate(templateName);
+  stopResolve();
+  if (!projectName) {
+    const response = await prompts({
+      type: "text",
+      name: "projectName",
+      message: "What is your project name?",
+      initial: "my-lumera-app",
+      validate: (value) => {
+        if (!value) return "Project name is required";
+        if (!/^[a-z0-9-]+$/.test(value)) {
+          return "Use lowercase letters, numbers, and hyphens only";
+        }
+        return true;
+      }
+    });
+    if (!response.projectName) {
+      console.log(pc2.red("Cancelled"));
+      process.exit(1);
+    }
+    projectName = response.projectName;
+  }
+  if (!/^[a-z0-9-]+$/.test(projectName)) {
+    console.log(pc2.red("  Error: Project name must use lowercase letters, numbers, and hyphens only"));
+    process.exit(1);
+  }
+  if (!directory) {
+    if (nonInteractive) {
+      directory = projectName;
+    } else {
+      const response = await prompts({
+        type: "text",
+        name: "directory",
+        message: "Where should we create the project?",
+        initial: projectName
+      });
+      if (!response.directory) {
+        console.log(pc2.red("Cancelled"));
+        process.exit(1);
+      }
+      directory = response.directory;
+    }
+  }
+  const projectTitle = toTitleCase(projectName);
+  const targetDir = resolve(process.cwd(), directory);
+  if (existsSync(targetDir)) {
+    if (nonInteractive) {
+      if (opts.force) {
+        rmSync(targetDir, { recursive: true });
+      } else {
+        console.log(pc2.red(`  Error: Directory ${directory} already exists`));
+        console.log(pc2.dim("  Use --force (-f) to overwrite"));
+        process.exit(1);
+      }
+    } else {
+      const { overwrite } = await prompts({
+        type: "confirm",
+        name: "overwrite",
+        message: `Directory ${directory} already exists. Overwrite?`,
+        initial: false
+      });
+      if (!overwrite) {
+        console.log(pc2.red("Cancelled"));
+        process.exit(1);
+      }
+      rmSync(targetDir, { recursive: true });
+    }
+  }
+  mkdirSync(targetDir, { recursive: true });
+  console.log();
+  if (templateName !== "default") {
+    console.log(pc2.dim(`  Creating ${projectName} from template ${pc2.cyan(templateName)}...`));
+  } else {
+    console.log(pc2.dim(`  Creating ${projectName}...`));
+  }
+  console.log();
+  const vars = {
+    projectName,
+    projectTitle
+  };
+  copyDir(templateDir, targetDir, vars);
+  function listFiles(dir, prefix = "") {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const relativePath = prefix + entry.name;
+      if (entry.isDirectory()) {
+        listFiles(join(dir, entry.name), relativePath + "/");
+      } else {
+        console.log(pc2.green("  \u2713"), pc2.dim(relativePath));
+      }
+    }
+  }
+  listFiles(targetDir);
+  if (isGitInstalled()) {
+    const stopGit = spinner("Initializing git repository...");
+    if (initGitRepo(targetDir, projectName)) {
+      stopGit(pc2.green("\u2713") + pc2.dim(" Git repository initialized with initial commit"));
+    } else {
+      stopGit(pc2.yellow("\u26A0") + pc2.dim(" Failed to initialize git repository"));
+    }
+  } else {
+    console.log(pc2.yellow("  \u26A0"), pc2.dim("Git not found \u2014 skipping repository initialization"));
+  }
+  let uvAvailable = isUvInstalled();
+  if (!uvAvailable) {
+    const stopUv = spinner("Installing uv (Python package manager)...");
+    if (installUv()) {
+      stopUv(pc2.green("\u2713") + pc2.dim(" uv installed successfully"));
+      uvAvailable = true;
+    } else {
+      stopUv(pc2.yellow("\u26A0") + pc2.dim(" Failed to install uv \u2014 install manually: https://docs.astral.sh/uv/"));
+    }
+  }
+  if (uvAvailable) {
+    const stopVenv = spinner("Creating Python venv with Lumera SDK...");
+    if (createPythonVenv(targetDir)) {
+      stopVenv(pc2.green("\u2713") + pc2.dim(" Python venv created (.venv/) with lumera SDK"));
+    } else {
+      stopVenv(pc2.yellow("\u26A0") + pc2.dim(" Failed to create Python venv"));
+    }
+  }
+  if (opts.install) {
+    const stopInstall = spinner("Installing dependencies...");
+    try {
+      execSync("pnpm install", { cwd: targetDir, stdio: "ignore" });
+      stopInstall(pc2.green("\u2713") + pc2.dim(" Dependencies installed"));
+    } catch {
+      stopInstall(pc2.yellow("\u26A0") + pc2.dim(" Failed to install dependencies"));
+    }
+  }
+  const stopSkills = spinner("Installing Lumera skills for AI agents...");
+  try {
+    const { installed, failed } = await installAllSkills(targetDir);
+    if (failed > 0) {
+      stopSkills(pc2.yellow("\u26A0") + pc2.dim(` Installed ${installed} skills (${failed} failed)`));
+    } else {
+      stopSkills(pc2.green("\u2713") + pc2.dim(` ${installed} Lumera skills installed`));
+    }
+    syncClaudeMd(targetDir);
+    if (isGitInstalled()) {
+      try {
+        execSync('git add -A && git commit -m "chore: install lumera skills"', {
+          cwd: targetDir,
+          stdio: "ignore"
+        });
+      } catch {
+      }
+    }
+  } catch (err) {
+    stopSkills(pc2.yellow("\u26A0") + pc2.dim(` Failed to install skills: ${err}`));
+  }
+  console.log();
+  console.log(pc2.green(pc2.bold("  Done!")), "Next steps:");
+  console.log();
+  console.log(pc2.cyan(`  cd ${directory}`));
+  if (!opts.install) {
+    console.log(pc2.cyan("  pnpm install"));
+  }
+  console.log(pc2.cyan("  lumera login"));
+  console.log(pc2.cyan("  lumera dev"));
+  console.log();
+  if (opts.open) {
+    openInEditor(targetDir);
+    console.log();
+  }
+}
+export {
+  init
+};

package/dist/{resources-PGBVCS2K.js → resources-GTG3QMVV.js}

@@ -2,11 +2,9 @@ import {
   deploy
 } from "./chunk-CDZZ3JYU.js";
 import {
-  createApiClient
-} from "./chunk-WRAZC6SJ.js";
-import {
+  createApiClient,
   loadEnv
-} from "./chunk-2CR762KB.js";
+} from "./chunk-HIYM7EM2.js";
 import {
   getToken
 } from "./chunk-NDLYGKS6.js";

package/dist/{run-WIRQDYYX.js → run-47GF5VVS.js}

@@ -1,9 +1,7 @@
 import {
-  createApiClient
-} from "./chunk-WRAZC6SJ.js";
-import {
+  createApiClient,
   loadEnv
-} from "./chunk-2CR762KB.js";
+} from "./chunk-HIYM7EM2.js";
 import {
   getToken
 } from "./chunk-NDLYGKS6.js";

package/dist/templates-6KMZWOYH.js

@@ -0,0 +1,194 @@
+import {
+  listAllTemplates
+} from "./chunk-CHRKCAIZ.js";
+
+// src/commands/templates.ts
+import pc from "picocolors";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, resolve, extname } from "path";
+function showHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera templates <command> [options]
+
+${pc.dim("Commands:")}
+  list, ls               List available templates (default)
+  validate [dir]         Validate a template directory
+
+${pc.dim("Options:")}
+  --verbose, -v          Show full descriptions (list)
+  --help, -h             Show this help
+
+${pc.dim("Examples:")}
+  lumera templates                              # List available templates
+  lumera templates list -v                      # Show with descriptions
+  lumera templates validate ./my-template       # Validate a template dir
+  lumera init my-app -t invoice-processing      # Use a template
+`);
+}
+async function list(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    return;
+  }
+  const verbose = args.includes("--verbose") || args.includes("-v");
+  try {
+    const allTemplates = await listAllTemplates();
+    if (process.env.LUMERA_JSON) {
+      console.log(JSON.stringify(allTemplates, null, 2));
+      return;
+    }
+    console.log();
+    console.log(pc.cyan(pc.bold("  Available Templates")));
+    console.log();
+    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);
+  }
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".venv", "dist", "__pycache__", ".tanstack"]);
+var TEXT_EXTS = /* @__PURE__ */ new Set([".json", ".ts", ".tsx", ".js", ".jsx", ".py", ".md", ".html", ".css", ".yaml", ".yml", ".toml"]);
+function scanForPlaceholders(dir, prefix = "") {
+  const results = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const fullPath = join(dir, entry.name);
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...scanForPlaceholders(fullPath, relativePath));
+    } else {
+      const ext = extname(entry.name);
+      if (!TEXT_EXTS.has(ext)) continue;
+      if (entry.name === "template.json") continue;
+      try {
+        const content = readFileSync(fullPath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const matches = lines[i].match(/\{\{[^}]+\}\}/g);
+          if (matches) {
+            for (const match of matches) {
+              if (match.includes(":")) continue;
+              results.push({ file: relativePath, line: i + 1, text: match });
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return results;
+}
+async function validate(args) {
+  const dir = args.find((a) => !a.startsWith("-")) || ".";
+  const targetDir = resolve(process.cwd(), dir);
+  console.log();
+  console.log(pc.cyan(pc.bold("  Validate Template")));
+  console.log(pc.dim(`  Directory: ${targetDir}`));
+  console.log();
+  const issues = [];
+  const warnings = [];
+  const templateJsonPath = join(targetDir, "template.json");
+  if (!existsSync(templateJsonPath)) {
+    issues.push("Missing template.json");
+  } else {
+    try {
+      const meta = JSON.parse(readFileSync(templateJsonPath, "utf-8"));
+      const required = ["name", "title", "description", "category"];
+      for (const field of required) {
+        if (!meta[field]) {
+          issues.push(`template.json: missing required field "${field}"`);
+        }
+      }
+    } catch {
+      issues.push("template.json: invalid JSON");
+    }
+  }
+  if (!existsSync(join(targetDir, "package.json"))) {
+    issues.push("Missing package.json");
+  }
+  if (!existsSync(join(targetDir, "platform"))) {
+    warnings.push("Missing platform/ directory");
+  } else if (!existsSync(join(targetDir, "platform", "collections"))) {
+    warnings.push("platform/ has no collections/ subdirectory");
+  }
+  const stalePatterns = scanForPlaceholders(targetDir);
+  for (const match of stalePatterns) {
+    warnings.push(`Stale placeholder: ${match.file}:${match.line} \u2014 ${match.text}`);
+  }
+  if (issues.length === 0 && warnings.length === 0) {
+    console.log(pc.green("  \u2713 Template is valid"));
+    console.log();
+    return;
+  }
+  if (issues.length > 0) {
+    console.log(pc.red(`  ${issues.length} error${issues.length > 1 ? "s" : ""}:`));
+    for (const issue of issues) {
+      console.log(pc.red(`    \u2717 ${issue}`));
+    }
+    console.log();
+  }
+  if (warnings.length > 0) {
+    console.log(pc.yellow(`  ${warnings.length} warning${warnings.length > 1 ? "s" : ""}:`));
+    for (const warning of warnings) {
+      console.log(pc.yellow(`    \u26A0 ${warning}`));
+    }
+    console.log();
+  }
+  if (issues.length > 0) {
+    process.exit(1);
+  }
+}
+async function templates(subcommand, args) {
+  if (subcommand === "--help" || subcommand === "-h") {
+    showHelp();
+    return;
+  }
+  const cmd = subcommand || "list";
+  switch (cmd) {
+    case "list":
+    case "ls":
+      await list(args);
+      break;
+    case "validate":
+      await validate(args);
+      break;
+    default:
+      if (cmd.startsWith("-")) {
+        await list([cmd, ...args]);
+        break;
+      }
+      console.error(pc.red(`Unknown templates command: ${cmd}`));
+      console.error(`Run ${pc.cyan("lumera templates --help")} for usage.`);
+      process.exit(1);
+  }
+}
+export {
+  templates
+};

package/package.json

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

package/dist/chunk-2CR762KB.js

@@ -1,18 +0,0 @@
-// src/lib/env.ts
-import { config } from "dotenv";
-import { existsSync } from "fs";
-import { resolve } from "path";
-function loadEnv(cwd = process.cwd()) {
-  const envPath = resolve(cwd, ".env");
-  const envLocalPath = resolve(cwd, ".env.local");
-  if (existsSync(envPath)) {
-    config({ path: envPath });
-  }
-  if (existsSync(envLocalPath)) {
-    config({ path: envLocalPath, override: true });
-  }
-}
-
-export {
-  loadEnv
-};