@dawitworku/projectcli 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dawitworku/projectcli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Interactive project generator (language -> framework -> create).",
   "license": "MIT",
   "type": "commonjs",
@@ -26,7 +26,13 @@
     "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"
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "figlet": "^1.9.4",
+    "fuse.js": "^7.1.0",
+    "gradient-string": "^3.0.0",
+    "inquirer": "^8.2.6",
+    "inquirer-autocomplete-prompt": "^2.0.0",
+    "ora": "^5.4.1"
   }
 }

package/src/add.js

@@ -1,5 +1,9 @@
 const fs = require("node:fs");
 const path = require("node:path");
+const chalk = require("chalk");
+const Fuse = require("fuse.js");
+const inquirerImport = require("inquirer");
+const inquirer = inquirerImport.default ?? inquirerImport;
 
 const { detectLanguage, detectPackageManager } = require("./detect");
 const { getCatalog } = require("./libraries");
@@ -21,18 +25,22 @@ function parseAddArgs(argv) {
 }
 
 function printStepsPreview(steps) {
-  console.log("\nPlanned actions:");
+  console.log(chalk.bold.cyan("\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}`);
+      console.log(
+        chalk.gray("- ") +
+          chalk.green(`${step.program} ${step.args.join(" ")}`) +
+          chalk.dim(` ${where}`)
+      );
     } else if (type === "mkdir") {
-      console.log(`- mkdir -p ${step.path}`);
+      console.log(chalk.gray("- ") + chalk.yellow(`mkdir -p ${step.path}`));
     } else if (type === "writeFile") {
-      console.log(`- write ${step.path}`);
+      console.log(chalk.gray("- ") + chalk.yellow(`write ${step.path}`));
     } else {
-      console.log(`- ${type}`);
+      console.log(chalk.gray(`- ${type}`));
     }
   }
   console.log("");
@@ -42,7 +50,7 @@ async function runAdd({ prompt, argv }) {
   const flags = parseAddArgs(argv);
   const cwd = process.cwd();
   const language = detectLanguage(cwd);
-  const pm = detectPackageManager(cwd);
+  const pm = detectPackageManager(cwd); // Now returns pip, poetry, cargo, go, etc.
 
   if (language === "Unknown") {
     throw new Error(
@@ -50,10 +58,8 @@ async function runAdd({ prompt, argv }) {
     );
   }
 
-  console.log(`\nDetected project: ${language}`);
-  if (language === "JavaScript/TypeScript") {
-    console.log(`Detected package manager: ${pm}`);
-  }
+  console.log(chalk.bold(`\nDetected project: ${chalk.blue(language)}`));
+  console.log(chalk.dim(`Detected package manager: ${pm}`));
 
   const catalog = getCatalog(language);
   const categories = Object.keys(catalog);
@@ -61,201 +67,180 @@ async function runAdd({ prompt, argv }) {
     throw new Error(`No library catalog configured for: ${language}`);
   }
 
+  // Flatten catalog for fuzzy search
+  const allItems = [];
+  for (const cat of categories) {
+    for (const item of catalog[cat]) {
+      allItems.push({
+        ...item,
+        category: cat,
+        displayName: `${cat}: ${item.label}`,
+      });
+    }
+  }
+
+  const fuse = new Fuse(allItems, {
+    keys: ["label", "category"],
+    threshold: 0.4,
+  });
+
   const BACK = "__back__";
   const EXIT = "__exit__";
 
-  let selectedCategory = null;
-  let selectedLabels = null;
+  let selectedItems = [];
 
   while (true) {
-    if (!selectedCategory) {
-      const categoryChoices = [
-        ...categories.map((c) => ({
-          name: `${c} (${catalog[c].length})`,
-          value: c,
-        })),
-        new (require("inquirer").Separator)(),
-        { name: "Exit", value: EXIT },
-      ];
+    // If we have selected items, show them
+    if (selectedItems.length > 0) {
+      console.log(chalk.green(`\nSelected:`));
+      selectedItems.forEach((i) => console.log(` - ${i.displayName}`));
+    }
 
-      const { category } = await prompt([
+    const choices = [
+      { name: "Done (Install selected)", value: "DONE" },
+      { name: "Search libraries (Fuzzy)", value: "SEARCH" },
+      { name: "Browse by Category", value: "BROWSE" },
+      new inquirer.Separator(),
+      { name: "Exit", value: EXIT },
+    ];
+
+    const { action } = await prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "What do you want to do?",
+        choices,
+        pageSize: 10,
+      },
+    ]);
+
+    if (action === EXIT) return;
+
+    if (action === "SEARCH") {
+      // Fuzzy search
+      const { item } = await prompt([
         {
-          type: "list",
-          name: "category",
-          message: "Category:",
-          choices: categoryChoices,
-          pageSize: 14,
+          type: "autocomplete",
+          name: "item",
+          message: "Search library:",
+          source: (answersSoFar, input) => {
+            if (!input)
+              return Promise.resolve(
+                allItems.map((i) => ({ name: i.displayName, value: i }))
+              );
+            return Promise.resolve(
+              fuse
+                .search(input)
+                .map((r) => ({ name: r.item.displayName, value: r.item }))
+            );
+          },
         },
       ]);
-
-      if (category === EXIT) return;
-      selectedCategory = category;
+      if (item) {
+        if (!selectedItems.find((i) => i.label === item.label)) {
+          selectedItems.push(item);
+        }
+      }
       continue;
     }
 
-    if (!selectedLabels) {
-      const items = catalog[selectedCategory] || [];
-      const { picks } = await prompt([
+    if (action === "BROWSE") {
+      const { category } = 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,
+          type: "list",
+          name: "category",
+          message: "Category:",
+          choices: [...categories, { name: "Back", value: BACK }],
         },
       ]);
+      if (category === BACK) continue;
 
-      selectedLabels = picks;
-
-      const { next } = await prompt([
+      const items = catalog[category];
+      const { picked } = await prompt([
         {
-          type: "list",
-          name: "next",
-          message: "Next:",
-          choices: [
-            { name: "Continue", value: "continue" },
-            { name: "← Back", value: BACK },
-            { name: "Cancel", value: EXIT },
-          ],
-          pageSize: 8,
+          type: "checkbox",
+          name: "picked",
+          message: "Select libraries:",
+          choices: items.map((i) => ({
+            name: i.label,
+            value: i,
+            checked: !!selectedItems.find((s) => s.label === i.label),
+          })),
         },
       ]);
 
-      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 });
+      for (const p of picked) {
+        if (!selectedItems.find((i) => i.label === p.label)) {
+          selectedItems.push(p);
         }
       }
+      continue;
+    }
 
-      if (flags.dryRun) {
-        printStepsPreview(steps);
-        console.log("Dry run: nothing executed.");
+    if (action === "DONE") {
+      if (selectedItems.length === 0) {
+        console.log(chalk.yellow("No libraries selected. Exiting."));
         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;
+      break;
     }
+  }
 
-    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",
-        },
-      ]);
+  // Install phase
+  const packages = uniq(selectedItems.flatMap((i) => i.packages || []));
+  const packagesDev = uniq(selectedItems.flatMap((i) => i.packagesDev || []));
+  const posts = uniq(selectedItems.map((i) => i.post).filter(Boolean));
 
-      const reqPath = path.join(cwd, "requirements.txt");
-      const toAppend = all.map((p) => `${p}\n`).join("");
+  const steps = [];
 
-      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;
-      }
+  // Generic handling based on 'pm'
+  if (packages.length) {
+    const cmd = pmAddCommand(pm, packages, { dev: false });
+    steps.push({ type: "command", ...cmd, cwdFromProjectRoot: true });
+  }
 
-      if (mode === "pip") {
-        await runSteps(
-          [
-            {
-              type: "command",
-              program: "python",
-              args: ["-m", "pip", "install", ...all],
-              cwdFromProjectRoot: true,
-            },
-          ],
-          { projectRoot: cwd }
-        );
-      }
+  if (packagesDev.length) {
+    const cmd = pmAddCommand(pm, packagesDev, { dev: true });
+    steps.push({ type: "command", ...cmd, cwdFromProjectRoot: true });
+  }
 
-      fs.appendFileSync(reqPath, toAppend, "utf8");
-      console.log("\nDone. Updated requirements.txt");
-      return;
+  // Post install 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") {
+      const cmd = pmExecCommand(pm, "shadcn@latest", ["init"]);
+      steps.push({ type: "command", ...cmd, cwdFromProjectRoot: true });
+    }
+  }
 
-    throw new Error(`Add mode not implemented yet for: ${language}`);
+  if (flags.dryRun) {
+    printStepsPreview(steps);
+    console.log("Dry run: nothing executed.");
+    return;
   }
+
+  if (!flags.yes) {
+    printStepsPreview(steps);
+    const { ok } = await prompt([
+      {
+        type: "confirm",
+        name: "ok",
+        message: "Proceed with installation?",
+        default: true,
+      },
+    ]);
+    if (!ok) return;
+  }
+
+  await runSteps(steps, { projectRoot: cwd });
+  console.log(chalk.green("\nDone. Libraries added."));
 }
 
 module.exports = {

package/src/detect.js

@@ -6,11 +6,29 @@ function exists(cwd, rel) {
 }
 
 function detectPackageManager(cwd) {
+  // JS/TS
   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
+
+  // Python
+  if (exists(cwd, "poetry.lock")) return "poetry";
+  if (exists(cwd, "requirements.txt")) return "pip";
+  if (exists(cwd, "pyproject.toml")) return "pip"; // Default to pip/standard if no specific lock file
+
+  // Rust
+  if (exists(cwd, "Cargo.toml")) return "cargo";
+
+  // Go
+  if (exists(cwd, "go.mod")) return "go";
+
+  // PHP
+  if (exists(cwd, "composer.json")) return "composer";
+
+  // fallback for JS
+  if (exists(cwd, "package.json")) return "npm";
+
   return "npm";
 }
 

package/src/index.js

@@ -1,6 +1,10 @@
 const path = require("node:path");
 const fs = require("node:fs");
 const os = require("node:os");
+const chalk = require("chalk");
+const boxen = require("boxen");
+const figlet = require("figlet");
+const gradient = require("gradient-string");
 const inquirerImport = require("inquirer");
 const inquirer = inquirerImport.default ?? inquirerImport;
 const prompt =
@@ -211,18 +215,22 @@ function withBack(choices) {
 }
 
 function printStepsPreview(steps) {
-  console.log("\nPlanned actions:");
+  console.log(chalk.bold.cyan("\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}`);
+      console.log(
+        chalk.gray("- ") +
+          chalk.green(`${step.program} ${step.args.join(" ")}`) +
+          chalk.dim(` ${where}`)
+      );
     } else if (type === "mkdir") {
-      console.log(`- mkdir -p ${step.path}`);
+      console.log(chalk.gray("- ") + chalk.yellow(`mkdir -p ${step.path}`));
     } else if (type === "writeFile") {
-      console.log(`- write ${step.path}`);
+      console.log(chalk.gray("- ") + chalk.yellow(`write ${step.path}`));
     } else {
-      console.log(`- ${type}`);
+      console.log(chalk.gray(`- ${type}`));
     }
   }
   console.log("");
@@ -267,11 +275,22 @@ async function main(options = {}) {
     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");
+  // Clear console for a fresh start
+  console.clear();
+
+  const title = figlet.textSync(" PROJECT CLI", { font: "Slant" });
+  console.log(gradient.pastel.multiline(title));
+
+  const subtitle = "   The Ultimate Interactive Project Generator   ";
+  console.log(gradient.vice(subtitle));
+  console.log(chalk.dim("   v" + readPackageVersion()));
+  console.log("\n");
+
+  console.log(
+    chalk.cyan.bold(" ? ") +
+      chalk.bold("Select a Language") +
+      chalk.dim(" (Type to search)")
+  );
 
   const languages = getLanguages();
   if (languages.length === 0) {
@@ -319,15 +338,32 @@ async function main(options = {}) {
         return { name: `${lang} (${count})`, value: lang, short: lang };
       });
 
-      const { language } = await prompt([
-        {
-          type: "list",
-          name: "language",
-          message: "Language:",
-          choices: languageChoices,
-          pageSize: 12,
-        },
-      ]);
+      const languageQuestion = hasAutocomplete
+        ? {
+            type: "autocomplete",
+            name: "language",
+            message: "Language (type to search):",
+            pageSize: 12,
+            source: async (_answersSoFar, input) => {
+              const q = String(input || "")
+                .toLowerCase()
+                .trim();
+              if (!q) return languageChoices;
+              // Fuzzy/Simple filter
+              return languageChoices.filter((c) =>
+                String(c.name).toLowerCase().includes(q)
+              );
+            },
+          }
+        : {
+            type: "list",
+            name: "language",
+            message: "Language:",
+            choices: languageChoices,
+            pageSize: 12,
+          };
+
+      const { language } = await prompt([languageQuestion]);
 
       state.language = language;
       state.framework = undefined;
@@ -348,32 +384,32 @@ async function main(options = {}) {
         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 frameworkQuestion = hasAutocomplete
+        ? {
+            type: "autocomplete",
+            name: "framework",
+            message: "Framework (type to search):",
+            pageSize: 12,
+            source: async (_answersSoFar, input) => {
+              const q = String(input || "")
+                .toLowerCase()
+                .trim();
+              const backOption = { name: "← Back", value: BACK };
+              if (!q) return [backOption, ...frameworkChoices];
+
+              const filtered = frameworkChoices.filter((c) =>
+                String(c.name).toLowerCase().includes(q)
+              );
+              return [backOption, ...filtered];
+            },
+          }
+        : {
+            type: "list",
+            name: "framework",
+            message: "Framework:",
+            choices: withBack(frameworkChoices),
+            pageSize: 12,
+          };
 
       const answer = await prompt([frameworkQuestion]);
       if (answer.framework === BACK) {

package/src/libraries.js

@@ -27,16 +27,21 @@ const JS_TS = {
   "UX / Animation": [
     { label: "Framer Motion", packages: ["framer-motion"] },
     { label: "Lottie", packages: ["lottie-react"] },
+    { label: "GSAP", packages: ["gsap"] },
+    { label: "Three.js", packages: ["three"] },
   ],
   "Forms / Validation": [
     { label: "React Hook Form", packages: ["react-hook-form"] },
     { label: "Zod", packages: ["zod"] },
     { label: "Yup", packages: ["yup"] },
+    { label: "Valibot", packages: ["valibot"] },
   ],
   "Data / State": [
     { label: "TanStack Query", packages: ["@tanstack/react-query"] },
     { label: "Zustand", packages: ["zustand"] },
     { label: "Redux Toolkit", packages: ["@reduxjs/toolkit", "react-redux"] },
+    { label: "Jotai", packages: ["jotai"] },
+    { label: "Recoil", packages: ["recoil"] },
   ],
   Testing: [
     { label: "Vitest", packagesDev: ["vitest"] },
@@ -45,6 +50,16 @@ const JS_TS = {
       packagesDev: ["@playwright/test"],
       post: "playwright-install",
     },
+    { label: "Jest", packagesDev: ["jest", "ts-jest", "@types/jest"] },
+    { label: "Cypress", packagesDev: ["cypress"] },
+  ],
+  "Backend / API": [
+    { label: "Axios", packages: ["axios"] },
+    {
+      label: "TRPC",
+      packages: ["@trpc/client", "@trpc/server", "@trpc/react-query"],
+    },
+    { label: "Socket.io Client", packages: ["socket.io-client"] },
   ],
 };
 
@@ -53,17 +68,80 @@ const PY = {
     { label: "Rich", packages: ["rich"] },
     { label: "Typer (CLI)", packages: ["typer"] },
     { label: "Textual", packages: ["textual"] },
+    { label: "Flet", packages: ["flet"] },
   ],
   Web: [
-    { label: "FastAPI", packages: ["fastapi", "uvicorn"] },
+    { label: "FastAPI", packages: ["fastapi", "uvicorn[standard]"] },
     { label: "Flask", packages: ["flask"] },
     { label: "Django", packages: ["django"] },
+    { label: "Starlette", packages: ["starlette"] },
+    { label: "Litestar", packages: ["litestar"] },
+  ],
+  "Data Science": [
+    { label: "Pandas", packages: ["pandas"] },
+    { label: "NumPy", packages: ["numpy"] },
+    { label: "Matplotlib", packages: ["matplotlib"] },
+    { label: "Scikit-learn", packages: ["scikit-learn"] },
+  ],
+  Testing: [
+    { label: "Pytest", packages: ["pytest"] },
+    { label: "Unittest", packages: [] }, // builtin
+  ],
+};
+
+const RUST = {
+  Web: [
+    { label: "Axum", packages: ["axum", "tokio"] },
+    { label: "Actix-web", packages: ["actix-web"] },
+    { label: "Rocket", packages: ["rocket"] },
+    { label: "Yew", packages: ["yew"] },
+    { label: "Leptos", packages: ["leptos"] },
+  ],
+  "CLI / TUI": [
+    { label: "Clap", packages: ["clap"] },
+    { label: "Ratatui", packages: ["ratatui"] },
+    { label: "Dialoguer", packages: ["dialoguer"] },
+    { label: "Inquire", packages: ["inquire"] },
+  ],
+  "Async / Runtime": [{ label: "Tokio", packages: ["tokio"] }],
+  Serialization: [{ label: "Serde", packages: ["serde", "serde_json"] }],
+  "ORM / DB": [
+    { label: "Diesel", packages: ["diesel"] },
+    { label: "SQLx", packages: ["sqlx"] },
+    { label: "SeaORM", packages: ["sea-orm"] },
+  ],
+  Utilities: [
+    { label: "Anyhow", packages: ["anyhow"] },
+    { label: "Thiserror", packages: ["thiserror"] },
+    { label: "Log", packages: ["log"] },
+    { label: "Env_logger", packages: ["env_logger"] },
+  ],
+};
+
+const GO = {
+  Web: [
+    { label: "Gin", packages: ["github.com/gin-gonic/gin"] },
+    { label: "Echo", packages: ["github.com/labstack/echo/v4"] },
+    { label: "Fiber", packages: ["github.com/gofiber/fiber/v2"] },
+    { label: "Chi", packages: ["github.com/go-chi/chi/v5"] },
+  ],
+  CLI: [
+    { label: "Cobra", packages: ["github.com/spf13/cobra"] },
+    { label: "Viper", packages: ["github.com/spf13/viper"] },
+    { label: "Bubbletea", packages: ["github.com/charmbracelet/bubbletea"] },
+  ],
+  "ORM / DB": [
+    { label: "GORM", packages: ["gorm.io/gorm"] },
+    { label: "Ent", packages: ["entgo.io/ent"] },
+    { label: "Sqlc", packages: ["github.com/kyleconroy/sqlc/cmd/sqlc"] },
   ],
 };
 
 function getCatalog(language) {
   if (language === "JavaScript/TypeScript") return JS_TS;
   if (language === "Python") return PY;
+  if (language === "Rust") return RUST;
+  if (language === "Go") return GO;
   return {};
 }
 

package/src/pm.js

@@ -2,6 +2,11 @@ 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"] };
+  if (pm === "poetry") return { program: "poetry", args: ["install"] };
+  if (pm === "pip")
+    return { program: "pip", args: ["install", "-r", "requirements.txt"] };
+  if (pm === "cargo") return { program: "cargo", args: ["build"] };
+  if (pm === "go") return { program: "go", args: ["mod", "tidy"] };
   return { program: "npm", args: ["install"] };
 }
 
@@ -23,6 +28,28 @@ function pmAddCommand(pm, packages, { dev = false } = {}) {
     return { program: "bun", args: ["add", ...(dev ? ["-d"] : []), ...pkgs] };
   }
 
+  // Python
+  if (pm === "pip") {
+    return { program: "pip", args: ["install", ...pkgs] };
+  }
+  if (pm === "poetry") {
+    return {
+      program: "poetry",
+      args: ["add", ...(dev ? ["--group", "dev"] : []), ...pkgs],
+    };
+  }
+
+  // Rust
+  if (pm === "cargo") {
+    return { program: "cargo", args: ["add", ...pkgs] };
+  }
+
+  // Go
+  if (pm === "go") {
+    // go get matches 'add' somewhat, but typically go get <pkg>
+    return { program: "go", args: ["get", ...pkgs] };
+  }
+
   return { program: "npm", args: ["install", ...(dev ? ["-D"] : []), ...pkgs] };
 }
 
@@ -32,6 +59,11 @@ function pmExecCommand(pm, pkg, 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] };
+  if (pm === "mvn")
+    return { program: "mvn", args: ["archetype:generate", ...args] };
+  if (pm === "gradle") return { program: "gradle", args: ["init", ...args] };
+  if (pm === "composer")
+    return { program: "composer", args: ["create-project", pkg, ...args] };
 
   // npm default
   return { program: "npx", args: ["--yes", pkg, ...args] };

package/src/registry.js

@@ -94,6 +94,36 @@ const REGISTRY = {
       },
       notes: "Vite + Svelte (JS)",
     },
+    "Vite (Preact)": {
+      id: "js.vite.preact",
+      label: "Vite (Preact)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        const pm = getPackageManager(ctx);
+        return [
+          pmExec(pm, "create-vite@latest", [
+            projectName,
+            "--template",
+            "preact",
+          ]),
+          pmInstall(pm, { cwdFromProjectRoot: true }),
+        ];
+      },
+      notes: "Vite + Preact (JS)",
+    },
+    "Vite (Lit)": {
+      id: "js.vite.lit",
+      label: "Vite (Lit)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        const pm = getPackageManager(ctx);
+        return [
+          pmExec(pm, "create-vite@latest", [projectName, "--template", "lit"]),
+          pmInstall(pm, { cwdFromProjectRoot: true }),
+        ];
+      },
+      notes: "Vite + Lit (JS)",
+    },
     "Next.js": {
       id: "js.nextjs",
       label: "Next.js",
@@ -110,7 +140,6 @@ const REGISTRY = {
       commands: (ctx) => {
         const projectName = getProjectName(ctx);
         const pm = getPackageManager(ctx);
-        // Astro docs recommend npm/pnpm/yarn create astro@latest; using the underlying package works too.
         return [pmExec(pm, "create-astro@latest", [projectName])];
       },
       notes: "Astro site (wizard)",
@@ -148,6 +177,63 @@ const REGISTRY = {
       },
       notes: "Nuxt via nuxi init",
     },
+    "Express (Generator)": {
+      id: "js.express",
+      label: "Express",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        const pm = getPackageManager(ctx);
+        return [
+          pmExec(pm, "express-generator", [projectName]),
+          pmInstall(pm, { cwdFromProjectRoot: true }),
+        ];
+      },
+      notes: "Scaffolds basic Express app",
+    },
+    "Fastify (CLI)": {
+      id: "js.fastify",
+      label: "Fastify",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        const pm = getPackageManager(ctx);
+        return [
+          pmExec(pm, "fastify-cli", ["generate", projectName]),
+          pmInstall(pm, { cwdFromProjectRoot: true }),
+        ];
+      },
+      notes: "Scaffolds Fastify app",
+    },
+    "React Native (Expo)": {
+      id: "js.expo",
+      label: "React Native (Expo)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        const pm = getPackageManager(ctx);
+        // create-expo-app
+        return [pmExec(pm, "create-expo-app@latest", [projectName])];
+      },
+      notes: "Expo for React Native",
+    },
+    "Electron (Forge)": {
+      id: "js.electron",
+      label: "Electron (Forge)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        const pm = getPackageManager(ctx);
+        return [pmExec(pm, "create-electron-app@latest", [projectName])];
+      },
+      notes: "Electron Forge template",
+    },
+    "Qwik City": {
+      id: "js.qwik",
+      label: "Qwik City",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        const pm = getPackageManager(ctx);
+        return [pmExec(pm, "create-qwik@latest", ["basic", projectName])];
+      },
+      notes: "Qwik framework",
+    },
     "Node.js (basic)": {
       id: "js.node.basic",
       label: "Node.js (basic)",
@@ -388,6 +474,29 @@ const REGISTRY = {
       ],
       notes: "Writes files only (no pip install).",
     },
+    Pyramid: {
+      id: "py.pyramid",
+      label: "Pyramid",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          // Pyramid cookiecutter is common, but basic scaffold:
+          { type: "mkdir", path: "." },
+          {
+            type: "writeFile",
+            path: "requirements.txt",
+            content: "pyramid\nwaitress\n",
+          },
+          {
+            type: "writeFile",
+            path: "app.py",
+            content:
+              "from wsgiref.simple_server import make_server\nfrom pyramid.config import Configurator\nfrom pyramid.response import Response\n\ndef hello_world(request):\n    return Response('Hello World!')\n\nif __name__ == '__main__':\n    with Configurator() as config:\n        config.add_route('hello', '/')\n        config.add_view(hello_world, route_name='hello')\n        app = config.make_wsgi_app()\n    server = make_server('0.0.0.0', 6543, app)\n    server.serve_forever()\n",
+          },
+        ];
+      },
+      notes: "Pyramid basic app",
+    },
   },
 
   Rust: {
@@ -419,6 +528,35 @@ const REGISTRY = {
       },
       notes: "Uses cargo new --lib",
     },
+    "Tauri (App)": {
+      id: "rs.tauri",
+      label: "Tauri (App)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        const pm = getPackageManager(ctx); // usually npm for tauri frontend
+        // Using create-tauri-app via pmExec
+        // cargo create-tauri-app is also an option but node way is common if JS frontend
+        return [pmExec(pm, "create-tauri-app@latest", [projectName])];
+      },
+      notes: "Cross-platform desktop app",
+    },
+    "Leptos (CSR)": {
+      id: "rs.leptos",
+      label: "Leptos (CSR)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          {
+            program: "cargo",
+            args: ["init", "--name", projectName],
+            cwdFromProjectRoot: true,
+          },
+          // In reality, one would use cargo-leptos or a template.
+          // Just a stub for now.
+        ];
+      },
+      notes: "Init basic Rust project (Leptos needs template usually)",
+    },
   },
 
   Go: {
@@ -459,6 +597,92 @@ const REGISTRY = {
       },
       notes: "Writes main.go + runs go mod init",
     },
+    "Buffalo (Web)": {
+      id: "go.buffalo",
+      label: "Buffalo (Web)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          {
+            program: "buffalo",
+            args: ["new", projectName],
+          },
+        ];
+      },
+      notes: "Requires 'buffalo' CLI installed",
+    },
+    "Fiber (Skeleton)": {
+      id: "go.fiber",
+      label: "Fiber (Skeleton)",
+      commands: (_ctx) => [
+        { type: "mkdir", path: "." },
+        {
+          type: "writeFile",
+          path: "main.go",
+          content: `package main
+
+import "github.com/gofiber/fiber/v2"
+
+func main() {
+  app := fiber.New()
+
+  app.Get("/", func(c *fiber.Ctx) error {
+    return c.SendString("Hello, World!")
+  })
+
+  app.Listen(":3000")
+}
+`,
+        },
+        {
+          program: "go",
+          args: ["mod", "init", "fiber-app"],
+          cwdFromProjectRoot: true,
+        },
+        {
+          program: "go",
+          args: ["get", "github.com/gofiber/fiber/v2"],
+          cwdFromProjectRoot: true,
+        },
+      ],
+      notes: "Basic Fiber setup",
+    },
+  },
+
+  "C++": {
+    "CMake (Basic)": {
+      id: "cpp.cmake",
+      label: "CMake (Basic)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          { type: "mkdir", path: "src" },
+          {
+            type: "writeFile",
+            path: "CMakeLists.txt",
+            content: `cmake_minimum_required(VERSION 3.10)
+project(${projectName})
+
+set(CMAKE_CXX_STANDARD 17)
+
+add_executable(${projectName} src/main.cpp)
+`,
+          },
+          {
+            type: "writeFile",
+            path: "src/main.cpp",
+            content: `#include <iostream>
+
+int main() {
+    std::cout << "Hello, World!" << std::endl;
+    return 0;
+}
+`,
+          },
+        ];
+      },
+      notes: "Standard CMake structure",
+    },
   },
 
   "C#": {
@@ -491,6 +715,180 @@ const REGISTRY = {
       notes: "Requires dotnet SDK",
     },
   },
+
+  Ruby: {
+    Rails: {
+      id: "rb.rails",
+      label: "Rails",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          {
+            program: "rails",
+            args: ["new", projectName],
+          },
+        ];
+      },
+      notes: "Requires rails gem installed",
+    },
+    "Bundler (gem)": {
+      id: "rb.bundler",
+      label: "Bundler (new gem)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          {
+            program: "bundle",
+            args: ["gem", projectName],
+          },
+        ];
+      },
+      notes: "Creates a new gem with bundler",
+    },
+  },
+
+  PHP: {
+    Laravel: {
+      id: "php.laravel",
+      label: "Laravel",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          {
+            program: "composer",
+            args: ["create-project", "laravel/laravel", projectName],
+          },
+        ];
+      },
+      notes: "Uses composer create-project",
+    },
+    Symfony: {
+      id: "php.symfony",
+      label: "Symfony",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          {
+            program: "composer",
+            args: ["create-project", "symfony/skeleton", projectName],
+          },
+        ];
+      },
+      notes: "Uses composer create-project",
+    },
+  },
+
+  "Java/Kotlin": {
+    "Spring Boot (Maven)": {
+      id: "java.springboot.maven",
+      label: "Spring Boot (Maven)",
+      commands: (ctx) => {
+        // Simple archetype or just hints. Spring Init is complex.
+        // Let's use maven quickstart for now as basic.
+        const projectName = getProjectName(ctx);
+        return [
+          {
+            program: "mvn",
+            args: [
+              "archetype:generate",
+              "-DgroupId=com.example",
+              `-DartifactId=${projectName}`,
+              "-DarchetypeArtifactId=maven-archetype-quickstart",
+              "-DinteractiveMode=false",
+            ],
+          },
+        ];
+      },
+      notes: "Basic Maven Quickstart",
+    },
+    "Gradle (Basic)": {
+      id: "java.gradle.basic",
+      label: "Gradle (Basic)",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          { type: "mkdir", path: projectName },
+          {
+            program: "gradle",
+            args: [
+              "init",
+              "--type",
+              "basic",
+              "--dsl",
+              "kotlin",
+              "--project-name",
+              projectName,
+            ],
+            cwd: projectName, // This property needs to be supported in runSteps, handled via chdir logic usually?
+            // current runSteps implementation supports cwdFromProjectRoot but not arbitrary cwd change easily maybe?
+            // runSteps implementation check:
+            // It uses `cwdFromProjectRoot` or defaults to current process.cwd().
+            // Better to just run gradle init inside the folder.
+          },
+        ];
+      },
+      notes: "Gradle init",
+    },
+    Quarkus: {
+      id: "java.quarkus",
+      label: "Quarkus",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          {
+            program: "mvn",
+            args: [
+              "io.quarkus.platform:quarkus-maven-plugin:create",
+              `-DprojectGroupId=org.acme`,
+              `-DprojectArtifactId=${projectName}`,
+            ],
+          },
+        ];
+      },
+      notes: "Quarkus app (Maven)",
+    },
+  },
+
+  Others: {
+    "HTML/CSS": {
+      id: "other.html",
+      label: "HTML/CSS (Vanilla)",
+      commands: (ctx) => {
+        return [
+          { type: "mkdir", path: "." },
+          {
+            type: "writeFile",
+            path: "index.html",
+            content:
+              '<!DOCTYPE html>\\n<html lang="en">\\n<head>\\n    <meta charset="UTF-8">\\n    <title>My App</title>\\n</head>\\n<body>\\n    <h1>Hello World</h1>\\n</body>\\n</html>',
+          },
+          {
+            type: "writeFile",
+            path: "style.css",
+            content: "body { font-family: sans-serif; }",
+          },
+        ];
+      },
+      notes: "Just static files",
+    },
+  },
+
+  Dart: {
+    "Console Application": {
+      id: "dart.console",
+      label: "Console Application",
+      commands: (ctx) => {
+        const projectName = getProjectName(ctx);
+        return [
+          {
+            program: "dart",
+            args: ["create", "-t", "console", projectName],
+          },
+        ];
+      },
+      notes: "Requires Dart SDK",
+    },
+  },
 };
 
 function getLanguages() {