@alphafox/cli 0.3.2 → 0.3.4

package/dist/engine-backtest/sweep-kernel/results.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSweepMetrics = extractSweepMetrics;
+exports.selectBestNonLiquidatedPoint = selectBestNonLiquidatedPoint;
+exports.resolveIslandRiskLevel = resolveIslandRiskLevel;
+exports.analyzeSweepIsland = analyzeSweepIsland;
+function extractSweepMetrics(source) {
+    return {
+        returnPct: source.returnPct,
+        maxDrawdownPct: source.maxDrawdownPct,
+        sharpeRatio: source.sharpeRatio,
+        winRatePct: source.winRatePct,
+        ...(source.maxLeverage === undefined
+            ? {}
+            : { maxLeverage: source.maxLeverage }),
+        liquidationCount: typeof source.liquidationCount === "number" &&
+            Number.isFinite(source.liquidationCount)
+            ? source.liquidationCount
+            : source.liquidated
+                ? 1
+                : 0,
+        netPnl: source.netPnl,
+        finalEquity: source.finalEquity,
+        tradeCount: source.tradeCount,
+    };
+}
+function selectBestNonLiquidatedPoint(points) {
+    const candidates = points.filter(isOkNonLiquidatedPoint);
+    if (candidates.length === 0) {
+        return null;
+    }
+    const best = candidates.reduce((leader, point) => point.metrics.returnPct > leader.metrics.returnPct ? point : leader);
+    return {
+        coordinate: best.coordinate,
+        returnPct: best.metrics.returnPct,
+    };
+}
+function resolveIslandRiskLevel(score) {
+    if (score >= 80) {
+        return "high";
+    }
+    if (score >= 50) {
+        return "medium";
+    }
+    if (score >= 30) {
+        return "low_medium";
+    }
+    return "low";
+}
+/**
+ * Score each swept point by how sharply it deviates from its neighbors, then
+ * flag the point closest to `centerValue` when it sits on a fragile island.
+ */
+function analyzeSweepIsland(points, centerValue) {
+    const rows = [...points].sort((left, right) => left.value - right.value);
+    if (rows.length === 0) {
+        return {
+            points: [],
+            warning: null,
+            overallScore: 0,
+            overallRiskLevel: "low",
+        };
+    }
+    const returnStd = populationStd(rows.map((row) => row.returnPct));
+    const drawdownStd = populationStd(rows.map((row) => row.maxDrawdownPct));
+    const centerIndex = rows.reduce((bestIndex, row, index) => Math.abs(row.value - centerValue) <
+        Math.abs(rows[bestIndex].value - centerValue)
+        ? index
+        : bestIndex, 0);
+    const scored = rows.map((row, index) => {
+        const neighbors = [index - 1, index + 1]
+            .filter((i) => i >= 0 && i < rows.length)
+            .map((i) => rows[i]);
+        const score = scoreNeighborhood(row, neighbors, returnStd, drawdownStd);
+        return {
+            ...row,
+            isCenter: index === centerIndex,
+            islandScore: Number(score.toFixed(2)),
+            riskLevel: resolveIslandRiskLevel(score),
+        };
+    });
+    const center = scored[centerIndex];
+    const centerNeighbors = [centerIndex - 1, centerIndex + 1]
+        .filter((i) => i >= 0 && i < scored.length)
+        .map((i) => scored[i]);
+    const hasLiquidationJump = center.liquidationCount === 0 &&
+        centerNeighbors.some((row) => row.liquidationCount > 0);
+    const warning = hasLiquidationJump || center.islandScore >= 50
+        ? {
+            centerValue: center.value,
+            islandScore: center.islandScore,
+            riskLevel: center.riskLevel,
+            counterexamples: centerNeighbors
+                .filter((row) => row.liquidationCount > center.liquidationCount)
+                .map((row) => ({
+                counterValue: row.value,
+                centerReturnPct: center.returnPct,
+                counterReturnPct: row.returnPct,
+                centerLiquidationCount: center.liquidationCount,
+                counterLiquidationCount: row.liquidationCount,
+            })),
+        }
+        : null;
+    const overallScore = scored.reduce((highest, row) => Math.max(highest, row.islandScore), 0);
+    return {
+        points: scored,
+        warning,
+        overallScore,
+        overallRiskLevel: resolveIslandRiskLevel(overallScore),
+    };
+}
+function isOkNonLiquidatedPoint(point) {
+    return (point.status === "ok" &&
+        point.metrics !== undefined &&
+        Number.isFinite(point.metrics.returnPct) &&
+        Number.isFinite(point.metrics.liquidationCount) &&
+        point.metrics.liquidationCount === 0);
+}
+function scoreNeighborhood(row, neighbors, returnStd, drawdownStd) {
+    if (neighbors.length === 0) {
+        return 0;
+    }
+    const neighborReturn = average(neighbors.map((n) => n.returnPct));
+    const neighborDrawdown = average(neighbors.map((n) => n.maxDrawdownPct));
+    const neighborLiquidations = average(neighbors.map((n) => n.liquidationCount));
+    const returnAdvantage = (Math.min(Math.max(row.returnPct - neighborReturn, 0) / Math.max(returnStd, 0.5), 2) /
+        2) *
+        100;
+    const drawdownAdvantage = (Math.min(Math.max(neighborDrawdown - row.maxDrawdownPct, 0) /
+        Math.max(drawdownStd, 0.1), 2) /
+        2) *
+        100;
+    const liquidationJump = (Math.min(Math.max(neighborLiquidations - row.liquidationCount, 0), 3) /
+        3) *
+        100;
+    return (0.35 * returnAdvantage + 0.3 * drawdownAdvantage + 0.25 * liquidationJump);
+}
+function average(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function populationStd(values) {
+    if (values.length < 2) {
+        return 0;
+    }
+    const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+    return Math.sqrt(values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length);
+}

package/dist/engine-backtest/sweep-kernel/session.d.ts

@@ -0,0 +1,55 @@
+export type SweepExecutionState = {
+    readonly status: "idle";
+} | {
+    readonly status: "running";
+    readonly total: number;
+} | {
+    readonly status: "succeeded";
+    readonly resultId: string;
+} | {
+    readonly status: "failed";
+    readonly message: string;
+} | {
+    readonly status: "cancelled";
+};
+export type SweepCloudSaveState = {
+    readonly status: "idle";
+} | {
+    readonly status: "saving";
+} | {
+    readonly status: "saved";
+    readonly sweepId: string;
+} | {
+    readonly status: "failed";
+    readonly message: string;
+};
+export interface SweepSessionState {
+    readonly execution: SweepExecutionState;
+    readonly cloudSave: SweepCloudSaveState;
+}
+export type SweepSessionEvent = {
+    readonly type: "execution-started";
+    readonly total: number;
+} | {
+    readonly type: "execution-succeeded";
+    readonly resultId: string;
+} | {
+    readonly type: "execution-failed";
+    readonly message: string;
+} | {
+    readonly type: "execution-cancelled";
+} | {
+    readonly type: "execution-reset";
+} | {
+    readonly type: "cloud-save-started";
+} | {
+    readonly type: "cloud-save-succeeded";
+    readonly sweepId: string;
+} | {
+    readonly type: "cloud-save-failed";
+    readonly message: string;
+} | {
+    readonly type: "cloud-save-retry";
+};
+export declare function createSweepSessionState(): SweepSessionState;
+export declare function reduceSweepSession(state: SweepSessionState, event: SweepSessionEvent): SweepSessionState;

package/dist/engine-backtest/sweep-kernel/session.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSweepSessionState = createSweepSessionState;
+exports.reduceSweepSession = reduceSweepSession;
+const IDLE_CLOUD_SAVE = { status: "idle" };
+function createSweepSessionState() {
+    return {
+        execution: { status: "idle" },
+        cloudSave: IDLE_CLOUD_SAVE,
+    };
+}
+function reduceSweepSession(state, event) {
+    switch (event.type) {
+        case "execution-started":
+            return {
+                execution: { status: "running", total: event.total },
+                cloudSave: IDLE_CLOUD_SAVE,
+            };
+        case "execution-succeeded":
+            return {
+                execution: { status: "succeeded", resultId: event.resultId },
+                cloudSave: IDLE_CLOUD_SAVE,
+            };
+        case "execution-failed":
+            return {
+                execution: { status: "failed", message: event.message },
+                cloudSave: IDLE_CLOUD_SAVE,
+            };
+        case "execution-cancelled":
+            return {
+                execution: { status: "cancelled" },
+                cloudSave: IDLE_CLOUD_SAVE,
+            };
+        case "execution-reset":
+            return createSweepSessionState();
+        case "cloud-save-started":
+        case "cloud-save-retry":
+            return applyCloudSave(state, { status: "saving" });
+        case "cloud-save-succeeded":
+            return applyCloudSave(state, {
+                status: "saved",
+                sweepId: event.sweepId,
+            });
+        case "cloud-save-failed":
+            return applyCloudSave(state, {
+                status: "failed",
+                message: event.message,
+            });
+    }
+}
+function applyCloudSave(state, cloudSave) {
+    if (state.execution.status !== "succeeded") {
+        return state;
+    }
+    return { ...state, cloudSave };
+}

package/dist/engine-backtest/sweep-kernel/types.d.ts

@@ -0,0 +1,36 @@
+export type SweepSubscriptionTier = "free" | "pro" | "pro_max";
+export type SweepSearchMode = "standard" | "fast";
+export interface SweepCoordinate {
+    readonly values: readonly number[];
+}
+export interface SweepAxisWindow {
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+}
+/** Explicit values, or a min/max/step window around the current value. */
+export interface SweepAxisInput {
+    readonly path: readonly string[];
+    readonly current: number;
+    readonly isInteger: boolean;
+    readonly min?: number;
+    readonly max?: number;
+    readonly minExclusive?: boolean;
+    readonly maxExclusive?: boolean;
+    readonly values?: readonly number[];
+    readonly window?: SweepAxisWindow;
+}
+export interface SweepPlanAxis {
+    readonly path: readonly string[];
+    readonly current: number;
+    readonly values: readonly number[];
+}
+export interface SweepPlan {
+    readonly axes: readonly SweepPlanAxis[];
+    readonly coordinates: readonly SweepCoordinate[];
+    readonly requestedCombinationCount: number;
+    readonly sampled: boolean;
+}
+export type SweepConfigRecord = {
+    readonly [key: string]: unknown;
+};

package/dist/engine-backtest/sweep-kernel/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/engine-backtest/types.d.ts

@@ -34,6 +34,14 @@ export interface EngineBacktestRunArgs {
     /** Replay/download bar. Defaults to 1m; never finer. */
     readonly replayTimeframe: string;
 }
+export type SweepMode = "neighborhood" | "range";
+export type SweepSearchMode = "standard" | "fast";
+export interface EngineBacktestSweepArgs extends EngineBacktestRunArgs {
+    readonly axesRaw?: string;
+    readonly mode: SweepMode;
+    readonly searchMode: SweepSearchMode;
+    readonly concurrency: number;
+}
 export interface EngineBacktestSeriesRequirement {
     readonly symbol: string;
     readonly timeframe: string;
@@ -105,6 +113,37 @@ export interface EngineBacktestResult {
     }>;
     readonly warnings?: string[];
 }
+export interface EngineBacktestBatchVariant {
+    readonly runId: string;
+    readonly config: unknown;
+}
+export interface EngineBacktestBatchRequest {
+    readonly version: 1;
+    readonly batchId: string;
+    readonly baseScenario: Omit<EngineBacktestScenario, "tape">;
+    readonly variants: readonly EngineBacktestBatchVariant[];
+    readonly tape: EngineBacktestTapeInput;
+}
+export interface EngineBacktestBatchPointResult {
+    readonly runId: string;
+    readonly status: "completed" | "failed";
+    readonly metrics: EngineBacktestMetrics;
+    readonly errors?: Array<{
+        code: string;
+        message: string;
+        path?: string;
+    }>;
+}
+export interface EngineBacktestBatchResult {
+    readonly batchId: string;
+    readonly status: "completed" | "failed";
+    readonly results: readonly EngineBacktestBatchPointResult[];
+    readonly errors?: Array<{
+        code: string;
+        message: string;
+        path?: string;
+    }>;
+}
 export interface EngineBacktestSupportReason {
     readonly code: string;
     readonly message: string;
@@ -180,6 +219,7 @@ export interface BacktestClientLike {
         readonly config: unknown;
     }): Promise<EngineBacktestPlan | EngineBacktestFailure>;
     runBacktest(scenario: EngineBacktestScenario, buffers: Record<string, ArrayBuffer>, onProgress?: (fraction: number) => void): Promise<EngineBacktestResult>;
+    runBacktestBatch(batch: EngineBacktestBatchRequest, buffers: Record<string, ArrayBuffer>, onProgress?: (fraction: number) => void): Promise<EngineBacktestBatchResult>;
     terminate(): void;
 }
 export interface BacktestWasmModule {
@@ -237,6 +277,8 @@ export interface CreateRunRequestBody {
     readonly metrics: EngineBacktestMetrics;
     readonly engineVersion: string;
     readonly configSchemaVersion: number;
+    /** Compact [[unix_ms, cumulative_return]]; omitted when the local run has no series. */
+    readonly returnCurve?: ReadonlyArray<readonly [number, number]>;
 }
 export interface EngineBacktestRunSuccess {
     readonly metrics: EngineBacktestMetrics;
@@ -247,3 +289,91 @@ export interface EngineBacktestRunSuccess {
     readonly persisted: boolean;
     readonly coverageWarnings: readonly string[];
 }
+export interface EngineBacktestSweepPointRow {
+    readonly coordinate: {
+        readonly values: readonly number[];
+    };
+    readonly status: "ok" | "failed";
+    readonly metrics?: {
+        readonly returnPct: number;
+        readonly maxDrawdownPct: number;
+        readonly sharpeRatio: number;
+        readonly winRatePct: number;
+        readonly maxLeverage?: number;
+        readonly liquidationCount: number;
+        readonly netPnl: number;
+        readonly finalEquity: number;
+        readonly tradeCount: number;
+    };
+    readonly error?: string;
+}
+export interface CreateSweepPointSummary {
+    readonly coordinate: {
+        readonly values: readonly number[];
+    };
+    readonly status: "ok" | "failed";
+    readonly error?: string;
+    readonly metrics?: EngineBacktestSweepPointRow["metrics"];
+}
+export interface CreateSweepRequestBody {
+    readonly clientSweepId: string;
+    readonly baseInputSnapshot: PersistedSnapshot;
+    readonly axes: ReadonlyArray<{
+        readonly path: readonly string[];
+        readonly current: number;
+        readonly values: readonly number[];
+    }>;
+    readonly searchMetadata: {
+        readonly mode: SweepMode;
+        readonly searchMode: SweepSearchMode;
+        readonly concurrency: number;
+        readonly requestedCombinationCount: number;
+        readonly sampled: boolean;
+    };
+    readonly aggregateSummary: {
+        readonly successfulCount: number;
+        readonly failedCount: number;
+        readonly liquidatedCount: number;
+        readonly elapsedMs: number;
+        readonly best: {
+            readonly coordinate: {
+                readonly values: readonly number[];
+            };
+            readonly returnPct: number;
+        } | null;
+    };
+    readonly pointSummaries: readonly CreateSweepPointSummary[];
+    readonly engineVersion: string;
+    readonly configSchemaVersion: number;
+}
+export interface EngineBacktestSweepSuccess {
+    readonly persisted: boolean;
+    readonly sweepId?: string;
+    readonly clientSweepId?: string;
+    readonly mode: SweepMode;
+    readonly searchMode: SweepSearchMode;
+    readonly requestedCombinationCount: number;
+    readonly sampled: boolean;
+    readonly combinationCount: number;
+    readonly successfulCount: number;
+    readonly failedCount: number;
+    readonly liquidatedCount: number;
+    readonly elapsedMs: number;
+    readonly best: {
+        readonly coordinate: {
+            readonly values: readonly number[];
+        };
+        readonly returnPct: number;
+        readonly config: unknown;
+    } | null;
+    readonly points: readonly EngineBacktestSweepPointRow[];
+    readonly engineVersion: string;
+    readonly experimentId?: string;
+    readonly experimentUrl?: string;
+    readonly coverageWarnings: readonly string[];
+    readonly axes: ReadonlyArray<{
+        readonly path: readonly string[];
+        readonly current: number;
+        readonly values: readonly number[];
+    }>;
+}

package/dist/install/exec.js

@@ -50,7 +50,11 @@ async function confirmTty(message) {
     try {
         const answer = await rl.question(`${message} [Y/n] `);
         const token = answer.trim().toLowerCase();
-        return token === "" || token === "y" || token === "yes";
+        return (token === "" ||
+            token === "y" ||
+            token === "yes" ||
+            token === "是" ||
+            token === "好");
     }
     finally {
         rl.close();

package/dist/install/wizard.js

@@ -49,24 +49,21 @@ function parseNpmListVersion(output) {
     return match?.[1] ?? null;
 }
 function skillsListHasAlphafox(output) {
-    const prefix = types_1.SKILLS_NAME_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`(^|\\s)${prefix}[\\w-]+`, "m").test(output);
+    return /(^|\s)alphafox(?:-[\w-]+)?(?=\s|$)/m.test(output);
 }
 function nextSteps(input) {
-    const steps = [
-        "Restart the AI tool so newly installed Skills are loaded.",
-    ];
+    const steps = ["请重启 AI 工具，以便加载刚安装的 Skills。"];
     if (input.auth.action === "skipped" || input.auth.action === "planned") {
         steps.push("alphafox auth login --browser --format json --no-input", "alphafox auth login --no-wait --format json --no-input");
     }
-    steps.push("alphafox doctor --format json --no-input", `Agent install guide: ${types_1.AGENT_INSTALL_GUIDE_BLOB_URL}`);
+    steps.push("alphafox doctor --format json --no-input", `Agent 安装指南：${types_1.AGENT_INSTALL_GUIDE_BLOB_URL}`);
     if (input.dryRun) {
-        steps.unshift("This was --dry-run; re-run without it to apply changes.");
+        steps.unshift("这是 --dry-run，去掉该参数再运行才会真正安装。");
     }
     return steps;
 }
 async function runInstallWizard(flags, env = process.env, runner = (0, exec_1.createDefaultInstallRunner)(env, defaultSearchDirs())) {
-    runner.log("Setting up Alphafox CLI...");
+    runner.log("正在安装 Alphafox CLI…");
     const installedVer = await readGloballyInstalledVersion(runner);
     const latestVer = await readLatestVersion(runner);
     const needsUpgrade = Boolean(installedVer) &&
@@ -140,7 +137,7 @@ async function npmPrefixGlobal(runner) {
 async function stepInstallCli(flags, runner, versions) {
     const { installedVer, latestVer, needsUpgrade } = versions;
     if (installedVer && !needsUpgrade) {
-        runner.log(`Already installed (${installedVer}). Skipped`);
+        runner.log(`已安装（${installedVer}），已跳过`);
         return {
             action: flags.dryRun ? "planned" : "skipped",
             version: installedVer,
@@ -149,8 +146,8 @@ async function stepInstallCli(flags, runner, versions) {
     }
     if (flags.dryRun) {
         runner.log(needsUpgrade
-            ? `Would upgrade ${version_1.CLI_PACKAGE} (${installedVer} → ${latestVer ?? "latest"})`
-            : `Would install ${version_1.CLI_PACKAGE} globally`);
+            ? `将升级 ${version_1.CLI_PACKAGE}（${installedVer} → ${latestVer ?? "latest"}）`
+            : `将全局安装 ${version_1.CLI_PACKAGE}`);
         return {
             action: "planned",
             previousVersion: installedVer ?? undefined,
@@ -158,8 +155,8 @@ async function stepInstallCli(flags, runner, versions) {
         };
     }
     runner.log(needsUpgrade
-        ? `Upgrading ${version_1.CLI_PACKAGE} (${installedVer} → ${latestVer})...`
-        : `Installing ${version_1.CLI_PACKAGE} globally...`);
+        ? `正在升级 ${version_1.CLI_PACKAGE}（${installedVer} → ${latestVer}）…`
+        : `正在全局安装 ${version_1.CLI_PACKAGE}…`);
     try {
         await runner.exec("npm", ["install", "-g", version_1.CLI_PACKAGE], {
             timeoutMs: NPM_TIMEOUT_MS,
@@ -169,13 +166,13 @@ async function stepInstallCli(flags, runner, versions) {
         throw new types_1.InstallError({
             type: "install",
             subtype: "npm_global_failed",
-            message: `Failed to install ${version_1.CLI_PACKAGE} globally.`,
+            message: `全局安装 ${version_1.CLI_PACKAGE} 失败。`,
             hint: `npm install -g ${version_1.CLI_PACKAGE}`,
             details: err instanceof Error ? err.message : String(err),
         });
     }
     const after = (await readGloballyInstalledVersion(runner)) ?? latestVer ?? version_1.CLI_VERSION;
-    runner.log(needsUpgrade ? `Upgraded to ${after}` : "Installed globally");
+    runner.log(needsUpgrade ? `已升级到 ${after}` : "已全局安装");
     return {
         action: needsUpgrade ? "upgraded" : "installed",
         version: after,
@@ -214,7 +211,7 @@ async function stepInstallSkills(flags, runner) {
     const sources = await resolveSkillsSources(runner);
     const already = flags.dryRun ? false : await skillsAlreadyInstalled(runner);
     if (already) {
-        runner.log("Skills already installed. Skipped");
+        runner.log("Skills 已安装，已跳过");
         return {
             action: "skipped",
             source: sources[0],
@@ -223,19 +220,19 @@ async function stepInstallSkills(flags, runner) {
         };
     }
     if (flags.dryRun) {
-        runner.log(`Would install Skills from ${sources[0] ?? types_1.SKILLS_GITHUB_SOURCE}`);
+        runner.log(`将从 ${sources[0] ?? types_1.SKILLS_GITHUB_SOURCE} 安装 Skills`);
         return {
             action: "planned",
             source: sources[0] ?? types_1.SKILLS_GITHUB_SOURCE,
             scope: "global",
         };
     }
-    runner.log("Installing AI Skills...");
+    runner.log("正在安装 AI Skills…");
     let lastError;
     for (const source of sources) {
         try {
             await runner.exec("npx", ["-y", "skills", "add", source, "-y", "-g"], { timeoutMs: SKILLS_TIMEOUT_MS });
-            runner.log(`Skills installed (${source})`);
+            runner.log(`Skills 已安装（${source}）`);
             return { action: "installed", source, scope: "global" };
         }
         catch (err) {
@@ -245,7 +242,7 @@ async function stepInstallSkills(flags, runner) {
     throw new types_1.InstallError({
         type: "install",
         subtype: "skills_add_failed",
-        message: "Failed to install Agent Skills.",
+        message: "安装 Agent Skills 失败。",
         hint: `npx skills add ${types_1.SKILLS_GITHUB_SOURCE} -y -g`,
         details: lastError instanceof Error ? lastError.message : String(lastError),
     });
@@ -274,16 +271,16 @@ async function stepAuth(flags, runner) {
         if (flags.dryRun) {
             return { action: "planned", reason: "non-interactive" };
         }
-        runner.log("To finish setup, run:\n  alphafox auth login --browser\n  alphafox auth login --no-wait --format json --no-input");
+        runner.log("要完成安装，请运行：\n  alphafox auth login --browser\n  alphafox auth login --no-wait --format json --no-input");
         return { action: "skipped", reason: "non-interactive" };
     }
     if (flags.dryRun) {
-        runner.log("Would prompt for alphafox auth login --browser");
+        runner.log("将提示运行 alphafox auth login --browser");
         return { action: "planned", reason: "tty" };
     }
-    const yes = await runner.confirm("Log in now so Agents can call the public Application API?");
+    const yes = await runner.confirm("现在登录，以便 Agent 可以调用公开 Application API？");
     if (!yes) {
-        runner.log("Skipped login. Run alphafox auth login later.");
+        runner.log("已跳过登录。之后可运行 alphafox auth login。");
         return { action: "skipped", reason: "declined" };
     }
     const bin = await resolveAlphafoxBin(runner);
@@ -291,19 +288,19 @@ async function stepAuth(flags, runner) {
         throw new types_1.InstallError({
             type: "install",
             subtype: "cli_bin_missing",
-            message: "alphafox binary not found after install.",
-            hint: "Ensure the npm global bin directory is on PATH, then run alphafox auth login --browser.",
+            message: "安装完成后找不到 alphafox 可执行文件。",
+            hint: "请确认 npm 全局 bin 目录在 PATH 中，然后运行 alphafox auth login --browser。",
         });
     }
     try {
         await runner.execInherit(bin, ["auth", "login", "--browser"], {
             timeoutMs: 10 * 60_000,
         });
-        runner.log("Login complete");
+        runner.log("登录完成");
         return { action: "completed" };
     }
     catch (err) {
-        runner.log("Login failed. Run alphafox auth login --browser to retry.");
+        runner.log("登录失败。请运行 alphafox auth login --browser 重试。");
         return {
             action: "failed",
             reason: err instanceof Error ? err.message : String(err),
@@ -319,7 +316,7 @@ function installHelpData() {
             "alphafox install --no-auth",
             "alphafox install --dry-run",
         ],
-        description: "Install @alphafox/cli globally and copy co-versioned Agent Skills into detected agents (Cursor, Claude Code, Codex, …) via npx skills add.",
+        description: "全局安装 @alphafox/cli，并通过 npx skills add 把同版本 Agent Skills 写入本机已检测到的 Agent（Cursor、Claude Code、Codex 等）的用户级目录。",
         agentGuide: types_1.AGENT_INSTALL_GUIDE_BLOB_URL,
     };
 }

package/dist/resolve-symbols/catalog.d.ts

@@ -0,0 +1,3 @@
+export declare const MARKET_SYMBOLS_PATH = "/api/v1/market/symbols";
+export declare function marketSymbolsPath(exchangeId: string): string;
+export declare function extractCatalogSymbols(json: unknown): string[];