generateproj 1.0.0

package/README.md

@@ -0,0 +1,78 @@
+# Welcome to Progen 👋
+
+[![Version](https://img.shields.io/npm/v/creaprogetto.svg)](https://www.npmjs.com/package/creaprogetto)  
+[![Documentation](https://img.shields.io/badge/documentation-yes-brightgreen.svg)](https://www.npmjs.com/package/creaprogetto)  
+[![License: ISC](https://img.shields.io/badge/License-ISC-yellow.svg)](#)
+
+> **creaprogetto** è uno strumento da riga di comando pensato per semplificare e velocizzare la creazione di progetti software.  
+> Supporta la generazione automatica di strutture base per i linguaggi e ambienti più comuni: **Java**, **Node.js**, **HTML/CSS/JavaScript**, **C++**, **astro**, **python**, **react (react+vite)** e **nextjs base**.
+
+Con un'interfaccia interattiva semplice e intuitiva, `creaprogetto` ti guida nella scelta del tipo di progetto da creare, generando per te una struttura di directory completa e pronta all’uso, comprensiva di file essenziali come `README.md`, `.gitignore`, `main.*` e cartelle organizzate per ogni linguaggio.
+
+---
+
+## 🚀 Installazione
+
+### Installazione Globale
+
+```bash
+npm install -g creaprogetto
+```
+
+### Installazione Locale
+
+```bash
+npm install creaprogetto
+```
+
+---
+
+## 🧪 Utilizzo
+
+### Creazione di un nuovo progetto
+
+```bash
+creaprogetto init <tipo>
+```
+
+Dove `<tipo>` può essere uno dei seguenti:
+
+- `java`
+- `nodejs`
+- `html`
+- `cpp`
+- `astro`
+- `python`
+- `react (react+vite)`
+- `nextjs`
+
+Esempio:
+
+```bash
+creaprogetto init java
+creaprogetto init nodejs
+creaprogetto init html
+creaprogetto init cpp
+creaprogetto init astro
+creaprogetto init python
+creaprogetto init react
+creaprogetto init nextjs
+```
+
+---
+
+## 👤 Autore
+
+**Ciro Andrea Strazzullo**
+
+- GitHub: [@strazzullociroandrea](https://github.com/strazzullociroandrea)
+- LinkedIn: [Ciro Andrea Strazzullo](https://www.linkedin.com/in/ciro-strazzullo-8484a5339)
+
+---
+
+## ⭐️ Supporta il progetto ##
+
+Se questo progetto ti è sembrato utile o vuoi dare delle opinioni non esitare a scrivermi!
+
+---
+

package/cli.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const args = process.argv.slice(2);
+
+/**
+ * Show the version of the application.
+ */
+if (args.includes('--version') || args.includes('-v')) {
+    try {
+        const packageJsonPath = path.join(__dirname, '..', 'package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        console.log(`Version: ${packageJson.version}`);
+    } catch (e) {
+        console.error('Unable to read version from package.json');
+    }
+    process.exit(0);
+}
+
+/**
+ * Show the possibile type of project that you can initialize.
+ */
+if (args.includes('--help') || args.includes('-h')) {
+    try {
+        const projects = ['Java', 'Nodejs', 'HTML', 'C++', 'Astro', 'Python', 'React', 'NextJs'];
+        console.log(`Available projects: ${projects.join(', ')}`);
+        console.log('\nUsage: generateproj <project-type>');
+    } catch (e) {
+        console.error('Unable to display available project types.');
+    }
+    process.exit(0);
+}
+
+/**
+ * Argument check
+ */
+if (args.length === 0) {
+    console.log('Usage: generateproj [nodejs|java|html|cpp|astro|python|react|nextjs]');
+    process.exit(1);
+}
+
+const projectType = args[1].toLowerCase();
+
+switch (projectType) {
+    case 'nodejs':
+        require('./dist/Nodejs/nodejs')();
+        break;
+    case 'java':
+        require('./dist/Java/java')();
+        break;
+    case 'html':
+        require('./dist/HTML/html')();
+        break;
+    case 'cpp':
+    case 'c++':
+    case 'c':
+        require('./dist/Cpp/cpp')();
+        break;
+    case 'astro':
+        require('./dist/Astro/astro')();
+        break;
+    case 'python':
+        require('./dist/Python/python')();
+        break;
+    case 'react':
+        require('./dist/React/react')();
+        break;
+    case 'nextjs':
+        require('./dist/NextJS/next')();
+        break;
+    default:
+        console.log(`Unsupported project type: ${projectType}`);
+        console.log('Run "generateproj --help" to see all options.');
+        process.exit(1);
+}

package/dist/Astro/astro.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+const {execSync} = require('child_process');
+
+/**
+ * Function to create a new Astro project.
+ * @returns {Promise<void>} The result of the project creation.
+ */
+const createAstroProject = async () => {
+    try {
+        execSync('npm create astro@latest', {stdio: 'inherit'});
+    } catch (err) {
+        console.error(`Error: Could not initialize your astro project. ${err.message}`);
+        process.exit(1);
+    }
+}
+
+module.exports = createAstroProject;

package/dist/Cpp/cpp.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const askQuestion = require('../lib/askQuestion');
+const gitIsAvailable = require('../lib/gitIsAvailable');
+
+/**
+ * Function to create a new C++ project.
+ * @returns {Promise<void>} The result of the project creation.
+ */
+const createCppProject = async () => {
+    try {
+        const baseDir = process.cwd();
+        let projectName;
+
+        while (!projectName || projectName.trim() === '') {
+            projectName = await askQuestion("Enter the project name: ");
+
+            if (!projectName.trim()) {
+                console.log("Error: Project name cannot be empty.");
+            }
+        }
+
+        console.log(`Initializing C++ project: ${projectName}...`);
+
+        const projectPath = path.join(baseDir, projectName);
+
+        if (fs.existsSync(projectPath)) {
+            console.error(`Error: The folder '${projectName}' already exists.`);
+            process.exit(1);
+        }
+
+        console.log(`Creating project folder: ${projectPath}`);
+        fs.mkdirSync(projectPath);
+        console.log(`Project folder created: ${projectPath}`);
+
+        console.log("Creating 'main.cpp' file.");
+        fs.writeFileSync(path.join(projectPath, 'main.cpp'), fs.readFileSync(path.join(__dirname, '.', 'templates', 'Main.txt'), 'utf8'));
+        console.log("Created 'main.cpp' file.");
+
+        console.log("Creating 'Makefile' file.");
+        fs.writeFileSync(path.join(projectPath, 'Makefile'), fs.readFileSync(path.join(__dirname, '.', 'templates', 'Makefile.txt'), 'utf8').replace("$projectName", projectName));
+        console.log("Created 'Makefile' file.");
+
+        const useGit =  gitIsAvailable()
+            ? (await askQuestion("Initialize a Git repository? (y/n): ")).toLowerCase() === 'y'
+            : false;
+
+        if (useGit) {
+            console.log("Initializing local Git repository...");
+
+            try {
+                execSync("git init", {cwd: projectPath, stdio: 'ignore'});
+
+                const gitignorePath = path.join(projectPath, '.gitignore');
+                if (!fs.existsSync(gitignorePath))
+                    fs.writeFileSync(gitignorePath, "");
+
+
+                const readmePath = path.join(projectPath, 'README.md');
+                if (!fs.existsSync(readmePath))
+                    fs.writeFileSync(readmePath, "");
+
+                console.log("Local Git repository initialized successfully.");
+            } catch (error) {
+                console.error("Failed to initialize Git repository. Skipping...");
+            }
+        }
+
+        console.log(`C++ project '${projectName}' initialized successfully at ${projectPath}.`);
+
+    } catch (err) {
+        console.error(`Error: Could not initialize your HTML project. ${err.message}`);
+        process.exit(1);
+    }
+}
+
+module.exports = createCppProject;

package/dist/Cpp/templates/Main.txt

@@ -0,0 +1,8 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+    cout << "Hello World!" << endl;
+    return 0;
+}
+

package/dist/Cpp/templates/Makefile.txt

@@ -0,0 +1,5 @@
+all:
+\tg++ -o $projectName main.cpp
+
+clean:
+\trm -f $projectName

package/dist/HTML/html.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const askQuestion = require('../lib/askQuestion');
+const gitIsAvailable = require('../lib/gitIsAvailable');
+
+/**
+ * Function to create a new HTML project.
+ * @returns {Promise<void>} The result of the project creation.
+ */
+const createHtmlProject = async () => {
+    try {
+        const baseDir = process.cwd();
+        let projectName;
+
+        while (!projectName || projectName.trim() === '') {
+            projectName = await askQuestion("Enter the project name: ");
+
+            if (!projectName.trim()) {
+                console.log("Error: Project name cannot be empty.");
+            }
+        }
+
+        console.log(`Initializing HTML project: ${projectName}...`);
+        const projectPath = path.join(baseDir, projectName);
+
+        if (fs.existsSync(projectPath)) {
+            console.error(`Error: The folder '${projectName}' already exists.`);
+            process.exit(1);
+        }
+
+        console.log(`Creating project folder: ${projectPath}`);
+        fs.mkdirSync(projectPath);
+        console.log(`Project folder created: ${projectPath}`);
+
+
+        console.log("Creating 'index.html' file.");
+        fs.writeFileSync(path.join(projectPath, 'index.html'), fs.readFileSync(path.join(__dirname, '.', 'templates', 'index.txt'), 'utf8'));
+        console.log("Created 'index.html' file.");
+
+        console.log("Creating 'style.css' file.");
+        fs.writeFileSync(path.join(projectPath, 'style.css'), `/*  CSS Styles for ${projectName} */`, 'utf8');
+        console.log("Created 'style.css' file.");
+
+        console.log("Creating 'script.js' file.");
+        fs.writeFileSync(path.join(projectPath, 'script.js'), `// JavaScript for ${projectName}\nconsole.log("Hello from ${projectName} script!");`, 'utf8');
+        console.log("Created 'script.js' file.");
+
+        const useGit = gitIsAvailable()
+            ? (await askQuestion("Initialize a Git repository? (y/n): ")).toLowerCase() === 'y'
+            : false;
+
+
+        if (useGit) {
+            console.log("Initializing local Git repository...");
+
+            try {
+                execSync("git init", {cwd: projectPath, stdio: 'ignore'});
+
+                const gitignorePath = path.join(projectPath, '.gitignore');
+                if (!fs.existsSync(gitignorePath))
+                    fs.writeFileSync(gitignorePath, "");
+
+
+                const readmePath = path.join(projectPath, 'README.md');
+                if (!fs.existsSync(readmePath))
+                    fs.writeFileSync(readmePath, "");
+
+                console.log("Local Git repository initialized successfully.");
+            } catch (error) {
+                console.error("Failed to initialize Git repository. Skipping...");
+            }
+        }
+        console.log(`HTML project '${projectName}' initialized successfully at ${projectPath}.`);
+
+    } catch (err) {
+        console.error(`Error: Could not initialize your HTML project. ${err.message}`);
+        process.exit(1);
+    }
+}
+
+module.exports = createHtmlProject;

package/dist/HTML/templates/index.txt

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="it">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Your project</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+    <div id="app">
+        <h1>Hello World!</h1>
+    </div>
+    <script src="script.js"></script>
+</body>
+</html>

package/dist/Java/java.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const askQuestion = require('../lib/askQuestion');
+const gitIsAvailable = require('../lib/gitIsAvailable');
+
+/**
+ * Function to create a new Java project.
+ * @returns {Promise<void>} The result of the project creation.
+ */
+const createJavaProject = async () => {
+    try {
+        const baseDir = process.cwd();
+        let projectName;
+
+        while (!projectName || projectName.trim() === '') {
+            projectName = await askQuestion("Enter the project name: ");
+
+            if (!projectName.trim()) {
+                console.log("Error: Project name cannot be empty.");
+            }
+        }
+
+        console.log(`Initializing Java project: ${projectName}...`);
+
+        const projectPath = path.join(baseDir, projectName);
+
+        if (fs.existsSync(projectPath)) {
+            console.error(`Error: The folder '${projectName}' already exists.`);
+            process.exit(1);
+        }
+
+        console.log(`Creating project folder: ${projectPath}`);
+        fs.mkdirSync(projectPath);
+        console.log(`Project folder created: ${projectPath}`);
+
+
+        console.log("Creating 'src' folder.");
+        fs.mkdirSync(path.join(projectPath, 'src'), {recursive: true});
+        console.log("Created 'src' folder.");
+
+        console.log("Creating 'Main.java' file.");
+        fs.writeFileSync(path.join(projectPath, 'src', 'Main.java'), fs.readFileSync(path.join(__dirname, '.', 'templates', 'Main.txt'), 'utf8'));
+        console.log("Created 'Main.java' file.");
+
+        const useGit = gitIsAvailable()
+            ? (await askQuestion("Initialize a Git repository? (y/n): ")).toLowerCase() === 'y'
+            : false;
+
+        if (useGit) {
+            console.log("Initializing local Git repository...");
+
+            try {
+                execSync("git init", {cwd: projectPath, stdio: 'ignore'});
+
+                const gitignorePath = path.join(projectPath, '.gitignore');
+                if (!fs.existsSync(gitignorePath))
+                    fs.writeFileSync(gitignorePath, "");
+
+
+                const readmePath = path.join(projectPath, 'README.md');
+                if (!fs.existsSync(readmePath))
+                    fs.writeFileSync(readmePath, "");
+
+                console.log("Local Git repository initialized successfully.");
+            } catch (error) {
+                console.error("Failed to initialize Git repository. Skipping...");
+            }
+        }
+
+        console.log(`Java project '${projectName}' initialized successfully at ${projectPath}.`);
+
+
+    } catch (err) {
+        console.error(`Error: Could not initialize your Java project. ${err.message}`);
+        process.exit(1);
+    }
+}

package/dist/Java/templates/Main.txt

@@ -0,0 +1,5 @@
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+    }
+}

package/dist/NextJs/next.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const askQuestion = require('../lib/askQuestion');
+const gitIsAvailable = require('../lib/gitIsAvailable');
+const {execSync} = require('child_process');
+
+/**
+ * Function to create a new NextJs project.
+ * @returns {Promise<void>} The result of the project creation.
+ */
+const createHtmlProject = async () => {
+    try {
+
+        try {
+            execSync("npx -v", {stdio: 'ignore'});
+        } catch {
+            execSync("npx install -g npx", {stdio: 'ignore'});
+            try {
+                execSync("npx -v", {stdio: 'ignore'});
+            } catch (e) {
+                console.log("npx: package not found")
+            }
+        }
+
+        console.log("Initializing NextJs project...");
+        execSync('npx create-next-app@latest --src-dir', {stdio: 'inherit'});
+        console.log("NextJs project initialized successfully.");
+
+    } catch (err) {
+        console.error(`Error: Could not initialize your NextJs project. ${err.message}`);
+        process.exit(1);
+    }
+}
+
+module.exports = createHtmlProject;

package/dist/Nodejs/nodejs.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const askQuestion = require('../lib/askQuestion');
+const gitIsAvailable = require('../lib/gitIsAvailable');
+const {execSync} = require('child_process');
+
+/**
+ * Function to create a new C++ project.
+ * @returns {Promise<void>} The result of the project creation.
+ */
+const createNodejsProject = async () => {
+    try {
+        const baseDir = process.cwd();
+        let projectName;
+
+        while (!projectName || projectName.trim() === '') {
+            projectName = await askQuestion("Enter the project name: ");
+
+            if (!projectName.trim()) {
+                console.log("Error: Project name cannot be empty.");
+            }
+        }
+
+        console.log(`Initializing Nodejs project: ${projectName}...`);
+
+        let type = '';
+        while (type !== 'module' && type !== 'commonjs') {
+            type = (await askQuestion("Select module type (module/commonjs): ")).toLowerCase();
+
+            if (type !== 'module' && type !== 'commonjs') {
+                console.log("Error: Please enter 'module' or 'commonjs'.");
+            }
+        }
+
+        const projectPath = path.join(baseDir, projectName);
+
+        if (fs.existsSync(projectPath)) {
+            console.error(`Error: The folder '${projectName}' already exists.`);
+            process.exit(1);
+        }
+
+        console.log(`Creating project folder: ${projectPath}`);
+        fs.mkdirSync(projectPath);
+        console.log(`Project folder created: ${projectPath}`);
+
+        console.log("Initializing nodejs project...");
+        execSync(`npm init -y`, {cwd: projectPath, stdio: 'ignore'});
+
+        console.log("Installing minimal dependencies...");
+        execSync(`npm install dotenv express path body-parser`, {cwd: projectPath, stdio: 'ignore'});
+
+        if (type == 'module') {
+            execSync(`npm install url`, {cwd: projectPath, stdio: 'ignore'});
+            const packageJsonPath = path.join(projectPath, 'package.json');
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            packageJson.type = "module";
+            fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        }
+
+        console.log("All minimal dependencies installed.");
+
+        console.log("Creating 'index.js' file.");
+        fs.writeFileSync(path.join(projectPath, 'index.js'), fs.readFileSync(path.join(__dirname, '.', 'templates', type == "module" ? "serverImport.txt" : "serverRequire.txt"), 'utf8'));
+        console.log("Created 'index.js' file.");
+
+        console.log("Creating 'public' folder.");
+        fs.mkdirSync(path.join(projectPath, 'public'));
+        console.log("Created 'public' folder.");
+
+        console.log("Creating 'html-public' file.");
+        fs.writeFileSync(path.join(path.join(projectPath, 'public'), 'index.html'), fs.readFileSync(path.join(__dirname, '.', 'templates', 'html-base.txt'), 'utf8'));
+        console.log("Created 'index.html' file.");
+
+        console.log("Creating '.env' file.");
+        fs.writeFileSync(path.join(projectPath, '.env'), fs.readFileSync(path.join(__dirname, '.', 'templates', '.env.txt'), 'utf8'));
+        console.log("Created '.env' file.");
+
+        const useGit = gitIsAvailable()
+            ? (await askQuestion("Initialize a Git repository? (y/n): ")).toLowerCase() === 'y'
+            : false;
+
+        if (useGit) {
+            console.log("Initializing local Git repository...");
+
+            try {
+                execSync("git init", {cwd: projectPath, stdio: 'ignore'});
+
+                const gitignorePath = path.join(projectPath, '.gitignore');
+                if (!fs.existsSync(gitignorePath))
+                    fs.writeFileSync(gitignorePath, "");
+
+
+                const readmePath = path.join(projectPath, 'README.md');
+                if (!fs.existsSync(readmePath))
+                    fs.writeFileSync(readmePath, "");
+
+                console.log("Local Git repository initialized successfully.");
+            } catch (error) {
+                console.error("Failed to initialize Git repository. Skipping...");
+            }
+        }
+
+        console.log(`Nodejs project '${projectName}' initialized successfully at ${projectPath}.`);
+
+
+    } catch (err) {
+        console.error(`Error: Could not initialize your Nodejs project. ${err.message}`);
+        process.exit(1);
+    }
+}
+
+module.exports = createNodejsProject;

package/dist/Nodejs/templates/.env.txt

@@ -0,0 +1 @@
+PORT=3000

package/dist/Nodejs/templates/html-base.txt

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>Base</title>
+    </head>
+    <body>
+        <h2> Server is running correctly! </h2>
+    </body>
+</html>

package/dist/Nodejs/templates/serverImport.txt

@@ -0,0 +1,34 @@
+require('dotenv').config();
+import express from 'express';
+import http from 'http';
+import path from 'path';
+import bodyParser from 'body-parser';
+import fs from 'fs';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const app = express();
+const server = http.createServer(app);
+
+
+(()=>{
+    try{
+        app.use(bodyParser.json());
+
+        app.use(
+            bodyParser.urlencoded({
+                extended: true,
+            })
+        );
+
+        app.use("/", express.static(path.join(__dirname, "public")));
+
+        server.listen(process.env.PORT, () => {
+            console.log("---> server running on http://localhost:" + process.env.PORT);
+        });
+
+    }catch(error){
+        console.error(error);
+    }
+})();

package/dist/Nodejs/templates/serverRequire.txt

@@ -0,0 +1,29 @@
+require('dotenv').config();
+const express = require('express');
+const http = require('http');
+const path = require('path');
+const bodyParser = require('body-parser');
+const app = express();
+const server = http.createServer(app);
+
+
+(() => {
+    try {
+        app.use(bodyParser.json());
+
+        app.use(
+            bodyParser.urlencoded({
+                extended: true,
+            })
+        );
+
+        app.use("/", express.static(path.join(__dirname, "public")));
+
+        server.listen(process.env.PORT, () => {
+            console.log("---> server running on http://localhost:" + process.env.PORT);
+        });
+
+    } catch (error) {
+        console.error(error);
+    }
+})();

package/dist/Python/python.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const askQuestion = require('../lib/askQuestion');
+const gitIsAvailable = require('../lib/gitIsAvailable');
+
+/**
+ * Function to create a new Python project.
+ * @returns {Promise<void>} The result of the project creation.
+ */
+const createPythonProject = async () => {
+    try {
+        const baseDir = process.cwd();
+        let projectName;
+
+        while (!projectName || projectName.trim() === '') {
+            projectName = await askQuestion("Enter the project name: ");
+
+            if (!projectName.trim()) {
+                console.log("Error: Project name cannot be empty.");
+            }
+        }
+
+        console.log(`Initializing Python project: ${projectName}...`);
+
+        const projectPath = path.join(baseDir, projectName);
+
+        if (fs.existsSync(projectPath)) {
+            console.error(`Error: The folder '${projectName}' already exists.`);
+            process.exit(1);
+        }
+
+        console.log(`Creating project folder: ${projectPath}`);
+        fs.mkdirSync(projectPath);
+        console.log(`Project folder created: ${projectPath}`);
+
+        console.log("Creating 'main.py' file.");
+        fs.writeFileSync(path.join(projectPath, 'main.py'), fs.readFileSync(path.join(__dirname, '.', 'templates', 'Main.txt'), 'utf8'));
+        console.log("Created 'main.py' file.");
+
+        console.log("Creating 'requirements.txt' file.");
+        fs.writeFileSync(path.join(projectPath, 'requirements.txt'), '');
+        console.log("Created 'requirements.txt' file.");
+
+        const useGit = gitIsAvailable()
+            ? (await askQuestion("Initialize a Git repository? (y/n): ")).toLowerCase() === 'y'
+            : false;
+
+        if (useGit) {
+            console.log("Initializing local Git repository...");
+
+            try {
+                execSync("git init", {cwd: projectPath, stdio: 'ignore'});
+
+                const gitignorePath = path.join(projectPath, '.gitignore');
+                if (!fs.existsSync(gitignorePath))
+                    fs.writeFileSync(gitignorePath, "");
+
+
+                const readmePath = path.join(projectPath, 'README.md');
+                if (!fs.existsSync(readmePath))
+                    fs.writeFileSync(readmePath, "");
+
+                console.log("Local Git repository initialized successfully.");
+            } catch (error) {
+                console.error("Failed to initialize Git repository. Skipping...");
+            }
+        }
+
+        console.log(`Python project '${projectName}' initialized successfully at ${projectPath}.`);
+    } catch (err) {
+        console.error(`Error: Could not initialize your Python project. ${err.message}`);
+        process.exit(1);
+    }
+}
+
+module.exports = createPythonProject;

package/dist/Python/templates/Main.txt

@@ -0,0 +1,5 @@
+def  greet():
+    print("Hello world")
+
+if __name__ == "__main__":
+    greet()

package/dist/React/react.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+const {execSync} = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const askQuestion = require('../lib/askQuestion');
+const gitIsAvailable = require('../lib/gitIsAvailable');
+
+/**
+ * Function to create a new React + Vite project.
+ * @returns {Promise<void>} The result of the project creation.
+ */
+const createReactViteProject = async () => {
+    try {
+        const baseDir = process.cwd();
+        let projectName;
+
+        while (!projectName || projectName.trim() === '') {
+            projectName = await askQuestion("Enter the project name: ");
+
+            if (!projectName.trim()) {
+                console.log("Error: Project name cannot be empty.");
+            }
+        }
+
+
+        execSync(`npm create vite@latest ${projectName} -- --template react`, {stdio: 'inherit'});
+        const useGit = gitIsAvailable()
+            ? (await askQuestion("Initialize a Git repository? (y/n): ")).toLowerCase() === 'y'
+            : false;
+
+        if (useGit) {
+            console.log("Initializing local Git repository...");
+            const projectPath = path.join(baseDir, projectName);
+
+            try {
+                execSync("git init", {cwd: projectPath, stdio: 'ignore'});
+
+                const gitignorePath = path.join(projectPath, '.gitignore');
+                if (!fs.existsSync(gitignorePath))
+                    fs.writeFileSync(gitignorePath, "");
+
+
+                const readmePath = path.join(projectPath, 'README.md');
+                if (!fs.existsSync(readmePath))
+                    fs.writeFileSync(readmePath, "");
+
+                console.log("Local Git repository initialized successfully.");
+            } catch (error) {
+                console.error("Failed to initialize Git repository. Skipping...");
+            }
+        }
+    } catch (err) {
+        console.error(`Error: Could not initialize your React + Vite project. ${err.message}`);
+        process.exit(1);
+    }
+}
+
+module.exports = createReactViteProject;

package/dist/utility/askQuestion.js

@@ -0,0 +1,22 @@
+const readline = require('readline');
+
+/**
+ * Function to ask a question to the user via command line.
+ * @param quest {string} The question to ask the user.
+ * @returns {Promise<unknown>} The user's answer.
+ */
+const askQuestion = (quest) => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+
+    return new Promise((resolve) => {
+        rl.question(quest, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+
+module.exports = askQuestion;

package/dist/utility/gitIsAvailable.js

@@ -0,0 +1,16 @@
+const {execSync} = require('child_process');
+
+/**
+ * Is Git available on the system?
+ * @returns {boolean} True if Git is available, false otherwise.
+ */
+
+const gitIsAvailable = async () => {
+    try {
+        execSync("git --version", {stdio: 'ignore'});
+        return true;
+    } catch {
+        return false;
+    }
+}
+module.exports = gitIsAvailable;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "generateproj",
+  "version": "1.0.0",
+  "main": "cli.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Strazzullo Ciro Andrea",
+  "license": "ISC",
+  "description": "A simple CLI tool to create basic and useful projects in various programming languages.",
+  "bin": {
+    "generateproj": "cli.js"
+  },
+  "dependencies": {
+    "child_process": "^1.0.2",
+    "https": "^1.0.0",
+    "path": "^0.12.7",
+    "readline": "^1.3.0",
+    "util": "^0.12.5"
+  },
+  "keywords": [
+    "Create starter projects",
+    "Utils",
+    "Project generator",
+    "Create projects",
+    "Cli",
+    "Starter",
+    "Java",
+    "Nodejs",
+    "HTML",
+    "C++",
+    "Astro",
+    "Python",
+    "React + Vite",
+    "NextJs"
+  ]
+}