render-create 0.1.0

package/dist/commands/sync.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sync command - Update local rules with the latest package templates
+ */
+import type { SyncOptions } from "../types.js";
+/**
+ * Main sync command handler
+ */
+export declare function sync(options: SyncOptions): Promise<void>;

package/dist/commands/sync.js

@@ -0,0 +1,126 @@
+/**
+ * Sync command - Update local rules with the latest package templates
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { compareFiles, copyTemplate, displayDiff, getTargetDir, TEMPLATES_DIR } from "../utils.js";
+/**
+ * Get list of synced files in the target project
+ */
+function getSyncedFiles(targetDir) {
+    const rules = [];
+    const configs = [];
+    // Check for cursor rules
+    const rulesDir = join(targetDir, ".cursor", "rules");
+    if (existsSync(rulesDir)) {
+        const files = readdirSync(rulesDir);
+        for (const file of files) {
+            if (file.endsWith(".mdc")) {
+                rules.push(file.replace(".mdc", ""));
+            }
+        }
+    }
+    // Check for config files
+    if (existsSync(join(targetDir, "biome.json"))) {
+        configs.push("biome");
+    }
+    if (existsSync(join(targetDir, "ruff.toml"))) {
+        configs.push("ruff");
+    }
+    if (existsSync(join(targetDir, "tsconfig.base.json"))) {
+        configs.push("tsconfig");
+    }
+    return { rules, configs };
+}
+/**
+ * Main sync command handler
+ */
+export async function sync(options) {
+    const targetDir = getTargetDir();
+    const { rules, configs } = getSyncedFiles(targetDir);
+    if (rules.length === 0 && configs.length === 0) {
+        console.log(chalk.yellow("No cursor-rules files found in this project."));
+        console.log(chalk.gray("Run 'npx @render-examples/cursor-rules init' to set up."));
+        return;
+    }
+    console.log(chalk.blue("Checking for updates...\n"));
+    const outOfSync = [];
+    // Check rule files
+    for (const rule of rules) {
+        const templatePath = `cursor/rules/${rule}.mdc`;
+        const targetPath = join(targetDir, ".cursor", "rules", `${rule}.mdc`);
+        // Check if template exists
+        if (!existsSync(join(TEMPLATES_DIR, templatePath))) {
+            console.log(chalk.yellow(`  ${rule}.mdc - custom rule (no template)`));
+            continue;
+        }
+        const result = compareFiles(templatePath, targetPath);
+        if (result.status === "in-sync") {
+            console.log(chalk.green(`  ${rule}.mdc - up to date`));
+        }
+        else if (result.status === "out-of-sync" && result.diff) {
+            console.log(chalk.yellow(`  ${rule}.mdc - out of sync`));
+            outOfSync.push({ templatePath, targetPath, diff: result.diff });
+        }
+    }
+    // Check config files
+    const configMappings = {
+        biome: { template: "biome.json", target: "biome.json" },
+        ruff: { template: "ruff.toml", target: "ruff.toml" },
+        tsconfig: { template: "tsconfig.base.json", target: "tsconfig.base.json" },
+    };
+    for (const config of configs) {
+        const mapping = configMappings[config];
+        if (!mapping) {
+            continue;
+        }
+        const targetPath = join(targetDir, mapping.target);
+        const result = compareFiles(mapping.template, targetPath);
+        if (result.status === "in-sync") {
+            console.log(chalk.green(`  ${mapping.target} - up to date`));
+        }
+        else if (result.status === "out-of-sync" && result.diff) {
+            console.log(chalk.yellow(`  ${mapping.target} - out of sync`));
+            outOfSync.push({ templatePath: mapping.template, targetPath, diff: result.diff });
+        }
+    }
+    if (outOfSync.length === 0) {
+        console.log(chalk.green("\nAll files are up to date!"));
+        return;
+    }
+    console.log(chalk.yellow(`\n${outOfSync.length} file(s) out of sync.`));
+    // Show diffs if not in dry-run mode
+    if (options.dryRun) {
+        console.log(chalk.gray("\n--dry-run: Showing diffs without applying changes:\n"));
+        for (const file of outOfSync) {
+            displayDiff(file.diff, file.targetPath);
+        }
+        return;
+    }
+    // Confirm before updating
+    if (!options.force) {
+        for (const file of outOfSync) {
+            displayDiff(file.diff, file.targetPath);
+        }
+        const { confirm } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "Apply these changes?",
+                default: false,
+            },
+        ]);
+        if (!confirm) {
+            console.log(chalk.gray("Sync cancelled."));
+            return;
+        }
+    }
+    // Apply updates
+    console.log(chalk.blue("\nApplying updates...\n"));
+    for (const file of outOfSync) {
+        copyTemplate(file.templatePath, file.targetPath);
+    }
+    console.log(chalk.green("\nSync complete!"));
+}

package/dist/types.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Type definitions for cursor-rules CLI
+ */
+/** Environment variable from key/value */
+export interface EnvVarKeyValue {
+    key: string;
+    value?: string;
+    generateValue?: boolean;
+    sync?: boolean;
+}
+/** Environment variable from database reference */
+export interface EnvVarFromDatabase {
+    key: string;
+    fromDatabase: {
+        name: string;
+        property: string;
+    };
+}
+/** Environment variable from service reference */
+export interface EnvVarFromService {
+    key: string;
+    fromService: {
+        type: string;
+        name: string;
+        property?: string;
+        envVarKey?: string;
+    };
+}
+export type BlueprintEnvVar = EnvVarKeyValue | EnvVarFromDatabase | EnvVarFromService;
+/** Route configuration for static sites */
+export interface BlueprintRoute {
+    type: "redirect" | "rewrite";
+    source: string;
+    destination: string;
+}
+/** Service definition in blueprint */
+export interface BlueprintService {
+    type: "web" | "worker" | "pserv" | "cron";
+    name?: string;
+    runtime: "node" | "python" | "docker" | "static" | "go" | "rust" | "ruby" | "elixir";
+    plan?: string;
+    rootDir?: string;
+    buildCommand?: string;
+    startCommand?: string;
+    healthCheckPath?: string;
+    staticPublishPath?: string;
+    envVars?: BlueprintEnvVar[];
+    routes?: BlueprintRoute[];
+}
+/** Database definition in blueprint */
+export interface BlueprintDatabase {
+    name: string;
+    plan?: string;
+    postgresMajorVersion?: string;
+}
+/** Key Value (Redis) definition in blueprint */
+export interface BlueprintKeyValue {
+    type: "keyvalue";
+    name: string;
+    plan?: string;
+    maxmemoryPolicy?: string;
+    ipAllowList?: Array<{
+        source: string;
+        description?: string;
+    }>;
+}
+/** Blueprint configuration for render.yaml */
+export interface BlueprintConfig {
+    services?: BlueprintService[];
+    databases?: BlueprintDatabase[];
+    keyValues?: BlueprintKeyValue[];
+}
+export interface Preset {
+    name: string;
+    description: string;
+    rules: string[];
+    configs: string[];
+    /** Package manager to use (npm, pnpm, yarn, pip) */
+    packageManager?: "npm" | "pnpm" | "yarn" | "pip";
+    /** Command to scaffold the project (e.g., npx create-next-app) */
+    createCommand?: string;
+    /** Dependencies to add after create command */
+    postCreateDependencies?: string[];
+    /** Dev dependencies to add after create command */
+    postCreateDevDependencies?: string[];
+    /** Scripts to add to package.json after create */
+    postCreateScripts?: Record<string, string>;
+    /** Files to copy after create command (target -> template source) */
+    postCreateFiles?: Record<string, string>;
+    /** Files to delete after create command */
+    postCreateDelete?: string[];
+    /** For presets without createCommand: npm dependencies */
+    dependencies?: string[];
+    /** For presets without createCommand: npm dev dependencies */
+    devDependencies?: string[];
+    /** For presets without createCommand: scripts for package.json */
+    scripts?: Record<string, string>;
+    /** For presets without createCommand: files to scaffold (target -> template) */
+    scaffoldFiles?: Record<string, string>;
+    /** Python dependencies for requirements.txt */
+    pythonDependencies?: string[];
+    /** Render Blueprint configuration */
+    blueprint?: BlueprintConfig;
+}
+export interface PresetsConfig {
+    presets: Record<string, Preset>;
+    components?: ComponentsConfig;
+}
+/** Base component definition */
+export interface BaseComponent {
+    name: string;
+    description?: string;
+    subdir: string;
+    rules?: string[];
+    configs?: string[];
+}
+/** Blueprint config for frontend deploy types */
+export interface FrontendBlueprintConfig {
+    type: "web";
+    runtime: "node" | "static";
+    buildCommand: string;
+    startCommand?: string;
+    staticPublishPath?: string;
+    healthCheckPath?: string;
+    envVars?: BlueprintEnvVar[];
+    routes?: BlueprintRoute[];
+}
+/** Frontend component (Next.js, Vite) */
+export interface FrontendComponent extends BaseComponent {
+    createCommand: string;
+    postCreateDependencies?: string[];
+    postCreateDevDependencies?: string[];
+    postCreateScripts?: Record<string, string>;
+    /** Files to copy for static deploy */
+    postCreateFilesStatic?: Record<string, string>;
+    /** Files to copy for webservice deploy */
+    postCreateFilesWebservice?: Record<string, string>;
+    /** Files to copy for both deploy types */
+    postCreateFiles?: Record<string, string>;
+    postCreateDelete?: string[];
+    /** Whether this frontend supports webservice deploy (default: true for Next.js, false for Vite) */
+    supportsWebservice?: boolean;
+    /** Blueprint config for static deploy */
+    blueprintStatic: FrontendBlueprintConfig;
+    /** Blueprint config for webservice deploy */
+    blueprintWebservice?: FrontendBlueprintConfig;
+}
+/** API component (Fastify, FastAPI) */
+export interface ApiComponent extends BaseComponent {
+    runtime: "node" | "python";
+    /** For Node.js APIs */
+    dependencies?: string[];
+    devDependencies?: string[];
+    scripts?: Record<string, string>;
+    /** For Python APIs */
+    pythonDependencies?: string[];
+    scaffoldFiles: Record<string, string>;
+    blueprint: {
+        type: "web";
+        runtime: "node" | "python";
+        buildCommand: string;
+        startCommand: string;
+        healthCheckPath: string;
+        envVars?: BlueprintEnvVar[];
+    };
+}
+/** Worker type for async components */
+export type WorkerType = "worker" | "cron" | "workflow";
+/** Worker/Cron/Workflow component */
+export interface WorkerComponent extends BaseComponent {
+    workerType: WorkerType;
+    runtime: "node" | "python";
+    /** SDK to install (e.g., @renderinc/sdk for workflows) */
+    sdk?: string;
+    /** For Node.js workers */
+    dependencies?: string[];
+    devDependencies?: string[];
+    scripts?: Record<string, string>;
+    /** For Python workers */
+    pythonDependencies?: string[];
+    scaffoldFiles: Record<string, string>;
+    /** Blueprint config - not available for workflows yet */
+    blueprint?: {
+        type: "worker" | "cron";
+        runtime: "node" | "python";
+        buildCommand: string;
+        startCommand: string;
+        schedule?: string;
+        envVars?: BlueprintEnvVar[];
+    };
+}
+/** Database component (PostgreSQL) */
+export interface DatabaseComponent {
+    name: string;
+    description?: string;
+    blueprint: BlueprintDatabase;
+}
+/** Cache component (Redis/KeyVal) */
+export interface CacheComponent {
+    name: string;
+    description?: string;
+    blueprint: BlueprintKeyValue;
+}
+/** All components configuration */
+export interface ComponentsConfig {
+    frontends: Record<string, FrontendComponent>;
+    apis: Record<string, ApiComponent>;
+    workers: Record<string, WorkerComponent>;
+    databases: Record<string, DatabaseComponent>;
+    caches: Record<string, CacheComponent>;
+}
+/** User's composable selection */
+/** Deploy type for frontend services */
+export type DeployType = "static" | "webservice";
+export interface ComposableSelection {
+    projectName: string;
+    frontend: string | null;
+    frontendDeployType: DeployType | null;
+    apis: string[];
+    workers: string[];
+    database: string | null;
+    cache: string | null;
+    extras: string[];
+}
+export interface InitOptions {
+    preset?: string;
+    yes?: boolean;
+    name?: string;
+    skipInstall?: boolean;
+}
+export interface SyncOptions {
+    force?: boolean;
+    dryRun?: boolean;
+}
+export interface CheckOptions {
+    ci?: boolean;
+}
+export type FileStatus = "in-sync" | "out-of-sync" | "local-missing" | "template-missing";
+export interface CompareResult {
+    status: FileStatus;
+    diff: import("diff").Change[] | null;
+}
+export interface FileMapping {
+    template: string;
+    target: string;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for cursor-rules CLI
+ */
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Utility functions for file operations, prompts, and diff display
+ */
+import { type Change } from "diff";
+import type { CompareResult, PresetsConfig } from "./types.js";
+/** Path to templates directory */
+export declare const TEMPLATES_DIR: string;
+/** Path to presets.json */
+export declare const PRESETS_PATH: string;
+/**
+ * Load presets configuration
+ */
+export declare function loadPresets(): PresetsConfig;
+/**
+ * Ensure a directory exists, creating it if necessary
+ */
+export declare function ensureDir(dirPath: string): void;
+/**
+ * Copy a template file to the target project
+ */
+export declare function copyTemplate(templatePath: string, targetPath: string): boolean;
+/**
+ * Copy a template file with variable substitution
+ */
+export declare function copyTemplateWithVars(templatePath: string, targetPath: string, vars?: Record<string, string>): boolean;
+/**
+ * Read a file, returning null if it doesn't exist
+ */
+export declare function readFileSafe(filePath: string): string | null;
+/**
+ * Compare two files and return diff
+ */
+export declare function compareFiles(templatePath: string, localPath: string): CompareResult;
+/**
+ * Display a diff in the terminal
+ */
+export declare function displayDiff(diff: Change[], filePath: string): void;
+/**
+ * Get the current working directory (target project)
+ */
+export declare function getTargetDir(): string;
+/**
+ * Check if we're in a valid project directory
+ */
+export declare function isValidProjectDir(): boolean;
+/**
+ * Get list of rules for a preset
+ */
+export declare function getRulesForPreset(presetId: string): string[];
+/**
+ * Get list of configs for a preset
+ */
+export declare function getConfigsForPreset(presetId: string): string[];

package/dist/utils.js

@@ -0,0 +1,142 @@
+/**
+ * Utility functions for file operations, prompts, and diff display
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { diffLines } from "diff";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/** Path to templates directory */
+export const TEMPLATES_DIR = resolve(__dirname, "../templates");
+/** Path to presets.json */
+export const PRESETS_PATH = join(TEMPLATES_DIR, "presets.json");
+/**
+ * Load presets configuration
+ */
+export function loadPresets() {
+    const content = readFileSync(PRESETS_PATH, "utf-8");
+    return JSON.parse(content);
+}
+/**
+ * Ensure a directory exists, creating it if necessary
+ */
+export function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Copy a template file to the target project
+ */
+export function copyTemplate(templatePath, targetPath) {
+    const sourcePath = join(TEMPLATES_DIR, templatePath);
+    if (!existsSync(sourcePath)) {
+        console.log(chalk.yellow(`  Warning: Template not found: ${templatePath}`));
+        return false;
+    }
+    ensureDir(dirname(targetPath));
+    copyFileSync(sourcePath, targetPath);
+    console.log(chalk.green(`  Created ${targetPath}`));
+    return true;
+}
+/**
+ * Copy a template file with variable substitution
+ */
+export function copyTemplateWithVars(templatePath, targetPath, vars = {}) {
+    const sourcePath = join(TEMPLATES_DIR, templatePath);
+    if (!existsSync(sourcePath)) {
+        console.log(chalk.yellow(`  Warning: Template not found: ${templatePath}`));
+        return false;
+    }
+    let content = readFileSync(sourcePath, "utf-8");
+    // Replace {{VAR_NAME}} patterns
+    for (const [key, value] of Object.entries(vars)) {
+        content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+    }
+    ensureDir(dirname(targetPath));
+    writeFileSync(targetPath, content);
+    console.log(chalk.green(`  Created ${targetPath}`));
+    return true;
+}
+/**
+ * Read a file, returning null if it doesn't exist
+ */
+export function readFileSafe(filePath) {
+    try {
+        return readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compare two files and return diff
+ */
+export function compareFiles(templatePath, localPath) {
+    const templateContent = readFileSafe(join(TEMPLATES_DIR, templatePath));
+    const localContent = readFileSafe(localPath);
+    if (!templateContent) {
+        return { status: "template-missing", diff: null };
+    }
+    if (!localContent) {
+        return { status: "local-missing", diff: null };
+    }
+    if (templateContent === localContent) {
+        return { status: "in-sync", diff: null };
+    }
+    const diff = diffLines(localContent, templateContent);
+    return { status: "out-of-sync", diff };
+}
+/**
+ * Display a diff in the terminal
+ */
+export function displayDiff(diff, filePath) {
+    console.log(chalk.cyan(`\n--- ${filePath}`));
+    for (const part of diff) {
+        if (part.added) {
+            process.stdout.write(chalk.green(part.value));
+        }
+        else if (part.removed) {
+            process.stdout.write(chalk.red(part.value));
+        }
+        else {
+            process.stdout.write(chalk.gray(part.value));
+        }
+    }
+    console.log();
+}
+/**
+ * Get the current working directory (target project)
+ */
+export function getTargetDir() {
+    return process.cwd();
+}
+/**
+ * Check if we're in a valid project directory
+ */
+export function isValidProjectDir() {
+    const cwd = getTargetDir();
+    // Check for common project indicators
+    return (existsSync(join(cwd, "package.json")) ||
+        existsSync(join(cwd, "requirements.txt")) ||
+        existsSync(join(cwd, "pyproject.toml")) ||
+        existsSync(join(cwd, ".git")));
+}
+/**
+ * Get list of rules for a preset
+ */
+export function getRulesForPreset(presetId) {
+    const presets = loadPresets();
+    const preset = presets.presets[presetId];
+    return preset?.rules ?? [];
+}
+/**
+ * Get list of configs for a preset
+ */
+export function getConfigsForPreset(presetId) {
+    const presets = loadPresets();
+    const preset = presets.presets[presetId];
+    return preset?.configs ?? [];
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "render-create",
+  "version": "0.1.0",
+  "description": "CLI to scaffold and deploy applications on Render with best practices, Cursor rules, and Infrastructure as Code",
+  "type": "module",
+  "bin": {
+    "render-create": "dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/R4ph-t/render-create-demo.git"
+  },
+  "homepage": "https://github.com/R4ph-t/render-create-demo#readme",
+  "bugs": {
+    "url": "https://github.com/R4ph-t/render-create-demo/issues"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "biome check .",
+    "format": "biome check --write .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build",
+    "preversion": "npm run lint && npm run build && npm test",
+    "postversion": "git push && git push --tags",
+    "release:patch": "npm version patch",
+    "release:minor": "npm version minor",
+    "release:major": "npm version major"
+  },
+  "keywords": [
+    "render",
+    "create",
+    "scaffold",
+    "deploy",
+    "template",
+    "cursor",
+    "cli",
+    "infrastructure-as-code",
+    "blueprint"
+  ],
+  "author": "Render",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "diff": "^7.0.0",
+    "inquirer": "^12.3.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.0.0",
+    "@types/diff": "^7.0.0",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}