TBaguette’s Atelier v2.3.1

Updated

The install command only touches one folder

A git clone into ~/.claude/skills/TBaguette sits right next to whatever else already lives under ~/.claude/skills/ — other skills, other plugins, things you already trust. It's a fair question whether installing this one could touch any of that. It can't. This page is why, and the actual test that proves it, not a claim restated in different words.

What the command does

The published command checks for an existing clone before doing anything: if ~/.claude/skills/TBaguette/.git already exists, it runs git pull in place; otherwise it runs git clone. The first run installs. Every run after that updates. Neither branch ever reads or writes anywhere else.

Why it can't reach anything else

Both branches are scoped to the single path ~/.claude/skills/TBaguette by construction — a git clone or git pull targeting that path has no mechanism to write outside it. The one case worth naming explicitly is a real collision: something else already sitting at that exact path, that isn't a clone of this repo. git clone refuses outright when its target already exists and is non-empty — it does not merge, does not overwrite, does not ask. It fails loudly and leaves whatever was there exactly as it was. That refusal is git's own behavior, not something this project added on top.

Four scenarios, not one

A single happy-path test would only prove the command works when nothing is in its way, which is the one case nobody actually worried about. The real test runs four scenarios, each against a throwaway HOME directory seeded with fake sibling skills and plugins alongside TBaguette, checksummed before and after:

  • A — fresh install. Nothing at that path yet. Confirms the clone succeeds and the siblings are untouched.
  • B — running it again. Continues from A. Confirms the second run updates in place (git pull) instead of erroring the way a bare git clone would, and that the siblings are still untouched.
  • C — an empty directory already named TBaguette. Confirms git clone is willing to use an empty directory that happens to already exist, and that siblings survive.
  • D — the real collision. A non-empty, non-git directory already sitting at that exact path, with its own unrelated content. Confirms the command refuses rather than merging into it — and that both the colliding directory's own content and every sibling skill survive the refusal.

All twelve checks across those four scenarios pass before this site is ever deployed — plus twelve more that run the exact command string published above, word for word, through every POSIX-ish shell this project's own build machine has installed (bash, zsh, fish, and sh), rather than trusting that this page's Python reimplementation of it stayed faithful to what actually ships. run_tests.py runs all twenty-four alongside everything else, not as a separate manual step someone has to remember.

Every platform, not just one

The install frame above shows a prompt addressed to Claude, not a command for you to type — paste it into a Claude Code conversation and Claude detects your OS and runs the matching command itself. That command, on every platform, is exactly what follows: a POSIX command for macOS, Linux, and anyone on Windows already inside WSL or Git Bash, and a PowerShell command for everyone else on Windows — which is most Windows users, since PowerShell has been the default terminal since Windows 10. All three do the exact same thing, in the same order, for the same reason: check for an existing clone, git pull if it's there, git clone if it isn't.

The POSIX command is the one machine-verified above, across four shells:

[ -d ~/.claude/skills/TBaguette/.git ] && git -C ~/.claude/skills/TBaguette pull || git clone https://github.com/LeSplooch/tbaguette-skills.git ~/.claude/skills/TBaguette

The PowerShell command carries the exact same logic over to Test-Path and native cmdlets:

if (Test-Path "$HOME\.claude\skills\TBaguette\.git" -PathType Container) { git -C "$HOME\.claude\skills\TBaguette" pull } else { git clone https://github.com/LeSplooch/tbaguette-skills.git "$HOME\.claude\skills\TBaguette" }

That one isn't cross-checked by an automated test the way the POSIX command is — this project's own build has no PowerShell runtime to run it against — so its correctness rests on Test-Path, git -C, and git clone being ordinary, well-documented behavior, not on an executed proof. If that's not good enough, that's a fair position to hold; the honest answer is "verified by careful construction," not "verified," for this one specifically.

And for Command Prompt, which nothing in the install frame targets but which still exists on every Windows machine:

if exist "%USERPROFILE%\.claude\skills\TBaguette\.git" (git -C "%USERPROFILE%\.claude\skills\TBaguette" pull) else (git clone https://github.com/LeSplooch/tbaguette-skills.git "%USERPROFILE%\.claude\skills\TBaguette")

Same logic again, translated to IF EXIST and %USERPROFILE% — with one honest imprecision. IF EXIST can't cleanly test "is this specifically a directory" in one line the way -d and -PathType Container can, so it matches a file or a directory at that path indiscriminately. That's never actually wrong here, since a real git checkout's .git is always a directory, but it's a looser guarantee than the other two, worth naming rather than glossing over.

The test itself

This is scripts/test_install_command.py, unedited — the same file the test suite actually runs, not a representative excerpt.

  1. """Proves the published install command (templates.INSTALL_COMMAND) can never
  2. alter, overwrite, or merge into anything a user already has under
  3. ~/.claude/skills/ that this repo doesn't own — a user asked "won't this alter
  4. other skills?" and this is the actual answer, re-checked on every run rather
  5. than trusted from memory.
  7. Stdlib only, and deliberately not a shell script (this file replaces what was
  8. originally test_install_command.sh): bash is not guaranteed to exist on every
  9. system this might run on, notably Windows without Git Bash or WSL, and even
  10. where a POSIX shell is present, the coreutils it calls out to differ across
  11. platforms in ways that silently break things — the original script's
  12. sha256sum has no equivalent by that name on macOS (it ships shasum -a 256
  13. instead). Python 3 is a much narrower, more realistic requirement here, since
  14. it's already needed to run scripts/generate.py, and git is already required
  15. to install the plugin in the first place — nothing new to ask a reader to
  16. have.
  18. Four scenarios, each in its own throwaway HOME so a real ~/.claude is never
  19. touched:
  20. A. fresh install — clones cleanly
  21. B. re-running once already installed — updates in place (git pull),
  22. does not error
  23. C. an empty dir already named TBaguette — clones into it cleanly
  24. D. a NON-empty, non-git dir already named
  25. TBaguette (the real collision case) — refuses, leaves it untouched
  27. Sibling directories (other skills, other plugins) are populated in every
  28. scenario and checksummed before/after to prove they are never touched, not
  29. just assumed to be.
  31. The install() function below reimplements the published command's logic as
  32. direct git subprocess calls rather than shelling out to run the literal
  33. string — the same two git operations, in the same order, gated by the same
  34. condition, but expressed so this file's core guarantee holds even on a
  35. system with no POSIX shell at all. Where a shell *is* available,
  36. check_matches_published_command() additionally runs the literal string from
  37. templates.INSTALL_COMMAND itself, so the claim "the published command is
  38. safe" stays backed by the actual text shown on the site, not only by code
  39. that is merely intended to match it.
  41. Usage:
  42. python3 scripts/test_install_command.py
  43. """
  45. from __future__ import annotations
  47. import hashlib
  48. import os
  49. import shutil
  50. import subprocess
  51. import sys
  52. import tempfile
  53. from pathlib import Path
  55. from templates import INSTALL_COMMAND
  57. REPO_URL = "https://github.com/LeSplooch/tbaguette-skills.git"
  60. class Tally:
  61. """Accumulates check() results instead of raising on the first failure —
  62. deliberately different from checker.Checker's fail-fast style (used by
  63. this project's other plain assert-based test files). This file's whole
  64. point is comparing results across four independent scenarios, and across
  65. several shells in the bonus check; stopping at the first failure would
  66. hide whether everything else still held, which is exactly the question
  67. a report of "3 of 24 failed, here's which three" answers and a bare
  68. traceback from the first one doesn't."""
  70. def __init__(self) -> None:
  71. self.total = 0
  72. self.failures = 0
  74. def check(self, label: str, condition: bool) -> None:
  75. self.total += 1
  76. if condition:
  77. print(f" ok {label}")
  78. else:
  79. print(f" FAIL {label}")
  80. self.failures += 1
  83. tally = Tally()
  84. check = tally.check
  87. def install(home: Path) -> subprocess.CompletedProcess:
  88. """The published install command's logic, as direct git calls instead of
  89. a shell string: if ~/.claude/skills/TBaguette/.git already exists, pull
  90. in place; otherwise clone. Scoped to that single path by construction —
  91. neither branch has any mechanism to read or write anywhere else."""
  92. target = home / ".claude" / "skills" / "TBaguette"
  93. if (target / ".git").is_dir():
  94. return subprocess.run(
  95. ["git", "-C", str(target), "pull"],
  96. capture_output=True, text=True, check=False,
  97. )
  98. return subprocess.run(
  99. ["git", "clone", REPO_URL, str(target)],
  100. capture_output=True, text=True, check=False,
  101. )
  104. def seed_sibling_skills(home: Path) -> None:
  105. """Fake pre-existing content the install must never touch: a loose
  106. skill directory and a separate plugin, exactly the two shapes
  107. ~/.claude/skills/ actually holds (see orienting-in-unfamiliar-code and
  108. the TBaguette plugin's own layout)."""
  109. other_skill = home / ".claude" / "skills" / "some-other-skill"
  110. other_skill.mkdir(parents=True, exist_ok=True)
  111. (other_skill / "SKILL.md").write_text(
  112. "precious user content that must survive\n", encoding="utf-8"
  113. )
  115. plugin = home / ".claude" / "skills" / "another-plugin"
  116. (plugin / ".claude-plugin").mkdir(parents=True, exist_ok=True)
  117. (plugin / ".claude-plugin" / "plugin.json").write_text(
  118. '{"name": "another-plugin"}\n', encoding="utf-8"
  119. )
  120. (plugin / "skills" / "foo").mkdir(parents=True, exist_ok=True)
  121. (plugin / "skills" / "foo" / "SKILL.md").write_text(
  122. "more precious user content\n", encoding="utf-8"
  123. )
  126. def siblings_checksum(home: Path) -> list[tuple[str, str]]:
  127. """(path relative to home, sha256) for every file under the two sibling
  128. directories, sorted — needs no external tool at all, unlike the original
  129. script's `find ... -exec sha256sum {} \\; | sort`, so there is nothing
  130. here that can be missing or spelled differently across platforms."""
  131. roots = (
  132. home / ".claude" / "skills" / "some-other-skill",
  133. home / ".claude" / "skills" / "another-plugin",
  134. )
  135. entries = [
  136. (str(path.relative_to(home)), hashlib.sha256(path.read_bytes()).hexdigest())
  137. for root in roots
  138. for path in root.rglob("*")
  139. if path.is_file()
  140. ]
  141. return sorted(entries)
  144. # Every shell worth naming explicitly rather than just "a POSIX shell": bash
  145. # and zsh cover the macOS/Linux default in every version this century, sh is
  146. # whatever /bin/sh resolves to locally (often bash or dash), and fish is
  147. # included deliberately even though it isn't POSIX-compatible in general —
  148. # fish 3.0+ (2018) added && / || specifically so commands copy-pasted from
  149. # bash/zsh docs would still work, which is exactly this page's use case, and
  150. # it's worth proving rather than assuming.
  151. CANDIDATE_SHELLS = ("bash", "zsh", "fish", "sh")
  154. def check_matches_published_command(workdir: Path) -> None:
  155. """Best-effort bonus: for every shell in CANDIDATE_SHELLS actually
  156. present on PATH, runs the literal published command string — not this
  157. file's reimplementation of it — against its own fresh scenario. A shell
  158. missing from PATH is skipped with a note, not a failure; on a bare
  159. Windows system with neither Git Bash nor WSL, every candidate is
  160. skipped, and that's fine — install() above already proves the same
  161. guarantee via git directly, with no shell dependency at all. This
  162. function exists to additionally cross-check the exact string published
  163. on the site, on whichever real shells happen to be available here."""
  164. tested_any = False
  165. for shell_name in CANDIDATE_SHELLS:
  166. shell = shutil.which(shell_name)
  167. if shell is None:
  168. print(f" (skipped {shell_name}: not on PATH)")
  169. continue
  170. tested_any = True
  172. home = workdir / f"shellcheck-{shell_name}"
  173. home.mkdir()
  174. seed_sibling_skills(home)
  175. before = siblings_checksum(home)
  177. env = {**os.environ, "HOME": str(home)}
  178. result = subprocess.run(
  179. [shell, "-c", INSTALL_COMMAND], env=env, capture_output=True, text=True, check=False,
  180. )
  181. check(f"the literal published command exits 0 under {shell_name}",
  182. result.returncode == 0)
  183. check(f"...and actually installs something, under {shell_name}",
  184. (home / ".claude" / "skills" / "TBaguette" / "README.md").is_file())
  185. check(f"...without touching the sibling skills under {shell_name}, using "
  186. "the exact string published on the site, not a reimplementation of it",
  187. before == siblings_checksum(home))
  189. if not tested_any:
  190. print(" (skipped entirely: no POSIX-ish shell on PATH — install() above "
  191. "already verified the same guarantee via git directly, without one)")
  194. def main() -> int:
  195. workdir = Path(tempfile.mkdtemp(prefix="tbaguette-install-test-"))
  196. try:
  197. print("scenario A: fresh install")
  198. home_a = workdir / "a"
  199. home_a.mkdir()
  200. seed_sibling_skills(home_a)
  201. before_a = siblings_checksum(home_a)
  202. result = install(home_a)
  203. check("clone exits 0", result.returncode == 0)
  204. check("TBaguette content actually present",
  205. (home_a / ".claude" / "skills" / "TBaguette" / "README.md").is_file())
  206. check("sibling skills byte-identical after install",
  207. before_a == siblings_checksum(home_a))
  209. print("scenario B: re-run when already installed (must update, not error)")
  210. home_b = home_a # continues from A, which already installed TBaguette
  211. before_b = siblings_checksum(home_b)
  212. result = install(home_b)
  213. combined_output = (result.stdout or "") + (result.stderr or "")
  214. check("re-run exits 0 (does not error)", result.returncode == 0)
  215. check(
  216. "re-run reports a pull, not a clone-refused error",
  217. any(marker in combined_output for marker in
  218. ("Already up to date", "Updating", "Fast-forward")),
  219. )
  220. check("sibling skills still byte-identical after re-run",
  221. before_b == siblings_checksum(home_b))
  223. print("scenario C: an empty pre-existing TBaguette directory")
  224. home_c = workdir / "c"
  225. (home_c / ".claude" / "skills" / "TBaguette").mkdir(parents=True)
  226. seed_sibling_skills(home_c)
  227. before_c = siblings_checksum(home_c)
  228. result = install(home_c)
  229. check("clone into empty existing dir exits 0", result.returncode == 0)
  230. check("TBaguette content actually present",
  231. (home_c / ".claude" / "skills" / "TBaguette" / "README.md").is_file())
  232. check("sibling skills byte-identical", before_c == siblings_checksum(home_c))
  234. print("scenario D: a non-empty, non-git TBaguette directory (real collision)")
  235. home_d = workdir / "d"
  236. target_d = home_d / ".claude" / "skills" / "TBaguette"
  237. target_d.mkdir(parents=True)
  238. marker_file = target_d / "dont-touch-me.txt"
  239. marker_file.write_text(
  240. "unrelated content some other tool put here\n", encoding="utf-8"
  241. )
  242. seed_sibling_skills(home_d)
  243. before_marker = hashlib.sha256(marker_file.read_bytes()).hexdigest()
  244. before_d = siblings_checksum(home_d)
  245. result = install(home_d)
  246. check("refuses (nonzero exit) rather than merging into unrelated content",
  247. result.returncode != 0)
  248. check("the colliding directory's own content is untouched",
  249. hashlib.sha256(marker_file.read_bytes()).hexdigest() == before_marker)
  250. check("sibling skills byte-identical even in the refusal case",
  251. before_d == siblings_checksum(home_d))
  253. print("bonus: the literal published command string, where a shell exists")
  254. check_matches_published_command(workdir)
  255. finally:
  256. shutil.rmtree(workdir, ignore_errors=True)
  258. print()
  259. if tally.failures == 0:
  260. print(f"{tally.total} checks passed.")
  261. return 0
  262. print(f"{tally.failures} of {tally.total} checks FAILED.")
  263. return 1
  266. if __name__ == "__main__":
  267. sys.exit(main())

Run it yourself

Clone the repo and run python3 scripts/test_install_command.py directly, or python3 scripts/run_tests.py for the full suite this page's claims are checked against. Standard-library Python only — no bash required, since it isn't guaranteed to exist on every system this might run on.