repokg 0.1.0__py3-none-any.whl

repokg/__init__.py

@@ -0,0 +1,3 @@
+"""repokg: generate an AI-ready knowledge graph of any codebase."""
+
+__version__ = "0.1.0"

repokg/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

repokg/cli.py

@@ -0,0 +1,144 @@
+"""repokg CLI: scan | prompts | render | generate."""
+
+import argparse
+import datetime
+import json
+import os
+import sys
+
+from . import __version__, code, deps, github, gitinfo, inject, markdown, ops, prompts
+
+
+def scan(repo, out, no_github, pr_limit):
+    info, branches = gitinfo.collect(repo)
+    if no_github:
+        prs, note = [], "GitHub lookup disabled (--no-github)"
+    else:
+        prs, note = github.collect(repo, pr_limit)
+    github.classify(branches, prs, info["trunk"], info["integration"])
+    tree = dict(code.walk(repo))  # single filesystem walk, shared by all collectors
+    languages, modules = code.collect(repo, tree)
+    kg = {
+        "repokg_version": 1,
+        "generated_at": datetime.date.today().isoformat(),
+        "repo": info,
+        "languages": languages,
+        "modules": modules,
+        "edges": deps.collect(repo, tree),
+        "branches": branches,
+        "prs": prs,
+        "github_note": note,
+        "ops": ops.collect(repo, tree),
+    }
+    os.makedirs(out, exist_ok=True)
+    path = os.path.join(out, "kg.json")
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(kg, f, indent=1)
+    print("wrote %s (%d modules, %d edges, %d branches, %d PRs)" %
+          (path, len(modules), len(kg["edges"]), len(branches), len(prs)))
+    return kg
+
+
+def write_prompts(repo, out, md):
+    pdir = os.path.join(out, "prompts")
+    os.makedirs(pdir, exist_ok=True)
+    path = os.path.join(pdir, "enrich.md")
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(prompts.render(repo, out, md))
+    print("wrote %s (hand this to your AI agent)" % path)
+
+
+def render(out, md):
+    with open(os.path.join(out, "kg.json"), encoding="utf-8") as f:
+        kg = json.load(f)
+    narratives = {}
+    npath = os.path.join(out, "narratives.json")
+    if os.path.isfile(npath):
+        with open(npath, encoding="utf-8") as f:
+            narratives = json.load(f)
+    doc = markdown.render(kg, narratives)
+    with open(md, "w", encoding="utf-8") as f:
+        f.write(doc)
+    state = "enriched" if narratives else "structure-only; run .repokg/prompts/enrich.md to enrich"
+    print("wrote %s (%s)" % (md, state))
+
+
+def do_inject(repo, md):
+    for path, status in inject.run(repo, md).items():
+        print("%s: %s" % (path, status))
+
+
+def check(repo, out, md):
+    """Exit 0 if the knowledge graph matches HEAD, 1 if stale/missing. CI-friendly."""
+    apath = os.path.join(out, "kg.json")
+    if not os.path.isfile(apath) or not os.path.isfile(md):
+        print("stale: knowledge graph not generated (run `repokg generate`)")
+        return 1
+    with open(apath, encoding="utf-8") as f:
+        stored = json.load(f).get("repo", {}).get("head", "")
+    head = gitinfo.try_run(repo, "rev-parse", "HEAD")
+    if stored and head and stored != head:
+        print("stale: knowledge graph at %s, HEAD is %s (run `repokg generate`)"
+              % (stored[:12], head[:12]))
+        return 1
+    print("fresh: knowledge graph matches HEAD %s" % (head[:12] or "(unknown)"))
+    return 0
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        prog="repokg",
+        description="Generate an AI-ready knowledge graph of a codebase.")
+    ap.add_argument("command", nargs="?", default="generate",
+                    choices=["scan", "prompts", "render", "generate", "inject",
+                             "check", "version"],
+                    help="scan: extract structure to .repokg/kg.json | "
+                         "prompts: write the AI enrichment prompt | "
+                         "render: kg.json (+narratives.json) -> KNOWLEDGE_GRAPH.md | "
+                         "generate: scan + prompts + render (default) | "
+                         "inject: add knowledge-graph pointer to CLAUDE.md/AGENTS.md/cursor rules | "
+                         "check: exit 1 if knowledge graph is stale vs HEAD")
+    ap.add_argument("path", nargs="?", default=".", help="repository path (default: .)")
+    ap.add_argument("--out", default=None, help="output dir (default: <repo>/.repokg)")
+    ap.add_argument("--md", default=None, help="markdown output (default: <repo>/KNOWLEDGE_GRAPH.md)")
+    ap.add_argument("--no-github", action="store_true", help="skip gh PR lookup")
+    ap.add_argument("--pr-limit", type=int, default=1000, help="max PRs to fetch (default 1000)")
+    args = ap.parse_args(argv)
+
+    if args.command == "version":
+        print("repokg %s" % __version__)
+        return 0
+
+    repo = os.path.abspath(args.path)
+    if not os.path.isdir(repo):
+        print("error: %s is not a directory" % repo, file=sys.stderr)
+        return 2
+    out = args.out or os.path.join(repo, ".repokg")
+    md = args.md or os.path.join(repo, "KNOWLEDGE_GRAPH.md")
+
+    try:
+        if args.command == "scan":
+            scan(repo, out, args.no_github, args.pr_limit)
+        elif args.command == "prompts":
+            write_prompts(repo, out, md)
+        elif args.command == "render":
+            render(out, md)
+        elif args.command == "inject":
+            do_inject(repo, md)
+        elif args.command == "check":
+            return check(repo, out, md)
+        else:  # generate
+            scan(repo, out, args.no_github, args.pr_limit)
+            write_prompts(repo, out, md)
+            render(out, md)
+    except RuntimeError as e:
+        print("error: %s" % e, file=sys.stderr)
+        return 1
+    except FileNotFoundError as e:
+        print("error: %s (run `repokg scan` first?)" % e, file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

repokg/code.py

@@ -0,0 +1,104 @@
+"""Code collectors: language breakdown, module discovery, LOC."""
+
+import os
+import re
+
+SKIP_DIRS = {
+    ".git", "node_modules", "vendor", "dist", "build", "out", "target", ".next",
+    ".venv", "venv", "__pycache__", ".idea", ".vscode", ".repokg", "coverage",
+    ".terraform", "third_party", ".tox", ".mypy_cache", ".ruff_cache",
+    "site-packages", ".pytest_cache", ".cache",
+}
+
+LANG_BY_EXT = {
+    ".go": "Go", ".py": "Python", ".ts": "TypeScript", ".tsx": "TypeScript",
+    ".js": "JavaScript", ".jsx": "JavaScript", ".mjs": "JavaScript",
+    ".rs": "Rust", ".java": "Java", ".kt": "Kotlin", ".rb": "Ruby",
+    ".php": "PHP", ".cs": "C#", ".c": "C", ".cpp": "C++", ".cc": "C++",
+    ".h": "C/C++", ".hpp": "C++", ".sol": "Solidity", ".swift": "Swift",
+    ".scala": "Scala", ".ex": "Elixir", ".exs": "Elixir", ".zig": "Zig",
+    ".lua": "Lua", ".dart": "Dart", ".vue": "Vue", ".svelte": "Svelte",
+    ".sql": "SQL", ".sh": "Shell", ".proto": "Protobuf", ".tf": "Terraform",
+    ".yaml": "YAML", ".yml": "YAML", ".html": "HTML", ".css": "CSS",
+}
+
+# Languages whose presence makes a directory a "module" worth graphing.
+MODULE_LANGS = {
+    "Go", "Python", "TypeScript", "JavaScript", "Rust", "Java", "Kotlin",
+    "Ruby", "PHP", "C#", "C", "C++", "Solidity", "Swift", "Scala", "Elixir",
+    "Zig", "Lua", "Dart", "Vue", "Svelte",
+}
+
+ROOT_MARKERS = {
+    "go.mod", "package.json", "pyproject.toml", "setup.py", "Cargo.toml",
+    "pom.xml", "build.gradle", "composer.json", "Gemfile",
+}
+
+GENERATED_RE = re.compile(r"(generated|sqlcgen|_pb2|\.pb\.|/pb$|/pb/|bindings)")
+MAX_FILE_BYTES = 2_000_000
+
+
+def walk(repo):
+    """os.walk with skip-dir pruning; yields (rel_dir, filenames)."""
+    for dirpath, dirnames, filenames in os.walk(repo):
+        dirnames[:] = sorted(
+            d for d in dirnames
+            if d not in SKIP_DIRS and not (d.startswith(".") and d != ".github")
+        )
+        rel = os.path.relpath(dirpath, repo)
+        yield ("" if rel == "." else rel.replace(os.sep, "/")), filenames
+
+
+def count_loc(path):
+    try:
+        if os.path.getsize(path) > MAX_FILE_BYTES:
+            return 0
+        with open(path, "rb") as f:
+            data = f.read()
+        if b"\0" in data[:1024]:  # binary
+            return 0
+        return data.count(b"\n") + (1 if data and not data.endswith(b"\n") else 0)
+    except OSError:
+        return 0
+
+
+def collect(repo, tree=None):
+    """Return (languages, modules).
+
+    languages: [{lang, files, loc}] sorted by loc desc
+    modules:   [{path, lang, files, loc, root, generated}] one per dir containing code
+    tree: optional pre-built {rel_dir: filenames} to avoid re-walking the repo.
+    """
+    lang_stats = {}
+    modules = []
+    for rel, files in (tree.items() if tree is not None else walk(repo)):
+        if rel.startswith(".github"):
+            continue
+        per_lang = {}
+        is_root = any(f in ROOT_MARKERS for f in files)
+        for f in files:
+            ext = os.path.splitext(f)[1].lower()
+            lang = LANG_BY_EXT.get(ext)
+            if not lang:
+                continue
+            loc = count_loc(os.path.join(repo, rel, f))
+            ls = lang_stats.setdefault(lang, {"lang": lang, "files": 0, "loc": 0})
+            ls["files"] += 1
+            ls["loc"] += loc
+            if lang in MODULE_LANGS:
+                pl = per_lang.setdefault(lang, [0, 0])
+                pl[0] += 1
+                pl[1] += loc
+        if per_lang:
+            dominant = max(per_lang.items(), key=lambda kv: kv[1][1])
+            modules.append({
+                "path": rel or "(root)",
+                "lang": dominant[0],
+                "files": sum(v[0] for v in per_lang.values()),
+                "loc": sum(v[1] for v in per_lang.values()),
+                "root": is_root,
+                "generated": bool(GENERATED_RE.search("/" + rel)),
+            })
+    languages = sorted(lang_stats.values(), key=lambda x: -x["loc"])
+    modules.sort(key=lambda m: -m["loc"])
+    return languages, modules

repokg/deps.py

@@ -0,0 +1,166 @@
+"""Dependency-edge extraction: internal import graphs for Go, Python, JS/TS.
+
+Edges are directory -> directory, deduplicated with counts. Only imports that
+resolve inside the repo are kept (external/third-party imports are ignored).
+"""
+
+import ast
+import os
+import re
+from collections import Counter
+
+from .code import walk
+
+GO_BLOCK_RE = re.compile(r"^import\s*\(\s*(.*?)\s*\)", re.S | re.M)
+GO_SINGLE_RE = re.compile(r'^import\s+(?:\w+\s+)?"([^"]+)"', re.M)
+GO_QUOTED_RE = re.compile(r'"([^"]+)"')
+GO_MODULE_RE = re.compile(r"^module\s+(\S+)", re.M)
+JS_IMPORT_RE = re.compile(
+    r"""(?:from\s+|require\(\s*|import\(\s*|^\s*import\s+)['"](\.{1,2}/[^'"]+)['"]""",
+    re.M)
+JS_EXTS = (".ts", ".tsx", ".js", ".jsx", ".mjs")
+
+
+def collect(repo, tree=None):
+    """Return [{"from": dir, "to": dir, "lang": lang, "count": n}] sorted by count.
+
+    tree: optional pre-built {rel_dir: filenames} to avoid re-walking the repo.
+    """
+    counter = Counter()
+    if tree is None:
+        tree = {rel: files for rel, files in walk(repo)}
+    dirs = set(tree)
+
+    _go_edges(repo, tree, counter)
+    _py_edges(repo, tree, dirs, counter)
+    _js_edges(repo, tree, dirs, counter)
+
+    edges = [{"from": f or "(root)", "to": t or "(root)", "lang": lang, "count": n}
+             for (f, t, lang), n in counter.items()]
+    edges.sort(key=lambda e: -e["count"])
+    return edges
+
+
+def _read(repo, rel, name):
+    try:
+        with open(os.path.join(repo, rel, name), encoding="utf-8", errors="replace") as f:
+            return f.read()
+    except OSError:
+        return ""
+
+
+# -- Go ----------------------------------------------------------------------
+
+def _go_edges(repo, tree, counter):
+    roots = {}  # rel dir of go.mod -> module path
+    for rel, files in tree.items():
+        if "go.mod" in files:
+            m = GO_MODULE_RE.search(_read(repo, rel, "go.mod"))
+            if m:
+                roots[rel] = m.group(1)
+    if not roots:
+        return
+    for rel, files in tree.items():
+        root = _owning_root(rel, roots)
+        if root is None:
+            continue
+        modpath = roots[root]
+        for f in files:
+            if not f.endswith(".go") or f.endswith("_test.go"):
+                continue
+            src = _read(repo, rel, f)
+            imports = GO_SINGLE_RE.findall(src)
+            for block in GO_BLOCK_RE.findall(src):
+                imports.extend(GO_QUOTED_RE.findall(block))
+            for imp in imports:
+                if imp != modpath and not imp.startswith(modpath + "/"):
+                    continue
+                sub = imp[len(modpath):].lstrip("/")
+                target = _norm(os.path.join(root, sub) if root else sub)
+                if target != rel and target in tree:
+                    counter[(rel, target, "Go")] += 1
+
+
+def _owning_root(rel, roots):
+    best = None
+    for root in roots:
+        if rel == root or root == "" or rel.startswith(root + "/"):
+            if best is None or len(root) > len(best):
+                best = root
+    return best
+
+
+# -- Python ------------------------------------------------------------------
+
+def _py_edges(repo, tree, dirs, counter):
+    # Internal top-level packages: dirs at repo root or under src/ holding .py files.
+    pkg_map = {}
+    for rel in dirs:
+        parts = rel.split("/") if rel else []
+        if not parts:
+            continue
+        if len(parts) == 1 or (len(parts) == 2 and parts[0] == "src"):
+            if any(f.endswith(".py") for f in tree.get(rel, ())):
+                pkg_map[parts[-1]] = rel
+    for rel, files in tree.items():
+        for f in files:
+            if not f.endswith(".py"):
+                continue
+            try:
+                node = ast.parse(_read(repo, rel, f))
+            except (SyntaxError, ValueError):  # ValueError: null bytes on py<=3.11
+                continue
+            for stmt in ast.walk(node):
+                if isinstance(stmt, ast.Import):
+                    for alias in stmt.names:
+                        _py_edge(rel, alias.name, 0, pkg_map, dirs, counter)
+                elif isinstance(stmt, ast.ImportFrom):
+                    _py_edge(rel, stmt.module or "", stmt.level, pkg_map, dirs, counter)
+
+
+def _py_edge(rel, module, level, pkg_map, dirs, counter):
+    if level:  # relative import
+        base = rel
+        for _ in range(level - 1):
+            base = os.path.dirname(base)
+        target = _norm(os.path.join(base, *module.split("."))) if module else base
+    else:
+        head = module.split(".")[0]
+        if head not in pkg_map:
+            return
+        target = _norm(os.path.join(os.path.dirname(pkg_map[head]),
+                                    *module.split(".")))
+    target = _existing_dir(target, dirs)
+    if target is not None and target != rel:
+        counter[(rel, target, "Python")] += 1
+
+
+# -- JS / TS -----------------------------------------------------------------
+
+def _js_edges(repo, tree, dirs, counter):
+    for rel, files in tree.items():
+        for f in files:
+            if not f.endswith(JS_EXTS) or f.endswith(".d.ts"):
+                continue
+            for imp in JS_IMPORT_RE.findall(_read(repo, rel, f)):
+                target = _existing_dir(_norm(os.path.join(rel, imp)), dirs)
+                if target is not None and target != rel:
+                    counter[(rel, target, "JS/TS")] += 1
+
+
+# -- helpers -----------------------------------------------------------------
+
+def _norm(p):
+    p = os.path.normpath(p).replace(os.sep, "/")
+    return "" if p == "." else p
+
+
+def _existing_dir(path, dirs):
+    """Resolve an import target to a known repo dir (itself, or its parent
+    when the import points at a file)."""
+    if path in dirs:
+        return path
+    parent = _norm(os.path.dirname(path))
+    if parent in dirs:
+        return parent
+    return None

repokg/github.py

@@ -0,0 +1,66 @@
+"""GitHub collectors (via `gh` CLI) and branch x PR classification."""
+
+import json
+import shutil
+import subprocess
+
+FIELDS = "number,title,state,headRefName,author,createdAt,mergedAt,closedAt,isDraft"
+
+# Branch statuses:
+#   trunk / integration          - the long-lived branches
+#   active                       - has an open PR
+#   merged                       - reachable from the default base (merge-commit merge)
+#   squash-merged                - not an ancestor, but its PR was merged (squash/rebase)
+#   abandoned                    - only closed-without-merge PRs
+#   stale                        - no PR ever opened
+
+
+def collect(repo, limit=1000):
+    """Return (prs, note). Degrades gracefully when gh is unavailable."""
+    if not shutil.which("gh"):
+        return [], "gh CLI not found; PR data skipped"
+    p = subprocess.run(
+        ["gh", "pr", "list", "--state", "all", "--limit", str(limit), "--json", FIELDS],
+        cwd=repo, capture_output=True, text=True)
+    if p.returncode != 0:
+        return [], "gh failed: " + p.stderr.strip()[:200]
+    prs = []
+    for x in json.loads(p.stdout or "[]"):
+        prs.append({
+            "number": x["number"],
+            "title": x.get("title", "").strip(),
+            "state": x.get("state", ""),
+            "head": x.get("headRefName", ""),
+            "author": (x.get("author") or {}).get("login", ""),
+            "created": (x.get("createdAt") or "")[:10],
+            "merged": (x.get("mergedAt") or "")[:10],
+            "closed": (x.get("closedAt") or "")[:10],
+            "draft": bool(x.get("isDraft")),
+        })
+    prs.sort(key=lambda pr: pr["number"])
+    return prs, ""
+
+
+def classify(branches, prs, trunk, integration):
+    """Set status + prs on every branch by cross-referencing PR head refs."""
+    by_head = {}
+    for pr in prs:
+        by_head.setdefault(pr["head"], []).append(pr)
+    for b in branches:
+        linked = by_head.get(b["name"], [])
+        b["prs"] = [pr["number"] for pr in linked]
+        states = {pr["state"] for pr in linked}
+        if b["name"] == trunk:
+            b["status"] = "trunk"
+        elif integration and b["name"] == integration:
+            b["status"] = "integration"
+        elif "OPEN" in states:
+            b["status"] = "active"
+        elif b.get("merged_ancestry"):
+            b["status"] = "merged"
+        elif "MERGED" in states:
+            b["status"] = "squash-merged"
+        elif "CLOSED" in states:
+            b["status"] = "abandoned"
+        else:
+            b["status"] = "stale"

repokg/gitinfo.py

@@ -0,0 +1,124 @@
+"""Git collectors: branches, trunk/integration detection, merge classification, contributors."""
+
+import os
+import subprocess
+
+INTEGRATION_CANDIDATES = ("staging", "develop", "dev", "next", "canary")
+
+
+def run(repo, *args):
+    p = subprocess.run(["git", *args], cwd=repo, capture_output=True, text=True)
+    if p.returncode != 0:
+        raise RuntimeError("git %s: %s" % (" ".join(args), p.stderr.strip()))
+    return p.stdout.strip()
+
+
+def try_run(repo, *args):
+    try:
+        return run(repo, *args)
+    except (RuntimeError, OSError):
+        return ""
+
+
+def collect(repo):
+    """Return (repo_info, branches). Each branch dict carries merged_ancestry/ahead
+    against the default base (integration branch if present, else trunk)."""
+    top = run(repo, "rev-parse", "--show-toplevel")
+    remote = try_run(repo, "remote", "get-url", "origin")
+
+    fmt = "%(refname:short)%09%(committerdate:short)%09%(authorname)%09%(contents:subject)"
+    raw = try_run(repo, "for-each-ref", "refs/remotes/origin", "--format=" + fmt)
+    use_remote = bool(raw)
+    if not use_remote:
+        raw = try_run(repo, "for-each-ref", "refs/heads", "--format=" + fmt)
+
+    branches = []
+    for line in raw.splitlines():
+        parts = line.split("\t", 3)
+        while len(parts) < 4:
+            parts.append("")
+        ref, date, author, subject = parts
+        name = ref[len("origin/"):] if use_remote and ref.startswith("origin/") else ref
+        if name in ("HEAD", "") or ref == "origin":
+            continue
+        branches.append({
+            "name": name, "ref": ref, "date": date,
+            "author": author, "subject": subject,
+        })
+    names = {b["name"] for b in branches}
+
+    trunk = _detect_trunk(repo, names, use_remote)
+    integration = next((c for c in INTEGRATION_CANDIDATES if c in names and c != trunk), "")
+    base = integration or trunk
+    base_ref = ("origin/" + base) if (use_remote and base) else base
+    prefix = "refs/remotes/origin" if use_remote else "refs/heads"
+
+    merged_refs, ahead_map = set(), {}
+    if base_ref:
+        out = try_run(repo, "for-each-ref", prefix, "--merged=" + base_ref,
+                      "--format=%(refname:short)")
+        merged_refs = set(out.splitlines())
+        # One call for all ahead counts (git >= 2.41); fall back per-branch below.
+        out = try_run(repo, "for-each-ref", prefix,
+                      "--format=%(refname:short)%09%(ahead-behind:" + base_ref + ")")
+        for line in out.splitlines():
+            parts = line.split("\t")
+            if len(parts) == 2:
+                nums = parts[1].split()
+                if len(nums) == 2 and nums[0].isdigit():
+                    ahead_map[parts[0]] = int(nums[0])
+
+    for b in branches:
+        b["merged_ancestry"] = b["ref"] in merged_refs
+        if b["name"] in (trunk, integration) or b["merged_ancestry"] or not base_ref:
+            b["ahead"] = 0
+        elif b["ref"] in ahead_map:
+            b["ahead"] = ahead_map[b["ref"]]
+        else:
+            n = try_run(repo, "rev-list", "--count", "%s..%s" % (base_ref, b["ref"]))
+            b["ahead"] = int(n) if n.isdigit() else 0
+
+    trunk_ref = ("origin/" + trunk) if use_remote and trunk in names else trunk
+    contributors = []
+    for line in try_run(repo, "shortlog", "-sn", "--no-merges", trunk_ref).splitlines():
+        parts = line.strip().split("\t", 1)
+        if len(parts) == 2 and parts[0].strip().isdigit():
+            contributors.append({"name": parts[1].strip(), "commits": int(parts[0])})
+
+    count = try_run(repo, "rev-list", "--count", trunk_ref)
+    roots = try_run(repo, "log", "--max-parents=0", "--format=%cs", trunk_ref).splitlines()
+
+    info = {
+        "path": top,
+        "name": _repo_name(remote, top),
+        "remote": remote,
+        "head": try_run(repo, "rev-parse", "HEAD"),
+        "trunk": trunk,
+        "integration": integration,
+        "default_base": base,
+        "first_commit": roots[-1] if roots else "",
+        "commit_count": int(count) if count.isdigit() else 0,
+        "contributors": contributors,
+    }
+    return info, branches
+
+
+def _detect_trunk(repo, names, use_remote):
+    if use_remote:
+        head = try_run(repo, "symbolic-ref", "refs/remotes/origin/HEAD")
+        if head:
+            return head.rsplit("/", 1)[-1]
+    for cand in ("main", "master"):
+        if cand in names:
+            return cand
+    cur = try_run(repo, "rev-parse", "--abbrev-ref", "HEAD")
+    if cur and cur != "HEAD":
+        return cur
+    return sorted(names)[0] if names else ""
+
+
+def _repo_name(remote, top):
+    if remote:
+        tail = remote.rstrip("/").rsplit("/", 1)[-1]
+        return tail[:-4] if tail.endswith(".git") else tail
+    return os.path.basename(top)