@aas-dev/stack 0.0.0-stage → 0.1.1

package/dist/plugin/aas.js

@@ -0,0 +1,379 @@
+// plugin/aas.mjs
+const markers = [
+	"@ts-ignore",
+	"@ts-expect-error",
+	"@ts-nocheck",
+	"eslint-disable",
+	"eslint-enable",
+	"oxlint-disable",
+	"oxlint-enable"
+];
+const errorNames = /* @__PURE__ */ new Set([
+	"Error",
+	"AggregateError",
+	"EvalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError"
+]);
+const rawSpecifiers = /* @__PURE__ */ new Set([
+	"child_process",
+	"fs",
+	"http",
+	"https",
+	"node:child_process",
+	"node:fs",
+	"node:fs/promises",
+	"node:http",
+	"node:https"
+]);
+const socketSpecifiers = /* @__PURE__ */ new Set([
+	"net",
+	"node:net",
+	"node:tls",
+	"tls"
+]);
+const consoleMethods = /* @__PURE__ */ new Set([
+	"debug",
+	"error",
+	"info",
+	"log",
+	"warn"
+]);
+const effectRunMethods = /* @__PURE__ */ new Set([
+	"runFork",
+	"runPromise",
+	"runPromiseExit",
+	"runSync"
+]);
+const bannedTestMembers = /* @__PURE__ */ new Set([
+	"only",
+	"skip",
+	"skipIf",
+	"todo"
+]);
+const testAliases = /* @__PURE__ */ new Set([
+	"fdescribe",
+	"fit",
+	"ftest",
+	"xdescribe",
+	"xit",
+	"xtest"
+]);
+const report = (context, node, message) => {
+	context.report({
+		node,
+		message
+	});
+};
+const literalName = (property, computed) => {
+	if (!computed && property.type === "Identifier") return property.name;
+	if (computed && (property.type === "Literal" || property.type === "StringLiteral") && typeof property.value === "string") return property.value;
+	return "";
+};
+const isProcessEnv = (node) => {
+	if (node.type !== "MemberExpression") return false;
+	return node.object.type === "Identifier" && node.object.name === "process" && literalName(node.property, node.computed) === "env";
+};
+const hasName = (node, name) => {
+	if (node === null || node === void 0 || typeof node !== "object") return false;
+	if (node.type === "Identifier" && node.name === name) return true;
+	return hasName(node.callee, name) || hasName(node.object, name) || hasName(node.property, name) || hasName(node.expression, name);
+};
+const blessedSuper = (node) => hasName(node, "TaggedError") || hasName(node, "Service");
+const specifier = (node) => {
+	if (node === null || node === void 0) return "";
+	if ((node.type === "Literal" || node.type === "StringLiteral") && typeof node.value === "string") return node.value;
+	return "";
+};
+const chainParts = (callee) => {
+	const parts = [];
+	let current = callee;
+	while (current.type === "MemberExpression" || current.type === "ChainExpression") {
+		if (current.type === "ChainExpression") {
+			current = current.expression;
+			continue;
+		}
+		if (current.computed || current.property.type !== "Identifier") return [];
+		parts.push(current.property.name);
+		current = current.object;
+	}
+	if (current.type !== "Identifier") return [];
+	parts.push(current.name);
+	parts.reverse();
+	return parts;
+};
+const isItEffect = (parts) => {
+	if (parts[0] !== "it" || parts[1] !== "effect") return false;
+	let index = 2;
+	while (index < parts.length) {
+		const part = parts[index];
+		if (part !== void 0 && bannedTestMembers.has(part)) return false;
+		index += 1;
+	}
+	return true;
+};
+const flagModuleBinding = (context, statement) => {
+	if (statement === null || statement === void 0) return;
+	if (statement.type === "VariableDeclaration" && statement.kind !== "const") report(context, statement, "module-scope let and var are banned; keep state in a Context.Service");
+	const binding = statement.init ?? statement.left;
+	if ((statement.type === "ForStatement" || statement.type === "ForInStatement" || statement.type === "ForOfStatement") && binding !== null && binding !== void 0 && binding.type === "VariableDeclaration" && binding.kind !== "const") report(context, binding, "module-scope let and var are banned; keep state in a Context.Service");
+};
+const noThrow = {
+	meta: { type: "problem" },
+	create(context) {
+		return { ThrowStatement(node) {
+			report(context, node, "throw is banned; yield a Schema.TaggedError");
+		} };
+	}
+};
+const noTry = {
+	meta: { type: "problem" },
+	create(context) {
+		return { TryStatement(node) {
+			report(context, node, "try is banned; failures stay on the Effect channel");
+		} };
+	}
+};
+const noErrorClass = {
+	meta: { type: "problem" },
+	create(context) {
+		return { NewExpression(node) {
+			const callee = node.callee;
+			const name = callee.type === "Identifier" ? callee.name : callee.type === "MemberExpression" ? literalName(callee.property, callee.computed) : "";
+			if (errorNames.has(name)) report(context, node, "new Error is banned; define a Schema.TaggedError");
+		} };
+	}
+};
+const noProcessEnv = {
+	meta: { type: "problem" },
+	create(context) {
+		return { MemberExpression(node) {
+			if (isProcessEnv(node)) report(context, node, "process.env is banned; declare the variable in .env.schema and read it with Config");
+		} };
+	}
+};
+const noTypeAssertion = {
+	meta: { type: "problem" },
+	create(context) {
+		return {
+			TSAsExpression(node) {
+				report(context, node, "type assertions are banned, including as const; parse with Schema or use a const type parameter");
+			},
+			TSTypeAssertion(node) {
+				report(context, node, "angle-bracket assertions are banned; parse with Schema or use a const type parameter");
+			}
+		};
+	}
+};
+const noExplicitAny = {
+	meta: { type: "problem" },
+	create(context) {
+		return { TSAnyKeyword(node) {
+			report(context, node, "any is banned; use unknown and decode it with Schema");
+		} };
+	}
+};
+const noNonNullAssertion = {
+	meta: { type: "problem" },
+	create(context) {
+		return { TSNonNullExpression(node) {
+			report(context, node, "non-null assertions are banned; narrow the value or decode it with Schema");
+		} };
+	}
+};
+const textOf = (context) => {
+	const source = context.sourceCode;
+	if (typeof source.text === "string") return source.text;
+	if (typeof source.getText === "function") return source.getText();
+	return "";
+};
+const commentStart = (comment) => {
+	const range = comment.range;
+	if (Array.isArray(range)) {
+		const start = range[0];
+		return typeof start === "number" ? start : -1;
+	}
+	if (range !== null && range !== void 0 && typeof range.start === "number") return range.start;
+	if (typeof comment.start === "number") return comment.start;
+	return -1;
+};
+const isShebang = (comment, text) => {
+	if (comment.type === "Shebang" || comment.type === "Hashbang") return true;
+	return text.startsWith("#!") && commentStart(comment) === 0;
+};
+const noComments = {
+	meta: { type: "problem" },
+	create(context) {
+		const text = textOf(context);
+		return { Program(node) {
+			for (const comment of context.sourceCode.getAllComments()) {
+				if (isShebang(comment, text)) continue;
+				const message = "comments are banned; use clearer names or docs";
+				if (comment.loc === void 0 || comment.loc === null) report(context, node, message);
+				else context.report({
+					loc: comment.loc,
+					message
+				});
+			}
+		} };
+	}
+};
+const noBypassComment = {
+	meta: { type: "problem" },
+	create(context) {
+		return { Program(node) {
+			for (const comment of context.sourceCode.getAllComments()) {
+				let matched = "";
+				for (const marker of markers) if (comment.value.includes(marker)) {
+					matched = marker;
+					break;
+				}
+				if (matched === "") continue;
+				const message = `directive comments are banned (${matched})`;
+				if (comment.loc === void 0 || comment.loc === null) report(context, node, message);
+				else context.report({
+					loc: comment.loc,
+					message
+				});
+			}
+		} };
+	}
+};
+const effectTests = {
+	meta: { type: "problem" },
+	create(context) {
+		const filename = typeof context.filename === "string" ? context.filename : "";
+		const isTest = filename.endsWith(".test.ts");
+		return {
+			ImportDeclaration(node) {
+				const source = specifier(node.source);
+				if (source === "vitest/config") {
+					if (!filename.endsWith("/vitest.config.ts") && !filename.endsWith("\\vitest.config.ts")) report(context, node, "import tests from @effect/vitest");
+					return;
+				}
+				if (source === "vitest" || source.startsWith("vitest/") || source.startsWith("@vitest/")) report(context, node, "import tests from @effect/vitest");
+			},
+			CallExpression(node) {
+				if (!isTest) return;
+				const parts = chainParts(node.callee);
+				const root = parts[0];
+				if (root === void 0) {
+					if (node.callee.type === "Identifier" && (node.callee.name === "it" || node.callee.name === "test" || testAliases.has(node.callee.name))) report(context, node, "tests use it.effect from @effect/vitest");
+					return;
+				}
+				if (isItEffect(parts)) return;
+				if (root === "it" || root === "test" || testAliases.has(root)) {
+					report(context, node, "tests use it.effect from @effect/vitest");
+					return;
+				}
+				if (root === "describe") {
+					let index = 1;
+					while (index < parts.length) {
+						const part = parts[index];
+						if (part !== void 0 && bannedTestMembers.has(part)) {
+							report(context, node, "skipped, focused, and todo tests are banned");
+							return;
+						}
+						index += 1;
+					}
+				}
+			}
+		};
+	}
+};
+const isAdapterFile = (context) => {
+	return (typeof context.filename === "string" ? context.filename : "").endsWith(".adapter.ts");
+};
+const rawMessage = (source) => {
+	if (socketSpecifiers.has(source)) return "node:net and node:tls belong in a .adapter.ts file; other raw IO stays banned";
+	return "raw IO imports are banned; use Effect FileSystem, HttpClient, or ChildProcess";
+};
+const bannedRaw = (context, node, source) => {
+	if (socketSpecifiers.has(source)) {
+		if (isAdapterFile(context)) return;
+		report(context, node, rawMessage(source));
+		return;
+	}
+	if (rawSpecifiers.has(source)) report(context, node, rawMessage(source));
+};
+const ruleNames = Object.keys({
+	"effect-tests": effectTests,
+	"no-bypass-comment": noBypassComment,
+	"no-comments": noComments,
+	"no-effect-run": {
+		meta: { type: "problem" },
+		create(context) {
+			return { CallExpression(node) {
+				const callee = node.callee;
+				if (callee.type !== "MemberExpression") return;
+				if (callee.object.type === "Identifier" && callee.object.name === "Effect" && effectRunMethods.has(literalName(callee.property, callee.computed))) report(context, node, "Effect.run* is banned; stay inside Effect and use it.effect in tests");
+			} };
+		}
+	},
+	"no-error-class": noErrorClass,
+	"no-explicit-any": noExplicitAny,
+	"no-module-let": {
+		meta: { type: "problem" },
+		create(context) {
+			return { Program(node) {
+				for (const statement of node.body) {
+					const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+					flagModuleBinding(context, declaration);
+				}
+			} };
+		}
+	},
+	"no-non-null-assertion": noNonNullAssertion,
+	"no-plain-class": {
+		meta: { type: "problem" },
+		create(context) {
+			return {
+				ClassDeclaration(node) {
+					if (!blessedSuper(node.superClass)) report(context, node, "plain classes are banned; extend Schema.TaggedError or Context.Service");
+				},
+				ClassExpression(node) {
+					if (!blessedSuper(node.superClass)) report(context, node, "plain classes are banned; extend Schema.TaggedError or Context.Service");
+				}
+			};
+		}
+	},
+	"no-process-env": noProcessEnv,
+	"no-raw-io": {
+		meta: { type: "problem" },
+		create(context) {
+			return {
+				ImportDeclaration(node) {
+					bannedRaw(context, node, specifier(node.source));
+				},
+				ImportExpression(node) {
+					bannedRaw(context, node, specifier(node.source));
+				},
+				CallExpression(node) {
+					const callee = node.callee;
+					if (callee.type === "Identifier" && callee.name === "fetch") {
+						report(context, node, "global fetch is banned; use Effect HttpClient");
+						return;
+					}
+					if (callee.type === "Identifier" && callee.name === "require") {
+						bannedRaw(context, node, specifier(node.arguments[0]));
+						return;
+					}
+					if (callee.type !== "MemberExpression") return;
+					const name = literalName(callee.property, callee.computed);
+					if (callee.object.type === "Identifier" && callee.object.name === "console" && consoleMethods.has(name)) {
+						report(context, node, "console is banned; use Effect Console");
+						return;
+					}
+					if (callee.object.type === "Identifier" && (callee.object.name === "globalThis" || callee.object.name === "global" || callee.object.name === "window") && name === "fetch") report(context, node, "global fetch is banned; use Effect HttpClient");
+				}
+			};
+		}
+	},
+	"no-throw": noThrow,
+	"no-try": noTry,
+	"no-type-assertion": noTypeAssertion
+});
+export { ruleNames };

package/dist/policy.d.ts

@@ -0,0 +1 @@
+export declare const commandBypassesVerify: (command: string) => boolean;

package/dist/policy.js

@@ -0,0 +1,124 @@
+// src/policy.ts
+const noVerifySubcommands = /* @__PURE__ */ new Set([
+	"am",
+	"cherry-pick",
+	"commit",
+	"merge",
+	"pull",
+	"rebase"
+]);
+const globalOptionsWithValue = /* @__PURE__ */ new Set([
+	"-C",
+	"-c",
+	"--config-env",
+	"--exec-path",
+	"--git-dir",
+	"--list-cmds",
+	"--namespace",
+	"--super-prefix",
+	"--work-tree"
+]);
+const isGitToken = (token) => token === "git" || token.endsWith("/git");
+const tokenAt = (tokens, index) => {
+	if (index < 0 || index >= tokens.length) return "";
+	const token = tokens[index];
+	if (token === void 0 || token === "") return "";
+	return token;
+};
+const tokenize = (command) => {
+	const tokens = [];
+	let current = "";
+	let quote = "";
+	let index = 0;
+	while (index < command.length) {
+		const char = command.charAt(index);
+		if (quote === "" && (char === " " || char === "	" || char === "\n")) {
+			if (current !== "") {
+				tokens.push(current);
+				current = "";
+			}
+			index += 1;
+			continue;
+		}
+		if (quote === "" && (char === "'" || char === "\"")) {
+			quote = char;
+			index += 1;
+			continue;
+		}
+		if (quote !== "" && char === quote) {
+			quote = "";
+			index += 1;
+			continue;
+		}
+		current += char;
+		index += 1;
+	}
+	if (current !== "") tokens.push(current);
+	return tokens;
+};
+const subcommandOf = (tokens) => {
+	let gitAt = -1;
+	let index = 0;
+	while (index < tokens.length) {
+		if (isGitToken(tokenAt(tokens, index))) {
+			gitAt = index;
+			break;
+		}
+		index += 1;
+	}
+	if (gitAt < 0) return {
+		name: "",
+		at: -1
+	};
+	index = gitAt + 1;
+	while (index < tokens.length) {
+		const token = tokenAt(tokens, index);
+		if (token === "--") return {
+			name: "",
+			at: -1
+		};
+		if (token.startsWith("-")) {
+			const option = token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
+			if (globalOptionsWithValue.has(option) && !token.includes("=")) {
+				index += 2;
+				continue;
+			}
+			index += 1;
+			continue;
+		}
+		return {
+			name: token,
+			at: index
+		};
+	}
+	return {
+		name: "",
+		at: -1
+	};
+};
+const shortClusterHasN = (tokens, from) => {
+	let index = from;
+	while (index < tokens.length) {
+		const token = tokenAt(tokens, index);
+		if (token.startsWith("-") && !token.startsWith("--") && token.includes("n")) return true;
+		index += 1;
+	}
+	return false;
+};
+const tokensBypass = (tokens) => {
+	const sub = subcommandOf(tokens);
+	if (noVerifySubcommands.has(sub.name) && shortClusterHasN(tokens, sub.at + 1)) return true;
+	let index = 0;
+	while (index < tokens.length) {
+		const token = tokenAt(tokens, index);
+		if ((token.includes(" ") || token.includes("\n")) && commandBypassesVerify(token)) return true;
+		index += 1;
+	}
+	return false;
+};
+const skipsHook = (command) => command.includes("--no-verify") || command.includes("LEFTHOOK=0") || command.includes("HUSKY=0") || command.includes("VP_GIT_HOOKS=0") || command.includes("VITE_GIT_HOOKS=0") || command.includes("vp hooks disable") || command.includes("vp.hooks.disabled");
+const commandBypassesVerify = (command) => {
+	if (skipsHook(command)) return true;
+	return tokensBypass(tokenize(command));
+};
+export { commandBypassesVerify };

package/dist/program.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+import { Stdio } from "effect/Stdio";
+export declare const main: (cwd: string) => Effect.Effect<number, import("effect/PlatformError").PlatformError, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | Stdio>;

package/dist/program.js

@@ -0,0 +1,49 @@
+import { CommandFailed } from "./errors.js";
+import { writeStdout } from "./run.js";
+import { verify } from "./verify.js";
+import { doctor } from "./doctor.js";
+import { explain } from "./explain.js";
+import { init, sync } from "./scaffold.js";
+import { Cause, Effect } from "effect";
+import { Stdio } from "effect/Stdio";
+// src/program.ts
+const usage = "usage: aas verify | aas init | aas sync | aas explain [rule] | aas doctor";
+const main = (cwd) => Effect.gen(function* () {
+	const args = yield* (yield* Stdio).args;
+	const command = args[0];
+	const rule = args[1];
+	return yield* dispatch(command, rule, cwd).pipe(Effect.catchTag("CommandFailed", (error) => Effect.gen(function* () {
+		yield* writeStdout(error.lines.join("\n"));
+		return 1;
+	})), Effect.catchCause((cause) => Effect.gen(function* () {
+		yield* writeStdout(Cause.pretty(cause));
+		return 1;
+	})));
+});
+const dispatch = (command, rule, cwd) => Effect.gen(function* () {
+	if (command === "verify") {
+		yield* verify(cwd);
+		return 0;
+	}
+	if (command === "init") {
+		yield* init(cwd);
+		return 0;
+	}
+	if (command === "sync") {
+		yield* sync(cwd);
+		return 0;
+	}
+	if (command === "explain") {
+		yield* explain(rule);
+		return 0;
+	}
+	if (command === "doctor") {
+		const report = yield* doctor(cwd);
+		yield* writeStdout(report.text);
+		if (!report.ok) return yield* new CommandFailed({ lines: [] });
+		return 0;
+	}
+	yield* writeStdout(usage);
+	return yield* new CommandFailed({ lines: [] });
+});
+export { main };

package/dist/run.d.ts

@@ -0,0 +1,18 @@
+import { CommandFailed } from "./errors.js";
+import { Effect, FileSystem } from "effect";
+import { Stdio } from "effect/Stdio";
+import { ChildProcessSpawner } from "effect/process";
+export declare const succeeded: (code: ChildProcessSpawner.ExitCode) => boolean;
+export declare const findBin: (name: string) => Effect.Effect<string, CommandFailed | import("effect/PlatformError").PlatformError, FileSystem.FileSystem>;
+export declare const runTool: (input: {
+  readonly bin: string;
+  readonly args: ReadonlyArray<string>;
+  readonly cwd: string;
+}) => Effect.Effect<{
+  stdout: string;
+  stderr: string;
+  exitCode: ChildProcessSpawner.ExitCode;
+}, import("effect/PlatformError").PlatformError, ChildProcessSpawner.ChildProcessSpawner>;
+export declare const writeStdout: (text: string) => Effect.Effect<void, import("effect/PlatformError").PlatformError, Stdio>;
+export declare const diagnosticsFrom: (text: string) => string[];
+export declare const failLines: (name: string, text: string) => string[];

package/dist/run.js

@@ -0,0 +1,99 @@
+import { CommandFailed } from "./errors.js";
+import { Effect, FileSystem, Stream } from "effect";
+import { Stdio } from "effect/Stdio";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+// src/run.ts
+const succeeded = (code) => code === ChildProcessSpawner.ExitCode(0);
+const findBin = (name) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const segments = import.meta.dirname.split("/");
+	let index = segments.length;
+	while (index > 1) {
+		index -= 1;
+		const candidate = `${segments.slice(0, index).join("/")}/node_modules/.bin/${name}`;
+		if (yield* fs.exists(candidate)) return candidate;
+	}
+	return yield* new CommandFailed({ lines: [`${name}:1: missing executable ${name}`] });
+});
+const runTool = (input) => Effect.gen(function* () {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	return yield* Effect.scoped(Effect.gen(function* () {
+		const handle = yield* spawner.spawn(ChildProcess.make(input.bin, Array.from(input.args), {
+			cwd: input.cwd,
+			env: {
+				CI: "1",
+				NO_COLOR: "1"
+			},
+			extendEnv: true
+		}));
+		const [stdout, stderr] = yield* Effect.all([Stream.mkString(Stream.decodeText(handle.stdout)), Stream.mkString(Stream.decodeText(handle.stderr))], { concurrency: 2 });
+		return {
+			stdout,
+			stderr,
+			exitCode: yield* handle.exitCode
+		};
+	}));
+});
+const writeStdout = (text) => Effect.gen(function* () {
+	if (text.length === 0) return;
+	const stdio = yield* Stdio;
+	const body = text.endsWith("\n") ? text : `${text}\n`;
+	yield* Stream.run(Stream.make(body), stdio.stdout());
+});
+const lintLine = /^(.*?):(\d+):\d+:\s*(.*)$/u;
+const tscLine = /^(.*?)\((\d+),\d+\):\s*(.*)$/u;
+const formatLine = /^(\S+\.[A-Za-z0-9]+)(?:\s+\(\d+ms\))?$/u;
+const escape = String.fromCharCode(27);
+const stripAnsi = (text) => {
+	let result = "";
+	let index = 0;
+	while (index < text.length) {
+		if (text.charAt(index) === escape && text.charAt(index + 1) === "[") {
+			index += 2;
+			while (index < text.length) {
+				const code = text.charCodeAt(index);
+				index += 1;
+				if (code >= 64 && code <= 126) break;
+			}
+			continue;
+		}
+		result += text.charAt(index);
+		index += 1;
+	}
+	return result;
+};
+const pushUnique = (lines, line) => {
+	if (!lines.includes(line)) lines.push(line);
+};
+const diagnosticsFrom = (text) => {
+	const lines = [];
+	for (const raw of stripAnsi(text).split("\n")) {
+		const trimmed = raw.trim();
+		if (trimmed === "") continue;
+		const lint = lintLine.exec(trimmed);
+		const lintFile = lint?.[1];
+		const lintNo = lint?.[2];
+		const lintMessage = lint?.[3];
+		if (lintFile !== void 0 && lintNo !== void 0 && lintMessage !== void 0) {
+			pushUnique(lines, `${lintFile}:${lintNo}: ${lintMessage}`);
+			continue;
+		}
+		const tsc = tscLine.exec(trimmed);
+		const tscFile = tsc?.[1];
+		const tscNo = tsc?.[2];
+		const tscMessage = tsc?.[3];
+		if (tscFile !== void 0 && tscNo !== void 0 && tscMessage !== void 0) {
+			pushUnique(lines, `${tscFile}:${tscNo}: ${tscMessage}`);
+			continue;
+		}
+		const formattedFile = formatLine.exec(trimmed)?.[1];
+		if (formattedFile !== void 0 && !formattedFile.includes("://")) pushUnique(lines, `${formattedFile}:1: format`);
+	}
+	return lines;
+};
+const failLines = (name, text) => {
+	const lines = diagnosticsFrom(text);
+	if (lines.length > 0) return lines;
+	return [`${name}:1: ${text.split("\n").map((line) => line.trim()).find((line) => line !== "") ?? "failed"}`];
+};
+export { diagnosticsFrom, failLines, findBin, runTool, succeeded, writeStdout };

package/dist/scaffold.d.ts

@@ -0,0 +1,5 @@
+import { CommandFailed } from "./errors.js";
+import { Effect, FileSystem } from "effect";
+export declare const writeTemplates: (cwd: string) => Effect.Effect<void, import("effect/PlatformError").PlatformError, FileSystem.FileSystem>;
+export declare const init: (cwd: string) => Effect.Effect<void, CommandFailed | import("effect/PlatformError").PlatformError, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | import("effect/Stdio").Stdio>;
+export declare const sync: typeof writeTemplates;