@dawitworku/projectcli 0.1.0

package/src/index.js

@@ -0,0 +1,513 @@
+const path = require("node:path");
+const fs = require("node:fs");
+const os = require("node:os");
+const inquirerImport = require("inquirer");
+const inquirer = inquirerImport.default ?? inquirerImport;
+const prompt =
+  typeof inquirer?.prompt === "function"
+    ? inquirer.prompt.bind(inquirer)
+    : typeof inquirer?.createPromptModule === "function"
+    ? inquirer.createPromptModule()
+    : null;
+
+let hasAutocomplete = false;
+try {
+  if (typeof inquirer?.registerPrompt === "function") {
+    const autocomplete = require("inquirer-autocomplete-prompt");
+    inquirer.registerPrompt("autocomplete", autocomplete);
+    hasAutocomplete = true;
+  }
+} catch {
+  hasAutocomplete = false;
+}
+
+const { getLanguages, getFrameworks, getGenerator } = require("./registry");
+const { runSteps } = require("./run");
+const { runAdd } = require("./add");
+
+function isSafeProjectName(name) {
+  // Avoid path traversal / empty names; keep permissive.
+  if (!name) return false;
+  if (name.includes("..")) return false;
+  if (name.includes(path.sep)) return false;
+  if (name.includes("/")) return false;
+  if (name.includes("\\")) return false;
+  return true;
+}
+
+function readPackageVersion() {
+  try {
+    const pkgPath = path.resolve(__dirname, "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+function parseArgs(argv) {
+  const out = {
+    help: false,
+    version: false,
+    list: false,
+    yes: false,
+    dryRun: false,
+    language: undefined,
+    framework: undefined,
+    name: undefined,
+    pm: undefined,
+  };
+
+  const nextValue = (i) => {
+    if (i + 1 >= argv.length) return undefined;
+    return argv[i + 1];
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") out.help = true;
+    else if (a === "--version" || a === "-v") out.version = true;
+    else if (a === "--list") out.list = true;
+    else if (a === "--yes" || a === "-y") out.yes = true;
+    else if (a === "--dry-run") out.dryRun = true;
+    else if (a.startsWith("--language="))
+      out.language = a.slice("--language=".length);
+    else if (a === "--language") {
+      out.language = nextValue(i);
+      i++;
+    } else if (a.startsWith("--framework="))
+      out.framework = a.slice("--framework=".length);
+    else if (a === "--framework") {
+      out.framework = nextValue(i);
+      i++;
+    } else if (a.startsWith("--name=")) out.name = a.slice("--name=".length);
+    else if (a === "--name") {
+      out.name = nextValue(i);
+      i++;
+    } else if (a.startsWith("--pm=")) out.pm = a.slice("--pm=".length);
+    else if (a === "--pm" || a === "--package-manager") {
+      out.pm = nextValue(i);
+      i++;
+    }
+  }
+
+  return out;
+}
+
+function splitCommand(argv) {
+  if (!argv || argv.length === 0) return { cmd: "init", rest: [] };
+  const first = argv[0];
+  if (typeof first === "string" && !first.startsWith("-")) {
+    if (first === "init" || first === "add") {
+      return { cmd: first, rest: argv.slice(1) };
+    }
+  }
+  return { cmd: "init", rest: argv };
+}
+
+function printHelp() {
+  console.log("projectcli - interactive project generator");
+  console.log("");
+  console.log("Usage:");
+  console.log("  projectcli               # init a new project");
+  console.log("  projectcli init          # init a new project");
+  console.log("  projectcli add           # add libraries to current project");
+  console.log("  projectcli --list        # list all frameworks");
+  console.log(
+    "  projectcli --language <lang> --framework <fw> --name <project>"
+  );
+  console.log("");
+  console.log("Flags:");
+  console.log("  --help, -h       Show help");
+  console.log("  --version, -v    Show version");
+  console.log("  --list           List available languages/frameworks");
+  console.log("  --yes, -y        Skip confirmation");
+  console.log("  --dry-run        Print planned actions, do nothing");
+  console.log("  --language       Preselect language");
+  console.log("  --framework      Preselect framework");
+  console.log("  --name           Project folder name");
+  console.log(
+    "  --pm             Package manager for JS/TS (npm|pnpm|yarn|bun)"
+  );
+}
+
+const BACK = "__back__";
+
+function withBack(choices) {
+  return [
+    { name: "← Back", value: BACK },
+    new inquirer.Separator(),
+    ...choices,
+  ];
+}
+
+function printStepsPreview(steps) {
+  console.log("\nPlanned actions:");
+  for (const step of steps) {
+    const type = step.type || "command";
+    if (type === "command") {
+      const where = step.cwdFromProjectRoot ? "(in project)" : "(here)";
+      console.log(`- ${step.program} ${step.args.join(" ")} ${where}`);
+    } else if (type === "mkdir") {
+      console.log(`- mkdir -p ${step.path}`);
+    } else if (type === "writeFile") {
+      console.log(`- write ${step.path}`);
+    } else {
+      console.log(`- ${type}`);
+    }
+  }
+  console.log("");
+}
+
+function printList() {
+  for (const lang of getLanguages()) {
+    console.log(`${lang}:`);
+    for (const fw of getFrameworks(lang)) {
+      const gen = getGenerator(lang, fw);
+      const note = gen?.notes ? ` - ${gen.notes}` : "";
+      console.log(`  - ${fw}${note}`);
+    }
+  }
+}
+
+async function main(options = {}) {
+  if (!prompt) {
+    throw new Error(
+      "Unable to initialize prompts (inquirer import shape not supported)."
+    );
+  }
+
+  const argv = options.argv || [];
+  const { cmd, rest } = splitCommand(argv);
+  const args = parseArgs(rest);
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  if (args.version) {
+    console.log(readPackageVersion());
+    return;
+  }
+  if (args.list) {
+    printList();
+    return;
+  }
+
+  if (cmd === "add") {
+    await runAdd({ prompt, argv: rest });
+    return;
+  }
+
+  console.log("\nprojectcli");
+  console.log("Create a project in seconds.");
+  console.log(`Host: ${os.platform()} ${os.arch()}`);
+  console.log("Tip: use ↑/↓, Enter, and type-to-search when available.");
+  console.log("Tip: Ctrl+C anytime to quit.\n");
+
+  const languages = getLanguages();
+  if (languages.length === 0) {
+    throw new Error("No languages configured.");
+  }
+
+  const allowedPms = ["npm", "pnpm", "yarn", "bun"];
+  const preselectedPm =
+    typeof args.pm === "string" && allowedPms.includes(args.pm)
+      ? args.pm
+      : undefined;
+
+  const state = {
+    language:
+      args.language && languages.includes(args.language)
+        ? args.language
+        : undefined,
+    framework: undefined,
+    pm: preselectedPm,
+    name: args.name && isSafeProjectName(args.name) ? args.name : undefined,
+  };
+
+  if (state.language) {
+    const frameworksForLanguage = getFrameworks(state.language);
+    state.framework =
+      args.framework && frameworksForLanguage.includes(args.framework)
+        ? args.framework
+        : undefined;
+  }
+
+  const needsPackageManager =
+    state.language === "JavaScript" || state.language === "TypeScript";
+
+  let step = "language";
+  if (!state.language) step = "language";
+  else if (!state.framework) step = "framework";
+  else if (needsPackageManager && !state.pm) step = "pm";
+  else if (!state.name) step = "name";
+  else step = "confirm";
+
+  while (true) {
+    if (step === "language") {
+      const languageChoices = languages.map((lang) => {
+        const count = getFrameworks(lang).length;
+        return { name: `${lang} (${count})`, value: lang, short: lang };
+      });
+
+      const { language } = await prompt([
+        {
+          type: "list",
+          name: "language",
+          message: "Language:",
+          choices: languageChoices,
+          pageSize: 12,
+        },
+      ]);
+
+      state.language = language;
+      state.framework = undefined;
+      if (!preselectedPm) state.pm = undefined;
+      step = "framework";
+      continue;
+    }
+
+    if (step === "framework") {
+      const frameworks = getFrameworks(state.language);
+      if (frameworks.length === 0) {
+        throw new Error(`No frameworks configured for ${state.language}.`);
+      }
+
+      const frameworkChoices = frameworks.map((fw) => {
+        const gen = getGenerator(state.language, fw);
+        const note = gen?.notes ? ` — ${gen.notes}` : "";
+        return { name: `${fw}${note}`, value: fw, short: fw };
+      });
+
+      const frameworkQuestion =
+        hasAutocomplete && frameworkChoices.length > 12
+          ? {
+              type: "autocomplete",
+              name: "framework",
+              message: "Framework (type to search):",
+              pageSize: 12,
+              source: async (_answersSoFar, input) => {
+                const q = String(input || "")
+                  .toLowerCase()
+                  .trim();
+                if (!q) return withBack(frameworkChoices);
+                return withBack(
+                  frameworkChoices.filter((c) =>
+                    String(c.name).toLowerCase().includes(q)
+                  )
+                );
+              },
+            }
+          : {
+              type: "list",
+              name: "framework",
+              message: "Framework:",
+              choices: withBack(frameworkChoices),
+              pageSize: 12,
+            };
+
+      const answer = await prompt([frameworkQuestion]);
+      if (answer.framework === BACK) {
+        step = "language";
+        continue;
+      }
+
+      state.framework = answer.framework;
+      step = "pm";
+      continue;
+    }
+
+    if (step === "pm") {
+      const needsPackageManager =
+        state.language === "JavaScript" || state.language === "TypeScript";
+
+      if (!needsPackageManager) {
+        state.pm = undefined;
+        step = "name";
+        continue;
+      }
+
+      if (state.pm) {
+        step = "name";
+        continue;
+      }
+
+      const { pm } = await prompt([
+        {
+          type: "list",
+          name: "pm",
+          message: "Package manager:",
+          choices: withBack([
+            { name: "npm (default)", value: "npm" },
+            { name: "pnpm", value: "pnpm" },
+            { name: "yarn", value: "yarn" },
+            { name: "bun", value: "bun" },
+          ]),
+          pageSize: 10,
+        },
+      ]);
+
+      if (pm === BACK) {
+        step = "framework";
+        continue;
+      }
+
+      state.pm = pm;
+      step = "name";
+      continue;
+    }
+
+    if (step === "name") {
+      if (state.name) {
+        step = "confirm";
+        continue;
+      }
+
+      const { projectName } = await prompt([
+        {
+          type: "input",
+          name: "projectName",
+          message: "Project folder name (or type 'back'):",
+          validate: (input) => {
+            const v = String(input || "").trim();
+            if (v.toLowerCase() === "back") return true;
+            if (!isSafeProjectName(v)) {
+              return "Use a simple folder name (no slashes).";
+            }
+            const target = path.resolve(process.cwd(), v);
+            if (fs.existsSync(target)) {
+              return "That folder already exists. Pick a different name.";
+            }
+            return true;
+          },
+        },
+      ]);
+
+      const v = String(projectName || "").trim();
+      if (v.toLowerCase() === "back") {
+        step =
+          state.language === "JavaScript" || state.language === "TypeScript"
+            ? "pm"
+            : "framework";
+        continue;
+      }
+
+      state.name = v;
+      step = "confirm";
+      continue;
+    }
+
+    if (step === "confirm") {
+      const generator = getGenerator(state.language, state.framework);
+      if (!generator) {
+        throw new Error("Generator not found (registry mismatch).");
+      }
+
+      const projectRoot = path.resolve(process.cwd(), state.name);
+      const targetExists = fs.existsSync(projectRoot);
+      if (targetExists && !args.dryRun) {
+        console.error(`\nError: Target folder already exists: ${projectRoot}`);
+        state.name = undefined;
+        step = "name";
+        continue;
+      }
+
+      const summaryLines = [
+        `Project: ${state.name}`,
+        `Language: ${state.language}`,
+        `Framework: ${state.framework}`,
+      ];
+      if (state.pm) summaryLines.push(`Package manager: ${state.pm}`);
+      console.log("\n" + summaryLines.join("\n") + "\n");
+
+      if (targetExists && args.dryRun) {
+        console.log(`Note: target folder already exists: ${projectRoot}`);
+      }
+
+      const steps = generator.commands({
+        projectName: state.name,
+        packageManager: state.pm,
+      });
+
+      if (args.dryRun) {
+        printStepsPreview(steps);
+        console.log("Dry run: nothing executed.");
+        return;
+      }
+
+      if (!args.yes) {
+        const { action } = await prompt([
+          {
+            type: "list",
+            name: "action",
+            message: "Continue?",
+            choices: [
+              { name: "Create project", value: "create" },
+              { name: "← Back", value: "back" },
+              { name: "Cancel", value: "cancel" },
+            ],
+            pageSize: 6,
+          },
+        ]);
+
+        if (action === "cancel") return;
+        if (action === "back") {
+          step = "name";
+          continue;
+        }
+      }
+
+      const needsCwd = steps.some((s) => s.cwdFromProjectRoot);
+      if (needsCwd) {
+        fs.mkdirSync(projectRoot, { recursive: true });
+      }
+
+      console.log(`\nCreating: ${state.name}`);
+      if (generator.notes) console.log(`Note: ${generator.notes}`);
+
+      try {
+        await runSteps(steps, { projectRoot });
+      } catch (err) {
+        const message = err && err.message ? err.message : String(err);
+        console.error(`\nError: ${message}`);
+
+        if (args.yes) {
+          throw err;
+        }
+
+        const { next } = await prompt([
+          {
+            type: "list",
+            name: "next",
+            message: "What next?",
+            choices: [
+              { name: "Try again", value: "retry" },
+              { name: "← Back", value: "back" },
+              { name: "Cancel", value: "cancel" },
+            ],
+            pageSize: 6,
+          },
+        ]);
+
+        if (next === "cancel") return;
+        if (next === "back") {
+          step = "name";
+          continue;
+        }
+
+        // retry
+        step = "confirm";
+        continue;
+      }
+
+      console.log(`\nDone. Created project in: ${projectRoot}`);
+      return;
+    }
+
+    throw new Error(`Unknown wizard step: ${step}`);
+  }
+}
+
+module.exports = {
+  main,
+};

package/src/libraries.js

@@ -0,0 +1,72 @@
+const JS_TS = {
+  "UI / Components": [
+    {
+      label: "Tailwind CSS",
+      packagesDev: ["tailwindcss", "postcss", "autoprefixer"],
+      post: "tailwind-init",
+    },
+    { label: "shadcn/ui (Next/Vite)", packagesDev: [], post: "shadcn-init" },
+    {
+      label: "Material UI (MUI)",
+      packages: ["@mui/material", "@emotion/react", "@emotion/styled"],
+    },
+    {
+      label: "Chakra UI",
+      packages: [
+        "@chakra-ui/react",
+        "@emotion/react",
+        "@emotion/styled",
+        "framer-motion",
+      ],
+    },
+    { label: "Ant Design", packages: ["antd"] },
+    { label: "Mantine", packages: ["@mantine/core", "@mantine/hooks"] },
+    { label: "Radix UI (primitives)", packages: ["@radix-ui/react-dialog"] },
+    { label: "DaisyUI (Tailwind plugin)", packagesDev: ["daisyui"] },
+  ],
+  "UX / Animation": [
+    { label: "Framer Motion", packages: ["framer-motion"] },
+    { label: "Lottie", packages: ["lottie-react"] },
+  ],
+  "Forms / Validation": [
+    { label: "React Hook Form", packages: ["react-hook-form"] },
+    { label: "Zod", packages: ["zod"] },
+    { label: "Yup", packages: ["yup"] },
+  ],
+  "Data / State": [
+    { label: "TanStack Query", packages: ["@tanstack/react-query"] },
+    { label: "Zustand", packages: ["zustand"] },
+    { label: "Redux Toolkit", packages: ["@reduxjs/toolkit", "react-redux"] },
+  ],
+  Testing: [
+    { label: "Vitest", packagesDev: ["vitest"] },
+    {
+      label: "Playwright",
+      packagesDev: ["@playwright/test"],
+      post: "playwright-install",
+    },
+  ],
+};
+
+const PY = {
+  "TUI / UI": [
+    { label: "Rich", packages: ["rich"] },
+    { label: "Typer (CLI)", packages: ["typer"] },
+    { label: "Textual", packages: ["textual"] },
+  ],
+  Web: [
+    { label: "FastAPI", packages: ["fastapi", "uvicorn"] },
+    { label: "Flask", packages: ["flask"] },
+    { label: "Django", packages: ["django"] },
+  ],
+};
+
+function getCatalog(language) {
+  if (language === "JavaScript/TypeScript") return JS_TS;
+  if (language === "Python") return PY;
+  return {};
+}
+
+module.exports = {
+  getCatalog,
+};

package/src/pm.js

@@ -0,0 +1,44 @@
+function pmInstallCommand(pm) {
+  if (pm === "pnpm") return { program: "pnpm", args: ["install"] };
+  if (pm === "yarn") return { program: "yarn", args: ["install"] };
+  if (pm === "bun") return { program: "bun", args: ["install"] };
+  return { program: "npm", args: ["install"] };
+}
+
+function pmAddCommand(pm, packages, { dev = false } = {}) {
+  const pkgs = Array.isArray(packages) ? packages.filter(Boolean) : [];
+  if (pkgs.length === 0) {
+    throw new Error("No packages to install.");
+  }
+
+  if (pm === "pnpm") {
+    return { program: "pnpm", args: ["add", ...(dev ? ["-D"] : []), ...pkgs] };
+  }
+
+  if (pm === "yarn") {
+    return { program: "yarn", args: ["add", ...(dev ? ["-D"] : []), ...pkgs] };
+  }
+
+  if (pm === "bun") {
+    return { program: "bun", args: ["add", ...(dev ? ["-d"] : []), ...pkgs] };
+  }
+
+  return { program: "npm", args: ["install", ...(dev ? ["-D"] : []), ...pkgs] };
+}
+
+function pmExecCommand(pm, pkg, pkgArgs) {
+  const args = Array.isArray(pkgArgs) ? pkgArgs : [];
+
+  if (pm === "pnpm") return { program: "pnpm", args: ["dlx", pkg, ...args] };
+  if (pm === "yarn") return { program: "yarn", args: ["dlx", pkg, ...args] };
+  if (pm === "bun") return { program: "bunx", args: [pkg, ...args] };
+
+  // npm default
+  return { program: "npx", args: ["--yes", pkg, ...args] };
+}
+
+module.exports = {
+  pmInstallCommand,
+  pmAddCommand,
+  pmExecCommand,
+};