devague 0.3.2__py3-none-any.whl

devague/cli/_errors.py

@@ -0,0 +1,39 @@
+"""DevagueError and exit-code policy.
+
+Every failure inside devague raises :class:`DevagueError`. The top-level
+``main()`` catches it, formats via :mod:`devague.cli._output`, and exits with
+:attr:`DevagueError.code`. This centralises the exit-code policy and
+guarantees no Python traceback leaks to stderr.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# Exit-code policy:
+#   0  = success
+#   1  = user-input error (bad flag, missing required arg, unknown path)
+#   2  = environment / setup error (tool not installed, file unreadable)
+#   3+ = reserved for future categorisation
+EXIT_SUCCESS = 0
+EXIT_USER_ERROR = 1
+EXIT_ENV_ERROR = 2
+
+
+@dataclass
+class DevagueError(Exception):
+    """Structured error raised within devague; carries a remediation hint."""
+
+    code: int
+    message: str
+    remediation: str = ""
+
+    def __post_init__(self) -> None:
+        super().__init__(self.message)
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "code": self.code,
+            "message": self.message,
+            "remediation": self.remediation,
+        }

devague/cli/_frames.py

@@ -0,0 +1,29 @@
+"""Resolve the target frame for a move: explicit --frame, else the current frame."""
+
+from __future__ import annotations
+
+from devague import store
+from devague.cli._errors import EXIT_USER_ERROR, DevagueError
+from devague.frame import Frame
+
+
+def resolve(slug: str | None) -> Frame:
+    slug = slug or store.current_slug()
+    if not slug:
+        raise DevagueError(
+            EXIT_USER_ERROR,
+            "no frame selected",
+            "run 'devague new \"<announcement>\"' or pass --frame <slug>",
+        )
+    try:
+        return store.load(slug)
+    except ValueError as exc:
+        raise DevagueError(
+            EXIT_USER_ERROR,
+            f"invalid frame slug: {slug!r}",
+            "slugs are lowercase letters, digits, and hyphens — no path separators",
+        ) from exc
+    except FileNotFoundError:
+        raise DevagueError(
+            EXIT_USER_ERROR, f"no such frame: {slug}", "run 'devague list' to see frames"
+        ) from None

devague/cli/_output.py

@@ -0,0 +1,45 @@
+"""stdout / stderr helpers with a strict split.
+
+Rule: **results go to stdout, diagnostics and errors go to stderr.** Agents
+parsing devague output can rely on this invariant. JSON mode routes structured
+payloads to the same streams — it never mixes them.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any, TextIO
+
+from devague.cli._errors import DevagueError
+
+
+def emit_result(data: Any, *, json_mode: bool, stream: TextIO | None = None) -> None:
+    """Write a command result to stdout (text or JSON), newline-terminated."""
+    s = stream if stream is not None else sys.stdout
+    if json_mode:
+        json.dump(data, s, ensure_ascii=False)
+        s.write("\n")
+        return
+    text = data if isinstance(data, str) else str(data)
+    s.write(text)
+    if not text.endswith("\n"):
+        s.write("\n")
+
+
+def emit_error(err: DevagueError, *, json_mode: bool, stream: TextIO | None = None) -> None:
+    """Write a :class:`DevagueError` to stderr (text or JSON)."""
+    s = stream if stream is not None else sys.stderr
+    if json_mode:
+        json.dump(err.to_dict(), s, ensure_ascii=False)
+        s.write("\n")
+        return
+    s.write(f"error: {err.message}\n")
+    if err.remediation:
+        s.write(f"hint: {err.remediation}\n")
+
+
+def emit_diagnostic(message: str, *, stream: TextIO | None = None) -> None:
+    """Write a human diagnostic (progress, summary) to stderr."""
+    s = stream if stream is not None else sys.stderr
+    s.write(message if message.endswith("\n") else message + "\n")

devague/convergence.py

@@ -0,0 +1,72 @@
+"""The convergence gate: is a frame solid enough to export a buildable spec?"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from devague.frame import SPEC_AFFECTING_KINDS, Frame
+
+
+@dataclass
+class ConvergenceResult:
+    passed: bool
+    missing: list[str] = field(default_factory=list)
+
+
+def _missing_required_kinds(confirmed_kinds: set[str]) -> list[str]:
+    """Required confirmed claims for an honest announcement frame."""
+    missing = [
+        f"missing confirmed '{required}' claim"
+        for required in ("announcement", "audience", "after_state")
+        if required not in confirmed_kinds
+    ]
+    if "before_state" not in confirmed_kinds and "why_it_matters" not in confirmed_kinds:
+        missing.append("missing 'before_state' or 'why_it_matters' claim")
+    if "boundary" not in confirmed_kinds:
+        missing.append("missing a 'boundary' / non-goal claim")
+    if "success_signal" not in confirmed_kinds:
+        missing.append("missing a 'success_signal' claim")
+    return missing
+
+
+def _missing_claim_resolution(frame: Frame, confirmed: list) -> list[str]:
+    """No spec-affecting claim left proposed; each confirmed one is pressure-tested."""
+    missing = [
+        f"claim {c.id} still proposed (confirm or reject it)"
+        for c in frame.claims
+        if c.kind in SPEC_AFFECTING_KINDS and c.status == "proposed"
+    ]
+    missing += [
+        f"claim {c.id} has no confirmed honesty condition"
+        for c in confirmed
+        if c.kind in SPEC_AFFECTING_KINDS
+        and not any(h.status == "confirmed" for h in c.honesty_conditions)
+    ]
+    return missing
+
+
+def _missing_open_uncertainty(frame: Frame) -> list[str]:
+    """No blocking vagueness or unresolved blocking hard question remains."""
+    missing = [
+        f"blocking vagueness {v.id} unresolved"
+        for v in frame.open_vagueness
+        if v.kind == "unknown_blocking"
+    ]
+    missing += [
+        f"blocking hard question {q.id} on {c.id} unresolved"
+        for c in frame.claims
+        for q in c.hard_questions
+        if q.blocking and not q.resolved
+    ]
+    return missing
+
+
+def evaluate(frame: Frame) -> ConvergenceResult:
+    confirmed = [c for c in frame.claims if c.status == "confirmed"]
+    confirmed_kinds = {c.kind for c in confirmed}
+    missing = (
+        _missing_required_kinds(confirmed_kinds)
+        + _missing_claim_resolution(frame, confirmed)
+        + _missing_open_uncertainty(frame)
+    )
+    return ConvergenceResult(passed=not missing, missing=missing)

devague/frame.py

@@ -0,0 +1,184 @@
+"""The Frame domain model — claims, honesty conditions, hard questions, vagueness.
+
+Pure data + transitions, no I/O. Persistence lives in :mod:`devague.store`.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from dataclasses import dataclass, field
+from typing import Optional
+
+CLAIM_KINDS = (
+    "announcement",
+    "audience",
+    "after_state",
+    "before_state",
+    "why_it_matters",
+    "boundary",
+    "success_signal",
+    "open_question",
+)
+SPEC_AFFECTING_KINDS = tuple(k for k in CLAIM_KINDS if k != "open_question")
+VAGUENESS_KINDS = (
+    "unknown_nonblocking",
+    "unknown_blocking",
+    "out_of_scope",
+    "follow_up",
+)
+CLAIM_STATUSES = ("proposed", "confirmed", "rejected")
+
+
+@dataclass
+class HonestyCondition:
+    id: str
+    text: str
+    status: str = "proposed"  # proposed | confirmed | rejected
+
+
+@dataclass
+class HardQuestion:
+    id: str
+    text: str
+    resolved: bool = False
+    blocking: bool = False
+
+
+@dataclass
+class Claim:
+    id: str
+    kind: str
+    text: str
+    origin: str = "user"  # user | llm
+    status: str = "confirmed"  # proposed | confirmed | rejected
+    honesty_conditions: list[HonestyCondition] = field(default_factory=list)
+    hard_questions: list[HardQuestion] = field(default_factory=list)
+    links: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Vagueness:
+    id: str
+    text: str
+    kind: str
+    claim_id: Optional[str] = None
+
+
+@dataclass
+class Frame:
+    slug: str
+    title: str
+    status: str = "drafting"  # drafting | converged | exported
+    created: str = ""
+    updated: str = ""
+    claims: list[Claim] = field(default_factory=list)
+    open_vagueness: list[Vagueness] = field(default_factory=list)
+
+    @staticmethod
+    def _next(items: list, prefix: str) -> str:
+        n = 0
+        for it in items:
+            if it.id.startswith(prefix):
+                try:
+                    n = max(n, int(it.id[len(prefix) :]))
+                except ValueError:
+                    pass
+        return f"{prefix}{n + 1}"
+
+    def _all_honesty(self) -> list[HonestyCondition]:
+        return [h for c in self.claims for h in c.honesty_conditions]
+
+    def _all_hard_questions(self) -> list[HardQuestion]:
+        return [q for c in self.claims for q in c.hard_questions]
+
+    def add_claim(self, kind: str, text: str, origin: str = "user") -> Claim:
+        if kind not in CLAIM_KINDS:
+            raise ValueError(f"unknown claim kind: {kind}")
+        status = "proposed" if origin == "llm" else "confirmed"
+        claim = Claim(
+            id=self._next(self.claims, "c"),
+            kind=kind,
+            text=text,
+            origin=origin,
+            status=status,
+        )
+        self.claims.append(claim)
+        return claim
+
+    def find_claim(self, cid: str) -> Optional[Claim]:
+        return next((c for c in self.claims if c.id == cid), None)
+
+    def find_honesty(self, hid: str) -> Optional[HonestyCondition]:
+        return next((h for h in self._all_honesty() if h.id == hid), None)
+
+    def add_honesty(self, claim: Claim, text: str, origin: str = "llm") -> HonestyCondition:
+        status = "confirmed" if origin == "user" else "proposed"
+        h = HonestyCondition(
+            id=self._next(self._all_honesty(), "h"),
+            text=text,
+            status=status,
+        )
+        claim.honesty_conditions.append(h)
+        return h
+
+    def add_hard_question(self, claim: Claim, text: str, blocking: bool = False) -> HardQuestion:
+        q = HardQuestion(
+            id=self._next(self._all_hard_questions(), "q"),
+            text=text,
+            blocking=blocking,
+        )
+        claim.hard_questions.append(q)
+        return q
+
+    def add_vagueness(self, text: str, kind: str, claim_id: Optional[str] = None) -> Vagueness:
+        if kind not in VAGUENESS_KINDS:
+            raise ValueError(f"unknown vagueness kind: {kind}")
+        v = Vagueness(
+            id=self._next(self.open_vagueness, "v"),
+            text=text,
+            kind=kind,
+            claim_id=claim_id,
+        )
+        self.open_vagueness.append(v)
+        return v
+
+    def set_status(self, item_id: str, status: str) -> bool:
+        claim = self.find_claim(item_id)
+        if claim is not None:
+            claim.status = status
+            return True
+        honesty = self.find_honesty(item_id)
+        if honesty is not None:
+            honesty.status = status
+            return True
+        return False
+
+
+def to_dict(frame: Frame) -> dict:
+    return dataclasses.asdict(frame)
+
+
+def from_dict(d: dict) -> Frame:
+    claims = [
+        Claim(
+            id=c["id"],
+            kind=c["kind"],
+            text=c["text"],
+            origin=c.get("origin", "user"),
+            status=c.get("status", "confirmed"),
+            honesty_conditions=[HonestyCondition(**h) for h in c.get("honesty_conditions", [])],
+            hard_questions=[HardQuestion(**q) for q in c.get("hard_questions", [])],
+            links=list(c.get("links", [])),
+        )
+        for c in d.get("claims", [])
+    ]
+    vag = [Vagueness(**v) for v in d.get("open_vagueness", [])]
+    return Frame(
+        slug=d["slug"],
+        title=d["title"],
+        status=d.get("status", "drafting"),
+        created=d.get("created", ""),
+        updated=d.get("updated", ""),
+        claims=claims,
+        open_vagueness=vag,
+    )

devague/render/__init__.py

@@ -0,0 +1,39 @@
+"""Renderer registry: frame/spec → text, selected by --format.
+
+New output modalities (NotebookLM, HTML, user stories) register here.
+"""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from devague.cli._errors import EXIT_USER_ERROR, DevagueError
+from devague.frame import Frame
+
+_REGISTRY: dict[str, Callable[[Frame], str]] = {}
+
+
+def register(name: str, fn: Callable[[Frame], str]) -> None:
+    _REGISTRY[name] = fn
+
+
+def formats() -> list[str]:
+    return sorted(_REGISTRY)
+
+
+def render(frame: Frame, fmt: str) -> str:
+    if fmt not in _REGISTRY:
+        raise DevagueError(
+            EXIT_USER_ERROR,
+            f"unknown format: {fmt}",
+            f"available formats: {', '.join(formats())}",
+        )
+    return _REGISTRY[fmt](frame)
+
+
+# Register the built-in renderers (import-time side effect).
+from devague.render import frame_md as _frame_md  # noqa: E402
+from devague.render import spec_md as _spec_md  # noqa: E402
+
+register("frame-md", _frame_md.render_frame)
+register("spec-md", _spec_md.render_spec)

devague/render/frame_md.py

@@ -0,0 +1,61 @@
+"""Renderer: the Announcement Frame as markdown."""
+
+from __future__ import annotations
+
+from devague.frame import Frame
+
+_SECTIONS = [
+    ("announcement", "Announcement"),
+    ("audience", "Audience"),
+    ("after_state", "After-state experience"),
+    ("why_it_matters", "Why it matters"),
+    ("before_state", "Before-state pain"),
+    ("boundary", "Boundaries / non-goals"),
+    ("success_signal", "Success signals"),
+    ("open_question", "Open questions"),
+]
+
+
+def _claim_lines(claim) -> list[str]:
+    mark = "" if claim.status == "confirmed" else f" _({claim.status})_"
+    lines = [f"- {claim.text}{mark}"]
+    for h in claim.honesty_conditions:
+        hm = "" if h.status == "confirmed" else f" _({h.status})_"
+        lines.append(f"  - honesty: {h.text}{hm}")
+    for q in claim.hard_questions:
+        qm = "blocking" if q.blocking else "open"
+        lines.append(f"  - Q ({qm}): {q.text}")
+    return lines
+
+
+def _section_lines(frame: Frame, kind: str, heading: str) -> list[str]:
+    claims = [c for c in frame.claims if c.kind == kind and c.status != "rejected"]
+    if not claims:
+        return []
+    lines = [f"## {heading}"]
+    for c in claims:
+        lines.extend(_claim_lines(c))
+    lines.append("")
+    return lines
+
+
+def _vagueness_lines(frame: Frame) -> list[str]:
+    if not frame.open_vagueness:
+        return []
+    lines = ["## Open vagueness"]
+    lines.extend(f"- [{v.kind}] {v.text}" for v in frame.open_vagueness)
+    lines.append("")
+    return lines
+
+
+def render_frame(frame: Frame) -> str:
+    out = [
+        f"# Announcement Frame — {frame.title}",
+        "",
+        f"_slug: {frame.slug} · status: {frame.status}_",
+        "",
+    ]
+    for kind, heading in _SECTIONS:
+        out.extend(_section_lines(frame, kind, heading))
+    out.extend(_vagueness_lines(frame))
+    return "\n".join(out).rstrip() + "\n"

devague/render/spec_md.py

@@ -0,0 +1,48 @@
+"""Renderer: the buildable spec as markdown, derived from a converged frame."""
+
+from __future__ import annotations
+
+from devague.frame import Frame
+
+
+def _texts(frame: Frame, kind: str) -> list[str]:
+    return [c.text for c in frame.claims if c.kind == kind and c.status == "confirmed"]
+
+
+def render_spec(frame: Frame) -> str:
+    out: list[str] = [f"# {frame.title}", ""]
+    ann = _texts(frame, "announcement")
+    if ann:
+        out += ["> " + ann[0], ""]
+    aud = _texts(frame, "audience")
+    if aud:
+        out += ["## Audience", *[f"- {t}" for t in aud], ""]
+    out += ["## Before → After", ""]
+    for t in _texts(frame, "before_state"):
+        out.append(f"- Before: {t}")
+    for t in _texts(frame, "after_state"):
+        out.append(f"- After: {t}")
+    out.append("")
+    why = _texts(frame, "why_it_matters")
+    if why:
+        out += ["## Why it matters", *[f"- {t}" for t in why], ""]
+    reqs = [h.text for c in frame.claims for h in c.honesty_conditions if h.status == "confirmed"]
+    if reqs:
+        out += ["## Requirements / honesty conditions", *[f"- {t}" for t in reqs], ""]
+    succ = _texts(frame, "success_signal")
+    if succ:
+        out += ["## Success signals", *[f"- {t}" for t in succ], ""]
+    bnd = _texts(frame, "boundary")
+    if bnd:
+        out += ["## Non-goals", *[f"- {t}" for t in bnd], ""]
+    hqs = [q for c in frame.claims for q in c.hard_questions]
+    if hqs:
+        out += [
+            "## Hard questions",
+            *[f"- {q.text}" + (" (blocking)" if q.blocking else "") for q in hqs],
+            "",
+        ]
+    follow = [v.text for v in frame.open_vagueness if v.kind in ("follow_up", "out_of_scope")]
+    if follow:
+        out += ["## Open / follow-up", *[f"- {t}" for t in follow], ""]
+    return "\n".join(out).rstrip() + "\n"

devague/store.py

@@ -0,0 +1,88 @@
+"""Frame persistence: JSON under .devague/frames/, plus a current-frame pointer.
+
+Paths are cwd-relative so the frames live in the repo being specced.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+from pathlib import Path
+
+from devague.frame import Frame, from_dict, to_dict
+
+FRAMES_DIR = Path(".devague/frames")
+CURRENT = Path(".devague/current")
+
+# A safe slug is a bounded, lowercase, hyphen-separated token with no path
+# separators or `.` segments — so it can never escape FRAMES_DIR / SPECS_DIR.
+_SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,79}$")
+
+
+def slugify(title: str) -> str:
+    s = re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-")
+    s = s[:50].strip("-")
+    return s or "frame"
+
+
+def validate_slug(slug: str) -> str:
+    """Return ``slug`` if it is filesystem-safe, else raise ``ValueError``.
+
+    Guards every path built from a slug (``--frame``, ``.devague/current``, a
+    persisted ``frame.slug``) against path traversal and absolute paths.
+    """
+    if not _SLUG_RE.fullmatch(slug or ""):
+        raise ValueError(f"invalid frame slug: {slug!r}")
+    return slug
+
+
+def _now() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+
+def path_for(slug: str) -> Path:
+    return FRAMES_DIR / f"{validate_slug(slug)}.json"
+
+
+def unique_slug(base: str) -> str:
+    """Return ``base`` if free, else the first ``base-N`` (N>=2) that is unused."""
+    base = base or "frame"
+    if not path_for(base).exists():
+        return base
+    n = 2
+    while path_for(f"{base}-{n}").exists():
+        n += 1
+    return f"{base}-{n}"
+
+
+def save(frame: Frame) -> Path:
+    FRAMES_DIR.mkdir(parents=True, exist_ok=True)
+    frame.updated = _now()
+    if not frame.created:
+        frame.created = frame.updated
+    p = path_for(frame.slug)
+    p.write_text(json.dumps(to_dict(frame), indent=2) + "\n", encoding="utf-8")
+    CURRENT.write_text(frame.slug + "\n", encoding="utf-8")
+    return p
+
+
+def load(slug: str) -> Frame:
+    p = path_for(slug)
+    if not p.exists():
+        raise FileNotFoundError(slug)
+    frame = from_dict(json.loads(p.read_text(encoding="utf-8")))
+    validate_slug(frame.slug)  # reject a tampered file whose internal slug escapes
+    return frame
+
+
+def list_slugs() -> list[str]:
+    if not FRAMES_DIR.exists():
+        return []
+    return sorted(p.stem for p in FRAMES_DIR.glob("*.json"))
+
+
+def current_slug() -> str | None:
+    if CURRENT.exists():
+        return CURRENT.read_text(encoding="utf-8").strip() or None
+    return None

devague-0.3.2.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: devague
+Version: 0.3.2
+Summary: devague — turns a vague feature idea into a buildable spec by working backwards.
+Project-URL: Homepage, https://github.com/agentculture/devague
+Project-URL: Issues, https://github.com/agentculture/devague/issues
+Author: AgentCulture
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# devague
+
+An AgentCulture agent that turns a vague feature idea into a buildable spec by working backwards.
+
+Greenfield: the CLI scaffold (`devague learn` / `explain`) ships as honest
+"not yet implemented" stubs. See `CLAUDE.md` for project shape and commands.

devague-0.3.2.dist-info/RECORD

@@ -0,0 +1,30 @@
+devague/__init__.py,sha256=IKSTqWc8OquRgC2y9E0TTv5CtNH3d2r82D2gLZa6hOQ,372
+devague/__main__.py,sha256=wmTRpe3jqjUBqCm9NnpB2wO5V8U-gHJ5L7qBJMfCS_k,145
+devague/convergence.py,sha256=mY-rh9eyd0halOzyoWefGqXk9yFGU1_cHnSG_Pq6B7Q,2532
+devague/frame.py,sha256=jhBd3Sq2ChE2Ax_e-rlVavjSM1qvv-3R11hGPNPCc-g,5346
+devague/store.py,sha256=XQ56DZwTgC_UuvAfhUiIKY9vsoTTDRVWVJc2ihztab0,2519
+devague/cli/__init__.py,sha256=p5kdxD4IOBNuKVPOJOwF0-KxApfic-FLbPceOPN7my4,4370
+devague/cli/_errors.py,sha256=VxfMpU-ZFv_-oXnxTaYpsCpn7CheS4ppwp3mrrSZh0k,1108
+devague/cli/_frames.py,sha256=BMxgZftUeVs9gy2RTQ-1Jl1FJzpz6RJByF51qKffXU4,963
+devague/cli/_output.py,sha256=JTtXNyd2MfIp77eguICh5ybZm2Y9xriZkYLti2Z_LcE,1547
+devague/cli/_commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devague/cli/_commands/capture.py,sha256=lHlgVlAXt4MPP-SQJw5oRQ2u-A_UyATbpPWBZSMbSPQ,1234
+devague/cli/_commands/confirm.py,sha256=YoiqJvy4czbGGvSoMKzDaiyq2g4V_hprREiuTFLzyw0,1323
+devague/cli/_commands/converge.py,sha256=wIX9GkxIfb2h58UwBXJIE4H72Db6IYRC88e-9O5WL8I,1300
+devague/cli/_commands/explain.py,sha256=gGSbBmGOhnjaLYhLth0XWbzklVb3ilukbkf6HwtY7yI,1042
+devague/cli/_commands/export.py,sha256=lVWg-ZjCNogdFjBS85ckibOcWaGjydIAuo56ce3CMe8,1673
+devague/cli/_commands/interrogate.py,sha256=J0g9I-3P1fepK4NIkrP54iy7GisPvrb-H-IIs9y3QQQ,2919
+devague/cli/_commands/learn.py,sha256=u8-e6bmBd3_xZeM-MZ1JrLIf9NcoWCG2ej2dV85iW3w,3844
+devague/cli/_commands/list_frames.py,sha256=rzM6FU9SY_rwxPaGhG-G3EVhmI0LVVNl4UiDNMBOyDA,861
+devague/cli/_commands/new.py,sha256=wUgJeS-drCnhZ-LGpA2WXKsm70iN_cmltVloFsUMpX4,1257
+devague/cli/_commands/park.py,sha256=CvdrDFzFgBOitTb-9xgOcFGoFgZxxXmR9riCkhhvdrk,1183
+devague/cli/_commands/reject.py,sha256=pc051ZrCzfzBOGtJW9rLiBnSNSq8qir1g4KBrE9YikM,653
+devague/cli/_commands/show.py,sha256=vIXoUmbruT8EDI7FrER514TGfSq2k3qGxcOPtLlt1Ls,960
+devague/render/__init__.py,sha256=DosV7sVtrOmkYTGKFgH0oMQZtJ_XhJBj1g0n__ysYJY,1043
+devague/render/frame_md.py,sha256=_-9xOfd50XbPBmdQGZCDilFObTnFkmW0JIb9qzFgxMI,1861
+devague/render/spec_md.py,sha256=uSOGmhe-NpSg6592iFEu0iQyCfdF6nRtPiJ1llwF_3c,1801
+devague-0.3.2.dist-info/METADATA,sha256=YpJrnFpu73ujN_mkpm5JUcWHcE6O0mdJKjNer-2wiZc,900
+devague-0.3.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+devague-0.3.2.dist-info/entry_points.txt,sha256=M6Y_rebZwi29hI8d4nihXrv6j1gt-XNyFwXocwGUfLk,45
+devague-0.3.2.dist-info/licenses/LICENSE,sha256=wCcdPywGtFXx1P8N0j0eEDINSWfSjrIsU7ds1YZl-MA,1069
+devague-0.3.2.dist-info/RECORD,,

devague-0.3.2.dist-info/WHEEL

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

devague-0.3.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devague = devague.cli:main