@zenbujs/core 0.0.1

package/dist/cli/bin.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+//#region src/cli/bin.ts
+const PUBLIC_SUBCOMMANDS = new Set([
+	"dev",
+	"build:source",
+	"build:electron",
+	"publish:source",
+	"link"
+]);
+const INTERNAL_SUBCOMMANDS = new Set(["monorepo", "db"]);
+function printUsage() {
+	console.log(`
+zen — Zenbu CLI
+
+Usage:
+  zen dev                                Run the local app in Electron with HMR
+  zen build:source                       Transform user TS into a portable seed
+                                         tree (default: .zenbu/build/seed)
+  zen build:electron [-- <eb args>]      Stage seed + bundled bun/pnpm + launcher,
+                                         then invoke electron-builder against
+                                         the project's electron-builder config.
+                                         Pass-through args after \`--\` go to
+                                         electron-builder (e.g. \`-- --publish always\`).
+  zen publish:source [init|push]         Push staged source to the mirror repo
+  zen link                               Regenerate registry types
+
+Hooks:
+  --config <zenbu.build.ts>   Override the build config path
+  --no-source                 Skip running build:source (use stale seed)
+`);
+}
+async function main() {
+	const argv = process.argv.slice(2);
+	const first = argv[0];
+	if (!first || first === "help" || first === "--help" || first === "-h") {
+		printUsage();
+		return;
+	}
+	if (!PUBLIC_SUBCOMMANDS.has(first) && !INTERNAL_SUBCOMMANDS.has(first)) {
+		console.error(`zen: unknown command "${first}"`);
+		console.error(`run \`zen --help\` to see available commands`);
+		process.exit(1);
+	}
+	const rest = argv.slice(1);
+	switch (first) {
+		case "dev": {
+			const { runDev } = await import("../dev-BuqklM0k.mjs");
+			await runDev(rest);
+			return;
+		}
+		case "build:source": {
+			const { runBuildSource } = await import("../build-source-_q1n1zTV.mjs");
+			await runBuildSource(rest);
+			return;
+		}
+		case "build:electron": {
+			const { runBuildElectron } = await import("../build-electron-B4Gd0Gi4.mjs");
+			await runBuildElectron(rest);
+			return;
+		}
+		case "publish:source": {
+			const { runPublishSource } = await import("../publish-source-BVgB62Zj.mjs");
+			await runPublishSource(rest);
+			return;
+		}
+		case "link": {
+			const { runLink } = await import("../link-6roQ7Cn6.mjs");
+			await runLink(rest);
+			return;
+		}
+		case "monorepo": {
+			const { runMonorepo } = await import("../monorepo-CmGPHsVm.mjs");
+			await runMonorepo(rest);
+			return;
+		}
+		case "db": {
+			const { runDb } = await import("../db-DhuAJrye.mjs");
+			await runDb(rest);
+			return;
+		}
+	}
+}
+main().catch((err) => {
+	console.error(err);
+	process.exit(1);
+});
+//#endregion
+export {};

package/dist/cli/build.d.mts

@@ -0,0 +1,53 @@
+//#region src/cli/lib/build-config.d.ts
+interface TransformInput {
+  path: string;
+  code: string;
+}
+interface TransformOutput {
+  code?: string;
+  drop?: boolean;
+}
+type Transform = (file: TransformInput) => TransformOutput | null | undefined | void;
+interface MirrorConfig {
+  target: string;
+  branch?: string;
+}
+interface BundleConfig {
+  seed?: boolean;
+  extraResources?: string[];
+}
+interface BuildConfig {
+  source?: string;
+  out?: string;
+  include: string[];
+  ignore?: string[];
+  transforms?: Transform[];
+  mirror?: MirrorConfig;
+  bundle?: BundleConfig;
+}
+declare function defineBuildConfig(config: BuildConfig): BuildConfig;
+type ResolvedBuildConfig = Required<Omit<BuildConfig, "mirror" | "bundle">> & {
+  mirror?: MirrorConfig;
+  bundle?: BundleConfig;
+};
+declare function resolveBuildConfig(config: BuildConfig): ResolvedBuildConfig;
+//#endregion
+//#region src/cli/lib/transforms.d.ts
+/**
+ * Marker-based feature-flag stripping. Removes lines between
+ *   // @zenbu:strip-if FLAG       (strip when FLAG is truthy)
+ *   // @zenbu:strip-if !FLAG      (strip when FLAG is falsy)
+ *   ...
+ *   // @zenbu:end
+ *
+ * Pure string/line ops — no AST, no compiler dep.
+ */
+declare function stripIfDisabled(flags: Record<string, boolean>): Transform;
+/**
+ * Drop files whose path matches the given pattern (relative path from the
+ * source root, posix slashes). Also covered by `ignore` globs in the config;
+ * use this when a regex is more convenient than a glob.
+ */
+declare function dropFiles(pattern: RegExp | ((path: string) => boolean)): Transform;
+//#endregion
+export { type BuildConfig, type BundleConfig, type MirrorConfig, type ResolvedBuildConfig, type Transform, type TransformInput, type TransformOutput, defineBuildConfig, dropFiles, resolveBuildConfig, stripIfDisabled };

package/dist/cli/build.mjs

@@ -0,0 +1,48 @@
+import { n as resolveBuildConfig, t as defineBuildConfig } from "../build-config-pbv0w4oN.mjs";
+//#region src/cli/lib/transforms.ts
+const STRIP_START = /^\s*\/\/\s*@zenbu:strip-if\s+(!?)([A-Za-z_][A-Za-z0-9_]*)\s*$/;
+const STRIP_END = /^\s*\/\/\s*@zenbu:end\s*$/;
+/**
+* Marker-based feature-flag stripping. Removes lines between
+*   // @zenbu:strip-if FLAG       (strip when FLAG is truthy)
+*   // @zenbu:strip-if !FLAG      (strip when FLAG is falsy)
+*   ...
+*   // @zenbu:end
+*
+* Pure string/line ops — no AST, no compiler dep.
+*/
+function stripIfDisabled(flags) {
+	return (file) => {
+		const lines = file.code.split("\n");
+		const out = [];
+		let stripDepth = 0;
+		for (const line of lines) {
+			const startMatch = STRIP_START.exec(line);
+			if (startMatch) {
+				const negated = startMatch[1] === "!";
+				const flagValue = flags[startMatch[2]] ?? false;
+				if ((negated ? !flagValue : flagValue) || stripDepth > 0) stripDepth += 1;
+				continue;
+			}
+			if (STRIP_END.test(line)) {
+				if (stripDepth > 0) stripDepth -= 1;
+				continue;
+			}
+			if (stripDepth === 0) out.push(line);
+		}
+		return { code: out.join("\n") };
+	};
+}
+/**
+* Drop files whose path matches the given pattern (relative path from the
+* source root, posix slashes). Also covered by `ignore` globs in the config;
+* use this when a regex is more convenient than a glob.
+*/
+function dropFiles(pattern) {
+	const test = typeof pattern === "function" ? pattern : (p) => pattern.test(p);
+	return (file) => {
+		if (test(file.path)) return { drop: true };
+	};
+}
+//#endregion
+export { defineBuildConfig, dropFiles, resolveBuildConfig, stripIfDisabled };