agentmap-scan 0.1.0__py3-none-any.whl

agentmap/__init__.py

@@ -0,0 +1,13 @@
+"""agentmap — map every AI API call in a codebase, offline. No LLM, no keys."""
+from .scanner import (
+    Finding, scan, call_sites, providers_found, routing,
+    hardcoded_sites, apply_autofix,
+)
+from .agents import Agent, extract_agents, purpose_by_file
+
+__all__ = [
+    "Finding", "scan", "call_sites", "providers_found", "routing",
+    "hardcoded_sites", "apply_autofix",
+    "Agent", "extract_agents", "purpose_by_file",
+]
+__version__ = "0.1.0"

agentmap/agents.py

@@ -0,0 +1,166 @@
+"""
+Code-only agent + responsibility extraction — no LLM, no API key.
+
+For each source file we find system-prompt strings and the nearest agent name,
+then tidy the prompt to its first sentence. This is a heuristic, not a parser.
+
+ponytail: regex heuristic with a known ceiling — covers raw OpenAI/Anthropic
+message dicts, `system=`/`system_prompt=`/`instructions=` assignments,
+CrewAI `Agent(role=...)`, `brevitas.agent("name")`, and plain enclosing
+functions/classes. It will miss graph-based frameworks (LangGraph node defs,
+AutoGen). Upgrade path: add a per-framework matcher here as users report misses.
+
+    python -m agentmap.agents        # runs the self-check
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from .scanner import _walk  # reuse the same file-walk (skips deps/binaries/docs)
+
+
+# ── system-prompt matchers ─────────────────────────────────────────────────────
+# Each yields the prompt text via group 'p'. Ordered most-specific first.
+_QUOTE = r"""(?:"{3}(?P<p3>.*?)"{3}|'{3}(?P<p3b>.*?)'{3}|"(?P<p1>(?:\\.|[^"\\])*)"|'(?P<p1b>(?:\\.|[^'\\])*)')"""
+
+_PROMPT_PATTERNS = [
+    # {"role": "system", "content": "..."}
+    re.compile(r"""role["']?\s*:\s*["']system["']\s*,\s*["']?content["']?\s*:\s*""" + _QUOTE,
+               re.IGNORECASE | re.DOTALL),
+    # system= / system_prompt= / instructions= / role=, with an optional name
+    # prefix so `copywriter_system = "..."` / `EDITOR_PROMPT = "..."` also match.
+    re.compile(r"""\b\w*(?:system_prompt|system|instructions|_prompt)\s*[:=]\s*""" + _QUOTE,
+               re.IGNORECASE | re.DOTALL),
+    re.compile(r"""\brole\s*[:=]\s*""" + _QUOTE, re.IGNORECASE | re.DOTALL),  # CrewAI Agent(role=)
+]
+
+# ── agent-name matchers (searched upward from the prompt) ───────────────────────
+_NAME_PATTERNS = [
+    re.compile(r"""\.agent\(\s*["'](\w+)["']"""),                 # brevitas.agent("x")
+    re.compile(r"""Agent\([^)]*\bname\s*=\s*["'](\w+)["']"""),    # Agent(name="x")
+    re.compile(r"""\bagent(?:_name)?\s*=\s*["'](\w+)["']"""),     # agent="x"
+    re.compile(r"""\b(\w+?)_(?:system|sys|prompt|instructions)\b\s*[:=]""", re.IGNORECASE),  # copywriter_system=
+    re.compile(r"""\bdef\s+(\w+)\s*\("""),                        # enclosing def
+    re.compile(r"""\bclass\s+(\w+)\b"""),                         # enclosing class
+]
+
+
+# Bare message-role values that leak from {"role": "user"} etc. — not agents.
+_MESSAGE_ROLES = {"system", "user", "assistant", "tool", "function", "developer", "model", "ai"}
+
+
+def _is_test_file(path: Path) -> bool:
+    n = path.name.lower()
+    return (n.startswith("test_") or n.endswith("_test.py")
+            or "test" in path.parts or "tests" in path.parts)
+
+
+@dataclass
+class Agent:
+    name: str
+    role: str          # tidied first sentence of the system prompt
+    file: str
+    line: int
+
+
+def _first_sentence(text: str) -> str:
+    t = re.sub(r"\s+", " ", (text or "").replace("\\n", " ")).strip()
+    # split on sentence end or the first newline-ish boundary
+    m = re.search(r"(.+?[.!?])(?:\s|$)", t)
+    s = m.group(1) if m else t
+    return s.strip()[:120]
+
+
+def _prompt_text(m: re.Match) -> str:
+    gd = m.groupdict()
+    for g in ("p3", "p3b", "p1", "p1b"):
+        if gd.get(g):
+            return gd[g]
+    return ""
+
+
+def extract_agents(root: str | Path) -> list[Agent]:
+    """Find (agent name → responsibility) pairs across a codebase, code-only."""
+    agents: list[Agent] = []
+    seen: set[tuple[str, str]] = set()   # (file, name) dedup
+
+    for path in _walk(Path(root)):
+        if _is_test_file(path):
+            continue  # test fixtures aren't real agents
+        try:
+            text = path.read_text(encoding="utf-8", errors="strict")
+        except (UnicodeDecodeError, OSError):
+            continue
+        lines = text.splitlines()
+
+        for pat in _PROMPT_PATTERNS:
+            for m in pat.finditer(text):
+                prompt = _prompt_text(m)
+                if not prompt or len(prompt.strip()) < 8:
+                    continue
+                if prompt.strip().lower() in _MESSAGE_ROLES:
+                    continue  # a message-role value, not a system prompt
+                line_no = text.count("\n", 0, m.start()) + 1
+                name = _nearest_name(lines, line_no)
+                key = (str(path), name)
+                if key in seen:
+                    continue
+                seen.add(key)
+                agents.append(Agent(name=name, role=_first_sentence(prompt),
+                                    file=str(path), line=line_no))
+    return agents
+
+
+# Generic tokens that are never a useful agent name (they're the prompt keyword itself).
+_GENERIC_NAMES = {"system", "agent", "prompt", "instructions", "role", "messages",
+                  "content", "user", "assistant", "sys", "self", "cls"}
+
+
+def _nearest_name(lines: list[str], line_no: int, look_back: int = 25) -> str:
+    """First non-generic agent-name signal at/above line_no; else the enclosing def/class."""
+    start = max(0, line_no - 1)
+    for i in range(start, max(-1, start - look_back), -1):
+        for pat in _NAME_PATTERNS:
+            m = pat.search(lines[i]) if i < len(lines) else None
+            if m and m.group(1).lower() not in _GENERIC_NAMES:
+                return m.group(1)
+    return "agent"
+
+
+def purpose_by_file(agents: list[Agent]) -> list[tuple[str, str]]:
+    """One purpose line per file = its first agent's role. [(file, role), …]."""
+    out: dict[str, str] = {}
+    for a in agents:
+        out.setdefault(a.file, a.role)
+    return sorted(out.items())
+
+
+# ── self-check ──────────────────────────────────────────────────────────────────
+
+def _selfcheck() -> None:
+    import tempfile
+    fixture = '''
+def researcher(client):
+    messages = [
+        {"role": "system", "content": "You are a market research analyst. Analyze competitors."},
+        {"role": "user", "content": user_input},
+    ]
+    return client.chat.completions.create(model="gpt-4o", messages=messages)
+
+copywriter_system = "You are a senior copywriter. Write punchy ad copy that converts."
+'''
+    with tempfile.TemporaryDirectory() as d:
+        (Path(d) / "agents.py").write_text(fixture)
+        found = extract_agents(d)
+        by_name = {a.name: a.role for a in found}
+        assert "researcher" in by_name, by_name
+        assert by_name["researcher"].startswith("You are a market research analyst"), by_name
+        assert not by_name["researcher"].endswith("competitors."), "should stop at first sentence"
+        assert any("copywriter" in n for n in by_name), by_name
+        print("ok: agents", {k: v[:40] for k, v in by_name.items()})
+
+
+if __name__ == "__main__":
+    _selfcheck()

agentmap/cli.py

@@ -0,0 +1,102 @@
+"""
+agentmap CLI.
+
+    agentmap [PATH]            scan a repo → open a webpage of its AI calls (default)
+    agentmap install [PATH]    write routing env vars; --auto rewrites hardcoded URLs
+"""
+from __future__ import annotations
+
+from collections import Counter
+from pathlib import Path
+
+import click
+
+from .scanner import scan, call_sites, routing, hardcoded_sites, apply_autofix
+from .agents import extract_agents, purpose_by_file
+from .report import render_and_open
+
+
+class DefaultGroup(click.Group):
+    """Group that runs `scan` when the first arg isn't a known subcommand.
+
+    Lets `agentmap PATH --no-open` work (PATH is not a command → falls to scan)
+    while `agentmap install …` still resolves normally.
+    """
+    def resolve_command(self, ctx, args):
+        try:
+            return super().resolve_command(ctx, args)
+        except click.UsageError:
+            return "scan", self.get_command(ctx, "scan"), args
+
+
+@click.group(cls=DefaultGroup, invoke_without_command=True)
+@click.pass_context
+def main(ctx: click.Context) -> None:
+    """Map every AI API call in a codebase. Bare `agentmap` scans the current dir."""
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(scan_cmd)
+
+
+@main.command(name="scan")
+@click.argument("path", default=".")
+@click.option("--target", default="http://localhost:4242", show_default=True,
+              help="Gateway URL to route calls through")
+@click.option("--open/--no-open", "open_", default=True, help="Open the report in a browser")
+def scan_cmd(path: str, target: str, open_: bool) -> None:
+    """Scan PATH and open a webpage of its AI calls, models, and agents."""
+    findings = scan(path)
+    calls = call_sites(findings)
+    plan = routing(findings, proxy=target)
+    agents = extract_agents(path)
+    purposes = purpose_by_file(agents)
+
+    counts = Counter(f.provider for f in calls)
+    click.echo(f"\n{len(calls)} AI call sites · {len(counts)} providers · {len(agents)} agents")
+    for pid, n in counts.most_common():
+        tag = "routed" if pid in plan["auto"] else "manual"
+        click.echo(f"  {n:>4}  {pid:<16} ({tag})")
+    if agents:
+        click.echo("\nagents:")
+        for a in agents:
+            click.echo(f"  {a.name:<16} {a.role}")
+
+    out = render_and_open(path, findings, plan, agents, purposes, open_browser=open_)
+    click.echo(f"\n✓ Report: {out}" + ("" if open_ else "  (drop --no-open to launch it)"))
+
+
+@main.command()
+@click.argument("path", default=".")
+@click.option("--target", default="http://localhost:4242", show_default=True, help="Gateway URL")
+@click.option("--auto", is_flag=True, help="Rewrite hardcoded provider URLs in place (edits your files)")
+@click.option("--env-file", default=".env.agentmap", show_default=True, help="Where to write routing env vars")
+def install(path: str, target: str, auto: bool, env_file: str) -> None:
+    """Route PATH's calls through the gateway: write env vars + handle hardcoded URLs."""
+    findings = scan(path)
+    plan = routing(findings, proxy=target)
+    hard = hardcoded_sites(findings)
+    if not plan["env"] and not hard:
+        click.echo("Nothing to route — no OpenAI/Anthropic-compatible calls found.")
+        return
+
+    lines = ["# agentmap routing — `source` this before running your app\n"]
+    lines += [f"export {k}={v}\n" for k, v in plan["env"].items()]
+    Path(env_file).write_text("".join(lines))
+    click.echo(f"\n✓ Wrote {env_file}  →  source {env_file}")
+    for k, v in plan["env"].items():
+        click.echo(f"    {k}={v}")
+    if plan["manual"]:
+        click.echo(f"\nManual (own SDK, point base_url at {target}): {', '.join(plan['manual'])}")
+
+    if auto:
+        edits = apply_autofix(findings, proxy=target)
+        click.echo(f"\n✓ Rewrote {len(edits)} hardcoded URL(s)")
+        for pth, ln, new in edits[:20]:
+            click.echo(f"    {pth}:{ln}  {new}")
+    elif hard:
+        click.echo(f"\n{len(hard)} hardcoded URL(s) — env vars can't override these. Edit or re-run with --auto:")
+        for f in hard[:20]:
+            click.echo(f"    {f.path}:{f.line}  {f.snippet}")
+
+
+if __name__ == "__main__":
+    main()

agentmap/report.py

@@ -0,0 +1,167 @@
+"""
+Minimalist static HTML report: calls-by-file, providers & models, agents &
+responsibilities, and the routing plan. No backend, no JS — one self-contained file.
+"""
+from __future__ import annotations
+
+import html as _html
+import tempfile
+import webbrowser
+from collections import Counter
+from pathlib import Path
+
+from .scanner import call_sites, hardcoded_sites, providers_found
+from .signatures import MODEL, PROVIDERS_BY_ID
+
+_CSS = """
+* { box-sizing: border-box; }
+body { margin:0; font:14px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;
+       background:#0b0f14; color:#d7dee8; }
+.wrap { max-width:1000px; margin:0 auto; padding:32px 20px 64px; }
+h1 { font-size:20px; margin:0 0 4px; color:#fff; }
+.sub { color:#7c8794; margin:0 0 24px; }
+.cards { display:grid; grid-template-columns:repeat(auto-fit,minmax(150px,1fr)); gap:12px; margin:0 0 28px; }
+.card { background:#131a23; border:1px solid #1f2a37; border-radius:10px; padding:16px; }
+.card .n { font-size:26px; font-weight:700; color:#fff; }
+.card .l { color:#7c8794; font-size:12px; text-transform:uppercase; letter-spacing:.04em; }
+h2 { font-size:13px; text-transform:uppercase; letter-spacing:.05em; color:#7c8794;
+     border-bottom:1px solid #1f2a37; padding-bottom:8px; margin:32px 0 14px; }
+.row { display:flex; align-items:center; gap:10px; margin:6px 0; }
+.row .name { width:150px; color:#d7dee8; }
+.bar { height:16px; background:#2563eb; border-radius:3px; min-width:2px; }
+.bar.manual { background:#f59e0b; }
+.row .c { color:#7c8794; width:70px; }
+.tag { font-size:11px; padding:1px 7px; border-radius:99px; }
+.tag.auto { background:#14351f; color:#4ade80; }
+.tag.manual { background:#3a2a10; color:#f59e0b; }
+pre { background:#0f151d; border:1px solid #1f2a37; border-radius:8px; padding:12px 14px;
+      overflow-x:auto; color:#9fd0ff; }
+code.f { color:#7c8794; }
+.file { margin:10px 0 14px; }
+.fp { color:#fff; font-weight:600; margin-bottom:2px; word-break:break-all; }
+.agent { margin:8px 0; }
+.agent .an { color:#fff; font-weight:600; }
+.agent .ar { color:#9fb3c8; }
+.agent .loc { color:#556; font-size:12px; }
+.hard { color:#f87171; }
+.empty { color:#7c8794; font-style:italic; }
+.foot { margin-top:40px; color:#7c8794; font-size:13px; border-top:1px solid #1f2a37; padding-top:16px; }
+a { color:#60a5fa; }
+"""
+
+
+def _esc(s) -> str:
+    return _html.escape(str(s))
+
+
+def _group_by_file(calls):
+    """[(path, [(line, provider, snippet), …]), …] ordered by call count desc."""
+    from collections import defaultdict
+    d = defaultdict(list)
+    for f in calls:
+        d[f.path].append((f.line, f.provider, f.snippet))
+    for v in d.values():
+        v.sort()
+    return sorted(d.items(), key=lambda kv: len(kv[1]), reverse=True)
+
+
+def _models(findings):
+    """[(provider_name, model, count), …] from MODEL-kind findings, most common first."""
+    c = Counter((PROVIDERS_BY_ID[f.provider].name, f.snippet_model) for f in _model_findings(findings))
+    return [(prov, model, n) for (prov, model), n in c.most_common()]
+
+
+def _model_findings(findings):
+    """Attach the matched model literal to each MODEL finding."""
+    import re
+    for f in findings:
+        if f.kind != MODEL:
+            continue
+        spec = PROVIDERS_BY_ID[f.provider]
+        pat = next((p for p in spec.patterns if p.kind == MODEL), None)
+        if not pat:
+            continue
+        m = pat.regex.search(f.snippet)
+        f.snippet_model = m.group(0) if m else "?"
+        yield f
+
+
+def build_html(path, findings, plan, agents, purposes) -> str:
+    calls = call_sites(findings)
+    counts = Counter(f.provider for f in calls)
+    hard = hardcoded_sites(findings)
+    mx = max(counts.values()) if counts else 1
+
+    prov_rows = "".join(
+        f'<div class="row"><span class="name">{_esc(pid)}</span>'
+        f'<span class="bar {"" if pid in plan["auto"] else "manual"}" style="width:{int(n / mx * 300)}px"></span>'
+        f'<span class="c">{n}</span>'
+        f'<span class="tag {"auto" if pid in plan["auto"] else "manual"}">{"routed" if pid in plan["auto"] else "manual"}</span></div>'
+        for pid, n in counts.most_common()) or '<div class="empty">no AI calls found</div>'
+
+    model_rows = "".join(
+        f'<div class="row"><span class="name">{_esc(prov)}</span>'
+        f'<code class="f">{_esc(model)}</code><span class="c">({n})</span></div>'
+        for prov, model, n in _models(findings)) or '<div class="empty">no model names detected</div>'
+
+    files_html = "".join(
+        f'<div class="file"><div class="fp">{_esc(fpath)}</div>' + "".join(
+            f'<div class="row"><span class="c" style="width:52px">L{ln}</span>'
+            f'<span class="tag {"auto" if pid in plan["auto"] else "manual"}">{_esc(pid)}</span> '
+            f'<code class="f">{_esc(snip[:100])}</code></div>'
+            for ln, pid, snip in items) + '</div>'
+        for fpath, items in _group_by_file(calls)) or '<div class="empty">no AI calls found</div>'
+
+    agents_html = "".join(
+        f'<div class="agent"><span class="an">{_esc(a.name)}</span> — '
+        f'<span class="ar">{_esc(a.role)}</span> '
+        f'<span class="loc">{_esc(a.file)}:{a.line}</span></div>'
+        for a in agents) or '<div class="empty">no agents detected (no system prompts found)</div>'
+
+    purpose_html = "".join(
+        f'<div class="row"><span class="name" style="width:220px">{_esc(Path(f).name)}</span>'
+        f'<span class="ar">{_esc(role)}</span></div>'
+        for f, role in purposes) or '<div class="empty">—</div>'
+
+    env_block = "\n".join(f"export {k}={v}" for k, v in plan["env"].items()) \
+        or "# no OpenAI/Anthropic-compatible calls found"
+    manual = f'<p class="sub">Manual (own SDK, edit base_url): {_esc(", ".join(plan["manual"]))}</p>' if plan["manual"] else ""
+    hard_html = ("".join(
+        f'<div class="row"><span class="hard">{_esc(h.path)}:{h.line}</span> '
+        f'<code class="f">{_esc(h.snippet[:90])}</code></div>' for h in hard[:15])
+        or '<div class="empty">none — every call routes via env vars</div>')
+
+    return f"""<!doctype html><html><head><meta charset="utf-8">
+<title>agentmap — {_esc(path)}</title><style>{_CSS}</style></head><body><div class="wrap">
+<h1>agentmap</h1><p class="sub">AI API calls in <code>{_esc(path)}</code></p>
+<div class="cards">
+  <div class="card"><div class="n">{sum(counts.values())}</div><div class="l">AI call sites</div></div>
+  <div class="card"><div class="n">{len(counts)}</div><div class="l">providers</div></div>
+  <div class="card"><div class="n">{len(agents)}</div><div class="l">agents</div></div>
+  <div class="card"><div class="n">{len(hard)}</div><div class="l">hardcoded URLs</div></div>
+</div>
+
+<h2>Calls by file</h2>{files_html}
+
+<h2>Providers &amp; models</h2>{prov_rows}
+<div style="height:10px"></div>{model_rows}
+
+<h2>Agents &amp; responsibilities</h2>{agents_html}
+<div style="height:14px"></div>
+<h2>Purpose per file</h2>{purpose_html}
+
+<h2>Routing — set these to send calls through your gateway</h2>
+{manual}<pre>{_esc(env_block)}</pre>
+<h2>Hardcoded URLs (need --auto or a manual edit)</h2>{hard_html}
+
+<div class="foot">Generated by <a href="https://github.com/">agentmap</a> ·
+route these calls through <b>Brevitas</b> to compress context and cut token cost.</div>
+</div></body></html>"""
+
+
+def render_and_open(path, findings, plan, agents, purposes, open_browser=True) -> Path:
+    out = Path(tempfile.gettempdir()) / "agentmap_report.html"
+    out.write_text(build_html(str(path), findings, plan, agents, purposes), encoding="utf-8")
+    if open_browser:
+        webbrowser.open(f"file://{out}")
+    return out

agentmap/scanner.py

@@ -0,0 +1,221 @@
+"""
+Repo scanner: walk a codebase, flag every LLM/AI API call site (any language),
+and derive the one-click routing config that sends them through a gateway.
+
+Detection is regex over source lines using the provider registry in
+`signatures.py` — endpoint hosts + call methods catch calls in Go, Rust, PHP,
+Ruby, Java, shell/curl, etc., not just the Python/JS SDKs.
+
+    python -m agentmap.scanner        # runs the self-check
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from .signatures import ENDPOINT, CALL, PROVIDERS_BY_ID, iter_patterns
+
+# Dirs we never scan — vendored deps, VCS, build output. ponytail: hardcoded skip
+# list beats parsing .gitignore; add gitignore support when a repo layout needs it.
+_SKIP_DIRS = {
+    ".git", "node_modules", "dist", "build", ".next", ".venv", "venv",
+    "__pycache__", ".pytest_cache", ".mypy_cache", "vendor", "target",
+    ".vercel", "site-packages", ".idea", ".vscode",
+}
+# Binary / non-source extensions to skip outright.
+_SKIP_EXT = {
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".svg", ".pdf", ".zip",
+    ".gz", ".tar", ".woff", ".woff2", ".ttf", ".eot", ".mp4", ".mp3", ".lock",
+    ".map", ".min.js", ".wasm", ".so", ".dylib", ".bin", ".db",
+    ".md", ".rst",  # prose docs — never a runtime call site, only noise
+}
+_MAX_BYTES = 1_000_000  # skip files larger than 1 MB
+
+
+@dataclass
+class Finding:
+    path: str
+    line: int
+    provider: str          # provider id
+    provider_name: str
+    kind: str              # endpoint | call | import | model
+    snippet: str
+
+
+def scan(root: str | Path) -> list[Finding]:
+    """Scan `root` recursively and return one Finding per (file, line, provider)."""
+    root = Path(root)
+    patterns = list(iter_patterns())
+    findings: list[Finding] = []
+    for path in _walk(root):
+        try:
+            text = path.read_text(encoding="utf-8", errors="strict")
+        except (UnicodeDecodeError, OSError):
+            continue  # binary or unreadable
+        for lineno, raw in enumerate(text.splitlines(), 1):
+            line = raw.strip()
+            if not line:
+                continue
+            seen: set[str] = set()  # dedup per provider per line
+            for provider, pat in patterns:
+                if provider.id in seen:
+                    continue
+                m = pat.regex.search(raw)
+                if m:
+                    seen.add(provider.id)
+                    findings.append(Finding(
+                        path=str(path), line=lineno, provider=provider.id,
+                        provider_name=provider.name, kind=pat.kind,
+                        snippet=line[:160],
+                    ))
+    return findings
+
+
+def _walk(root: Path):
+    for path in root.rglob("*"):
+        if not path.is_file():
+            continue
+        if any(part in _SKIP_DIRS for part in path.parts):
+            continue
+        if path.suffix.lower() in _SKIP_EXT or path.name.endswith(".min.js"):
+            continue
+        try:
+            if path.stat().st_size > _MAX_BYTES:
+                continue
+        except OSError:
+            continue
+        yield path
+
+
+def call_sites(findings: list[Finding]) -> list[Finding]:
+    """Findings that are actual call sites (endpoint or call method), highest signal."""
+    return [f for f in findings if f.kind in (ENDPOINT, CALL)]
+
+
+def providers_found(findings: list[Finding]) -> list[str]:
+    """Provider ids present, ordered by first appearance."""
+    out: list[str] = []
+    for f in findings:
+        if f.provider not in out:
+            out.append(f.provider)
+    return out
+
+
+def routing(findings: list[Finding], proxy: str = "http://localhost:4242") -> dict:
+    """
+    One-click routing plan. OpenAI- and Anthropic-SDK calls redirect with a
+    single env var each (the proxy serves both). OpenAI-compatible providers
+    (deepseek, groq, …) ride the same OPENAI_BASE_URL when called through the
+    OpenAI SDK. Everyone else needs a manual base_url change.
+    """
+    env: dict[str, str] = {}
+    auto: list[str] = []
+    manual: list[str] = []
+    for pid in providers_found(findings):
+        spec = PROVIDERS_BY_ID[pid]
+        if pid == "anthropic":
+            env["ANTHROPIC_BASE_URL"] = proxy
+            auto.append(pid)
+        elif pid == "openai" or spec.openai_compatible:
+            env["OPENAI_BASE_URL"] = f"{proxy}/openai"
+            auto.append(pid)
+        else:
+            manual.append(pid)  # google, cohere, bedrock, replicate, hf, langchain, azure
+    return {"env": env, "auto": auto, "manual": manual, "proxy": proxy}
+
+
+def _route_target(spec, proxy: str) -> str | None:
+    """Proxy base URL a hardcoded site should point at, or None if not auto-routable."""
+    if spec.id == "anthropic":
+        return proxy                       # SDK appends /v1/messages
+    if spec.id == "openai" or spec.openai_compatible:
+        return f"{proxy}/openai"           # SDK appends /chat/completions
+    return None                            # google/cohere/bedrock/hf/… → manual
+
+
+def hardcoded_sites(findings: list[Finding]) -> list[Finding]:
+    """
+    ENDPOINT findings for auto-routable providers = literal provider URLs in
+    source (e.g. base_url="https://api.openai.com/v1"). These bypass the env-var
+    redirect, so they're what `--auto` rewrites (or we flag for a manual edit).
+    """
+    return [f for f in findings
+            if f.kind == ENDPOINT and _route_target(PROVIDERS_BY_ID[f.provider], "") is not None]
+
+
+def apply_autofix(findings: list[Finding], proxy: str = "http://localhost:4242") -> list[tuple[str, int, str]]:
+    """
+    Rewrite each hardcoded provider URL to the Brevitas proxy, in place.
+    Only touches the exact flagged line and only the `https://<host>…` literal on
+    it — never comments elsewhere. Returns (path, line, new_line) for each edit.
+    Skips .md so docs aren't rewritten.
+    """
+    edits: list[tuple[str, int, str]] = []
+    by_file: dict[str, list[Finding]] = {}
+    for f in hardcoded_sites(findings):
+        by_file.setdefault(f.path, []).append(f)
+
+    for path, fs in by_file.items():
+        p = Path(path)
+        if p.suffix.lower() == ".md":
+            continue
+        lines = p.read_text(encoding="utf-8").splitlines(keepends=True)
+        changed = False
+        for f in fs:
+            spec = PROVIDERS_BY_ID[f.provider]
+            target = _route_target(spec, proxy)
+            endpoint_pat = next((pt for pt in spec.patterns if pt.kind == ENDPOINT), None)
+            if target is None or endpoint_pat is None or f.line > len(lines):
+                continue
+            url_re = re.compile(r"https?://" + endpoint_pat.regex.pattern + r"""[^\s'"`)]*""",
+                                re.IGNORECASE)
+            before = lines[f.line - 1]
+            after = url_re.sub(target, before)
+            if after != before:
+                lines[f.line - 1] = after
+                edits.append((path, f.line, after.strip()))
+                changed = True
+        if changed:
+            p.write_text("".join(lines), encoding="utf-8")
+    return edits
+
+
+# ── self-check ────────────────────────────────────────────────────────────────
+
+def _selfcheck() -> None:
+    import tempfile
+    fixtures = {
+        "app.py": "resp = client.chat.completions.create(model='gpt-4o', messages=m)\n",
+        "bot.ts": "const r = await anthropic.messages.create({ model: 'claude-3-5' })\n",
+        "main.go": 'req, _ := http.NewRequest("POST", "https://api.deepseek.com/v1/chat/completions", body)\n',
+        "svc.rb": 'uri = URI("https://generativelanguage.googleapis.com/v1/models")\n',
+        "hard.py": 'client = OpenAI(base_url="https://api.openai.com/v1", api_key=k)\n',
+        "readme.md": "just prose, no api calls here\n",
+    }
+    with tempfile.TemporaryDirectory() as d:
+        for name, body in fixtures.items():
+            (Path(d) / name).write_text(body)
+        f = scan(d)
+        found = providers_found(f)
+        assert "openai" in found, found
+        assert "anthropic" in found, found
+        assert "deepseek" in found, found          # Go, host-only match
+        assert "google_gemini" in found, found     # Ruby, host-only match
+        plan = routing(f)
+        assert plan["env"]["OPENAI_BASE_URL"].endswith("/openai"), plan
+        assert plan["env"]["ANTHROPIC_BASE_URL"] == "http://localhost:4242", plan
+        assert "google_gemini" in plan["manual"], plan  # no env redirect for Gemini
+
+        # hardcoded URL detection + --auto rewrite
+        assert any(h.path.endswith("hard.py") for h in hardcoded_sites(f)), "missed hardcoded"
+        edits = apply_autofix(f)
+        hardpy = (Path(d) / "hard.py").read_text()
+        assert "api.openai.com" not in hardpy, hardpy            # literal rewritten
+        assert "http://localhost:4242/openai" in hardpy, hardpy  # → proxy
+        assert edits, edits
+    print("ok: detected", found, "| autofixed", len(edits))
+
+
+if __name__ == "__main__":
+    _selfcheck()

agentmap/signatures.py

@@ -0,0 +1,324 @@
+"""
+Polyglot signature registry for detecting LLM / AI API calls in source code.
+
+The scanner is deliberately *not* built on per-language AST parsing. Instead it
+matches on provider-identifying signals that appear in the source of **any**
+language:
+
+  1. HTTP endpoint hosts   — `api.openai.com`, `api.anthropic.com`, … These catch
+                             calls made from Go, Rust, PHP, Ruby, Java, shell/curl,
+                             etc., not just the official Python/JS SDKs.
+  2. SDK import / package  — `import openai`, `@anthropic-ai/sdk`, `litellm`, …
+  3. Call-method signatures — `.chat.completions.create`, `.messages.create`,
+                             `generateContent(`, `invoke_model(`, …
+  4. Model-id literals     — `gpt-4o`, `claude-…`, `gemini-…` (supporting evidence,
+                             also used to estimate cost).
+
+Each match carries a `kind` and a `confidence`. A file/line is *flagged as a call
+site* when it has at least one high-confidence signal (endpoint or call method).
+Imports and model IDs are corroborating signals that raise confidence and help
+routing/estimation.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+
+HIGH = "high"
+MEDIUM = "medium"
+LOW = "low"
+
+# Signal kinds
+ENDPOINT = "endpoint"   # a provider HTTP host — language-agnostic, strong
+CALL = "call"           # an SDK call method — strong
+IMPORT = "import"       # an SDK import / package reference — medium
+MODEL = "model"         # a model-id literal — supporting
+
+
+@dataclass(frozen=True)
+class Pattern:
+    """A single compiled signature pattern."""
+    regex: re.Pattern
+    kind: str
+    confidence: str
+
+
+@dataclass(frozen=True)
+class ProviderSpec:
+    """Everything the scanner + installer need to know about one provider."""
+    id: str
+    name: str
+    patterns: tuple[Pattern, ...]
+    # OpenAI-compatible providers can be routed by pointing the OpenAI SDK's
+    # base URL at the Brevitas proxy. `env_base_url` is the env var the official
+    # SDK honors (if any); `honors_env` means it can be routed with zero code
+    # changes. `openai_compatible` means the /openai proxy path applies.
+    env_base_url: str | None = None
+    honors_env: bool = False
+    openai_compatible: bool = False
+    # Approx blended $/1M tokens (input+output), for a *rough* spend estimate.
+    # These are order-of-magnitude anchors — override with --price if it matters.
+    approx_price_per_mtok: float = 5.0
+
+
+def _p(pattern: str, kind: str, confidence: str, *, flags: int = re.IGNORECASE) -> Pattern:
+    return Pattern(re.compile(pattern, flags), kind, confidence)
+
+
+# ── Provider registry ─────────────────────────────────────────────────────────
+# Ordered roughly by specificity; the scanner tries every provider on every line.
+
+PROVIDERS: tuple[ProviderSpec, ...] = (
+    ProviderSpec(
+        id="openai",
+        name="OpenAI",
+        env_base_url="OPENAI_BASE_URL",
+        honors_env=True,
+        openai_compatible=True,
+        approx_price_per_mtok=5.0,
+        patterns=(
+            _p(r"api\.openai\.com", ENDPOINT, HIGH),
+            _p(r"\.chat\.completions\.create\b", CALL, HIGH),
+            _p(r"\.responses\.create\b", CALL, HIGH),
+            _p(r"\.completions\.create\b", CALL, MEDIUM),
+            _p(r"\.embeddings\.create\b", CALL, MEDIUM),
+            _p(r"(?:^|[^.\w])import\s+openai\b|from\s+openai\s+import|require\(['\"]openai['\"]\)|@ai-sdk/openai", IMPORT, MEDIUM),
+            _p(r"\b(?:gpt-4o|gpt-4\.1|gpt-4|gpt-3\.5|o1|o3|o4|text-embedding-3)\b", MODEL, LOW),
+        ),
+    ),
+    ProviderSpec(
+        id="azure_openai",
+        name="Azure OpenAI",
+        env_base_url="AZURE_OPENAI_ENDPOINT",
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=5.0,
+        patterns=(
+            _p(r"[a-z0-9.-]*\.openai\.azure\.com", ENDPOINT, HIGH),
+            _p(r"AzureOpenAI\b", CALL, HIGH),
+            _p(r"azure[_-]?openai", IMPORT, MEDIUM),
+        ),
+    ),
+    ProviderSpec(
+        id="anthropic",
+        name="Anthropic",
+        env_base_url="ANTHROPIC_BASE_URL",
+        honors_env=True,
+        openai_compatible=False,
+        approx_price_per_mtok=9.0,
+        patterns=(
+            _p(r"api\.anthropic\.com", ENDPOINT, HIGH),
+            _p(r"\.messages\.create\b", CALL, HIGH),
+            _p(r"\.messages\.stream\b", CALL, HIGH),
+            _p(r"from\s+anthropic\s+import|(?:^|[^.\w])import\s+anthropic\b|@anthropic-ai/sdk|require\(['\"]@anthropic-ai/sdk['\"]\)", IMPORT, MEDIUM),
+            _p(r"\bclaude-[a-z0-9.\-]+\b", MODEL, LOW),
+        ),
+    ),
+    ProviderSpec(
+        id="google_gemini",
+        name="Google Gemini / Vertex",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=False,
+        approx_price_per_mtok=3.0,
+        patterns=(
+            _p(r"generativelanguage\.googleapis\.com", ENDPOINT, HIGH),
+            _p(r"[a-z0-9-]*aiplatform\.googleapis\.com", ENDPOINT, HIGH),
+            _p(r"\.generate_content\b|\.generateContent\b", CALL, HIGH),
+            _p(r"google\.generativeai|google\.genai|from\s+google\s+import\s+genai|@google/generative-ai|google-genai|vertexai", IMPORT, MEDIUM),
+            _p(r"\bgemini-[a-z0-9.\-]+\b", MODEL, LOW),
+        ),
+    ),
+    ProviderSpec(
+        id="deepseek",
+        name="DeepSeek",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=0.5,
+        patterns=(
+            _p(r"api\.deepseek\.com", ENDPOINT, HIGH),
+            _p(r"\bdeepseek-(?:chat|reasoner|[a-z0-9.\-]+)\b", MODEL, LOW),
+        ),
+    ),
+    ProviderSpec(
+        id="groq",
+        name="Groq",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=0.3,
+        patterns=(
+            _p(r"api\.groq\.com", ENDPOINT, HIGH),
+            _p(r"from\s+groq\s+import|(?:^|[^.\w])import\s+groq\b|require\(['\"]groq-sdk['\"]\)", IMPORT, MEDIUM),
+        ),
+    ),
+    ProviderSpec(
+        id="xai",
+        name="xAI Grok",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=5.0,
+        patterns=(
+            _p(r"api\.x\.ai", ENDPOINT, HIGH),
+            _p(r"\bgrok-[a-z0-9.\-]+\b", MODEL, LOW),
+        ),
+    ),
+    ProviderSpec(
+        id="mistral",
+        name="Mistral",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=2.0,
+        patterns=(
+            _p(r"api\.mistral\.ai", ENDPOINT, HIGH),
+            _p(r"from\s+mistralai|(?:^|[^.\w])import\s+mistralai\b|@mistralai/mistralai", IMPORT, MEDIUM),
+            _p(r"\b(?:mistral-[a-z0-9.\-]+|mixtral-[a-z0-9x.\-]+|codestral-[a-z0-9.\-]+)\b", MODEL, LOW),
+        ),
+    ),
+    ProviderSpec(
+        id="cohere",
+        name="Cohere",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=False,
+        approx_price_per_mtok=2.0,
+        patterns=(
+            _p(r"api\.cohere\.(?:ai|com)", ENDPOINT, HIGH),
+            _p(r"from\s+cohere\s+import|(?:^|[^.\w])import\s+cohere\b|require\(['\"]cohere-ai['\"]\)", IMPORT, MEDIUM),
+            _p(r"\bcommand-[a-z0-9.\-]+\b", MODEL, LOW),
+        ),
+    ),
+    ProviderSpec(
+        id="litellm",
+        name="LiteLLM (router)",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=5.0,
+        patterns=(
+            _p(r"(?:^|[^.\w])import\s+litellm\b|from\s+litellm\s+import", IMPORT, HIGH),
+            _p(r"litellm\.(?:completion|acompletion|embedding)\b", CALL, HIGH),
+        ),
+    ),
+    ProviderSpec(
+        id="langchain",
+        name="LangChain",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=False,
+        approx_price_per_mtok=5.0,
+        patterns=(
+            _p(r"from\s+langchain|(?:^|[^.\w])import\s+langchain\b|@langchain/", IMPORT, MEDIUM),
+            _p(r"\bChat(?:OpenAI|Anthropic|Google[A-Za-z]*|Mistral[A-Za-z]*|Groq|Cohere)\b", CALL, MEDIUM),
+        ),
+    ),
+    ProviderSpec(
+        id="bedrock",
+        name="AWS Bedrock",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=False,
+        approx_price_per_mtok=8.0,
+        patterns=(
+            _p(r"bedrock[a-z-]*\.[a-z0-9-]+\.amazonaws\.com", ENDPOINT, HIGH),
+            _p(r"\binvoke_model\b|\bInvokeModel\b|\.converse\(", CALL, MEDIUM),
+            _p(r"['\"]bedrock-runtime['\"]|['\"]bedrock['\"]", IMPORT, MEDIUM),
+        ),
+    ),
+    ProviderSpec(
+        id="together",
+        name="Together AI",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=0.9,
+        patterns=(
+            _p(r"api\.together\.(?:xyz|ai)", ENDPOINT, HIGH),
+            _p(r"from\s+together\s+import|(?:^|[^.\w])import\s+together\b", IMPORT, MEDIUM),
+        ),
+    ),
+    ProviderSpec(
+        id="fireworks",
+        name="Fireworks AI",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=0.9,
+        patterns=(
+            _p(r"api\.fireworks\.ai", ENDPOINT, HIGH),
+            _p(r"from\s+fireworks|(?:^|[^.\w])import\s+fireworks\b", IMPORT, MEDIUM),
+        ),
+    ),
+    ProviderSpec(
+        id="openrouter",
+        name="OpenRouter",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=5.0,
+        patterns=(
+            _p(r"openrouter\.ai/api", ENDPOINT, HIGH),
+        ),
+    ),
+    ProviderSpec(
+        id="perplexity",
+        name="Perplexity",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=1.0,
+        patterns=(
+            _p(r"api\.perplexity\.ai", ENDPOINT, HIGH),
+        ),
+    ),
+    ProviderSpec(
+        id="replicate",
+        name="Replicate",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=False,
+        approx_price_per_mtok=3.0,
+        patterns=(
+            _p(r"api\.replicate\.com", ENDPOINT, HIGH),
+            _p(r"from\s+replicate|(?:^|[^.\w])import\s+replicate\b|require\(['\"]replicate['\"]\)", IMPORT, MEDIUM),
+        ),
+    ),
+    ProviderSpec(
+        id="huggingface",
+        name="Hugging Face Inference",
+        env_base_url=None,
+        honors_env=False,
+        openai_compatible=False,
+        approx_price_per_mtok=1.0,
+        patterns=(
+            _p(r"api-inference\.huggingface\.co|router\.huggingface\.co", ENDPOINT, HIGH),
+            _p(r"InferenceClient\b|from\s+huggingface_hub", IMPORT, MEDIUM),
+        ),
+    ),
+    ProviderSpec(
+        id="ollama",
+        name="Ollama (local)",
+        env_base_url="OLLAMA_HOST",
+        honors_env=False,
+        openai_compatible=True,
+        approx_price_per_mtok=0.0,
+        patterns=(
+            _p(r"localhost:11434|127\.0\.0\.1:11434|/api/(?:generate|chat)\b", ENDPOINT, MEDIUM),
+            _p(r"from\s+ollama|(?:^|[^.\w])import\s+ollama\b|require\(['\"]ollama['\"]\)", IMPORT, MEDIUM),
+        ),
+    ),
+)
+
+
+PROVIDERS_BY_ID: dict[str, ProviderSpec] = {p.id: p for p in PROVIDERS}
+
+
+def iter_patterns():
+    """Yield (provider, pattern) for every pattern in the registry."""
+    for provider in PROVIDERS:
+        for pattern in provider.patterns:
+            yield provider, pattern

agentmap_scan-0.1.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: agentmap-scan
+Version: 0.1.0
+Summary: Map every AI API call in a codebase — offline, no LLM, no keys. Opens a webpage of your providers, models, and agents.
+Author: Brevitas
+License: MIT
+Project-URL: Homepage, https://github.com/brevitas-ai/agentmap
+Keywords: llm,openai,anthropic,scanner,agents,observability
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.0
+Dynamic: license-file
+
+# agentmap
+
+Map every AI API call in a codebase — **offline, no LLM, no API keys**. Run one
+command and get a webpage showing which files call which providers, what models
+you use, and what each agent is responsible for.
+
+```bash
+pip install agentmap-scan
+cd your-project
+agentmap
+```
+
+A browser page opens with four sections:
+
+- **Calls by file** — every AI API call site, `file:line`, provider-tagged.
+- **Providers & models** — the distinct providers and model names in use, with counts.
+- **Agents & responsibilities** — each agent's name and what its system prompt says it does.
+- **Routing** — the env vars to send those calls through a gateway.
+
+## How it works
+
+Pure regex over your source — it matches provider **endpoint hosts**
+(`api.openai.com`, `api.anthropic.com`, …) and **SDK call signatures**
+(`.chat.completions.create`, `.messages.create`, …), so it finds calls in
+Python, JS/TS, Go, Rust, Ruby, PHP, Java, shell/curl — not just the official
+SDKs. Agent responsibilities come straight from the system prompts in your code,
+trimmed to one line. Nothing leaves your machine.
+
+Detects 20 providers: OpenAI, Anthropic, Google Gemini/Vertex, Azure OpenAI,
+DeepSeek, Groq, xAI, Mistral, Cohere, Bedrock, Together, Fireworks, OpenRouter,
+Perplexity, Replicate, Hugging Face, Ollama, LiteLLM, LangChain.
+
+## Commands
+
+```bash
+agentmap [PATH]              # scan + open the report (default: current dir)
+agentmap --no-open PATH      # scan, write the HTML, don't launch a browser
+agentmap install PATH        # write .env.agentmap routing env vars
+agentmap install PATH --auto # also rewrite hardcoded provider base_urls in place
+```
+
+## Routing → save money
+
+`agentmap install` writes the env vars that point your OpenAI/Anthropic-compatible
+calls at a gateway. Point them at [**Brevitas**](https://github.com/brevitas-ai)
+to compress context losslessly and cut your token bill:
+
+```bash
+agentmap install . --target http://localhost:4242
+source .env.agentmap
+```
+
+## Limitations (honest)
+
+Agent detection is a heuristic. It reliably catches raw OpenAI/Anthropic message
+dicts, `system=`/`system_prompt=`/`instructions=` assignments (incl. `X_system`,
+`X_PROMPT` names), CrewAI `Agent(role=…)`, and `.agent("name")` calls. It does
+**not** yet understand graph frameworks (LangGraph node graphs, AutoGen). PRs
+adding per-framework matchers welcome.
+
+## License
+
+MIT.

agentmap_scan-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+agentmap/__init__.py,sha256=0zLemHaGtDpctFtaMrEmjhS9q5jmeVZ_WV0n3n6dUjg,453
+agentmap/agents.py,sha256=7DMI-9SzA52GTOsYdP7WmRCv8yxfkvkge6Vzxt7onjo,7011
+agentmap/cli.py,sha256=EutexJS1iJBySbj2Wi25GjUNQMX3ttk1884s5N6YsLg,4135
+agentmap/report.py,sha256=XjMuNvMKaz7Q1MSOSBSWH8g03X6HziZt4ZDIJQTlCf0,7610
+agentmap/scanner.py,sha256=IgzMNhLIVewVZVfTbrPh1Pyb_x21YUlf3VLPRLUQV-8,9142
+agentmap/signatures.py,sha256=Rf2ZC3Lr8gcp7l32NnKIBXv1q1oNisfSThDcq2uXehE,11552
+agentmap_scan-0.1.0.dist-info/licenses/LICENSE,sha256=O-52TMTEqIm01Mx06mqRnAabhYPyowUuidSeMv9OLPY,1065
+agentmap_scan-0.1.0.dist-info/METADATA,sha256=K0pyVp3Xwclty5GcNSgKq--3SDvUl8HpNlrd7B-y6SI,2875
+agentmap_scan-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+agentmap_scan-0.1.0.dist-info/entry_points.txt,sha256=8HUXamWqkeDIcnWUAtXXfkg5YOaJOJCdFXU2IW-YTuc,47
+agentmap_scan-0.1.0.dist-info/top_level.txt,sha256=-StwAqR4ZaGiBDM6U9khs1t_9jPgTdUBhFJ4YSbz2N4,9
+agentmap_scan-0.1.0.dist-info/RECORD,,

agentmap_scan-0.1.0.dist-info/WHEEL

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

agentmap_scan-0.1.0.dist-info/entry_points.txt

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

agentmap_scan-0.1.0.dist-info/licenses/LICENSE

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

agentmap_scan-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agentmap