@apolloyh/apollo-agent 0.1.0

package/src/skills/tech-research-skill/repo-fetch

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+import argparse
+import datetime as dt
+import json
+import os
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+
+VERSION = "1.0.0"
+
+
+def load_env_file():
+    env_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env")
+    if not os.path.exists(env_path):
+        return
+    try:
+        with open(env_path, "r", encoding="utf-8") as handle:
+            for raw_line in handle:
+                line = raw_line.strip()
+                if not line or line.startswith("#") or "=" not in line:
+                    continue
+                key, value = line.split("=", 1)
+                key = key.strip()
+                value = value.strip().strip('"').strip("'")
+                if key and key not in os.environ:
+                    os.environ[key] = value
+    except OSError as exc:
+        fail("env_error", "could not read .env file", {"error": str(exc)})
+
+
+def now_iso():
+    return dt.datetime.now(dt.timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def fail(code, message, details=None, exit_code=1):
+    payload = {
+        "ok": False,
+        "error": {
+            "code": code,
+            "message": message,
+            "details": details or {},
+        },
+    }
+    print(json.dumps(payload, ensure_ascii=False, sort_keys=True), file=sys.stderr)
+    raise SystemExit(exit_code)
+
+
+def parse_owner_repo(value):
+    cleaned = value.strip()
+    if "github.com/" in cleaned:
+        parsed = urllib.parse.urlparse(cleaned)
+        cleaned = parsed.path.strip("/")
+    parts = cleaned.strip("/").split("/")
+    if len(parts) != 2 or not all(parts):
+        fail("invalid_arguments", "repo must be in owner/repo form", {"value": value})
+    return parts[0], parts[1]
+
+
+def parse_include(values, include_issues, include_commits):
+    selected = set()
+    for value in values or []:
+        for item in value.split(","):
+            item = item.strip().lower()
+            if not item:
+                continue
+            if item not in {"issues", "commits"}:
+                fail("invalid_arguments", "include must contain only issues or commits", {"value": item})
+            selected.add(item)
+    if include_issues:
+        selected.add("issues")
+    if include_commits:
+        selected.add("commits")
+    return sorted(selected)
+
+
+def request_json(url):
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "User-Agent": "tech-research-skill/repo-fetch",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    request = urllib.request.Request(url, headers=headers)
+    try:
+        with urllib.request.urlopen(request, timeout=20) as response:
+            charset = response.headers.get_content_charset() or "utf-8"
+            return json.loads(response.read().decode(charset))
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        message = body
+        try:
+            parsed = json.loads(body)
+            message = parsed.get("message", body)
+        except json.JSONDecodeError:
+            pass
+        details = {"url": url, "status": exc.code, "message": message}
+        if exc.code in {403, 429}:
+            details["hint"] = "GitHub API may be rate-limited. Set GITHUB_TOKEN or GH_TOKEN, or put GITHUB_TOKEN in this skill directory's ignored .env file."
+        fail("github_http_error", "GitHub API request failed", details)
+    except urllib.error.URLError as exc:
+        fail("network_error", "GitHub API request failed", {"url": url, "reason": str(exc.reason)})
+    except json.JSONDecodeError as exc:
+        fail("invalid_response", "GitHub API returned invalid JSON", {"url": url, "error": str(exc)})
+
+
+def build_url(api_url, path, params=None):
+    base = api_url.rstrip("/")
+    query = urllib.parse.urlencode(params or {})
+    return f"{base}{path}" + (f"?{query}" if query else "")
+
+
+def compact_repo(repo):
+    return {
+        "id": repo.get("id"),
+        "name": repo.get("name"),
+        "full_name": repo.get("full_name"),
+        "description": repo.get("description"),
+        "private": repo.get("private"),
+        "html_url": repo.get("html_url"),
+        "default_branch": repo.get("default_branch"),
+        "language": repo.get("language"),
+        "topics": repo.get("topics", []),
+        "stargazers_count": repo.get("stargazers_count"),
+        "watchers_count": repo.get("watchers_count"),
+        "forks_count": repo.get("forks_count"),
+        "open_issues_count": repo.get("open_issues_count"),
+        "license": repo.get("license", {}).get("spdx_id") if repo.get("license") else None,
+        "archived": repo.get("archived"),
+        "disabled": repo.get("disabled"),
+        "created_at": repo.get("created_at"),
+        "updated_at": repo.get("updated_at"),
+        "pushed_at": repo.get("pushed_at"),
+        "owner": {
+            "login": (repo.get("owner") or {}).get("login"),
+            "type": (repo.get("owner") or {}).get("type"),
+        },
+    }
+
+
+def compact_search_repo(repo):
+    compacted = compact_repo(repo)
+    compacted.update(
+        {
+            "score": repo.get("score"),
+            "size": repo.get("size"),
+            "homepage": repo.get("homepage"),
+            "has_issues": repo.get("has_issues"),
+            "has_projects": repo.get("has_projects"),
+            "has_wiki": repo.get("has_wiki"),
+        }
+    )
+    return compacted
+
+
+def compact_issue(issue):
+    return {
+        "id": issue.get("id"),
+        "number": issue.get("number"),
+        "title": issue.get("title"),
+        "state": issue.get("state"),
+        "html_url": issue.get("html_url"),
+        "labels": [label.get("name") for label in issue.get("labels", []) if label.get("name")],
+        "comments": issue.get("comments"),
+        "created_at": issue.get("created_at"),
+        "updated_at": issue.get("updated_at"),
+        "closed_at": issue.get("closed_at"),
+        "user": {
+            "login": (issue.get("user") or {}).get("login"),
+            "type": (issue.get("user") or {}).get("type"),
+        },
+    }
+
+
+def compact_commit(commit):
+    commit_data = commit.get("commit") or {}
+    author_data = commit_data.get("author") or {}
+    return {
+        "sha": commit.get("sha"),
+        "html_url": commit.get("html_url"),
+        "message": (commit_data.get("message") or "").splitlines()[0],
+        "date": author_data.get("date"),
+        "author": {
+            "name": author_data.get("name"),
+            "login": (commit.get("author") or {}).get("login"),
+        },
+    }
+
+
+def fetch_paged(api_url, path, per_page, max_pages, extra_params=None):
+    items = []
+    for page in range(1, max_pages + 1):
+        params = {"per_page": per_page, "page": page}
+        params.update(extra_params or {})
+        batch = request_json(build_url(api_url, path, params))
+        if not isinstance(batch, list):
+            fail("invalid_response", "GitHub API returned a non-list page", {"path": path, "page": page})
+        items.extend(batch)
+        if len(batch) < per_page:
+            break
+    return items
+
+
+def main():
+    load_env_file()
+
+    parser = argparse.ArgumentParser(description="Fetch GitHub repository or repository-search data as JSON.")
+    parser.add_argument("repo", nargs="?", help="Repository in owner/repo form or a GitHub repository URL.")
+    parser.add_argument("--search", help="GitHub repository search query.")
+    parser.add_argument("--include", action="append", help="Comma-separated optional datasets: issues,commits.")
+    parser.add_argument("--issues", action="store_true", help="Include open issues. Pull requests are filtered out.")
+    parser.add_argument("--commits", action="store_true", help="Include recent commits.")
+    parser.add_argument("--per-page", type=int, default=30, help="GitHub page size, 1-100. Default: 30.")
+    parser.add_argument("--max-pages", type=int, default=1, help="Maximum pages per optional dataset. Default: 1.")
+    args = parser.parse_args()
+
+    if args.per_page < 1 or args.per_page > 100:
+        fail("invalid_arguments", "--per-page must be between 1 and 100", {"per_page": args.per_page})
+    if args.max_pages < 1:
+        fail("invalid_arguments", "--max-pages must be at least 1", {"max_pages": args.max_pages})
+    if bool(args.repo) == bool(args.search):
+        fail("invalid_arguments", "provide exactly one of repo or --search")
+
+    include = parse_include(args.include, args.issues, args.commits)
+    api_url = os.environ.get("GITHUB_API_URL", "https://api.github.com")
+
+    if args.search:
+        if include:
+            fail("invalid_arguments", "--include, --issues, and --commits require a concrete repository")
+        search_json = request_json(
+            build_url(
+                api_url,
+                "/search/repositories",
+                {
+                    "q": args.search,
+                    "sort": "stars",
+                    "order": "desc",
+                    "per_page": args.per_page,
+                    "page": 1,
+                },
+            )
+        )
+        items = search_json.get("items")
+        if not isinstance(items, list):
+            fail("invalid_response", "GitHub search returned invalid results")
+        payload = {
+            "ok": True,
+            "source": "repo-fetch",
+            "version": VERSION,
+            "fetched_at": now_iso(),
+            "mode": "search",
+            "input": {
+                "query": args.search,
+                "per_page": args.per_page,
+                "max_pages": 1,
+            },
+            "search": {
+                "query": args.search,
+                "total_count": search_json.get("total_count"),
+                "incomplete_results": search_json.get("incomplete_results"),
+                "items": [compact_search_repo(item) for item in items],
+            },
+            "data": {},
+        }
+        print(json.dumps(payload, ensure_ascii=False, sort_keys=True))
+        return
+
+    owner, repo = parse_owner_repo(args.repo)
+    repo_json = request_json(build_url(api_url, f"/repos/{owner}/{repo}"))
+    data = {}
+
+    if "issues" in include:
+        raw_issues = fetch_paged(
+            api_url,
+            f"/repos/{owner}/{repo}/issues",
+            args.per_page,
+            args.max_pages,
+            {"state": "all", "sort": "updated", "direction": "desc"},
+        )
+        data["issues"] = [compact_issue(item) for item in raw_issues if "pull_request" not in item]
+
+    if "commits" in include:
+        raw_commits = fetch_paged(api_url, f"/repos/{owner}/{repo}/commits", args.per_page, args.max_pages)
+        data["commits"] = [compact_commit(item) for item in raw_commits]
+
+    payload = {
+        "ok": True,
+        "source": "repo-fetch",
+        "version": VERSION,
+        "fetched_at": now_iso(),
+        "mode": "repository",
+        "input": {
+            "owner": owner,
+            "repo": repo,
+            "include": include,
+            "per_page": args.per_page,
+            "max_pages": args.max_pages,
+        },
+        "repository": compact_repo(repo_json),
+        "data": data,
+    }
+    print(json.dumps(payload, ensure_ascii=False, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

package/src/skills/tech-research-skill/report-generate

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+import argparse
+import datetime as dt
+import html
+import json
+import sys
+
+VERSION = "1.0.0"
+
+
+def now_iso():
+    return dt.datetime.now(dt.timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def fail(code, message, details=None, exit_code=1):
+    payload = {
+        "ok": False,
+        "error": {
+            "code": code,
+            "message": message,
+            "details": details or {},
+        },
+    }
+    print(json.dumps(payload, ensure_ascii=False, sort_keys=True), file=sys.stderr)
+    raise SystemExit(exit_code)
+
+
+def read_stdin_json():
+    raw = sys.stdin.read()
+    if not raw.strip():
+        fail("invalid_input", "stdin is empty")
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as exc:
+        fail("invalid_json", "stdin must be valid JSON", {"error": str(exc)})
+
+
+def validate_analysis_payload(payload):
+    if not isinstance(payload, dict):
+        fail("invalid_input", "input JSON must be an object")
+    if payload.get("ok") is not True or payload.get("source") != "repo-analyze":
+        fail("invalid_input", "input must be successful repo-analyze output")
+    analysis = payload.get("analysis")
+    if not isinstance(analysis, dict):
+        fail("invalid_input", "input missing analysis object")
+    return analysis
+
+
+def bullet_lines(items, formatter):
+    if not items:
+        return ["- None reported."]
+    return [f"- {formatter(item)}" for item in items]
+
+
+def evidence_source_lines(payload):
+    sources = payload.get("evidence_sources") or {}
+    lines = ["", "## Evidence Sources", ""]
+    has_sources = False
+
+    query = sources.get("github_search_query")
+    if query:
+        lines.append(f"- GitHub search query: `{query}`")
+        has_sources = True
+
+    for repo in sources.get("repositories") or []:
+        if not isinstance(repo, dict):
+            continue
+        name = repo.get("name") or "GitHub repository"
+        url = repo.get("url")
+        lines.append(f"- GitHub repository: {name}" + (f" - {url}" if url else ""))
+        has_sources = True
+
+    for page in sources.get("web_pages") or []:
+        if not isinstance(page, dict):
+            continue
+        title = page.get("title") or page.get("url") or "Web page"
+        url = page.get("url")
+        lines.append(f"- Web page: {title}" + (f" - {url}" if url else ""))
+        has_sources = True
+
+    if not has_sources:
+        repo = payload.get("input", {}).get("repository_full_name")
+        if repo and not repo.startswith("github search:"):
+            lines.append(f"- GitHub repository: {repo} - https://github.com/{repo}")
+        else:
+            lines.append("- None captured in the input payload.")
+
+    return lines
+
+
+def render_daily_markdown(payload, analysis):
+    repo = payload.get("input", {}).get("repository_full_name") or "unknown repository"
+    lines = [
+        f"# Daily Repository Health Report: {repo}",
+        "",
+        f"- Generated: {now_iso()}",
+        f"- Health score: {analysis.get('health_score')}/100",
+        f"- Model: {payload.get('model')}",
+        "",
+        "## Summary",
+        "",
+        str(analysis.get("summary", "")),
+        "",
+        "## Signals",
+        "",
+    ]
+    lines.extend(bullet_lines(analysis.get("signals", []), lambda x: f"**{x.get('name', 'signal')}** ({x.get('status', 'unknown')}): {x.get('detail', '')}"))
+    lines.extend(["", "## Actions", ""])
+    lines.extend(bullet_lines(analysis.get("recommendations", []), lambda x: f"[{x.get('priority', 'unknown')}] {x.get('action', '')} - {x.get('reason', '')}"))
+    lines.extend(evidence_source_lines(payload))
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def render_weekly_markdown(payload, analysis):
+    repo = payload.get("input", {}).get("repository_full_name") or "unknown repository"
+    lines = [
+        f"# Weekly Repository Health Review: {repo}",
+        "",
+        f"- Generated: {now_iso()}",
+        f"- Health score: {analysis.get('health_score')}/100",
+        f"- Included data: {', '.join(payload.get('input', {}).get('included', [])) or 'repository metadata only'}",
+        "",
+        "## Executive Summary",
+        "",
+        str(analysis.get("summary", "")),
+        "",
+        "## Health Signals",
+        "",
+    ]
+    lines.extend(bullet_lines(analysis.get("signals", []), lambda x: f"**{x.get('name', 'signal')}**: {x.get('status', 'unknown')} - {x.get('detail', '')}"))
+    lines.extend(["", "## Risks", ""])
+    lines.extend(bullet_lines(analysis.get("risks", []), lambda x: f"[{x.get('severity', 'unknown')}] {x.get('title', '')} - {x.get('detail', '')}"))
+    lines.extend(["", "## Recommended Next Steps", ""])
+    lines.extend(bullet_lines(analysis.get("recommendations", []), lambda x: f"[{x.get('priority', 'unknown')}] {x.get('action', '')} - {x.get('reason', '')}"))
+    lines.extend(evidence_source_lines(payload))
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def render_investment_markdown(payload, analysis):
+    repo = payload.get("input", {}).get("repository_full_name") or "unknown repository"
+    notes = analysis.get("investment_notes") or {}
+    lines = [
+        f"# Investment Repository Diligence: {repo}",
+        "",
+        f"- Generated: {now_iso()}",
+        f"- Health score: {analysis.get('health_score')}/100",
+        f"- Investment fit: {notes.get('fit', 'unknown')}",
+        "",
+        "## Thesis",
+        "",
+        str(notes.get("rationale") or analysis.get("summary", "")),
+        "",
+        "## Key Signals",
+        "",
+    ]
+    lines.extend(bullet_lines(analysis.get("signals", []), lambda x: f"**{x.get('name', 'signal')}** ({x.get('status', 'unknown')}): {x.get('detail', '')}"))
+    lines.extend(["", "## Diligence Risks", ""])
+    lines.extend(bullet_lines(analysis.get("risks", []), lambda x: f"[{x.get('severity', 'unknown')}] {x.get('title', '')} - {x.get('detail', '')}"))
+    lines.extend(["", "## Diligence Questions", ""])
+    lines.extend(bullet_lines(notes.get("diligence_questions", []), lambda x: str(x)))
+    lines.extend(evidence_source_lines(payload))
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def markdown_to_html(markdown):
+    lines = []
+    in_list = False
+    for raw_line in markdown.splitlines():
+        line = raw_line.rstrip()
+        if line.startswith("# "):
+            if in_list:
+                lines.append("</ul>")
+                in_list = False
+            lines.append(f"<h1>{html.escape(line[2:])}</h1>")
+        elif line.startswith("## "):
+            if in_list:
+                lines.append("</ul>")
+                in_list = False
+            lines.append(f"<h2>{html.escape(line[3:])}</h2>")
+        elif line.startswith("- "):
+            if not in_list:
+                lines.append("<ul>")
+                in_list = True
+            lines.append(f"<li>{html.escape(line[2:])}</li>")
+        elif not line:
+            if in_list:
+                lines.append("</ul>")
+                in_list = False
+        else:
+            if in_list:
+                lines.append("</ul>")
+                in_list = False
+            lines.append(f"<p>{html.escape(line)}</p>")
+    if in_list:
+        lines.append("</ul>")
+    body = "\n".join(lines)
+    return f"""<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Repository Health Report</title>
+  <style>
+    body {{ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; line-height: 1.55; margin: 40px auto; max-width: 920px; padding: 0 20px; color: #172026; }}
+    h1, h2 {{ line-height: 1.2; }}
+    h1 {{ margin-bottom: 24px; }}
+    h2 {{ border-top: 1px solid #d8dee4; margin-top: 32px; padding-top: 24px; }}
+    li {{ margin: 8px 0; }}
+  </style>
+</head>
+<body>
+{body}
+</body>
+</html>
+"""
+
+
+def render_report(template, output_format, payload, analysis):
+    renderers = {
+        "daily": render_daily_markdown,
+        "weekly": render_weekly_markdown,
+        "investment": render_investment_markdown,
+    }
+    markdown = renderers[template](payload, analysis)
+    if output_format == "markdown":
+        return markdown
+    if output_format == "html":
+        return markdown_to_html(markdown)
+    fail("invalid_arguments", "unsupported output format", {"format": output_format})
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate markdown or HTML reports from repo-analyze JSON.")
+    parser.add_argument("--template", choices=["daily", "weekly", "investment"], default="daily", help="Report template. Default: daily.")
+    parser.add_argument("--format", choices=["markdown", "html"], default="markdown", help="Output format. Default: markdown.")
+    parser.add_argument("--output", help="Write report to this path instead of stdout.")
+    args = parser.parse_args()
+
+    payload = read_stdin_json()
+    analysis = validate_analysis_payload(payload)
+    report = render_report(args.template, args.format, payload, analysis)
+
+    if args.output:
+        try:
+            with open(args.output, "w", encoding="utf-8") as handle:
+                handle.write(report)
+        except OSError as exc:
+            fail("write_error", "could not write output file", {"path": args.output, "error": str(exc)})
+    else:
+        print(report, end="")
+
+
+if __name__ == "__main__":
+    main()