@rrlab/astro-plugin 0.0.0 → 0.0.1-git-f854273.0

package/README.md

@@ -1,3 +1,31 @@
 # @rrlab/astro-plugin
 
-Placeholder. The first release comes from [withvariablelab/dx](https://github.com/withvariablelab/dx).
+Astro plugin for [`@rrlab/cli`](https://npmjs.com/package/@rrlab/cli). Provides the `typecheck` capability backed by [`astro check`](https://docs.astro.build/en/reference/cli-reference/#astro-check), so `rr tsc` and `rr check` type-check `.astro` files along with the rest of the project.
+
+## Install
+
+```sh
+rr plugins add astro
+```
+
+`rr plugins add` installs `@rrlab/astro-plugin` and adds `@astrojs/check` and `typescript` as `devDependencies`: `astro check` needs both. It scaffolds no config: your Astro project already has its `tsconfig.json`, and `astro` itself stays your project's own dependency.
+
+## What it provides
+
+| Capability | Surface |
+|---|---|
+| `typecheck` | `rr tsc` (workspace-aware in monorepos), `rr check`, `rr tsc doctor` |
+
+`rr tsc` runs `astro check` in each package with a `tsconfig.json`. It reports the same diagnostics as `astro check`, for `.astro` files and plain `.ts` files alike, and fails when `astro check` exits non-zero (any error, by default).
+
+`astro check` also checks your `.ts` files, so in an Astro project it replaces `ts`. Configure one `typecheck` provider. If another plugin also provides one (`ts`, or `oxc`), narrow it, e.g. `oxc({ only: ["lint", "format"] })`.
+
+If `@astrojs/check` or `typescript` is missing, `rr tsc` fails and names it. Left alone, `astro check` would prompt to install them instead of checking anything.
+
+## Removal
+
+```sh
+rr plugins remove astro
+```
+
+Removes `@astrojs/check` and `typescript` from `package.json` and drops the `astro()` entry from `run-run.config.{ts,mts}`. `astro` and your `tsconfig.json` are left untouched.

package/dist/index.d.mts

@@ -0,0 +1,35 @@
+import { InstallContext, InstallResult, RunReport, ToolService, TypeCheckOptions, TypeChecker, UninstallContext, UninstallResult } from "@rrlab/cli/plugin";
+import { ShellService } from "@variablelab/clibuddy";
+
+//#region src/tool-versions.d.ts
+declare const TOOL_VERSIONS: {
+  readonly "@astrojs/check": {
+    readonly install: "^0.9.10";
+  };
+  readonly typescript: {
+    readonly install: "^6.0.0";
+  };
+};
+//#endregion
+//#region src/index.d.ts
+declare class AstroCheckService extends ToolService implements TypeChecker {
+  #private;
+  constructor(shellService: ShellService, cwd: string);
+  check(options?: TypeCheckOptions): Promise<RunReport>;
+  doctor(): Promise<RunReport>;
+}
+/**
+ * Lists the `astro check` dependencies the project at `root` can't resolve,
+ * looking them up the way astro does (`require.resolve(pkg, { paths: [root] })`).
+ * When one is missing, astro prompts to install it instead of checking: under a
+ * captured run that prompt hangs, and with stdin closed astro exits 0 having
+ * checked nothing. So we fail before running it.
+ */
+declare function missingCheckDeps(root: string): string[];
+declare function install(_ctx: InstallContext): Promise<InstallResult>;
+declare function uninstall(_ctx: UninstallContext): Promise<UninstallResult>;
+declare const astro: (options?: {
+  only?: readonly "typecheck"[] | undefined;
+} | undefined) => import("@rrlab/cli/plugin").Plugin;
+//#endregion
+export { AstroCheckService, TOOL_VERSIONS, astro as default, install, missingCheckDeps, uninstall };

package/dist/index.mjs

@@ -0,0 +1,79 @@
+import { createRequire } from "node:module";
+import { ToolService, definePlugin } from "@rrlab/cli/plugin";
+import { colorize } from "@variablelab/clibuddy";
+//#region src/tool-versions.ts
+const TOOL_VERSIONS = {
+	"@astrojs/check": { install: "^0.9.10" },
+	typescript: { install: "^6.0.0" }
+};
+//#endregion
+//#region src/index.ts
+const FROM = import.meta.url;
+const localRequire = createRequire(FROM);
+const CHECK_DEPS = ["@astrojs/check", "typescript"];
+const astroColor = colorize("#BC52EE");
+var AstroCheckService = class extends ToolService {
+	#cwd;
+	constructor(shellService, cwd) {
+		super({
+			bin: "astro",
+			color: astroColor,
+			shellService,
+			from: FROM
+		});
+		this.#cwd = cwd;
+	}
+	async check(options = {}) {
+		const cwd = options.cwd ?? this.#cwd;
+		const missing = missingCheckDeps(cwd);
+		if (missing.length > 0) return missingDepsReport(missing);
+		return this.runReport(["check"], { cwd });
+	}
+	async doctor() {
+		const missing = missingCheckDeps(this.#cwd);
+		if (missing.length > 0) return missingDepsReport(missing);
+		return super.doctor();
+	}
+};
+/**
+* Lists the `astro check` dependencies the project at `root` can't resolve,
+* looking them up the way astro does (`require.resolve(pkg, { paths: [root] })`).
+* When one is missing, astro prompts to install it instead of checking: under a
+* captured run that prompt hangs, and with stdin closed astro exits 0 having
+* checked nothing. So we fail before running it.
+*/
+function missingCheckDeps(root) {
+	return CHECK_DEPS.filter((pkg) => {
+		try {
+			localRequire.resolve(pkg, { paths: [root] });
+			return false;
+		} catch {
+			return true;
+		}
+	});
+}
+function missingDepsReport(missing) {
+	return {
+		ok: false,
+		output: `@rrlab/astro-plugin requires ${missing.join(", ")} to be installed in the host project. Run: rr plugins add astro  (or: pnpm add -D ${missing.join(" ")})`
+	};
+}
+async function install(_ctx) {
+	return { devDependencies: {
+		"@astrojs/check": TOOL_VERSIONS["@astrojs/check"].install,
+		typescript: TOOL_VERSIONS.typescript.install
+	} };
+}
+async function uninstall(_ctx) {
+	return { removeDependencies: ["@astrojs/check", "typescript"] };
+}
+const astro = definePlugin({
+	apiVersion: 1,
+	name: "astro",
+	color: astroColor,
+	install,
+	uninstall,
+	services: ({ shell, cwd }) => ({ typecheck: new AstroCheckService(shell, cwd) })
+});
+//#endregion
+export { AstroCheckService, TOOL_VERSIONS, astro as default, install, missingCheckDeps, uninstall };

package/package.json

@@ -1,11 +1,57 @@
 {
   "name": "@rrlab/astro-plugin",
-  "version": "0.0.0",
-  "description": "Placeholder. The first release comes from withvariablelab/dx.",
-  "license": "MIT",
+  "version": "0.0.1-git-f854273.0",
+  "description": "Astro plugin for @rrlab/cli — provides the typecheck capability via astro check.",
+  "homepage": "https://github.com/withvariablelab/dx/tree/main/run-run/astro-plugin#readme",
+  "bugs": {
+    "url": "https://github.com/withvariablelab/dx/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/withvariablelab/dx.git",
     "directory": "run-run/astro-plugin"
+  },
+  "license": "MIT",
+  "author": "rcrd <ricardo@variable.land>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/__tests__",
+    "!src/**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "dependencies": {
+    "@variablelab/clibuddy": "0.7.4"
+  },
+  "peerDependencies": {
+    "@astrojs/check": ">=0.9.0",
+    "astro": ">=5.0.0",
+    "typescript": "^5.0.0 || ^6.0.0",
+    "@rrlab/cli": "^1.3.6-git-f854273.0"
+  },
+  "devDependencies": {
+    "@astrojs/check": "0.9.10",
+    "@types/semver": "^7.7.1",
+    "astro": "7.4.0",
+    "semver": "^7.8.1",
+    "typescript": "6.0.3",
+    "@rrlab/cli": "1.3.6-git-f854273.0",
+    "@rrlab/tsdown-config": "^0.1.2"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run"
   }
-}
+}

package/src/index.ts

@@ -0,0 +1,100 @@
+import { createRequire } from "node:module";
+import {
+  definePlugin,
+  type InstallContext,
+  type InstallResult,
+  type RunReport,
+  ToolService,
+  type TypeChecker,
+  type TypeCheckOptions,
+  type UninstallContext,
+  type UninstallResult,
+} from "@rrlab/cli/plugin";
+import { colorize, type ShellService } from "@variablelab/clibuddy";
+import { TOOL_VERSIONS } from "./tool-versions.ts";
+
+export { TOOL_VERSIONS } from "./tool-versions.ts";
+
+const FROM = import.meta.url;
+const localRequire = createRequire(FROM);
+// What `astro check` loads from the project root before checking anything.
+const CHECK_DEPS = ["@astrojs/check", "typescript"] as const;
+const astroColor = colorize("#BC52EE");
+
+export class AstroCheckService extends ToolService implements TypeChecker {
+  #cwd: string;
+
+  constructor(shellService: ShellService, cwd: string) {
+    super({ bin: "astro", color: astroColor, shellService, from: FROM });
+    this.#cwd = cwd;
+  }
+
+  async check(options: TypeCheckOptions = {}): Promise<RunReport> {
+    const cwd = options.cwd ?? this.#cwd;
+    const missing = missingCheckDeps(cwd);
+    if (missing.length > 0) return missingDepsReport(missing);
+    // `astro check`, not @astrojs/check's own `astro-check` bin: only the
+    // former runs `astro sync` first, so generated types (content collections,
+    // `astro:env`, …) exist. Its diagnostics keep their color when captured.
+    return this.runReport(["check"], { cwd });
+  }
+
+  override async doctor(): Promise<RunReport> {
+    const missing = missingCheckDeps(this.#cwd);
+    if (missing.length > 0) return missingDepsReport(missing);
+    return super.doctor();
+  }
+}
+
+/**
+ * Lists the `astro check` dependencies the project at `root` can't resolve,
+ * looking them up the way astro does (`require.resolve(pkg, { paths: [root] })`).
+ * When one is missing, astro prompts to install it instead of checking: under a
+ * captured run that prompt hangs, and with stdin closed astro exits 0 having
+ * checked nothing. So we fail before running it.
+ */
+export function missingCheckDeps(root: string): string[] {
+  return CHECK_DEPS.filter((pkg) => {
+    try {
+      localRequire.resolve(pkg, { paths: [root] });
+      return false;
+    } catch {
+      return true;
+    }
+  });
+}
+
+function missingDepsReport(missing: string[]): RunReport {
+  return {
+    ok: false,
+    output:
+      `@rrlab/astro-plugin requires ${missing.join(", ")} to be installed in the host project. ` +
+      `Run: rr plugins add astro  (or: pnpm add -D ${missing.join(" ")})`,
+  };
+}
+
+// No config scaffolding: an Astro project already has its tsconfig.json, and
+// `astro` itself is the host's own dependency, so only the checker is added.
+export async function install(_ctx: InstallContext): Promise<InstallResult> {
+  return {
+    devDependencies: {
+      "@astrojs/check": TOOL_VERSIONS["@astrojs/check"].install,
+      typescript: TOOL_VERSIONS.typescript.install,
+    },
+  };
+}
+
+export async function uninstall(_ctx: UninstallContext): Promise<UninstallResult> {
+  return { removeDependencies: ["@astrojs/check", "typescript"] };
+}
+
+const astro = definePlugin({
+  apiVersion: 1,
+  name: "astro",
+  color: astroColor,
+  install,
+  uninstall,
+  services: ({ shell, cwd }) => ({ typecheck: new AstroCheckService(shell, cwd) }),
+});
+
+export default astro;

package/src/tool-versions.ts

@@ -0,0 +1,7 @@
+export const TOOL_VERSIONS = {
+  // `install` is the prescriptive pin used by `rr plugins add`'s nypm call.
+  // The looser contracts live in package.json#peerDependencies. `astro` itself
+  // isn't here: the host project owns its framework version.
+  "@astrojs/check": { install: "^0.9.10" },
+  typescript: { install: "^6.0.0" },
+} as const;