@reliverse/rempts 2.2.9 → 2.3.1

package/templates/advanced/src/commands/validate.ts

@@ -0,0 +1,130 @@
+import { relico } from "@reliverse/relico";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { loadConfig } from "../utils/config";
+import { glob } from "../utils/glob";
+import { validateFiles } from "../utils/validator";
+
+const validateCommand = defineCommand({
+  name: "validate",
+  description: "Validate files against defined rules",
+  options: {
+    config: option(
+      type("string | undefined").narrow((s, ctx) => {
+        if (!s) {
+          return true;
+        }
+        return (
+          s.endsWith(".json") ||
+          s.endsWith(".ts") ||
+          s.endsWith(".js") ||
+          ctx.reject(`Config file must be .json, .ts, or .js (was "${s}")`)
+        );
+      }),
+      {
+        short: "c",
+        description: "Path to config file (.json, .ts, or .js)",
+      }
+    ),
+    fix: option(
+      type("boolean").pipe((v) => v ?? false),
+      {
+        short: "f",
+        description: "Auto-fix issues",
+      }
+    ),
+    cache: option(
+      type("boolean").pipe((v) => v ?? true),
+      {
+        description: "Enable caching",
+      }
+    ),
+    files: option(type("string | undefined"), {
+      description: "Files to validate (if not specified, uses config patterns)",
+    }),
+  },
+  handler: async ({ positional, flags, spinner }) => {
+    const spin = spinner("Loading configuration...");
+    spin.start();
+
+    try {
+      // Load config
+      const config = await loadConfig(flags.config);
+      spin.succeed("Configuration loaded");
+
+      // Resolve files
+      const fileSpin = spinner("Resolving files...");
+      fileSpin.start();
+
+      const files = await glob(flags.files ? [flags.files] : positional, {
+        include: config.include,
+        exclude: config.exclude,
+      });
+
+      fileSpin.succeed(`Found ${files.length} files to validate`);
+
+      if (files.length === 0) {
+        console.log(relico.yellow("No files matched the pattern"));
+        return;
+      }
+
+      // Run validation
+      const validateSpin = spinner("Validating files...");
+      validateSpin.start();
+
+      const results = await validateFiles(files, {
+        rules: config.rules,
+        fix: flags.fix,
+        cache: flags.cache && config.cache?.enabled,
+      });
+
+      validateSpin.stop();
+
+      // Display results
+      let hasErrors = false;
+
+      for (const result of results) {
+        if (result.errors.length > 0 || result.warnings.length > 0) {
+          console.log();
+          console.log(relico.bold(result.file));
+
+          for (const error of result.errors) {
+            console.log(relico.red(`  ✗ ${error.line}:${error.column} ${error.message}`));
+            hasErrors = true;
+          }
+
+          for (const warning of result.warnings) {
+            console.log(relico.yellow(`  ⚠ ${warning.line}:${warning.column} ${warning.message}`));
+          }
+        }
+      }
+
+      // Summary
+      const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+      const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0);
+
+      console.log();
+      if (totalErrors === 0 && totalWarnings === 0) {
+        console.log(relico.green("✅ All files passed validation!"));
+      } else {
+        console.log(relico.bold("Summary:"));
+        if (totalErrors > 0) {
+          console.log(relico.red(`  ${totalErrors} error${totalErrors !== 1 ? "s" : ""}`));
+        }
+        if (totalWarnings > 0) {
+          console.log(relico.yellow(`  ${totalWarnings} warning${totalWarnings !== 1 ? "s" : ""}`));
+        }
+
+        if (hasErrors) {
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      spin.fail("Validation failed");
+      console.error(relico.red(String(error)));
+      process.exit(1);
+    }
+  },
+});
+
+export default validateCommand;

package/templates/advanced/src/mod.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+import { createCLI } from "@reliverse/rempts-core";
+import configCommand from "./commands/config";
+import initCommand from "./commands/init";
+import serveCommand from "./commands/serve";
+import validateCommand from "./commands/validate";
+import { loadConfig } from "./utils/config";
+
+const cli = await createCLI({
+  name: "{{name}}",
+  version: "0.1.0",
+  description: "{{description}}",
+});
+
+// Global setup hook
+cli.before(async (context) => {
+  // Set up logging based on flags (commands can define their own verbose/quiet options)
+  const logger = {
+    level: "info",
+    log: (message: string) => console.log(`[${new Date().toISOString()}] ${message}`),
+    error: (message: string) => console.error(`[ERROR] ${message}`),
+  };
+
+  context.set("logger", logger);
+});
+
+// Add commands
+cli.command(initCommand);
+cli.command(validateCommand);
+cli.command(serveCommand);
+cli.command(configCommand);
+
+// Load config and run
+async function run() {
+  try {
+    await loadConfig();
+    await cli.run();
+  } catch (error) {
+    console.error("Failed to start CLI:", error);
+    process.exit(1);
+  }
+}
+
+await run();

package/templates/advanced/src/utils/config.ts

@@ -0,0 +1,83 @@
+import path from "node:path";
+import { CONFIG_FILE_NAME, DEFAULT_CONFIG } from "./constants";
+
+export interface Config {
+  rules?: Record<string, any>;
+  server?: {
+    port?: number;
+    host?: string;
+    open?: boolean;
+    cors?: boolean;
+  };
+  include?: string[];
+  exclude?: string[];
+  cache?: {
+    enabled?: boolean;
+    directory?: string;
+  };
+  hooks?: {
+    beforeValidate?: (files: string[]) => Promise<void>;
+    afterValidate?: (results: any) => Promise<void>;
+  };
+}
+
+let cachedConfig: Config | null = null;
+
+export async function loadConfig(configPath?: string): Promise<Config> {
+  // Return cached config if available
+  if (cachedConfig && !configPath) {
+    return cachedConfig;
+  }
+
+  const finalPath = configPath || path.join(process.cwd(), CONFIG_FILE_NAME);
+
+  try {
+    // Check if config file exists
+    const file = Bun.file(finalPath);
+    if (!(await file.exists())) {
+      return DEFAULT_CONFIG;
+    }
+
+    // Import the config file
+    const configModule = await import(finalPath);
+    const config = configModule.default || configModule;
+
+    // Merge with defaults
+    cachedConfig = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      server: {
+        ...DEFAULT_CONFIG.server,
+        ...config.server,
+      },
+    };
+
+    return cachedConfig;
+  } catch (error) {
+    console.warn(`Failed to load config from ${finalPath}:`, error);
+    return DEFAULT_CONFIG;
+  }
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+  const configPath = path.join(process.cwd(), CONFIG_FILE_NAME);
+
+  // Convert config to ES module format
+  const content = `export default ${JSON.stringify(config, null, 2)}`;
+
+  await Bun.write(configPath, content);
+
+  // Clear cache
+  cachedConfig = null;
+}
+
+export async function getConfigPath(): Promise<string> {
+  const configPath = path.join(process.cwd(), CONFIG_FILE_NAME);
+  const file = Bun.file(configPath);
+
+  if (await file.exists()) {
+    return configPath;
+  }
+
+  return "No config file found";
+}

package/templates/advanced/src/utils/constants.ts

@@ -0,0 +1,12 @@
+export const CONFIG_FILE_NAME = "{{name}}.config.js";
+
+export const DEFAULT_CONFIG = {
+  rules: {},
+  server: {
+    port: 3000,
+    host: "localhost",
+    open: true,
+  },
+  include: ["src/**/*.{js,ts}"],
+  exclude: ["node_modules", "dist"],
+};

package/templates/advanced/src/utils/glob.ts

@@ -0,0 +1,49 @@
+import path from "node:path";
+import { Glob } from "bun";
+
+export interface GlobOptions {
+  include?: string[];
+  exclude?: string[];
+}
+
+export async function glob(patterns: string[], options: GlobOptions = {}): Promise<string[]> {
+  const { include = [], exclude = [] } = options;
+
+  // Combine user patterns with include patterns
+  const allPatterns = [...patterns, ...include];
+
+  // Convert exclude patterns to absolute paths
+  const excludePatterns = exclude.map((pattern) => {
+    if (pattern.startsWith("/")) {
+      return pattern;
+    }
+    return path.join(process.cwd(), pattern);
+  });
+
+  const results = new Set<string>();
+
+  for (const pattern of allPatterns) {
+    const glob = new Glob(pattern);
+
+    for await (const file of glob.scan({
+      cwd: process.cwd(),
+      absolute: true,
+    })) {
+      // Check if file should be excluded
+      let shouldExclude = false;
+
+      for (const excludePattern of excludePatterns) {
+        if (file.includes(excludePattern)) {
+          shouldExclude = true;
+          break;
+        }
+      }
+
+      if (!shouldExclude) {
+        results.add(file);
+      }
+    }
+  }
+
+  return Array.from(results).sort();
+}

package/templates/advanced/src/utils/validator.ts

@@ -0,0 +1,128 @@
+export interface ValidationResult {
+  file: string;
+  errors: ValidationIssue[];
+  warnings: ValidationIssue[];
+}
+
+export interface ValidationIssue {
+  line: number;
+  column: number;
+  message: string;
+  rule: string;
+}
+
+export interface ValidateOptions {
+  rules?: Record<string, any>;
+  fix?: boolean;
+  cache?: boolean;
+}
+
+export async function validateFiles(
+  files: string[],
+  options: ValidateOptions = {}
+): Promise<ValidationResult[]> {
+  const { rules = {}, fix = false } = options;
+  const results: ValidationResult[] = [];
+
+  for (const file of files) {
+    const result = await validateFile(file, rules, fix);
+    results.push(result);
+  }
+
+  return results;
+}
+
+async function validateFile(
+  filePath: string,
+  rules: Record<string, any>,
+  fix: boolean
+): Promise<ValidationResult> {
+  const errors: ValidationIssue[] = [];
+  const warnings: ValidationIssue[] = [];
+
+  try {
+    const content = await Bun.file(filePath).text();
+    const lines = content.split("\n");
+
+    // Example rule implementations
+    if (rules.noConsoleLog) {
+      lines.forEach((line, index) => {
+        const match = line.match(/console\.log\s*\(/);
+        if (match) {
+          errors.push({
+            line: index + 1,
+            column: match.index! + 1,
+            message: "console.log is not allowed",
+            rule: "noConsoleLog",
+          });
+        }
+      });
+    }
+
+    if (rules.noDebugger) {
+      lines.forEach((line, index) => {
+        const match = line.match(/\bdebugger\b/);
+        if (match) {
+          errors.push({
+            line: index + 1,
+            column: match.index! + 1,
+            message: "debugger statement is not allowed",
+            rule: "noDebugger",
+          });
+        }
+      });
+    }
+
+    if (rules.maxLineLength) {
+      const maxLength = typeof rules.maxLineLength === "number" ? rules.maxLineLength : 100;
+      lines.forEach((line, index) => {
+        if (line.length > maxLength) {
+          warnings.push({
+            line: index + 1,
+            column: maxLength + 1,
+            message: `Line exceeds maximum length of ${maxLength}`,
+            rule: "maxLineLength",
+          });
+        }
+      });
+    }
+
+    if (rules.requireFileHeader && !(content.startsWith("/*") || content.startsWith("//"))) {
+      errors.push({
+        line: 1,
+        column: 1,
+        message: "File must start with a header comment",
+        rule: "requireFileHeader",
+      });
+    }
+
+    // Auto-fix if requested
+    if (fix && errors.length > 0) {
+      // This is a simplified example - real fix logic would be more complex
+      let fixedContent = content;
+
+      if (rules.noConsoleLog) {
+        fixedContent = fixedContent.replace(/console\.log\s*\([^)]*\);?/g, "");
+      }
+
+      if (rules.noDebugger) {
+        fixedContent = fixedContent.replace(/\bdebugger\b;?/g, "");
+      }
+
+      await Bun.write(filePath, fixedContent);
+    }
+  } catch (error) {
+    errors.push({
+      line: 0,
+      column: 0,
+      message: `Failed to validate file: ${error}`,
+      rule: "system",
+    });
+  }
+
+  return {
+    file: filePath,
+    errors,
+    warnings,
+  };
+}

package/templates/advanced/template.json

@@ -0,0 +1,40 @@
+{
+  "name": "@reliverse/rempts-advanced",
+  "description": "Advanced Rempts CLI template with multiple commands",
+  "variables": [
+    {
+      "name": "name",
+      "message": "Project name",
+      "type": "string",
+      "default": "my-rempts-cli"
+    },
+    {
+      "name": "description",
+      "message": "Project description",
+      "type": "string",
+      "default": "A powerful CLI built with Rempts"
+    },
+    {
+      "name": "author",
+      "message": "Author name",
+      "type": "string",
+      "default": ""
+    },
+    {
+      "name": "license",
+      "message": "License",
+      "type": "select",
+      "default": "MIT",
+      "choices": [
+        { "label": "MIT", "value": "MIT" },
+        { "label": "Apache-2.0", "value": "Apache-2.0" },
+        { "label": "GPL-3.0", "value": "GPL-3.0" },
+        { "label": "BSD-3-Clause", "value": "BSD-3-Clause" },
+        { "label": "Unlicense", "value": "Unlicense" }
+      ]
+    }
+  ],
+  "files": {
+    "exclude": ["node_modules/**", ".git/**", "template.json"]
+  }
+}

package/templates/advanced/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun"],
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test/**/*"]
+}

package/templates/basic/README.md

@@ -0,0 +1,41 @@
+# {{name}}
+
+{{description}}
+
+## Installation
+
+```bash
+bun install
+```
+
+## Development
+
+```bash
+bun dev -- [command]
+```
+
+## Building
+
+```bash
+bun run build
+```
+
+## Testing
+
+```bash
+bun test
+```
+
+## Usage
+
+```bash
+{{name}} hello --name World
+```
+
+## Commands
+
+- `hello` - A simple greeting command
+
+## License
+
+MIT

package/templates/basic/dler.config.ts

@@ -0,0 +1,40 @@
+import { defineConfig } from "@reliverse/rempts-core";
+
+export default defineConfig({
+  name: "{{name}}",
+  version: "{{version}}",
+  description: "{{description}}",
+
+  build: {
+    entry: "./src/mod.ts",
+    outdir: "./dist",
+    targets: ["native"],
+    minify: true,
+    sourcemap: true,
+    compress: false,
+  },
+
+  dev: {
+    watch: true,
+    inspect: true,
+  },
+
+  test: {
+    pattern: ["**/*.test.ts", "**/*.spec.ts"],
+    coverage: true,
+    watch: false,
+  },
+
+  plugins: [],
+
+  workspace: {
+    versionStrategy: "fixed",
+  },
+
+  release: {
+    npm: true,
+    github: false,
+    tagFormat: "v{{version}}",
+    conventionalCommits: true,
+  },
+});

package/templates/basic/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "{{name}}",
+  "version": "2.3.0",
+  "description": "{{description}}",
+  "author": "{{author}}",
+  "bin": {
+    "{{name}}": "./src/mod.ts"
+  },
+  "type": "module",
+  "scripts": {
+    "postinstall": "bun dler generate",
+    "dev": "bun run src/mod.ts",
+    "build": "bun dler build",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@reliverse/rempts-core": "workspace:*"
+  },
+  "devDependencies": {
+    "@reliverse/rempts-test": "workspace:*",
+    "@reliverse/tsconfig": "workspace:*",
+    "@types/bun": "catalog:",
+    "rempts": "workspace:*",
+    "typescript": "catalog:"
+  },
+  "rempts": {
+    "entry": "./src/mod.ts",
+    "outDir": "./dist"
+  }
+}

package/templates/basic/src/commands/hello.ts

@@ -0,0 +1,26 @@
+import { relico } from "@reliverse/relico";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+
+const helloCommand = defineCommand({
+  name: "hello",
+  description: "Say hello to someone",
+  options: {
+    name: option(type("string", "=", "World"), {
+      description: "Name to greet",
+      short: "n",
+    }),
+    excited: option(type("boolean", "=", false), {
+      description: "Add excitement!",
+      short: "e",
+    }),
+  },
+  handler: async ({ flags, colors }) => {
+    const greeting = `Hello, ${flags.name}`;
+    const message = flags.excited ? `${greeting}!` : `${greeting}.`;
+
+    console.log(relico.green(message));
+  },
+});
+
+export default helloCommand;

package/templates/basic/src/mod.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+import { createCLI } from "@reliverse/rempts-core";
+import helloCommand from "./commands/hello";
+
+const cli = await createCLI({
+  name: "{{name}}",
+  version: "0.1.0",
+  description: "{{description}}",
+});
+
+cli.command(helloCommand);
+
+await cli.run();

package/templates/basic/template.json

@@ -0,0 +1,27 @@
+{
+  "name": "@reliverse/rempts-basic",
+  "description": "Basic Rempts CLI template",
+  "variables": [
+    {
+      "name": "projectName",
+      "message": "Project name",
+      "type": "string",
+      "default": "my-rempts-cli"
+    },
+    {
+      "name": "description",
+      "message": "Project description",
+      "type": "string",
+      "default": "A CLI built with Rempts"
+    },
+    {
+      "name": "author",
+      "message": "Author name",
+      "type": "string",
+      "default": ""
+    }
+  ],
+  "files": {
+    "exclude": ["node_modules/**", ".git/**", "template.json"]
+  }
+}