gamealgo-cli 0.3.8 → 0.4.1

package/README.md

@@ -1,6 +1,6 @@
 # GameAlgo CLI
 
-`gamealgo-cli` is the independently released command-line client for GameAlgo. It is intended for AI coding agents and game developers to manage integration plans, event dictionaries, reports, scripts, configuration, keys, and experiments.
+`gamealgo-cli` is the independently released command-line client for GameAlgo. It is intended for AI coding agents and game developers to manage integration plans, event dictionaries, reports, scripts, configuration, keys, experiments, and game diagnosis.
 
 Source repository: <https://github.com/sunyuhao-code/GameAlgoCli>
 
@@ -35,6 +35,20 @@ gamealgo listapi
 gamealgo docs api GameAlgo.Init --platform lua
 ```
 
+Report Pack v2 uses materialized ordinary Datasets and inline Views. Common report commands are:
+
+```bash
+gamealgo report pull --out gamealgo-report-pack.json
+gamealgo report validate gamealgo-report-pack.json
+gamealgo report preview --pack gamealgo-report-pack.json
+gamealgo report publish gamealgo-report-pack.json
+gamealgo report result --from 2026-09-04 --to 2026-09-17 --platform maker --tab-id overview
+gamealgo report advanced run --query-id battle_analysis --from 2026-09-04 --to 2026-09-17 --platform maker --wait
+gamealgo report advanced list
+```
+
+The current CLI reads legacy v1 Packs during migration, but all Report Pack write commands require `schemaVersion: 2`. Advanced query runs are explicit, are never preloaded, and remain available as immutable reports for 30 days.
+
 Help and documentation are fetched from the configured Server on every invocation. The CLI intentionally does not keep a documentation cache.
 
 ## Agent skill
@@ -51,8 +65,11 @@ The skill uses the project-bound CLI and live Server content. It can discover th
 ```bash
 gamealgo optimize list --json
 gamealgo optimize get ad-monetization --json
+gamealgo diagnosis --json
 ```
 
+`gamealgo diagnosis` returns the same structured competition, monetization, and retention diagnosis shown in the dashboard. It requires a Game Admin Key with `reports:read` and an account-verified Maker game binding; save the complete result with `--out diagnosis.json` when an agent needs to use it in a local workflow.
+
 Adjust S2S event forwarding can be configured with an explicit event allowlist:
 
 ```bash

package/dist/client.js

@@ -168,6 +168,24 @@ export class GameAlgoAdminClient {
         const query = params.size ? `?${params.toString()}` : "";
         return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/reports/manifest${query}`);
     }
+    async readReportDataset(input) {
+        const params = new URLSearchParams({
+            platform: input.platform,
+            startDate: input.startDate,
+            endDate: input.endDate,
+        });
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/report-datasets/${encodeURIComponent(input.datasetFingerprint)}/results?${params.toString()}`);
+    }
+    async createAdvancedReportRun(body, options = {}) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/reports/advanced-runs`, body, options);
+    }
+    async getAdvancedReportRun(runId, includeResult = true) {
+        const params = new URLSearchParams({ includeResult: includeResult ? "true" : "false" });
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/reports/advanced-runs/${encodeURIComponent(runId)}?${params.toString()}`);
+    }
+    async listAdvancedReportRuns(limit = 50) {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/reports/advanced-runs?limit=${encodeURIComponent(String(limit))}`);
+    }
     async queryReportDashboard(body, options = {}) {
         return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/reports/query`, body, options);
     }
@@ -209,6 +227,9 @@ export class GameAlgoAdminClient {
         const params = new URLSearchParams({ environment, platform });
         return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/integration/plan?${params.toString()}`);
     }
+    async getGameDiagnosis() {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/diagnosis`);
+    }
     async listOptimizationTasks() {
         return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/optimization/tasks`);
     }
@@ -228,8 +249,8 @@ export class GameAlgoAdminClient {
     async listGameKeys() {
         return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/keys`);
     }
-    async createGameKey(name) {
-        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/keys`, { name });
+    async createGameKey(name, platform) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/keys`, { name, ...(platform ? { platform } : {}) });
     }
     async revealGameKey(selector) {
         return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/keys/reveal`, selector);

package/dist/commands/diagnosis.js

@@ -0,0 +1,17 @@
+import { parseFlags } from "../args.js";
+import { printResult } from "../output.js";
+import { writeTextFile } from "../resources.js";
+export async function handleDiagnosis(client, args, global) {
+    const flags = parseFlags(args);
+    if (args.length)
+        throw new Error("usage: gamealgo diagnosis [--out diagnosis.json]");
+    if (flags.out === true)
+        throw new Error("--out requires a file path");
+    const diagnosis = await client.getGameDiagnosis();
+    if (typeof flags.out === "string") {
+        await writeTextFile(flags.out, `${JSON.stringify(diagnosis, null, 2)}\n`);
+        await printResult({ ok: true, out: flags.out }, global);
+        return;
+    }
+    await printResult(diagnosis, global);
+}

package/dist/commands/experiment.js

@@ -129,7 +129,7 @@ export async function handleExperimentStrategy(client, args, global) {
         const platform = flags.platform === undefined ? undefined : experimentPlatform(flags.platform);
         const message = requiredMessage(flags, "experiment strategy rollback");
         if (!strategyKey || !versionId) {
-            throw new Error("usage: gamealgo experiment strategy rollback <strategyKey> --version-id <versionId> [--platform ios|android|rest] --message <reason> --yes");
+            throw new Error("usage: gamealgo experiment strategy rollback <strategyKey> --version-id <versionId> [--platform ios|android|maker|web] --message <reason> --yes");
         }
         await requireYes(flags, global, "experiment strategy rollback");
         await printResult(await client.rollbackExperimentV2Strategy(strategyKey, versionId, message, platform), global);

package/dist/commands/integration.js

@@ -16,7 +16,7 @@ export async function handleIntegration(client, args, global) {
         await writeIntegrationOutput(response, flags, global);
         return;
     }
-    throw new Error("usage: gamealgo integration get-plan --environment <domestic|overseas> --platform <ios|android|maker|rest>");
+    throw new Error("usage: gamealgo integration get-plan --environment <domestic|overseas> --platform <ios|android|maker|web>");
 }
 export async function writeIntegrationOutput(value, flags, global) {
     if (flags.out) {

package/dist/commands/keys.js

@@ -1,7 +1,7 @@
 import { parseFlags } from "../args.js";
 import { confirm, isInteractive, printResult } from "../output.js";
 import { announceTargetGame } from "../target.js";
-import { optionalString } from "../utils.js";
+import { integrationPlatform, optionalString } from "../utils.js";
 export async function handleGameKey(client, args, global) {
     const sub = args.shift();
     if (sub === "list") {
@@ -15,8 +15,9 @@ export async function handleGameKey(client, args, global) {
         const flags = parseFlags(args);
         const name = optionalString(flags.name) || optionalString(args.shift());
         if (!name)
-            throw new Error("usage: gamealgo key create --name <key-name>");
-        const response = await client.createGameKey(name);
+            throw new Error("usage: gamealgo key create --name <key-name> [--platform ios|android|maker|web]");
+        const platform = flags.platform === undefined ? undefined : integrationPlatform(flags.platform);
+        const response = await client.createGameKey(name, platform);
         await printResult({
             ok: true,
             created: response.created !== false,
@@ -25,6 +26,7 @@ export async function handleGameKey(client, args, global) {
             prefix: response.key.keyPrefix,
             keyPrefix: response.key.keyPrefix,
             status: response.key.status,
+            platform: response.key.platform,
             createdAt: response.key.createdAt,
         }, global);
         return;
@@ -40,6 +42,7 @@ export async function handleGameKey(client, args, global) {
             prefix: response.key.keyPrefix,
             keyPrefix: response.key.keyPrefix,
             status: response.key.status,
+            platform: response.key.platform,
             createdAt: response.key.createdAt,
         }, global);
         return;
@@ -72,6 +75,7 @@ export function publicGameKeyForCli(key) {
         prefix: key.keyPrefix,
         keyPrefix: key.keyPrefix,
         status: key.status,
+        platform: key.platform,
         createdAt: key.createdAt,
     };
 }

package/dist/commands/report.js

@@ -4,16 +4,24 @@ import { formatDuration, markCommandFailed, printResult, reportTimeoutMs, startP
 import { reportDashboardCsv, reportDashboardCsvExports } from "../report-csv.js";
 import { normalizeReportSampleRows, summarizeReportDashboard, summarizeReportManifest, summarizeReportValidation, } from "../report-summary.js";
 import { objectValue, readJsonFile, writeTextFile } from "../resources.js";
+import { queryReportPackV2Result } from "../report-v2/result.js";
+import { assertWritableReportPackV2, reportPackSchemaVersion } from "../report-v2/schema.js";
+import { summarizeReportPackV2Manifest } from "../report-v2/summary.js";
 import { announceTargetGame } from "../target.js";
 import { optionalString } from "../utils.js";
 export async function handleReport(client, args, global) {
     const sub = args.shift();
+    if (sub === "advanced") {
+        await handleAdvancedReport(client, args, global);
+        return;
+    }
     if (sub === "pull") {
         const flags = parseFlags(args);
         const pack = await client.getReportPack();
-        const out = String(flags.out || "gamealgo-report-pack-v1.json");
+        const schemaVersion = reportPackSchemaVersion(pack.reportPack.content);
+        const out = String(flags.out || `gamealgo-report-pack-v${schemaVersion}.json`);
         await writeTextFile(out, JSON.stringify(pack.reportPack.content, null, 2) + "\n");
-        await printResult({ ok: true, out }, global);
+        await printResult({ ok: true, out, schemaVersion }, global);
         return;
     }
     if (sub === "validate") {
@@ -23,6 +31,7 @@ export async function handleReport(client, args, global) {
         const flags = parseFlags(args);
         const full = reportFullOutput(flags);
         const content = await readJsonFile(filePath);
+        assertWritableReportPackV2(content, "report validate");
         const response = await client.previewReportPack(content, { responseMode: full ? "full" : "summary" });
         const summary = summarizeReportValidation(response);
         await printResult(full ? response : summary, global);
@@ -36,6 +45,7 @@ export async function handleReport(client, args, global) {
             throw new Error("usage: gamealgo report publish <report-pack.json>");
         parseFlags(args);
         const content = await readJsonFile(filePath);
+        assertWritableReportPackV2(content, "report publish");
         await announceTargetGame(client);
         const response = await client.putReportPack(content);
         await printResult({ ok: true, validation: response.reportPack.validation }, global);
@@ -45,7 +55,10 @@ export async function handleReport(client, args, global) {
         const flags = parseFlags(args);
         const full = reportFullOutput(flags);
         const response = await client.reportManifest({ responseMode: full ? "full" : "summary" });
-        await printResult(full ? response : summarizeReportManifest(response), global);
+        const manifest = objectValue(objectValue(response)?.manifest);
+        await printResult(full
+            ? response
+            : manifest?.schemaVersion === 2 ? summarizeReportPackV2Manifest(response) : summarizeReportManifest(response), global);
         return;
     }
     if (sub === "result") {
@@ -54,32 +67,50 @@ export async function handleReport(client, args, global) {
         const startDate = String(flags.from || flags.start || flags.startDate || "");
         const endDate = String(flags.to || flags.end || flags.endDate || "");
         if (!startDate || !endDate)
-            throw new Error("usage: gamealgo report result --from YYYY-MM-DD --to YYYY-MM-DD [--platform ios|android|rest] [--tab name] [--group name] [--chart name] [--selector k=v] [--sample-rows 0..20] [--full] [--format json|csv] [--out file-or-directory]");
+            throw new Error("usage: gamealgo report result --from YYYY-MM-DD --to YYYY-MM-DD [--platform ios|android|maker|web] [--tab name] [--group name] [--chart name] [--selector k=v] [--sample-rows 0..20] [--full] [--format json|csv] [--out file-or-directory]");
         requireReportQueryScope(flags, "report result");
         const timeoutMs = reportTimeoutMs(flags);
         const format = reportOutputFormat(flags.format);
         const full = reportFullOutput(flags) || format === "csv";
         const sampleRows = reportSampleRows(flags, full);
         const platform = await resolveCliReportPlatform(client, flags.platform, selectors.platform, startDate, endDate);
+        const manifestResponse = await client.reportManifest({ responseMode: "full" });
+        const manifest = objectValue(objectValue(manifestResponse)?.manifest);
+        const schemaVersion = manifest?.schemaVersion === 2 ? 2 : 1;
         const startedAt = Date.now();
-        const stopProgress = startProgress("Querying report results", timeoutMs);
+        const stopProgress = startProgress(schemaVersion === 2 ? "Reading report results" : "Querying report results", timeoutMs);
         let response;
         try {
-            response = await client.queryReportDashboard({
-                startDate,
-                endDate,
-                tab: optionalString(flags.tab),
-                tabId: optionalString(flags["tab-id"]),
-                group: optionalString(flags.group),
-                groupId: optionalString(flags["group-id"]),
-                chart: optionalString(flags.chart),
-                chartId: optionalString(flags["chart-id"]),
-                platform,
-                selectors,
-                refresh: Boolean(flags.refresh),
-                responseMode: full ? "full" : "summary",
-                sampleRows,
-            }, { timeoutMs });
+            response = schemaVersion === 2
+                ? await queryReportPackV2Result(client, manifestResponse, {
+                    startDate,
+                    endDate,
+                    tab: optionalString(flags.tab),
+                    tabId: optionalString(flags["tab-id"]),
+                    group: optionalString(flags.group),
+                    groupId: optionalString(flags["group-id"]),
+                    chart: optionalString(flags.chart),
+                    chartId: optionalString(flags["chart-id"]),
+                    platform,
+                    selectors,
+                    refresh: Boolean(flags.refresh),
+                    timeoutMs,
+                })
+                : await client.queryReportDashboard({
+                    startDate,
+                    endDate,
+                    tab: optionalString(flags.tab),
+                    tabId: optionalString(flags["tab-id"]),
+                    group: optionalString(flags.group),
+                    groupId: optionalString(flags["group-id"]),
+                    chart: optionalString(flags.chart),
+                    chartId: optionalString(flags["chart-id"]),
+                    platform,
+                    selectors,
+                    refresh: Boolean(flags.refresh),
+                    responseMode: full ? "full" : "summary",
+                    sampleRows,
+                }, { timeoutMs });
         }
         finally {
             stopProgress();
@@ -93,53 +124,159 @@ export async function handleReport(client, args, global) {
         return;
     }
     if (sub === "preview") {
-        const selectors = parseSelectorFlags(args);
         const flags = parseFlags(args);
         const filePath = String(flags.pack || flags.file || args.shift() || "");
-        const startDate = String(flags.from || flags.start || flags.startDate || "");
-        const endDate = String(flags.to || flags.end || flags.endDate || "");
-        if (!filePath || !startDate || !endDate) {
-            throw new Error("usage: gamealgo report preview --pack report-pack.json --from YYYY-MM-DD --to YYYY-MM-DD [--platform ios|android|rest] [--tab name] [--group name] [--chart name] [--selector k=v] [--sample-rows 0..20] [--full] [--format json|csv] [--out file-or-directory]");
-        }
-        requireReportQueryScope(flags, "report preview");
+        if (!filePath)
+            throw new Error("usage: gamealgo report preview --pack report-pack.json [--full]");
         const content = await readJsonFile(filePath);
+        assertWritableReportPackV2(content, "report preview");
         const timeoutMs = reportTimeoutMs(flags);
-        const format = reportOutputFormat(flags.format);
-        const full = reportFullOutput(flags) || format === "csv";
-        const sampleRows = reportSampleRows(flags, full);
-        const platform = await resolveCliReportPlatform(client, flags.platform, selectors.platform, startDate, endDate);
+        const full = reportFullOutput(flags);
         const startedAt = Date.now();
-        const stopProgress = startProgress("Previewing report results", timeoutMs);
+        const stopProgress = startProgress("Validating Report Pack v2 preview", timeoutMs);
         let response;
         try {
-            response = await client.previewReportDashboard({
-                content,
-                startDate,
-                endDate,
-                tab: optionalString(flags.tab),
-                tabId: optionalString(flags["tab-id"]),
-                group: optionalString(flags.group),
-                groupId: optionalString(flags["group-id"]),
-                chart: optionalString(flags.chart),
-                chartId: optionalString(flags["chart-id"]),
-                platform,
-                selectors,
-                responseMode: full ? "full" : "summary",
-                sampleRows,
-            }, { timeoutMs });
+            response = await client.previewReportPack(content, { responseMode: full ? "full" : "summary" });
         }
         finally {
             stopProgress();
         }
         const elapsedMs = Date.now() - startedAt;
         const rawOutputValue = withCliMeta(response, { elapsedMs, timeoutMs });
-        const statusSummary = summarizeReportDashboard(rawOutputValue, { command: "report.preview", sampleRows });
+        const statusSummary = summarizeReportValidation(rawOutputValue, "report.preview");
         const outputValue = full ? rawOutputValue : statusSummary;
-        process.stderr.write(`Report preview finished in ${formatDuration(elapsedMs)}.\n`);
-        await writeReportQueryOutput(outputValue, flags, global, elapsedMs, statusSummary.ok);
+        process.stderr.write(`Report Pack preview finished in ${formatDuration(elapsedMs)}.\n`);
+        const out = optionalString(flags.out);
+        if (flags.out === true)
+            throw new Error("--out requires a file path");
+        if (out) {
+            await writeTextFile(out, JSON.stringify(outputValue, null, 2) + "\n");
+            await printResult({ ok: statusSummary.ok, out, elapsedMs }, global);
+        }
+        else {
+            await printResult(outputValue, global);
+        }
+        if (!statusSummary.ok)
+            markCommandFailed();
         return;
     }
-    throw new Error("usage: gamealgo report <pull|validate|publish|manifest|result|preview>");
+    throw new Error("usage: gamealgo report <pull|validate|publish|manifest|result|preview|advanced>");
+}
+async function handleAdvancedReport(client, args, global) {
+    const action = args.shift();
+    if (action === "run") {
+        const flags = parseFlags(args);
+        const queryId = requiredTextFlag(flags["query-id"], "--query-id");
+        const startDate = requiredTextFlag(flags.from || flags.start || flags.startDate, "--from");
+        const endDate = requiredTextFlag(flags.to || flags.end || flags.endDate, "--to");
+        const platform = optionalCliReportPlatform(flags.platform, "--platform");
+        if (!platform)
+            throw new Error("--platform is required for report advanced run");
+        if (flags.format !== undefined && flags.format !== "json")
+            throw new Error("report advanced currently supports only --format json");
+        const packPath = optionalString(flags.pack);
+        if (flags.pack === true)
+            throw new Error("--pack requires a file path");
+        const pack = packPath ? await readJsonFile(packPath) : undefined;
+        if (pack !== undefined)
+            assertWritableReportPackV2(pack, "report advanced run");
+        const wait = booleanFlag(flags.wait, "--wait");
+        const timeoutMs = reportTimeoutMs(flags) ?? 15 * 60 * 1000;
+        await announceTargetGame(client);
+        const created = await client.createAdvancedReportRun({
+            queryId,
+            startDate,
+            endDate,
+            platform,
+            ...(pack !== undefined ? { pack } : {}),
+        }, { timeoutMs: Math.min(timeoutMs, 30_000) });
+        if (!wait) {
+            await writeAdvancedOutput(created, flags, global);
+            return;
+        }
+        const runId = requiredRunId(created.run?.id);
+        const startedAt = Date.now();
+        const stopProgress = startProgress(`Waiting for advanced report ${runId}`, timeoutMs);
+        let response;
+        try {
+            response = await waitForAdvancedReport(client, runId, timeoutMs, startedAt);
+        }
+        finally {
+            stopProgress();
+        }
+        await writeAdvancedOutput(withCliMeta(response, { elapsedMs: Date.now() - startedAt, timeoutMs }), flags, global);
+        if (response.run.status === "failed")
+            markCommandFailed();
+        return;
+    }
+    if (action === "get") {
+        const runId = args.shift();
+        if (!runId)
+            throw new Error("usage: gamealgo report advanced get <run-id> [--metadata-only] [--out file]");
+        const flags = parseFlags(args);
+        const metadataOnly = booleanFlag(flags["metadata-only"], "--metadata-only");
+        const response = await client.getAdvancedReportRun(runId, !metadataOnly);
+        await writeAdvancedOutput(response, flags, global);
+        if (response.run.status === "failed")
+            markCommandFailed();
+        return;
+    }
+    if (action === "list") {
+        const flags = parseFlags(args);
+        const limit = positiveIntegerFlag(flags.limit, "--limit", 50);
+        await writeAdvancedOutput(await client.listAdvancedReportRuns(limit), flags, global);
+        return;
+    }
+    throw new Error("usage: gamealgo report advanced <run|get|list>");
+}
+async function waitForAdvancedReport(client, runId, timeoutMs, startedAt) {
+    while (true) {
+        const response = await client.getAdvancedReportRun(runId, true);
+        if (response.run.status === "succeeded" || response.run.status === "failed")
+            return response;
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw new Error(`advanced report ${runId} did not finish within ${formatDuration(timeoutMs)}; use report advanced get ${runId} later`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2_000));
+    }
+}
+async function writeAdvancedOutput(value, flags, global) {
+    if (flags.format !== undefined && flags.format !== "json")
+        throw new Error("report advanced currently supports only --format json");
+    const out = optionalString(flags.out);
+    if (flags.out === true)
+        throw new Error("--out requires a file path");
+    if (!out) {
+        await printResult(value, global);
+        return;
+    }
+    await writeTextFile(out, JSON.stringify(value, null, 2) + "\n");
+    await printResult({ ok: true, out }, global);
+}
+function requiredTextFlag(value, flag) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${flag} is required`);
+    return value.trim();
+}
+function requiredRunId(value) {
+    if (typeof value !== "string" || !value)
+        throw new Error("advanced report create response is missing run.id");
+    return value;
+}
+function booleanFlag(value, flag) {
+    if (value === undefined)
+        return false;
+    if (value !== true)
+        throw new Error(`${flag} does not accept a value`);
+    return true;
+}
+function positiveIntegerFlag(value, flag, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "string" || !/^\d+$/.test(value) || Number(value) < 1) {
+        throw new Error(`${flag} must be a positive integer`);
+    }
+    return Number(value);
 }
 function reportFullOutput(flags) {
     if (flags.full === undefined)
@@ -293,7 +430,7 @@ export async function resolveCliReportPlatform(client, flagValue, selectorValue,
     const detected = objectValue(await client.countEventPlatforms(startDate, endDate));
     const detectedPlatform = optionalCliReportPlatform(detected?.recommendedPlatform, "detected report platform");
     if (!detectedPlatform) {
-        throw new Error("report platform could not be detected for the selected date range; pass --platform ios, --platform android, or --platform rest");
+        throw new Error("report platform could not be detected for the selected date range; pass --platform ios, android, maker, or web");
     }
     process.stderr.write(`Report platform: ${detectedPlatform} (detected from event data)\n`);
     return detectedPlatform;
@@ -301,7 +438,7 @@ export async function resolveCliReportPlatform(client, flagValue, selectorValue,
 export function optionalCliReportPlatform(value, field) {
     if (value === undefined || value === null || value === "")
         return undefined;
-    if (value === "ios" || value === "android" || value === "rest")
+    if (value === "ios" || value === "android" || value === "maker" || value === "web")
         return value;
-    throw new Error(`${field} must be ios, android, or rest`);
+    throw new Error(`${field} must be ios, android, maker, or web`);
 }

package/dist/compatibility.js

@@ -1,6 +1,6 @@
 import { loadPackageMetadata } from "./config.js";
 import { requestJson } from "./http.js";
-export const CLI_PROTOCOL_VERSION = 1;
+export const CLI_PROTOCOL_VERSION = 2;
 export async function assertServerCompatibility(host) {
     const metadata = await requestJson(host, "/admin/v1/cli/meta", {
         headers: { "Cache-Control": "no-cache" },

package/dist/docs.js

@@ -459,12 +459,12 @@ export function parseDocsApiPlatform(value) {
     if (value === undefined || value === false || value === "")
         return undefined;
     const platform = String(value).trim().toLowerCase();
-    if (platform === "maker")
-        return "lua";
-    if (platform === "lua" || platform === "ios" || platform === "android" || platform === "rest") {
+    if (platform === "lua")
+        return "maker";
+    if (platform === "maker" || platform === "ios" || platform === "android" || platform === "web") {
         return platform;
     }
-    throw new Error("--platform must be lua, maker, ios, android, or rest");
+    throw new Error("--platform must be ios, android, maker, or web");
 }
 export async function printDocsApiResult(options) {
     const { query, platform, manifest, topic, document, webUrl, host, global } = options;
@@ -537,8 +537,8 @@ export function parseDocsApiEntries(content) {
         if (!symbols.length)
             continue;
         const platforms = parseDocsApiMetadataList(section, "平台")
-            .map((item) => item.toLowerCase())
-            .filter((item) => item === "lua" || item === "ios" || item === "android" || item === "rest");
+            .map((item) => item.toLowerCase() === "lua" ? "maker" : item.toLowerCase())
+            .filter((item) => item === "maker" || item === "ios" || item === "android" || item === "web");
         const summaryMatch = section.match(/^-\s*用途[：:]\s*(.+)$/m);
         entries.push({
             name: stripInlineMarkdown(heading[1]),

package/dist/main.js

@@ -13,6 +13,7 @@ import { handleSkill } from "./commands/skill.js";
 import { loadPackageMetadata } from "./config.js";
 import { handleDocs, handleHelp } from "./docs.js";
 import { handleDynamicConfig } from "./commands/dynamic-config.js";
+import { handleDiagnosis } from "./commands/diagnosis.js";
 import { cliErrorPayload } from "./http.js";
 import { printResult } from "./output.js";
 export async function main() {
@@ -98,6 +99,10 @@ export async function main() {
             await handleIntegration(client, args, global);
             return;
         }
+        if (command === "diagnosis" || command === "diagnose") {
+            await handleDiagnosis(client, args, global);
+            return;
+        }
         if (command === "marketing") {
             await handleMarketing(client, args, global);
             return;

package/dist/report-summary.js

@@ -2,7 +2,7 @@ export const REPORT_SUMMARY_SCHEMA_VERSION = 1;
 export const REPORT_SUMMARY_MAX_ITEMS = 200;
 export const REPORT_SUMMARY_MAX_ISSUES = 100;
 export const REPORT_SUMMARY_MAX_SAMPLE_ROWS = 20;
-export function summarizeReportValidation(value) {
+export function summarizeReportValidation(value, command = "report.validate") {
     const root = objectValue(value);
     const validation = objectValue(root?.validation);
     const errorMessages = stringValues(validation?.errors);
@@ -24,7 +24,7 @@ export function summarizeReportValidation(value) {
     const items = statementItems.slice(0, REPORT_SUMMARY_MAX_ITEMS);
     return {
         schemaVersion: REPORT_SUMMARY_SCHEMA_VERSION,
-        command: "report.validate",
+        command,
         ok: validation?.ok === true && errorMessages.length === 0,
         summary: {
             errorCount: errorMessages.length,
@@ -146,6 +146,13 @@ export function summarizeReportDashboard(value, options) {
         if (result?.stale === true) {
             allWarnings.push({ scope, message: "Report result is stale" });
         }
+        if (result?.partial === true) {
+            const missingDates = stringValues(result.missingDates);
+            allWarnings.push({
+                scope,
+                message: `Report Dataset coverage is partial${missingDates.length ? `; missing dates: ${missingDates.join(", ")}` : ""}`,
+            });
+        }
         allItems.push(compactObject({
             kind: "chart-result",
             status,
@@ -162,6 +169,9 @@ export function summarizeReportDashboard(value, options) {
             cached: typeof result?.cached === "boolean" ? result.cached : undefined,
             cachedAt: stringValue(result?.cachedAt),
             stale: typeof result?.stale === "boolean" ? result.stale : undefined,
+            partial: typeof result?.partial === "boolean" ? result.partial : undefined,
+            missingDates: stringValues(result?.missingDates),
+            snapshotVersion: stringValue(result?.snapshotVersion),
             truncated,
             rowLimit: finiteNonNegativeNumber(result?.rowLimit),
             error,
@@ -243,6 +253,8 @@ function reportResultStatus(result) {
         return "retrying";
     if (result?.refreshing === true)
         return "refreshing";
+    if (result?.partial === true)
+        return "partial";
     if (result?.stale === true)
         return "stale";
     return "ready";