byterover-cli 3.3.0 → 3.4.0

package/dist/agent/infra/swarm/config/swarm-config-schema.d.ts

@@ -0,0 +1,667 @@
+import { z } from 'zod';
+/**
+ * Resolve `${VAR}` patterns in a string using the given environment.
+ * Returns the original string if the variable is not found.
+ */
+export declare function resolveEnvVars(value: string, env: Record<string, string | undefined>): string;
+/**
+ * Full Zod schema for `.brv/swarm/config.yaml`.
+ * Accepts snake_case YAML input and outputs camelCase TypeScript.
+ */
+export declare const SwarmConfigSchema: z.ZodObject<{
+    budget: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        globalMonthlyCapCents: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        perProvider: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
+            maxQueriesPerMinute: z.ZodOptional<z.ZodNumber>;
+            monthlyCapCents: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            monthlyCapCents: number;
+            maxQueriesPerMinute?: number | undefined;
+        }, {
+            monthlyCapCents: number;
+            maxQueriesPerMinute?: number | undefined;
+        }>, {
+            monthlyCapCents: number;
+            maxQueriesPerMinute?: number | undefined;
+        }, unknown>>>;
+        warningThresholdPct: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        weightReductionThresholdPct: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        globalMonthlyCapCents: number;
+        warningThresholdPct: number;
+        weightReductionThresholdPct: number;
+        perProvider?: Record<string, {
+            monthlyCapCents: number;
+            maxQueriesPerMinute?: number | undefined;
+        }> | undefined;
+    }, {
+        globalMonthlyCapCents?: number | undefined;
+        perProvider?: Record<string, unknown> | undefined;
+        warningThresholdPct?: number | undefined;
+        weightReductionThresholdPct?: number | undefined;
+    }>, {
+        globalMonthlyCapCents: number;
+        warningThresholdPct: number;
+        weightReductionThresholdPct: number;
+        perProvider?: Record<string, {
+            monthlyCapCents: number;
+            maxQueriesPerMinute?: number | undefined;
+        }> | undefined;
+    }, unknown>>;
+    enrichment: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        edges: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+        }, {
+            from: string;
+            to: string;
+        }>, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        edges: {
+            from: string;
+            to: string;
+        }[];
+    }, {
+        edges?: {
+            from: string;
+            to: string;
+        }[] | undefined;
+    }>>>;
+    optimization: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        edgeLearning: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            explorationRate: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            fixThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            minObservationsToPrune: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            pruneThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            explorationRate: number;
+            fixThreshold: number;
+            minObservationsToPrune: number;
+            pruneThreshold: number;
+        }, {
+            enabled?: boolean | undefined;
+            explorationRate?: number | undefined;
+            fixThreshold?: number | undefined;
+            minObservationsToPrune?: number | undefined;
+            pruneThreshold?: number | undefined;
+        }>, {
+            enabled: boolean;
+            explorationRate: number;
+            fixThreshold: number;
+            minObservationsToPrune: number;
+            pruneThreshold: number;
+        }, unknown>>>;
+        templateOptimization: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            abTestSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            failureRateTrigger: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            frequency: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            abTestSize: number;
+            failureRateTrigger: number;
+            frequency: number;
+        }, {
+            enabled?: boolean | undefined;
+            abTestSize?: number | undefined;
+            failureRateTrigger?: number | undefined;
+            frequency?: number | undefined;
+        }>, {
+            enabled: boolean;
+            abTestSize: number;
+            failureRateTrigger: number;
+            frequency: number;
+        }, unknown>>>;
+    }, "strip", z.ZodTypeAny, {
+        edgeLearning: {
+            enabled: boolean;
+            explorationRate: number;
+            fixThreshold: number;
+            minObservationsToPrune: number;
+            pruneThreshold: number;
+        };
+        templateOptimization: {
+            enabled: boolean;
+            abTestSize: number;
+            failureRateTrigger: number;
+            frequency: number;
+        };
+    }, {
+        edgeLearning?: unknown;
+        templateOptimization?: unknown;
+    }>, {
+        edgeLearning: {
+            enabled: boolean;
+            explorationRate: number;
+            fixThreshold: number;
+            minObservationsToPrune: number;
+            pruneThreshold: number;
+        };
+        templateOptimization: {
+            enabled: boolean;
+            abTestSize: number;
+            failureRateTrigger: number;
+            frequency: number;
+        };
+    }, unknown>>>;
+    performance: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        fileWatcherDebounceMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        indexCacheTtlSeconds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxConcurrentProviders: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxQueryLatencyMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        resultCacheTtlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        fileWatcherDebounceMs: number;
+        indexCacheTtlSeconds: number;
+        maxConcurrentProviders: number;
+        maxQueryLatencyMs: number;
+        resultCacheTtlMs: number;
+    }, {
+        fileWatcherDebounceMs?: number | undefined;
+        indexCacheTtlSeconds?: number | undefined;
+        maxConcurrentProviders?: number | undefined;
+        maxQueryLatencyMs?: number | undefined;
+        resultCacheTtlMs?: number | undefined;
+    }>, {
+        fileWatcherDebounceMs: number;
+        indexCacheTtlSeconds: number;
+        maxConcurrentProviders: number;
+        maxQueryLatencyMs: number;
+        resultCacheTtlMs: number;
+    }, unknown>>>;
+    provenance: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        fullRetentionDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        keepSummaries: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        storagePath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        storagePath: string;
+        fullRetentionDays: number;
+        keepSummaries: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        storagePath?: string | undefined;
+        fullRetentionDays?: number | undefined;
+        keepSummaries?: boolean | undefined;
+    }>, {
+        enabled: boolean;
+        storagePath: string;
+        fullRetentionDays: number;
+        keepSummaries: boolean;
+    }, unknown>>>;
+    providers: z.ZodEffects<z.ZodObject<{
+        byterover: z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled: boolean;
+        }>;
+        gbrain: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            connectionString: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodBoolean;
+            repoPath: z.ZodString;
+            searchMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hybrid", "keyword", "vector"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            repoPath: string;
+            searchMode: "keyword" | "hybrid" | "vector";
+            connectionString?: string | undefined;
+        }, {
+            enabled: boolean;
+            repoPath: string;
+            connectionString?: string | undefined;
+            searchMode?: "keyword" | "hybrid" | "vector" | undefined;
+        }>, {
+            enabled: boolean;
+            repoPath: string;
+            searchMode: "keyword" | "hybrid" | "vector";
+            connectionString?: string | undefined;
+        }, unknown>>;
+        hindsight: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            caraParams: z.ZodOptional<z.ZodObject<{
+                empathy: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                literalism: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                skepticism: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, "strip", z.ZodTypeAny, {
+                empathy: number;
+                literalism: number;
+                skepticism: number;
+            }, {
+                empathy?: number | undefined;
+                literalism?: number | undefined;
+                skepticism?: number | undefined;
+            }>>;
+            connectionString: z.ZodString;
+            enabled: z.ZodBoolean;
+            networks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            connectionString: string;
+            networks: string[];
+            caraParams?: {
+                empathy: number;
+                literalism: number;
+                skepticism: number;
+            } | undefined;
+        }, {
+            enabled: boolean;
+            connectionString: string;
+            caraParams?: {
+                empathy?: number | undefined;
+                literalism?: number | undefined;
+                skepticism?: number | undefined;
+            } | undefined;
+            networks?: string[] | undefined;
+        }>, {
+            enabled: boolean;
+            connectionString: string;
+            networks: string[];
+            caraParams?: {
+                empathy: number;
+                literalism: number;
+                skepticism: number;
+            } | undefined;
+        }, unknown>>;
+        honcho: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            apiKey: z.ZodString;
+            appId: z.ZodString;
+            enabled: z.ZodBoolean;
+            maxTokensPerQuery: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            userId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            apiKey: string;
+            appId: string;
+            maxTokensPerQuery: number;
+            userId: string;
+        }, {
+            enabled: boolean;
+            apiKey: string;
+            appId: string;
+            maxTokensPerQuery?: number | undefined;
+            userId?: string | undefined;
+        }>, {
+            enabled: boolean;
+            apiKey: string;
+            appId: string;
+            maxTokensPerQuery: number;
+            userId: string;
+        }, unknown>>;
+        localMarkdown: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            folders: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                followWikilinks: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                name: z.ZodString;
+                path: z.ZodString;
+                readOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                name: string;
+                readOnly: boolean;
+                followWikilinks: boolean;
+            }, {
+                path: string;
+                name: string;
+                readOnly?: boolean | undefined;
+                followWikilinks?: boolean | undefined;
+            }>, {
+                path: string;
+                name: string;
+                readOnly: boolean;
+                followWikilinks: boolean;
+            }, unknown>, "many">;
+            watchForChanges: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            watchForChanges: boolean;
+            folders: {
+                path: string;
+                name: string;
+                readOnly: boolean;
+                followWikilinks: boolean;
+            }[];
+        }, {
+            enabled: boolean;
+            folders: unknown[];
+            watchForChanges?: boolean | undefined;
+        }>, {
+            enabled: boolean;
+            watchForChanges: boolean;
+            folders: {
+                path: string;
+                name: string;
+                readOnly: boolean;
+                followWikilinks: boolean;
+            }[];
+        }, unknown>>;
+        memoryWiki: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            boostFresh: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            enabled: z.ZodBoolean;
+            vaultPath: z.ZodString;
+            writePageType: z.ZodDefault<z.ZodOptional<z.ZodEnum<["concept", "entity"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            vaultPath: string;
+            boostFresh: boolean;
+            writePageType: "entity" | "concept";
+        }, {
+            enabled: boolean;
+            vaultPath: string;
+            boostFresh?: boolean | undefined;
+            writePageType?: "entity" | "concept" | undefined;
+        }>, {
+            enabled: boolean;
+            vaultPath: string;
+            boostFresh: boolean;
+            writePageType: "entity" | "concept";
+        }, unknown>>;
+        obsidian: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            indexOnStartup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            readOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            vaultPath: z.ZodString;
+            watchForChanges: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            indexOnStartup: boolean;
+            readOnly: boolean;
+            vaultPath: string;
+            watchForChanges: boolean;
+            ignorePatterns?: string[] | undefined;
+        }, {
+            enabled: boolean;
+            vaultPath: string;
+            ignorePatterns?: string[] | undefined;
+            indexOnStartup?: boolean | undefined;
+            readOnly?: boolean | undefined;
+            watchForChanges?: boolean | undefined;
+        }>, {
+            enabled: boolean;
+            indexOnStartup: boolean;
+            readOnly: boolean;
+            vaultPath: string;
+            watchForChanges: boolean;
+            ignorePatterns?: string[] | undefined;
+        }, unknown>>;
+    }, "strip", z.ZodTypeAny, {
+        byterover: {
+            enabled: boolean;
+        };
+        honcho?: {
+            enabled: boolean;
+            apiKey: string;
+            appId: string;
+            maxTokensPerQuery: number;
+            userId: string;
+        } | undefined;
+        hindsight?: {
+            enabled: boolean;
+            connectionString: string;
+            networks: string[];
+            caraParams?: {
+                empathy: number;
+                literalism: number;
+                skepticism: number;
+            } | undefined;
+        } | undefined;
+        obsidian?: {
+            enabled: boolean;
+            indexOnStartup: boolean;
+            readOnly: boolean;
+            vaultPath: string;
+            watchForChanges: boolean;
+            ignorePatterns?: string[] | undefined;
+        } | undefined;
+        gbrain?: {
+            enabled: boolean;
+            repoPath: string;
+            searchMode: "keyword" | "hybrid" | "vector";
+            connectionString?: string | undefined;
+        } | undefined;
+        localMarkdown?: {
+            enabled: boolean;
+            watchForChanges: boolean;
+            folders: {
+                path: string;
+                name: string;
+                readOnly: boolean;
+                followWikilinks: boolean;
+            }[];
+        } | undefined;
+        memoryWiki?: {
+            enabled: boolean;
+            vaultPath: string;
+            boostFresh: boolean;
+            writePageType: "entity" | "concept";
+        } | undefined;
+    }, {
+        byterover: {
+            enabled: boolean;
+        };
+        honcho?: unknown;
+        hindsight?: unknown;
+        obsidian?: unknown;
+        gbrain?: unknown;
+        localMarkdown?: unknown;
+        memoryWiki?: unknown;
+    }>, {
+        byterover: {
+            enabled: boolean;
+        };
+        honcho?: {
+            enabled: boolean;
+            apiKey: string;
+            appId: string;
+            maxTokensPerQuery: number;
+            userId: string;
+        } | undefined;
+        hindsight?: {
+            enabled: boolean;
+            connectionString: string;
+            networks: string[];
+            caraParams?: {
+                empathy: number;
+                literalism: number;
+                skepticism: number;
+            } | undefined;
+        } | undefined;
+        obsidian?: {
+            enabled: boolean;
+            indexOnStartup: boolean;
+            readOnly: boolean;
+            vaultPath: string;
+            watchForChanges: boolean;
+            ignorePatterns?: string[] | undefined;
+        } | undefined;
+        gbrain?: {
+            enabled: boolean;
+            repoPath: string;
+            searchMode: "keyword" | "hybrid" | "vector";
+            connectionString?: string | undefined;
+        } | undefined;
+        localMarkdown?: {
+            enabled: boolean;
+            watchForChanges: boolean;
+            folders: {
+                path: string;
+                name: string;
+                readOnly: boolean;
+                followWikilinks: boolean;
+            }[];
+        } | undefined;
+        memoryWiki?: {
+            enabled: boolean;
+            vaultPath: string;
+            boostFresh: boolean;
+            writePageType: "entity" | "concept";
+        } | undefined;
+    }, unknown>;
+    routing: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        classificationMethod: z.ZodDefault<z.ZodOptional<z.ZodEnum<["auto", "llm"]>>>;
+        defaultMaxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        defaultStrategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["adaptive", "all", "manual"]>>>;
+        minRrfScore: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        rrfGapRatio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        rrfK: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        classificationMethod: "llm" | "auto";
+        defaultMaxResults: number;
+        defaultStrategy: "all" | "manual" | "adaptive";
+        minRrfScore: number;
+        rrfGapRatio: number;
+        rrfK: number;
+    }, {
+        classificationMethod?: "llm" | "auto" | undefined;
+        defaultMaxResults?: number | undefined;
+        defaultStrategy?: "all" | "manual" | "adaptive" | undefined;
+        minRrfScore?: number | undefined;
+        rrfGapRatio?: number | undefined;
+        rrfK?: number | undefined;
+    }>, {
+        classificationMethod: "llm" | "auto";
+        defaultMaxResults: number;
+        defaultStrategy: "all" | "manual" | "adaptive";
+        minRrfScore: number;
+        rrfGapRatio: number;
+        rrfK: number;
+    }, unknown>>>;
+}, "strip", z.ZodTypeAny, {
+    performance: {
+        fileWatcherDebounceMs: number;
+        indexCacheTtlSeconds: number;
+        maxConcurrentProviders: number;
+        maxQueryLatencyMs: number;
+        resultCacheTtlMs: number;
+    };
+    enrichment: {
+        edges: {
+            from: string;
+            to: string;
+        }[];
+    };
+    optimization: {
+        edgeLearning: {
+            enabled: boolean;
+            explorationRate: number;
+            fixThreshold: number;
+            minObservationsToPrune: number;
+            pruneThreshold: number;
+        };
+        templateOptimization: {
+            enabled: boolean;
+            abTestSize: number;
+            failureRateTrigger: number;
+            frequency: number;
+        };
+    };
+    provenance: {
+        enabled: boolean;
+        storagePath: string;
+        fullRetentionDays: number;
+        keepSummaries: boolean;
+    };
+    providers: {
+        byterover: {
+            enabled: boolean;
+        };
+        honcho?: {
+            enabled: boolean;
+            apiKey: string;
+            appId: string;
+            maxTokensPerQuery: number;
+            userId: string;
+        } | undefined;
+        hindsight?: {
+            enabled: boolean;
+            connectionString: string;
+            networks: string[];
+            caraParams?: {
+                empathy: number;
+                literalism: number;
+                skepticism: number;
+            } | undefined;
+        } | undefined;
+        obsidian?: {
+            enabled: boolean;
+            indexOnStartup: boolean;
+            readOnly: boolean;
+            vaultPath: string;
+            watchForChanges: boolean;
+            ignorePatterns?: string[] | undefined;
+        } | undefined;
+        gbrain?: {
+            enabled: boolean;
+            repoPath: string;
+            searchMode: "keyword" | "hybrid" | "vector";
+            connectionString?: string | undefined;
+        } | undefined;
+        localMarkdown?: {
+            enabled: boolean;
+            watchForChanges: boolean;
+            folders: {
+                path: string;
+                name: string;
+                readOnly: boolean;
+                followWikilinks: boolean;
+            }[];
+        } | undefined;
+        memoryWiki?: {
+            enabled: boolean;
+            vaultPath: string;
+            boostFresh: boolean;
+            writePageType: "entity" | "concept";
+        } | undefined;
+    };
+    routing: {
+        classificationMethod: "llm" | "auto";
+        defaultMaxResults: number;
+        defaultStrategy: "all" | "manual" | "adaptive";
+        minRrfScore: number;
+        rrfGapRatio: number;
+        rrfK: number;
+    };
+    budget?: {
+        globalMonthlyCapCents: number;
+        warningThresholdPct: number;
+        weightReductionThresholdPct: number;
+        perProvider?: Record<string, {
+            monthlyCapCents: number;
+            maxQueriesPerMinute?: number | undefined;
+        }> | undefined;
+    } | undefined;
+}, {
+    performance?: unknown;
+    budget?: unknown;
+    enrichment?: {
+        edges?: {
+            from: string;
+            to: string;
+        }[] | undefined;
+    } | undefined;
+    optimization?: unknown;
+    provenance?: unknown;
+    providers?: unknown;
+    routing?: unknown;
+}>;
+/**
+ * Validated swarm configuration type (camelCase TypeScript output).
+ */
+export type SwarmConfig = z.output<typeof SwarmConfigSchema>;
+/**
+ * Validate swarm config (throwing).
+ * @throws ZodError on invalid input
+ */
+export declare function validateSwarmConfig(config: unknown): SwarmConfig;
+/**
+ * Validate swarm config (non-throwing).
+ * Returns a SafeParseResult with success/error.
+ */
+export declare function safeValidateSwarmConfig(config: unknown): z.SafeParseReturnType<unknown, SwarmConfig>;