@osovv/vv-opencode 0.14.0 → 0.17.0

package/dist/lib/vvoc-config.d.ts

@@ -1,5 +1,13 @@
-export declare const VVOC_CONFIG_VERSION = 1;
+import { type SupportedModelTargetName } from "./agent-models.js";
+export declare const VVOC_CONFIG_VERSION = 2;
 export declare const VVOC_CONFIG_SCHEMA_URL: string;
+type VvocConfigVersion = 1 | 2;
+export type VvocPresetAgents = Partial<Record<SupportedModelTargetName, string>>;
+export type VvocPreset = {
+    description?: string;
+    agents: VvocPresetAgents;
+};
+export type VvocPresets = Record<string, VvocPreset>;
 export type GuardianConfig = {
     model?: string;
     variant?: string;
@@ -42,151 +50,185 @@ export type VvocConfig = {
     guardian: GuardianConfig;
     memory: MemoryConfig;
     secretsRedaction: SecretsRedactionConfig;
+    presets: VvocPresets;
+};
+export type ParsedVvocConfig = {
+    sourceSchema: string;
+    sourceVersion: VvocConfigVersion;
+    config: VvocConfig;
 };
 export declare const VVOC_CONFIG_SCHEMA: {
-    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly $id: string;
-    readonly title: "vvoc config";
-    readonly description: "Canonical vvoc configuration document.";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["$schema", "version", "guardian", "memory", "secretsRedaction"];
-    readonly properties: {
-        readonly $schema: {
-            readonly type: "string";
-            readonly minLength: 1;
-            readonly description: "Hosted JSON Schema URL for vvoc.json.";
+    $schema: string;
+    $id: string;
+    title: string;
+    description: string;
+    type: string;
+    additionalProperties: boolean;
+    required: string[];
+    properties: {
+        $schema: {
+            type: string;
+            minLength: number;
+            description: string;
         };
-        readonly version: {
-            readonly type: "integer";
-            readonly const: 1;
+        version: {
+            type: string;
+            const: number;
         };
-        readonly guardian: {
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly required: readonly ["timeoutMs", "approvalRiskThreshold", "reviewToastDurationMs"];
-            readonly properties: {
-                readonly model: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly variant: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly timeoutMs: {
-                    readonly type: "integer";
-                    readonly minimum: 1;
-                };
-                readonly approvalRiskThreshold: {
-                    readonly type: "integer";
-                    readonly minimum: 0;
-                    readonly maximum: 100;
-                };
-                readonly reviewToastDurationMs: {
-                    readonly type: "integer";
-                    readonly minimum: 1;
+        guardian: {
+            type: string;
+            additionalProperties: boolean;
+            required: string[];
+            properties: {
+                model: {
+                    type: string;
+                    minLength: number;
+                };
+                variant: {
+                    type: string;
+                    minLength: number;
+                };
+                timeoutMs: {
+                    type: string;
+                    minimum: number;
+                };
+                approvalRiskThreshold: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+                reviewToastDurationMs: {
+                    type: string;
+                    minimum: number;
                 };
             };
         };
-        readonly memory: {
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly required: readonly ["enabled", "defaultSearchLimit"];
-            readonly properties: {
-                readonly enabled: {
-                    readonly type: "boolean";
-                };
-                readonly defaultSearchLimit: {
-                    readonly type: "integer";
-                    readonly minimum: 1;
-                };
-                readonly reviewerModel: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly reviewerVariant: {
-                    readonly type: "string";
-                    readonly minLength: 1;
+        memory: {
+            type: string;
+            additionalProperties: boolean;
+            required: string[];
+            properties: {
+                enabled: {
+                    type: string;
+                };
+                defaultSearchLimit: {
+                    type: string;
+                    minimum: number;
+                };
+                reviewerModel: {
+                    type: string;
+                    minLength: number;
+                };
+                reviewerVariant: {
+                    type: string;
+                    minLength: number;
                 };
             };
         };
-        readonly secretsRedaction: {
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly required: readonly ["enabled", "secret", "ttlMs", "maxMappings", "patterns", "debug"];
-            readonly properties: {
-                readonly enabled: {
-                    readonly type: "boolean";
-                };
-                readonly secret: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly ttlMs: {
-                    readonly type: "integer";
-                    readonly minimum: 0;
-                };
-                readonly maxMappings: {
-                    readonly type: "integer";
-                    readonly minimum: 1;
-                };
-                readonly debug: {
-                    readonly type: "boolean";
-                };
-                readonly patterns: {
-                    readonly type: "object";
-                    readonly additionalProperties: false;
-                    readonly required: readonly ["keywords", "regex", "builtin", "exclude"];
-                    readonly properties: {
-                        readonly keywords: {
-                            readonly type: "array";
-                            readonly items: {
-                                readonly type: "object";
-                                readonly additionalProperties: false;
-                                readonly required: readonly ["value"];
-                                readonly properties: {
-                                    readonly value: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
+        secretsRedaction: {
+            type: string;
+            additionalProperties: boolean;
+            required: string[];
+            properties: {
+                enabled: {
+                    type: string;
+                };
+                secret: {
+                    type: string;
+                    minLength: number;
+                };
+                ttlMs: {
+                    type: string;
+                    minimum: number;
+                };
+                maxMappings: {
+                    type: string;
+                    minimum: number;
+                };
+                debug: {
+                    type: string;
+                };
+                patterns: {
+                    type: string;
+                    additionalProperties: boolean;
+                    required: string[];
+                    properties: {
+                        keywords: {
+                            type: string;
+                            items: {
+                                type: string;
+                                additionalProperties: boolean;
+                                required: string[];
+                                properties: {
+                                    value: {
+                                        type: string;
+                                        minLength: number;
                                     };
-                                    readonly category: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
+                                    category: {
+                                        type: string;
+                                        minLength: number;
                                     };
                                 };
                             };
                         };
-                        readonly regex: {
-                            readonly type: "array";
-                            readonly items: {
-                                readonly type: "object";
-                                readonly additionalProperties: false;
-                                readonly required: readonly ["pattern", "category"];
-                                readonly properties: {
-                                    readonly pattern: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
+                        regex: {
+                            type: string;
+                            items: {
+                                type: string;
+                                additionalProperties: boolean;
+                                required: string[];
+                                properties: {
+                                    pattern: {
+                                        type: string;
+                                        minLength: number;
                                     };
-                                    readonly category: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
+                                    category: {
+                                        type: string;
+                                        minLength: number;
                                     };
                                 };
                             };
                         };
-                        readonly builtin: {
-                            readonly type: "array";
-                            readonly items: {
-                                readonly type: "string";
-                                readonly minLength: 1;
+                        builtin: {
+                            type: string;
+                            items: {
+                                type: string;
+                                minLength: number;
                             };
                         };
-                        readonly exclude: {
-                            readonly type: "array";
-                            readonly items: {
-                                readonly type: "string";
-                                readonly minLength: 1;
+                        exclude: {
+                            type: string;
+                            items: {
+                                type: string;
+                                minLength: number;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        presets: {
+            type: string;
+            propertyNames: {
+                minLength: number;
+            };
+            additionalProperties: {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    description: {
+                        type: string;
+                        minLength: number;
+                    };
+                    agents: {
+                        type: string;
+                        additionalProperties: boolean;
+                        minProperties: number;
+                        properties: {
+                            [k: string]: {
+                                type: string;
+                                minLength: number;
                             };
                         };
                     };
@@ -198,12 +240,15 @@ export declare const VVOC_CONFIG_SCHEMA: {
 export declare function createGuardianConfig(overrides?: GuardianConfigOverrides): GuardianConfig;
 export declare function createMemoryConfig(overrides?: MemoryConfigOverrides): MemoryConfig;
 export declare function createDefaultSecretsRedactionConfig(): SecretsRedactionConfig;
+export declare function createDefaultVvocPresets(): VvocPresets;
 export declare function createDefaultVvocConfig(): VvocConfig;
 export declare function parseGuardianConfigText(text: string, label: string): GuardianConfigOverrides;
 export declare function renderGuardianConfig(overrides?: GuardianConfigOverrides): string;
 export declare function parseMemoryConfigText(text: string, label: string): MemoryConfigOverrides;
 export declare function renderMemoryConfig(overrides?: MemoryConfigOverrides): string;
+export declare function parseVersionedVvocConfigText(text: string, label: string): ParsedVvocConfig;
 export declare function parseVvocConfigText(text: string, label: string): VvocConfig;
 export declare function loadLenientVvocConfigText(text: string, label: string, warnings: string[]): VvocConfig;
 export declare function renderVvocConfig(config?: VvocConfig): string;
 export declare function validateVvocConfigDocument(document: unknown): string[];
+export {};