skit is a script manager and launcher in your terminal.
skit keeps your scripts in one place and makes them painless to launch — Python, shell, JS/TS, executables, prompts, and more.
It is painless because skit reads each script and turns its CLI flags, input() calls, and hard-coded constants into a launch menu with descriptions — you edit inputs and variables on screen, without ever touching the script.
So you can finally stop worrying about where to store your script and whether you still know how to use it next year — put it in skit and forget about it.
There are exactly two commands to remember:
skit add script.py # put a script in the libraryskit # open the menu — pick, fill in the inputs, run
Not a terminal person? That is fine — skit works like a GUI app that happens to live in your terminal: point, click, and type your way through everything. Hotkeys exist too — hinted right on screen — but there is nothing to learn or memorize.
Your AI agent gets the same library: you use it from a menu, agents use it through a deterministic CLI and a skill, so scripts get saved and reused.
One home for your scripts and prompts.skit add collects scattered scripts and prompts into one searchable library.
No flags to memorize, no opening an editor just to change a value. Flags, input() calls, and the constants you select become typed and described fields in the launch menu. The Ratatui form validates booleans, choices, numbers, and paths when you submit it.
Remembers your last inputs. Input parameters in the launch menu come back prefilled on the next run. Clear an override to use the script's current default. Save favorites as named presets — tokens like {cwd} and {today} keep them portable. Parameters marked secret are never saved: not in last-used values, presets, or run history.
No environment mess. Python scripts declare their dependencies inline (PEP 723) and run via uv in isolated environments; JS/TS scripts get a per-script node_modules, installed from their declared packages on first run. Nothing global either way. Other languages use the tools already on your machine — skit checks that declared external commands are on your PATH before running.
Prompts as scripts. Store a parameterized prompt (managed {{placeholders}} become input fields) and launch it with your coding agent — claude, codex, opencode, or any prompt runner you like.
Mouse or keyboard, in your language. Plain skit opens the full TUI; every key hint on screen is also a clickable button. Ships in English, 繁體中文, and 简体中文 (Languages).
Built for AI agents too. Every TUI action is also a CLI command with --json output and meaningful exit codes, and the official Agent Skill teaches Claude Code, Codex, Cursor, Gemini CLI, and friends to check your library first, run what is there, and save the good ones — see Works with your AI agent.
Problem
What skit does
Scripts scattered all over the place
One central menu, with search
Scripts that need specific packages or tools
Per-script dependencies for Python (PEP 723 + uv) and JS/TS (npm); for any language, skit checks declared external commands on your PATH
CLI flags you do not remember, input() prompts, constants meant to be edited by hand
Static analysis turns them all into an interactive menu — no code changes, no config. Last-used values come prefilled; favorites save as presets.
The weird script an AI wrote for you gets lost with the chat session
Agents check the library first, reuse what is there, and save the keepers — one-off scripts become permanent, parameterized tools
No need to modify your script for skit — we will take care of it, and will ask you interactively when we need to.
No auto-detection for your type? Declare parameters by hand — every type gets the same launch menu / preset / --set experience, even a plain executable (declared values are passed as ordinary command-line arguments). Any entry can also list the external commands it depends on (ffmpeg, jq, …); skit checks they are on your PATH before each run.
Python and JS/TS get isolated per-script package dependencies: uv resolves the PEP 723 block, and npm-style deps install into a node_modules next to the stored copy — installs never run package lifecycle scripts. The finer points (copied vs referenced entries, deno's --allow-all behavior) are in the docs.
skit bootstraps uv for Python, but never a JS runtime — you supply node, bun, or deno.
A prompt entry stores reusable text for an AI coding agent. Add a .prompt.md file, or use
skit add --prompt to create one. skit can make up to 30 detected {{placeholders}} into input
fields. If the source has more than 30 placeholders, skit does not manage any of them by default.
This limit prevents skit from treating code samples as variables. Use Entry settings or
skit params to select the fields that you want to manage. Managed fields support presets,
last-used values, and --set.
skit does not use escape sequences for prompts. It sends all unmanaged text byte-for-byte. This
includes unmanaged {{holes}}. Pi can require one exception. skit warns you and adds one newline
when Pi can parse the opening text as an option, file, or package command. Use --no-interpolate
to turn off all insertion for one prompt.
Select the runner in the launch menu, or pin one runner for the prompt. skit includes claude,
codex, opencode, amp, antigravity, copilot, cursor, and pi. Use skit runner add to register a
different CLI. Do not use prompts for secrets. The receiving agent can store the rendered text in
its session logs. Read the prompt documentation
for runner behavior, non-interactive selection, the Pi fallback, and the no-shell delivery rule.
skit add review.prompt.md # managed placeholders become input fieldsskit run review # pick the agent, fill in the inputs, goskit run review --runner codex --set target=src/app.py --no-input
skit uses uv 0.12.3. If uv is not installed, skit asks for
consent and then downloads this version into its private directory. skit does not change your
PATH or global environment. A system-wide
install is still preferred.
# Install skit with uv tool from PyPI (the package is named skit-cli; the command is skit)uv tool install skit-cli
In mainland China? Set the mirror by hand for this one command (details in Mainland China (中国大陆)):
Version 0.5 replaces the Python and Textual implementation with Rust, Ratatui, and Crossterm. Run
uv tool upgrade skit-cli; no export or import is necessary. skit reads the same library,
configuration, presets, remembered values, and metadata in place. It keeps unknown TOML fields and
does not rewrite data during startup.
The terminal workflow is more direct. Search now uses case-insensitive substring matching. Forms
use one text editor for every scalar type and validate values when you submit. The first Rust
release does not show the old checkbox, choice-list, or file-browser widgets. The add screen is one
form; use the settings screen after the add to manage detected source fields. These presentation
changes do not change stored scripts or state. See the cutover design
for the complete compatibility boundary.
skit add my_script.py # add a scriptskit add # not sure what you are adding? it asksskit # open the menu, pick it, fill in the inputs, run
Everything else happens inside the TUI — on screen, mouse or keyboard, nothing to memorize.
The rest of the CLI exists for automation and AI agents — every TUI action, scriptable:
skit run my_script -p fast # run with a saved presetskit run my_script --dry-run # print the exact command, do not run itskit run my_script --set width=800 --no-input # set values explicitly, never promptskit show my_script --json # one script's full parameter schema, machine-readableskit params my_script # show managed parameters and last-used valuesskit deps my_script --dep "requests>=2" # set a script's package dependenciesskit list --json # machine-readable listingskit config # settings: language, editor, mirror, form styleskit --help # everything else
skit is a script repository for humans and AI agents: one library — you get the
TUI, agents get a deterministic CLI. The official Agent Skill
teaches compatible agents (Claude Code, Codex, Cursor, Gemini CLI, and many more) to
check your library before writing yet another one-off script, to inspect and run what is
already there, and to offer to save the useful scripts they write — so they outlive the
session that created them.
skit agent install # use the sole detected agent directory; otherwise, select oneskit agent install claude # select claude / codex / agents (--project limits it to this repo)npx skills add t41372/skit # or install through skills.sh into 70+ agents
skit follows your system language; switch it in the TUI preferences (for automation: skit config lang zh-TW, or SKIT_LANG=zh-CN skit for one run). Want another language? Open an issue or PR.
Four downloads tend to fail in mainland China: PyPI packages, npm packages, the Python builds uv fetches from GitHub, and skit's own uv bootstrap. skit can route all four through domestic mirrors.
Mirror settings live inside skit only: your global uv config is never touched, and existing mirror settings (UV_DEFAULT_INDEX, uv.toml, …) are respected. The npm registry rides NPM_CONFIG_REGISTRY: an existing value of that variable in your environment still wins, but note npm itself ranks it above ~/.npmrc.
Each ecosystem is its own, independent choice — mirror vendors differ per ecosystem, so no single vendor name spans them:
First run: if PyPI/GitHub look unreachable, skit offers mirror setup — one question per ecosystem, Enter accepts each one's recommended preset.
Any time: TUI Preferences → mirrors, or:
skit config mirror.pypi tsinghua # Python packages: tsinghua / aliyun / ustc / a URL / offskit config mirror.github nju # Python builds + the uv binary: nju / an https:// base URL / offskit config mirror.npm npmmirror # JS/TS packages: npmmirror / a URL / offskit config mirror off # master switch: off keeps the URLs; `on` restores them
Custom URLs: pick custom in TUI Preferences (or the first-run wizard), or pass a URL to the axis key directly.
That removes skit and its PATH shim. Your library and settings live outside the package, so they survive on purpose — reinstall and you are right back where you left off. To erase those too, delete skit's own directories:
They hold your tool library, config, presets, and last-used values — plus, if skit ever bootstrapped its own uv, the private uv binary (in …/skit/bin, deleted along with the rest).
# macOSrm -rf ~/Library/Application\ Support/skit# Linux — honors XDG_DATA_HOME / XDG_STATE_HOME / XDG_CONFIG_HOME if you have set themrm -rf "${XDG_DATA_HOME:-$HOME/.local/share}/skit" "${XDG_STATE_HOME:-$HOME/.local/state}/skit" "${XDG_CONFIG_HOME:-$HOME/.config}/skit"
# Windows (PowerShell)Remove-Item -Recurse -Force $env:LOCALAPPDATA\skit
Not sure where yours landed? skit doctor prints the resolved library path (and respects any SKIT_DATA_DIR / SKIT_STATE_DIR / SKIT_CONFIG_DIR overrides). That is everything skit owns — it never writes to your PATH, shell, or global uv config, so nothing else needs undoing. The uv download cache and any Python builds uv fetched are shared with the rest of your uv setup, not skit's to remove; if you do not use uv elsewhere and want the space back, uv cache clean clears the cache.
Development uses the pinned Rust toolchain. See CONTRIBUTING.md for the TDD
workflow and the complete coverage, cargo-mutants, supply-chain, wheel, documentation, and benchmark
gates.
cargo build --lockedcargo test --locked --workspace --all-targets --all-featurescargo run -p skit-cli-rs -- --help
skit
