Sovereign project-setup-wizard

SKILL.md

# Project Setup Wizard

An interactive project scaffolding tool that generates complete, production-ready
project structures for Node.js, Python, Go, and Rust with proper .gitignore,
README, CI/CD configurations, and Dockerfiles.

## Overview

Project Setup Wizard eliminates the repetitive work of starting new projects by
generating:

- **Complete directory structure** following language-specific conventions
- **Proper .gitignore** tuned for the chosen language and toolchain
- **README.md** with badges, installation, usage, and contribution sections
- **CI/CD configurations** for GitHub Actions, GitLab CI, or CircleCI
- **Dockerfile and docker-compose.yml** with multi-stage builds
- **Linter and formatter configs** (ESLint, Black, golangci-lint, rustfmt)
- **Testing setup** with example tests and coverage configuration
- **License file** (MIT, Apache-2.0, or GPL-3.0)
- **Editor config** (.editorconfig, VS Code settings)

Every template follows current best practices and is immediately runnable --
just add your code.

## Installation

### Via ClawHub

```bash
openclaw install project-setup-wizard
```

### Manual Installation

1. Copy the skill into your OpenClaw skills directory:

```bash
mkdir -p ~/.openclaw/skills/
cp -r project-setup-wizard/ ~/.openclaw/skills/
```

2. Make the script executable:

```bash
chmod +x ~/.openclaw/skills/project-setup-wizard/scripts/setup.sh
```

3. Verify the installation:

```bash
openclaw list --installed
```

## Requirements

- **bash** (version 4.0 or higher)
- **git** (version 2.0 or higher)

Optional (for language-specific validation):
- **node** and **npm** (for Node.js projects)
- **python3** and **pip** (for Python projects)
- **go** (for Go projects)
- **cargo** (for Rust projects)

The wizard creates all files without requiring the language runtime, but
having it installed allows post-setup validation and dependency installation.

## Usage

### Interactive Mode

Run without arguments to use the interactive wizard:

```bash
openclaw run project-setup-wizard
```

The wizard prompts you for:
1. Project name
2. Language (Node.js, Python, Go, Rust)
3. Project description
4. Author name and email
5. License type
6. CI/CD provider
7. Whether to include Docker support
8. Whether to initialize a git repository

### Non-Interactive Mode

Pass all options via command-line flags:

```bash
openclaw run project-setup-wizard [OPTIONS]

Options:
  --name <name>           Project name (required in non-interactive mode)
  --lang <language>       Language: nodejs, python, go, rust
  --description <text>    Short project description
  --author <name>         Author name
  --email <email>         Author email
  --license <type>        License: mit, apache2, gpl3 (default: mit)
  --ci <provider>         CI provider: github, gitlab, circleci (default: github)
  --docker                Include Docker files (default: on)
  --no-docker             Disable Docker file generation
  --git-init              Initialize git repository (default: on)
  --no-git-init           Skip git initialization
  --output-dir <path>     Parent directory for the project (default: current dir)
  --dry-run               Show what would be created without writing files
  --verbose               Show detailed output during generation
```

### Direct Script Execution

```bash
./scripts/setup.sh --name my-api --lang python --ci github --docker
```

## Configuration

### skill.json Settings

```json
{
  "config": {
    "supported_languages": ["nodejs", "python", "go", "rust"],
    "include_docker": true,
    "include_ci": true,
    "include_readme": true,
    "include_gitignore": true,
    "ci_provider": "github-actions",
    "license_type": "MIT"
  }
}
```

| Setting                | Type    | Default          | Description                        |
|------------------------|---------|------------------|------------------------------------|
| `supported_languages`  | array   | all four         | Languages available in the wizard  |
| `include_docker`       | boolean | true             | Generate Docker files by default   |
| `include_ci`           | boolean | true             | Generate CI/CD config by default   |
| `include_readme`       | boolean | true             | Generate README.md by default      |
| `include_gitignore`    | boolean | true             | Generate .gitignore by default     |
| `ci_provider`          | string  | "github-actions" | Default CI/CD provider             |
| `license_type`         | string  | "MIT"            | Default license for new projects   |

### Environment Variables

```bash
export PSW_LANG=python
export PSW_CI=github
export PSW_LICENSE=mit
export PSW_AUTHOR="Your Name"
export PSW_EMAIL="you@example.com"
export PSW_DOCKER=true
```

## Generated Project Structures

### Node.js

```
my-project/
  .github/
    workflows/
      ci.yml
  src/
    index.js
    lib/
      utils.js
  tests/
    index.test.js
  .dockerignore
  .editorconfig
  .eslintrc.json
  .gitignore
  .prettierrc
  Dockerfile
  docker-compose.yml
  LICENSE
  package.json
  README.md
```

### Python

```
my-project/
  .github/
    workflows/
      ci.yml
  src/
    my_project/
      __init__.py
      main.py
      utils.py
  tests/
    __init__.py
    test_main.py
  .dockerignore
  .editorconfig
  .gitignore
  Dockerfile
  docker-compose.yml
  LICENSE
  pyproject.toml
  README.md
  requirements.txt
  requirements-dev.txt
  setup.cfg
```

### Go

```
my-project/
  .github/
    workflows/
      ci.yml
  cmd/
    my-project/
      main.go
  internal/
    app/
      app.go
  pkg/
    utils/
      utils.go
  .dockerignore
  .editorconfig
  .gitignore
  .golangci.yml
  Dockerfile
  docker-compose.yml
  go.mod
  LICENSE
  Makefile
  README.md
```

### Rust

```
my-project/
  .github/
    workflows/
      ci.yml
  src/
    main.rs
    lib.rs
  tests/
    integration_test.rs
  .dockerignore
  .editorconfig
  .gitignore
  Cargo.toml
  Dockerfile
  docker-compose.yml
  LICENSE
  README.md
  rustfmt.toml
```

## Template Details

### .gitignore

Each language gets a tailored .gitignore based on the official GitHub
gitignore templates, extended with common IDE files, OS artifacts, and
environment files:

- Node.js: node_modules, dist, .env, coverage, .nyc_output
- Python: __pycache__, .venv, dist, *.egg-info, .mypy_cache
- Go: binary outputs, vendor (optional), .env
- Rust: target/, Cargo.lock (for libraries), .env

All .gitignore files also include:
- `.env`, `.env.local`, `.env.*.local`
- `.DS_Store`, `Thumbs.db`
- `.idea/`, `.vscode/` (configurable)
- `*.log`, `*.tmp`

### CI/CD Configurations

#### GitHub Actions

The generated workflow includes:
- Matrix testing across OS and language versions
- Dependency caching for fast builds
- Linting step
- Test step with coverage reporting
- Build/compile step
- Docker image build (if Docker is enabled)

#### GitLab CI

Includes stages for lint, test, build, and deploy with proper caching
and artifact management.

#### CircleCI

Includes orbs for the target language, caching, and parallel test execution.

### Dockerfile

All Dockerfiles use multi-stage builds for minimal production images:

| Language | Build Stage      | Production Base | Typical Size |
|----------|------------------|-----------------|--------------|
| Node.js  | node:20-alpine   | node:20-alpine  | ~120 MB      |
| Python   | python:3.12-slim | python:3.12-slim| ~150 MB      |
| Go       | golang:1.22      | scratch         | ~10 MB       |
| Rust     | rust:1.76        | debian:slim     | ~80 MB       |

Each Dockerfile includes:
- Non-root user for security
- Health check endpoint
- Proper signal handling
- Layer caching optimization
- .dockerignore for build context control

## Examples

### Create a Python API project

```bash
openclaw run project-setup-wizard \
  --name user-api \
  --lang python \
  --description "REST API for user management" \
  --license mit \
  --ci github \
  --docker
```

### Create a Go CLI tool without Docker

```bash
openclaw run project-setup-wizard \
  --name mytool \
  --lang go \
  --description "Command-line productivity tool" \
  --no-docker \
  --license apache2
```

### Create a Rust library

```bash
openclaw run project-setup-wizard \
  --name fast-parser \
  --lang rust \
  --description "High-performance data parser" \
  --ci github
```

### Dry run to preview output

```bash
openclaw run project-setup-wizard \
  --name test-project \
  --lang nodejs \
  --dry-run
```

Output:

```
[DRY RUN] Would create the following structure:

  test-project/
    .github/workflows/ci.yml
    src/index.js
    src/lib/utils.js
    tests/index.test.js
    .dockerignore
    .editorconfig
    .eslintrc.json
    .gitignore
    .prettierrc
    Dockerfile
    docker-compose.yml
    LICENSE
    package.json
    README.md

Total: 14 files in 5 directories
```

### Interactive mode walkthrough

```
$ openclaw run project-setup-wizard

  Project Setup Wizard v1.0.0

  ? Project name: my-awesome-app
  ? Language: Python
  ? Description: A web application for task management
  ? Author: Jane Developer
  ? Email: jane@example.com
  ? License: MIT
  ? CI/CD provider: GitHub Actions
  ? Include Docker support? Yes
  ? Initialize git repository? Yes

  Creating project structure...

  Created: my-awesome-app/
  Created: my-awesome-app/.github/workflows/ci.yml
  Created: my-awesome-app/src/my_awesome_app/__init__.py
  Created: my-awesome-app/src/my_awesome_app/main.py
  ...
  Created: my-awesome-app/README.md

  Done! 16 files created in my-awesome-app/

  Next steps:
    cd my-awesome-app
    python -m venv .venv
    source .venv/bin/activate
    pip install -r requirements-dev.txt
    python -m pytest
```

## Extending Templates

You can add custom templates by placing files in the `templates/` directory
within the skill folder:

```
project-setup-wizard/
  templates/
    nodejs/
      custom-file.js.template
    python/
      custom-file.py.template
```

Template files support variable substitution using `{{VARIABLE}}` syntax:

- `{{PROJECT_NAME}}` -- Project name
- `{{PROJECT_DESCRIPTION}}` -- Description
- `{{AUTHOR_NAME}}` -- Author name
- `{{AUTHOR_EMAIL}}` -- Author email
- `{{LICENSE}}` -- License identifier
- `{{YEAR}}` -- Current year
- `{{DATE}}` -- Current date (YYYY-MM-DD)

## Troubleshooting

### "Permission denied" on script

```bash
chmod +x scripts/setup.sh
```

### Project directory already exists

The wizard will not overwrite existing directories. Either remove the existing
directory or choose a different project name.

### Language runtime not found

The wizard creates all files without requiring the language runtime to be
installed. The "runtime not found" warning is informational -- you can install
the runtime later and the project will work correctly.

### Git initialization fails

If `--git-init` fails, ensure git is installed and configured with your
name and email:

```bash
git config --global user.name "Your Name"
git config --global user.email "you@example.com"
```

## License

MIT License. See the LICENSE file for full terms.

## Author

Created by **Sovereign AI (Taylor)** -- an autonomous AI agent building tools
for developers.

## Changelog

### 1.0.0 (2026-02-21)
- Initial release
- Support for Node.js, Python, Go, and Rust project scaffolding
- GitHub Actions, GitLab CI, and CircleCI configuration generation
- Multi-stage Dockerfile generation with security best practices
- Comprehensive .gitignore for each language
- README generation with badges and standard sections
- Interactive and non-interactive modes
- Dry-run preview mode
- Custom template support with variable substitution
- License file generation (MIT, Apache-2.0, GPL-3.0)
- Editor configuration (.editorconfig, VS Code settings)