@enerlence/suntropy-cli 0.1.0

package/dist/bin/suntropy.js

@@ -0,0 +1,2926 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Command as Command2 } from "commander";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".suntropy");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  activeProfile: "default",
+  profiles: {
+    default: {
+      server: "https://api.enerlence.com"
+    }
+  }
+};
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  if (!existsSync(CONFIG_FILE)) {
+    writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2));
+    return { ...DEFAULT_CONFIG };
+  }
+  return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getActiveProfile(config, profileOverride) {
+  const name = profileOverride || config.activeProfile;
+  const profile = config.profiles[name];
+  if (!profile) {
+    throw new Error(`Profile "${name}" not found. Available: ${Object.keys(config.profiles).join(", ")}`);
+  }
+  return profile;
+}
+function setConfigValue(key, value, profileName) {
+  const config = loadConfig();
+  const name = profileName || config.activeProfile;
+  if (!config.profiles[name]) {
+    config.profiles[name] = { server: "https://api.enerlence.com" };
+  }
+  const profile = config.profiles[name];
+  profile[key] = value;
+  saveConfig(config);
+}
+function getConfigValue(key, profileName) {
+  const config = loadConfig();
+  const profile = getActiveProfile(config, profileName);
+  return profile[key];
+}
+var SERVICE_PATHS = {
+  security: "/security",
+  solar: "/solar",
+  templates: "/templates",
+  profiles: "/profiles",
+  periods: "/periods"
+};
+var LOCAL_PORTS = {
+  security: 8080,
+  solar: 8086,
+  templates: 8090,
+  profiles: 8085,
+  periods: 8084
+};
+function getServiceUrl(baseServer, service) {
+  if (baseServer.includes("localhost") || baseServer.match(/:\d+$/)) {
+    const port = LOCAL_PORTS[service];
+    const host = baseServer.replace(/:\d+$/, "").replace(/\/$/, "");
+    return `${host}:${port}`;
+  }
+  return `${baseServer.replace(/\/$/, "")}${SERVICE_PATHS[service]}`;
+}
+
+// src/client.ts
+import axios from "axios";
+function resolveAuth(opts) {
+  const config = loadConfig();
+  const profile = getActiveProfile(config, opts.profile);
+  const server = opts.server || profile.server;
+  const token = opts.token || profile.token;
+  if (!token) {
+    throw new Error("Not authenticated. Run: suntropy auth set-key --key <jwt> or suntropy auth login");
+  }
+  return { server, token };
+}
+function createServiceClient(service, opts) {
+  const { server, token } = resolveAuth(opts);
+  const baseURL = getServiceUrl(server, service);
+  const client = axios.create({
+    baseURL,
+    timeout: 3e4,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (opts.verbose) {
+    client.interceptors.request.use((req) => {
+      process.stderr.write(`\u2192 ${req.method?.toUpperCase()} ${req.baseURL}${req.url}
+`);
+      if (req.data) process.stderr.write(`  Body: ${JSON.stringify(req.data).slice(0, 200)}
+`);
+      return req;
+    });
+    client.interceptors.response.use(
+      (res) => {
+        process.stderr.write(`\u2190 ${res.status} (${JSON.stringify(res.data).length} bytes)
+`);
+        return res;
+      },
+      (err) => {
+        process.stderr.write(`\u2190 ERROR ${err.response?.status || "NETWORK"}: ${err.message}
+`);
+        return Promise.reject(err);
+      }
+    );
+  }
+  return client;
+}
+function createUnauthClient(baseURL) {
+  return axios.create({
+    baseURL,
+    timeout: 15e3,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function handleApiError(err) {
+  if (axios.isAxiosError(err)) {
+    const ae = err;
+    return {
+      error: true,
+      status: ae.response?.status || 0,
+      message: ae.response?.statusText || ae.message,
+      details: ae.response?.data
+    };
+  }
+  return {
+    error: true,
+    status: 0,
+    message: err instanceof Error ? err.message : String(err)
+  };
+}
+
+// src/output.ts
+import chalk from "chalk";
+import { writeFileSync as writeFileSync2 } from "fs";
+function pickFields(obj, fields) {
+  const result = {};
+  for (const f of fields) {
+    if (f.includes(".")) {
+      const parts = f.split(".");
+      let val = obj;
+      for (const p of parts) {
+        val = val && typeof val === "object" ? val[p] : void 0;
+      }
+      result[f] = val;
+    } else {
+      result[f] = obj[f];
+    }
+  }
+  return result;
+}
+function applyFieldSelection(data, fields) {
+  if (!fields) return data;
+  const fieldList = fields.split(",").map((f) => f.trim());
+  if (Array.isArray(data)) {
+    return data.map((item) => pickFields(item, fieldList));
+  }
+  if (typeof data === "object" && data !== null) {
+    return pickFields(data, fieldList);
+  }
+  return data;
+}
+function formatHumanValue(val) {
+  if (val === null || val === void 0) return "-";
+  if (typeof val === "object") return JSON.stringify(val);
+  return String(val);
+}
+function formatHuman(data) {
+  if (Array.isArray(data)) {
+    if (data.length === 0) return chalk.dim("(empty)");
+    const keys = Object.keys(data[0]);
+    const widths = keys.map((k) => Math.max(k.length, ...data.map((r) => formatHumanValue(r[k]).length)));
+    const header = keys.map((k, i) => chalk.bold(k.padEnd(widths[i]))).join("  ");
+    const rows = data.map(
+      (row) => keys.map((k, i) => formatHumanValue(row[k]).padEnd(widths[i])).join("  ")
+    );
+    return [header, keys.map((_, i) => "\u2500".repeat(widths[i])).join("  "), ...rows].join("\n");
+  }
+  if (typeof data === "object" && data !== null) {
+    const entries = Object.entries(data);
+    const maxKey = Math.max(...entries.map(([k]) => k.length));
+    return entries.map(([k, v]) => `${chalk.bold(k.padEnd(maxKey))}  ${formatHumanValue(v)}`).join("\n");
+  }
+  return String(data);
+}
+function formatCsv(data) {
+  if (!Array.isArray(data)) {
+    if (typeof data === "object" && data !== null) data = [data];
+    else return String(data);
+  }
+  const arr = data;
+  if (arr.length === 0) return "";
+  const keys = Object.keys(arr[0]);
+  const escape = (v) => {
+    const s = v === null || v === void 0 ? "" : String(v);
+    return s.includes(",") || s.includes('"') || s.includes("\n") ? `"${s.replace(/"/g, '""')}"` : s;
+  };
+  return [keys.join(","), ...arr.map((r) => keys.map((k) => escape(r[k])).join(","))].join("\n");
+}
+function output(data, opts = {}) {
+  const filtered = applyFieldSelection(data, opts.fields);
+  let text;
+  switch (opts.format) {
+    case "human":
+      text = formatHuman(filtered);
+      break;
+    case "csv":
+      text = formatCsv(filtered);
+      break;
+    default:
+      text = JSON.stringify(filtered, null, 2);
+  }
+  process.stdout.write(text + "\n");
+  if (opts.save) {
+    writeFileSync2(opts.save, JSON.stringify(filtered, null, 2));
+  }
+}
+function outputError(err) {
+  if (err && typeof err === "object" && "error" in err) {
+    const apiErr = err;
+    const out = { error: true, message: apiErr.message || "Unknown error" };
+    if (apiErr.status) out.status = apiErr.status;
+    if (apiErr.details) out.details = apiErr.details;
+    process.stderr.write(JSON.stringify(out) + "\n");
+  } else {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(JSON.stringify({ error: true, message: msg }) + "\n");
+  }
+  process.exitCode = 1;
+}
+function outputPaginated(data, total, limit, offset, opts = {}) {
+  if (opts.format === "human") {
+    const filtered = applyFieldSelection(data, opts.fields);
+    const end = Math.min(offset + limit, total);
+    process.stdout.write(chalk.dim(`Showing ${offset + 1}-${end} of ${total}
+
+`));
+    process.stdout.write(formatHuman(filtered) + "\n");
+  } else {
+    output({ data: applyFieldSelection(data, opts.fields), total, limit, offset, hasMore: offset + limit < total }, { ...opts, fields: void 0 });
+  }
+}
+
+// src/commands/auth.ts
+function getGlobalOpts(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Authentication management");
+  auth.command("set-key").description("Set an API key (JWT) for authentication. Preferred method for agents.").requiredOption("--key <jwt>", "JWT API key").option("--server <url>", "API server URL").option("--profile <name>", "Profile name").action(async (opts) => {
+    try {
+      const config = loadConfig();
+      const profileName = opts.profile || config.activeProfile;
+      if (!config.profiles[profileName]) {
+        config.profiles[profileName] = { server: "https://api.enerlence.com" };
+      }
+      const profile = config.profiles[profileName];
+      profile.token = opts.key;
+      profile.authMethod = "api-key";
+      if (opts.server) profile.server = opts.server;
+      try {
+        const payload = JSON.parse(Buffer.from(opts.key.split(".")[1], "base64").toString());
+        profile.clientUID = payload.clientUID;
+        profile.userUID = payload.userUID;
+      } catch {
+      }
+      saveConfig(config);
+      output({ success: true, method: "api-key", profile: profileName, clientUID: profile.clientUID, server: profile.server }, getGlobalOpts(auth));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  auth.command("login").description("Login with email and password").requiredOption("--email <email>", "User email").requiredOption("--password <password>", "User password").option("--server <url>", "API server URL").option("--profile <name>", "Profile name").action(async (opts) => {
+    try {
+      const config = loadConfig();
+      const profileName = opts.profile || config.activeProfile;
+      if (!config.profiles[profileName]) {
+        config.profiles[profileName] = { server: "https://api.enerlence.com" };
+      }
+      const profile = config.profiles[profileName];
+      if (opts.server) profile.server = opts.server;
+      const securityUrl = getServiceUrl(profile.server, "security");
+      const client = createUnauthClient(securityUrl);
+      const res = await client.post("/auth/login", { email: opts.email, password: opts.password });
+      if (res.data?.token?.access_token) {
+        profile.token = res.data.token.access_token;
+        profile.authMethod = "login";
+        profile.email = opts.email;
+        profile.clientUID = res.data.user?.clientUID;
+        profile.userUID = res.data.user?.userUID;
+        saveConfig(config);
+        output({
+          success: true,
+          method: "login",
+          profile: profileName,
+          user: {
+            email: res.data.user?.email,
+            clientUID: res.data.user?.clientUID,
+            userUID: res.data.user?.userUID
+          }
+        }, getGlobalOpts(auth));
+      } else {
+        outputError(new Error(res.data?.errors?.[0]?.message || "Login failed"));
+      }
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  auth.command("status").description("Show current authentication status").option("--profile <name>", "Profile name").action(async (opts) => {
+    try {
+      const config = loadConfig();
+      const profile = getActiveProfile(config, opts.profile);
+      if (!profile.token) {
+        output({ authenticated: false, message: "No token configured" }, getGlobalOpts(auth));
+        return;
+      }
+      let expiresAt;
+      let expired = false;
+      try {
+        const payload = JSON.parse(Buffer.from(profile.token.split(".")[1], "base64").toString());
+        if (payload.exp) {
+          const expDate = new Date(payload.exp * 1e3);
+          expiresAt = expDate.toISOString();
+          expired = expDate < /* @__PURE__ */ new Date();
+        }
+      } catch {
+      }
+      output({
+        authenticated: !expired,
+        method: profile.authMethod || "unknown",
+        server: profile.server,
+        email: profile.email,
+        clientUID: profile.clientUID,
+        userUID: profile.userUID,
+        expiresAt,
+        expired
+      }, getGlobalOpts(auth));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  auth.command("refresh").description("Refresh the current JWT token").option("--profile <name>", "Profile name").action(async (opts) => {
+    try {
+      const config = loadConfig();
+      const profileName = opts.profile || config.activeProfile;
+      const globalOpts = program2.opts();
+      const client = createServiceClient("security", { ...globalOpts, profile: profileName });
+      const res = await client.get("/auth/jwt/refreshToken");
+      if (res.data?.access_token || res.data?.token?.access_token) {
+        const newToken = res.data.access_token || res.data.token.access_token;
+        config.profiles[profileName].token = newToken;
+        saveConfig(config);
+        output({ success: true, message: "Token refreshed" }, getGlobalOpts(auth));
+      } else {
+        outputError(new Error("Refresh failed"));
+      }
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+}
+
+// src/commands/config.ts
+function registerConfigCommands(program2) {
+  const cfg = program2.command("config").description("CLI configuration management");
+  cfg.command("set <key> <value>").description("Set a configuration value. Keys: server, token, activeProfile").option("--profile <name>", "Profile to modify").action((key, value, opts) => {
+    try {
+      if (key === "activeProfile") {
+        const config = loadConfig();
+        config.activeProfile = value;
+        saveConfig(config);
+      } else {
+        setConfigValue(key, value, opts.profile);
+      }
+      output({ success: true, key, value });
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  cfg.command("get <key>").description("Get a configuration value").option("--profile <name>", "Profile to read from").action((key, opts) => {
+    try {
+      if (key === "activeProfile") {
+        const config = loadConfig();
+        output({ activeProfile: config.activeProfile });
+      } else {
+        output({ [key]: getConfigValue(key, opts.profile) });
+      }
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  cfg.command("list").description("Show all configuration").action(() => {
+    try {
+      const config = loadConfig();
+      const safe = JSON.parse(JSON.stringify(config));
+      for (const [name, profile] of Object.entries(safe.profiles)) {
+        const p = profile;
+        if (p.token) p.token = p.token.slice(0, 20) + "...";
+      }
+      output(safe);
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  cfg.command("create-profile <name>").description("Create a new profile").option("--server <url>", "API server URL", "https://api.enerlence.com").action((name, opts) => {
+    try {
+      const config = loadConfig();
+      if (config.profiles[name]) {
+        outputError(new Error(`Profile "${name}" already exists`));
+        return;
+      }
+      config.profiles[name] = { server: opts.server };
+      saveConfig(config);
+      output({ success: true, profile: name, server: opts.server });
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  cfg.command("use <name>").description("Switch to a profile").action((name) => {
+    try {
+      const config = loadConfig();
+      if (!config.profiles[name]) {
+        outputError(new Error(`Profile "${name}" not found. Available: ${Object.keys(config.profiles).join(", ")}`));
+        return;
+      }
+      config.activeProfile = name;
+      saveConfig(config);
+      output({ success: true, activeProfile: name });
+    } catch (err) {
+      outputError(err);
+    }
+  });
+}
+
+// src/commands/inventory/factory.ts
+import { Command } from "commander";
+function getGlobalOpts2(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function parseData(data) {
+  if (!data) return void 0;
+  if (data === "-") {
+    const { readFileSync: readFileSync5 } = __require("fs");
+    const input = readFileSync5(0, "utf-8");
+    return JSON.parse(input);
+  }
+  return JSON.parse(data);
+}
+function createResourceCommands(cfg) {
+  const cmd = new Command(cfg.name).description(`Manage ${cfg.singular}s`);
+  const service = cfg.service || "solar";
+  cmd.command("list").description(`List ${cfg.singular}s with pagination. Fields: ${cfg.listFields.join(", ")}`).option("--limit <n>", "Max results", "20").option("--offset <n>", "Skip results", "0").option("--active-only", "Only active items (exclude inactive)").action(async (opts) => {
+    try {
+      const global = getGlobalOpts2(cmd);
+      const client = createServiceClient(service, global);
+      const params = {
+        limit: parseInt(opts.limit),
+        offset: parseInt(opts.offset)
+      };
+      if (!opts.activeOnly) params.unactive = true;
+      const res = await client.get(cfg.basePath, { params });
+      let data;
+      let total;
+      if (Array.isArray(res.data) && res.data.length >= 2 && Array.isArray(res.data[0]) && typeof res.data[1] === "number") {
+        data = res.data[0];
+        total = res.data[1];
+      } else if (Array.isArray(res.data)) {
+        data = res.data;
+        total = res.data.length;
+      } else {
+        data = res.data?.data || [];
+        total = res.data?.total ?? data.length;
+      }
+      const outOpts = { ...global };
+      if (!global.fields && cfg.listFields.length > 0) {
+        outOpts.fields = [cfg.idField, ...cfg.listFields].join(",");
+      }
+      if (Array.isArray(data)) {
+        outputPaginated(data, total, parseInt(opts.limit), parseInt(opts.offset), outOpts);
+      } else {
+        output(data, outOpts);
+      }
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  cmd.command("get <id>").description(`Get a ${cfg.singular} by ID. All fields returned by default.`).action(async (id) => {
+    try {
+      const global = getGlobalOpts2(cmd);
+      const client = createServiceClient(service, global);
+      if (cfg.getViaFilter) {
+        const res = await client.get(cfg.basePath, { params: { unactive: true } });
+        const all = Array.isArray(res.data) ? res.data : Array.isArray(res.data?.[0]) ? res.data[0] : res.data?.data || [];
+        const idNum = parseInt(id);
+        const item = all.find((r) => r[cfg.idField] === idNum || r[cfg.idField] === id);
+        if (!item) {
+          outputError(new Error(`${cfg.singular} with ${cfg.idField}=${id} not found`));
+          return;
+        }
+        output(item, global);
+      } else {
+        const url = cfg.getPath ? cfg.getPath.replace(":id", id) : `${cfg.basePath}/${id}`;
+        const res = await client.get(url);
+        output(res.data, global);
+      }
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  cmd.command("create").description(`Create a new ${cfg.singular}. Pass JSON via --data or stdin (--data -)`).requiredOption("--data <json>", "JSON data (or - for stdin)").action(async (opts) => {
+    try {
+      const global = getGlobalOpts2(cmd);
+      const client = createServiceClient(service, global);
+      const body = parseData(opts.data);
+      const res = await client.post(cfg.basePath, body);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  cmd.command("update <id>").description(`Update a ${cfg.singular}`).requiredOption("--data <json>", "JSON data with fields to update (or - for stdin)").action(async (id, opts) => {
+    try {
+      const global = getGlobalOpts2(cmd);
+      const client = createServiceClient(service, global);
+      const body = parseData(opts.data);
+      if (cfg.putBodyOnly) {
+        const res = await client.put(cfg.basePath, { ...body, [cfg.idField]: id });
+        output(res.data, global);
+      } else {
+        const res = await client.put(`${cfg.basePath}/${id}`, body);
+        output(res.data, global);
+      }
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  cmd.command("delete <id>").description(`Delete a ${cfg.singular}`).action(async (id) => {
+    try {
+      const global = getGlobalOpts2(cmd);
+      const client = createServiceClient(service, global);
+      const res = await client.delete(`${cfg.basePath}/${id}`);
+      output(res.data ?? { success: true, deleted: id }, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  if (cfg.batchDeletePath) {
+    cmd.command("delete-batch").description(`Batch delete ${cfg.singular}s`).requiredOption("--ids <ids>", "Comma-separated IDs").action(async (opts) => {
+      try {
+        const global = getGlobalOpts2(cmd);
+        const client = createServiceClient(service, global);
+        const ids = opts.ids.split(",").map((s) => s.trim());
+        const res = await client.post(`${cfg.basePath}/${cfg.batchDeletePath}`, ids);
+        output(res.data ?? { success: true, deleted: ids.length }, global);
+      } catch (err) {
+        outputError(handleApiError(err));
+      }
+    });
+  }
+  cmd.command("filter").description(`Advanced filter for ${cfg.singular}s. Pass filter query as JSON.`).requiredOption("--query <json>", "Filter query JSON (or - for stdin)").option("--limit <n>", "Max results", "20").option("--offset <n>", "Skip results", "0").action(async (opts) => {
+    try {
+      const global = getGlobalOpts2(cmd);
+      const client = createServiceClient(service, global);
+      const query = parseData(opts.query);
+      const filterUrl = cfg.filterPath || `${cfg.basePath}/filter`;
+      const res = await client.post(filterUrl, {
+        ...query,
+        limit: parseInt(opts.limit),
+        offset: parseInt(opts.offset)
+      });
+      const data = Array.isArray(res.data) ? res.data : res.data?.data || res.data;
+      const total = res.data?.total ?? (Array.isArray(data) ? data.length : 0);
+      outputPaginated(data, total, parseInt(opts.limit), parseInt(opts.offset), global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  return cmd;
+}
+
+// src/commands/inventory/kits.ts
+function getGlobalOpts3(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function parseData2(data) {
+  if (data === "-") {
+    const { readFileSync: readFileSync5 } = __require("fs");
+    return JSON.parse(readFileSync5(0, "utf-8"));
+  }
+  return JSON.parse(data);
+}
+function registerKitsCommands(inventory) {
+  const kits = createResourceCommands({
+    name: "kits",
+    singular: "solar kit",
+    basePath: "/solar-kits",
+    idField: "idSolarKit",
+    listFields: ["identifier", "peakPower", "panelNumber", "inverterNumber", "price", "totalPrice", "phaseNumber", "active"],
+    filterPath: "/solar-kits/filters",
+    batchDeletePath: "delete-batch-solar-kits",
+    getViaFilter: true
+  });
+  kits.command("archive <kitId>").description("Archive a solar kit (soft-disable)").action(async (kitId) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.put(`/solar-kits/archive/${kitId}`);
+      output(res.data ?? { success: true, archived: kitId }, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  const kitPanels = kits.command("panels").description("Manage kit solar panels");
+  kitPanels.command("list").description("List all kit solar panels. Fields: idKitSolarPanel, name, manufacturer, peakPower, efficiency, costPerUnit").option("--limit <n>", "Max results", "50").option("--offset <n>", "Skip results", "0").action(async (opts) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.get("/solar-kits/solar-panels", { params: { limit: opts.limit, offset: opts.offset } });
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitPanels.command("get <id>").description("Get a kit solar panel by ID").action(async (id) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.post("/solar-kits/solar-panels/filter", { idKitSolarPanel: id });
+      const data = Array.isArray(res.data) ? res.data[0] : res.data?.data?.[0] || res.data;
+      output(data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitPanels.command("create").description("Create a kit solar panel").requiredOption("--data <json>", "JSON data").action(async (opts) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.post("/solar-kits/solar-panels", parseData2(opts.data));
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitPanels.command("update <id>").description("Update a kit solar panel").requiredOption("--data <json>", "JSON data").action(async (id, opts) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.put(`/solar-kits/solar-panels/${id}`, parseData2(opts.data));
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitPanels.command("delete <id>").description("Delete a kit solar panel").action(async (id) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.delete(`/solar-kits/solar-panels/${id}`);
+      output(res.data ?? { success: true, deleted: id }, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitPanels.command("featured <kitPanelId>").description("List solar kits that feature this kit panel").action(async (kitPanelId) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.get(`/solar-kits/solar-panels/findFeaturedSolarKits/${kitPanelId}`);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  const kitInverters = kits.command("inverters").description("Manage kit inverters");
+  kitInverters.command("list").description("List all kit inverters. Fields: idKitInverter, name, manufacturer, nominalPower, efficiency, costPerUnit").option("--limit <n>", "Max results", "50").option("--offset <n>", "Skip results", "0").action(async (opts) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.get("/solar-kits/inverters", { params: { limit: opts.limit, offset: opts.offset } });
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitInverters.command("create").description("Create a kit inverter").requiredOption("--data <json>", "JSON data").action(async (opts) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.post("/solar-kits/inverters", parseData2(opts.data));
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitInverters.command("update <id>").description("Update a kit inverter").requiredOption("--data <json>", "JSON data").action(async (id, opts) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.put(`/solar-kits/inverters/${id}`, parseData2(opts.data));
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitInverters.command("delete <id>").description("Delete a kit inverter").action(async (id) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.delete(`/solar-kits/inverters/${id}`);
+      output(res.data ?? { success: true, deleted: id }, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitInverters.command("featured <kitInverterId>").description("List solar kits that feature this kit inverter").action(async (kitInverterId) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.get(`/solar-kits/inverters/findFeaturedSolarKits/${kitInverterId}`);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  const kitBatteries = kits.command("batteries").description("Manage kit batteries");
+  kitBatteries.command("list").description("List all kit batteries. Fields: idKitBattery, name, manufacturer, capacity, costPerUnit").option("--limit <n>", "Max results", "50").option("--offset <n>", "Skip results", "0").action(async (opts) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.get("/solar-kits/batteries", { params: { limit: opts.limit, offset: opts.offset } });
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitBatteries.command("create").description("Create a kit battery").requiredOption("--data <json>", "JSON data").action(async (opts) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.post("/solar-kits/batteries", parseData2(opts.data));
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kitBatteries.command("delete <id>").description("Delete a kit battery").action(async (id) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const res = await client.delete(`/solar-kits/batteries/${id}`);
+      output(res.data ?? { success: true, deleted: id }, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  kits.command("assemble").description(
+    'Assemble a solar kit from existing components by ID.\nReferences kit panels, inverters, batteries, and custom assets by their IDs.\n\nCustom assets format: --custom-asset <assetId>:<units> (repeatable)\n\nExamples:\n  suntropy inventory kits assemble --name "Kit 5kW" --panel 123 --inverter 456 --panels-count 12 --price 6500\n  suntropy inventory kits assemble --name "Kit Premium" --panel 123 --inverter 456 --battery 789 \\\n    --panels-count 12 --inverters-count 1 --batteries-count 1 --peak-power 5.4 --price 8500 \\\n    --custom-asset 100:12 --custom-asset 200:1 --phase single_phase'
+  ).requiredOption("--name <identifier>", "Kit name/identifier").option("--panel <kitPanelId>", "Kit panel ID (idKitSolarPanel)").option("--inverter <kitInverterId>", "Kit inverter ID (idKitInverter)").option("--battery <batteryId>", "Battery ID from inventory (batteryId)").option("--panels-count <n>", "Number of panels", "12").option("--inverters-count <n>", "Number of inverters", "1").option("--batteries-count <n>", "Number of batteries", "0").option("--peak-power <kW>", "Total peak power in kW").option("--price <eur>", "Kit price in EUR").option("--phase <type>", "Phase: single_phase or three_phase", "single_phase").option("--coplanar", "Coplanar mounting").option("--taxes <pct>", "Default tax percentage", "21").option("--custom-asset <id:units>", "Custom asset as id:units (repeatable)", collectCustomAssets, []).action(async (opts) => {
+    try {
+      const global = getGlobalOpts3(kits);
+      const client = createServiceClient("solar", global);
+      const body = {
+        identifier: opts.name,
+        panelNumber: parseInt(opts.panelsCount),
+        inverterNumber: parseInt(opts.invertersCount),
+        batteriesNumber: parseInt(opts.batteriesCount),
+        phaseNumber: opts.phase,
+        defaultTaxesPercentage: parseFloat(opts.taxes),
+        active: true
+      };
+      if (opts.panel) body.kitSolarPanel = { idKitSolarPanel: parseInt(opts.panel) };
+      if (opts.inverter) body.kitInverter = { idKitInverter: parseInt(opts.inverter) };
+      if (opts.battery) body.battery = { batteryId: parseInt(opts.battery) };
+      if (opts.peakPower) body.peakPower = parseFloat(opts.peakPower);
+      if (opts.price) body.price = parseFloat(opts.price);
+      if (opts.coplanar) body.coplanar = true;
+      if (opts.customAsset && opts.customAsset.length > 0) {
+        body.solarKitCustomAssets = opts.customAsset.map((ca) => ({
+          customAsset: { idCustomAsset: ca.id },
+          units: ca.units
+        }));
+      }
+      const res = await client.post("/solar-kits", body);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  inventory.addCommand(kits);
+}
+function collectCustomAssets(value, previous) {
+  const [idStr, unitsStr] = value.split(":");
+  const id = parseInt(idStr);
+  const units = unitsStr ? parseInt(unitsStr) : 1;
+  if (isNaN(id)) throw new Error(`Invalid custom asset format: "${value}". Use <id>:<units> (e.g. 100:12)`);
+  return [...previous, { id, units }];
+}
+
+// src/commands/inventory/manufacturers.ts
+function getGlobalOpts4(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function registerManufacturersCommands(inventory) {
+  const mfr = inventory.command("manufacturers").description("Manage manufacturers (referenced by all inventory devices)");
+  mfr.command("list").description("List all manufacturers. Fields: idManufacturer, name, imageUrl").action(async () => {
+    try {
+      const global = getGlobalOpts4(mfr);
+      const client = createServiceClient("solar", global);
+      const res = await client.get("/manufacturers");
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  mfr.command("create").description("Create a new manufacturer").requiredOption("--data <json>", 'JSON: { "name": "Manufacturer Name", "imageUrl": "..." }').action(async (opts) => {
+    try {
+      const global = getGlobalOpts4(mfr);
+      const client = createServiceClient("solar", global);
+      const body = JSON.parse(opts.data);
+      const res = await client.post("/manufacturers", body);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+}
+
+// src/commands/inventory/custom-fields.ts
+function getGlobalOpts5(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function parseData3(data) {
+  if (!data) return void 0;
+  return JSON.parse(data);
+}
+function registerCustomFieldsCommands(inventory) {
+  const fields = inventory.command("custom-fields").description(
+    "Manage custom fields for custom asset types.\nFields define the schema of a custom asset type (e.g. text, number, options).\nTypes: text, number, date, datetime, time, email, phonenumber, website, options, labels, currency, large_text, user"
+  );
+  fields.command("list").description("List all custom fields").action(async () => {
+    try {
+      const global = getGlobalOpts5(fields);
+      const client = createServiceClient("solar", global);
+      const res = await client.get("/custom-asset/custom-field/all");
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  fields.command("get <id>").description("Get a custom field by ID").action(async (id) => {
+    try {
+      const global = getGlobalOpts5(fields);
+      const client = createServiceClient("solar", global);
+      const res = await client.get(`/custom-asset/custom-field/id/${id}`);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  fields.command("create").description(
+    `Create a custom field for a custom asset type.
+Required: label, type, customAssetTypeId
+For options/labels type, include customFieldOptions array.
+
+Example:
+  suntropy inventory custom-fields create --data '{"label":"Power","type":"number","customAssetTypeId":1}'
+  suntropy inventory custom-fields create --data '{"label":"Size","type":"options","customAssetTypeId":1,"customFieldOptions":[{"label":"S","value":"s"},{"label":"M","value":"m"},{"label":"L","value":"l"}]}'`
+  ).requiredOption("--data <json>", "Field definition as JSON").action(async (opts) => {
+    try {
+      const global = getGlobalOpts5(fields);
+      const client = createServiceClient("solar", global);
+      const body = parseData3(opts.data);
+      const res = await client.post("/custom-asset/custom-field", body);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  fields.command("update <id>").description("Update a custom field").requiredOption("--data <json>", "Updated field data as JSON").action(async (id, opts) => {
+    try {
+      const global = getGlobalOpts5(fields);
+      const client = createServiceClient("solar", global);
+      const body = parseData3(opts.data);
+      const res = await client.put(`/custom-asset/custom-field/${id}`, body);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  fields.command("delete <id>").description("Delete a custom field").action(async (id) => {
+    try {
+      const global = getGlobalOpts5(fields);
+      const client = createServiceClient("solar", global);
+      const res = await client.delete(`/custom-asset/custom-field/${id}`);
+      output(res.data ?? { success: true, deleted: id }, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+}
+
+// src/commands/inventory/index.ts
+var RESOURCES = [
+  {
+    name: "panels",
+    singular: "solar panel",
+    basePath: "/solar-panels",
+    idField: "solarPanelId",
+    listFields: ["name", "manufacturer", "peakPower", "efficiency", "costPerUnit", "active"],
+    batchDeletePath: "delete-batch-solar-panels"
+  },
+  {
+    name: "inverters",
+    singular: "solar inverter",
+    basePath: "/solar-inverter",
+    idField: "idInverter",
+    listFields: ["name", "manufacturer", "nominalPower", "efficiency", "phaseNumber", "isMicroinverter", "isHybrid", "costPerUnit", "active"],
+    batchDeletePath: "delete-batch-solar-inverters",
+    putBodyOnly: true
+  },
+  {
+    name: "batteries",
+    singular: "battery",
+    basePath: "/solar-battery",
+    idField: "batteryId",
+    listFields: ["name", "manufacturer", "capacity", "isModular", "costPerUnit", "active"],
+    batchDeletePath: "delete-batch-solar-batteries"
+  },
+  {
+    name: "chargers",
+    singular: "VE charger",
+    basePath: "/charger",
+    idField: "idCharger",
+    listFields: ["name", "manufacturer", "maxPower", "connectorType", "phaseNumber", "costPerUnit", "active"],
+    batchDeletePath: "delete-batch-chargers",
+    putBodyOnly: true
+  },
+  {
+    name: "heatpumps",
+    singular: "heat pump",
+    basePath: "/heat-pump",
+    idField: "idHeatpump",
+    listFields: ["name", "manufacturer", "lowerPower", "upperPower", "scop", "costPerUnit", "active"],
+    batchDeletePath: "delete-batch-heatpumps",
+    putBodyOnly: true
+  },
+  {
+    name: "custom-assets",
+    singular: "custom asset",
+    basePath: "/custom-asset",
+    idField: "idCustomAsset",
+    listFields: ["label", "customAssetType", "identifier", "isMaterial", "costPerUnit", "active"],
+    getPath: "/custom-asset/id/:id"
+  },
+  {
+    name: "custom-asset-types",
+    singular: "custom asset type",
+    basePath: "/custom-asset/type",
+    idField: "idCustomAssetType",
+    listFields: ["label", "isMaterialConcept", "panelsQuantity"],
+    getPath: "/custom-asset/type/id/:id"
+  },
+  {
+    name: "charger-kits",
+    singular: "VE charger kit",
+    basePath: "/charger/ve-charger-kits",
+    idField: "idVEChargerKit",
+    listFields: ["identifier", "charger", "price", "phaseNumber", "active"],
+    filterPath: "/charger/ve-charger-kits/filter",
+    batchDeletePath: "delete-batch-ve-charger-kits",
+    putBodyOnly: true
+  },
+  {
+    name: "heatpump-kits",
+    singular: "heat pump kit",
+    basePath: "/heat-pump/heatpump-kits",
+    idField: "idHeatpumpKit",
+    listFields: ["identifier", "heatpump", "price", "phaseNumber", "active"],
+    filterPath: "/heat-pump/heatpump-kits/filter",
+    batchDeletePath: "delete-batch-heatpump-kits",
+    putBodyOnly: true
+  }
+];
+function registerInventoryCommands(program2) {
+  const inventory = program2.command("inventory").description("Manage inventory: panels, inverters, batteries, chargers, heatpumps, custom-assets, kits");
+  registerManufacturersCommands(inventory);
+  for (const resource of RESOURCES) {
+    inventory.addCommand(createResourceCommands(resource));
+  }
+  registerCustomFieldsCommands(inventory);
+  registerKitsCommands(inventory);
+}
+
+// src/commands/studies/builder.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync2 } from "fs";
+
+// node_modules/uuid/dist/esm-node/rng.js
+import crypto from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// node_modules/uuid/dist/esm-node/regex.js
+var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+// node_modules/uuid/dist/esm-node/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default = validate;
+
+// node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).substr(1));
+}
+function stringify(arr, offset = 0) {
+  const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+  if (!validate_default(uuid)) {
+    throw TypeError("Stringified UUID is invalid");
+  }
+  return uuid;
+}
+var stringify_default = stringify;
+
+// node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return stringify_default(rnds);
+}
+var v4_default = v4;
+
+// src/commands/studies/builder.ts
+function createDefaultStudy(name) {
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().split("T")[0];
+  return {
+    id: v4_default(),
+    surfaces: void 0,
+    clientDetails: {
+      identifier: void 0,
+      sector: void 0,
+      email: void 0,
+      cups: void 0,
+      phoneNumber: void 0,
+      address: void 0,
+      instalationLocation: void 0,
+      region: void 0,
+      subregion: void 0,
+      addressCode: void 0,
+      dniOrCif: void 0,
+      includeTaxes: false,
+      taxesPercentage: 0
+    },
+    location: void 0,
+    atrTariff: void 0,
+    geographicalZone: void 0,
+    energyPrices: { units: "\u20AC/kWh" },
+    contractedPower: {},
+    powerPrices: { units: "\u20AC/kW \xB7 dia" },
+    results: void 0,
+    consumptionIntroductionMode: "periods",
+    peakPowerIntroductionMode: "solarKit",
+    instalationPhaseNumber: "single_phase",
+    peakPowerOptimizationMethod: {
+      maxNumberOfOverproductionMonths: 3
+    },
+    useAlternativePrices: false,
+    economicResults: {
+      guaranteeProductionPercentage: 85,
+      inflation: 3,
+      instalationLifeTime: 25,
+      commercialFeePercentage: 85,
+      instalationFinancingPercentage: 0,
+      taxesPercentage: 21,
+      includeTaxes: false,
+      margen: 0
+    },
+    creationTimestamp: dateStr,
+    solarStudyProgress: {
+      stepsProgress: {
+        clientDetails: void 0,
+        consumption: void 0,
+        economicBalance: void 0,
+        production: void 0,
+        results: void 0,
+        surfacesSelector: void 0
+      },
+      stepsUpdates: {
+        clientDetails: false,
+        consumption: false,
+        economicBalance: false,
+        production: false,
+        results: false,
+        surfacesSelector: false
+      },
+      editingSolarStudy: false,
+      lastStateUpdateMomentMS: now.getTime()
+    },
+    activeBatteries: false,
+    batteriesConfiguration: {
+      initialCapacityPercentage: 100,
+      maxCapacityPercentage: 100,
+      minCapacityPercentage: 0
+    },
+    layout: "v2",
+    lastStateUpdateMomentMS: now.getTime(),
+    name: name || `Estudio Solar ${dateStr}`,
+    notes: void 0,
+    market: "es"
+  };
+}
+function checkByPeriodCompletion(periodNumber, element) {
+  if (!element) return false;
+  let assigned = 0;
+  for (let i = 1; i <= 6; i++) {
+    const val = element["p" + i];
+    if (val !== void 0 && val !== null && !isNaN(val)) {
+      assigned++;
+    }
+  }
+  return assigned >= periodNumber;
+}
+function evaluateSteps(study) {
+  const missing = {};
+  const atrTariff = study.atrTariff;
+  const energyPrices = study.energyPrices;
+  const geographicalZone = study.geographicalZone;
+  const market = study.market;
+  const extraCostPrice = study.extraCostPrice;
+  let clientDetailsComplete = true;
+  if (!atrTariff) {
+    clientDetailsComplete = false;
+    missing.clientDetails = "Needs atrTariff (use: studies set tariff)";
+  } else if (!checkByPeriodCompletion(atrTariff.periods || 3, energyPrices)) {
+    clientDetailsComplete = false;
+    missing.clientDetails = `Needs energyPrices with ${atrTariff.periods || 3} periods filled (use: studies set prices)`;
+  } else if (!geographicalZone) {
+    clientDetailsComplete = false;
+    missing.clientDetails = "Needs geographicalZone (use: studies set tariff --zone-id N)";
+  } else if (market === "pt" && !checkByPeriodCompletion(1, extraCostPrice)) {
+    clientDetailsComplete = false;
+    missing.clientDetails = "PT market needs extraCostPrice with 1 period (use: studies set prices --extra-cost-p1 N)";
+  }
+  const consumption = study.consumption;
+  const consumptionComplete = !!consumption?.days?.length;
+  if (!consumptionComplete) {
+    missing.consumption = "Needs consumption curve (use: studies set consumption)";
+  }
+  const surfaces = study.surfaces;
+  const surfacesComplete = !!surfaces?.length;
+  if (!surfacesComplete) {
+    missing.surfacesSelector = "Needs at least one surface (use: studies add surface)";
+  }
+  const solarPanel = study.solarPanel;
+  const solarKit = study.solarKit;
+  const hasEquipment = !!solarPanel || !!solarKit;
+  let hasProductionCurve = false;
+  if (surfaces && surfaces.length > 0) {
+    for (const s of surfaces) {
+      const surf = s;
+      if (surf.production?.days?.length) {
+        hasProductionCurve = true;
+        break;
+      }
+    }
+  }
+  const productionComplete = hasProductionCurve && hasEquipment;
+  if (!productionComplete) {
+    const reasons = [];
+    if (!hasEquipment) reasons.push("no panel or kit selected (use: studies set panel or studies set kit)");
+    if (!hasProductionCurve) reasons.push("no surface has a production curve (use: studies calculate production)");
+    missing.production = reasons.join("; ");
+  }
+  const results = study.results;
+  const resultsComplete = results !== void 0;
+  if (!resultsComplete) {
+    missing.results = "Results not calculated (use: studies calculate results)";
+  }
+  const economicResults = study.economicResults;
+  const economicBalanceComplete = economicResults?.margen !== void 0 && economicResults?.totalCost !== void 0 && results !== void 0;
+  if (!economicBalanceComplete) {
+    const reasons = [];
+    if (economicResults?.margen === void 0) reasons.push("margen");
+    if (economicResults?.totalCost === void 0) reasons.push("totalCost");
+    if (!results) reasons.push("results");
+    missing.economicBalance = `Needs: ${reasons.join(", ")} (use: studies set economics)`;
+  }
+  return {
+    stepsProgress: {
+      clientDetails: clientDetailsComplete,
+      consumption: consumptionComplete,
+      surfacesSelector: surfacesComplete,
+      production: productionComplete,
+      results: resultsComplete,
+      economicBalance: economicBalanceComplete
+    },
+    missing
+  };
+}
+function calculateCompletionPercentage(stepsProgress) {
+  const completed = Object.values(stepsProgress).filter(Boolean).length;
+  return Math.round(completed / 6 * 100);
+}
+var CASCADE_RESETS = {
+  consumption: ["production", "results", "economicBalance"],
+  surfaces: ["production", "results", "economicBalance"]
+};
+function applyCascadeResets(study, changedField) {
+  const resetSteps = CASCADE_RESETS[changedField];
+  if (!resetSteps) return [];
+  const progress = study.solarStudyProgress;
+  const resets = [];
+  for (const step of resetSteps) {
+    if (progress.stepsProgress[step] !== void 0) {
+      progress.stepsProgress[step] = void 0;
+      resets.push(step);
+    }
+  }
+  if (changedField === "consumption") {
+    study.results = void 0;
+  }
+  if (changedField === "surfaces") {
+    study.results = void 0;
+  }
+  return resets;
+}
+function readStudy(filePath) {
+  if (!existsSync2(filePath)) {
+    throw new Error(`Study file not found: ${filePath}. Use 'studies init --file ${filePath}' to create one.`);
+  }
+  return JSON.parse(readFileSync2(filePath, "utf-8"));
+}
+function writeStudy(filePath, study) {
+  writeFileSync3(filePath, JSON.stringify(study, null, 2), "utf-8");
+}
+function updateStudy(filePath, updater) {
+  const study = readStudy(filePath);
+  const cascadeField = updater(study);
+  let cascadeResets = [];
+  if (cascadeField) {
+    cascadeResets = applyCascadeResets(study, cascadeField);
+  }
+  const { stepsProgress, missing } = evaluateSteps(study);
+  const progress = study.solarStudyProgress;
+  progress.stepsProgress = stepsProgress;
+  progress.lastStateUpdateMomentMS = Date.now();
+  study.lastStateUpdateMomentMS = Date.now();
+  writeStudy(filePath, study);
+  return {
+    stepsProgress,
+    completionPercentage: calculateCompletionPercentage(stepsProgress),
+    missing,
+    cascadeResets
+  };
+}
+function deepMerge(target, source) {
+  for (const key of Object.keys(source)) {
+    const sv = source[key];
+    const tv = target[key];
+    if (sv && typeof sv === "object" && !Array.isArray(sv) && tv && typeof tv === "object" && !Array.isArray(tv)) {
+      deepMerge(tv, sv);
+    } else {
+      target[key] = sv;
+    }
+  }
+}
+function getGlobalOpts6(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function resolveFile(opts) {
+  return opts.file || process.env.SUNTROPY_STUDY || "./study.json";
+}
+function registerStudyBuilderCommands(studies) {
+  studies.command("init").description(
+    'Create a new study workspace (local JSON file with defaults).\nExample: suntropy studies init --file /tmp/study.json --name "Residencial 5kW"'
+  ).option("--file <path>", "Output file path (default: ./study.json)").option("--name <studyName>", "Study name").option("--market <code>", "Market country: es, pt, it, fr, de, etc.", "es").action(async (opts) => {
+    try {
+      const filePath = resolveFile(opts);
+      const study = createDefaultStudy(opts.name);
+      if (opts.market) study.market = opts.market;
+      writeStudy(filePath, study);
+      const { stepsProgress, missing } = evaluateSteps(study);
+      output({
+        file: filePath,
+        id: study.id,
+        name: study.name,
+        stepsProgress,
+        completionPercentage: 0,
+        missing
+      }, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  studies.command("validate").description(
+    "Check completion status of all study steps.\nReturns stepsProgress, completionPercentage, and what is missing for each incomplete step."
+  ).option("--file <path>", "Study file path").action(async (opts) => {
+    try {
+      const study = readStudy(resolveFile(opts));
+      const { stepsProgress, missing } = evaluateSteps(study);
+      output({
+        name: study.name,
+        stepsProgress,
+        completionPercentage: calculateCompletionPercentage(stepsProgress),
+        missing
+      }, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  studies.command("save").description(
+    "Save study to the backend (POST /solar-study).\nIf the study has _id, it updates the existing study. Otherwise creates new.\nExample: suntropy studies save --file /tmp/study.json --state-id 1"
+  ).option("--file <path>", "Study file path").option("--state-id <n>", "Solar study metadata state ID").option("--credit-amount <n>", "Credit amount to consume").option("--save-as-new", "Force save as new study (even if _id exists)").action(async (opts) => {
+    try {
+      const filePath = resolveFile(opts);
+      const global = getGlobalOpts6(studies);
+      const study = readStudy(filePath);
+      const { stepsProgress } = evaluateSteps(study);
+      const progress = study.solarStudyProgress;
+      progress.stepsProgress = stepsProgress;
+      progress.lastStateUpdateMomentMS = Date.now();
+      const isEditing = progress.editingSolarStudy || !!study._id;
+      const comments = study.comments || [];
+      const commentType = opts.saveAsNew ? "duplicated" : isEditing ? "modified" : "created";
+      comments.push(createComment(commentType));
+      study.comments = comments;
+      if (opts.saveAsNew) {
+        delete study._id;
+      }
+      const client = createServiceClient("solar", global);
+      const params = {};
+      if (opts.stateId) params.idSolarStudyState = opts.stateId;
+      if (opts.creditAmount) params.creditAmount = opts.creditAmount;
+      if (opts.saveAsNew) params.saveAsNew = "true";
+      const queryString = Object.entries(params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+      const url = `/solar-study${queryString ? "?" + queryString : ""}`;
+      const res = await client.post(url, study);
+      const responseData = res.data;
+      if (responseData?.solarStudyId) {
+        study._id = responseData.solarStudyId;
+        progress.editingSolarStudy = true;
+        writeStudy(filePath, study);
+      }
+      output({
+        saved: true,
+        metadata: responseData,
+        file: filePath,
+        completionPercentage: calculateCompletionPercentage(stepsProgress)
+      }, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  studies.command("pull <studyId>").description(
+    "Download an existing study from the backend into a local file.\nExample: suntropy studies pull abc123 --file /tmp/study.json"
+  ).option("--file <path>", "Output file path").action(async (studyId, opts) => {
+    try {
+      const filePath = resolveFile(opts);
+      const global = getGlobalOpts6(studies);
+      const client = createServiceClient("solar", global);
+      const res = await client.get(`/solar-study/findById/${studyId}`);
+      const study = res.data;
+      const { stepsProgress, missing } = evaluateSteps(study);
+      const progress = study.solarStudyProgress || {};
+      progress.stepsProgress = stepsProgress;
+      progress.editingSolarStudy = true;
+      study.solarStudyProgress = progress;
+      writeStudy(filePath, study);
+      output({
+        file: filePath,
+        _id: study._id,
+        name: study.name,
+        stepsProgress,
+        completionPercentage: calculateCompletionPercentage(stepsProgress),
+        missing
+      }, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  const set = studies.command("set").description("Set study properties. Each sub-command auto-validates after changes.");
+  set.command("name").description("Set the study name").option("--file <path>", "Study file path").requiredOption("--name <studyName>", "Study name").action(async (opts) => {
+    try {
+      const result = updateStudy(resolveFile(opts), (study) => {
+        study.name = opts.name;
+        return void 0;
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  set.command("market").description("Set the market country code (es, pt, it, fr, de, etc.)").option("--file <path>", "Study file path").requiredOption("--market <code>", "Market country code").action(async (opts) => {
+    try {
+      const result = updateStudy(resolveFile(opts), (study) => {
+        study.market = opts.market;
+        return void 0;
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  set.command("client").description(
+    'Set client details (name, email, phone, cups, address, etc.)\nExample: suntropy studies set client --file study.json --name "Juan Garc\xEDa" --email j@co.com --cups ES001234'
+  ).option("--file <path>", "Study file path").option("--name <clientName>", "Client name (identifier/raz\xF3n social)").option("--email <email>", "Client email").option("--phone <phone>", "Phone number").option("--cups <cups>", "CUPS code").option("--address <addr>", "Address").option("--city <city>", "City").option("--region <region>", "Region (comunidad aut\xF3noma)").option("--subregion <subregion>", "Subregion (provincia)").option("--dni <dni>", "DNI or CIF").option("--sector <sector>", "Client sector").option("--installation-location <loc>", "Installation location description").action(async (opts) => {
+    try {
+      const result = updateStudy(resolveFile(opts), (study) => {
+        const cd = study.clientDetails || {};
+        if (opts.name) cd.identifier = opts.name;
+        if (opts.email) cd.email = opts.email;
+        if (opts.phone) cd.phoneNumber = opts.phone;
+        if (opts.cups) cd.cups = opts.cups;
+        if (opts.address) cd.address = opts.address;
+        if (opts.city) cd.city = opts.city;
+        if (opts.region) cd.region = opts.region;
+        if (opts.subregion) cd.subregion = opts.subregion;
+        if (opts.dni) cd.dniOrCif = opts.dni;
+        if (opts.sector) cd.sector = opts.sector;
+        if (opts.installationLocation) cd.instalationLocation = opts.installationLocation;
+        study.clientDetails = cd;
+        return void 0;
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  set.command("tariff").description(
+    "Set ATR tariff and geographical zone. Auto-sets phase (>3 periods \u2192 three_phase).\nCommon tariff IDs (Spain): 13=2.0TD (3 periods), 14=3.0TD (6 periods)\nZone IDs (Spain): 1=Peninsula, 2=Canarias, 3=Baleares\nExample: suntropy studies set tariff --file study.json --tariff-id 13 --zone-id 1"
+  ).option("--file <path>", "Study file path").requiredOption("--tariff-id <n>", "ATR tariff ID").option("--zone-id <n>", "Geographical zone ID", "1").option("--market <code>", "Market code for tariff lookup", "es").action(async (opts) => {
+    try {
+      const global = getGlobalOpts6(studies);
+      const client = createServiceClient("periods", global);
+      const tariffRes = await client.get("/tarifas-atr", {
+        params: { market: opts.market }
+      });
+      const tariffs = Array.isArray(tariffRes.data) ? tariffRes.data : tariffRes.data?.data || [];
+      const tariffId = parseInt(opts.tariffId);
+      const tariff = tariffs.find((t) => t.idTarifaATR === tariffId);
+      if (!tariff) {
+        outputError(new Error(`Tariff ID ${tariffId} not found. Available: ${tariffs.map((t) => `${t.idTarifaATR}=${t.nombre}`).join(", ")}`));
+        return;
+      }
+      const zoneRes = await client.get("/zonas", {
+        params: { market: opts.market }
+      });
+      const zones = Array.isArray(zoneRes.data) ? zoneRes.data : zoneRes.data?.data || [];
+      const zoneId = parseInt(opts.zoneId);
+      const zone = zones.find((z) => z.idZona === zoneId);
+      const result = updateStudy(resolveFile(opts), (study) => {
+        study.atrTariff = tariff;
+        if (zone) study.geographicalZone = zone;
+        const periods = tariff.periods || 3;
+        study.instalationPhaseNumber = periods > 3 ? "three_phase" : "single_phase";
+        return void 0;
+      });
+      output(result, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  set.command("prices").description(
+    `Set energy prices by period.
+Examples:
+  suntropy studies set prices --file study.json --energy '{"p1":0.15,"p2":0.08,"p3":0.06}'
+  suntropy studies set prices --file study.json --energy-p1 0.15 --energy-p2 0.08 --energy-p3 0.06
+  suntropy studies set prices --file study.json --energy '{"p1":0.15,...}' --power '{"p1":40,...}' --contracted '{"p1":5.5,...}'`
+  ).option("--file <path>", "Study file path").option("--energy <json>", 'Energy prices JSON: {"p1":N,"p2":N,...}').option("--energy-p1 <n>", "Energy price period 1 (\u20AC/kWh)").option("--energy-p2 <n>", "Energy price period 2 (\u20AC/kWh)").option("--energy-p3 <n>", "Energy price period 3 (\u20AC/kWh)").option("--energy-p4 <n>", "Energy price period 4 (\u20AC/kWh)").option("--energy-p5 <n>", "Energy price period 5 (\u20AC/kWh)").option("--energy-p6 <n>", "Energy price period 6 (\u20AC/kWh)").option("--power <json>", 'Power prices JSON: {"p1":N,"p2":N,...} (\u20AC/kW\xB7day)').option("--contracted <json>", 'Contracted power JSON: {"p1":N,"p2":N,...} (kW)').option("--extra-cost-p1 <n>", "Extra cost price P1 (Portugal market)").action(async (opts) => {
+    try {
+      const result = updateStudy(resolveFile(opts), (study) => {
+        const ep = study.energyPrices || { units: "\u20AC/kWh" };
+        if (opts.energy) {
+          const parsed = JSON.parse(opts.energy);
+          Object.assign(ep, parsed);
+        }
+        for (let i = 1; i <= 6; i++) {
+          const val = opts[`energyP${i}`];
+          if (val !== void 0) ep[`p${i}`] = parseFloat(val);
+        }
+        study.energyPrices = ep;
+        if (opts.power) {
+          const pp = study.powerPrices || { units: "\u20AC/kW \xB7 dia" };
+          Object.assign(pp, JSON.parse(opts.power));
+          study.powerPrices = pp;
+        }
+        if (opts.contracted) {
+          const cp = study.contractedPower || {};
+          Object.assign(cp, JSON.parse(opts.contracted));
+          study.contractedPower = cp;
+        }
+        if (opts.extraCostP1 !== void 0) {
+          study.extraCostPrice = { p1: parseFloat(opts.extraCostP1), units: "\u20AC/kWh" };
+        }
+        return void 0;
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  set.command("consumption").description(
+    `Set the consumption curve.
+Modes:
+  --from-file <path>     Load PowerCurve from JSON file
+  --annual + --pattern   Generate via consumption-estimation API
+  --by-period <json>     Period consumption: {"p1":N,"p2":N,"p3":N} + REE profile
+  --monthly <json>       Monthly consumption: {"1":N,"2":N,...,"12":N} + REE profile
+  --monthly-by-period    Monthly by period: {"1":{"p1":N,"p2":N},...} + REE profile
+
+Examples:
+  suntropy studies set consumption --file study.json --from-file /tmp/cons.json
+  suntropy studies set consumption --file study.json --annual 4000 --pattern Balance
+  suntropy studies set consumption --file study.json --by-period '{"p1":2500,"p2":1000,"p3":500}'
+  suntropy studies set consumption --file study.json --monthly '{"1":350,"2":320,...}'`
+  ).option("--file <path>", "Study file path").option("--from-file <curvePath>", "Load PowerCurve from JSON file").option("--annual <kWh>", "Annual consumption in kWh").option("--pattern <name>", "Pattern: Balance, Nightly, Morning, Afternoon, Domestic, Commercial").option("--by-period <json>", 'Period consumption JSON: {"p1":N,"p2":N,...}').option("--monthly <json>", 'Monthly consumption JSON: {"1":N,...,"12":N}').option("--monthly-by-period <json>", 'Monthly by period: {"1":{"p1":N,...},...}').option("--tariff <code>", "Tariff code for profile lookup (default: from study)").option("--market <code>", "Market code (default: from study)").action(async (opts) => {
+    try {
+      const global = getGlobalOpts6(studies);
+      const filePath = resolveFile(opts);
+      const study = readStudy(filePath);
+      const studyTariff = study.atrTariff?.nombre || "3.0TD";
+      const studyMarket = study.market || "es";
+      const tariff = opts.tariff || studyTariff;
+      const market = opts.market || studyMarket;
+      const year = (/* @__PURE__ */ new Date()).getFullYear();
+      let curveData;
+      let introductionMode;
+      if (opts.fromFile) {
+        curveData = JSON.parse(readFileSync2(opts.fromFile, "utf-8"));
+        introductionMode = "upload";
+      } else if (opts.annual && opts.pattern) {
+        const profilesClient = createServiceClient("profiles", global);
+        const params = {
+          startDate: `${year}-01-01`,
+          endDate: `${year}-12-31`,
+          tariff,
+          type: "Final",
+          anualConsumption: opts.annual,
+          market,
+          consumptionType: opts.pattern
+        };
+        const queryString = Object.entries(params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+        const res = await profilesClient.post(`/consumption-estimation?${queryString}`, {});
+        curveData = res.data;
+        introductionMode = "consumption_patterns";
+      } else if (opts.byPeriod) {
+        const periodValues = JSON.parse(opts.byPeriod);
+        curveData = await generateFromProfile(global, tariff, market, year, "CONSUMPTION_BY_PERIOD", periodValues);
+        introductionMode = "periods";
+      } else if (opts.monthly) {
+        const monthValues = JSON.parse(opts.monthly);
+        curveData = await generateFromProfile(global, tariff, market, year, "MONTH_CONSUMPTION", monthValues);
+        introductionMode = "monthly_consumption";
+      } else if (opts.monthlyByPeriod) {
+        const monthPeriodValues = JSON.parse(opts.monthlyByPeriod);
+        curveData = await generateFromProfile(global, tariff, market, year, "MONTHLY_BY_PERIOD", monthPeriodValues);
+        introductionMode = "monthly_periods";
+      } else {
+        outputError(new Error("Specify one of: --from-file, --annual + --pattern, --by-period, --monthly, --monthly-by-period"));
+        return;
+      }
+      const result = updateStudy(filePath, (s) => {
+        s.consumption = curveData;
+        s.consumptionIntroductionMode = introductionMode;
+        if (opts.annual) s.monthlyConsumption = parseFloat(opts.annual) / 12;
+        if (opts.pattern) s.selectedConsumptionPattern = opts.pattern;
+        if (opts.byPeriod) s.periodConsumptionDictionary = JSON.parse(opts.byPeriod);
+        if (opts.monthly) s.monthConsumptionDictionary = JSON.parse(opts.monthly);
+        if (opts.monthlyByPeriod) s.monthPeriodConsumptionDictionary = JSON.parse(opts.monthlyByPeriod);
+        return "consumption";
+      });
+      output(result, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  studies.command("add").description("Add elements to the study").command("surface").description(
+    "Add a solar surface to the study.\nExample: suntropy studies add surface --file study.json --lat 37.39 --lon -5.99 --angle 30 --azimuth 180 --power 5000"
+  ).option("--file <path>", "Study file path").requiredOption("--lat <n>", "Latitude").requiredOption("--lon <n>", "Longitude").option("--angle <n>", "Panel inclination degrees", "30").option("--azimuth <n>", "Panel azimuth degrees (0=N, 180=S)", "180").option("--power <w>", "Installed power in Watts").option("--panels-count <n>", "Number of panels").option("--production <file>", "Production PowerCurve JSON file to attach").option("--identifier <name>", "Surface name/identifier").action(async (opts) => {
+    try {
+      const result = updateStudy(resolveFile(opts), (study) => {
+        const lat = parseFloat(opts.lat);
+        const lng = parseFloat(opts.lon);
+        const surface = {
+          surfaceId: v4_default(),
+          name: opts.identifier || `Surface ${(study.surfaces?.length || 0) + 1}`,
+          inclination: parseFloat(opts.angle),
+          orientation: parseFloat(opts.azimuth),
+          panelInclination: parseFloat(opts.angle),
+          panelOrientation: parseFloat(opts.azimuth),
+          lossesPercentage: 14,
+          // polygonPath required by backend metadata constructor
+          polygonPath: [{ lat, lng }]
+        };
+        if (opts.power) surface.installedPower = parseFloat(opts.power);
+        if (opts.panelsCount) surface.panelNumber = parseInt(opts.panelsCount);
+        if (opts.production) {
+          surface.production = JSON.parse(readFileSync2(opts.production, "utf-8"));
+        }
+        study.location = { lat: parseFloat(opts.lat), lng: parseFloat(opts.lon) };
+        study.mapCenter = { lat: parseFloat(opts.lat), lng: parseFloat(opts.lon) };
+        const surfaces = study.surfaces || [];
+        surfaces.push(surface);
+        study.surfaces = surfaces;
+        return "surfaces";
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  studies.command("remove").description("Remove elements from the study").command("surface").description("Remove a surface by index").option("--file <path>", "Study file path").requiredOption("--index <n>", "Surface index (0-based)").action(async (opts) => {
+    try {
+      const result = updateStudy(resolveFile(opts), (study) => {
+        const surfaces = study.surfaces || [];
+        const idx = parseInt(opts.index);
+        if (idx < 0 || idx >= surfaces.length) {
+          throw new Error(`Surface index ${idx} out of range (0-${surfaces.length - 1})`);
+        }
+        surfaces.splice(idx, 1);
+        study.surfaces = surfaces.length > 0 ? surfaces : void 0;
+        return "surfaces";
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  set.command("panel").description(
+    'Set solar panel for the study. Auto-sets peakPowerIntroductionMode to "solarPanel".\nFetches full panel data from inventory.\nExample: suntropy studies set panel --file study.json --panel-id 456 --panels-count 12'
+  ).option("--file <path>", "Study file path").requiredOption("--panel-id <n>", "Solar panel ID from inventory").option("--panels-count <n>", "Number of panels").action(async (opts) => {
+    try {
+      const global = getGlobalOpts6(studies);
+      const solarClient = createServiceClient("solar", global);
+      const panelRes = await solarClient.get(`/solar-panels/${opts.panelId}`);
+      const panel = panelRes.data;
+      const result = updateStudy(resolveFile(opts), (study) => {
+        study.solarPanel = panel;
+        study.peakPowerIntroductionMode = "solarPanel";
+        study.solarKit = void 0;
+        if (opts.panelsCount) {
+          const surfaces = study.surfaces;
+          if (surfaces?.length) {
+            surfaces[0].panelNumber = parseInt(opts.panelsCount);
+          }
+        }
+        return void 0;
+      });
+      output(result, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  set.command("kit").description(
+    'Set solar kit for the study. Auto-sets peakPowerIntroductionMode to "solarKit".\nFetches full kit data from inventory.\nExample: suntropy studies set kit --file study.json --kit-id 123'
+  ).option("--file <path>", "Study file path").requiredOption("--kit-id <n>", "Solar kit ID from inventory").action(async (opts) => {
+    try {
+      const global = getGlobalOpts6(studies);
+      const solarClient = createServiceClient("solar", global);
+      const kitsRes = await solarClient.get("/solar-kits", { params: { unactive: true } });
+      const allKits = Array.isArray(kitsRes.data) && Array.isArray(kitsRes.data[0]) ? kitsRes.data[0] : Array.isArray(kitsRes.data) ? kitsRes.data : kitsRes.data?.data || [];
+      const kitId = parseInt(opts.kitId);
+      const kit = allKits.find((k) => k.idSolarKit === kitId);
+      if (!kit) {
+        outputError(new Error(`Kit ${kitId} not found`));
+        return;
+      }
+      const result = updateStudy(resolveFile(opts), (study) => {
+        study.solarKit = kit;
+        study.peakPowerIntroductionMode = "solarKit";
+        study.solarPanel = void 0;
+        study.solarInverters = void 0;
+        return void 0;
+      });
+      output(result, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  set.command("inverter").description(
+    "Set inverter(s) for the study (when using solarPanel mode).\nExample: suntropy studies set inverter --file study.json --inverter-id 789"
+  ).option("--file <path>", "Study file path").requiredOption("--inverter-id <ids>", "Inverter ID(s), comma-separated for multiple").action(async (opts) => {
+    try {
+      const global = getGlobalOpts6(studies);
+      const solarClient = createServiceClient("solar", global);
+      const ids = opts.inverterId.split(",").map((s) => parseInt(s.trim()));
+      const inverters = [];
+      for (const id of ids) {
+        const res = await solarClient.get(`/solar-inverter/${id}`);
+        inverters.push(res.data);
+      }
+      const result = updateStudy(resolveFile(opts), (study) => {
+        study.solarInverters = inverters;
+        return void 0;
+      });
+      output(result, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  set.command("phase").description("Manually set installation phase (overrides auto-set from tariff)").option("--file <path>", "Study file path").requiredOption("--phase <type>", "Phase: single_phase or three_phase").action(async (opts) => {
+    try {
+      if (!["single_phase", "three_phase"].includes(opts.phase)) {
+        outputError(new Error("Phase must be single_phase or three_phase"));
+        return;
+      }
+      const result = updateStudy(resolveFile(opts), (study) => {
+        study.instalationPhaseNumber = opts.phase;
+        return void 0;
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  set.command("economics").description(
+    "Set economic parameters for the study.\nExample: suntropy studies set economics --file study.json --margin 15 --total-cost 6500 --lifetime 25"
+  ).option("--file <path>", "Study file path").option("--margin <n>", "Margin percentage").option("--total-cost <n>", "Total installation cost (\u20AC)").option("--lifetime <n>", "Installation lifetime in years").option("--inflation <n>", "Inflation rate percentage").option("--taxes-pct <n>", "Tax percentage").option("--include-taxes", "Include taxes in pricing").option("--commercial-fee <n>", "Commercial fee percentage").option("--excesses-mode <mode>", "Excesses compensation: gridSelling, PPA, noInjection, virtualBattery").option("--excesses-buy-price <n>", "Excesses buy price (\u20AC/MWh)").option("--excesses-selling-price <n>", "Excesses selling price (\u20AC/MWh)").option("--peak-power-cost <n>", "Cost per kWp (\u20AC/kWp)").option("--guarantee-production <n>", "Guarantee production percentage").action(async (opts) => {
+    try {
+      const result = updateStudy(resolveFile(opts), (study) => {
+        const er = study.economicResults || {};
+        if (opts.margin !== void 0) er.margen = parseFloat(opts.margin);
+        if (opts.totalCost !== void 0) er.totalCost = parseFloat(opts.totalCost);
+        if (opts.lifetime !== void 0) er.instalationLifeTime = parseInt(opts.lifetime);
+        if (opts.inflation !== void 0) er.inflation = parseFloat(opts.inflation);
+        if (opts.taxesPct !== void 0) er.taxesPercentage = parseFloat(opts.taxesPct);
+        if (opts.includeTaxes) er.includeTaxes = true;
+        if (opts.commercialFee !== void 0) er.commercialFeePercentage = parseFloat(opts.commercialFee);
+        if (opts.excessesMode) er.excessesCompensationMode = opts.excessesMode;
+        if (opts.excessesBuyPrice !== void 0) er.excessesBuyPrice = parseFloat(opts.excessesBuyPrice);
+        if (opts.excessesSellingPrice !== void 0) er.excessesSellingPrice = parseFloat(opts.excessesSellingPrice);
+        if (opts.peakPowerCost !== void 0) er.peakPowerCost = parseFloat(opts.peakPowerCost);
+        if (opts.guaranteeProduction !== void 0) er.guaranteeProductionPercentage = parseFloat(opts.guaranteeProduction);
+        study.economicResults = er;
+        return void 0;
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  set.command("custom-assets").description(
+    "Set selected custom assets for the study.\nExample: suntropy studies set custom-assets --file study.json --asset 100:12 --asset 200:1"
+  ).option("--file <path>", "Study file path").requiredOption("--asset <id:qty>", "Custom asset as id:quantity (repeatable)", collectAssets, []).action(async (opts) => {
+    try {
+      const global = getGlobalOpts6(studies);
+      const solarClient = createServiceClient("solar", global);
+      const assets = [];
+      for (const { id, quantity } of opts.asset) {
+        const res = await solarClient.get(`/custom-asset/id/${id}`);
+        assets.push({ customAsset: res.data, quantity });
+      }
+      const result = updateStudy(resolveFile(opts), (study) => {
+        study.selectedCustomAssets = assets;
+        return void 0;
+      });
+      output(result, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  set.command("batteries").description(
+    "Enable/disable batteries and set configuration.\nExample: suntropy studies set batteries --file study.json --enable --battery-id 789 --count 1"
+  ).option("--file <path>", "Study file path").option("--enable", "Enable batteries").option("--disable", "Disable batteries").option("--battery-id <n>", "Battery ID from inventory").option("--count <n>", "Number of batteries").action(async (opts) => {
+    try {
+      const result = updateStudy(resolveFile(opts), (study) => {
+        if (opts.enable) study.activeBatteries = true;
+        if (opts.disable) study.activeBatteries = false;
+        if (opts.batteryId) {
+          const config = study.batteriesConfiguration || {};
+          config.batteryId = parseInt(opts.batteryId);
+          if (opts.count) config.batteriesNumber = parseInt(opts.count);
+          study.batteriesConfiguration = config;
+        }
+        return void 0;
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  set.command("data").description(
+    `Generic JSON merge into the study (fallback for any field).
+Example: suntropy studies set data --file study.json --data '{"referenceId":"REF-001"}'`
+  ).option("--file <path>", "Study file path").requiredOption("--data <json>", "JSON to merge into the study").action(async (opts) => {
+    try {
+      const parsed = JSON.parse(opts.data);
+      const cascadeFields = Object.keys(parsed);
+      let cascadeField;
+      if (cascadeFields.includes("consumption")) cascadeField = "consumption";
+      if (cascadeFields.includes("surfaces")) cascadeField = "surfaces";
+      const result = updateStudy(resolveFile(opts), (study) => {
+        deepMerge(study, parsed);
+        return cascadeField;
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  studies.command("calculate").description("Calculate derived data for the study").command("production").description(
+    "Calculate production for study surfaces using backend API.\nExample: suntropy studies calculate production --file study.json [--surface-index 0 | --all-surfaces]"
+  ).option("--file <path>", "Study file path").option("--surface-index <n>", "Calculate for specific surface index").option("--all-surfaces", "Calculate for all surfaces").option("--losses <n>", "Losses percentage", "14").action(async (opts) => {
+    try {
+      const global = getGlobalOpts6(studies);
+      const filePath = resolveFile(opts);
+      const study = readStudy(filePath);
+      const surfaces = study.surfaces;
+      if (!surfaces?.length) {
+        outputError(new Error("No surfaces in study. Use: studies add surface"));
+        return;
+      }
+      const solarClient = createServiceClient("solar", global);
+      const indicesToCalc = opts.surfaceIndex !== void 0 ? [parseInt(opts.surfaceIndex)] : Array.from({ length: surfaces.length }, (_, i) => i);
+      for (const idx of indicesToCalc) {
+        const surface = surfaces[idx];
+        if (!surface) continue;
+        const center = surface.center;
+        const studyLocation = study.location;
+        const lat = center?.lat || studyLocation?.lat;
+        const lng = center?.lng || studyLocation?.lng;
+        if (!lat || !lng) {
+          outputError(new Error(`Surface ${idx} has no coordinates. Use: studies add surface --lat N --lon N`));
+          continue;
+        }
+        const body = {
+          lat,
+          long: lng,
+          instaledPower: surface.installedPower || 5e3,
+          angle: surface.inclination || surface.angle || 30,
+          azimuth: surface.orientation || surface.azimuth || 180,
+          lossesPercentage: parseFloat(opts.losses),
+          year: (/* @__PURE__ */ new Date()).getFullYear(),
+          isOptimized: false
+        };
+        const res = await solarClient.post("/solar-study/calculateProduction", body);
+        surface.production = res.data;
+      }
+      const result = updateStudy(filePath, (s) => {
+        s.surfaces = surfaces;
+        return void 0;
+      });
+      output(result, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  studies.command("calculate-results").description(
+    "Calculate energy results replicating frontend SolarResultCalculator.\nComputes: net consumption, excesses, spending/savings by period, coverage.\nRequires: consumption, production, energyPrices, atrTariff.\nExample: suntropy studies calculate-results --file study.json"
+  ).option("--file <path>", "Study file path").action(async (opts) => {
+    try {
+      const global = getGlobalOpts6(studies);
+      const filePath = resolveFile(opts);
+      const study = readStudy(filePath);
+      const consumption = study.consumption;
+      if (!consumption?.days?.length) {
+        outputError(new Error("No consumption curve. Use: studies set consumption"));
+        return;
+      }
+      const surfaces = study.surfaces;
+      if (!surfaces?.length) {
+        outputError(new Error("No surfaces. Use: studies add surface"));
+        return;
+      }
+      const energyPrices = study.energyPrices;
+      if (!energyPrices) {
+        outputError(new Error("No energy prices. Use: studies set prices"));
+        return;
+      }
+      const { PowerCurve } = await import("energy-types/lib/energy/classes/powerCurve.class");
+      const consCurve = new PowerCurve(consumption.days, false, consumption.identifier || "consumption", false);
+      let totalProdCurve = null;
+      for (const surf of surfaces) {
+        const prod = surf.production;
+        if (prod?.days?.length) {
+          const surfProd = new PowerCurve(prod.days, false, prod.identifier || "production", false);
+          totalProdCurve = totalProdCurve ? totalProdCurve.aggregatePowerCurve(surfProd) : surfProd;
+        }
+      }
+      if (!totalProdCurve) {
+        outputError(new Error("No production curves found. Use: studies calculate production"));
+        return;
+      }
+      const results = {};
+      const netConsumptionCurve = consCurve.aggregatePowerCurve(totalProdCurve.applyMultiplier(-1));
+      results.netConsumption = netConsumptionCurve;
+      results.totalProduction = totalProdCurve.getTotalAcumulate();
+      results.totalConsumptionCoverage = results.totalProduction / consCurve.getTotalAcumulate() * 100;
+      const periodDistribution = await fetchPeriodDistribution(study, global);
+      if (periodDistribution) {
+        const clientDetails = study.clientDetails;
+        const market = study.market;
+        const oneBaseEnergyDiscountFactor = 1 - (study.energyPricesDiscount || 0) / 100;
+        const oneBasePowerDiscountFactor = 1 - (study.powerPricesDiscount || 0) / 100;
+        const positiveNetConsumptionCurve = netConsumptionCurve.filterNegativeValues();
+        const positiveNetByPeriod = positiveNetConsumptionCurve.aggregateByPeriod(periodDistribution);
+        const rawConsumptionByPeriod = consCurve.aggregateByPeriod(periodDistribution);
+        const contractedPower = study.contractedPower || {};
+        const powerPrices = study.powerPrices || {};
+        const contractedPowerRawCostByPeriod = {};
+        if (study.useAlternativePrices) {
+          for (let i = 1; i <= 6; i++) {
+            const p = `p${i}`;
+            if (contractedPower[p] && powerPrices[p]) {
+              contractedPowerRawCostByPeriod[p] = contractedPower[p] * 365 * powerPrices[p] * oneBasePowerDiscountFactor;
+            }
+          }
+        }
+        if (market === "pt") {
+          const extraCostPrice = study.extraCostPrice || {};
+          let numberOfP1hours = 0;
+          periodDistribution.forEach((day) => {
+            Object.values(day.valuesList).forEach((hour) => {
+              if (hour === 1) numberOfP1hours++;
+            });
+          });
+          const coefficient = 1 / numberOfP1hours * (extraCostPrice.p1 || 0) * netConsumptionCurve.days.length;
+          results.rawPeakConsumptionCostPt = (rawConsumptionByPeriod?.p1 || 0) * coefficient;
+          results.netPeakConsumptionCostPt = (positiveNetByPeriod?.p1 || 0) * coefficient;
+        }
+        const totalRawSpendingByPeriod = {};
+        for (let i = 1; i <= 6; i++) {
+          const p = `p${i}`;
+          const rawConsP = rawConsumptionByPeriod?.[p] || 0;
+          const priceP = energyPrices[p] || 0;
+          const includeTaxes = clientDetails?.includeTaxes;
+          const taxPct = clientDetails?.taxesPercentage || 0;
+          const priceWithTax = includeTaxes && taxPct ? priceP * (1 + taxPct / 100) : priceP;
+          totalRawSpendingByPeriod[p] = rawConsP * priceWithTax * oneBaseEnergyDiscountFactor + (contractedPowerRawCostByPeriod[p] || 0);
+        }
+        results.totalRawSpendingByPeriod = totalRawSpendingByPeriod;
+        results.totalRawSpending = Object.values(totalRawSpendingByPeriod).filter((v) => typeof v === "number").reduce((a, b) => a + b, 0) + (results.rawPeakConsumptionCostPt || 0);
+        const alternativeEnergyPrices = study.alternativeEnergyPrices || {};
+        const alternativePowerPrices = study.alternativePowerPrices || {};
+        const contractedPowerFinalCostByPeriod = {};
+        const contractedPowerSavingsByPeriod = {};
+        if (study.useAlternativePrices) {
+          for (let i = 1; i <= 6; i++) {
+            const p = `p${i}`;
+            if (contractedPower[p] && alternativePowerPrices[p]) {
+              contractedPowerFinalCostByPeriod[p] = contractedPower[p] * 365 * alternativePowerPrices[p];
+            }
+            if (contractedPower[p] && powerPrices[p] && alternativePowerPrices[p]) {
+              contractedPowerSavingsByPeriod[p] = contractedPower[p] * 365 * powerPrices[p] * oneBasePowerDiscountFactor - contractedPower[p] * 365 * alternativePowerPrices[p] * oneBasePowerDiscountFactor;
+            }
+          }
+          results.contractedPowerSavingsByPeriod = contractedPowerSavingsByPeriod;
+        }
+        const totalNetSpendingByPeriod = {};
+        const alternativeTotalNetSpendingByPeriod = {};
+        for (let i = 1; i <= 6; i++) {
+          const p = `p${i}`;
+          const posNetP = positiveNetByPeriod?.[p] || 0;
+          const priceP = energyPrices[p] || 0;
+          const altPriceP = alternativeEnergyPrices[p] || 0;
+          const includeTaxes = clientDetails?.includeTaxes;
+          const taxPct = clientDetails?.taxesPercentage || 0;
+          totalNetSpendingByPeriod[p] = posNetP * (includeTaxes ? priceP * (1 + taxPct / 100) : priceP) * oneBaseEnergyDiscountFactor;
+          if (study.alternativeEnergyPrices) {
+            alternativeTotalNetSpendingByPeriod[p] = posNetP * altPriceP + (contractedPowerFinalCostByPeriod[p] || 0);
+          }
+        }
+        results.totalNetSpendingByPeriod = totalNetSpendingByPeriod;
+        if (study.alternativeEnergyPrices) {
+          results.alternativeTotalNetSpendingByPeriod = alternativeTotalNetSpendingByPeriod;
+        }
+        results.totalNetSpending = Object.values(totalNetSpendingByPeriod).filter((v) => typeof v === "number").reduce((a, b) => a + b, 0) + (results.netPeakConsumptionCostPt || 0);
+        const totalSavingsByPeriod = {};
+        for (let i = 1; i <= 6; i++) {
+          const p = `p${i}`;
+          totalSavingsByPeriod[p] = (totalRawSpendingByPeriod[p] || 0) - (totalNetSpendingByPeriod[p] || 0);
+        }
+        results.totalSavingsByPeriod = totalSavingsByPeriod;
+        if (study.alternativeEnergyPrices) {
+          const altSavings = {};
+          for (let i = 1; i <= 6; i++) {
+            const p = `p${i}`;
+            altSavings[p] = (totalRawSpendingByPeriod[p] || 0) - (alternativeTotalNetSpendingByPeriod[p] || 0);
+          }
+          results.totalSavingsByPeriodAlternativeSavings = altSavings;
+        }
+        results.totalSavings = Object.values(totalSavingsByPeriod).filter((v) => typeof v === "number").reduce((a, b) => a + b, 0) + ((results.rawPeakConsumptionCostPt || 0) - (results.netPeakConsumptionCostPt || 0));
+        if (study.alternativeEnergyPrices) {
+          results.totalSavingsAlternativePrices = Object.values(alternativeTotalNetSpendingByPeriod).filter((v) => typeof v === "number").reduce((a, b) => a + b, 0) + ((results.rawPeakConsumptionCostPt || 0) - (results.netPeakConsumptionCostPt || 0));
+        }
+        const excessesCurve = totalProdCurve.aggregatePowerCurve(consCurve.applyMultiplier(-1)).filterNegativeValues();
+        results.excessesCurve = excessesCurve;
+        results.totalExcessesByPeriod = excessesCurve.aggregateByPeriod(periodDistribution);
+        results.totalExcesses = Object.values(results.totalExcessesByPeriod).filter((v) => typeof v === "number").reduce((a, b) => a + b, 0);
+      }
+      const result = updateStudy(filePath, (s) => {
+        s.results = results;
+        return void 0;
+      });
+      output(result, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  studies.command("add-comment").description(
+    'Add a comment to the local study file.\nExample: suntropy studies add-comment --file study.json --content "Panel layout reviewed"'
+  ).option("--file <path>", "Study file path").requiredOption("--content <text>", "Comment text").action(async (opts) => {
+    try {
+      const result = updateStudy(resolveFile(opts), (study) => {
+        const comments = study.comments || [];
+        comments.push(createComment("commented", opts.content));
+        study.comments = comments;
+        return void 0;
+      });
+      output(result, getGlobalOpts6(studies));
+    } catch (err) {
+      outputError(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+  studies.command("comment <studyId>").description(
+    'Add a comment to an existing study via API.\nExample: suntropy studies comment abc123 --content "Revisado por agente"'
+  ).requiredOption("--content <text>", "Comment text").action(async (studyId, opts) => {
+    try {
+      const global = getGlobalOpts6(studies);
+      const client = createServiceClient("solar", global);
+      const comment = createComment("commented", opts.content);
+      const res = await client.post(`/solar-study/addSolarStudyComment/${studyId}`, comment);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+}
+async function generateFromProfile(global, tariff, market, year, mode, data) {
+  const profilesClient = createServiceClient("profiles", global);
+  const periodsClient = createServiceClient("periods", global);
+  const profileRes = await profilesClient.get("/ree-profiles", {
+    params: {
+      startDate: `${year}-01-01`,
+      endDate: `${year}-12-31`,
+      tariff,
+      type: "Final",
+      market
+    }
+  });
+  const profile = profileRes.data?.profile || profileRes.data;
+  if (!profile || !Array.isArray(profile) || profile.length === 0) {
+    throw new Error("Failed to fetch REE profiles");
+  }
+  const { applyProfileToConsumption, ConsumptionIntroductionModes } = await import("energy-types/lib/energy/calculations/applyProfileToConsumption");
+  if (mode === "CONSUMPTION_BY_PERIOD") {
+    const tariffIdMap = { "2.0TD": 13, "3.0TD": 14, "6.1TD": 15 };
+    const tariffId = tariffIdMap[tariff] || 14;
+    const periodsRes = await periodsClient.get("/periodos", {
+      params: {
+        idTarifa: tariffId,
+        idZona: 1,
+        fechaInicio: `${year}-01-01`,
+        fechaFin: `${year}-12-31`,
+        market
+      }
+    });
+    const periodDistribution = periodsRes.data;
+    const result = applyProfileToConsumption(
+      ConsumptionIntroductionModes.CONSUMPTION_BY_PERIOD,
+      profile,
+      data,
+      periodDistribution
+    );
+    return result;
+  } else if (mode === "MONTH_CONSUMPTION") {
+    const flatData = data;
+    const yearMonthData = { [year]: {} };
+    for (const [month, value] of Object.entries(flatData)) {
+      yearMonthData[year][parseInt(month)] = value;
+    }
+    const result = applyProfileToConsumption(
+      ConsumptionIntroductionModes.MONTH_CONSUMPTION,
+      profile,
+      yearMonthData
+    );
+    return result;
+  } else if (mode === "MONTHLY_BY_PERIOD") {
+    const monthlyData = data;
+    const monthTotals = {};
+    for (const [month, periods] of Object.entries(monthlyData)) {
+      monthTotals[month] = Object.values(periods).reduce((a, b) => a + b, 0);
+    }
+    const result = applyProfileToConsumption(
+      ConsumptionIntroductionModes.MONTH_CONSUMPTION,
+      profile,
+      monthTotals
+    );
+    return result;
+  }
+  throw new Error(`Unknown consumption mode: ${mode}`);
+}
+function collectAssets(value, previous) {
+  const [idStr, qtyStr] = value.split(":");
+  const id = parseInt(idStr);
+  const quantity = qtyStr ? parseInt(qtyStr) : 1;
+  if (isNaN(id)) throw new Error(`Invalid asset format: "${value}". Use <id>:<quantity>`);
+  return [...previous, { id, quantity }];
+}
+async function fetchPeriodDistribution(study, global) {
+  const atrTariff = study.atrTariff;
+  const geoZone = study.geographicalZone;
+  if (!atrTariff) return null;
+  const tariffId = atrTariff.idTarifaATR;
+  const zoneId = geoZone?.idZona || 1;
+  const market = study.market || "es";
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  try {
+    const periodsClient = createServiceClient("periods", global);
+    const res = await periodsClient.get("/periodos", {
+      params: {
+        idTarifa: tariffId,
+        idZona: zoneId,
+        fechaInicio: `${year}-01-01`,
+        fechaFin: `${year}-12-31`,
+        market
+      }
+    });
+    const data = res.data;
+    if (Array.isArray(data) && data.length > 0) return data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function createComment(type, content) {
+  const config = loadConfig();
+  const profile = getActiveProfile(config);
+  const autoContent = {
+    created: "Estudio creado via CLI",
+    modified: "Estudio actualizado via CLI"
+  };
+  return {
+    content: content || autoContent[type] || "",
+    type,
+    creationTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    creationUserUID: profile.userUID || "cli-agent"
+  };
+}
+
+// src/commands/studies/index.ts
+function getGlobalOpts7(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function compactCurves(obj) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(compactCurves);
+  const record = obj;
+  if (Array.isArray(record.days) && record.days.length > 0 && record.identifier !== void 0) {
+    return { _type: "PowerCurve", days: record.days.length, identifier: record.identifier };
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(record)) {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const v = val;
+      if (Array.isArray(v.days) && v.days.length > 0 && v.identifier !== void 0) {
+        result[key] = { _type: "PowerCurve", days: v.days.length, identifier: v.identifier };
+        continue;
+      }
+    }
+    result[key] = compactCurves(val);
+  }
+  return result;
+}
+var EXPAND_SECTIONS = {
+  surfaces: ["surfaces"],
+  results: ["results"],
+  economics: ["economicResults"],
+  batteries: ["activeBatteries", "batteriesConfiguration", "batteriesEnergyBalance", "batteriesResults", "bateries"],
+  consumption: ["consumption", "consumptionIntroductionMode", "monthConsumptionDictionary", "monthPeriodConsumptionDictionary", "periodConsumptionDictionary"],
+  equipment: ["solarPanel", "solarKit", "solarInverters", "selectedChargers", "selectedCustomAssets"],
+  client: ["clientDetails", "clientsDetails"],
+  location: ["location", "mapCenter", "geographicalZone", "atrTariff"]
+};
+var CORE_FIELDS = [
+  "_id",
+  "id",
+  "name",
+  "identifier",
+  "clientUID",
+  "creationTimestamp",
+  "lastEditTimestamp",
+  "assignedUserUID",
+  "creationUserUID",
+  "selectedSolarStudyMode",
+  "solarStudyProgress",
+  "market",
+  "layout",
+  "peakPowerIntroductionMode",
+  "instalationPhaseNumber"
+];
+function filterStudy(study, expand) {
+  if (expand === "all") return study;
+  const sections = expand ? expand.split(",").map((s) => s.trim()) : [];
+  const allowedFields = new Set(CORE_FIELDS);
+  for (const section of sections) {
+    const fields = EXPAND_SECTIONS[section];
+    if (fields) fields.forEach((f) => allowedFields.add(f));
+  }
+  if (sections.length === 0) {
+    ["peakPowerIntroductionMode", "instalationPhaseNumber", "location", "atrTariff"].forEach((f) => allowedFields.add(f));
+  }
+  const result = {};
+  for (const key of allowedFields) {
+    if (key in study) result[key] = study[key];
+  }
+  return compactCurves(result);
+}
+function registerStudiesCommands(program2) {
+  const studies = program2.command("studies").description(
+    "Explore and manage solar studies. Progressive exploration: list \u2192 metadata \u2192 get \u2192 get --expand \u2192 curves"
+  );
+  studies.command("list").description("List solar studies metadata. Fields: idSolarStudyMetadata, solarStudyId, clientName, peakPower, currentState, creationTimestamp").option("--limit <n>", "Max results", "20").option("--offset <n>", "Skip results", "0").option("--state <state>", "Filter by state name").option("--client-name <name>", "Filter by client name").option("--from <date>", "Filter from date (YYYY-MM-DD)").option("--to <date>", "Filter to date (YYYY-MM-DD)").action(async (opts) => {
+    try {
+      const global = getGlobalOpts7(studies);
+      const client = createServiceClient("solar", global);
+      const body = {
+        limit: parseInt(opts.limit),
+        offset: parseInt(opts.offset)
+      };
+      if (opts.state) body.state = opts.state;
+      if (opts.clientName) body.clientName = opts.clientName;
+      if (opts.from) body.fromDate = opts.from;
+      if (opts.to) body.toDate = opts.to;
+      const res = await client.post("/solar-study/findWithPaginationAndFilters", body);
+      let data;
+      let total;
+      if (Array.isArray(res.data) && res.data.length >= 2 && Array.isArray(res.data[0]) && typeof res.data[1] === "number") {
+        data = res.data[0];
+        total = res.data[1];
+      } else if (Array.isArray(res.data)) {
+        data = res.data;
+        total = res.data.length;
+      } else {
+        data = res.data?.data || res.data?.solarStudiesMetadata || [];
+        total = res.data?.total ?? res.data?.count ?? (Array.isArray(data) ? data.length : 0);
+      }
+      const outOpts = { ...global };
+      if (!global.fields) {
+        outOpts.fields = "idSolarStudyMetadata,solarStudyId,clientName,peakPower,anualProduction,anualConsumption,totalCost,sellingPrice,currentState,creationTimestamp";
+      }
+      outputPaginated(data, total, parseInt(opts.limit), parseInt(opts.offset), outOpts);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  studies.command("metadata <id>").description("Get solar study metadata by metadata ID (relational). Full MySQL record with state, costs, versions.").option("--by-study-id", "Interpret <id> as MongoDB solarStudyId instead of metadata ID").action(async (id, opts) => {
+    try {
+      const global = getGlobalOpts7(studies);
+      const client = createServiceClient("solar", global);
+      const path = opts.byStudyId ? `/solar-study/metadata/solar-study-id/${id}` : `/solar-study/findSolarStudyMetadataById/${id}`;
+      const res = await client.get(path);
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  studies.command("get <studyId>").description(
+    "Get solar study by MongoDB ID. By default returns summary (no heavy curves).\nExpand sections: surfaces, results, economics, batteries, consumption, equipment, client, location\nExamples:\n  suntropy studies get abc123\n  suntropy studies get abc123 --expand surfaces,results\n  suntropy studies get abc123 --expand all"
+  ).option("--expand <sections>", 'Comma-separated sections to expand (or "all")').action(async (studyId, opts) => {
+    try {
+      const global = getGlobalOpts7(studies);
+      const client = createServiceClient("solar", global);
+      const res = await client.get(`/solar-study/findById/${studyId}`);
+      const study = res.data;
+      const filtered = filterStudy(study, opts.expand);
+      output(filtered, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  studies.command("curves <studyId> <curveName>").description(
+    "Extract and analyze a PowerCurve from a study.\nCurve names: consumption, production, net-consumption, excesses\nDefault: --stats. Use --raw for full hourly data (8760 values).\nUse --monthly for monthly aggregates, --daily for daily totals."
+  ).option("--stats", "Show statistics (default if no other flag)").option("--monthly", "Monthly accumulated values").option("--daily", "Daily accumulated values").option("--raw", "Full hourly DayCurve[] data").option("--total", "Just the total accumulated value").option("--surface-index <n>", "Surface index for production curve", "0").option("--save <file>", "Save curve data to file").action(async (studyId, curveName, opts) => {
+    try {
+      const global = getGlobalOpts7(studies);
+      const client = createServiceClient("solar", global);
+      const res = await client.get(`/solar-study/findById/${studyId}`);
+      const study = res.data;
+      let curveData;
+      switch (curveName) {
+        case "consumption":
+          curveData = study.consumption;
+          break;
+        case "production": {
+          const surfaces = study.surfaces;
+          const idx = parseInt(opts.surfaceIndex);
+          if (surfaces && surfaces[idx]?.production) {
+            curveData = surfaces[idx].production;
+          } else {
+            outputError(new Error(`No production curve at surface index ${idx}. Study has ${surfaces?.length || 0} surfaces.`));
+            return;
+          }
+          break;
+        }
+        case "net-consumption":
+          curveData = study.results?.netConsumption;
+          break;
+        case "excesses":
+          curveData = study.results?.excessesCurve;
+          break;
+        default:
+          outputError(new Error(`Unknown curve: ${curveName}. Available: consumption, production, net-consumption, excesses`));
+          return;
+      }
+      if (!curveData) {
+        outputError(new Error(`Curve "${curveName}" not found or empty in this study.`));
+        return;
+      }
+      const { PowerCurve } = await import("energy-types/lib/energy/classes/powerCurve.class");
+      const cd = curveData;
+      const pc = new PowerCurve(cd.days || cd, cd.ignore0 ?? false, cd.identifier || curveName, cd.parseDate ?? false);
+      const showRaw = opts.raw;
+      const showMonthly = opts.monthly;
+      const showDaily = opts.daily;
+      const showTotal = opts.total;
+      const showStats = opts.stats || !showRaw && !showMonthly && !showDaily && !showTotal;
+      let result;
+      if (showRaw) {
+        result = pc.days;
+      } else if (showTotal) {
+        result = { total: pc.getTotalAcumulate(), identifier: curveName, days: pc.days.length };
+      } else if (showStats) {
+        const raw = pc.calculateStatistics();
+        result = raw.statistics || raw;
+      } else if (showMonthly) {
+        const raw = pc.calculateStatistics();
+        const s = raw.statistics || raw;
+        result = { anualMonthAccumulate: s.anualMonthAccumulate, anualMonthCount: s.anualMonthCount, anualMonthlyAverage: s.anualMonthlyAverage };
+      } else if (showDaily) {
+        const raw = pc.calculateStatistics();
+        const s = raw.statistics || raw;
+        result = { dailyAccumulate: s.dailyAccumulate };
+      }
+      const outOpts = { ...global, save: opts.save || global.save };
+      output(result, outOpts);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  studies.command("calculate-production").description("Calculate solar production curve for given coordinates and configuration").requiredOption("--lat <n>", "Latitude").requiredOption("--lon <n>", "Longitude").requiredOption("--power <w>", "Installed power in Watts").option("--angle <n>", "Panel inclination degrees", "30").option("--azimuth <n>", "Panel orientation degrees (0=north, 180=south)", "180").option("--losses <n>", "Losses percentage", "14").option("--year <n>", "Year for calculation", String((/* @__PURE__ */ new Date()).getFullYear())).option("--save <file>", "Save result to file").action(async (opts) => {
+    try {
+      const global = getGlobalOpts7(studies);
+      const client = createServiceClient("solar", global);
+      const body = {
+        lat: parseFloat(opts.lat),
+        long: parseFloat(opts.lon),
+        instaledPower: parseFloat(opts.power),
+        angle: parseFloat(opts.angle),
+        azimuth: parseFloat(opts.azimuth),
+        lossesPercentage: parseFloat(opts.losses),
+        year: parseInt(opts.year),
+        isOptimized: false
+      };
+      const res = await client.post("/solar-study/calculateProduction", body);
+      output(res.data, { ...global, save: opts.save || global.save });
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  studies.command("optimize-surfaces").description("Calculate optimal panel angle and azimuth for coordinates").requiredOption("--lat <n>", "Latitude").requiredOption("--lon <n>", "Longitude").action(async (opts) => {
+    try {
+      const global = getGlobalOpts7(studies);
+      const client = createServiceClient("solar", global);
+      const res = await client.get("/solar-study/optimizeSurfaces", {
+        params: { lat: parseFloat(opts.lat), lon: parseFloat(opts.lon) }
+      });
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  registerStudyBuilderCommands(studies);
+}
+
+// src/commands/curves/index.ts
+import { readFileSync as readFileSync3 } from "fs";
+function getGlobalOpts8(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+  });
+}
+async function readCurveInput(inputPath) {
+  let raw;
+  if (inputPath && inputPath !== "-") {
+    raw = readFileSync3(inputPath, "utf-8");
+  } else {
+    raw = await readStdin();
+  }
+  return JSON.parse(raw);
+}
+async function buildCurve(data, identifier = "curve") {
+  const { PowerCurve } = await import("energy-types/lib/energy/classes/powerCurve.class");
+  if (Array.isArray(data)) {
+    return new PowerCurve(data, false, identifier, false);
+  }
+  return new PowerCurve(data.days || data, data.ignore0 ?? false, data.identifier || identifier, data.parseDate ?? false);
+}
+function serializeCurve(pc) {
+  return { days: pc.days, identifier: pc.identifier, ignore0: pc.ignore0 };
+}
+function registerCurvesCommands(program2) {
+  const curves = program2.command("curves").description(
+    "PowerCurve operations (pipe-friendly). Accept input via --input <file> or stdin.\nCurve-returning commands output serialized PowerCurve JSON for chaining.\nUse --save <file> to persist and still output to stdout."
+  );
+  curves.command("stats").description("Calculate comprehensive statistics: monthly/daily/hourly averages, max, min, period aggregation").option("--input <file>", "Input file (or - for stdin)").action(async (opts) => {
+    try {
+      const data = await readCurveInput(opts.input);
+      const pc = await buildCurve(data, "stats");
+      const raw = pc.calculateStatistics();
+      output(raw.statistics || raw, getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("total").description("Calculate total accumulated value across all hours").option("--input <file>", "Input file (or - for stdin)").action(async (opts) => {
+    try {
+      const data = await readCurveInput(opts.input);
+      const pc = await buildCurve(data, "total");
+      output({ total: pc.getTotalAcumulate(), days: pc.days.length }, getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("multiply <factor>").description("Multiply all hourly values by a factor. Returns a new PowerCurve.").option("--input <file>", "Input file (or - for stdin)").action(async (factor, opts) => {
+    try {
+      const data = await readCurveInput(opts.input);
+      const pc = await buildCurve(data, "multiplied");
+      const result = pc.applyMultiplier(parseFloat(factor));
+      output(serializeCurve(result), getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("aggregate").description("Sum two PowerCurves (A + B). Returns a new PowerCurve.").requiredOption("--a <file>", "First curve file").requiredOption("--b <file>", "Second curve file").action(async (opts) => {
+    try {
+      const dataA = JSON.parse(readFileSync3(opts.a, "utf-8"));
+      const dataB = JSON.parse(readFileSync3(opts.b, "utf-8"));
+      const pcA = await buildCurve(dataA, "a");
+      const pcB = await buildCurve(dataB, "b");
+      const result = pcA.aggregatePowerCurve(pcB);
+      output(serializeCurve(result), getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("subtract").description("Subtract two PowerCurves (A - B). Returns a new PowerCurve.").requiredOption("--a <file>", "First curve file (minuend)").requiredOption("--b <file>", "Second curve file (subtrahend)").action(async (opts) => {
+    try {
+      const dataA = JSON.parse(readFileSync3(opts.a, "utf-8"));
+      const dataB = JSON.parse(readFileSync3(opts.b, "utf-8"));
+      const pcA = await buildCurve(dataA, "a");
+      const pcB = await buildCurve(dataB, "b");
+      const negB = pcB.applyMultiplier(-1);
+      const result = pcA.aggregatePowerCurve(negB);
+      output(serializeCurve(result), getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("filter-positive").description("Keep only non-negative hourly values (zero out negatives). Returns a new PowerCurve.").option("--input <file>", "Input file (or - for stdin)").action(async (opts) => {
+    try {
+      const data = await readCurveInput(opts.input);
+      const pc = await buildCurve(data, "positive");
+      const result = pc.filterNegativeValues();
+      output(serializeCurve(result), getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("filter-negative").description("Keep only non-positive hourly values (zero out positives). Returns a new PowerCurve.").option("--input <file>", "Input file (or - for stdin)").action(async (opts) => {
+    try {
+      const data = await readCurveInput(opts.input);
+      const pc = await buildCurve(data, "negative");
+      const result = pc.filterPositiveValues();
+      output(serializeCurve(result), getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("sort").description("Sort curve days by date ascending. Returns a new PowerCurve.").option("--input <file>", "Input file (or - for stdin)").action(async (opts) => {
+    try {
+      const data = await readCurveInput(opts.input);
+      const pc = await buildCurve(data, "sorted");
+      const sortedDays = pc.sortByDate();
+      output({ days: sortedDays, identifier: pc.identifier, ignore0: pc.ignore0 }, getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("filter-dates").description("Filter curve to a date range. Returns a new PowerCurve.").option("--input <file>", "Input file (or - for stdin)").option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)").action(async (opts) => {
+    try {
+      const data = await readCurveInput(opts.input);
+      const pc = await buildCurve(data, "filtered");
+      const start = opts.start ? new Date(opts.start) : void 0;
+      const end = opts.end ? new Date(opts.end) : void 0;
+      const filteredDays = pc.filterByDates(start, end);
+      output({ days: filteredDays, identifier: pc.identifier, ignore0: pc.ignore0 }, getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("to-serie").description("Convert curve to chart-ready series format (x/y arrays)").option("--input <file>", "Input file (or - for stdin)").action(async (opts) => {
+    try {
+      const data = await readCurveInput(opts.input);
+      const pc = await buildCurve(data, "serie");
+      const serie = pc.convertoToSerie();
+      output(serie, getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+  curves.command("by-period").description(
+    "Aggregate a PowerCurve by tariff periods (P1-P6) using a period distribution.\nReturns { p1, p2, p3, p4, p5, p6 } with accumulated kWh per period.\n\nThe period distribution maps each hour of each day to a tariff period.\nGet it with: suntropy consumption periods --save /tmp/periods.json\n\nExamples:\n  suntropy curves by-period --input /tmp/production.json --periods /tmp/periods.json\n  suntropy curves by-period --input /tmp/consumption.json --periods /tmp/periods.json"
+  ).requiredOption("--periods <file>", "Period distribution file (DayCurve[] from consumption periods)").option("--input <file>", "Input PowerCurve file (or stdin)").action(async (opts) => {
+    try {
+      const data = await readCurveInput(opts.input);
+      const pc = await buildCurve(data, "by-period");
+      const periodsData = JSON.parse(readFileSync3(opts.periods, "utf-8"));
+      const result = pc.aggregateByPeriod(periodsData);
+      output(result, getGlobalOpts8(curves));
+    } catch (err) {
+      outputError(err);
+    }
+  });
+}
+
+// src/commands/consumption/index.ts
+import { readFileSync as readFileSync4 } from "fs";
+function getGlobalOpts9(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function registerConsumptionCommands(program2) {
+  const consumption = program2.command("consumption").description(
+    "Generate consumption curves using the profiles service.\nSupports multiple estimation methods: standard patterns, custom profiles, monthly data.\nReturns PowerCurve JSON compatible with `suntropy curves` for further processing."
+  );
+  consumption.command("estimate").description(
+    `Generate a consumption PowerCurve from patterns and annual consumption.
+Patterns: Balance, Nightly, Morning, Afternoon, Domestic, Commercial
+Examples:
+  suntropy consumption estimate --annual 5000 --pattern Balance
+  suntropy consumption estimate --annual 8000 --pattern Domestic --tariff 3.0TD --market es
+  suntropy consumption estimate --annual 3500 --monthly-data '{"1":300,"2":280,...}'
+  suntropy consumption estimate --annual 5000 --custom-profile-id abc123`
+  ).requiredOption("--annual <kWh>", "Annual consumption in kWh").option("--pattern <name>", "Consumption pattern: Balance, Nightly, Morning, Afternoon, Domestic, Commercial").option("--start-date <YYYY-MM-DD>", "Start date (default: Jan 1 current year)").option("--end-date <YYYY-MM-DD>", "End date (default: Dec 31 current year)").option("--tariff <code>", "Electricity tariff code (e.g. 3.0TD)", "3.0TD").option("--type <type>", "Profile type: Initial or Final", "Final").option("--market <code>", "Market: es, pt, it", "es").option("--custom-profile-id <id>", "Use a custom consumption profile by ID").option("--monthly-data <json>", 'Monthly consumption JSON: {"1":val,"2":val,...,"12":val}').option("--daily-curve <json>", "Custom daily curve JSON (DayCurve format)").option("--save <file>", "Save result to file").action(async (opts) => {
+    try {
+      const global = getGlobalOpts9(consumption);
+      const client = createServiceClient("profiles", global);
+      const year = (/* @__PURE__ */ new Date()).getFullYear();
+      const startDate = opts.startDate || `${year}-01-01`;
+      const endDate = opts.endDate || `${year}-12-31`;
+      const params = {
+        startDate,
+        endDate,
+        tariff: opts.tariff,
+        type: opts.type,
+        anualConsumption: opts.annual,
+        market: opts.market
+      };
+      if (opts.pattern) params.consumptionType = opts.pattern;
+      if (opts.customProfileId) params.customProfileId = opts.customProfileId;
+      let body;
+      if (opts.monthlyData || opts.dailyCurve) {
+        body = {};
+        if (opts.monthlyData) body.consumptionByMonth = JSON.parse(opts.monthlyData);
+        if (opts.dailyCurve) body.dailyCurve = JSON.parse(opts.dailyCurve);
+      }
+      const queryString = Object.entries(params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+      const res = await client.post(`/consumption-estimation?${queryString}`, body || {});
+      output(res.data, { ...global, save: opts.save || global.save });
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  consumption.command("ree-profiles").description(
+    "Fetch REE (Red El\xE9ctrica) hourly profiles for a date range and tariff.\nReturns the raw profile data used as basis for consumption estimation.\nExample: suntropy consumption ree-profiles --start 2024-01-01 --end 2024-12-31 --tariff 3.0TD"
+  ).requiredOption("--start <YYYY-MM-DD>", "Start date").requiredOption("--end <YYYY-MM-DD>", "End date").option("--tariff <code>", "Tariff code", "3.0TD").option("--type <type>", "Profile type: Initial or Final", "Final").option("--market <code>", "Market code: es, pt, it", "es").option("--save <file>", "Save result to file").action(async (opts) => {
+    try {
+      const global = getGlobalOpts9(consumption);
+      const client = createServiceClient("profiles", global);
+      const res = await client.get("/ree-profiles", {
+        params: {
+          startDate: opts.start,
+          endDate: opts.end,
+          tariff: opts.tariff,
+          type: opts.type,
+          market: opts.market
+        }
+      });
+      output(res.data, { ...global, save: opts.save || global.save });
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  consumption.command("custom-tags").description("List available custom consumption profile tags for the authenticated client").action(async () => {
+    try {
+      const global = getGlobalOpts9(consumption);
+      const client = createServiceClient("profiles", global);
+      const res = await client.get("/custom-profiles/getTags");
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  consumption.command("custom-profile-info").description("Get details of a custom consumption profile by ID").requiredOption("--id <profileId>", "Custom profile ID").action(async (opts) => {
+    try {
+      const global = getGlobalOpts9(consumption);
+      const client = createServiceClient("profiles", global);
+      const res = await client.get("/custom-profiles/getInfo", {
+        params: { id: opts.id }
+      });
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  consumption.command("periods").description(
+    "Fetch period distribution (hour\u2192P1-P6 mapping) from the periods service.\nReturns DayCurve[] where each hour's value is the period number (1-6).\nUse with `suntropy curves by-period` to aggregate any curve by tariff period.\n\nCommon tariff IDs (Spain): 13=2.0TD, 14=3.0TD\nZone IDs (Spain): 1=Peninsula, 2=Canarias, 3=Baleares\n\nExamples:\n  suntropy consumption periods --tariff-id 14 --zone-id 1 --save /tmp/periods.json\n  suntropy consumption periods --tariff-id 13 --start 2025-01-01 --end 2025-12-31"
+  ).option("--tariff-id <n>", "ATR tariff ID (13=2.0TD, 14=3.0TD)", "14").option("--zone-id <n>", "Geographical zone ID (1=Peninsula)", "1").option("--start <YYYY-MM-DD>", "Start date (default: Jan 1 current year)").option("--end <YYYY-MM-DD>", "End date (default: Dec 31 current year)").option("--market <code>", "Market: es, pt, it, fr", "es").option("--save <file>", "Save result to file").action(async (opts) => {
+    try {
+      const global = getGlobalOpts9(consumption);
+      const client = createServiceClient("periods", global);
+      const year = (/* @__PURE__ */ new Date()).getFullYear();
+      const res = await client.get("/periodos", {
+        params: {
+          idTarifa: parseInt(opts.tariffId),
+          idZona: parseInt(opts.zoneId),
+          fechaInicio: opts.start || `${year}-01-01`,
+          fechaFin: opts.end || `${year}-12-31`,
+          market: opts.market
+        }
+      });
+      output(res.data, { ...global, save: opts.save || global.save });
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  consumption.command("from-file").description(
+    "Generate consumption curve from an uploaded file.\nSupported formats: Portuguese EREDES ZIP files.\nExample: suntropy consumption from-file --eredes-zip /path/to/file.zip"
+  ).option("--eredes-zip <path>", "Path to Portuguese EREDES ZIP file").option("--save <file>", "Save result to file").action(async (opts) => {
+    try {
+      const global = getGlobalOpts9(consumption);
+      const client = createServiceClient("profiles", global);
+      if (opts.eredesZip) {
+        const FormData = (await import("form-data")).default;
+        const form = new FormData();
+        form.append("file", readFileSync4(opts.eredesZip), {
+          filename: opts.eredesZip.split("/").pop(),
+          contentType: "application/zip"
+        });
+        const res = await client.post("/consumption-files-processor/portugal/eredes-zip", form, {
+          headers: form.getHeaders()
+        });
+        output(res.data, { ...global, save: opts.save || global.save });
+      } else {
+        outputError(new Error("Specify a file format: --eredes-zip <path>"));
+      }
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+}
+
+// src/commands/solarform/index.ts
+function getGlobalOpts10(cmd) {
+  let root = cmd;
+  while (root.parent) root = root.parent;
+  return root.opts();
+}
+function readStdin2() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+  });
+}
+async function parseData4(data) {
+  if (!data) return void 0;
+  if (data === "-") {
+    const input = await readStdin2();
+    return JSON.parse(input);
+  }
+  return JSON.parse(data);
+}
+function unwrapPublicApiResponse(resData) {
+  if (resData && typeof resData === "object" && !Array.isArray(resData)) {
+    const r = resData;
+    if ("code" in r && typeof r.code === "number") {
+      if (r.data !== void 0) return r.data;
+      if (r.error) {
+        const err = r.error;
+        throw new Error(`API error (${err.code || r.code}): ${err.message || JSON.stringify(err)}`);
+      }
+      return resData;
+    }
+  }
+  return resData;
+}
+function compactStudyOutput(study) {
+  if (study === null || study === void 0 || typeof study !== "object") return study;
+  if (Array.isArray(study)) return study.map(compactStudyOutput);
+  const record = study;
+  if (Array.isArray(record.days) && record.days.length > 0 && record.identifier !== void 0) {
+    return { _type: "PowerCurve", days: record.days.length, identifier: record.identifier };
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(record)) {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const v = val;
+      if (Array.isArray(v.days) && v.days.length > 0 && v.identifier !== void 0) {
+        result[key] = { _type: "PowerCurve", days: v.days.length, identifier: v.identifier };
+        continue;
+      }
+    }
+    result[key] = compactStudyOutput(val);
+  }
+  return result;
+}
+function registerSolarformCommands(program2) {
+  const solarform = program2.command("solarform").description(
+    'Create solar studies via the Solar Form API.\nTwo modes: "simple" (minimal params, auto-optimized) and "calculate" (full control).\nUse --save flag to persist the study to the database.'
+  );
+  solarform.command("simple").description(
+    'Create a solar study with minimal parameters (simplified mode).\nAutomatically resolves location from region/subregion, applies consumption patterns,\nand optimizes kit selection.\n\nConsumption patterns: Balance, Nightly, Morning, Afternoon, Domestic, Commercial\nConsumption mode: monthlyConsumption (kWh) or monthlySpending (EUR)\nExcesses modes: PPA, gridSelling, noInjection, virtualBattery\n\nExamples:\n  suntropy solarform simple --region "Andaluc\xEDa" --sub-region "Sevilla" --consumption 5000\n  suntropy solarform simple --region "Catalu\xF1a" --sub-region "Barcelona" --consumption 300 --consumption-mode monthlySpending --save\n  suntropy solarform simple --region "Madrid" --sub-region "Madrid" --consumption 8000 --pattern Domestic --kit-id abc123 --save'
+  ).requiredOption("--region <name>", "Region name (must exist in database)").requiredOption("--sub-region <name>", "Sub-region name").requiredOption("--consumption <value>", "Consumption value (kWh or EUR depending on --consumption-mode)").option("--pattern <name>", "Consumption pattern: Balance, Nightly, Morning, Afternoon, Domestic, Commercial", "Balance").option("--consumption-mode <mode>", "monthlyConsumption (kWh) or monthlySpending (EUR)", "monthlyConsumption").option("--kit-id <id>", "Use a specific solar kit instead of auto-optimization").option("--excesses-mode <mode>", "Excesses compensation: PPA, gridSelling, noInjection, virtualBattery").option("--assigned-user <uid>", "Assign study to a user UID").option("--email <email>", "Send results to this email").option("--save", "Save study to database").option("--raw", "Return full study with PowerCurve data (no compaction)").option("--save-file <file>", "Save result to local file").action(async (opts) => {
+    try {
+      const global = getGlobalOpts10(solarform);
+      const client = createServiceClient("solar", global);
+      const body = {
+        region: opts.region,
+        subRegion: opts.subRegion,
+        selectedConsumptionPattern: opts.pattern,
+        consumptionQuantity: parseFloat(opts.consumption),
+        consumptionQuantityIntroductionMode: opts.consumptionMode
+      };
+      if (opts.assignedUser) body.assignedUserUID = opts.assignedUser;
+      const params = {};
+      if (opts.save) params.save = "true";
+      if (opts.email) params.email = opts.email;
+      if (opts.kitId) params.solarKitId = opts.kitId;
+      if (opts.excessesMode) params.excessesCompensationMode = opts.excessesMode;
+      const queryString = Object.entries(params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+      const url = `/api/solar-form/simple${queryString ? "?" + queryString : ""}`;
+      const res = await client.post(url, body);
+      const study = unwrapPublicApiResponse(res.data);
+      const result = opts.raw ? study : compactStudyOutput(study);
+      output(result, { ...global, save: opts.saveFile || global.save });
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  solarform.command("calculate").description(
+    `Create a solar study with full control over all parameters.
+Pass the complete SimplifiedSolarStudy body as JSON.
+
+Required body fields:
+  center: { lat, lng } \u2014 Installation coordinates
+  surfaces: [{ path, inclination, orientation }] \u2014 Panel surfaces
+  consumptionMode: "cups" | "consumptionPatterns"
+  clientDetails: { name, email, phone }
+
+Optional: atrTariff, geographicalZone, location, contractedPower,
+  monthPeriodConsumptionDictionary, selectedConsumptionPattern,
+  consumptionQuantity, consumptionQuantityIntroductionMode
+
+Examples:
+  suntropy solarform calculate --data '{"center":{"lat":37.39,"lng":-5.99},...}' --save
+  cat study-input.json | suntropy solarform calculate --data - --save --email client@co.com`
+  ).requiredOption("--data <json>", "Full SimplifiedSolarStudy JSON body (or - for stdin)").option("--save", "Save study to database").option("--email <email>", "Send results to this email").option("--raw", "Return full study with PowerCurve data (no compaction)").option("--save-file <file>", "Save result to local file").action(async (opts) => {
+    try {
+      const global = getGlobalOpts10(solarform);
+      const client = createServiceClient("solar", global);
+      const body = await parseData4(opts.data);
+      if (!body) {
+        outputError(new Error("--data is required. Pass JSON or - for stdin."));
+        return;
+      }
+      const params = {};
+      if (opts.save) params.save = "true";
+      if (opts.email) params.email = opts.email;
+      const queryString = Object.entries(params).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+      const url = `/api/solar-form${queryString ? "?" + queryString : ""}`;
+      const res = await client.post(url, body);
+      const study = unwrapPublicApiResponse(res.data);
+      if (!study || typeof study === "object" && !Array.isArray(study) && !("selectedSolarStudyMode" in study)) {
+        outputError(new Error('API returned no study data. The /api/solar-form endpoint requires a complete body with: center, surfaces, consumptionMode, and typically locationMode. Use "solarform simple" for minimal-parameter study creation.'));
+        return;
+      }
+      const result = opts.raw ? study : compactStudyOutput(study);
+      output(result, { ...global, save: opts.saveFile || global.save });
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  solarform.command("config").description(
+    "Get the solar form configuration for the authenticated client.\nReturns form settings, appearance, enabled steps, custom fields, etc."
+  ).action(async () => {
+    try {
+      const global = getGlobalOpts10(solarform);
+      const client = createServiceClient("solar", global);
+      const res = await client.get("/solar-form/solar-form-config");
+      output(res.data, global);
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+  solarform.command("statistics").description(
+    "List or create solar form submission statistics.\nUsed for tracking form analytics and conversion data."
+  ).option("--create", "Create a new statistics entry").option("--update", "Update an existing statistics entry").option("--data <json>", "Statistics data as JSON").option("--stats-id <id>", "Statistics ID (for update or linking)").action(async (opts) => {
+    try {
+      const global = getGlobalOpts10(solarform);
+      const client = createServiceClient("solar", global);
+      if (opts.update) {
+        const body = await parseData4(opts.data);
+        const res = await client.put("/solar-form/solar-form-statistics", body);
+        output(res.data, global);
+      } else if (opts.create) {
+        const body = await parseData4(opts.data) || {};
+        const params = {};
+        if (opts.statsId) params.statsId = opts.statsId;
+        const res = await client.post("/solar-form/solar-form-statistics", body, { params });
+        output(res.data, global);
+      } else {
+        outputError(new Error("Specify --create or --update"));
+      }
+    } catch (err) {
+      outputError(handleApiError(err));
+    }
+  });
+}
+
+// src/index.ts
+function createProgram() {
+  const program2 = new Command2();
+  program2.name("suntropy").description("Agent-first CLI for Suntropy solar platform. Optimized for programmatic data manipulation and progressive exploration.").version("0.1.0").option("--format <format>", "Output format: json (default), human, csv", "json").option("--fields <fields>", "Comma-separated fields to include in output").option("--server <url>", "Override API server URL").option("--token <jwt>", "Override authentication token").option("--profile <name>", "Use a specific config profile").option("--verbose", "Show HTTP request/response details on stderr").option("--quiet", "Suppress non-data output").option("--save <file>", "Save output to file (also writes to stdout)");
+  registerAuthCommands(program2);
+  registerConfigCommands(program2);
+  registerInventoryCommands(program2);
+  registerStudiesCommands(program2);
+  registerCurvesCommands(program2);
+  registerConsumptionCommands(program2);
+  registerSolarformCommands(program2);
+  return program2;
+}
+
+// bin/suntropy.ts
+var program = createProgram();
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(JSON.stringify({ error: true, message: err.message }) + "\n");
+  process.exit(1);
+});
+//# sourceMappingURL=suntropy.js.map