@reliverse/rempts 2.2.9 → 2.3.1

package/templates/advanced/README.md

@@ -0,0 +1,118 @@
+# {{name}}
+
+{{description}}
+
+## Installation
+
+```bash
+# Install globally
+bun add -g {{name}}
+
+# Or use directly with bunx
+bunx {{name}} [command]
+```
+
+## Usage
+
+```bash
+{{name}} <command> [options]
+```
+
+### Commands
+
+#### `init`
+
+Initialize a new configuration file in the current directory.
+
+```bash
+{{name}} init [options]
+
+Options:
+  -f, --force     Overwrite existing config
+  -t, --template  Config template to use
+```
+
+#### `validate`
+
+Validate files against defined rules.
+
+```bash
+{{name}} validate <files...> [options]
+
+Options:
+  -c, --config    Path to config file
+  -f, --fix       Auto-fix issues
+  --no-cache      Disable caching
+```
+
+#### `serve`
+
+Start a development server.
+
+```bash
+{{name}} serve [options]
+
+Options:
+  -p, --port      Port to listen on (default: 3000)
+  -h, --host      Host to bind to (default: localhost)
+  --no-open       Don't open browser
+```
+
+#### `config`
+
+Manage configuration settings.
+
+```bash
+{{name}} config <action> [key] [value]
+
+Actions:
+  get <key>       Get a config value
+  set <key> <value>  Set a config value
+  list            List all config values
+  reset           Reset to defaults
+```
+
+### Global Options
+
+- `-v, --version` - Show version
+- `-h, --help` - Show help
+- `--verbose` - Enable verbose output
+- `--quiet` - Suppress output
+- `--no-color` - Disable colored output
+
+## Configuration
+
+Create a `{{name}}.config.js` file in your project root:
+
+```javascript
+export default {
+  // Configuration options
+  rules: {
+    // Define your rules
+  },
+  server: {
+    port: 3000,
+    host: 'localhost'
+  }
+}
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development
+bun dev
+
+# Run tests
+bun test
+
+# Build for production
+bun run build
+```
+
+## License
+
+{{license}}

package/templates/advanced/dler.config.ts

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

package/templates/advanced/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "{{name}}",
+  "version": "2.3.0",
+  "description": "{{description}}",
+  "license": "{{license}}",
+  "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",
+    "test:watch": "bun test --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "prepare": "bun run build"
+  },
+  "dependencies": {
+    "@reliverse/rempts-core": "workspace:*",
+    "@reliverse/rempts-utils": "workspace:*",
+    "arktype": "catalog:"
+  },
+  "devDependencies": {
+    "@reliverse/rempts-test": "workspace:*",
+    "@reliverse/tsconfig": "workspace:*",
+    "@types/bun": "catalog:",
+    "rempts": "workspace:*",
+    "typescript": "catalog:"
+  },
+  "rempts": {
+    "entry": "./src/mod.ts",
+    "outDir": "./dist",
+    "external": [
+      "@reliverse/rempts-core",
+      "@reliverse/rempts-utils",
+      "zod"
+    ]
+  }
+}

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

@@ -0,0 +1,157 @@
+import { relico } from "@reliverse/relico";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { getConfigPath, loadConfig, saveConfig } from "../utils/config";
+
+const configCommand = defineCommand({
+  name: "config",
+  description: "Manage configuration",
+  commands: [
+    defineCommand({
+      name: "get",
+      description: "Get a config value",
+      options: {
+        key: option(type("string | undefined"), {
+          description: "Config key to get",
+        }),
+      },
+      handler: async ({ flags }) => {
+        const key = flags.key;
+
+        try {
+          const config = await loadConfig();
+          const value = getNestedValue(config, key);
+
+          if (value === undefined) {
+            console.log(relico.yellow(`Config key '${key}' not found`));
+          } else {
+            console.log(JSON.stringify(value, null, 2));
+          }
+        } catch (error) {
+          console.error(relico.red(`Failed to load config: ${error}`));
+          process.exit(1);
+        }
+      },
+    }),
+
+    defineCommand({
+      name: "set",
+      description: "Set a config value",
+      options: {
+        key: option(type("string | undefined"), {
+          description: "Config key to set",
+        }),
+        value: option(type("string | undefined"), {
+          description: "Value to set",
+        }),
+      },
+      handler: async ({ flags, spinner }) => {
+        const key = flags.key;
+        const value = flags.value;
+
+        const spin = spinner("Updating config...");
+        spin.start();
+
+        try {
+          const config = await loadConfig();
+          setNestedValue(config, key, JSON.parse(value));
+          await saveConfig(config);
+
+          spin.succeed(`Config '${key}' updated`);
+        } catch (error) {
+          spin.fail("Failed to update config");
+          console.error(relico.red(String(error)));
+          process.exit(1);
+        }
+      },
+    }),
+
+    defineCommand({
+      name: "list",
+      description: "List all config values",
+      handler: async () => {
+        try {
+          const config = await loadConfig();
+          const configPath = await getConfigPath();
+
+          console.log(relico.bold("Configuration:"));
+          console.log(relico.dim(`  File: ${configPath}`));
+          console.log();
+          console.log(JSON.stringify(config, null, 2));
+        } catch (error) {
+          console.error(relico.red(`Failed to load config: ${error}`));
+          process.exit(1);
+        }
+      },
+    }),
+
+    defineCommand({
+      name: "reset",
+      description: "Reset config to defaults",
+      options: {
+        force: option(type("boolean", "=", false), {
+          short: "f",
+          description: "Skip confirmation",
+        }),
+      },
+      handler: async ({ flags, prompt, spinner }) => {
+        if (!flags.force) {
+          const confirmed = await prompt.confirm(
+            "This will reset all config to defaults. Continue?",
+            { default: false }
+          );
+
+          if (!confirmed) {
+            console.log(relico.yellow("Reset cancelled"));
+            return;
+          }
+        }
+
+        const spin = spinner("Resetting config...");
+        spin.start();
+
+        try {
+          const { DEFAULT_CONFIG } = await import("../utils/constants.js");
+          await saveConfig(DEFAULT_CONFIG);
+
+          spin.succeed("Config reset to defaults");
+        } catch (error) {
+          spin.fail("Failed to reset config");
+          console.error(relico.red(String(error)));
+          process.exit(1);
+        }
+      },
+    }),
+  ],
+});
+
+function getNestedValue(obj: any, path: string): any {
+  const keys = path.split(".");
+  let current = obj;
+
+  for (const key of keys) {
+    if (current === null || current === undefined) {
+      return undefined;
+    }
+    current = current[key];
+  }
+
+  return current;
+}
+
+function setNestedValue(obj: any, path: string, value: any): void {
+  const keys = path.split(".");
+  const lastKey = keys.pop()!;
+  let current = obj;
+
+  for (const key of keys) {
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+
+  current[lastKey] = value;
+}
+
+export default configCommand;

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

@@ -0,0 +1,149 @@
+import { relico } from "@reliverse/relico";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { CONFIG_FILE_NAME, DEFAULT_CONFIG } from "../utils/constants";
+
+const initCommand = defineCommand({
+  name: "init",
+  description: "Initialize a new configuration file",
+  options: {
+    force: option(type("boolean", "=", false), {
+      short: "f",
+      description: "Overwrite existing config",
+    }),
+    template: option(type("'minimal'|'default'|'full'", "=", "default"), {
+      short: "t",
+      description: "Config template to use",
+    }),
+  },
+  handler: async ({ flags, prompt, spinner, hooks }) => {
+    const logger = hooks?.logger;
+    const configPath = `${process.cwd()}/${CONFIG_FILE_NAME}`;
+
+    // Check if config already exists
+    const configFile = Bun.file(configPath);
+    if ((await configFile.exists()) && !flags.force) {
+      const overwrite = await prompt.confirm("Config file already exists. Overwrite?", {
+        default: false,
+      });
+
+      if (!overwrite) {
+        logger?.log("Init cancelled");
+        return;
+      }
+    }
+
+    const spin = spinner("Creating config file...");
+    spin.start();
+
+    try {
+      // Get template content
+      const configContent = getConfigTemplate(flags.template);
+
+      // Write config file
+      await Bun.write(configPath, configContent);
+
+      spin.succeed("Config file created");
+      logger?.log(`Created ${CONFIG_FILE_NAME}`);
+
+      // Next steps
+      console.log();
+      console.log("Next steps:");
+      console.log(relico.gray(`  1. Edit ${CONFIG_FILE_NAME} to customize your configuration`));
+      console.log(relico.gray(`  2. Run '{{name}} validate' to check your files`));
+    } catch (error) {
+      spin.fail("Failed to create config file");
+      logger?.error(String(error));
+      process.exit(1);
+    }
+  },
+});
+
+function getConfigTemplate(template: "minimal" | "default" | "full"): string {
+  const templates = {
+    minimal: `export default ${JSON.stringify(DEFAULT_CONFIG, null, 2)}`,
+
+    default: `export default {
+  // Validation rules
+  rules: {
+    // Add your validation rules here
+    noConsoleLog: true,
+    requireFileHeader: false,
+  },
+  
+  // Server configuration
+  server: {
+    port: 3000,
+    host: 'localhost',
+    open: true,
+  },
+  
+  // File patterns
+  include: ['src/**/*.{js,ts}'],
+  exclude: ['node_modules', 'dist', 'test'],
+}`,
+
+    full: `import { defineConfig } from '{{name}}'
+
+export default defineConfig({
+  // Validation rules
+  rules: {
+    // Code style rules
+    noConsoleLog: true,
+    noDebugger: true,
+    requireFileHeader: true,
+    maxLineLength: 100,
+    
+    // Import rules
+    noUnusedImports: true,
+    sortImports: true,
+    
+    // Function rules
+    maxFunctionLength: 50,
+    maxComplexity: 10,
+  },
+  
+  // Server configuration
+  server: {
+    port: process.env.PORT || 3000,
+    host: process.env.HOST || 'localhost',
+    open: !process.env.CI,
+    cors: true,
+  },
+  
+  // File patterns
+  include: [
+    'src/**/*.{js,ts,jsx,tsx}',
+    'scripts/**/*.{js,ts}',
+  ],
+  exclude: [
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '**/*.test.{js,ts}',
+    '**/*.spec.{js,ts}',
+  ],
+  
+  // Caching
+  cache: {
+    enabled: true,
+    directory: '.cache',
+  },
+  
+  // Hooks
+  hooks: {
+    beforeValidate: async (files) => {
+      console.log(\`Validating \${files.length} files...\`)
+    },
+    afterValidate: async (results) => {
+      console.log(\`Found \${results.errors} errors and \${results.warnings} warnings\`)
+    },
+  },
+})`,
+  };
+
+  return templates[template];
+}
+
+export default initCommand;

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

@@ -0,0 +1,172 @@
+import { relico } from "@reliverse/relico";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { loadConfig } from "../utils/config";
+
+const serveCommand = defineCommand({
+  name: "serve",
+  description: "Start a development server",
+  options: {
+    port: option(type("number", { divisor: 1, min: 1, max: 65_535 }, "=", 3000), {
+      short: "p",
+      description: "Port to listen on",
+    }),
+    host: option(type("string", "=", "localhost"), {
+      short: "h",
+      description: "Host to bind to",
+    }),
+    open: option(type("boolean", "=", true), {
+      description: "Open browser on start",
+    }),
+  },
+  handler: async ({ flags, spinner, shell }) => {
+    const spin = spinner("Starting server...");
+    spin.start();
+
+    try {
+      // Load config
+      const config = await loadConfig();
+
+      // Merge flags with config
+      const port = flags.port || config.server?.port || 3000;
+      const host = flags.host || config.server?.host || "localhost";
+      const shouldOpen = flags.open ?? config.server?.open ?? true;
+
+      // Create server
+      const server = Bun.serve({
+        port,
+        hostname: host,
+        fetch(req) {
+          const url = new URL(req.url);
+
+          // Simple router
+          if (url.pathname === "/") {
+            return new Response(getHomePage(), {
+              headers: { "Content-Type": "text/html" },
+            });
+          }
+
+          if (url.pathname === "/api/status") {
+            return Response.json({
+              status: "ok",
+              version: "0.1.0",
+              uptime: process.uptime(),
+            });
+          }
+
+          return new Response("Not Found", { status: 404 });
+        },
+      });
+
+      spin.succeed(`Server running at http://${host}:${port}`);
+
+      // Open browser
+      if (shouldOpen) {
+        const openSpin = spinner("Opening browser...");
+        openSpin.start();
+
+        try {
+          const url = `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`;
+
+          // Platform-specific open commands
+          const openCommand =
+            process.platform === "darwin"
+              ? "open"
+              : process.platform === "win32"
+                ? "start"
+                : "xdg-open";
+
+          await shell`${openCommand} ${url}`.quiet();
+          openSpin.succeed("Browser opened");
+        } catch {
+          openSpin.fail("Failed to open browser");
+        }
+      }
+
+      // Keep server running
+      console.log();
+      console.log(relico.dim("Press Ctrl+C to stop the server"));
+
+      // Handle shutdown
+      process.on("SIGINT", () => {
+        console.log();
+        console.log(relico.yellow("Shutting down server..."));
+        server.stop();
+        process.exit(0);
+      });
+    } catch (error) {
+      spin.fail("Failed to start server");
+      console.error(relico.red(String(error)));
+      process.exit(1);
+    }
+  },
+});
+
+function getHomePage(): string {
+  return `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>{{name}}</title>
+  <style>
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      max-width: 800px;
+      margin: 0 auto;
+      padding: 2rem;
+      background: #f5f5f5;
+    }
+    .container {
+      background: white;
+      padding: 2rem;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    h1 {
+      color: #333;
+      margin-top: 0;
+    }
+    .status {
+      display: inline-block;
+      padding: 0.25rem 0.5rem;
+      background: #10b981;
+      color: white;
+      border-radius: 4px;
+      font-size: 0.875rem;
+    }
+    code {
+      background: #f3f4f6;
+      padding: 0.125rem 0.25rem;
+      border-radius: 3px;
+      font-family: monospace;
+    }
+    .endpoints {
+      margin-top: 2rem;
+      padding: 1rem;
+      background: #f9fafb;
+      border-radius: 4px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>{{name}}</h1>
+    <p>{{description}}</p>
+    <p><span class="status">Running</span></p>
+    
+    <div class="endpoints">
+      <h3>API Endpoints</h3>
+      <ul>
+        <li><code>GET /</code> - This page</li>
+        <li><code>GET /api/status</code> - Server status</li>
+      </ul>
+    </div>
+    
+    <p>To get started, check out the <a href="https://github.com/reliverse/dler">documentation</a>.</p>
+  </div>
+</body>
+</html>
+  `.trim();
+}
+
+export default serveCommand;