@robineb/project-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robineb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# project-cli
+
+[![npm version](https://img.shields.io/npm/v/@robineb/project-cli.svg)](https://www.npmjs.com/package/@robineb/project-cli)
+
+Persönliches CLI-Tool, das neue Projekte anlegt: Grundgerüst erzeugen, Git
+initialisieren, optional ein Remote-Repository auf GitHub oder Gitea
+anlegen und pushen. Läuft unter Windows und macOS.
+
+## Installation
+
+```
+npm i -g @robineb/project-cli
+```
+
+(Package auf [npmjs.com](https://www.npmjs.com/package/@robineb/project-cli),
+anonym installierbar – kein Account/Token nötig. Scoped, weil der
+naheliegende unscoped Name `project-cli` bereits an ein fremdes Paket
+vergeben ist. Der aufgerufene Befehl heißt trotzdem schlicht `project-cli`,
+das bestimmt der `bin`-Eintrag, nicht der Package-Name. Zusätzlich als
+`@robin1053/project-cli` auf GitHub Packages veröffentlicht, rein für die
+Sichtbarkeit im Repo; installieren lohnt sich darüber nur, wenn man ohnehin
+schon für GitHub Packages authentifiziert ist.)
+
+## Voraussetzungen
+
+- Node.js 26+ (das Tool nutzt Node's native, Strip-only TypeScript-Ausführung –
+  kein Build-Schritt nötig)
+- Git
+- Für den `esp32`-Stack zusätzlich [PlatformIO Core](https://docs.platformio.org/en/latest/core/installation/index.html) (`pio`)
+
+## Benutzung
+
+```
+node index.ts [name] [--private]
+```
+
+Ohne Argumente führt `node index.ts` interaktiv durch:
+
+1. Projektname
+2. Stack (`next`, `ts-lib`, `esp32`, …)
+3. Remote-Repository: keins / GitHub / Gitea
+4. Grundgerüst wird erzeugt, Git initialisiert und der erste Commit gemacht
+5. Bei Remote-Wahl: Repo wird angelegt und gepusht
+
+`-p, --private` legt ein angelegtes Remote-Repo privat statt öffentlich an.
+
+Bricht ab, wenn der Zielordner bereits existiert.
+
+### Stacks
+
+| Stack | Beschreibung |
+|---|---|
+| `next` | Next.js (TypeScript, App Router) via `create-next-app` |
+| `ts-lib` | Eigenes TypeScript-Package-Template |
+| `esp32` | PlatformIO/ESP32-Projekt (Arduino-Framework) |
+
+Neue Stacks werden einfach als Eintrag in `STACKS` in `index.ts` ergänzt –
+entweder mit `command` (delegiert an einen externen Generator) oder mit
+`template` (kopiert einen Ordner aus `templates/`).
+
+### PlatformIO-Befehle (für `esp32`-Projekte)
+
+Im Projektordner eines gescaffoldeten `esp32`-Projekts ausgeführt:
+
+```
+node <pfad-zu-project-cli>/index.ts build [env]
+node <pfad-zu-project-cli>/index.ts upload [env]
+node <pfad-zu-project-cli>/index.ts add-board
+```
+
+- `build` – Firmware bauen (`pio run`)
+- `upload` – Firmware bauen und aufs Board flashen (`pio run -t upload`)
+- `add-board` – neues ESP32-Board suchen (`pio boards espressif32`) und als
+  `[env:...]`-Sektion zur `platformio.ini` hinzufügen
+
+`env` ist optional – ohne Angabe wird interaktiv aus den in `platformio.ini`
+definierten `[env:...]`-Sektionen ausgewählt.
+
+### Remote-Repos & Zugangsdaten
+
+GitHub- bzw. Gitea-Token werden in dieser Reihenfolge aufgelöst:
+
+1. Umgebungsvariable (`GITHUB_TOKEN` bzw. `GITEA_URL`/`GITEA_TOKEN`)
+2. gespeicherter Wert
+3. interaktive Abfrage (wird danach für nächstes Mal gespeichert)
+
+Tokens landen dabei im OS-eigenen Schlüsselbund über [`@napi-rs/keyring`](https://github.com/napi-rs/keyring-node)
+(Windows Credential Manager, macOS Keychain, Linux Secret Service/libsecret) –
+nicht in einer Klartextdatei. Die Gitea-URL (kein Geheimnis) bleibt plattformgerecht
+in [`conf`](https://github.com/sindresorhus/conf) (`%APPDATA%` unter Windows,
+`~/Library/Application Support` unter macOS, XDG-Pfade unter Linux).
+
+Token-Scopes: Gitea braucht `write:repository`. GitHub braucht „Administration"
+(Schreibrecht) auf einem Fine-grained PAT, oder `repo`/`public_repo` auf
+einem Classic PAT.
+
+## Entwicklung
+
+Typecheck gegen die Root-`tsconfig.json`:
+
+```
+npx tsc --noEmit
+```
+
+Build für die globale Installation (kompiliert nach `dist/` und kopiert
+`templates/` dorthin, siehe `bin` in `package.json`):
+
+```
+npm run build
+npm i -g .
+```
+
+Es gibt noch keine Tests.
+
+### Veröffentlichen
+
+`.github/workflows/publish.yaml` läuft bei jedem GitHub Release (`types:
+[published]`) und veröffentlicht die gebaute Version zweimal parallel:
+
+- als `@robineb/project-cli` auf npmjs.com via **Trusted Publishing** (OIDC) –
+  kein Secret im Repo, npm tauscht den GitHub-Actions-OIDC-Token automatisch
+  gegen einen kurzlebigen Publish-Token. (Klassische Access-Tokens mit
+  direktem Publish-Recht werden von npm ab Januar 2027 abgeschafft –
+  Trusted Publishing ist der empfohlene Ersatz.)
+- als `@robin1053/project-cli` auf GitHub Packages (Auth über das
+  eingebaute `GITHUB_TOKEN`, kein Secret nötig)
+
+Trusted Publishing lässt sich laut npm erst einrichten, wenn das Paket
+mindestens einmal existiert – deshalb einmaliger manueller Bootstrap, danach
+läuft alles Weitere über die CI ohne jedes Secret:
+
+```
+npm run build
+npm login
+npm publish
+npm trust github --allow-publish --file publish.yaml
+```
+
+Ablauf für jede weitere Version: `version` in `package.json` erhöhen,
+committen, Git-Tag + GitHub Release mit dieser Version anlegen – der
+Workflow übernimmt den Rest.
+
+## Lizenz
+
+[MIT](./LICENSE)

package/dist/index.js

@@ -0,0 +1,347 @@
+#!/usr/bin/env node
+import path from "node:path";
+import fs from "node:fs/promises";
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import { execa } from "execa";
+import { simpleGit, CheckRepoActions } from "simple-git";
+import Conf from "conf";
+import { Entry } from "@napi-rs/keyring";
+const STACKS = [
+    {
+        id: "next",
+        label: "Next.js (TypeScript, App Router)",
+        command: (name) => ({
+            file: "npx",
+            args: ["create-next-app@latest", name, "--ts", "--app", "--yes"],
+        }),
+    },
+    {
+        id: "ts-lib",
+        label: "TypeScript Package (eigenes Template)",
+        template: "ts-lib",
+    },
+    {
+        id: "esp32",
+        label: "PlatformIO / ESP32 (Arduino)",
+        template: "esp32",
+    },
+    // TODO: hier deine weiteren Stacks eintragen (python, ...)
+];
+class GiteaProvider {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    async createRepo(name, isPrivate) {
+        const res = await fetch(`${this.baseUrl}/api/v1/user/repos`, {
+            method: "POST",
+            headers: {
+                Authorization: `token ${this.token}`,
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+            // auto_init: false -> leeres Repo, sonst scheitert der Push
+            body: JSON.stringify({ name, private: isPrivate, auto_init: false }),
+        });
+        if (res.status === 409)
+            throw new Error(`Repo "${name}" existiert bereits.`);
+        if (!res.ok)
+            throw new Error(`Gitea ${res.status}: ${await res.text()}`);
+        const repo = (await res.json());
+        return repo.clone_url;
+    }
+}
+class GitHubProvider {
+    token;
+    constructor(token) {
+        this.token = token;
+    }
+    async createRepo(name, isPrivate) {
+        const res = await fetch("https://api.github.com/user/repos", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                Accept: "application/vnd.github+json",
+                "X-GitHub-Api-Version": "2026-03-10",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ name, private: isPrivate, auto_init: false }),
+        });
+        // GitHub liefert 422 sowohl bei Namenskollision als auch bei Validierungsfehlern
+        if (res.status === 422) {
+            throw new Error(`Repo "${name}" existiert wohl schon.`);
+        }
+        if (!res.ok)
+            throw new Error(`GitHub ${res.status}: ${await res.text()}`);
+        const repo = (await res.json());
+        return repo.clone_url;
+    }
+}
+const config = new Conf({ projectName: "project-cli" });
+const KEYRING_SERVICE = "project-cli";
+function getStoredSecret(account) {
+    return new Entry(KEYRING_SERVICE, account).getPassword() ?? undefined;
+}
+function setStoredSecret(account, value) {
+    new Entry(KEYRING_SERVICE, account).setPassword(value);
+}
+async function ask(message) {
+    const answer = await p.password({ message });
+    if (p.isCancel(answer))
+        throw new Error("Abgebrochen.");
+    return answer;
+}
+async function askText(message) {
+    const answer = await p.text({ message });
+    if (p.isCancel(answer))
+        throw new Error("Abgebrochen.");
+    return answer;
+}
+async function resolveGitHubToken() {
+    const existing = process.env.GITHUB_TOKEN ?? getStoredSecret("github-token");
+    if (existing)
+        return existing;
+    const token = await ask("GitHub Personal Access Token (repo-Scope)");
+    setStoredSecret("github-token", token);
+    return token;
+}
+async function resolveGiteaCredentials() {
+    const existingUrl = process.env.GITEA_URL ?? config.get("giteaUrl");
+    const baseUrl = existingUrl ??
+        (await askText("Gitea-URL (z.B. https://gitea.example.com)"));
+    if (!existingUrl)
+        config.set("giteaUrl", baseUrl);
+    const existingToken = process.env.GITEA_TOKEN ?? getStoredSecret("gitea-token");
+    const token = existingToken ?? (await ask("Gitea Access Token (write:repository-Scope)"));
+    if (!existingToken)
+        setStoredSecret("gitea-token", token);
+    return [baseUrl, token];
+}
+// ---------------------------------------------------------------------------
+// 3. Die einzelnen Arbeitsschritte
+// ---------------------------------------------------------------------------
+async function scaffold(stack, targetDir, name) {
+    if (stack.command) {
+        const { file, args } = stack.command(name);
+        // cwd = Elternordner, weil der Generator den Zielordner selbst anlegt
+        await execa(file, args, { cwd: path.dirname(targetDir), stdio: "inherit" });
+        return;
+    }
+    if (stack.template) {
+        const src = path.join(import.meta.dirname, "templates", stack.template);
+        await fs.cp(src, targetDir, { recursive: true });
+        await restoreGitignore(targetDir);
+        await replacePlaceholders(targetDir, { projectName: name });
+        return;
+    }
+    throw new Error(`Stack ${stack.id} hat weder command noch template`);
+}
+// npm streicht jede Datei, die exakt ".gitignore" heißt, aus jedem Package
+// (unabhängig vom Pfad) -> Templates lagern sie ohne Punkt als "gitignore"
+// und wir benennen sie hier, nach dem Kopieren ins neue Projekt, zurück um.
+async function restoreGitignore(targetDir) {
+    const from = path.join(targetDir, "gitignore");
+    const to = path.join(targetDir, ".gitignore");
+    await fs.rename(from, to).catch(() => { });
+}
+async function replacePlaceholders(dir, vars) {
+    const entries = await fs.readdir(dir, {
+        withFileTypes: true,
+        recursive: true,
+    });
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const full = path.join(entry.parentPath, entry.name);
+        let content;
+        try {
+            content = await fs.readFile(full, "utf8");
+        }
+        catch {
+            continue; // Binärdatei o.ä. -> überspringen
+        }
+        let replaced = content;
+        for (const [key, value] of Object.entries(vars)) {
+            replaced = replaced.replaceAll(`{{${key}}}`, value);
+        }
+        if (replaced !== content)
+            await fs.writeFile(full, replaced, "utf8");
+    }
+}
+async function initGit(targetDir) {
+    const git = simpleGit(targetDir);
+    // IS_REPO_ROOT statt Default: Default prüft nur "irgendwo unter einem Repo",
+    // das wäre auch true, wenn targetDir zufällig innerhalb eines fremden
+    // Repos liegt -> init() würde übersprungen und add/commit liefen gegen
+    // das falsche (übergeordnete) Repo. Hier soll nur erkannt werden, ob
+    // targetDir selbst schon ein eigenes .git hat (z.B. von create-next-app).
+    const alreadyRepo = await git
+        .checkIsRepo(CheckRepoActions.IS_REPO_ROOT)
+        .catch(() => false);
+    if (!alreadyRepo)
+        await git.init();
+    await git.add(".");
+    await git.commit("chore: initial scaffold");
+}
+// ---------------------------------------------------------------------------
+// 3b. PlatformIO-Helfer (build/upload/add-board)
+//     Ersatz für das commands.sh-Script aus dem esp32-Template-Vorbild:
+//     dort Bash + fzf, hier execa + @clack/prompts, damit es auch unter
+//     PowerShell/cmd läuft. Arbeiten immer auf der platformio.ini im cwd.
+// ---------------------------------------------------------------------------
+async function readPioEnvironments(cwd) {
+    const iniPath = path.join(cwd, "platformio.ini");
+    let content;
+    try {
+        content = await fs.readFile(iniPath, "utf8");
+    }
+    catch {
+        throw new Error(`Keine platformio.ini in ${cwd} gefunden.`);
+    }
+    return [...content.matchAll(/^\[env:([^\]]+)\]/gm)].map((m) => m[1]);
+}
+async function selectPioEnvironment(cwd, message) {
+    const envs = await readPioEnvironments(cwd);
+    if (envs.length === 0)
+        throw new Error("Keine [env:...]-Sektionen in platformio.ini gefunden.");
+    if (envs.length === 1)
+        return envs[0];
+    const choice = await p.select({
+        message,
+        options: envs.map((e) => ({ value: e, label: e })),
+    });
+    if (p.isCancel(choice))
+        throw new Error("Abgebrochen.");
+    return choice;
+}
+async function searchEsp32Boards(query) {
+    const { stdout } = await execa("pio", [
+        "boards",
+        "espressif32",
+        "--json-output",
+    ]);
+    const boards = JSON.parse(stdout);
+    if (!query.trim())
+        return boards;
+    const q = query.toLowerCase();
+    return boards.filter((b) => `${b.id} ${b.name}`.toLowerCase().includes(q));
+}
+async function addBoard(cwd) {
+    const query = await askText('Board suchen (z.B. "esp32-s3", leer = alle anzeigen)');
+    const boards = await searchEsp32Boards(query);
+    if (boards.length === 0)
+        throw new Error("Keine passenden Boards gefunden.");
+    const boardId = await p.select({
+        message: "Welches Board?",
+        options: boards
+            .slice(0, 50)
+            .map((b) => ({ value: b.id, label: `${b.name} (${b.id})` })),
+    });
+    if (p.isCancel(boardId))
+        throw new Error("Abgebrochen.");
+    const envName = await askText('Name der neuen Environment (z.B. "my-esp32-s3")');
+    const section = `\n[env:${envName}]\nplatform = espressif32\nboard = ${boardId}\n`;
+    await fs.appendFile(path.join(cwd, "platformio.ini"), section, "utf8");
+}
+// ---------------------------------------------------------------------------
+// 4. Der eigentliche Ablauf
+// ---------------------------------------------------------------------------
+async function run(nameArg, opts) {
+    p.intro("Projekt-Setup");
+    const name = nameArg ??
+        (await p.text({
+            message: "Wie soll das Projekt heißen?",
+            validate: (v) => (v?.trim() ? undefined : "Name darf nicht leer sein"),
+        }));
+    if (p.isCancel(name))
+        return p.cancel("Abgebrochen.");
+    const stackId = await p.select({
+        message: "Welcher Stack?",
+        options: STACKS.map((s) => ({ value: s.id, label: s.label })),
+    });
+    if (p.isCancel(stackId))
+        return p.cancel("Abgebrochen.");
+    const remoteChoice = await p.select({
+        message: "Remote-Repository anlegen?",
+        options: [
+            { value: "none", label: "Nein, nur lokal" },
+            { value: "github", label: "GitHub" },
+            { value: "gitea", label: "Gitea" },
+        ],
+    });
+    if (p.isCancel(remoteChoice))
+        return p.cancel("Abgebrochen.");
+    const stack = STACKS.find((s) => s.id === stackId);
+    const targetDir = path.resolve(process.cwd(), name);
+    // Nicht in einen vorhandenen Ordner schreiben
+    const exists = await fs.stat(targetDir).then(() => true, () => false);
+    if (exists) {
+        p.cancel(`Ordner "${name}" existiert bereits.`);
+        return;
+    }
+    const s = p.spinner();
+    s.start("Grundgerüst wird angelegt");
+    await scaffold(stack, targetDir, name);
+    s.stop("Grundgerüst steht");
+    s.start("Git wird initialisiert");
+    await initGit(targetDir);
+    s.stop("Erster Commit ist da");
+    if (remoteChoice !== "none") {
+        // Zugangsdaten zuerst einsammeln (interaktiv, falls nötig) — danach erst
+        // den Spinner starten, sonst überlagern sich Prompt und Spinner.
+        const provider = remoteChoice === "gitea"
+            ? new GiteaProvider(...(await resolveGiteaCredentials()))
+            : new GitHubProvider(await resolveGitHubToken());
+        s.start("Remote wird angelegt");
+        const cloneUrl = await provider.createRepo(name, opts.private ?? false);
+        const git = simpleGit(targetDir);
+        await git.addRemote("origin", cloneUrl);
+        await git.push(["-u", "origin", "HEAD"]);
+        s.stop(`Gepusht nach ${cloneUrl}`);
+    }
+    p.outro(`Fertig. cd ${name}`);
+}
+// ---------------------------------------------------------------------------
+// 5. Einstiegspunkt
+// ---------------------------------------------------------------------------
+const program = new Command();
+program
+    .name("myinit")
+    .description("Legt neue Projekte inkl. Repo an")
+    .argument("[name]", "Projektname")
+    .option("-p, --private", "Remote-Repo privat anlegen")
+    .action(run);
+// Die folgenden Befehle arbeiten auf einem bestehenden PlatformIO-Projekt
+// im aktuellen Arbeitsverzeichnis (nicht auf dem Scaffold-Flow oben).
+program
+    .command("build [env]")
+    .description("PlatformIO-Firmware bauen (pio run)")
+    .action(async (env) => {
+    const cwd = process.cwd();
+    const selected = env ?? (await selectPioEnvironment(cwd, "Welche Environment bauen?"));
+    await execa("pio", ["run", "-e", selected], { cwd, stdio: "inherit" });
+});
+program
+    .command("upload [env]")
+    .description("Firmware bauen und aufs Board flashen (pio run -t upload)")
+    .action(async (env) => {
+    const cwd = process.cwd();
+    const selected = env ?? (await selectPioEnvironment(cwd, "Welche Environment flashen?"));
+    await execa("pio", ["run", "-e", selected, "-t", "upload"], {
+        cwd,
+        stdio: "inherit",
+    });
+});
+program
+    .command("add-board")
+    .description("Neues ESP32-Board zur platformio.ini hinzufügen")
+    .action(async () => {
+    await addBoard(process.cwd());
+});
+program.parseAsync().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/templates/esp32/.gitattributes

@@ -0,0 +1 @@
+* text=auto

package/dist/templates/esp32/.github/workflows/build.yml

@@ -0,0 +1,31 @@
+name: PlatformIO CI
+
+on:
+  push:
+    paths:
+      - 'include/**'
+      - 'src/**'
+      - 'lib/**'
+      - 'test/**'
+      - 'platformio.ini'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.platformio/.cache
+          key: ${{ runner.os }}-pio
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.9'
+      - name: Install PlatformIO Core
+        run: pip install --upgrade platformio
+
+      - name: Build PlatformIO Project
+        run: pio run

package/dist/templates/esp32/README.md

@@ -0,0 +1,30 @@
+# {{projectName}}
+
+PlatformIO-Projekt für ESP32 (Arduino-Framework).
+
+## Setup
+
+1. [PlatformIO Core](https://docs.platformio.org/en/latest/core/installation/index.html) installieren.
+2. Board per USB anschließen.
+
+## Bauen & Flashen
+
+Über project-cli (im Projektordner ausgeführt):
+
+    node <pfad-zu-project-cli>/index.ts build [env]
+    node <pfad-zu-project-cli>/index.ts upload [env]
+    node <pfad-zu-project-cli>/index.ts add-board
+
+`env` ist optional — ohne Angabe wird interaktiv aus den in `platformio.ini`
+definierten `[env:...]`-Sektionen ausgewählt.
+
+Oder direkt über PlatformIO:
+
+    pio run -e esp32dev
+    pio run -e esp32dev -t upload
+    pio device monitor
+
+## Boards
+
+Vordefiniert: `esp32dev`, `featheresp32`, `adafruit_feather_esp32s2`.
+Weitere über `add-board` oder manuell in `platformio.ini` ergänzen.

package/dist/templates/esp32/gitignore

@@ -0,0 +1,37 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+.pio
+.cache
+
+compile_commands.json

package/dist/templates/esp32/include/README

@@ -0,0 +1,39 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the usual convention is to give header files names that end with `.h'.
+It is most portable to use only letters, digits, dashes, and underscores in
+header file names, and at most one dot.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

package/dist/templates/esp32/lib/README

@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into executable file.
+
+The source code of each library should be placed in an own separate directory
+("lib/your_library_name/[here are source files]").
+
+For example, see a structure of the following two libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+and a contents of `src/main.c`:
+```
+#include <Foo.h>
+#include <Bar.h>
+
+int main (void)
+{
+  ...
+}
+
+```
+
+PlatformIO Library Dependency Finder will find automatically dependent
+libraries scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html

package/dist/templates/esp32/platformio.ini

@@ -0,0 +1,39 @@
+; PlatformIO-Konfiguration für {{projectName}}
+;
+; Nur ESP32-Boards. Weitere Boards über `add-board` (project-cli) oder
+; manuell per `pio boards espressif32` suchen und [env:...]-Sektion ergänzen.
+
+[platformio]
+description = {{projectName}}
+default_envs = esp32dev
+
+[env]
+framework = arduino
+
+; C++17 statt PlatformIO-Default gnu++11
+build_unflags = -std=gnu++11
+build_flags = -std=gnu++17 -Wno-unused-variable -Wno-unused-but-set-variable -Wno-unused-function -Wno-format-extra-args
+
+; clang-tidy für `pio check`
+check_tool = clangtidy
+
+; Serial-Monitor-Baudrate, muss zu Serial.begin() im Code passen
+monitor_speed = 115200
+
+lib_deps =
+  # Zum Einkommentieren, Beispiele:
+  # dxinteractive/ResponsiveAnalogRead   ; glättet Analogwerte (Poti, Sensoren)
+  # thomasfredericks/Bounce2             ; Taster entprellen
+  # arkhipenko/TaskScheduler             ; kooperatives Task-Scheduling
+
+[env:esp32dev]
+platform = espressif32
+board = esp32dev
+
+[env:featheresp32]
+platform = espressif32
+board = featheresp32
+
+[env:adafruit_feather_esp32s2]
+platform = espressif32
+board = adafruit_feather_esp32s2

package/dist/templates/esp32/src/main.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+
+// {{projectName}}
+
+void setup() {
+  Serial.begin(115200);
+}
+
+void loop() {
+}

package/dist/templates/esp32/test/README

@@ -0,0 +1,11 @@
+
+This directory is intended for PlatformIO Test Runner and project tests.
+
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.
+
+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html

package/dist/templates/ts-lib/README.md

@@ -0,0 +1,6 @@
+# {{projectName}}
+
+## Entwicklung
+
+    npm install
+    npm run dev

package/dist/templates/ts-lib/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "{{projectName}}",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "node --watch src/index.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "typescript": "^5.7.0"
+  }
+}

package/dist/templates/ts-lib/src/index.ts

@@ -0,0 +1 @@
+console.log("{{projectName}} läuft");

package/dist/templates/ts-lib/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "types": ["node"],
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@robineb/project-cli",
+  "version": "1.0.0",
+  "description": "My own Project cli tool to start projecs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Robin1053/Project-CLI.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc && node scripts/copy-templates.mjs",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "bin": {
+    "project-cli": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "@napi-rs/keyring": "^2.1.0",
+    "commander": "^15.0.0",
+    "conf": "^15.1.0",
+    "execa": "^10.0.1",
+    "simple-git": "^3.36.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.0",
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2"
+  },
+  "allowScripts": {
+    "esbuild@0.28.2": true
+  }
+}