@aas-dev/stack 0.0.0-stage → 0.1.0

package/dist/verify.js

@@ -0,0 +1,166 @@
+import { CommandFailed } from "./errors.js";
+import { diagnosticsFrom, failLines, findBin, runTool, succeeded } from "./run.js";
+import { managedFiles, readTemplate } from "./templates.js";
+import { Effect, FileSystem, Result, Schema } from "effect";
+// src/verify.ts
+const checkDrift = (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 (!present || actual !== expected) lines.push(`${file.path}:1: drifted from the aas template; run aas sync`);
+	}
+	if (lines.length > 0) return yield* new CommandFailed({ lines });
+});
+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* 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 { verify };

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.0",
+  "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