poe-code 3.0.178 → 3.0.180

package/packages/cmdkit/dist/index.compile-check.d.ts

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

package/packages/cmdkit/dist/index.compile-check.js

@@ -0,0 +1,50 @@
+import { S } from "@poe-code/cmdkit-schema";
+import { defineCommand, defineGroup } from "./index.js";
+const ignoredScope = ["cli", "sdk"];
+const ignoredSecrets = {
+    apiKey: { env: "API_KEY" },
+    sessionToken: { env: "SESSION_TOKEN", optional: true },
+};
+const ignoredCommand = defineCommand({
+    name: "deploy",
+    params: S.Object({
+        name: S.String(),
+        force: S.Optional(S.Boolean()),
+    }),
+    secrets: ignoredSecrets,
+    requires: {
+        auth: true,
+    },
+    render: {
+        json: (result) => result,
+    },
+    handler: async ({ params, secrets, fetch, fs, env, progress }) => {
+        progress(params.name);
+        await fs.exists("/tmp");
+        env.get("HOME");
+        void fetch;
+        return {
+            authenticated: Boolean(secrets.apiKey),
+            force: params.force ?? false,
+        };
+    },
+});
+const ignoredGroup = defineGroup({
+    name: "root",
+    scope: ignoredScope,
+    secrets: {
+        rootToken: { env: "ROOT_TOKEN" },
+    },
+    children: [ignoredCommand],
+    default: ignoredCommand,
+});
+const ignoredStringSchema = S.String();
+const ignoredNumberSchema = S.Number();
+const ignoredBooleanSchema = S.Boolean();
+const ignoredEnumSchema = S.Enum(["cli", "sdk"]);
+const ignoredArraySchema = S.Array(S.String());
+const ignoredObjectSchema = S.Object({
+    name: S.String(),
+    enabled: S.Optional(S.Boolean()),
+});
+const ignoredOptionalSchema = S.Optional(S.Number());

package/packages/cmdkit/dist/index.d.ts

@@ -0,0 +1,164 @@
+import type { ObjectSchema, Static } from "../../cmdkit-schema/dist/index.js";
+import type { LoggerOutput, RenderTableOptions, ThemePalette } from "../../design-system/dist/index.js";
+type ScopeValue = "cli" | "mcp" | "sdk";
+type AnyObjectSchema = ObjectSchema<Record<string, never>>;
+type EmptyServices = Record<string, never>;
+type ScopeInput = readonly Scope[] | undefined;
+export type Scope = ScopeValue;
+export interface SecretDefinition {
+    env: string;
+    description?: string;
+    optional?: boolean;
+}
+export type SecretDeclarations = Record<string, SecretDefinition>;
+type OptionalSecretKeys<TSecrets extends SecretDeclarations> = {
+    [TKey in keyof TSecrets]: TSecrets[TKey] extends {
+        optional: true;
+    } ? TKey : never;
+}[keyof TSecrets];
+type RequiredSecretKeys<TSecrets extends SecretDeclarations> = Exclude<keyof TSecrets, OptionalSecretKeys<TSecrets>>;
+export type InferSecrets<TSecrets extends SecretDeclarations | undefined> = TSecrets extends SecretDeclarations ? {
+    [TKey in RequiredSecretKeys<TSecrets>]: string;
+} & {
+    [TKey in OptionalSecretKeys<TSecrets>]?: string;
+} : Record<string, never>;
+export interface HandlerFs {
+    readFile(path: string, encoding?: BufferEncoding): Promise<string>;
+    writeFile(path: string, contents: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+}
+export interface HandlerEnv {
+    get(key: string): string | undefined;
+}
+export interface RenderPrimitives {
+    logger: LoggerOutput;
+    renderTable(options: RenderTableOptions): string;
+    getTheme(): ThemePalette;
+    note(message: string, title?: string): void;
+}
+export interface CheckResult {
+    ok: boolean;
+    message?: string;
+}
+export type GroupCheckContext<TServices extends object = EmptyServices> = TServices & {
+    params?: unknown;
+    secrets?: Record<string, string | undefined>;
+    fetch: typeof globalThis.fetch;
+    fs: HandlerFs;
+    env: HandlerEnv;
+    progress(message: string): void;
+};
+export type CommandCheckContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & {
+    params?: Static<TParamsSchema>;
+    secrets?: InferSecrets<TSecrets>;
+    fetch: typeof globalThis.fetch;
+    fs: HandlerFs;
+    env: HandlerEnv;
+    progress(message: string): void;
+};
+export interface Requires<TContext = unknown> {
+    auth?: boolean;
+    apiVersion?: string;
+    check?: (ctx: TContext) => Promise<CheckResult>;
+}
+export interface Renderers<TResult> {
+    rich?: (result: TResult, primitives: RenderPrimitives) => void;
+    markdown?: (result: TResult, primitives: RenderPrimitives) => string;
+    json?: (result: TResult, primitives: RenderPrimitives) => unknown;
+}
+export type HandlerContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & {
+    params: Static<TParamsSchema>;
+    secrets: InferSecrets<TSecrets>;
+    fetch: typeof globalThis.fetch;
+    fs: HandlerFs;
+    env: HandlerEnv;
+    progress(message: string): void;
+};
+export interface CommandConfig<TServices extends object, TParamsSchema extends ObjectSchema<any>, TSecrets extends SecretDeclarations | undefined, TResult> {
+    name: string;
+    description?: string;
+    aliases?: string[];
+    positional?: string[];
+    params: TParamsSchema;
+    secrets?: TSecrets;
+    scope?: Scope[];
+    confirm?: boolean;
+    requires?: Requires<CommandCheckContext<TParamsSchema, TSecrets, TServices>>;
+    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult>;
+    render?: Renderers<TResult>;
+}
+export interface Command<TServices extends object = EmptyServices, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TResult = unknown> {
+    kind: "command";
+    name: string;
+    description?: string;
+    aliases: string[];
+    positional: string[];
+    params: TParamsSchema;
+    secrets: SecretDeclarations;
+    scope: Scope[];
+    confirm: boolean;
+    requires?: Requires<any>;
+    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult>;
+    render?: Renderers<TResult>;
+}
+export interface GroupConfig<TServices extends object> {
+    name: string;
+    description?: string;
+    aliases?: string[];
+    scope?: Scope[];
+    secrets?: SecretDeclarations;
+    requires?: Requires<GroupCheckContext<TServices>>;
+    children: Array<CommandNode<TServices>>;
+    default?: Command<TServices, any, any, any>;
+}
+export interface Group<TServices extends object = EmptyServices> {
+    kind: "group";
+    name: string;
+    description?: string;
+    aliases: string[];
+    scope?: Scope[];
+    secrets: SecretDeclarations;
+    requires?: Requires<any>;
+    children: Array<CommandNode<TServices>>;
+    default?: Command<TServices, any, any, any>;
+}
+export type CommandNode<TServices extends object = EmptyServices> = Command<TServices, any, any, any> | Group<TServices>;
+export interface CommandTypeInfo<TName extends string = string, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TResult = unknown, TOwnScope extends ScopeInput = ScopeInput> {
+    name: TName;
+    params: TParamsSchema;
+    result: TResult;
+    ownScope: TOwnScope;
+}
+export interface GroupTypeInfo<TServices extends object = EmptyServices, TName extends string = string, TChildren extends readonly unknown[] = readonly CommandNode<TServices>[], TOwnScope extends ScopeInput = ScopeInput> {
+    name: TName;
+    children: TChildren;
+    ownScope: TOwnScope;
+}
+type TypedCommandMetadata<TName extends string, TParamsSchema extends ObjectSchema<any>, TResult, TOwnScope extends ScopeInput> = {
+    readonly __cmdkitCommandTypeInfo: CommandTypeInfo<TName, TParamsSchema, TResult, TOwnScope>;
+};
+type TypedGroupMetadata<TServices extends object, TName extends string, TChildren extends readonly unknown[], TOwnScope extends ScopeInput> = {
+    readonly __cmdkitGroupTypeInfo: GroupTypeInfo<TServices, TName, TChildren, TOwnScope>;
+};
+export declare class UserError extends Error {
+    constructor(message: string);
+}
+export interface CommandRequirementOptions {
+    apiVersion?: string;
+    authEnvVar?: string;
+    env?: Record<string, string | undefined>;
+}
+export declare function resolveCommandSecrets(command: Command<any, any, any, any>, env?: Record<string, string | undefined>): Record<string, string | undefined>;
+export declare function assertCommandRequirements(command: Command<any, any, any, any>, context: GroupCheckContext<any>, options?: CommandRequirementOptions): Promise<void>;
+export declare function defineCommand<TServices extends object = EmptyServices, TName extends string = string, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TResult = unknown, TOwnScope extends ScopeInput = undefined>(config: Omit<CommandConfig<TServices, TParamsSchema, TSecrets, TResult>, "name" | "scope"> & {
+    name: TName;
+    scope?: TOwnScope;
+}): Command<TServices, TParamsSchema, TSecrets, TResult> & TypedCommandMetadata<TName, TParamsSchema, TResult, TOwnScope>;
+export declare function defineGroup<TServices extends object = EmptyServices, TName extends string = string, TChildren extends readonly unknown[] = readonly CommandNode<TServices>[], TOwnScope extends ScopeInput = undefined>(config: Omit<GroupConfig<TServices>, "name" | "children" | "scope"> & {
+    name: TName;
+    children: TChildren & readonly CommandNode<TServices>[];
+    scope?: TOwnScope;
+}): Group<TServices> & TypedGroupMetadata<TServices, TName, TChildren, TOwnScope>;
+export declare function getCommandSourcePath(command: Command<any, any, any, any>): string | undefined;
+export { S, toJsonSchema } from "../../cmdkit-schema/dist/index.js";
+export type { AnySchema, ArraySchema, BooleanSchema, EnumSchema, JsonSchema, NumberSchema, ObjectSchema, OptionalSchema, Static, StringSchema } from "../../cmdkit-schema/dist/index.js";