create-unmint 1.0.0

package/README.md

@@ -0,0 +1,57 @@
+# create-unmint
+
+Create beautiful documentation sites with Unmint - a free, open-source Mintlify alternative.
+
+## Usage
+
+```bash
+# Create a new documentation project
+npx create-unmint@latest my-docs
+
+# Create with all defaults (skip prompts)
+npx create-unmint@latest my-docs --yes
+
+# Update an existing project
+cd my-docs
+npx create-unmint@latest --update
+```
+
+## What You Get
+
+- **Beautiful out-of-the-box** - Professional styling without configuration
+- **MDX Components** - Cards, callouts, tabs, steps, accordions, and more
+- **Built-in Search** - Full-text search powered by Fumadocs
+- **Dynamic OG Images** - Auto-generated social preview images
+- **Dark Mode** - Seamless light/dark theme switching
+- **Easy Theming** - Single config file for all customization
+
+## Interactive Setup
+
+When you run `npx create-unmint@latest`, you'll be prompted to configure:
+
+- **Project name** - Name of your documentation project
+- **Description** - A brief description for SEO and metadata
+- **Accent color** - Choose from presets or enter a custom hex color
+- **GitHub URL** - Link to your project's repository (optional)
+- **Site URL** - Where your docs will be deployed
+
+## Project Structure
+
+```
+my-docs/
+├── app/                  # Next.js app directory
+├── content/
+│   └── docs/            # Your MDX documentation files
+├── lib/
+│   └── theme-config.ts  # Site configuration
+└── public/              # Static assets (logo, images)
+```
+
+## Learn More
+
+- [Unmint GitHub](https://github.com/gregce/unmint)
+- [Fumadocs Documentation](https://fumadocs.vercel.app)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,499 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk4 from "chalk";
+
+// src/commands/init.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+import { execa } from "execa";
+
+// src/prompts.ts
+import inquirer from "inquirer";
+import chalk from "chalk";
+var accentColors = [
+  { name: "Cyan", value: "#0891b2" },
+  { name: "Blue", value: "#3b82f6" },
+  { name: "Green", value: "#22c55e" },
+  { name: "Purple", value: "#a855f7" },
+  { name: "Orange", value: "#f97316" },
+  { name: "Pink", value: "#ec4899" },
+  { name: "Custom", value: "custom" }
+];
+async function promptProjectConfig(defaultName) {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      default: defaultName || "my-docs",
+      validate: (input) => {
+        if (!input.trim()) return "Project name is required";
+        if (!/^[a-z0-9-_]+$/i.test(input)) {
+          return "Project name can only contain letters, numbers, hyphens, and underscores";
+        }
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Description:",
+      default: "Documentation for my project"
+    },
+    {
+      type: "list",
+      name: "accentColor",
+      message: "Accent color:",
+      choices: accentColors.map((c) => ({
+        name: c.name === "Cyan" ? `${c.name} ${chalk.dim("(default)")}` : c.name,
+        value: c.value
+      })),
+      default: "#0891b2"
+    },
+    {
+      type: "input",
+      name: "customAccent",
+      message: "Custom accent color (hex):",
+      when: (answers2) => answers2.accentColor === "custom",
+      validate: (input) => {
+        if (!/^#[0-9a-f]{6}$/i.test(input)) {
+          return "Please enter a valid hex color (e.g., #ff5733)";
+        }
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "githubUrl",
+      message: `GitHub URL ${chalk.dim("(optional)")}:`,
+      default: ""
+    },
+    {
+      type: "input",
+      name: "siteUrl",
+      message: "Site URL:",
+      default: "https://docs.example.com"
+    },
+    {
+      type: "confirm",
+      name: "initGit",
+      message: "Initialize git repository?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "installDeps",
+      message: "Install dependencies?",
+      default: true
+    }
+  ]);
+  if (answers.accentColor === "custom" && answers.customAccent) {
+    answers.accentColor = answers.customAccent;
+  }
+  return answers;
+}
+function getDefaultConfig(projectName) {
+  return {
+    projectName,
+    description: "Documentation for my project",
+    accentColor: "#0891b2",
+    githubUrl: "",
+    siteUrl: "https://docs.example.com",
+    initGit: true,
+    installDeps: true
+  };
+}
+
+// src/scaffold.ts
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var EXCLUDE_PATTERNS = [
+  "node_modules",
+  ".next",
+  ".git",
+  "dist",
+  ".turbo",
+  ".vercel"
+];
+async function scaffoldProject(targetDir, config) {
+  const bundledTemplate = path.resolve(__dirname, "../template");
+  const devTemplate = path.resolve(__dirname, "../../template");
+  const templateDir = await fs.pathExists(bundledTemplate) ? bundledTemplate : devTemplate;
+  if (!await fs.pathExists(templateDir)) {
+    throw new Error(`Template not found. Please ensure you're running from a valid create-unmint installation.`);
+  }
+  await fs.ensureDir(targetDir);
+  await copyTemplateFiles(templateDir, targetDir);
+  await transformFiles(targetDir, config);
+  await createVersionFile(targetDir);
+}
+async function copyTemplateFiles(sourceDir, targetDir) {
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
+    if (EXCLUDE_PATTERNS.some((pattern) => entry.name === pattern)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await fs.ensureDir(targetPath);
+      await copyTemplateFiles(sourcePath, targetPath);
+    } else {
+      await fs.copy(sourcePath, targetPath);
+    }
+  }
+}
+async function transformFiles(targetDir, config) {
+  const packageJsonPath = path.join(targetDir, "package.json");
+  if (await fs.pathExists(packageJsonPath)) {
+    const packageJson = await fs.readJson(packageJsonPath);
+    packageJson.name = config.projectName;
+    packageJson.description = config.description;
+    packageJson.version = "0.1.0";
+    delete packageJson.repository;
+    delete packageJson.keywords;
+    delete packageJson.author;
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+  }
+  const themeConfigPath = path.join(targetDir, "lib/theme-config.ts");
+  if (await fs.pathExists(themeConfigPath)) {
+    let content = await fs.readFile(themeConfigPath, "utf-8");
+    content = content.replace(
+      /name:\s*['"][^'"]*['"]/,
+      `name: '${config.projectName}'`
+    );
+    content = content.replace(
+      /description:\s*['"][^'"]*['"]/,
+      `description: '${config.description}'`
+    );
+    content = content.replace(
+      /url:\s*['"][^'"]*['"]/,
+      `url: '${config.siteUrl}'`
+    );
+    if (config.githubUrl) {
+      content = content.replace(
+        /github:\s*['"][^'"]*['"]/,
+        `github: '${config.githubUrl}'`
+      );
+    }
+    await fs.writeFile(themeConfigPath, content);
+  }
+  const globalsCssPath = path.join(targetDir, "app/globals.css");
+  if (await fs.pathExists(globalsCssPath)) {
+    let content = await fs.readFile(globalsCssPath, "utf-8");
+    content = content.replace(
+      /--accent:\s*#[0-9a-fA-F]{6}/g,
+      `--accent: ${config.accentColor}`
+    );
+    const lighterAccent = lightenColor(config.accentColor);
+    content = content.replace(
+      /\.dark\s*\{[^}]*--accent:\s*#[0-9a-fA-F]{6}/,
+      (match) => match.replace(/--accent:\s*#[0-9a-fA-F]{6}/, `--accent: ${lighterAccent}`)
+    );
+    await fs.writeFile(globalsCssPath, content);
+  }
+  const indexMdxPath = path.join(targetDir, "content/docs/index.mdx");
+  if (await fs.pathExists(indexMdxPath)) {
+    let content = await fs.readFile(indexMdxPath, "utf-8");
+    content = content.replace(
+      /title:\s*['"][^'"]*['"]/,
+      `title: '${config.projectName}'`
+    );
+    content = content.replace(
+      /description:\s*['"][^'"]*['"]/,
+      `description: '${config.description}'`
+    );
+    await fs.writeFile(indexMdxPath, content);
+  }
+  const readmePath = path.join(targetDir, "README.md");
+  await fs.writeFile(readmePath, generateReadme(config));
+}
+async function createVersionFile(targetDir) {
+  const unmintDir = path.join(targetDir, ".unmint");
+  await fs.ensureDir(unmintDir);
+  const versionInfo = {
+    version: "1.0.0",
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    generator: "create-unmint"
+  };
+  await fs.writeJson(path.join(unmintDir, "version.json"), versionInfo, { spaces: 2 });
+}
+function lightenColor(hex) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  const lighten = (c) => Math.min(255, Math.round(c + (255 - c) * 0.3));
+  const lr = lighten(r).toString(16).padStart(2, "0");
+  const lg = lighten(g).toString(16).padStart(2, "0");
+  const lb = lighten(b).toString(16).padStart(2, "0");
+  return `#${lr}${lg}${lb}`;
+}
+function generateReadme(config) {
+  return `# ${config.projectName}
+
+${config.description}
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Start development server
+npm run dev
+\`\`\`
+
+Your docs will be available at [http://localhost:3000](http://localhost:3000)
+
+## Project Structure
+
+\`\`\`
+\u251C\u2500\u2500 app/                  # Next.js app directory
+\u251C\u2500\u2500 content/
+\u2502   \u2514\u2500\u2500 docs/            # Your documentation (MDX files)
+\u251C\u2500\u2500 lib/
+\u2502   \u2514\u2500\u2500 theme-config.ts  # Site configuration
+\u2514\u2500\u2500 public/              # Static assets
+\`\`\`
+
+## Writing Documentation
+
+Add MDX files to \`content/docs/\` to create new pages. The sidebar navigation is automatically generated based on your file structure.
+
+## Built with Unmint
+
+This documentation site was created with [Unmint](https://github.com/gregce/unmint), a free and open-source documentation system.
+`;
+}
+
+// src/commands/init.ts
+async function init(projectName, options = {}) {
+  let config;
+  if (options.yes && projectName) {
+    config = getDefaultConfig(projectName);
+    console.log(chalk2.dim("  Using default configuration..."));
+    console.log();
+  } else {
+    config = await promptProjectConfig(projectName);
+  }
+  const targetDir = path2.resolve(process.cwd(), config.projectName);
+  if (await fs2.pathExists(targetDir)) {
+    const isEmpty = (await fs2.readdir(targetDir)).length === 0;
+    if (!isEmpty) {
+      console.log(chalk2.red(`  Error: Directory "${config.projectName}" already exists and is not empty.`));
+      console.log(chalk2.dim(`  Please choose a different name or remove the existing directory.`));
+      process.exit(1);
+    }
+  }
+  console.log();
+  const scaffoldSpinner = ora("Creating project structure...").start();
+  try {
+    await scaffoldProject(targetDir, config);
+    scaffoldSpinner.succeed("Project structure created");
+  } catch (error) {
+    scaffoldSpinner.fail("Failed to create project structure");
+    console.error(chalk2.red(`  ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+  if (config.initGit) {
+    const gitSpinner = ora("Initializing git repository...").start();
+    try {
+      await execa("git", ["init"], { cwd: targetDir });
+      await execa("git", ["add", "-A"], { cwd: targetDir });
+      await execa("git", ["commit", "-m", "Initial commit from create-unmint"], { cwd: targetDir });
+      gitSpinner.succeed("Git repository initialized");
+    } catch (error) {
+      gitSpinner.warn("Could not initialize git repository");
+    }
+  }
+  if (config.installDeps) {
+    const installSpinner = ora("Installing dependencies...").start();
+    try {
+      const packageManager = await detectPackageManager();
+      await execa(packageManager, ["install"], { cwd: targetDir });
+      installSpinner.succeed(`Dependencies installed with ${packageManager}`);
+    } catch (error) {
+      installSpinner.warn("Could not install dependencies");
+      console.log(chalk2.dim(`  Run "npm install" manually to install dependencies`));
+    }
+  }
+  console.log();
+  console.log(chalk2.green.bold("  Success!") + ` Created ${chalk2.cyan(config.projectName)}`);
+  console.log();
+  console.log("  Next steps:");
+  console.log();
+  console.log(chalk2.cyan(`    cd ${config.projectName}`));
+  if (!config.installDeps) {
+    console.log(chalk2.cyan("    npm install"));
+  }
+  console.log(chalk2.cyan("    npm run dev"));
+  console.log();
+  console.log(chalk2.dim(`  Your docs will be at ${chalk2.white("http://localhost:3000")}`));
+  console.log();
+}
+async function detectPackageManager() {
+  const cwd = process.cwd();
+  if (await fs2.pathExists(path2.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fs2.pathExists(path2.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (await fs2.pathExists(path2.join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.includes("pnpm")) return "pnpm";
+  if (userAgent.includes("yarn")) return "yarn";
+  if (userAgent.includes("bun")) return "bun";
+  return "npm";
+}
+
+// src/commands/update.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import chalk3 from "chalk";
+import ora2 from "ora";
+import inquirer2 from "inquirer";
+async function update(options = {}) {
+  const cwd = process.cwd();
+  const versionFilePath = path3.join(cwd, ".unmint/version.json");
+  if (!await fs3.pathExists(versionFilePath)) {
+    console.log(chalk3.red("  Error: This does not appear to be an Unmint project."));
+    console.log(chalk3.dim("  Run this command from the root of an Unmint documentation project."));
+    console.log();
+    console.log(chalk3.dim("  To create a new project, run:"));
+    console.log(chalk3.cyan("    npx create-unmint@latest my-docs"));
+    process.exit(1);
+  }
+  const versionInfo = await fs3.readJson(versionFilePath);
+  const currentVersion = versionInfo.version;
+  console.log(chalk3.dim(`  Current version: ${currentVersion}`));
+  console.log();
+  if (options.dryRun) {
+    console.log(chalk3.yellow("  Dry run mode - no changes will be made"));
+    console.log();
+  }
+  const spinner = ora2("Checking for updates...").start();
+  try {
+    const latestVersion = "1.0.0";
+    if (currentVersion === latestVersion) {
+      spinner.succeed("Already up to date!");
+      return;
+    }
+    spinner.info(`Update available: ${currentVersion} \u2192 ${latestVersion}`);
+    console.log();
+    const changes = await analyzeChanges(cwd);
+    if (changes.length === 0) {
+      console.log(chalk3.green("  No files need updating."));
+      return;
+    }
+    console.log("  Changes:");
+    for (const change of changes) {
+      const icon = change.type === "update" ? "\u21BB" : change.type === "add" ? "+" : "\u2212";
+      const color = change.type === "update" ? chalk3.blue : change.type === "add" ? chalk3.green : chalk3.red;
+      const status = change.protected ? chalk3.yellow(" (protected - skip)") : "";
+      console.log(`    ${color(icon)} ${change.file}${status}`);
+    }
+    console.log();
+    if (options.dryRun) {
+      console.log(chalk3.dim("  Dry run complete. No changes were made."));
+      return;
+    }
+    const { proceed } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "Proceed with update?",
+        default: true
+      }
+    ]);
+    if (!proceed) {
+      console.log(chalk3.dim("  Update cancelled."));
+      return;
+    }
+    const backupSpinner = ora2("Creating backup...").start();
+    const backupDir = await createBackup(cwd);
+    backupSpinner.succeed(`Backup created at ${path3.relative(cwd, backupDir)}`);
+    const updateSpinner = ora2("Applying updates...").start();
+    const results = await applyUpdates(cwd, changes);
+    updateSpinner.succeed("Updates applied");
+    versionInfo.version = latestVersion;
+    versionInfo.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await fs3.writeJson(versionFilePath, versionInfo, { spaces: 2 });
+    console.log();
+    console.log(chalk3.green.bold("  Update complete!"));
+    console.log();
+    console.log(`    Updated: ${results.updated}`);
+    console.log(`    Skipped: ${results.skipped}`);
+    console.log(`    Added:   ${results.added}`);
+    console.log();
+  } catch (error) {
+    spinner.fail("Update failed");
+    console.error(chalk3.red(`  ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+}
+async function analyzeChanges(projectDir) {
+  return [];
+}
+async function createBackup(projectDir) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const backupDir = path3.join(projectDir, ".unmint/backup", timestamp);
+  await fs3.ensureDir(backupDir);
+  const filesToBackup = [
+    "lib/theme-config.ts",
+    "app/globals.css",
+    "package.json"
+  ];
+  for (const file of filesToBackup) {
+    const sourcePath = path3.join(projectDir, file);
+    if (await fs3.pathExists(sourcePath)) {
+      const targetPath = path3.join(backupDir, file);
+      await fs3.ensureDir(path3.dirname(targetPath));
+      await fs3.copy(sourcePath, targetPath);
+    }
+  }
+  return backupDir;
+}
+async function applyUpdates(projectDir, changes) {
+  const results = {
+    updated: 0,
+    skipped: 0,
+    added: 0
+  };
+  for (const change of changes) {
+    if (change.protected) {
+      results.skipped++;
+      continue;
+    }
+    if (change.type === "update") {
+      results.updated++;
+    } else if (change.type === "add") {
+      results.added++;
+    }
+  }
+  return results;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("create-unmint").description("Create and manage Unmint documentation projects").version("1.0.0");
+program.argument("[project-name]", "Name of the project to create").option("-y, --yes", "Skip prompts and use defaults").option("--update", "Update an existing Unmint project").option("--dry-run", "Show what would be updated without making changes").action(async (projectName, options) => {
+  console.log();
+  console.log(chalk4.cyan.bold("  Unmint"));
+  console.log(chalk4.dim("  Beautiful documentation, open source"));
+  console.log();
+  if (options.update) {
+    await update(options);
+  } else {
+    await init(projectName, options);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "create-unmint",
+  "version": "1.0.0",
+  "description": "Create a new Unmint documentation project",
+  "type": "module",
+  "bin": {
+    "create-unmint": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "template"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean && npm run copy-template",
+    "copy-template": "rm -rf template && cp -r ../template template && rm -rf template/node_modules template/.next template/.git",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "execa": "^9.5.2",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^12.3.0",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.10.7",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.3"
+  },
+  "keywords": [
+    "create",
+    "unmint",
+    "documentation",
+    "docs",
+    "cli",
+    "scaffold"
+  ],
+  "author": "Greg Ceccarelli",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gregce/unmint.git",
+    "directory": "packages/create-unmint"
+  }
+}

package/template/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Unmint Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.