taskill 0.1.1__py3-none-any.whl

taskill/state.py

@@ -0,0 +1,42 @@
+"""Persistent state — what was the project's snapshot last time we ran?"""
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+@dataclass
+class TaskillState:
+    last_run_iso: str | None = None
+    last_commit_sha: str | None = None
+    last_coverage_pct: float | None = None
+    last_failed_tests: int | None = None
+    last_sumd_hash: str | None = None
+    file_mtimes: dict[str, float] = field(default_factory=dict)
+
+    @property
+    def last_run_dt(self) -> datetime | None:
+        if not self.last_run_iso:
+            return None
+        return datetime.fromisoformat(self.last_run_iso)
+
+    def stamp(self) -> None:
+        self.last_run_iso = datetime.now(timezone.utc).isoformat()
+
+
+def load_state(path: Path) -> TaskillState:
+    if not path.exists():
+        return TaskillState()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return TaskillState(**data)
+    except (json.JSONDecodeError, TypeError):
+        # corrupt state → start fresh, don't crash
+        return TaskillState()
+
+
+def save_state(path: Path, state: TaskillState) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(asdict(state), indent=2), encoding="utf-8")

taskill/triggers.py

@@ -0,0 +1,94 @@
+"""Decide whether thresholds in taskill.yaml are met → should we run?"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+from taskill.config import Triggers
+from taskill.git_state import ProjectSnapshot
+from taskill.state import TaskillState
+
+
+@dataclass
+class TriggerEvaluation:
+    should_run: bool
+    reasons: list[str]
+    skipped: list[str]
+
+    def summary(self) -> str:
+        if self.should_run:
+            return "RUN: " + "; ".join(self.reasons)
+        return "SKIP: thresholds not met"
+
+
+def evaluate(
+    triggers: Triggers,
+    state: TaskillState,
+    snapshot: ProjectSnapshot,
+    project_root: Path,
+) -> TriggerEvaluation:
+    reasons: list[str] = []
+    skipped: list[str] = []
+
+    # 1. time since last run
+    if state.last_run_dt is None:
+        reasons.append("never run before")
+    else:
+        delta_h = (datetime.now(timezone.utc) - state.last_run_dt).total_seconds() / 3600
+        if delta_h >= triggers.min_hours_since_last_run:
+            reasons.append(f"{delta_h:.1f}h since last run (≥{triggers.min_hours_since_last_run}h)")
+        else:
+            skipped.append(f"only {delta_h:.1f}h since last run")
+
+    # 2. commits since last
+    n_commits = len(snapshot.commits_since_last_run)
+    if n_commits >= triggers.min_commits_since_last_run:
+        reasons.append(f"{n_commits} new commit(s)")
+    else:
+        skipped.append(f"only {n_commits} commits (<{triggers.min_commits_since_last_run})")
+
+    # 3. changed files
+    n_changed = len(snapshot.changed_files)
+    if n_changed >= triggers.changed_files_threshold:
+        reasons.append(f"{n_changed} changed file(s)")
+    else:
+        skipped.append(f"only {n_changed} files changed")
+
+    # 4. coverage delta
+    if triggers.coverage_change_pct is not None and snapshot.coverage_pct is not None and \
+       state.last_coverage_pct is not None:
+        delta = abs(snapshot.coverage_pct - state.last_coverage_pct)
+        if delta >= triggers.coverage_change_pct:
+            reasons.append(f"coverage moved {delta:.1f}pp")
+        else:
+            skipped.append(f"coverage Δ {delta:.1f}pp")
+
+    # 5. failed tests changed
+    if triggers.failed_tests_changed and snapshot.failed_tests is not None and \
+       state.last_failed_tests is not None and snapshot.failed_tests != state.last_failed_tests:
+        reasons.append(
+            f"failed tests {state.last_failed_tests} → {snapshot.failed_tests}"
+        )
+
+    # 6. SUMD changed
+    if snapshot.sumd_hash and snapshot.sumd_hash != state.last_sumd_hash:
+        reasons.append("SUMD.md changed")
+
+    # 7. watched files mtime
+    for rel in triggers.watch_files:
+        p = project_root / rel
+        if not p.exists():
+            continue
+        mtime = p.stat().st_mtime
+        prev = state.file_mtimes.get(rel)
+        if prev is None or mtime > prev:
+            reasons.append(f"{rel} touched")
+
+    if triggers.require_all:
+        # AND semantics: must have NO skipped reasons
+        should_run = bool(reasons) and not skipped
+    else:
+        should_run = bool(reasons)
+
+    return TriggerEvaluation(should_run=should_run, reasons=reasons, skipped=skipped)

taskill/updaters/__init__.py

@@ -0,0 +1,6 @@
+"""Document updaters — apply GeneratedDocs to README/CHANGELOG/TODO."""
+from taskill.updaters.changelog import update_changelog
+from taskill.updaters.todo import update_todo
+from taskill.updaters.readme import update_readme
+
+__all__ = ["update_changelog", "update_todo", "update_readme"]

taskill/updaters/changelog.py

@@ -0,0 +1,92 @@
+"""Update CHANGELOG.md following the Keep a Changelog convention.
+
+Strategy:
+- Keep the file's prelude (intro before first version heading).
+- Find or create the `## [Unreleased]` section.
+- Append new entries under it (deduplicated by exact line match).
+"""
+from __future__ import annotations
+
+import re
+from datetime import date
+from pathlib import Path
+
+UNRELEASED_HEADING = "## [Unreleased]"
+
+DEFAULT_HEADER = """# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+"""
+
+
+def update_changelog(path: Path, entries: list[str]) -> bool:
+    """Append entries under [Unreleased]. Returns True if the file changed."""
+    if not entries:
+        return False
+
+    if path.exists():
+        original = path.read_text(encoding="utf-8")
+    else:
+        original = DEFAULT_HEADER + UNRELEASED_HEADING + "\n\n"
+
+    # ensure [Unreleased] section exists
+    if UNRELEASED_HEADING not in original:
+        # insert it after the header (after first blank line following "# Changelog")
+        if original.startswith("# "):
+            head, _, tail = original.partition("\n\n")
+            original = f"{head}\n\n{UNRELEASED_HEADING}\n\n{tail}"
+        else:
+            original = UNRELEASED_HEADING + "\n\n" + original
+
+    # find the [Unreleased] block (until next "## [" or EOF)
+    pattern = re.compile(
+        rf"({re.escape(UNRELEASED_HEADING)}\n)(.*?)(?=^## \[|\Z)",
+        re.DOTALL | re.MULTILINE,
+    )
+    m = pattern.search(original)
+    if not m:
+        # shouldn't happen, but fail safely
+        return False
+
+    block_body = m.group(2)
+    existing_lines = set(line.rstrip() for line in block_body.splitlines() if line.strip())
+
+    # add only genuinely new entries; preserve order from `entries`
+    new_lines: list[str] = []
+    for entry in entries:
+        clean = entry.rstrip()
+        if clean and clean not in existing_lines:
+            new_lines.append(clean)
+            existing_lines.add(clean)
+
+    if not new_lines:
+        return False
+
+    # rebuild block: keep original body, append new bullets at the end of the
+    # appropriate subsection if a heading-of-headings exists; otherwise dump at end
+    new_block = block_body.rstrip() + "\n\n" + "\n".join(new_lines) + "\n\n"
+    updated = original[:m.start(2)] + new_block + original[m.end(2):]
+
+    path.write_text(updated, encoding="utf-8")
+    return True
+
+
+def release_unreleased(path: Path, version: str, today: date | None = None) -> bool:
+    """Move [Unreleased] block to a versioned [x.y.z] - YYYY-MM-DD heading.
+
+    Optional helper, not invoked by default. Useful for `taskill release`.
+    """
+    if not path.exists():
+        return False
+    today = today or date.today()
+    txt = path.read_text(encoding="utf-8")
+    if UNRELEASED_HEADING not in txt:
+        return False
+    new_heading = f"## [{version}] - {today.isoformat()}"
+    txt = txt.replace(UNRELEASED_HEADING, f"{UNRELEASED_HEADING}\n\n{new_heading}", 1)
+    path.write_text(txt, encoding="utf-8")
+    return True

taskill/updaters/readme.py

@@ -0,0 +1,74 @@
+"""README updater — refresh marked sections only.
+
+Philosophy: never overwrite the whole README. We only touch sections wrapped in
+HTML comment markers, so users can curate the rest by hand:
+
+    <!-- taskill:status:start -->
+    ...auto-generated content...
+    <!-- taskill:status:end -->
+
+If the markers don't exist, we append a status block at the bottom.
+"""
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+from taskill.git_state import ProjectSnapshot
+
+START = "<!-- taskill:status:start -->"
+END = "<!-- taskill:status:end -->"
+
+
+def render_status_block(snapshot: ProjectSnapshot, summary: str) -> str:
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+    coverage = f"{snapshot.coverage_pct:.1f}%" if snapshot.coverage_pct is not None else "—"
+    failed = (
+        str(snapshot.failed_tests) if snapshot.failed_tests is not None else "—"
+    )
+    head = (snapshot.head_sha or "")[:7] or "—"
+
+    lines = [
+        START,
+        "",
+        "## Status",
+        "",
+        f"_Last updated by [taskill](https://github.com/oqlos/taskill) at {now}_",
+        "",
+        "| Metric | Value |",
+        "|---|---|",
+        f"| HEAD | `{head}` |",
+        f"| Coverage | {coverage} |",
+        f"| Failing tests | {failed} |",
+        f"| Commits in last cycle | {len(snapshot.commits_since_last_run)} |",
+    ]
+    if summary:
+        lines += ["", f"> {summary}"]
+    lines += ["", END]
+    return "\n".join(lines)
+
+
+def update_readme(path: Path, snapshot: ProjectSnapshot, summary: str) -> bool:
+    block = render_status_block(snapshot, summary)
+
+    if not path.exists():
+        # don't invent a README — too presumptuous. Just write the block.
+        path.write_text(f"# {path.parent.name}\n\n{block}\n", encoding="utf-8")
+        return True
+
+    original = path.read_text(encoding="utf-8")
+
+    if START in original and END in original:
+        pattern = re.compile(
+            rf"{re.escape(START)}.*?{re.escape(END)}", re.DOTALL
+        )
+        updated = pattern.sub(block, original)
+    else:
+        sep = "\n\n" if not original.endswith("\n\n") else ""
+        updated = original.rstrip() + "\n\n" + block + "\n"
+
+    if updated == original:
+        return False
+    path.write_text(updated, encoding="utf-8")
+    return True

taskill/updaters/todo.py

@@ -0,0 +1,77 @@
+"""Update TODO.md.
+
+Two operations:
+  1. Remove (or strike-through) lines that are now done.
+  2. Append newly-discovered TODOs.
+
+Behavior is conservative — we never delete user-authored text we don't recognize.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+DEFAULT_HEADER = "# TODO\n\n"
+
+
+def update_todo(
+    path: Path,
+    completed_lines: list[str],
+    new_items: list[str],
+    *,
+    archive_completed: bool = True,
+) -> bool:
+    """Remove completed_lines from TODO and append new_items. Returns True on change."""
+    if not (completed_lines or new_items):
+        return False
+
+    if path.exists():
+        original = path.read_text(encoding="utf-8")
+    else:
+        original = DEFAULT_HEADER
+
+    lines = original.splitlines(keepends=False)
+    completed_set = {l.rstrip() for l in completed_lines if l.strip()}
+
+    kept: list[str] = []
+    archived: list[str] = []
+    for line in lines:
+        if line.rstrip() in completed_set and line.strip().startswith(("-", "*", "+")):
+            archived.append(line)
+        else:
+            kept.append(line)
+
+    # dedup new items: don't re-add what's already in TODO
+    existing = {l.strip() for l in kept if l.strip()}
+    fresh_new = [item for item in new_items if item.strip() not in existing]
+
+    # build output
+    out_lines = list(kept)
+    if fresh_new:
+        if out_lines and out_lines[-1].strip():
+            out_lines.append("")
+        # if no header, prepend one
+        if not any(l.startswith("# ") for l in out_lines):
+            out_lines = ["# TODO", ""] + out_lines
+        out_lines.append("## Discovered")
+        out_lines.append("")
+        out_lines.extend(fresh_new)
+        out_lines.append("")
+
+    if archive_completed and archived:
+        out_lines.append("")
+        out_lines.append("## Done (moved to CHANGELOG)")
+        out_lines.append("")
+        out_lines.extend(archived)
+        out_lines.append("")
+
+    new_content = "\n".join(out_lines).rstrip() + "\n"
+    if new_content == original:
+        return False
+
+    path.write_text(new_content, encoding="utf-8")
+    return True
+
+
+def empty_todo(path: Path, header: str = DEFAULT_HEADER) -> None:
+    """Reset TODO.md to a clean empty header. Used by `taskill clean-todo`."""
+    path.write_text(header, encoding="utf-8")

taskill-0.1.1.dist-info/METADATA

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: taskill
+Version: 0.1.1
+Summary: Daily project hygiene: keep README / CHANGELOG / TODO in sync with reality. LLM-first, algorithmic fallback.
+Project-URL: Homepage, https://github.com/oqlos/taskill
+Project-URL: Issues, https://github.com/oqlos/taskill/issues
+Author: Tom Sapletta
+Author-email: Tom Sapletta <tom@sapletta.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: automation,changelog,ci-cd,llm,mcp,openrouter,readme,todo
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1
+Requires-Dist: costs>=0.1.20
+Requires-Dist: goal>=2.1.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: pfix>=0.1.60
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Provides-Extra: dev
+Requires-Dist: costs>=0.1.20; extra == 'dev'
+Requires-Dist: goal>=2.1.0; extra == 'dev'
+Requires-Dist: mypy>=1.5; extra == 'dev'
+Requires-Dist: pfix>=0.1.60; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == 'mcp'
+Provides-Extra: schedule
+Requires-Dist: apscheduler>=3.10; extra == 'schedule'
+Description-Content-Type: text/markdown
+
+# taskill
+
+
+## AI Cost Tracking
+
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.1.1-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$0.15-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-1.0h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+
+- 🤖 **LLM usage:** $0.1500 (1 commits)
+- 👤 **Human dev:** ~$100 (1.0h @ $100/h, 30min dedup)
+
+Generated on 2026-04-25 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+
+---
+
+
+
+> Daily project hygiene: keep `README.md` / `CHANGELOG.md` / `TODO.md` in sync with reality.
+> LLM-first, algorithmic fallback. Works standalone, in CI, or via Ansible.
+
+`taskill` is the small daemon you stop forgetting to run. Once a day (or whenever metrics drift), it reads your git log, your `SUMD.md` / `SUMR.md`, your coverage report, and updates the three documentation files everyone tells themselves they'll keep current and never do.
+
+It uses an LLM where one is available — Windsurf MCP first (because you're probably already running it in JetBrains), OpenRouter second — and falls back to a deterministic Conventional Commits parser when no LLM is reachable. The fallback is always available and always runs offline.
+
+`taskill` deliberately doesn't replace `pyqual`, `llx`, or `prefact`. It calls them as subprocesses when configured, picks up their reports, and stays out of the way otherwise.
+
+## Install
+
+```bash
+pip install taskill                    # core
+pip install "taskill[mcp]"             # with Windsurf MCP support
+pip install "taskill[mcp,schedule]"    # with built-in scheduler
+```
+
+## Quickstart
+
+```bash
+cd your-project/
+taskill init                  # writes taskill.yaml + .env.example
+cp .env.example .env          # add OPENROUTER_API_KEY
+taskill status                # preview without running
+taskill run --dry-run         # see what would change
+taskill run                   # do it
+```
+
+## What it does
+
+Every run produces three (idempotent) edits:
+
+1. **`CHANGELOG.md`** — appends new entries under `## [Unreleased]`, grouped by Conventional Commit type (`### Added`, `### Fixed`, `### Performance`, etc.). Uses [Keep a Changelog](https://keepachangelog.com/) layout. Existing entries are deduplicated.
+2. **`TODO.md`** — moves completed items to a `## Done (moved to CHANGELOG)` section, and appends `TODO:` / `FIXME:` markers found in new commit bodies under `## Discovered`.
+3. **`README.md`** — refreshes only the block between `<!-- taskill:status:start -->` and `<!-- taskill:status:end -->` markers (HEAD, coverage, failing tests, summary). Never touches the rest of the file.
+
+## Provider chain
+
+The chain runs top-to-bottom. First provider that's available *and* succeeds wins.
+
+| Order | Provider | Used when |
+|---|---|---|
+| 1 | `windsurf_mcp` | `mcp` package installed and a Windsurf endpoint resolves |
+| 2 | `openrouter` | `OPENROUTER_API_KEY` is set |
+| 3 | `algorithmic` | always — pure git-log + Conventional Commits parser |
+
+You can reorder, disable, or pass options via `taskill.yaml`:
+
+```yaml
+providers:
+  - name: openrouter         # skip windsurf, go straight to OpenRouter
+    enabled: true
+  - name: algorithmic
+    enabled: true
+```
+
+## Triggers
+
+`taskill run` is a no-op unless one of the configured thresholds is crossed. State lives in `.taskill/state.json` so cron, GitHub Actions, and Ansible all share the same delta logic.
+
+```yaml
+triggers:
+  min_hours_since_last_run: 24
+  min_commits_since_last_run: 1
+  changed_files_threshold: 1
+  coverage_change_pct: 2.0       # absolute pp; null to disable
+  failed_tests_changed: true
+  watch_files: [SUMD.md, SUMR.md]
+  require_all: false             # OR by default; set true for AND
+```
+
+`taskill run --force` ignores triggers entirely.
+
+## Running it
+
+### Cron / systemd timer
+
+```cron
+0 6 * * * cd /path/to/project && /usr/local/bin/taskill run >> ~/.taskill.log 2>&1
+```
+
+### GitHub Actions
+
+See `examples/github-action.yml`. Triggers on `push` to main, runs `taskill run`, opens a PR if files changed.
+
+### GitLab CI
+
+See `examples/gitlab-ci.yml`. Same idea, with merge-request creation via the GitLab API.
+
+### Ansible
+
+See `examples/ansible-playbook.yml`. Useful for fleet-wide hygiene across many self-hosted repos.
+
+## CLI
+
+```
+taskill init           # generate taskill.yaml + .env.example
+taskill status         # show what would happen, no writes
+taskill run            # execute (respects triggers)
+taskill run --force    # ignore triggers
+taskill run --dry-run  # don't write files or state
+taskill run --json     # machine-readable output
+taskill release X.Y.Z  # promote [Unreleased] → versioned heading
+taskill clean-todo     # wipe TODO.md (after a release)
+```
+
+## Configuration reference
+
+See [`taskill.yaml`](./taskill.yaml) at the repo root for the annotated default config.
+
+## Reusing existing tools
+
+`taskill` doesn't try to absorb `pyqual` / `llx` / `prefact`. It calls them by `subprocess` when toggled in `reuse:` and feeds their JSON output to the LLM as extra context:
+
+```yaml
+reuse:
+  pyqual: true       # taskill will run `pyqual report --json`
+  llx: false         # ...add llx context (planned for v0.2)
+  prefact: false     # ...add prefact suggestions (planned for v0.2)
+```
+
+If a tool isn't on `PATH`, `taskill` skips it silently — no hard dependency.
+
+## How it relates to the wider stack
+
+```
+SUMD (description) ─┐
+                    ├─→ taskill ──→ README.md
+git log ────────────┤              CHANGELOG.md
+pyqual report ──────┤              TODO.md
+SUMR (state) ───────┘
+```
+
+`taskill` reads, never generates code. That's what `prefact` / `llx` / `pyqual` are for.
+
+## License
+
+Licensed under Apache-2.0.
+## Status
+
+<!-- taskill:status:start -->
+_Bootstrapped — no live project status yet. Will populate after first `taskill run`._
+<!-- taskill:status:end -->

taskill-0.1.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+taskill/__init__.py,sha256=ghzG0Zm7axLz8dgGLVma8qCNXD196BLIQQoec80WodI,812
+taskill/cli.py,sha256=cChFaM96O8LSrYvvKEz14iPtEEp2lX5cQXAix4dnQRc,8731
+taskill/config.py,sha256=Z32qtXgLTqIF5o8PhXBPT4MCt7Xo47rKnWTm2zDoagE,5660
+taskill/core.py,sha256=VhzZ6Y8j8539RXWt3BjHsP5wncKAUSJHSMRc9x02YWc,8126
+taskill/git_state.py,sha256=4GCs-9yp0xUyRgYGV8rIYzzj-YhG0kwWCfCYDMW55cQ,5055
+taskill/state.py,sha256=pEhShu_tEus5LuL2qwXDu4xETyscMmtnchdJlPT5vQk,1327
+taskill/triggers.py,sha256=6LIS7TrD0TXGUkbMWrnkVOTxuAYmm2a4W2BZjQibybE,3228
+taskill/providers/__init__.py,sha256=NZARGAesk3QfNMDlFMXbC8IcA1NBhHTNtdgns7prBOE,1128
+taskill/providers/algorithmic.py,sha256=a5BVG41NOFhwxIJoMJOiwYAIhJgs8HdSV6JZEoxI7eA,5670
+taskill/providers/base.py,sha256=-zEqWn_ho2fKjsOmGNbUN5qPukze6He8G_koj5mxTNU,3497
+taskill/providers/openrouter.py,sha256=p1J-EprSOPbSjJlZbLjChFwPqY-9DT4IAoR8gksdPUI,4000
+taskill/providers/windsurf_mcp.py,sha256=KrafaByK-6OJkA80C5J86V-sKzX1x6i8EcTtE2_k5LE,5199
+taskill/updaters/__init__.py,sha256=Ks0dfgA7KlnrmIvPTytMTcr8PPkwJsXEVd2hC-R0m4E,290
+taskill/updaters/changelog.py,sha256=m_y1enqLDMNt3G4_U6QcbzwPelQwlu1IMyzXu_EpiFc,3174
+taskill/updaters/readme.py,sha256=W_eOwcasYPvJtT4JwOUZFS77NJ3XnthkRHMYN76JO1g,2344
+taskill/updaters/todo.py,sha256=7V9oGp9oI5tERj-w18La_IOHVLVIeWbRsoyL66-u64A,2301
+taskill-0.1.1.dist-info/METADATA,sha256=W3PZEH9bqmXFlDpAZF00-i9mdgP8LIS8oZFYgNONr8A,7357
+taskill-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+taskill-0.1.1.dist-info/entry_points.txt,sha256=LRZ0ou7wTswiRh3bMpi9E0O57tf4njpjv5jd8jX3_GE,45
+taskill-0.1.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+taskill-0.1.1.dist-info/RECORD,,

taskill-0.1.1.dist-info/WHEEL

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

taskill-0.1.1.dist-info/entry_points.txt

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