@quantbrasil/cli 0.1.0-beta.0

package/dist/vendor/core/capabilities/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/capabilities/registry.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKrB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;AAErE,eAAO,MAAM,sBAAsB,EAE9B,MAAM,CAAC,YAAY,EAAE,CAAC,OAAO,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAC;AAE/D,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjD"}

package/dist/vendor/core/capabilities/registry.js

@@ -0,0 +1,14 @@
+import { analyticsCapabilities } from "./analytics.js";
+import { assetCapabilities } from "./assets.js";
+import { marketCapabilities } from "./market.js";
+import { portfolioCapabilities } from "./portfolios.js";
+export const capabilityRegistry = [
+    ...marketCapabilities,
+    ...assetCapabilities,
+    ...portfolioCapabilities,
+    ...analyticsCapabilities,
+];
+export const capabilityRegistryById = Object.fromEntries(capabilityRegistry.map(capability => [capability.id, capability]));
+export function getCapabilityById(id) {
+    return capabilityRegistryById[id];
+}

package/dist/vendor/core/capabilities/shared.d.ts

@@ -0,0 +1,3 @@
+export declare const publicRuntimeVisibility: readonly ["cli", "opencode"];
+export declare const standardOutputModes: readonly ["json", "human"];
+//# sourceMappingURL=shared.d.ts.map

package/dist/vendor/core/capabilities/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/capabilities/shared.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,8BAA+B,CAAC;AACpE,eAAO,MAAM,mBAAmB,4BAA6B,CAAC"}

package/dist/vendor/core/capabilities/shared.js

@@ -0,0 +1,2 @@
+export const publicRuntimeVisibility = ["cli", "opencode"];
+export const standardOutputModes = ["json", "human"];

package/dist/vendor/core/capabilities/types.d.ts

@@ -0,0 +1,75 @@
+export type CapabilityVisibility = "cli" | "opencode";
+export type CapabilityKind = "read" | "mutation";
+export type CapabilityGroup = "market" | "assets" | "portfolios" | "analytics";
+export type CapabilityHttpMethod = "GET" | "POST";
+export type CapabilityInputMode = "none" | "query" | "json_body";
+export type CapabilityOutputMode = "json" | "human";
+export type CapabilityParameterType = "string" | "integer" | "number" | "enum" | "string_array" | "enum_array";
+export type CapabilityCollectionFormat = "repeatable" | "comma_separated" | "space_separated";
+export type CapabilityDefaultValue = string | number | boolean | readonly (string | number | boolean)[];
+/** Backend schema references for one deterministic capability. */
+export interface CapabilitySchemaReference {
+    /** Request schema name, or `null` when the route takes no request payload. */
+    request: string | null;
+    /** Response schema name. This is always required. */
+    response: string;
+}
+/** Exact backend transport contract used by the capability executor. */
+export interface CapabilityHttpMetadata {
+    method: CapabilityHttpMethod;
+    path: `/api/desk/tools/${string}`;
+    inputMode: CapabilityInputMode;
+    schemas: CapabilitySchemaReference;
+}
+/** Shared fields for CLI positional and option parameters. */
+export interface CapabilityCliParameterBase {
+    name: string;
+    description: string;
+    type: CapabilityParameterType;
+    required: boolean;
+    placeholder?: string;
+    defaultValue?: CapabilityDefaultValue;
+    enumValues?: readonly string[];
+    multiple?: boolean;
+    collectionFormat?: CapabilityCollectionFormat;
+    exclusiveGroup?: string;
+}
+export interface CapabilityCliPositionalParameter extends CapabilityCliParameterBase {
+    kind: "positional";
+}
+export interface CapabilityCliOptionParameter extends CapabilityCliParameterBase {
+    kind: "option";
+    flag: `--${string}`;
+}
+export type CapabilityCliParameter = CapabilityCliPositionalParameter | CapabilityCliOptionParameter;
+/** CLI-facing metadata for one published capability. */
+export interface CapabilityCliMetadata {
+    group: CapabilityGroup;
+    command: string;
+    summary: string;
+    positional: readonly CapabilityCliPositionalParameter[];
+    options: readonly CapabilityCliOptionParameter[];
+    /**
+     * Copy-pasteable examples are required.
+     * Treat these as part of the product contract, especially for capabilities
+     * with mutually exclusive inputs, repeatable flags, or non-obvious defaults.
+     */
+    examples: readonly string[];
+}
+/** Metadata exposed to the hosted OpenCode runtime. */
+export interface CapabilityToolMetadata {
+    name: string;
+    title: string;
+}
+/** Canonical hand-authored contract for one deterministic Desk capability. */
+export interface CapabilityDefinition {
+    id: string;
+    kind: CapabilityKind;
+    visibility: readonly CapabilityVisibility[];
+    description: string;
+    http: CapabilityHttpMetadata;
+    cli: CapabilityCliMetadata;
+    tool: CapabilityToolMetadata;
+    outputModes: readonly CapabilityOutputMode[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/vendor/core/capabilities/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/capabilities/types.ts"],"names":[],"mappings":"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"}

package/dist/vendor/core/capabilities/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/core/errors.d.ts

@@ -0,0 +1,22 @@
+export declare class DeskCoreError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class DeskConfigError extends DeskCoreError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class DeskJsonCompatibilityError extends DeskCoreError {
+    readonly valuePath: string;
+    readonly valueDescription: string;
+    constructor(valuePath: string, valueDescription: string);
+}
+export declare class DeskHttpError extends DeskCoreError {
+    readonly status: number;
+    readonly path: string;
+    readonly requestId: string;
+    readonly body: unknown;
+    constructor(status: number, path: string, requestId: string, body: unknown);
+}
+export declare class DeskInvocationError extends DeskCoreError {
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/vendor/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD;AAED,qBAAa,eAAgB,SAAQ,aAAa;gBACpC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD;AAED,qBAAa,0BAA2B,SAAQ,aAAa;aAEzC,SAAS,EAAE,MAAM;aACjB,gBAAgB,EAAE,MAAM;gBADxB,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,MAAM;CAK3C;AAED,qBAAa,aAAc,SAAQ,aAAa;aAE5B,MAAM,EAAE,MAAM;aACd,IAAI,EAAE,MAAM;aACZ,SAAS,EAAE,MAAM;aACjB,IAAI,EAAE,OAAO;gBAHb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,OAAO;CAKhC;AAED,qBAAa,mBAAoB,SAAQ,aAAa;gBACxC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/dist/vendor/core/errors.js

@@ -0,0 +1,42 @@
+export class DeskCoreError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "DeskCoreError";
+    }
+}
+export class DeskConfigError extends DeskCoreError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "DeskConfigError";
+    }
+}
+export class DeskJsonCompatibilityError extends DeskCoreError {
+    valuePath;
+    valueDescription;
+    constructor(valuePath, valueDescription) {
+        super(`Value at ${valuePath} is not JSON-compatible: ${valueDescription}.`);
+        this.valuePath = valuePath;
+        this.valueDescription = valueDescription;
+        this.name = "DeskJsonCompatibilityError";
+    }
+}
+export class DeskHttpError extends DeskCoreError {
+    status;
+    path;
+    requestId;
+    body;
+    constructor(status, path, requestId, body) {
+        super(`Desk request failed (${status} ${path}, request ${requestId}).`);
+        this.status = status;
+        this.path = path;
+        this.requestId = requestId;
+        this.body = body;
+        this.name = "DeskHttpError";
+    }
+}
+export class DeskInvocationError extends DeskCoreError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "DeskInvocationError";
+    }
+}

package/dist/vendor/core/http/client.d.ts

@@ -0,0 +1,45 @@
+import type { CapabilityHttpMethod } from "../capabilities/types.js";
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonQueryScalar = string | number | boolean;
+export type JsonQueryValue = JsonQueryScalar | readonly JsonQueryScalar[] | null | undefined;
+export type JsonQueryParams = Record<string, JsonQueryValue>;
+export interface DeskClientConfig {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    defaultHeaders?: Record<string, string>;
+}
+export interface DeskJsonRequest {
+    method: CapabilityHttpMethod;
+    path: `/api/desk/${string}`;
+    authHeaders?: Record<string, string>;
+    headers?: Record<string, string>;
+    requestId?: string;
+    query?: JsonQueryParams;
+    body?: JsonValue;
+    abort?: AbortSignal;
+}
+export interface DeskJsonResponse<T extends JsonValue = JsonValue> {
+    data: T;
+    requestId: string;
+    status: number;
+}
+export interface DeskHttpClient {
+    request<T extends JsonValue = JsonValue>(request: DeskJsonRequest): Promise<DeskJsonResponse<T>>;
+}
+export interface DeskInternalAuthHeadersInput {
+    sessionID: string;
+    messageID?: string;
+    token?: string;
+}
+export declare const DESK_REQUEST_ID_PREFIX = "qbreq_";
+export declare const DESK_REQUEST_ID_HEADER = "x-request-id";
+export declare function resolveDeskBackendUrl(raw?: string): string;
+export declare function resolveDeskInternalToken(raw?: string): string;
+export declare function createDeskRequestId(): string;
+export declare function buildDeskInternalAuthHeaders(input: DeskInternalAuthHeadersInput): Record<string, string>;
+export declare function assertJsonCompatible(value: unknown, valuePath?: string): asserts value is JsonValue;
+export declare function createDeskHttpClient(config?: DeskClientConfig): DeskHttpClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/vendor/core/http/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/http/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAOrE,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAC7D,MAAM,MAAM,SAAS,GACjB,aAAa,GACb,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AACjC,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AACxD,MAAM,MAAM,cAAc,GACtB,eAAe,GACf,SAAS,eAAe,EAAE,GAC1B,IAAI,GACJ,SAAS,CAAC;AACd,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,oBAAoB,CAAC;IAC7B,IAAI,EAAE,aAAa,MAAM,EAAE,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAC/D,IAAI,EAAE,CAAC,CAAC;IACR,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACrC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,sBAAsB,WAAW,CAAC;AAC/C,eAAO,MAAM,sBAAsB,iBAAiB,CAAC;AAErD,wBAAgB,qBAAqB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED,wBAAgB,wBAAwB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAU7D;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,4BAA4B,GAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxB;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,SAAS,SAAM,GACd,OAAO,CAAC,KAAK,IAAI,SAAS,CA4C5B;AAED,wBAAgB,oBAAoB,CAClC,MAAM,GAAE,gBAAqB,GAC5B,cAAc,CAkEhB"}

package/dist/vendor/core/http/client.js

@@ -0,0 +1,170 @@
+import { randomUUID } from "node:crypto";
+import { DeskConfigError, DeskHttpError, DeskJsonCompatibilityError, } from "../errors.js";
+export const DESK_REQUEST_ID_PREFIX = "qbreq_";
+export const DESK_REQUEST_ID_HEADER = "x-request-id";
+export function resolveDeskBackendUrl(raw) {
+    const source = raw ??
+        process.env.QB_BACKEND_URL ??
+        process.env.DESK_API_URL ??
+        "http://127.0.0.1:8000";
+    return source.endsWith("/") ? source.slice(0, -1) : source;
+}
+export function resolveDeskInternalToken(raw) {
+    const token = raw ?? process.env.DESK_AGENT_SECRET ?? "";
+    if (!token) {
+        throw new DeskConfigError("DESK_AGENT_SECRET is not set. Internal Desk calls require machine auth.");
+    }
+    return token;
+}
+export function createDeskRequestId() {
+    return `${DESK_REQUEST_ID_PREFIX}${randomUUID()}`;
+}
+export function buildDeskInternalAuthHeaders(input) {
+    const headers = {
+        authorization: `Bearer ${resolveDeskInternalToken(input.token)}`,
+        "x-opencode-session-id": input.sessionID,
+    };
+    if (input.messageID) {
+        headers["x-opencode-message-id"] = input.messageID;
+    }
+    return headers;
+}
+export function assertJsonCompatible(value, valuePath = "$") {
+    if (value === null) {
+        return;
+    }
+    if (typeof value === "string" || typeof value === "boolean") {
+        return;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new DeskJsonCompatibilityError(valuePath, `non-finite number ${value}`);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const [index, item] of value.entries()) {
+            assertJsonCompatible(item, `${valuePath}[${index}]`);
+        }
+        return;
+    }
+    if (isPlainObject(value)) {
+        for (const [key, item] of Object.entries(value)) {
+            if (item === undefined) {
+                throw new DeskJsonCompatibilityError(`${valuePath}.${key}`, "undefined value");
+            }
+            assertJsonCompatible(item, `${valuePath}.${key}`);
+        }
+        return;
+    }
+    throw new DeskJsonCompatibilityError(valuePath, describeValue(value));
+}
+export function createDeskHttpClient(config = {}) {
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new DeskConfigError("Global fetch is unavailable. Pass a fetch implementation to createDeskHttpClient().");
+    }
+    const baseUrl = resolveDeskBackendUrl(config.baseUrl);
+    return {
+        async request(request) {
+            const requestId = request.requestId ?? createDeskRequestId();
+            const url = new URL(`${baseUrl}${request.path}`);
+            if (request.query) {
+                appendQueryParams(url, request.query);
+            }
+            const headers = {
+                accept: "application/json",
+                ...config.defaultHeaders,
+                ...request.headers,
+                ...request.authHeaders,
+                [DESK_REQUEST_ID_HEADER]: requestId,
+            };
+            let body;
+            if (request.body !== undefined) {
+                assertJsonCompatible(request.body);
+                headers["content-type"] = "application/json";
+                body = JSON.stringify(request.body);
+            }
+            const response = await fetchImpl(url.toString(), {
+                method: request.method,
+                headers,
+                body,
+                signal: request.abort,
+            });
+            const resolvedRequestId = response.headers.get(DESK_REQUEST_ID_HEADER) ?? requestId;
+            const payload = await readResponsePayload(response, response.ok);
+            if (!response.ok) {
+                throw new DeskHttpError(response.status, request.path, resolvedRequestId, payload);
+            }
+            assertJsonCompatible(payload);
+            return {
+                data: payload,
+                requestId: resolvedRequestId,
+                status: response.status,
+            };
+        },
+    };
+}
+function appendQueryParams(url, query) {
+    for (const [key, rawValue] of Object.entries(query)) {
+        if (rawValue === undefined || rawValue === null) {
+            continue;
+        }
+        if (isQueryScalarArray(rawValue)) {
+            for (const item of rawValue) {
+                url.searchParams.append(key, serializeQueryScalar(item, key));
+            }
+            continue;
+        }
+        url.searchParams.set(key, serializeQueryScalar(rawValue, key));
+    }
+}
+function serializeQueryScalar(value, key) {
+    if (typeof value === "number" && !Number.isFinite(value)) {
+        throw new DeskJsonCompatibilityError(`$.${key}`, `non-finite number ${value}`);
+    }
+    return String(value);
+}
+function isQueryScalarArray(value) {
+    return Array.isArray(value);
+}
+async function readResponsePayload(response, requireJson) {
+    const text = await response.text();
+    if (!text.trim()) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        if (requireJson) {
+            throw new DeskConfigError(`Desk endpoint ${response.url} returned a non-JSON success payload.`);
+        }
+        return text;
+    }
+}
+function isPlainObject(value) {
+    if (Object.prototype.toString.call(value) !== "[object Object]") {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === null || prototype === Object.prototype;
+}
+function describeValue(value) {
+    if (value === undefined) {
+        return "undefined";
+    }
+    if (typeof value === "bigint") {
+        return "bigint";
+    }
+    if (typeof value === "function") {
+        return "function";
+    }
+    if (typeof value === "symbol") {
+        return "symbol";
+    }
+    if (value instanceof Date) {
+        return "Date";
+    }
+    return Object.prototype.toString.call(value);
+}

package/dist/vendor/core/http/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/vendor/core/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/vendor/core/http/index.js

@@ -0,0 +1 @@
+export * from "./client.js";

package/dist/vendor/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./capabilities/index.js";
+export * from "./errors.js";
+export * from "./http/index.js";
+export * from "./invoke.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/vendor/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/dist/vendor/core/index.js

@@ -0,0 +1,4 @@
+export * from "./capabilities/index.js";
+export * from "./errors.js";
+export * from "./http/index.js";
+export * from "./invoke.js";

package/dist/vendor/core/invoke.d.ts

@@ -0,0 +1,17 @@
+import { type CapabilityId } from "./capabilities/registry.js";
+import type { CapabilityDefinition } from "./capabilities/types.js";
+import { type DeskHttpClient, type DeskJsonResponse, type JsonQueryParams, type JsonValue } from "./http/client.js";
+export interface InvokeCapabilityOptions {
+    capability: CapabilityDefinition | CapabilityId;
+    input?: JsonValue | JsonQueryParams;
+    client?: DeskHttpClient;
+    authHeaders?: Record<string, string>;
+    headers?: Record<string, string>;
+    requestId?: string;
+    abort?: AbortSignal;
+}
+export interface CapabilityInvocationResult<T extends JsonValue = JsonValue> extends DeskJsonResponse<T> {
+    capability: CapabilityDefinition;
+}
+export declare function invokeCapability<T extends JsonValue = JsonValue>(options: InvokeCapabilityOptions): Promise<CapabilityInvocationResult<T>>;
+//# sourceMappingURL=invoke.d.ts.map

package/dist/vendor/core/invoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../src/invoke.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,oBAAoB,GAAG,YAAY,CAAC;IAChD,KAAK,CAAC,EAAE,SAAS,GAAG,eAAe,CAAC;IACpC,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,0BAA0B,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,CACzE,SAAQ,gBAAgB,CAAC,CAAC,CAAC;IAC3B,UAAU,EAAE,oBAAoB,CAAC;CAClC;AAED,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACpE,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAkBxC"}

package/dist/vendor/core/invoke.js

@@ -0,0 +1,70 @@
+import { capabilityRegistryById, } from "./capabilities/registry.js";
+import { DeskInvocationError } from "./errors.js";
+import { assertJsonCompatible, createDeskHttpClient, } from "./http/client.js";
+export async function invokeCapability(options) {
+    const capability = resolveCapability(options.capability);
+    const client = options.client ?? createDeskHttpClient();
+    const request = buildCapabilityRequest(capability, options.input);
+    const response = await client.request({
+        method: capability.http.method,
+        path: capability.http.path,
+        authHeaders: options.authHeaders,
+        headers: options.headers,
+        requestId: options.requestId,
+        abort: options.abort,
+        ...request,
+    });
+    return {
+        capability,
+        ...response,
+    };
+}
+function resolveCapability(capability) {
+    if (typeof capability !== "string") {
+        return capability;
+    }
+    return capabilityRegistryById[capability];
+}
+function buildCapabilityRequest(capability, input) {
+    switch (capability.http.inputMode) {
+        case "none":
+            assertNoInput(capability, input);
+            return {};
+        case "query":
+            return {
+                query: normalizeQueryInput(capability, input),
+            };
+        case "json_body":
+            return {
+                body: normalizeJsonBodyInput(capability, input),
+            };
+    }
+}
+function assertNoInput(capability, input) {
+    if (input === undefined || input === null) {
+        return;
+    }
+    if (isRecord(input) && Object.keys(input).length === 0) {
+        return;
+    }
+    throw new DeskInvocationError(`${capability.id} does not accept input because its mode is "none".`);
+}
+function normalizeQueryInput(capability, input) {
+    if (input === undefined || input === null) {
+        return {};
+    }
+    if (!isRecord(input) || Array.isArray(input)) {
+        throw new DeskInvocationError(`${capability.id} requires a plain object input for query parameters.`);
+    }
+    return input;
+}
+function normalizeJsonBodyInput(capability, input) {
+    if (input === undefined) {
+        throw new DeskInvocationError(`${capability.id} requires JSON input because its mode is "json_body".`);
+    }
+    assertJsonCompatible(input);
+    return input;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@quantbrasil/cli",
+  "version": "0.1.0-beta.0",
+  "type": "module",
+  "description": "Public QuantBrasil CLI for deterministic operations",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/quantbrasil/quantbrasil.git",
+    "directory": "monorepo/packages/cli"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "skills",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "quantbrasil": "./bin/quantbrasil.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli/index.js",
+      "types": "./dist/cli/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "eslint": "^9.15.0",
+    "typescript": "^5.3.3",
+    "vitest": "^3.2.4",
+    "@repo/core": "0.0.0",
+    "@repo/eslint-config": "0.0.0",
+    "@repo/typescript-config": "0.0.0"
+  },
+  "scripts": {
+    "build": "pnpm --filter @repo/core build && pnpm run clean && tsc && node scripts/vendor-core.mjs",
+    "clean": "node scripts/clean.mjs",
+    "dev": "tsc --watch",
+    "lint": "eslint . --max-warnings 0",
+    "pack:smoke": "node scripts/smoke-packed-cli.mjs",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write \"**/*.{ts,js,json,md}\"",
+    "test": "vitest run"
+  }
+}

package/skills/quantbrasil/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: quantbrasil
+description: Use QuantBrasil CLI for deterministic market, asset, portfolio, and analytics workflows.
+---
+
+# QuantBrasil CLI
+
+Use this skill when user needs deterministic QuantBrasil data or analytics through CLI.
+
+## Routing
+
+- Check readiness first: `quantbrasil --status`
+- Inspect public surface when unsure: `quantbrasil capabilities --json`
+- Use narrow command first:
+  - asset discovery: `quantbrasil market assets`
+  - price lookup: `quantbrasil market price <ticker>`
+  - richer asset analysis: `quantbrasil assets overview <ticker> --sections ...`
+  - saved portfolio discovery: `quantbrasil portfolios list`
+  - saved portfolio details: `quantbrasil portfolios get <id>`
+  - portfolio analytics: `quantbrasil analytics historical-return|beta|var ...`
+- Use `--json` when output will be parsed by agent or script
+
+## References
+
+- CLI surface: [`references/cli.md`](./references/cli.md)
+- Common workflows: [`references/workflows.md`](./references/workflows.md)
+- Cost-aware behavior: [`references/costs.md`](./references/costs.md)
+- Failure handling: [`references/errors.md`](./references/errors.md)
+- Unsupported / not-yet-public operations: [`references/unsupported.md`](./references/unsupported.md)