agentledger-cli 0.1.0__py3-none-any.whl

agentledger/git_context.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""AgentLedger hook: tell the Snowflake app which repo and branch a coding-agent
+session is working on, so its cost can be attributed to branches and pull requests.
+
+Runs on SessionStart, UserPromptSubmit and SubagentStart (Cortex Code and Claude Code hook
+format). Every prompt is reported with a running count, so the app can count turns exactly;
+SessionStart is reported only when the git state changed. For SubagentStart it reports the
+sub-agent's session with its parent, because Cortex Code's telemetry records sub-agents as
+separate sessions without linking them.
+It reads the hook payload from stdin, collects git state for the session's working
+directory, and, when the state changed, calls <app>.core.register_git_context in the
+background through the Snowflake CLI. The hook itself returns immediately and never fails
+the agent: any problem is logged to ~/.cache/agentledger/hook.log.
+
+No configuration is needed when the app publishes this plugin (it writes the app name to
+config.json in the plugin root) and the agent is Cortex Code (the session's Snowflake
+connection is read from its metadata file). Otherwise, or to override, use
+~/.snowflake/agentledger.json:
+  {"app": "AGENTLEDGER", "connection": "my_conn", "role": "DEVELOPER"}
+Environment variables AGENTLEDGER_APP / AGENTLEDGER_CONNECTION / AGENTLEDGER_ROLE override both.
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+from datetime import datetime, timezone
+
+STATE_DIR = os.path.expanduser("~/.cache/agentledger")
+CONFIG_PATH = os.path.expanduser("~/.snowflake/agentledger.json")
+PLUGIN_CONFIG_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "config.json")
+LOG_PATH = os.path.join(STATE_DIR, "hook.log")
+MAX_LOG_BYTES = 256 * 1024
+IDENTIFIER = re.compile(r"^[A-Za-z_][A-Za-z0-9_$]*(\.[A-Za-z_][A-Za-z0-9_$]*)?$")
+
+
+def log(message):
+    try:
+        os.makedirs(STATE_DIR, exist_ok=True)
+        if os.path.exists(LOG_PATH) and os.path.getsize(LOG_PATH) > MAX_LOG_BYTES:
+            os.replace(LOG_PATH, LOG_PATH + ".1")
+        with open(LOG_PATH, "a") as f:
+            f.write(f"{datetime.now(timezone.utc).isoformat()} {message}\n")
+    except OSError:
+        pass
+
+
+def read_json(path):
+    try:
+        with open(path) as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def load_config(session_meta=None):
+    """Defaults < plugin config.json < session metadata < user config file < environment."""
+    config = {"app": "AGENTLEDGER", "connection": None, "role": None}
+    sources = [
+        read_json(PLUGIN_CONFIG_PATH),
+        {"connection": (session_meta or {}).get("connection_name")},
+        read_json(CONFIG_PATH),
+    ]
+    for source in sources:
+        config.update({k: v for k, v in source.items() if k in config and v})
+    for key in config:
+        config[key] = os.environ.get(f"AGENTLEDGER_{key.upper()}", config[key])
+    return config
+
+
+def session_metadata(transcript_path):
+    """Cortex Code's per-session metadata (connection_name, git_branch, ...), if that's what
+    the hook's transcript_path points at. Claude Code transcripts are JSONL and yield {}."""
+    if not transcript_path or not transcript_path.endswith(".json"):
+        return {}
+    return read_json(transcript_path)
+
+
+def parse_remote(url):
+    """Return (host, slug) for a git remote URL, dropping any credentials and the port.
+
+    Handles scp-style (git@host:group/repo.git), ssh://, https:// and git:// remotes, and
+    nested GitLab groups (host/group/subgroup/repo).
+    """
+    if not url:
+        return None, None
+    url = url.strip()
+    scp = re.match(r"^(?:[^@/]+@)?([^:/]+):(?!//)(.+)$", url)
+    if scp and "://" not in url:
+        host, path = scp.group(1), scp.group(2)
+    else:
+        m = re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://(?:[^@/]*@)?([^/:]+)(?::\d+)?/(.+)$", url)
+        if not m:
+            return None, None
+        host, path = m.group(1), m.group(2)
+    path = re.sub(r"\.git/?$", "", path.strip("/"))
+    if not path or "/" not in path:
+        return host.lower(), None
+    return host.lower(), path.lower()
+
+
+def git(cwd, *args):
+    out = subprocess.run(["git", "-C", cwd, *args], capture_output=True, text=True, timeout=5)
+    return out.stdout.strip() if out.returncode == 0 else None
+
+
+def git_state(cwd):
+    if not git(cwd, "rev-parse", "--is-inside-work-tree"):
+        return None
+    host, slug = parse_remote(git(cwd, "config", "--get", "remote.origin.url"))
+    branch = git(cwd, "rev-parse", "--abbrev-ref", "HEAD")
+    return {
+        "repo_host": host,
+        "repo_slug": slug,
+        "branch": None if branch == "HEAD" else branch,  # detached HEAD
+        "head_sha": git(cwd, "rev-parse", "HEAD"),
+        "is_dirty": bool(git(cwd, "status", "--porcelain", "--untracked-files=no")),
+    }
+
+
+def sql_string(value):
+    """Quote a value as a Snowflake single-quoted string literal."""
+    return "'" + value.replace("\\", "\\\\").replace("'", "\\'") + "'"
+
+
+def build_call(app, payload):
+    if not IDENTIFIER.match(app):
+        raise ValueError(f"invalid app name: {app!r}")
+    return f"CALL {app}.core.register_git_context(PARSE_JSON({sql_string(json.dumps(payload))}))"
+
+
+def state_path(session_id):
+    safe = re.sub(r"[^A-Za-z0-9_.-]", "_", session_id)[:128]
+    return os.path.join(STATE_DIR, f"session-{safe}.json")
+
+
+def next_prompt(session_id):
+    """Count this session's prompts (1, 2, ...), so the app can count turns exactly."""
+    path = state_path(session_id)[:-len(".json")] + ".prompts"
+    try:
+        with open(path) as f:
+            n = int(f.read().strip() or 0) + 1
+    except (OSError, ValueError):
+        n = 1
+    os.makedirs(STATE_DIR, exist_ok=True)
+    with open(path, "w") as f:
+        f.write(str(n))
+    return n
+
+
+def changed_since_last_report(session_id, state):
+    """True if this session hasn't reported this repo/branch/commit yet."""
+    key = {k: state[k] for k in ("repo_host", "repo_slug", "branch", "head_sha")}
+    path = state_path(session_id)
+    try:
+        with open(path) as f:
+            if json.load(f) == key:
+                return False
+    except (OSError, ValueError):
+        pass
+    os.makedirs(STATE_DIR, exist_ok=True)
+    with open(path, "w") as f:
+        json.dump(key, f)
+    return True
+
+
+def detect_agent(transcript_path):
+    if transcript_path and "/.snowflake/cortex/" in transcript_path:
+        return "cortex-code"
+    if transcript_path and "/.claude/" in transcript_path:
+        return "claude-code"
+    return "claude-code" if "CLAUDE_PROJECT_DIR" in os.environ else "cortex-code"
+
+
+def send(config, sql):
+    cmd = ["snow", "sql", "--silent", "--enable-templating", "NONE", "-q", sql]
+    if config["connection"]:
+        cmd += ["-c", config["connection"]]
+    if config["role"]:
+        cmd += ["--role", config["role"]]
+    out = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+    if out.returncode != 0 or "ok" not in out.stdout:
+        log(f"register_git_context failed ({out.returncode}): {(out.stderr or out.stdout).strip()[:500]}")
+
+
+def main():
+    if len(sys.argv) == 3 and sys.argv[1] == "--send":
+        send(load_config(), sys.argv[2])
+        return
+
+    try:
+        hook = json.load(sys.stdin)
+    except ValueError:
+        return
+    session_id = hook.get("session_id")
+    event = hook.get("hook_event_name")
+    parent = None
+    if event == "SubagentStart":
+        parent = hook.get("parent_session_id") or session_id
+        session_id = hook.get("agent_id")
+    cwd = hook.get("cwd") or os.environ.get("CORTEX_PROJECT_DIR") or os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
+    if not session_id:
+        return
+
+    state = git_state(cwd)
+    prompt_seq = next_prompt(session_id) if event == "UserPromptSubmit" else None
+    changed = state is not None and changed_since_last_report(session_id, state)
+    if not (parent or prompt_seq or changed):
+        return
+    # Sub-agents and prompts are reported even outside a repo (the app counts turns from prompts).
+    state = state or {k: None for k in ("repo_host", "repo_slug", "branch", "head_sha", "is_dirty")}
+
+    transcript_path = hook.get("transcript_path")
+    config = load_config(session_metadata(transcript_path))
+    payload = {
+        "session_id": session_id,
+        "event": event,
+        "agent": detect_agent(transcript_path),
+        "observed_at": datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S.%f"),
+        **state,
+    }
+    if parent:
+        payload.update(parent_session_id=parent, agent_type=hook.get("agent_type"))
+    if prompt_seq:
+        payload["prompt_seq"] = prompt_seq
+    # Detach so the agent never waits on the Snowflake round trip. The resolved connection
+    # and role go through the environment, since the child has no hook payload.
+    env = dict(os.environ)
+    env.update({f"AGENTLEDGER_{k.upper()}": v for k, v in config.items() if v})
+    subprocess.Popen(
+        [sys.executable, os.path.abspath(__file__), "--send", build_call(config["app"], payload)],
+        stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        start_new_session=True, env=env,
+    )
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:  # a broken hook must never break the agent
+        log(f"hook error: {e!r}")

agentledger/hooks.py

@@ -0,0 +1,94 @@
+"""Adding and removing the agentledger hook in an agent's JSON hook file.
+
+Cursor's ~/.cursor/hooks.json lists commands per event:
+    {"version": 1, "hooks": {"stop": [{"command": "..."}]}}
+Claude Code's settings.json nests them in matcher groups:
+    {"hooks": {"Stop": [{"hooks": [{"type": "command", "command": "..."}]}]}}
+Only entries that run agentledger are touched; everything else in the file is kept as it was.
+"""
+import shlex
+from pathlib import Path
+
+from .config import read_json, write_json
+
+# The repo's own hook script, before the agentledger CLI. Replaced on install.
+LEGACY = "session_hook.py"
+
+
+def is_ours(command, legacy=True):
+    try:
+        words = shlex.split(command) if isinstance(command, str) else []
+    except ValueError:
+        return False
+    names = ("agentledger", LEGACY) if legacy else ("agentledger",)
+    return any(Path(w).name in names for w in words[:2])
+
+
+def _commands(entry, nested):
+    if not isinstance(entry, dict):
+        return []
+    if not nested:
+        return [entry.get("command")]
+    return [h.get("command") for h in entry.get("hooks") or [] if isinstance(h, dict)]
+
+
+def _without_ours(entry, nested):
+    """The entry with our commands taken out, or None when nothing else is left in it."""
+    if not any(is_ours(c) for c in _commands(entry, nested)):
+        return entry
+    if not nested:
+        return None
+    rest = [h for h in entry["hooks"] if not (isinstance(h, dict) and is_ours(h.get("command")))]
+    return {**entry, "hooks": rest} if rest else None
+
+
+def _strip(hooks, nested):
+    for event in list(hooks):
+        if not isinstance(hooks[event], list):
+            continue
+        kept = [e for e in (_without_ours(e, nested) for e in hooks[event]) if e is not None]
+        if kept:
+            hooks[event] = kept
+        elif hooks[event]:
+            del hooks[event]
+
+
+def present(path, nested):
+    """True when the file runs the current agentledger hook."""
+    hooks = read_json(path).get("hooks") or {}
+    return any(is_ours(c, legacy=False) for entries in hooks.values() if isinstance(entries, list)
+               for entry in entries for c in _commands(entry, nested))
+
+
+def install(path, events, command, nested):
+    """Points `events` at `command`, replacing earlier agentledger entries. Returns whether the
+    file changed."""
+    data = read_json(path)
+    before = repr(data)
+    hooks = data.setdefault("hooks", {})
+    if not nested:
+        data.setdefault("version", 1)
+    _strip(hooks, nested)
+    for event in events:
+        hooks.setdefault(event, []).append(
+            {"hooks": [{"type": "command", "command": command}]} if nested else {"command": command})
+    if repr(data) == before:
+        return False
+    write_json(path, data)
+    return True
+
+
+def remove(path, nested):
+    """Removes every agentledger entry. Returns whether the file changed."""
+    data = read_json(path)
+    hooks = data.get("hooks")
+    if not isinstance(hooks, dict) or not hooks:
+        return False
+    before = repr(data)
+    _strip(hooks, nested)
+    if not hooks:
+        del data["hooks"]
+    if repr(data) == before:
+        return False
+    write_json(path, data)
+    return True

agentledger/repo.py

@@ -0,0 +1,96 @@
+"""Which git repository a session worked in, and on which branches."""
+import re
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .git_context import git, git_state
+
+# Reflog entries that leave HEAD on another branch (a rebase's own checkouts are transient).
+MOVES = re.compile(r"^(?:checkout: moving from (?P<left>\S+) to |rebase \(finish\): returning to (?:refs/heads/)?)"
+                   r"(?P<to>\S+)$")
+SHA = re.compile(r"[0-9a-f]{7,40}")
+
+# Tool arguments that name a file or folder, across agents.
+PATH_ARGS = ("path", "file_path", "working_directory", "target_directory", "dir_path")
+# A repository at the home folder holds dotfiles, never the project.
+HOME = str(Path.home())
+
+
+def toplevel(folder):
+    top = git(str(folder), "rev-parse", "--show-toplevel") if Path(folder).is_dir() else None
+    return None if top == HOME else top
+
+
+def repo_of_paths(paths):
+    """The git repository most of these absolute paths are in, or None."""
+    tops, counts = {}, Counter()
+    for raw in paths:
+        if not isinstance(raw, str) or not raw.startswith("/"):
+            continue
+        folder = Path(raw) if Path(raw).is_dir() else Path(raw).parent
+        if folder not in tops:
+            tops[folder] = toplevel(folder)
+        if tops[folder]:
+            counts[tops[folder]] += 1
+    return counts.most_common(1)[0][0] if counts else None
+
+
+def repo_state(folder):
+    """The git state the git hook would report for a folder, or None outside a repository. A
+    repository without a remote is named after its folder, on host "local"."""
+    top = toplevel(folder) if folder else None
+    state = git_state(top) if top else None
+    if state and not state["repo_slug"]:
+        state["repo_host"], state["repo_slug"] = "local", Path(top).name
+    return state
+
+
+def checkouts(top):
+    """When HEAD moved to another branch, oldest first, from the reflog: (naive UTC datetime,
+    branch left, branch moved to). A detached HEAD (a commit or a remote branch) is None; so is
+    the branch a rebase left, which the reflog doesn't name."""
+    log = git(top, "reflog", "--date=unix", "--format=%gd%x09%gs") or ""
+    remotes = set((git(top, "for-each-ref", "--format=%(refname:short)", "refs/remotes") or "").split())
+
+    def branch(name):
+        return None if not name or name == "HEAD" or SHA.fullmatch(name) or name in remotes else name
+
+    moves = []
+    for line in log.splitlines():
+        stamp, _, subject = line.partition("\t")
+        when, move = re.search(r"\{(\d+)\}", stamp), MOVES.match(subject)
+        if when and move:
+            moves.append((datetime.fromtimestamp(int(when[1]), timezone.utc).replace(tzinfo=None),
+                          branch(move["left"]), branch(move["to"])))
+    return moves[::-1]
+
+
+def git_reports(folder, started, prompts):
+    """Git reports for a session in `folder` whose files don't record branches: the state when it
+    started, at each branch checkout since (from the reflog) and at its latest prompt, each with
+    the number of prompts sent by then. Times are naive UTC datetimes; the commit and dirty flag
+    are known only for the branch checked out now. [] outside a repository."""
+    state = repo_state(folder)
+    if not state:
+        return []
+    moves = checkouts(toplevel(folder))
+    before, after = [m for m in moves if m[0] <= started], [m for m in moves if m[0] > started]
+    if before:
+        branch = before[-1][2]
+    elif after:
+        branch = after[0][1] if after[0][1] else after[0][2]
+    else:
+        branch = state["branch"]
+    points = [(started, branch)] + [(t, to) for t, _, to in after]
+    latest = max(prompts[-1] if prompts else started, started)
+    if points[-1][0] < latest:
+        points.append((latest, points[-1][1]))
+    reports = []
+    for when, branch in points:
+        report = {**state, "observed_at": f"{when:%Y-%m-%d %H:%M:%S}", "prompt_seq": sum(p <= when for p in prompts)}
+        if branch != state["branch"]:
+            report.update(branch=branch, head_sha=None, is_dirty=None)
+        reports.append(report)
+    reports[-1]["prompt_seq"] = len(prompts)
+    return reports

agentledger/runner.py

@@ -0,0 +1,92 @@
+"""Reporting sessions in the background, so an agent never waits on Snowflake.
+
+A hook call queues its session under ~/.cache/agentledger/pending/ and returns. One detached
+process per agent drains the queue, reading each session's file as it is at that moment, so turns
+that end while it works are picked up by its next pass. Passes start at least MIN_INTERVAL
+apart: a long session is reported every couple of minutes rather than after every turn.
+"""
+import fcntl
+import json
+import os
+import time
+from datetime import datetime, timezone
+
+from .config import STATE
+
+PENDING = STATE / "pending"
+MIN_INTERVAL = 120
+MAX_LOG_BYTES = 256 * 1024
+
+
+def log_path(agent):
+    return STATE / f"{agent}-hook.log"
+
+
+def log(agent, message):
+    path = log_path(agent)
+    STATE.mkdir(parents=True, exist_ok=True)
+    if path.exists() and path.stat().st_size > MAX_LOG_BYTES:
+        os.replace(path, path.with_name(path.name + ".1"))
+    with path.open("a") as f:
+        f.write(f"{datetime.now(timezone.utc):%Y-%m-%d %H:%M:%S} {message}\n")
+
+
+def enqueue(agent, job):
+    PENDING.mkdir(parents=True, exist_ok=True)
+    path = PENDING / f"{agent}-{job['label']}.json"
+    tmp = path.with_name(f".{path.name}")
+    tmp.write_text(json.dumps(job))
+    os.replace(tmp, path)
+
+
+def pending(agent):
+    return sorted(PENDING.glob(f"{agent}-*.json"))
+
+
+def detach(agent):
+    """Forks a process outside the agent's session. Returns True in that process, with its output
+    going to the agent's log, and False in the caller."""
+    if os.fork():
+        return False
+    os.setsid()
+    if os.fork():
+        os._exit(0)
+    STATE.mkdir(parents=True, exist_ok=True)
+    out = os.open(log_path(agent), os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+    null = os.open(os.devnull, os.O_RDONLY)
+    os.dup2(null, 0)
+    os.dup2(out, 1)
+    os.dup2(out, 2)
+    return True
+
+
+def _take(agent):
+    jobs = []
+    for path in pending(agent):
+        try:
+            jobs.append(json.loads(path.read_text()))
+        except (OSError, ValueError):
+            pass
+        path.unlink(missing_ok=True)
+    return jobs
+
+
+def drain(agent, report):
+    """Calls report(jobs) until the queue is empty. Returns at once when another process is
+    already draining it; that one picks up what this one queued."""
+    STATE.mkdir(parents=True, exist_ok=True)
+    last = STATE / f"{agent}-last-pass"
+    while pending(agent):
+        with open(STATE / f"{agent}.lock", "a+") as lock:
+            try:
+                fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except BlockingIOError:
+                return
+            while pending(agent):
+                since = time.time() - (last.stat().st_mtime if last.exists() else 0)
+                if since < MIN_INTERVAL:
+                    time.sleep(MIN_INTERVAL - since)
+                last.touch()
+                report(_take(agent))
+        # Anything queued after the last check, while the lock was still held, is drained by the
+        # next turn of the outer loop.

agentledger/trace.py

@@ -0,0 +1,43 @@
+"""The shape every loader reduces a session to: the model-call rows core.ingest_external_session
+loads, with tool calls packed the way Cortex Code's telemetry packs them."""
+import json
+
+RESULT_CHARS = 12000
+ARG_CHARS = 20000
+
+
+def clip(text, limit):
+    text = "" if text is None else str(text)
+    return text if len(text) <= limit else f"{text[:limit]}\n… ({len(text) - limit:,} more characters)"
+
+
+def clip_args(raw, renames=None):
+    renames = renames or {}
+    return {renames.get(k, k): clip(v, ARG_CHARS) if isinstance(v, str) else v for k, v in (raw or {}).items()}
+
+
+def request(request_id, step, start, end, query, response, tools, **usage):
+    """One model call. `tools` are {"id", "name", "args", "result"}; `usage` is any of model, status
+    and the token counts."""
+    ids = json.dumps([t["id"] for t in tools])
+    names = [t["name"] for t in tools]
+    arg_names = json.dumps([",".join(t["args"]) for t in tools])
+    arg_values = json.dumps([",".join(json.dumps(v) for v in t["args"].values()) for t in tools])
+    return {
+        "request_id": request_id,
+        "step_number": step,
+        "start_ts": start,
+        "end_ts": end,
+        **usage,
+        "query": query,
+        "response": response,
+        "tool_names": names,
+        "selected_ids": ids,
+        "selected_names": json.dumps(names),
+        "selected_arg_names": arg_names,
+        "selected_arg_values": arg_values,
+        "executed_ids": ids,
+        "executed_arg_names": arg_names,
+        "executed_arg_values": arg_values,
+        "executed_results": json.dumps([t["result"] for t in tools]),
+    }

agentledger_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.5
+Name: agentledger-cli
+Version: 0.1.0
+Summary: Report Claude Code, Cursor, Gemini CLI and Cortex Code sessions to the AgentLedger Snowflake Native App.
+Requires-Python: >=3.10
+Requires-Dist: snowflake-connector-python>=3.12
+Description-Content-Type: text/markdown
+
+# agentledger
+
+Reports your Claude Code, Cursor CLI, Gemini CLI and Cortex Code sessions to the AgentLedger Snowflake
+Native App, so your team sees agent cost, prompts and tool use per developer, repo, branch and
+pull request.
+
+```bash
+uv tool install agentledger-cli    # or: pipx install agentledger-cli
+agentledger install
+```
+
+`install` checks that your Snowflake connection can report to the app, then sets up every agent
+it finds:
+
+| Agent | What it adds |
+|---|---|
+| Claude Code | `Stop` and `SessionEnd` hooks in `~/.claude/settings.json` |
+| Cursor CLI | `stop` and `sessionEnd` hooks in `~/.cursor/hooks.json` |
+| Gemini CLI | `AfterAgent` and `SessionEnd` hooks in `~/.gemini/settings.json` (`$GEMINI_CLI_HOME` moves it); Gemini CLI runs hooks in trusted folders |
+| Cortex Code | the app's git plugin (`cortex plugin install <APP>.PLUGINS.AGENTLEDGER`); Snowflake records its sessions already |
+
+After each turn the hook queues the session and returns at once. A background process loads it
+into the app over your own connection, at most every two minutes per agent, so a session is
+always stored as yours. Logs are in `~/.cache/agentledger/`.
+
+## Requirements
+
+- A Snowflake connection in `~/.snowflake/connections.toml` that works without a prompt (key
+  pair or cached SSO), whose role an admin has granted the reporter role:
+  `GRANT APPLICATION ROLE AGENTLEDGER.APP_REPORTER TO ROLE <role>;`
+- Python 3.10 or later.
+
+## Options
+
+```bash
+agentledger install --connection work --role DEVELOPER   # pick the connection and role
+agentledger install --only ~/work                        # report only sessions in these folders
+agentledger install --app AGENTLEDGER_PROD               # the app's name, if it isn't AGENTLEDGER
+agentledger status                                       # what's set up, and each agent's latest report
+agentledger upload claude ~/.claude/projects/*/*.jsonl   # report earlier sessions
+agentledger upload gemini ~/.gemini/tmp/*/chats/*.jsonl
+agentledger uninstall                                    # remove the hooks and the plugin
+```
+
+Settings live in `~/.snowflake/agentledger.json`, which the Cortex Code plugin reads too.

agentledger_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+agentledger/__init__.py,sha256=V7ljJUrzkRr6xRlk9ZDqNFkntCZd5ROK9-BIw4S91Jw,98
+agentledger/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+agentledger/app.py,sha256=KlzLPcKGtzWf_IL1oNFVRaRFZ1wMGgdV8ye4H3dXsfg,1750
+agentledger/cli.py,sha256=cQtIgzVjmJB4c60RjrjYOuF22Y-OMxWp21brNBzdcO0,10200
+agentledger/config.py,sha256=u5MoyOl0Nwt6NJBIQw_8x8DVSLQSEjyy0k2RPA9A0-Y,2421
+agentledger/git_context.py,sha256=CzDQ7rl8XTDKbUJKiAKUM4aHngllsjTz7m0SZqqJN-M,9391
+agentledger/hooks.py,sha256=TiWzxiT4sAjXS9CQyoyaQv_Oc_0ld1QVUH43tsrBhh8,3188
+agentledger/repo.py,sha256=eLqrbmLH2WlMaHiSYOBI9hLGBmOu0LKdavpTt1p1qq0,4164
+agentledger/runner.py,sha256=2YJ2ACkJFQhr6pzeN-fqw_BdgYgRGWb58bi_qDjz-PA,3009
+agentledger/trace.py,sha256=AkFqhNOgZ7c6UEpNru22VUpZ7pUx6ErC7lUBWVW5Hs4,1608
+agentledger/agents/__init__.py,sha256=BnuXvKsIQah3zkAwh7hpgAT-n-CQmA6FFcuIaoUPvIg,579
+agentledger/agents/claude.py,sha256=5d6C1Df7dLvwQlqvwKEc0L4zmJTR3wUverR0u3ZMY1Y,12908
+agentledger/agents/cortex.py,sha256=VDwT-doMUDzxFke1jpEded0axrUCOeVLqxlh7e9A_dw,1351
+agentledger/agents/cursor.py,sha256=kB9L9cO85vK57MP3JJFJJ80xN5jSBXt8VFKANMN4QvA,10058
+agentledger/agents/gemini.py,sha256=2yFI527xAO8cQQrtVrPnSfe1oBS--4GsJKzC-MDEtVY,12391
+agentledger_cli-0.1.0.dist-info/METADATA,sha256=jHxoSXiDXDJHX9YUe_NGMibOO2xtKgNI2OWYpgtzSPI,2455
+agentledger_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+agentledger_cli-0.1.0.dist-info/entry_points.txt,sha256=BVWEN762nxZkUGqr-uD0F3iRPK4tWjrngVf9CEJI2Qc,53
+agentledger_cli-0.1.0.dist-info/RECORD,,

agentledger_cli-0.1.0.dist-info/WHEEL

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

agentledger_cli-0.1.0.dist-info/entry_points.txt

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