script creator with github companion

Create and modify scripts in ~/.nanobot/workspace/test with strict Git versioning. Each script lives in its own directory with an isolated git repository. Al...

view source

installs

stars

karma

SkillRank score ↗

8.3/ 10

evaluated by implexa, claude-haiku-4-5 · 2026-07-07

script-creator enforces deterministic git-backed workflows for creating and modifying isolated python scripts, requiring explicit user confirmation before each operation and reporting progress at every step.

structure

10.0

trigger phrases

9.0

procedure

9.0

edge cases

6.0

documentation

9.0

strengths

view original SKILL.md from clawhubclick to expand

---
name: script-git-manager
description: >
  Create and modify scripts in ~/.nanobot/workspace/test with strict Git versioning.
  Each script lives in its own directory with an isolated git repository.
  Always confirms creation plan before execution and reports progress at each step.
  Uses ~/.nanobot/workspace/venv for Python environment and package management.
---

# Script Git Manager Skill

This skill enforces a strict, deterministic workflow for creating and modifying scripts,
using Git as the sole state memory.
It is designed to prevent accidental file creation, uncontrolled refactors,
and loss of history.

---

## Scope

- Base directory: `~/.nanobot/workspace/test`
- Python virtual environment: `~/.nanobot/workspace/venv`
- One script = one directory = one git repository
- Git is mandatory and authoritative

---

## Python Environment

All Python-related operations (pip install, script execution) must use the virtual environment:

```bash
# Activate virtual environment
source ~/.nanobot/workspace/venv/bin/activate

# Install packages
pip install <package_name>

# Execute Python scripts
python <script_path>

# Deactivate when done
deactivate
```

**Always activate the venv before any pip or python command.**

---

## Creation Workflow

Use this skill **only when the user explicitly asks to create a new script**.

### Phase 1: Plan Confirmation

Before creating anything, present a detailed creation plan to the user:

```
📋 Script Creation Plan for: <script_name>

Directory: ~/.nanobot/workspace/test/<script_name>
File: <script_name>.<extension>
Language: <language>
Dependencies: <list of required packages, or "None">

Steps to execute:
1. Create directory ~/.nanobot/workspace/test/<script_name>
2. Initialize Git repository
3. Create script file <script_name>.<extension>
4. [If Python with dependencies] Activate venv and install: <packages>
5. Write script content
6. Create initial Git commit

Proceed with this plan? (yes/no)
```

**Wait for explicit user confirmation before proceeding.**

### Phase 2: Step-by-Step Execution

Execute each step sequentially and report progress after each one:

**Step 1: Create directory**
```bash
cd ~/.nanobot/workspace/test
mkdir <script_name>
```
Output: `✓ Created directory: ~/.nanobot/workspace/test/<script_name>`

**Step 2: Initialize Git**
```bash
cd <script_name>
git init
```
Output: `✓ Initialized Git repository`

**Step 3: Create script file**
```bash
touch <script_name>.<extension>
```
Output: `✓ Created file: <script_name>.<extension>`

**Step 4: Install dependencies (if Python with dependencies)**
```bash
source ~/.nanobot/workspace/venv/bin/activate
pip install <package1> <package2> ...
deactivate
```
Output: `✓ Installed Python packages: <package_list>`

**Step 5: Write script content**
```bash
# Write the actual script code to the file
```
Output: `✓ Script content written (<X> lines)`

**Step 6: Create initial commit**
```bash
git add .
git commit -m "Initial commit: <script_name>"
```
Output: `✓ Initial Git commit created`

**Final summary:**
```
✅ Script created successfully!

Location: ~/.nanobot/workspace/test/<script_name>/<script_name>.<extension>
Git status: Clean (1 commit)
[If Python] Virtual environment: ~/.nanobot/workspace/venv
```

---

## Modification Workflow

Use this skill **only when the user asks to modify an existing script**.

### Phase 1: Plan Confirmation

Before modifying, present the modification plan:

```
📝 Script Modification Plan for: <script_name>

Location: ~/.nanobot/workspace/test/<script_name>/<script_file>
Changes requested: <summary of user's request>

Steps to execute:
1. Enter script directory
2. Create checkpoint commit (current state)
3. Apply modifications: <specific changes>
4. [If new Python dependencies] Install via venv: <packages>
5. Commit changes with message: "<description>"

Proceed with this plan? (yes/no)
```

**Wait for explicit user confirmation before proceeding.**

### Phase 2: Step-by-Step Execution

**Step 1: Enter directory**
```bash
cd ~/.nanobot/workspace/test/<script_name>
```
Output: `✓ Entered script directory`

**Step 2: Create checkpoint**
```bash
git add .
git commit -m "Checkpoint before modification"
```
Output: `✓ Checkpoint commit created`

**Step 3: Apply modifications**
```bash
# Modify the script file as requested
```
Output: `✓ Modifications applied to <script_file>`

**Step 4: Install new dependencies (if applicable)**
```bash
source ~/.nanobot/workspace/venv/bin/activate
pip install <new_package>
deactivate
```
Output: `✓ Installed new packages: <package_list>`

**Step 5: Commit changes**
```bash
git add .
git commit -m "<concise description of the change>"
```
Output: `✓ Changes committed: "<commit_message>"`

**Final summary:**
```
✅ Script modified successfully!

Location: ~/.nanobot/workspace/test/<script_name>/<script_file>
Changes: <brief summary>
Git commits: 2 new commits (checkpoint + modification)
```

---

## Hard Constraints (Must Never Be Violated)

- Never create a new script unless explicitly instructed
- Never proceed without user confirmation of the plan
- Never skip progress reporting after each step
- Never create additional files unless explicitly instructed
- Never skip the pre-modification git commit
- Never modify files outside the target script
- Never rewrite git history
- Never use system Python - always use ~/.nanobot/workspace/venv
- Never assume missing intent

---

## Decision Rules

- If the script directory does not exist → creation workflow
- If the script directory exists → modification workflow
- If intent is ambiguous → ask for clarification, do nothing
- If plan is not confirmed → stop and wait for confirmation

---

## Progress Reporting Format

Use these symbols for consistency:

- `📋` Plan presentation
- `✓` Successful step completion
- `✅` Final success summary
- `⚠️` Warning or clarification needed
- `❌` Error or failure

Each step output should be concise (1-2 lines) but informative.

---

## Philosophy

Git is the memory.  
The filesystem is the contract.  
Confirmation prevents mistakes.  
Transparency builds trust.  
The venv isolates dependencies.

related skills

semantically similar in the cross-vendor index

clawhub

65% match

GitHub Workflow

Professional GitHub workflow skill for AI agents. Covers full project lifecycle: repo setup, Git Flow branching, atomic commits, pull requests, code review,...

don't have the plugin yet? install it then click "run inline in claude" again.

added explicit inputs section with external dependencies (git, venv setup), edge cases (network timeouts, rate limiting, disk space), and detailed decision points; restructured procedure with step-by-step inputs/outputs; added output contract with success criteria; clarified outcome signals with concrete user validation steps.

Script Creator with GitHub Companion

This skill enforces a strict, deterministic workflow for creating and modifying scripts using Git as the sole state memory. It prevents accidental file creation, uncontrolled refactors, and loss of history by requiring explicit user confirmation before any filesystem changes and reporting progress at each step.

Intent

Use this skill when you need to create a new script from scratch or modify an existing script in the ~/.nanobot/workspace/test directory. The skill ensures every script has its own isolated Git repository, deterministic version control, and a reproducible Python environment. creation requires explicit user confirmation of the plan before execution. Modification requires a checkpoint commit to preserve pre-change state. This is your tool for scripting that doesn't lose history.

Inputs

filesystem paths (required):

base workspace: ~/.nanobot/workspace/test (must exist; create if missing)
python venv: ~/.nanobot/workspace/venv (must be pre-initialized with python -m venv ~/.nanobot/workspace/venv)

git (required):

git must be installed and accessible via git --version
user must have configured git config --global user.name and git config --global user.email (skill will fail if missing)

context from user (required):

explicit creation or modification request (ambiguous intent = ask for clarification, do nothing)
script name (alphanumeric + underscore only; no spaces, no special chars)
target language (python, bash, sh, etc.)
list of required packages (if applicable)
modification scope (if modifying: which lines, which functions, which behavior changes)

edge cases to handle:

network timeouts during pip install (retry once, then report failure)
pip rate limiting (if hit, report and suggest manual install later)
disk space exhaustion (check before creating directory)
git author/email not configured (fail with clear setup instructions)
venv corrupted or missing (fail with venv rebuild instructions)
script directory already exists (switch to modification workflow, do not overwrite)
empty pip dependency list (skip dependency step entirely)

Procedure

Creation Workflow

Step 1: Validate inputs and present plan

Input: user's explicit request to create script, script name, language, dependencies list

confirm user intent is unambiguous (if not, ask for clarification and halt)
confirm script name contains only alphanumeric chars and underscores
confirm git user.name and user.email are configured (git config --global user.name)
check that ~/.nanobot/workspace/test exists (if not, create it: mkdir -p ~/.nanobot/workspace/test)
check that ~/.nanobot/workspace/venv exists and is valid python venv
check available disk space (if < 100 MB, report and halt)
present detailed creation plan to user in the format below
wait for explicit user confirmation (yes/no) before proceeding to step 2

Output: creation plan displayed, user confirmation captured

📋 Script Creation Plan for: <script_name>

Directory: ~/.nanobot/workspace/test/<script_name>
File: <script_name>.<extension>
Language: <language>
Dependencies: <list of required packages, or "None">

Steps to execute:
1. Create directory ~/.nanobot/workspace/test/<script_name>
2. Initialize Git repository
3. Create script file <script_name>.<extension>
4. [If dependencies] Activate venv and install: <packages>
5. Write script content
6. Create initial Git commit

Proceed with this plan? (yes/no)

Step 2: Create directory

Input: script_name, confirmed user approval

execute: cd ~/.nanobot/workspace/test && mkdir <script_name>
if directory already exists, halt and report conflict (switch to modification workflow instead)
if mkdir fails (permissions, disk full), report error and halt

Output: ✓ Created directory: ~/.nanobot/workspace/test/<script_name>

Step 3: Initialize Git repository

Input: script_name

execute: cd ~/.nanobot/workspace/test/<script_name> && git init
if git init fails (git not installed, permission denied), report error and halt

Output: ✓ Initialized Git repository

Step 4: Create script file

Input: script_name, extension

execute: touch <script_name>.<extension> (from within the script directory)
if touch fails, report error and halt

Output: ✓ Created file: <script_name>.<extension>

Step 5: Install dependencies (if applicable)

Input: dependencies list, venv path

if dependencies list is empty, skip this step and report "No dependencies to install"
if dependencies list is not empty:
- execute: source ~/.nanobot/workspace/venv/bin/activate
- execute: pip install <package1> <package2> ... (each package on command line)
- if pip install times out (> 30 sec), retry once
- if pip install fails on retry, report error, deactivate venv, halt
- if pip rate limit hit (HTTP 429), report warning and continue (user can retry later)
- execute: deactivate

Output: ✓ Installed Python packages: <package_list> or ✓ No dependencies to install

Step 6: Write script content

Input: script_name, extension, user-provided code

write user-provided code to <script_name>.<extension> (in script directory)
if write fails (disk full, permission denied), report error and halt
count lines written

Output: ✓ Script content written (<X> lines)

Step 7: Create initial Git commit

Input: script_name

execute from script directory: git add .
execute: git commit -m "Initial commit: <script_name>"
if git commit fails (author not configured), report error with setup instructions, halt

Output: ✓ Initial Git commit created

Step 8: Report final success

Input: (none, reporting phase)

display final summary

Output:

✅ Script created successfully!

Location: ~/.nanobot/workspace/test/<script_name>/<script_name>.<extension>
Git status: Clean (1 commit)
[If Python] Virtual environment: ~/.nanobot/workspace/venv

Modification Workflow

Step 1: Validate inputs and present plan

Input: user's explicit request to modify script, script name, modification scope

confirm user intent is unambiguous (if not, ask for clarification and halt)
check that script directory exists at ~/.nanobot/workspace/test/<script_name>
if directory does not exist, report error and offer to create it instead
check that git repository exists in script directory (.git/ folder)
if git repo missing, report error and halt (user should not manually delete .git/)
check that script file exists and is readable
present detailed modification plan to user
wait for explicit user confirmation (yes/no) before proceeding to step 2

Output: modification plan displayed, user confirmation captured

📝 Script Modification Plan for: <script_name>

Location: ~/.nanobot/workspace/test/<script_name>/<script_file>
Changes requested: <summary of user's request>

Steps to execute:
1. Enter script directory
2. Create checkpoint commit (current state)
3. Apply modifications: <specific changes>
4. [If new dependencies] Install via venv: <packages>
5. Commit changes with message: "<description>"

Proceed with this plan? (yes/no)

Step 2: Enter directory

Input: script_name

execute: cd ~/.nanobot/workspace/test/<script_name>
if directory not found, report error and halt

Output: ✓ Entered script directory

Step 3: Create checkpoint commit

Input: (none, automatic)

execute: git add .
execute: git commit -m "Checkpoint before modification" (from script directory)
if there are no uncommitted changes, git commit will report "nothing to commit" and exit with code 1; treat this as success (nothing changed since last commit)
if git commit fails for other reasons (author not configured, etc.), report error and halt

Output: ✓ Checkpoint commit created (or ✓ No changes to checkpoint (already committed))

Step 4: Apply modifications

Input: script_name, extension, modification scope, user-provided code/changes

read current file content
apply modifications as specified by user (replace lines, add functions, refactor, etc.)
write modified content to script file
if write fails (disk full, permission denied), report error and halt
report what was changed

Output: ✓ Modifications applied to <script_file>

Step 5: Install new dependencies (if applicable)

Input: new dependencies list (if any)

if no new dependencies, skip this step
if new dependencies provided:
- execute: source ~/.nanobot/workspace/venv/bin/activate
- execute: pip install <new_package1> <new_package2> ...
- if pip install times out, retry once
- if pip install fails on retry, report error, deactivate venv, halt
- execute: deactivate

Output: ✓ Installed new packages: <package_list> or ✓ No new dependencies to install

Step 6: Commit changes

Input: modification scope, change summary

execute from script directory: git add .
execute: git commit -m "<concise description of the change>" (e.g., "Add error handling to main loop")
if git commit fails (author not configured), report error and halt

Output: ✓ Changes committed: "<commit_message>"

Step 7: Report final success

Input: (none, reporting phase)

display final summary

Output:

✅ Script modified successfully!

Location: ~/.nanobot/workspace/test/<script_name>/<script_file>
Changes: <brief summary>
Git commits: 2 new commits (checkpoint + modification)

Decision Points

if script directory does not exist:

offer creation workflow instead
halt modification workflow

if script directory exists but .git/ folder is missing:

report fatal error (user must not delete git history manually)
halt

if user intent is ambiguous (e.g., "make a script" vs. "update the script"):

ask for explicit clarification: "do you want to CREATE a new script or MODIFY an existing one?"
halt until clarified

if user does not confirm the plan:

report "Plan not confirmed. No changes made."
halt and wait for next instruction

if git author/email not configured:

report error with setup instructions: git config --global user.name "Your Name" and git config --global user.email "your@email.com"
halt

if pip install times out or fails:

retry once
if retry fails, report error and halt (do not force proceed)
if pip rate limit hit (HTTP 429), report warning and skip (user can retry later manually)

if disk space < 100 MB:

report warning and halt

if venv does not exist or is corrupted:

report error with rebuild instructions: python -m venv ~/.nanobot/workspace/venv
halt

if script file already exists with same name (during creation):

report conflict and switch to modification workflow instead
halt creation workflow

Output Contract

on successful creation:

script directory created: ~/.nanobot/workspace/test/<script_name>/
script file created: ~/.nanobot/workspace/test/<script_name>/<script_name>.<extension> (readable, contains user-provided code)
git repository initialized: .git/ folder present in script directory
initial git commit created: git log shows exactly 1 commit with message "Initial commit: "
git status clean: git status shows "working tree clean"
(if python with dependencies) all listed packages installed in venv: pip list (after activating venv) shows all packages

on successful modification:

script file updated: <script_name>.<extension> contains new code
git history preserved: git log shows all previous commits plus 2 new commits (checkpoint + modification)
git status clean: git status shows "working tree clean"
(if new dependencies) all new packages installed in venv: pip list (after activating venv) includes new packages

on failure:

no files created or modified
no git commits created
filesystem and git state unchanged from before the skill ran
error message reported to user with actionable next steps

Outcome Signal

user knows creation worked when:

final success summary displays with checkmark: ✅ Script created successfully!
script file exists and contains the code provided
user can navigate to ~/.nanobot/workspace/test/<script_name>/ and see the script file
user can run cd ~/.nanobot/workspace/test/<script_name> && git log and see the initial commit

user knows modification worked when:

final success summary displays with checkmark: ✅ Script modified successfully!
script file contains the updated code
user can run cd ~/.nanobot/workspace/test/<script_name> && git log and see 2 new commits (checkpoint + modification) above the original commits
user can run git diff HEAD~1 HEAD and see the exact changes applied

user knows something failed when:

an error message appears with ❌ symbol
error message includes actionable next steps (e.g., "Configure git author: git config --global user.name...")
no files created or modified (filesystem unchanged)
no commits added to git history

credits: original author cadot-eu (clawhub). enriched for implexa quality standards.