@lumerahq/cli 0.7.0

package/dist/run-4NDI2CN4.js

@@ -0,0 +1,257 @@
+import {
+  createApiClient
+} from "./chunk-V2XXMMEI.js";
+import {
+  loadEnv
+} from "./chunk-2CR762KB.js";
+import {
+  getToken
+} from "./chunk-NDLYGKS6.js";
+import {
+  findProjectRoot,
+  getApiUrl
+} from "./chunk-D2BLSEGR.js";
+
+// src/commands/run.ts
+import pc from "picocolors";
+import { spawn } from "child_process";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { resolve, extname, join } from "path";
+function showHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera run <target> [options]
+
+${pc.dim("Description:")}
+  Run a script locally or trigger an automation on the platform.
+
+${pc.dim("Targets:")}
+  scripts/<name>.py      Run a Python script locally using uv
+  automations/<name>     Trigger an automation run on the platform
+
+${pc.dim("Options:")}
+  --local                Run automation code locally instead of on platform
+  --preset <name>        Use a specific preset when triggering automation
+  --input <json>         Pass JSON input to the automation
+  --help, -h             Show this help
+
+${pc.dim("Examples:")}
+  lumera run scripts/seed.py                # Run script locally
+  lumera run automations/sync               # Trigger automation on platform
+  lumera run automations/sync --preset daily
+  lumera run automations/sync --local       # Run automation code locally
+
+${pc.dim("Notes:")}
+  - Scripts can declare dependencies using PEP 723 inline metadata
+  - Auth token is resolved from stored credentials or LUMERA_TOKEN env var
+  - Output streams directly to terminal
+`);
+}
+function parseFlags(args) {
+  const flags = {};
+  let target = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (!target) {
+      target = arg;
+    }
+  }
+  return { target, flags };
+}
+async function runScript(scriptPath, projectRoot) {
+  const fullScriptPath = resolve(projectRoot, scriptPath);
+  if (!existsSync(fullScriptPath)) {
+    console.error(pc.red(`Script not found: ${scriptPath}`));
+    console.error(pc.dim(`Looked for: ${fullScriptPath}`));
+    process.exit(1);
+  }
+  const ext = extname(fullScriptPath).toLowerCase();
+  if (ext === ".py") {
+    console.log(pc.dim(`Running: ${scriptPath}`));
+    console.log();
+    const uv = spawn("uv", ["run", fullScriptPath], {
+      stdio: "inherit",
+      env: process.env,
+      cwd: projectRoot
+    });
+    uv.on("close", (code) => {
+      process.exit(code || 0);
+    });
+    uv.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        console.error(pc.red("uv is not installed."));
+        console.error(pc.dim("Install it with: curl -LsSf https://astral.sh/uv/install.sh | sh"));
+      } else {
+        console.error(pc.red(`Failed to run script: ${err.message}`));
+      }
+      process.exit(1);
+    });
+    process.on("SIGINT", () => uv.kill("SIGINT"));
+    process.on("SIGTERM", () => uv.kill("SIGTERM"));
+  } else if (ext === ".ts" || ext === ".js") {
+    console.log(pc.yellow("JavaScript/TypeScript scripts are not yet supported."));
+    console.log(pc.dim("This feature is planned for a future release."));
+    process.exit(1);
+  } else {
+    console.error(pc.red(`Unsupported script type: ${ext}`));
+    console.error(pc.dim("Supported: .py (Python)"));
+    process.exit(1);
+  }
+}
+async function triggerAutomation(automationName, projectRoot, flags) {
+  const api = createApiClient();
+  const token = getToken(projectRoot);
+  let apiUrl = getApiUrl().replace(/\/+$/, "").replace(/\/api$/, "");
+  console.log();
+  console.log(pc.cyan(pc.bold("  Trigger Automation")));
+  console.log();
+  const automations = await api.listAutomations();
+  const automation = automations.find(
+    (a) => a.external_id === automationName || a.name === automationName
+  );
+  if (!automation) {
+    console.error(pc.red(`  Automation "${automationName}" not found on platform.`));
+    console.error(pc.dim("  Run `lumera list automations` to see available automations."));
+    process.exit(1);
+  }
+  console.log(pc.dim(`  Automation: ${automation.name}`));
+  console.log(pc.dim(`  ID: ${automation.id}`));
+  let inputs = {};
+  if (flags.preset) {
+    const presets = await api.listPresets(automation.id);
+    const preset = presets.find((p) => p.name === flags.preset || p.name.toLowerCase() === String(flags.preset).toLowerCase());
+    if (!preset) {
+      console.error(pc.red(`  Preset "${flags.preset}" not found.`));
+      console.error(pc.dim("  Available presets:"));
+      for (const p of presets) {
+        console.error(pc.dim(`    - ${p.name}`));
+      }
+      process.exit(1);
+    }
+    inputs = preset.inputs || {};
+    console.log(pc.dim(`  Using preset: ${preset.name}`));
+  }
+  if (flags.input) {
+    try {
+      const inputOverrides = JSON.parse(String(flags.input));
+      inputs = { ...inputs, ...inputOverrides };
+    } catch (e) {
+      console.error(pc.red("  Invalid JSON in --input flag."));
+      process.exit(1);
+    }
+  }
+  console.log();
+  const response = await fetch(`${apiUrl}/api/pb/collections/lm_automation_runs/records`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      automation: automation.id,
+      inputs: JSON.stringify(inputs),
+      status: "pending"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    console.error(pc.red(`  Failed to create automation run: ${error}`));
+    process.exit(1);
+  }
+  const run2 = await response.json();
+  console.log(pc.green("  \u2713"), `Automation run created: ${run2.id}`);
+  console.log(pc.dim(`    View at: ${apiUrl}/automations/${automation.id}/runs/${run2.id}`));
+  console.log();
+}
+async function runAutomationLocally(automationName, projectRoot, flags) {
+  const platformDir = existsSync(join(projectRoot, "platform")) ? join(projectRoot, "platform") : join(projectRoot, "lumera_platform");
+  const automationsDir = join(platformDir, "automations");
+  if (!existsSync(automationsDir)) {
+    console.error(pc.red("No automations directory found."));
+    process.exit(1);
+  }
+  let automationDir = null;
+  for (const entry of readdirSync(automationsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const configPath = join(automationsDir, entry.name, "config.json");
+    if (!existsSync(configPath)) continue;
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (config.external_id === automationName || config.name === automationName || entry.name === automationName) {
+        automationDir = join(automationsDir, entry.name);
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!automationDir) {
+    console.error(pc.red(`Automation "${automationName}" not found locally.`));
+    process.exit(1);
+  }
+  const mainPath = join(automationDir, "main.py");
+  if (!existsSync(mainPath)) {
+    console.error(pc.red(`Automation main.py not found at ${mainPath}`));
+    process.exit(1);
+  }
+  console.log(pc.dim(`Running automation locally: ${automationName}`));
+  console.log();
+  const env = { ...process.env };
+  if (flags.input) {
+    env.LUMERA_INPUTS = String(flags.input);
+  }
+  const uv = spawn("uv", ["run", mainPath], {
+    stdio: "inherit",
+    env,
+    cwd: projectRoot
+  });
+  uv.on("close", (code) => {
+    process.exit(code || 0);
+  });
+  uv.on("error", (err) => {
+    if (err.code === "ENOENT") {
+      console.error(pc.red("uv is not installed."));
+      console.error(pc.dim("Install it with: curl -LsSf https://astral.sh/uv/install.sh | sh"));
+    } else {
+      console.error(pc.red(`Failed to run automation: ${err.message}`));
+    }
+    process.exit(1);
+  });
+  process.on("SIGINT", () => uv.kill("SIGINT"));
+  process.on("SIGTERM", () => uv.kill("SIGTERM"));
+}
+async function run(args) {
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    showHelp();
+    process.exit(args.length === 0 ? 1 : 0);
+  }
+  const { target, flags } = parseFlags(args);
+  let projectRoot;
+  try {
+    projectRoot = findProjectRoot();
+  } catch {
+    projectRoot = process.cwd();
+  }
+  loadEnv(projectRoot);
+  if (target.startsWith("automations/")) {
+    const automationName = target.replace("automations/", "");
+    if (flags.local) {
+      await runAutomationLocally(automationName, projectRoot, flags);
+    } else {
+      await triggerAutomation(automationName, projectRoot, flags);
+    }
+    return;
+  }
+  await runScript(target, projectRoot);
+}
+export {
+  run
+};

package/dist/skills-56EUKHGY.js

@@ -0,0 +1,414 @@
+import {
+  getBaseUrl
+} from "./chunk-D2BLSEGR.js";
+
+// src/commands/skills.ts
+import pc from "picocolors";
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== "/") {
+    if (existsSync(join(dir, "lumera.json")) || existsSync(join(dir, ".claude"))) {
+      return dir;
+    }
+    dir = resolve(dir, "..");
+  }
+  return null;
+}
+function slugToFilename(slug) {
+  const normalizedSlug = slug.startsWith("lumera-") ? slug : `lumera-${slug}`;
+  return `${normalizedSlug.replace(/-/g, "_")}.md`;
+}
+function filenameToSlug(filename) {
+  return filename.replace(/\.md$/, "").replace(/_/g, "-");
+}
+function hashContent(content) {
+  return createHash("md5").update(content).digest("hex");
+}
+async function fetchSkillsList() {
+  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}`);
+  }
+  return listRes.json();
+}
+async function fetchSkillContent(slug) {
+  const baseUrl = getBaseUrl();
+  const skillsApiUrl = `${baseUrl}/api/public/skills`;
+  const mdRes = await fetch(`${skillsApiUrl}/${slug}.md`);
+  if (!mdRes.ok) {
+    return null;
+  }
+  return mdRes.text();
+}
+function getLocalSkills(skillsDir) {
+  const localSkills = /* @__PURE__ */ new Map();
+  if (!existsSync(skillsDir)) {
+    return localSkills;
+  }
+  for (const file of readdirSync(skillsDir)) {
+    if (file.endsWith(".md")) {
+      const content = readFileSync(join(skillsDir, file), "utf-8");
+      const slug = filenameToSlug(file);
+      localSkills.set(slug, hashContent(content));
+    }
+  }
+  return localSkills;
+}
+async function computeDiff(skillsDir, filterSlug) {
+  const skills2 = await fetchSkillsList();
+  const localSkills = getLocalSkills(skillsDir);
+  const remoteSkillSlugs = /* @__PURE__ */ new Set();
+  const diff = {
+    added: [],
+    updated: [],
+    removed: [],
+    unchanged: []
+  };
+  for (const skill of skills2) {
+    if (filterSlug) {
+      const normalizedFilter = filterSlug.startsWith("lumera-") ? filterSlug : `lumera-${filterSlug}`;
+      const normalizedSlug2 = skill.slug.startsWith("lumera-") ? skill.slug : `lumera-${skill.slug}`;
+      if (normalizedSlug2 !== normalizedFilter && skill.slug !== filterSlug) {
+        continue;
+      }
+    }
+    const normalizedSlug = skill.slug.startsWith("lumera-") ? skill.slug : `lumera-${skill.slug}`;
+    remoteSkillSlugs.add(normalizedSlug);
+    const localHash = localSkills.get(normalizedSlug);
+    if (!localHash) {
+      diff.added.push(skill);
+    } else {
+      const remoteContent = await fetchSkillContent(skill.slug);
+      if (remoteContent) {
+        const remoteHash = hashContent(remoteContent);
+        if (localHash !== remoteHash) {
+          diff.updated.push(skill);
+        } else {
+          diff.unchanged.push(skill.slug);
+        }
+      }
+    }
+  }
+  if (!filterSlug) {
+    for (const [localSlug] of localSkills) {
+      if (!remoteSkillSlugs.has(localSlug)) {
+        diff.removed.push(localSlug);
+      }
+    }
+  }
+  return diff;
+}
+function showHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera skills <command> [options]
+
+${pc.dim("Commands:")}
+  list, ls               List available skills from Lumera platform
+  install                Install skills (first-time setup)
+  update [slug]          Update skills to latest versions
+
+${pc.dim("Options:")}
+  --verbose, -v          Show detailed output
+  --force, -f            Force overwrite (install)
+  --dry-run              Show what would change (update)
+  --help, -h             Show this help
+
+${pc.dim("Examples:")}
+  lumera skills list                    # List available skills
+  lumera skills list -v                 # List with summaries
+  lumera skills install                 # First-time skill setup
+  lumera skills install --force         # Overwrite existing skills
+  lumera skills update                  # Update all skills
+  lumera skills update lumera-sdk       # Update a single skill
+  lumera skills update --dry-run        # Preview changes
+`);
+}
+async function skills(subcommand, args) {
+  if (subcommand === "--help" || subcommand === "-h") {
+    showHelp();
+    return;
+  }
+  const flags = parseFlags(args);
+  if (flags.help || flags.h || !subcommand) {
+    showHelp();
+    return;
+  }
+  switch (subcommand) {
+    case "list":
+    case "ls":
+      await list(flags);
+      break;
+    case "install":
+      await install(flags);
+      break;
+    case "update":
+      await update(args, flags);
+      break;
+    default:
+      console.error(pc.red(`Unknown skills command: ${subcommand}`));
+      console.error(`Run ${pc.cyan("lumera skills --help")} for usage.`);
+      process.exit(1);
+  }
+}
+function parseFlags(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        result[key] = next;
+        i++;
+      } else {
+        result[key] = true;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      result[key] = true;
+    }
+  }
+  return result;
+}
+function getPositionalArgs(args) {
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("-")) {
+      if (arg.startsWith("--")) {
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          i++;
+        }
+      }
+      continue;
+    }
+    positional.push(arg);
+  }
+  return positional;
+}
+async function list(flags) {
+  const verbose = Boolean(flags.verbose || flags.v);
+  console.log();
+  console.log(pc.cyan(pc.bold("  Available Lumera Skills")));
+  console.log();
+  try {
+    const skills2 = await fetchSkillsList();
+    if (skills2.length === 0) {
+      console.log(pc.dim("  No skills available"));
+      return;
+    }
+    for (const skill of skills2) {
+      if (verbose) {
+        console.log(`  ${pc.green(skill.name)}`);
+        console.log(`  ${pc.dim(skill.slug)}`);
+        console.log(`  ${pc.dim(skill.summary)}`);
+        console.log();
+      } else {
+        console.log(`  ${skill.name} ${pc.dim(`(${skill.slug})`)}`);
+      }
+    }
+    if (!verbose) {
+      console.log();
+      console.log(pc.dim(`  ${skills2.length} skills available. Use -v for details.`));
+    }
+    console.log();
+  } catch (err) {
+    console.log(pc.red("  Error:"), String(err));
+    process.exit(1);
+  }
+}
+async function install(flags) {
+  const force = Boolean(flags.force || flags.f);
+  const verbose = Boolean(flags.verbose || flags.v);
+  console.log();
+  console.log(pc.cyan(pc.bold("  Install Lumera Skills")));
+  console.log();
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log(pc.red("  Error: Not in a Lumera project directory"));
+    console.log(pc.dim("  Run this command from a directory containing lumera.json or .claude/"));
+    process.exit(1);
+  }
+  const skillsDir = join(projectRoot, ".claude", "skills");
+  const existingSkills = getLocalSkills(skillsDir);
+  if (existingSkills.size > 0 && !force) {
+    console.log(pc.yellow("  \u26A0"), `Skills already installed (${existingSkills.size} skills found)`);
+    console.log(pc.dim("  Use --force to overwrite existing skills"));
+    console.log(pc.dim('  Or use "lumera skills update" to update to latest versions'));
+    console.log();
+    return;
+  }
+  if (verbose) {
+    console.log(pc.dim(`  Project root: ${projectRoot}`));
+    console.log(pc.dim(`  Fetching skills from ${getBaseUrl()}...`));
+  }
+  try {
+    const skills2 = await fetchSkillsList();
+    mkdirSync(skillsDir, { recursive: true });
+    if (force && existsSync(skillsDir)) {
+      for (const file of readdirSync(skillsDir)) {
+        if (file.endsWith(".md")) {
+          rmSync(join(skillsDir, file));
+        }
+      }
+    }
+    let installed = 0;
+    let failed = 0;
+    for (const skill of skills2) {
+      const content = await fetchSkillContent(skill.slug);
+      if (!content) {
+        if (verbose) {
+          console.log(pc.yellow("  \u26A0"), pc.dim(`Failed to fetch ${skill.slug}`));
+        }
+        failed++;
+        continue;
+      }
+      const filename = slugToFilename(skill.slug);
+      writeFileSync(join(skillsDir, filename), content);
+      if (verbose) {
+        console.log(pc.green("  \u2713"), pc.dim(filename));
+      }
+      installed++;
+    }
+    console.log();
+    if (failed > 0) {
+      console.log(pc.yellow("  \u26A0"), `Installed ${installed} skills (${failed} failed)`);
+    } else {
+      console.log(pc.green("  \u2713"), `Installed ${installed} skills`);
+    }
+    console.log(pc.dim(`  Location: .claude/skills/`));
+    console.log();
+  } catch (err) {
+    console.log(pc.red("  Error:"), String(err));
+    process.exit(1);
+  }
+}
+async function update(args, flags) {
+  const dryRun = Boolean(flags["dry-run"]);
+  const verbose = Boolean(flags.verbose || flags.v);
+  const positional = getPositionalArgs(args);
+  const filterSlug = positional[0];
+  console.log();
+  if (dryRun) {
+    console.log(pc.cyan(pc.bold("  Update Lumera Skills (dry run)")));
+  } else {
+    console.log(pc.cyan(pc.bold("  Update Lumera Skills")));
+  }
+  console.log();
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log(pc.red("  Error: Not in a Lumera project directory"));
+    console.log(pc.dim("  Run this command from a directory containing lumera.json or .claude/"));
+    process.exit(1);
+  }
+  const skillsDir = join(projectRoot, ".claude", "skills");
+  if (!existsSync(skillsDir)) {
+    console.log(pc.yellow("  \u26A0"), "No skills installed yet");
+    console.log(pc.dim('  Run "lumera skills install" first'));
+    console.log();
+    return;
+  }
+  if (verbose) {
+    console.log(pc.dim(`  Project root: ${projectRoot}`));
+    if (filterSlug) {
+      console.log(pc.dim(`  Filtering by: ${filterSlug}`));
+    }
+    console.log(pc.dim(`  Computing diff...`));
+    console.log();
+  }
+  try {
+    const diff = await computeDiff(skillsDir, filterSlug);
+    const hasChanges = diff.added.length > 0 || diff.updated.length > 0 || diff.removed.length > 0;
+    if (!hasChanges) {
+      console.log(pc.green("  \u2713"), "All skills are up to date");
+      if (verbose && diff.unchanged.length > 0) {
+        console.log(pc.dim(`  ${diff.unchanged.length} skills unchanged`));
+      }
+      console.log();
+      return;
+    }
+    if (diff.added.length > 0) {
+      console.log(pc.green("  + New skills to add:"));
+      for (const skill of diff.added) {
+        console.log(`    ${pc.green("+")} ${skill.name} ${pc.dim(`(${skill.slug})`)}`);
+        if (verbose) {
+          console.log(`      ${pc.dim(skill.summary)}`);
+        }
+      }
+      console.log();
+    }
+    if (diff.updated.length > 0) {
+      console.log(pc.yellow("  ~ Skills to update:"));
+      for (const skill of diff.updated) {
+        console.log(`    ${pc.yellow("~")} ${skill.name} ${pc.dim(`(${skill.slug})`)}`);
+        if (verbose) {
+          console.log(`      ${pc.dim(skill.summary)}`);
+        }
+      }
+      console.log();
+    }
+    if (diff.removed.length > 0) {
+      console.log(pc.red("  - Skills to remove (no longer on platform):"));
+      for (const slug of diff.removed) {
+        console.log(`    ${pc.red("-")} ${slug}`);
+      }
+      console.log();
+    }
+    if (verbose && diff.unchanged.length > 0) {
+      console.log(pc.dim(`  ${diff.unchanged.length} skills unchanged`));
+      console.log();
+    }
+    const changes = [];
+    if (diff.added.length > 0) changes.push(`${diff.added.length} to add`);
+    if (diff.updated.length > 0) changes.push(`${diff.updated.length} to update`);
+    if (diff.removed.length > 0) changes.push(`${diff.removed.length} to remove`);
+    if (dryRun) {
+      console.log(pc.dim(`  Summary: ${changes.join(", ")}`));
+      console.log(pc.dim("  Run without --dry-run to apply changes"));
+      console.log();
+      return;
+    }
+    console.log(pc.dim("  Applying changes..."));
+    console.log();
+    for (const skill of diff.added) {
+      const content = await fetchSkillContent(skill.slug);
+      if (content) {
+        const filename = slugToFilename(skill.slug);
+        writeFileSync(join(skillsDir, filename), content);
+        console.log(pc.green("  +"), `Added ${skill.name}`);
+      }
+    }
+    for (const skill of diff.updated) {
+      const content = await fetchSkillContent(skill.slug);
+      if (content) {
+        const filename = slugToFilename(skill.slug);
+        writeFileSync(join(skillsDir, filename), content);
+        console.log(pc.yellow("  ~"), `Updated ${skill.name}`);
+      }
+    }
+    for (const slug of diff.removed) {
+      const filename = slugToFilename(slug);
+      const filepath = join(skillsDir, filename);
+      if (existsSync(filepath)) {
+        rmSync(filepath);
+        console.log(pc.red("  -"), `Removed ${slug}`);
+      }
+    }
+    console.log();
+    console.log(pc.green("  \u2713"), `Update complete (${changes.join(", ")})`);
+    console.log();
+  } catch (err) {
+    console.log(pc.red("  Error:"), String(err));
+    process.exit(1);
+  }
+}
+export {
+  skills
+};