project-kit-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{project_kit_cli-0.3.0 → project_kit_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: project-kit-cli
-Version: 0.3.0
+Version: 0.4.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
@@ -138,6 +138,7 @@ It never rewrites issues that already exist, and re-running it is always safe.
 | `pjkit backlog validate` | Validate `.project-kit/backlog.json` |
 | `pjkit provision [--dry-run] [--project X]` | Create milestones, branches, the Project and issues on GitHub |
 | `pjkit handoff [--install-speckit]` | Generate the Spec Kit constitution input |
+| `pjkit statusline [--install]` | One line for Claude Code's status bar: model, context, usage limits and the project phase |
 | `pjkit context [--dry-run]` | Write or refresh the project block in `CLAUDE.md` / `AGENTS.md` / `GEMINI.md` |
 | `pjkit skills list\|show\|mark` | Recommended third-party skills, their install command, and what the project decided |
 
@@ -155,6 +156,23 @@ writes the context file each one reads (`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`).
 between its markers is managed; the rest of the file is yours. Only Claude Code is started by
 `init`; for the others, open the agent and ask it to run the `pk-start` skill.
 
+## Status bar
+
+Claude Code can show a line of your choosing at the bottom of the screen. `pjkit statusline`
+fills it with the model, the context in use, the 5-hour and 7-day usage limits (Pro and Max
+plans) and where the project is in the flow:
+
+```
+[Opus · high] · ctx 23% · 5h 41% (↻ 17:00) · 7d 12% · ~$1.23 · fase: decide → /pk-decide
+```
+
+`init` asks whether you want it, and `pjkit statusline --install` sets it up in
+`.claude/settings.json` (`--remove` undoes it). It is never turned on without a yes. If you
+already have a status bar, yours is kept and runs first. It is one line: when the terminal is
+narrow, the cost goes first, then the 7-day limit, the effort and the context. The cost is an
+estimate at list price. More in
+[docs/statusline.md](https://github.com/miguelmatg/project-kit/blob/main/docs/statusline.md).
+
 ## GitLab
 
 `pjkit init --provider gitlab` makes `provision` use `glab`: phases become milestones, kind,

{project_kit_cli-0.3.0 → project_kit_cli-0.4.0}/README.md

@@ -118,6 +118,7 @@ It never rewrites issues that already exist, and re-running it is always safe.
 | `pjkit backlog validate` | Validate `.project-kit/backlog.json` |
 | `pjkit provision [--dry-run] [--project X]` | Create milestones, branches, the Project and issues on GitHub |
 | `pjkit handoff [--install-speckit]` | Generate the Spec Kit constitution input |
+| `pjkit statusline [--install]` | One line for Claude Code's status bar: model, context, usage limits and the project phase |
 | `pjkit context [--dry-run]` | Write or refresh the project block in `CLAUDE.md` / `AGENTS.md` / `GEMINI.md` |
 | `pjkit skills list\|show\|mark` | Recommended third-party skills, their install command, and what the project decided |
 
@@ -135,6 +136,23 @@ writes the context file each one reads (`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`).
 between its markers is managed; the rest of the file is yours. Only Claude Code is started by
 `init`; for the others, open the agent and ask it to run the `pk-start` skill.
 
+## Status bar
+
+Claude Code can show a line of your choosing at the bottom of the screen. `pjkit statusline`
+fills it with the model, the context in use, the 5-hour and 7-day usage limits (Pro and Max
+plans) and where the project is in the flow:
+
+```
+[Opus · high] · ctx 23% · 5h 41% (↻ 17:00) · 7d 12% · ~$1.23 · fase: decide → /pk-decide
+```
+
+`init` asks whether you want it, and `pjkit statusline --install` sets it up in
+`.claude/settings.json` (`--remove` undoes it). It is never turned on without a yes. If you
+already have a status bar, yours is kept and runs first. It is one line: when the terminal is
+narrow, the cost goes first, then the 7-day limit, the effort and the context. The cost is an
+estimate at list price. More in
+[docs/statusline.md](https://github.com/miguelmatg/project-kit/blob/main/docs/statusline.md).
+
 ## GitLab
 
 `pjkit init --provider gitlab` makes `provision` use `glab`: phases become milestones, kind,

{project_kit_cli-0.3.0 → project_kit_cli-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "project-kit-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "Project definition and dev-workflow kit that hands off to Spec Kit"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -31,7 +31,7 @@ Repository = "https://github.com/miguelmatg/project-kit"
 Issues = "https://github.com/miguelmatg/project-kit/issues"
 
 [project.scripts]
-pjkit = "project_kit.cli:main"
+pjkit = "project_kit.entry:main"
 
 [tool.uv.build-backend]
 module-name = "project_kit"

{project_kit_cli-0.3.0 → project_kit_cli-0.4.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "project-kit-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "Project definition and dev-workflow kit that hands off to Spec Kit"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -25,7 +25,7 @@ Repository = "https://github.com/miguelmatg/project-kit"
 Issues = "https://github.com/miguelmatg/project-kit/issues"
 
 [project.scripts]
-pjkit = "project_kit.cli:main"
+pjkit = "project_kit.entry:main"
 
 [tool.uv.build-backend]
 # The distribution is project-kit-cli (the name free on PyPI); the package keeps its name.

project_kit_cli-0.4.0/src/project_kit/__init__.py

@@ -0,0 +1,14 @@
+"""project-kit: define, plan and set up a project before handing off to Spec Kit."""
+
+
+def __getattr__(name: str) -> str:
+    """``__version__`` is looked up on first use: reading package metadata costs more than the
+    whole status line command, which runs at every update of the agent's status bar."""
+    if name == "__version__":
+        from importlib.metadata import PackageNotFoundError, version
+
+        try:
+            return version("project-kit-cli")
+        except PackageNotFoundError:  # running from a source tree that was never installed
+            return "0.0.0"
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{project_kit_cli-0.3.0 → project_kit_cli-0.4.0}/src/project_kit/assets/skills/pk-start/SKILL.md

@@ -28,7 +28,12 @@ now. Nothing is created in GitHub or GitLab here.
      `commit-msg` hook that strips the co-author trailer of any other assistant;
    - ask before running `git config core.hooksPath .githooks`, which switches the hook on for
      this clone. Each teammate runs that command once.
-4. **Ask how far to go now**, with a selection list (`AskUserQuestion`, see
+4. **Status bar (Claude Code only).** If `config.yml` lists `claude` and `pjkit doctor` shows
+   the status bar as not set up, ask with a selection list (**Yes, show it** / **No, thanks**)
+   whether to show the model, the usage limits and the project phase in the status bar. Only on
+   a yes run `pjkit statusline --install`; it keeps any status bar the user already has and
+   runs it first. Never set it up without that yes. `pjkit statusline --remove` undoes it.
+5. **Ask how far to go now**, with a selection list (`AskUserQuestion`, see
    `.project-kit/templates/interview.md`) and exactly these two options. Put B first with
    `(Recommended)` unless the user said they are in a hurry:
 
@@ -36,8 +41,8 @@ now. Nothing is created in GitHub or GitLab here.
    |--------|--------------|
    | **B. Start defining the project** | Continue now with the discovery interview |
    | **A. Only initialise** | Stop here. The user comes back later with `/pk-discover` |
-5. **If A:** run `pjkit status`, show it, and explain that `/pk-discover` is next. Done.
-6. **If B:** ask for a short description of the project in the user's own words, a few
+6. **If A:** run `pjkit status`, show it, and explain that `/pk-discover` is next. Done.
+7. **If B:** ask for a short description of the project in the user's own words, a few
    sentences, a pasted note or "nothing yet, ask me". Then follow the `pk-discover` skill
    (`.claude/skills/pk-discover/SKILL.md`) using that description as the starting point.
 

{project_kit_cli-0.3.0 → project_kit_cli-0.4.0}/src/project_kit/cli.py

@@ -17,6 +17,7 @@ from project_kit import (
     provision,
     provision_gitlab,
     skills,
+    statusline,
     upgrade,
 )
 from project_kit import (
@@ -84,6 +85,19 @@ def build_parser() -> argparse.ArgumentParser:
         "is attached)",
     )
 
+    init.add_argument(
+        "--statusline",
+        action=argparse.BooleanOptionalAction,
+        help="show model, usage limits and the project phase in Claude Code's status bar "
+        "(asked when omitted and a terminal is attached; never turned on without a yes)",
+    )
+
+    st = sub.add_parser(
+        "statusline",
+        help="one line for the agent's status bar (reads the agent's JSON on stdin)",
+    )
+    statusline.add_arguments(st)
+
     up = sub.add_parser(
         "upgrade",
         help="bring the skills and templates installed by init up to this version",
@@ -251,8 +265,29 @@ def _help() -> int:
     return 0
 
 
+def _offer_statusline(root: Path, requested: bool | None, *, fresh: bool) -> None:
+    """Set up Claude Code's status bar if the user says yes. Never without a yes.
+
+    ``requested`` is the flag; without it the question is asked only in a new project with a
+    terminal, so running ``init`` again does not ask what was already answered.
+    """
+    if "claude" not in load_config(root).agents or statusline.is_configured(root):
+        return
+    if requested is None:
+        if not (fresh and sys.stdin.isatty()):
+            return
+        before = statusline.existing_command(root)
+        keep = f" Your current bar ({before}) is kept and runs first." if before else ""
+        requested = _ask(
+            "Show the model, usage limits and the project phase in Claude Code's status bar?" + keep
+        )
+    if requested:
+        print(statusline.install(root).message)
+
+
 def _init(args: argparse.Namespace) -> int:
     root = Path.cwd()
+    fresh = not config_path(root).exists()
     choice = args.ai_coauthor
     if choice is None and sys.stdin.isatty() and not config_path(root).exists():
         remove = _ask("Remove AI assistants (Claude, Copilot...) as co-authors of commits and PRs?")
@@ -283,6 +318,7 @@ def _init(args: argparse.Namespace) -> int:
         print(f"pjkit init: {exc}", file=sys.stderr)
         return 1
     _print_init_report(report)
+    _offer_statusline(root, args.statusline, fresh=fresh)
     if not _offer_agent(root, args.agent, load_config(root).agents):
         print(NEXT_AFTER_INIT)
     return 0
@@ -476,6 +512,8 @@ def main(argv: Sequence[str] | None = None) -> int:
         return _provision(args)
     if args.command == "handoff":
         return _handoff(args)
+    if args.command == "statusline":
+        return statusline.run(args)
     if args.command == "context":
         return _context(dry_run=args.dry_run)
     if args.command == "skills":

{project_kit_cli-0.3.0 → project_kit_cli-0.4.0}/src/project_kit/doctor.py

@@ -200,6 +200,20 @@ def check_agents(which: Which, cwd: Path) -> list[Check]:
     return checks
 
 
+def check_statusline(cwd: Path) -> list[Check]:
+    """Whether Claude Code's status bar shows project-kit; optional, so never a warning."""
+    from project_kit import statusline
+
+    try:
+        if "claude" not in load_config(cwd).agents:
+            return []
+    except ConfigError:
+        return []
+    if statusline.is_configured(cwd):
+        return [Check("status bar", Status.OK, "configured in .claude/settings.json")]
+    return [Check("status bar", Status.OK, "not set up (optional: pjkit statusline --install)")]
+
+
 def run_checks(
     *,
     gh: Gh | None = None,
@@ -224,6 +238,7 @@ def run_checks(
         check_uv(which, runner),
         check_speckit(which, runner, here),
         *check_agents(which, here),
+        *check_statusline(here),
     ]
 
 

project_kit_cli-0.4.0/src/project_kit/entry.py

@@ -0,0 +1,36 @@
+"""The ``pjkit`` command's entry point.
+
+``statusline`` runs at every update of an agent's status bar, so it must start in a fraction of
+a second: it is dispatched here, before ``cli`` imports every command of the program. Every
+other command goes through ``cli.main`` unchanged.
+"""
+
+import argparse
+import sys
+from collections.abc import Sequence
+
+
+def _utf8_stdout() -> None:
+    """Print UTF-8 whatever the console code page is (the line has arrows and accents)."""
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[union-attr]
+    except (AttributeError, ValueError):
+        pass
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if args and args[0] == "statusline" and "--help" not in args and "-h" not in args:
+        from project_kit import statusline
+
+        parser = argparse.ArgumentParser(prog="pjkit statusline")
+        statusline.add_arguments(parser)
+        _utf8_stdout()
+        return statusline.run(parser.parse_args(args[1:]))
+    from project_kit.cli import main as cli_main
+
+    return cli_main(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{project_kit_cli-0.3.0 → project_kit_cli-0.4.0}/src/project_kit/help.py

@@ -31,6 +31,7 @@ TERMINAL_COMMANDS = (
         "pjkit skills list|show|mark|detect",
         "recommended skills for this project and what was decided",
     ),
+    ("pjkit statusline [--install]", "one-line status bar: model, limits and project phase"),
     ("pjkit help", "show this guide"),
 )
 

project_kit_cli-0.4.0/src/project_kit/statusline.py

@@ -0,0 +1,347 @@
+"""``pjkit statusline``: one line for the agent's status bar - model, context, usage limits and
+where the project is in the flow.
+
+The agent runs the command at every update and hands it a JSON document on stdin. What is in
+that JSON belongs to the agent, so reading it is isolated in an *adapter* per agent
+(``ADAPTERS``): it turns the agent's document into ``Metrics`` and nothing else in this module
+knows the shape. Only Claude Code has a documented status bar today, so it has the only
+adapter; another agent needs a new adapter and an entry in ``ADAPTERS``.
+
+The project's part (phase and next skill) comes from ``.project-kit/`` and does not depend on
+the agent. Everything is optional: a missing field, a document that is not JSON, or a directory
+that is not a project still prints something sensible, and nothing here touches the network.
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+DEFAULT_WIDTH = 120
+COMMAND = "pjkit statusline"
+SETTINGS = Path(".claude") / "settings.json"
+_SEP = " · "
+_ANSI = re.compile("\x1b\\[[0-9;]*m")
+_GREEN, _YELLOW, _RED, _DIM = "32", "33", "31", "2"
+
+
+@dataclass(frozen=True)
+class Metrics:
+    """What the status bar shows, from whichever agent supplied it. ``None``: not available."""
+
+    model: str | None = None
+    effort: str | None = None
+    context_pct: float | None = None
+    cost_usd: float | None = None
+    five_hour_pct: float | None = None
+    five_hour_resets: float | None = None  # unix seconds
+    seven_day_pct: float | None = None
+    cwd: str | None = None
+
+
+def _get(data: Any, *path: str) -> Any:
+    for key in path:
+        if not isinstance(data, Mapping):
+            return None
+        data = data.get(key)
+    return data
+
+
+def _number(value: Any) -> float | None:
+    return float(value) if isinstance(value, int | float) and not isinstance(value, bool) else None
+
+
+def _text(value: Any) -> str | None:
+    return value if isinstance(value, str) and value.strip() else None
+
+
+def claude_adapter(data: Mapping[str, Any]) -> Metrics:
+    """Claude Code's status line document (https://code.claude.com/docs/en/statusline)."""
+    return Metrics(
+        model=_text(_get(data, "model", "display_name")),
+        effort=_text(_get(data, "effort", "level")),
+        context_pct=_number(_get(data, "context_window", "used_percentage")),
+        cost_usd=_number(_get(data, "cost", "total_cost_usd")),
+        five_hour_pct=_number(_get(data, "rate_limits", "five_hour", "used_percentage")),
+        five_hour_resets=_number(_get(data, "rate_limits", "five_hour", "resets_at")),
+        seven_day_pct=_number(_get(data, "rate_limits", "seven_day", "used_percentage")),
+        cwd=_text(_get(data, "workspace", "current_dir")) or _text(data.get("cwd")),
+    )
+
+
+ADAPTERS: dict[str, Callable[[Mapping[str, Any]], Metrics]] = {"claude": claude_adapter}
+
+
+def parse_input(raw: str, agent: str = "claude") -> Metrics:
+    """Metrics from the agent's document; empty ones if it is missing or not what we expect."""
+    try:
+        data = json.loads(raw) if raw.strip() else {}
+    except json.JSONDecodeError:
+        return Metrics()
+    return ADAPTERS[agent](data) if isinstance(data, Mapping) else Metrics()
+
+
+# --- the project's part -------------------------------------------------------------------
+
+
+def project_segment(root: Path) -> str:
+    """``fase: decide -> /pk-decide`` from the project's state; empty outside a project."""
+    if not (root / ".project-kit" / "config.yml").is_file():
+        return ""  # not a project: do not even load the YAML reader
+    from project_kit.config import ConfigError, load_config
+    from project_kit.state import StateError, load_state
+    from project_kit.workflow import WorkflowError, load_workflow
+
+    try:
+        load_config(root)
+        workflow, state = load_workflow(root), load_state(root)
+    except (ConfigError, StateError, WorkflowError):
+        return ""
+    step = workflow.next_step(state)
+    if step is None:
+        return "fase: completa"
+    return f"fase: {step.id} → /{step.skill}"
+
+
+# --- rendering ----------------------------------------------------------------------------
+
+
+def _paint(text: str, code: str, color: bool) -> str:
+    return f"\033[{code}m{text}\033[0m" if color else text
+
+
+def _level(pct: float) -> str:
+    return _GREEN if pct < 60 else _YELLOW if pct < 85 else _RED
+
+
+def _clock(epoch: float, now: float) -> str:
+    local = time.localtime(epoch)
+    if epoch - now > 20 * 3600:
+        return time.strftime("%d/%m %H:%M", local)
+    return time.strftime("%H:%M", local)
+
+
+def _pieces(metrics: Metrics, segment: str, dropped: set[str], color: bool, now: float) -> str:
+    """The line with the parts in ``dropped`` left out."""
+    out: list[str] = []
+    label = metrics.model
+    if label and metrics.effort and "effort" not in dropped:
+        label = f"{label} · {metrics.effort}"
+    if label and "model" not in dropped:
+        out.append(_paint(f"[{label}]", _DIM, color))
+    if metrics.context_pct is not None and "context" not in dropped:
+        pct = f"{metrics.context_pct:.0f}%"
+        out.append(f"ctx {_paint(pct, _level(metrics.context_pct), color)}")
+    if metrics.five_hour_pct is not None:
+        pct = f"{metrics.five_hour_pct:.0f}%"
+        text = f"5h {_paint(pct, _level(metrics.five_hour_pct), color)}"
+        if metrics.five_hour_resets:
+            text += f" (↻ {_clock(metrics.five_hour_resets, now)})"
+        out.append(text)
+    if metrics.seven_day_pct is not None and "seven" not in dropped:
+        pct = f"{metrics.seven_day_pct:.0f}%"
+        out.append(f"7d {_paint(pct, _level(metrics.seven_day_pct), color)}")
+    if metrics.cost_usd is not None and "cost" not in dropped:
+        out.append(f"~${metrics.cost_usd:.2f}")
+    if segment:
+        out.append(segment)
+    return _SEP.join(out)
+
+
+# What goes first when the line is too long: the least important to the most.
+_DROP_ORDER = ("cost", "seven", "effort", "context", "model")
+
+
+def render(
+    metrics: Metrics,
+    segment: str = "",
+    *,
+    width: int = DEFAULT_WIDTH,
+    color: bool = True,
+    now: float | None = None,
+) -> str:
+    """One line. The 5-hour limit and the project's phase are the last to go."""
+    now = time.time() if now is None else now
+    dropped: set[str] = set()
+    for step in (None, *_DROP_ORDER):
+        if step:
+            dropped.add(step)
+        line = _pieces(metrics, segment, dropped, color, now)
+        if len(_ANSI.sub("", line)) <= width:
+            return line
+    return line
+
+
+# --- wrapping the bar the user already has -------------------------------------------------
+
+
+def run_wrapped(command: str, raw: str, timeout: float = 2.0) -> str:
+    """First line the user's own status command prints for this document; empty if it fails."""
+    try:
+        proc = subprocess.run(
+            command, shell=True, input=raw, capture_output=True, text=True,
+            encoding="utf-8", timeout=timeout,
+        )  # fmt: skip
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    lines = (proc.stdout or "").strip().splitlines() if proc.returncode == 0 else []
+    return lines[0].strip() if lines else ""
+
+
+def build_line(
+    raw: str,
+    root: Path,
+    *,
+    segment_only: bool = False,
+    wrap: str = "",
+    width: int = DEFAULT_WIDTH,
+    color: bool = True,
+) -> str:
+    """What the command prints for one update."""
+    segment = project_segment(root)
+    if segment_only:
+        return segment
+    before = run_wrapped(wrap, raw) if wrap else ""
+    metrics = parse_input(raw)
+    own = render(metrics, segment, width=max(width - len(before) - 3, 20), color=color)
+    return _SEP.join(p for p in (before, own) if p)
+
+
+# --- configuring the agent's settings -----------------------------------------------------
+
+
+@dataclass(frozen=True)
+class Outcome:
+    changed: bool
+    message: str
+
+
+def _read_settings(path: Path) -> dict[str, Any] | None:
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _command_of(settings: Mapping[str, Any]) -> str:
+    bar = settings.get("statusLine")
+    if isinstance(bar, Mapping) and bar.get("type", "command") == "command":
+        command = bar.get("command")
+        return command if isinstance(command, str) else ""
+    return ""
+
+
+def existing_command(root: Path, home: Path | None = None) -> str:
+    """The status command the user has: the project's, else the one in their own settings."""
+    home = home if home is not None else Path.home()
+    for path in (root / SETTINGS, home / SETTINGS):
+        data = _read_settings(path)
+        if data and (command := _command_of(data)):
+            return command
+    return ""
+
+
+def is_configured(root: Path) -> bool:
+    data = _read_settings(root / SETTINGS)
+    return bool(data) and COMMAND in _command_of(data)
+
+
+def install(root: Path, home: Path | None = None, *, dry_run: bool = False) -> Outcome:
+    """Point the project's Claude Code status line at ``pjkit statusline``.
+
+    An existing command (the project's or the user's own) is kept: it runs first and ours is
+    added after it. Settings that cannot be read are never overwritten.
+    """
+    from project_kit.fsutil import atomic_write_text
+
+    path = root / SETTINGS
+    data = _read_settings(path)
+    if data is None:
+        return Outcome(False, f"{SETTINGS.as_posix()} is not a valid JSON object; left alone.")
+    if COMMAND in _command_of(data):
+        return Outcome(False, "The status bar is already configured.")
+    before = existing_command(root, home)
+    command = f"{COMMAND} --wrap {json.dumps(before)}" if before else COMMAND
+    data["statusLine"] = {"type": "command", "command": command}
+    if not dry_run:
+        atomic_write_text(path, json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+    kept = f" Your existing bar ({before}) is kept and runs first." if before else ""
+    return Outcome(True, f"Status bar set in {SETTINGS.as_posix()}.{kept}")
+
+
+def remove(root: Path, *, dry_run: bool = False) -> Outcome:
+    """Undo ``install``: restore the wrapped command, or drop ``statusLine`` if there was none."""
+    from project_kit.fsutil import atomic_write_text
+
+    path = root / SETTINGS
+    data = _read_settings(path)
+    if data is None:
+        return Outcome(False, f"{SETTINGS.as_posix()} is not a valid JSON object; left alone.")
+    command = _command_of(data)
+    if COMMAND not in command:
+        return Outcome(False, "The status bar was not set by project-kit; nothing to remove.")
+    match = re.search(r"--wrap (\".*\")\s*$", command)
+    if match:
+        data["statusLine"] = {"type": "command", "command": json.loads(match.group(1))}
+    else:
+        del data["statusLine"]
+    if not dry_run:
+        atomic_write_text(path, json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+    return Outcome(True, "Status bar removed.")
+
+
+# --- the command line -----------------------------------------------------------------------
+
+
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--install", action="store_true", help="set it up in .claude/settings.json")
+    parser.add_argument("--remove", action="store_true", help="undo --install")
+    parser.add_argument(
+        "--dry-run", action="store_true", help="with --install/--remove: change nothing"
+    )
+    parser.add_argument("--segment", action="store_true", help="only the project's part, to embed")
+    parser.add_argument(
+        "--wrap", default="", help="a status command to run first (set by --install)"
+    )
+    parser.add_argument("--width", type=int, help="columns available (default: $COLUMNS or 120)")
+    parser.add_argument("--no-color", action="store_true", help="plain text (NO_COLOR also works)")
+
+
+def run(args: argparse.Namespace) -> int:
+    root = Path.cwd()
+    if args.install or args.remove:
+        from project_kit.config import ConfigError, load_config
+
+        try:
+            load_config(root)
+        except ConfigError as exc:
+            print(f"pjkit statusline: {exc}", file=sys.stderr)
+            return 1
+        outcome = (install if args.install else remove)(root, dry_run=args.dry_run)
+        print(("Dry run: " if args.dry_run and outcome.changed else "") + outcome.message)
+        return 0 if outcome.changed or "already" in outcome.message else 1
+    raw = "" if sys.stdin.isatty() else sys.stdin.read()
+    cwd = parse_input(raw).cwd
+    project = Path(cwd) if cwd and Path(cwd).is_dir() else root
+    width = args.width or int(os.environ.get("COLUMNS", "") or DEFAULT_WIDTH)
+    print(
+        build_line(
+            raw,
+            project,
+            segment_only=args.segment,
+            wrap=args.wrap,
+            width=width,
+            color=not (args.no_color or os.environ.get("NO_COLOR")),
+        )
+    )
+    return 0

project_kit_cli-0.3.0/src/project_kit/__init__.py

@@ -1,8 +0,0 @@
-"""project-kit: define, plan and set up a project before handing off to Spec Kit."""
-
-from importlib.metadata import PackageNotFoundError, version
-
-try:
-    __version__ = version("project-kit-cli")
-except PackageNotFoundError:  # running from a source tree that was never installed
-    __version__ = "0.0.0"