@alphafox/cli 0.3.3 → 0.3.5

package/dist/resolve-symbols/parse-args.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOLVE_SYMBOLS_USAGE = exports.RESOLVE_SYMBOLS_MAX_LIMIT = exports.RESOLVE_SYMBOLS_DEFAULT_LIMIT = void 0;
+exports.parseResolveSymbolsArgs = parseResolveSymbolsArgs;
+const errors_1 = require("./errors");
+const exchanges_1 = require("./exchanges");
+exports.RESOLVE_SYMBOLS_DEFAULT_LIMIT = 8;
+exports.RESOLVE_SYMBOLS_MAX_LIMIT = 25;
+exports.RESOLVE_SYMBOLS_USAGE = [
+    "alphafox resolve-symbols <query...> [--exchange binance] [--limit 8]",
+    "alphafox resolve-symbols --query BTC --query ETH --exchange okx",
+];
+function usage(message, subtype = "invalid_args") {
+    throw new errors_1.ResolveSymbolsError({
+        type: "usage",
+        subtype,
+        message,
+        hint: exports.RESOLVE_SYMBOLS_USAGE[0],
+        status: 400,
+    });
+}
+function takeValue(args, i, flag) {
+    const next = args[i + 1];
+    if (next === undefined || next.startsWith("--")) {
+        usage(`Missing value for ${flag}`, "missing_flag_value");
+    }
+    return { value: next, next: i + 1 };
+}
+function parseResolveSymbolsArgs(args) {
+    const queries = [];
+    let exchange = exchanges_1.RESOLVE_SYMBOLS_DEFAULT_EXCHANGE;
+    let limit = exports.RESOLVE_SYMBOLS_DEFAULT_LIMIT;
+    let help = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--help" || a === "-h") {
+            help = true;
+            continue;
+        }
+        if (!a.startsWith("--")) {
+            queries.push(a);
+            continue;
+        }
+        const eq = a.indexOf("=");
+        const flag = eq >= 0 ? a.slice(0, eq) : a;
+        const inline = eq >= 0 ? a.slice(eq + 1) : undefined;
+        const read = () => {
+            if (inline !== undefined)
+                return inline;
+            const taken = takeValue(args, i, flag);
+            i = taken.next;
+            return taken.value;
+        };
+        switch (flag) {
+            case "--query":
+            case "--symbol":
+                queries.push(read());
+                break;
+            case "--exchange":
+                exchange = read();
+                break;
+            case "--limit": {
+                const n = Number(read());
+                if (!Number.isInteger(n) || n <= 0 || n > exports.RESOLVE_SYMBOLS_MAX_LIMIT) {
+                    usage(`--limit must be an integer 1..${exports.RESOLVE_SYMBOLS_MAX_LIMIT}`, "invalid_limit");
+                }
+                limit = n;
+                break;
+            }
+            default:
+                usage(`Unknown flag: ${flag}`, "unknown_flag");
+        }
+    }
+    if (help) {
+        return { help: true, queries: [], exchange, limit };
+    }
+    const normalizedQueries = queries.map((item) => item.trim()).filter(Boolean);
+    if (normalizedQueries.length === 0) {
+        usage("Provide at least one symbol query", "missing_query");
+    }
+    let resolvedExchange;
+    try {
+        resolvedExchange = (0, exchanges_1.resolveSymbolsExchangeId)(exchange).id;
+    }
+    catch (err) {
+        usage(err instanceof Error ? err.message : String(err), "invalid_exchange");
+    }
+    return {
+        help: false,
+        queries: uniqueQueries(normalizedQueries),
+        exchange: resolvedExchange,
+        limit,
+    };
+}
+function uniqueQueries(queries) {
+    const seen = new Set();
+    const out = [];
+    for (const query of queries) {
+        const key = query.toUpperCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(query);
+    }
+    return out;
+}

package/dist/resolve-symbols/run-command.d.ts

@@ -0,0 +1,21 @@
+import type { ApiRequestOptions, ApiResponse } from "../http/client";
+import type { ResolveSymbolsRunArgs, ResolveSymbolsSuccess } from "./types";
+export interface ResolveSymbolsCliFlags {
+    readonly profile?: string;
+    readonly format: "json" | "jsonl" | "text";
+    readonly yes: boolean;
+    readonly dryRun: boolean;
+    readonly noInput: boolean;
+    readonly unsafeCustomEndpoint?: string;
+    readonly jq?: string;
+}
+export interface ResolveSymbolsRunDeps {
+    readonly apiRequest?: (options: ApiRequestOptions, env?: NodeJS.ProcessEnv) => Promise<ApiResponse>;
+}
+export declare function resolveSymbolsHelpData(): {
+    readonly name: string;
+    readonly usage: string[];
+    readonly notes: string[];
+};
+export declare function executeResolveSymbols(args: ResolveSymbolsRunArgs, flags: ResolveSymbolsCliFlags, env?: NodeJS.ProcessEnv, deps?: ResolveSymbolsRunDeps): Promise<ResolveSymbolsSuccess>;
+export declare function cmdResolveSymbols(args: string[], flags: ResolveSymbolsCliFlags, env?: NodeJS.ProcessEnv, deps?: ResolveSymbolsRunDeps): Promise<number>;

package/dist/resolve-symbols/run-command.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSymbolsHelpData = resolveSymbolsHelpData;
+exports.executeResolveSymbols = executeResolveSymbols;
+exports.cmdResolveSymbols = cmdResolveSymbols;
+const profiles_1 = require("../config/profiles");
+const envelope_1 = require("../envelope");
+const client_1 = require("../http/client");
+const catalog_1 = require("./catalog");
+const errors_1 = require("./errors");
+const exchanges_1 = require("./exchanges");
+const match_1 = require("./match");
+const parse_args_1 = require("./parse-args");
+function extractErrorMessage(json, fallback) {
+    if (json && typeof json === "object") {
+        const o = json;
+        if (typeof o.message === "string")
+            return o.message;
+        if (typeof o.detail === "string")
+            return o.detail;
+        if (typeof o.error === "string")
+            return o.error;
+        if (o.error && typeof o.error === "object") {
+            const e = o.error;
+            if (typeof e.message === "string")
+                return e.message;
+        }
+    }
+    return fallback || "Request failed";
+}
+function extractErrorCode(json) {
+    if (json && typeof json === "object") {
+        const o = json;
+        if (typeof o.code === "string" || typeof o.code === "number")
+            return o.code;
+    }
+    return undefined;
+}
+function resolveSymbolsHelpData() {
+    return {
+        name: "resolve-symbols",
+        usage: parse_args_1.RESOLVE_SYMBOLS_USAGE,
+        notes: [
+            "Resolves user-mentioned tickers against the public linear-perp catalog from market.symbols.list",
+            "Default --exchange is binance (binance_perp_usdt). Aliases: binance|okx|bybit|bitget|hyperliquid|aster",
+            "Do not guess CCXT symbols. Exact match may be used directly; a single close match needs user confirmation; multiple close matches must be chosen by the user",
+            "Catalog CRUD remains alphafox market symbols list --exchange <id>",
+        ],
+    };
+}
+async function executeResolveSymbols(args, flags, env = process.env, deps = {}) {
+    if (args.help) {
+        throw new errors_1.ResolveSymbolsError({
+            type: "usage",
+            message: "internal: help should be handled by the command wrapper",
+        });
+    }
+    const exchange = (0, exchanges_1.resolveSymbolsExchangeId)(args.exchange);
+    const profile = (0, profiles_1.resolveProfile)(flags.profile, env, {
+        unsafeCustomEndpoint: flags.unsafeCustomEndpoint,
+    });
+    const api = deps.apiRequest ?? client_1.apiRequest;
+    const res = await api({
+        method: "GET",
+        path: (0, catalog_1.marketSymbolsPath)(exchange.id),
+        profile,
+    }, env);
+    if (res.status >= 400) {
+        throw new errors_1.ResolveSymbolsError({
+            type: "http",
+            status: res.status,
+            message: extractErrorMessage(res.json, res.bodyText),
+            code: extractErrorCode(res.json),
+            hint: res.status === 401 || res.status === 403
+                ? "Run alphafox auth login. Tokens live in the OS keychain."
+                : undefined,
+            details: res.json,
+        });
+    }
+    const catalog = (0, match_1.indexCatalogSymbols)((0, catalog_1.extractCatalogSymbols)(res.json));
+    return {
+        exchange: exchange.id,
+        exchangeLabel: exchange.label,
+        catalogSize: catalog.length,
+        queries: args.queries.map((query) => (0, match_1.resolveQueryAgainstCatalog)(query, catalog, args.limit)),
+    };
+}
+async function cmdResolveSymbols(args, flags, env = process.env, deps = {}) {
+    let parsed;
+    try {
+        parsed = (0, parse_args_1.parseResolveSymbolsArgs)(args);
+    }
+    catch (err) {
+        if ((0, errors_1.isResolveSymbolsError)(err)) {
+            (0, envelope_1.writeError)({
+                type: err.type,
+                subtype: err.subtype,
+                message: err.message,
+                hint: err.hint,
+                status: err.status,
+                details: err.details,
+            }, { exitCode: err.status === 401 || err.status === 403 ? 77 : undefined });
+        }
+        throw err;
+    }
+    if (parsed.help) {
+        (0, envelope_1.writeSuccess)(resolveSymbolsHelpData(), {
+            format: flags.format,
+            jq: flags.jq,
+        });
+        return 0;
+    }
+    const exchange = (0, exchanges_1.resolveSymbolsExchangeId)(parsed.exchange);
+    if (flags.dryRun) {
+        (0, envelope_1.writeSuccess)({
+            dryRun: true,
+            operationId: "market.symbols.list",
+            method: "GET",
+            path: (0, catalog_1.marketSymbolsPath)(exchange.id),
+            exchange: exchange.id,
+            exchangeLabel: exchange.label,
+            queries: parsed.queries,
+        }, { format: flags.format, jq: flags.jq });
+        return 0;
+    }
+    try {
+        const result = await executeResolveSymbols(parsed, flags, env, deps);
+        (0, envelope_1.writeSuccess)(result, {
+            format: flags.format,
+            jq: flags.jq,
+            meta: { operationId: "market.symbols.list" },
+        });
+        return 0;
+    }
+    catch (err) {
+        if ((0, errors_1.isResolveSymbolsError)(err)) {
+            (0, envelope_1.writeError)({
+                type: err.type,
+                subtype: err.subtype,
+                message: err.message,
+                hint: err.hint,
+                status: err.status,
+                code: err.code,
+                details: err.details,
+            }, { exitCode: err.status === 401 || err.status === 403 ? 77 : undefined });
+        }
+        throw err;
+    }
+}

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

@@ -0,0 +1,37 @@
+export type ResolveSymbolsStatus = "exact" | "close" | "ambiguous" | "none";
+export type ResolveSymbolsMatchReason = "exact_canonical" | "exact_compact" | "exact_pair" | "exact_base" | "prefix" | "contains" | "close";
+export interface ResolveSymbolsMatch {
+    readonly symbol: string;
+    readonly reason: ResolveSymbolsMatchReason;
+    readonly score: number;
+}
+export interface ResolveSymbolsQueryResult {
+    readonly query: string;
+    readonly status: ResolveSymbolsStatus;
+    readonly resolved: string | null;
+    readonly needsConfirmation: boolean;
+    readonly matches: readonly ResolveSymbolsMatch[];
+    readonly matchCount: number;
+}
+export interface ResolveSymbolsSuccess {
+    readonly exchange: string;
+    readonly exchangeLabel: string;
+    readonly catalogSize: number;
+    readonly queries: readonly ResolveSymbolsQueryResult[];
+}
+export interface ResolveSymbolsRunArgs {
+    readonly help: boolean;
+    readonly queries: readonly string[];
+    readonly exchange: string;
+    readonly limit: number;
+}
+export interface CatalogSymbol {
+    readonly symbol: string;
+    readonly base: string;
+    readonly quote: string;
+    readonly pair: string;
+    readonly compact: string;
+    readonly searchKey: string;
+    readonly baseKey: string;
+    readonly compactKey: string;
+}

package/dist/resolve-symbols/types.js

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

package/dist/skills/manager.d.ts

@@ -0,0 +1,96 @@
+export interface SkillManifestFile {
+    readonly path: string;
+    readonly sha256: string;
+    readonly size: number;
+}
+export interface SkillManifestEntry {
+    readonly name: string;
+    readonly version: string;
+    readonly hash: string;
+    readonly files: readonly SkillManifestFile[];
+}
+export interface SkillsBundleManifest {
+    readonly schemaVersion: 1;
+    readonly packageName: "@alphafox/cli";
+    readonly packageVersion: string;
+    readonly contractVersion: string;
+    readonly bundleHash: string;
+    readonly skills: readonly SkillManifestEntry[];
+}
+export interface InstalledSkillState {
+    readonly version: string;
+    readonly hash: string;
+}
+export interface SkillsInstallState {
+    readonly schemaVersion: 1;
+    readonly packageVersion: string;
+    readonly contractVersion: string;
+    readonly bundleHash: string;
+    readonly syncedAt: string;
+    readonly skills: Readonly<Record<string, InstalledSkillState>>;
+}
+export type SkillStatus = "current" | "missing" | "stale" | "modified";
+export interface InspectedSkill {
+    readonly name: string;
+    readonly expectedVersion: string;
+    readonly installedVersion: string | null;
+    readonly expectedHash: string;
+    readonly installedHash: string | null;
+    readonly status: SkillStatus;
+    readonly managed: boolean;
+}
+export interface SkillsStatus {
+    readonly bundleVersion: string;
+    readonly contractVersion: string;
+    readonly bundleHash: string;
+    readonly installedRoot: string;
+    readonly skills: readonly InspectedSkill[];
+    readonly orphans: readonly {
+        readonly name: string;
+        readonly installedHash: string;
+        readonly recordedHash: string;
+        readonly modified: boolean;
+    }[];
+    readonly summary: Readonly<Record<SkillStatus, number>>;
+    readonly restartRequired: boolean;
+}
+export interface SkillsSyncResult {
+    readonly action: "synced" | "planned" | "skipped";
+    readonly updated: readonly string[];
+    readonly removed: readonly string[];
+    readonly blocked: readonly string[];
+    readonly backupDir?: string;
+    readonly status: SkillsStatus;
+    readonly restartRequired: boolean;
+}
+export interface SkillsSyncDeps {
+    readonly install: (names: readonly string[]) => Promise<void>;
+    readonly remove?: (names: readonly string[]) => Promise<void>;
+    readonly now?: () => Date;
+}
+export declare function buildSkillsManifest(packageRoot: string, versions: {
+    readonly packageVersion: string;
+    readonly contractVersion: string;
+}): SkillsBundleManifest;
+export declare function writeSkillsManifest(packageRoot: string, outputPath: string, versions: {
+    readonly packageVersion: string;
+    readonly contractVersion: string;
+}): SkillsBundleManifest;
+export declare function loadAndVerifySkillsManifest(packageRoot: string, manifestPath?: string): SkillsBundleManifest;
+export declare function inspectSkills(input: {
+    readonly manifest: SkillsBundleManifest;
+    readonly installedRoot: string;
+    readonly state: SkillsInstallState | null;
+}): SkillsStatus;
+export declare function syncSkills(input: {
+    readonly manifest: SkillsBundleManifest;
+    readonly packageRoot: string;
+    readonly installedRoot: string;
+    readonly statePath: string;
+    readonly dryRun: boolean;
+    readonly force: boolean;
+}, deps: SkillsSyncDeps): Promise<SkillsSyncResult>;
+export declare function loadSkillsState(path: string): SkillsInstallState | null;
+export declare function hashSkillDirectory(skillRoot: string): string;
+export declare function readSkillVersion(skillPath: string): string | null;
+export declare function readSkillName(skillPath: string): string | null;