@lumerahq/cli 0.7.0

package/dist/init-OQCIET53.js

@@ -0,0 +1,363 @@
+import {
+  getBaseUrl
+} from "./chunk-D2BLSEGR.js";
+
+// src/commands/init.ts
+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(", ")}`);
+}
+function toTitleCase(str) {
+  return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function processTemplate(content, vars) {
+  let result = content;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return result;
+}
+function copyDir(src, dest, vars) {
+  if (!existsSync(dest)) {
+    mkdirSync(dest, { recursive: true });
+  }
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    const srcPath = join(src, entry.name);
+    let destName = entry.name;
+    if (destName.endsWith(".hbs")) {
+      destName = destName.slice(0, -4);
+    }
+    const destPath = join(dest, destName);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, vars);
+    } 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: "inherit",
+        shell: "/bin/bash"
+      });
+      return true;
+    } catch {
+      execSync("wget -qO- https://astral.sh/uv/install.sh | sh", {
+        stdio: "inherit",
+        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;
+  }
+}
+async function installSkills(targetDir) {
+  const baseUrl = getBaseUrl();
+  const skillsApiUrl = `${baseUrl}/api/public/skills`;
+  const listRes = await fetch(skillsApiUrl);
+  if (!listRes.ok) {
+    throw new Error(`Failed to fetch skills list: ${listRes.status}`);
+  }
+  const skills = await listRes.json();
+  const skillsDir = join(targetDir, ".claude", "skills");
+  mkdirSync(skillsDir, { recursive: true });
+  for (const skill of skills) {
+    const mdRes = await fetch(`${skillsApiUrl}/${skill.slug}.md`);
+    if (!mdRes.ok) {
+      console.log(pc.yellow("  \u26A0"), pc.dim(`Failed to fetch skill ${skill.slug}`));
+      continue;
+    }
+    const content = await mdRes.text();
+    const slug = skill.slug.startsWith("lumera-") ? skill.slug : `lumera-${skill.slug}`;
+    const filename = `${slug.replace(/-/g, "_")}.md`;
+    writeFileSync(join(skillsDir, filename), content);
+  }
+}
+function parseArgs(args) {
+  const result = {
+    projectName: void 0,
+    directory: void 0,
+    install: 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 === "--install" || arg === "-i") {
+      result.install = 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.startsWith("-") && !result.projectName) {
+      result.projectName = arg;
+    }
+  }
+  return result;
+}
+function showHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera init [name] [options]
+
+${pc.dim("Description:")}
+  Scaffold a new Lumera project.
+
+${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
+
+${pc.dim("CI/CD example:")}
+  lumera init my-app -y -f -i     # Full non-interactive setup
+`);
+}
+async function init(args) {
+  const opts = parseArgs(args);
+  if (opts.help) {
+    showHelp();
+    return;
+  }
+  console.log();
+  console.log(pc.cyan(pc.bold("  Create Lumera App")));
+  console.log();
+  let projectName = opts.projectName;
+  let directory = opts.directory;
+  const nonInteractive = opts.yes;
+  if (nonInteractive && !projectName) {
+    console.log(pc.red("  Error: Project name is required in non-interactive mode"));
+    console.log(pc.dim("  Usage: lumera init <name> -y"));
+    process.exit(1);
+  }
+  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(pc.red("Cancelled"));
+      process.exit(1);
+    }
+    projectName = response.projectName;
+  }
+  if (!/^[a-z0-9-]+$/.test(projectName)) {
+    console.log(pc.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(pc.red("Cancelled"));
+        process.exit(1);
+      }
+      directory = response.directory;
+    }
+  }
+  const projectTitle = toTitleCase(projectName);
+  const projectInitial = projectTitle.charAt(0).toUpperCase();
+  const targetDir = resolve(process.cwd(), directory);
+  if (existsSync(targetDir)) {
+    if (nonInteractive) {
+      if (opts.force) {
+        rmSync(targetDir, { recursive: true });
+      } else {
+        console.log(pc.red(`  Error: Directory ${directory} already exists`));
+        console.log(pc.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(pc.red("Cancelled"));
+        process.exit(1);
+      }
+      rmSync(targetDir, { recursive: true });
+    }
+  }
+  mkdirSync(targetDir, { recursive: true });
+  console.log();
+  console.log(pc.dim(`  Creating ${projectName} in ${directory}...`));
+  console.log();
+  const templatesDir = getTemplatesDir();
+  const vars = {
+    projectName,
+    projectTitle,
+    projectInitial
+  };
+  copyDir(templatesDir, 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(pc.green("  \u2713"), pc.dim(relativePath));
+      }
+    }
+  }
+  listFiles(targetDir);
+  if (isGitInstalled()) {
+    console.log();
+    console.log(pc.dim("  Initializing git repository..."));
+    if (initGitRepo(targetDir, projectName)) {
+      console.log(pc.green("  \u2713"), pc.dim("Git repository initialized with initial commit"));
+    } else {
+      console.log(pc.yellow("  \u26A0"), pc.dim("Failed to initialize git repository"));
+    }
+  } else {
+    console.log();
+    console.log(pc.yellow("  \u26A0"), pc.dim("Git not found - skipping repository initialization"));
+  }
+  let uvAvailable = isUvInstalled();
+  if (!uvAvailable) {
+    console.log();
+    console.log(pc.dim("  Installing uv (Python package manager)..."));
+    if (installUv()) {
+      console.log(pc.green("  \u2713"), pc.dim("uv installed successfully"));
+      uvAvailable = true;
+    } else {
+      console.log(pc.yellow("  \u26A0"), pc.dim("Failed to install uv - install manually: https://docs.astral.sh/uv/"));
+    }
+  }
+  if (uvAvailable) {
+    console.log();
+    console.log(pc.dim("  Creating Python venv with Lumera SDK..."));
+    if (createPythonVenv(targetDir)) {
+      console.log(pc.green("  \u2713"), pc.dim("Python venv created (.venv/) with lumera SDK"));
+    } else {
+      console.log(pc.yellow("  \u26A0"), pc.dim("Failed to create Python venv"));
+    }
+  }
+  if (opts.install) {
+    console.log();
+    console.log(pc.dim("  Installing dependencies..."));
+    try {
+      execSync("pnpm install", { cwd: targetDir, stdio: "inherit" });
+      console.log(pc.green("  \u2713"), pc.dim("Dependencies installed"));
+    } catch {
+      console.log(pc.yellow("  \u26A0"), pc.dim("Failed to install dependencies"));
+    }
+  }
+  console.log();
+  console.log(pc.dim("  Installing Lumera skills for AI agents..."));
+  try {
+    await installSkills(targetDir);
+    console.log(pc.green("  \u2713"), pc.dim("Lumera skills installed"));
+  } catch (err) {
+    console.log(pc.yellow("  \u26A0"), pc.dim(`Failed to install skills: ${err}`));
+  }
+  console.log();
+  console.log(pc.green(pc.bold("  Done!")), "Next steps:");
+  console.log();
+  console.log(pc.cyan(`  cd ${directory}`));
+  if (!opts.install) {
+    console.log(pc.cyan("  pnpm install"));
+  }
+  console.log(pc.cyan("  lumera login"));
+  console.log(pc.cyan("  pnpm dev"));
+  console.log();
+}
+export {
+  init
+};

package/dist/migrate-2DZ6RQ5K.js

@@ -0,0 +1,190 @@
+import {
+  detectProjectVersion,
+  findProjectRoot
+} from "./chunk-D2BLSEGR.js";
+
+// src/commands/migrate.ts
+import pc from "picocolors";
+import { existsSync, mkdirSync, renameSync, readdirSync, readFileSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+function showHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera migrate [options]
+
+${pc.dim("Description:")}
+  Upgrade legacy project structure (v0) to the current structure (v1).
+  Moves files from lumera_platform/ to platform/ and updates package.json.
+
+${pc.dim("Options:")}
+  --dry-run              Preview migration changes without applying
+  --help, -h             Show this help
+
+${pc.dim("Examples:")}
+  lumera migrate              # Migrate to v1 structure
+  lumera migrate --dry-run    # Preview migration changes
+`);
+}
+async function migrate(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    return;
+  }
+  const dryRun = args.includes("--dry-run");
+  let projectRoot;
+  try {
+    projectRoot = findProjectRoot();
+  } catch {
+    console.error(pc.red("Not in a Lumera project directory."));
+    process.exit(1);
+  }
+  const version = detectProjectVersion(projectRoot);
+  if (version === 1) {
+    console.log(pc.green("Project is already using v1 structure."));
+    return;
+  }
+  if (version !== 0) {
+    console.error(pc.red(`Unknown project version: ${version}`));
+    process.exit(1);
+  }
+  const legacyDir = join(projectRoot, "lumera_platform");
+  if (!existsSync(legacyDir)) {
+    console.error(pc.red("Legacy lumera_platform/ directory not found."));
+    console.error(pc.dim("This project may already be migrated or is not a Lumera project."));
+    process.exit(1);
+  }
+  console.log(pc.bold("Migration Plan:"));
+  console.log();
+  const actions = [];
+  const newDirs = ["platform/collections", "platform/automations", "platform/hooks", "scripts"];
+  for (const dir of newDirs) {
+    const fullPath = join(projectRoot, dir);
+    if (!existsSync(fullPath)) {
+      actions.push({ type: "mkdir", to: dir, desc: `Create ${dir}/` });
+    }
+  }
+  const legacyCollections = join(legacyDir, "collections");
+  if (existsSync(legacyCollections)) {
+    for (const file of readdirSync(legacyCollections)) {
+      actions.push({
+        type: "move",
+        from: `lumera_platform/collections/${file}`,
+        to: `platform/collections/${file}`,
+        desc: `Move collections/${file}`
+      });
+    }
+  }
+  const legacyAutomations = join(legacyDir, "automations");
+  if (existsSync(legacyAutomations)) {
+    for (const item of readdirSync(legacyAutomations, { withFileTypes: true })) {
+      actions.push({
+        type: "move",
+        from: `lumera_platform/automations/${item.name}`,
+        to: `platform/automations/${item.name}`,
+        desc: `Move automations/${item.name}`
+      });
+    }
+  }
+  const legacyHooks = join(legacyDir, "hooks");
+  if (existsSync(legacyHooks)) {
+    for (const file of readdirSync(legacyHooks)) {
+      actions.push({
+        type: "move",
+        from: `lumera_platform/hooks/${file}`,
+        to: `platform/hooks/${file}`,
+        desc: `Move hooks/${file}`
+      });
+    }
+  }
+  const legacyScripts = join(legacyDir, "scripts");
+  const legacySeed = join(legacyDir, "seed");
+  for (const dir of [legacyScripts, legacySeed]) {
+    if (existsSync(dir)) {
+      for (const file of readdirSync(dir)) {
+        const fromDir = dir === legacyScripts ? "scripts" : "seed";
+        actions.push({
+          type: "move",
+          from: `lumera_platform/${fromDir}/${file}`,
+          to: `scripts/${file}`,
+          desc: `Move ${fromDir}/${file} to scripts/`
+        });
+      }
+    }
+  }
+  actions.push({
+    type: "update",
+    to: "package.json",
+    desc: "Add lumera.version: 1 to package.json"
+  });
+  actions.push({
+    type: "delete",
+    from: "lumera_platform/",
+    desc: "Remove legacy lumera_platform/ directory"
+  });
+  for (const action of actions) {
+    switch (action.type) {
+      case "mkdir":
+        console.log(pc.cyan(`  + ${action.to}`));
+        break;
+      case "move":
+        console.log(pc.yellow(`  \u2192 ${action.from} \u2192 ${action.to}`));
+        break;
+      case "update":
+        console.log(pc.blue(`  \u270E ${action.to}`));
+        break;
+      case "delete":
+        console.log(pc.red(`  - ${action.from}`));
+        break;
+    }
+  }
+  console.log();
+  if (dryRun) {
+    console.log(pc.dim("Dry run - no changes made."));
+    console.log(pc.dim("Run without --dry-run to apply changes."));
+    return;
+  }
+  console.log(pc.bold("Applying changes..."));
+  console.log();
+  for (const action of actions) {
+    try {
+      switch (action.type) {
+        case "mkdir":
+          mkdirSync(join(projectRoot, action.to), { recursive: true });
+          console.log(pc.green(`  \u2713 Created ${action.to}`));
+          break;
+        case "move":
+          renameSync(
+            join(projectRoot, action.from),
+            join(projectRoot, action.to)
+          );
+          console.log(pc.green(`  \u2713 Moved ${action.from} \u2192 ${action.to}`));
+          break;
+        case "update":
+          if (action.to === "package.json") {
+            const pkgPath = join(projectRoot, "package.json");
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            pkg.lumera = pkg.lumera || {};
+            pkg.lumera.version = 1;
+            writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+            console.log(pc.green(`  \u2713 Updated package.json`));
+          }
+          break;
+        case "delete":
+          rmSync(join(projectRoot, action.from), { recursive: true, force: true });
+          console.log(pc.green(`  \u2713 Removed ${action.from}`));
+          break;
+      }
+    } catch (err) {
+      console.error(pc.red(`  \u2717 Failed: ${action.desc}`));
+      if (err instanceof Error) {
+        console.error(pc.dim(`    ${err.message}`));
+      }
+    }
+  }
+  console.log();
+  console.log(pc.green("Migration complete!"));
+  console.log(pc.dim("Your project now uses the v1 structure."));
+}
+export {
+  migrate
+};