@praneeth_54/agentdoctor 2.0.1 → 3.0.0

package/dist/ai/redact.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Redaction for outbound model payloads.
+ * Extends the local-ai redaction patterns; never send raw secrets to providers.
+ * Patterns avoid nested unbounded quantifiers (ReDoS-safe).
+ */
+export declare function redactForModel(text: string): string;
+export declare function redactMessages<T extends {
+    content: string;
+}>(messages: T[]): T[];

package/dist/ai/redact.js

@@ -0,0 +1,61 @@
+/**
+ * Redaction for outbound model payloads.
+ * Extends the local-ai redaction patterns; never send raw secrets to providers.
+ * Patterns avoid nested unbounded quantifiers (ReDoS-safe).
+ */
+const REDACTED = "[REDACTED]";
+const SIMPLE_SECRET_PATTERNS = [
+    /\b(AKIA[0-9A-Z]{16})\b/g,
+    /\b(ghp_[A-Za-z0-9]{36})\b/g,
+    /\b(sk-[A-Za-z0-9]{20,80})\b/g,
+    /\b((?:export\s+)?(?:AWS_SECRET_ACCESS_KEY|GITHUB_TOKEN|NPM_TOKEN|OPENAI_API_KEY|ANTHROPIC_API_KEY|STRIPE_SECRET_KEY|AGENTDOCTOR_AI_API_KEY)\s*=\s*)(\S+)/gi,
+];
+/** Linear scan — avoids polynomial backtracking on PEM fences. */
+function redactPrivateKeyBlocks(text) {
+    const beginToken = "-----BEGIN ";
+    const endToken = "-----END ";
+    const keySuffix = "PRIVATE KEY-----";
+    let out = "";
+    let i = 0;
+    while (i < text.length) {
+        const start = text.indexOf(beginToken, i);
+        if (start === -1) {
+            out += text.slice(i);
+            break;
+        }
+        out += text.slice(i, start);
+        const afterBegin = start + beginToken.length;
+        const keyLabelEnd = text.indexOf(keySuffix, afterBegin);
+        if (keyLabelEnd === -1 || keyLabelEnd - afterBegin > 64) {
+            out += text.slice(start, afterBegin);
+            i = afterBegin;
+            continue;
+        }
+        const headerEnd = keyLabelEnd + keySuffix.length;
+        const endStart = text.indexOf(endToken, headerEnd);
+        if (endStart === -1) {
+            out += text.slice(start, headerEnd);
+            i = headerEnd;
+            continue;
+        }
+        const endLabelEnd = text.indexOf(keySuffix, endStart + endToken.length);
+        if (endLabelEnd === -1 || endLabelEnd - (endStart + endToken.length) > 64) {
+            out += text.slice(start, headerEnd);
+            i = headerEnd;
+            continue;
+        }
+        out += REDACTED;
+        i = endLabelEnd + keySuffix.length;
+    }
+    return out;
+}
+export function redactForModel(text) {
+    let out = redactPrivateKeyBlocks(text);
+    for (const re of SIMPLE_SECRET_PATTERNS) {
+        out = out.replace(re, (_m, prefix) => typeof prefix === "string" && prefix.includes("=") ? `${prefix}${REDACTED}` : REDACTED);
+    }
+    return out;
+}
+export function redactMessages(messages) {
+    return messages.map((m) => ({ ...m, content: redactForModel(m.content) }));
+}

package/dist/ai/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Provider-agnostic model types for AgentDoctor 2.1 Project AI Agent.
+ * The model reasons; AgentDoctor owns context, tools, and verification.
+ */
+export type AiProviderId = "none" | "deterministic" | "mock" | "openai-compatible" | "ollama" | "anthropic" | "gemini";
+export type ChatRole = "system" | "user" | "assistant" | "tool";
+export interface ChatMessage {
+    role: ChatRole;
+    content: string;
+    /** Tool call id when role is tool */
+    toolCallId?: string;
+    name?: string;
+}
+export interface ToolSpec {
+    name: string;
+    description: string;
+    /** JSON Schema object for arguments */
+    parameters: Record<string, unknown>;
+}
+export interface ToolCallRequest {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface TokenUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+}
+export interface ChatRequest {
+    messages: ChatMessage[];
+    tools?: ToolSpec[];
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** AbortSignal for cancellation when supported */
+    signal?: AbortSignal;
+}
+export interface ChatResponse {
+    provider: AiProviderId;
+    model: string;
+    message: ChatMessage;
+    toolCalls: ToolCallRequest[];
+    usage?: TokenUsage;
+    finishReason?: string;
+    /** Always true for model-generated content */
+    aiGenerated: true;
+    error?: string;
+}
+export interface ModelMetadata {
+    provider: AiProviderId;
+    model: string;
+    supportsTools: boolean;
+    supportsStreaming: boolean;
+    supportsStructuredOutput: boolean;
+}
+export interface ModelProvider {
+    readonly id: AiProviderId;
+    metadata(): ModelMetadata;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    /**
+     * Optional streaming. Providers that do not support streaming reject.
+     */
+    streamChat?(request: ChatRequest): AsyncIterable<{
+        delta: string;
+        done: boolean;
+        response?: ChatResponse;
+    }>;
+}
+/** User-facing copy when AI is not configured. */
+export declare const AI_PROVIDER_REQUIRED_MESSAGE = "AI features require an AI provider. AgentDoctor's project analysis features continue to work without AI.";

package/dist/ai/types.js

@@ -0,0 +1,6 @@
+/**
+ * Provider-agnostic model types for AgentDoctor 2.1 Project AI Agent.
+ * The model reasons; AgentDoctor owns context, tools, and verification.
+ */
+/** User-facing copy when AI is not configured. */
+export const AI_PROVIDER_REQUIRED_MESSAGE = "AI features require an AI provider. AgentDoctor's project analysis features continue to work without AI.";

package/dist/cli/commands/agent.d.ts

@@ -0,0 +1,29 @@
+import { type AgentRole } from "../../agent/roles.js";
+import { type ExitCode } from "../../types/index.js";
+/**
+ * agentdoctor plan — produce an implementation plan (no writes unless --apply elsewhere).
+ */
+export declare function runPlanCommand(options: {
+    goal: string;
+    root?: string;
+    json?: boolean;
+    approve?: boolean;
+}): Promise<ExitCode>;
+/**
+ * agentdoctor agent — inspect, plan, and (with --approve) mutate via controlled tools.
+ */
+export declare function runAgentCommand(options: {
+    root?: string;
+    goal?: string;
+    tool?: string;
+    toolArgs?: Record<string, unknown>;
+    listTools?: boolean;
+    json?: boolean;
+    approve?: boolean;
+    apply?: boolean;
+    /** JSON array of {name, arguments} for deterministic apply */
+    applyOpsJson?: string;
+    verify?: boolean;
+    runTests?: boolean;
+    role?: AgentRole;
+}): Promise<ExitCode>;

package/dist/cli/commands/agent.js

@@ -0,0 +1,164 @@
+import { approvePlan, buildAgentPlan, formatAgentPlan } from "../../agent/plan.js";
+import { evaluateApproval, formatApprovalPrompt } from "../../agent/approvals.js";
+import { runCodingLoop } from "../../agent/loop.js";
+import { runRoleAgent } from "../../agent/roles.js";
+import { executeAgentTool, getToolSpec, listAgentToolSpecs, newToolCall, } from "../../agent/tools/index.js";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { colors } from "../../utils/colors.js";
+/**
+ * agentdoctor plan — produce an implementation plan (no writes unless --apply elsewhere).
+ */
+export async function runPlanCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const plan = await buildAgentPlan({ root, goal: options.goal });
+    if (options.approve) {
+        const approved = approvePlan(plan, true);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ...approved, note: "Approval recorded; use agent --apply to mutate" }, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(formatAgentPlan(approved));
+            process.stdout.write(`${colors.yellow('\nApproval recorded. Use: agentdoctor agent --goal "..." --approve --apply\n')}\n`);
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(formatAgentPlan(plan));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+/**
+ * agentdoctor agent — inspect, plan, and (with --approve) mutate via controlled tools.
+ */
+export async function runAgentCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const approvedByHuman = options.approve === true;
+    if (options.listTools) {
+        const tools = listAgentToolSpecs({ includeWrite: true, includeExecute: true });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(tools, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(`\n${colors.bold("AgentDoctor tools")}\n\n`);
+            for (const t of tools) {
+                process.stdout.write(`  [${t.risk}] ${t.name} (${t.category}) — ${t.description}\n`);
+            }
+            process.stdout.write("\n");
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.tool) {
+        const name = options.tool;
+        const spec = getToolSpec(name);
+        if (!spec) {
+            process.stderr.write(`Unknown tool: ${name}\n`);
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        const approval = evaluateApproval({ action: `tool:${name}`, risk: spec.risk, toolName: name }, { approvedByHuman });
+        if (approval.needsHumanApproval) {
+            process.stderr.write(formatApprovalPrompt({ action: `tool:${name}`, risk: approval.risk, toolName: name }, approval));
+            process.stderr.write("Re-run with --approve for write/execute tools.\n");
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        const call = newToolCall("cli-agent", name, options.toolArgs ?? {});
+        const result = await executeAgentTool(root, call, {
+            allowWrite: approvedByHuman,
+            allowExecute: approvedByHuman,
+            approvedByHuman,
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        }
+        else if (result.ok) {
+            process.stdout.write(`${JSON.stringify(result.data, null, 2)}\n`);
+        }
+        else {
+            process.stderr.write(`Tool failed: ${result.error?.code} — ${result.error?.message}\n`);
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.goal && options.apply) {
+        if (!approvedByHuman) {
+            process.stderr.write("Refusing --apply without --approve (human approval required).\n");
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        let toolCalls;
+        if (options.applyOpsJson) {
+            try {
+                const parsed = JSON.parse(options.applyOpsJson);
+                if (!Array.isArray(parsed))
+                    throw new Error("expected array");
+                toolCalls = parsed.map((item) => {
+                    const row = item;
+                    if (!row.name || typeof row.name !== "string")
+                        throw new Error("ops need name");
+                    return {
+                        name: row.name,
+                        arguments: row.arguments ?? {},
+                    };
+                });
+            }
+            catch (error) {
+                process.stderr.write(`Invalid --apply-ops JSON: ${error instanceof Error ? error.message : String(error)}\n`);
+                return EXIT_CODES.USAGE_ERROR;
+            }
+        }
+        const result = options.role
+            ? await runRoleAgent({
+                role: options.role,
+                root,
+                goal: options.goal,
+                approvedByHuman: true,
+                ...(toolCalls ? { toolCalls } : {}),
+                verify: options.verify !== false,
+                runTests: options.runTests === true,
+            })
+            : await runCodingLoop({
+                root,
+                goal: options.goal,
+                approvedByHuman: true,
+                ...(toolCalls ? { toolCalls } : {}),
+                verify: options.verify !== false,
+                runTests: options.runTests === true,
+            });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(result.responseText);
+        }
+        if (result.stoppedReason === "awaiting-approval")
+            return EXIT_CODES.USAGE_ERROR;
+        if (result.stoppedReason === "failed" || result.stoppedReason === "limit") {
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.goal) {
+        return runPlanCommand({
+            goal: options.goal,
+            root,
+            ...(options.json !== undefined ? { json: options.json } : {}),
+            ...(approvedByHuman ? { approve: true } : {}),
+        });
+    }
+    process.stderr.write([
+        "",
+        "AgentDoctor agent (Milestone 4)",
+        "",
+        "Usage:",
+        "  agentdoctor agent --list-tools",
+        "  agentdoctor agent --tool inspect_project [path]",
+        '  agentdoctor plan "Add registration" [path]',
+        "  agentdoctor agent --goal \"Add registration\" --approve --apply --apply-ops '[...]' [path]",
+        "",
+        "Writes require --approve. Unrestricted shell is never exposed.",
+        "",
+    ].join("\n"));
+    return EXIT_CODES.USAGE_ERROR;
+}

package/dist/cli/commands/chat.d.ts

@@ -0,0 +1,14 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runAskCommand(options: {
+    question: string;
+    root?: string;
+    json?: boolean;
+    /** Test-only: force mock provider */
+    useMock?: boolean;
+}): Promise<ExitCode>;
+export declare function runChatCommand(options: {
+    root?: string;
+    /** Non-interactive scripted lines (tests) */
+    scriptedInputs?: string[];
+    useMock?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/chat.js

@@ -0,0 +1,153 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { ChatService, formatChatResponseForCli } from "../../agent/chat/index.js";
+import { MockModelProvider, createModelProvider, loadAiConfig } from "../../ai/index.js";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { colors } from "../../utils/colors.js";
+function printBanner(options) {
+    const lines = [
+        "",
+        colors.bold("AgentDoctor Project Chat"),
+        "",
+        `Project:`,
+        `  ${options.name}`,
+        `  ${options.root}`,
+        "",
+        `Detected:`,
+        `  ${(options.languages.length ? options.languages : ["(none)"]).join(", ")}`,
+        `  frameworks: ${(options.frameworks.length ? options.frameworks : ["(none)"]).join(", ")}`,
+        "",
+        `AI:`,
+        `  ${options.providerLabel}`,
+        "",
+        "Ask questions about your project.",
+        "",
+        "Commands:",
+        "  /help     Show help",
+        "  /project  Project summary",
+        "  /context  Context used for last answer",
+        "  /clear    Clear conversation memory",
+        "  /exit     Leave chat",
+        "",
+        "Milestone 2 does not edit files or run commands.",
+        "",
+    ];
+    process.stdout.write(`${lines.join("\n")}\n`);
+}
+function printHelp() {
+    process.stdout.write([
+        "",
+        "Ask natural-language questions about this repository.",
+        "Answers use project evidence (Brain/graph/context) when available.",
+        "",
+        "Truth labels: VERIFIED | INFERRED | UNKNOWN | EXTERNAL",
+        "",
+        "Examples:",
+        "  Explain my project.",
+        "  How does authentication work?",
+        "  Explain this like I'm a beginner.",
+        "",
+    ].join("\n"));
+}
+export async function runAskCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
+    const chat = new ChatService({
+        root,
+        provider,
+        persistAudit: !options.useMock,
+    });
+    try {
+        const response = await chat.ask(options.question);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(formatChatResponseForCli(response));
+        }
+        if (response.status === "provider-none")
+            return EXIT_CODES.USAGE_ERROR;
+        if (response.status === "provider-error" || response.status === "failed") {
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    finally {
+        await chat.end();
+    }
+}
+export async function runChatCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
+    const chat = new ChatService({
+        root,
+        provider,
+        persistAudit: !options.useMock,
+    });
+    const started = await chat.start();
+    printBanner({
+        root: started.summary.root,
+        name: started.summary.name,
+        providerLabel: started.providerLabel,
+        languages: started.summary.languages,
+        frameworks: started.summary.frameworks,
+    });
+    if (provider.id === "none" && !options.useMock) {
+        process.stdout.write("Deterministic project chat (no LLM). Architecture, auth, and dependency questions use local analyzers.\n\n");
+    }
+    const scripted = options.scriptedInputs ? [...options.scriptedInputs] : undefined;
+    const rl = scripted === undefined
+        ? readline.createInterface({ input, output, terminal: Boolean(output.isTTY) })
+        : undefined;
+    const readLine = async () => {
+        if (scripted) {
+            if (scripted.length === 0)
+                return null;
+            return scripted.shift() ?? null;
+        }
+        const answer = await rl.question("You:\n> ");
+        return answer;
+    };
+    try {
+        while (true) {
+            const raw = await readLine();
+            if (raw === null)
+                break;
+            const line = raw.trim();
+            if (!line)
+                continue;
+            if (line === "/exit" || line === "exit" || line === "quit") {
+                process.stdout.write("Goodbye.\n");
+                break;
+            }
+            if (line === "/help" || line === "help") {
+                printHelp();
+                continue;
+            }
+            if (line === "/project") {
+                process.stdout.write(await chat.formatProject());
+                continue;
+            }
+            if (line === "/context") {
+                process.stdout.write(chat.formatContext());
+                continue;
+            }
+            if (line === "/clear") {
+                chat.clearMemory();
+                process.stdout.write("Conversation memory cleared.\n");
+                continue;
+            }
+            const response = await chat.ask(line);
+            process.stdout.write(chat.formatResponse(response));
+            if (response.status === "provider-error") {
+                // stay in loop; user may fix provider elsewhere
+            }
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    finally {
+        rl?.close();
+        await chat.end();
+    }
+}

package/dist/cli/commands/learn.d.ts

@@ -0,0 +1,12 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runLearnCommand(options: {
+    root?: string;
+    mode?: string;
+    viva?: boolean;
+    docs?: boolean;
+    build?: string;
+    approve?: boolean;
+    applyOpsJson?: string;
+    json?: boolean;
+    useMock?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/learn.js

@@ -0,0 +1,107 @@
+import { MockModelProvider, createModelProvider, loadAiConfig } from "../../ai/index.js";
+import { StudentService } from "../../agent/student.js";
+import { parseAgentMode, defaultStudentMode } from "../../agent/modes.js";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+export async function runLearnCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const mode = parseAgentMode(options.mode) ?? defaultStudentMode();
+    const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
+    const resolvedMode = options.build
+        ? mode === "LEARN"
+            ? "BUILD_WITH_ME"
+            : mode
+        : options.viva || options.docs
+            ? "LEARN"
+            : mode;
+    const student = new StudentService({
+        root,
+        provider,
+        mode: resolvedMode,
+    });
+    try {
+        if (options.build) {
+            let toolCalls;
+            if (options.applyOpsJson) {
+                try {
+                    const parsed = JSON.parse(options.applyOpsJson);
+                    if (!Array.isArray(parsed))
+                        throw new Error("expected array");
+                    toolCalls = parsed.map((item) => {
+                        const row = item;
+                        if (!row.name || typeof row.name !== "string")
+                            throw new Error("ops need name");
+                        return {
+                            name: row.name,
+                            arguments: row.arguments ?? {},
+                        };
+                    });
+                }
+                catch (error) {
+                    process.stderr.write(`Invalid --apply-ops JSON: ${error instanceof Error ? error.message : String(error)}\n`);
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+            }
+            const result = await student.buildFeature({
+                goal: options.build,
+                approvedByHuman: options.approve === true,
+                ...(toolCalls ? { toolCalls } : {}),
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+            }
+            else {
+                process.stdout.write(result.explanation);
+                if (result.status === "awaiting-approval") {
+                    process.stdout.write("\nRe-run with --approve to execute the coding loop.\n");
+                }
+                else if (result.coding) {
+                    process.stdout.write(result.evidenceText);
+                }
+                else {
+                    process.stdout.write(`${result.evidenceText}\n`);
+                }
+            }
+            if (result.status === "awaiting-approval" || result.status === "mode_forbidden") {
+                return EXIT_CODES.USAGE_ERROR;
+            }
+            if (result.status === "failed" || result.status === "limit") {
+                return EXIT_CODES.INTERNAL_ERROR;
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.viva) {
+            const questions = await student.generateVivaQuestions();
+            if (options.json)
+                process.stdout.write(`${JSON.stringify({ mode, questions }, null, 2)}\n`);
+            else {
+                process.stdout.write("\nViva questions (grounded in detected stack):\n\n");
+                for (const [i, q] of questions.entries())
+                    process.stdout.write(`  ${i + 1}. ${q}\n`);
+                process.stdout.write("\n");
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.docs) {
+            const sections = await student.generateProjectDocumentation();
+            if (options.json)
+                process.stdout.write(`${JSON.stringify({ mode, sections }, null, 2)}\n`);
+            else {
+                for (const s of sections) {
+                    process.stdout.write(`\n[${s.truth}] ${s.title}\n${s.body}\n`);
+                }
+                process.stdout.write("\n");
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        const explained = await student.explainProject();
+        if (options.json)
+            process.stdout.write(`${JSON.stringify({ mode, ...explained }, null, 2)}\n`);
+        else
+            process.stdout.write(explained.text);
+        return EXIT_CODES.SUCCESS;
+    }
+    finally {
+        await student.end();
+    }
+}

package/dist/cli/commands/product.d.ts

@@ -0,0 +1,19 @@
+import { type ExitCode } from "../../types/index.js";
+import { type AgentRole } from "../../agent/roles.js";
+export type ProductCommandAction = "requirements" | "api" | "database" | "events" | "dependency" | "health-code" | "map" | "what-if" | "decisions" | "forensic" | "twin" | "eval-lab" | "self-check" | "infra" | "incident" | "security-doctor" | "privacy-doctor" | "search" | "tech-debt" | "features" | "evolution" | "memory" | "org" | "role-agent" | "test-brain";
+export declare function runProductCommand(options: {
+    action: ProductCommandAction;
+    root?: string;
+    json?: boolean;
+    target?: string;
+    changedFiles?: string[];
+    query?: string;
+    role?: AgentRole;
+    goal?: string;
+    approve?: boolean;
+    apply?: boolean;
+}): Promise<ExitCode>;
+export declare function runChangeLedgerListCommand(options: {
+    root?: string;
+    json?: boolean;
+}): Promise<ExitCode>;