@mcpeak/cli 0.10.0 → 0.12.0

package/dist/src-CwhDFSWk.cjs

@@ -1,482 +0,0 @@
-const require_test_command = require("./test-command-BbjJIX7j.cjs");
-let node_fs_promises = require("node:fs/promises");
-//#region src/verify-command.ts
-/**
-* 런타임 모듈을 못 불러 fallback 의존성이 쓰일 때 던진다.
-*
-* 타입을 따로 두는 이유는 이 실패가 **카세트 손상과 구분돼야** 하기 때문이다. 그냥 던지면
-* `CASSETTE_READ_FAILED` 로 잡혀 "카세트 파일이 손상되지 않았는지 확인하세요" 가 나가고,
-* 사용자는 멀쩡한 파일을 들여다보게 된다. 고칠 곳은 설치다.
-*/
-var VerifyRuntimeUnavailableError = class extends Error {
-	constructor() {
-		super("verify 실행에 필요한 모듈을 로드하지 못했습니다.");
-		this.name = "VerifyRuntimeUnavailableError";
-	}
-};
-const dictionary = {
-	VERIFY_RUNTIME_UNAVAILABLE: {
-		message: "verify 에 필요한 @mcpeak/record 를 로드하지 못했습니다.",
-		hint: "의존성을 설치한 뒤 다시 실행하세요. 카세트 파일의 문제가 아닙니다."
-	},
-	CASSETTE_NOT_FOUND: {
-		message: "카세트 파일이 없습니다.",
-		hint: "`mcpeak generate --cassette <path> --record` 로 먼저 녹화하세요."
-	},
-	CASSETTE_READ_FAILED: {
-		message: "카세트를 읽지 못했습니다.",
-		hint: "카세트 파일이 손상되지 않았는지 확인하세요."
-	},
-	SERVER_CONNECT_FAILED: {
-		message: "MCP 서버에 연결하지 못했습니다.",
-		hint: "--command 와 --arg 가 카세트를 녹화할 때 쓴 서버와 같은지 확인하세요."
-	},
-	CASSETTE_DRIFTED: {
-		message: "카세트가 실서버 응답과 다릅니다.",
-		hint: "서버가 바뀐 것이라면 `--record` 로 카세트를 다시 만드세요."
-	}
-};
-var VerifyCommandError = class extends Error {
-	failure;
-	constructor(failure) {
-		super(failure.message);
-		this.failure = failure;
-	}
-};
-const usage = (message) => {
-	throw new VerifyCommandError({
-		code: "CLI_USAGE",
-		message,
-		hint: require_test_command.VERIFY_USAGE_HINT
-	});
-};
-/**
-* 값을 하나 읽는다. `--opt value` 와 `--opt=value` 를 모두 받는다.
-*
-* `--arg` 만 값의 모양을 검사하지 않는다. 서버 인자는 대부분 플래그 모양이고(`-y`, `--with`,
-* `--db-path`) 빈 문자열도 정상적인 인자다. `generate` 와 `test` 가 이미 `--arg` 를 그렇게
-* 받으므로, 여기서 거절하면 **`generate --record` 로 녹화한 바로 그 서버를 `verify` 로는
-* 부를 수 없다.** 같은 명령줄을 못 받는 verify 는 그 카세트를 확인할 방법이 아예 없다.
-*
-* `--command` 는 그대로 검사한다. 실행 파일 자리에 들어온 플래그는 값을 빠뜨린 오타다.
-*/
-function optionValue(argv, index, name) {
-	const anyShape = name === "--arg";
-	const token = argv[index] ?? "";
-	if (token.startsWith(`${name}=`)) {
-		const value = token.slice(name.length + 1);
-		if (value === "" && !anyShape) usage(`${name} 옵션 값이 필요합니다.`);
-		return [value, index];
-	}
-	const next = argv[index + 1];
-	if (next === void 0 || !anyShape && (next === "" || next.startsWith("--"))) usage(`${name} 옵션 값이 필요합니다.`);
-	return [next, index + 1];
-}
-function parseVerifyCommand(argv) {
-	let cassettePath;
-	let command;
-	const args = [];
-	for (let index = 0; index < argv.length; index++) {
-		const token = argv[index] ?? "";
-		const [name] = token.startsWith("--") ? token.split("=", 1) : [token];
-		if (name === "--command") {
-			if (command !== void 0) usage("--command 는 한 번만 사용할 수 있습니다.");
-			[command, index] = optionValue(argv, index, "--command");
-			continue;
-		}
-		if (name === "--arg") {
-			let value;
-			[value, index] = optionValue(argv, index, "--arg");
-			args.push(value);
-			continue;
-		}
-		if (name === "--record") usage("verify 는 카세트를 고치지 않습니다. 다시 녹화하려면 generate --record 를 쓰세요.");
-		if (token.startsWith("--")) usage(`알 수 없는 옵션입니다: ${token}`);
-		if (cassettePath !== void 0) usage(`카세트는 하나만 받습니다: ${token}`);
-		cassettePath = token;
-	}
-	if (cassettePath === void 0 || cassettePath === "") usage("카세트 JSON 경로가 필요합니다.");
-	if (command === void 0) usage("--command 에 MCP 서버 실행 명령이 필요합니다.");
-	return Object.freeze({
-		cassettePath,
-		command,
-		args: Object.freeze([...args])
-	});
-}
-const format = (failure) => `오류 [${failure.code}]: ${failure.message}\n해결: ${failure.hint}\n`;
-const writeFailure = (dependencies, failure) => {
-	dependencies.writeStderr(format(failure));
-	return 1;
-};
-/**
-* 결과 요약. 숫자만 찍고 끝내지 않는다 — 무엇이 어떻게 다른지가 이 명령의 산출물이다.
-* `record` 가 만든 문장을 그대로 싣는다. 여기서 다시 쓰면 두 곳이 갈린다.
-*/
-function formatVerifyResult(result, cassettePath) {
-	const lines = [];
-	const total = result.matched + result.mismatched.length + result.failed.length + result.skipped.length;
-	for (const item of [
-		...result.mismatched,
-		...result.failed,
-		...result.skipped
-	]) lines.push(item.message, "");
-	lines.push(`카세트: ${cassettePath}`);
-	lines.push(`  일치 ${result.matched} · 불일치 ${result.mismatched.length} · 실패 ${result.failed.length} · 확인불가 ${result.skipped.length} (총 ${total})`);
-	if (result.skipped.length > 0) lines.push("  확인불가는 args 에 마스킹된 비밀값이 있어 실서버에 그대로 보낼 수 없는 요청입니다.");
-	if (result.mismatched.length === 0 && result.failed.length === 0) lines.push(result.skipped.length === 0 ? "  카세트가 실서버와 일치합니다." : `  확인한 ${result.matched}개는 실서버와 일치합니다. ${result.skipped.length}개는 확인하지 못했습니다.`);
-	return `${lines.join("\n")}\n`;
-}
-async function runVerifyCommand(argv, dependencies) {
-	let input;
-	try {
-		input = parseVerifyCommand(argv);
-	} catch (error) {
-		if (error instanceof VerifyCommandError) return writeFailure(dependencies, error.failure);
-		throw error;
-	}
-	let cassette;
-	try {
-		cassette = await dependencies.loadCassette(input.cassettePath);
-	} catch (error) {
-		const code = error instanceof VerifyRuntimeUnavailableError ? "VERIFY_RUNTIME_UNAVAILABLE" : "CASSETTE_READ_FAILED";
-		return writeFailure(dependencies, {
-			code,
-			...dictionary[code]
-		});
-	}
-	if (cassette === null) return writeFailure(dependencies, {
-		code: "CASSETTE_NOT_FOUND",
-		...dictionary.CASSETTE_NOT_FOUND
-	});
-	let client;
-	try {
-		client = await dependencies.connect({
-			command: input.command,
-			args: input.args
-		});
-	} catch {
-		return writeFailure(dependencies, {
-			code: "SERVER_CONNECT_FAILED",
-			...dictionary.SERVER_CONNECT_FAILED
-		});
-	}
-	let result;
-	try {
-		result = await dependencies.verifyCassette(client, cassette, { cassettePath: input.cassettePath });
-	} finally {
-		await client.close().catch(() => {});
-	}
-	dependencies.writeStdout(formatVerifyResult(result, input.cassettePath));
-	if (result.mismatched.length === 0 && result.failed.length === 0) return 0;
-	dependencies.writeStderr(format({
-		code: "CASSETTE_DRIFTED",
-		...dictionary.CASSETTE_DRIFTED
-	}));
-	return 1;
-}
-//#endregion
-//#region src/index.ts
-const COMMANDS = [
-	"test",
-	"generate",
-	"repair",
-	"record",
-	"replay",
-	"verify",
-	"mock"
-];
-const unavailableDependencies = {
-	readFile: async () => {
-		throw new Error("runtime dependencies unavailable");
-	},
-	validateSuite: () => {
-		throw new Error("runtime dependencies unavailable");
-	},
-	connect: async () => {
-		throw new Error("runtime dependencies unavailable");
-	},
-	startRunner: () => {
-		throw new Error("runtime dependencies unavailable");
-	},
-	finalize: async () => {
-		throw new Error("runtime dependencies unavailable");
-	},
-	renderReport: () => {
-		throw new Error("runtime dependencies unavailable");
-	},
-	renderJUnit: () => {
-		throw new Error("runtime dependencies unavailable");
-	},
-	writeFile: async () => {
-		throw new Error("runtime dependencies unavailable");
-	},
-	colorEnabled: false,
-	writeStdout: (text) => process.stdout.write(text),
-	writeStderr: (text) => process.stderr.write(text)
-};
-const unavailableRuntimeDependencies = {
-	...unavailableDependencies,
-	readFile: node_fs_promises.readFile
-};
-/**
-* `repair` 실행 의존성. 함수로 빼 둔 이유는 **주입 자체를 테스트가 단언할 수 있게** 하기
-* 위해서다. 분기 안에 리터럴로 두면 `reviewIO` 를 빠뜨려도 아무 테스트도 안 깨진다.
-* 실제로 그렇게 한 번 빠뜨렸다(T10 보고서).
-*
-* 대화형 판정은 `generate` 와 같은 기준이다. 같은 `nodeReviewIO()` 를 쓰고, 그 구현이
-* stdin·stdout 이 둘 다 TTY 일 때만 `interactive` 를 참으로 만든다.
-*/
-function nodeRepairDependencies(generate) {
-	return {
-		readFile: (path) => (0, node_fs_promises.readFile)(path, "utf8"),
-		writeStdout: (text) => void process.stdout.write(text),
-		writeStderr: (text) => void process.stderr.write(text),
-		reviewIO: require_test_command.nodeReviewIO(),
-		diagnosis: {
-			prepare: generate.prepareDiagnosisRequest,
-			dispatch: generate.dispatchDiagnosisRequest,
-			providers: {
-				codex: (model) => generate.createCodexProvider({ model }),
-				claude: (model) => generate.createClaudeProvider({ model })
-			}
-		}
-	};
-}
-/**
-* replay 는 `connect` 를 쓰지 않는다. 대신 카세트 로더가 필요하다. 런타임 의존성을 못 불러도
-* 사용 오류는 정상적으로 내야 하므로, 실제로 쓰이기 전에 끝나는 경로를 위해 자리만 채운다.
-*
-* **테스트가 배선을 직접 단언할 수 있도록 내보낸다.** 여기서 평범한 Error 로 되돌아가면
-* 사용자는 "이슈를 보고하세요" 를 보게 되는데, 모듈 모킹으로는 이 경로를 재현할 수 없다 —
-* `record` 와 `runner` 가 `generate-command` 를 통해 정적 import 체인에 있어서, 그것을
-* 모킹하면 `index.ts` 로드 자체가 깨진다. `nodeRepairDependencies` 를 함수로 뺀 것과 같은
-* 이유다(주입을 빠뜨려도 아무 테스트가 안 깨지는 상황을 막는다).
-*/
-const unavailableReplayDependencies = {
-	...unavailableRuntimeDependencies,
-	/**
-	* 런타임에서 오는 의존성은 전용 오류 타입을 던진다. 평범한 Error 로 두면 `validateSuite`
-	* 자리에서 `CLI_INTERNAL_ERROR` 로 잡혀 "이슈를 보고하세요" 가 나가고, 사용자는 자기
-	* 설치 문제로 버그 리포트를 쓰게 된다. 실제로 가장 먼저 걸리는 것이 `validateSuite` 다.
-	*
-	* `unavailableRuntimeDependencies` 자체는 `test` 경로와 공유하므로 여기서만 덮는다.
-	*/
-	validateSuite: () => {
-		throw new require_test_command.ReplayRuntimeUnavailableError();
-	},
-	loadCassette: async () => {
-		throw new require_test_command.ReplayRuntimeUnavailableError();
-	},
-	startRunner: () => {
-		throw new require_test_command.ReplayRuntimeUnavailableError();
-	},
-	finalize: async () => {
-		throw new require_test_command.ReplayRuntimeUnavailableError();
-	},
-	renderReport: () => {
-		throw new require_test_command.ReplayRuntimeUnavailableError();
-	}
-};
-/**
-* verify 도 런타임을 못 불러도 사용 오류는 정상적으로 내야 한다. 파싱은 의존성 없이 끝나므로
-* `--command` 누락 같은 오류는 여기까지 오지 않는다.
-*/
-const unavailableVerifyDependencies = {
-	loadCassette: async () => {
-		throw new VerifyRuntimeUnavailableError();
-	},
-	connect: async () => {
-		throw new VerifyRuntimeUnavailableError();
-	},
-	verifyCassette: async () => {
-		throw new VerifyRuntimeUnavailableError();
-	},
-	writeStdout: (text) => void process.stdout.write(text),
-	writeStderr: (text) => void process.stderr.write(text)
-};
-async function run(argv) {
-	if (argv.length === 0 || argv.length === 1 && [
-		"--help",
-		"-h",
-		"help"
-	].includes(argv[0] ?? "")) {
-		process.stdout.write(require_test_command.GLOBAL_HELP);
-		return 0;
-	}
-	if (argv.length === 2) {
-		const command = argv[0] === "help" ? argv[1] : argv[1] === "--help" ? argv[0] : void 0;
-		if (command === "test" || command === "generate" || command === "repair" || command === "replay" || command === "verify") {
-			process.stdout.write(require_test_command.commandHelp(command));
-			return 0;
-		}
-	}
-	if (argv.length === 1 && argv[0] === "--version") {
-		process.stdout.write(`mcpeak ${require_test_command.version}\n`);
-		return 0;
-	}
-	if (argv[0] === "generate") {
-		let core;
-		let runner;
-		let generate;
-		try {
-			[core, runner, generate] = await Promise.all([
-				import("@mcpeak/core"),
-				import("@mcpeak/runner"),
-				import("@mcpeak/generate")
-			]);
-		} catch {
-			return require_test_command.runGenerateCommand(argv, {
-				...require_test_command.nodeGenerateDependencies(),
-				connect: unavailableDependencies.connect,
-				createBaselineSuite: unavailableDependencies.validateSuite,
-				createAuthoringSession: unavailableDependencies.validateSuite,
-				finalizeAuthoringDraft: unavailableDependencies.validateSuite,
-				getAuthoringExecutionSuite: unavailableDependencies.validateSuite,
-				validateSuite: unavailableDependencies.validateSuite
-			});
-		}
-		return require_test_command.runGenerateCommand(argv, {
-			...require_test_command.nodeGenerateDependencies(),
-			connect: core.connectStdio,
-			createBaselineSuite: generate.createBaselineSuite,
-			createAuthoringSession: generate.createAuthoringSession,
-			finalizeAuthoringDraft: generate.finalizeAuthoringDraft,
-			getAuthoringExecutionSuite: generate.getAuthoringExecutionSuite,
-			validateSuite: runner.validateMcpSuite,
-			reviewIO: require_test_command.nodeReviewIO(),
-			providers: {
-				codex: (model) => generate.createCodexAuthoringProvider({ model }),
-				claude: (model) => generate.createClaudeAuthoringProvider({ model })
-			},
-			prepareAuthoringRequest: generate.prepareAuthoringRequest,
-			dispatchAuthoringRequest: generate.dispatchAuthoringRequest,
-			createAuthoringDiff: generate.createAuthoringDiff,
-			applyAuthoringChanges: generate.applyAuthoringChanges,
-			reviewLocalAuthoringCandidate: generate.reviewLocalAuthoringCandidate,
-			computeCoverage: generate.computeCoverage,
-			preparePreFillRequest: generate.preparePreFillRequest,
-			previewPreFillRequest: generate.previewPreFillRequest,
-			dispatchPreFillRequest: generate.dispatchPreFillRequest,
-			preFillProviders: {
-				codex: (model) => generate.createCodexProvider({ model }),
-				claude: (model) => generate.createClaudeProvider({ model })
-			},
-			prepareRejectionDiagnosisRequests: generate.prepareRejectionDiagnosisRequests,
-			dispatchRejectionDiagnosis: generate.dispatchRejectionDiagnosis,
-			rejectionProviders: {
-				codex: (model) => generate.createCodexProvider({ model }),
-				claude: (model) => generate.createClaudeProvider({ model })
-			},
-			GenerateTestsError: generate.GenerateTestsError
-		});
-	}
-	if (argv[0] === "repair") {
-		/**
-		* `generate` 분기와 같은 모양으로 동적 import 한다. `test` 경로는 이 분기를 지나지 않으므로
-		* 여전히 `core` 와 `runner` 만 로드한다. 계획서 §8 위험표 첫 줄.
-		*/
-		let generate;
-		try {
-			generate = await import("@mcpeak/generate");
-		} catch {
-			process.stderr.write("오류 [REPAIR_RUNTIME_UNAVAILABLE]: 진단에 필요한 @mcpeak/generate 를 로드하지 못했습니다.\n해결: 의존성을 설치한 뒤 다시 실행하세요.\n");
-			return 1;
-		}
-		const dependencies = nodeRepairDependencies(generate);
-		try {
-			return await require_test_command.runRepairCommand(argv, dependencies);
-		} finally {
-			dependencies.reviewIO?.close?.();
-		}
-	}
-	if (argv[0] === "replay") {
-		let runner;
-		let record;
-		try {
-			[runner, record] = await Promise.all([import("@mcpeak/runner"), import("@mcpeak/record")]);
-		} catch {
-			return require_test_command.runReplayCommand(argv.slice(1), unavailableReplayDependencies);
-		}
-		return require_test_command.runReplayCommand(argv.slice(1), {
-			readFile: node_fs_promises.readFile,
-			validateSuite: runner.validateMcpSuite,
-			loadCassette: record.loadCassette,
-			startRunner: runner.runSuite,
-			finalize: runner.finalizeRunnerExecution,
-			renderReport: runner.renderReport,
-			colorEnabled: process.stdout.isTTY === true && process.env.NO_COLOR === void 0,
-			writeStdout: (text) => process.stdout.write(text),
-			writeStderr: (text) => process.stderr.write(text)
-		});
-	}
-	if (argv[0] === "verify") {
-		let core;
-		let record;
-		try {
-			[core, record] = await Promise.all([import("@mcpeak/core"), import("@mcpeak/record")]);
-		} catch {
-			return runVerifyCommand(argv.slice(1), unavailableVerifyDependencies);
-		}
-		return runVerifyCommand(argv.slice(1), {
-			loadCassette: record.loadCassette,
-			connect: (options) => core.connect({
-				command: options.command,
-				args: options.args
-			}),
-			verifyCassette: record.verifyCassette,
-			writeStdout: (text) => void process.stdout.write(text),
-			writeStderr: (text) => void process.stderr.write(text)
-		});
-	}
-	if (argv[0] !== "test") return require_test_command.runCli(argv, unavailableDependencies);
-	try {
-		if (!require_test_command.parseTestCommand(argv.slice(1)).suitePath.toLowerCase().endsWith(".json")) return require_test_command.runCli(argv, unavailableDependencies);
-	} catch {
-		return require_test_command.runCli(argv, unavailableDependencies);
-	}
-	let core;
-	let runner;
-	try {
-		[core, runner] = await Promise.all([import("@mcpeak/core"), import("@mcpeak/runner")]);
-	} catch {
-		return require_test_command.runCli(argv, unavailableRuntimeDependencies);
-	}
-	return require_test_command.runCli(argv, {
-		readFile: node_fs_promises.readFile,
-		validateSuite: runner.validateMcpSuite,
-		connect: core.connectStdio,
-		startRunner: runner.runSuite,
-		finalize: runner.finalizeRunnerExecution,
-		renderReport: runner.renderReport,
-		renderJUnit: runner.renderJUnit,
-		writeFile: (path, text) => (0, node_fs_promises.writeFile)(path, text, "utf8"),
-		colorEnabled: process.stdout.isTTY === true && process.env.NO_COLOR === void 0,
-		writeStdout: (text) => process.stdout.write(text),
-		writeStderr: (text) => process.stderr.write(text)
-	});
-}
-//#endregion
-Object.defineProperty(exports, "COMMANDS", {
-	enumerable: true,
-	get: function() {
-		return COMMANDS;
-	}
-});
-Object.defineProperty(exports, "nodeRepairDependencies", {
-	enumerable: true,
-	get: function() {
-		return nodeRepairDependencies;
-	}
-});
-Object.defineProperty(exports, "run", {
-	enumerable: true,
-	get: function() {
-		return run;
-	}
-});
-Object.defineProperty(exports, "unavailableReplayDependencies", {
-	enumerable: true,
-	get: function() {
-		return unavailableReplayDependencies;
-	}
-});