agentltl-coding 0.2.4__py3-none-any.whl

agentltl_coding/scan.py

@@ -0,0 +1,54 @@
+"""
+agentltl_coding/scan.py – spot credentials in what a tool call returned.
+
+A rule can only stop a call before it runs; when a program prints a credential anyway
+(`python app.py` logging its config, a test failure dumping the environment), the value is
+already in the conversation. The harness's after-the-call hook scans the output for well-known credential
+formats, the documented prefixes that secret scanners also use, and reports what kind was
+seen, never the value, so the user can rotate it and the agent does not repeat it.
+
+Only formats with a distinctive prefix or structure are matched, to keep false alarms rare.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, List, Tuple
+
+_MAX_SCAN = 1_000_000
+
+# (kind, pattern): documented prefixes; lengths keep ordinary words from matching.
+_FORMATS = [
+    ("AWS access key ID", r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b"),
+    ("GitHub token", r"\b(?:gh[pousr]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{60,})\b"),
+    ("GitLab token", r"\bglpat-[A-Za-z0-9_-]{20,}\b"),
+    ("Slack token", r"\bxox[abprs]-[A-Za-z0-9-]{10,}\b"),
+    ("Stripe live key", r"\b[rs]k_live_[A-Za-z0-9]{20,}\b"),
+    ("Google API key", r"\bAIza[0-9A-Za-z_-]{35}\b"),
+    ("Anthropic API key", r"\bsk-ant-[A-Za-z0-9_-]{20,}"),
+    ("OpenAI API key", r"\bsk-(?:proj-)?[A-Za-z0-9_-]{40,}"),
+    ("npm token", r"\bnpm_[A-Za-z0-9]{36}\b"),
+    ("private key", r"-----BEGIN (?:[A-Z]+ )?PRIVATE KEY-----"),
+]
+_COMPILED = [(kind, re.compile(pattern)) for kind, pattern in _FORMATS]
+
+
+def credential_kinds(value: Any) -> List[str]:
+    """The kinds of credential that appear in *value* (a tool response), in a stable order."""
+    text = value if isinstance(value, str) else json.dumps(value, default=str)
+    text = text[:_MAX_SCAN]
+    return [kind for kind, pattern in _COMPILED if pattern.search(text)]
+
+
+def report(tool: str, kinds: List[str]) -> Tuple[str, str]:
+    """What to say after a call whose output has credentials of *kinds*: a notice for the
+    user, and an instruction for the agent. The harness puts each where its agent shows it."""
+    what = ", ".join(kinds)
+    user = (f"AgentLTL: the output of {tool} contains what looks like a credential ({what}). "
+            "If it is real, consider rotating it.")
+    agent = (f"The output of this {tool} call contains what looks like a credential ({what}). "
+             "Do not repeat, quote, copy or write that value anywhere: not in replies, files, "
+             "commands or commit messages. Tell the user it appeared, so they can rotate it, "
+             "and carry on without it.")
+    return user, agent

agentltl_coding/session.py

@@ -0,0 +1,149 @@
+"""
+agentltl_coding/session.py – what a harness's hooks do, whatever their I/O.
+
+Each agent calls its hooks with its own payloads and expects its own JSON back; what they
+do in between is the same everywhere. A harness turns its payload into one of these calls
+and the result into its answer::
+
+    s = Session(cwd, project, session_id)
+    if not s.files: ...                       # no AGENTLTL.yaml: stay out of the way
+    s.prompt()                                # the user wrote: lift a stop, new turn
+    s.start()                                 # the reminder of the rules, or None
+    s.pre("Bash", {"command": "git push"}, auto=False)    # a Verdict
+    s.post("Bash", {...}, "id", output, status=0)         # (user notice, agent note) or None
+    s.finish()                                # a Verdict: "block" while `finally` is unmet
+
+Tool names may be the agent's own: the guard maps them (``Harness.tool_aliases``).
+:class:`~agentltl_coding.rules.RuleFileError` from a broken rule file reaches the caller,
+which tells the user (see :func:`broken`).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+from . import store
+from .guard import Guard, Verdict
+from .harness import current as _harness
+from .pattern import Paths
+from .rules import RuleSet, load, rule_files
+
+STILL_STOPPED = (
+    "[AGENTLTL] Rule '{rule}' stopped this session: every tool call is refused until the user "
+    "replies. Nothing was executed. Don't try another command or a workaround. Tell the user "
+    "what you were trying to do, why, and what you need from them, then end your turn.")
+_MAX_DECISIONS = 200
+
+
+class Session:
+    def __init__(self, cwd: str, project: str, session_id: Optional[str]) -> None:
+        self.cwd, self.project, self.sid = cwd, project, session_id or "default"
+        self.files: List[str] = rule_files(cwd, project)
+        self._ruleset: Optional[RuleSet] = None
+        logging.getLogger("agentltl").setLevel(logging.ERROR)
+        logging.getLogger("cli_to_tools").setLevel(logging.ERROR)
+
+    @property
+    def ruleset(self) -> RuleSet:
+        """The compiled rules. Raises RuleFileError for a broken rule file."""
+        if self._ruleset is None:
+            self._ruleset = load(self.files, Paths(self.cwd, self.project))
+        return self._ruleset
+
+    # ── events ────────────────────────────────────────────────────────────────
+
+    def prompt(self) -> None:
+        """The user wrote: lift a stop (even if the rule file has since become unreadable),
+        and let ``finally`` rules send the agent back again in this new turn."""
+        with store.locked(self.sid) as state:
+            state.pop("stopped", None)
+            state["termination_nudges"] = 0
+        with store.locked_project(self.project) as project_state:
+            project_state["termination_nudges"] = 0
+
+    def start(self) -> Optional[str]:
+        """What to tell the agent at the start of a session (None: settings.announce off)."""
+        return reminder(self.ruleset)
+
+    def pre(self, tool: str, tool_input: Dict[str, Any], *, auto: bool = False) -> Verdict:
+        """Decide a call before it runs. After a ``stop``, every call is denied until
+        :meth:`prompt`."""
+        def decide(guard: Guard, state: Dict[str, Any]) -> Verdict:
+            if state.get("stopped"):
+                return Verdict("deny", STILL_STOPPED.format(**state["stopped"]),
+                               rule=state["stopped"].get("rule"))
+            verdict = guard.decide(tool, tool_input, auto=auto)
+            if verdict.action == "stop":
+                state["stopped"] = {"rule": verdict.rule or "?"}
+            return verdict
+
+        return self._with_guard(decide, _harness().canonical(tool, tool_input))
+
+    def post(self, tool: str, tool_input: Dict[str, Any], tool_id: str, result: Any,
+             status: Optional[int] = None) -> Optional[Tuple[str, str]]:
+        """Record a call that ran (status 0) or failed (1). Returns what to say when its output
+        holds a credential: (notice for the user, instruction for the agent)."""
+        self._with_guard(lambda guard, state: guard.record(tool, tool_input, tool_id, result,
+                                                           status=status))
+        if not self.ruleset.settings.scan_output or result is None:
+            return None
+        from .scan import credential_kinds, report
+        kinds = credential_kinds(result)
+        return report(_harness().canonical(tool, {})[0], kinds) if kinds else None
+
+    def finish(self) -> Verdict:
+        """The agent is about to end its turn: "block" with what is missing while a
+        ``finally`` rule is unmet."""
+        return self._with_guard(lambda guard, state: guard.finish()) or Verdict()
+
+    # ── state ─────────────────────────────────────────────────────────────────
+
+    def _with_guard(self, fn: Any, call: Optional[Tuple[str, Dict[str, Any]]] = None) -> Any:
+        """Run *fn(guard, session_state)* on the saved state and save it again. A verdict on
+        *call* that intervenes is logged for ``agentltl trace``."""
+        guard = Guard(self.ruleset, Paths(self.cwd, self.project))
+        with store.locked(self.sid) as state, store.locked_project(self.project) as project_state:
+            guard.restore(state, project_state)
+            out = fn(guard, state)
+            for old in ("trace", "engine"):          # saved before AgentLTL 0.2
+                state.pop(old, None)
+            state.update(guard.dump())
+            state["project_dir"] = self.project
+            project_state.update(guard.dump_project())
+            if call and isinstance(out, Verdict) and out.action not in ("none", "block"):
+                state.setdefault("decisions", []).append(
+                    {"tool": call[0], "input": call[1], "action": out.action, "rule": out.rule})
+                state["decisions"] = state["decisions"][-_MAX_DECISIONS:]
+        return out
+
+
+def reminder(ruleset: RuleSet) -> Optional[str]:
+    """The session-start reminder: the rules in force, one line each."""
+    if not ruleset.settings.announce:
+        return None
+    lines = [
+        f"This project enforces {len(ruleset.rules)} AGENTLTL rule(s) on every tool call, shell "
+        "commands included (each command line is checked as the sequence of commands it runs). "
+        "A call that breaks a rule is refused with the reason; follow it rather than working "
+        "around it. When a rule keeps you from doing what the user asked, or refuses a call, "
+        "tell the user in your reply and name the rule. Rules:",
+    ]
+    note = _harness().memory_note
+    for r in ruleset.rules:
+        if r.id == "memory-first" and r.kind == "never" and note:
+            lines.append(f"- memory-first [{r.mode}]: {note}")
+            continue
+        why = f" — {r.why}" if r.why else ""
+        memory = ", whole project" if r.scope == "project" else ""
+        lines.append(f"- {r.id} [{r.mode}{memory}]: {r.summary}{why}")
+    return "\n".join(lines)
+
+
+def broken(problems: List[str]) -> str:
+    """What to tell the agent (and through it the user) about a broken rule file."""
+    return ("AGENTLTL.yaml has errors, so NO AGENTLTL rules are being enforced until it is "
+            "fixed:\n" + "\n".join(f"- {p}" for p in problems))
+
+
+__all__ = ["Session", "STILL_STOPPED", "broken", "reminder"]

agentltl_coding/store.py

@@ -0,0 +1,123 @@
+"""
+agentltl_coding/store.py – per-session state on disk.
+
+Each hook call is a fresh process, so traces and enforcer counters live on disk: the
+session memory in ``<state dir>/<session id>.json``, the project memory (every call made in
+a project, across sessions) in ``<state dir>/../projects/<hash of the project dir>.json``. A harness may run tool calls in parallel, so every
+read-modify-write holds an exclusive lock on ``<file>.lock``.
+
+State dir: ``$AGENTLTL_STATE`` (or ``$AGENTLTL_CC_STATE``), else the harness's ``state_dir``,
+else ``sessions/`` next to the virtualenv the guard runs in (``<data>/venv-<pins>`` →
+``<data>/sessions``, so a hook and the ``agentltl`` CLI agree without sharing an
+environment), else ``~/.cache/agentltl-<harness>/sessions``.
+"""
+
+from __future__ import annotations
+
+import fcntl
+import hashlib
+import json
+import os
+import re
+import sys
+import tempfile
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, List, Optional
+
+
+def state_dir() -> str:
+    from .harness import current
+    for var in ("AGENTLTL_STATE", "AGENTLTL_CC_STATE"):
+        if os.environ.get(var):
+            return os.environ[var]
+    if current().state_dir:
+        return os.path.expanduser(current().state_dir)
+    if re.fullmatch(r"venv(-\d+)?", os.path.basename(sys.prefix)):
+        return os.path.join(os.path.dirname(sys.prefix), "sessions")
+    return os.path.join(os.path.expanduser("~"), ".cache", f"agentltl-{current().name}", "sessions")
+
+
+def session_path(session_id: str) -> str:
+    safe = re.sub(r"[^A-Za-z0-9_.-]", "_", session_id or "default")[:128]
+    return os.path.join(state_dir(), f"{safe}.json")
+
+
+def project_path(project_dir: str) -> str:
+    key = hashlib.sha1(os.path.abspath(project_dir).encode()).hexdigest()[:16]
+    return os.path.join(os.path.dirname(state_dir()), "projects", f"{key}.json")
+
+
+def _read(path: str) -> Dict[str, Any]:
+    try:
+        with open(path, encoding="utf-8") as fh:
+            return json.load(fh)
+    except (OSError, ValueError):
+        return {}
+
+
+def read(session_id: str) -> Dict[str, Any]:
+    return _read(session_path(session_id))
+
+
+def read_project(project_dir: str) -> Dict[str, Any]:
+    return _read(project_path(project_dir))
+
+
+@contextmanager
+def _locked(path: str) -> Iterator[Dict[str, Any]]:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path + ".lock", "w") as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        state = _read(path)
+        yield state
+        fd, tmp = tempfile.mkstemp(dir=os.path.dirname(path), suffix=".tmp")
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            json.dump(state, fh, default=str)
+        os.replace(tmp, path)
+
+
+@contextmanager
+def locked(session_id: str) -> Iterator[Dict[str, Any]]:
+    """Yield the session state for update; whatever it holds on exit is written back."""
+    with _locked(session_path(session_id)) as state:
+        yield state
+
+
+@contextmanager
+def locked_project(project_dir: str) -> Iterator[Dict[str, Any]]:
+    """Like :func:`locked`, for the project memory. Take it after the session lock."""
+    with _locked(project_path(project_dir)) as state:
+        state["project_dir"] = os.path.abspath(project_dir)
+        yield state
+
+
+def latest_session(cwd: Optional[str] = None) -> Optional[str]:
+    """The most recently updated session, optionally only one whose project contains *cwd*."""
+    folder = state_dir()
+    try:
+        names = [n for n in os.listdir(folder) if n.endswith(".json")]
+    except OSError:
+        return None
+    names.sort(key=lambda n: os.path.getmtime(os.path.join(folder, n)), reverse=True)
+    for name in names:
+        sid = name[:-5]
+        project = read(sid).get("project_dir")
+        if cwd is None or (project and (cwd == project or cwd.startswith(project + os.sep))):
+            return sid
+    return None
+
+
+def reset(session_id: str) -> None:
+    with locked(session_id) as state:
+        keep = {k: state[k] for k in ("project_dir",) if k in state}
+        state.clear()
+        state.update(keep)
+
+
+def reset_project(project_dir: str) -> None:
+    with locked_project(project_dir) as state:
+        state.clear()
+
+
+__all__: List[str] = ["state_dir", "session_path", "project_path", "read", "read_project",
+                       "locked", "locked_project", "latest_session", "reset", "reset_project"]

agentltl_coding-0.2.4.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: agentltl-coding
+Version: 0.2.4
+Summary: AgentLTL rules for coding agents: the AGENTLTL.yaml language, a rule library, and a guard any harness can call.
+License: MIT
+Project-URL: Homepage, https://agentltl.github.io
+Project-URL: Source, https://github.com/AgentLTL/agentltl-coding
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agentltl>=0.2
+Requires-Dist: cli-to-tools>=0.2
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Dynamic: license-file
+
+# agentltl-coding
+
+AgentLTL rules for coding agents, whatever the harness: the `AGENTLTL.yaml` rule language, a
+library of tested rules, and a guard that decides each tool call before it runs.
+
+- **Rules** in plain YAML, compiled to [AgentLTL](https://github.com/AgentLTL/AgentLTL)
+  formulas over the calls made so far:
+
+  ```yaml
+  rules:
+    - id: tests-before-push
+      before: {first: pytest, then: git_push, since: [Edit, Write]}
+      why: CI is slow; run the tests locally first.
+      mode: warn
+  use: [no-force-push, protect-secret-files]   # from the library
+  ```
+
+- **Shell commands** are checked as the structured calls of their command line
+  ([cli-to-tools](https://github.com/AgentLTL/cli-to-tools)): `git add . && git push -f` is
+  `git_add`, then `git_push {force: true}`, checked all or nothing, with redirections,
+  paths after `cd`, and files only known at run time accounted for.
+- **Modes** map one to one onto AgentLTL severities: `block`, `warn` (the agent may insist),
+  `ask` (you decide), `retry` (then you decide), `stop`, `log`.
+- **Memory:** each rule reads the calls of this session, or of the project across sessions.
+
+Four harnesses are built on it: the
+[Claude Code plugin](https://github.com/AgentLTL/agentltl-claude-code), the
+[GitHub Copilot CLI plugin](https://github.com/AgentLTL/agentltl-copilot-cli), the
+[Mistral Vibe plugin](https://github.com/AgentLTL/agentltl-mistral-vibe) and the
+[Codex plugin](https://github.com/AgentLTL/agentltl-codex). The full rule
+reference is on [agentltl.github.io](https://agentltl.github.io/rules/).
+
+## Installation
+
+Most people want a plugin for their agent, not this library: paste the prompt from the
+plugin's README into your agent ([Claude Code](https://github.com/AgentLTL/agentltl-claude-code#installation),
+[Codex](https://github.com/AgentLTL/agentltl-codex#installation),
+[Copilot CLI](https://github.com/AgentLTL/agentltl-copilot-cli#installation),
+[Mistral Vibe](https://github.com/AgentLTL/agentltl-mistral-vibe#installation)). To build a
+harness for another agent, paste this into your coding agent:
+
+```
+Install agentltl-coding (pip install "git+https://github.com/AgentLTL/agentltl-coding.git" in a virtual environment) and read its README at https://github.com/AgentLTL/agentltl-coding, then help me write a harness for my agent.
+```
+
+## A harness in a few lines
+
+```python
+from agentltl_coding import Harness, Session, configure
+
+configure(Harness(name="my-agent", agent="the agent", user_dir="~/.my-agent",
+                  shell_tools={"Bash": "command"},
+                  tool_aliases={"shell": ("Bash", {"cmd": "command"}),
+                                "write_file": ("Write", {"path": "file_path"})}))
+
+s = Session(cwd, project_root, session_id)       # one per hook call; state is on disk
+if s.files:                                      # an AGENTLTL.yaml applies here
+    verdict = s.pre("shell", {"cmd": "git push --force"})      # before the call
+    # verdict.action: "none" | "deny" | "ask" | "stop"; verdict.reason: the message
+    ...
+    s.post("shell", {"cmd": "pytest"}, call_id, output, status=0)   # after it ran
+    s.finish()          # the agent wants to stop: "block" while a `finally` rule is unmet
+    s.prompt()          # the user wrote: lift a `stop`
+```
+
+`Harness` says what differs between agents:
+
+- the agent's name in messages, and where the user's `AGENTLTL.yaml` lives;
+- `tool_aliases`: its tool names mapped onto the canonical ones rules use (Claude Code's
+  `Bash`, `Write`, `Edit`, `Read`...), so the library works unchanged (Copilot's
+  `create {path, file_text}` is `Write {file_path, content}`);
+- which tools take shell command lines, and the permission modes in which nobody answers a
+  prompt;
+- built-in rules of its own (`memory-first`), and where its memory lives, for
+  `agentltl memory scan` (`agentltl_coding.memory`).
+
+`Session` is what the hooks do: it keeps the session and project traces on disk, holds a
+`stop` until the user replies, logs interventions, and scans call output for credentials.
+`Guard` underneath decides one call. `agentltl_coding.cli.main(argv, extend=...)` is the
+`agentltl` command (validate, check, translate, tools, library, use, memory...), to which a
+harness can add commands. A library entry with `harnesses: [claude-code]` is for that agent
+only; elsewhere `use:` of it switches nothing on, so one project file serves every agent.
+
+## Testing a harness end to end
+
+`e2e/` lets a plugin test itself in the real agent, without a model or an account:
+
+- `e2e/scripted_model.py SCRIPT.json` serves the OpenAI chat-completions, OpenAI responses
+  and Anthropic messages formats (Mistral Vibe, Copilot CLI with a custom provider, Codex with
+  `wire_api = "responses"`, Claude Code with `ANTHROPIC_BASE_URL`) and answers each request with the next step of a script: tool calls,
+  then a final text.
+- `e2e/check.py TRACE EXPECTED` checks that `agentltl trace` shows the expected refusals, in
+  order.
+- `.github/workflows/agent-e2e.yml` is a reusable workflow: it runs the plugin's
+  `docker/e2e.sh` and, when that fails on a pull request (such as Dependabot's update of the
+  agent's version), says so on the pull request and mentions who to notify.
+
+Each plugin pins the agent version it tests in `docker/` (a `package.json` or a
+`requirements.txt`), so Dependabot proposes every new release as a pull request.
+
+## Develop
+
+```bash
+pip install -e ".[dev]" "agentltl @ git+https://github.com/AgentLTL/AgentLTL.git" \
+    "cli-to-tools @ git+https://github.com/AgentLTL/cli-to-tools.git"
+pytest -q
+```
+
+`tests/golden/verdicts.json` records what every packaged rule, example file and formula
+rule decides, step by step; a change that alters a verdict regenerates it
+(`AGENTLTL_GOLDEN_UPDATE=1 pytest tests/test_golden.py`) and shows up as a reviewed diff.

agentltl_coding-0.2.4.dist-info/RECORD

@@ -0,0 +1,40 @@
+agentltl_coding/__init__.py,sha256=-bsuqhM7lxy_x8-tdUwDhoh7RGtU5dUk28TGflB0i9A,991
+agentltl_coding/cli.py,sha256=mtbKqiysDywC-hcBRpUL8VuhLbB1il8XEARPLd_QdwE,20686
+agentltl_coding/edit.py,sha256=Fw_IYv-cn7OMKFbRPiHkMulh9E0g6IX5rP56TfqgajQ,2690
+agentltl_coding/guard.py,sha256=tsLz09sGwaFa-cvdMGAefsu3wAg5eoAnbnz2ODeOHVI,23281
+agentltl_coding/harness.py,sha256=xrI5p9N7k6F18DrK2KTHi9DmrYtUhoQmgiK1OYju-VU,4771
+agentltl_coding/memory.py,sha256=ZtDfbcfsEERLgHjrNUpacmt5Y0RK22vkUmGe171tUHo,17820
+agentltl_coding/pattern.py,sha256=eY8C7YSKQNxP41-ZjXBK8_Y-2enZTn00DPLvekYdifw,13234
+agentltl_coding/rules.py,sha256=OtNCKLbf4nwcNKVBm0esOiZmwCNUOH-fDc2CR9Nfqts,41675
+agentltl_coding/scan.py,sha256=owdbGriXg9zvpQdGflO3fL25E9xyIPQeL0eLq6PMz6g,2631
+agentltl_coding/session.py,sha256=i2Kxl5Td7bE1E1B2UZ-0qh097wio0U-Ghbx8tGHOzJ8,7669
+agentltl_coding/store.py,sha256=oDe7HwkUY3QaGU1iEvu_Zu4qVDG_5kpwREfMXC-G-xU,4367
+agentltl_coding/library/ask-before-creating-credentials.yaml,sha256=Al2_JHoo-3JXORY0t8xGz5PtYPInzKaBw8-0YE7-Hag,582
+agentltl_coding/library/ask-before-discarding-work.yaml,sha256=-tn4y_14UyyKb4AD3_hMp7RW_pzzi3YCTc-3KEAxSAI,492
+agentltl_coding/library/ask-before-infra-changes.yaml,sha256=bKGPnrVtdnw6fhufBWw6O1o1vDwaG1LbHvhg_XN9HtE,484
+agentltl_coding/library/ask-before-installing.yaml,sha256=_nHRBBy5jHqgpuz0MdzH5n3OAkDn_KBYtN1rU28HYtk,557
+agentltl_coding/library/ask-before-reading-secret-stores.yaml,sha256=qPgc_V4sOYo9WJ-p6_MBoW190k3IJEcfpvH3D4btZu0,2365
+agentltl_coding/library/ask-before-recursive-delete.yaml,sha256=r9mE6eMg6S-cRJMfKRa0fYa3kIZPCCaAIUwWP-EIu9M,222
+agentltl_coding/library/devops-secrets.yaml,sha256=L86wDUFsM__Hd4auZgHa2Vkx_KH27cp6gvaQdIYY1ME,404
+agentltl_coding/library/no-claude-coauthor.yaml,sha256=XoUgeHt0rt3ueNkO7qDVLkWc5dGJNVxY6RqD2oBMa50,602
+agentltl_coding/library/no-codex-coauthor.yaml,sha256=VJ_-FZMUE2LYNcMQ9Pn2_nw_ric0Mz2QQOZsRX1cCkY,587
+agentltl_coding/library/no-copilot-coauthor.yaml,sha256=Y2zJ_SWrD4kjgr_0pvy2WecbVgusrXb_CO1ZvY54_8A,580
+agentltl_coding/library/no-env-dumps.yaml,sha256=GBdc15SXtBUbgpyAVt6WDR6Cico1vaWImOyyJ-NMTZY,938
+agentltl_coding/library/no-force-push.yaml,sha256=-esr5Ue9gMlZuapyCBpGqV8S0FBKVcTXtyM75JSD9CI,321
+agentltl_coding/library/no-leaky-debug.yaml,sha256=sCUKpPZYvuIWSDVcekf1f3Ht4PtYgglo0KHiHDCLqls,709
+agentltl_coding/library/no-push-to-main.yaml,sha256=VyMt5E9KBjW8WNvi1_UwbDsT6BKgwIiwtzSwDsCMB1U,339
+agentltl_coding/library/no-secrets-in-commands.yaml,sha256=_M_2tAoivUYjBA1nbYZ6jSbK8uiWHMPpgT3Gw65KKFI,1356
+agentltl_coding/library/no-skipping-secret-scans.yaml,sha256=80s2v4BYBWTzNLo1CyCPTAqdSVMUgTcK9bgfa53pCBY,415
+agentltl_coding/library/no-vibe-coauthor.yaml,sha256=ql8uXkQrbQySCFEct3AGBKDFtQ-GLm02eofJXSa5O_Q,620
+agentltl_coding/library/protect-env-files.yaml,sha256=dE91Jc3GWGf6DBaE7qd31-c2o0z7x7wAtoVMpI5G2lI,474
+agentltl_coding/library/protect-secret-files.yaml,sha256=r1lP5rfrLlPyatKm0Kror48bjONqkBHEBN8XcwOSrPk,1660
+agentltl_coding/library/read-before-overwrite.yaml,sha256=VfeVl8hGSvBEv6Ai88bIuA9pW0Txe4GRvBNu75AgsJc,519
+agentltl_coding/library/subagents-on-sonnet.yaml,sha256=arF7txB3cejhpK97GnQ06iy8X3Sz8IHmZTVbpyADtdM,619
+agentltl_coding/library/tests-before-finishing.yaml,sha256=tbRgXDGKDEAutE6w7S8MJe9GtYp4FuvQOC3s7cp-cdI,631
+agentltl_coding/library/tests-before-push.yaml,sha256=-KvlpX_pNOQ-k8mbs8dNO_LusmKSFm42nCrFlNHbXJY,771
+agentltl_coding-0.2.4.dist-info/licenses/LICENSE,sha256=s8Kl1HVH8xqtOmxdNgTs-k9B8E6jYtpoF-u8k5WECac,1072
+agentltl_coding-0.2.4.dist-info/METADATA,sha256=qQzlIa5SqrOPkpqKCNPdYL2482P4_xhnmZejdTS9mAw,6441
+agentltl_coding-0.2.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+agentltl_coding-0.2.4.dist-info/entry_points.txt,sha256=F8jVGaO3XCi60loecZlnq_5T4GnGpkzhnOE_GG0zzPo,54
+agentltl_coding-0.2.4.dist-info/top_level.txt,sha256=U6DuI1edF6v8PK7oKaiHubdumNVs9btT8unBtnBqlwU,16
+agentltl_coding-0.2.4.dist-info/RECORD,,

agentltl_coding-0.2.4.dist-info/WHEEL

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

agentltl_coding-0.2.4.dist-info/entry_points.txt

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

agentltl_coding-0.2.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Laïla Elkoussy
+
+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.

agentltl_coding-0.2.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+agentltl_coding