issueloop 0.2.0__py3-none-any.whl

issueloop/__init__.py

@@ -0,0 +1,71 @@
+
+from pathlib import Path
+from typing import Optional
+
+from .config import use, get_config
+from .db import get_backend
+from .agent_state import TaskStatus
+from . import folder_reader, test_runner,ticket_creator
+
+
+def _backend():
+    cfg = get_config()
+    return get_backend(cfg.database, path=cfg.database_path)
+
+
+def scan_repo(repo_path: str):
+    out_file = folder_reader.write_inventory(Path(repo_path).resolve())
+    import json
+    return json.loads(out_file.read_text())
+
+
+def run_tests(repo_name: str):
+    return test_runner.run_tests(repo_name)
+
+
+def create_tickets(repo_name: str):
+    tickets = ticket_creator.create_tickets_for_repo(repo_name)
+    return [_ticket_to_dict(t) for t in tickets]
+
+
+def get_top_error(repo_name: str):
+    ticket = _backend().dispense_next(repo_name)
+    return _ticket_to_dict(ticket) if ticket else None
+
+
+def get_all_errors(repo_name: Optional[str] = None):
+    return [_ticket_to_dict(t) for t in _backend().get_open_tickets(repo_name)]
+
+
+def resolve(ticket_id: str):
+    _backend().update_ticket(ticket_id, status=TaskStatus.DONE)
+
+
+def fail(ticket_id: str):
+    _backend().update_ticket(ticket_id, status=TaskStatus.FAILED)
+
+
+def cleanup(older_than_days: Optional[int] = None, repo: Optional[str] = None):
+    days = older_than_days if older_than_days is not None else get_config().retention_days
+    return _backend().purge_old(days, repo)
+
+
+def _ticket_to_dict(ticket):
+    return {
+        "id": ticket.id,
+        "repo": ticket.repo,
+        "priority": ticket.priority.value,
+        "status": ticket.status.value,
+        "error_summary": ticket.error_summary,
+        "raw_log_ref": ticket.raw_log_ref,
+        "command": ticket.command,
+        "test_id": ticket.test_id,
+        "created_at": str(ticket.created_at),
+    }
+
+
+__all__ = [
+    "use", "get_config",
+    "scan_repo", "run_tests", "create_tickets",
+    "get_top_error", "get_all_errors", "resolve", "fail", "cleanup",
+]

issueloop/agent_state.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Optional
+
+
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    BLOCKED = "blocked"
+    DONE = "done"
+    FAILED = "failed"
+    NEEDS_HUMAN = "needs_human"
+
+
+class TicketPriority(str, Enum):
+    BLOCKING = "blocking"
+    HIGH = "high"
+    NORMAL = "normal"
+    LOW = "low"
+
+
+@dataclass
+class SubTask:
+    id: str
+    description: str
+    depends_on: list[str] = field(default_factory=list)
+    status: TaskStatus = TaskStatus.PENDING
+    result: Optional[dict[str, Any]] = None
+
+
+@dataclass
+class Ticket:
+    id: str
+    repo: str
+    error_summary: str
+    raw_log_ref: str
+    priority: TicketPriority
+    status: TaskStatus = TaskStatus.PENDING
+    attempts: int = 0
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    resolved_at: Optional[datetime] = None
+    escalation_summary: Optional[str] = None
+    command: Optional[str] = None
+    test_id: Optional[str] = None
+
+
+@dataclass
+class AgentState:
+    allowed_commands: list[str] = field(default_factory=list)
+    create_pr_permission: bool = False
+    supabase_write_permission: bool = False
+    repo: str = ""
+    branch: str = ""
+    current_task_id: str = ""
+    current_task: Optional[SubTask] = None
+    previous_task_and_result: Optional[dict[str, Any]] = None
+    next_task_id: Optional[str] = None
+    queue_independent_tasks: list[SubTask] = field(default_factory=list)
+    queue_dependent_task: list[SubTask] = field(default_factory=list)
+    active_tickets: list[Ticket] = field(default_factory=list)
+    message_from_user: Optional[str] = None
+    pending_confirmation: bool = False
+    goal: str = ""
+    what_to_do: list[str] = field(default_factory=list)
+    what_not_to_do: list[str] = field(default_factory=list)
+    overall_points: int = 0
+    current_task_points: int = 0
+    max_retries_per_ticket: int = 3
+    log_cache_ref: str = ""
+    last_error: Optional[str] = None
+
+
+def new_run_state(repo: str, goal: str, allowed_commands: list[str]):
+    return AgentState(repo=repo, goal=goal, allowed_commands=allowed_commands)

issueloop/check_env.py

@@ -0,0 +1,78 @@
+
+import shutil
+import sys
+
+import requests
+
+from .config import get_config
+
+OLLAMA_URL = "http://localhost:11434"
+REQUIRED_MODELS = {"qwen2.5-coder:7b": "blocking"}
+CORE_PY_PACKAGES = ["requests", "yaml", "pathspec"]
+
+
+def check(label: str, ok: bool, detail: str = "", blocking: bool = True):
+    status = "PASS" if ok else ("FAIL" if blocking else "WARN")
+    print(f"[{status}] {label}" + (f" — {detail}" if detail else ""))
+    return ok or not blocking
+
+
+def main():
+    all_ok = True
+    cfg = get_config()
+
+    for pkg in CORE_PY_PACKAGES:
+        try:
+            __import__(pkg)
+            check(f"python package: {pkg}", True)
+        except ImportError:
+            all_ok &= check(f"python package: {pkg}", False, "run: pip install -r requirements.txt")
+
+    if cfg.database == "local":
+        check("database backend: local (sqlite)", True, "no external service required")
+    elif cfg.database == "supabase":
+        import os
+        configured = bool(os.environ.get("SUPABASE_URL")) and bool(os.environ.get("SUPABASE_KEY"))
+        all_ok &= check("SUPABASE_URL / SUPABASE_KEY set", configured,
+                         "" if configured else "copy .env.example to .env and fill them in")
+        try:
+            import supabase  
+            check("python package: supabase", True)
+        except ImportError:
+            all_ok &= check("python package: supabase", False, 'run: pip install -e ".[supabase]"')
+
+    if cfg.llm.provider == "ollama":
+        ollama_path = shutil.which("ollama")
+        all_ok &= check("ollama binary on PATH", ollama_path is not None, ollama_path or "not found — run setup_ollama.sh")
+
+        server_up = False
+        try:
+            r = requests.get(f"{OLLAMA_URL}/api/tags", timeout=3)
+            server_up = r.status_code == 200
+        except requests.exceptions.ConnectionError:
+            pass
+        all_ok &= check("ollama server responding", server_up, f"{OLLAMA_URL}/api/tags — run: ollama serve")
+
+        pulled_models = set()
+        if server_up:
+            try:
+                tags = requests.get(f"{OLLAMA_URL}/api/tags", timeout=5).json()
+                pulled_models = {m["name"] for m in tags.get("models", [])}
+            except Exception as e:
+                check("could not parse ollama /api/tags response", False, str(e))
+
+        for model, level in REQUIRED_MODELS.items():
+            have_it = any(model in m for m in pulled_models)
+            all_ok &= check(f"model pulled: {model}", have_it, "" if have_it else f"run: ollama pull {model}",
+                             blocking=(level == "blocking"))
+    else:
+        check(f"llm provider: {cfg.llm.provider}", bool(cfg.llm.api_key),
+              "" if cfg.llm.api_key else "set llm.apiKey via issueloop.use(llm={...})")
+
+    print()
+    print("ALL BLOCKING CHECKS PASSED" if all_ok else "BLOCKING CHECKS FAILED — fix the FAIL lines above before proceeding")
+    return 0 if all_ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

issueloop/cli.py

@@ -0,0 +1,79 @@
+import argparse
+import json
+import sys
+
+import issueloop
+from . import check_env
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="issueloop")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("check-env", help="verify ollama, models, and Supabase env are ready")
+
+    p_scan = sub.add_parser("scan", help="build a file inventory for a repo")
+    p_scan.add_argument("repo_path")
+
+    p_test = sub.add_parser("test", help="run test_manifest.json commands for a repo, write log cache")
+    p_test.add_argument("repo_name")
+
+    p_tickets = sub.add_parser("tickets", help="create tickets from failing log entries")
+    p_tickets.add_argument("repo_name")
+
+    p_next = sub.add_parser("next", help="dispense the next ticket for a repo, one at a time")
+    p_next.add_argument("repo_name")
+
+    p_cleanup = sub.add_parser("cleanup", help="delete done/failed tickets older than N days")
+    p_cleanup.add_argument("--days", type=int, default=None)
+    p_cleanup.add_argument("--repo", default=None)
+
+    p_serve = sub.add_parser("serve", help="start the local HTTP bridge for non-Python callers")
+    p_serve.add_argument("--port", type=int, default=8787)
+
+    args = parser.parse_args()
+
+    if args.command == "check-env":
+        return check_env.main()
+
+    if args.command == "scan":
+        inventory = issueloop.scan_repo(args.repo_path)
+        print(f"scanned {inventory['file_count']} files — {inventory['language_breakdown']}")
+        return 0
+
+    if args.command == "test":
+        for r in issueloop.run_tests(args.repo_name):
+            status = "OK" if r["exit_code"] == 0 else "FAIL"
+            print(f"[{status}] {r['test_id']} (exit {r['exit_code']})")
+        return 0
+
+    if args.command == "tickets":
+        created = issueloop.create_tickets(args.repo_name)
+        print(f"created {len(created)} ticket(s)")
+        for t in created:
+            print(f"  [{t['priority']}] {t['error_summary']}")
+        return 0
+
+    if args.command == "next":
+        ticket = issueloop.get_top_error(args.repo_name)
+        if ticket is None:
+            print("no pending tickets")
+            return 0
+        print(json.dumps(ticket, indent=2))
+        return 0
+
+    if args.command == "cleanup":
+        removed = issueloop.cleanup(older_than_days=args.days, repo=args.repo)
+        print(f"removed {removed} old ticket(s)")
+        return 0
+
+    if args.command == "serve":
+        from . import server
+        server.serve(port=args.port)
+        return 0
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

issueloop/config.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+@dataclass
+class LLMConfig:
+    provider: str = "ollama"          
+    model: str = "qwen2.5-coder:7b"
+    api_key: Optional[str] = None      
+    base_url: str = "http://localhost:11434"
+    token_size: int = 1024           
+    
+@dataclass
+class NotifyConfig:
+    email: Optional[str] = None
+    webhook: Optional[str] = None 
+    
+
+@dataclass
+class Config:
+    database: str = "local"           
+    database_path: Optional[str] = None  
+    retention_days: int = 30          
+    llm: LLMConfig = field(default_factory=LLMConfig)
+    notify: NotifyConfig = field(default_factory=NotifyConfig)
+    
+_config = Config()
+
+def use(
+    database: str = "local",
+    database_path: Optional[str] = None,
+    retention_days: int = 30,
+    llm: Optional[dict] = None,
+    notify: Optional[dict] = None):
+    global _config
+    llm = llm or {}
+    notify = notify or {}
+    _config = Config(
+        database=database,
+        database_path=database_path,
+        retention_days=retention_days,
+        llm=LLMConfig(
+            provider=llm.get("provider", "ollama"),
+            model=llm.get("model", "qwen2.5-coder:7b"),
+            api_key=llm.get("apiKey") or llm.get("api_key"),
+            base_url=llm.get("baseUrl") or llm.get("base_url", "http://localhost:11434"),
+            token_size=llm.get("tokenSize") or llm.get("token_size", 1024),
+        ),
+        notify=NotifyConfig(
+            email=notify.get("email"),
+            webhook=notify.get("webhook"),
+        ),
+    )
+    return _config
+
+
+def get_config():
+    return _config

issueloop/db/__init__.py

@@ -0,0 +1,11 @@
+from .base import TicketStoreBackend
+
+
+def get_backend(kind: str = "local", **kwargs) -> TicketStoreBackend:
+    if kind == "local":
+        from .local_store import LocalStore
+        return LocalStore(db_path=kwargs.get("path"))
+    if kind == "supabase":
+        from .supabase_store import SupabaseStore
+        return SupabaseStore()
+    raise ValueError(f"unknown database backend '{kind}' — expected 'local' or 'supabase'")

issueloop/db/base.py

@@ -0,0 +1,22 @@
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from ..agent_state import Ticket
+
+
+class TicketStoreBackend(ABC):
+    @abstractmethod
+    def create_ticket(self, ticket: Ticket): ...
+
+    @abstractmethod
+    def update_ticket(self, ticket_id: str, **fields): ...
+
+    @abstractmethod
+    def get_open_tickets(self, repo: Optional[str] = None): ...
+
+    @abstractmethod
+    def dispense_next(self, repo: Optional[str] = None):...
+
+    @abstractmethod
+    def purge_old(self, older_than_days: int, repo: Optional[str] = None):...

issueloop/db/local_store.py

@@ -0,0 +1,102 @@
+
+import sqlite3
+import uuid
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Optional
+
+from ..agent_state import TaskStatus, Ticket, TicketPriority
+from .base import TicketStoreBackend
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS tickets (
+    id TEXT PRIMARY KEY,
+    repo TEXT NOT NULL,
+    error_summary TEXT NOT NULL,
+    raw_log_ref TEXT,
+    priority TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending',
+    created_at TEXT NOT NULL,
+    resolved_at TEXT,
+    command TEXT,
+    test_id TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_repo_status ON tickets (repo, status);
+CREATE INDEX IF NOT EXISTS idx_created_at ON tickets (created_at);
+"""
+
+PRIORITY_ORDER = {"blocking": 0, "high": 1, "normal": 2, "low": 3}
+
+
+class LocalStore(TicketStoreBackend):
+    def __init__(self, db_path: Optional[Path] = None):
+        default = Path(__file__).resolve().parent.parent.parent / "data" / "issueloop.db"
+        self.db_path = Path(db_path) if db_path else default
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(str(self.db_path), check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._conn.executescript(SCHEMA)
+        self._conn.commit()
+
+    def _row_to_ticket(self, row: sqlite3.Row):
+        return Ticket(
+            id=row["id"],
+            repo=row["repo"],
+            error_summary=row["error_summary"],
+            raw_log_ref=row["raw_log_ref"],
+            priority=TicketPriority(row["priority"]),
+            status=TaskStatus(row["status"]),
+            created_at=row["created_at"],
+            resolved_at=row["resolved_at"],
+            command=row["command"],
+            test_id=row["test_id"],
+        )
+
+    def create_ticket(self, ticket: Ticket):
+        if not ticket.id:
+            ticket.id = str(uuid.uuid4())
+        self._conn.execute(
+            "INSERT INTO tickets (id, repo, error_summary, raw_log_ref, priority, status, created_at, command, test_id) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (ticket.id, ticket.repo, ticket.error_summary, ticket.raw_log_ref,
+             ticket.priority.value, ticket.status.value,
+             datetime.now(timezone.utc).isoformat(), ticket.command, ticket.test_id),
+        )
+        self._conn.commit()
+        return ticket
+
+    def update_ticket(self, ticket_id: str, **fields):
+        clean = {k: (v.value if hasattr(v, "value") else v) for k, v in fields.items()}
+        set_clause = ", ".join(f"{k} = ?" for k in clean)
+        self._conn.execute(f"UPDATE tickets SET {set_clause} WHERE id = ?", (*clean.values(), ticket_id))
+        self._conn.commit()
+
+    def get_open_tickets(self, repo: Optional[str] = None):
+        query = "SELECT * FROM tickets WHERE status NOT IN ('done', 'in_progress')"
+        params: tuple = ()
+        if repo:
+            query += " AND repo = ?"
+            params = (repo,)
+        rows = self._conn.execute(query, params).fetchall()
+        return [self._row_to_ticket(r) for r in rows]
+
+    def dispense_next(self, repo: Optional[str] = None):
+        candidates = self.get_open_tickets(repo)
+        if not candidates:
+            return None
+        candidates.sort(key=lambda t: (PRIORITY_ORDER[t.priority.value], t.created_at))
+        ticket = candidates[0]
+        self.update_ticket(ticket.id, status=TaskStatus.IN_PROGRESS)
+        ticket.status = TaskStatus.IN_PROGRESS
+        return ticket
+
+    def purge_old(self, older_than_days: int, repo: Optional[str] = None):
+        cutoff = (datetime.now(timezone.utc) - timedelta(days=older_than_days)).isoformat()
+        query = "DELETE FROM tickets WHERE status IN ('done', 'failed') AND created_at < ?"
+        params: tuple = (cutoff,)
+        if repo:
+            query += " AND repo = ?"
+            params = (cutoff, repo)
+        cur = self._conn.execute(query, params)
+        self._conn.commit()
+        return cur.rowcount

issueloop/db/supabase_store.py

@@ -0,0 +1,88 @@
+import json
+import os
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Optional
+from supabase import create_client 
+
+from ..agent_state import TaskStatus, Ticket, TicketPriority
+from .base import TicketStoreBackend
+
+TABLE = "tickets"
+AUDIT_LOG = Path(__file__).resolve().parent.parent.parent / "data" / "logs" / "tickets_audit.jsonl"
+
+PRIORITY_ORDER = {"blocking": 0, "high": 1, "normal": 2, "low": 3}
+
+
+class SupabaseStore(TicketStoreBackend):
+    def __init__(self):
+        from dotenv import load_dotenv
+        load_dotenv()
+        url = os.environ.get("SUPABASE_URL")
+        key = os.environ.get("SUPABASE_KEY")
+        if not url or not key:
+            raise RuntimeError(
+                "SUPABASE_URL / SUPABASE_KEY not set. Copy .env.example to .env and fill them in, "
+                "or pass issueloop.use(database='local') instead."
+            )
+        self._client = create_client(url, key)
+
+    def _audit(self, event: str, ticket_id: str, detail: dict):
+        AUDIT_LOG.parent.mkdir(parents=True, exist_ok=True)
+        with AUDIT_LOG.open("a") as f:
+            f.write(json.dumps({
+                "ts": datetime.now(timezone.utc).isoformat(),
+                "event": event, "ticket_id": ticket_id, **detail,
+            }) + "\n")
+
+    def _row_to_ticket(self, row: dict):
+        return Ticket(
+            id=row["id"], repo=row["repo"], error_summary=row["error_summary"],
+            raw_log_ref=row["raw_log_ref"], priority=TicketPriority(row["priority"]),
+            status=TaskStatus(row["status"]),
+            created_at=row.get("created_at") or datetime.now(timezone.utc).isoformat(),
+            resolved_at=row.get("resolved_at"), command=row.get("command"), test_id=row.get("test_id"),
+        )
+
+    def create_ticket(self, ticket: Ticket):
+        row = {
+            "id": ticket.id, "repo": ticket.repo, "error_summary": ticket.error_summary,
+            "raw_log_ref": ticket.raw_log_ref, "priority": ticket.priority.value,
+            "status": ticket.status.value, "command": ticket.command, "test_id": ticket.test_id,
+        }
+        self._client.table(TABLE).insert(row).execute()
+        self._audit("created", ticket.id, {"priority": ticket.priority.value, "error_summary": ticket.error_summary})
+        return ticket
+
+    def update_ticket(self, ticket_id: str, **fields):
+        clean = {k: (v.value if hasattr(v, "value") else v) for k, v in fields.items()}
+        self._client.table(TABLE).update(clean).eq("id", ticket_id).execute()
+        self._audit("updated", ticket_id, clean)
+
+    def get_open_tickets(self, repo: Optional[str] = None):
+        q = self._client.table(TABLE).select("*")
+        if repo:
+            q = q.eq("repo", repo)
+        rows = q.execute().data
+        return [self._row_to_ticket(r) for r in rows if r["status"] not in ("done", "in_progress")]
+
+    def dispense_next(self, repo: Optional[str] = None):
+        candidates = self.get_open_tickets(repo)
+        if not candidates:
+            return None
+        candidates.sort(key=lambda t: (PRIORITY_ORDER[t.priority.value], t.created_at))
+        ticket = candidates[0]
+        self.update_ticket(ticket.id, status=TaskStatus.IN_PROGRESS)
+        ticket.status = TaskStatus.IN_PROGRESS
+        return ticket
+
+    def purge_old(self, older_than_days: int, repo: Optional[str] = None):
+        cutoff = (datetime.now(timezone.utc) - timedelta(days=older_than_days)).isoformat()
+        q = self._client.table(TABLE).select("id").in_("status", ["done", "failed"]).lt("created_at", cutoff)
+        if repo:
+            q = q.eq("repo", repo)
+        rows = q.execute().data
+        ids = [r["id"] for r in rows]
+        for tid in ids:
+            self._client.table(TABLE).delete().eq("id", tid).execute()
+        return len(ids)

issueloop/folder_reader.py

@@ -0,0 +1,89 @@
+import json
+import sys
+from pathlib import Path
+
+import pathspec
+
+EXT_LANGUAGE_MAP = {
+    ".py": "python",
+    ".go": "go",
+    ".js": "javascript",
+    ".ts": "typescript",
+    ".jsx": "javascript",
+    ".tsx": "typescript",
+    ".rs": "rust",
+    ".java": "java",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".rb": "ruby",
+}
+
+ALWAYS_SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", "vectordb"}
+
+
+def load_gitignore_spec(repo_path: Path):
+    gitignore = repo_path / ".gitignore"
+    lines = gitignore.read_text().splitlines() if gitignore.exists() else []
+    return pathspec.PathSpec.from_lines("gitwildmatch", lines)
+
+
+def walk_repo(repo_path: Path):
+    spec = load_gitignore_spec(repo_path)
+    files = []
+    lang_counts: dict[str, int] = {}
+    for path in repo_path.rglob("*"):
+        if path.is_dir():
+            continue
+        if any(part in ALWAYS_SKIP_DIRS for part in path.parts):
+            continue
+        rel = path.relative_to(repo_path)
+        if spec.match_file(str(rel)):
+            continue
+        ext = path.suffix
+        language = EXT_LANGUAGE_MAP.get(ext, "unknown")
+        try:
+            size = path.stat().st_size
+        except OSError:
+            continue
+        files.append({
+            "path": str(rel),
+            "ext": ext,
+            "language": language,
+            "size_bytes": size,
+        })
+        lang_counts[language] = lang_counts.get(language, 0) + 1
+    return {
+        "repo_path": str(repo_path),
+        "file_count": len(files),
+        "language_breakdown": lang_counts,
+        "files": files,
+    }
+
+
+def write_inventory(repo_path: Path):
+    inventory = walk_repo(repo_path)
+    out_dir = Path(__file__).resolve().parent.parent / "data" / "logs"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_file = out_dir / f"{repo_path.name}_files.json"
+    out_file.write_text(json.dumps(inventory, indent=2))
+    return out_file
+
+
+def main():
+    if len(sys.argv) != 2:
+        print("ISSUELOOP:: usage: python -m issueloop.folder_reader <path-to-repo>")
+        sys.exit(1)
+    repo_path = Path(sys.argv[1]).resolve()
+    if not repo_path.is_dir():
+        print(f"ISSUELOOP:: There is no directory: {repo_path}")
+        sys.exit(1)
+    out_file = write_inventory(repo_path)
+    inventory = json.loads(out_file.read_text())
+
+    print(f"ISSUELOOP:: scanned {inventory['file_count']} files in {repo_path}")
+    print(f"ISSUELOOP:: language breakdown: {inventory['language_breakdown']}")
+    print(f"ISSUELOOP:: written: {out_file}")
+
+
+if __name__ == "__main__":
+    main()