import argparse

import asyncio

import logging

import datetime

from rich.console import Console

from rich.table import Table

from rich.panel import Panel

from rich.layout import Layout

from rich.text import Text

from rich.markdown import Markdown

# Import core components - adjust paths

from github_processor_node.core import node

from github_processor_node import index_db

from github_processor_node.utils import owner_repo_to_repo_rid, repo_rid_to_owner_repo

logger = logging.getLogger(__name__)

# CLI command implementations

async def list_repos_cmd():

"""List all tracked repositories."""

repos = index_db.get_repositories(node.config.index_db_path)

if not repos:

print("No repositories are currently being tracked.")

return

console = Console()

table = Table(title="Tracked GitHub Repositories")

table.add_column("Repository RID", style="cyan", no_wrap=True)

table.add_column("Owner/Repo", style="green")

table.add_column("First Indexed", style="yellow")

table.add_column("Last Updated", style="yellow")

table.add_column("Events", style="magenta")

for repo in repos:

events_count = len(

index_db.get_events_for_repo(

node.config.index_db_path,

repo["repo_rid"],

limit=1000

)

)

owner, repo_name = repo_rid_to_owner_repo(repo["repo_rid"])

owner_repo = f"{owner}/{repo_name}"

table.add_row(

repo["repo_rid"],

owner_repo,

repo.get("first_indexed", "N/A"),

repo.get("last_updated", "N/A"),

str(events_count)

)

console.print(table)

async def show_events_cmd(repo_arg: str, limit: int = 50):

"""Show events for a repository."""

if "/" in repo_arg and not repo_arg.startswith("orn:"):

owner, repo = repo_arg.split("/", 1)

repo_rid = owner_repo_to_repo_rid(owner, repo)

else:

repo_rid = repo_arg

events = index_db.get_events_for_repo(node.config.index_db_path, repo_rid, limit=limit)

if not events:

print(f"No events found for repository: {repo_arg}")

return

console = Console()

table = Table(title=f"Events for {repo_arg}")

table.add_column("Type", style="cyan")

table.add_column("Timestamp", style="green")

table.add_column("Commit SHA", style="yellow", no_wrap=True)

table.add_column("Summary", style="white")

table.add_column("Event RID", style="dim")

for event in events:

timestamp = event.get("timestamp", "")

if timestamp:

try:

dt = datetime.datetime.fromisoformat(timestamp.replace("Z", "+00:00"))

timestamp = dt.strftime("%Y-%m-%d %H:%M:%S")

except ValueError:

pass

commit_sha = event.get("commit_sha", "") or ""

if commit_sha:

commit_sha = commit_sha[:8]

table.add_row(

event.get("event_type", "unknown"),

timestamp,

commit_sha,

event.get("summary", ""),

event.get("event_rid", "")

)

console.print(table)

async def show_event_details_cmd(event_rid: str):

"""Show detailed information about a specific event."""

import sqlite3

conn = sqlite3.connect(node.config.index_db_path)

conn.row_factory = lambda c, r: dict(

(col[0], r[idx]) for idx, col in enumerate(c.description)

)

cursor = conn.cursor()

cursor.execute("SELECT * FROM events WHERE event_rid = ?", (event_rid,))

event = cursor.fetchone()

if not event:

print(f"Event not found: {event_rid}")

conn.close()

return

cursor.execute(

"SELECT * FROM repositories WHERE repo_rid = ?",

(event.get("repo_rid", ""),)

)

repo = cursor.fetchone() or {}

conn.close()

console = Console()

layout = Layout()

layout.split(Layout(name="header", size=3), Layout(name="main"))

event_type = event.get("event_type", "unknown").upper()

layout["header"].update(

Panel(

Text(f"Event Details: {event_type}", style="bold white on blue"),

style="bold white on blue"

)

)

details = [

f"## {event_type} Event\n",

f"**RID:** {event.get('event_rid', 'N/A')}\n",

f"**Repository:** {event.get('repo_rid', 'N/A')}\n",

f"**Repository URL:** {repo.get('repo_url', 'N/A')}\n",

f"**Timestamp:** {event.get('timestamp', 'N/A')}\n",

]

if event.get("commit_sha"):

details.append(f"**Commit SHA:** {event.get('commit_sha', 'N/A')}\n")

details.append(f"**Summary:** {event.get('summary', 'N/A')}\n")

if event.get("bundle_rid"):

details.append(f"**Bundle RID:** {event.get('bundle_rid', 'N/A')}\n")

layout["main"].update(Panel(Markdown("\n".join(details))))

console.print(layout)

async def add_repo_cmd(repo_arg: str):

"""Manually add a repository to the database."""

if "/" in repo_arg and not repo_arg.startswith("orn:"):

owner, repo = repo_arg.split("/", 1)

repo_rid = owner_repo_to_repo_rid(owner, repo)

else:

repo_rid = repo_arg

try:

owner, repo = repo_rid_to_owner_repo(repo_rid)

repo_url = f"https://github.com/{owner}/{repo}"

console = Console()

console.print(f"Adding repository [cyan]{owner}/{repo}[/cyan] to database...")

index_db.add_repository(node.config.index_db_path, repo_rid, repo_url)

console.print(f"[green]Repository added successfully:[/green] {repo_rid}")

except Exception as e:

Console().print(f"[red]Error adding repository:[/red] {e}")

async def summarize_events_cmd():

"""Show a summary of all events in the database."""

import sqlite3

conn = sqlite3.connect(node.config.index_db_path)

conn.row_factory = lambda c, r: dict(

(col[0], r[idx]) for idx, col in enumerate(c.description)

)

cursor = conn.cursor()

try:

cursor.execute(

"SELECT event_type, COUNT(*) as count FROM events GROUP BY event_type ORDER BY count DESC"

)

event_types = cursor.fetchall()

cursor.execute("SELECT COUNT(*) as count FROM events")

total_events = cursor.fetchone()["count"]

cursor.execute("SELECT COUNT(*) as count FROM repositories")

repo_count = cursor.fetchone()["count"]

cursor.execute("SELECT * FROM events ORDER BY timestamp DESC LIMIT 1")

latest_event = cursor.fetchone()

except Exception as e:

Console().print(f"[red]Error querying database:[/red] {e}")

return

finally:

conn.close()

console = Console()

console.print(Panel(Text("GitHub Events Summary", style="bold white"), style="bold blue"))

console.print(f"Total Repositories: [cyan]{repo_count}[/cyan]")

console.print(f"Total Events: [cyan]{total_events}[/cyan]")

if latest_event and latest_event.get("timestamp"):

console.print(

f"Latest Event: [yellow]{latest_event.get('timestamp')}[/yellow] "

f"({latest_event.get('event_type')})"

)

table = Table(title="Events by Type")

table.add_column("Event Type", style="cyan")

table.add_column("Count", style="magenta", justify="right")

table.add_column("Percentage", style="green", justify="right")

for et in event_types:

pct = (et["count"] / total_events) * 100 if total_events else 0

table.add_row(et["event_type"], str(et["count"]), f"{pct:.1f}%")

console.print(table)

def get_db_connection(db_path):

"""Helper function to get a database connection with dict factory."""

import sqlite3

conn = sqlite3.connect(db_path)

conn.row_factory = sqlite3.Row

return conn

def main():

parser = argparse.ArgumentParser(

description="KOI-net GitHub Events Explorer CLI"

)

subs = parser.add_subparsers(dest="command", help="Available commands")

subs.add_parser("list-repos", help="List all tracked repositories")

subs.add_parser("summary", help="Show summary of all events in the database")

show_ev = subs.add_parser("show-events", help="Show events for a repository")

show_ev.add_argument("repo", help="Repository identifier (owner/repo or RID)")

show_ev.add_argument(

"--limit", type=int, default=50, help="Maximum number of events to show"

)

det = subs.add_parser("event-details", help="Show details for a specific event")

det.add_argument("event_rid", help="Event RID")

add = subs.add_parser("add-repo", help="Manually add a repository")

add.add_argument("repo", help="Repository identifier (owner/repo or RID)")

args = parser.parse_args()

if args.command == "list-repos":

asyncio.run(list_repos_cmd())

elif args.command == "show-events":

asyncio.run(show_events_cmd(args.repo, args.limit))

elif args.command == "event-details":

asyncio.run(show_event_details_cmd(args.event_rid))

elif args.command == "add-repo":

asyncio.run(add_repo_cmd(args.repo))

elif args.command == "summary":

asyncio.run(summarize_events_cmd())

else:

console = Console()

if args.command is None:

console.print(

Panel(

Markdown("# GitHub Events Explorer\n\n"

"This CLI tool allows you to explore GitHub events stored in the database."),

title="Welcome",

border_style="green"

)

)

print("\nAvailable commands:")

else:

print(f"Unknown command: {args.command}")

parser.print_help()

if __name__ == "__main__":

main()