@dxtmisha/scripts 0.11.7 → 1.0.0

package/dist/library.js

@@ -0,0 +1,1436 @@
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c, u as l } from "./AiZAi-x3CInynJ.js";
+import { n as u, t as d } from "./PropertiesConfig-ChizwW5y.js";
+import { UI_DIRS_FILE_EXPORT as ee, UI_DIRS_LIST_EXPORT as te, UI_DIR_AI_PROMPT_SCREENSHOT as f, UI_DIR_AI_TYPES_LIST as p, UI_DIR_PACKAGES as ne, UI_DIR_RESOURCES as re, UI_FILE_AI_DESCRIPTION as m, UI_FILE_AI_MCP as h, UI_FILE_AI_MCP_ALL as g, UI_FILE_AI_MCP_ALL_TS as ie, UI_FILE_AI_PROMPT_DESCRIPTION as _, UI_FILE_AI_PROMPT_DEVELOPER as v, UI_FILE_AI_PROMPT_INFO as y, UI_FILE_AI_PROMPT_INSTRUCTION as ae, UI_FILE_AI_PROMPT_PROMPT as b, UI_FILE_AI_PROMPT_TYPES as x, UI_FILE_AI_TYPES as S, UI_FILE_PACKAGE as oe, UI_FLAG_NOT_EXPORT as se, UI_MODULES as C } from "./config.js";
+import { a as w, i as ce, n as le, r as ue, t as de } from "./propertyTypes-DflziKuR.js";
+import { n as fe, t as pe } from "./figmaApiTypes-CArSsNW8.js";
+import { Datetime as me, ServerStorage as T, forEach as E, isArray as D, isFilled as O, isObject as he, isString as k, removeCommonPrefix as ge, sleep as _e, toArray as A, toCamelCaseFirst as j } from "@dxtmisha/functional-basic";
+import { execFile as M, execSync as N, spawn as ve } from "node:child_process";
+import { promisify as P } from "node:util";
+import { createHash as ye } from "node:crypto";
+import F from "typescript";
+//#region src/classes/Ai/AiClaudeAgentLite.ts
+var I = class extends l {
+	async init() {
+		this.ai = {};
+	}
+	toImages() {
+		return [];
+	}
+	toContents() {
+		return this.contents.join("\n\n");
+	}
+	async response(e, t) {
+		let n = [this.toContents(), t].filter(Boolean).join("\n\n");
+		try {
+			let { query: t } = await import("@anthropic-ai/claude-agent-sdk"), r = t({
+				prompt: n,
+				options: {
+					model: e || void 0,
+					env: {
+						...process.env,
+						ANTHROPIC_API_KEY: this.key
+					},
+					permissionMode: "acceptEdits",
+					allowDangerouslySkipPermissions: !0,
+					...this.config
+				}
+			}), i = "";
+			for await (let e of r) e.type === "result" && e.subtype === "success" && (i = e.result);
+			return i.trim();
+		} catch (e) {
+			return console.error("[AiClaudeAgent] Error:", e), "";
+		}
+	}
+}, L = class extends I {
+	constructor() {
+		super(...r());
+	}
+}, be = "./ai-tmp", R = class e {
+	static idFileGlobal = 0;
+	createdFiles = [];
+	getFileName() {
+		return e.idFileGlobal += 1, `${be}/Prompt-${e.idFileGlobal}.txt`;
+	}
+	createFile(e) {
+		let t = this.getFileName();
+		return this.createdFiles.push(t), u.writeByPath(t, e.trim()), `Please read the following file as it contains the prompt instructions: @${t}`;
+	}
+	removeFile() {
+		for (let e of this.createdFiles) u.removeFile(e);
+		this.createdFiles.length = 0;
+	}
+}, z = class extends l {
+	tmp = new R();
+	async init() {
+		this.ai = {};
+	}
+	toImages() {
+		return [];
+	}
+	toContents() {
+		return E(this.contents, (e) => this.tmp.createFile(e));
+	}
+	async response(e, t) {
+		return new Promise((n) => {
+			let r = [`${[...this.toContents(), this.tmp.createFile(t)].join("\n\n##################\n\n")} -- Output strictly the code/answer. No preamble, no chatter, no reasoning`, ...e ? ["--model", e] : []];
+			try {
+				M("claude", r, {
+					encoding: "utf8",
+					env: { ...process.env }
+				}, (e, t, r) => {
+					e ? (console.error("Error executing Claude CLI:", r || e.message), n("")) : n(t.trim()), this.tmp.removeFile();
+				});
+			} catch {
+				this.tmp.removeFile();
+			}
+		});
+	}
+}, B = class extends z {
+	constructor() {
+		super(...r());
+	}
+}, V = class extends l {
+	tmp = new R();
+	async init() {
+		this.ai = {};
+	}
+	toImages() {
+		return [];
+	}
+	toContents() {
+		return E(this.contents, (e) => this.tmp.createFile(e));
+	}
+	async response(e, t) {
+		return new Promise((n) => {
+			let r = [
+				`${[...this.toContents(), this.tmp.createFile(t)].join("\n\n##################\n\n")} -- Output strictly the code/answer. No preamble, no chatter, no reasoning`,
+				...e ? ["--model", e] : [],
+				"--yolo"
+			];
+			try {
+				M("gemini", r, {
+					encoding: "utf8",
+					env: { ...process.env }
+				}, (e, t, r) => {
+					e ? (console.error("Error executing Gemini CLI:", r || e.message), n("")) : n(t.trim()), this.tmp.removeFile();
+				});
+			} catch {
+				this.tmp.removeFile();
+			}
+		});
+	}
+}, H = class extends V {
+	constructor() {
+		super(...r());
+	}
+}, xe = [
+	"--no-sandbox",
+	"--disable-setuid-sandbox",
+	"--disable-dev-shm-usage"
+], Se = "webp", Ce = 1080, we = 80, Te = 32e4, U = ["networkidle0", "domcontentloaded"], Ee = 1920, W = class {
+	url;
+	options;
+	browser;
+	page;
+	response;
+	pageWidth = -1;
+	pageHeight = -1;
+	constructor(e, t = {}) {
+		this.url = e, this.options = t;
+	}
+	get args() {
+		return this.options.args ?? xe;
+	}
+	get waitUntil() {
+		return this.options.waitUntil ?? U;
+	}
+	get timeout() {
+		return this.options.timeout ?? 32e4;
+	}
+	get format() {
+		return this.options.format ?? "webp";
+	}
+	get width() {
+		return this.options.width ?? 1920;
+	}
+	get height() {
+		return this.options.height ?? 1080;
+	}
+	get quality() {
+		return this.options.quality ?? 80;
+	}
+	get fullPage() {
+		return this.options.fullPage ?? !1;
+	}
+	get extension() {
+		let e = this.format;
+		return e === "jpeg" ? ".jpg" : `.${e}`;
+	}
+	async getBrowser() {
+		if (!this.browser) {
+			let { launch: e } = await import("puppeteer");
+			this.browser = await e({
+				headless: !0,
+				args: this.args
+			});
+		}
+		return this.browser;
+	}
+	async getPage() {
+		return this.page || (this.page = await (await this.getBrowser()).newPage(), await this.page.setViewport({
+			width: this.width,
+			height: this.height
+		}), this.page.on("console", (e) => this.toConsole(`Log: ${e.text()}`)), this.page.on("pageerror", (e) => this.toConsole(`Error: ${e?.message}`))), this.page;
+	}
+	async getResponse() {
+		if (!this.response) {
+			let e = await (await this.getPage()).goto(this.url, {
+				waitUntil: this.waitUntil,
+				timeout: this.timeout
+			});
+			e && e.ok() ? this.response = e : this.toConsole(`Failed to load page: ${this.url}. Status: ${e?.status()}`);
+		}
+		return this.response;
+	}
+	async getDom() {
+		return await (await this.getPage()).content();
+	}
+	async getBody() {
+		return await this.evaluate(() => document.body.innerHTML) ?? "";
+	}
+	async getStyles() {
+		return await this.evaluate(() => Array.from(document.styleSheets).map((e) => {
+			try {
+				return Array.from(e.cssRules).map((e) => e.cssText).join("\n");
+			} catch (e) {
+				return console.error("Error getting CSS rules:", e), "";
+			}
+		}).join("\n")) ?? "";
+	}
+	async getMetrics() {
+		if (await this.getResponse() && (this.pageWidth === -1 || this.pageHeight === -1)) {
+			let e = await this.evaluate(() => ({
+				height: document.documentElement.scrollHeight,
+				width: document.documentElement.scrollWidth
+			}));
+			e && (this.pageWidth = e.width, this.pageHeight = e.height);
+		}
+		return {
+			height: this.pageHeight,
+			width: this.pageWidth
+		};
+	}
+	async evaluate(e, ...t) {
+		return await (await this.getPage()).evaluate(e, ...t);
+	}
+	async screenshot(e) {
+		return this.fullPage ? await this.screenshotFull(e) : await this.screenshotPages(e), this;
+	}
+	async reset() {
+		return this.page = void 0, this.pageWidth = -1, this.pageHeight = -1, this.response = void 0, this;
+	}
+	getOutputPath(e, t = 1, n = 1) {
+		return this.fullPage ? e + this.extension : e + `-${n}_${t}` + this.extension;
+	}
+	async saveScreenshot(e) {
+		let t = this.format, n = t === "png" ? void 0 : this.quality;
+		return await (await this.getPage()).screenshot({
+			path: e,
+			type: t,
+			quality: n,
+			fullPage: this.fullPage
+		}), this;
+	}
+	async screenshotPages(e) {
+		let { height: t } = await this.getMetrics(), n = this.height, r = Math.ceil(t / n);
+		this.toConsole(`Page height: ${t}px, viewport height: ${n}px, total pages: ${r}`);
+		for (let t = 0; t < r; t++) {
+			let i = t * n, a = this.getOutputPath(e, t + 1, r);
+			await this.evaluate((e) => window.scrollTo(0, e), i), await _e(320), await this.saveScreenshot(a), this.toConsole(`Saved screenshot page ${t + 1}/${r} to ${a}`);
+		}
+		return this;
+	}
+	async screenshotFull(e) {
+		let t = this.getOutputPath(e);
+		return await this.saveScreenshot(t), this.toConsole(`Saved full page screenshot to ${t}`), this;
+	}
+	toConsole(e) {
+		console.log("Browser", e);
+	}
+}, G = class {
+	path;
+	data;
+	constructor(e) {
+		this.path = e, this.data = u.readFile(this.getPath()) ?? {};
+	}
+	is() {
+		return u.is(this.getPath());
+	}
+	isVersionConsistency(e) {
+		return !!e && this.getVersion() === e;
+	}
+	isTest() {
+		return this.get()?.["ui-test"] === !0;
+	}
+	isNoPublish() {
+		let e = this.get();
+		return e?.["ui-no-publish"] === !0 || e?.private === !0;
+	}
+	get() {
+		return this.data;
+	}
+	getName() {
+		return this.get()?.name ?? u.joinPath(this.getDir());
+	}
+	getVersion() {
+		return this.get()?.version ?? "0.0.0";
+	}
+	getScripts() {
+		return this.get()?.scripts ?? {};
+	}
+	getDir() {
+		return A(this.path);
+	}
+	getPath() {
+		return [...this.getDir(), oe];
+	}
+	getCodeBuildOrRecovery() {
+		let e = this.getScripts();
+		if ("prepublishOnly" in e) return "npm run prepublishOnly";
+		if ("build-recovery" in e) return "npm run build-recovery";
+		if ("build" in e) return "npm run build";
+	}
+	getCodePublish() {
+		return "publish-to-npm" in this.getScripts() ? "npm run publish-to-npm" : "npm publish --access public";
+	}
+}, De = P(M);
+async function K(e, t, n = !1, r = !1) {
+	let i = e.getName(), [a, ...o] = t.split(" ");
+	try {
+		let { stdout: s, stderr: c } = await De(a, o, { cwd: u.joinPath(e.getDir()) });
+		return console.log(`Command ${t} for ${i}`), s && n && console.log(s), c && r && console.error(c), !0;
+	} catch (e) {
+		return console.error(`Error command ${t} for ${i}:`, e), !1;
+	}
+}
+//#endregion
+//#region src/classes/Build/BuildPackages.ts
+var q = [
+	".",
+	"logs",
+	"ui-build.log.json"
+], Oe = class {
+	path;
+	log;
+	constructor(e = ne) {
+		this.path = e, this.log = u.readFile(q) ?? {};
+	}
+	async make() {
+		let e = this.getList(), t = 0;
+		console.info(`Build packages(${e.length})...`);
+		for (let n of e) this.isUpdate(n) && await this.build(n) && (this.updateLog(n), t++);
+		this.saveLog(), console.info(t > 0 ? `Build packages changed: ${t}` : "Build packages - no changes");
+	}
+	async build(e) {
+		let t = e.getCodeBuildOrRecovery();
+		return t ? await K(e, t) : !1;
+	}
+	isUpdate(e) {
+		return !e.isVersionConsistency(this.getVersionLog(e.getName()));
+	}
+	getList() {
+		let e = u.readDir(this.path), t = [];
+		for (let n of e) {
+			let e = new G([this.path, n]);
+			e.is() && !e.isTest() && t.push(e);
+		}
+		return t.sort((e, t) => (e.get()?.["ui-priority"] ?? 500) - (t.get()?.["ui-priority"] ?? 500));
+	}
+	getVersionLog(e) {
+		return this.log?.[e] ?? "0.0.0";
+	}
+	updateLog(e) {
+		this.log[e.getName()] = e.getVersion();
+	}
+	saveLog() {
+		u.writeByPath(q, this.log);
+	}
+}, ke = P(M), Ae = class {
+	path;
+	constructor(e = ne) {
+		this.path = e;
+	}
+	async make() {
+		let e = u.readDir(this.path), t = 0;
+		console.info(`Publish packages(${e.length})...`);
+		for (let n of e) {
+			let e = new G([this.path, n]);
+			e.is() && !e.isNoPublish() && await this.isUpdate(e) && await K(e, e.getCodePublish(), !0, !0) && t++;
+		}
+		console.info(t > 0 ? `Publish packages changed: ${t}` : "Publish packages - no changes");
+	}
+	async isUpdate(e) {
+		let t = await this.getNpmVersion(e.getName());
+		return t === void 0 || !e.isVersionConsistency(t);
+	}
+	async getNpmVersion(e) {
+		try {
+			let { stdout: t } = await ke("npm", [
+				"view",
+				e,
+				"version"
+			]);
+			return t.trim() || void 0;
+		} catch {
+			return;
+		}
+	}
+}, je = class {
+	file;
+	isReading = !1;
+	url;
+	constructor(e = "./ai-screenshot/screenshot") {
+		this.file = e, T.setErrorStatus(!0);
+	}
+	async make() {
+		console.info("Screenshot");
+		let e = u.getPathDir(`${this.file}.file`);
+		return u.removeDir(e), u.createDir(e), this.makeServer(), this;
+	}
+	listener = async () => {
+		if (this.url && !this.isReading) {
+			this.isReading = !0, console.info("URL", this.url);
+			let e = new W(this.url, { height: 12288 });
+			return await e.screenshot(this.file), u.writeByPath(`${this.file}-code.html`, await e.getBody()), u.writeByPath(`${this.file}-styles.css`, await e.getStyles()), !0;
+		}
+		return !1;
+	};
+	makeServer() {
+		let e = ve("npm", ["run", "dev"], {
+			shell: !0,
+			stdio: "pipe"
+		});
+		return e.stdout?.on("data", (t) => {
+			console.log("Server", "start");
+			let n = t.toString();
+			this.makeUrl(n), this.url && (console.info("Server", "init"), this.listener().then((t) => {
+				t && (e.kill(), console.info("Server", "kill"), process.exit(0));
+			}));
+		}), e.stderr?.on("data", (e) => {
+			console.error(`Server Error: ${e.toString()}`);
+		}), this;
+	}
+	makeUrl(e) {
+		let t = e.match(/(https?:\/\/localhost\S+)/);
+		return t && (this.url = t[1]), this;
+	}
+}, Me = /* @__PURE__ */ new Map([
+	["claude", () => new s()],
+	["claude-agent", () => new L()],
+	["claude-cli", () => new B()],
+	["gemini", () => new e()],
+	["gemini-cli", () => new H()],
+	["openai", () => new o()],
+	["zai", () => new c()]
+]);
+function J() {
+	let e = d.getAiType();
+	return Me.get(e)?.();
+}
+//#endregion
+//#region src/classes/Design/DesignTypesAi.ts
+var Y = class {
+	dir;
+	projectName;
+	dirArray;
+	constructor(e = d.getTypesTemporaryDirectory()) {
+		this.dir = e, this.dirArray = this.dir.split("/"), this.projectName = w()?.name ?? "none";
+	}
+	isFile(e) {
+		return e.endsWith(".d.ts");
+	}
+	isFileJs(e) {
+		return e.endsWith(".js");
+	}
+	getDirArray() {
+		return this.dirArray;
+	}
+	getMd5(e) {
+		return ye("md5").update(e.trim()).digest("hex");
+	}
+	getProjectName() {
+		return this.projectName;
+	}
+	async toAi(e, t, n) {
+		let r = J();
+		if (r) {
+			n && r.addPrompt(`File JS Code (SUPPLEMENTARY REFERENCE & CONTEXT ONLY):
+The following JavaScript code is provided STRICTLY as supplementary background context to give a full picture of implementation details and logic.
+CRITICAL RESTRICTION: You MUST NOT treat or use this data as "File Content". Do NOT generate, return, or include any classes, methods, functions, or entities from "File JS Code" in the output unless they are explicitly present in "File Content".
+
+\`\`\`
+${n}\n\`\`\``), r.addPrompt("You are a world-class senior developer and an exceptional technical writer."), r.addPrompt("CRITICAL DIRECTIVE: No data stored in history, previous chat messages, or prior conversation context must influence the result. Process strictly and exclusively the data provided in the text below."), r.addPrompt(`TASK INSTRUCTIONS & GOAL:
+The following are the exact rules, requirements, and execution instructions for processing the file content:
+
+${t}`), r.addPrompt(`File Content (PRIMARY DATA TO PROCESS):
+The following is the primary target file content that you MUST process according to the instructions in the prompt above:
+\`\`\`
+${e}\n\`\`\``);
+			let i = await r.generate("go!");
+			if (i) return i;
+		}
+	}
+	async toAiJson(e, t, n) {
+		let r = await this.toAi(e, t, n);
+		if (r) try {
+			let e = r.replace(/```json|```/g, "").trim();
+			return JSON.parse(e);
+		} catch {
+			return;
+		}
+	}
+}, X = class {
+	temporaryDirectory;
+	constructor(e = d.getTypesTemporaryDirectory()) {
+		this.temporaryDirectory = e;
+	}
+}, Z = class extends X {
+	configuration;
+	constructor(e = d.getTypesTemporaryDirectory()) {
+		super(e);
+	}
+	is() {
+		return u.is(this.getTemporaryDirectory());
+	}
+	isVue() {
+		if (d.isTypesWithoutVue()) return !1;
+		let e = d.getTypesPaths(), t = O(e) ? e : ["src"];
+		for (let e of t) {
+			let t = this.resolveDirectory(e);
+			if (u.is(t)) {
+				let e = u.readDirRecursive(t);
+				for (let n of e) {
+					let e = u.joinPath([t, n]);
+					if (n.endsWith(".vue") && this.isAllowed(e)) return !0;
+				}
+			}
+		}
+		return !1;
+	}
+	build() {
+		return this.clean(), this.isVue() ? this.buildVue() : this.buildTs(), this;
+	}
+	clean() {
+		let e = this.getTemporaryDirectory();
+		return u.is(e) && u.removeDir(e), this;
+	}
+	isAllowed(e) {
+		return this.isFileTs(e) && this.isPath(e) && this.isMatch(e) && !this.isExclude(e);
+	}
+	isAllowedDeclaration(e) {
+		return this.isFileDts(e) && !e.endsWith("main.d.ts") && !e.endsWith("App.d.ts") && !this.isFileTest(e) && this.isPath(e) && this.isMatch(e) && !this.isExclude(e);
+	}
+	isExclude(e) {
+		return this.isPattern(e, d.getTypesExclude());
+	}
+	isFileDts(e) {
+		return e.endsWith(".d.ts");
+	}
+	isFileTest(e) {
+		return e.includes("__tests__") || !!e.match(/\.(test|spec|stories)\.(ts|tsx|js|vue|d\.ts)$/);
+	}
+	isFileTs(e) {
+		return !!((e.endsWith(".ts") || e.endsWith(".tsx") || e.endsWith(".js") || e.endsWith(".vue")) && !this.isFileDts(e) && !this.isFileTest(e));
+	}
+	isMatch(e) {
+		let t = d.getTypesMatch();
+		return !O(t) || this.isPattern(e, t);
+	}
+	isPath(e) {
+		let t = d.getTypesPaths();
+		return !O(t) || t.some((t) => {
+			let n = t.replace(/^[./\\]+/, "").replace(/[/\\]+$/, ""), r = n.replace(/^src[/\\]/, "");
+			return e.startsWith(n) || e.startsWith(`./${n}`) || e.startsWith(r) || e.startsWith(`./${r}`) || e.includes(`/${n}/`) || e.includes(`\\${n}\\`) || e.includes(`/${r}/`) || e.includes(`\\${r}\\`);
+		});
+	}
+	isPattern(e, t) {
+		return O(t) ? A(t).some((t) => {
+			try {
+				return new RegExp(t).test(e);
+			} catch {
+				return e.includes(t);
+			}
+		}) : !1;
+	}
+	getTemporaryDirectory() {
+		return this.temporaryDirectory;
+	}
+	getTsConfigName() {
+		if (u.is("tsconfig.app.json")) return "tsconfig.app.json";
+		if (u.is("tsconfig.json")) return "tsconfig.json";
+	}
+	getTsConfiguration() {
+		if (this.configuration) return this.configuration;
+		let e = u.getRoot(), t = this.getTsConfigName();
+		if (t) {
+			let n = F.findConfigFile(e, F.sys.fileExists, t);
+			if (n) {
+				let e = F.readConfigFile(n, F.sys.readFile);
+				if (!e.error) return this.configuration = F.parseJsonConfigFileContent(e.config, F.sys, u.getPathDir(n), void 0, n, void 0, [{
+					extension: ".vue",
+					isMixedContent: !0,
+					scriptKind: F.ScriptKind.Deferred
+				}]), this.configuration;
+			}
+		}
+	}
+	getTsSourceFiles() {
+		let e = this.getTsConfiguration();
+		if (e && e.fileNames.length > 0) return e.fileNames.filter((e) => this.isAllowed(e));
+		let t = d.getTypesPaths(), n = O(t) ? t : ["src"], r = [];
+		for (let e of n) {
+			let t = this.resolveDirectory(e);
+			if (u.is(t)) {
+				let e = u.readDirRecursive(t);
+				for (let n of e) {
+					let e = u.joinPath([t, n]);
+					this.isAllowed(e) && r.push(e);
+				}
+			}
+		}
+		return r;
+	}
+	buildTs() {
+		let e = this.getTemporaryDirectory(), t = this.getTsConfiguration(), n = this.getTsSourceFiles();
+		if (n.length > 0) {
+			let r = t?.options?.rootDir ?? (u.is("src") ? "src" : void 0), i = {
+				...t?.options ?? {},
+				declaration: !0,
+				emitDeclarationOnly: !0,
+				noEmit: !1,
+				outDir: e,
+				...r ? { rootDir: r } : {}
+			}, a = F.createCompilerHost(i);
+			F.createProgram(n, i, a).emit(), this.cleanExcess();
+		}
+		return this;
+	}
+	buildVue() {
+		let e = this.getTsConfigName();
+		if (e) {
+			let t = `npx vue-tsc -p ${e} --declaration --emitDeclarationOnly --outDir ${this.getTemporaryDirectory()} --noEmit false --rootDir src --noEmitOnError false`;
+			try {
+				N(t, {
+					cwd: u.getRoot(),
+					stdio: "pipe"
+				});
+			} catch (e) {
+				console.warn("DesignTypesBuild: vue-tsc compilation executed with output", e);
+			}
+			this.cleanExcess();
+		} else this.buildTs();
+		return this;
+	}
+	cleanExcess() {
+		let e = this.getTemporaryDirectory();
+		if (u.is(e)) {
+			let t = u.readDirRecursive(e);
+			for (let n of t) this.isAllowedDeclaration(n) || u.removeFile([e, n]);
+		}
+		return this;
+	}
+	resolveDirectory(e) {
+		let t = e.replace(/^[./\\]+/, "").replace(/[/\\]+$/, "");
+		if (u.is(t)) return t;
+		let n = u.joinPath(["src", t]);
+		return u.is(n) ? n : u.joinPath(t);
+	}
+}, Ne = class {
+	ai;
+	makeTypes;
+	prompts;
+	fullDescription;
+	constructor(e, t, n) {
+		this.ai = e, this.makeTypes = t, this.prompts = n;
+	}
+	is() {
+		return u.is(m);
+	}
+	getFullDescription() {
+		return this.fullDescription ?? "";
+	}
+	async make() {
+		let e = this.makeTypes.getFullContent(), t = this.makeTypes.getFullJsContent(), n = await this.prompts.toAiPrompts(), r = `${await this.toAiDescription(e, t)}\n${n}`;
+		return this.fullDescription = r, this.saveDescription(r), this;
+	}
+	saveDescription(e) {
+		u.writeByPath(m, e);
+	}
+	async toAiDescription(e, t) {
+		return !O(e) && !O(t) ? "" : await this.ai.toAi(e, "Goal: Generate a concise package overview for an AI coding assistant detailing what this package is, why to study it, and listing its key capabilities.\n\nSTRUCTURE & CONTENT REQUIREMENTS:\n1. Package Description: 1-2 concise sentences explaining what this package is and its core technical purpose.\n2. Triggers for Studying ai-types.md: Maximally concise yet complete explanation of when and why an AI assistant must study \"ai-types.md\" (specific tasks, keywords, or architectural requirements) without losing any essential information.\n3. Key Capabilities: A single comma-separated list of key functional capabilities (e.g. \"Key Capabilities: Form Controls, API Integration, Storage State\") where each item is strictly 1 to 3 words long.\n\nCRITICAL RESTRICTIONS:\n- Triggers for Studying ai-types.md MUST be maximally concise and dense without omitting any technical triggers or information.\n- Key Capabilities MUST be formatted strictly as a single comma-separated list, NOT as bullet points or separate lines.\n- Each item in the Key Capabilities list MUST be strictly 1 to 3 words.\n- Do NOT list individual method, function, or class names.\n- Analyze ONLY the provided type definitions and JS code.\n- Do NOT wrap output in markdown code blocks (```).\n\nOUTPUT REQUIREMENTS:\nReturn ONLY the final description text. No explanations, no code blocks, and no conversational fluff.\n", t) ?? "";
+	}
+}, Pe = class {
+	ai;
+	dir;
+	dirDist;
+	constructor(e, t = d.getTypesTemporaryDirectory(), n = d.getDistDir()) {
+		this.ai = e, this.dir = t, this.dirDist = n;
+	}
+}, Fe = class {
+	ai;
+	dir;
+	dirDist;
+	listByFilter;
+	listByFilterJs;
+	listCache;
+	constructor(e, t = d.getTypesTemporaryDirectory(), n = d.getDistDir()) {
+		this.ai = e, this.dir = t, this.dirDist = n;
+	}
+	getListByFilter() {
+		return this.listByFilter === void 0 && (this.listByFilter = this.getListBy((e) => this.ai.isFile(e), this.getTemporaryDirectory())), this.listByFilter;
+	}
+	getListByFilterJs() {
+		return this.listByFilterJs === void 0 && (this.listByFilterJs = this.getListBy((e) => this.ai.isFileJs(e), this.getDistDirectory())), this.listByFilterJs;
+	}
+	getListCache() {
+		return this.listCache === void 0 && (this.listCache = this.getListBy((e) => this.ai.isFile(e), p)), this.listCache;
+	}
+	getListAi(e) {
+		return E(e, (e) => {
+			let t = u.readFileOnly([p, e.path]), n = t ? t.replace(/^\/\/ md5:[^\n]*\n?/, "") : e.content;
+			return {
+				...e,
+				content: n.trim()
+			};
+		});
+	}
+	toOneFile(e) {
+		return E(e, (e) => e.content).join("\n\n");
+	}
+	readFile(e, t = this.getTemporaryDirectory()) {
+		return u.readFileOnly(this.getPath(e, t));
+	}
+	save(e) {
+		let t = w();
+		if (t) {
+			let n = t.version ? ` (v${t.version})` : "";
+			u.writeByPath(S, [
+				`All these methods are in the ${t.name}${n} library.`,
+				"",
+				e
+			].join("\n"));
+		}
+	}
+	saveFile(e, t = !1) {
+		u.writeByPath([p, e.path], `${this.getMd5Header(e.md5, t)}\n${e.content}`);
+	}
+	saveList(e) {
+		return E(e, (e) => {
+			let t = [p, e.path], n = u.readFileOnly(t);
+			if (!O(n) || !n.startsWith(this.getMd5Header(e.md5))) return this.saveFile(e), e;
+			if (!n.startsWith(this.getMd5Header(e.md5, !0))) return e;
+		});
+	}
+	isContent(e) {
+		return !!(e && e.includes("export"));
+	}
+	getList(e = this.getTemporaryDirectory()) {
+		return u.is(e) ? u.readDirRecursive(e) : [];
+	}
+	getListBy(e, t = this.getTemporaryDirectory()) {
+		return E(this.getList(t), (n) => {
+			if (e(n)) {
+				let e = this.readFile(n, t);
+				if (this.isContent(e)) return {
+					path: n,
+					content: e,
+					md5: this.ai.getMd5(e)
+				};
+			}
+		});
+	}
+	getMd5Header(e, t = !1) {
+		return `// md5:${e ?? "none"}${t ? " true" : ""}`;
+	}
+	getPath(e, t = this.getTemporaryDirectory()) {
+		return [t, e];
+	}
+	getTemporaryDirectory() {
+		return this.dir;
+	}
+	getDistDirectory() {
+		return this.dirDist;
+	}
+}, Ie = class {
+	cleanContent(e) {
+		let t = F.createSourceFile("clean.d.ts", e, F.ScriptTarget.Latest, !0, F.ScriptKind.TS), n = F.transform(t, [this.getCleanTransformer()]), r = F.createPrinter({ newLine: F.NewLineKind.LineFeed }).printNode(F.EmitHint.Unspecified, n.transformed[0], t);
+		return n.dispose(), r.replace(/^\s*\/\/.*$/gm, "").replace(/^\s*[\r\n]/gm, "").trim();
+	}
+	getCleanTransformer() {
+		return (e) => (t) => {
+			let n = (t) => {
+				if (!(this.isRelativeImport(t) || this.isRelativeExport(t) || this.isNonPublicMember(t))) return F.visitEachChild(t, n, e);
+			};
+			return F.visitNode(t, n);
+		};
+	}
+	isNonPublicMember(e) {
+		return !!(F.canHaveModifiers(e) ? F.getModifiers(e) : void 0)?.some((e) => e.kind === F.SyntaxKind.PrivateKeyword || e.kind === F.SyntaxKind.ProtectedKeyword);
+	}
+	isRelativeImport(e) {
+		return F.isImportDeclaration(e) && F.isStringLiteral(e.moduleSpecifier) && e.moduleSpecifier.text.startsWith(".");
+	}
+	isRelativeExport(e) {
+		return F.isExportDeclaration(e) && e.moduleSpecifier !== void 0 && F.isStringLiteral(e.moduleSpecifier) && e.moduleSpecifier.text.startsWith(".");
+	}
+}, Le = class extends Pe {
+	fullContent;
+	fullJsContent;
+	AI_TYPES_CONCURRENCY = d.getAiTypesConcurrency();
+	tsTransformer = new Ie();
+	files;
+	constructor(e, t = d.getTypesTemporaryDirectory(), n = d.getDistDir()) {
+		super(e, t, n), this.files = new Fe(this.ai, this.dir, this.dirDist);
+	}
+	getFullContent() {
+		if (this.fullContent === void 0) {
+			let e = this.files.getListCache(), t = this.files.getListAi(e);
+			this.fullContent = this.files.toOneFile(t);
+		}
+		return this.fullContent;
+	}
+	getFullJsContent() {
+		return this.fullJsContent === void 0 && (this.fullJsContent = this.files.toOneFile(this.files.getListByFilterJs())), this.fullJsContent;
+	}
+	async make() {
+		let e = this.files.getListByFilter(), t = this.getFullJsContent(), n = this.files.saveList(e);
+		return await this.saveListAi(n, t), this.makeSave();
+	}
+	makeSave() {
+		let e = this.getFullContent();
+		return this.files.save(e), this;
+	}
+	hasJSDoc(e) {
+		return e.includes("/**");
+	}
+	cleanContent(e) {
+		return this.tsTransformer.cleanContent(e);
+	}
+	async saveListAi(e, t) {
+		let n = e.length;
+		if (n === 0) return;
+		let r = [...e], i = 0, a = async () => {
+			let e;
+			for (; (e = r.shift()) !== void 0;) {
+				let r = this.cleanContent(e.content);
+				O(r) && (i += 1, console.log(`-- processing AI types [${i}/${n}] for ${e.path}...`), r = await this.toAiEdit(r, this.hasJSDoc(r) ? "" : t)), e.content !== r && this.files.saveFile({
+					...e,
+					content: r
+				}, !0);
+			}
+		};
+		await Promise.all(Array.from({ length: Math.min(this.AI_TYPES_CONCURRENCY, n) }, () => a()));
+	}
+	async toAiEdit(e, t) {
+		return await this.ai.toAi(e, "Goal: Optimize TypeScript type definitions for declarations in `File Content`.\n\nSCOPE & CONTEXT:\n- Process STRICTLY entities in `File Content`. Do NOT add unexported entities or code from `File JS Code`.\n- Use `File JS Code` ONLY as reference to understand implementation logic for writing JSDoc descriptions.\n- AI coding agents will rely EXCLUSIVELY on this output. Ensure complete type contracts and clear JSDoc descriptions.\n- Do NOT include file paths, links, or internal imports in the output.\n\nJSDOC RULES:\n- MANDATORY FOR ALL CLASSES, METHODS, FUNCTIONS & ACCESSORS: Every `class`, `declare class`, `abstract class`, `function`, `declare function`, method (public/static/abstract), `constructor`, and `get`/`set` accessor MUST ALWAYS have a JSDoc description.\n  * Style: Descriptions MUST be maximally clear and informative, yet maximally short and concise. Avoid fluff.\n  * Single-Line Preference: Prefer single-line JSDoc format (`/** Description @keywords search_terms */`) to conserve vertical space and reduce file size.\n  * Remove `@return` / `@returns`: STRICTLY REMOVE `@return` and `@returns` tags from all JSDoc comments.\n  * `@param` Tag: Include `@param` ONLY if critically necessary to clarify parameter behavior; otherwise omit `@param`.\n  * AI Search Keywords: Include relevant search tags/keywords (e.g. `@keywords` tag or search terms) to help AI code search easily discover functionality.\n  * Allowed tags: PRESERVE ONLY `@example`, `@remarks`, `@note`, `@warning`, `@keywords`, and critical `@param` tags. Remove `@return`/`@returns` and all other tags.\n  * If JSDoc is missing: Generate a clear, concise, search-optimized English JSDoc derived from inspecting `File JS Code`.\n  * If JSDoc exists: Optimize, condense, translate to English, and apply tag rules.\n- TYPES, INTERFACES & ENUMS: Delete JSDoc for simple/obvious types; add or keep concise JSDoc for complex types.\n- Place JSDoc directly above declarations. Remove regular inline comments (`//` or `/* */`).\n\nCLEANING & STRUCTURING:\n- Remove internal `import` statements and internal re-exports. Keep external package exports.\n- Delete non-public content (private/protected members, unexported elements). Keep all public API surfaces.\n- Do NOT delete any `type` definitions. Preserve abstract classes.\n- Format output tightly without unnecessary blank lines.\n\nOUTPUT FORMAT:\nReturn ONLY raw TypeScript code corresponding to `File Content`. No markdown, no code blocks (```), no text explanations.\n", t) ?? e;
+	}
+}, Re = class {
+	ai;
+	prompts;
+	constructor(e, t) {
+		this.ai = e, this.prompts = t;
+	}
+	is() {
+		return u.is(h);
+	}
+	async make() {
+		let e = this.ai.getProjectName(), t = [];
+		t.push({
+			uri: `${e}/${S}`,
+			name: `Type Definitions (${e})`,
+			mimeType: "text/markdown",
+			description: "TypeScript type definitions and signatures for AI coding assistant."
+		}), t.push({
+			uri: `${e}/${m}`,
+			name: `Project Overview (${e})`,
+			mimeType: "text/markdown",
+			description: "Project overview, usage guidelines, and mandatory prompt rules for AI coding assistant."
+		}), t.push(...this.getScreenshotList(e));
+		let n = this.prompts.getCacheList();
+		for (let r of n) O(r.name) && O(r.description) && t.push({
+			uri: `${e}/${r.path}`,
+			name: `${r.name} (${e})`,
+			mimeType: "text/markdown",
+			description: r.description
+		});
+		return this.saveMcp(t), this;
+	}
+	getMimeType(e) {
+		return e.endsWith(".webp") ? "image/webp" : e.endsWith(".png") ? "image/png" : e.endsWith(".jpg") || e.endsWith(".jpeg") ? "image/jpeg" : e.endsWith(".svg") ? "image/svg+xml" : e.endsWith(".html") || e.endsWith(".htm") ? "text/html" : e.endsWith(".css") ? "text/css" : e.endsWith(".json") ? "application/json" : e.endsWith(".md") ? "text/markdown" : "text/plain";
+	}
+	getScreenshotList(e) {
+		let t = [];
+		if (u.is("ai-screenshot")) {
+			let n = u.readDir(f);
+			for (let r of n) r.startsWith(".") || t.push({
+				uri: `${e}/${f}/${r}`,
+				name: `Screenshot: ${r} (${e})`,
+				mimeType: this.getMimeType(r),
+				description: `Visual reference screenshot / asset (${r}) for ${e}.`
+			});
+		}
+		return t;
+	}
+	saveMcp(e) {
+		u.writeByPath(h, JSON.stringify(e, null, 2));
+	}
+}, Q = class {
+	promptsDir;
+	ai;
+	constructor(e = d.getAiResourcesDir(), t) {
+		this.promptsDir = e, this.ai = t;
+	}
+}, ze = "Goal: Generate a document metadata object in valid JSON format for an AI coding assistant.\n\nCRITICAL RESTRICTIONS:\n- The output MUST be a valid JSON object with keys: \"name\" and \"description\".\n- Field \"name\": Short and concise document title (maximum 4-5 words).\n- Field \"description\": Clear description for an AI agent explaining what exact standards, rules, or tools this file contains and what commercial or technical task it solves (maximum 3 sentences).\n- Do NOT include markdown code block wrappers (```json). Return ONLY the raw JSON string.\n\nEXAMPLES OF GOOD OUTPUT:\n{\n  \"name\": \"Coding Standards\",\n  \"description\": \"Строгие архитектурные конвенции и стандарты написания кода для продукта\"\n}\n\nOUTPUT REQUIREMENTS:\nReturn ONLY the JSON object. No explanations, no markdown formatting, no conversational text.\n", Be = class extends Q {
+	listPrompts;
+	cacheList;
+	getCacheList() {
+		if (this.cacheList === void 0) {
+			let e = this.getCacheDir(), t = u.readDirRecursive(e), n = [];
+			for (let r of t) if (r.endsWith(".json")) {
+				let t = u.readFile([e, r]);
+				t && O(t.path) && O(t.name) && O(t.description) && n.push(t);
+			}
+			this.cacheList = n;
+		}
+		return this.cacheList;
+	}
+	getListPrompts() {
+		if (this.listPrompts === void 0) {
+			let e = u.readDirRecursive(this.promptsDir);
+			this.listPrompts = E(e, (e) => {
+				if (e.endsWith(".json")) return;
+				let t = `${this.promptsDir}/${e}`, n = u.readFileOnly(t);
+				if (n) return {
+					path: t,
+					content: n,
+					md5: this.getMd5(n)
+				};
+			});
+		}
+		return this.listPrompts;
+	}
+	async init() {
+		await this.make();
+		let e = this.getListPrompts(), t = this.getCacheList(), n = [];
+		for (let r of e) {
+			let e = t.find((e) => e.path === r.path);
+			e && O(e.description) && n.push(this.getPromptLine(r.path, e.description));
+		}
+		return n;
+	}
+	async make() {
+		let e = this.getListPrompts();
+		for (let t of e) await this.toAiPromptItem(t);
+		return this;
+	}
+	async toAiPrompts() {
+		let e = await this.init();
+		return e.length > 0 ? `## Mandatory Rules
+You MUST evaluate whether your task relates to any of the following topics (even if not working directly with this package). If related material is present, you are strictly obligated to read and study the corresponding file before proceeding:
+${e.join("\n")}` : "";
+	}
+	getCacheDir() {
+		return u.joinPath([p, re]);
+	}
+	getCachePath(e) {
+		let t = e.replace(RegExp(`^${this.promptsDir}/`), "").replace(/\.[^/.]+$/, ".json");
+		return u.joinPath([this.getCacheDir(), t]);
+	}
+	getMd5(e) {
+		return this.ai.getMd5(e);
+	}
+	getPromptLine(e, t) {
+		return `- '${C}/${this.ai.getProjectName()}/${e}': ${t}`;
+	}
+	saveCacheItem(e) {
+		u.writeByPath(this.getCachePath(e.path), e);
+	}
+	saveCacheList(e) {
+		this.cacheList = e;
+		for (let t of e) this.saveCacheItem(t);
+	}
+	async toAiPromptData(e) {
+		return this.ai.toAiJson(e, ze);
+	}
+	async toAiPromptItem(e) {
+		let t = e.md5 ?? this.getMd5(e.content), n = this.getCacheList(), r = n.findIndex((t) => t.path === e.path), i = r >= 0 ? n[r] : void 0;
+		if (i && i.md5 === t && O(i.name) && O(i.description)) return {
+			prompt: this.getPromptLine(e.path, i.description),
+			isChanged: !1
+		};
+		console.log(`-- processing prompt metadata for ${e.path}...`);
+		let a = await this.toAiPromptData(e.content);
+		if (a && O(a.name) && O(a.description)) {
+			let i = {
+				path: e.path,
+				md5: t,
+				name: a.name,
+				description: a.description
+			};
+			return r >= 0 ? n[r] = i : n.push(i), this.saveCacheItem(i), {
+				prompt: this.getPromptLine(e.path, a.description),
+				isChanged: !0
+			};
+		}
+		return { isChanged: !1 };
+	}
+}, Ve = class {
+	promptsDir;
+	dir;
+	dirDist;
+	ai;
+	buildTypes;
+	description;
+	makeTypes;
+	mcp;
+	prompts;
+	constructor(e = d.getAiResourcesDir(), t = d.getTypesTemporaryDirectory(), n = d.getDistDir(), r = {}) {
+		this.promptsDir = e, this.dir = t, this.dirDist = n;
+		let { DesignTypesBuildConstructor: i = Z, DesignTypesMakeConstructor: a = Le, DesignTypesPromptsConstructor: o = Be } = r;
+		T.setErrorStatus(!0), this.ai = new Y(this.dir), this.buildTypes = new i(this.dir), this.makeTypes = new a(this.ai, this.dir, this.dirDist), this.prompts = new o(this.promptsDir, this.ai), this.description = new Ne(this.ai, this.makeTypes, this.prompts), this.mcp = new Re(this.ai, this.prompts);
+	}
+	async make() {
+		console.log("DesignTypes: making AI types...");
+		try {
+			this.buildTypes.build(), await this.makeTypes.make(), await this.prompts.make(), await this.description.make(), await this.mcp.make();
+		} finally {
+			this.buildTypes.clean();
+		}
+		return console.log("DesignTypes: AI types saved."), this;
+	}
+	async makeSave() {
+		return console.log("DesignTypes: saving AI types from list..."), this.makeTypes.makeSave(), this.description.is() || await this.description.make(), this.mcp.is() || await this.mcp.make(), console.log("DesignTypes: AI types saved."), this;
+	}
+}, He = /* @__PURE__ */ function(e) {
+	return e.MODIFIED = "M", e.ADDED = "A", e.DELETED = "D", e.RENAMED = "R", e.COPIED = "C", e.UPDATED = "U", e.UNTRACKED = "??", e.IGNORED = "!!", e.BOTH_MODIFIED = "UU", e.ADDED_BY_US = "AU", e.DELETED_BY_US = "DU", e.ADDED_BY_THEM = "UA", e.DELETED_BY_THEM = "UD", e.BOTH_ADDED = "AA", e.BOTH_DELETED = "DD", e.MODIFIED_IN_INDEX = "MM", e.ADDED_IN_INDEX = "AM", e.DELETED_IN_INDEX = "DM", e.RENAMED_IN_INDEX = "RM", e.COPIED_IN_INDEX = "CM", e;
+}({}), Ue = class {
+	static getList(e) {
+		let t = this.getDirPrefix();
+		return E(this.getFilesPath(), (n) => {
+			if (e && !e(n)) return;
+			let r = this.getDate(this.getFileDate(n));
+			return {
+				path: n,
+				pathByOS: this.splitPath(n),
+				pathFull: `${t}${n}`,
+				date: r,
+				status: void 0
+			};
+		});
+	}
+	static getListPorcelain(e) {
+		let t = this.getDate(), n = this.getDirPrefix();
+		return E(this.getFilesPorcelain(), (r) => {
+			let i = r.replace(/ {2,}/, " ").split(" ", 2), a = i[0], o = i[1] ?? "";
+			if (e && !e(o)) return;
+			let s = ge(o, n), c = this.splitPath(s);
+			return {
+				path: s,
+				pathByOS: c,
+				pathFull: o,
+				date: u.getTime(c) ?? t,
+				status: a
+			};
+		});
+	}
+	static getListUnique(e) {
+		return this.mergeUnique(this.getListPorcelain(e), this.getList(e));
+	}
+	static getListByDirectory(e) {
+		return this.getListUnique((t) => !!(t.match(e) && t.endsWith(".ts") && !t.endsWith(".test.ts")));
+	}
+	static getClassesList() {
+		return this.getListByDirectory("/classes/");
+	}
+	static getFunctionsList() {
+		return this.getListByDirectory("/functions/");
+	}
+	static getFilesPath() {
+		return E(this.exec("git ls-tree -r --name-only HEAD").split("\n"), (e) => e.trim());
+	}
+	static getFilesPorcelain() {
+		return E(this.exec("git status --porcelain").split("\n"), (e) => e.trim());
+	}
+	static getFileDate(e) {
+		return this.exec(`git log -1 --format="%ci" -- "${e}"`);
+	}
+	static getDirPrefix() {
+		return this.exec("git rev-parse --show-prefix");
+	}
+	static getDate(e) {
+		return new me(e).setType("full").standard();
+	}
+	static filterByDirectory(e) {
+		let t = this.getDirPrefix();
+		return e.filter((e) => e.pathFull.startsWith(t));
+	}
+	static mergeUnique(e, t) {
+		let n = [...e];
+		return E(t, (e) => {
+			n.find((t) => t.pathFull === e.pathFull) || n.push(e);
+		}), n;
+	}
+	static splitPath(e) {
+		return e.split("/").filter((e) => e.length > 0);
+	}
+	static exec(e) {
+		return N(e, { encoding: "utf8" }).trim();
+	}
+}, We = class {
+	source;
+	fileTs;
+	constructor(e = g, t = ie) {
+		this.source = e, this.fileTs = t;
+	}
+	isPrompt() {
+		return u.is(b);
+	}
+	getResources() {
+		let e = [];
+		if (this.isPrompt() && e.push(this.getPromptResource()), D(this.source) && this.source.length > 0 && he(this.source[0])) return e.push(...this.source), e;
+		let t = this.source;
+		if (u.is(t)) {
+			let n = u.readFile(t);
+			D(n) && n.length > 0 && e.push(...n);
+		}
+		return e;
+	}
+	make() {
+		console.log("Generating AI MCP TypeScript resources...");
+		let e = this.getResources();
+		if (e.length > 0) {
+			let t = this.initFile(e);
+			this.write(t), console.log(`Generated ${e.length} MCP resources in ${u.joinPath(this.fileTs)}`);
+		} else console.log("No MCP resources found to generate.");
+		return this;
+	}
+	getImportPath(e) {
+		let t = !e.startsWith("@") && !e.startsWith("./") && !e.startsWith("/") ? `./${e}` : e;
+		return [
+			".md",
+			".html",
+			".css",
+			".scss",
+			".txt",
+			".json",
+			".svg"
+		].some((e) => t.endsWith(e)) ? `${t}?raw` : t;
+	}
+	getPackageConstName(e, t) {
+		let n = e.replace(/^@[^/]+\//, ""), r = `mcp${j(n)}Resources`;
+		if (t.has(r)) {
+			let t = e.replace(/^@/, "").replace("/", "-");
+			r = `mcp${j(t)}Resources`;
+		}
+		return t.add(r), r;
+	}
+	getPackages(e) {
+		let t = /* @__PURE__ */ new Map();
+		return e.forEach((e) => {
+			let n = k(e.uri) ? e.uri : "", r = this.extractPackageName(n);
+			t.has(r) || t.set(r, []), t.get(r)?.push(e);
+		}), t;
+	}
+	getPromptResource() {
+		return {
+			uri: b,
+			name: "System Prompt (dxt-ui)",
+			mimeType: "text/markdown",
+			description: "Consolidated system instructions, coding guidelines, and prompt rules for AI coding assistant."
+		};
+	}
+	escapeString(e) {
+		return `'${e.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\r/g, "\\r").replace(/\n/g, "\\n")}'`;
+	}
+	extractPackageName(e) {
+		if (e.startsWith("@")) {
+			let t = e.split("/");
+			if (t.length >= 2) return `${t[0]}/${t[1]}`;
+		}
+		let t = e.indexOf("/");
+		return t > 0 ? e.substring(0, t) : "system";
+	}
+	formatItem(e) {
+		let t = [];
+		if (k(e.uri) && t.push(`    uri: ${this.escapeString(e.uri)}`), k(e.name) && t.push(`    name: ${this.escapeString(e.name)}`), k(e.description) && O(e.description) && t.push(`    description: ${this.escapeString(e.description)}`), k(e.mimeType) && O(e.mimeType) && t.push(`    mimeType: ${this.escapeString(e.mimeType)}`), k(e.text) && O(e.text) && t.push(`    text: ${this.escapeString(e.text)}`), k(e.blob) && O(e.blob) && t.push(`    blob: ${this.escapeString(e.blob)}`), k(e.uri) && O(e.uri) && !e.text && !e.blob) {
+			let n = this.getImportPath(e.uri);
+			t.push(`    handler: async () => (await import('${n}'))?.default`);
+		}
+		return `  {\n${t.join(",\n")}\n  }`;
+	}
+	initFile(e) {
+		let t = this.getPackages(e), n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map(), i = [
+			"// This file is generated by a script, do not edit.",
+			"",
+			"import type { McpResourceItem } from '@dxtmisha/mcp'"
+		], a = [], o = [];
+		return t.forEach((e, t) => {
+			let s = this.getPackageConstName(t, n);
+			r.set(t, s), o.push(s);
+			let c = e.map((e) => this.formatItem(e)).join(",\n");
+			i.push(""), i.push("/**"), i.push(` * MCP resources for ${t}.`), i.push(" */"), i.push(`export const ${s}: McpResourceItem[] = [`), i.push(c), i.push("]"), a.push(`  '${t}': ${s}`);
+		}), i.push(""), i.push("/**"), i.push(" * MCP resources grouped by package name."), i.push(" */"), i.push("export const mcpPackageResources: Record<string, McpResourceItem[]> = {"), i.push(a.join(",\n")), i.push("}"), i.push(""), i.push("/**"), i.push(" * All aggregated MCP resources for McpResource."), i.push(" */"), i.push("export const mcpAllResources: McpResourceItem[] = ["), i.push(o.map((e) => `  ...${e}`).join(",\n")), i.push("]"), i.push(""), i.push("export default mcpAllResources"), i.push(""), i.join("\n");
+	}
+	write(e) {
+		return u.writeByPath(this.fileTs, e, !1), this;
+	}
+}, Ge = class {
+	dir;
+	constructor(e = []) {
+		this.dir = e;
+	}
+	isMcp() {
+		return u.is(this.getPath(h));
+	}
+	make() {
+		if (this.isMcp()) {
+			let e = u.readFile(this.getPath(h));
+			if (Array.isArray(e) && e.length > 0) return e;
+		}
+	}
+	getPath(e) {
+		return [...this.dir, e];
+	}
+}, $ = class {
+	dir;
+	itemMcp;
+	constructor(e = []) {
+		this.dir = e, this.itemMcp = new Ge(this.dir);
+	}
+	getDir() {
+		return this.dir;
+	}
+	getMcp() {
+		return this.itemMcp.make();
+	}
+	getProjectName() {
+		return w(this.dir)?.name ?? "none";
+	}
+	isPrompt() {
+		return this.isDescription() || this.isInfo() || this.isTypes() || this.isScreenshot() || this.isDeveloper() || this.isMcp();
+	}
+	isDescription() {
+		return u.is(this.getPath(_));
+	}
+	isDeveloper() {
+		return u.is(this.getPath(v));
+	}
+	isInfo() {
+		return u.is(this.getPath(y));
+	}
+	isMcp() {
+		return this.itemMcp.isMcp();
+	}
+	isScreenshot() {
+		return u.is(this.getPath(f));
+	}
+	isTypes() {
+		return u.is(this.getPath(x));
+	}
+	make() {
+		console.log(this.getProjectName());
+		let e = [
+			this.getDescription(),
+			this.getInfo(),
+			this.getTypes(),
+			this.getScreenshot(),
+			this.getDeveloper()
+		].filter((e) => e !== void 0);
+		if (e.length > 0) {
+			let t = this.getPathString() || ".";
+			return `
+# ${this.getProjectName()}
+## Project location: Root directory
+The project is located at: '${t}'.
+
+${e.join("\n\n")}
+    `.trim();
+		}
+	}
+	getDescription() {
+		if (this.isDescription()) return console.log("-- Description"), `
+## Package Description & Module Overview
+${this.readFile(_)}
+      `.trim();
+	}
+	getDeveloper() {
+		if (this.isDeveloper()) return console.log("-- Developer"), `
+## Developer Rules (Must Read Before Modifying Code)
+'${this.getPathString(v)}'
+      `.trim();
+	}
+	getInfo() {
+		if (this.isInfo()) return console.log("-- Info"), `
+## Package Core Information
+${this.readFile(y)}
+      `.trim();
+	}
+	getPath(e) {
+		return [...this.dir, e];
+	}
+	getPathString(e) {
+		let t = this.dir.join("/");
+		return e ? t ? `${t}/${e}` : e : t;
+	}
+	getScreenshot() {
+		let e = this.getScreenshotList();
+		if (e) {
+			console.log("-- Screenshot");
+			let t = this.getPathString(f);
+			return `## Component Visual References (Screenshots)
+${e.map((e) => `- '${t}/${e}'`).join("\n")}
+      `.trim();
+		}
+	}
+	getScreenshotList() {
+		if (this.isScreenshot()) return u.readDir(this.getPath(f));
+	}
+	getTypes() {
+		if (this.isTypes()) return console.log("-- Types"), `
+## Package Type Definitions (Must Read in Full When Working with Package)
+'${this.getPathString(x)}'
+      `.trim();
+	}
+	readFile(e) {
+		let t = u.readFileOnly(this.getPath(e));
+		return t ? this.dir.length > 0 ? t.replace(/([ '"`]|^)\.\//g, `$1${this.getPathString()}/`) : t : "";
+	}
+}, Ke = "### Vue Component Implementation Rules (Vue.js Style Guide)\n\n- **Script Setup**: Use strictly `<script setup lang=\"ts\">`.\n- **Naming**: Component names must be multi-word, match their project path, and use PascalCase.\n- **CSS**: The root CSS class name of the component must match its name (in kebab-case).\n- **Typing**: Mandatory interfaces for Props (`defineProps<{...}>()`) and Emits (`defineEmits<{...}>()`).\n- **Lists (v-for)**: Always use a unique `:key`. Avoid using the array index as a key.\n- **Directives**: Never use `v-if` on the same element as `v-for`.\n- **Reactivity**: Use `ref` for data. Calculate complex logic via `computed`.\n- **Logic**: Extract only complex logic into Composables. Simple logic or calling existing hooks (even multiple) does not need to be extracted into a separate composable.\n- **Templates**: Cleanest possible HTML. No function calls, calculations, or inline styles. If complex logic is needed, split into sub-components.\n- **Props**: One-way data flow. Never mutate incoming props.\n- **Events**: Event names must be strictly in kebab-case.\n- **A11y**: Use semantic HTML and ARIA attributes.\n- **Atomicity**: Components should be minimal and perform only one function. Avoid universal \"Swiss army knife\" components.\n- **UI Styles**: Modifying the styles of ready-made UI components in the library is strictly forbidden. This is a taboo.\n- **Purity**: Write declaratively, avoid \"fluff,\" and save tokens.\n", qe = "### Global Development Principles (AI Code Promise)\n\nStrictly follow these rules for flawless dxt-ui code:\n\n0. **Mandatory Deep Study (CHRONOLOGICAL GUARD)**:\n   - **Step 1**: Read/create local `ai-memory.md` strictly in the current package root (e.g., `packages/constructor/`). Using repository root `ai-memory.md` for package files is FORBIDDEN.\n   - **Step 2**: Read root `ai-prompt.md` and study descriptions of all mentioned libraries.\n   - **Step 3**: Study linked `ai-types.md` and `ai-developer.md` BEFORE proposing plans, inspecting directory structures, or writing code, ONLY if you think that library may be relevant/useful for the current task. If a package is in `node_modules/` but exists locally (e.g., `packages/`), resolve and study the local source instead.\n   - Fully read source file contents before modifying them (superficial scans without reading context are forbidden when modifying existing code). Always check existing infrastructure before writing custom logic.\n\n1. **\"Copy-Paste Ready\"**: Generate complete, runnable files with correct imports. No placeholders (e.g., `// rest of code`).\n2. **Zero Hallucinations**: Strictly use `package.json` dependencies. No invented APIs. Ask if unsure.\n3. **Uncompromising TS**: No `any` (use `unknown` or generics). Interfaces for all I/O. `as const`, `readonly`, enums. Use `@ts-expect-error` with comments, never `@ts-ignore`.\n4. **Professional Documentation (TSDoc)**: Document all exported entities (purpose, params, returns). Use [wikiLanguage] by default unless the project defines its own documentation standard. Include examples for complex logic.\n5. **Architectural Consistency**: Respect project structure. Reuse existing infrastructure (always re-study this file before writing custom code). Do not modify global/base UI styles unless explicitly requested.\n6. **Strict Adherence & Optimization (STRICT PROHIBITION OF UNSOLICITED ACTIONS)**: Do STRICTLY and ONLY what is requested in the prompt. Making unsolicited changes, arbitrary refactoring, or modifying unrelated files without explicit instructions is STRICTLY FORBIDDEN. Follow instructions precisely without guessing, proposing technical optimizations only within the approved scope.\n7. **AI Workspace Memory (`ai-memory.md`)**: Apply its rules with highest priority. Update local `ai-memory.md` **ONLY** upon explicit command (e.g., \"remember\") or confirmed architectural rules. When adding rules, only resolve duplicates and direct conflicts — existing rules **MUST NOT be modified, condensed, or deleted**. Changelogs and absolute paths are forbidden (relative only). Store strictly key architectural constraints.\n8. **Package Type Reference (`ai-types.md`)**:\n    - **Purpose & Content**: An AI-optimized complete technical reference of a package containing all public TypeScript declarations (classes, methods, functions, types, interfaces, enums, constants) with concise JSDoc and search tags (`@keywords`).\n    - **How to Work (Search Before Full Scan)**: Due to the large size of `ai-types.md` files (thousands of lines), do **NOT** read or scan the entire file line-by-line upfront. **First, use text search** (by keywords, `@keywords`, function/class names) to locate required helpers, types, and signatures quickly to save context tokens. Reading the entire file is only needed when performing deep architectural analysis of the whole package.\n    - **Code Reuse**: Before writing custom utility logic or types, ALWAYS check `ai-types.md` of relevant packages to discover and reuse existing infrastructure, classes, and helper functions (DRY).\n9. **Build & Test Execution Guard**: Do **NOT** run project builds (`npm run build`, `storybook build`, etc.) or test suites (`npm run test`, `vitest`, etc.) proactively during code authoring or intermediate steps until the developer explicitly confirms that work is completed, asks to run tests/verification, or when entering dedicated debugging and fix mode.\n\n", Je = [C], Ye = class {
+	isMcp;
+	dirs;
+	exFileOnDirs = /^.+\.[^.]{2,4}$/;
+	exNotRead = /^\./;
+	constructor(e = [], t = !1) {
+		this.isMcp = t, this.dirs = [...Je, ...e];
+	}
+	make() {
+		console.log("Generating AI prompt...");
+		let e = this.getList(), t = [
+			"# System Role: AI Coding Assistant & Project Analyzer\nConsolidated documentation, architectural guidelines, and mandatory rules for the project.",
+			this.getGlobalPrompt(),
+			this.getVuePrompt()
+		], n = [];
+		e.length > 0 && e.forEach((e) => {
+			let r = e.make();
+			if (r && t.push(r), this.isMcp) {
+				let t = e.getMcp();
+				t && n.push(...t);
+			}
+		});
+		let r = this.getInstruction();
+		r && t.push(r), t.push(this.getAuditPrompt()), this.write(t), this.isMcp && (this.writeMcp(n), new We().make()), console.log("end");
+	}
+	isFileOnDirs(e) {
+		return e.some((e) => this.exFileOnDirs.test(e));
+	}
+	getAuditPrompt() {
+		return "## Mandatory Final Self-Audit (CRITICAL GUARD & STRICT COMPLIANCE)\n\n🔴 **STOP! BEFORE DECLARING WORK COMPLETE OR ENDING YOUR TURN, YOU MUST AUDIT ALL CODE!** 🔴\n\n1. **Mandatory Full Re-Study**: Inspect EVERY single line of code created or modified in this task.\n2. **Rule-by-Rule Compliance Check**: Cross-reference all code changes against ALL architectural conventions, coding standards, JSDoc/TSDoc guidelines, and package rules defined in `ai-prompt.md`.\n3. **Zero Ignored Rules**: Ensure NO project rule, typing constraint, or code structure guideline was bypassed, forgotten, or ignored.\n4. **Self-Correction**: If any discrepancy, missing typing, bad JSDoc formatting, or rule violation is found during this audit, fix it IMMEDIATELY before concluding your turn.";
+	}
+	getInstruction() {
+		if (u.is("ai-instruction.md")) return `
+## High-Priority Directives (Overrides Base Rules)
+${u.readFileOnly(ae)}
+      `.trim();
+	}
+	getVuePrompt() {
+		return `
+## Vue Component Implementation Rules
+${Ke}
+    `.trim();
+	}
+	getGlobalPrompt() {
+		return `
+## Global Code Implementation Rules
+${qe}
+    `.trim();
+	}
+	getList(e = this.dirs, t = [], n = d.getPromptScanDepth()) {
+		if (n <= 0) return [];
+		let r = [];
+		if (t.length === 0) {
+			let e = this.getRootItem();
+			e && r.push(e);
+		}
+		for (let i of e) {
+			if (this.exNotRead.test(i)) continue;
+			let e = [...t, i], a = u.readDir(e);
+			if (!this.isFileOnDirs(a) || i === "node_modules") r.push(...this.getList(a, e, n - 1));
+			else {
+				let t = new $(e);
+				t.isPrompt() && r.push(t);
+			}
+		}
+		return r;
+	}
+	getRootItem() {
+		let e = new $([]);
+		if (e.isPrompt()) return e;
+	}
+	write(e) {
+		return u.writeByPath(b, e.join("\n\n---\n\n")), this;
+	}
+	writeMcp(e) {
+		return u.writeByPath(g, e), this;
+	}
+}, Xe = class {
+	make() {
+		console.log("Library export"), u.writeByPath(ee, `${this.initFile().trim()}\r\n`), console.log("\r\nfinish");
+	}
+	getPath(e) {
+		return ["src", e];
+	}
+	isExport(e) {
+		return !u.joinPath(e).match(".test.") && !this.getFile(e).match(se);
+	}
+	getDirectory() {
+		let e = [];
+		return te.forEach((t) => {
+			let n = this.getPath(t), r = u.readDirRecursiveWithIndex(n);
+			r.length > 0 && e.push({
+				name: t,
+				path: n,
+				files: r
+			});
+		}), e;
+	}
+	getName(e) {
+		return e.replace(/^[a-z]/, (e) => e.toUpperCase());
+	}
+	getFile(e) {
+		return u.readFile(e) ?? "";
+	}
+	initFile() {
+		let e = this.getDirectory(), t = [this.initStyles()], n = [];
+		return e.forEach((e) => {
+			let r = e.name;
+			n.push(""), n.push(`// ${this.getName(r)}`), console.log(r), e.files.forEach((i) => {
+				if (this.isExport([...e.path, i])) {
+					if (console.log(`  ${i}`), i.match(/\.ts$/)) n.push(`export * from './${r}/${i.replace(/\.ts$/, "")}'`);
+					else if (i.match(/\.vue$/)) {
+						let e = i.replace(/\.vue$/, "").replace(/^(.*?)([^/]+)$/, "$2");
+						t.push(`import _${e} from './${r}/${i}'`), n.push(`export const ${e} = _${e}`);
+					}
+				}
+			});
+		}), t.join("\r\n").trim() + "\r\n\r\n" + n.join("\r\n").trim();
+	}
+	initStyles() {
+		let e = [];
+		return ["style.scss", "style.css"].forEach((t) => {
+			let n = ["src", t];
+			u.is(n) && e.push(`import './${t}'`);
+		}), e.join("\r\n") + "\r\n";
+	}
+};
+//#endregion
+export { l as AiAbstract, s as AiClaude, L as AiClaudeAgent, I as AiClaudeAgentLite, B as AiClaudeCli, z as AiClaudeCliLite, t as AiClaudeLite, e as AiGoogle, H as AiGoogleCli, V as AiGoogleCliLite, a as AiGoogleLite, o as AiOpenAi, n as AiOpenAiLite, c as AiZAi, i as AiZAiLite, R as ApiTmp, W as BrowserItem, Oe as BuildPackages, Ae as BuildPublishPackages, je as DesignScreenshot, Ve as DesignTypes, Y as DesignTypesAi, Z as DesignTypesBuild, X as DesignTypesBuildAbstract, Ne as DesignTypesDescription, Le as DesignTypesMake, Pe as DesignTypesMakeAbstract, Fe as DesignTypesMakeFile, Ie as DesignTypesMakeTsTransformer, Re as DesignTypesMcp, Be as DesignTypesPrompts, Q as DesignTypesPromptsAbstract, pe as FIGMA_API_URL, fe as FigmaApiEndpoint, Ue as GitRead, He as GitStatus, We as LibraryAiMcp, Ge as LibraryAiMcpItem, Ye as LibraryAiPrompt, $ as LibraryAiPromptItem, Xe as LibraryExport, G as PackageFile, ce as PackageInit, u as PropertiesFile, de as PropertyCategory, le as PropertyKey, ue as PropertyType, xe as SCREENSHOT_ARGS, Se as SCREENSHOT_FORMAT, Ce as SCREENSHOT_HEIGHTS, we as SCREENSHOT_QUALITY, Te as SCREENSHOT_TIMEOUT, U as SCREENSHOT_WAIT_UNTIL, Ee as SCREENSHOT_WIDTHS, w as getPackageJson, K as run, J as useAi };