@aas-dev/stack 0.0.0-stage → 0.1.1

package/dist/scaffold.js

@@ -0,0 +1,76 @@
+import { CommandFailed } from "./errors.js";
+import { failLines, findBin, runTool, succeeded, writeStdout } from "./run.js";
+import { managedFiles, readTemplate } from "./templates.js";
+import { mergeAllowBuilds } from "./workspace.js";
+import { ensureVerifyScript } from "./package-script.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 template = yield* readTemplate(file.template);
+		const target = `${cwd}/${file.path}`;
+		const parent = parentOf(target);
+		if (parent !== "") yield* fs.makeDirectory(parent, { recursive: true });
+		const previous = (yield* fs.exists(target)) ? yield* fs.readFileString(target) : "";
+		const text = file.template === "pnpm-workspace.yaml" && previous !== "" ? mergeAllowBuilds(template, previous) : template;
+		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)) {
+		yield* writeStdout(`core.hooksPath is ${hooksPath.stdout.trim()}; vp hooks enable skipped`);
+		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 refreshLockfile = (cwd) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	if (!(yield* fs.exists(`${cwd}/pnpm-lock.yaml`))) return;
+	const state = `${cwd}/node_modules/.pnpm-workspace-state-v1.json`;
+	if (yield* fs.exists(state)) yield* fs.remove(state);
+	const installed = yield* runTool({
+		bin: "pnpm",
+		args: ["install"],
+		cwd
+	});
+	if (!succeeded(installed.exitCode)) return yield* new CommandFailed({ lines: failLines("pnpm", `${installed.stdout}\n${installed.stderr}`) });
+});
+const init = (cwd) => Effect.gen(function* () {
+	yield* writeTemplates(cwd);
+	yield* ensureVerifyScript(cwd);
+	yield* installHooks(cwd);
+	yield* refreshLockfile(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,4 @@
+import { CommandFailed } from "./errors.js";
+import { Effect, FileSystem } from "effect";
+export declare const driftLines: (cwd: string) => Effect.Effect<string[], import("effect/PlatformError").PlatformError, FileSystem.FileSystem>;
+export declare const verify: (cwd: string) => Effect.Effect<undefined, CommandFailed | import("effect/PlatformError").PlatformError, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem>;

package/dist/verify.js

@@ -0,0 +1,190 @@
+import { CommandFailed } from "./errors.js";
+import { diagnosticsFrom, failLines, findBin, runTool, succeeded } from "./run.js";
+import { managedFiles, readTemplate } from "./templates.js";
+import { workspaceDrift } from "./workspace.js";
+import { Effect, FileSystem, Result, Schema } from "effect";
+// src/verify.ts
+const driftLines = (cwd) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const lines = [];
+	for (const file of managedFiles) {
+		const expected = yield* readTemplate(file.template);
+		const target = `${cwd}/${file.path}`;
+		const present = yield* fs.exists(target);
+		const actual = present ? yield* fs.readFileString(target) : "";
+		if (file.template === "pnpm-workspace.yaml") {
+			const reason = present ? workspaceDrift(expected, actual) : "drifted from the aas template; run aas sync";
+			if (reason !== "") lines.push(`${file.path}:1: ${reason}`);
+			continue;
+		}
+		if (!present || actual !== expected) lines.push(`${file.path}:1: drifted from the aas template; run aas sync`);
+	}
+	return lines;
+});
+const checkDrift = (cwd) => Effect.gen(function* () {
+	const lines = yield* driftLines(cwd);
+	if (lines.length > 0) return yield* new CommandFailed({ lines });
+});
+const patchTypeScript = (tsc) => Effect.gen(function* () {
+	const at = tsc.lastIndexOf("/node_modules/.bin/");
+	if (at <= 0) return yield* new CommandFailed({ lines: [`tsc:1: unable to locate the typescript package for ${tsc}`] });
+	const effectTsgo = yield* findBin("effect-tsgo");
+	yield* runChecked({
+		bin: effectTsgo,
+		args: ["patch", "--typescript"],
+		cwd: tsc.slice(0, at),
+		label: "effect-tsgo"
+	});
+});
+const runChecked = (input) => Effect.gen(function* () {
+	const result = yield* runTool(input);
+	if (succeeded(result.exitCode)) return;
+	return yield* new CommandFailed({ lines: failLines(input.label, `${result.stdout}\n${result.stderr}`) });
+});
+const packTargets = (cwd) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const targets = [];
+	const packagesDir = `${cwd}/packages`;
+	if (yield* fs.exists(packagesDir)) {
+		const sorted = [...yield* fs.readDirectory(packagesDir)].sort();
+		for (const name of sorted) {
+			const dir = `${packagesDir}/${name}`;
+			if (yield* fs.exists(`${dir}/src/index.ts`)) targets.push(dir);
+		}
+	}
+	if (targets.length === 0 && (yield* fs.exists(`${cwd}/src/index.ts`))) targets.push(cwd);
+	if (targets.includes(`${cwd}/packages/cli`)) {
+		const rest = targets.filter((dir) => dir !== `${cwd}/packages/cli`);
+		return [`${cwd}/packages/cli`, ...rest];
+	}
+	return targets;
+});
+const verify = (cwd) => Effect.gen(function* () {
+	yield* checkDrift(cwd);
+	const fs = yield* FileSystem.FileSystem;
+	const vp = yield* findBin("vp");
+	const tsc = yield* findBin("tsc");
+	if (yield* fs.exists(`${cwd}/.env.schema`)) {
+		const varlock = yield* findBin("varlock");
+		yield* runChecked({
+			bin: varlock,
+			args: ["load"],
+			cwd,
+			label: "varlock"
+		});
+	}
+	yield* runChecked({
+		bin: vp,
+		args: [
+			"fmt",
+			"--check",
+			"."
+		],
+		cwd,
+		label: "fmt"
+	});
+	yield* runChecked({
+		bin: vp,
+		args: [
+			"lint",
+			"--format",
+			"unix"
+		],
+		cwd,
+		label: "lint"
+	});
+	const targets = yield* packTargets(cwd);
+	for (const target of targets) yield* runChecked({
+		bin: vp,
+		args: [
+			"pack",
+			"--logLevel",
+			"error"
+		],
+		cwd: target,
+		label: "pack"
+	});
+	if (yield* fs.exists(`${cwd}/tsconfig.json`)) {
+		yield* patchTypeScript(tsc);
+		yield* runChecked({
+			bin: tsc,
+			args: [
+				"--noEmit",
+				"--pretty",
+				"false",
+				"-p",
+				"tsconfig.json"
+			],
+			cwd,
+			label: "tsc"
+		});
+	}
+	const reportPath = `${cwd}/.vitest/aas-report.json`;
+	const tested = yield* runTool({
+		bin: vp,
+		args: [
+			"test",
+			"run",
+			"--reporter=json",
+			"--outputFile",
+			".vitest/aas-report.json"
+		],
+		cwd
+	});
+	const report = (yield* fs.exists(reportPath)) ? yield* fs.readFileString(reportPath) : "";
+	yield* fs.remove(reportPath).pipe(Effect.ignore);
+	if (!succeeded(tested.exitCode)) {
+		const parsed = testFailures(report === "" ? tested.stdout : report, cwd);
+		return yield* new CommandFailed({ lines: parsed.length > 0 ? parsed : failLines("test", `${tested.stdout}\n${tested.stderr}`) });
+	}
+});
+const Assertion = Schema.Struct({
+	status: Schema.String,
+	title: Schema.optionalKey(Schema.String),
+	failureMessages: Schema.optionalKey(Schema.Array(Schema.String))
+});
+const TestFile = Schema.Struct({
+	name: Schema.optionalKey(Schema.String),
+	status: Schema.optionalKey(Schema.String),
+	message: Schema.optionalKey(Schema.String),
+	assertionResults: Schema.optionalKey(Schema.Array(Assertion))
+});
+const Report = Schema.Struct({ testResults: Schema.optionalKey(Schema.Array(TestFile)) });
+const decodeReport = (text) => Schema.decodeResult(Schema.fromJsonString(Report))(text);
+const failureLine = /([A-Za-z0-9_./-]+\.ts):(\d+):\d+/u;
+const relativeTo = (file, cwd) => {
+	const prefix = `${cwd}/`;
+	return file.startsWith(prefix) ? file.slice(prefix.length) : file;
+};
+const firstLine = (text) => text.split("\n")[0] ?? "failed";
+const testFailures = (text, cwd) => {
+	const start = text.indexOf("{");
+	const end = text.lastIndexOf("}");
+	if (start < 0 || end <= start) return diagnosticsFrom(text);
+	const decoded = decodeReport(text.slice(start, end + 1));
+	if (Result.isFailure(decoded)) return diagnosticsFrom(text);
+	const results = decoded.success.testResults;
+	if (results === void 0) return diagnosticsFrom(text);
+	const lines = [];
+	for (const result of results) {
+		const assertions = result.assertionResults ?? [];
+		let failedAssertions = 0;
+		for (const assertion of assertions) {
+			if (assertion.status !== "failed") continue;
+			failedAssertions += 1;
+			const message = assertion.failureMessages?.[0];
+			const located = message === void 0 ? null : failureLine.exec(message);
+			const locatedFile = located?.[1];
+			const file = relativeTo(locatedFile ?? result.name ?? "test", cwd);
+			const line = located?.[2] ?? "1";
+			const reason = message === void 0 ? assertion.title ?? "failed" : firstLine(message);
+			lines.push(`${file}:${line}: ${reason}`);
+		}
+		if (failedAssertions === 0 && result.status === "failed") {
+			const file = relativeTo(result.name ?? "test", cwd);
+			lines.push(`${file}:1: ${firstLine(result.message ?? "failed")}`);
+		}
+	}
+	return lines;
+};
+export { driftLines, verify };

package/dist/workspace.d.ts

@@ -0,0 +1,4 @@
+export declare const scalarEntries: (text: string, key: string) => (readonly [string, string])[] | undefined;
+export declare const workspaceDrift: (template: string, actual: string) => "" | "drifted from the aas template; run aas sync";
+export declare const mergeAllowBuilds: (template: string, previous: string) => string;
+export declare const sameScalars: (left: ReadonlyArray<readonly [string, string]>, right: ReadonlyArray<readonly [string, string]>) => boolean;

package/dist/workspace.js

@@ -0,0 +1,76 @@
+// src/workspace.ts
+const unquote = (raw) => {
+	const trimmed = raw.trim();
+	if (trimmed.length >= 2 && (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'"))) return trimmed.slice(1, -1);
+	return trimmed;
+};
+const linesOf = (text) => text.split("\n");
+const sectionRange = (lines, key) => {
+	const start = lines.findIndex((line) => line === `${key}:`);
+	if (start < 0) return;
+	let end = start + 1;
+	while (end < lines.length) {
+		const line = lines[end] ?? "";
+		if (line === "" || line.startsWith(" ") || line.startsWith("#")) {
+			end += 1;
+			continue;
+		}
+		break;
+	}
+	return {
+		start,
+		end
+	};
+};
+const sectionBody = (text, key) => {
+	const lines = linesOf(text);
+	const range = sectionRange(lines, key);
+	if (range === void 0) return;
+	return lines.slice(range.start + 1, range.end).join("\n");
+};
+const remainder = (text, key) => {
+	const lines = linesOf(text);
+	const range = sectionRange(lines, key);
+	if (range === void 0) return text;
+	return [...lines.slice(0, range.start), ...lines.slice(range.end)].join("\n");
+};
+const entryPattern = /^("?)([A-Za-z0-9@/_.+*-]+)\1:\s*(.+)$/u;
+const scalarEntries = (text, key) => {
+	const body = sectionBody(text, key);
+	if (body === void 0) return;
+	const entries = [];
+	for (const line of body.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed === "" || trimmed.startsWith("#")) continue;
+		if (trimmed.startsWith("-")) return;
+		const matched = entryPattern.exec(trimmed);
+		const name = matched?.[2];
+		const value = matched?.[3];
+		if (name === void 0 || value === void 0) return;
+		entries.push([name, unquote(value)]);
+	}
+	return entries;
+};
+const drift = "drifted from the aas template; run aas sync";
+const workspaceDrift = (template, actual) => {
+	if (remainder(template, "allowBuilds") !== remainder(actual, "allowBuilds")) return drift;
+	const expected = scalarEntries(template, "allowBuilds");
+	const found = scalarEntries(actual, "allowBuilds");
+	if (expected === void 0 || found === void 0) return drift;
+	for (const [key, value] of expected) {
+		const match = found.find((entry) => entry[0] === key);
+		if (match === void 0 || match[1] !== value) return drift;
+	}
+	return "";
+};
+const mergeAllowBuilds = (template, previous) => {
+	const expected = scalarEntries(template, "allowBuilds");
+	const found = scalarEntries(previous, "allowBuilds");
+	if (expected === void 0 || found === void 0) return template;
+	const extras = found.filter((entry) => !expected.some((required) => required[0] === entry[0])).sort((left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0);
+	if (extras.length === 0) return template;
+	return `${template.endsWith("\n") ? template.slice(0, -1) : template}\n${extras.map(([key, value]) => `  ${key}: ${value}`).join("\n")}\n`;
+};
+const pairText = (entries) => entries.map(([key, value]) => `${key}=${value}`).sort().join("\n");
+const sameScalars = (left, right) => pairText(left) === pairText(right);
+export { mergeAllowBuilds, sameScalars, scalarEntries, workspaceDrift };

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@aas-dev/stack",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "The aas command. One installable toolchain: Vite+, Effect tsgo, and the fence.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://origin.cursor.com/git/kristoffer-aas/aas-stack.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "aas": "./bin/aas.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "plugin",
+    "templates",
+    "tsconfig.base.json"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js"
+    },
+    "./tsconfig.base.json": "./tsconfig.base.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.0.6",
+    "@effect/tsgo": "0.56.0",
+    "effect": "4.0.6",
+    "typescript": "7.0.2",
+    "varlock": "1.23.0",
+    "vite-plus": "1.4.0"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.6",
+    "@types/node": "22.20.5"
+  },
+  "engines": {
+    "node": ">=22.18.0",
+    "pnpm": "11.3.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit --pretty false -p tsconfig.json",
+    "test": "vp test run",
+    "build": "vp pack --logLevel error"
+  }
 }

package/plugin/aas.d.mts

@@ -0,0 +1,8 @@
+export declare const ruleNames: ReadonlyArray<string>
+
+declare const plugin: {
+  readonly meta: { readonly name: string }
+  readonly rules: Readonly<Record<string, object>>
+}
+
+export default plugin