craftkit 0.3.0__py3-none-any.whl

craft_kit/workspace.py

@@ -0,0 +1,320 @@
+"""The project folder and its one state file, craft.json (versioned, written atomically).
+
+<project>/
+  craft.json        request, target, kind, stack, mode, rounds used, step states
+  BRIEF.md          what the builder is told (regenerated before each first turn)
+  capture/          Study's evidence, README.md first (read-only for the builder)
+  reference/        pictures or files the person adds (read-only)
+  app/              the only folder the builder changes
+  checks/round-N/   each check: result.json, screenshots, logs
+  checks/turn-N/    each builder turn: the message sent, its log and reply
+  unknowns.md       open questions about the original, kept by the builder
+  questions.json    questions the builder asks the person, with their answers
+  feed.log          everything that happened, in order
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import tempfile
+import time
+from pathlib import Path
+from typing import Optional
+
+from . import proc, tables
+
+STATE = "craft.json"
+VERSION = 1
+STEPS = ["study", "build", "check", "ready"]
+IGNORED = {"node_modules", "target", "dist", "out", "build", ".git", "__pycache__", ".venv", "venv", ".next", "shots", ".pytest_cache"}
+
+
+class CraftError(Exception):
+    """A failure with a plain-English remediation."""
+
+    def __init__(self, message: str, fix: str = ""):
+        super().__init__(message)
+        self.message = message
+        self.fix = fix
+
+
+def write_atomic(path: Path, data: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(prefix=f".{path.name}.", suffix=".tmp", dir=str(path.parent))
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as f:
+            f.write(data)
+        os.chmod(tmp, 0o644)
+        for attempt in range(5):  # Windows: a scanner may hold the file for a moment
+            try:
+                os.replace(tmp, path)
+                return
+            except PermissionError:
+                if attempt == 4:
+                    raise
+                time.sleep(0.2)
+    finally:
+        if os.path.exists(tmp):
+            os.unlink(tmp)
+
+
+def read_json(path: Path, default=None):
+    try:
+        return json.loads(path.read_text("utf-8"))
+    except (OSError, ValueError):
+        return default
+
+
+def parse_target(raw: str) -> dict:
+    raw = (raw or "").strip()
+    if not raw:
+        return {"type": "none", "value": ""}
+    if re.match(r"^https?://", raw, re.I):
+        return {"type": "website", "value": raw}
+    p = Path(raw).expanduser()
+    if p.exists():
+        return {"type": "local", "value": str(p.resolve())}
+    found = proc.which(raw)
+    if found and os.sep not in raw:
+        return {"type": "local", "value": found}
+    if re.match(r"^[\w-]+(\.[\w-]+)+(/.*)?$", raw):
+        return {"type": "website", "value": f"https://{raw}"}
+    raise CraftError(f"Can't find the target “{raw}”.", "Give a web address (https://…), a file or folder path, a command on your PATH, or nothing to build from the request alone.")
+
+
+def slug(text: str) -> str:
+    s = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+    return (s[:40].rstrip("-") or "project")
+
+
+# The projects the person has made or opened, for the home screen (config_dir/projects.json).
+REGISTRY_LIMIT = 300
+
+
+def projects_dir() -> Path:
+    """Where the home screen creates new projects."""
+    return Path(os.environ.get("CRAFT_PROJECTS_DIR") or Path.home() / "craft-projects").expanduser()
+
+
+def _registry_path() -> Path:
+    return tables.config_dir() / "projects.json"
+
+
+def remembered() -> list[dict]:
+    data = read_json(_registry_path(), {})
+    items = data.get("projects") if isinstance(data, dict) else None
+    if not isinstance(items, list):
+        return []
+    good = [i for i in items if isinstance(i, dict) and isinstance(i.get("path"), str)]
+    return sorted(good, key=lambda i: str(i.get("opened", "")), reverse=True)
+
+
+def _save_registry(items: list[dict]) -> None:
+    try:
+        write_atomic(_registry_path(), json.dumps({"version": 1, "projects": items[:REGISTRY_LIMIT]}, indent=1, ensure_ascii=False) + "\n")
+    except OSError:
+        pass  # the list is a convenience: never fail a command over it
+
+
+def remember(root: Path) -> None:
+    path = str(Path(root).resolve())
+    items = [i for i in remembered() if i["path"] != path]
+    items.insert(0, {"path": path, "opened": time.strftime("%Y-%m-%dT%H:%M:%S")})
+    _save_registry(items)
+
+
+def forget(path: str) -> None:
+    _save_registry([i for i in remembered() if i["path"] != path])
+
+
+def find_root(start: Path) -> Path:
+    here = start.resolve()
+    for d in [here, *here.parents]:
+        if (d / STATE).is_file():
+            return d
+    raise CraftError("This folder isn't a craft project.", "Run `craft new` to start one, or `craft -C <project> …`.")
+
+
+class Project:
+    def __init__(self, root: Path, state: dict):
+        self.root = root
+        self.state = state
+
+    # paths -------------------------------------------------------------------
+    @property
+    def app(self) -> Path:
+        return self.root / "app"
+
+    @property
+    def capture(self) -> Path:
+        return self.root / "capture"
+
+    @property
+    def reference(self) -> Path:
+        return self.root / "reference"
+
+    def round_dir(self, n: int) -> Path:
+        return self.root / "checks" / f"round-{n}"
+
+    # state -------------------------------------------------------------------
+    @classmethod
+    def create(cls, folder: Path, target: dict, request: str, kind: str, stack: str, deep: bool, allow_run: bool) -> "Project":
+        if (folder / STATE).exists():
+            raise CraftError(f"{folder} is already a craft project.", "Use `craft run` there, or pick another folder with --dir.")
+        state = {
+            "version": VERSION,
+            "name": folder.name,
+            "request": request,
+            "target": target,
+            "kind": kind,
+            "stack": stack,
+            "deep": deep,
+            "allow_run": allow_run,
+            "max_rounds": tables.MAX_ROUNDS,
+            "good_enough": tables.GOOD_ENOUGH,
+            "rounds_used": 0,
+            "round": 0,
+            "steps": {s: "todo" for s in STEPS},
+            "agent": None,
+            "session": None,
+            "unchanged": 0,
+            "fingerprint": None,
+            "created": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        }
+        for d in ("app", "capture", "reference", "checks"):
+            (folder / d).mkdir(parents=True, exist_ok=True)
+        p = cls(folder, state)
+        unknowns = folder / "unknowns.md"
+        if not unknowns.exists():
+            write_atomic(unknowns, "# Unknowns\n\nQuestions the evidence doesn't answer yet.\n`- [ ] question — what would settle it — impact: high|medium|low`; tick with the answer and its evidence.\n\n")
+        p.save()
+        remember(folder)
+        p.log(f"new project: {request!r} target={target['value'] or '-'} kind={kind} stack={stack} mode={'deep' if deep else 'clean room'}")
+        return p
+
+    @classmethod
+    def open(cls, start: Path) -> "Project":
+        root = find_root(start)
+        state = read_json(root / STATE)
+        if not isinstance(state, dict):
+            raise CraftError(f"{root / STATE} can't be read.", "Fix or delete the file; it is JSON.")
+        v = state.get("version")
+        if not isinstance(v, int) or v > VERSION:
+            raise CraftError(f"{STATE} says version {v}; this craft reads version {VERSION}.", "Update craft (`pipx upgrade craftkit`, `uv tool upgrade craftkit` or `npm update -g craftkit`).")
+        # migrations go here as versions are added
+        state.setdefault("steps", {s: "todo" for s in STEPS})
+        remember(root)
+        return cls(root, state)
+
+    def save(self) -> None:
+        write_atomic(self.root / STATE, json.dumps(self.state, indent=2, ensure_ascii=False) + "\n")
+
+    def set_step(self, step: str, status: str) -> None:
+        self.state["steps"][step] = status
+        self.save()
+
+    def log(self, text: str) -> None:
+        try:
+            with open(self.root / "feed.log", "a", encoding="utf-8") as f:
+                f.write(f"{time.strftime('%H:%M:%S')} {text}\n")
+        except OSError:
+            pass
+
+    @property
+    def deep(self) -> bool:
+        return bool(self.state.get("deep"))
+
+    def mode(self) -> str:
+        return "deep" if self.deep else "clean room"
+
+    # what the builder made -----------------------------------------------------
+    def app_spec(self) -> dict:
+        """How the build is built, tested and run: app/craft-app.json if the builder wrote one,
+        else what its files show. Lists of program + arguments; `site` is the folder to serve."""
+        spec: dict = {}
+        declared = read_json(self.app / "craft-app.json", {})
+        if isinstance(declared, dict):
+            for key in ("install", "build", "test", "run"):
+                v = declared.get(key)
+                if isinstance(v, list) and v and all(isinstance(a, str) for a in v):
+                    spec[key] = v
+            if isinstance(declared.get("site"), str):
+                spec["site"] = declared["site"]
+        for tc in tables.TOOLCHAINS:
+            if (self.app / tc["file"]).exists():
+                for key in ("install", "build", "test"):
+                    if key not in spec and key in tc:
+                        spec[key] = list(tc[key])
+                spec.setdefault("toolchain", tc["file"])
+                break
+        return spec
+
+    def site_dir(self) -> Optional[Path]:
+        spec = self.app_spec()
+        names = [spec["site"]] if "site" in spec else tables.SITE_DIRS
+        for n in names:
+            d = (self.app / n).resolve()
+            if self.app.resolve() in [d, *d.parents] and (d / "index.html").is_file():
+                return d
+        return None
+
+    def fingerprint(self) -> str:
+        h = hashlib.sha256()
+        count = 0
+        for dirpath, dirnames, filenames in os.walk(self.app):
+            dirnames[:] = sorted(d for d in dirnames if d not in IGNORED)
+            for name in sorted(filenames):
+                path = Path(dirpath) / name
+                try:
+                    st = path.stat()
+                    h.update(str(path.relative_to(self.app)).encode())
+                    if st.st_size <= 1_000_000:
+                        h.update(path.read_bytes())
+                    else:
+                        h.update(f"{st.st_size}:{st.st_mtime_ns}".encode())
+                except OSError:
+                    continue
+                count += 1
+                if count > 20_000:
+                    return h.hexdigest()
+        return h.hexdigest()
+
+    # questions -----------------------------------------------------------------
+    def questions(self) -> list[dict]:
+        data = read_json(self.root / "questions.json", {})
+        qs = data.get("questions") if isinstance(data, dict) else None
+        return [q for q in qs if isinstance(q, dict) and isinstance(q.get("question"), str)] if isinstance(qs, list) else []
+
+    def pending_questions(self) -> list[dict]:
+        return [q for q in self.questions() if not q.get("answer")]
+
+    def undelivered_answers(self) -> list[dict]:
+        """Answers the builder hasn't been given yet (typed here or written into questions.json)."""
+        return [q for q in self.questions() if q.get("answer") and not q.get("delivered")]
+
+    def mark_delivered(self, answered: list[dict]) -> None:
+        if not answered:
+            return
+        done = {q["question"] for q in answered}
+        qs = self.questions()
+        for q in qs:
+            if q["question"] in done:
+                q["delivered"] = True
+        write_atomic(self.root / "questions.json", json.dumps({"version": 1, "questions": qs}, indent=2, ensure_ascii=False) + "\n")
+
+    def save_answers(self, answered: list[dict]) -> None:
+        by_q = {q["question"]: q.get("answer") for q in answered}
+        qs = self.questions()
+        for q in qs:
+            if q["question"] in by_q and by_q[q["question"]]:
+                q["answer"] = by_q[q["question"]]
+        write_atomic(self.root / "questions.json", json.dumps({"version": 1, "questions": qs}, indent=2, ensure_ascii=False) + "\n")
+
+    def open_unknowns(self) -> int:
+        try:
+            return sum(1 for line in (self.root / "unknowns.md").read_text("utf-8").splitlines() if line.lstrip().startswith("- [ ]"))
+        except OSError:
+            return 0

craftkit-0.3.0.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: craftkit
+Version: 0.3.0
+Summary: Study → build → check → refine any software, from the terminal, with your coding agent.
+License-Expression: MIT OR Apache-2.0
+Keywords: cli,coding-agent,claude-code,codex,gemini,rebuild,skill
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE-MIT
+License-File: LICENSE-APACHE
+Provides-Extra: browser
+Requires-Dist: playwright>=1.40; extra == "browser"
+Dynamic: license-file
+
+# craftkit
+
+> **In English:** `craft` rebuilds any software (website, CLI, app, game, library) with the coding
+> agent you already use (Claude Code, Codex, Gemini CLI): it studies the original, briefs the agent,
+> checks the result against the original and sends it back until it holds. Install with
+> `npm install -g craftkit` or `pipx install craftkit`, then type `craft`.
+
+La méthode de Craft Anything, réduite à l'essentiel : **étudier → construire → vérifier → affiner**,
+pour recréer ou construire n'importe quel logiciel (site web, outil en ligne de commande, application,
+jeu, librairie), depuis le terminal.
+
+Deux façons de l'utiliser :
+
+1. **Le skill** (`craft_kit/SKILL.md`) : la méthode seule, en Markdown. N'importe quel agent de code
+   (Claude Code, Codex, Gemini CLI, Cursor…) peut la suivre, avec ou sans la CLI.
+2. **La CLI `craft`** : la même méthode, outillée. Elle tient le dossier du projet, collecte les
+   preuves, donne la tâche à un agent de code, mesure le résultat et relance l'agent jusqu'à ce que
+   ça passe. Python 3.9+, **aucune dépendance**.
+
+```text
+ craft · horloge-pomodoro                        cli · Rust · clean room
+ ▍study  ./pomodoro ────────────────────────────────────────────────
+ ✓ runs    4 runs recorded
+ ▍build  building · turn 1 ─────────────────────────────────────────
+   0:03 ◇ read   BRIEF.md
+   0:05 ☰ plan   2/5 · Writing the timer
+   0:41 ✚ write  app/src/main.rs
+   1:02 ❯ run    cargo build
+   1:20 ✗ failed error[E0425]: cannot find value `paused`
+   1:31 ✎ edit   app/src/main.rs
+   └ 2m14s · 14 actions: 6 edit, 4 run, 3 read, 1 plan · 1 failed
+ ✓ build   I built the timer with pause and resume.
+ ▍check  round 1 ───────────────────────────────────────────────────
+ ✗ runs    6 of 8 claims hold; output 71% alike.
+   │ With --help, it prints what the original prints: 52% of the words match
+ ▍refine  refining 1/6 · turn 2 ────────────────────────────────────
+   ⠼ refining 1/6 · claude · 0m48s · 3 · Edit app/src/main.rs
+```
+
+Pendant le travail, chaque action de l'agent s'affiche en direct (lecture, écriture, commande,
+recherche, plan, échec), chacune avec sa couleur, et chaque étape a la sienne : étude bleu ciel,
+construction bleu, affinage violet, vérification ambre, prêt vert.
+
+## Installation
+
+Gratuit, au choix :
+
+```sh
+npm install -g craftkit        # avec Node ; il faut aussi Python 3.9+ sur la machine
+pipx install craftkit          # ou : uv tool install craftkit
+```
+
+Pour l'essayer sans rien installer : `npx craftkit` ou `uvx craftkit`.
+Ensuite, le skill pour Claude Code (tous les projets) : `craft skill --install ~/.claude/skills`.
+
+Les deux paquets contiennent exactement le même programme Python (aucune dépendance) ; celui de npm
+le lance avec le Python de la machine (`CRAFT_PYTHON=/chemin/vers/python3` pour en choisir un).
+Mise à jour : `npm update -g craftkit`, `pipx upgrade craftkit` ou `uv tool upgrade craftkit`.
+
+Depuis les sources : `pipx install .` dans ce dossier, ou `python3 -m craft_kit …` sans installer.
+
+Optionnel, pour les sites web : un navigateur pour les captures. La CLI prend, dans l'ordre,
+Playwright pour Python (`pip install playwright && playwright install chromium`, qui ajoute les
+mesures visibles : polices, couleurs, titres, texte), sinon Chrome/Edge installé (en mode headless,
+avec un profil temporaire), sinon Playwright via `npx`.
+
+## Utilisation
+
+Tapez simplement **`craft`** : l'écran d'accueil affiche le titre CRAFT KIT, vos créations
+précédentes et « + New project ».
+
+| Touche | Action |
+|--------|--------|
+| ↑ ↓ (ou j k) | se déplacer |
+| Entrée | ouvrir le projet : continuer, demander un changement, ouvrir le résultat, revérifier, voir le dossier |
+| n | nouveau projet (quelques questions, créé dans `~/craft-projects`, ou `CRAFT_PROJECTS_DIR`) |
+| x | retirer de la liste (le dossier n'est pas supprimé) |
+| q / Échap | retour, ou quitter |
+
+La liste contient tous les projets créés ou ouverts avec `craft` (mémorisés dans
+`~/.config/craft/projects.json`), plus ceux du dossier courant.
+
+Raccourcis : `craft-new …` = `craft new …`, `craft-run …` = `craft run …`.
+
+En ligne de commande directe :
+
+```sh
+craft new https://exemple.com "recrée ce site en React"   # crée ./recree-ce-site-en-react/
+cd recree-ce-site-en-react
+craft run                                   # toute la boucle
+craft run "le bouton doit être bleu"        # une modification (nouveau budget d'affinage)
+craft open                                  # ouvrir le résultat
+```
+
+| Commande | Rôle |
+|----------|------|
+| `craft new [CIBLE] [DEMANDE…]` | crée le projet ; demande ce qui manque. CIBLE = URL, fichier, dossier, commande du PATH, ou rien |
+| `craft run [MESSAGE…]` | étude (si pas faite) → construction → vérification → affinage, jusqu'à la réussite |
+| `craft study` / `build` / `check` | une étape à la fois |
+| `craft check --self` | la vérification que l'agent lance lui-même pendant qu'il travaille (non comptée) |
+| `craft` | écran d'accueil : créations précédentes, nouveau projet |
+| `craft status` | où en est le projet |
+| `craft answer` | répondre aux questions de l'agent |
+| `craft brief` | afficher la tâche, pour la coller dans n'importe quel agent |
+| `craft skill [--install DOSSIER]` | afficher ou installer le SKILL.md |
+
+Options de `new` : `--kind website|cli|app|game|tool`, `--stack rust|python|react|html|…`,
+`--deep` (regarder à l'intérieur de l'original, usage privé), `--allow-run` (lancer le programme
+d'origine pour enregistrer ce qu'il affiche), `--dir`.
+
+## Ce que la CLI reprend de Craft Anything
+
+| Craft Anything | craft-kit |
+|----------------|-----------|
+| Clean room / Deep | même règle : par défaut, seulement ce qu'un visiteur voit ; `--deep` pour regarder dedans |
+| Study → `capture/README.md` | captures à 1440/768/390 px + mesures visibles ; exécutions d'un CLI ; inventaire en Deep |
+| Le builder ne touche que `app/` | idem, et `app/craft-app.json` déclare build/test/run |
+| `rebuild_check` pendant la construction | `craft check --self` |
+| Contrats `--screenshot` / `--self-test` | identiques (applis et jeux) |
+| Comparaison des runs d'un programme console | même code de sortie + ≥ 80 % de mots communs |
+| `max_rounds` 6, `good_enough` 90 %, arrêt après 2 tours sans changement | identiques ; le budget survit aux relances, seule une nouvelle demande le remet à zéro |
+| Cartes question/approbation | `questions.json` → questions numérotées dans le terminal |
+| Inconnues (`core_unknown_add`) | `unknowns.md` |
+| Processus : stdin fermé, délais, groupe tué | idem (`proc.py`) |
+
+Ce qu'elle ne reprend pas : les ~320 outils d'analyse (désassembleur, décompilateur, Ghidra, adb,
+Frida…), l'interface graphique et le serveur MCP. En mode Deep, c'est l'agent qui inspecte avec ses
+propres outils.
+
+## Agents
+
+Ordre par défaut : `claude`, `codex`, `gemini` (le premier installé). Choisir : `--agent codex` ou
+`CRAFT_AGENT=codex`. La tâche est envoyée sur l'entrée standard (jamais en argument : elle peut être
+longue). Ajouter ou modifier un agent dans `~/.config/craft/agents.json` :
+
+```json
+{"mon-agent": {"argv": ["mon-agent", "--non-interactive"], "stream": "text"}}
+```
+
+Claude Code est lancé avec `--permission-mode acceptEdits` et une liste d'outils autorisés
+(lecture/écriture, npm, cargo, go, python, make, craft…), pas en contournant les permissions.
+
+Délais : `CRAFT_TURN_TIMEOUT` (3 h par tour), `CRAFT_IDLE_TIMEOUT` (20 min sans sortie).
+Navigateur : `CRAFT_BROWSER=python|chrome|npx|none`, `CRAFT_CHROME=/chemin/vers/chrome`.
+Affichage : `CRAFT_FEED=0` garde seulement la ligne animée (sans le fil d'actions) ; `NO_COLOR=1`
+retire les couleurs. Hors terminal (pipe, CI), le fil s'écrit en texte simple, une ligne par action.
+
+## Limites connues
+
+- La comparaison visuelle est une grille de couleurs (64 colonnes, tolérance 32) : elle repère les
+  écarts de mise en page et de couleur, pas les détails fins.
+- Avec Chrome headless, la capture fait 2400 px de haut, pas la page entière ; les mesures visibles
+  (polices, titres, texte) demandent Playwright pour Python.
+- Les adaptateurs `codex` et `gemini` n'ont pas été essayés en vrai.

craftkit-0.3.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+craft_kit/SKILL.md,sha256=5pLGJ0gJGQ52cdhAsk08elLHzn_ZowKkeIerr3QoyoA,8406
+craft_kit/__init__.py,sha256=Sark2099VyVu-REBs2AVCRvWRREmCQzIfBn9niAwHVY,110
+craft_kit/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+craft_kit/agent.py,sha256=qOH2I8HZk2nIL4b7RNMDfGqKwLXWDCkobKcytpP1tR8,7704
+craft_kit/banner.py,sha256=RtOoEF4iZdwwvVimtGoAsNgzJSb0Wl0A4LCnh4FJBLk,3544
+craft_kit/brief.py,sha256=jAbmYeUNknRRN11sQDYp35bxJP1AxGpEmfc_JGfGH58,7862
+craft_kit/browser.py,sha256=nMGprBKH352UjdsxegiS8eQlATD3aFezS2KD0cejGrA,8563
+craft_kit/checks.py,sha256=6iMH2pY3jeMRZuzreRwWSlvlLwMzDTaW50KeTBNdNvk,11597
+craft_kit/cli.py,sha256=5d2Tq-0OxrJ8AsN3DudfPD6EEHm-oF5WDdauzMJ8uc8,15928
+craft_kit/home.py,sha256=10NL8dQOT3PUSCw_eybbhr1r7TTvSndNRuTobXrNyjA,15121
+craft_kit/png.py,sha256=ouawGipJIbzj4Mvxcg_7ifRAVPf_IAGxb_h--8E2sjk,5170
+craft_kit/proc.py,sha256=I7MqSYQV4-6r4f232E_Nr59gtHDEPsOKFztwY7gA8IM,5106
+craft_kit/study.py,sha256=GNdtK7wiL7ktkwSUAQ396Y4zmFwqarVgvmkYotWvGQg,7963
+craft_kit/tables.py,sha256=fApV6te6rUPqeob1NbDKR4Lwks2jrBgqdhO0hwK30z0,8325
+craft_kit/ui.py,sha256=T9adCzuYhb1bdDcfITFpkKA3EyCnari-MskIZPK8Z1Q,10896
+craft_kit/workspace.py,sha256=mu7L-BzR4t4S2bAnrZ-Pkl15SEal_aQjxrk5NSN2JX4,12497
+craftkit-0.3.0.dist-info/licenses/LICENSE-APACHE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+craftkit-0.3.0.dist-info/licenses/LICENSE-MIT,sha256=d3tfDGW9nCicsjTjKFe1lHRdXHbWEwNIcKoFvQDTJiI,1106
+craftkit-0.3.0.dist-info/METADATA,sha256=FQf1Skq5E9lMiHsyLAoFe5ErLE2Uh0l4w_NeJnc2hdE,9417
+craftkit-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+craftkit-0.3.0.dist-info/entry_points.txt,sha256=zYsBuXnXq6R7GctQayEx5gNE8T28SeCgLO6WFIjfPHU,145
+craftkit-0.3.0.dist-info/top_level.txt,sha256=uU70H-OKnfKZ18GpHxj2PTjwQ66nTtprja_UZrAXnQs,10
+craftkit-0.3.0.dist-info/RECORD,,

craftkit-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

craftkit-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+craft = craft_kit.cli:main
+craft-new = craft_kit.cli:main_new
+craft-run = craft_kit.cli:main_run
+craftkit = craft_kit.cli:main