@reporting-bi/cli 0.0.9 → 0.0.11

package/dist/index.js

@@ -1055,13 +1055,13 @@ var require_implementation = __commonJS({
       if (typeof target !== "function" || toStr2.apply(target) !== funcType) {
         throw new TypeError(ERROR_MESSAGE + target);
       }
-      var args2 = slicy(arguments, 1);
+      var args = slicy(arguments, 1);
       var bound;
       var binder = function() {
         if (this instanceof bound) {
           var result = target.apply(
             this,
-            concatty(args2, arguments)
+            concatty(args, arguments)
           );
           if (Object(result) === result) {
             return result;
@@ -1070,10 +1070,10 @@ var require_implementation = __commonJS({
         }
         return target.apply(
           that,
-          concatty(args2, arguments)
+          concatty(args, arguments)
         );
       };
-      var boundLength = max(0, target.length - args2.length);
+      var boundLength = max(0, target.length - args.length);
       var boundArgs = [];
       for (var i = 0; i < boundLength; i++) {
         boundArgs[i] = "$" + i;
@@ -1144,11 +1144,11 @@ var require_call_bind_apply_helpers = __commonJS({
     var $TypeError = require_type();
     var $call = require_functionCall();
     var $actualApply = require_actualApply();
-    module2.exports = function callBindBasic(args2) {
-      if (args2.length < 1 || typeof args2[0] !== "function") {
+    module2.exports = function callBindBasic(args) {
+      if (args.length < 1 || typeof args[0] !== "function") {
         throw new $TypeError("a function is required");
       }
-      return $actualApply(bind, $call, args2);
+      return $actualApply(bind, $call, args);
     };
   }
 });
@@ -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(path2 = "", 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;
-        path2 = path2.replace(/^\//, "");
-        const parts = [this.options.baseUrl, a, this.options.name, path2];
+        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(path2, params, options) {
-        return fetch(this.createUrl(path2, params), {
+      async getRaw(path5, params, options) {
+        return fetch(this.createUrl(path5, params), {
           headers: await this.createHeaders(options?.headers),
           credentials: this.credentials
         });
       }
-      async get(path2, params, options) {
+      async get(path5, params, options) {
         if (options?.cache) {
-          const cachedData = this.cache.get({ path: path2, params });
+          const cachedData = this.cache.get({ path: path5, params });
           if (cachedData)
             return cachedData;
         }
-        const response = await this.getRaw(path2, 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: path2, params }, responseData);
+          this.cache.set({ path: path5, params }, responseData);
         }
         return responseData;
       }
-      async postRaw(path2, data, params, options) {
+      async postRaw(path5, data, params, options) {
         const json = isObject(data) || Array.isArray(data);
-        return fetch(this.createUrl(path2, 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(path2, data, params, options) {
-        const response = await this.postRaw(path2, data, params, options);
+      async post(path5, data, params, options) {
+        const response = await this.postRaw(path5, data, params, options);
         return this.handleResponse(response);
       }
-      async deleteRaw(path2, params, options) {
-        return fetch(this.createUrl(path2, 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(path2, params, options) {
-        const response = await this.deleteRaw(path2, params, options);
+      async delete(path5, params, options) {
+        const response = await this.deleteRaw(path5, params, options);
         return this.handleResponse(response);
       }
-      async putRaw(path2, data, params, options) {
+      async putRaw(path5, data, params, options) {
         const json = isObject(data) || Array.isArray(data);
-        return fetch(this.createUrl(path2, 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(path2, data, params, options) {
-        const response = await this.putRaw(path2, data, params, options);
+      async put(path5, data, params, options) {
+        const response = await this.putRaw(path5, data, params, options);
         return this.handleResponse(response);
       }
     };
@@ -3136,21 +3136,21 @@ var FLAG_ALIASES = {
   s: "sort",
   f: "filter"
 };
-function parseArgs(args2) {
+function parseArgs(args) {
   const positional = [];
   const flags = {};
-  for (let i = 0; i < args2.length; i++) {
-    if (args2[i].startsWith("--") && (i + 1 >= args2.length || args2[i + 1].startsWith("-"))) {
-      flags[args2[i].slice(2)] = "true";
-    } else if (args2[i].startsWith("--") && i + 1 < args2.length) {
-      flags[args2[i].slice(2)] = args2[i + 1];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--") && (i + 1 >= args.length || args[i + 1].startsWith("-"))) {
+      flags[args[i].slice(2)] = "true";
+    } else if (args[i].startsWith("--") && i + 1 < args.length) {
+      flags[args[i].slice(2)] = args[i + 1];
       i++;
-    } else if (args2[i].startsWith("-") && !args2[i].startsWith("--") && i + 1 < args2.length) {
-      const key = FLAG_ALIASES[args2[i].slice(1)] || args2[i].slice(1);
-      flags[key] = args2[i + 1];
+    } else if (args[i].startsWith("-") && !args[i].startsWith("--") && i + 1 < args.length) {
+      const key = FLAG_ALIASES[args[i].slice(1)] || args[i].slice(1);
+      flags[key] = args[i + 1];
       i++;
     } else {
-      positional.push(args2[i]);
+      positional.push(args[i]);
     }
   }
   return { positional, flags };
@@ -3209,8 +3209,8 @@ async function fetchAccountingName(accountingId) {
   const match = accountings?.find((a) => a.accounting === accountingId);
   return match?.company ?? null;
 }
-async function accounting(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function accounting(args) {
+  const { positional, flags } = parseArgs(args);
   const [subcommand] = positional;
   switch (subcommand) {
     case "list":
@@ -3286,16 +3286,16 @@ 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;
   const cmd = platform === "darwin" ? "open" : platform === "win32" ? 'start ""' : "xdg-open";
   (0, import_node_child_process.exec)(`${cmd} ${JSON.stringify(url)}`);
 }
-async function login(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function login(args) {
+  const { positional, flags } = parseArgs(args);
   const domain = positional[0] || "https://reporting.bi";
   const accounting2 = flags.accounting ? parseInt(flags.accounting) : void 0;
   console.log(`Logging in to ${domain}...`);
@@ -3331,12 +3331,12 @@ async function login(args2) {
   }
 }
 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");
@@ -3426,8 +3426,8 @@ function status() {
 }
 
 // src/commands/use.ts
-async function use(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function use(args) {
+  const { positional, flags } = parseArgs(args);
   const accounting2 = flags.accounting ? parseInt(flags.accounting) : void 0;
   let domain = positional[0];
   if (!domain && !accounting2) {
@@ -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.");
@@ -3525,8 +3525,8 @@ async function del(id, flags) {
   await service.delete(`page/${lang}/${id}`);
   console.log(`Page ${id} deleted.`);
 }
-async function wiki(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function wiki(args) {
+  const { positional, flags } = parseArgs(args);
   const [subcommand, ...rest] = positional;
   switch (subcommand) {
     case "list":
@@ -3564,7 +3564,433 @@ async function wiki(args2) {
 }
 
 // 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;
   }
@@ -3597,8 +4023,8 @@ async function search2(query, flags) {
   const results = await service.get("search", { ...getListParams(flags, DEFAULT_FIELDS), q: query });
   output(results || [], flags);
 }
-async function etl(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function etl(args) {
+  const { positional, flags } = parseArgs(args);
   const [subcommand, ...rest] = positional;
   switch (subcommand) {
     case "list":
@@ -3627,8 +4053,16 @@ async function etl(args2) {
         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;
   }
 }
@@ -3656,8 +4090,8 @@ async function statusCmd(flags) {
   const statuses = await service.get("jobStatuses", getListParams(flags, DEFAULT_STATUS_FIELDS));
   output(statuses || [], flags);
 }
-async function jobs(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function jobs(args) {
+  const { positional, flags } = parseArgs(args);
   const [subcommand, ...rest] = positional;
   switch (subcommand) {
     case "list":
@@ -3684,8 +4118,8 @@ async function jobs(args2) {
 
 // src/commands/analytics.ts
 var DEFAULT_CONTEXT_FIELDS = ["id_context", "name", "module", "user_name"];
-async function context(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function context2(args) {
+  const { positional, flags } = parseArgs(args);
   const [subcommand, ...rest] = positional;
   switch (subcommand) {
     case "list":
@@ -3710,8 +4144,8 @@ async function context(args2) {
       break;
   }
 }
-async function report(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function report(args) {
+  const { positional, flags } = parseArgs(args);
   const id = positional[0];
   if (!id) {
     console.error("Usage: rpbi report <context_id> [--index N]");
@@ -3722,8 +4156,8 @@ async function report(args2) {
   const result = await service.get(`report/${id}/${index}`, void 0, { parseResponse: false });
   process.stdout.write(result || "");
 }
-async function dimensions(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function dimensions(args) {
+  const { positional, flags } = parseArgs(args);
   const module2 = flags.module || flags.m;
   if (!module2) {
     console.error("Usage: rpbi dimensions --module <module>");
@@ -3733,8 +4167,8 @@ async function dimensions(args2) {
   const dims = await service.get(`visibleDimensions/${module2}`, getListParams(flags));
   output(dims || [], flags);
 }
-async function years(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function years(args) {
+  const { positional, flags } = parseArgs(args);
   const service = await createService("analytics");
   const tree = await service.get("years");
   output(tree || [], flags);
@@ -3764,8 +4198,8 @@ async function roles(flags) {
   const result = await service.get("accessRoles", getListParams(flags, DEFAULT_ROLES_FIELDS));
   output(result || [], flags);
 }
-async function users(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function users(args) {
+  const { positional, flags } = parseArgs(args);
   const [subcommand, ...rest] = positional;
   switch (subcommand) {
     case "list":
@@ -3823,8 +4257,8 @@ async function fiscalYears(flags) {
   const result = await service.get("fiscalYears", getListParams(flags));
   output(result || [], flags);
 }
-async function def(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function def(args) {
+  const { positional, flags } = parseArgs(args);
   const [subcommand, ...rest] = positional;
   switch (subcommand) {
     case "statements":
@@ -3877,8 +4311,8 @@ async function exportCsv(id, flags) {
   const result = await service.get(`export/${id}/${type}`, void 0, { parseResponse: false });
   process.stdout.write(result || "");
 }
-async function mdm(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function mdm(args) {
+  const { positional, flags } = parseArgs(args);
   const [subcommand, ...rest] = positional;
   switch (subcommand) {
     case "tables":
@@ -3947,8 +4381,8 @@ async function create(flags) {
   }
   output(result, flags);
 }
-async function helpdesk(args2) {
-  const { positional, flags } = parseArgs(args2);
+async function helpdesk(args) {
+  const { positional, flags } = parseArgs(args);
   const [subcommand, ...rest] = positional;
   switch (subcommand) {
     case "list":
@@ -3973,6 +4407,79 @@ async function helpdesk(args2) {
   }
 }
 
+// src/autoupdate.ts
+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 = 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(fs6.readFileSync(UPDATE_CHECK_FILE, "utf-8"));
+  } catch {
+    return { lastCheck: 0 };
+  }
+}
+function saveUpdateCheck(data) {
+  fs6.mkdirSync(CONFIG_DIR2, { recursive: true });
+  fs6.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(data, null, 2));
+}
+function fetchLatestVersion() {
+  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 resolve3(null);
+      }
+      let body = "";
+      res.on("data", (chunk) => body += chunk);
+      res.on("end", () => {
+        try {
+          resolve3(JSON.parse(body).version ?? null);
+        } catch {
+          resolve3(null);
+        }
+      });
+    });
+    req.on("error", () => resolve3(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve3(null);
+    });
+  });
+}
+function isNewer(remote, local) {
+  const r = remote.split(".").map(Number);
+  const l = local.split(".").map(Number);
+  for (let i = 0; i < Math.max(r.length, l.length); i++) {
+    const rv = r[i] ?? 0;
+    const lv = l[i] ?? 0;
+    if (rv > lv) return true;
+    if (rv < lv) return false;
+  }
+  return false;
+}
+async function checkForUpdate() {
+  if (process.env.RPBI_EMBEDDED) return;
+  try {
+    const data = loadUpdateCheck();
+    const now = Date.now();
+    if (now - data.lastCheck < CHECK_INTERVAL) return;
+    saveUpdateCheck({ lastCheck: now });
+    const latest = await fetchLatestVersion();
+    if (!latest) return;
+    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 {
+  }
+}
+
 // USAGE.md
 var USAGE_default = `Reporting.bi CLI
 
@@ -4091,57 +4598,64 @@ Examples:
 `;
 
 // src/index.ts
-var [command, ...args] = process.argv.slice(2);
-switch (command) {
-  case "login":
-    login(args);
-    break;
-  case "logout":
-    logout(args[0]);
-    break;
-  case "use":
-    use(args);
-    break;
-  case "wiki":
-    wiki(args);
-    break;
-  case "accounting":
-    accounting(args);
-    break;
-  case "etl":
-    etl(args);
-    break;
-  case "jobs":
-    jobs(args);
-    break;
-  case "context":
-    context(args);
-    break;
-  case "report":
-    report(args);
-    break;
-  case "dimensions":
-    dimensions(args);
-    break;
-  case "years":
-    years(args);
-    break;
-  case "users":
-    users(args);
-    break;
-  case "def":
-    def(args);
-    break;
-  case "mdm":
-    mdm(args);
-    break;
-  case "helpdesk":
-    helpdesk(args);
-    break;
-  case "status":
-    status();
-    break;
-  default:
-    console.log(USAGE_default);
-    break;
-}
+(async () => {
+  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);
+      break;
+    case "logout":
+      logout(args[0]);
+      break;
+    case "use":
+      use(args);
+      break;
+    case "wiki":
+      wiki(args);
+      break;
+    case "accounting":
+      accounting(args);
+      break;
+    case "etl":
+      etl(args);
+      break;
+    case "jobs":
+      jobs(args);
+      break;
+    case "context":
+      context2(args);
+      break;
+    case "report":
+      report(args);
+      break;
+    case "dimensions":
+      dimensions(args);
+      break;
+    case "years":
+      years(args);
+      break;
+    case "users":
+      users(args);
+      break;
+    case "def":
+      def(args);
+      break;
+    case "mdm":
+      mdm(args);
+      break;
+    case "helpdesk":
+      helpdesk(args);
+      break;
+    case "status":
+      status();
+      break;
+    default:
+      console.log(USAGE_default);
+      break;
+  }
+})();

package/package.json

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