tools-template-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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.

package/README.md

@@ -0,0 +1,54 @@
+# tmp-cli
+
+A small TypeScript CLI for cloning the starter templates in this repository into a fresh project directory.
+
+## Install
+
+### From npm
+
+```bash
+npm install -g tools-template-cli
+tmp-cli list
+```
+
+### Locally while developing
+
+```bash
+npm install
+npm run build
+npm link
+tmp-cli list
+```
+
+## Commands
+
+```bash
+npm install
+npm run build
+node dist/index.js list
+node dist/index.js create supabase-expo-app my-mobile-app
+node dist/index.js create ./apps/admin --template supabase-user-management --git
+```
+
+## What it does
+
+- Lists the templates that live in this repository
+- Copies a template into a new target directory
+- Skips `.git`, `node_modules`, `.DS_Store`, and common build output directories
+- Renames basic config values for the JavaScript templates
+- Optionally runs `npm install`, `pnpm install`, `yarn install`, or `bun install`
+- Optionally initializes a fresh git repository in the generated project
+
+## Global usage
+
+```bash
+tmp-cli list
+tmp-cli create supabase-expo-app my-mobile-app
+tmp-cli create ./apps/admin --template supabase-user-management --git
+```
+
+## Notes
+
+- `supabase-expo-app` and `supabase-user-management` get automatic config renaming in `package.json`, `package-lock.json`, `app.json`, and `README.md`
+- The SwiftUI and Flutter templates are copied as-is, apart from the target directory name
+- Use `node dist/index.js help` to see all options

package/dist/index.js

@@ -0,0 +1,380 @@
+#!/usr/bin/env node
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { basename, dirname, join, resolve } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { getTemplate, templates } from "./templates.js";
+const CLI_VERSION = "0.1.0";
+const ROOT_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const SKIP_NAMES = new Set([
+    ".git",
+    ".DS_Store",
+    "node_modules",
+    ".next",
+    ".expo",
+    ".turbo",
+    "dist",
+    "build"
+]);
+const VALID_PACKAGE_MANAGERS = new Set([
+    "npm",
+    "pnpm",
+    "yarn",
+    "bun"
+]);
+function main() {
+    try {
+        const parsed = parseArgs(process.argv.slice(2));
+        if (hasBooleanFlag(parsed.flags, "help") || parsed.command === "help") {
+            printHelp();
+            return;
+        }
+        if (hasBooleanFlag(parsed.flags, "version")) {
+            console.log(CLI_VERSION);
+            return;
+        }
+        switch (parsed.command) {
+            case "list":
+                listTemplates();
+                return;
+            case "create":
+                createProject(resolveCreateOptions(parsed));
+                return;
+            default:
+                printHelp(`Unknown command: ${parsed.command}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown CLI failure";
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    }
+}
+function parseArgs(argv) {
+    const command = argv[0] ?? "help";
+    const positionals = [];
+    const flags = new Map();
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token.startsWith("-")) {
+            positionals.push(token);
+            continue;
+        }
+        if (token === "--") {
+            positionals.push(...argv.slice(index + 1));
+            break;
+        }
+        if (token.startsWith("--")) {
+            const [rawName, inlineValue] = token.slice(2).split("=", 2);
+            const name = normalizeFlagName(rawName);
+            if (inlineValue !== undefined) {
+                flags.set(name, inlineValue);
+                continue;
+            }
+            if (flagTakesValue(name)) {
+                const next = argv[index + 1];
+                if (!next || next.startsWith("-")) {
+                    throw new Error(`Missing value for --${rawName}`);
+                }
+                flags.set(name, next);
+                index += 1;
+                continue;
+            }
+            flags.set(name, true);
+            continue;
+        }
+        const shortFlags = token.slice(1).split("");
+        for (let shortIndex = 0; shortIndex < shortFlags.length; shortIndex += 1) {
+            const shortFlag = shortFlags[shortIndex];
+            const name = mapShortFlag(shortFlag);
+            if (flagTakesValue(name)) {
+                const remainder = shortFlags.slice(shortIndex + 1).join("");
+                if (remainder.length > 0) {
+                    flags.set(name, remainder);
+                    break;
+                }
+                const next = argv[index + 1];
+                if (!next || next.startsWith("-")) {
+                    throw new Error(`Missing value for -${shortFlag}`);
+                }
+                flags.set(name, next);
+                index += 1;
+                break;
+            }
+            flags.set(name, true);
+        }
+    }
+    return { command, positionals, flags };
+}
+function resolveCreateOptions(parsed) {
+    const templateFlag = getStringFlag(parsed.flags, "template");
+    const force = hasBooleanFlag(parsed.flags, "force");
+    const install = hasBooleanFlag(parsed.flags, "install");
+    const git = hasBooleanFlag(parsed.flags, "git");
+    let templateId = templateFlag;
+    let targetDirArg;
+    if (templateId) {
+        targetDirArg = parsed.positionals[0] ?? templateId;
+    }
+    else {
+        templateId = parsed.positionals[0];
+        targetDirArg = parsed.positionals[1] ?? parsed.positionals[0];
+    }
+    if (!templateId) {
+        throw new Error("Missing template name. Run `tmp-cli list` to see available templates.");
+    }
+    const template = getTemplate(templateId);
+    if (!template) {
+        throw new Error(`Unknown template "${templateId}". Run \`tmp-cli list\` to see available templates.`);
+    }
+    if (!targetDirArg) {
+        throw new Error("Missing target directory for create command.");
+    }
+    const targetDir = resolve(process.cwd(), targetDirArg);
+    const directoryName = basename(targetDir);
+    const displayName = getStringFlag(parsed.flags, "name") ?? directoryName;
+    const packageName = normalizePackageName(directoryName);
+    const packageManagerValue = getStringFlag(parsed.flags, "package-manager") ??
+        template.defaultPackageManager;
+    if (packageManagerValue !== undefined &&
+        !VALID_PACKAGE_MANAGERS.has(packageManagerValue)) {
+        throw new Error(`Unsupported package manager "${packageManagerValue}". Use npm, pnpm, yarn, or bun.`);
+    }
+    return {
+        template,
+        targetDir,
+        displayName,
+        directoryName,
+        packageName,
+        force,
+        install,
+        git,
+        packageManager: packageManagerValue
+    };
+}
+function createProject(options) {
+    const templateSourceDir = resolve(ROOT_DIR, options.template.path);
+    if (!existsSync(templateSourceDir)) {
+        throw new Error(`Template path does not exist: ${templateSourceDir}`);
+    }
+    prepareTargetDirectory(options.targetDir, options.force);
+    copyDirectory(templateSourceDir, options.targetDir);
+    applyTransforms(options);
+    const nextSteps = [`cd ${options.targetDir}`];
+    if (options.git) {
+        runCommand("git", ["init"], options.targetDir);
+        nextSteps.push("git add .", 'git commit -m "Initial commit"');
+    }
+    if (options.install) {
+        const packageManager = options.packageManager;
+        if (!packageManager) {
+            console.warn("Warning: --install is only supported for templates with a configured JavaScript package manager.");
+        }
+        else {
+            runCommand(packageManager, ["install"], options.targetDir);
+        }
+    }
+    else if (options.packageManager) {
+        nextSteps.push(`${options.packageManager} install`);
+    }
+    console.log(`Created ${options.template.id} at ${options.targetDir}`);
+    console.log(`Platform: ${options.template.platform}`);
+    if (options.template.renameStrategy === "directory-only") {
+        console.log("Note: this template keeps its original framework identifiers. Only the target directory and README reference were updated.");
+    }
+    if (nextSteps.length > 0) {
+        console.log("\nNext:");
+        for (const step of nextSteps) {
+            console.log(`  ${step}`);
+        }
+    }
+}
+function listTemplates() {
+    console.log("Available templates:\n");
+    for (const template of templates) {
+        console.log(`- ${template.id}`);
+        console.log(`  ${template.description}`);
+        console.log(`  Platform: ${template.platform}`);
+    }
+}
+function prepareTargetDirectory(targetDir, force) {
+    if (!existsSync(targetDir)) {
+        return;
+    }
+    const targetStats = statSync(targetDir);
+    if (!targetStats.isDirectory()) {
+        throw new Error(`Target path is not a directory: ${targetDir}`);
+    }
+    const entries = readdirSync(targetDir);
+    if (entries.length === 0) {
+        rmSync(targetDir, { recursive: true, force: true });
+        return;
+    }
+    if (!force) {
+        throw new Error(`Target directory is not empty: ${targetDir}. Use --force to overwrite it.`);
+    }
+    rmSync(targetDir, { recursive: true, force: true });
+}
+function copyDirectory(sourceDir, targetDir) {
+    mkdirSync(targetDir, { recursive: true });
+    for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+        if (SKIP_NAMES.has(entry.name)) {
+            continue;
+        }
+        const sourcePath = join(sourceDir, entry.name);
+        const targetPath = join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            copyDirectory(sourcePath, targetPath);
+            continue;
+        }
+        if (entry.isFile()) {
+            copyFileSync(sourcePath, targetPath);
+            chmodSync(targetPath, statSync(sourcePath).mode);
+        }
+    }
+}
+function applyTransforms(options) {
+    for (const transform of options.template.transforms) {
+        applyTransform(transform, options);
+    }
+}
+function applyTransform(transform, options) {
+    switch (transform) {
+        case "package-json-name":
+            updateJsonFile(join(options.targetDir, "package.json"), (json) => {
+                json.name = options.packageName;
+            });
+            return;
+        case "package-lock-name":
+            updateJsonFile(join(options.targetDir, "package-lock.json"), (json) => {
+                json.name = options.packageName;
+                if (json.packages?.[""]) {
+                    json.packages[""].name = options.packageName;
+                }
+            });
+            return;
+        case "expo-config":
+            updateJsonFile(join(options.targetDir, "app.json"), (json) => {
+                if (!json.expo) {
+                    return;
+                }
+                json.expo.name = options.displayName;
+                json.expo.slug = slugify(options.directoryName);
+            });
+            return;
+        case "readme-name":
+            replaceInFile(join(options.targetDir, "README.md"), options.template.id, options.directoryName);
+    }
+}
+function updateJsonFile(filePath, updater) {
+    if (!existsSync(filePath)) {
+        return;
+    }
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    updater(parsed);
+    writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}\n`);
+}
+function replaceInFile(filePath, searchValue, replacementValue) {
+    if (!existsSync(filePath)) {
+        return;
+    }
+    const original = readFileSync(filePath, "utf8");
+    const updated = original.split(searchValue).join(replacementValue);
+    if (updated !== original) {
+        writeFileSync(filePath, updated);
+    }
+}
+function runCommand(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        stdio: "inherit"
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error(`Command failed: ${command} ${args.join(" ")}`);
+    }
+}
+function normalizeFlagName(name) {
+    return name.trim().toLowerCase();
+}
+function flagTakesValue(name) {
+    return name === "template" || name === "name" || name === "package-manager";
+}
+function mapShortFlag(flag) {
+    switch (flag) {
+        case "t":
+            return "template";
+        case "n":
+            return "name";
+        case "p":
+            return "package-manager";
+        case "f":
+            return "force";
+        case "i":
+            return "install";
+        case "g":
+            return "git";
+        case "h":
+            return "help";
+        case "v":
+            return "version";
+        default:
+            throw new Error(`Unknown flag: -${flag}`);
+    }
+}
+function hasBooleanFlag(flags, name) {
+    return flags.get(name) === true;
+}
+function getStringFlag(flags, name) {
+    const value = flags.get(name);
+    return typeof value === "string" ? value : undefined;
+}
+function normalizePackageName(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}
+function slugify(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}
+function printHelp(errorMessage) {
+    if (errorMessage) {
+        console.error(errorMessage);
+        console.error("");
+    }
+    console.log(`tmp-cli ${CLI_VERSION}
+
+Usage:
+  tmp-cli list
+  tmp-cli create <template> [target-directory] [options]
+  tmp-cli create <target-directory> --template <template> [options]
+
+Options:
+  -t, --template <name>         Template name to copy
+  -n, --name <display-name>     Display name for supported templates
+  -p, --package-manager <tool>  npm | pnpm | yarn | bun
+  -f, --force                   Overwrite a non-empty target directory
+  -i, --install                 Run package-manager install after copy
+  -g, --git                     Run git init in the generated directory
+  -h, --help                    Show help
+  -v, --version                 Show CLI version
+
+Examples:
+  tmp-cli list
+  tmp-cli create supabase-expo-app my-mobile-app
+  tmp-cli create ./apps/admin --template supabase-user-management --git
+  tmp-cli create supabase-expo-app my-mobile-app --name "My Mobile App" --install
+`);
+}
+main();

package/dist/templates.js

@@ -0,0 +1,44 @@
+export const templates = [
+    {
+        id: "supabase-expo-app",
+        path: "supabase-expo-app",
+        description: "Expo + Supabase starter with auth, account, and avatar flows",
+        platform: "React Native / Expo",
+        defaultPackageManager: "npm",
+        transforms: [
+            "package-json-name",
+            "package-lock-name",
+            "expo-config",
+            "readme-name"
+        ],
+        renameStrategy: "config-only"
+    },
+    {
+        id: "supabase-user-management",
+        path: "supabase-user-management",
+        description: "Next.js + Supabase user management starter",
+        platform: "Next.js",
+        defaultPackageManager: "npm",
+        transforms: ["package-json-name", "package-lock-name", "readme-name"],
+        renameStrategy: "config-only"
+    },
+    {
+        id: "supabase-swiftui-app",
+        path: "supabase-swiftui-app",
+        description: "SwiftUI + Supabase starter",
+        platform: "SwiftUI",
+        transforms: ["readme-name"],
+        renameStrategy: "directory-only"
+    },
+    {
+        id: "supabase_flutter_app",
+        path: "supabase_flutter_app",
+        description: "Flutter + Supabase starter",
+        platform: "Flutter",
+        transforms: ["readme-name"],
+        renameStrategy: "directory-only"
+    }
+];
+export function getTemplate(id) {
+    return templates.find((template) => template.id === id);
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "tools-template-cli",
+  "version": "0.1.0",
+  "description": "CLI for cloning starter templates from this repository into fresh project directories",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "tmp-cli": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vinzeny/templates.git"
+  },
+  "homepage": "https://github.com/vinzeny/templates",
+  "bugs": {
+    "url": "https://github.com/vinzeny/templates/issues"
+  },
+  "keywords": [
+    "cli",
+    "template",
+    "starter",
+    "expo",
+    "nextjs",
+    "flutter",
+    "swiftui"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "npm run build",
+    "prepack": "npm run build",
+    "list": "node dist/index.js list",
+    "create": "node dist/index.js create"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "supabase-expo-app",
+    "supabase-user-management",
+    "supabase-swiftui-app",
+    "supabase_flutter_app"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.17",
+    "typescript": "^5.9.3"
+  }
+}

package/supabase-expo-app/.env.example

@@ -0,0 +1,2 @@
+EXPO_PUBLIC_SUPABASE_URL=your_supabase_url
+EXPO_PUBLIC_SUPABASE_PUBLISHABLE_KEY=your_supabase_publishable_key

package/supabase-expo-app/App.tsx

@@ -0,0 +1,55 @@
+import { useState, useEffect } from 'react'
+import { StyleSheet, View, ActivityIndicator } from 'react-native'
+import { supabase } from './lib/supabase'
+import Auth from './components/Auth'
+import Account from './components/Account'
+
+export default function App() {
+  const [session, setSession] = useState<any>(null)
+  const [loading, setLoading] = useState(true)
+
+  useEffect(() => {
+    // Get initial session
+    supabase.auth.getSession().then(({ data: { session } }) => {
+      setSession(session)
+      setLoading(false)
+    })
+
+    // Listen for auth changes
+    const { data: { subscription } } = supabase.auth.onAuthStateChange((_event, session) => {
+      setSession(session)
+    })
+
+    return () => subscription.unsubscribe()
+  }, [])
+
+  if (loading) {
+    return (
+      <View style={styles.loadingContainer}>
+        <ActivityIndicator size="large" color="#10b981" />
+      </View>
+    )
+  }
+
+  return (
+    <View style={styles.container}>
+      {session && session.user ? (
+        <Account key={session.user.id} session={session} />
+      ) : (
+        <Auth onAuthSuccess={() => {}} />
+      )}
+    </View>
+  )
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#fff',
+  },
+  loadingContainer: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+})