@lonca/baron-adapter-github 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,20 @@
+# @lonca/baron-adapter-github
+
+Baron adapter for GitHub: issues, scm, ci, deploy.
+
+Part of **[Baron](https://github.com/loncadev/baron)** — a platform-agnostic work-orchestration layer for AI coding agents:
+one pane of glass (issues, scm, ci, deploy, notify) across providers, via MCP + CLI.
+
+## Install
+
+```bash
+npm install @lonca/baron-adapter-github
+```
+
+## Documentation
+
+See the [Baron documentation](https://github.com/loncadev/baron#readme). Source: [`packages/adapters/github`](https://github.com/loncadev/baron/tree/main/packages/adapters/github).
+
+## License
+
+[Apache-2.0](./LICENSE) © Baron contributors.

package/dist/index.d.ts

@@ -0,0 +1,92 @@
+import { IssuesTransport, Introspector, ScmTransport, GapPolicy, Logger, BaseScmAdapter, ScmManifest, CiTransport, BaseCiAdapter, CiManifest, CiStatusMaps, DeployTransport, BaseDeployAdapter, DeployManifest, DeployStatusMaps, IssuesProviderConfig, BaseIssuesAdapter, LinkMap, ProviderRoleMap, TypeMap, CapabilityManifest } from '@lonca/baron-core';
+
+/**
+ * The GitHub provider id. Kept in its own leaf module (no imports) so the transport, introspector,
+ * and scm modules can read it WITHOUT importing `index.ts` — `index.ts` re-exports those modules, so
+ * referencing an `index.ts` const at their module top-level would hit a circular temporal-dead-zone
+ * error under real ESM evaluation order.
+ */
+declare const GITHUB_PROVIDER = "github";
+
+interface GithubTransportOptions {
+    readonly owner: string;
+    readonly repo: string;
+    /** Fine-grained PAT or token. Read from env / secret-manager by the caller; never committed. */
+    readonly token: string;
+}
+/**
+ * Live transport over the GitHub REST API (octokit). Baron's issue `id` is the per-repo issue
+ * NUMBER (every REST path keys on `issue_number`); hierarchy is emulated by the core via labels, so
+ * this transport never deals with parents. The role-bearing discriminator is a label, so writes
+ * ECHO `target.label` back as the discriminator (a cold {@link getIssue} can only report open/closed
+ * — recovering a mid-workflow role from labels would need the role map, which invariant #4 forbids
+ * the transport from holding; this lossy cold read is the same documented debt as type-role reverse
+ * resolution).
+ */
+declare function createGithubTransport(options: GithubTransportOptions): IssuesTransport;
+
+/**
+ * Live introspection over the GitHub REST API. GitHub's issue vocabulary is mostly fixed: states
+ * are binary (open/closed) and workflow nuance rides on labels, so `stateKey` is 'label' and the
+ * states are the two intrinsic terminals. Native issue TYPES are an org opt-in feature (often
+ * disabled); when present they enrich `workItemTypes`, otherwise it collapses to a single 'issue'.
+ * Board columns and iterations live in the separate Projects v2 GraphQL API and are omitted here.
+ */
+declare function createGithubIntrospector(options: GithubTransportOptions): Introspector;
+
+/** GitHub supports draft PRs and PR discussion (PR-level issue comments). */
+declare const githubScmManifest: ScmManifest;
+/**
+ * Live `scm` transport over the GitHub REST API (octokit). Branches are created via the git refs
+ * API (read the base ref's sha, create a new ref). A PR "thread" is a PR-level discussion comment —
+ * GitHub models PRs as issues, so it is an issue comment on the PR number (a positioned review
+ * thread would need a diff location, which the abstract primitive does not carry).
+ */
+declare function createGithubScmTransport(options: GithubTransportOptions): ScmTransport;
+declare function defineGithubScmAdapter(transport: ScmTransport, gapPolicy?: GapPolicy, logger?: Logger): BaseScmAdapter;
+
+/** GitHub Actions capabilities. A run's jobs are surfaced as stages in run detail. */
+declare const githubCiManifest: CiManifest;
+/**
+ * GitHub Actions' fixed string enums → normalized RunStatus. A completed run is decided by its
+ * `conclusion`; an in-flight run by its `status`. 'completed' is intentionally absent from the status
+ * map so a finished run is always classified by its conclusion (which is null until then).
+ */
+declare const githubCiStatusMaps: CiStatusMaps;
+/**
+ * Live `ci` transport over the GitHub Actions REST API (octokit). Read-only in slice 1. Run logs are
+ * a zip archive on GitHub, so `fetchLogs` tails the last job's plain-text log instead.
+ */
+declare function createGithubCiTransport(options: GithubTransportOptions): CiTransport;
+declare function defineGithubCiAdapter(transport: CiTransport, gapPolicy?: GapPolicy, logger?: Logger): BaseCiAdapter;
+
+/** GitHub Environments + Deployments. Read-only (no create) in this slice. */
+declare const githubDeployManifest: DeployManifest;
+/** GitHub deployment-status `state` strings → normalized DeployStatus (no separate result axis). */
+declare const githubDeployStatusMaps: DeployStatusMaps;
+declare function createGithubDeployTransport(options: GithubTransportOptions): DeployTransport;
+declare function defineGithubDeployAdapter(transport: DeployTransport, gapPolicy?: GapPolicy, logger?: Logger): BaseDeployAdapter;
+
+/**
+ * GitHub Issues is deliberately flat: no native parent/child hierarchy (sub-issues exist but are
+ * a separate primitive), and only binary open/closed states. Workflow states beyond that must be
+ * emulated (Baron does this via labels). This is the divergent counterpart to Azure and the
+ * reason the impedance layer earns its keep.
+ */
+declare const githubManifest: CapabilityManifest;
+/** Example role map: mid-workflow roles ride on labels, `done` closes the issue. */
+declare const exampleGithubRoleMap: ProviderRoleMap;
+/** GitHub has one issue type; every type role maps onto a plain issue. */
+declare const exampleGithubTypeMap: TypeMap;
+/** GitHub has no native typed links; links are emulated/degraded per the gap policy, so this is empty. */
+declare const exampleGithubLinkMap: LinkMap;
+/**
+ * Recommended gap policy for GitHub: emulate hierarchy and arbitrary states via labels, and drop
+ * sprints with a warning. Installations may override; the point is the choice is explicit, not a
+ * silent default baked into the adapter.
+ */
+declare const recommendedGithubGapPolicy: GapPolicy;
+type GithubIssuesConfig = Omit<IssuesProviderConfig, 'provider'>;
+declare function defineGithubIssuesAdapter(config: GithubIssuesConfig, transport: IssuesTransport, logger?: Logger): BaseIssuesAdapter;
+
+export { GITHUB_PROVIDER, type GithubIssuesConfig, type GithubTransportOptions, createGithubCiTransport, createGithubDeployTransport, createGithubIntrospector, createGithubScmTransport, createGithubTransport, defineGithubCiAdapter, defineGithubDeployAdapter, defineGithubIssuesAdapter, defineGithubScmAdapter, exampleGithubLinkMap, exampleGithubRoleMap, exampleGithubTypeMap, githubCiManifest, githubCiStatusMaps, githubDeployManifest, githubDeployStatusMaps, githubManifest, githubScmManifest, recommendedGithubGapPolicy };

package/dist/index.js

@@ -0,0 +1,555 @@
+// src/index.ts
+import {
+  BaseIssuesAdapter
+} from "@lonca/baron-core";
+
+// src/provider.ts
+var GITHUB_PROVIDER = "github";
+
+// src/transport.ts
+import {
+  BaronError
+} from "@lonca/baron-core";
+import { Octokit } from "octokit";
+var GH_STATE = { OPEN: "open", CLOSED: "closed" };
+var TARGET = { STATE: "state", LABEL: "label" };
+var GH_NATIVE_TYPE = "issue";
+function labelNames(labels) {
+  return labels.map((label) => typeof label === "string" ? label : label.name ?? "").filter((name) => name.length > 0);
+}
+function createGithubTransport(options) {
+  const { owner, repo, token } = options;
+  const octokit = new Octokit({ auth: token });
+  const toNative = (data, discriminator) => ({
+    id: String(data.number),
+    key: `#${data.number}`,
+    title: data.title,
+    body: data.body ?? void 0,
+    nativeType: GH_NATIVE_TYPE,
+    discriminator: discriminator ?? data.state ?? GH_STATE.OPEN,
+    parentId: void 0,
+    labels: labelNames(data.labels),
+    url: data.html_url
+  });
+  return {
+    async createIssue(input) {
+      const { data } = await octokit.rest.issues.create({
+        owner,
+        repo,
+        title: input.title,
+        ...input.body !== void 0 ? { body: input.body } : {},
+        labels: [...input.labels]
+      });
+      return toNative(data);
+    },
+    async getIssue(id) {
+      const { data } = await octokit.rest.issues.get({ owner, repo, issue_number: Number(id) });
+      return toNative(data);
+    },
+    async applyTarget(id, target) {
+      const issue_number = Number(id);
+      const roleLabel = target[TARGET.LABEL];
+      const state = target[TARGET.STATE];
+      if (roleLabel !== void 0) {
+        await octokit.rest.issues.addLabels({ owner, repo, issue_number, labels: [roleLabel] });
+      }
+      if (state === GH_STATE.CLOSED) {
+        await octokit.rest.issues.update({
+          owner,
+          repo,
+          issue_number,
+          state: GH_STATE.CLOSED,
+          state_reason: "completed"
+        });
+      } else if (state === GH_STATE.OPEN) {
+        await octokit.rest.issues.update({
+          owner,
+          repo,
+          issue_number,
+          state: GH_STATE.OPEN,
+          state_reason: "reopened"
+        });
+      }
+      const { data } = await octokit.rest.issues.get({ owner, repo, issue_number });
+      return toNative(data, roleLabel ?? state);
+    },
+    async addLabel(id, label) {
+      await octokit.rest.issues.addLabels({
+        owner,
+        repo,
+        issue_number: Number(id),
+        labels: [label]
+      });
+    },
+    async addComment(id, body) {
+      const { data } = await octokit.rest.issues.createComment({
+        owner,
+        repo,
+        issue_number: Number(id),
+        body
+      });
+      return {
+        id: String(data.id),
+        body: data.body ?? body,
+        author: data.user?.login,
+        createdAt: data.created_at,
+        url: data.html_url
+      };
+    },
+    async linkIssues() {
+      throw new BaronError(
+        "GitHub has no native typed issue links; links are handled by the gap policy, not the transport.",
+        "NOT_SUPPORTED"
+      );
+    },
+    async queryIssues(query) {
+      const stateValue = query.target?.[TARGET.STATE];
+      const label = query.target?.[TARGET.LABEL];
+      const state = stateValue === GH_STATE.CLOSED ? GH_STATE.CLOSED : stateValue === GH_STATE.OPEN ? GH_STATE.OPEN : "all";
+      const { limit } = query;
+      const results = [];
+      for await (const { data } of octokit.paginate.iterator(octokit.rest.issues.listForRepo, {
+        owner,
+        repo,
+        state,
+        ...label !== void 0 ? { labels: label } : {},
+        per_page: 100
+      })) {
+        for (const item of data) {
+          if (item.pull_request !== void 0) continue;
+          results.push(toNative(item));
+          if (limit !== void 0 && results.length >= limit) return results;
+        }
+      }
+      return results;
+    }
+  };
+}
+
+// src/introspector.ts
+import { Octokit as Octokit2 } from "octokit";
+function createGithubIntrospector(options) {
+  const { owner, repo, token } = options;
+  const octokit = new Octokit2({ auth: token });
+  return {
+    async introspect() {
+      let workItemTypes = [{ name: "issue" }];
+      try {
+        const request = octokit.request;
+        const { data } = await request("GET /repos/{owner}/{repo}/issue-types", { owner, repo });
+        if (Array.isArray(data) && data.length > 0) {
+          workItemTypes = data.map((entry) => ({
+            name: String(entry.name ?? "issue")
+          }));
+        }
+      } catch {
+      }
+      return {
+        provider: GITHUB_PROVIDER,
+        stateKey: "label",
+        workItemTypes,
+        states: [
+          { name: "open", category: "proposed" },
+          { name: "closed", category: "completed" }
+        ]
+      };
+    }
+  };
+}
+
+// src/scm.ts
+import {
+  BaseScmAdapter
+} from "@lonca/baron-core";
+import { Octokit as Octokit3 } from "octokit";
+var githubScmManifest = {
+  provider: GITHUB_PROVIDER,
+  scm: { draftPullRequests: true, pullRequestThreads: true }
+};
+function createGithubScmTransport(options) {
+  const { owner, repo, token } = options;
+  const octokit = new Octokit3({ auth: token });
+  return {
+    async createBranch(name, fromBranch) {
+      const base = await octokit.rest.git.getRef({ owner, repo, ref: `heads/${fromBranch}` });
+      const created = await octokit.rest.git.createRef({
+        owner,
+        repo,
+        ref: `refs/heads/${name}`,
+        sha: base.data.object.sha
+      });
+      return { name, sha: created.data.object.sha, url: created.data.url };
+    },
+    async createPullRequest(input) {
+      const { data } = await octokit.rest.pulls.create({
+        owner,
+        repo,
+        title: input.title,
+        ...input.body !== void 0 ? { body: input.body } : {},
+        head: input.sourceBranch,
+        base: input.targetBranch,
+        draft: input.draft
+      });
+      return {
+        id: String(data.number),
+        number: String(data.number),
+        title: data.title,
+        url: data.html_url,
+        sourceBranch: input.sourceBranch,
+        targetBranch: input.targetBranch,
+        draft: data.draft ?? input.draft
+      };
+    },
+    async addPullRequestThread(pullRequestId, body) {
+      const { data } = await octokit.rest.issues.createComment({
+        owner,
+        repo,
+        issue_number: Number(pullRequestId),
+        body
+      });
+      return { id: String(data.id), url: data.html_url };
+    },
+    async defaultBranch() {
+      const { data } = await octokit.rest.repos.get({ owner, repo });
+      return data.default_branch;
+    },
+    async getPullRequestStatus(pullRequestId) {
+      const prNum = Number(pullRequestId);
+      const { data: pr } = await octokit.rest.pulls.get({ owner, repo, pull_number: prNum });
+      const state = pr.merged ? "merged" : pr.state === "closed" ? "closed" : pr.state === "open" ? "open" : "unknown";
+      const { data: reviews } = await octokit.rest.pulls.listReviews({
+        owner,
+        repo,
+        pull_number: prNum,
+        per_page: 100
+      });
+      const latest = /* @__PURE__ */ new Map();
+      let hadComment = false;
+      for (const r of reviews) {
+        const login = r.user?.login;
+        if (login === void 0) continue;
+        if (r.state === "APPROVED" || r.state === "CHANGES_REQUESTED") latest.set(login, r.state);
+        else if (r.state === "DISMISSED") latest.delete(login);
+        else if (r.state === "COMMENTED") hadComment = true;
+      }
+      const states = [...latest.values()];
+      const reviewDecision = states.includes("CHANGES_REQUESTED") ? "changes_requested" : states.includes("APPROVED") ? "approved" : (
+        // engaged (commented) but undecided → pending; no engagement at all → review_required.
+        hadComment ? "pending" : "review_required"
+      );
+      const { data: checks } = await octokit.rest.checks.listForRef({
+        owner,
+        repo,
+        ref: pr.head.sha,
+        per_page: 100
+      });
+      let succeeded = 0;
+      let failed = 0;
+      let pending = 0;
+      for (const c of checks.check_runs) {
+        if (c.status !== "completed") pending += 1;
+        else if (c.conclusion === "success" || c.conclusion === "neutral" || c.conclusion === "skipped")
+          succeeded += 1;
+        else failed += 1;
+      }
+      const total = checks.check_runs.length;
+      const rollup = total === 0 ? "none" : failed > 0 ? "failed" : pending > 0 ? "pending" : "succeeded";
+      return {
+        id: String(pr.number),
+        state,
+        reviewDecision,
+        ...pr.mergeable != null ? { mergeable: pr.mergeable } : {},
+        checks: { total, succeeded, failed, pending, rollup },
+        url: pr.html_url
+      };
+    }
+  };
+}
+function defineGithubScmAdapter(transport, gapPolicy, logger) {
+  return new BaseScmAdapter(githubScmManifest, transport, gapPolicy, logger);
+}
+
+// src/ci.ts
+import {
+  BaseCiAdapter
+} from "@lonca/baron-core";
+import { Octokit as Octokit4 } from "octokit";
+var githubCiManifest = {
+  provider: GITHUB_PROVIDER,
+  ci: {
+    canTrigger: true,
+    canCancel: true,
+    hasStages: true,
+    hasApprovalGates: true,
+    providesLogs: true,
+    hasArtifacts: true
+  }
+};
+var githubCiStatusMaps = {
+  status: {
+    queued: "queued",
+    in_progress: "running",
+    requested: "queued",
+    waiting: "waiting",
+    pending: "queued"
+  },
+  result: {
+    success: "succeeded",
+    failure: "failed",
+    cancelled: "canceled",
+    skipped: "skipped",
+    timed_out: "failed",
+    action_required: "waiting",
+    neutral: "succeeded",
+    startup_failure: "failed"
+  }
+};
+var DEFAULT_RUN_LIMIT = 50;
+var DEFAULT_TAIL_LINES = 200;
+function toNativeRun(r) {
+  return {
+    id: String(r.id),
+    pipelineId: String(r.workflow_id ?? ""),
+    pipelineName: r.name ?? void 0,
+    status: r.status ?? "queued",
+    // conclusion is null until the run finishes; treat that as "no result yet" so status classifies it.
+    result: r.conclusion ?? void 0,
+    branch: r.head_branch ?? void 0,
+    number: r.run_number !== void 0 ? String(r.run_number) : void 0,
+    url: r.html_url,
+    createdAt: r.created_at,
+    finishedAt: r.updated_at
+  };
+}
+function createGithubCiTransport(options) {
+  const { owner, repo, token } = options;
+  const octokit = new Octokit4({ auth: token });
+  return {
+    async listPipelines(query) {
+      const { data } = await octokit.rest.actions.listRepoWorkflows({
+        owner,
+        repo,
+        per_page: query.limit ?? 100
+      });
+      return data.workflows.map((w) => ({ id: String(w.id), name: w.name, url: w.html_url }));
+    },
+    async listRuns(query) {
+      const { data } = await octokit.rest.actions.listWorkflowRunsForRepo({
+        owner,
+        repo,
+        ...query.branch !== void 0 ? { branch: query.branch } : {},
+        per_page: query.limit ?? DEFAULT_RUN_LIMIT
+      });
+      const runs = data.workflow_runs.map(toNativeRun);
+      return query.pipelineId !== void 0 ? runs.filter((r) => r.pipelineId === query.pipelineId) : runs;
+    },
+    async getRun(id) {
+      const { data } = await octokit.rest.actions.getWorkflowRun({
+        owner,
+        repo,
+        run_id: Number(id)
+      });
+      const jobsResp = await octokit.rest.actions.listJobsForWorkflowRun({
+        owner,
+        repo,
+        run_id: Number(id),
+        per_page: 100
+      });
+      const stages = jobsResp.data.jobs.map((j) => ({
+        name: j.name,
+        status: j.status,
+        result: j.conclusion ?? void 0
+      }));
+      return { ...toNativeRun(data), stages };
+    },
+    async fetchLogs(runId, options2) {
+      const jobs = await octokit.rest.actions.listJobsForWorkflowRun({
+        owner,
+        repo,
+        run_id: Number(runId),
+        per_page: 100
+      });
+      const list = jobs.data.jobs;
+      const last = list[list.length - 1];
+      if (last === void 0) return { content: "", truncated: false };
+      const logResp = await octokit.rest.actions.downloadJobLogsForWorkflowRun({
+        owner,
+        repo,
+        job_id: last.id
+      });
+      const lines = String(logResp.data ?? "").split("\n");
+      const tail = options2.tailLines ?? DEFAULT_TAIL_LINES;
+      const start = Math.max(0, lines.length - tail);
+      return { content: lines.slice(start).join("\n"), truncated: start > 0 || list.length > 1 };
+    },
+    async triggerRun(input) {
+      const ref = input.ref ?? (await octokit.rest.repos.get({ owner, repo })).data.default_branch;
+      await octokit.rest.actions.createWorkflowDispatch({
+        owner,
+        repo,
+        workflow_id: Number(input.pipelineId),
+        ref,
+        ...input.variables !== void 0 ? { inputs: input.variables } : {}
+      });
+      return { accepted: true };
+    },
+    async cancelRun(runId) {
+      await octokit.rest.actions.cancelWorkflowRun({ owner, repo, run_id: Number(runId) });
+      const { data } = await octokit.rest.actions.getWorkflowRun({
+        owner,
+        repo,
+        run_id: Number(runId)
+      });
+      return toNativeRun(data);
+    }
+  };
+}
+function defineGithubCiAdapter(transport, gapPolicy, logger) {
+  return new BaseCiAdapter(githubCiManifest, githubCiStatusMaps, transport, gapPolicy, logger);
+}
+
+// src/deploy.ts
+import {
+  BaseDeployAdapter
+} from "@lonca/baron-core";
+import { Octokit as Octokit5 } from "octokit";
+var githubDeployManifest = {
+  provider: GITHUB_PROVIDER,
+  deploy: { environments: true, deployments: true, canTrigger: false }
+};
+var githubDeployStatusMaps = {
+  status: {
+    queued: "pending",
+    pending: "pending",
+    waiting: "pending",
+    in_progress: "running",
+    success: "succeeded",
+    failure: "failed",
+    error: "failed",
+    inactive: "unknown"
+  },
+  result: {}
+};
+var DEFAULT_LIMIT = 20;
+function createGithubDeployTransport(options) {
+  const { owner, repo, token } = options;
+  const octokit = new Octokit5({ auth: token });
+  return {
+    async listEnvironments(query) {
+      const { data } = await octokit.rest.repos.getAllEnvironments({
+        owner,
+        repo,
+        per_page: query.limit ?? 100
+      });
+      return (data.environments ?? []).map((e) => ({
+        id: String(e.id),
+        name: e.name,
+        url: e.html_url
+      }));
+    },
+    async listDeployments(query) {
+      const { data } = await octokit.rest.repos.listDeployments({
+        owner,
+        repo,
+        ...query.environment !== void 0 ? { environment: query.environment } : {},
+        per_page: query.limit ?? DEFAULT_LIMIT
+      });
+      return Promise.all(
+        data.map(async (d) => {
+          const statuses = await octokit.rest.repos.listDeploymentStatuses({
+            owner,
+            repo,
+            deployment_id: d.id,
+            per_page: 1
+          });
+          const latest = statuses.data[0];
+          return {
+            id: String(d.id),
+            environment: typeof d.environment === "string" ? d.environment : "",
+            ...latest !== void 0 ? { status: latest.state } : {},
+            ref: typeof d.ref === "string" ? d.ref : void 0,
+            sha: d.sha,
+            ...typeof d.created_at === "string" ? { createdAt: d.created_at } : {},
+            // The deployment's own updated_at is its finish time — not the status record's created_at.
+            ...typeof d.updated_at === "string" ? { finishedAt: d.updated_at } : {}
+          };
+        })
+      );
+    }
+  };
+}
+function defineGithubDeployAdapter(transport, gapPolicy, logger) {
+  return new BaseDeployAdapter(
+    githubDeployManifest,
+    githubDeployStatusMaps,
+    transport,
+    gapPolicy,
+    logger
+  );
+}
+
+// src/index.ts
+var githubManifest = {
+  provider: GITHUB_PROVIDER,
+  issues: {
+    hierarchy: false,
+    subIssues: true,
+    separateBoardColumn: false,
+    sprints: false,
+    arbitraryStates: false,
+    nativeLabels: true,
+    comments: true,
+    issueLinks: false
+  }
+};
+var exampleGithubRoleMap = {
+  stateKey: "label",
+  states: {
+    in_progress: { label: "in-progress" },
+    in_review: { label: "in-review" },
+    done: { state: "closed", label: "done" }
+  }
+};
+var exampleGithubTypeMap = {
+  epic: "issue",
+  story: "issue",
+  task: "issue",
+  subtask: "issue"
+};
+var exampleGithubLinkMap = {};
+var recommendedGithubGapPolicy = {
+  hierarchy: { kind: "emulate", strategy: "labels" },
+  arbitraryStates: { kind: "emulate", strategy: "labels" },
+  sprints: { kind: "degrade" },
+  issueLinks: { kind: "emulate", strategy: "labels" }
+};
+function defineGithubIssuesAdapter(config, transport, logger) {
+  return new BaseIssuesAdapter(
+    githubManifest,
+    { linkMap: exampleGithubLinkMap, ...config, provider: GITHUB_PROVIDER },
+    transport,
+    logger
+  );
+}
+export {
+  GITHUB_PROVIDER,
+  createGithubCiTransport,
+  createGithubDeployTransport,
+  createGithubIntrospector,
+  createGithubScmTransport,
+  createGithubTransport,
+  defineGithubCiAdapter,
+  defineGithubDeployAdapter,
+  defineGithubIssuesAdapter,
+  defineGithubScmAdapter,
+  exampleGithubLinkMap,
+  exampleGithubRoleMap,
+  exampleGithubTypeMap,
+  githubCiManifest,
+  githubCiStatusMaps,
+  githubDeployManifest,
+  githubDeployStatusMaps,
+  githubManifest,
+  githubScmManifest,
+  recommendedGithubGapPolicy
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@lonca/baron-adapter-github",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "octokit": "^5.0.5",
+    "@lonca/baron-core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@lonca/baron-conformance": "0.1.0"
+  },
+  "description": "Baron adapter for GitHub: issues, scm, ci, deploy.",
+  "keywords": [
+    "baron",
+    "ai-agents",
+    "mcp",
+    "work-orchestration",
+    "devops",
+    "github",
+    "adapter"
+  ],
+  "author": "Baron contributors",
+  "homepage": "https://github.com/loncadev/baron#readme",
+  "bugs": {
+    "url": "https://github.com/loncadev/baron/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/loncadev/baron.git",
+    "directory": "packages/adapters/github"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit"
+  }
+}