github-reporadar 0.1.0

package/dist-cli/cli.js

@@ -0,0 +1,655 @@
+import { execFileSync, execFile } from "node:child_process";
+import { readFileSync, mkdirSync, writeFileSync, createReadStream, existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve, extname, normalize, sep, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:http";
+function toLocalYMD(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function dateRange(now, days) {
+  const dates = [];
+  for (let i = days - 1; i >= 0; i--) {
+    dates.push(toLocalYMD(new Date(now.getTime() - i * 24 * 60 * 60 * 1e3)));
+  }
+  return dates;
+}
+function daysSince(iso, now) {
+  return Math.max(0, Math.floor((now.getTime() - new Date(iso).getTime()) / (24 * 60 * 60 * 1e3)));
+}
+function buildRepoStats(repos, activity, days, now) {
+  const dates = dateRange(now, days);
+  const dateIndex = new Map(dates.map((d, i) => [d, i]));
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const a of activity) {
+    const idx = dateIndex.get(a.date);
+    if (idx === void 0) continue;
+    let arr = byRepo.get(a.repo);
+    if (!arr) {
+      arr = new Array(days).fill(0);
+      byRepo.set(a.repo, arr);
+    }
+    arr[idx] += a.commits;
+  }
+  return repos.map((repo) => {
+    const dailyCommits = byRepo.get(repo.nameWithOwner) ?? new Array(days).fill(0);
+    return {
+      repo,
+      totalCommits: dailyCommits.reduce((s, n) => s + n, 0),
+      daysSincePush: daysSince(repo.pushedAt, now),
+      dailyCommits
+    };
+  });
+}
+function sortRepoStats(stats, key) {
+  const sorted = [...stats];
+  switch (key) {
+    case "active":
+      sorted.sort((a, b) => b.totalCommits - a.totalCommits);
+      break;
+    case "recent":
+      sorted.sort((a, b) => a.daysSincePush - b.daysSincePush);
+      break;
+    case "stale":
+      sorted.sort((a, b) => b.daysSincePush - a.daysSincePush);
+      break;
+  }
+  return sorted;
+}
+const CACHE_DIR = join(import.meta.dirname, "..", "public", "data");
+const dim = (s) => `\x1B[2m${s}\x1B[0m`;
+const bold = (s) => `\x1B[1m${s}\x1B[0m`;
+const green = (s) => `\x1B[32m${s}\x1B[0m`;
+const yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+const red = (s) => `\x1B[31m${s}\x1B[0m`;
+const cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+const SPARK_CHARS = ["·", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+function sparkline(daily, width) {
+  const bucketSize = Math.ceil(daily.length / width);
+  const buckets = [];
+  for (let i = 0; i < daily.length; i += bucketSize) {
+    buckets.push(daily.slice(i, i + bucketSize).reduce((s, n) => s + n, 0));
+  }
+  const max = Math.max(...buckets, 1);
+  return buckets.map((v) => v === 0 ? SPARK_CHARS[0] : SPARK_CHARS[1 + Math.min(7, Math.floor(v / max * 7))]).join("");
+}
+function argValue(flag) {
+  const i = process.argv.indexOf(flag);
+  return i !== -1 ? process.argv[i + 1] : void 0;
+}
+function runBrief({ dataDir, days, sort, limit, includePrivate }) {
+  let repos, activity, meta;
+  try {
+    repos = JSON.parse(readFileSync(join(dataDir, "repos.json"), "utf8"));
+    activity = JSON.parse(readFileSync(join(dataDir, "activity.json"), "utf8"));
+    meta = JSON.parse(readFileSync(join(dataDir, "meta.json"), "utf8"));
+  } catch {
+    throw new Error(`キャッシュがありません(${dataDir})。先にsyncを実行してください。`);
+  }
+  const now = /* @__PURE__ */ new Date();
+  const visibleRepos = includePrivate ? repos : repos.filter((r) => !r.isPrivate);
+  const stats = sortRepoStats(buildRepoStats(visibleRepos, activity, days, now), sort);
+  const shown = stats.slice(0, limit);
+  const nameWidth = Math.max(...shown.map((s) => s.repo.nameWithOwner.length), 10);
+  console.log(
+    bold(`GitHub RepoRadar`) + dim(
+      `  ${days}日間 / sort:${sort} / sync: ${meta.lastSyncAt.slice(0, 16).replace("T", " ")} (${meta.login})`
+    )
+  );
+  console.log();
+  for (const s of shown) {
+    const ago = s.daysSincePush === 0 ? green("today ") : s.daysSincePush <= 7 ? yellow(`${String(s.daysSincePush).padStart(2)}d ago`) : red(`${String(s.daysSincePush).padStart(2)}d ago`);
+    const lastMsg = s.repo.lastCommits[0]?.message.split("\n")[0] ?? dim("(no commits)");
+    const priv = s.repo.isPrivate ? dim(" 🔒") : "";
+    console.log(
+      `${cyan(s.repo.nameWithOwner.padEnd(nameWidth))}${priv}  ${sparkline(s.dailyCommits, 20)}  ${String(s.totalCommits).padStart(4)}c  ${ago}  ${dim(lastMsg.slice(0, 60))}`
+    );
+  }
+  console.log();
+  const total = stats.reduce((sum, s) => sum + s.totalCommits, 0);
+  console.log(dim(`${stats.length} repos / ${total} commits (直近${days}日)。全件はWeb UIで。`));
+}
+const isMain$1 = process.argv[1]?.endsWith("brief.ts") || process.argv[1]?.endsWith("brief.js");
+if (isMain$1) {
+  try {
+    runBrief({
+      dataDir: CACHE_DIR,
+      days: Number(argValue("--days") ?? 30),
+      sort: argValue("--sort") ?? "active",
+      limit: Number(argValue("--limit") ?? 15),
+      includePrivate: process.argv.includes("--private")
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+}
+function createLimiter(limit) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new RangeError(`createLimiter: limitは1以上の整数が必要 (受け取った値: ${limit})`);
+  }
+  let active = 0;
+  const waiting = [];
+  let failure = null;
+  let failed = false;
+  return async function run(fn) {
+    while (active >= limit) await new Promise((resolve2) => waiting.push(resolve2));
+    if (failed) {
+      waiting.shift()?.();
+      throw failure;
+    }
+    active++;
+    try {
+      return await fn();
+    } catch (err) {
+      if (!failed) {
+        failed = true;
+        failure = err;
+      }
+      throw err;
+    } finally {
+      active--;
+      waiting.shift()?.();
+    }
+  };
+}
+function getToken() {
+  return execFileSync("gh", ["auth", "token"], { encoding: "utf8" }).trim();
+}
+const API = "https://api.github.com";
+const MAX_COMMIT_PAGES = 10;
+const CONCURRENCY = 16;
+const MAX_RETRIES = 3;
+async function rest(token, path) {
+  const url = path.startsWith("https://") ? path : `${API}${path}`;
+  for (let attempt = 0; ; attempt++) {
+    const res = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+      }
+    });
+    if (res.ok) {
+      const link = res.headers.get("link");
+      const next = link?.match(/<([^>]+)>;\s*rel="next"/)?.[1] ?? null;
+      return { json: await res.json(), next };
+    }
+    const retryable = res.status === 403 || res.status === 429 || res.status >= 500;
+    if (retryable && attempt < MAX_RETRIES) {
+      const retryAfter = Number(res.headers.get("retry-after"));
+      const reset = Number(res.headers.get("x-ratelimit-reset"));
+      let waitMs = 2e3 * (attempt + 1);
+      if (Number.isFinite(retryAfter) && retryAfter > 0) waitMs = retryAfter * 1e3;
+      else if (Number.isFinite(reset) && reset > 0) waitMs = Math.max(0, reset * 1e3 - Date.now());
+      await new Promise((r) => setTimeout(r, Math.min(waitMs, 6e4)));
+      continue;
+    }
+    throw new Error(`GitHub API HTTP ${res.status} for ${path}: ${await res.text()}`);
+  }
+}
+async function fetchLogin(token) {
+  const { json } = await rest(token, "/user");
+  return json.login;
+}
+async function listRecentRepos(token, since, includePrivate) {
+  const repos = [];
+  const visibility = "";
+  let url = `/user/repos?sort=pushed&per_page=100&affiliation=owner${visibility}`;
+  while (url) {
+    const { json, next } = await rest(token, url);
+    const page = json;
+    repos.push(...page);
+    if (page.length === 0 || new Date(page[page.length - 1].pushed_at) < since) break;
+    url = next;
+  }
+  return repos.filter((r) => {
+    return new Date(r.pushed_at) >= since;
+  });
+}
+async function listCommits(token, repo, since) {
+  const commits = [];
+  let url = `/repos/${repo.full_name}/commits?since=${since.toISOString()}&per_page=100`;
+  let pages = 0;
+  while (url && pages < MAX_COMMIT_PAGES) {
+    let result;
+    try {
+      result = await rest(token, url);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("HTTP 409")) return [];
+      throw err;
+    }
+    commits.push(...result.json);
+    url = result.next;
+    pages++;
+  }
+  return commits.filter((c) => c.author?.type !== "Bot");
+}
+async function fetchOpenCounts(token, fullNames, limit) {
+  const result = /* @__PURE__ */ new Map();
+  const CHUNK = 25;
+  const chunks = [];
+  for (let i = 0; i < fullNames.length; i += CHUNK) chunks.push(fullNames.slice(i, i + CHUNK));
+  await Promise.all(chunks.map((chunk) => limit(async () => {
+    const fields = chunk.map((name, j) => {
+      const [owner, repo] = name.split("/");
+      return `r${j}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(repo)}) { issues(states: OPEN) { totalCount } pullRequests(states: OPEN) { totalCount } }`;
+    }).join("\n");
+    const res = await fetch(`${API}/graphql`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ query: `query {
+${fields}
+}` })
+    });
+    if (!res.ok) throw new Error(`GitHub GraphQL HTTP ${res.status}: ${await res.text()}`);
+    const json = await res.json();
+    chunk.forEach((name, j) => {
+      const node = json.data?.[`r${j}`];
+      result.set(name, {
+        pr: node?.pullRequests.totalCount ?? 0,
+        issue: node?.issues.totalCount ?? 0
+      });
+    });
+  })));
+  return result;
+}
+async function listOpenIssues(token, repo) {
+  const items = [];
+  let url = `/repos/${repo.full_name}/issues?state=open&per_page=100`;
+  let pages = 0;
+  while (url && pages < 5) {
+    let result;
+    try {
+      result = await rest(token, url);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("HTTP 409")) return [];
+      throw err;
+    }
+    for (const it of result.json) {
+      items.push({
+        repo: repo.full_name,
+        type: it.pull_request ? "pr" : "issue",
+        number: it.number,
+        title: it.title,
+        state: it.state,
+        labels: it.labels.map((l) => l.name),
+        updatedAt: it.updated_at,
+        url: it.html_url,
+        comments: it.comments
+      });
+    }
+    url = result.next;
+    pages++;
+  }
+  return items;
+}
+function createProgress(repoTotal, issueTotal) {
+  const enabled = process.stdout.isTTY === true;
+  let repos = 0;
+  let issues = 0;
+  const render = () => {
+    if (enabled) process.stdout.write(`\r  repos: ${repos}/${repoTotal}  issues/PRs: ${issues}/${issueTotal}`);
+  };
+  return {
+    repoDone: () => {
+      repos++;
+      render();
+    },
+    issueDone: () => {
+      issues++;
+      render();
+    },
+    finish: () => {
+      if (enabled && repoTotal > 0) process.stdout.write("\n");
+    }
+  };
+}
+async function fetchActivity(token, from, opts) {
+  const limit = createLimiter(CONCURRENCY);
+  const [login, recentRepos] = await Promise.all([
+    fetchLogin(token),
+    listRecentRepos(token, from)
+  ]);
+  const openCounts = await fetchOpenCounts(token, recentRepos.map((r) => r.full_name), limit);
+  const issueRepos = recentRepos.filter((r) => {
+    const c = openCounts.get(r.full_name);
+    return c != null && c.pr + c.issue > 0;
+  });
+  const progress = createProgress(recentRepos.length, issueRepos.length);
+  const commitsPromise = Promise.all(
+    recentRepos.map(
+      (r) => limit(() => listCommits(token, r, from)).then((commits) => {
+        progress.repoDone();
+        return commits;
+      })
+    )
+  );
+  const issuesPromise = Promise.all(
+    issueRepos.map(
+      (r) => limit(() => listOpenIssues(token, r)).then((items) => {
+        progress.issueDone();
+        return items;
+      })
+    )
+  );
+  const [commitsByRepo, issuesByRepo] = await Promise.all([commitsPromise, issuesPromise]);
+  progress.finish();
+  const repos = [];
+  const activity = [];
+  recentRepos.forEach((r, i) => {
+    const commits = commitsByRepo[i];
+    if (commits.length === 0) return;
+    const daily = /* @__PURE__ */ new Map();
+    for (const c of commits) {
+      const ymd = toLocalYMD(new Date(c.commit.author.date));
+      daily.set(ymd, (daily.get(ymd) ?? 0) + 1);
+    }
+    for (const [date, count] of daily) {
+      activity.push({ date, repo: r.full_name, commits: count });
+    }
+    const counts = openCounts.get(r.full_name) ?? { pr: 0, issue: 0 };
+    repos.push({
+      nameWithOwner: r.full_name,
+      url: r.html_url,
+      description: r.description,
+      isPrivate: r.private,
+      primaryLanguage: r.language,
+      pushedAt: r.pushed_at,
+      openPrCount: counts.pr,
+      openIssueCount: counts.issue,
+      lastCommits: commits.slice(0, 5).map((c) => ({
+        message: c.commit.message,
+        committedDate: c.commit.author.date
+      }))
+    });
+  });
+  const issues = issuesByRepo.flat();
+  return { login, repos, activity, issues };
+}
+const REPO_CACHE_DIR = join(import.meta.dirname, "..", "public", "data");
+const DEFAULT_WINDOW_DAYS = 90;
+async function runSync(opts) {
+  const windowDays = opts.days ?? DEFAULT_WINDOW_DAYS;
+  const log = opts.log ?? ((line) => console.log(line));
+  if (!Number.isFinite(windowDays) || windowDays < 1 || windowDays > 365) {
+    throw new Error(`--days は 1〜365 で指定してください: ${windowDays}`);
+  }
+  const to = /* @__PURE__ */ new Date();
+  const from = new Date(to.getTime() - windowDays * 24 * 60 * 60 * 1e3);
+  log(`GitHub RepoRadar sync: ${from.toISOString().slice(0, 10)} 〜 ${to.toISOString().slice(0, 10)} (${windowDays}日)`);
+  const token = getToken();
+  const { login, repos, activity, issues } = await fetchActivity(token, from);
+  mkdirSync(opts.dataDir, { recursive: true });
+  const meta = { lastSyncAt: to.toISOString(), login, windowDays, includesPrivate: true };
+  writeFileSync(join(opts.dataDir, "repos.json"), JSON.stringify(repos, null, 2));
+  writeFileSync(join(opts.dataDir, "activity.json"), JSON.stringify(activity, null, 2));
+  writeFileSync(join(opts.dataDir, "issues.json"), JSON.stringify(issues, null, 2));
+  writeFileSync(join(opts.dataDir, "meta.json"), JSON.stringify(meta, null, 2));
+  const totalCommits = activity.reduce((sum, a) => sum + a.commits, 0);
+  log(`OK: ${repos.length} repos / ${totalCommits} commits / ${issues.length} open issues+PRs → ${opts.dataDir}`);
+  return { login, repos: repos.length, commits: totalCommits, issues: issues.length };
+}
+const isMain = process.argv[1]?.endsWith("sync.ts") || process.argv[1]?.endsWith("sync.js");
+if (isMain) {
+  const daysArg = process.argv.indexOf("--days");
+  const days = daysArg !== -1 ? Number(process.argv[daysArg + 1]) : void 0;
+  runSync({ dataDir: REPO_CACHE_DIR, days }).catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  });
+}
+const COMMANDS = ["serve", "sync", "brief", "help"];
+const SORTS = ["active", "recent", "stale"];
+const BRIEF_DAYS = [7, 30, 90];
+const DEFAULTS = {
+  command: "serve",
+  days: 90,
+  port: 5177,
+  open: true,
+  sync: true,
+  dataDir: null,
+  includePrivate: false,
+  sort: "active",
+  limit: 15
+};
+function intIn(flag, raw, min, max) {
+  if (raw === void 0 || raw.startsWith("--")) throw new RangeError(`${flag} には値が要ります`);
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < min || n > max) {
+    throw new RangeError(`${flag} は${min}〜${max} の整数で指定してください(受け取った値: ${raw})`);
+  }
+  return n;
+}
+function parseArgs(argv) {
+  const out = { ...DEFAULTS };
+  let command = null;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case "--help":
+      case "-h":
+        command = "help";
+        break;
+      case "--no-open":
+        out.open = false;
+        break;
+      case "--no-sync":
+        out.sync = false;
+        break;
+      case "--private":
+        out.includePrivate = true;
+        break;
+      case "--days":
+        out.days = intIn(a, argv[++i], 1, 365);
+        break;
+      case "--port":
+        out.port = intIn(a, argv[++i], 0, 65535);
+        break;
+      case "--limit":
+        out.limit = intIn(a, argv[++i], 1, 1e3);
+        break;
+      case "--data-dir": {
+        const v = argv[++i];
+        if (v === void 0 || v.startsWith("--")) throw new RangeError(`${a} には値が要ります`);
+        out.dataDir = v;
+        break;
+      }
+      case "--sort": {
+        const v = argv[++i];
+        if (!SORTS.includes(v)) throw new RangeError(`--sortは${SORTS.join(" | ")} のどれか(受け取った値: ${v})`);
+        out.sort = v;
+        break;
+      }
+      default:
+        if (a.startsWith("-")) throw new RangeError(`知らないフラグです: ${a}`);
+        if (!COMMANDS.includes(a)) throw new RangeError(`知らないコマンドです: ${a}(${COMMANDS.join(" | ")})`);
+        if (command && command !== "help") throw new RangeError(`コマンドは1つだけ: ${command} と${a}`);
+        command = a;
+    }
+  }
+  out.command = command ?? "serve";
+  if (out.command === "brief" && !BRIEF_DAYS.includes(out.days)) {
+    throw new RangeError(`briefの --daysは${BRIEF_DAYS.join(" | ")} のどれか(受け取った値: ${out.days})`);
+  }
+  return out;
+}
+const USAGE = `github-reporadar — 自分のGitHub活動を一晩ぶん眺める計器盤
+
+使い方:
+  npx github-reporadar同期してからローカルで開く(既定)
+  npx github-reporadar sync同期だけ
+  npx github-reporadar brief端末に要約を出す
+
+フラグ:
+  --days N取得する期間(1〜365、既定90)。briefは7 | 30 | 90
+  --port N待ち受けポート(既定5177。使用中なら次を探す)
+  --no-openブラウザを開かない
+  --no-sync同期せずに手元のデータで開く
+  --data-dir DIRデータの置き場(既定: $XDG_CACHE_HOMEか~/.cacheのgithub-reporadar/data)
+  --sort KEY      briefの並び: active | recent | stale
+  --limit N       briefの件数(既定15)
+  --private       briefにprivate repoも出す
+
+トークンはgh CLI(gh auth token)から実行時に取り、どこにも保存しません。
+待ち受けは127.0.0.1だけです。データにはprivate repo名とコミット文が含まれます。
+`;
+function defaultDataDir(env, home) {
+  const base = env.XDG_CACHE_HOME && env.XDG_CACHE_HOME !== "" ? env.XDG_CACHE_HOME : join(home, ".cache");
+  return join(base, "github-reporadar", "data");
+}
+const HOST = "127.0.0.1";
+const DATA_FILES = /* @__PURE__ */ new Set(["repos.json", "activity.json", "issues.json", "meta.json"]);
+const PORT_TRIES = 20;
+const TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".txt": "text/plain; charset=utf-8",
+  ".webmanifest": "application/manifest+json"
+};
+function contentTypeFor(file) {
+  return TYPES[extname(file).toLowerCase()] ?? "application/octet-stream";
+}
+function insideRoot(root, rel) {
+  const full = resolve(root, "." + normalize("/" + rel));
+  const base = resolve(root);
+  return full === base || full.startsWith(base + sep) ? full : null;
+}
+function isFile(p) {
+  try {
+    return existsSync(p) && statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveRequest(rawPath, dist, dataDir) {
+  let pathname;
+  try {
+    pathname = decodeURIComponent(new URL(rawPath, "http://localhost").pathname);
+  } catch {
+    return null;
+  }
+  if (pathname.startsWith("/data/")) {
+    const name = pathname.slice("/data/".length);
+    if (!DATA_FILES.has(name)) return null;
+    const file = insideRoot(dataDir, name);
+    return file ? { file, fallback: false } : null;
+  }
+  const candidate = insideRoot(dist, pathname);
+  if (candidate && isFile(candidate)) return { file: candidate, fallback: false };
+  return { file: join(dist, "index.html"), fallback: true };
+}
+function listen(server, port) {
+  return new Promise((ok, ng) => {
+    const onError = (e) => {
+      server.off("listening", onListening);
+      ng(e);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      const addr = server.address();
+      ok(typeof addr === "object" && addr ? addr.port : port);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, HOST);
+  });
+}
+async function startServer(opts) {
+  const server = createServer((req, res) => {
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405).end();
+      return;
+    }
+    const r = resolveRequest(req.url ?? "/", opts.dist, opts.dataDir);
+    if (!r || !isFile(r.file)) {
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8" }).end("not found");
+      return;
+    }
+    const isData = r.file.startsWith(resolve(opts.dataDir));
+    res.writeHead(200, {
+      "content-type": contentTypeFor(r.file),
+      // データは同期のたびに変わる。index.htmlはハッシュ付きassetを指すので毎回確かめる
+      "cache-control": isData || r.fallback ? "no-store" : "no-cache"
+    });
+    if (req.method === "HEAD") {
+      res.end();
+      return;
+    }
+    createReadStream(r.file).pipe(res);
+  });
+  let port = opts.port;
+  for (let i = 0; ; i++) {
+    try {
+      port = await listen(server, port);
+      break;
+    } catch (e) {
+      const code = e.code;
+      if (code !== "EADDRINUSE" || opts.port === 0 || i >= PORT_TRIES) throw e;
+      port += 1;
+    }
+  }
+  return {
+    port,
+    host: HOST,
+    close: () => new Promise((ok) => server.close(() => ok()))
+  };
+}
+function distDir() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "..", "dist");
+}
+function openBrowser(url) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  execFile(cmd, args, () => {
+  });
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.command === "help") {
+    process.stdout.write(USAGE);
+    return;
+  }
+  const dataDir = args.dataDir ?? defaultDataDir(process.env, homedir());
+  if (args.command === "sync" || args.command === "serve" && args.sync) {
+    await runSync({ dataDir, days: args.days });
+  }
+  if (args.command === "sync") return;
+  if (args.command === "brief") {
+    runBrief({ dataDir, days: args.days, sort: args.sort, limit: args.limit, includePrivate: args.includePrivate });
+    return;
+  }
+  if (!existsSync(join(dataDir, "meta.json"))) {
+    throw new Error(`データがありません: ${dataDir}
+先に \`github-reporadar sync\`を実行するか、--no-syncを外してください`);
+  }
+  const dist = distDir();
+  if (!existsSync(join(dist, "index.html"))) {
+    throw new Error(`viewerのビルドが見つかりません: ${dist}
+開発中なら \`pnpm build\`を先に実行してください`);
+  }
+  const server = await startServer({ dist, dataDir, port: args.port });
+  const url = `http://${server.host}:${server.port}/`;
+  console.log(`GitHub RepoRadar: ${url}  (データ: ${dataDir})`);
+  console.log("止めるにはCtrl+C");
+  if (args.open) openBrowser(url);
+  const stop = () => {
+    server.close().then(() => process.exit(0));
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});