@apolloyh/apollo-agent 0.1.2 → 0.1.4

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

@@ -1,310 +0,0 @@
-#!/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

@@ -1,254 +0,0 @@
-#!/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()