@reporting-bi/cli 0.0.16 → 0.0.17

package/dist/index.js

@@ -9803,9 +9803,9 @@ function saveCredentials(data) {
 function findLocalConfig(startDir) {
   let dir = path.resolve(startDir || process.cwd());
   while (true) {
-    const manifestPath = path.join(dir, ".rpbi", "manifest.json");
+    const configPath = path.join(dir, ".rpbi", "config.json");
     try {
-      const data = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      const data = JSON.parse(fs.readFileSync(configPath, "utf-8"));
       if (data.domain) return { domain: data.domain, accounting: data.accounting };
     } catch {
     }
@@ -10197,7 +10197,7 @@ function status() {
   const local = findLocalConfig();
   const domains = Object.keys(creds.connections);
   if (local) {
-    console.log(`Local config (.rpbi/manifest.json):`);
+    console.log(`Local config (.rpbi/config.json):`);
     console.log(`  domain:     ${local.domain}`);
     console.log(`  accounting: ${local.accounting ?? "not set"}`);
     console.log();
@@ -10379,41 +10379,124 @@ 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";
+var CONFIG_FILE = "config.json";
+var INDEX_FILE = "index.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 getConfigPath(dir) {
+  return path2.join(dir, RPBI_DIR, CONFIG_FILE);
 }
-function readManifest(dir) {
-  const filePath = getManifestPath(dir);
+function getIndexPath(dir) {
+  return path2.join(dir, RPBI_DIR, INDEX_FILE);
+}
+function readConfig(dir) {
   try {
-    const data = fs3.readFileSync(filePath, "utf-8");
+    const data = fs3.readFileSync(getConfigPath(dir), "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
   }
 }
-function writeManifest(dir, manifest) {
+function writeConfig(dir, config2) {
   const rpbiDir = path2.join(dir, RPBI_DIR);
   fs3.mkdirSync(rpbiDir, { recursive: true });
   fs3.writeFileSync(
-    path2.join(rpbiDir, MANIFEST_FILE),
-    JSON.stringify(manifest, null, 2)
+    path2.join(rpbiDir, CONFIG_FILE),
+    JSON.stringify(config2, null, 2)
+  );
+}
+function readIndex(dir) {
+  try {
+    const data = fs3.readFileSync(getIndexPath(dir), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+function writeIndex(dir, index) {
+  const rpbiDir = path2.join(dir, RPBI_DIR);
+  fs3.mkdirSync(rpbiDir, { recursive: true });
+  fs3.writeFileSync(
+    path2.join(rpbiDir, INDEX_FILE),
+    JSON.stringify(index, null, 2)
   );
 }
 function findEtlRoot(startDir) {
   let dir = path2.resolve(startDir);
   while (true) {
-    if (fs3.existsSync(getManifestPath(dir))) return dir;
+    if (fs3.existsSync(getConfigPath(dir))) return dir;
     const parent = path2.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 
+// src/yaml.ts
+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);
+}
+
 // src/commands/etl-sync.ts
+var TYPE_DIR_NAMES = {
+  "IA": "threads_import",
+  "IM": "threads_import_manual",
+  "O": "threads_export",
+  "A": "agent_parameters",
+  "AC": "agent_config",
+  "EC": "excel_config",
+  "D": "threads_delete",
+  "L": "lists",
+  "S": "scripts"
+};
+var DIR_NAME_TYPES = Object.fromEntries(
+  Object.entries(TYPE_DIR_NAMES).map(([k, v]) => [v, k])
+);
+function typeToDirName(type) {
+  return TYPE_DIR_NAMES[type] || "unknown";
+}
+function dirNameToType(dirName) {
+  return DIR_NAME_TYPES[dirName] || null;
+}
 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"];
@@ -10466,15 +10549,15 @@ function getFilePath(description, extension = ".sql") {
 }
 function threadToRelPath(thread) {
   const segments = getFilePath(thread.description || "");
-  return [thread.type, ...segments].join("/");
+  return [typeToDirName(thread.type), ...segments].join("/");
 }
 function threadToParamPath(thread) {
   const segments = getFilePath(thread.description || "", ".yaml");
-  return [".parameters", thread.type, ...segments].join("/");
+  return [".rpbi", "parameters", typeToDirName(thread.type), ...segments].join("/");
 }
 function threadToMetaPath(thread) {
   const segments = getFilePath(thread.description || "", ".yaml");
-  return [".threads", thread.type, ...segments].join("/");
+  return [".rpbi", "threads", typeToDirName(thread.type), ...segments].join("/");
 }
 function writeFileSync4(filePath, content2) {
   fs4.mkdirSync(path3.dirname(filePath), { recursive: true });
@@ -10489,48 +10572,6 @@ function stripFields(obj, excludeFields) {
   }
   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();
@@ -10546,12 +10587,7 @@ async function pull(flags) {
     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: {}
-  };
+  const index = [];
   let pulled = 0;
   for (const thread of threads) {
     if (!thread.id_thread || !thread.type || !thread.description) continue;
@@ -10564,11 +10600,12 @@ async function pull(flags) {
         { parseResponse: false }
       ) || "";
       writeFileSync4(absPath, content2);
-      manifest.threads[relPath] = {
+      index.push({
+        path: 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) {
@@ -10608,24 +10645,30 @@ async function pull(flags) {
   if (!flags["no-context"]) {
     await pullContext(dir, etlService, defService);
   }
-  writeManifest(dir, manifest);
+  writeConfig(dir, {
+    domain: conn.domain,
+    accounting: conn.tokens.accounting,
+    pulledAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeIndex(dir, index);
   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.');
+    console.error('No .rpbi/config.json found. Run "rpbi etl pull" first.');
     process.exit(1);
   }
-  const manifest = readManifest(root);
+  const index = readIndex(root);
+  const indexMap = new Map(index.map((e) => [e.path, e]));
   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);
+    filesToPush = detectModifiedFiles(root, index);
   }
   if (filesToPush.length === 0) {
     console.log("Nothing to push.");
@@ -10639,7 +10682,7 @@ async function push(flags, files) {
       continue;
     }
     const localContent = fs4.readFileSync(absPath, "utf-8");
-    const entry = manifest.threads[relPath];
+    const entry = indexMap.get(relPath);
     if (entry) {
       if (!force) {
         try {
@@ -10657,11 +10700,16 @@ async function push(flags, files) {
         }
       }
       await etlService.post(`threadContent/${entry.id_thread}`, localContent);
-      manifest.threads[relPath].hash = computeHash(localContent);
+      entry.hash = computeHash(localContent);
       console.log(`  Updated: ${relPath}`);
     } else {
       const parts = relPath.split("/");
-      const type = parts[0];
+      const dirName = parts[0];
+      const type = dirNameToType(dirName);
+      if (!type) {
+        console.error(`  Unknown thread type directory: ${dirName}`);
+        continue;
+      }
       const description = parts.slice(1).join("/").replace(/\.sql$/, "");
       const newThread = await etlService.post("threads", {
         type,
@@ -10670,22 +10718,23 @@ async function push(flags, files) {
       });
       if (newThread?.id_thread) {
         await etlService.post(`threadContent/${newThread.id_thread}`, localContent);
-        manifest.threads[relPath] = {
+        index.push({
+          path: 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);
+  writeIndex(path3.resolve(root), index);
   console.log("Push complete.");
 }
 async function pullContext(dir, etlService, defService) {
-  const contextDir = path3.join(dir, ".context");
+  const contextDir = path3.join(dir, ".rpbi", "context");
   console.log("Pulling context (schema & modules)...");
   try {
     const modules2 = await defService.get("accountingModules");
@@ -10722,39 +10771,40 @@ async function context(flags) {
   await pullContext(dir, etlService, defService);
   console.log("Context pull complete.");
 }
-function detectModifiedFiles(root, manifest) {
+function detectModifiedFiles(root, index) {
   const modified = [];
-  for (const [relPath, entry] of Object.entries(manifest.threads)) {
-    const absPath = path3.join(root, relPath);
+  for (const entry of index) {
+    const absPath = path3.join(root, entry.path);
     if (!fs4.existsSync(absPath)) {
-      modified.push(relPath);
+      modified.push(entry.path);
       continue;
     }
     const content2 = fs4.readFileSync(absPath, "utf-8");
     if (computeHash(content2) !== entry.hash) {
-      modified.push(relPath);
+      modified.push(entry.path);
     }
   }
   return modified;
 }
-function detectNewFiles(root, manifest) {
+function detectNewFiles(root, index) {
   const newFiles = [];
+  const knownPaths = new Set(index.map((e) => e.path));
   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);
+    walkDir(path3.join(root, entry.name), root, knownPaths, newFiles);
   }
   return newFiles;
 }
-function walkDir(dir, root, manifest, result) {
+function walkDir(dir, root, knownPaths, 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);
+      walkDir(full, root, knownPaths, result);
     } else if (entry.name.endsWith(".sql")) {
       const rel = path3.relative(root, full);
-      if (!manifest.threads[rel]) {
+      if (!knownPaths.has(rel)) {
         result.push(rel);
       }
     }
@@ -10764,16 +10814,17 @@ 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.');
+    console.error('No .rpbi/config.json found. Run "rpbi etl pull" first.');
     process.exit(1);
   }
-  const manifest = readManifest(root);
+  const config2 = readConfig(root);
+  const index = readIndex(root);
   console.log(`ETL workspace: ${root}`);
-  console.log(`Domain: ${manifest.domain} | Accounting: ${manifest.accounting}`);
-  console.log(`Pulled at: ${manifest.pulledAt}`);
+  console.log(`Domain: ${config2?.domain} | Accounting: ${config2?.accounting}`);
+  console.log(`Pulled at: ${config2?.pulledAt}`);
   console.log("");
-  const modified = detectModifiedFiles(root, manifest);
-  const newFiles = detectNewFiles(root, manifest);
+  const modified = detectModifiedFiles(root, index);
+  const newFiles = detectNewFiles(root, index);
   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) {
@@ -34395,7 +34446,7 @@ function text(data) {
 async function mcp() {
   const server = new McpServer({
     name: "reporting-bi",
-    version: "0.0.16"
+    version: "0.0.17"
   });
   server.tool(
     "status",
@@ -34845,17 +34896,16 @@ function init(args) {
     console.error(`Not logged in to "${domain2}". Run "rpbi login ${domain2}" first.`);
     process.exit(1);
   }
-  const existing = readManifest(process.cwd());
-  const manifest = {
+  const existing = readConfig(process.cwd());
+  const config2 = {
     domain: domain2,
     accounting: flags.accounting ? parseInt(flags.accounting) : existing?.accounting ?? creds.connections[domain2].accounting ?? 0,
-    ...existing?.pulledAt && { pulledAt: existing.pulledAt },
-    ...existing?.threads && { threads: existing.threads }
+    ...existing?.pulledAt && { pulledAt: existing.pulledAt }
   };
-  writeManifest(process.cwd(), manifest);
-  console.log(`Initialized .rpbi/manifest.json`);
-  console.log(`  domain:     ${manifest.domain}`);
-  console.log(`  accounting: ${manifest.accounting || "not set"}`);
+  writeConfig(process.cwd(), config2);
+  console.log(`Initialized .rpbi/config.json`);
+  console.log(`  domain:     ${config2.domain}`);
+  console.log(`  accounting: ${config2.accounting || "not set"}`);
 }
 
 // src/autoupdate.ts
@@ -34937,8 +34987,8 @@ async function checkForUpdate() {
     saveUpdateCheck({ lastCheck: now });
     const latest = await fetchLatestVersion();
     if (!latest) return;
-    if (!isNewer(latest, "0.0.16")) return;
-    console.log(`\x1B[33mUpdating ${PACKAGE_NAME} ${"0.0.16"} \u2192 ${latest}...\x1B[0m`);
+    if (!isNewer(latest, "0.0.17")) return;
+    console.log(`\x1B[33mUpdating ${PACKAGE_NAME} ${"0.0.17"} \u2192 ${latest}...\x1B[0m`);
     (0, import_node_child_process2.execSync)(npmInstallCmd(latest), { stdio: "inherit" });
     console.log(`\x1B[32mUpdated to ${latest}.\x1B[0m`);
   } catch {
@@ -34950,11 +35000,11 @@ async function forceUpdate() {
     console.error("Could not fetch latest version from npm.");
     process.exit(1);
   }
-  if (!isNewer(latest, "0.0.16")) {
-    console.log(`Already up to date (${"0.0.16"}).`);
+  if (!isNewer(latest, "0.0.17")) {
+    console.log(`Already up to date (${"0.0.17"}).`);
     return;
   }
-  console.log(`Updating ${PACKAGE_NAME} ${"0.0.16"} \u2192 ${latest}...`);
+  console.log(`Updating ${PACKAGE_NAME} ${"0.0.17"} \u2192 ${latest}...`);
   (0, import_node_child_process2.execSync)(npmInstallCmd(latest), { stdio: "inherit" });
   console.log(`\x1B[32mUpdated to ${latest}.\x1B[0m`);
   saveUpdateCheck({ lastCheck: Date.now() });
@@ -34983,6 +35033,10 @@ ETL:
   etl content <id>                      Get thread SQL content (plain text)
   etl exec <id> [--sql "..."|--file f]  Execute thread (optionally with custom SQL)
   etl search <query>                    Search threads
+  etl pull [--dir <path>] [--no-context]  Pull all ETL threads, parameters, metadata & schema to local files
+  etl push [files...] [--dir <path>] [--force]  Push modified/new .sql files back to server
+  etl status [--dir <path>]             Show local changes (modified, new, deleted)
+  etl context [--dir <path>]            Pull context only (schema & modules)
 
 Jobs:
   jobs list                             List available jobs
@@ -35052,6 +35106,10 @@ Examples:
   rpbi etl list
   rpbi etl exec 42
   rpbi etl content 42
+  rpbi etl pull
+  rpbi etl push
+  rpbi etl push IA/folder/script.sql
+  rpbi etl status
 
   rpbi jobs list
   rpbi jobs start "My Job"
@@ -35084,7 +35142,7 @@ Examples:
 (async () => {
   const [command, ...args] = process.argv.slice(2);
   if (command === "--version" || command === "-v") {
-    console.log("0.0.16");
+    console.log("0.0.17");
     return;
   }
   await checkForUpdate();

package/package.json

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