sonamu 0.10.13 → 0.11.0

package/dist/tooling/__tests__/helpers/sonamu-test-root.js

@@ -0,0 +1,42 @@
+import { Sonamu, init_sonamu } from "../../../api/sonamu.js";
+import os from "node:os";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import path from "node:path";
+//#region src/tooling/__tests__/helpers/sonamu-test-root.ts
+init_sonamu();
+const createdWorkspaces = [];
+let capturedSnapshot = null;
+let capturedInitialized = false;
+/**
+* 임시 api root를 만들어 Sonamu singleton의 공개 setter로 주입합니다.
+*
+* tooling 연산은 `Sonamu.isInitialized`가 참이면 초기화를 건너뛰므로,
+* 실제 DB/설정 없이 파일 경로 기반 동작만 검증할 수 있습니다.
+*/
+async function attachSonamuTestRoot() {
+	const workspace = await mkdtemp(path.join(os.tmpdir(), "sonamu-tooling-"));
+	createdWorkspaces.push(workspace);
+	const apiRootPath = path.join(workspace, "api");
+	await mkdir(path.join(apiRootPath, "src", "application"), { recursive: true });
+	capturedSnapshot ??= Sonamu.captureTestingSnapshot();
+	capturedInitialized = Sonamu.isInitialized;
+	Sonamu.apiRootPath = apiRootPath;
+	Sonamu.isInitialized = true;
+	return apiRootPath;
+}
+/** 주입한 Sonamu 상태를 되돌리고 임시 디렉터리를 정리합니다. */
+async function detachSonamuTestRoot() {
+	if (capturedSnapshot !== null) {
+		Sonamu.restoreTestingSnapshot(capturedSnapshot);
+		capturedSnapshot = null;
+	}
+	Sonamu.isInitialized = capturedInitialized;
+	await Promise.all(createdWorkspaces.splice(0).map((workspace) => rm(workspace, {
+		recursive: true,
+		force: true
+	})));
+}
+//#endregion
+export { attachSonamuTestRoot, detachSonamuTestRoot };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/tooling/cdd-service.d.ts

@@ -0,0 +1,87 @@
+import * as defaultFs from "node:fs/promises";
+type CddFileSystem = Pick<typeof defaultFs, "lstat" | "mkdir" | "open" | "opendir" | "realpath">;
+export declare function createDefaultCddToolingAdapter({ contractRoot, fs, }: {
+    contractRoot: string;
+    fs?: CddFileSystem;
+}): {
+    read(input: {
+        path: string;
+    }): Promise<{
+        content: string;
+        fileType: "contract";
+    }>;
+    rules(): Promise<{
+        rules: {
+            key: string;
+            path: string;
+            description: string;
+            ruleCount: number;
+        }[];
+    }>;
+    showRule(input: {
+        ruleId: string;
+    }): Promise<{
+        description?: string;
+        rules?: Array<{
+            id: string;
+            when: string;
+            instruction: string;
+            examples?: string[];
+        }>;
+        key: string;
+        path: string;
+    }>;
+    addRule(input: {
+        ruleKey: string;
+        id: string;
+        when: string;
+        text: string;
+        examples?: string[];
+        dryRun: boolean;
+    }): Promise<{
+        dryRun: true;
+        rule: {
+            ruleKey: string;
+            id: string;
+            when: string;
+            text: string;
+        };
+    } | {
+        description?: string;
+        rules?: Array<{
+            id: string;
+            when: string;
+            instruction: string;
+            examples?: string[];
+        }>;
+        dryRun?: undefined;
+        rule?: undefined;
+        key: string;
+        path: string;
+    }>;
+    addAcceptanceCriterion(input: {
+        document: string;
+        text: string;
+        dryRun: boolean;
+    }): Promise<{
+        operation: "addAcceptanceCriterion";
+        input: {
+            document: string;
+            text: string;
+            dryRun: boolean;
+        };
+        dryRun: boolean;
+        document?: undefined;
+        text?: undefined;
+        applied?: undefined;
+    } | {
+        dryRun?: undefined;
+        operation?: undefined;
+        input?: undefined;
+        document: string;
+        text: string;
+        applied: true;
+    }>;
+};
+export {};
+//# sourceMappingURL=cdd-service.d.ts.map

package/dist/tooling/cdd-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdd-service.d.ts","sourceRoot":"","sources":["../../src/tooling/cdd-service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,kBAAkB,CAAC;AAG9C,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,SAAS,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC,CAAC;AA8KjG,wBAAgB,8BAA8B,CAAC,EAC7C,YAAY,EACZ,EAAc,GACf,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,EAAE,CAAC,EAAE,aAAa,CAAC;CACpB;IAIS,IAAI,QAAQ;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;;kBAC0B,UAAU;;IAEhE,KAAK;;;;;;;;IAyBL,QAAQ,QAAQ;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE;sBA1E5B,MAAM;gBACZ,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC;;;;IAiF7E,OAAO,QAAQ;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,MAAM,EAAE,OAAO,CAAC;KACjB;;;;;;;;;sBAzFW,MAAM;gBACZ,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC;;;;;;IAwG7E,sBAAsB,QAAQ;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE;mBAE/D,wBAAwB;;sBAFA,MAAM;kBAAQ,MAAM;oBAAU,OAAO;;;;;;;;;;;;;;EAQxF"}

package/dist/tooling/cdd-service.js

@@ -0,0 +1,215 @@
+import { constants } from "node:fs";
+import * as defaultFs from "node:fs/promises";
+import path from "node:path";
+//#region src/tooling/cdd-service.ts
+function invalidCddPath(relativePath, cause) {
+	return Object.assign(/* @__PURE__ */ new Error(`CDD 경로가 contract 밖을 참조합니다: ${relativePath}`), {
+		code: "INVALID_CDD_PATH",
+		cause
+	});
+}
+function isWithin(root, target) {
+	const relative = path.relative(root, target);
+	return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== "..";
+}
+async function nearestExistingPath(fs, target) {
+	let candidate = target;
+	while (true) try {
+		await fs.lstat(candidate);
+		return candidate;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		const parent = path.dirname(candidate);
+		if (parent === candidate) throw error;
+		candidate = parent;
+	}
+}
+function createCddFileOperation({ contractRoot, fs = defaultFs }) {
+	async function resolveBoundary(relativePath) {
+		const [canonicalRoot, configuredRoot] = await Promise.all([fs.realpath(contractRoot), Promise.resolve(path.resolve(contractRoot))]);
+		const target = path.resolve(configuredRoot, relativePath);
+		if (!isWithin(configuredRoot, target)) throw invalidCddPath(relativePath);
+		return {
+			canonicalRoot,
+			target
+		};
+	}
+	async function assertCanonicalPath(canonicalRoot, target, relativePath) {
+		const canonicalTarget = await fs.realpath(target);
+		if (!isWithin(canonicalRoot, canonicalTarget)) throw invalidCddPath(relativePath);
+		return canonicalTarget;
+	}
+	return {
+		async readDirectory(relativePath) {
+			const { canonicalRoot, target } = await resolveBoundary(relativePath);
+			const canonicalTarget = await assertCanonicalPath(canonicalRoot, target, relativePath);
+			let directory;
+			try {
+				directory = await fs.opendir(target);
+				if (await assertCanonicalPath(canonicalRoot, target, relativePath) !== canonicalTarget) throw invalidCddPath(relativePath);
+				const entries = [];
+				while (true) {
+					const entry = await directory.read();
+					if (entry === null) return entries;
+					entries.push(entry);
+				}
+			} finally {
+				await directory?.close();
+			}
+		},
+		async read(relativePath) {
+			const { canonicalRoot, target } = await resolveBoundary(relativePath);
+			const canonicalTarget = await assertCanonicalPath(canonicalRoot, target, relativePath);
+			let handle;
+			try {
+				handle = await fs.open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+				if (await assertCanonicalPath(canonicalRoot, target, relativePath) !== canonicalTarget) throw invalidCddPath(relativePath);
+				return await handle.readFile("utf8");
+			} catch (error) {
+				if (error.code === "ELOOP") throw invalidCddPath(relativePath, error);
+				throw error;
+			} finally {
+				await handle?.close();
+			}
+		},
+		async write(relativePath, contents) {
+			const { canonicalRoot, target } = await resolveBoundary(relativePath);
+			const existing = await nearestExistingPath(fs, target);
+			const canonicalExisting = await assertCanonicalPath(canonicalRoot, existing, relativePath);
+			const targetExists = existing === target;
+			if (!targetExists) {
+				await fs.mkdir(path.dirname(target), { recursive: true });
+				await assertCanonicalPath(canonicalRoot, path.dirname(target), relativePath);
+			}
+			let handle;
+			try {
+				const flags = targetExists ? constants.O_WRONLY | constants.O_NOFOLLOW : constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW;
+				handle = await fs.open(target, flags, 438);
+				const canonicalTarget = await assertCanonicalPath(canonicalRoot, target, relativePath);
+				if (!isWithin(canonicalRoot, canonicalTarget) || targetExists && canonicalTarget !== canonicalExisting) throw invalidCddPath(relativePath);
+				await handle.truncate(0);
+				await handle.writeFile(contents, "utf8");
+			} catch (error) {
+				if (error.code === "ELOOP") throw invalidCddPath(relativePath, error);
+				throw error;
+			} finally {
+				await handle?.close();
+			}
+		}
+	};
+}
+function parseCddRules(contents) {
+	try {
+		return JSON.parse(contents);
+	} catch (cause) {
+		throw Object.assign(/* @__PURE__ */ new Error("CDD rules JSON is malformed"), {
+			code: "INVALID_CDD_RULES",
+			exitCode: 2,
+			cause
+		});
+	}
+}
+/**
+* 규칙 문서를 읽되, 아직 파일이 없으면 빈 문서로 취급합니다.
+*
+* 첫 규칙 등록 시 rules 디렉터리와 파일이 없는 상태를 부트스트랩하기 위한 처리이며,
+* 깨진 JSON은 그대로 INVALID_CDD_RULES로 실패시켜 덮어쓰기를 막습니다.
+*/
+async function readCddRuleDocument(files, relativePath) {
+	try {
+		return parseCddRules(await files.read(relativePath));
+	} catch (error) {
+		if (error.code === "ENOENT") return {};
+		throw error;
+	}
+}
+function createDefaultCddToolingAdapter({ contractRoot, fs = defaultFs }) {
+	const files = createCddFileOperation({
+		contractRoot,
+		fs
+	});
+	return {
+		async read(input) {
+			return {
+				content: await files.read(input.path),
+				fileType: "contract"
+			};
+		},
+		async rules() {
+			let entries;
+			try {
+				entries = await files.readDirectory("rules");
+			} catch (error) {
+				if (error.code === "ENOENT") return { rules: [] };
+				throw error;
+			}
+			const rules = [];
+			for (const entry of entries) {
+				if (!entry.isFile() || !entry.name.endsWith(".rules.json")) continue;
+				const key = entry.name.replace(/\.rules\.json$/, "");
+				const relativePath = `rules/${entry.name}`;
+				const document = parseCddRules(await files.read(relativePath));
+				rules.push({
+					key,
+					path: relativePath,
+					description: document.description ?? "",
+					ruleCount: document.rules?.length ?? 0
+				});
+			}
+			return { rules };
+		},
+		async showRule(input) {
+			const relativePath = `rules/${input.ruleId}.rules.json`;
+			return {
+				key: input.ruleId,
+				path: relativePath,
+				...parseCddRules(await files.read(relativePath))
+			};
+		},
+		async addRule(input) {
+			const rule = {
+				ruleKey: input.ruleKey,
+				id: input.id,
+				when: input.when,
+				text: input.text
+			};
+			if (input.dryRun) return {
+				dryRun: true,
+				rule
+			};
+			const relativePath = `rules/${input.ruleKey}.rules.json`;
+			const document = await readCddRuleDocument(files, relativePath);
+			document.rules ??= [];
+			document.rules.push({
+				id: input.id,
+				when: input.when,
+				instruction: input.text,
+				examples: input.examples ?? []
+			});
+			await files.write(relativePath, `${JSON.stringify(document, null, 2)}\n`);
+			return {
+				key: input.ruleKey,
+				path: relativePath,
+				...document
+			};
+		},
+		async addAcceptanceCriterion(input) {
+			if (input.dryRun) return {
+				operation: "addAcceptanceCriterion",
+				input,
+				dryRun: true
+			};
+			const contents = await files.read(input.document);
+			await files.write(input.document, `${contents}\n- ${input.text}\n`);
+			return {
+				document: input.document,
+				text: input.text,
+				applied: true
+			};
+		}
+	};
+}
+//#endregion
+export { createDefaultCddToolingAdapter };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cdd-service.js","names":[],"sources":["../../src/tooling/cdd-service.ts"],"sourcesContent":["import { constants } from \"node:fs\";\nimport * as defaultFs from \"node:fs/promises\";\nimport path from \"node:path\";\n\ntype CddFileSystem = Pick<typeof defaultFs, \"lstat\" | \"mkdir\" | \"open\" | \"opendir\" | \"realpath\">;\n\nfunction invalidCddPath(relativePath: string, cause?: unknown): Error {\n  return Object.assign(new Error(`CDD 경로가 contract 밖을 참조합니다: ${relativePath}`), {\n    code: \"INVALID_CDD_PATH\",\n    cause,\n  });\n}\n\nfunction isWithin(root: string, target: string): boolean {\n  const relative = path.relative(root, target);\n  return relative === \"\" || (!relative.startsWith(`..${path.sep}`) && relative !== \"..\");\n}\n\nasync function nearestExistingPath(fs: CddFileSystem, target: string): Promise<string> {\n  let candidate = target;\n  while (true) {\n    try {\n      await fs.lstat(candidate);\n      return candidate;\n    } catch (error) {\n      // SAFETY: node:fs lstat 실패의 code만 읽어 경로 부재를 구분합니다.\n      if ((error as NodeJS.ErrnoException).code !== \"ENOENT\") throw error;\n      const parent = path.dirname(candidate);\n      if (parent === candidate) throw error;\n      candidate = parent;\n    }\n  }\n}\n\nfunction createCddFileOperation({\n  contractRoot,\n  fs = defaultFs,\n}: {\n  contractRoot: string;\n  fs?: CddFileSystem;\n}) {\n  async function resolveBoundary(relativePath: string) {\n    const [canonicalRoot, configuredRoot] = await Promise.all([\n      fs.realpath(contractRoot),\n      Promise.resolve(path.resolve(contractRoot)),\n    ]);\n    const target = path.resolve(configuredRoot, relativePath);\n    if (!isWithin(configuredRoot, target)) throw invalidCddPath(relativePath);\n    return { canonicalRoot, target };\n  }\n\n  async function assertCanonicalPath(\n    canonicalRoot: string,\n    target: string,\n    relativePath: string,\n  ): Promise<string> {\n    const canonicalTarget = await fs.realpath(target);\n    if (!isWithin(canonicalRoot, canonicalTarget)) throw invalidCddPath(relativePath);\n    return canonicalTarget;\n  }\n\n  return {\n    async readDirectory(relativePath: string) {\n      const { canonicalRoot, target } = await resolveBoundary(relativePath);\n      const canonicalTarget = await assertCanonicalPath(canonicalRoot, target, relativePath);\n      let directory;\n      try {\n        directory = await fs.opendir(target);\n        const recheckedTarget = await assertCanonicalPath(canonicalRoot, target, relativePath);\n        if (recheckedTarget !== canonicalTarget) throw invalidCddPath(relativePath);\n        const entries = [];\n        while (true) {\n          const entry = await directory.read();\n          if (entry === null) return entries;\n          entries.push(entry);\n        }\n      } finally {\n        await directory?.close();\n      }\n    },\n    async read(relativePath: string): Promise<string> {\n      const { canonicalRoot, target } = await resolveBoundary(relativePath);\n      const canonicalTarget = await assertCanonicalPath(canonicalRoot, target, relativePath);\n      let handle;\n      try {\n        // 최종 symlink를 따라가지 않은 descriptor를 연 뒤 실제 경로를 다시 확인합니다.\n        handle = await fs.open(target, constants.O_RDONLY | constants.O_NOFOLLOW);\n        const recheckedTarget = await assertCanonicalPath(canonicalRoot, target, relativePath);\n        if (recheckedTarget !== canonicalTarget) throw invalidCddPath(relativePath);\n        return await handle.readFile(\"utf8\");\n      } catch (error) {\n        // SAFETY: node:fs open 실패의 code만 읽어 symlink 거부를 정규화합니다.\n        if ((error as NodeJS.ErrnoException).code === \"ELOOP\") {\n          throw invalidCddPath(relativePath, error);\n        }\n        throw error;\n      } finally {\n        await handle?.close();\n      }\n    },\n\n    async write(relativePath: string, contents: string): Promise<void> {\n      const { canonicalRoot, target } = await resolveBoundary(relativePath);\n      const existing = await nearestExistingPath(fs, target);\n      const canonicalExisting = await assertCanonicalPath(canonicalRoot, existing, relativePath);\n      const targetExists = existing === target;\n\n      if (!targetExists) {\n        await fs.mkdir(path.dirname(target), { recursive: true });\n        await assertCanonicalPath(canonicalRoot, path.dirname(target), relativePath);\n      }\n\n      let handle;\n      try {\n        // 검증 전 truncate를 피하고 새 파일은 배타적으로 생성합니다.\n        const flags = targetExists\n          ? constants.O_WRONLY | constants.O_NOFOLLOW\n          : constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW;\n        handle = await fs.open(target, flags, 0o666);\n        const canonicalTarget = await assertCanonicalPath(canonicalRoot, target, relativePath);\n        if (\n          !isWithin(canonicalRoot, canonicalTarget) ||\n          (targetExists && canonicalTarget !== canonicalExisting)\n        ) {\n          throw invalidCddPath(relativePath);\n        }\n        await handle.truncate(0);\n        await handle.writeFile(contents, \"utf8\");\n      } catch (error) {\n        // SAFETY: node:fs open 실패의 code만 읽어 symlink 거부를 정규화합니다.\n        if ((error as NodeJS.ErrnoException).code === \"ELOOP\") {\n          throw invalidCddPath(relativePath, error);\n        }\n        throw error;\n      } finally {\n        await handle?.close();\n      }\n    },\n  };\n}\n\ntype CddRuleDocument = {\n  description?: string;\n  rules?: Array<{ id: string; when: string; instruction: string; examples?: string[] }>;\n};\n\nfunction parseCddRules(contents: string): CddRuleDocument {\n  try {\n    // SAFETY: CDD 규칙 소비 지점은 선택 필드만 읽고 배열 부재를 기본값으로 처리합니다.\n    return JSON.parse(contents) as CddRuleDocument;\n  } catch (cause) {\n    throw Object.assign(new Error(\"CDD rules JSON is malformed\"), {\n      code: \"INVALID_CDD_RULES\",\n      exitCode: 2,\n      cause,\n    });\n  }\n}\n\n/**\n * 규칙 문서를 읽되, 아직 파일이 없으면 빈 문서로 취급합니다.\n *\n * 첫 규칙 등록 시 rules 디렉터리와 파일이 없는 상태를 부트스트랩하기 위한 처리이며,\n * 깨진 JSON은 그대로 INVALID_CDD_RULES로 실패시켜 덮어쓰기를 막습니다.\n */\nasync function readCddRuleDocument(\n  files: { read(relativePath: string): Promise<string> },\n  relativePath: string,\n): Promise<CddRuleDocument> {\n  try {\n    return parseCddRules(await files.read(relativePath));\n  } catch (error) {\n    // SAFETY: node:fs 읽기 실패의 code만 읽어 규칙 문서 부재를 구분합니다.\n    if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return {};\n    throw error;\n  }\n}\n\nexport function createDefaultCddToolingAdapter({\n  contractRoot,\n  fs = defaultFs,\n}: {\n  contractRoot: string;\n  fs?: CddFileSystem;\n}) {\n  const files = createCddFileOperation({ contractRoot, fs });\n\n  return {\n    async read(input: { path: string }) {\n      return { content: await files.read(input.path), fileType: \"contract\" as const };\n    },\n    async rules() {\n      let entries;\n      try {\n        entries = await files.readDirectory(\"rules\");\n      } catch (error) {\n        // SAFETY: node:fs 디렉터리 조회 실패의 code만 읽어 규칙 디렉터리 부재를 구분합니다.\n        if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return { rules: [] };\n        throw error;\n      }\n\n      const rules = [];\n      for (const entry of entries) {\n        if (!entry.isFile() || !entry.name.endsWith(\".rules.json\")) continue;\n        const key = entry.name.replace(/\\.rules\\.json$/, \"\");\n        const relativePath = `rules/${entry.name}`;\n        const document = parseCddRules(await files.read(relativePath));\n        rules.push({\n          key,\n          path: relativePath,\n          description: document.description ?? \"\",\n          ruleCount: document.rules?.length ?? 0,\n        });\n      }\n      return { rules };\n    },\n    async showRule(input: { ruleId: string }) {\n      const relativePath = `rules/${input.ruleId}.rules.json`;\n      return {\n        key: input.ruleId,\n        path: relativePath,\n        ...parseCddRules(await files.read(relativePath)),\n      };\n    },\n    async addRule(input: {\n      ruleKey: string;\n      id: string;\n      when: string;\n      text: string;\n      examples?: string[];\n      dryRun: boolean;\n    }) {\n      const rule = { ruleKey: input.ruleKey, id: input.id, when: input.when, text: input.text };\n      if (input.dryRun) return { dryRun: true as const, rule };\n\n      const relativePath = `rules/${input.ruleKey}.rules.json`;\n      const document = await readCddRuleDocument(files, relativePath);\n      document.rules ??= [];\n      document.rules.push({\n        id: input.id,\n        when: input.when,\n        instruction: input.text,\n        examples: input.examples ?? [],\n      });\n      await files.write(relativePath, `${JSON.stringify(document, null, 2)}\\n`);\n      return { key: input.ruleKey, path: relativePath, ...document };\n    },\n    async addAcceptanceCriterion(input: { document: string; text: string; dryRun: boolean }) {\n      if (input.dryRun)\n        return { operation: \"addAcceptanceCriterion\" as const, input, dryRun: true };\n      const contents = await files.read(input.document);\n      await files.write(input.document, `${contents}\\n- ${input.text}\\n`);\n      return { document: input.document, text: input.text, applied: true as const };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/tooling/cli-tooling.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+declare const jsonValueSchema: z.ZodJSONSchema;
+type CommandValue = z.infer<typeof jsonValueSchema> | undefined;
+type CommandInput = Record<string, CommandValue>;
+type ToolingResult = object | string | number | boolean | null | void | AsyncIterable<object>;
+type ToolingOperation = (input: CommandInput) => ToolingResult | Promise<ToolingResult>;
+type ToolingGroup = Record<string, ToolingOperation>;
+export type CliToolingOperations = Record<string, ToolingGroup>;
+export declare const tooling: CliToolingOperations;
+export {};
+//# sourceMappingURL=cli-tooling.d.ts.map

package/dist/tooling/cli-tooling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-tooling.d.ts","sourceRoot":"","sources":["../../src/tooling/cli-tooling.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,QAAA,MAAM,eAAe,iBAAW,CAAC;AACjC,KAAK,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAAG,SAAS,CAAC;AAChE,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AACjD,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;AAC9F,KAAK,gBAAgB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AACxF,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AACrD,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AA+4BhE,eAAO,MAAM,OAAO,EAAE,oBAUrB,CAAC"}