@lumerahq/cli 0.13.1 → 0.14.0

package/README.md

@@ -23,12 +23,15 @@ lumera dev                 # Start dev server
 lumera apply app           # Deploy frontend
 lumera destroy app         # Delete app from Lumera
 
-lumera plan                # Preview infrastructure changes
-lumera apply               # Apply collections, automations, hooks
+lumera plan                # Preview changes (with inline diffs)
+lumera diff <resource>     # Full diff between local and remote
+lumera apply               # Apply collections, automations, hooks, agents
 lumera pull                # Pull remote state to local
+lumera list                # List resources with sync status
+lumera show <resource>     # Show resource details
 lumera destroy             # Delete remote resources
 
-lumera run <script>        # Run Python scripts locally
+lumera run <target>        # Run script, automation, or invoke agent
 ```
 
 ## Scaffolding Projects

package/dist/{chunk-7ZGIC6F7.js → chunk-NL6MEHA3.js}

@@ -5,10 +5,19 @@ import {
 // src/lib/api.ts
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
-import { dirname, join } from "path";
+import { dirname, resolve } from "path";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-8"));
+var __pkgDir = dirname(__filename);
+while (__pkgDir !== "/") {
+  try {
+    const candidate = resolve(__pkgDir, "package.json");
+    const parsed = JSON.parse(readFileSync(candidate, "utf-8"));
+    if (parsed.name === "@lumerahq/cli") break;
+  } catch {
+  }
+  __pkgDir = resolve(__pkgDir, "..");
+}
+var pkg = JSON.parse(readFileSync(resolve(__pkgDir, "package.json"), "utf-8"));
 var CLI_USER_AGENT = `lumera-cli/${pkg.version}`;
 var ApiClient = class {
   baseUrl;
@@ -190,10 +199,10 @@ function createApiClient(token, baseUrl) {
 // src/lib/env.ts
 import { config } from "dotenv";
 import { existsSync } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 function loadEnv(cwd = process.cwd()) {
-  const envPath = resolve(cwd, ".env");
-  const envLocalPath = resolve(cwd, ".env.local");
+  const envPath = resolve2(cwd, ".env");
+  const envLocalPath = resolve2(cwd, ".env.local");
   if (existsSync(envPath)) {
     config({ path: envPath });
   }

package/dist/{chunk-CDZZ3JYU.js → chunk-XTRDJLIA.js}

@@ -136,20 +136,37 @@ async function registerDevApp(apiBase, token, appName, appTitle, appUrl) {
     throw new Error(`Failed to register app: ${await res.text()}`);
   }
 }
+function detectRunner(projectRoot) {
+  if (existsSync(resolve(projectRoot, "bun.lockb")) || existsSync(resolve(projectRoot, "bun.lock"))) {
+    return ["bunx"];
+  }
+  if (existsSync(resolve(projectRoot, "pnpm-lock.yaml"))) {
+    return ["pnpm", "exec"];
+  }
+  try {
+    execSync("pnpm --version", { stdio: "ignore" });
+    return ["pnpm", "exec"];
+  } catch {
+    return ["bunx"];
+  }
+}
 async function dev(options) {
   const {
     token,
     appName,
     appTitle,
     port,
+    host,
     appUrl = `http://localhost:${port}`,
     apiUrl
   } = options;
+  const projectRoot = process.cwd();
   console.log();
   console.log(pc.cyan(pc.bold(`  ${appTitle} - Dev Server`)));
   console.log();
   console.log(pc.dim("  Configuration:"));
   console.log(pc.dim(`    Port: ${port}`));
+  if (host) console.log(pc.dim(`    Host: ${host}`));
   console.log(pc.dim(`    URL:  ${appUrl}`));
   console.log();
   console.log(pc.dim("  Registering app with Lumera..."));
@@ -175,7 +192,17 @@ async function dev(options) {
       ([key]) => safeEnvPrefixes.some((prefix) => key.startsWith(prefix)) || safeEnvKeys.includes(key)
     )
   );
-  const vite = spawn("pnpm", ["exec", "vite", "--port", String(port)], {
+  const runner = detectRunner(projectRoot);
+  const viteArgs = ["vite", "--port", String(port)];
+  const sandboxConfig = resolve(projectRoot, "vite.sandbox.config.ts");
+  if (existsSync(sandboxConfig)) {
+    viteArgs.push("--config", "vite.sandbox.config.ts");
+  }
+  if (host) {
+    viteArgs.push("--host", host);
+  }
+  const [cmd, ...cmdArgs] = runner;
+  const vite = spawn(cmd, [...cmdArgs, ...viteArgs], {
     stdio: "inherit",
     env: {
       ...filteredEnv,

package/dist/{dev-LNH47WSS.js → dev-5EAZUQ2S.js}

@@ -1,10 +1,10 @@
 import {
   dev
-} from "./chunk-CDZZ3JYU.js";
+} from "./chunk-XTRDJLIA.js";
 import {
   createApiClient,
   loadEnv
-} from "./chunk-7ZGIC6F7.js";
+} from "./chunk-NL6MEHA3.js";
 import {
   getToken
 } from "./chunk-NDLYGKS6.js";
@@ -49,6 +49,7 @@ ${pc.dim("Description:")}
 
 ${pc.dim("Options:")}
   --port <number>        Dev server port (default: 8080)
+  --host <host>          Host to bind to (e.g., 0.0.0.0 for all interfaces)
   --url <url>            App URL for dev mode (default: http://localhost:{port})
   --skip-setup           Skip auto-apply on first run
   --help, -h             Show this help
@@ -140,12 +141,14 @@ async function dev2(args) {
     }
   }
   const port = Number(flags.port || process.env.PORT || "8080");
+  const host = typeof flags.host === "string" ? flags.host : void 0;
   const appUrl = typeof flags.url === "string" ? flags.url : process.env.APP_URL;
   await dev({
     token,
     appName,
     appTitle,
     port,
+    host,
     appUrl,
     apiUrl
   });

package/dist/index.js

@@ -81,6 +81,7 @@ var COMMANDS = [
   "destroy",
   "list",
   "show",
+  "diff",
   "dev",
   "run",
   "init",
@@ -136,6 +137,7 @@ ${pc.dim("Resource Commands:")}
   ${pc.cyan("destroy")} [resource]       Delete resources
   ${pc.cyan("list")} [type]              List resources with status
   ${pc.cyan("show")} <resource>          Show resource details
+  ${pc.cyan("diff")} <resource>          Show full diff between local and remote
 
 ${pc.dim("Development:")}
   ${pc.cyan("dev")}                      Start dev server
@@ -210,29 +212,32 @@ async function main() {
     switch (command) {
       // Resource commands
       case "plan":
-        await import("./resources-PKLA2XDG.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-QKEUX3C3.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-PKLA2XDG.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-QKEUX3C3.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-PKLA2XDG.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-QKEUX3C3.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-PKLA2XDG.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-QKEUX3C3.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-PKLA2XDG.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-QKEUX3C3.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-PKLA2XDG.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-QKEUX3C3.js").then((m) => m.show(args.slice(1)));
+        break;
+      case "diff":
+        await import("./resources-QKEUX3C3.js").then((m) => m.diff(args.slice(1)));
         break;
       // Development
       case "dev":
-        await import("./dev-LNH47WSS.js").then((m) => m.dev(args.slice(1)));
+        await import("./dev-5EAZUQ2S.js").then((m) => m.dev(args.slice(1)));
         break;
       case "run":
-        await import("./run-3UBV3SVA.js").then((m) => m.run(args.slice(1)));
+        await import("./run-SPC4YXWR.js").then((m) => m.run(args.slice(1)));
         break;
       // Project
       case "init":

package/dist/{resources-PKLA2XDG.js → resources-QKEUX3C3.js}

@@ -1,10 +1,10 @@
 import {
   deploy
-} from "./chunk-CDZZ3JYU.js";
+} from "./chunk-XTRDJLIA.js";
 import {
   createApiClient,
   loadEnv
-} from "./chunk-7ZGIC6F7.js";
+} from "./chunk-NL6MEHA3.js";
 import {
   getToken
 } from "./chunk-NDLYGKS6.js";
@@ -31,6 +31,55 @@ function detectPackageManager() {
   }
   return "npm";
 }
+function computeLineDiff(oldText, newText) {
+  const oldLines = (oldText || "").trimEnd().split("\n");
+  const newLines = (newText || "").trimEnd().split("\n");
+  const m = oldLines.length;
+  const n = newLines.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      dp[i2][j2] = oldLines[i2 - 1] === newLines[j2 - 1] ? dp[i2 - 1][j2 - 1] + 1 : Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+    }
+  }
+  const result = [];
+  let i = m, j = n;
+  const stack = [];
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      stack.push({ type: " ", line: oldLines[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      stack.push({ type: "+", line: newLines[j - 1] });
+      j--;
+    } else {
+      stack.push({ type: "-", line: oldLines[i - 1] });
+      i--;
+    }
+  }
+  stack.reverse();
+  const contextLines = 2;
+  const changeIndices = /* @__PURE__ */ new Set();
+  stack.forEach((entry, idx) => {
+    if (entry.type !== " ") {
+      for (let c = Math.max(0, idx - contextLines); c <= Math.min(stack.length - 1, idx + contextLines); c++) {
+        changeIndices.add(c);
+      }
+    }
+  });
+  let lastIncluded = -2;
+  for (let idx = 0; idx < stack.length; idx++) {
+    if (changeIndices.has(idx)) {
+      if (lastIncluded < idx - 1) {
+        result.push({ type: " ", line: "..." });
+      }
+      result.push(stack[idx]);
+      lastIncluded = idx;
+    }
+  }
+  return result;
+}
 function showPlanHelp() {
   console.log(`
 ${pc.dim("Usage:")}
@@ -89,10 +138,15 @@ ${pc.dim("Examples:")}
 function showPullHelp() {
   console.log(`
 ${pc.dim("Usage:")}
-  lumera pull [resource]
+  lumera pull [resource] [--force]
 
 ${pc.dim("Description:")}
   Download remote state to local files.
+  Refuses to overwrite local files that have uncommitted changes
+  (use --force to override, or 'lumera diff' to inspect first).
+
+${pc.dim("Options:")}
+  --force, -f         Overwrite local files even if they have changes
 
 ${pc.dim("Resources:")}
   (none)              Pull all resources
@@ -105,9 +159,10 @@ ${pc.dim("Resources:")}
   agents/<name>       Pull single agent
 
 ${pc.dim("Examples:")}
-  lumera pull                        # Pull all resources
-  lumera pull collections            # Pull only collections
-  lumera pull automations/sync       # Pull single automation
+  lumera pull                        # Pull all (safe \u2014 warns on conflicts)
+  lumera pull agents                 # Pull only agents
+  lumera pull --force                # Pull all, overwrite local changes
+  lumera diff agents/my_agent        # Inspect before pulling
 `);
 }
 function showDestroyHelp() {
@@ -502,12 +557,17 @@ async function planAutomations(api, localAutomations) {
         if (codeChanged) details.push("code");
         if (nameChanged) details.push("name");
         if (descChanged) details.push("description");
+        const textDiffs = [];
+        if (codeChanged) {
+          textDiffs.push({ field: "main.py", oldText: remote.code || "", newText: code });
+        }
         changes.push({
           type: "update",
           resource: "automation",
           id: automation.external_id,
           name: automation.name,
-          details: `changed: ${details.join(", ")}`
+          details: `changed: ${details.join(", ")}`,
+          textDiffs
         });
       }
     }
@@ -539,12 +599,17 @@ async function planHooks(api, localHooks, collections) {
         const details = [];
         if (scriptChanged) details.push("script");
         if (eventChanged) details.push("trigger");
+        const textDiffs = [];
+        if (scriptChanged) {
+          textDiffs.push({ field: fileName, oldText: remote.script || "", newText: script });
+        }
         changes.push({
           type: "update",
           resource: "hook",
           id: hook.external_id,
           name: `${hook.collection}.${hook.trigger}`,
-          details: `changed: ${details.join(", ")}`
+          details: `changed: ${details.join(", ")}`,
+          textDiffs
         });
       }
     }
@@ -854,6 +919,7 @@ function loadLocalAgents(platformDir, filterName, appName) {
     const agentDir = join(agentsDir, entry.name);
     const configPath = join(agentDir, "config.json");
     const promptPath = join(agentDir, "system_prompt.md");
+    const policyPath = join(agentDir, "policy.js");
     if (!existsSync(configPath)) {
       errors.push(`${entry.name}: missing config.json`);
       continue;
@@ -880,7 +946,8 @@ function loadLocalAgents(platformDir, filterName, appName) {
         continue;
       }
       const systemPrompt = readFileSync(promptPath, "utf-8");
-      agents.push({ agent: config, systemPrompt });
+      const policyScript = existsSync(policyPath) ? readFileSync(policyPath, "utf-8") : "";
+      agents.push({ agent: config, systemPrompt, policyScript });
     } catch (e) {
       errors.push(`${entry.name}: failed to parse config.json - ${e}`);
     }
@@ -900,7 +967,7 @@ async function planAgents(api, localAgents) {
   const remoteByExternalId = new Map(
     remoteAgents.filter((a) => a.external_id && !a.managed).map((a) => [a.external_id, a])
   );
-  for (const { agent, systemPrompt } of localAgents) {
+  for (const { agent, systemPrompt, policyScript } of localAgents) {
     const remote = remoteByExternalId.get(agent.external_id);
     if (!remote) {
       changes.push({ type: "create", resource: "agent", id: agent.external_id, name: agent.name });
@@ -909,8 +976,18 @@ async function planAgents(api, localAgents) {
       if (remote.name !== agent.name) diffs.push("name");
       if ((remote.description || "") !== (agent.description || "")) diffs.push("description");
       if ((remote.system_prompt || "").trim() !== systemPrompt.trim()) diffs.push("system_prompt");
+      if ((remote.model || "") !== (agent.model || "")) diffs.push("model");
+      if ((remote.policy_script || "").trim() !== (policyScript || "").trim()) diffs.push("policy_script");
+      if ((remote.policy_enabled || false) !== (agent.policy_enabled || false)) diffs.push("policy_enabled");
       if (diffs.length > 0) {
-        changes.push({ type: "update", resource: "agent", id: agent.external_id, name: agent.name, details: `changed: ${diffs.join(", ")}` });
+        const textDiffs = [];
+        if (diffs.includes("system_prompt")) {
+          textDiffs.push({ field: "system_prompt.md", oldText: remote.system_prompt || "", newText: systemPrompt });
+        }
+        if (diffs.includes("policy_script")) {
+          textDiffs.push({ field: "policy.js", oldText: remote.policy_script || "", newText: policyScript });
+        }
+        changes.push({ type: "update", resource: "agent", id: agent.external_id, name: agent.name, details: `changed: ${diffs.join(", ")}`, textDiffs });
       }
     }
   }
@@ -932,7 +1009,7 @@ async function applyAgents(api, localAgents) {
       console.log(pc.yellow(`    \u26A0 Could not fetch skills for resolution: ${e}`));
     }
   }
-  for (const { agent, systemPrompt } of localAgents) {
+  for (const { agent, systemPrompt, policyScript } of localAgents) {
     const remote = remoteByExternalId.get(agent.external_id);
     const skillIds = [];
     if (agent.skills) {
@@ -950,7 +1027,10 @@ async function applyAgents(api, localAgents) {
       name: agent.name,
       description: agent.description || "",
       system_prompt: systemPrompt,
-      skill_ids: skillIds
+      model: agent.model || "",
+      skill_ids: skillIds,
+      policy_script: policyScript || "",
+      policy_enabled: agent.policy_enabled || false
     };
     try {
       if (remote) {
@@ -997,9 +1077,14 @@ async function pullAgents(api, platformDir, filterName) {
       name: agent.name
     };
     if (agent.description) config.description = agent.description;
+    if (agent.model) config.model = agent.model;
     if (skillSlugs.length > 0) config.skills = skillSlugs;
+    if (agent.policy_enabled) config.policy_enabled = true;
     writeFileSync(join(agentDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
     writeFileSync(join(agentDir, "system_prompt.md"), agent.system_prompt || "");
+    if (agent.policy_script) {
+      writeFileSync(join(agentDir, "policy.js"), agent.policy_script);
+    }
     console.log(pc.green("  \u2713"), `${agent.name} \u2192 agents/${dirName}/`);
   }
 }
@@ -1619,6 +1704,26 @@ async function plan(args) {
       }
       console.log();
     }
+    if (change.textDiffs && change.textDiffs.length > 0) {
+      const maxDiffLines = 20;
+      for (const td of change.textDiffs) {
+        const diffLines = computeLineDiff(td.oldText, td.newText);
+        if (diffLines.length > 0) {
+          console.log(pc.dim(`      --- ${td.field}`));
+          const shown = diffLines.slice(0, maxDiffLines);
+          for (const dl of shown) {
+            if (dl.type === "+") console.log(pc.green(`      + ${dl.line}`));
+            else if (dl.type === "-") console.log(pc.red(`      - ${dl.line}`));
+            else console.log(pc.dim(`        ${dl.line}`));
+          }
+          if (diffLines.length > maxDiffLines) {
+            const remaining = diffLines.length - maxDiffLines;
+            console.log(pc.dim(`      ... ${remaining} more lines \u2014 use ${pc.cyan(`lumera diff ${change.resource}s/${change.name}`)} for full diff`));
+          }
+          console.log();
+        }
+      }
+    }
   }
   console.log();
   console.log(pc.dim(`  Run 'lumera apply' to apply these changes.`));
@@ -1725,10 +1830,63 @@ async function pull(args) {
     showPullHelp();
     return;
   }
-  loadEnv();
+  const force = args.includes("--force") || args.includes("-f");
+  const filteredArgs = args.filter((a) => a !== "--force" && a !== "-f");
+  const projectRoot = findProjectRoot();
+  loadEnv(projectRoot);
   const platformDir = getPlatformDir();
   const api = createApiClient();
-  const { type, name } = parseResource(args[0]);
+  const appName = getAppName(projectRoot);
+  const { type, name } = parseResource(filteredArgs[0]);
+  if (!force) {
+    const conflicts = [];
+    let collections;
+    try {
+      const remoteCollections = await api.listCollections();
+      collections = new Map(remoteCollections.map((c) => [c.name, c.id]));
+    } catch {
+      collections = /* @__PURE__ */ new Map();
+    }
+    if (!type || type === "agents") {
+      const localAgents = loadLocalAgents(platformDir, name || void 0, appName);
+      if (localAgents.length > 0) {
+        const changes = await planAgents(api, localAgents);
+        for (const c of changes) {
+          if (c.type === "update") conflicts.push(`agents/${c.name}`);
+        }
+      }
+    }
+    if (!type || type === "automations") {
+      const localAutomations = loadLocalAutomations(platformDir, name || void 0, appName);
+      if (localAutomations.length > 0) {
+        const changes = await planAutomations(api, localAutomations);
+        for (const c of changes) {
+          if (c.type === "update") conflicts.push(`automations/${c.name}`);
+        }
+      }
+    }
+    if (!type || type === "hooks") {
+      const localHooks = loadLocalHooks(platformDir, name || void 0, appName);
+      if (localHooks.length > 0) {
+        const changes = await planHooks(api, localHooks, collections);
+        for (const c of changes) {
+          if (c.type === "update") conflicts.push(`hooks/${c.name}`);
+        }
+      }
+    }
+    if (conflicts.length > 0) {
+      console.log();
+      console.log(pc.yellow(`  \u26A0 ${conflicts.length} local file${conflicts.length > 1 ? "s have" : " has"} changes that would be lost:`));
+      for (const f of conflicts) {
+        console.log(pc.dim(`    ${f}`));
+      }
+      console.log();
+      console.log(pc.dim(`  Use ${pc.cyan("lumera diff <resource>")} to inspect changes.`));
+      console.log(pc.dim(`  Use ${pc.cyan("lumera pull --force")} to overwrite local files.`));
+      console.log();
+      process.exit(1);
+    }
+  }
   console.log();
   console.log(pc.cyan(pc.bold("  Pull")));
   console.log(pc.dim(`  Downloading remote state to ${platformDir}/...`));
@@ -1885,9 +2043,164 @@ async function show(args) {
     await showResource(api, platformDir, type, name, appName);
   }
 }
+function showDiffHelp() {
+  console.log(`
+${pc.bold("lumera diff")} - Show full diff between local and remote state
+
+${pc.dim("Usage:")}
+  lumera diff <resource>
+
+${pc.dim("Resources:")}
+  agents/<name>       Diff agent (system_prompt, policy_script)
+  automations/<name>  Diff automation code
+  hooks/<name>        Diff hook script
+
+${pc.dim("Examples:")}
+  lumera diff agents/bank_activity_matcher
+  lumera diff automations/sync
+  lumera diff hooks/encoding_protect_create
+`);
+}
+function renderFullDiff(field, oldText, newText) {
+  const diffLines = computeLineDiff(oldText, newText);
+  if (diffLines.length === 0) {
+    console.log(pc.dim(`  ${field}: no changes`));
+    return;
+  }
+  console.log(pc.bold(`  --- ${field}`));
+  for (const dl of diffLines) {
+    if (dl.type === "+") console.log(pc.green(`  + ${dl.line}`));
+    else if (dl.type === "-") console.log(pc.red(`  - ${dl.line}`));
+    else console.log(pc.dim(`    ${dl.line}`));
+  }
+  console.log();
+}
+async function diff(args) {
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    showDiffHelp();
+    if (args.length === 0) process.exit(1);
+    return;
+  }
+  const projectRoot = findProjectRoot();
+  loadEnv(projectRoot);
+  const platformDir = getPlatformDir();
+  const api = createApiClient();
+  const appName = getAppName(projectRoot);
+  const { type, name } = parseResource(args[0]);
+  if (!type || !name) {
+    console.log(pc.red(`  Invalid resource path: ${args[0]}`));
+    console.log(pc.dim("  Use format: <type>/<name> (e.g., agents/bank_activity_matcher)"));
+    process.exit(1);
+  }
+  console.log();
+  if (type === "agents") {
+    const localAgents = loadLocalAgents(platformDir, name, appName);
+    const remoteAgents = await api.listAgents();
+    const local = localAgents[0];
+    const localExtId = local?.agent.external_id;
+    const remote = remoteAgents.find(
+      (a) => a.external_id === name || a.name === name || localExtId && a.external_id === localExtId
+    );
+    if (!local && !remote) {
+      console.log(pc.red(`  Agent "${name}" not found locally or remotely`));
+      process.exit(1);
+    }
+    if (!local) {
+      console.log(pc.cyan(`  Agent "${name}" exists only remotely (not in local files)`));
+      process.exit(0);
+    }
+    if (!remote) {
+      console.log(pc.yellow(`  Agent "${name}" exists only locally (not yet deployed)`));
+      process.exit(0);
+    }
+    console.log(pc.bold(`  Agent: ${local.agent.name}`));
+    console.log();
+    if (remote.name !== local.agent.name)
+      console.log(`  name: ${pc.red(remote.name)} \u2192 ${pc.green(local.agent.name)}`);
+    if ((remote.description || "") !== (local.agent.description || ""))
+      console.log(`  description: ${pc.red(remote.description || "(empty)")} \u2192 ${pc.green(local.agent.description || "(empty)")}`);
+    if ((remote.model || "") !== (local.agent.model || ""))
+      console.log(`  model: ${pc.red(remote.model || "(default)")} \u2192 ${pc.green(local.agent.model || "(default)")}`);
+    if ((remote.policy_enabled || false) !== (local.agent.policy_enabled || false))
+      console.log(`  policy_enabled: ${pc.red(String(remote.policy_enabled || false))} \u2192 ${pc.green(String(local.agent.policy_enabled || false))}`);
+    const promptChanged = (remote.system_prompt || "").trim() !== local.systemPrompt.trim();
+    const policyChanged = (remote.policy_script || "").trim() !== (local.policyScript || "").trim();
+    if (!promptChanged && !policyChanged && remote.name === local.agent.name && (remote.description || "") === (local.agent.description || "") && (remote.model || "") === (local.agent.model || "") && (remote.policy_enabled || false) === (local.agent.policy_enabled || false)) {
+      console.log(pc.green(`  \u2713 No changes`));
+    } else {
+      if (promptChanged) renderFullDiff("system_prompt.md", remote.system_prompt || "", local.systemPrompt);
+      if (policyChanged) renderFullDiff("policy.js", remote.policy_script || "", local.policyScript);
+    }
+  } else if (type === "automations") {
+    const localAutomations = loadLocalAutomations(platformDir, name, appName);
+    const remoteAutomations = await api.listAutomations({ include_code: true });
+    const local = localAutomations[0];
+    const localExtId = local?.automation.external_id;
+    const remote = remoteAutomations.find(
+      (a) => a.external_id === name || a.name === name || localExtId && a.external_id === localExtId
+    );
+    if (!local && !remote) {
+      console.log(pc.red(`  Automation "${name}" not found locally or remotely`));
+      process.exit(1);
+    }
+    if (!local) {
+      console.log(pc.cyan(`  Automation "${name}" exists only remotely`));
+      process.exit(0);
+    }
+    if (!remote) {
+      console.log(pc.yellow(`  Automation "${name}" exists only locally (not yet deployed)`));
+      process.exit(0);
+    }
+    console.log(pc.bold(`  Automation: ${local.automation.name}`));
+    console.log();
+    if (remote.name !== local.automation.name)
+      console.log(`  name: ${pc.red(remote.name)} \u2192 ${pc.green(local.automation.name)}`);
+    const codeChanged = (remote.code || "") !== local.code;
+    if (!codeChanged && remote.name === local.automation.name) {
+      console.log(pc.green(`  \u2713 No changes`));
+    } else if (codeChanged) {
+      renderFullDiff("main.py", remote.code || "", local.code);
+    }
+  } else if (type === "hooks") {
+    const localHooks = loadLocalHooks(platformDir, name, appName);
+    const remoteHooks = await api.listHooks();
+    const local = localHooks[0];
+    const localExtId = local?.hook.external_id;
+    const remote = remoteHooks.find(
+      (h) => h.external_id === name || h.name === name || localExtId && h.external_id === localExtId
+    );
+    if (!local && !remote) {
+      console.log(pc.red(`  Hook "${name}" not found locally or remotely`));
+      process.exit(1);
+    }
+    if (!local) {
+      console.log(pc.cyan(`  Hook "${name}" exists only remotely`));
+      process.exit(0);
+    }
+    if (!remote) {
+      console.log(pc.yellow(`  Hook "${name}" exists only locally (not yet deployed)`));
+      process.exit(0);
+    }
+    console.log(pc.bold(`  Hook: ${local.hook.external_id}`));
+    console.log();
+    if (remote.event !== local.hook.trigger)
+      console.log(`  trigger: ${pc.red(remote.event)} \u2192 ${pc.green(local.hook.trigger)}`);
+    const scriptChanged = (remote.script || "").trim() !== local.script.trim();
+    if (!scriptChanged && remote.event === local.hook.trigger) {
+      console.log(pc.green(`  \u2713 No changes`));
+    } else if (scriptChanged) {
+      renderFullDiff(local.fileName, remote.script || "", local.script);
+    }
+  } else {
+    console.log(pc.red(`  Diff not supported for "${type}" \u2014 use agents, automations, or hooks`));
+    process.exit(1);
+  }
+  console.log();
+}
 export {
   apply,
   destroy,
+  diff,
   list,
   plan,
   pull,

package/dist/{run-3UBV3SVA.js → run-SPC4YXWR.js}

@@ -1,7 +1,7 @@
 import {
   createApiClient,
   loadEnv
-} from "./chunk-7ZGIC6F7.js";
+} from "./chunk-NL6MEHA3.js";
 import {
   getToken
 } from "./chunk-NDLYGKS6.js";

package/package.json

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