@dawitworku/projectcli 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,75 @@
+# projectcli
+
+Interactive project generator.
+
+Run it as a single command, pick language → framework, and it scaffolds the project by calling the underlying official CLIs (Vite, Next.js, Nest, etc.).
+
+## Run with npx (recommended)
+
+After you publish this package to npm:
+
+```bash
+npx projectcli@latest
+```
+
+You can also run non-interactively:
+
+```bash
+npx projectcli@latest --language "TypeScript" --framework "NestJS" --name my-api --pm npm
+```
+
+## Run (dev)
+
+```bash
+npm install
+npm start
+```
+
+## Install as a single-word command
+
+From this repo folder:
+
+```bash
+npm install
+npm link
+```
+
+Then you can run:
+
+```bash
+projectcli
+```
+
+## Add libraries to an existing project
+
+Run inside a project folder:
+
+```bash
+projectcli add
+```
+
+## Notes
+
+- If you type a project name that already exists, the CLI will ask for another name (it won’t quit).
+- Some generators (like Vite/Next/etc.) can still ask their own questions — those prompts come from the underlying tool.
+
+## Useful flags
+
+```bash
+projectcli --help
+projectcli --version
+projectcli --list
+projectcli --language "JavaScript" --framework "Astro" --name myapp --pm pnpm
+projectcli --language "TypeScript" --framework "TanStack Start" --name myapp --pm npm
+projectcli --language "TypeScript" --framework "NestJS" --name myapi --pm pnpm
+projectcli --dry-run --language "JavaScript" --framework "Vite (React)" --name demo --pm pnpm
+```
+
+## How it works
+
+- Choose language
+- Choose framework
+- Enter project name
+- CLI runs the underlying generator commands (npm/cargo/django-admin/etc.)
+
+If a generator command is missing on your machine, install it and re-run.

package/bin/projectcli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const { main } = require("../src/index");
+
+main({ argv: process.argv.slice(2) }).catch((err) => {
+  const message = err && err.message ? err.message : String(err);
+  console.error(`\nError: ${message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@dawitworku/projectcli",
+  "version": "0.1.0",
+  "description": "Interactive project generator (language -> framework -> create).",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "projectcli": "bin/projectcli.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "generator",
+    "project"
+  ],
+  "scripts": {
+    "start": "node bin/projectcli.js",
+    "lint": "node -c bin/projectcli.js && node -c src/index.js && node -c src/registry.js && node -c src/run.js"
+  },
+  "dependencies": {
+    "inquirer": "^9.2.23",
+    "inquirer-autocomplete-prompt": "^3.0.1"
+  }
+}

package/src/add.js

@@ -0,0 +1,263 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { detectLanguage, detectPackageManager } = require("./detect");
+const { getCatalog } = require("./libraries");
+const { pmAddCommand, pmExecCommand } = require("./pm");
+const { runSteps } = require("./run");
+
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+
+function parseAddArgs(argv) {
+  const out = { yes: false, dryRun: false };
+  const args = Array.isArray(argv) ? argv : [];
+  for (const a of args) {
+    if (a === "--yes" || a === "-y") out.yes = true;
+    else if (a === "--dry-run") out.dryRun = true;
+  }
+  return out;
+}
+
+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("");
+}
+
+async function runAdd({ prompt, argv }) {
+  const flags = parseAddArgs(argv);
+  const cwd = process.cwd();
+  const language = detectLanguage(cwd);
+  const pm = detectPackageManager(cwd);
+
+  if (language === "Unknown") {
+    throw new Error(
+      "Couldn't detect project type here. Run inside a project folder (package.json, pyproject.toml, go.mod, etc.)."
+    );
+  }
+
+  console.log(`\nDetected project: ${language}`);
+  if (language === "JavaScript/TypeScript") {
+    console.log(`Detected package manager: ${pm}`);
+  }
+
+  const catalog = getCatalog(language);
+  const categories = Object.keys(catalog);
+  if (categories.length === 0) {
+    throw new Error(`No library catalog configured for: ${language}`);
+  }
+
+  const BACK = "__back__";
+  const EXIT = "__exit__";
+
+  let selectedCategory = null;
+  let selectedLabels = null;
+
+  while (true) {
+    if (!selectedCategory) {
+      const categoryChoices = [
+        ...categories.map((c) => ({
+          name: `${c} (${catalog[c].length})`,
+          value: c,
+        })),
+        new (require("inquirer").Separator)(),
+        { name: "Exit", value: EXIT },
+      ];
+
+      const { category } = await prompt([
+        {
+          type: "list",
+          name: "category",
+          message: "Category:",
+          choices: categoryChoices,
+          pageSize: 14,
+        },
+      ]);
+
+      if (category === EXIT) return;
+      selectedCategory = category;
+      continue;
+    }
+
+    if (!selectedLabels) {
+      const items = catalog[selectedCategory] || [];
+      const { picks } = await prompt([
+        {
+          type: "checkbox",
+          name: "picks",
+          message: "Select libraries (space to toggle):",
+          choices: items.map((i) => ({ name: i.label, value: i.label })),
+          validate: (v) =>
+            v && v.length ? true : "Pick at least one library.",
+          pageSize: 14,
+        },
+      ]);
+
+      selectedLabels = picks;
+
+      const { next } = await prompt([
+        {
+          type: "list",
+          name: "next",
+          message: "Next:",
+          choices: [
+            { name: "Continue", value: "continue" },
+            { name: "← Back", value: BACK },
+            { name: "Cancel", value: EXIT },
+          ],
+          pageSize: 8,
+        },
+      ]);
+
+      if (next === EXIT) return;
+      if (next === BACK) {
+        selectedLabels = null;
+        selectedCategory = null;
+        continue;
+      }
+
+      // continue
+    }
+
+    const items = catalog[selectedCategory] || [];
+    const chosen = items.filter((i) => selectedLabels.includes(i.label));
+
+    const packages = uniq(chosen.flatMap((i) => i.packages || []));
+    const packagesDev = uniq(chosen.flatMap((i) => i.packagesDev || []));
+    const posts = uniq(chosen.map((i) => i.post).filter(Boolean));
+
+    const steps = [];
+
+    if (language === "JavaScript/TypeScript") {
+      if (!fs.existsSync(path.join(cwd, "package.json"))) {
+        throw new Error(
+          "No package.json found; run this inside a JS/TS project."
+        );
+      }
+
+      if (packages.length) {
+        const cmd = pmAddCommand(pm, packages, { dev: false });
+        steps.push({ type: "command", ...cmd, cwdFromProjectRoot: true });
+      }
+      if (packagesDev.length) {
+        const cmd = pmAddCommand(pm, packagesDev, { dev: true });
+        steps.push({ type: "command", ...cmd, cwdFromProjectRoot: true });
+      }
+
+      // Optional post-steps
+      for (const post of posts) {
+        if (post === "tailwind-init") {
+          const cmd = pmExecCommand(pm, "tailwindcss", ["init", "-p"]);
+          steps.push({ type: "command", ...cmd, cwdFromProjectRoot: true });
+        }
+        if (post === "playwright-install") {
+          const cmd = pmExecCommand(pm, "playwright", ["install"]);
+          steps.push({ type: "command", ...cmd, cwdFromProjectRoot: true });
+        }
+        if (post === "shadcn-init") {
+          // shadcn/ui uses a CLI; keep it interactive.
+          const cmd = pmExecCommand(pm, "shadcn@latest", ["init"]);
+          steps.push({ type: "command", ...cmd, cwdFromProjectRoot: true });
+        }
+      }
+
+      if (flags.dryRun) {
+        printStepsPreview(steps);
+        console.log("Dry run: nothing executed.");
+        return;
+      }
+
+      if (!flags.yes) {
+        const { ok } = await prompt([
+          {
+            type: "confirm",
+            name: "ok",
+            message: "Install selected libraries now?",
+            default: true,
+          },
+        ]);
+        if (!ok) {
+          selectedLabels = null;
+          continue;
+        }
+      }
+
+      await runSteps(steps, { projectRoot: cwd });
+      console.log("\nDone. Libraries added.");
+      return;
+    }
+
+    if (language === "Python") {
+      const all = uniq([...packages, ...packagesDev]);
+      const { mode } = await prompt([
+        {
+          type: "list",
+          name: "mode",
+          message: "How to add Python packages?",
+          choices: [
+            {
+              name: "Append to requirements.txt (no install)",
+              value: "requirements",
+            },
+            {
+              name: "pip install now (and append requirements.txt)",
+              value: "pip",
+            },
+          ],
+          default: "requirements",
+        },
+      ]);
+
+      const reqPath = path.join(cwd, "requirements.txt");
+      const toAppend = all.map((p) => `${p}\n`).join("");
+
+      if (flags.dryRun) {
+        console.log("\nPlanned actions:");
+        if (mode === "pip") {
+          console.log(`- python -m pip install ${all.join(" ")} (here)`);
+        }
+        console.log(`- append requirements.txt: ${all.join(", ")}`);
+        console.log("\nDry run: nothing executed.");
+        return;
+      }
+
+      if (mode === "pip") {
+        await runSteps(
+          [
+            {
+              type: "command",
+              program: "python",
+              args: ["-m", "pip", "install", ...all],
+              cwdFromProjectRoot: true,
+            },
+          ],
+          { projectRoot: cwd }
+        );
+      }
+
+      fs.appendFileSync(reqPath, toAppend, "utf8");
+      console.log("\nDone. Updated requirements.txt");
+      return;
+    }
+
+    throw new Error(`Add mode not implemented yet for: ${language}`);
+  }
+}
+
+module.exports = {
+  runAdd,
+};

package/src/detect.js

@@ -0,0 +1,44 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function exists(cwd, rel) {
+  return fs.existsSync(path.join(cwd, rel));
+}
+
+function detectPackageManager(cwd) {
+  if (exists(cwd, "pnpm-lock.yaml")) return "pnpm";
+  if (exists(cwd, "yarn.lock")) return "yarn";
+  if (exists(cwd, "bun.lockb") || exists(cwd, "bun.lock")) return "bun";
+  if (exists(cwd, "package-lock.json")) return "npm";
+  // fallback
+  return "npm";
+}
+
+function detectLanguage(cwd) {
+  if (exists(cwd, "package.json")) return "JavaScript/TypeScript";
+  if (exists(cwd, "pyproject.toml") || exists(cwd, "requirements.txt"))
+    return "Python";
+  if (exists(cwd, "go.mod")) return "Go";
+  if (exists(cwd, "Cargo.toml")) return "Rust";
+  if (exists(cwd, "composer.json")) return "PHP";
+  if (
+    exists(cwd, "pom.xml") ||
+    exists(cwd, "build.gradle") ||
+    exists(cwd, "build.gradle.kts")
+  )
+    return "Java/Kotlin";
+  if (
+    fs.readdirSync(cwd).some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))
+  )
+    return "C#";
+  if (exists(cwd, "pubspec.yaml")) return "Dart";
+  if (exists(cwd, "Gemfile")) return "Ruby";
+  if (exists(cwd, "Package.swift")) return "Swift";
+  if (exists(cwd, "CMakeLists.txt")) return "C++";
+  return "Unknown";
+}
+
+module.exports = {
+  detectLanguage,
+  detectPackageManager,
+};