@reliverse/rempts 2.2.9 → 2.3.1

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env bun
+import { createApp, defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { create } from "./create.js";
+const cli = await createApp({
+  config: {
+    name: "rempts",
+    version: "0.1.0",
+    description: "Scaffold new Rempts CLI projects"
+  },
+  defaultCommand: "create"
+});
+cli.command(
+  defineCommand({
+    description: "Create a new Rempts CLI project",
+    options: {
+      name: option(type("string | undefined"), { description: "Project name" }),
+      template: option(type("string | undefined"), {
+        short: "t",
+        description: "Project template (basic, advanced, monorepo, or github:user/repo)"
+      }),
+      dir: option(type("string | undefined"), {
+        short: "d",
+        description: "Directory to create project in"
+      }),
+      git: option(type("boolean | undefined"), {
+        short: "g",
+        description: "Initialize git repository"
+      }),
+      install: option(type("boolean | undefined"), {
+        short: "i",
+        description: "Install dependencies"
+      }),
+      offline: option(type("boolean | undefined"), {
+        description: "Use cached templates when available"
+      })
+    },
+    handler: async (context) => {
+      const options = {
+        name: context.flags.name,
+        template: context.flags.template ?? "basic",
+        dir: context.flags.dir,
+        git: context.flags.git ?? true,
+        install: context.flags.install ?? true,
+        offline: context.flags.offline ?? false
+      };
+      return create({ ...context, flags: options });
+    }
+  })
+);
+await cli.run();

package/dist/create-project.d.ts

@@ -0,0 +1,14 @@
+import type { RemptsUtils } from "@reliverse/rempts-utils";
+import type { CreateOptions } from "./types.js";
+interface CreateProjectOptions extends Omit<CreateOptions, "name" | "dir" | "offline"> {
+    name: string;
+    dir: string;
+    template: string;
+    offline: boolean;
+    prompt: RemptsUtils["prompt"];
+    spinner: RemptsUtils["spinner"];
+    colors: typeof import("@reliverse/relico").relico;
+    shell: typeof Bun.$;
+}
+export declare function createProject(options: CreateProjectOptions): Promise<void>;
+export {};

package/dist/create-project.js

@@ -0,0 +1,84 @@
+import { relico } from "@reliverse/relico";
+import {
+  getBundledTemplatePath,
+  isLocalTemplate,
+  processTemplate,
+  resolveTemplateSource
+} from "./template-engine.js";
+export async function createProject(options) {
+  const { name, dir, template, git, install, prompt, spinner, colors, shell, offline } = options;
+  try {
+    await shell`test -d ${dir}`.quiet();
+    const overwrite = await prompt.confirm(`Directory ${dir} already exists. Overwrite?`, {
+      default: false
+    });
+    if (!overwrite) {
+      console.log(relico.red("Cancelled"));
+      process.exit(1);
+    }
+    await shell`rm -rf ${dir}`;
+  } catch {
+  }
+  const spin = spinner("Creating project structure...");
+  spin.start();
+  await shell`mkdir -p ${dir}`;
+  try {
+    let templateSource = template;
+    if (await isLocalTemplate(template)) {
+      templateSource = getBundledTemplatePath(template);
+    } else {
+      templateSource = resolveTemplateSource(template);
+    }
+    const { manifest } = await processTemplate({
+      source: templateSource,
+      dir,
+      offline,
+      variables: {
+        name,
+        version: "0.1.0",
+        description: "A CLI built with Rempts",
+        author: "",
+        license: "MIT",
+        year: (/* @__PURE__ */ new Date()).getFullYear().toString()
+      }
+    });
+    spin.succeed("Project structure created");
+    if (git) {
+      const gitSpin = spinner("Initializing git repository...");
+      gitSpin.start();
+      try {
+        await shell`cd ${dir} && git init`.quiet();
+        await shell`cd ${dir} && git add .`.quiet();
+        await shell`cd ${dir} && git commit -m "feat: initialize ${name} CLI project with Rempts
+
+- Generated using @reliverse/rempts template
+- Includes basic CLI structure with commands directory
+- Configured with Rempts build system and TypeScript
+- Ready for development with bun run dev"`;
+        gitSpin.succeed("Git repository initialized");
+      } catch (error) {
+        gitSpin.fail("Failed to initialize git repository");
+        console.error(relico.dim(`  ${error}`));
+      }
+    }
+    if (install) {
+      const installSpin = spinner("Installing dependencies...");
+      installSpin.start();
+      try {
+        await shell`cd ${dir} && bun install`;
+        installSpin.succeed("Dependencies installed");
+      } catch (_error) {
+        installSpin.fail("Failed to install dependencies");
+        console.error(relico.dim("  You can install them manually by running: bun install"));
+      }
+    }
+  } catch (error) {
+    spin.fail("Failed to create project");
+    console.error(relico.red(`Error: ${error}`));
+    try {
+      await shell`rm -rf ${dir}`.quiet();
+    } catch {
+    }
+    process.exit(1);
+  }
+}

package/dist/create.d.ts

@@ -0,0 +1,11 @@
+import type { HandlerArgs } from "@reliverse/rempts-core";
+interface CreateOptions {
+    name: string | undefined;
+    template: string;
+    dir: string | undefined;
+    git: boolean;
+    install: boolean;
+    offline: boolean | undefined;
+}
+export declare function create(context: HandlerArgs<CreateOptions>): Promise<void>;
+export {};

package/dist/create.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+import { relico } from "@reliverse/relico";
+import { createProject } from "./create-project.js";
+export async function create(context) {
+  const { flags, positional, prompt, spinner, colors, shell } = context;
+  let projectName = positional[0] || flags.name;
+  if (!projectName) {
+    projectName = await prompt("Project name:", {
+      validate: (value) => {
+        if (!value) {
+          return "Project name is required";
+        }
+        if (!/^[a-z0-9-]+$/.test(value)) {
+          return "Project name must only contain lowercase letters, numbers, and hyphens";
+        }
+        return true;
+      }
+    });
+  } else if (!/^[a-z0-9-]+$/.test(projectName)) {
+    console.error(
+      relico.red("Project name must only contain lowercase letters, numbers, and hyphens")
+    );
+    process.exit(1);
+  }
+  const projectDir = flags.dir || path.join(process.cwd(), projectName);
+  console.log();
+  console.log(relico.bold("Creating Rempts project:"));
+  console.log(relico.dim("  Name:     ") + relico.cyan(projectName));
+  console.log(relico.dim("  Template: ") + relico.cyan(flags.template));
+  console.log(relico.dim("  Location: ") + relico.cyan(projectDir));
+  console.log(relico.dim("  Git:      ") + relico.cyan(flags.git ? "Yes" : "No"));
+  console.log(relico.dim("  Install:  ") + relico.cyan(flags.install ? "Yes" : "No"));
+  console.log();
+  const confirmed = await prompt.confirm("Continue?", { default: true });
+  if (!confirmed) {
+    console.log(relico.red("Cancelled"));
+    process.exit(1);
+  }
+  console.log();
+  await createProject({
+    name: projectName,
+    dir: projectDir,
+    template: flags.template,
+    git: flags.git,
+    install: flags.install,
+    offline: flags.offline ?? false,
+    prompt,
+    spinner,
+    colors,
+    shell
+  });
+  console.log();
+  console.log(relico.green("\u2728 Project created successfully!"));
+  console.log();
+  console.log("Next steps:");
+  console.log(relico.gray(`  cd ${path.relative(process.cwd(), projectDir)}`));
+  if (!flags.install) {
+    console.log(relico.gray("  bun install"));
+  }
+  console.log(relico.gray("  bun run dev"));
+  console.log();
+}

package/dist/mod.d.ts

@@ -1,6 +1,4 @@
-export * from "./cancel.js";
-export * from "./group.js";
-export * from "./launcher/mod.js";
-export * from "./prompt.js";
-export * from "./selection.js";
-export * from "./spinner.js";
+export { createProject } from "./create-project.js";
+export { isLocalTemplate, processTemplate, resolveTemplateSource, } from "./template-engine.js";
+export type { CreateOptions, ProjectConfig, TemplateManifest, TemplateVariable, } from "./types.js";
+export declare const version = "0.1.0";

package/dist/mod.js

@@ -1,6 +1,7 @@
-export * from "./cancel.js";
-export * from "./group.js";
-export * from "./launcher/mod.js";
-export * from "./prompt.js";
-export * from "./selection.js";
-export * from "./spinner.js";
+export { createProject } from "./create-project.js";
+export {
+  isLocalTemplate,
+  processTemplate,
+  resolveTemplateSource
+} from "./template-engine.js";
+export const version = "0.1.0";

package/dist/template-engine.d.ts

@@ -0,0 +1,27 @@
+import type { TemplateManifest } from "./types.js";
+export interface TemplateOptions {
+    source: string;
+    type?: "github" | "npm" | "local" | "bundled";
+    dir: string;
+    offline?: boolean;
+    variables?: Record<string, string>;
+}
+/**
+ * Download and process a template
+ */
+export declare function processTemplate(options: TemplateOptions): Promise<{
+    dir: string;
+    manifest: TemplateManifest | null;
+}>;
+/**
+ * Resolve template source to giget-compatible format
+ */
+export declare function resolveTemplateSource(template: string): string;
+/**
+ * Get bundled template path
+ */
+export declare function getBundledTemplatePath(name: string): string;
+/**
+ * Check if template exists locally (for development)
+ */
+export declare function isLocalTemplate(template: string): Promise<boolean>;

package/dist/template-engine.js

@@ -0,0 +1,145 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { downloadTemplate } from "giget";
+export async function processTemplate(options) {
+  const { source, dir, offline, variables = {} } = options;
+  let templateDir;
+  if (source.startsWith("/") || source.startsWith("./") || source.startsWith("../")) {
+    const sourceDir = source.startsWith("/") ? source : join(process.cwd(), source);
+    await Bun.spawn(["cp", "-r", `${sourceDir}/.`, dir], {
+      stdout: "inherit",
+      stderr: "inherit"
+    }).exited;
+    templateDir = dir;
+  } else {
+    const result = await downloadTemplate(source, {
+      dir,
+      offline: offline ?? false,
+      preferOffline: true,
+      force: true
+    });
+    templateDir = result.dir;
+  }
+  const manifest = await loadTemplateManifest(templateDir);
+  if (manifest?.files || Object.keys(variables).length > 0) {
+    await processTemplateFiles(templateDir, variables, manifest);
+  }
+  if (manifest?.hooks?.postInstall) {
+    await runPostInstallHooks(templateDir, manifest.hooks.postInstall);
+  }
+  return { dir: templateDir, manifest };
+}
+async function loadTemplateManifest(dir) {
+  const possiblePaths = [
+    join(dir, "template.json"),
+    join(dir, ".template.json"),
+    join(dir, "template.yaml"),
+    join(dir, ".template.yaml")
+  ];
+  for (const path of possiblePaths) {
+    const file = Bun.file(path);
+    if (await file.exists()) {
+      const content = await file.text();
+      if (path.endsWith(".json")) {
+        const manifest = JSON.parse(content);
+        try {
+          await Bun.spawn(["rm", "-f", path], {
+            stdout: "ignore",
+            stderr: "ignore"
+          }).exited;
+        } catch {
+        }
+        return manifest;
+      }
+    }
+  }
+  return null;
+}
+async function processTemplateFiles(dir, variables, manifest) {
+  const files = await getFilesToProcess(dir, manifest);
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const content = await Bun.file(filePath).text();
+    let processedContent = content;
+    for (const [key, value] of Object.entries(variables)) {
+      processedContent = processedContent.replaceAll(`{{${key}}}`, value).replaceAll(`<%= ${key} %>`, value).replaceAll(`$${key}`, value).replaceAll(`__${key}__`, value);
+    }
+    let newFilePath = filePath;
+    for (const [key, value] of Object.entries(variables)) {
+      newFilePath = newFilePath.replaceAll(`__${key}__`, value);
+    }
+    await Bun.write(newFilePath, processedContent);
+    if (newFilePath !== filePath) {
+      await Bun.spawn(["rm", filePath]).exited;
+    }
+  }
+}
+async function getFilesToProcess(dir, manifest) {
+  if (manifest?.files?.include) {
+    return manifest.files.include;
+  }
+  const files = [];
+  async function walk(currentDir, prefix = "") {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const path = join(prefix, entry.name);
+      if (entry.isDirectory()) {
+        if (!["node_modules", ".git", ".next", "dist", "build"].includes(entry.name)) {
+          await walk(join(currentDir, entry.name), path);
+        }
+      } else {
+        if (!path.match(/^(template\.json|\.template\.json|\.DS_Store|Thumbs\.db)$/) || path === ".gitignore") {
+          files.push(path);
+        }
+      }
+    }
+  }
+  await walk(dir);
+  if (manifest?.files?.exclude) {
+    return files.filter((file) => {
+      return !manifest.files?.exclude?.some((pattern) => {
+        const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(file);
+      });
+    });
+  }
+  return files;
+}
+async function runPostInstallHooks(dir, hooks) {
+  for (const hook of hooks) {
+    const proc = Bun.spawn(hook.split(" "), {
+      cwd: dir,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    await proc.exited;
+  }
+}
+export function resolveTemplateSource(template) {
+  const specialTemplates = {
+    basic: "github:rempts/templates/basic",
+    advanced: "github:rempts/templates/advanced",
+    monorepo: "github:rempts/templates/monorepo"
+  };
+  if (specialTemplates[template]) {
+    return specialTemplates[template];
+  }
+  if (template.startsWith("npm:")) {
+    return template.replace("npm:", "npm:/");
+  }
+  if (template.includes("/") && !template.includes(":")) {
+    return `github:${template}`;
+  }
+  return template;
+}
+export function getBundledTemplatePath(name) {
+  return join(import.meta.dir, "..", "templates", name);
+}
+export async function isLocalTemplate(template) {
+  if (template.startsWith("file:") || template.startsWith("./") || template.startsWith("../")) {
+    return true;
+  }
+  const bundledPath = getBundledTemplatePath(template);
+  return await Bun.file(join(bundledPath, "package.json")).exists();
+}

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+export interface CreateOptions {
+    template?: string;
+    install?: boolean;
+    git?: boolean;
+    offline?: boolean;
+}
+export interface ProjectConfig {
+    name: string;
+    template: string;
+    install: boolean;
+    git: boolean;
+    offline?: boolean;
+}
+export interface TemplateManifest {
+    name?: string;
+    description?: string;
+    variables?: TemplateVariable[];
+    files?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    hooks?: {
+        postInstall?: string[];
+    };
+    requirements?: {
+        node?: string;
+        bun?: string;
+    };
+}
+export interface TemplateVariable {
+    name: string;
+    message: string;
+    type?: "string" | "boolean" | "number" | "select";
+    default?: any;
+    choices?: Array<{
+        label: string;
+        value: any;
+    }>;
+    validate?: (value: any) => boolean | string;
+}
+export interface Template {
+    name: string;
+    description: string;
+    files: Record<string, string>;
+}

package/package.json

@@ -1,51 +1,53 @@
 {
   "name": "@reliverse/rempts",
-  "version": "2.2.9",
-  "private": false,
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/mod.d.ts",
-      "default": "./dist/mod.js"
-    }
-  },
-  "description": "",
-  "files": [
-    "dist",
-    "release",
-    "cleanup.mjs",
-    "package.json"
-  ],
+  "version": "2.3.1",
+  "description": "Scaffold new Rempts CLI projects with ease",
   "keywords": [
-    "bun"
+    "bun",
+    "cli",
+    "create",
+    "rempts",
+    "scaffold",
+    "starter",
+    "template",
+    "typescript"
   ],
-  "publishConfig": {
-    "access": "public"
+  "homepage": "https://github.com/reliverse/dler#readme",
+  "bugs": {
+    "url": "https://github.com/reliverse/dler/issues"
   },
   "license": "MIT",
-  "homepage": "https://github.com/reliverse/dler/tree/main/packages/prompt#readme",
+  "author": "blefnk",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/reliverse/dler.git",
-    "directory": "packages/prompt"
+    "url": "https://github.com/reliverse/dler.git",
+    "directory": "packages/rempts"
+  },
+  "bin": {
+    "rempts": "./src/cli.ts"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "type": "module",
+  "module": "./src/mod.ts",
+  "types": "./src/mod.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "import": "./dist/mod.js"
+    }
   },
-  "bugs": "https://github.com/reliverse/dler/issues",
-  "author": "Nazar Kornienko <blefnk@gmail.com>",
   "dependencies": {
-    "log-update": "^7.0.2",
-    "sisteransi": "^1.0.5",
-    "cli-cursor": "^5.0.0",
-    "cli-spinners": "^3.3.0",
-    "is-interactive": "^2.0.0",
-    "is-unicode-supported": "^2.1.0",
-    "stdin-discarder": "^0.3.0",
-    "string-width": "^8.1.0",
-    "strip-ansi": "^7.1.2",
-    "pretty-bytes": "^7.1.0",
-    "pretty-ms": "^9.3.0",
-    "@reliverse/relico": "2.2.9",
-    "@reliverse/relinka": "2.2.9",
-    "@reliverse/mapkit": "2.2.9",
-    "@reliverse/helpers": "2.2.13"
+    "@reliverse/relico": "2.3.1",
+    "@reliverse/rempts-core": "2.3.1",
+    "@reliverse/rempts-test": "2.3.1",
+    "@reliverse/rempts-utils": "2.3.1",
+    "arktype": "^2.1.29",
+    "giget": "^2.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/cli.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env bun
+import { createApp, defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { create } from "./create";
+
+const cli = await createApp({
+  config: {
+    name: "rempts",
+    version: "0.1.0",
+    description: "Scaffold new Rempts CLI projects",
+  },
+  defaultCommand: "create",
+});
+
+// Use type assertion to access internal command() method
+// This is needed for the @reliverse/rempts CLI itself which registers commands programmatically
+(cli as any).command(
+  defineCommand({
+    description: "Create a new Rempts CLI project",
+    options: {
+      name: option(type("string | undefined"), { description: "Project name" }),
+      template: option(type("string | undefined"), {
+        short: "t",
+        description: "Project template (basic, advanced, monorepo, or github:user/repo)",
+      }),
+      dir: option(type("string | undefined"), {
+        short: "d",
+        description: "Directory to create project in",
+      }),
+      git: option(type("boolean | undefined"), {
+        short: "g",
+        description: "Initialize git repository",
+      }),
+      install: option(type("boolean | undefined"), {
+        short: "i",
+        description: "Install dependencies",
+      }),
+      offline: option(type("boolean | undefined"), {
+        description: "Use cached templates when available",
+      }),
+    },
+    handler: async (context) => {
+      // Apply defaults
+      const options = {
+        name: context.flags.name,
+        template: context.flags.template ?? "basic",
+        dir: context.flags.dir,
+        git: context.flags.git ?? true,
+        install: context.flags.install ?? true,
+        offline: context.flags.offline ?? false,
+      } as {
+        name: string | undefined;
+        template: string;
+        dir: string | undefined;
+        git: boolean;
+        install: boolean;
+        offline: boolean;
+      };
+      return create({ ...context, flags: options });
+    },
+  })
+);
+
+await cli.run();