@theholocron/cli 5.0.0-alpha.110 → 5.0.0-alpha.111

package/dist/cli.mjs

@@ -2167,14 +2167,16 @@ describe("resolveToken", () => {
 	});
 
 	it("throws AuthError with a helpful message when nothing is set", () => {
-		try {
-			resolveToken({ env: {}, keyring: noKeyring });
-			throw new Error("should have thrown");
-		} catch (err) {
-			expect(err).toBeInstanceOf(AuthError);
-			expect((err as Error).message).toMatch(/${inputs.tokenEnv}/);
-			expect((err as Error).message).toMatch(/holocron auth set ${inputs.slug}/);
-		}
+		const err = (() => {
+			try {
+				resolveToken({ env: {}, keyring: noKeyring });
+			} catch (e) {
+				return e;
+			}
+		})();
+		expect(err).toBeInstanceOf(AuthError);
+		expect((err as Error).message).toMatch(/${inputs.tokenEnv}/);
+		expect((err as Error).message).toMatch(/holocron auth set ${inputs.slug}/);
 	});
 });
 `;
@@ -2218,24 +2220,24 @@ export class ${inputs.capabilityClass} {
 //#endregion
 //#region src/commands/plugin-create/templates/capability-test.ts
 function render$14(inputs) {
-	const clientClass = `${inputs.vendorName}RestClient`;
-	return `import { describe, it } from "vitest";
+	const factoryName = `create${inputs.vendorName}RestClient`;
+	return `import { describe, expect, it } from "vitest";
 
 import { ${inputs.capabilityClass} } from "../capabilities/${inputs.capability}.js";
-import { ${clientClass} } from "../rest.js";
+import { ${factoryName} } from "../rest.js";
 import { stubFetch } from "./helpers.js";
 
 // Stub client used by the constructor smoke test. Real capability
 // tests replace this with per-method stubs once implementations land.
 function makeCapability() {
 	const stub = stubFetch([]);
-	const rest = new ${clientClass}({ token: "t", fetch: stub.fetch });
+	const rest = ${factoryName}({ token: "t", fetch: stub.fetch });
 	return new ${inputs.capabilityClass}(() => rest);
 }
 
 describe("${inputs.capabilityClass}", () => {
 	it("constructs with a REST client", () => {
-		makeCapability();
+		expect(makeCapability().key).toBe("${inputs.capability}");
 	});
 
 	// TODO: implement one test per ${inputs.capability} capability method
@@ -2251,14 +2253,11 @@ describe("${inputs.capabilityClass}", () => {
 //#endregion
 //#region src/commands/plugin-create/templates/eslint-config.ts
 function render$13(_inputs) {
-	return `import root from "../../eslint.config.js";
+	return `import type { Linter } from "eslint";
 
-export default [
-	...root,
-	{
-		ignores: ["dist/**", "coverage/**"],
-	},
-];
+import root from "../../eslint.config.js";
+
+export default [...root, { ignores: ["dist/**", "coverage/**"] }] satisfies Linter.Config[];
 `;
 }
 //#endregion
@@ -2341,10 +2340,17 @@ describe("AUTH_HINT", () => {
 //#endregion
 //#region src/commands/plugin-create/templates/package-json.ts
 function render$10(inputs) {
+	const keywords = [
+		inputs.capability,
+		"holocron",
+		"plugin",
+		inputs.slug
+	].sort((a, b) => a.localeCompare(b));
 	return JSON.stringify({
 		name: `@theholocron/holocron-plugin-${inputs.slug}`,
 		version: "2.0.0-alpha.1",
 		description: `Holocron plugin for ${inputs.vendorName}. Implements the ${inputs.capability} capability against ${inputs.vendorName}'s REST API, plus exports verifyToken + AUTH_HINT for \`holocron auth\`.`,
+		keywords,
 		homepage: `https://github.com/theholocron/holocron/tree/main/packages/holocron-plugin-${inputs.slug}#readme`,
 		bugs: "https://github.com/theholocron/holocron/issues",
 		repository: {
@@ -2354,9 +2360,13 @@ function render$10(inputs) {
 		},
 		license: "MIT",
 		author: "Newton Koumantzelis",
+		sideEffects: false,
 		type: "module",
-		main: "./src/index.ts",
-		exports: { ".": "./src/index.ts" },
+		exports: { ".": {
+			types: "./dist/index.d.mts",
+			import: "./dist/index.mjs",
+			default: "./dist/index.mjs"
+		} },
 		scripts: {
 			"delivery.build": "tsdown",
 			"sourceQuality.staticAnalysis": "holocron run sourceQuality.staticAnalysis --",
@@ -2368,33 +2378,26 @@ function render$10(inputs) {
 		peerDependencies: { "@theholocron/cli": "workspace:*" },
 		devDependencies: {
 			"@theholocron/cli": "workspace:*",
-			"@theholocron/tsconfig": "catalog:",
-			"@tsconfig/node-lts": "catalog:",
+			"@theholocron/tsconfig": "catalog:configs",
+			"@types/node": "catalog:",
 			"@vitest/coverage-v8": "catalog:",
 			eslint: "catalog:",
 			globals: "catalog:",
-			typescript: "catalog:",
-			vitest: "catalog:",
 			tsdown: "catalog:",
-			tsx: "catalog:"
-		},
-		publishConfig: {
-			access: "public",
-			main: "./dist/index.mjs",
-			types: "./dist/index.d.mts",
-			exports: { ".": {
-				types: "./dist/index.d.mts",
-				import: "./dist/index.mjs",
-				default: "./dist/index.mjs"
-			} }
+			tsx: "catalog:",
+			typescript: "catalog:",
+			vitest: "catalog:"
 		},
-		files: ["dist", "README.md"]
-	}, null, "	") + "\n";
+		engines: { node: ">=22" },
+		publishConfig: { access: "public" },
+		files: ["dist"]
+	}, null, 2) + "\n";
 }
 //#endregion
 //#region src/commands/plugin-create/templates/plugin-index.ts
 function render$9(inputs) {
 	const clientClass = `${inputs.vendorName}RestClient`;
+	const factoryName = `create${inputs.vendorName}RestClient`;
 	const capabilityInterface = inputs.capability.charAt(0).toUpperCase() + inputs.capability.slice(1);
 	return `/**
  * \`@theholocron/holocron-plugin-${inputs.slug}\` — entrypoint.
@@ -2411,7 +2414,7 @@ function render$9(inputs) {
 
 import { resolveToken, type ResolveTokenInput } from "./auth.js";
 import { ${inputs.capabilityClass} } from "./capabilities/${inputs.capability}.js";
-import { ${clientClass} } from "./rest.js";
+import { ${factoryName}, type ${clientClass} } from "./rest.js";
 
 export interface ${inputs.vendorName}PluginOptions extends ResolveTokenInput {
 	/** Override base URL for tests. */
@@ -2432,10 +2435,12 @@ export function createContext(options: ${inputs.vendorName}PluginOptions): Plugi
 		options,
 		rest: () => {
 			if (rest) return rest;
-			const restOpts: ConstructorParameters<typeof ${clientClass}>[0] = { token: resolveToken(options) };
+			const restOpts: { token: string; baseUrl?: string; fetch?: typeof fetch } = {
+				token: resolveToken(options),
+			};
 			if (options.baseUrl !== undefined) restOpts.baseUrl = options.baseUrl;
 			if (options.fetch !== undefined) restOpts.fetch = options.fetch;
-			return (rest = new ${clientClass}(restOpts));
+			return (rest = ${factoryName}(restOpts));
 		},
 	};
 }
@@ -2469,7 +2474,7 @@ export const AUTH_HINT =
 // ── Public re-exports ────────────────────────────────────────────────
 
 export * from "./auth.js";
-export { ${clientClass} } from "./rest.js";
+export { type ${clientClass}, ${factoryName} } from "./rest.js";
 export { ${inputs.capabilityClass} } from "./capabilities/${inputs.capability}.js";
 export { verifyToken } from "./verify-token.js";
 export type { VerifyTokenResult, VerifyTokenSuccess, VerifyTokenFailure } from "./verify-token.js";
@@ -2546,15 +2551,26 @@ Not yet published; capability methods are stubs.
 //#endregion
 //#region src/commands/plugin-create/templates/rest.ts
 function render$7(inputs) {
-	return `import { createRestClient, type RequestOptions, type RestClient } from "@theholocron/cli";
+	const factoryName = `create${inputs.vendorName}RestClient`;
+	const clientType = `${inputs.vendorName}RestClient`;
+	return `import { createRestClient, type RestClient } from "@theholocron/cli";
 
-export type { RequestOptions, RestClient };
+export type { RestClient };
 
-export function ${`create${inputs.vendorName}RestClient`}(opts: {
+/**
+ * TODO: narrow this to the specific ${inputs.vendorName} endpoints this
+ * plugin's capability needs (see \`@theholocron/holocron-plugin-axiom\`'s
+ * \`rest.ts\` for the pattern: an interface with one method per endpoint,
+ * built internally via \`createRestClient\`). Starts as an alias for the
+ * generic client so the scaffold compiles end to end immediately.
+ */
+export type ${clientType} = RestClient;
+
+export function ${factoryName}(opts: {
 \ttoken: string;
 \tbaseUrl?: string;
 \tfetch?: typeof fetch;
-}): RestClient {
+}): ${clientType} {
 \treturn createRestClient({
 \t\tbaseUrl: opts.baseUrl ?? "${inputs.baseUrl}",
 \t\ttoken: opts.token,
@@ -2627,7 +2643,7 @@ describe("${factoryName}", () => {
 function render$5(inputs) {
 	return JSON.stringify({
 		display: `Holocron Plugin: ${inputs.vendorName}`,
-		extends: "@tsconfig/node-lts/tsconfig.json",
+		extends: "@theholocron/tsconfig/node-lts",
 		compilerOptions: {
 			baseUrl: "./",
 			outDir: "./dist",
@@ -2635,7 +2651,7 @@ function render$5(inputs) {
 		},
 		include: ["src/**/*.ts"],
 		exclude: ["node_modules", "dist"]
-	}, null, "	") + "\n";
+	}, null, 2) + "\n";
 }
 //#endregion
 //#region src/commands/plugin-create/templates/tsdown-config.ts
@@ -2751,6 +2767,7 @@ console.log("Done. Fill in capability method calls above before shipping.");
 // ── helpers ────────────────────────────────────────────────────────
 
 /** Wrap a capability call, print ERROR + hint on failure. */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- called once a real capability check replaces the TODO example above
 async function runStep(body) {
 	try {
 		await body();
@@ -2790,7 +2807,7 @@ function hintFor(message) {
 //#endregion
 //#region src/commands/plugin-create/templates/verify-token.ts
 function render$2(inputs) {
-	const clientClass = `${inputs.vendorName}RestClient`;
+	const factoryName = `create${inputs.vendorName}RestClient`;
 	return `/**
  * \`verifyToken\` — plugin-level export used by \`holocron auth set\` +
  * \`holocron auth check\`. Hits a lightweight whoami-style endpoint
@@ -2807,7 +2824,7 @@ function render$2(inputs) {
  * \`/me\`, \`/account\`.
  */
 
-import { ${clientClass} } from "./rest.js";
+import { ${factoryName} } from "./rest.js";
 
 export interface VerifyTokenSuccess {
 	ok: true;
@@ -2834,10 +2851,10 @@ export interface VerifyTokenOptions {
 }
 
 export async function verifyToken(token: string, opts: VerifyTokenOptions = {}): Promise<VerifyTokenResult> {
-	const restOpts: ConstructorParameters<typeof ${clientClass}>[0] = { token };
+	const restOpts: { token: string; baseUrl?: string; fetch?: typeof fetch } = { token };
 	if (opts.baseUrl !== undefined) restOpts.baseUrl = opts.baseUrl;
 	if (opts.fetch !== undefined) restOpts.fetch = opts.fetch;
-	const rest = new ${clientClass}(restOpts);
+	const rest = ${factoryName}(restOpts);
 	try {
 		const me = await rest.request<MeResponse>("/me");
 		// Optional chaining because \`me\` is \`undefined\` on 204 / empty body.
@@ -2863,18 +2880,14 @@ describe("verifyToken", () => {
 		const stub = stubFetch([{ status: 200, body: { email: "user@example.com" } }]);
 		const result = await verifyToken("token", { fetch: stub.fetch });
 		expect(result.ok).toBe(true);
-		if (result.ok) {
-			expect(result.subject).toMatch(/user@example.com/);
-		}
+		expect((result as { ok: boolean; subject?: string }).subject).toMatch(/user@example.com/);
 	});
 
 	it("returns ok:false with the error message on 401", async () => {
 		const stub = stubFetch([{ status: 401, body: { messages: ["Invalid token"] } }]);
 		const result = await verifyToken("bad", { fetch: stub.fetch });
 		expect(result.ok).toBe(false);
-		if (!result.ok) {
-			expect(result.message).toMatch(/→ 401/);
-		}
+		expect((result as { ok: boolean; message?: string }).message).toMatch(/→ 401/);
 	});
 
 	it("returns ok:false when the network layer throws", async () => {
@@ -2883,9 +2896,7 @@ describe("verifyToken", () => {
 		};
 		const result = await verifyToken("t", { fetch: throwing });
 		expect(result.ok).toBe(false);
-		if (!result.ok) {
-			expect(result.message).toMatch(/network down/);
-		}
+		expect((result as { ok: boolean; message?: string }).message).toMatch(/network down/);
 	});
 });
 `;
@@ -2959,7 +2970,7 @@ const TEMPLATES = [
 		render
 	},
 	{
-		path: "eslint.config.js",
+		path: "eslint.config.ts",
 		render: render$13
 	},
 	{