@tailor-platform/erp-kit 0.4.1 → 0.5.1

package/dist/cli.mjs

@@ -9,9 +9,22 @@ import { execFile, execSync } from "node:child_process";
 import fg from "fast-glob";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { toString } from "mdast-util-to-string";
+import { createHash } from "node:crypto";
 import { createServer, request } from "node:http";
 import { createServer as createServer$1 } from "node:net";
 import { readFile, readdir, stat } from "node:fs/promises";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
 //#region src/util.ts
 const PACKAGE_ROOT = path.resolve(import.meta.dirname, "..");
 function readErpKitVersion() {
@@ -98,6 +111,15 @@ function copyConfigs(cwd) {
 		removed: 0
 	};
 }
+function createSymlink(target, linkPath) {
+	const type = process.platform === "win32" ? "junction" : void 0;
+	const resolvedTarget = type === "junction" ? path.resolve(path.dirname(linkPath), target) : target;
+	fs.symlinkSync(resolvedTarget, linkPath, type);
+}
+function copySkillsDirectory(src, dest) {
+	if (!fs.existsSync(src)) return;
+	fs.cpSync(src, dest, { recursive: true });
+}
 function setupSymlink(cwd) {
 	const skillsDest = path.join(cwd, ".agents", "skills");
 	const claudeSkills = path.join(cwd, ".claude", "skills");
@@ -111,14 +133,44 @@ function setupSymlink(cwd) {
 		if (fs.lstatSync(claudeSkills).isSymbolicLink()) {
 			if (fs.readlinkSync(claudeSkills) === relTarget) return "already_linked";
 			fs.unlinkSync(claudeSkills);
-			fs.symlinkSync(relTarget, claudeSkills);
-			return "linked";
+			try {
+				createSymlink(relTarget, claudeSkills);
+				return "linked";
+			} catch {
+				copySkillsDirectory(skillsDest, claudeSkills);
+				return "copied";
+			}
 		}
 		return "skipped_directory";
 	}
 	fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
-	fs.symlinkSync(relTarget, claudeSkills);
-	return "linked";
+	try {
+		createSymlink(relTarget, claudeSkills);
+		return "linked";
+	} catch {
+		copySkillsDirectory(skillsDest, claudeSkills);
+		return "copied";
+	}
+}
+/**
+* When .claude/skills is a real directory (copy fallback on Windows),
+* re-sync it with .agents/skills after an update.
+*/
+function refreshCopiedSkills(cwd) {
+	const claudeSkills = path.join(cwd, ".claude", "skills");
+	try {
+		const stat = fs.lstatSync(claudeSkills);
+		if (stat.isSymbolicLink() || !stat.isDirectory()) return false;
+	} catch {
+		return false;
+	}
+	const skillsDest = path.join(cwd, ".agents", "skills");
+	fs.rmSync(claudeSkills, {
+		recursive: true,
+		force: true
+	});
+	copySkillsDirectory(skillsDest, claudeSkills);
+	return true;
 }
 function isAlreadyInitialized(cwd) {
 	const skillsDest = path.join(cwd, ".agents", "skills");
@@ -137,6 +189,7 @@ function runInit(cwd) {
 	console.log(chalk.green(`  Copied ${skills.copied} skill files to .agents/skills/`));
 	const symlink = setupSymlink(cwd);
 	if (symlink === "linked") console.log(chalk.green("  .claude/skills -> .agents/skills/ (linked)"));
+	else if (symlink === "copied") console.log(chalk.yellow("  .claude/skills (copied — re-run `erp-kit update skills` after changes)"));
 	else if (symlink === "skipped_directory") console.log(chalk.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
 	const workflows = copyWorkflows(cwd);
 	if (workflows.copied > 0) console.log(chalk.green(`  Copied ${workflows.copied} workflow(s) to .github/workflows/`));
@@ -159,6 +212,7 @@ function runUpdate(cwd, resources) {
 		const result = copySkills(cwd);
 		if (result.removed > 0) console.log(chalk.green(`  Removed ${result.removed} stale erp-kit-* skills`));
 		console.log(chalk.green(`  Copied ${result.copied} skill files to .agents/skills/`));
+		if (refreshCopiedSkills(cwd)) console.log(chalk.green(`  Refreshed .claude/skills/ (copy)`));
 	}
 	if (selected.has("workflows")) {
 		const result = copyWorkflows(cwd);
@@ -310,12 +364,35 @@ function runLicenseCheck(configPath) {
 //#endregion
 //#region src/mdschema.ts
 const require = createRequire(import.meta.url);
+const PLATFORMS = {
+	darwin: {
+		arm64: "@jackchuka/mdschema-darwin-arm64",
+		x64: "@jackchuka/mdschema-darwin-x64"
+	},
+	linux: {
+		arm64: "@jackchuka/mdschema-linux-arm64",
+		x64: "@jackchuka/mdschema-linux-x64"
+	},
+	win32: {
+		arm64: "@jackchuka/mdschema-windows-arm64",
+		x64: "@jackchuka/mdschema-windows-x64"
+	}
+};
 function getMdschemaBin() {
 	const pkgPath = require.resolve("@jackchuka/mdschema/package.json");
-	const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-	const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.mdschema;
+	const pkgDir = path.dirname(pkgPath);
+	const mdschemaRequire = createRequire(pkgPath);
+	const ext = process.platform === "win32" ? ".exe" : "";
+	const pkg = PLATFORMS[process.platform]?.[process.arch];
+	if (pkg) try {
+		return mdschemaRequire.resolve(`${pkg}/bin/mdschema${ext}`);
+	} catch {}
+	const localBin = path.join(pkgDir, "bin", `mdschema${ext}`);
+	if (fs.existsSync(localBin)) return localBin;
+	const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+	const bin = typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.mdschema;
 	if (!bin) throw new Error("Could not resolve mdschema binary from package.json bin field");
-	return path.join(path.dirname(pkgPath), bin);
+	return path.join(pkgDir, bin);
 }
 function runMdschema(args, cwd) {
 	return new Promise((resolve) => {
@@ -350,12 +427,12 @@ const MODULE_SCHEMAS = {
 	query: path.join(SCHEMAS_ROOT, "module", "query.yml")
 };
 const APP_COMPOSE_SCHEMAS = {
-	app: path.join(SCHEMAS_ROOT, "app-compose", "requirements.yml"),
-	actors: path.join(SCHEMAS_ROOT, "app-compose", "actors.yml"),
-	"business-flow": path.join(SCHEMAS_ROOT, "app-compose", "business-flow.yml"),
-	story: path.join(SCHEMAS_ROOT, "app-compose", "story.yml"),
-	screen: path.join(SCHEMAS_ROOT, "app-compose", "screen.yml"),
-	resolver: path.join(SCHEMAS_ROOT, "app-compose", "resolver.yml")
+	app: path.join(SCHEMAS_ROOT, "app", "requirements.yml"),
+	actors: path.join(SCHEMAS_ROOT, "app", "actors.yml"),
+	"business-flow": path.join(SCHEMAS_ROOT, "app", "business-flow.yml"),
+	story: path.join(SCHEMAS_ROOT, "app", "story.yml"),
+	screen: path.join(SCHEMAS_ROOT, "app", "screen.yml"),
+	resolver: path.join(SCHEMAS_ROOT, "app", "resolver.yml")
 };
 const ALL_SCHEMAS = {
 	...MODULE_SCHEMAS,
@@ -498,10 +575,6 @@ async function runCheck(config, cwd) {
 //#region src/commands/init-module.ts
 function runInitModule(name, dir) {
 	const moduleDir = path.resolve(dir, name);
-	if (fs.existsSync(moduleDir)) {
-		console.error(`Directory already exists: ${moduleDir}`);
-		return 1;
-	}
 	fs.mkdirSync(moduleDir, { recursive: true });
 	return 0;
 }
@@ -524,10 +597,6 @@ async function runInitModuleWithReadme(name, dir, cwd) {
 }
 function runInitApp(name, dir) {
 	const appDir = path.resolve(dir, name);
-	if (fs.existsSync(appDir)) {
-		console.error(`Directory already exists: ${appDir}`);
-		return 1;
-	}
 	fs.mkdirSync(appDir, { recursive: true });
 	return 0;
 }
@@ -1075,7 +1144,16 @@ function copyTemplateDir(srcDir, destDir, replacements, placeholderFiles) {
 	}
 }
 function scaffoldModuleBoilerplate(moduleDir, moduleName) {
-	copyTemplateDir(path.join(PACKAGE_ROOT, "templates", "scaffold", "module"), moduleDir, { "template-module": moduleName }, new Set(["permissions.ts", "tailor.config.ts"]));
+	const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "module");
+	const erpKitVersion = readErpKitVersion();
+	copyTemplateDir(templateDir, moduleDir, {
+		"template-module": moduleName,
+		"\"workspace:*\"": `"${erpKitVersion}"`
+	}, new Set([
+		"package.json",
+		"permissions.ts",
+		"tailor.config.ts"
+	]));
 }
 function scaffoldAppBoilerplate(appDir, appName) {
 	const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "app");
@@ -1496,11 +1574,396 @@ function runGenerateAppCode(appPath) {
 	return 0;
 }
 //#endregion
+//#region src/shared/uuidv5.ts
+/**
+* Generates a deterministic UUID v5 from a namespace and name.
+* Uses SHA-1 hashing per RFC 4122 §4.3.
+*/
+function uuidv5(namespace, name) {
+	const hash = createHash("sha1").update(namespace).update(name).digest();
+	hash[6] = hash[6] & 15 | 80;
+	hash[8] = hash[8] & 63 | 128;
+	const hex = hash.toString("hex");
+	return [
+		hex.slice(0, 8),
+		hex.slice(8, 12),
+		hex.slice(12, 16),
+		hex.slice(16, 20),
+		hex.slice(20, 32)
+	].join("-");
+}
+//#endregion
+//#region src/modules/primitives/seed/uomCategories.ts
+const NS$3 = "erp-kit:primitives";
+const uomCategoryIds = {
+	Weight: uuidv5(NS$3, "uom-category:Weight"),
+	Length: uuidv5(NS$3, "uom-category:Length"),
+	Volume: uuidv5(NS$3, "uom-category:Volume"),
+	Area: uuidv5(NS$3, "uom-category:Area"),
+	Time: uuidv5(NS$3, "uom-category:Time"),
+	Quantity: uuidv5(NS$3, "uom-category:Quantity")
+};
+const uomCategories = {
+	[uomCategoryIds.Weight]: {
+		name: "Weight",
+		description: "Mass and weight measurement",
+		isActive: true
+	},
+	[uomCategoryIds.Length]: {
+		name: "Length",
+		description: "Length and distance measurement",
+		isActive: true
+	},
+	[uomCategoryIds.Volume]: {
+		name: "Volume",
+		description: "Volume and capacity measurement",
+		isActive: true
+	},
+	[uomCategoryIds.Area]: {
+		name: "Area",
+		description: "Surface area measurement",
+		isActive: true
+	},
+	[uomCategoryIds.Time]: {
+		name: "Time",
+		description: "Time duration measurement",
+		isActive: true
+	},
+	[uomCategoryIds.Quantity]: {
+		name: "Quantity",
+		description: "Discrete count measurement",
+		isActive: true
+	}
+};
+//#endregion
+//#region src/modules/primitives/seed/units.ts
+const NS$2 = "erp-kit:primitives";
+const unitIds = {
+	kg: uuidv5(NS$2, "unit:kg"),
+	g: uuidv5(NS$2, "unit:g"),
+	lb: uuidv5(NS$2, "unit:lb"),
+	oz: uuidv5(NS$2, "unit:oz"),
+	m: uuidv5(NS$2, "unit:m"),
+	cm: uuidv5(NS$2, "unit:cm"),
+	ft: uuidv5(NS$2, "unit:ft"),
+	in: uuidv5(NS$2, "unit:in"),
+	L: uuidv5(NS$2, "unit:L"),
+	mL: uuidv5(NS$2, "unit:mL"),
+	gal: uuidv5(NS$2, "unit:gal"),
+	sqm: uuidv5(NS$2, "unit:sqm"),
+	sqft: uuidv5(NS$2, "unit:sqft"),
+	hr: uuidv5(NS$2, "unit:hr"),
+	min: uuidv5(NS$2, "unit:min"),
+	s: uuidv5(NS$2, "unit:s"),
+	ea: uuidv5(NS$2, "unit:ea"),
+	dz: uuidv5(NS$2, "unit:dz"),
+	pk: uuidv5(NS$2, "unit:pk")
+};
+const units = {
+	[unitIds.kg]: {
+		name: "Kilogram",
+		symbol: "kg",
+		categoryId: uomCategoryIds.Weight,
+		conversionFactor: 1,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.g]: {
+		name: "Gram",
+		symbol: "g",
+		categoryId: uomCategoryIds.Weight,
+		conversionFactor: .001,
+		roundingPrecision: 0,
+		isActive: true
+	},
+	[unitIds.lb]: {
+		name: "Pound",
+		symbol: "lb",
+		categoryId: uomCategoryIds.Weight,
+		conversionFactor: .453592,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.oz]: {
+		name: "Ounce",
+		symbol: "oz",
+		categoryId: uomCategoryIds.Weight,
+		conversionFactor: .0283495,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.m]: {
+		name: "Meter",
+		symbol: "m",
+		categoryId: uomCategoryIds.Length,
+		conversionFactor: 1,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.cm]: {
+		name: "Centimeter",
+		symbol: "cm",
+		categoryId: uomCategoryIds.Length,
+		conversionFactor: .01,
+		roundingPrecision: 0,
+		isActive: true
+	},
+	[unitIds.ft]: {
+		name: "Foot",
+		symbol: "ft",
+		categoryId: uomCategoryIds.Length,
+		conversionFactor: .3048,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.in]: {
+		name: "Inch",
+		symbol: "in",
+		categoryId: uomCategoryIds.Length,
+		conversionFactor: .0254,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.L]: {
+		name: "Liter",
+		symbol: "L",
+		categoryId: uomCategoryIds.Volume,
+		conversionFactor: 1,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.mL]: {
+		name: "Milliliter",
+		symbol: "mL",
+		categoryId: uomCategoryIds.Volume,
+		conversionFactor: .001,
+		roundingPrecision: 0,
+		isActive: true
+	},
+	[unitIds.gal]: {
+		name: "Gallon",
+		symbol: "gal",
+		categoryId: uomCategoryIds.Volume,
+		conversionFactor: 3.78541,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.sqm]: {
+		name: "Square Meter",
+		symbol: "m²",
+		categoryId: uomCategoryIds.Area,
+		conversionFactor: 1,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.sqft]: {
+		name: "Square Foot",
+		symbol: "ft²",
+		categoryId: uomCategoryIds.Area,
+		conversionFactor: .092903,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.hr]: {
+		name: "Hour",
+		symbol: "hr",
+		categoryId: uomCategoryIds.Time,
+		conversionFactor: 1,
+		roundingPrecision: 2,
+		isActive: true
+	},
+	[unitIds.min]: {
+		name: "Minute",
+		symbol: "min",
+		categoryId: uomCategoryIds.Time,
+		conversionFactor: 1 / 60,
+		roundingPrecision: 0,
+		isActive: true
+	},
+	[unitIds.s]: {
+		name: "Second",
+		symbol: "s",
+		categoryId: uomCategoryIds.Time,
+		conversionFactor: 1 / 3600,
+		roundingPrecision: 0,
+		isActive: true
+	},
+	[unitIds.ea]: {
+		name: "Each",
+		symbol: "ea",
+		categoryId: uomCategoryIds.Quantity,
+		conversionFactor: 1,
+		roundingPrecision: 0,
+		isActive: true
+	},
+	[unitIds.dz]: {
+		name: "Dozen",
+		symbol: "dz",
+		categoryId: uomCategoryIds.Quantity,
+		conversionFactor: 12,
+		roundingPrecision: 0,
+		isActive: true
+	},
+	[unitIds.pk]: {
+		name: "Pack",
+		symbol: "pk",
+		categoryId: uomCategoryIds.Quantity,
+		conversionFactor: 1,
+		roundingPrecision: 0,
+		isActive: true
+	}
+};
+//#endregion
+//#region src/modules/primitives/seed/currencies.ts
+const NS$1 = "erp-kit:primitives";
+const currencyIds = {
+	USD: uuidv5(NS$1, "currency:USD"),
+	EUR: uuidv5(NS$1, "currency:EUR"),
+	GBP: uuidv5(NS$1, "currency:GBP"),
+	JPY: uuidv5(NS$1, "currency:JPY"),
+	CNY: uuidv5(NS$1, "currency:CNY")
+};
+const currencies = {
+	[currencyIds.USD]: {
+		code: "USD",
+		name: "US Dollar",
+		symbol: "$",
+		decimalPlaces: 2,
+		isBaseCurrency: true,
+		isActive: true
+	},
+	[currencyIds.EUR]: {
+		code: "EUR",
+		name: "Euro",
+		symbol: "€",
+		decimalPlaces: 2,
+		isBaseCurrency: false,
+		isActive: true
+	},
+	[currencyIds.GBP]: {
+		code: "GBP",
+		name: "British Pound",
+		symbol: "£",
+		decimalPlaces: 2,
+		isBaseCurrency: false,
+		isActive: true
+	},
+	[currencyIds.JPY]: {
+		code: "JPY",
+		name: "Japanese Yen",
+		symbol: "¥",
+		decimalPlaces: 0,
+		isBaseCurrency: false,
+		isActive: true
+	},
+	[currencyIds.CNY]: {
+		code: "CNY",
+		name: "Chinese Yuan",
+		symbol: "¥",
+		decimalPlaces: 2,
+		isBaseCurrency: false,
+		isActive: true
+	}
+};
+//#endregion
+//#region src/modules/primitives/seed/exchangeRates.ts
+const NS = "erp-kit:primitives";
+const exchangeRateIds = {
+	"USD-EUR": uuidv5(NS, "rate:USD-EUR"),
+	"USD-GBP": uuidv5(NS, "rate:USD-GBP"),
+	"USD-JPY": uuidv5(NS, "rate:USD-JPY"),
+	"USD-CNY": uuidv5(NS, "rate:USD-CNY")
+};
+const exchangeRates = {
+	[exchangeRateIds["USD-EUR"]]: {
+		sourceCurrencyId: currencyIds.USD,
+		targetCurrencyId: currencyIds.EUR,
+		rate: .92,
+		effectiveDate: /* @__PURE__ */ new Date("2025-01-01")
+	},
+	[exchangeRateIds["USD-GBP"]]: {
+		sourceCurrencyId: currencyIds.USD,
+		targetCurrencyId: currencyIds.GBP,
+		rate: .79,
+		effectiveDate: /* @__PURE__ */ new Date("2025-01-01")
+	},
+	[exchangeRateIds["USD-JPY"]]: {
+		sourceCurrencyId: currencyIds.USD,
+		targetCurrencyId: currencyIds.JPY,
+		rate: 148.5,
+		effectiveDate: /* @__PURE__ */ new Date("2025-01-01")
+	},
+	[exchangeRateIds["USD-CNY"]]: {
+		sourceCurrencyId: currencyIds.USD,
+		targetCurrencyId: currencyIds.CNY,
+		rate: 7.24,
+		effectiveDate: /* @__PURE__ */ new Date("2025-01-01")
+	}
+};
+//#endregion
+//#region src/generator/generate-seed.ts
+const INTERNAL_SEED = { primitives: /* @__PURE__ */ __exportAll({
+	Currency: () => currencies,
+	ExchangeRate: () => exchangeRates,
+	Unit: () => units,
+	UoMCategory: () => uomCategories,
+	currencyIds: () => currencyIds,
+	unitIds: () => unitIds,
+	uomCategoryIds: () => uomCategoryIds
+}) };
+function mapToJsonl(data) {
+	return Object.entries(data).map(([id, row]) => JSON.stringify({
+		id,
+		...row
+	})).join("\n") + "\n";
+}
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/**
+* Checks if a value is a seed data map: Record<string, Record<string, unknown>>.
+* Distinguishes from ID maps (Record<string, string>) by checking nested values.
+*/
+function isSeedMap(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const entries = Object.entries(value);
+	if (entries.length === 0) return false;
+	return entries.every(([, v]) => typeof v === "object" && v !== null && !Array.isArray(v));
+}
+function runGenerateSeed(appPath) {
+	const seedDir = path.join(appPath, "backend", "seed", "data");
+	fs.mkdirSync(seedDir, { recursive: true });
+	let written = 0;
+	let skipped = 0;
+	const modulesWithSeed = [];
+	for (const [moduleName, mod] of Object.entries(INTERNAL_SEED)) {
+		const entries = Object.entries(mod).filter(([, v]) => isSeedMap(v));
+		if (entries.length === 0) continue;
+		modulesWithSeed.push(moduleName);
+		for (const [exportName, data] of entries) {
+			const fileName = capitalize(exportName);
+			const filePath = path.join(seedDir, `${fileName}.jsonl`);
+			if (fs.existsSync(filePath)) {
+				console.log(`  skipped ${fileName}.jsonl (already exists)`);
+				skipped++;
+				continue;
+			}
+			const rowCount = Object.keys(data).length;
+			fs.writeFileSync(filePath, mapToJsonl(data));
+			console.log(`  wrote ${fileName}.jsonl (${rowCount} rows)`);
+			written++;
+		}
+	}
+	console.log(`\nModules with seed data: ${modulesWithSeed.join(", ") || "none"}`);
+	console.log(`Generated ${written} file(s), skipped ${skipped} existing`);
+	return 0;
+}
+//#endregion
 //#region src/commands/app/index.ts
 const cwd$1 = process.cwd();
 const pathArgs = z.object({ path: arg(z.string(), {
 	alias: "p",
-	description: "Path to app-compose directory"
+	description: "Path to app directory"
 }) });
 const checkCommand = defineCommand({
 	name: "check",
@@ -1547,7 +2010,7 @@ const initCommand$1 = defineCommand({
 });
 const generateCommand = defineCommand({
 	name: "generate",
-	description: "Generate docs and code for an app",
+	description: "Generate docs, code, and seed data for an app",
 	subCommands: {
 		doc: defineCommand({
 			name: "doc",
@@ -1579,12 +2042,23 @@ const generateCommand = defineCommand({
 					return exitCode === 0 ? success() : silentFailure(exitCode);
 				});
 			}
+		}),
+		seed: defineCommand({
+			name: "seed",
+			description: "Generate seed data from module defaults",
+			args: pathArgs,
+			run: (args) => {
+				return executeCommand(() => {
+					const exitCode = runGenerateSeed(path.resolve(cwd$1, args.path));
+					return exitCode === 0 ? success() : silentFailure(exitCode);
+				});
+			}
 		})
 	}
 });
 const appCommand = defineCommand({
 	name: "app",
-	description: "App-compose management",
+	description: "App management",
 	subCommands: {
 		check: checkCommand,
 		"sync-check": syncCheckCommand,
@@ -1904,7 +2378,6 @@ const mockCommand = defineCommand({
 //#endregion
 //#region src/commands/doc/modules.ts
 const MODULES_DIR$2 = join(PACKAGE_ROOT, "src", "modules");
-const EXCLUDED_DIRS$2 = new Set(["shared", "testing"]);
 function countDocs(dir) {
 	if (!existsSync(dir)) return 0;
 	return readdirSync(dir).filter((f) => f.endsWith(".md")).length;
@@ -1931,7 +2404,7 @@ function extractDependencies(readmePath) {
 }
 function getModuleOverviews() {
 	if (!existsSync(MODULES_DIR$2)) return [];
-	return readdirSync(MODULES_DIR$2, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DIRS$2.has(d.name)).map((d) => {
+	return readdirSync(MODULES_DIR$2, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
 		const modDir = join(MODULES_DIR$2, d.name);
 		const readmePath = join(modDir, "README.md");
 		return {
@@ -1971,7 +2444,6 @@ function runDocModules(format = "text") {
 //#endregion
 //#region src/commands/doc/module.ts
 const MODULES_DIR$1 = join(PACKAGE_ROOT, "src", "modules");
-const EXCLUDED_DIRS$1 = new Set(["shared", "testing"]);
 const DOC_TYPE_MAP$1 = {
 	command: MODULE_PATHS.docs.commands,
 	query: MODULE_PATHS.docs.queries,
@@ -1987,14 +2459,14 @@ function formatDocList(type, names) {
 	return `${type}: ${names.join(", ")}`;
 }
 function runDocModule(moduleName, docType, docName, format = "text") {
-	if (!existsSync(MODULES_DIR$1) || EXCLUDED_DIRS$1.has(moduleName)) {
+	if (!existsSync(MODULES_DIR$1)) {
 		console.error(`Module not found: ${moduleName}`);
 		return 1;
 	}
 	const modDir = join(MODULES_DIR$1, moduleName);
 	if (!existsSync(modDir)) {
 		console.error(`Module not found: ${moduleName}`);
-		const available = readdirSync(MODULES_DIR$1, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DIRS$1.has(d.name)).map((d) => d.name).sort();
+		const available = readdirSync(MODULES_DIR$1, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
 		console.error(`Available modules: ${available.join(", ")}`);
 		return 1;
 	}
@@ -2050,7 +2522,6 @@ function runDocModule(moduleName, docType, docName, format = "text") {
 //#endregion
 //#region src/commands/doc/search.ts
 const MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
-const EXCLUDED_DIRS = new Set(["shared", "testing"]);
 const DOC_TYPE_MAP = {
 	command: MODULE_PATHS.docs.commands,
 	query: MODULE_PATHS.docs.queries,
@@ -2075,7 +2546,7 @@ function searchFile(filePath, query, module, type, name) {
 function searchModuleDocs(query, typeFilter) {
 	if (!existsSync(MODULES_DIR)) return [];
 	const results = [];
-	const modules = readdirSync(MODULES_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name)).sort((a, b) => a.name.localeCompare(b.name));
+	const modules = readdirSync(MODULES_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
 	for (const mod of modules) {
 		const modDir = join(MODULES_DIR, mod.name);
 		if (!typeFilter || typeFilter === "readme") results.push(...searchFile(join(modDir, "README.md"), query, mod.name, "readme", "README"));