@alphafox/cli 0.1.5 → 0.2.0

package/dist/catalog/operations.d.ts

@@ -1,7 +1,8 @@
 /**
- * Embedded capability catalog (co-versioned with CLI).
- * Source of truth for full matrix lives in alphafox-contracts + parity-matrix-m0.md.
+ * CLI capability catalog generated from `@alphafoxai/contracts/public-api`.
+ * Do not hand-edit generated JSON; run `node scripts/generate-catalog.mjs`.
  */
+import type { CompatibilityRange } from "./compatibility";
 export interface CatalogOperation {
     readonly operationId: string;
     readonly method: string;
@@ -9,26 +10,98 @@ export interface CatalogOperation {
     readonly role: string;
     readonly risk: "read" | "write" | "high-risk-write" | string;
     readonly scopes: readonly string[];
+    readonly auth?: string;
     readonly stream?: boolean;
+    readonly file?: boolean;
+    readonly pagination?: boolean;
+    readonly idempotent?: boolean;
+    readonly catchAll?: boolean;
     readonly mvp?: boolean;
+    readonly contractStatus?: string;
+    readonly requestBodySchema?: string | null;
+    readonly querySchema?: string | null;
+    readonly responseSchema?: string;
+    readonly errorSchema?: string;
     readonly description?: string;
 }
-export declare const CATALOG_VERSION = "2026-08-11";
+export interface CatalogSource {
+    readonly package: string;
+    readonly export: string;
+    readonly contractsSha: string;
+    readonly registryVersion: string;
+    readonly contractVersion: string;
+    readonly scannedAt: string;
+    readonly totalOperations: number;
+    readonly cliOperations: number;
+}
+export interface OperationSchemaDocument {
+    readonly operationId: string;
+    readonly method: string;
+    readonly path: string;
+    readonly role: string;
+    readonly risk: string;
+    readonly auth: string;
+    readonly scopes: readonly string[];
+    readonly idempotent: boolean;
+    readonly pagination: boolean;
+    readonly stream: boolean;
+    readonly file: boolean;
+    readonly contractStatus: string;
+    readonly webZodContract: string;
+    readonly sharedContractRef: string;
+    readonly compatibility: CompatibilityRange;
+    readonly request: {
+        readonly contentType: string | null;
+        readonly path: Record<string, unknown>;
+        readonly query: Record<string, unknown> | null;
+        readonly body: Record<string, unknown> | null;
+        readonly pathParamNames: readonly string[];
+    };
+    readonly response: {
+        readonly contentType: string;
+        readonly success: Record<string, unknown>;
+    };
+    readonly error: {
+        readonly contentType: "application/problem+json" | string;
+        readonly schema: Record<string, unknown>;
+    };
+}
+export declare const CATALOG_SOURCE: CatalogSource;
+export declare const CATALOG_VERSION: string;
 export declare const CATALOG_OPERATIONS: readonly CatalogOperation[];
+export declare const COMPATIBILITY_RANGE: CompatibilityRange;
+export declare function getCompatibilityRange(): CompatibilityRange;
 export declare function findCatalogOperation(operationId: string): CatalogOperation | undefined;
+export declare function findCatalogOperationByRoute(method: string, path: string): CatalogOperation | undefined;
+export declare function getOperationSchemaDocument(operationId: string): OperationSchemaDocument | undefined;
+export declare function extractPathParamNames(template: string): string[];
 export declare function buildCapabilityManifest(): {
     contractVersion: string;
     registryVersion: string;
+    minCliVersion: string;
+    maxCliVersion: string;
+    openapi: string;
+    source: CatalogSource;
     operations: {
         operationId: string;
         method: string;
         path: string;
         role: string;
         risk: string;
+        auth: string;
         scopes: readonly string[];
         stream: boolean;
+        file: boolean;
+        pagination: boolean;
+        idempotent: boolean;
         mvp: boolean;
+        contractStatus: string;
+        requestBodySchema: string | null;
+        querySchema: string | null;
+        responseSchema: string;
+        errorSchema: string;
     }[];
 };
 /** Resolve path templates like /api/v1/backtests/{backtestId}. */
 export declare function resolveOperationPath(template: string, params: Record<string, string>): string;
+export declare function checkGeneratedCatalogCompatibility(cliVersion: string): import("./compatibility").CompatibilityResult;

package/dist/catalog/operations.js

@@ -1,237 +1,105 @@
 "use strict";
 /**
- * Embedded capability catalog (co-versioned with CLI).
- * Source of truth for full matrix lives in alphafox-contracts + parity-matrix-m0.md.
+ * CLI capability catalog generated from `@alphafoxai/contracts/public-api`.
+ * Do not hand-edit generated JSON; run `node scripts/generate-catalog.mjs`.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CATALOG_OPERATIONS = exports.CATALOG_VERSION = void 0;
+exports.COMPATIBILITY_RANGE = exports.CATALOG_OPERATIONS = exports.CATALOG_VERSION = exports.CATALOG_SOURCE = void 0;
+exports.getCompatibilityRange = getCompatibilityRange;
 exports.findCatalogOperation = findCatalogOperation;
+exports.findCatalogOperationByRoute = findCatalogOperationByRoute;
+exports.getOperationSchemaDocument = getOperationSchemaDocument;
+exports.extractPathParamNames = extractPathParamNames;
 exports.buildCapabilityManifest = buildCapabilityManifest;
 exports.resolveOperationPath = resolveOperationPath;
-exports.CATALOG_VERSION = "2026-08-11";
-exports.CATALOG_OPERATIONS = [
-    {
-        operationId: "meta.get",
-        method: "GET",
-        path: "/api/v1/meta",
-        role: "public",
-        risk: "read",
-        scopes: [],
-        mvp: true,
-        description: "Environment, commit SHA, contract version",
-    },
-    {
-        operationId: "me.whoami",
-        method: "GET",
-        path: "/api/v1/me",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile"],
-        mvp: true,
-        description: "Authenticated user identity",
-    },
-    {
-        operationId: "trading.strategy_definitions.list",
-        method: "GET",
-        path: "/api/v1/trading/strategy-definitions",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "trading:read"],
-        mvp: true,
-    },
-    {
-        operationId: "exchange_connectors.list",
-        method: "GET",
-        path: "/api/v1/exchange-connectors",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "exchange-connectors:read"],
-        mvp: true,
-    },
-    {
-        operationId: "trading.traders.list",
-        method: "GET",
-        path: "/api/v1/trading/traders",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "trading:read"],
-        mvp: true,
-    },
-    {
-        operationId: "chats.create",
-        method: "POST",
-        path: "/api/v1/chats",
-        role: "user",
-        risk: "write",
-        scopes: ["openid", "profile", "chats:write"],
-        mvp: true,
-    },
-    {
-        operationId: "backtests.create",
-        method: "POST",
-        path: "/api/v1/backtests",
-        role: "user",
-        risk: "write",
-        scopes: ["openid", "profile", "backtests:write"],
-        mvp: true,
-    },
-    {
-        operationId: "backtests.byId.get",
-        method: "GET",
-        path: "/api/v1/backtests/{backtestId}",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "backtests:read"],
-        mvp: true,
-    },
-    {
-        operationId: "backtests.byId.stream",
-        method: "GET",
-        path: "/api/v1/backtests/{backtestId}/stream",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "backtests:read"],
-        stream: true,
-        mvp: true,
-    },
-    {
-        operationId: "backtests.byId.cancel",
-        method: "POST",
-        path: "/api/v1/backtests/{backtestId}/cancel",
-        role: "user",
-        risk: "write",
-        scopes: ["openid", "profile", "backtests:write"],
-        mvp: true,
-    },
-    {
-        operationId: "trading.traders.byId.start",
-        method: "POST",
-        path: "/api/v1/trading/traders/{traderId}/start",
-        role: "user",
-        risk: "high-risk-write",
-        scopes: ["openid", "profile", "trading:write", "trading:high-risk"],
-    },
-    {
-        operationId: "trading.traders.byId.stop",
-        method: "POST",
-        path: "/api/v1/trading/traders/{traderId}/stop",
-        role: "user",
-        risk: "high-risk-write",
-        scopes: ["openid", "profile", "trading:write", "trading:high-risk"],
-    },
-    {
-        operationId: "wallet.get",
-        method: "GET",
-        path: "/api/v1/wallet",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "wallet:read"],
-    },
-    {
-        operationId: "notification.channels.list",
-        method: "GET",
-        path: "/api/v1/notification/channels",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "notification:read"],
-    },
-    {
-        operationId: "account.exchange_uids.list",
-        method: "GET",
-        path: "/api/v1/account/exchange-uids",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "account:read"],
-    },
-    {
-        operationId: "subscriptions.me.get",
-        method: "GET",
-        path: "/api/v1/subscriptions/me",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "subscriptions:read"],
-    },
-    {
-        operationId: "managed_wallets.list",
-        method: "GET",
-        path: "/api/v1/managed-wallets",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "managed-wallets:read"],
-    },
-    {
-        operationId: "strategy_plaza.publications.list",
-        method: "GET",
-        path: "/api/v1/strategy-plaza/publications",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "strategy-plaza:read"],
-    },
-    {
-        operationId: "spread_radar.pairs.list",
-        method: "GET",
-        path: "/api/v1/spread-radar/pairs",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "spread-radar:read"],
-    },
-    {
-        operationId: "trader_dna.report.get",
-        method: "GET",
-        path: "/api/v1/trader-dna/report",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "trader-dna:read"],
-    },
-    {
-        operationId: "platform_statistics.get",
-        method: "GET",
-        path: "/api/v1/platform-statistics",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "platform-statistics:read"],
-    },
-    {
-        operationId: "asr.transcribe",
-        method: "POST",
-        path: "/api/v1/asr/transcribe",
-        role: "user",
-        risk: "write",
-        scopes: ["openid", "profile", "asr:write"],
-    },
-    {
-        operationId: "lite.catalog_config.get",
-        method: "GET",
-        path: "/api/v1/lite/catalog-config",
-        role: "user",
-        risk: "read",
-        scopes: ["openid", "profile", "lite:read"],
-    },
-    {
-        operationId: "admin.users.list",
-        method: "GET",
-        path: "/api/v1/admin/users",
-        role: "admin",
-        risk: "read",
-        scopes: ["openid", "profile", "admin:read"],
-    },
-];
+exports.checkGeneratedCatalogCompatibility = checkGeneratedCatalogCompatibility;
+const compatibility_1 = require("./compatibility");
+const registry_json_1 = __importDefault(require("./generated/registry.json"));
+const schemas_json_1 = __importDefault(require("./generated/schemas.json"));
+const generated = registry_json_1.default;
+const generatedSchemas = schemas_json_1.default;
+exports.CATALOG_SOURCE = generated.source;
+exports.CATALOG_VERSION = generated.compatibility.contractVersion;
+exports.CATALOG_OPERATIONS = generated.operations;
+exports.COMPATIBILITY_RANGE = generated.compatibility;
+function getCompatibilityRange() {
+    return exports.COMPATIBILITY_RANGE;
+}
 function findCatalogOperation(operationId) {
     return exports.CATALOG_OPERATIONS.find((op) => op.operationId === operationId);
 }
+function findCatalogOperationByRoute(method, path) {
+    const verb = method.toUpperCase();
+    return exports.CATALOG_OPERATIONS.find((op) => op.method.toUpperCase() === verb &&
+        pathTemplateMatchesOp(op.path, path, Boolean(op.catchAll)));
+}
+function pathTemplateMatchesOp(template, actual, catchAll) {
+    const t = template.split("/").filter(Boolean);
+    const a = actual.split("/").filter(Boolean);
+    if (catchAll) {
+        if (a.length < t.length)
+            return false;
+        for (let i = 0; i < t.length; i += 1) {
+            const seg = t[i];
+            if (seg.startsWith("{") && seg.endsWith("}"))
+                continue;
+            if (seg !== a[i])
+                return false;
+        }
+        return true;
+    }
+    if (t.length !== a.length)
+        return false;
+    for (let i = 0; i < t.length; i += 1) {
+        const seg = t[i];
+        if (seg.startsWith("{") && seg.endsWith("}"))
+            continue;
+        if (seg !== a[i])
+            return false;
+    }
+    return true;
+}
+function getOperationSchemaDocument(operationId) {
+    return generatedSchemas[operationId];
+}
+function extractPathParamNames(template) {
+    const names = [];
+    const re = /\{([^}]+)\}/g;
+    let m;
+    while ((m = re.exec(template))) {
+        names.push(m[1]);
+    }
+    return names;
+}
 function buildCapabilityManifest() {
     return {
-        contractVersion: exports.CATALOG_VERSION,
-        registryVersion: "1.0.0",
+        contractVersion: exports.COMPATIBILITY_RANGE.contractVersion,
+        registryVersion: exports.COMPATIBILITY_RANGE.registryVersion,
+        minCliVersion: exports.COMPATIBILITY_RANGE.minCliVersion,
+        maxCliVersion: exports.COMPATIBILITY_RANGE.maxCliVersion,
+        openapi: exports.COMPATIBILITY_RANGE.openapi,
+        source: exports.CATALOG_SOURCE,
         operations: exports.CATALOG_OPERATIONS.map((op) => ({
             operationId: op.operationId,
             method: op.method,
             path: op.path,
             role: op.role,
             risk: op.risk,
+            auth: op.auth ?? "bearer",
             scopes: op.scopes,
             stream: Boolean(op.stream),
+            file: Boolean(op.file),
+            pagination: Boolean(op.pagination),
+            idempotent: Boolean(op.idempotent),
             mvp: Boolean(op.mvp),
+            contractStatus: op.contractStatus ?? "envelope",
+            requestBodySchema: op.requestBodySchema ?? null,
+            querySchema: op.querySchema ?? null,
+            responseSchema: op.responseSchema ?? "JsonValue",
+            errorSchema: op.errorSchema ?? "ProblemDetails",
         })),
     };
 }
@@ -245,3 +113,9 @@ function resolveOperationPath(template, params) {
         return encodeURIComponent(value);
     });
 }
+function checkGeneratedCatalogCompatibility(cliVersion) {
+    return (0, compatibility_1.checkCliCompatibility)({
+        cliVersion,
+        contractVersion: exports.COMPATIBILITY_RANGE.contractVersion,
+    }, exports.COMPATIBILITY_RANGE);
+}