@reporting-bi/cli 0.0.10 → 0.0.11

package/dist/index.js

@@ -2028,9 +2028,9 @@ var require_stringify = __commonJS({
       }
     };
     var isArray = Array.isArray;
-    var push = Array.prototype.push;
+    var push2 = Array.prototype.push;
     var pushToArray = function(arr, valueOrArray) {
-      push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
+      push2.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
     };
     var toISO = Date.prototype.toISOString;
     var defaultFormat = formats["default"];
@@ -2650,7 +2650,7 @@ var require_service = __commonJS({
           this.options.baseUrl = `https://${this.options.baseUrl}`;
         }
       }
-      createUrl(path3 = "", params) {
+      createUrl(path5 = "", params) {
         if (this.options.xdebugSession) {
           params = params || {};
           params.XDEBUG_SESSION = this.options.xdebugSession === true ? "1" : this.options.xdebugSession.toString();
@@ -2660,8 +2660,8 @@ var require_service = __commonJS({
         }
         const queryString = params ? "?" + serializeRequestParams(params) : "";
         const a = params && params.accounting ? params.accounting.toString() : this.a ? this.a.toString() : null;
-        path3 = path3.replace(/^\//, "");
-        const parts = [this.options.baseUrl, a, this.options.name, path3];
+        path5 = path5.replace(/^\//, "");
+        const parts = [this.options.baseUrl, a, this.options.name, path5];
         return parts.filter((p) => p != null && p !== "").join("/") + queryString;
       }
       async createHeaders(headers) {
@@ -2702,28 +2702,28 @@ var require_service = __commonJS({
           return await response.text();
         }
       }
-      async getRaw(path3, params, options) {
-        return fetch(this.createUrl(path3, params), {
+      async getRaw(path5, params, options) {
+        return fetch(this.createUrl(path5, params), {
           headers: await this.createHeaders(options?.headers),
           credentials: this.credentials
         });
       }
-      async get(path3, params, options) {
+      async get(path5, params, options) {
         if (options?.cache) {
-          const cachedData = this.cache.get({ path: path3, params });
+          const cachedData = this.cache.get({ path: path5, params });
           if (cachedData)
             return cachedData;
         }
-        const response = await this.getRaw(path3, params, options);
+        const response = await this.getRaw(path5, params, options);
         const responseData = await this.handleResponse(response, options?.parseResponse);
         if (options?.cache && responseData) {
-          this.cache.set({ path: path3, params }, responseData);
+          this.cache.set({ path: path5, params }, responseData);
         }
         return responseData;
       }
-      async postRaw(path3, data, params, options) {
+      async postRaw(path5, data, params, options) {
         const json = isObject(data) || Array.isArray(data);
-        return fetch(this.createUrl(path3, params), {
+        return fetch(this.createUrl(path5, params), {
           method: "POST",
           body: json ? JSON.stringify(data) : data,
           headers: await this.createHeaders({
@@ -2733,24 +2733,24 @@ var require_service = __commonJS({
           credentials: this.credentials
         });
       }
-      async post(path3, data, params, options) {
-        const response = await this.postRaw(path3, data, params, options);
+      async post(path5, data, params, options) {
+        const response = await this.postRaw(path5, data, params, options);
         return this.handleResponse(response);
       }
-      async deleteRaw(path3, params, options) {
-        return fetch(this.createUrl(path3, params), {
+      async deleteRaw(path5, params, options) {
+        return fetch(this.createUrl(path5, params), {
           method: "DELETE",
           headers: await this.createHeaders(options?.headers),
           credentials: this.credentials
         });
       }
-      async delete(path3, params, options) {
-        const response = await this.deleteRaw(path3, params, options);
+      async delete(path5, params, options) {
+        const response = await this.deleteRaw(path5, params, options);
         return this.handleResponse(response);
       }
-      async putRaw(path3, data, params, options) {
+      async putRaw(path5, data, params, options) {
         const json = isObject(data) || Array.isArray(data);
-        return fetch(this.createUrl(path3, params), {
+        return fetch(this.createUrl(path5, params), {
           method: "PUT",
           body: json ? JSON.stringify(data) : data,
           headers: await this.createHeaders({
@@ -2760,8 +2760,8 @@ var require_service = __commonJS({
           credentials: this.credentials
         });
       }
-      async put(path3, data, params, options) {
-        const response = await this.putRaw(path3, data, params, options);
+      async put(path5, data, params, options) {
+        const response = await this.putRaw(path5, data, params, options);
         return this.handleResponse(response);
       }
     };
@@ -3286,8 +3286,8 @@ var callback_default = `<!DOCTYPE html>
 `;
 
 // src/commands/login.ts
-function renderCallback(status2, title, message) {
-  return callback_default.replace("{{status}}", status2).replace("{{title}}", title).replace("{{message}}", message);
+function renderCallback(status3, title, message) {
+  return callback_default.replace("{{status}}", status3).replace("{{title}}", title).replace("{{message}}", message);
 }
 function openBrowser(url) {
   const platform = process.platform;
@@ -3331,12 +3331,12 @@ async function login(args) {
   }
 }
 function getAuthorizationCode(domain) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     let timeout;
     const done = (result) => {
       clearTimeout(timeout);
       server.close();
-      resolve(result);
+      resolve3(result);
     };
     const server = http.createServer((req, res) => {
       const url = new URL(req.url || "", "http://localhost");
@@ -3496,11 +3496,11 @@ async function readContent(flags) {
     return flags.content;
   }
   if (!process.stdin.isTTY) {
-    return new Promise((resolve) => {
+    return new Promise((resolve3) => {
       let data = "";
       process.stdin.setEncoding("utf-8");
       process.stdin.on("data", (chunk) => data += chunk);
-      process.stdin.on("end", () => resolve(data));
+      process.stdin.on("end", () => resolve3(data));
     });
   }
   console.error("No content provided. Use --file, --content, or pipe to stdin.");
@@ -3564,7 +3564,433 @@ async function wiki(args) {
 }
 
 // src/commands/etl.ts
+var fs5 = __toESM(require("node:fs"));
+
+// src/commands/etl-sync.ts
+var fs4 = __toESM(require("node:fs"));
+var path3 = __toESM(require("node:path"));
+
+// src/manifest.ts
 var fs3 = __toESM(require("node:fs"));
+var path2 = __toESM(require("node:path"));
+var crypto = __toESM(require("node:crypto"));
+var RPBI_DIR = ".rpbi";
+var MANIFEST_FILE = "manifest.json";
+function computeHash(content2) {
+  return crypto.createHash("sha256").update(content2, "utf-8").digest("hex");
+}
+function getManifestPath(dir) {
+  return path2.join(dir, RPBI_DIR, MANIFEST_FILE);
+}
+function readManifest(dir) {
+  const filePath = getManifestPath(dir);
+  try {
+    const data = fs3.readFileSync(filePath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function writeManifest(dir, manifest) {
+  const rpbiDir = path2.join(dir, RPBI_DIR);
+  fs3.mkdirSync(rpbiDir, { recursive: true });
+  fs3.writeFileSync(
+    path2.join(rpbiDir, MANIFEST_FILE),
+    JSON.stringify(manifest, null, 2)
+  );
+}
+function findEtlRoot(startDir) {
+  let dir = path2.resolve(startDir);
+  while (true) {
+    if (fs3.existsSync(getManifestPath(dir))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// src/commands/etl-sync.ts
+var PARAMETER_TYPES = ["IA", "IM", "O", "D"];
+var PARAMETER_EXCLUDE_FIELDS = ["accounting", "id_thread", "idz", "validate_flag", "date_created"];
+var THREAD_EXCLUDE_FIELDS = ["command_txt", "command_preview", "accounting", "id_thread", "type", "idz", "validate_flag", "date_created"];
+var CONTEXT_SCHEMA_DIRS = {
+  "schema/db_data/tables": { db: "db_data", objectType: "tables" },
+  "schema/db_data/procedures": { db: "db_data", objectType: "procedures" },
+  "schema/db_data/functions": { db: "db_data", objectType: "functions" },
+  "schema/db_master/views": { db: "db_master", objectType: "views" },
+  "schema/db_master/procedures": { db: "db_master", objectType: "procedures" },
+  "schema/db_master/functions": { db: "db_master", objectType: "functions" },
+  "schema/db_super/views": { db: "db_super", objectType: "views" },
+  "schema/db_super/procedures": { db: "db_super", objectType: "procedures" },
+  "schema/db_super/functions": { db: "db_super", objectType: "functions" }
+};
+function optimizeForLlm(data) {
+  if (data === null || data === void 0) return void 0;
+  if (Array.isArray(data)) {
+    const result = data.map((item) => optimizeForLlm(item)).filter((item) => item !== void 0);
+    return result.length > 0 ? result : void 0;
+  }
+  if (typeof data === "object") {
+    const result = {};
+    let hasKeys = false;
+    for (const [key, value] of Object.entries(data)) {
+      const optimized = optimizeForLlm(value);
+      if (optimized !== void 0) {
+        result[key] = optimized;
+        hasKeys = true;
+      }
+    }
+    return hasKeys ? result : void 0;
+  }
+  return data;
+}
+function getFilePath(description, extension = ".sql") {
+  const parts = description.split("/");
+  const name = parts.pop();
+  let fileName;
+  if (!name.includes(".")) {
+    fileName = name + extension;
+  } else if (name.endsWith(".sql") && extension !== ".sql") {
+    fileName = name.slice(0, -4) + extension;
+  } else if (extension !== ".sql") {
+    const dotIndex = name.lastIndexOf(".");
+    fileName = name.slice(0, dotIndex) + extension;
+  } else {
+    fileName = name;
+  }
+  return [...parts, fileName];
+}
+function threadToRelPath(thread) {
+  const segments = getFilePath(thread.description || "");
+  return [thread.type, ...segments].join("/");
+}
+function threadToParamPath(thread) {
+  const segments = getFilePath(thread.description || "", ".yaml");
+  return [".parameters", thread.type, ...segments].join("/");
+}
+function threadToMetaPath(thread) {
+  const segments = getFilePath(thread.description || "", ".yaml");
+  return [".threads", thread.type, ...segments].join("/");
+}
+function writeFileSync4(filePath, content2) {
+  fs4.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs4.writeFileSync(filePath, content2, "utf-8");
+}
+function stripFields(obj, excludeFields) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (!excludeFields.includes(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function toYaml(data, indent = 0) {
+  if (data === null || data === void 0) return "null";
+  if (typeof data === "boolean") return data ? "true" : "false";
+  if (typeof data === "number") return String(data);
+  if (typeof data === "string") {
+    if (data.includes("\n")) {
+      const prefix = " ".repeat(indent);
+      const lines = data.split("\n").map((l) => prefix + "  " + l).join("\n");
+      return "|\n" + lines;
+    }
+    if (data === "" || /[:{}\[\],&*?|>!'"%@`#]/.test(data) || /^\s|\s$/.test(data)) {
+      return JSON.stringify(data);
+    }
+    return data;
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) return "[]";
+    const prefix = " ".repeat(indent);
+    return data.map((item) => {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const entries = Object.entries(item);
+        if (entries.length === 0) return `${prefix}- {}`;
+        const [firstKey, firstVal] = entries[0];
+        const firstLine = `${prefix}- ${firstKey}: ${toYaml(firstVal, indent + 2)}`;
+        const rest = entries.slice(1).map(
+          ([k, v]) => `${prefix}  ${k}: ${toYaml(v, indent + 2)}`
+        );
+        return [firstLine, ...rest].join("\n");
+      }
+      return `${prefix}- ${toYaml(item, indent + 2)}`;
+    }).join("\n");
+  }
+  if (typeof data === "object") {
+    const entries = Object.entries(data);
+    if (entries.length === 0) return "{}";
+    const prefix = " ".repeat(indent);
+    return entries.map(
+      ([k, v]) => `${prefix}${k}: ${toYaml(v, indent)}`
+    ).join("\n");
+  }
+  return String(data);
+}
+async function pull(flags) {
+  const dir = path3.resolve(flags.dir || ".");
+  const conn = getActiveConnection();
+  if (!conn) {
+    console.error('Not logged in. Run "rpbi login" first.');
+    process.exit(1);
+  }
+  const etlService = await createService("etl");
+  const defService = await createService("definition");
+  console.log(`Pulling ETL threads to ${dir}...`);
+  const threads = await etlService.get("threads", {
+    fields: ["id_thread", "description", "type", "enabled", "ord_num", "module"],
+    order: [["type", "asc"], ["description", "asc"]]
+  }) || [];
+  console.log(`Found ${threads.length} threads`);
+  const manifest = {
+    domain: conn.domain,
+    accounting: conn.tokens.accounting,
+    pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    threads: {}
+  };
+  let pulled = 0;
+  for (const thread of threads) {
+    if (!thread.id_thread || !thread.type || !thread.description) continue;
+    const relPath = threadToRelPath(thread);
+    const absPath = path3.join(dir, relPath);
+    try {
+      const content2 = await etlService.get(
+        `threadContent/${thread.id_thread}`,
+        void 0,
+        { parseResponse: false }
+      ) || "";
+      writeFileSync4(absPath, content2);
+      manifest.threads[relPath] = {
+        id_thread: thread.id_thread,
+        hash: computeHash(content2),
+        type: thread.type
+      };
+      pulled++;
+      if (pulled % 50 === 0) console.log(`  ${pulled}/${threads.length} threads...`);
+    } catch (err) {
+      console.error(`  Failed to pull ${relPath}: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  console.log("Pulling parameters...");
+  for (const thread of threads) {
+    if (!thread.id_thread || !PARAMETER_TYPES.includes(thread.type || "")) continue;
+    try {
+      const params = await etlService.get(
+        `threads/${thread.id_thread}/parameters`
+      ) || [];
+      if (params.length === 0) continue;
+      const cleaned = params.map((p) => stripFields(p, PARAMETER_EXCLUDE_FIELDS));
+      const optimized = optimizeForLlm(cleaned);
+      if (!optimized || !Array.isArray(optimized) || optimized.length === 0) continue;
+      const paramPath = path3.join(dir, threadToParamPath(thread));
+      writeFileSync4(paramPath, toYaml(optimized) + "\n");
+    } catch {
+    }
+  }
+  console.log("Pulling thread metadata...");
+  for (const thread of threads) {
+    if (!thread.id_thread) continue;
+    try {
+      const full = await etlService.get(`threads/${thread.id_thread}`);
+      if (!full) continue;
+      const cleaned = stripFields(full, THREAD_EXCLUDE_FIELDS);
+      const optimized = optimizeForLlm(cleaned);
+      if (!optimized || Object.keys(optimized).length === 0) continue;
+      const metaPath = path3.join(dir, threadToMetaPath(thread));
+      writeFileSync4(metaPath, toYaml(optimized) + "\n");
+    } catch {
+    }
+  }
+  if (!flags["no-context"]) {
+    await pullContext(dir, etlService, defService);
+  }
+  writeManifest(dir, manifest);
+  console.log(`Done. Pulled ${pulled} threads to ${dir}`);
+}
+async function push(flags, files) {
+  const startDir = flags.dir || ".";
+  const root = findEtlRoot(startDir);
+  if (!root) {
+    console.error('No .rpbi/manifest.json found. Run "rpbi etl pull" first.');
+    process.exit(1);
+  }
+  const manifest = readManifest(root);
+  const etlService = await createService("etl");
+  const force = flags.force === "true";
+  let filesToPush;
+  if (files.length > 0) {
+    filesToPush = files.map((f) => path3.relative(root, path3.resolve(f)));
+  } else {
+    filesToPush = detectModifiedFiles(root, manifest);
+  }
+  if (filesToPush.length === 0) {
+    console.log("Nothing to push.");
+    return;
+  }
+  console.log(`Pushing ${filesToPush.length} file(s)...`);
+  for (const relPath of filesToPush) {
+    const absPath = path3.join(root, relPath);
+    if (!fs4.existsSync(absPath)) {
+      console.log(`  Skipping ${relPath} (file not found)`);
+      continue;
+    }
+    const localContent = fs4.readFileSync(absPath, "utf-8");
+    const entry = manifest.threads[relPath];
+    if (entry) {
+      if (!force) {
+        try {
+          const serverContent = await etlService.get(
+            `threadContent/${entry.id_thread}`,
+            void 0,
+            { parseResponse: false }
+          ) || "";
+          const serverHash = computeHash(serverContent);
+          if (serverHash !== entry.hash) {
+            console.error(`  CONFLICT: ${relPath} was modified on server. Use --force to overwrite.`);
+            continue;
+          }
+        } catch {
+        }
+      }
+      await etlService.post(`threadContent/${entry.id_thread}`, localContent);
+      manifest.threads[relPath].hash = computeHash(localContent);
+      console.log(`  Updated: ${relPath}`);
+    } else {
+      const parts = relPath.split("/");
+      const type = parts[0];
+      const description = parts.slice(1).join("/").replace(/\.sql$/, "");
+      const newThread = await etlService.post("threads", {
+        type,
+        description,
+        enabled: 1
+      });
+      if (newThread?.id_thread) {
+        await etlService.post(`threadContent/${newThread.id_thread}`, localContent);
+        manifest.threads[relPath] = {
+          id_thread: newThread.id_thread,
+          hash: computeHash(localContent),
+          type
+        };
+        console.log(`  Created: ${relPath} (thread #${newThread.id_thread})`);
+      } else {
+        console.error(`  Failed to create thread for ${relPath}`);
+      }
+    }
+  }
+  writeManifest(path3.resolve(root), manifest);
+  console.log("Push complete.");
+}
+async function pullContext(dir, etlService, defService) {
+  const contextDir = path3.join(dir, ".context");
+  console.log("Pulling context (schema & modules)...");
+  try {
+    const modules2 = await defService.get("accountingModules");
+    if (modules2) {
+      const optimized = optimizeForLlm(modules2);
+      writeFileSync4(
+        path3.join(contextDir, "modules.json"),
+        JSON.stringify(optimized, null, 2)
+      );
+    }
+  } catch (err) {
+    console.error(`  Failed to pull modules: ${err instanceof Error ? err.message : err}`);
+  }
+  for (const [dirPath, { db, objectType }] of Object.entries(CONTEXT_SCHEMA_DIRS)) {
+    try {
+      const items = await etlService.get(`schema/${db}/${objectType}`) || [];
+      for (const item of items) {
+        const name = item?.name;
+        if (!name) continue;
+        const optimized = optimizeForLlm(item);
+        writeFileSync4(
+          path3.join(contextDir, dirPath, `${name}.json`),
+          JSON.stringify(optimized, null, 2)
+        );
+      }
+    } catch {
+    }
+  }
+}
+async function context(flags) {
+  const dir = path3.resolve(flags.dir || ".");
+  const etlService = await createService("etl");
+  const defService = await createService("definition");
+  await pullContext(dir, etlService, defService);
+  console.log("Context pull complete.");
+}
+function detectModifiedFiles(root, manifest) {
+  const modified = [];
+  for (const [relPath, entry] of Object.entries(manifest.threads)) {
+    const absPath = path3.join(root, relPath);
+    if (!fs4.existsSync(absPath)) {
+      modified.push(relPath);
+      continue;
+    }
+    const content2 = fs4.readFileSync(absPath, "utf-8");
+    if (computeHash(content2) !== entry.hash) {
+      modified.push(relPath);
+    }
+  }
+  return modified;
+}
+function detectNewFiles(root, manifest) {
+  const newFiles = [];
+  const entries = fs4.readdirSync(root, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    walkDir(path3.join(root, entry.name), root, manifest, newFiles);
+  }
+  return newFiles;
+}
+function walkDir(dir, root, manifest, result) {
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkDir(full, root, manifest, result);
+    } else if (entry.name.endsWith(".sql")) {
+      const rel = path3.relative(root, full);
+      if (!manifest.threads[rel]) {
+        result.push(rel);
+      }
+    }
+  }
+}
+async function status2(flags) {
+  const startDir = flags.dir || ".";
+  const root = findEtlRoot(startDir);
+  if (!root) {
+    console.error('No .rpbi/manifest.json found. Run "rpbi etl pull" first.');
+    process.exit(1);
+  }
+  const manifest = readManifest(root);
+  console.log(`ETL workspace: ${root}`);
+  console.log(`Domain: ${manifest.domain} | Accounting: ${manifest.accounting}`);
+  console.log(`Pulled at: ${manifest.pulledAt}`);
+  console.log("");
+  const modified = detectModifiedFiles(root, manifest);
+  const newFiles = detectNewFiles(root, manifest);
+  const deleted = modified.filter((f) => !fs4.existsSync(path3.join(root, f)));
+  const changed = modified.filter((f) => fs4.existsSync(path3.join(root, f)));
+  if (changed.length === 0 && newFiles.length === 0 && deleted.length === 0) {
+    console.log("No changes.");
+    return;
+  }
+  if (changed.length > 0) {
+    console.log("Modified:");
+    for (const f of changed) console.log(`  M ${f}`);
+  }
+  if (newFiles.length > 0) {
+    console.log("New (untracked):");
+    for (const f of newFiles) console.log(`  + ${f}`);
+  }
+  if (deleted.length > 0) {
+    console.log("Deleted locally:");
+    for (const f of deleted) console.log(`  - ${f}`);
+  }
+}
+
+// src/commands/etl.ts
 var DEFAULT_FIELDS = ["id_thread", "description", "module", "type", "enabled", "ord_num"];
 async function list3(flags) {
   const service = await createService("etl");
@@ -3585,7 +4011,7 @@ async function exec2(id, flags) {
   const service = await createService("etl");
   let body = void 0;
   if (flags.file) {
-    body = fs3.readFileSync(flags.file, "utf-8");
+    body = fs5.readFileSync(flags.file, "utf-8");
   } else if (flags.sql) {
     body = flags.sql;
   }
@@ -3627,8 +4053,16 @@ async function etl(args) {
         process.exit(1);
       }
       return search2(rest[0], flags);
+    case "pull":
+      return pull(flags);
+    case "push":
+      return push(flags, rest);
+    case "context":
+      return context(flags);
+    case "status":
+      return status2(flags);
     default:
-      console.log("Usage: rpbi etl <list|get|content|exec|search> [options]");
+      console.log("Usage: rpbi etl <list|get|content|exec|search|pull|push|context|status> [options]");
       break;
   }
 }
@@ -3684,7 +4118,7 @@ async function jobs(args) {
 
 // src/commands/analytics.ts
 var DEFAULT_CONTEXT_FIELDS = ["id_context", "name", "module", "user_name"];
-async function context(args) {
+async function context2(args) {
   const { positional, flags } = parseArgs(args);
   const [subcommand, ...rest] = positional;
   switch (subcommand) {
@@ -3974,47 +4408,47 @@ async function helpdesk(args) {
 }
 
 // src/autoupdate.ts
-var fs4 = __toESM(require("node:fs"));
-var path2 = __toESM(require("node:path"));
+var fs6 = __toESM(require("node:fs"));
+var path4 = __toESM(require("node:path"));
 var os2 = __toESM(require("node:os"));
 var https = __toESM(require("node:https"));
 var import_node_child_process2 = require("node:child_process");
-var CONFIG_DIR2 = path2.join(os2.homedir(), ".config", "reporting-bi");
-var UPDATE_CHECK_FILE = path2.join(CONFIG_DIR2, "update-check.json");
+var CONFIG_DIR2 = path4.join(os2.homedir(), ".config", "reporting-bi");
+var UPDATE_CHECK_FILE = path4.join(CONFIG_DIR2, "update-check.json");
 var CHECK_INTERVAL = 60 * 60 * 1e3;
 var PACKAGE_NAME = "@reporting-bi/cli";
 function loadUpdateCheck() {
   try {
-    return JSON.parse(fs4.readFileSync(UPDATE_CHECK_FILE, "utf-8"));
+    return JSON.parse(fs6.readFileSync(UPDATE_CHECK_FILE, "utf-8"));
   } catch {
     return { lastCheck: 0 };
   }
 }
 function saveUpdateCheck(data) {
-  fs4.mkdirSync(CONFIG_DIR2, { recursive: true });
-  fs4.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(data, null, 2));
+  fs6.mkdirSync(CONFIG_DIR2, { recursive: true });
+  fs6.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(data, null, 2));
 }
 function fetchLatestVersion() {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const req = https.get(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { timeout: 5e3 }, (res) => {
       if (res.statusCode !== 200) {
         res.resume();
-        return resolve(null);
+        return resolve3(null);
       }
       let body = "";
       res.on("data", (chunk) => body += chunk);
       res.on("end", () => {
         try {
-          resolve(JSON.parse(body).version ?? null);
+          resolve3(JSON.parse(body).version ?? null);
         } catch {
-          resolve(null);
+          resolve3(null);
         }
       });
     });
-    req.on("error", () => resolve(null));
+    req.on("error", () => resolve3(null));
     req.on("timeout", () => {
       req.destroy();
-      resolve(null);
+      resolve3(null);
     });
   });
 }
@@ -4030,6 +4464,7 @@ function isNewer(remote, local) {
   return false;
 }
 async function checkForUpdate() {
+  if (process.env.RPBI_EMBEDDED) return;
   try {
     const data = loadUpdateCheck();
     const now = Date.now();
@@ -4037,8 +4472,8 @@ async function checkForUpdate() {
     saveUpdateCheck({ lastCheck: now });
     const latest = await fetchLatestVersion();
     if (!latest) return;
-    if (!isNewer(latest, "0.0.10")) return;
-    console.log(`\x1B[33mUpdating ${PACKAGE_NAME} ${"0.0.10"} \u2192 ${latest}...\x1B[0m`);
+    if (!isNewer(latest, "0.0.11")) return;
+    console.log(`\x1B[33mUpdating ${PACKAGE_NAME} ${"0.0.11"} \u2192 ${latest}...\x1B[0m`);
     (0, import_node_child_process2.execSync)(`npm install -g ${PACKAGE_NAME}@${latest}`, { stdio: "inherit" });
     console.log(`\x1B[32mUpdated to ${latest}.\x1B[0m`);
   } catch {
@@ -4164,8 +4599,12 @@ Examples:
 
 // src/index.ts
 (async () => {
-  await checkForUpdate();
   const [command, ...args] = process.argv.slice(2);
+  if (command === "--version" || command === "-v") {
+    console.log("0.0.11");
+    return;
+  }
+  await checkForUpdate();
   switch (command) {
     case "login":
       login(args);
@@ -4189,7 +4628,7 @@ Examples:
       jobs(args);
       break;
     case "context":
-      context(args);
+      context2(args);
       break;
     case "report":
       report(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reporting-bi/cli",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "license": "UNLICENSED",
   "description": "Reporting.bi CLI — command-line interface for the Reporting.bi platform",
   "main": "./dist/index.js",