@checkstack/scripts 0.0.2

package/src/templates.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import {
+  copyTemplate,
+  prepareTemplateData,
+  registerHelpers,
+} from "./utils/template";
+import { execSync } from "node:child_process";
+import { rmSync, existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const TEST_BASE_NAME = "scaffoldtest";
+const TEST_SCAFFOLDS_DIR = "plugins/_test-scaffolds";
+
+// Plugin types to test - these have the most template complexity
+// Order matters: common must be scaffolded before frontend (frontend depends on common)
+const PLUGIN_TYPES = ["common", "backend", "frontend"] as const;
+
+describe("CLI Template Scaffolding", () => {
+  const rootDir = path.resolve(__dirname, "../../..");
+  const scaffoldsDir = path.join(rootDir, TEST_SCAFFOLDS_DIR);
+
+  beforeAll(() => {
+    registerHelpers();
+
+    // Clean up any previous test scaffolds
+    if (existsSync(scaffoldsDir)) {
+      rmSync(scaffoldsDir, { recursive: true });
+    }
+
+    // Ensure the test scaffolds directory exists
+    mkdirSync(scaffoldsDir, { recursive: true });
+
+    // Scaffold ALL plugins first (order matters for dependencies)
+    for (const pluginType of PLUGIN_TYPES) {
+      const templateData = prepareTemplateData({
+        baseName: TEST_BASE_NAME,
+        pluginType,
+        description: `Test ${pluginType} plugin for template validation`,
+      });
+
+      const templateDir = path.join(__dirname, "templates", pluginType);
+      const targetDir = path.join(scaffoldsDir, templateData.pluginName);
+
+      copyTemplate({
+        templateDir,
+        targetDir,
+        data: templateData,
+      });
+    }
+
+    // Run bun install ONCE after all plugins are scaffolded
+    // This ensures workspace dependencies are resolved correctly
+    execSync("bun install", {
+      cwd: rootDir,
+      stdio: "pipe",
+      timeout: 120_000,
+    });
+  });
+
+  afterAll(() => {
+    // Cleanup all test packages
+    if (existsSync(scaffoldsDir)) {
+      rmSync(scaffoldsDir, { recursive: true });
+    }
+
+    // Re-run bun install to remove stale entries from bun.lock
+    execSync("bun install", {
+      cwd: rootDir,
+      stdio: "pipe",
+      timeout: 60_000,
+    });
+  });
+
+  for (const pluginType of PLUGIN_TYPES) {
+    const pluginName = `${TEST_BASE_NAME}-${pluginType}`;
+    const targetDir = path.join(scaffoldsDir, pluginName);
+
+    describe(`${pluginType} plugin template`, () => {
+      it("should have scaffolded files", () => {
+        expect(existsSync(path.join(targetDir, "package.json"))).toBe(true);
+        expect(existsSync(path.join(targetDir, "src"))).toBe(true);
+        expect(existsSync(path.join(targetDir, "tsconfig.json"))).toBe(true);
+      });
+
+      it(
+        "should pass typecheck",
+        () => {
+          try {
+            execSync(
+              `bun run --filter '@checkstack/${pluginName}' typecheck`,
+              {
+                cwd: rootDir,
+                stdio: "pipe",
+                timeout: 60_000,
+              }
+            );
+          } catch (error) {
+            const execError = error as { stderr?: Buffer; stdout?: Buffer };
+            const stderr = execError.stderr?.toString() ?? "";
+            const stdout = execError.stdout?.toString() ?? "";
+            throw new Error(
+              `Typecheck failed for ${pluginName}:\n${stderr}\n${stdout}`
+            );
+          }
+        },
+        { timeout: 30_000 }
+      );
+
+      it(
+        "should pass lint",
+        () => {
+          try {
+            execSync(`bun run eslint ${TEST_SCAFFOLDS_DIR}/${pluginName}`, {
+              cwd: rootDir,
+              stdio: "pipe",
+              timeout: 60_000,
+            });
+          } catch (error) {
+            const execError = error as { stderr?: Buffer; stdout?: Buffer };
+            const stderr = execError.stderr?.toString() ?? "";
+            const stdout = execError.stdout?.toString() ?? "";
+            throw new Error(
+              `Lint failed for ${pluginName}:\n${stderr}\n${stdout}`
+            );
+          }
+        },
+        { timeout: 30_000 }
+      );
+    });
+  }
+});

package/src/utils/template.ts

@@ -0,0 +1,154 @@
+import Handlebars from "handlebars";
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+} from "node:fs";
+import path from "node:path";
+
+export interface TemplateData {
+  pluginName: string;
+  pluginBaseName: string;
+  pluginNamePascal: string;
+  pluginNameCamel: string;
+  pluginDescription: string;
+  pluginId: string;
+  pluginType: string;
+  currentYear: number;
+}
+
+/**
+ * Register custom Handlebars helpers for common case transformations
+ */
+export function registerHelpers() {
+  Handlebars.registerHelper("pascalCase", (value: string) => {
+    return value
+      .split("-")
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join("");
+  });
+
+  Handlebars.registerHelper("camelCase", (value: string) => {
+    const pascal = value
+      .split("-")
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join("");
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  });
+
+  Handlebars.registerHelper("kebabCase", (value: string) => {
+    return value.toLowerCase().replaceAll(/\s+/g, "-");
+  });
+
+  Handlebars.registerHelper("year", () => {
+    return new Date().getFullYear();
+  });
+}
+
+/**
+ * Process a single template file using Handlebars
+ */
+export function processTemplate(content: string, data: TemplateData): string {
+  const template = Handlebars.compile(content);
+  return template(data);
+}
+
+/**
+ * Recursively copy template directory and process .hbs files
+ */
+export function copyTemplate({
+  templateDir,
+  targetDir,
+  data,
+}: {
+  templateDir: string;
+  targetDir: string;
+  data: TemplateData;
+}): string[] {
+  const createdFiles: string[] = [];
+
+  // Create target directory if it doesn't exist
+  if (!statSync(targetDir, { throwIfNoEntry: false })) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  // Read all items in template directory
+  const items = readdirSync(templateDir);
+
+  for (const item of items) {
+    const templatePath = path.join(templateDir, item);
+    const stat = statSync(templatePath);
+
+    if (stat.isDirectory()) {
+      // Recursively copy directories
+      const newTargetDir = path.join(targetDir, item);
+      const subFiles = copyTemplate({
+        templateDir: templatePath,
+        targetDir: newTargetDir,
+        data,
+      });
+      createdFiles.push(...subFiles);
+    } else if (stat.isFile()) {
+      // Process files
+      const isTemplate = item.endsWith(".hbs");
+      let targetFileName = isTemplate ? item.slice(0, -4) : item; // Remove .hbs extension
+
+      // Process Handlebars patterns in filename
+      if (targetFileName.includes("{{")) {
+        targetFileName = processTemplate(targetFileName, data);
+      }
+
+      const targetPath = path.join(targetDir, targetFileName);
+
+      if (isTemplate) {
+        // Process Handlebars template
+        const content = readFileSync(templatePath, "utf8");
+        const processed = processTemplate(content, data);
+        writeFileSync(targetPath, processed, "utf8");
+      } else {
+        // Copy non-template files as-is
+        const content = readFileSync(templatePath);
+        writeFileSync(targetPath, content);
+      }
+
+      createdFiles.push(targetPath);
+    }
+  }
+
+  return createdFiles;
+}
+
+/**
+ * Prepare template data from user inputs
+ */
+export function prepareTemplateData({
+  baseName,
+  pluginType,
+  description,
+}: {
+  baseName: string;
+  pluginType: string;
+  description: string;
+}): TemplateData {
+  const pluginName = `${baseName}-${pluginType}`;
+  const pluginNamePascal = baseName
+    .split("-")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("");
+
+  const pluginNameCamel =
+    pluginNamePascal.charAt(0).toLowerCase() + pluginNamePascal.slice(1);
+
+  return {
+    pluginName,
+    pluginBaseName: baseName,
+    pluginNamePascal,
+    pluginNameCamel,
+    pluginDescription: description,
+    pluginId: pluginName,
+    pluginType,
+    currentYear: new Date().getFullYear(),
+  };
+}

package/src/utils/validation.ts

@@ -0,0 +1,110 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+const RESERVED_NAMES = new Set(["checkstack", "core", "api", "common"]);
+
+/**
+ * Validate plugin name follows naming conventions
+ */
+export function validatePluginName(name: string): {
+  valid: boolean;
+  error?: string;
+} {
+  // Must not be empty
+  if (!name || name.trim().length === 0) {
+    return { valid: false, error: "Plugin name cannot be empty" };
+  }
+
+  // Must be lowercase
+  if (name !== name.toLowerCase()) {
+    return {
+      valid: false,
+      error: "Plugin name must be lowercase (use hyphens for word separation)",
+    };
+  }
+
+  // Can only contain lowercase letters, numbers, and hyphens
+  if (!/^[\da-z-]+$/.test(name)) {
+    return {
+      valid: false,
+      error:
+        "Plugin name can only contain lowercase letters, numbers, and hyphens",
+    };
+  }
+
+  // Cannot start or end with hyphen
+  if (name.startsWith("-") || name.endsWith("-")) {
+    return {
+      valid: false,
+      error: "Plugin name cannot start or end with a hyphen",
+    };
+  }
+
+  // Cannot have consecutive hyphens
+  if (name.includes("--")) {
+    return {
+      valid: false,
+      error: "Plugin name cannot contain consecutive hyphens",
+    };
+  }
+
+  // Check reserved names
+  if (RESERVED_NAMES.has(name)) {
+    return {
+      valid: false,
+      error: `'${name}' is a reserved name and cannot be used`,
+    };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Check if a plugin already exists
+ */
+export function pluginExists({
+  baseName,
+  pluginType,
+  rootDir,
+}: {
+  baseName: string;
+  pluginType: string;
+  rootDir: string;
+}): boolean {
+  const pluginName = `${baseName}-${pluginType}`;
+  const pluginPath = path.join(rootDir, "plugins", pluginName);
+  return existsSync(pluginPath);
+}
+
+/**
+ * Check if a package already exists in core/
+ */
+export function packageExists({
+  baseName,
+  pluginType,
+  rootDir,
+}: {
+  baseName: string;
+  pluginType: string;
+  rootDir: string;
+}): boolean {
+  const packageName = `${baseName}-${pluginType}`;
+  const packagePath = path.join(rootDir, "core", packageName);
+  return existsSync(packagePath);
+}
+
+/**
+ * Extract base name from full plugin name if provided
+ * e.g., "catalog-backend" -> "catalog"
+ */
+export function extractBaseName(fullName: string): string {
+  const parts = fullName.split("-");
+  if (parts.length > 1) {
+    const lastPart = parts.at(-1);
+    const knownTypes = ["backend", "frontend", "common", "node", "react"];
+    if (lastPart && knownTypes.includes(lastPart)) {
+      return parts.slice(0, -1).join("-");
+    }
+  }
+  return fullName;
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "@checkstack/tsconfig/backend.json",
+  "include": [
+    "src"
+  ]
+}