project-kit-cli 0.1.0__py3-none-any.whl

project_kit/state.py

@@ -0,0 +1,115 @@
+""".project-kit/state.json: where the project is and what exists in the provider.
+
+The ``provider_ids`` map (``kind -> local_id -> provider_id``) is what makes provisioning
+resumable: after a partial failure, items already created are looked up here instead of
+being created again.
+"""
+
+import json
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from project_kit.config import PROJECT_DIR
+from project_kit.fsutil import atomic_write_text
+
+STATE_VERSION = 1
+PHASES = ("init", "discover", "decide", "workflow", "plan", "provision", "handoff")
+
+
+class StateError(ValueError):
+    """The state file is unreadable or invalid."""
+
+
+def state_path(root: Path) -> Path:
+    return root / PROJECT_DIR / "state.json"
+
+
+@dataclass
+class State:
+    phase: str = "init"
+    approvals: dict[str, str] = field(default_factory=dict)
+    provider_ids: dict[str, dict[str, str]] = field(default_factory=dict)
+
+    def validate(self) -> None:
+        problems = []
+        if self.phase not in PHASES:
+            problems.append(f"phase must be one of {', '.join(PHASES)}, got {self.phase!r}")
+        for phase, when in self.approvals.items():
+            if phase not in PHASES:
+                problems.append(f"approvals has unknown phase {phase!r}")
+            if not isinstance(when, str):
+                problems.append(f"approvals.{phase} must be a timestamp string")
+        for kind, ids in self.provider_ids.items():
+            if not isinstance(ids, dict) or not all(
+                isinstance(k, str) and isinstance(v, str) for k, v in ids.items()
+            ):
+                problems.append(f"provider_ids.{kind} must map local ids to provider ids (strings)")
+        if problems:
+            raise StateError("Invalid state: " + "; ".join(problems))
+
+    def approve(self, phase: str, when: datetime | None = None) -> None:
+        if phase not in PHASES:
+            raise StateError(f"Unknown phase {phase!r}")
+        self.approvals[phase] = (when or datetime.now(UTC)).isoformat(timespec="seconds")
+
+    def is_approved(self, phase: str) -> bool:
+        return phase in self.approvals
+
+    def set_id(self, kind: str, local_id: str, provider_id: str) -> None:
+        self.provider_ids.setdefault(kind, {})[local_id] = provider_id
+
+    def get_id(self, kind: str, local_id: str) -> str | None:
+        return self.provider_ids.get(kind, {}).get(local_id)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "version": STATE_VERSION,
+            "phase": self.phase,
+            "approvals": self.approvals,
+            "provider_ids": self.provider_ids,
+        }
+
+
+def parse_state(text: str) -> State:
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise StateError(
+            f"state.json is not valid JSON ({exc}). It is written atomically, so it was "
+            "probably edited by hand; fix or delete it."
+        ) from exc
+    if not isinstance(data, dict):
+        raise StateError("state.json must contain an object")
+
+    version = data.get("version")
+    if version != STATE_VERSION:
+        hint = (
+            " Upgrade project-kit." if isinstance(version, int) and version > STATE_VERSION else ""
+        )
+        raise StateError(f"Unsupported state.json version {version!r}.{hint}")
+
+    state = State(
+        phase=data.get("phase", "init"),
+        approvals=data.get("approvals", {}),
+        provider_ids=data.get("provider_ids", {}),
+    )
+    state.validate()
+    return state
+
+
+def load_state(root: Path) -> State:
+    """Load the state, or a fresh one if the project has none yet."""
+    try:
+        text = state_path(root).read_text(encoding="utf-8")
+    except FileNotFoundError:
+        return State()
+    return parse_state(text)
+
+
+def save_state(root: Path, state: State) -> None:
+    state.validate()
+    atomic_write_text(
+        state_path(root), json.dumps(state.to_dict(), indent=2, sort_keys=True) + "\n"
+    )

project_kit/templating.py

@@ -0,0 +1,23 @@
+"""Minimal ``{{variable}}`` substitution for the templates project-kit ships.
+
+Deliberately strict: an unknown variable is an error, so a typo in a template that the
+project has overridden is reported instead of leaking ``{{...}}`` into generated files.
+"""
+
+import re
+
+_VARIABLE = re.compile(r"\{\{\s*([A-Za-z_][\w.]*)\s*\}\}")
+
+
+class TemplateError(ValueError):
+    """The template uses a variable that was not provided."""
+
+
+def render(text: str, variables: dict[str, str]) -> str:
+    unknown = sorted({name for name in _VARIABLE.findall(text) if name not in variables})
+    if unknown:
+        known = ", ".join(sorted(variables))
+        raise TemplateError(
+            f"Unknown template variable(s): {', '.join(unknown)}. Available: {known}."
+        )
+    return _VARIABLE.sub(lambda m: variables[m.group(1)], text)

project_kit/workflow.py

@@ -0,0 +1,168 @@
+""".project-kit/workflow.yml: the ordered phases of the project-definition flow.
+
+Modelled on Spec Kit's ``workflow.yml``: a list of steps, each one with an optional review
+gate. The skills and ``project-kit status`` read it to know what comes next, and
+``project-kit approve`` uses it to refuse a gate while an earlier enabled gate is still open.
+"""
+
+from dataclasses import dataclass, field
+from importlib.resources import files
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from project_kit.config import PROJECT_DIR
+from project_kit.state import PHASES, State
+
+SCHEMA_VERSION = "1.0"
+_STEP_KEYS = {"id", "title", "skill", "gate", "enabled", "produces"}
+
+
+class WorkflowError(ValueError):
+    """The workflow file is missing, unreadable or invalid."""
+
+
+def workflow_path(root: Path) -> Path:
+    return root / PROJECT_DIR / "workflow.yml"
+
+
+@dataclass(frozen=True)
+class Step:
+    id: str
+    title: str
+    skill: str
+    gate: bool = True
+    enabled: bool = True
+    produces: tuple[str, ...] = ()
+
+
+@dataclass
+class Workflow:
+    steps: list[Step] = field(default_factory=list)
+
+    def enabled_steps(self) -> list[Step]:
+        return [s for s in self.steps if s.enabled]
+
+    def open_gates_before(self, phase: str, state: State) -> list[Step]:
+        """Enabled steps with a gate, earlier than ``phase``, that nobody has approved yet."""
+        later = PHASES.index(phase)
+        return [
+            s
+            for s in self.enabled_steps()
+            if s.gate and PHASES.index(s.id) < later and not state.is_approved(s.id)
+        ]
+
+    def next_step(self, state: State) -> Step | None:
+        """First enabled step that is not done. ``init`` is done once the project exists."""
+        for step in self.enabled_steps():
+            if step.id != "init" and not state.is_approved(step.id):
+                return step
+        return None
+
+
+def _flag(raw: dict[str, Any], key: str, where: str, problems: list[str]) -> bool:
+    value = raw.get(key, True)
+    if not isinstance(value, bool):
+        problems.append(f"{where}.{key} must be true or false")
+        return True
+    return value
+
+
+def parse_workflow(text: str) -> Workflow:
+    try:
+        data = yaml.safe_load(text)
+    except yaml.YAMLError as exc:
+        raise WorkflowError(f"workflow.yml is not valid YAML: {exc}") from exc
+    if not isinstance(data, dict):
+        raise WorkflowError("workflow.yml must contain a mapping")
+    if str(data.get("schema_version")) != SCHEMA_VERSION:
+        raise WorkflowError(f"Unsupported workflow.yml schema_version; expected {SCHEMA_VERSION!r}")
+    raw_steps = data.get("steps")
+    if not isinstance(raw_steps, list) or not raw_steps:
+        raise WorkflowError("workflow.yml needs a non-empty `steps` list")
+
+    problems: list[str] = []
+    steps: list[Step] = []
+    for n, raw in enumerate(raw_steps, 1):
+        where = f"steps[{n}]"
+        if not isinstance(raw, dict):
+            problems.append(f"{where} must be a mapping")
+            continue
+        unknown = set(raw) - _STEP_KEYS
+        if unknown:
+            problems.append(f"{where} has unknown key(s): {', '.join(sorted(map(str, unknown)))}")
+        step_id = raw.get("id")
+        if step_id not in PHASES:
+            problems.append(f"{where}.id must be one of {', '.join(PHASES)}, got {step_id!r}")
+            continue
+        produces = raw.get("produces") or []
+        if not isinstance(produces, list) or not all(isinstance(p, str) for p in produces):
+            problems.append(f"{where}.produces must be a list of paths")
+            produces = []
+        title, skill = raw.get("title"), raw.get("skill")
+        for key, value in (("title", title), ("skill", skill)):
+            if not isinstance(value, str) or not value.strip():
+                problems.append(f"{where}.{key} must be a non-empty string")
+        steps.append(
+            Step(
+                id=step_id,
+                title=title if isinstance(title, str) else "",
+                skill=skill if isinstance(skill, str) else "",
+                gate=_flag(raw, "gate", where, problems),
+                enabled=_flag(raw, "enabled", where, problems),
+                produces=tuple(produces),
+            )
+        )
+
+    ids = [s.id for s in steps]
+    if len(set(ids)) != len(ids):
+        problems.append("steps must not repeat an id")
+    if [i for i in PHASES if i in ids] != ids:
+        problems.append(f"steps must follow this order: {', '.join(PHASES)}")
+    if problems:
+        raise WorkflowError("Invalid workflow.yml: " + "; ".join(problems))
+    return Workflow(steps)
+
+
+def default_workflow() -> Workflow:
+    text = (files("project_kit") / "assets" / "project" / "workflow.yml").read_text("utf-8")
+    return parse_workflow(text)
+
+
+def load_workflow(root: Path) -> Workflow:
+    """The project's workflow, or the shipped one for projects created before it existed."""
+    path = workflow_path(root)
+    if not path.exists():
+        return default_workflow()
+    return parse_workflow(path.read_text(encoding="utf-8"))
+
+
+def step_marks(workflow: Workflow, state: State) -> list[tuple[Step, str, str]]:
+    """Each step with its mark (``x`` done, ``>`` next, ``-`` skipped, blank pending) and note."""
+    next_step = workflow.next_step(state)
+    marks = []
+    for step in workflow.steps:
+        if not step.enabled:
+            mark, note = "-", "skipped (disabled in workflow.yml)"
+        elif step.id == "init" or state.is_approved(step.id):
+            mark, note = "x", "done"
+        elif step is next_step:
+            mark, note = ">", "next"
+        else:
+            mark, note = " ", "pending"
+        marks.append((step, mark, note))
+    return marks
+
+
+def render_status(workflow: Workflow, state: State, project_name: str) -> str:
+    next_step = workflow.next_step(state)
+    lines = [f"Project: {project_name}", ""]
+    for step, mark, note in step_marks(workflow, state):
+        lines.append(f"  [{mark}] {step.id:<10} /{step.skill:<12} {note}")
+    lines.append("")
+    if next_step is None:
+        lines.append("Every enabled phase is done.")
+    else:
+        lines.append(f"Next: /{next_step.skill}: {next_step.title}")
+    return "\n".join(lines)

project_kit_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: project-kit-cli
+Version: 0.1.0
+Summary: Project definition and dev-workflow kit that hands off to Spec Kit
+Keywords: project-management,spec-kit,claude-code,workflow,github
+Author: Miguel Tomás
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Requires-Dist: pyyaml>=6.0.3
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/miguelmatg/project-kit
+Project-URL: Issues, https://github.com/miguelmatg/project-kit/issues
+Description-Content-Type: text/markdown
+
+# project-kit
+
+Herramienta para el **antes** de un proyecto: definirlo, planificarlo, decidir su
+arquitectura y montar su flujo de desarrollo y gestión (GitHub primero, GitLab después).
+Al terminar entrega el relevo a [Spec Kit](https://github.com/github/spec-kit), que define e
+implementa cada spec.
+
+> Estado: diseño y esqueleto del paquete (v0.1 en desarrollo). Ver [`docs/design.md`](docs/design.md).
+
+## Instalación y uso
+
+Requisitos: [uv](https://docs.astral.sh/uv/), `git`, y [`gh`](https://cli.github.com/) con
+sesión iniciada y los scopes `repo` y `project` (`gh auth refresh -s project`) para publicar en
+GitHub. [Claude Code](https://claude.com/claude-code) es el agente que guía las fases.
+
+```
+# Instalar (ahora, desde un clon; cuando se publique será `uv tool install project-kit-cli`; el comando es `project-kit`)
+uv tool install --editable <ruta-a-este-clon>
+
+# En el repositorio del proyecto (puede estar vacío)
+project-kit doctor     # comprueba las herramientas
+project-kit init       # instala skills y plantillas; pregunta si la IA firma commits y si abrir Claude
+project-kit help       # guía visual del flujo y los comandos (también: `project-kit` a secas)
+```
+
+`init` copia los ficheros y, al terminar, muestra los agentes de IA soportados (hoy solo Claude
+Code) y ofrece abrirlo en esa misma terminal ya con **`/pk-start`** (Intro acepta). Se puede
+evitar con `--agent none`; sin terminal no pregunta ni lanza nada, y dentro de Claude Code no
+abre otro. Si lo prefieres, ábrelo tú y ejecuta `/pk-start`. Pregunta si quieres **solo
+inicializar** o **empezar a definir el proyecto**, y al terminar cada fase ofrece continuar o
+parar. `project-kit status` muestra en qué fase estás y cuál toca.
+
+| Fase | Skill | Qué hace | Salida |
+|---|---|---|---|
+| 0 | `/pk-start` | Comprueba el entorno y elige: solo inicializar o empezar | `.project-kit/` |
+| 1 | `/pk-discover` | Entrevista sobre qué es el proyecto | `docs/project/brief.md` |
+| 2 | `/pk-decide` | Guía las decisiones de stack y arquitectura | `docs/adr/*.md` |
+| 3 | `/pk-workflow` | Acuerda el flujo de trabajo del equipo | `docs/development-workflow.md` |
+| 4 | `/pk-plan` | Deriva fases, épicas y backlog | `roadmap.md`, `backlog.json` |
+| 5 | `/pk-provision` | Crea milestones, ramas, Project e issues | GitHub |
+| 6 | `/pk-handoff` | Relevo a Spec Kit (una spec por issue) | `constitution-input.md` |
+
+Cada fase termina con una aprobación (`project-kit approve <fase>`) y puede rellenarse a mano
+a partir de las plantillas de `.project-kit/templates/`. Las fases se listan en
+`.project-kit/workflow.yml`, con el mismo estilo que el de Spec Kit; para un proyecto pequeño se
+desactiva una con `enabled: false`.
+
+## Documentación
+
+- [Diseño](docs/design.md): alcance, fases, proveedor, relevo a Spec Kit, decisiones abiertas.
+- [Publicación](docs/publishing.md): qué hace falta para `uv tool install project-kit-cli` público.
+- [Esquema de `backlog.json`](docs/backlog-schema.md): formato del backlog y reglas de validación.
+- [Relevo a Spec Kit](docs/handoff.md): qué genera `handoff`, cómo instala Spec Kit y qué viene después.
+- [Provisionado en GitHub](docs/provisioning.md): qué crea `provision`, idempotencia y protección de ramas.
+- [Referencia: playbook del flujo](docs/references/template-repo-playbook.md): receta de origen
+  (extraída de otro proyecto).
+
+## Licencia y contribuciones
+
+MIT ([`LICENSE`](LICENSE)). Las issues con ideas y mejoras son bienvenidas; el código lo
+desarrolla solo su autor y las pull requests están desactivadas ([`CONTRIBUTING.md`](CONTRIBUTING.md)).
+
+## Ramas
+
+`main` (estable), `release` (pruebas) y `develop` (desarrollo). Todo entra por PR.
+
+## Desarrollo
+
+Requiere [uv](https://docs.astral.sh/uv/).
+
+```
+uv sync                 # entorno y dependencias
+uv run project-kit --version
+uv run pytest           # tests
+uv run ruff check .     # lint
+uv run ruff format .    # formato
+```

project_kit_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,49 @@
+project_kit/__init__.py,sha256=rfqHzTyFKfQC37a8Drkf3RPB3g_MFIdwPohAC_bEIN8,308
+project_kit/__main__.py,sha256=30-4ifzqERnbwzERDfR8OIvPTAnCa1p4cRLKqJnXdR0,63
+project_kit/agents.py,sha256=LSbperuz7qfNRPeQfu7e3DhjQ2KEJ4f7D5s6s8xvDkw,2575
+project_kit/ai_attribution.py,sha256=SYmYUxNdwEFj0jL2ZIXvLCRfNM0Y6dBzT5N0yZn_BZU,2848
+project_kit/approval.py,sha256=FNC40ZH_CslKSiGnoakPkkQH3YuQg2smny_YDnr6vW4,1490
+project_kit/assets/hooks/commit-msg,sha256=hXK6LP8jC4bxq8AkfktQ6Ff65OEnAs_94fL9r1BZ8aU,573
+project_kit/assets/project/workflow.yml,sha256=XVxUIuLAyVqs170lbseAXX6YiMdCao_udJmXx1F_tLM,1892
+project_kit/assets/skills/pk-decide/SKILL.md,sha256=bXE7_fdKxs4pHC5Nsf_HelwGXKh6hlyG4-6HZwZt5TU,3572
+project_kit/assets/skills/pk-discover/SKILL.md,sha256=ziwlpu5S_o1UG8wajV4BhNfrJi1scN_H1EFSkQvR_2o,3454
+project_kit/assets/skills/pk-handoff/SKILL.md,sha256=uoxd_mST1OGDMRchTzQ7U9eEcF3O3ntsVuRk0k8CnrA,2613
+project_kit/assets/skills/pk-plan/SKILL.md,sha256=9lRB97dEMtOnlxXjBrY-CrgaKUcRASpdvs-5rlP2qws,3174
+project_kit/assets/skills/pk-provision/SKILL.md,sha256=HQgJusTvK41lhhtmk2tLDcvb7szPWzvKbw0CDA72IlU,2457
+project_kit/assets/skills/pk-start/SKILL.md,sha256=5PrjdfdxlWwkjqV4LQS65bhDJiRiF5UPEz3LeaNKgd8,2852
+project_kit/assets/skills/pk-workflow/SKILL.md,sha256=PO8IYLCcvzwlfGBobCKCbj7P7-wvMau0eF8QbkEyIzE,2654
+project_kit/assets/templates/adr.md,sha256=akh47VtHesUwu04xqWuF0lMxtFqX_la2FUNiJdOdF5A,760
+project_kit/assets/templates/backlog.example.json,sha256=J5ccoKNq5oiTkn6BwELOUDybsbvtUnhVrTy-N4Ti8IE,1745
+project_kit/assets/templates/brief.md,sha256=acTirEJx_PzuYiXjscG3dh_Ca27KlL3UFxHj6X6I5_o,1502
+project_kit/assets/templates/constitution-input.md,sha256=UzrkT4YvnA-tIfOZycwIp085ferK-pw47GZQOI8ooPk,3968
+project_kit/assets/templates/development-workflow.md,sha256=7Y7mknEvGQ2RZMTBdkd2-m24veP3yTBArXCzttwYIhA,1397
+project_kit/assets/templates/github/ISSUE_TEMPLATE/adr.yml,sha256=QZkRGgOR84jwH1oEtqf01J97Im97Hft9GOVUNG0Tzwk,459
+project_kit/assets/templates/github/ISSUE_TEMPLATE/bug.yml,sha256=V4wW0mPYh7Nck9zVe1cg7I8l0iKK8hJTk_aTc6tRoyI,530
+project_kit/assets/templates/github/ISSUE_TEMPLATE/config.yml,sha256=HxA8ap3QfNE6mm8XrOa4E_R3R-uct-AEiMsgc8qvkbs,28
+project_kit/assets/templates/github/ISSUE_TEMPLATE/epic.yml,sha256=CV_bMgSimkG0CyD4IAwf7VTJpC_vyJrX3yhnp7jW0cw,309
+project_kit/assets/templates/github/ISSUE_TEMPLATE/feature.yml,sha256=m-IT6NG7AESFuBr9B51mFmERS20Kd_jZG0Jl19JuH_s,475
+project_kit/assets/templates/github/pull_request_template.md,sha256=VFVxbuFFVkYxfXi6R8j_v1fRhEbKEYUBjPmE20q3QAc,394
+project_kit/assets/templates/interview.md,sha256=iQ74Ml5NkwAoFYsjiaFSuua16kxeqQN_s091-gXDm4E,3612
+project_kit/backlog.py,sha256=sLY1TWynro9q9Nb3G1i2_KIwwJm4-T6PkpGRcw8vGFE,11247
+project_kit/cli.py,sha256=NbB3WOO1IjDjuR-nzDkTVgMOnNJputi8SPWqFwzFkQI,9933
+project_kit/config.py,sha256=PP222aKodd8Di1ShDxygJDRQ-JWH9BcN2hOzQHkTwxQ,4817
+project_kit/doctor.py,sha256=qZ5GB_NJ_2BHvLwZmzr94XRh-tAC2W6b6vVv1qlyiUY,5790
+project_kit/fsutil.py,sha256=MoocEm8qAvGw4HfAkQzWmwxEp6fId55dkQmi62j9n7c,951
+project_kit/gh.py,sha256=u-PjjpCrgbHitr0tU-s2f7ntRAMk2YKldNDz-vhennw,5491
+project_kit/handoff.py,sha256=289o1NUpRtCssvFU9KqnUmHCazwlnQ6zO0-xyjL4xPg,12490
+project_kit/help.py,sha256=Y8e126puyP69St0t_7jz1gLYTC8_FLREti5ZgAnSpzw,5793
+project_kit/installer.py,sha256=gYu-naIWu7X-PSBXl38m4RB4HMMmy_GsZLCnQU7wAao,3767
+project_kit/labels.py,sha256=I5l_g7QRJWlzrZdoQWDuBM4hsn7HOeVn0fX1P8GfI_Y,764
+project_kit/project_choice.py,sha256=D7yBF3VLQfQLc2KUQg4ubXZyeS06ygjgCelkOWu3_EM,4663
+project_kit/providers/__init__.py,sha256=iV97GHRPiMZJq0w6j0lRV4FcYToM9m_5ccMioagdAT0,85
+project_kit/providers/github.py,sha256=0ZBDqxWkWF1JTMnQ9qV6ivvEpMDmxwhW56CGP-NS7ck,12793
+project_kit/provision.py,sha256=qecVdcgAGIJVNw7QuOfVXXzIqmaQmzMj19-aOpy6nWI,9651
+project_kit/provision_issues.py,sha256=rr2wq5n-rFPNTo2okppW1L-bzRV8dbhQjyxEPX8OGEQ,14449
+project_kit/state.py,sha256=S9d_2iPQuSi0hi2gdOwHT8zOSOlyNejhOjafJwbyFHU,4003
+project_kit/templating.py,sha256=BV3e51DktlUxOtIcahp2iq8X0f63MfxZktFjh6Pwnpw,826
+project_kit/workflow.py,sha256=C6PD-nTNIrzznn2aJ0L1qlGTnqu9ZC5dz0jFfKGNL00,6204
+project_kit_cli-0.1.0.dist-info/licenses/LICENSE,sha256=dFazNRGw47ZuUFnKCZRvdgbjpEH2aO--gWslO1Ck3Us,1070
+project_kit_cli-0.1.0.dist-info/WHEEL,sha256=9IUYslYuG_asT4WlWvfk_K76nveuLvSTKDoLeL0cV-Q,80
+project_kit_cli-0.1.0.dist-info/entry_points.txt,sha256=HtNObc7MmuDfwtN4c9mktht-Sri29HVzEg3DSjtj9cE,54
+project_kit_cli-0.1.0.dist-info/METADATA,sha256=uLIQ20pbse9sKYHzpcH5Vt33M0UFsFeHerk4d1YiiuQ,4708
+project_kit_cli-0.1.0.dist-info/RECORD,,

project_kit_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.1
+Root-Is-Purelib: true
+Tag: py3-none-any

project_kit_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+project-kit = project_kit.cli:main
+

project_kit_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Miguel Tomás
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.