@alphafox/cli 0.3.3 → 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/wizard.js

@@ -49,8 +49,7 @@ 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 = ["请重启 AI 工具，以便加载刚安装的 Skills。"];

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[];

package/dist/resolve-symbols/catalog.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKET_SYMBOLS_PATH = void 0;
+exports.marketSymbolsPath = marketSymbolsPath;
+exports.extractCatalogSymbols = extractCatalogSymbols;
+const errors_1 = require("./errors");
+exports.MARKET_SYMBOLS_PATH = "/api/v1/market/symbols";
+function marketSymbolsPath(exchangeId) {
+    const query = new URLSearchParams({ exchange: exchangeId }).toString();
+    return `${exports.MARKET_SYMBOLS_PATH}?${query}`;
+}
+function extractCatalogSymbols(json) {
+    const root = asRecord(json);
+    const payload = asRecord(root?.data) ?? root;
+    const symbols = payload?.symbols;
+    if (!Array.isArray(symbols)) {
+        throw new errors_1.ResolveSymbolsError({
+            type: "runtime",
+            subtype: "catalog_invalid",
+            message: "market.symbols.list response did not include a symbols array",
+            details: json,
+        });
+    }
+    const out = [];
+    const seen = new Set();
+    for (const item of symbols) {
+        if (typeof item !== "string")
+            continue;
+        const trimmed = item.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    if (out.length === 0) {
+        throw new errors_1.ResolveSymbolsError({
+            type: "runtime",
+            subtype: "catalog_empty",
+            message: "market.symbols.list returned no contract symbols",
+            details: json,
+        });
+    }
+    return out;
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}

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

@@ -0,0 +1,18 @@
+export declare class ResolveSymbolsError extends Error {
+    readonly type: string;
+    readonly subtype?: string;
+    readonly status?: number;
+    readonly code?: string | number;
+    readonly hint?: string;
+    readonly details?: unknown;
+    constructor(input: {
+        readonly message: string;
+        readonly type?: string;
+        readonly subtype?: string;
+        readonly status?: number;
+        readonly code?: string | number;
+        readonly hint?: string;
+        readonly details?: unknown;
+    });
+}
+export declare function isResolveSymbolsError(value: unknown): value is ResolveSymbolsError;

package/dist/resolve-symbols/errors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveSymbolsError = void 0;
+exports.isResolveSymbolsError = isResolveSymbolsError;
+class ResolveSymbolsError extends Error {
+    type;
+    subtype;
+    status;
+    code;
+    hint;
+    details;
+    constructor(input) {
+        super(input.message);
+        this.name = "ResolveSymbolsError";
+        this.type = input.type ?? "runtime";
+        this.subtype = input.subtype;
+        this.status = input.status;
+        this.code = input.code;
+        this.hint = input.hint;
+        this.details = input.details;
+    }
+}
+exports.ResolveSymbolsError = ResolveSymbolsError;
+function isResolveSymbolsError(value) {
+    return value instanceof ResolveSymbolsError;
+}

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

@@ -0,0 +1,8 @@
+export declare const RESOLVE_SYMBOLS_DEFAULT_EXCHANGE = "binance_perp_usdt";
+export interface ResolveSymbolsExchange {
+    readonly id: string;
+    readonly label: string;
+    readonly aliases: readonly string[];
+}
+export declare const RESOLVE_SYMBOLS_EXCHANGES: readonly ResolveSymbolsExchange[];
+export declare function resolveSymbolsExchangeId(raw: string): ResolveSymbolsExchange;

package/dist/resolve-symbols/exchanges.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOLVE_SYMBOLS_EXCHANGES = exports.RESOLVE_SYMBOLS_DEFAULT_EXCHANGE = void 0;
+exports.resolveSymbolsExchangeId = resolveSymbolsExchangeId;
+exports.RESOLVE_SYMBOLS_DEFAULT_EXCHANGE = "binance_perp_usdt";
+exports.RESOLVE_SYMBOLS_EXCHANGES = [
+    {
+        id: "binance_perp_usdt",
+        label: "Binance",
+        aliases: ["binance", "binanceusdm", "binance_perp_usdt"],
+    },
+    {
+        id: "okx_perp_usdt",
+        label: "OKX",
+        aliases: ["okx", "okx_perp_usdt"],
+    },
+    {
+        id: "bybit_perp_usdt",
+        label: "Bybit",
+        aliases: ["bybit", "bybit_perp_usdt"],
+    },
+    {
+        id: "bitget_perp_usdt",
+        label: "Bitget",
+        aliases: ["bitget", "bitget_perp_usdt"],
+    },
+    {
+        id: "hyperliquid_perp_usdc",
+        label: "HyperLiquid",
+        aliases: ["hyperliquid", "hyperliquid_perp_usdc"],
+    },
+    {
+        id: "aster_perp_usdt",
+        label: "Aster",
+        aliases: ["aster", "aster_perp_usdt"],
+    },
+];
+const EXCHANGE_BY_ALIAS = new Map();
+for (const exchange of exports.RESOLVE_SYMBOLS_EXCHANGES) {
+    EXCHANGE_BY_ALIAS.set(exchange.id, exchange);
+    for (const alias of exchange.aliases) {
+        EXCHANGE_BY_ALIAS.set(alias.toLowerCase(), exchange);
+    }
+}
+function resolveSymbolsExchangeId(raw) {
+    const key = raw.trim().toLowerCase();
+    const exchange = EXCHANGE_BY_ALIAS.get(key);
+    if (!exchange) {
+        const allowed = exports.RESOLVE_SYMBOLS_EXCHANGES.map((item) => item.aliases[0]).join("|");
+        throw new Error(`--exchange must be ${allowed} (got ${raw.trim() || "<empty>"})`);
+    }
+    return exchange;
+}

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

@@ -0,0 +1,6 @@
+import type { CatalogSymbol, ResolveSymbolsQueryResult } from "./types";
+export declare function normalizeSymbolSearchKey(value: string): string;
+export declare function parseCatalogSymbol(symbol: string): CatalogSymbol | null;
+export declare function indexCatalogSymbols(symbols: readonly string[]): readonly CatalogSymbol[];
+export declare function resolveQueryAgainstCatalog(query: string, catalog: readonly CatalogSymbol[], limit?: number): ResolveSymbolsQueryResult;
+export declare function levenshtein(left: string, right: string): number;