bioscode 0.1.5

package/dist/auth/index.d.ts

@@ -0,0 +1,202 @@
+import { z } from "zod";
+export declare namespace Auth {
+    const Oauth: z.ZodObject<{
+        type: z.ZodLiteral<"oauth">;
+        refresh: z.ZodString;
+        access: z.ZodString;
+        expires: z.ZodNumber;
+        enterpriseUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth";
+        refresh: string;
+        access: string;
+        expires: number;
+        enterpriseUrl?: string | undefined;
+    }, {
+        type: "oauth";
+        refresh: string;
+        access: string;
+        expires: number;
+        enterpriseUrl?: string | undefined;
+    }>;
+    const Api: z.ZodObject<{
+        type: z.ZodLiteral<"api">;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "api";
+        key: string;
+    }, {
+        type: "api";
+        key: string;
+    }>;
+    const WellKnown: z.ZodObject<{
+        type: z.ZodLiteral<"wellknown">;
+        key: z.ZodString;
+        token: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "wellknown";
+        key: string;
+        token: string;
+    }, {
+        type: "wellknown";
+        key: string;
+        token: string;
+    }>;
+    const ServiceAccount: z.ZodObject<{
+        type: z.ZodLiteral<"service-account">;
+        serviceAccount: z.ZodObject<{
+            project_id: z.ZodString;
+            client_email: z.ZodString;
+            private_key: z.ZodString;
+            location: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            project_id: string;
+            client_email: string;
+            private_key: string;
+            location?: string | undefined;
+        }, {
+            project_id: string;
+            client_email: string;
+            private_key: string;
+            location?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "service-account";
+        serviceAccount: {
+            project_id: string;
+            client_email: string;
+            private_key: string;
+            location?: string | undefined;
+        };
+    }, {
+        type: "service-account";
+        serviceAccount: {
+            project_id: string;
+            client_email: string;
+            private_key: string;
+            location?: string | undefined;
+        };
+    }>;
+    const PerplexityApiKey: z.ZodObject<{
+        type: z.ZodLiteral<"perplexity-api-key">;
+        apiKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "perplexity-api-key";
+        apiKey: string;
+    }, {
+        type: "perplexity-api-key";
+        apiKey: string;
+    }>;
+    const Info: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"oauth">;
+        refresh: z.ZodString;
+        access: z.ZodString;
+        expires: z.ZodNumber;
+        enterpriseUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth";
+        refresh: string;
+        access: string;
+        expires: number;
+        enterpriseUrl?: string | undefined;
+    }, {
+        type: "oauth";
+        refresh: string;
+        access: string;
+        expires: number;
+        enterpriseUrl?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"api">;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "api";
+        key: string;
+    }, {
+        type: "api";
+        key: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"wellknown">;
+        key: z.ZodString;
+        token: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "wellknown";
+        key: string;
+        token: string;
+    }, {
+        type: "wellknown";
+        key: string;
+        token: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"service-account">;
+        serviceAccount: z.ZodObject<{
+            project_id: z.ZodString;
+            client_email: z.ZodString;
+            private_key: z.ZodString;
+            location: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            project_id: string;
+            client_email: string;
+            private_key: string;
+            location?: string | undefined;
+        }, {
+            project_id: string;
+            client_email: string;
+            private_key: string;
+            location?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "service-account";
+        serviceAccount: {
+            project_id: string;
+            client_email: string;
+            private_key: string;
+            location?: string | undefined;
+        };
+    }, {
+        type: "service-account";
+        serviceAccount: {
+            project_id: string;
+            client_email: string;
+            private_key: string;
+            location?: string | undefined;
+        };
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"perplexity-api-key">;
+        apiKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "perplexity-api-key";
+        apiKey: string;
+    }, {
+        type: "perplexity-api-key";
+        apiKey: string;
+    }>]>;
+    type Info = z.infer<typeof Info>;
+    function get(providerID: string): Promise<{
+        type: "oauth";
+        refresh: string;
+        access: string;
+        expires: number;
+        enterpriseUrl?: string | undefined;
+    } | {
+        type: "api";
+        key: string;
+    } | {
+        type: "wellknown";
+        key: string;
+        token: string;
+    } | {
+        type: "service-account";
+        serviceAccount: {
+            project_id: string;
+            client_email: string;
+            private_key: string;
+            location?: string | undefined;
+        };
+    } | {
+        type: "perplexity-api-key";
+        apiKey: string;
+    }>;
+    function all(): Promise<Record<string, Info>>;
+    function set(key: string, info: Info): Promise<void>;
+    function remove(key: string): Promise<void>;
+}

package/dist/brand/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Brand Module
+ *
+ * Re-exports brand configuration from theme.ts for backward compatibility
+ */
+export { PRODUCT_NAME, PRODUCT_COMMAND, CONFIG_DIR, CONFIG_FILE, RULES_FILE, ENV_PREFIX, LOGO_SIMPLE, LOGO_EXTENDED, LOGO_ASCII, LOCAL_RULE_FILES, GLOBAL_RULE_FILES, DEFAULT_THEME, PRIMARY_COLOR, themes, getTheme, setTheme, getThemeNames, initTheme, } from "../theme";
+export type { Theme } from "../theme";

package/dist/brand/loader.d.ts

@@ -0,0 +1,463 @@
+/**
+ * Brand Configuration Loader
+ *
+ * Handles loading and merging brand configurations from files
+ */
+import z from "zod";
+import { type BrandConfig, type BrandConfigOverride } from "./schema";
+export declare namespace BrandLoader {
+    /**
+     * Brand loading error
+     */
+    const LoadError: {
+        new (data: {
+            message: string;
+            path?: string | undefined;
+            cause?: any;
+        }, options?: ErrorOptions): {
+            readonly name: "BrandLoadError";
+            readonly data: {
+                message: string;
+                path?: string | undefined;
+                cause?: any;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"BrandLoadError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                    path: z.ZodOptional<z.ZodString>;
+                    cause: z.ZodOptional<z.ZodAny>;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                }, {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "BrandLoadError";
+                data: {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                };
+            }, {
+                name: "BrandLoadError";
+                data: {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                };
+            }>;
+            toObject(): {
+                name: "BrandLoadError";
+                data: {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"BrandLoadError">;
+            data: z.ZodObject<{
+                message: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+                cause: z.ZodOptional<z.ZodAny>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                path?: string | undefined;
+                cause?: any;
+            }, {
+                message: string;
+                path?: string | undefined;
+                cause?: any;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            name: "BrandLoadError";
+            data: {
+                message: string;
+                path?: string | undefined;
+                cause?: any;
+            };
+        }, {
+            name: "BrandLoadError";
+            data: {
+                message: string;
+                path?: string | undefined;
+                cause?: any;
+            };
+        }>;
+        isInstance(input: any): input is {
+            readonly name: "BrandLoadError";
+            readonly data: {
+                message: string;
+                path?: string | undefined;
+                cause?: any;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"BrandLoadError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                    path: z.ZodOptional<z.ZodString>;
+                    cause: z.ZodOptional<z.ZodAny>;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                }, {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "BrandLoadError";
+                data: {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                };
+            }, {
+                name: "BrandLoadError";
+                data: {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                };
+            }>;
+            toObject(): {
+                name: "BrandLoadError";
+                data: {
+                    message: string;
+                    path?: string | undefined;
+                    cause?: any;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): {
+            new (data: z.input<Data>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: z.input<Data>;
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                toObject(): {
+                    name: Name;
+                    data: z.input<Data>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+            isInstance(input: any): input is InstanceType</*elided*/ any>;
+            create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+            readonly Unknown: {
+                new (data: {
+                    message: string;
+                }, options?: ErrorOptions): {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            message: string;
+                        }, {
+                            message: string;
+                        }>;
+                    }, "strip", z.ZodTypeAny, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                isInstance(input: any): input is {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            message: string;
+                        }, {
+                            message: string;
+                        }>;
+                    }, "strip", z.ZodTypeAny, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                }, {
+                    message: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            }, {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            }>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): {
+                new (data: z.input<Data>, options?: ErrorOptions): {
+                    readonly name: Name;
+                    readonly data: z.input<Data>;
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                    toObject(): {
+                        name: Name;
+                        data: z.input<Data>;
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                isInstance(input: any): input is InstanceType</*elided*/ any>;
+                create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            readonly Unknown: /*elided*/ any;
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    type LoadError = InstanceType<typeof LoadError>;
+    /**
+     * Load brand config from a JSONC file
+     */
+    function loadFromFile(filepath: string, partial?: boolean): Promise<BrandConfig | BrandConfigOverride>;
+    /**
+     * Load brand config from repository root
+     */
+    function loadRepoConfig(repoRoot?: string): Promise<BrandConfig>;
+    /**
+     * Load client-level brand override
+     */
+    function loadClientConfig(configDir: string): Promise<BrandConfigOverride | null>;
+    /**
+     * Get default Porter brand configuration
+     */
+    function getDefaultBrand(): BrandConfig;
+    /**
+     * Merge base brand config with client override
+     */
+    function merge(base: BrandConfig, override: BrandConfigOverride | null): BrandConfig;
+    /**
+     * Save brand config to file
+     */
+    function saveToFile(filepath: string, config: BrandConfig | BrandConfigOverride): Promise<void>;
+}

package/dist/brand/rules.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Brand-aware Rule Files
+ *
+ * Provides dynamic rule file names based on brand configuration
+ */
+export declare namespace BrandRules {
+    /**
+     * Get local rule files for the current brand
+     * Returns array with brand-specific rule file + standard files
+     */
+    function getLocalRuleFiles(): Promise<string[]>;
+    /**
+     * Get global rule files for the current brand
+     * Returns array with only the brand-specific rule file
+     */
+    function getGlobalRuleFiles(): Promise<string[]>;
+    /**
+     * Get local rule files synchronously (uses build-time config)
+     */
+    function getLocalRuleFilesSync(): string[];
+    /**
+     * Get global rule files synchronously (uses build-time config)
+     */
+    function getGlobalRuleFilesSync(): string[];
+}