@dawitworku/projectcli 0.2.0 → 0.2.2

package/README.md

@@ -1,75 +1,118 @@
-# projectcli
+# ProjectCLI 🚀
 
-Interactive project generator.
+> **The Swiss Army Knife for Project Scaffolding.**  
+> Bootstrapping new projects shouldn't require memorizing 50 different CLI commands.
 
-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.).
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm version](https://badge.fury.io/js/@dawitworku%2Fprojectcli.svg)](https://badge.fury.io/js/@dawitworku%2Fprojectcli)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
 
-## Run with npx (recommended)
+**ProjectCLI** is an interactive, cross-language project generator. Instead of remembering usage for `create-react-app`, `cargo new`, `poetry new`, `laravel new`, `rails new`, etc., just run `projectcli`.
 
-After you publish this package to npm:
+We handle the complexity of calling the official CLIs for you.
+
+## ✨ Features
+
+- **Multi-Language Support**: Rust, Go, Python, JavaScript, TypeScript, PHP, Java, C#, Ruby, Swift, Dart.
+- **Unified Interface**: One interactive wizard to rule them all.
+- **Smart Context Awareness**: Running `projectcli` inside an existing project automatically offers to add libraries, CI/CD, or Dockerfiles tailored to that language.
+- **Preflight Checks**: Warns you if you are missing required tools (e.g. `cargo`, `go`, `node`) before you start.
+- **Remote Templates**: Clone any GitHub repository and automatically strip `.git` history for a fresh start.
+- **CI/CD & Docker**: One-click generation of GitHub Actions workflows and Dockerfiles.
+- **Dev Containers**: Generate `.devcontainer/devcontainer.json` for VS Code / Codespaces.
+- **License Generator**: Add a standard `LICENSE` file (configurable default).
+
+## 🚀 Quick Start
+
+Run instantly with `npx`:
 
 ```bash
 npx @dawitworku/projectcli@latest
 ```
 
-You can also run non-interactively:
+Or install globally:
 
 ```bash
-npx @dawitworku/projectcli@latest --language "TypeScript" --framework "NestJS" --name my-api --pm npm
+npm install -g @dawitworku/projectcli
+projectcli
 ```
 
-## Run (dev)
+## 🎮 Interactive Mode
+
+Just run `projectcli` and follow the prompts:
+
+1. Select **Language** (fuzzy search supported).
+2. Select **Framework** (React, Vue, Next.js, Actix, Axum, Django, FastAPI, etc.).
+3. Choose **Project Name**.
+4. (Optional) Add **CI/CD** or **Docker**.
+
+## 🛠 Advanced Usage
+
+### Context Awareness
+
+Run it inside a project to detect the language and offer relevant tools:
 
 ```bash
-npm install
-npm start
+cd my-rust-project
+projectcli
+# Output: "✓ Detected active Rust project"
+# Options: [Add GitHub Actions CI], [Add Dockerfile], [Add Dependencies]
 ```
 
-## Install as a single-word command
+### Remote Templates
 
-From this repo folder:
+Clone a starter kit from GitHub and make it your own instantly:
 
 ```bash
-npm install
-npm link
+projectcli --template https://github.com/example/starter-repo --name my-app
 ```
 
-Then you can run:
+### Automation / CI Use
+
+Skip the interactive prompts for scripts or specialized workflows:
 
 ```bash
-projectcli
+projectcli --language Rust --framework Actix --name my-api --ci --docker --yes
 ```
 
-## Add libraries to an existing project
+### Configuration
 
-Run inside a project folder:
+Save your preferences (like default package manager):
 
 ```bash
-projectcli add
+projectcli config
 ```
 
-## Notes
+You can set defaults like:
 
-- 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.
+- JS/TS package manager
+- Author name (for LICENSE)
+- Default license type (MIT/Apache2/ISC)
 
-## Useful flags
+## 📦 Supported Generators (Partial List)
 
-```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
-```
+| Language                  | Frameworks / Tools                                            |
+| ------------------------- | ------------------------------------------------------------- |
+| **JavaScript/TypeScript** | React (Vite), Vue, Next.js, NestJS, Express, Astro, Svelte... |
+| **Rust**                  | Binary, Library, Actix Web, Axum, Rocket, Taurus...           |
+| **Python**                | Poetry, Setuptools, Django, Flask, FastAPI...                 |
+| **Go**                    | Binary, Fiber, Gin, Chi, Echo...                              |
+| **PHP**                   | Laravel, Symfony, Slim...                                     |
+| **Java/Kotlin**           | Spring Boot, Gradle/Maven...                                  |
+| **...and more**           | C#, Ruby, Swift, Dart                                         |
+
+## 🤝 Contributing
+
+We love contributions! Whether it's adding a new framework to the registry or fixing a bug.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b feature/new-framework`).
+3.  Commit your changes (`git commit -am 'Add support for X'`).
+4.  Push to the branch (`git push origin feature/new-framework`).
+5.  Create a new Pull Request.
 
-## How it works
+See [CONTRIBUTING.md](CONTRIBUTING.md) for more details.
 
-- Choose language
-- Choose framework
-- Enter project name
-- CLI runs the underlying generator commands (npm/cargo/django-admin/etc.)
+## 📝 License
 
-If a generator command is missing on your machine, install it and re-run.
+MIT © [Dawit Worku](https://github.com/dawitworku)

package/package.json

@@ -1,7 +1,16 @@
 {
   "name": "@dawitworku/projectcli",
-  "version": "0.2.0",
-  "description": "Interactive project generator (language -> framework -> create).",
+  "version": "0.2.2",
+  "description": "The ultimate interactive project generator (language -> framework -> create).",
+  "author": "Dawit Worku",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dawitworku/projectcli"
+  },
+  "bugs": {
+    "url": "https://github.com/dawitworku/projectcli/issues"
+  },
+  "homepage": "https://github.com/dawitworku/projectcli#readme",
   "license": "MIT",
   "type": "commonjs",
   "bin": {
@@ -23,7 +32,7 @@
   ],
   "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"
+    "lint": "node -c bin/projectcli.js && node -c src/index.js && node -c src/registry.js && node -c src/run.js && node -c src/settings.js && node -c src/config.js && node -c src/devcontainer.js && node -c src/license.js"
   },
   "dependencies": {
     "boxen": "^5.1.2",

package/src/config.js

@@ -0,0 +1,34 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const CONFIG_PATH = path.join(os.homedir(), ".projectcli.json");
+
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const content = fs.readFileSync(CONFIG_PATH, "utf8");
+      return JSON.parse(content);
+    }
+  } catch (err) {
+    // ignore
+  }
+  return {};
+}
+
+function saveConfig(data) {
+  try {
+    const current = loadConfig();
+    const updated = { ...current, ...data };
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(updated, null, 2));
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  CONFIG_PATH,
+};

package/src/devcontainer.js

@@ -0,0 +1,82 @@
+const DEVCONTAINER_NODE = `{
+  "name": "Node.js",
+  "image": "mcr.microsoft.com/devcontainers/javascript-node:20",
+  "features": {
+    "ghcr.io/devcontainers/features/node:1": {}
+  },
+  "forwardPorts": [3000],
+  "postCreateCommand": "npm install"
+}`;
+
+const DEVCONTAINER_PYTHON = `{
+  "name": "Python 3",
+  "image": "mcr.microsoft.com/devcontainers/python:3.11",
+  "features": {
+    "ghcr.io/devcontainers/features/python:1": {}
+  },
+  "postCreateCommand": "pip install -r requirements.txt"
+}`;
+
+const DEVCONTAINER_RUST = `{
+  "name": "Rust",
+  "image": "mcr.microsoft.com/devcontainers/rust:1",
+  "features": {
+    "ghcr.io/devcontainers/features/rust:1": {}
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["rust-lang.rust-analyzer", "tamasfe.even-better-toml"]
+    }
+  },
+  "postCreateCommand": "cargo build"
+}`;
+
+const DEVCONTAINER_GO = `{
+  "name": "Go",
+  "image": "mcr.microsoft.com/devcontainers/go:1.21",
+  "features": {
+    "ghcr.io/devcontainers/features/go:1": {}
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["golang.Go"]
+    }
+  },
+  "postCreateCommand": "go mod download"
+}`;
+
+function getDevContainer(language) {
+  if (language === "JavaScript" || language === "TypeScript")
+    return DEVCONTAINER_NODE;
+  if (language === "Python") return DEVCONTAINER_PYTHON;
+  if (language === "Rust") return DEVCONTAINER_RUST;
+  if (language === "Go") return DEVCONTAINER_GO;
+
+  // Generic fallback
+  return `{
+  "name": "Default",
+  "image": "mcr.microsoft.com/devcontainers/base:ubuntu",
+  "features": {
+    "ghcr.io/devcontainers/features/common-utils:2": {}
+  }
+}`;
+}
+
+function generateDevContainer(projectRoot, language) {
+  const content = getDevContainer(language);
+  return [
+    {
+      type: "mkdir",
+      path: ".devcontainer",
+    },
+    {
+      type: "writeFile",
+      path: ".devcontainer/devcontainer.json",
+      content: content,
+    },
+  ];
+}
+
+module.exports = {
+  generateDevContainer,
+};

package/src/index.js

@@ -28,8 +28,15 @@ try {
 const { getLanguages, getFrameworks, getGenerator } = require("./registry");
 const { runSteps } = require("./run");
 const { runAdd } = require("./add");
+const { checkBinaries } = require("./preflight");
+const { gitClone, removeGitFolder } = require("./remote");
 const { generateCI, generateDocker } = require("./cicd");
+const { generateDevContainer } = require("./devcontainer");
+const { generateLicense, licenseTypes } = require("./license");
 const { getDescription } = require("./descriptions");
+const { detectLanguage, detectPackageManager } = require("./detect");
+const { loadConfig } = require("./config");
+const { runConfig } = require("./settings");
 
 const RUST_KEYWORDS = new Set(
   [
@@ -133,7 +140,10 @@ function parseArgs(argv) {
     pm: undefined,
     ci: false,
     docker: false,
+    devcontainer: false,
+    license: undefined,
     learning: false,
+    template: undefined,
   };
 
   const nextValue = (i) => {
@@ -150,8 +160,16 @@ function parseArgs(argv) {
     else if (a === "--dry-run") out.dryRun = true;
     else if (a === "--ci") out.ci = true;
     else if (a === "--docker") out.docker = true;
+    else if (a === "--devcontainer") out.devcontainer = true;
+    else if (a === "--license") out.license = true;
+    else if (a === "--no-license") out.license = false;
     else if (a === "--learning") out.learning = true;
-    else if (a.startsWith("--language="))
+    else if (a.startsWith("--template="))
+      out.template = a.slice("--template=".length);
+    else if (a === "--template") {
+      out.template = nextValue(i);
+      i++;
+    } else if (a.startsWith("--language="))
       out.language = a.slice("--language=".length);
     else if (a === "--language") {
       out.language = nextValue(i);
@@ -197,6 +215,7 @@ function printHelp() {
   console.log(
     "  projectcli --language <lang> --framework <fw> --name <project>"
   );
+  console.log("  projectcli config        # configure defaults");
   console.log("");
   console.log("Flags:");
   console.log("  --help, -h       Show help");
@@ -212,10 +231,15 @@ function printHelp() {
   );
   console.log("  --ci             Auto-add GitHub Actions CI");
   console.log("  --docker         Auto-add Dockerfile");
+  console.log("  --devcontainer   Auto-add VS Code Dev Container");
+  console.log("  --license        Force-add LICENSE (uses config defaults)");
+  console.log("  --no-license     Never add LICENSE");
   console.log("  --learning       Enable learning mode (shows descriptions)");
+  console.log("  --template       Clone from a Git repository URL");
 }
 
 const BACK = "__back__";
+const COMMUNITY = "Community / Remote";
 
 function withBack(choices) {
   return [
@@ -247,6 +271,22 @@ function printStepsPreview(steps) {
   console.log("");
 }
 
+function filterExistingWriteFiles(steps, projectRoot) {
+  const kept = [];
+  const skipped = [];
+  for (const step of steps || []) {
+    if (step && step.type === "writeFile" && typeof step.path === "string") {
+      const target = path.resolve(projectRoot, step.path);
+      if (fs.existsSync(target)) {
+        skipped.push(step.path);
+        continue;
+      }
+    }
+    kept.push(step);
+  }
+  return { kept, skipped };
+}
+
 function printList() {
   for (const lang of getLanguages()) {
     console.log(`${lang}:`);
@@ -310,6 +350,134 @@ async function main(options = {}) {
     return;
   }
 
+  if (cmd === "config") {
+    await runConfig({ prompt });
+    return;
+  }
+
+  // Smart Context Detection
+  if (
+    cmd === "init" &&
+    rest.length === 0 &&
+    !args.language &&
+    !args.framework &&
+    !args.template &&
+    !args.name
+  ) {
+    const detected = detectLanguage(process.cwd());
+    if (detected && detected !== "Unknown") {
+      console.clear();
+      console.log(
+        gradient.pastel.multiline(
+          figlet.textSync("ProjectCLI", { font: "Standard" })
+        )
+      );
+      console.log(chalk.bold.magenta("  The Swiss Army Knife for Developers"));
+      console.log("");
+      console.log(
+        chalk.green(`✓ Detected active ${chalk.bold(detected)} project.`)
+      );
+
+      const { action } = await prompt([
+        {
+          type: "list",
+          name: "action",
+          message: "What would you like to do?",
+          choices: [
+            { name: "Add Library / Dependency", value: "add" },
+            { name: "Add GitHub Actions CI", value: "ci" },
+            { name: "Add Dockerfile", value: "docker" },
+            { name: "Add Dev Container (VS Code)", value: "devcontainer" },
+            { name: "Add License", value: "license" },
+            new inquirer.Separator(),
+            { name: "Start New Project Here", value: "new" },
+            { name: "Exit", value: "exit" },
+          ],
+        },
+      ]);
+
+      if (action === "exit") process.exit(0);
+
+      if (action === "add") {
+        // reuse the add logic, passing empty args so it detects locally
+        await runAdd({ prompt, argv: [] });
+        return;
+      }
+
+      if (action === "ci" || action === "docker" || action === "devcontainer") {
+        const pm = detectPackageManager(process.cwd());
+        let langArg = detected;
+        if (detected === "JavaScript/TypeScript") langArg = "JavaScript";
+        if (detected === "Java/Kotlin") langArg = "Java";
+
+        let steps = [];
+        if (action === "ci") steps = generateCI(process.cwd(), langArg, pm);
+        else if (action === "docker")
+          steps = generateDocker(process.cwd(), langArg);
+        else steps = generateDevContainer(process.cwd(), langArg);
+
+        const { kept, skipped } = filterExistingWriteFiles(
+          steps,
+          process.cwd()
+        );
+
+        if (kept.length > 0) {
+          console.log("\nApplying changes...");
+          await runSteps(kept, { projectRoot: process.cwd() });
+          if (skipped.length > 0) {
+            console.log(
+              chalk.dim(`Skipped existing files: ${skipped.join(", ")}`)
+            );
+          }
+          console.log(chalk.green("Done!"));
+        } else {
+          console.log(
+            chalk.yellow(
+              "No standard template available for this language yet."
+            )
+          );
+        }
+        return;
+      }
+
+      if (action === "license") {
+        const { type, author } = await prompt([
+          {
+            type: "list",
+            name: "type",
+            message: "Choose a license:",
+            choices: licenseTypes,
+          },
+          {
+            type: "input",
+            name: "author",
+            message: "Author Name:",
+            default: userConfig.author || "The Authors",
+          },
+        ]);
+        const steps = generateLicense(process.cwd(), type, author);
+        const { kept, skipped } = filterExistingWriteFiles(
+          steps,
+          process.cwd()
+        );
+        if (kept.length === 0) {
+          console.log(chalk.dim("Nothing to do (LICENSE already exists)."));
+          return;
+        }
+        await runSteps(kept, { projectRoot: process.cwd() });
+        if (skipped.length > 0) {
+          console.log(
+            chalk.dim(`Skipped existing files: ${skipped.join(", ")}`)
+          );
+        }
+        console.log(chalk.green("Done!"));
+        return;
+      }
+
+      // If 'new', fall through to normal wizard
+    }
+  }
+
   // Clear console for a fresh start
   console.clear();
 
@@ -332,13 +500,37 @@ async function main(options = {}) {
     throw new Error("No languages configured.");
   }
 
+  const userConfig = loadConfig();
+
   const allowedPms = ["npm", "pnpm", "yarn", "bun"];
-  const preselectedPm =
+  let preselectedPm =
     typeof args.pm === "string" && allowedPms.includes(args.pm)
       ? args.pm
       : undefined;
 
+  if (!preselectedPm && userConfig.packageManager) {
+    if (allowedPms.includes(userConfig.packageManager)) {
+      preselectedPm = userConfig.packageManager;
+    }
+  }
+
+  if (userConfig.learningMode && args.learning === false) {
+    args.learning = true;
+  }
+
+  const defaultLicenseType =
+    typeof userConfig.defaultLicense === "string" &&
+    licenseTypes.includes(userConfig.defaultLicense)
+      ? userConfig.defaultLicense
+      : null;
+
+  const defaultAuthor =
+    typeof userConfig.author === "string" && userConfig.author.trim()
+      ? userConfig.author.trim()
+      : "The Authors";
+
   const state = {
+    template: args.template || undefined,
     language:
       args.language && languages.includes(args.language)
         ? args.language
@@ -360,7 +552,10 @@ async function main(options = {}) {
     state.language === "JavaScript" || state.language === "TypeScript";
 
   let step = "language";
-  if (!state.language) step = "language";
+  if (state.template) {
+    if (!state.name) step = "name";
+    else step = "confirm";
+  } else if (!state.language) step = "language";
   else if (!state.framework) step = "framework";
   else if (needsPackageManager && !state.pm) step = "pm";
   else if (!state.name) step = "name";
@@ -453,6 +648,38 @@ async function main(options = {}) {
       }
 
       state.framework = answer.framework;
+
+      // Preflight Checks
+      const gen = getGenerator(state.language, state.framework);
+      if (gen && gen.check && gen.check.length > 0) {
+        /* eslint-disable-next-line no-console */
+        console.log(chalk.dim("\n(checking requirements...)"));
+        const results = await checkBinaries(gen.check);
+        const missing = results.filter((r) => !r.ok);
+
+        if (missing.length > 0) {
+          console.log(chalk.red.bold("\nMissing required tools:"));
+          missing.forEach((m) => console.log(chalk.red(` - ${m.bin}`)));
+          console.log(
+            chalk.yellow("You may not be able to build or run this project.\n")
+          );
+
+          const { proceed } = await prompt([
+            {
+              type: "confirm",
+              name: "proceed",
+              message: "Continue anyway?",
+              default: false,
+            },
+          ]);
+
+          if (!proceed) {
+            step = "framework";
+            continue;
+          }
+        }
+      }
+
       step = "pm";
       continue;
     }
@@ -528,6 +755,10 @@ async function main(options = {}) {
 
       const v = String(projectName || "").trim();
       if (v.toLowerCase() === "back") {
+        if (state.template) {
+          console.log("Operation cancelled.");
+          process.exit(0);
+        }
         step =
           state.language === "JavaScript" || state.language === "TypeScript"
             ? "pm"
@@ -541,13 +772,173 @@ async function main(options = {}) {
     }
 
     if (step === "confirm") {
+      const projectRoot = path.resolve(process.cwd(), state.name);
+      const targetExists = fs.existsSync(projectRoot);
+
+      if (state.template) {
+        if (targetExists && !args.dryRun) {
+          console.error(
+            `\nError: Target folder already exists: ${projectRoot}`
+          );
+          state.name = undefined;
+          step = "name";
+          continue;
+        }
+
+        console.log("\nProject Configuration:");
+        console.log(`  Template: ${state.template}`);
+        console.log(`  Folder:   ${state.name}`);
+        console.log("");
+
+        if (!args.yes) {
+          const { action } = await prompt([
+            {
+              type: "list",
+              name: "action",
+              message: "Clone this template?",
+              choices: [
+                { name: "Clone template", value: "create" },
+                { name: "Cancel", value: "cancel" },
+              ],
+            },
+          ]);
+          if (action === "cancel") {
+            console.log("Aborted.");
+            return;
+          }
+        }
+
+        if (args.dryRun) {
+          console.log(
+            `[Dry Run] Would clone ${state.template} to ${projectRoot}`
+          );
+          return;
+        }
+
+        console.log(chalk.dim("\nCloning repository..."));
+        try {
+          await gitClone(state.template, projectRoot);
+          // Remove .git to make it a fresh project
+          removeGitFolder(projectRoot);
+
+          // Optional extras after cloning
+          const detectedTemplate = detectLanguage(projectRoot);
+          const pmTemplate = detectPackageManager(projectRoot);
+
+          let langArg = detectedTemplate;
+          if (detectedTemplate === "JavaScript/TypeScript")
+            langArg = "JavaScript";
+          if (detectedTemplate === "Java/Kotlin") langArg = "Java";
+
+          let wantCi = Boolean(args.ci);
+          let wantDocker = Boolean(args.docker);
+          let wantDevContainer = Boolean(args.devcontainer);
+          let wantLicense =
+            typeof args.license === "boolean"
+              ? args.license
+              : defaultLicenseType !== null;
+
+          if (!args.yes) {
+            const licenseLabel =
+              defaultLicenseType !== null
+                ? `LICENSE (${defaultLicenseType})`
+                : "LICENSE (skip)";
+
+            const { extras } = await prompt([
+              {
+                type: "checkbox",
+                name: "extras",
+                message: "Extras to apply after clone:",
+                choices: [
+                  { name: "GitHub Actions CI", value: "ci", checked: wantCi },
+                  {
+                    name: "Dockerfile",
+                    value: "docker",
+                    checked: wantDocker,
+                  },
+                  {
+                    name: "Dev Container (VS Code)",
+                    value: "devcontainer",
+                    checked: wantDevContainer,
+                  },
+                  {
+                    name: licenseLabel,
+                    value: "license",
+                    checked: wantLicense,
+                    disabled:
+                      defaultLicenseType === null
+                        ? "Configure a default license in 'projectcli config'"
+                        : false,
+                  },
+                ],
+              },
+            ]);
+            if (extras) {
+              wantCi = extras.includes("ci");
+              wantDocker = extras.includes("docker");
+              wantDevContainer = extras.includes("devcontainer");
+              wantLicense = extras.includes("license");
+            }
+          }
+
+          const extraSteps = [];
+          if (wantCi)
+            extraSteps.push(...generateCI(projectRoot, langArg, pmTemplate));
+          if (wantDocker)
+            extraSteps.push(...generateDocker(projectRoot, langArg));
+          if (wantDevContainer) {
+            extraSteps.push(...generateDevContainer(projectRoot, langArg));
+          }
+          if (wantLicense && defaultLicenseType !== null) {
+            extraSteps.push(
+              ...generateLicense(projectRoot, defaultLicenseType, defaultAuthor)
+            );
+          }
+
+          if (wantLicense && defaultLicenseType === null) {
+            console.log(
+              chalk.dim(
+                "Skipping LICENSE (no default license configured; run 'projectcli config')."
+              )
+            );
+          }
+
+          if (extraSteps.length > 0) {
+            const { kept, skipped } = filterExistingWriteFiles(
+              extraSteps,
+              projectRoot
+            );
+            if (kept.length > 0) {
+              console.log(chalk.dim("\nApplying extras..."));
+              await runSteps(kept, { projectRoot });
+            }
+            if (skipped.length > 0) {
+              console.log(
+                chalk.dim(`Skipped existing files: ${skipped.join(", ")}`)
+              );
+            }
+          }
+
+          console.log(
+            chalk.green(`\nSuccess! Created project at ${projectRoot}`)
+          );
+          console.log(
+            chalk.dim(
+              "You may need to run 'npm install' or similar inside the folder."
+            )
+          );
+        } catch (err) {
+          console.error(chalk.red("\nFailed to clone template:"), err.message);
+          process.exit(1);
+        }
+        return;
+      }
+
       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;
@@ -712,10 +1103,15 @@ async function main(options = {}) {
         }
       }
 
-      // CI/CD & Docker
+      // CI/CD & Docker & DevContainer
       if (!args.dryRun) {
         let wantCi = args.ci;
         let wantDocker = args.docker;
+        let wantDevContainer = Boolean(args.devcontainer);
+        let wantLicense =
+          typeof args.license === "boolean"
+            ? args.license
+            : defaultLicenseType !== null;
 
         if (!args.yes) {
           const { extras } = await prompt([
@@ -726,12 +1122,31 @@ async function main(options = {}) {
               choices: [
                 { name: "GitHub Actions CI", value: "ci", checked: wantCi },
                 { name: "Dockerfile", value: "docker", checked: wantDocker },
+                {
+                  name: "Dev Container (VS Code)",
+                  value: "devcontainer",
+                  checked: wantDevContainer,
+                },
+                {
+                  name:
+                    defaultLicenseType !== null
+                      ? `LICENSE (${defaultLicenseType})`
+                      : "LICENSE (skip)",
+                  value: "license",
+                  checked: wantLicense,
+                  disabled:
+                    defaultLicenseType === null
+                      ? "Configure a default license in 'projectcli config'"
+                      : false,
+                },
               ],
             },
           ]);
           if (extras) {
             wantCi = extras.includes("ci");
             wantDocker = extras.includes("docker");
+            wantDevContainer = extras.includes("devcontainer");
+            wantLicense = extras.includes("license");
           }
         }
 
@@ -742,10 +1157,28 @@ async function main(options = {}) {
         if (wantDocker) {
           extraSteps.push(...generateDocker(projectRoot, state.language));
         }
+        if (wantDevContainer) {
+          extraSteps.push(...generateDevContainer(projectRoot, state.language));
+        }
+        if (wantLicense && defaultLicenseType !== null) {
+          extraSteps.push(
+            ...generateLicense(projectRoot, defaultLicenseType, defaultAuthor)
+          );
+        }
 
-        if (extraSteps.length > 0) {
+        const { kept, skipped } = filterExistingWriteFiles(
+          extraSteps,
+          projectRoot
+        );
+
+        if (kept.length > 0) {
           console.log("Adding extras...");
-          await runSteps(extraSteps, { projectRoot });
+          await runSteps(kept, { projectRoot });
+        }
+        if (skipped.length > 0) {
+          console.log(
+            chalk.dim(`Skipped existing files: ${skipped.join(", ")}`)
+          );
         }
       }
 

package/src/license.js

@@ -0,0 +1,80 @@
+const licenses = {
+  MIT: (year, author) => `MIT License
+
+Copyright (c) ${year} ${author}
+
+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.
+`,
+  Apache2: (year, author) => `                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright ${year} ${author}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+`,
+  ISC: (year, author) => `ISC License
+
+Copyright (c) ${year}, ${author}
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+`,
+};
+
+function getLicense(type, author) {
+  const year = new Date().getFullYear();
+  const template = licenses[type] || licenses.MIT;
+  return template(year, author || "The Authors");
+}
+
+function generateLicense(projectRoot, type, author) {
+  return [
+    {
+      type: "writeFile",
+      path: "LICENSE",
+      content: getLicense(type, author),
+    },
+  ];
+}
+
+module.exports = {
+  getLicense,
+  generateLicense,
+  licenseTypes: ["MIT", "Apache2", "ISC"],
+};

package/src/preflight.js

@@ -0,0 +1,25 @@
+const { spawn } = require("node:child_process");
+
+function checkBinary(binary, args = ["--version"]) {
+  return new Promise((resolve) => {
+    const child = spawn(binary, args, {
+      stdio: "ignore",
+      shell: false,
+    });
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+  });
+}
+
+function checkBinaries(binaries) {
+  if (!binaries || binaries.length === 0) return [];
+  const checks = binaries.map((bin) =>
+    checkBinary(bin).then((ok) => ({ bin, ok }))
+  );
+  return Promise.all(checks);
+}
+
+module.exports = {
+  checkBinary,
+  checkBinaries,
+};

package/src/registry.js

@@ -33,6 +33,7 @@ const REGISTRY = {
     "Vite (Vanilla)": {
       id: "js.vite.vanilla",
       label: "Vite (Vanilla)",
+      check: ["npm"],
       commands: (ctx) => {
         const projectName = getProjectName(ctx);
         const pm = getPackageManager(ctx);
@@ -409,6 +410,7 @@ const REGISTRY = {
     Django: {
       id: "py.django",
       label: "Django",
+      check: ["django-admin"],
       commands: (ctx) => {
         const projectName = getProjectName(ctx);
         return [
@@ -423,6 +425,7 @@ const REGISTRY = {
     Flask: {
       id: "py.flask.basic",
       label: "Flask (basic)",
+      check: ["python3"],
       commands: (_ctx) => [
         { type: "mkdir", path: "." },
         {
@@ -502,6 +505,7 @@ const REGISTRY = {
     "Cargo (bin)": {
       id: "rs.cargo.bin",
       label: "Cargo (bin)",
+      check: ["cargo"],
       commands: (ctx) => {
         const projectName = getProjectName(ctx);
         return [
@@ -516,6 +520,7 @@ const REGISTRY = {
     "Cargo (lib)": {
       id: "rs.cargo.lib",
       label: "Cargo (lib)",
+      check: ["cargo"],
       commands: (ctx) => {
         const projectName = getProjectName(ctx);
         return [
@@ -558,6 +563,7 @@ const REGISTRY = {
     "Go module (basic)": {
       id: "go.module.basic",
       label: "Go module (basic)",
+      check: ["go"],
       commands: (ctx) => {
         const projectName = getProjectName(ctx);
         return [

package/src/remote.js

@@ -0,0 +1,39 @@
+const { spawn } = require("node:child_process");
+
+function gitClone(url, targetDir) {
+  return new Promise((resolve, reject) => {
+    // git clone --depth 1 url targetDir
+    const child = spawn("git", ["clone", "--depth", "1", url, targetDir], {
+      stdio: "inherit",
+      shell: false,
+    });
+
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Git clone failed with code ${code}`));
+    });
+  });
+}
+
+/**
+ * Removes the .git folder from the target directory so it becomes a fresh project.
+ */
+function removeGitFolder(targetDir) {
+  const fs = require("node:fs");
+  const path = require("node:path");
+  const gitPath = path.join(targetDir, ".git");
+
+  try {
+    if (fs.existsSync(gitPath)) {
+      fs.rmSync(gitPath, { recursive: true, force: true });
+    }
+  } catch (err) {
+    // ignore
+  }
+}
+
+module.exports = {
+  gitClone,
+  removeGitFolder,
+};

package/src/settings.js

@@ -0,0 +1,63 @@
+const chalk = require("chalk");
+const { loadConfig, saveConfig, CONFIG_PATH } = require("./config");
+
+async function runConfig({ prompt }) {
+  const config = loadConfig();
+
+  console.log(chalk.bold.cyan("\nConfiguration Settings"));
+  console.log(chalk.dim(`File: ${CONFIG_PATH}\n`));
+
+  const answers = await prompt([
+    {
+      type: "list",
+      name: "packageManager",
+      message: "Default Package Manager (for JS/TS):",
+      choices: [
+        { name: "None (Always ask)", value: null },
+        inquirerSeparator(),
+        { name: "npm", value: "npm" },
+        { name: "pnpm", value: "pnpm" },
+        { name: "yarn", value: "yarn" },
+        { name: "bun", value: "bun" },
+      ],
+      default: config.packageManager || null,
+    },
+    {
+      type: "input",
+      name: "author",
+      message: "Default Author Name (for LICENSE):",
+      default: config.author || "The Authors",
+      filter: (v) => String(v || "").trim(),
+    },
+    {
+      type: "list",
+      name: "defaultLicense",
+      message: "Default License Type:",
+      choices: [
+        { name: "None", value: null },
+        inquirerSeparator(),
+        { name: "MIT", value: "MIT" },
+        { name: "Apache-2.0", value: "Apache2" },
+        { name: "ISC", value: "ISC" },
+      ],
+      default: config.defaultLicense || "MIT",
+    },
+    {
+      type: "confirm",
+      name: "learningMode",
+      message: "Enable Learning Mode by default?",
+      default: config.learningMode || false,
+    },
+  ]);
+
+  saveConfig(answers);
+  console.log(chalk.green("\n✓ Settings saved!"));
+}
+
+// Helper for pure inquirer usage if needed,
+// though index.js passes the prompt instance.
+function inquirerSeparator() {
+  return { name: "──────────────", disabled: true };
+}
+
+module.exports = { runConfig };