@dotsetlabs/bellwether 2.1.0 → 2.1.2

package/dist/dashboard/runtime/command-profiles.js

@@ -0,0 +1,691 @@
+import { z } from 'zod';
+const dashboardProfiles = [
+    {
+        id: 'check',
+        label: 'Check',
+        description: 'Run deterministic schema drift detection',
+        requiresServerCommand: true,
+        category: 'core',
+    },
+    {
+        id: 'explore',
+        label: 'Explore',
+        description: 'Run LLM-powered behavioral exploration',
+        requiresServerCommand: true,
+        category: 'core',
+    },
+    {
+        id: 'validate-config',
+        label: 'Validate Config',
+        description: 'Validate bellwether.yaml without running tests',
+        requiresServerCommand: false,
+        category: 'core',
+    },
+    {
+        id: 'discover',
+        label: 'Discover',
+        description: 'Discover tools, prompts, and resources',
+        requiresServerCommand: true,
+        category: 'advanced',
+    },
+    {
+        id: 'watch',
+        label: 'Watch',
+        description: 'Start watch mode for automatic check runs',
+        requiresServerCommand: false,
+        category: 'advanced',
+    },
+    {
+        id: 'baseline.save',
+        label: 'Baseline Save',
+        description: 'Save check report as baseline',
+        requiresServerCommand: false,
+        category: 'baseline',
+    },
+    {
+        id: 'baseline.compare',
+        label: 'Baseline Compare',
+        description: 'Compare current check report with baseline',
+        requiresServerCommand: false,
+        category: 'baseline',
+    },
+    {
+        id: 'baseline.show',
+        label: 'Baseline Show',
+        description: 'Inspect baseline contents',
+        requiresServerCommand: false,
+        category: 'baseline',
+    },
+    {
+        id: 'baseline.diff',
+        label: 'Baseline Diff',
+        description: 'Compare two baseline files',
+        requiresServerCommand: false,
+        category: 'baseline',
+    },
+    {
+        id: 'baseline.accept',
+        label: 'Baseline Accept',
+        description: 'Accept current drift and update baseline',
+        requiresServerCommand: false,
+        category: 'baseline',
+    },
+    {
+        id: 'registry.search',
+        label: 'Registry Search',
+        description: 'Search MCP Registry servers',
+        requiresServerCommand: false,
+        category: 'advanced',
+    },
+    {
+        id: 'contract.validate',
+        label: 'Contract Validate',
+        description: 'Validate server behavior against a contract',
+        requiresServerCommand: true,
+        category: 'advanced',
+    },
+    {
+        id: 'contract.generate',
+        label: 'Contract Generate',
+        description: 'Generate contract from current server behavior',
+        requiresServerCommand: true,
+        category: 'advanced',
+    },
+    {
+        id: 'contract.show',
+        label: 'Contract Show',
+        description: 'Display contract file contents',
+        requiresServerCommand: false,
+        category: 'advanced',
+    },
+    {
+        id: 'golden.save',
+        label: 'Golden Save',
+        description: 'Capture current tool output as golden reference',
+        requiresServerCommand: false,
+        category: 'advanced',
+    },
+    {
+        id: 'golden.compare',
+        label: 'Golden Compare',
+        description: 'Compare live outputs against saved goldens',
+        requiresServerCommand: false,
+        category: 'advanced',
+    },
+    {
+        id: 'golden.list',
+        label: 'Golden List',
+        description: 'List captured golden outputs',
+        requiresServerCommand: false,
+        category: 'advanced',
+    },
+    {
+        id: 'golden.delete',
+        label: 'Golden Delete',
+        description: 'Delete captured golden outputs for a tool',
+        requiresServerCommand: false,
+        category: 'advanced',
+    },
+];
+const nonEmptyString = z.string().transform((value) => value.trim()).optional();
+const optionalBoolean = z.boolean().optional();
+const optionalPositiveInteger = z.preprocess((value) => {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isNaN(parsed) ? value : parsed;
+    }
+    return value;
+}, z.number().int().min(1).optional());
+const serverCommandArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    serverCommand: nonEmptyString,
+    serverArgs: z.array(z.string()).optional(),
+})
+    .strict();
+const validateConfigArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+})
+    .strict();
+const discoverArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    serverCommand: nonEmptyString,
+    serverArgs: z.array(z.string()).optional(),
+    json: optionalBoolean,
+    timeout: optionalPositiveInteger,
+    transport: z.enum(['stdio', 'sse', 'streamable-http']).optional(),
+    url: nonEmptyString,
+    sessionId: nonEmptyString,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const transport = value.transport ?? 'stdio';
+    const isRemoteTransport = transport === 'sse' || transport === 'streamable-http';
+    if (!isRemoteTransport && !value.serverCommand?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'serverCommand is required for stdio transport',
+            path: ['serverCommand'],
+        });
+    }
+    if (isRemoteTransport && !value.url?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'url is required for remote transport',
+            path: ['url'],
+        });
+    }
+    if (!isRemoteTransport && value.url?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'url requires transport sse or streamable-http',
+            path: ['url'],
+        });
+    }
+});
+const watchArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    serverCommand: nonEmptyString,
+    serverArgs: z.array(z.string()).optional(),
+})
+    .strict();
+const baselineSaveArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    baselinePath: nonEmptyString,
+    reportPath: nonEmptyString,
+    force: optionalBoolean,
+})
+    .strict();
+const baselineCompareArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    baselinePath: nonEmptyString,
+    reportPath: nonEmptyString,
+    format: z.enum(['text', 'json', 'markdown', 'compact']).optional(),
+    failOnDrift: optionalBoolean,
+    ignoreVersionMismatch: optionalBoolean,
+})
+    .strict();
+const baselineShowArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    baselinePath: nonEmptyString,
+    json: optionalBoolean,
+    tools: optionalBoolean,
+    assertions: optionalBoolean,
+})
+    .strict();
+const baselineDiffArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    path1: z.string().transform((value) => value.trim()),
+    path2: z.string().transform((value) => value.trim()),
+    format: z.enum(['text', 'json', 'markdown', 'compact']).optional(),
+    ignoreVersionMismatch: optionalBoolean,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (!value.path1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'path1 is required',
+            path: ['path1'],
+        });
+    }
+    if (!value.path2) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'path2 is required',
+            path: ['path2'],
+        });
+    }
+});
+const baselineAcceptArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    reportPath: nonEmptyString,
+    baselinePath: nonEmptyString,
+    reason: nonEmptyString,
+    acceptedBy: nonEmptyString,
+    dryRun: optionalBoolean,
+    force: optionalBoolean,
+})
+    .strict();
+const registrySearchArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    query: nonEmptyString,
+    limit: optionalPositiveInteger,
+    json: optionalBoolean,
+})
+    .strict();
+const contractValidateArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    serverCommand: z.string().transform((value) => value.trim()),
+    serverArgs: z.array(z.string()).optional(),
+    contractPath: nonEmptyString,
+    mode: z.enum(['strict', 'lenient', 'report']).optional(),
+    failOnViolation: optionalBoolean,
+    format: z.enum(['text', 'json', 'markdown']).optional(),
+    timeout: optionalPositiveInteger,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (!value.serverCommand) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'serverCommand is required',
+            path: ['serverCommand'],
+        });
+    }
+});
+const contractGenerateArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    serverCommand: z.string().transform((value) => value.trim()),
+    serverArgs: z.array(z.string()).optional(),
+    outputPath: nonEmptyString,
+    timeout: optionalPositiveInteger,
+    force: optionalBoolean,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (!value.serverCommand) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'serverCommand is required',
+            path: ['serverCommand'],
+        });
+    }
+});
+const contractShowArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    path: nonEmptyString,
+    json: optionalBoolean,
+})
+    .strict();
+const goldenSaveArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    toolName: z.string().transform((value) => value.trim()),
+    argsJson: nonEmptyString,
+    mode: z.enum(['exact', 'structural', 'semantic']).optional(),
+    allowedDrift: nonEmptyString,
+    normalizeTimestamps: optionalBoolean,
+    normalizeUuids: optionalBoolean,
+    description: nonEmptyString,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (!value.toolName) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'toolName is required',
+            path: ['toolName'],
+        });
+    }
+});
+const goldenCompareArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    toolName: nonEmptyString,
+    failOnDrift: optionalBoolean,
+    format: z.enum(['text', 'json', 'markdown']).optional(),
+})
+    .strict();
+const goldenListArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    format: z.enum(['text', 'json']).optional(),
+})
+    .strict();
+const goldenDeleteArgsSchema = z
+    .object({
+    configPath: nonEmptyString,
+    toolName: z.string().transform((value) => value.trim()),
+    all: optionalBoolean,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (!value.toolName) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'toolName is required',
+            path: ['toolName'],
+        });
+    }
+});
+const runRequestSchema = z.discriminatedUnion('profile', [
+    z.object({
+        profile: z.literal('check'),
+        args: serverCommandArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('explore'),
+        args: serverCommandArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('validate-config'),
+        args: validateConfigArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('discover'),
+        args: discoverArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('watch'),
+        args: watchArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('baseline.save'),
+        args: baselineSaveArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('baseline.compare'),
+        args: baselineCompareArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('baseline.show'),
+        args: baselineShowArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('baseline.diff'),
+        args: baselineDiffArgsSchema,
+    }),
+    z.object({
+        profile: z.literal('baseline.accept'),
+        args: baselineAcceptArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('registry.search'),
+        args: registrySearchArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('contract.validate'),
+        args: contractValidateArgsSchema,
+    }),
+    z.object({
+        profile: z.literal('contract.generate'),
+        args: contractGenerateArgsSchema,
+    }),
+    z.object({
+        profile: z.literal('contract.show'),
+        args: contractShowArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('golden.save'),
+        args: goldenSaveArgsSchema,
+    }),
+    z.object({
+        profile: z.literal('golden.compare'),
+        args: goldenCompareArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('golden.list'),
+        args: goldenListArgsSchema.optional().default({}),
+    }),
+    z.object({
+        profile: z.literal('golden.delete'),
+        args: goldenDeleteArgsSchema,
+    }),
+]);
+function normalizeString(value) {
+    const normalized = value?.trim();
+    if (!normalized) {
+        return undefined;
+    }
+    return normalized;
+}
+function normalizeServerArgs(args) {
+    if (!args) {
+        return [];
+    }
+    return args.map((arg) => arg.trim()).filter((arg) => arg.length > 0);
+}
+function pushOptionIfValue(args, option, value) {
+    if (value) {
+        args.push(option, value);
+    }
+}
+function pushFlagIfTrue(args, enabled, option) {
+    if (enabled) {
+        args.push(option);
+    }
+}
+function pushOptionIfNumber(args, option, value) {
+    if (typeof value === 'number') {
+        args.push(option, String(value));
+    }
+}
+function buildServerCommandArgs(commandName, args) {
+    const commandArgs = [commandName];
+    const configPath = normalizeString(args.configPath);
+    const serverCommand = normalizeString(args.serverCommand);
+    const serverArgs = normalizeServerArgs(args.serverArgs);
+    pushOptionIfValue(commandArgs, '--config', configPath);
+    if (serverCommand) {
+        commandArgs.push(serverCommand, ...serverArgs);
+    }
+    return commandArgs;
+}
+function buildValidateConfigArgs(args) {
+    const commandArgs = ['validate-config'];
+    pushOptionIfValue(commandArgs, '--config', normalizeString(args.configPath));
+    return commandArgs;
+}
+function buildDiscoverArgs(args) {
+    const value = args;
+    const commandArgs = ['discover'];
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushFlagIfTrue(commandArgs, value.json, '--json');
+    pushOptionIfNumber(commandArgs, '--timeout', value.timeout);
+    pushOptionIfValue(commandArgs, '--transport', value.transport);
+    pushOptionIfValue(commandArgs, '--url', normalizeString(value.url));
+    pushOptionIfValue(commandArgs, '--session-id', normalizeString(value.sessionId));
+    const serverCommand = normalizeString(value.serverCommand);
+    if (serverCommand) {
+        commandArgs.push(serverCommand, ...normalizeServerArgs(value.serverArgs));
+    }
+    return commandArgs;
+}
+function buildBaselineSaveArgs(args) {
+    const commandArgs = ['baseline', 'save'];
+    const value = args;
+    const baselinePath = normalizeString(value.baselinePath);
+    if (baselinePath) {
+        commandArgs.push(baselinePath);
+    }
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfValue(commandArgs, '--report', normalizeString(value.reportPath));
+    pushFlagIfTrue(commandArgs, value.force, '--force');
+    return commandArgs;
+}
+function buildBaselineCompareArgs(args) {
+    const commandArgs = ['baseline', 'compare'];
+    const value = args;
+    const baselinePath = normalizeString(value.baselinePath);
+    if (baselinePath) {
+        commandArgs.push(baselinePath);
+    }
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfValue(commandArgs, '--report', normalizeString(value.reportPath));
+    pushOptionIfValue(commandArgs, '--format', value.format);
+    pushFlagIfTrue(commandArgs, value.failOnDrift, '--fail-on-drift');
+    pushFlagIfTrue(commandArgs, value.ignoreVersionMismatch, '--ignore-version-mismatch');
+    return commandArgs;
+}
+function buildBaselineShowArgs(args) {
+    const commandArgs = ['baseline', 'show'];
+    const value = args;
+    const baselinePath = normalizeString(value.baselinePath);
+    if (baselinePath) {
+        commandArgs.push(baselinePath);
+    }
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushFlagIfTrue(commandArgs, value.json, '--json');
+    pushFlagIfTrue(commandArgs, value.tools, '--tools');
+    pushFlagIfTrue(commandArgs, value.assertions, '--assertions');
+    return commandArgs;
+}
+function buildBaselineDiffArgs(args) {
+    const value = args;
+    const commandArgs = ['baseline', 'diff', value.path1.trim(), value.path2.trim()];
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfValue(commandArgs, '--format', value.format);
+    pushFlagIfTrue(commandArgs, value.ignoreVersionMismatch, '--ignore-version-mismatch');
+    return commandArgs;
+}
+function buildBaselineAcceptArgs(args) {
+    const commandArgs = ['baseline', 'accept'];
+    const value = args;
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfValue(commandArgs, '--report', normalizeString(value.reportPath));
+    pushOptionIfValue(commandArgs, '--baseline', normalizeString(value.baselinePath));
+    pushOptionIfValue(commandArgs, '--reason', normalizeString(value.reason));
+    pushOptionIfValue(commandArgs, '--accepted-by', normalizeString(value.acceptedBy));
+    pushFlagIfTrue(commandArgs, value.dryRun, '--dry-run');
+    pushFlagIfTrue(commandArgs, value.force, '--force');
+    return commandArgs;
+}
+function buildRegistrySearchArgs(args) {
+    const commandArgs = ['registry'];
+    const value = args;
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfNumber(commandArgs, '--limit', value.limit);
+    pushFlagIfTrue(commandArgs, value.json, '--json');
+    const query = normalizeString(value.query);
+    if (query) {
+        commandArgs.push(query);
+    }
+    return commandArgs;
+}
+function buildContractValidateArgs(args) {
+    const commandArgs = ['contract', 'validate'];
+    const value = args;
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfValue(commandArgs, '--contract', normalizeString(value.contractPath));
+    pushOptionIfValue(commandArgs, '--mode', value.mode);
+    pushOptionIfValue(commandArgs, '--format', value.format);
+    pushOptionIfNumber(commandArgs, '--timeout', value.timeout);
+    pushFlagIfTrue(commandArgs, value.failOnViolation, '--fail-on-violation');
+    commandArgs.push(value.serverCommand, ...normalizeServerArgs(value.serverArgs));
+    return commandArgs;
+}
+function buildContractGenerateArgs(args) {
+    const commandArgs = ['contract', 'generate'];
+    const value = args;
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfValue(commandArgs, '--output', normalizeString(value.outputPath));
+    pushOptionIfNumber(commandArgs, '--timeout', value.timeout);
+    pushFlagIfTrue(commandArgs, value.force, '--force');
+    commandArgs.push(value.serverCommand, ...normalizeServerArgs(value.serverArgs));
+    return commandArgs;
+}
+function buildContractShowArgs(args) {
+    const commandArgs = ['contract', 'show'];
+    const value = args;
+    const path = normalizeString(value.path);
+    if (path) {
+        commandArgs.push(path);
+    }
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushFlagIfTrue(commandArgs, value.json, '--json');
+    return commandArgs;
+}
+function buildGoldenSaveArgs(args) {
+    const commandArgs = ['golden', 'save'];
+    const value = args;
+    commandArgs.push('--tool', value.toolName);
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfValue(commandArgs, '--args', normalizeString(value.argsJson));
+    pushOptionIfValue(commandArgs, '--mode', value.mode);
+    pushOptionIfValue(commandArgs, '--allowed-drift', normalizeString(value.allowedDrift));
+    if (value.normalizeTimestamps === false) {
+        commandArgs.push('--no-normalize-timestamps');
+    }
+    if (value.normalizeUuids === false) {
+        commandArgs.push('--no-normalize-uuids');
+    }
+    pushOptionIfValue(commandArgs, '--description', normalizeString(value.description));
+    return commandArgs;
+}
+function buildGoldenCompareArgs(args) {
+    const commandArgs = ['golden', 'compare'];
+    const value = args;
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfValue(commandArgs, '--tool', normalizeString(value.toolName));
+    pushFlagIfTrue(commandArgs, value.failOnDrift, '--fail-on-drift');
+    pushOptionIfValue(commandArgs, '--format', value.format);
+    return commandArgs;
+}
+function buildGoldenListArgs(args) {
+    const commandArgs = ['golden', 'list'];
+    const value = args;
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushOptionIfValue(commandArgs, '--format', value.format);
+    return commandArgs;
+}
+function buildGoldenDeleteArgs(args) {
+    const commandArgs = ['golden', 'delete'];
+    const value = args;
+    commandArgs.push('--tool', value.toolName);
+    pushOptionIfValue(commandArgs, '--config', normalizeString(value.configPath));
+    pushFlagIfTrue(commandArgs, value.all, '--all');
+    return commandArgs;
+}
+export function listDashboardProfiles() {
+    return dashboardProfiles.map((profile) => ({ ...profile }));
+}
+export function parseDashboardRunRequest(request) {
+    return runRequestSchema.parse(request);
+}
+export function buildBellwetherArgs(request) {
+    switch (request.profile) {
+        case 'check':
+            return buildServerCommandArgs('check', request.args);
+        case 'explore':
+            return buildServerCommandArgs('explore', request.args);
+        case 'validate-config':
+            return buildValidateConfigArgs(request.args);
+        case 'discover':
+            return buildDiscoverArgs(request.args);
+        case 'watch':
+            return buildServerCommandArgs('watch', request.args);
+        case 'baseline.save':
+            return buildBaselineSaveArgs(request.args);
+        case 'baseline.compare':
+            return buildBaselineCompareArgs(request.args);
+        case 'baseline.show':
+            return buildBaselineShowArgs(request.args);
+        case 'baseline.diff':
+            return buildBaselineDiffArgs(request.args);
+        case 'baseline.accept':
+            return buildBaselineAcceptArgs(request.args);
+        case 'registry.search':
+            return buildRegistrySearchArgs(request.args);
+        case 'contract.validate':
+            return buildContractValidateArgs(request.args);
+        case 'contract.generate':
+            return buildContractGenerateArgs(request.args);
+        case 'contract.show':
+            return buildContractShowArgs(request.args);
+        case 'golden.save':
+            return buildGoldenSaveArgs(request.args);
+        case 'golden.compare':
+            return buildGoldenCompareArgs(request.args);
+        case 'golden.list':
+            return buildGoldenListArgs(request.args);
+        case 'golden.delete':
+            return buildGoldenDeleteArgs(request.args);
+    }
+}
+//# sourceMappingURL=command-profiles.js.map

package/dist/dashboard/runtime/config-service.d.ts

@@ -0,0 +1,21 @@
+import { type BellwetherConfig } from '../../config/validator.js';
+export interface DashboardConfigDocument {
+    absolutePath: string;
+    workspacePath: string;
+    exists: boolean;
+    content: string;
+}
+export interface DashboardConfigValidationResult {
+    valid: boolean;
+    warnings: string[];
+    config: BellwetherConfig;
+}
+export declare function resolveWorkspacePath(cwd: string, targetPath: string): string;
+export declare function resolveConfigPath(cwd: string, explicitPath?: string): string;
+export declare function getConfigDocument(cwd: string, explicitPath?: string): DashboardConfigDocument;
+export declare function saveConfigDocument(cwd: string, explicitPath: string | undefined, content: string): DashboardConfigDocument;
+export declare function validateConfigSource(cwd: string, options: {
+    path?: string;
+    content?: string;
+}): DashboardConfigValidationResult;
+//# sourceMappingURL=config-service.d.ts.map