@restoai/resto-datacli 0.1.12 → 0.2.1

package/dist/commands/knowledge.js

@@ -1,9 +1,10 @@
 import { Command } from "commander";
 import { AuthStore } from "../config/auth-store.js";
 import { LocalKnowledgeStore } from "../knowledge/local-store.js";
-import { ManifestClient } from "../knowledge/manifest-client.js";
+import { KnowledgeManifestError, ManifestClient } from "../knowledge/manifest-client.js";
 import { KnowledgeSyncService } from "../knowledge/sync-service.js";
 import { failJson, printJson } from "./json-command.js";
+const DEFAULT_REPORT_CLI_SERVICE_URL = "http://127.0.0.1:18081";
 function parseSchemaVersion(write, value) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) || parsed <= 0 || String(parsed) !== value) {
@@ -23,8 +24,14 @@ function createDefaultSyncService(localRoot, profile, baseUrl, factory) {
         })
     });
 }
-function resolveManifestBaseUrl(profile) {
-    return profile.baseUrl;
+function resolveManifestBaseUrl(reportCliUrl) {
+    return reportCliUrl || process.env.RESTO_REPORT_CLI_URL || DEFAULT_REPORT_CLI_SERVICE_URL;
+}
+function failKnowledgeError(write, error) {
+    if (error instanceof KnowledgeManifestError) {
+        failJson(write, error.code, error.message);
+    }
+    failJson(write, "KNOWLEDGE_ERROR", "knowledge command failed");
 }
 export function createKnowledgeCommand(options = {}) {
     const write = options.write ?? ((message) => process.stdout.write(message));
@@ -44,6 +51,7 @@ export function createKnowledgeCommand(options = {}) {
         .description("Sync local knowledge artifacts")
         .option("--env <env>", "Knowledge environment", "test")
         .option("--schema-version <version>", "Knowledge schema version", "1")
+        .option("--report-cli-url <url>", "report-cli-service base URL for knowledge manifest", process.env.RESTO_REPORT_CLI_URL ?? DEFAULT_REPORT_CLI_SERVICE_URL)
         .option("--fixture", "Sync bundled local fixture knowledge without remote services or auth")
         .allowExcessArguments(false)
         .action(async (rawOptions) => {
@@ -57,18 +65,24 @@ export function createKnowledgeCommand(options = {}) {
                 if (!profile) {
                     failJson(write, "AUTH_NOT_CONFIGURED", "Authentication profile is not configured. Run resto auth login first.");
                 }
-                return createDefaultSyncService(options.localRoot, profile, resolveManifestBaseUrl(profile), options.createKnowledgeSyncService);
+                return createDefaultSyncService(options.localRoot, profile, resolveManifestBaseUrl(rawOptions.reportCliUrl), options.createKnowledgeSyncService);
             })();
-        printJson(write, await service.sync({
-            env: rawOptions.env,
-            schemaVersion
-        }));
+        try {
+            printJson(write, await service.sync({
+                env: rawOptions.env,
+                schemaVersion
+            }));
+        }
+        catch (error) {
+            failKnowledgeError(write, error);
+        }
     });
     knowledge
         .command("check")
         .description("Check whether local knowledge is stale against the remote manifest")
         .option("--env <env>", "Knowledge environment", "test")
         .option("--schema-version <version>", "Knowledge schema version", "1")
+        .option("--report-cli-url <url>", "report-cli-service base URL for knowledge manifest", process.env.RESTO_REPORT_CLI_URL ?? DEFAULT_REPORT_CLI_SERVICE_URL)
         .option("--fixture", "Check bundled local fixture knowledge without remote services or auth")
         .allowExcessArguments(false)
         .action(async (rawOptions) => {
@@ -82,12 +96,17 @@ export function createKnowledgeCommand(options = {}) {
                 if (!profile) {
                     failJson(write, "AUTH_NOT_CONFIGURED", "Authentication profile is not configured. Run resto auth login first.");
                 }
-                return createDefaultSyncService(options.localRoot, profile, resolveManifestBaseUrl(profile), options.createKnowledgeSyncService);
+                return createDefaultSyncService(options.localRoot, profile, resolveManifestBaseUrl(rawOptions.reportCliUrl), options.createKnowledgeSyncService);
             })();
-        printJson(write, await service.check({
-            env: rawOptions.env,
-            schemaVersion
-        }));
+        try {
+            printJson(write, await service.check({
+                env: rawOptions.env,
+                schemaVersion
+            }));
+        }
+        catch (error) {
+            failKnowledgeError(write, error);
+        }
     });
     return knowledge;
 }

package/dist/commands/order.js

@@ -0,0 +1,109 @@
+import { Command } from "commander";
+import { AuthStore } from "../config/auth-store.js";
+import { ReportApiError, ReportCliServiceClient } from "../report-api/report-api-client.js";
+import { configureJsonParseErrors, failJson, parsePositiveIntegerArgument, printJson } from "./json-command.js";
+const DEFAULT_REPORT_CLI_SERVICE_URL = "http://127.0.0.1:18081";
+const MAX_POS_ORDER_BUSINESS_DATE_RANGE_DAYS = 31;
+function requiredOption(write, value, optionName) {
+    if (!value) {
+        failJson(write, "INVALID_ARGUMENTS", `Missing required option: ${optionName}`);
+    }
+    return value;
+}
+function resolveReportCliUrl(options, auth, explicitUrl) {
+    return explicitUrl
+        ?? options.reportCliUrl
+        ?? process.env.RESTO_REPORT_CLI_URL
+        ?? auth.baseUrl
+        ?? DEFAULT_REPORT_CLI_SERVICE_URL;
+}
+function safeErrorMessage(error, token) {
+    const message = error instanceof ReportApiError || error instanceof Error
+        ? error.message
+        : "report-cli-service order detail request failed";
+    return message.split(token).join("***").replace(/\s+/g, " ").trim().slice(0, 240);
+}
+function parseBusinessDate(write, value, optionName) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        failJson(write, "INVALID_ARGUMENTS", `${optionName} must use YYYY-MM-DD.`);
+    }
+    const [year, month, day] = value.split("-").map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
+        failJson(write, "INVALID_ARGUMENTS", `${optionName} must be a valid calendar date.`);
+    }
+    return date;
+}
+function resolvePosOrderBusinessDateRange(write, rawOptions) {
+    const businessDateStart = requiredOption(write, rawOptions.businessDateStart?.trim(), "--business-date-start");
+    const businessDateEnd = requiredOption(write, rawOptions.businessDateEnd?.trim(), "--business-date-end");
+    const start = parseBusinessDate(write, businessDateStart, "--business-date-start");
+    const end = parseBusinessDate(write, businessDateEnd, "--business-date-end");
+    if (start > end) {
+        failJson(write, "INVALID_ARGUMENTS", "--business-date-start must not be after --business-date-end.");
+    }
+    const rangeDays = Math.floor((end.getTime() - start.getTime()) / 86_400_000) + 1;
+    if (rangeDays > MAX_POS_ORDER_BUSINESS_DATE_RANGE_DAYS) {
+        failJson(write, "INVALID_ARGUMENTS", "POS order business date range must not exceed 31 days.");
+    }
+    return { businessDateStart, businessDateEnd };
+}
+export function createOrderCommand(options = {}) {
+    const write = options.write ?? ((message) => process.stdout.write(message));
+    const order = new Command("order").description("Query protected order drilldown details");
+    order
+        .command("detail")
+        .description("Get rendered order detail by POS order id or internal order id")
+        .requiredOption("--report-id <id>", "Authorized main report id, for example 888002")
+        .option("--pos-order-id <id>", "POS order id")
+        .option("--order-id <id>", "Internal order id")
+        .option("--business-date-start <date>", "Business date start for POS order id (YYYY-MM-DD)")
+        .option("--business-date-end <date>", "Business date end for POS order id (YYYY-MM-DD)")
+        .option("--report-cli-url <url>", "report-cli-service gateway base URL")
+        .allowExcessArguments(false)
+        .action(async (rawOptions) => {
+        const auth = new AuthStore(options.localRoot).load();
+        if (!auth) {
+            failJson(write, "AUTH_NOT_CONFIGURED", "No local auth profile found. Run resto auth login first.");
+        }
+        const reportId = parsePositiveIntegerArgument(write, "--report-id", requiredOption(write, rawOptions.reportId, "--report-id"));
+        const posOrderId = rawOptions.posOrderId?.trim();
+        const orderId = rawOptions.orderId?.trim();
+        if (Boolean(posOrderId) === Boolean(orderId)) {
+            failJson(write, "INVALID_ARGUMENTS", "Pass exactly one of --pos-order-id and --order-id.");
+        }
+        const businessDateRange = posOrderId
+            ? resolvePosOrderBusinessDateRange(write, rawOptions)
+            : undefined;
+        if (!posOrderId && (rawOptions.businessDateStart || rawOptions.businessDateEnd)) {
+            failJson(write, "INVALID_ARGUMENTS", "Business date options are only supported with --pos-order-id.");
+        }
+        const request = {
+            reportId,
+            ...(posOrderId ? { posOrderId } : {}),
+            ...(orderId ? { orderId } : {}),
+            ...(businessDateRange ?? {})
+        };
+        const baseUrl = resolveReportCliUrl(options, auth, rawOptions.reportCliUrl);
+        const client = options.orderDetailClient
+            ?? options.createOrderDetailClient?.(auth, baseUrl)
+            ?? new ReportCliServiceClient({ auth, baseUrl });
+        let response;
+        try {
+            response = await client.getReportOrderDetail(request);
+        }
+        catch (error) {
+            failJson(write, "REPORT_API_ERROR", safeErrorMessage(error, auth.token));
+        }
+        printJson(write, {
+            source: "/api/report-cli/report/order/detail",
+            reportId: response.reportId,
+            shopId: response.shopId,
+            posOrderId: response.posOrderId,
+            orderId: response.orderId,
+            detail: response.detail
+        });
+    });
+    configureJsonParseErrors(order, write);
+    return order;
+}

package/dist/commands/public-records.js

@@ -46,6 +46,36 @@ function toPublicReportCompositionRecord(composition) {
         source: composition.source
     };
 }
+function toPublicReportMetricsByDimRecord(record) {
+    return {
+        reportId: record.reportId,
+        sourceReportId: record.sourceReportId,
+        modelId: record.modelId,
+        dimensionFieldName: record.dimensionFieldName,
+        dimensionDisplayText: record.dimensionDisplayText,
+        onlyMetricsByDim: record.onlyMetricsByDim,
+        disableMetricsByDim: record.disableMetricsByDim,
+        metricFieldNames: record.metricFieldNames,
+        defaultMetricFieldNames: record.defaultMetricFieldNames,
+        source: record.source
+    };
+}
+function toPublicReportMergedHeadRecord(record) {
+    return {
+        reportId: record.reportId,
+        sourceReportId: record.sourceReportId,
+        modelId: record.modelId,
+        mergedHeadId: record.mergedHeadId,
+        defaultSortIndex: record.defaultSortIndex,
+        primaryHeadMetricsCode: record.primaryHeadMetricsCode,
+        subHeadIsDynamic: record.subHeadIsDynamic,
+        subHeadMetricsCodes: record.subHeadMetricsCodes,
+        subHeadByDimCode: record.subHeadByDimCode,
+        displaySubTotal: record.displaySubTotal,
+        subTotalMetricsCode: record.subTotalMetricsCode,
+        source: record.source
+    };
+}
 function toPublicReportQueryPlanRecord(plan) {
     return {
         reportId: plan.reportId,
@@ -100,6 +130,8 @@ export function toPublicReportRecord(report) {
         ...(report.routeMap ? { routeMap: report.routeMap.map(toPublicReportRouteMapRecord) } : {}),
         ...(report.menuTree ? { menuTree: report.menuTree.map(toPublicReportMenuTreeRecord) } : {}),
         ...(report.composition ? { composition: toPublicReportCompositionRecord(report.composition) } : {}),
+        ...(report.metricsByDim ? { metricsByDim: report.metricsByDim.map(toPublicReportMetricsByDimRecord) } : {}),
+        ...(report.mergedHeads ? { mergedHeads: report.mergedHeads.map(toPublicReportMergedHeadRecord) } : {}),
         ...(report.queryPlans ? { queryPlans: report.queryPlans.map(toPublicReportQueryPlanRecord) } : {}),
         ...(report.filterSurfaces ? { filterSurfaces: report.filterSurfaces.map(toPublicReportFilterSurfaceRecord) } : {}),
         ...(report.entityBindings ? { entityBindings: report.entityBindings.map(toPublicReportEntityBindingRecord) } : {})

package/dist/commands/query.js

@@ -2,10 +2,11 @@ import { readFileSync } from "node:fs";
 import { Command } from "commander";
 import { AuthStore } from "../config/auth-store.js";
 import { SearchIndex } from "../knowledge/search-index.js";
-import { ReportApiClient, ReportApiError } from "../report-api/report-api-client.js";
+import { ReportApiError, ReportCliServiceClient } from "../report-api/report-api-client.js";
 import { normalizeExecutableQueryPlan, parseQueryPlan, QueryPlanValidator } from "../report-api/query-plan.js";
 import { SnapshotStore } from "../snapshot/snapshot-store.js";
 import { configureJsonParseErrors, failJson, failMissingKnowledge, JsonCommandError, jsonError, printJson } from "./json-command.js";
+const DEFAULT_REPORT_CLI_SERVICE_URL = "http://127.0.0.1:18081";
 function parseSchemaVersion(write, value) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) || parsed <= 0 || String(parsed) !== value) {
@@ -57,9 +58,23 @@ function throwValidationError(write, validation) {
 function failReportApiError(write, error) {
     const message = error instanceof ReportApiError
         ? error.message
-        : "Report API request failed";
+        : "report-cli-service request failed";
     failJson(write, "REPORT_API_ERROR", message);
 }
+function parseQueryBackend(write, value) {
+    const backend = value || "report-cli-service";
+    if (backend === "report-cli-service") {
+        return backend;
+    }
+    if (backend === "report-api") {
+        failJson(write, "INVALID_ARGUMENTS", "Direct report-api query backend is not allowed. Use report-cli-service.");
+    }
+    failJson(write, "INVALID_ARGUMENTS", "Invalid query backend. Expected report-cli-service.");
+}
+function createQueryDataClient(options, auth, reportCliUrl) {
+    const baseUrl = reportCliUrl || DEFAULT_REPORT_CLI_SERVICE_URL;
+    return options.reportCliServiceClient ?? options.createReportCliServiceClient?.(auth, baseUrl) ?? new ReportCliServiceClient({ auth, baseUrl });
+}
 function schemaFromValidation(validation, response) {
     if (response.schema.length > 0) {
         return response.schema;
@@ -95,7 +110,7 @@ Examples:
   resto query validate --plan ./plan.json
   resto query execute --plan ./plan.json
 
-Field names inside plans must use exact report field codes required by report-api.
+Field names inside plans must use exact report field codes required by the report service.
 `);
     query
         .command("validate")
@@ -115,6 +130,8 @@ Field names inside plans must use exact report field codes required by report-ap
         .option("--plan <path>", "Query plan JSON file")
         .option("--env <env>", "Knowledge environment", options.env ?? "test")
         .option("--schema-version <version>", "Knowledge schema version", "1")
+        .option("--backend <backend>", "Execution backend: report-cli-service", process.env.RESTO_QUERY_BACKEND ?? "report-cli-service")
+        .option("--report-cli-url <url>", "report-cli-service base URL for query execution", process.env.RESTO_REPORT_CLI_URL ?? DEFAULT_REPORT_CLI_SERVICE_URL)
         .allowExcessArguments(false)
         .action(async (rawOptions) => {
         const plan = readPlanFile(requireOption(write, rawOptions.plan, "--plan"), write);
@@ -128,7 +145,8 @@ Field names inside plans must use exact report field codes required by report-ap
         if (!auth) {
             failJson(write, "AUTH_NOT_CONFIGURED", "No local auth profile found. Run resto auth login first.");
         }
-        const client = options.reportApiClient ?? options.createReportApiClient?.(auth) ?? new ReportApiClient({ auth });
+        parseQueryBackend(write, rawOptions.backend);
+        const client = createQueryDataClient(options, auth, rawOptions.reportCliUrl);
         let response;
         try {
             response = await client.queryData(parsedPlan, { env: rawOptions.env, schemaVersion });

package/dist/commands/shop.js

@@ -1,7 +1,8 @@
 import { Command } from "commander";
 import { AuthStore } from "../config/auth-store.js";
-import { ReportApiClient, ReportApiError } from "../report-api/report-api-client.js";
+import { ReportApiError, ReportCliServiceClient } from "../report-api/report-api-client.js";
 import { configureJsonParseErrors, failJson, parsePositiveIntegerArgument, printJson } from "./json-command.js";
+const DEFAULT_REPORT_CLI_SERVICE_URL = "http://127.0.0.1:18081";
 function requireOption(write, value, optionName) {
     if (!value) {
         failJson(write, "INVALID_ARGUMENTS", `Missing required option: ${optionName}. Pass it explicitly or save report context with auth login.`);
@@ -47,23 +48,76 @@ function filterShops(response, query, limit) {
         .sort((left, right) => left.score - right.score || left.index - right.index);
     return scored.slice(0, limit).map((item) => item.shop);
 }
-function failReportApiError(write, error) {
+function stringValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return String(value);
+    }
+    return undefined;
+}
+function redactSensitiveText(value, sensitiveValues) {
+    return sensitiveValues.reduce((result, sensitiveValue) => {
+        if (!sensitiveValue) {
+            return result;
+        }
+        return result.split(sensitiveValue).join("***");
+    }, value);
+}
+function safeErrorDetail(error, sensitiveValues) {
+    const details = [];
+    collectErrorDetails(error, details, new Set());
+    const detail = details.join(": ").replace(/\s+/g, " ").trim();
+    return detail ? redactSensitiveText(detail, sensitiveValues).slice(0, 240) : undefined;
+}
+function collectErrorDetails(error, details, seen) {
+    if (error === null || error === undefined || seen.has(error)) {
+        return;
+    }
+    seen.add(error);
+    if (error instanceof Error && error.message) {
+        details.push(error.message);
+    }
+    if (typeof error !== "object") {
+        return;
+    }
+    const record = error;
+    const causeParts = [record.code, record.syscall, record.address, record.port].flatMap((value) => {
+        const text = stringValue(value);
+        return text ? [text] : [];
+    });
+    if (causeParts.length > 0) {
+        details.push(causeParts.join(" "));
+    }
+    collectErrorDetails(record.cause, details, seen);
+    if (Array.isArray(record.errors)) {
+        for (const nestedError of record.errors.slice(0, 3)) {
+            collectErrorDetails(nestedError, details, seen);
+        }
+    }
+}
+function failReportServiceError(write, error, sensitiveValues = []) {
     const status = error instanceof ReportApiError ? error.status : undefined;
-    const message = status === undefined ? "Report API request failed" : `Report API request failed with status ${status}`;
-    failJson(write, "REPORT_API_ERROR", message);
+    const message = status === undefined ? "report-cli-service request failed" : `report-cli-service request failed with status ${status}`;
+    const detail = safeErrorDetail(error, sensitiveValues);
+    failJson(write, "REPORT_API_ERROR", `${message}${detail ? `: ${detail}` : ""}`);
+}
+function createShopFiltersClient(options, auth, reportCliUrl) {
+    const baseUrl = reportCliUrl || options.reportCliUrl || DEFAULT_REPORT_CLI_SERVICE_URL;
+    return options.shopFiltersClient ?? options.createShopFiltersClient?.(auth, baseUrl) ?? new ReportCliServiceClient({ auth, baseUrl });
 }
 export function createShopCommand(options = {}) {
     const write = options.write ?? ((message) => process.stdout.write(message));
-    const shop = new Command("shop").description("Search authorized report shop filters from report-api");
+    const shop = new Command("shop").description("Search authorized report shop filters from report-cli-service");
     shop
         .command("search")
         .description("Search online authorized shops by name or ID")
         .argument("<query...>", "Shop name or ID")
-        .option("--employee-code <code>", "Employee code for permission filtering")
-        .option("--organization-id <id>", "Organization ID for permission filtering")
         .option("--org-type-list <list>", "Comma-separated organization type list")
-        .option("--organization-type <type>", "Organization-Type request header")
-        .option("--report-id <id>", "Report ID used by report-api shop filtering")
+        .option("--organization-type <type>", "Organization type used by report permission context")
+        .option("--report-id <id>", "Report ID used by report-cli-service shop filtering")
+        .option("--report-cli-url <url>", "report-cli-service base URL for shop filters", process.env.RESTO_REPORT_CLI_URL ?? options.reportCliUrl ?? DEFAULT_REPORT_CLI_SERVICE_URL)
         .option("--limit <n>", "Maximum number of matches", "20")
         .allowExcessArguments(false)
         .action(async (queryParts, rawOptions) => {
@@ -75,26 +129,24 @@ export function createShopCommand(options = {}) {
         }
         const savedContext = auth.reportContext;
         const request = {
-            employeeCode: requireOption(write, rawOptions.employeeCode ?? savedContext?.employeeCode, "--employee-code"),
-            organizationId: requireOption(write, rawOptions.organizationId ?? savedContext?.organizationId, "--organization-id"),
             orgTypeList: rawOptions.orgTypeList
                 ? parseIntegerList(write, "--org-type-list", rawOptions.orgTypeList)
                 : requireOption(write, savedContext?.orgTypeList, "--org-type-list"),
             organizationType: requireOption(write, rawOptions.organizationType ?? savedContext?.organizationType, "--organization-type"),
             ...(rawOptions.reportId ? { reportId: parsePositiveIntegerArgument(write, "--report-id", rawOptions.reportId) } : {})
         };
-        const client = options.shopApiClient ?? options.createShopApiClient?.(auth) ?? new ReportApiClient({ auth });
+        const client = createShopFiltersClient(options, auth, rawOptions.reportCliUrl);
         let response;
         try {
             response = await client.getReportShopFilters(request);
         }
         catch (error) {
-            failReportApiError(write, error);
+            failReportServiceError(write, error, [auth.token]);
         }
         const matches = filterShops(response, query, limit);
         printJson(write, {
             query,
-            source: "/api/report/merchant/getReportShopFilters",
+            source: "/api/report-cli/shop/filters",
             ...(request.reportId === undefined ? {} : { reportId: request.reportId }),
             shopFilterType: response.shopFilterType,
             totalAuthorizedShops: response.shops.length,

package/dist/config/profile.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 const authProfileSchema = z.object({
     baseUrl: z.string().min(1),
+    plat: z.string().min(1).optional(),
     token: z.string().min(1),
     corporationId: z.string().min(1),
     languageCode: z.string().min(1),

package/dist/knowledge/local-store.js

@@ -16,6 +16,8 @@ const artifactFileNames = {
     reportMenuTree: "report-menu-tree.jsonl",
     reportCompositions: "report-compositions.jsonl",
     reportMergedFields: "report-merged-fields.jsonl",
+    reportMetricsByDim: "report-metrics-by-dim.jsonl",
+    reportMergedHeads: "report-merged-heads.jsonl",
     reportQueryPlans: "report-query-plans.jsonl",
     reportFilterSurfaces: "report-filter-surfaces.jsonl",
     reportEntityBindings: "report-entity-bindings.jsonl",

package/dist/knowledge/manifest-client.js

@@ -1,5 +1,52 @@
 import { fetch } from "undici";
 import { parseKnowledgeManifest } from "./schema.js";
+export class KnowledgeManifestError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "KnowledgeManifestError";
+        this.code = code;
+    }
+}
+function stringValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return String(value);
+    }
+    return undefined;
+}
+function redactSensitiveText(value, sensitiveValues) {
+    return sensitiveValues.reduce((result, sensitiveValue) => {
+        if (!sensitiveValue) {
+            return result;
+        }
+        return result.split(sensitiveValue).join("***");
+    }, value);
+}
+function sanitizeRemoteMessage(value, sensitiveValues) {
+    const message = stringValue(value);
+    if (!message) {
+        return undefined;
+    }
+    return redactSensitiveText(message.replace(/\s+/g, " ").trim(), sensitiveValues).slice(0, 240);
+}
+function throwIfBusinessError(payload, sensitiveValues) {
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        return;
+    }
+    const body = payload;
+    const success = typeof body.success === "boolean" ? body.success : undefined;
+    const code = stringValue(body.errorCode ?? body.code);
+    const okCode = !code || code === "0" || code === "000";
+    if (okCode && success !== false) {
+        return;
+    }
+    const safeCode = code || "KNOWLEDGE_MANIFEST_ERROR";
+    const message = sanitizeRemoteMessage(body.message ?? body.msg ?? body.errorMessage, sensitiveValues);
+    throw new KnowledgeManifestError(safeCode, `Knowledge manifest request failed with code ${safeCode}${message ? `: ${message}` : ""}`);
+}
 function unwrapManifestPayload(payload) {
     if (payload && typeof payload === "object" && "data" in payload) {
         return payload.data;
@@ -16,7 +63,7 @@ export class ManifestClient {
         this.fetchImpl = options.fetchImpl ?? fetch;
     }
     async fetchManifest(request) {
-        const response = await this.fetchImpl(`${this.baseUrl}/api/knowledge/manifest`, {
+        const response = await this.fetchImpl(`${this.baseUrl}/api/report-cli/knowledge/manifest`, {
             method: "POST",
             headers: {
                 "corporation-id": this.profile.corporationId,
@@ -32,8 +79,10 @@ export class ManifestClient {
             })
         });
         if (!response.ok) {
-            throw new Error(`Knowledge manifest request failed: ${response.status} ${response.statusText}`.trim());
+            throw new KnowledgeManifestError("KNOWLEDGE_MANIFEST_HTTP_ERROR", `Knowledge manifest request failed: ${response.status} ${response.statusText}`.trim());
         }
-        return parseKnowledgeManifest(unwrapManifestPayload(await response.json()));
+        const payload = await response.json();
+        throwIfBusinessError(payload, [this.profile.token]);
+        return parseKnowledgeManifest(unwrapManifestPayload(payload));
     }
 }

package/dist/knowledge/schema.js

@@ -10,6 +10,8 @@ export const knowledgeArtifactTypes = [
     "reportMenuTree",
     "reportCompositions",
     "reportMergedFields",
+    "reportMetricsByDim",
+    "reportMergedHeads",
     "reportQueryPlans",
     "reportFilterSurfaces",
     "reportEntityBindings",

package/dist/knowledge/search-index.js

@@ -82,6 +82,34 @@ const reportMergedFieldRecordSchema = fieldRecordSchema.extend({
     aliases: z.array(z.string()),
     tags: z.array(z.string())
 });
+const reportMetricsByDimRecordSchema = z.object({
+    reportId: z.number().int().positive(),
+    sourceReportId: z.number().int().positive(),
+    modelId: z.number().int().positive(),
+    dimensionFieldName: z.string().min(1),
+    dimensionDisplayText: z.string().min(1),
+    onlyMetricsByDim: z.boolean(),
+    disableMetricsByDim: z.boolean(),
+    metricFieldNames: z.array(z.string().min(1)),
+    defaultMetricFieldNames: z.array(z.string().min(1)),
+    rawMetricsByDimConfig: z.string().nullable().optional(),
+    source: z.string().min(1)
+});
+const reportMergedHeadRecordSchema = z.object({
+    reportId: z.number().int().positive(),
+    sourceReportId: z.number().int().positive(),
+    modelId: z.number().int().positive(),
+    mergedHeadId: z.string().min(1),
+    defaultSortIndex: z.number().int(),
+    primaryHeadMetricsCode: z.string().min(1).nullable().optional(),
+    subHeadIsDynamic: z.boolean(),
+    subHeadMetricsCodes: z.array(z.string().min(1)),
+    subHeadByDimCode: z.string().min(1).nullable().optional(),
+    displaySubTotal: z.boolean(),
+    subTotalMetricsCode: z.string().min(1).nullable().optional(),
+    rawMergedHeadConfig: z.string().min(1),
+    source: z.string().min(1)
+});
 const reportQueryPlanRecordSchema = z.object({
     reportId: z.number().int(),
     planId: z.string().min(1),
@@ -385,6 +413,12 @@ function localizeReportFilterSurfaceRecord(surface, translations) {
         ...(aliases ? { aliases } : {})
     };
 }
+function localizeReportMetricsByDimRecord(record, translations) {
+    return {
+        ...record,
+        dimensionDisplayText: translations.get(record.dimensionFieldName) ?? localizeText(record.dimensionDisplayText, translations)
+    };
+}
 function rankByMatch(query, exactIdentifier, exactText, substringFields, overlapFields) {
     const trimmedQuery = query.trim();
     const normalizedQuery = normalizeText(query);
@@ -455,6 +489,8 @@ export class SearchIndex {
     reportMenuTree;
     reportCompositions;
     reportMergedFields;
+    reportMetricsByDim;
+    reportMergedHeads;
     reportQueryPlans;
     reportFilterSurfaces;
     reportEntityBindings;
@@ -471,6 +507,8 @@ export class SearchIndex {
         this.reportMenuTree = parseRecords(records.reportMenuTree ?? [], "report menu tree", reportMenuTreeRecordSchema).map((item) => localizeReportMenuTreeRecord(item, translations));
         this.reportCompositions = parseRecords(records.reportCompositions ?? [], "report compositions", reportCompositionRecordSchema);
         this.reportMergedFields = parseRecords(records.reportMergedFields ?? [], "report merged fields", reportMergedFieldRecordSchema).map((field) => localizeFieldRecord(field, translations));
+        this.reportMetricsByDim = parseRecords(records.reportMetricsByDim ?? [], "report metrics by dim", reportMetricsByDimRecordSchema).map((record) => localizeReportMetricsByDimRecord(record, translations));
+        this.reportMergedHeads = parseRecords(records.reportMergedHeads ?? [], "report merged heads", reportMergedHeadRecordSchema);
         this.reportQueryPlans = parseRecords(records.reportQueryPlans ?? [], "report query plans", reportQueryPlanRecordSchema);
         this.reportFilterSurfaces = parseRecords(records.reportFilterSurfaces ?? [], "report filter surfaces", reportFilterSurfaceRecordSchema).map((surface) => localizeReportFilterSurfaceRecord(surface, translations));
         this.reportEntityBindings = parseRecords(records.reportEntityBindings ?? [], "report entity bindings", reportEntityBindingRecordSchema);
@@ -488,6 +526,8 @@ export class SearchIndex {
             reportMenuTree: parseOptionalJsonlFile(join(root, "report-menu-tree.jsonl"), reportMenuTreeRecordSchema),
             reportCompositions: parseOptionalJsonlFile(join(root, "report-compositions.jsonl"), reportCompositionRecordSchema),
             reportMergedFields: parseOptionalJsonlFile(join(root, "report-merged-fields.jsonl"), reportMergedFieldRecordSchema),
+            reportMetricsByDim: parseOptionalJsonlFile(join(root, "report-metrics-by-dim.jsonl"), reportMetricsByDimRecordSchema),
+            reportMergedHeads: parseOptionalJsonlFile(join(root, "report-merged-heads.jsonl"), reportMergedHeadRecordSchema),
             reportQueryPlans: parseOptionalJsonlFile(join(root, "report-query-plans.jsonl"), reportQueryPlanRecordSchema),
             reportFilterSurfaces: parseOptionalJsonlFile(join(root, "report-filter-surfaces.jsonl"), reportFilterSurfaceRecordSchema),
             reportEntityBindings: parseOptionalJsonlFile(join(root, "report-entity-bindings.jsonl"), reportEntityBindingRecordSchema),
@@ -517,6 +557,8 @@ export class SearchIndex {
             reportMenuTree: parseOptionalJsonlFile(localStore.currentArtifactPath(env, "reportMenuTree"), reportMenuTreeRecordSchema),
             reportCompositions: parseOptionalJsonlFile(localStore.currentArtifactPath(env, "reportCompositions"), reportCompositionRecordSchema),
             reportMergedFields: parseOptionalJsonlFile(localStore.currentArtifactPath(env, "reportMergedFields"), reportMergedFieldRecordSchema),
+            reportMetricsByDim: parseOptionalJsonlFile(localStore.currentArtifactPath(env, "reportMetricsByDim"), reportMetricsByDimRecordSchema),
+            reportMergedHeads: parseOptionalJsonlFile(localStore.currentArtifactPath(env, "reportMergedHeads"), reportMergedHeadRecordSchema),
             reportQueryPlans: parseOptionalJsonlFile(localStore.currentArtifactPath(env, "reportQueryPlans"), reportQueryPlanRecordSchema),
             reportFilterSurfaces: parseOptionalJsonlFile(localStore.currentArtifactPath(env, "reportFilterSurfaces"), reportFilterSurfaceRecordSchema),
             reportEntityBindings: parseOptionalJsonlFile(localStore.currentArtifactPath(env, "reportEntityBindings"), reportEntityBindingRecordSchema),
@@ -609,6 +651,8 @@ export class SearchIndex {
         const routeMap = this.reportRouteMap.filter((route) => route.reportId === report.reportId);
         const menuTree = this.reportMenuTree.filter((item) => pages.some((page) => page.routeKey === item.key));
         const composition = this.reportCompositions.find((candidate) => candidate.reportId === report.reportId);
+        const metricsByDim = this.reportMetricsByDim.filter((record) => record.reportId === report.reportId);
+        const mergedHeads = this.reportMergedHeads.filter((record) => record.reportId === report.reportId);
         const queryPlans = this.reportQueryPlans.filter((plan) => plan.reportId === report.reportId);
         const filterSurfaces = this.reportFilterSurfaces.filter((surface) => surface.reportId === report.reportId);
         const entityBindings = this.reportEntityBindings.filter((binding) => binding.reportId === report.reportId);
@@ -619,6 +663,8 @@ export class SearchIndex {
             ...(routeMap.length > 0 ? { routeMap } : {}),
             ...(menuTree.length > 0 ? { menuTree } : {}),
             ...(composition ? { composition } : {}),
+            ...(metricsByDim.length > 0 ? { metricsByDim } : {}),
+            ...(mergedHeads.length > 0 ? { mergedHeads } : {}),
             ...(queryPlans.length > 0 ? { queryPlans } : {}),
             ...(filterSurfaces.length > 0 ? { filterSurfaces } : {}),
             ...(entityBindings.length > 0 ? { entityBindings } : {})