dsh-agy-cli 0.0.0-stage → 0.12.0

package/lib/agy/stream-protocol.js

@@ -0,0 +1,156 @@
+/**
+ * Small, transport-neutral helpers for AGY's stdin stream-json mode.
+ *
+ * Real AGY 1.1.15 stream-json input is event-driven. Factual envelope sampled
+ * in V8-M1 (see findings.md 2026-08-20, .tmp/v8-m1/three-turn.log):
+ *   input:  {"event":"user","message":{"role":"user","content":[{"type":"text","text":"..."}]}} per NDJSON line
+ *   output: {"event":"init","conversation_id":"...","init":{...}} then
+ *           {"event":"step_update",...} then {"event":"result",...} per turn.
+ * The generic encodeAgyStreamInput is retained for forward compatibility, but
+ * callers should use the typed encodeAgyUserMessage helper.
+ */
+export class AgyStreamProtocolError extends Error {
+    code;
+    constructor(message, code, options) {
+        super(message, options);
+        this.code = code;
+        this.name = 'AgyStreamProtocolError';
+    }
+}
+function byteLength(value) {
+    return Buffer.byteLength(value, 'utf8');
+}
+/** Encode one stdin NDJSON message without invoking a shell. */
+export function encodeAgyStreamInput(message, maxFrameBytes = 256 * 1024) {
+    if (message === undefined || typeof message === 'function' || typeof message === 'symbol') {
+        throw new AgyStreamProtocolError('AGY stream-json input must be JSON serializable', 'INVALID_INPUT');
+    }
+    let line;
+    try {
+        line = JSON.stringify(message);
+    }
+    catch (error) {
+        throw new AgyStreamProtocolError('AGY stream-json input could not be encoded', 'INVALID_INPUT', { cause: error });
+    }
+    const encoded = `${line}\n`;
+    if (byteLength(encoded) > maxFrameBytes) {
+        throw new AgyStreamProtocolError(`AGY stream-json input exceeds the configured frame limit (${byteLength(encoded)} > ${maxFrameBytes} bytes)`, 'FRAME_TOO_LARGE');
+    }
+    return encoded;
+}
+function userMessagePayload(text) {
+    return {
+        event: 'user',
+        message: { role: 'user', content: [{ type: 'text', text }] },
+    };
+}
+/** Return the exact UTF-8 size of one encoded AGY user frame. */
+export function getAgyUserMessageByteLength(text) {
+    if (typeof text !== 'string' || text.length === 0) {
+        throw new AgyStreamProtocolError('AGY stream-json user text must be a non-empty string', 'INVALID_INPUT');
+    }
+    const line = JSON.stringify(userMessagePayload(text));
+    return byteLength(`${line}\n`);
+}
+/** Encode one AGY stream-json user turn with the factual V8-M1 envelope. */
+export function encodeAgyUserMessage(text, maxFrameBytes = 256 * 1024) {
+    if (typeof text !== "string" || text.length === 0) {
+        throw new AgyStreamProtocolError("AGY stream-json user text must be a non-empty string", "INVALID_INPUT");
+    }
+    const payload = userMessagePayload(text);
+    return encodeAgyStreamInput(payload, maxFrameBytes);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function safeEnumKey(key) {
+    return key === 'event'
+        || key === 'status'
+        || key === 'subtype'
+        || key === 'step_type'
+        || key === 'state'
+        || key === 'kind'
+        || key === 'type'
+        || key === 'role';
+}
+function safeEnum(value) {
+    return /^[A-Za-z0-9_.:-]{1,64}$/.test(value) ? value : '<enum>';
+}
+/**
+ * Replace all free-form strings and identifiers while retaining enough
+ * structure to replay parser behavior. Stable protocol enum fields remain.
+ */
+export function sanitizeAgyProtocolValue(value, key = '', depth = 0) {
+    if (depth > 8)
+        return '<depth-limit>';
+    if (typeof value === 'string') {
+        if (safeEnumKey(key))
+            return safeEnum(value);
+        return `<string:${value.length}>`;
+    }
+    if (typeof value === 'number')
+        return key.toLowerCase().includes('usage') ? 0 : 0;
+    if (typeof value === 'boolean' || value === null)
+        return value;
+    if (Array.isArray(value))
+        return value.slice(0, 32).map(item => sanitizeAgyProtocolValue(item, '', depth + 1));
+    if (isRecord(value)) {
+        const entries = Object.entries(value).slice(0, 128);
+        return Object.fromEntries(entries.map(([entryKey, entryValue]) => [
+            entryKey,
+            sanitizeAgyProtocolValue(entryValue, entryKey, depth + 1),
+        ]));
+    }
+    return '<unsupported>';
+}
+function collectShape(value, path, paths, kinds, stringLengths, depth = 0) {
+    if (depth > 8 || paths.size >= 256)
+        return;
+    if (value === null) {
+        kinds.add('null');
+        paths.add(path || '$');
+        return;
+    }
+    if (Array.isArray(value)) {
+        kinds.add('array');
+        paths.add(`${path || '$'}[]`);
+        for (const item of value.slice(0, 16))
+            collectShape(item, `${path || '$'}[]`, paths, kinds, stringLengths, depth + 1);
+        return;
+    }
+    if (typeof value === 'object') {
+        kinds.add('object');
+        for (const [key, nested] of Object.entries(value).slice(0, 128)) {
+            const nestedPath = path ? `${path}.${key}` : key;
+            paths.add(nestedPath);
+            collectShape(nested, nestedPath, paths, kinds, stringLengths, depth + 1);
+        }
+        return;
+    }
+    kinds.add(typeof value);
+    paths.add(path || '$');
+    if (typeof value === 'string')
+        stringLengths[path || '$'] = value.length;
+}
+/** Summarize one decoded output record without returning its payload. */
+export function summarizeAgyProtocolValue(value) {
+    const paths = new Set();
+    const kinds = new Set();
+    const stringLengths = {};
+    collectShape(value, '', paths, kinds, stringLengths);
+    const event = isRecord(value) && typeof value.event === 'string'
+        ? safeEnum(value.event)
+        : null;
+    return {
+        topLevelKeys: isRecord(value) ? Object.keys(value).sort() : [],
+        event,
+        shapePaths: [...paths].sort(),
+        valueKinds: [...kinds].sort(),
+        stringLengths: Object.freeze({ ...stringLengths }),
+    };
+}
+/** Convert one decoded output record into a safe fixture value. */
+export function sanitizeAgyProtocolRecord(value) {
+    return sanitizeAgyProtocolValue(value);
+}
+//# sourceMappingURL=stream-protocol.js.map

package/lib/agy/windows-launcher.d.ts

@@ -0,0 +1,21 @@
+export interface AgyLaunchSpec {
+    readonly executable: string;
+    readonly args: readonly string[];
+}
+export type WindowsLauncherArchitecture = 'x64' | 'arm64';
+export declare class AgyWindowsLauncherError extends Error {
+    readonly code: 'UNSUPPORTED_ARCH' | 'MISSING';
+    constructor(message: string, code: 'UNSUPPORTED_ARCH' | 'MISSING');
+}
+export declare function bundledWindowsLauncherPath(targetPlatform?: NodeJS.Platform, targetArch?: string): string | undefined;
+/** Quote one argument using the CommandLineToArgvW/MSVC convention. */
+export declare function quoteWindowsArgument(value: string): string;
+/**
+ * Route a Windows console-subsystem AGY executable through the bundled
+ * GUI-subsystem launcher. The child command line is UTF-8/base64 encoded so
+ * the launcher itself receives only a short, secret-free argument and can
+ * pass the original stdin/stdout/stderr handles through unchanged.
+ */
+export declare function buildWindowsNoConsoleLaunch(executable: string, args: readonly string[], targetPlatform?: NodeJS.Platform, targetArch?: string): AgyLaunchSpec;
+export declare function isWindowsLauncherAvailable(targetPlatform?: NodeJS.Platform, targetArch?: string): boolean;
+//# sourceMappingURL=windows-launcher.d.ts.map

package/lib/agy/windows-launcher.js

@@ -0,0 +1,76 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+export class AgyWindowsLauncherError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'AgyWindowsLauncherError';
+    }
+}
+function launcherArchitecture(arch) {
+    if (arch === 'x64')
+        return 'x64';
+    if (arch === 'arm64')
+        return 'arm64';
+    throw new AgyWindowsLauncherError(`No bundled Windows AGY launcher is available for architecture ${arch}`, 'UNSUPPORTED_ARCH');
+}
+export function bundledWindowsLauncherPath(targetPlatform = process.platform, targetArch = process.arch) {
+    if (targetPlatform !== 'win32')
+        return undefined;
+    const architecture = launcherArchitecture(targetArch);
+    return fileURLToPath(new URL(`../../bin/win32-${architecture}/agy-launcher.exe`, import.meta.url));
+}
+/** Quote one argument using the CommandLineToArgvW/MSVC convention. */
+export function quoteWindowsArgument(value) {
+    if (value.length === 0)
+        return '""';
+    if (!/[\s"]/.test(value))
+        return value;
+    let output = '"';
+    let backslashes = 0;
+    for (const character of value) {
+        if (character === '\\') {
+            backslashes += 1;
+            continue;
+        }
+        if (character === '"') {
+            output += '\\'.repeat(backslashes * 2 + 1);
+            output += '"';
+            backslashes = 0;
+            continue;
+        }
+        output += '\\'.repeat(backslashes);
+        output += character;
+        backslashes = 0;
+    }
+    output += '\\'.repeat(backslashes * 2);
+    return `${output}"`;
+}
+function childCommandLine(executable, args) {
+    return [executable, ...args].map(quoteWindowsArgument).join(' ');
+}
+/**
+ * Route a Windows console-subsystem AGY executable through the bundled
+ * GUI-subsystem launcher. The child command line is UTF-8/base64 encoded so
+ * the launcher itself receives only a short, secret-free argument and can
+ * pass the original stdin/stdout/stderr handles through unchanged.
+ */
+export function buildWindowsNoConsoleLaunch(executable, args, targetPlatform = process.platform, targetArch = process.arch) {
+    if (targetPlatform !== 'win32')
+        return { executable, args: [...args] };
+    const launcher = bundledWindowsLauncherPath(targetPlatform, targetArch);
+    if (launcher === undefined)
+        throw new AgyWindowsLauncherError('Windows launcher is unavailable', 'MISSING');
+    const command = childCommandLine(executable, args);
+    const encodedCommand = Buffer.from(command, 'utf8').toString('base64');
+    return {
+        executable: launcher,
+        args: ['--command-base64', encodedCommand],
+    };
+}
+export function isWindowsLauncherAvailable(targetPlatform = process.platform, targetArch = process.arch) {
+    const launcher = bundledWindowsLauncherPath(targetPlatform, targetArch);
+    return launcher !== undefined && existsSync(launcher);
+}
+//# sourceMappingURL=windows-launcher.js.map

package/lib/diagnostics.d.ts

@@ -0,0 +1,78 @@
+import { type AgyDiagnosticCommand, type AgyDiagnosticResult } from './agy/diagnostics.js';
+import { type AgyModelDiscoveryCommand, type ModelDiscoverySource } from './agy/models.js';
+import type { ModelDiscoveryErrorCode } from './provider/error-codes.js';
+import { type Config, type ToolPolicy } from './provider/config.js';
+export interface DiagnosticModel {
+    id: string;
+    name: string;
+    description: string | null;
+    inputModalities: readonly ('text' | 'image')[];
+    contextWindow: number | null;
+}
+export type DiagnosticComponent = 'node' | 'bundle' | 'agy' | 'models' | 'config' | 'profile';
+export interface DiagnosticIssue {
+    component: DiagnosticComponent;
+    code: string;
+    message: string;
+}
+export interface ProviderDiagnosticOptions {
+    config?: Config;
+    executable?: string;
+    timeoutMs?: number;
+    runCommand?: AgyDiagnosticCommand;
+    runModelDiscovery?: AgyModelDiscoveryCommand;
+    pluginVersion?: string | null;
+    dshCliVersion?: string | null;
+    dshLlmVersion?: string | null;
+    bundlePatchPresent?: boolean;
+    nodeVersion?: string;
+}
+export interface ProviderDiagnosticResult {
+    schemaVersion: 2;
+    ok: boolean;
+    quotaUsed: false;
+    plugin: {
+        name: string;
+        version: string | null;
+        enabled: boolean;
+    };
+    node: {
+        version: string;
+        major: number | null;
+        supported: boolean;
+    };
+    dsh: {
+        cliVersion: string | null;
+        llmContractVersion: string | null;
+        bundlePatchPresent: boolean;
+    };
+    configuration: {
+        provider: string;
+        agent: string;
+        defaultModel: string;
+        modelDiscovery: 'auto' | 'off';
+        toolPolicy: ToolPolicy;
+        sessionMode: 'resume' | 'full';
+        enabled: boolean;
+        transport: string;
+        persistentIdleTtlMs: number;
+        persistentReadyTimeoutMs: number;
+        persistentFallback: string;
+    };
+    models: readonly DiagnosticModel[];
+    modelCatalog: {
+        source: 'static' | ModelDiscoverySource;
+        stale: boolean;
+        warning: string | null;
+        warningCode: ModelDiscoveryErrorCode | null;
+    };
+    agy: AgyDiagnosticResult;
+    errors: readonly DiagnosticIssue[];
+}
+/**
+ * Build the machine-readable, quota-free diagnostic contract for the plugin.
+ * It deliberately exposes only safe labels and metadata, never AGY paths,
+ * environment values, credentials, prompts, or session content.
+ */
+export declare function diagnoseProvider(options?: ProviderDiagnosticOptions): Promise<ProviderDiagnosticResult>;
+//# sourceMappingURL=diagnostics.d.ts.map

package/lib/diagnostics.js

@@ -0,0 +1,162 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { diagnoseAgy, } from './agy/diagnostics.js';
+import { AgyModelDiscovery, } from './agy/models.js';
+import { redactText } from './agy/redact.js';
+import { Config as ConfigSchema, configuredModels, readConfigFlag, DEFAULT_AGENT, } from './provider/config.js';
+const require = createRequire(import.meta.url);
+function loadPackageMetadata() {
+    try {
+        return require('../package.json');
+    }
+    catch {
+        return {};
+    }
+}
+const packageMetadata = loadPackageMetadata();
+function modelDiagnostic(model, imageInput) {
+    return {
+        id: model.id,
+        name: model.name ?? model.id,
+        description: model.description ?? null,
+        inputModalities: imageInput === 'experimental' ? ['text', 'image'] : ['text'],
+        contextWindow: model.contextWindow ?? null,
+    };
+}
+function issueCode(message) {
+    if (/below the required minimum/i.test(message))
+        return 'AGY_VERSION_UNSUPPORTED';
+    if (/version from --version/i.test(message))
+        return 'AGY_VERSION_UNREADABLE';
+    if (/Agent .* was not found/i.test(message))
+        return 'AGY_AGENT_MISSING';
+    if (/agents failed/i.test(message))
+        return 'AGY_AGENT_CHECK_FAILED';
+    if (/--version failed/i.test(message))
+        return 'AGY_VERSION_CHECK_FAILED';
+    return 'AGY_DIAGNOSTIC_FAILED';
+}
+function nodeMajorOf(version) {
+    const match = /^(\d+)/.exec(version);
+    if (match === null)
+        return null;
+    const major = Number(match[1]);
+    return Number.isSafeInteger(major) ? major : null;
+}
+/**
+ * Build the machine-readable, quota-free diagnostic contract for the plugin.
+ * It deliberately exposes only safe labels and metadata, never AGY paths,
+ * environment values, credentials, prompts, or session content.
+ */
+export async function diagnoseProvider(options = {}) {
+    const config = ConfigSchema(options.config ?? {});
+    const nodeVersion = options.nodeVersion ?? process.versions.node;
+    const nodeMajor = nodeMajorOf(nodeVersion);
+    const nodeSupported = nodeMajor !== null && nodeMajor >= 20;
+    const bundlePatchPresent = options.bundlePatchPresent
+        ?? existsSync(fileURLToPath(new URL('../cordis.patch.yml', import.meta.url)));
+    const executable = options.executable ?? config.agyPath;
+    const configuredCatalog = configuredModels(config);
+    const modelDiscoveryCommand = options.runModelDiscovery ?? options.runCommand;
+    const discovery = config.modelDiscovery === 'off'
+        ? undefined
+        : new AgyModelDiscovery({
+            ...(executable === undefined || executable.trim().length === 0 ? {} : { executable }),
+            ...(config.modelDiscoveryTtlMs === undefined ? {} : { ttlMs: config.modelDiscoveryTtlMs }),
+            ...(config.modelDiscoveryTimeoutMs === undefined ? {} : { timeoutMs: config.modelDiscoveryTimeoutMs }),
+            ...(config.maxOutputBytes === undefined ? {} : { maxOutputBytes: config.maxOutputBytes }),
+            ...(modelDiscoveryCommand === undefined ? {} : { runCommand: modelDiscoveryCommand }),
+        });
+    const modelCatalog = discovery === undefined
+        ? { models: configuredCatalog, source: 'static', stale: false }
+        : await discovery.discover(configuredCatalog);
+    const models = modelCatalog.models.map(model => modelDiagnostic(model, config.imageInput));
+    const agyOptions = {
+        ...(executable === undefined || executable.trim().length === 0 ? {} : { executable }),
+        expectedAgent: config.agent ?? DEFAULT_AGENT,
+        minimumVersion: config.minimumAgyVersion ?? '1.1.15',
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+        ...(options.runCommand === undefined ? {} : { runCommand: options.runCommand }),
+    };
+    const agy = await diagnoseAgy(agyOptions);
+    const errors = [];
+    if (!nodeSupported) {
+        errors.push({
+            component: 'node',
+            code: 'NODE_UNSUPPORTED',
+            message: `Node.js ${nodeVersion} is below the required major version 20`,
+        });
+    }
+    if (!bundlePatchPresent) {
+        errors.push({
+            component: 'bundle',
+            code: 'BUNDLE_PATCH_MISSING',
+            message: 'dsh.bundle.patch and cordis.patch.yml could not be verified',
+        });
+    }
+    if (models.length === 0) {
+        errors.push({
+            component: 'models',
+            code: 'MODEL_CATALOG_EMPTY',
+            message: 'No effective model is configured',
+        });
+    }
+    for (const message of agy.errors) {
+        errors.push({
+            component: 'agy',
+            code: issueCode(message),
+            message: redactText(message, 512),
+        });
+    }
+    const metadata = packageMetadata;
+    const llmContractVersion = options.dshLlmVersion
+        ?? metadata.devDependencies?.['@deepseek-ai/dsh-llm']
+        ?? metadata.peerDependencies?.['@deepseek-ai/dsh-llm']
+        ?? null;
+    return {
+        schemaVersion: 2,
+        ok: errors.length === 0,
+        quotaUsed: false,
+        plugin: {
+            name: metadata.name ?? 'dsh-agy-cli',
+            version: options.pluginVersion ?? metadata.version ?? null,
+            enabled: readConfigFlag(config.enabled),
+        },
+        node: {
+            version: nodeVersion,
+            major: nodeMajor,
+            supported: nodeSupported,
+        },
+        dsh: {
+            cliVersion: options.dshCliVersion ?? process.env.DSH_CLI_VERSION ?? null,
+            llmContractVersion,
+            bundlePatchPresent,
+        },
+        configuration: {
+            provider: config.provider ?? 'agy',
+            agent: config.agent ?? DEFAULT_AGENT,
+            defaultModel: config.model ?? models[0]?.id ?? 'unknown',
+            modelDiscovery: config.modelDiscovery === 'off' ? 'off' : 'auto',
+            toolPolicy: config.toolPolicy === 'agy-owned'
+                ? 'agy-owned'
+                : config.toolPolicy === 'dsh-owned' ? 'dsh-owned' : 'reject',
+            sessionMode: config.sessionMode === 'resume' ? 'resume' : 'full',
+            enabled: readConfigFlag(config.enabled),
+            transport: config.transport ?? 'one-shot',
+            persistentIdleTtlMs: config.persistentIdleTtlMs ?? 30000,
+            persistentReadyTimeoutMs: config.persistentReadyTimeoutMs ?? 10000,
+            persistentFallback: config.persistentFallback ?? 'before-accept',
+        },
+        models,
+        modelCatalog: {
+            source: modelCatalog.source,
+            stale: modelCatalog.stale,
+            warning: modelCatalog.warning ?? null,
+            warningCode: modelCatalog.warningCode ?? null,
+        },
+        agy,
+        errors,
+    };
+}
+//# sourceMappingURL=diagnostics.js.map

package/lib/doctor.d.ts

@@ -0,0 +1,138 @@
+import { type DiagnosticIssue, type ProviderDiagnosticOptions, type ProviderDiagnosticResult } from './diagnostics.js';
+import { type ToolPolicy } from './provider/config.js';
+export interface ProfileDiagnosticOptions {
+    profileName: string;
+    dshHome?: string | undefined;
+    dshBin?: string | undefined;
+    timeoutMs?: number | undefined;
+    runCommand?: ((executable: string, args: readonly string[], options?: {
+        timeoutMs?: number | undefined;
+        cwd?: string | undefined;
+        env?: NodeJS.ProcessEnv | undefined;
+    }) => Promise<{
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+        timedOut: boolean;
+    }>) | undefined;
+}
+export type ProfileDumpStatus = 'not-run' | 'ok' | 'unavailable' | 'timeout' | 'nonzero' | 'parse-error';
+export interface EffectivePurposeRoute {
+    configured: boolean;
+    complete: boolean | null;
+    model: string | null;
+    agent: string | null;
+    reasoningEffort: string | null;
+}
+export interface EffectiveDshContext {
+    source: 'profile-dump';
+    session: {
+        state: 'not-probed';
+        required: boolean;
+    };
+    workspace: {
+        state: 'not-probed';
+        configured: boolean;
+    };
+    permission: {
+        state: 'not-probed';
+        preset: null;
+    };
+    approval: {
+        state: 'not-probed';
+        policy: null;
+    };
+    services: {
+        sessions: 'not-probed';
+        workspaceRegistry: 'not-probed';
+        sandboxPolicy: 'not-probed';
+        permissionPresets: 'not-probed';
+        approval: 'not-probed';
+    };
+}
+export interface EffectiveBridgeCapability {
+    owner: 'none' | 'agy' | 'dsh' | 'unknown';
+    enabled: boolean | null;
+    agent: string | null;
+    internalTools: 'empty' | 'present' | 'unknown';
+    schemaCapability: 'unsupported' | 'agy-owned' | 'prompt-contract-v1' | 'unknown';
+    legacyConfig: {
+        agyOwned: boolean;
+        workspaceRootConfigured: boolean;
+    };
+}
+export interface EffectiveProfileConfig {
+    dumpStatus: ProfileDumpStatus;
+    provider: string | null;
+    model: string | null;
+    agent: string | null;
+    agentPreset: string | null;
+    sessionMode: string | null;
+    retryPolicy: {
+        maxRetries: number | null;
+        retryableCodes: readonly string[];
+    } | null;
+    purposeRoutes: {
+        compaction: EffectivePurposeRoute | null;
+        sessionTitle: EffectivePurposeRoute | null;
+    };
+    workspaceRootStatus: 'configured' | 'missing' | 'not-directory' | 'unknown';
+    workspaceSource: 'dsh-session-cwd' | 'config-legacy' | 'unknown';
+    visibleModels: {
+        raw: string | null;
+        count: number | null;
+        filtered: boolean;
+    };
+    modelEffortSplit: {
+        baseModel: string | null;
+        suffixDetected: boolean;
+        normalized: boolean;
+    };
+    imageInput: string | null;
+    modelCapability: {
+        inputModalities: readonly ('text' | 'image')[];
+        imageBridge: 'off' | 'experimental' | 'unknown';
+    };
+    agentCapability: {
+        knownPreset: boolean | null;
+        frontmatterValid: boolean | null;
+        tools: readonly string[];
+        viewFile: boolean | null;
+        writeTools: boolean | null;
+        commandExecutionPolicy: string | null;
+        mcpServersEmpty: boolean | null;
+        subagent: boolean | null;
+    };
+    dshContext: EffectiveDshContext;
+    bridgeCapability: EffectiveBridgeCapability;
+}
+export interface ProfileDiagnosticResult {
+    profileSchemaVersion: 4;
+    name: string;
+    dshHomePresent: boolean;
+    profilePresent: boolean;
+    packageInstalled: boolean;
+    bundleDeclared: boolean;
+    bundleEnabled: boolean | null;
+    toolPolicy: ToolPolicy | string | null;
+    effectiveProvider: string | null;
+    effectiveModel: string | null;
+    effective: EffectiveProfileConfig;
+    repairSuggestions: readonly string[];
+    issues: DiagnosticIssue[];
+}
+export interface DoctorOptions extends ProviderDiagnosticOptions {
+    profile?: string | undefined;
+    dshHome?: string | undefined;
+    dshBin?: string | undefined;
+    runProfileCommand?: ProfileDiagnosticOptions['runCommand'] | undefined;
+}
+export interface DoctorResult extends ProviderDiagnosticResult {
+    profile?: ProfileDiagnosticResult | undefined;
+}
+export declare function diagnoseProfile(options: ProfileDiagnosticOptions): Promise<ProfileDiagnosticResult>;
+export declare function runDoctor(options?: DoctorOptions): Promise<DoctorResult>;
+export declare function formatDoctorHuman(result: DoctorResult): string;
+export declare function formatDoctorHelp(): string;
+export declare function runDoctorCli(argv: readonly string[], stdout?: (text: string) => void, stderr?: (text: string) => void): Promise<number>;
+//# sourceMappingURL=doctor.d.ts.map