@aas-dev/stack 0.0.0-stage → 0.1.0

package/bin/aas.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/bin.js"

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/bin.js

@@ -0,0 +1,15 @@
+import { main } from "./program.js";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Effect, Exit } from "effect";
+// src/bin.ts
+const teardown = (exit, onExit) => {
+	onExit(Exit.match(exit, {
+		onFailure: () => 1,
+		onSuccess: (code) => typeof code === "number" ? code : 1
+	}));
+};
+NodeRuntime.runMain(main(process.cwd()).pipe(Effect.provide(NodeServices.layer)), {
+	disableErrorReporting: true,
+	teardown
+});
+export {};

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import { UserConfig } from "vite-plus";
+export type AasConfig = UserConfig;
+export declare const defineConfig: (options?: {
+  readonly ignorePatterns?: ReadonlyArray<string>;
+}) => AasConfig;

package/dist/config.js

@@ -0,0 +1,75 @@
+import { defineConfig as defineConfig$1 } from "vite-plus";
+// src/config.ts
+const pluginPath = `${import.meta.dirname}/../plugin/aas.mjs`;
+const errors = (rules) => rules;
+const rules = errors({
+	"aas/no-throw": "error",
+	"aas/no-try": "error",
+	"aas/no-error-class": "error",
+	"aas/no-process-env": "error",
+	"aas/no-type-assertion": "error",
+	"aas/no-explicit-any": "error",
+	"aas/no-non-null-assertion": "error",
+	"aas/no-bypass-comment": "error",
+	"aas/no-comments": "error",
+	"aas/effect-tests": "error",
+	"aas/no-raw-io": "error",
+	"aas/no-effect-run": "error",
+	"aas/no-module-let": "error",
+	"aas/no-plain-class": "error"
+});
+const defaultIgnore = [
+	"dist",
+	"vendor",
+	"node_modules",
+	"coverage",
+	".vite-hooks/_",
+	"packages/fence/fixtures"
+];
+const defineConfig = (options) => defineConfig$1({
+	lint: {
+		jsPlugins: [pluginPath],
+		options: {
+			denyWarnings: true,
+			respectEslintDisableDirectives: false
+		},
+		ignorePatterns: [...options?.ignorePatterns ?? defaultIgnore],
+		rules
+	},
+	fmt: {
+		printWidth: 100,
+		semi: false,
+		ignorePatterns: [
+			"node_modules",
+			"dist",
+			"vendor",
+			"coverage",
+			".vitest",
+			".vite-hooks/_"
+		]
+	},
+	test: {
+		include: ["**/*.test.ts"],
+		exclude: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/fixtures/**",
+			"**/vendor/**"
+		],
+		passWithNoTests: false,
+		server: { deps: { inline: ["@effect/vitest"] } }
+	},
+	pack: {
+		entry: ["src/**/*.ts", "!src/**/*.test.ts"],
+		dts: true,
+		unbundle: true,
+		fixedExtension: false,
+		hash: false,
+		clean: true,
+		logLevel: "error",
+		failOnWarn: false,
+		report: false,
+		deps: { neverBundle: true }
+	}
+});
+export { defineConfig };

package/dist/cursor-hook.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cursor-hook.js

@@ -0,0 +1,28 @@
+import { BadHookInput } from "./errors.js";
+import { writeStdout } from "./run.js";
+import { commandBypassesVerify } from "./policy.js";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Effect, Result, Schema, Stream } from "effect";
+import { Stdio } from "effect/Stdio";
+// src/cursor-hook.ts
+const HookInput = Schema.Struct({ command: Schema.optionalKey(Schema.String) });
+const deny = JSON.stringify({
+	permission: "deny",
+	user_message: "pnpm verify cannot be skipped.",
+	agent_message: "Run pnpm verify. Do not pass --no-verify, a short -n on commit, LEFTHOOK=0, HUSKY=0, VP_GIT_HOOKS=0, VITE_GIT_HOOKS=0, or vp hooks disable."
+});
+const allow = JSON.stringify({ permission: "allow" });
+const hook = Effect.gen(function* () {
+	const stdio = yield* Stdio;
+	const input = yield* Stream.mkString(Stream.decodeText(stdio.stdin));
+	const decoded = Schema.decodeResult(Schema.fromJsonString(HookInput))(input);
+	if (Result.isFailure(decoded)) return yield* new BadHookInput({});
+	const command = decoded.success.command ?? "";
+	if (command === "" || commandBypassesVerify(command)) {
+		yield* writeStdout(deny);
+		return;
+	}
+	yield* writeStdout(allow);
+});
+NodeRuntime.runMain(hook.pipe(Effect.provide(NodeServices.layer)), { disableErrorReporting: true });
+export {};

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+declare const CommandFailed_base: Schema.Class<CommandFailed, Schema.TaggedStruct<"CommandFailed", {
+  readonly lines: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class CommandFailed extends CommandFailed_base {}
+declare const BadHookInput_base: Schema.Class<BadHookInput, Schema.TaggedStruct<"BadHookInput", {}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class BadHookInput extends BadHookInput_base {}
+export {};

package/dist/errors.js

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+// src/errors.ts
+var CommandFailed = class extends Schema.TaggedError()("CommandFailed", { lines: Schema.Array(Schema.String) }) {};
+var BadHookInput = class extends Schema.TaggedError()("BadHookInput", {}) {};
+export { BadHookInput, CommandFailed };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { defineConfig } from "./config.js";
+import { commandBypassesVerify } from "./policy.js";
+export { commandBypassesVerify, defineConfig };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { defineConfig } from "./config.js";
+import { commandBypassesVerify } from "./policy.js";
+export { commandBypassesVerify, defineConfig };

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,35 @@
+import { CommandFailed } from "./errors.js";
+import { writeStdout } from "./run.js";
+import { init, sync } from "./scaffold.js";
+import { verify } from "./verify.js";
+import { Cause, Effect } from "effect";
+import { Stdio } from "effect/Stdio";
+// src/program.ts
+const usage = "usage: aas verify | aas init | aas sync";
+const main = (cwd) => Effect.gen(function* () {
+	const command = (yield* (yield* Stdio).args)[0];
+	return yield* dispatch(command, 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, 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;
+	}
+	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>;
+export declare const sync: typeof writeTemplates;

package/dist/scaffold.js

@@ -0,0 +1,55 @@
+import { CommandFailed } from "./errors.js";
+import { findBin, runTool, succeeded } from "./run.js";
+import { managedFiles, readTemplate } from "./templates.js";
+import { Effect, FileSystem } from "effect";
+// src/scaffold.ts
+const parentOf = (path) => {
+	const slash = path.lastIndexOf("/");
+	if (slash <= 0) return "";
+	return path.slice(0, slash);
+};
+const writeTemplates = (cwd) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	for (const file of managedFiles) {
+		const text = yield* readTemplate(file.template);
+		const target = `${cwd}/${file.path}`;
+		const parent = parentOf(target);
+		if (parent !== "") yield* fs.makeDirectory(parent, { recursive: true });
+		yield* fs.writeFileString(target, text);
+	}
+});
+const installHooks = (cwd) => Effect.gen(function* () {
+	const git = yield* runTool({
+		bin: "git",
+		args: ["rev-parse", "--git-dir"],
+		cwd
+	});
+	if (!succeeded(git.exitCode)) return;
+	const hooksPath = yield* runTool({
+		bin: "git",
+		args: [
+			"config",
+			"--get",
+			"core.hooksPath"
+		],
+		cwd
+	});
+	if (succeeded(hooksPath.exitCode)) return;
+	const vp = yield* findBin("vp");
+	const installed = yield* runTool({
+		bin: vp,
+		args: ["hooks", "enable"],
+		cwd
+	});
+	if (!succeeded(installed.exitCode)) return yield* new CommandFailed({ lines: failOr(installed.stdout, installed.stderr) });
+});
+const failOr = (stdout, stderr) => {
+	const text = `${stdout}\n${stderr}`.trim();
+	return [`vp:1: ${text === "" ? "vp hooks enable failed" : text.split("\n")[0] ?? "failed"}`];
+};
+const init = (cwd) => Effect.gen(function* () {
+	yield* writeTemplates(cwd);
+	yield* installHooks(cwd);
+});
+const sync = writeTemplates;
+export { init, sync, writeTemplates };

package/dist/templates.d.ts

@@ -0,0 +1,6 @@
+import { Effect, FileSystem } from "effect";
+export declare const managedFiles: ReadonlyArray<{
+  readonly template: string;
+  readonly path: string;
+}>;
+export declare const readTemplate: (name: string) => Effect.Effect<string, import("effect/PlatformError").PlatformError, FileSystem.FileSystem>;

package/dist/templates.js

@@ -0,0 +1,37 @@
+import { Effect, FileSystem } from "effect";
+// src/templates.ts
+const managedFiles = [
+	{
+		template: "hooks.json",
+		path: ".cursor/hooks.json"
+	},
+	{
+		template: "pre-commit",
+		path: ".vite-hooks/pre-commit"
+	},
+	{
+		template: "pnpm-workspace.yaml",
+		path: "pnpm-workspace.yaml"
+	},
+	{
+		template: "AGENTS.md",
+		path: "AGENTS.md"
+	},
+	{
+		template: "verify.yml",
+		path: ".github/workflows/verify.yml"
+	},
+	{
+		template: "vite.config.ts",
+		path: "vite.config.ts"
+	},
+	{
+		template: "tsconfig.json",
+		path: "tsconfig.json"
+	}
+];
+const templateRoot = `${import.meta.dirname}/../templates`;
+const readTemplate = (name) => Effect.gen(function* () {
+	return yield* (yield* FileSystem.FileSystem).readFileString(`${templateRoot}/${name}`);
+});
+export { managedFiles, readTemplate };

package/dist/verify.d.ts

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