@bpinternal/overwatch 0.1.0

package/dist/github.js

@@ -0,0 +1,258 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var github_exports = {};
+__export(github_exports, {
+  Github: () => Github
+});
+module.exports = __toCommonJS(github_exports);
+var import_octokit = require("octokit");
+class Github {
+  branch;
+  email;
+  repoUrl;
+  owner;
+  name;
+  key;
+  octokit;
+  constructor(props) {
+    this.repoUrl = props.repo;
+    this.branch = props.branch;
+    this.email = props.email || void 0;
+    this.key = props.key || void 0;
+    this.octokit = new import_octokit.Octokit({ auth: this.key });
+    const match = props.repo.match(/github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (!match) throw new Error(`could not parse owner/repo from "${props.repo}"`);
+    this.owner = match[1];
+    this.name = match[2];
+  }
+  async countOpenPrs(label) {
+    return (await this.openPrIssues(label)).length;
+  }
+  async listOpenPrBodies(label) {
+    return (await this.openPrIssues(label)).map((issue) => issue.body ?? "");
+  }
+  // The issues endpoint covers PRs too (a PR is an issue with a `pull_request` key)
+  // and, unlike /pulls, supports filtering by label server-side.
+  async openPrIssues(label) {
+    const issues = await this.octokit.paginate(this.octokit.rest.issues.listForRepo, {
+      owner: this.owner,
+      repo: this.name,
+      labels: label,
+      state: "open",
+      per_page: 100
+    });
+    return issues.filter((issue) => issue.pull_request);
+  }
+  async cloneInto(sandbox, path, branch) {
+    await sandbox.git.clone(
+      this.repoUrl,
+      path,
+      branch ?? this.branch,
+      void 0,
+      this.key ? "x-access-token" : void 0,
+      this.key
+    );
+  }
+  async getPr(prNumber) {
+    const { data: pr } = await this.octokit.rest.pulls.get({
+      owner: this.owner,
+      repo: this.name,
+      pull_number: prNumber
+    });
+    const { data: commit } = await this.octokit.rest.repos.getCommit({
+      owner: this.owner,
+      repo: this.name,
+      ref: pr.head.sha
+    });
+    const headCommittedAt = commit.commit.committer?.date ?? pr.created_at;
+    return { branch: pr.head.ref, headCommittedAt };
+  }
+  async listPrComments(prNumber) {
+    const base = { owner: this.owner, repo: this.name, per_page: 100 };
+    const [review, issue, resolved] = await Promise.all([
+      this.octokit.paginate(this.octokit.rest.pulls.listReviewComments, {
+        ...base,
+        pull_number: prNumber
+      }),
+      this.octokit.paginate(this.octokit.rest.issues.listComments, {
+        ...base,
+        issue_number: prNumber
+      }),
+      this.resolvedReviewCommentIds(prNumber)
+    ]);
+    const comments = [
+      ...review.filter((comment) => !resolved.has(comment.id)).map((comment) => ({
+        id: comment.id,
+        author: comment.user.login,
+        body: comment.body,
+        file: comment.path,
+        line: comment.line ?? comment.original_line ?? void 0,
+        createdAt: comment.created_at
+      })),
+      ...issue.map((comment) => ({
+        id: comment.id,
+        author: comment.user?.login ?? "unknown",
+        body: comment.body ?? "",
+        createdAt: comment.created_at
+      }))
+    ];
+    return comments.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async push(sandbox, path, branch) {
+    this.requireKey("push");
+    const setup = await sandbox.process.executeCommand(
+      `printf 'https://x-access-token:%s@github.com\\n' "$GIT_TOKEN" > ~/.git-credentials && git config --global credential.helper store`,
+      path,
+      { GIT_TOKEN: this.key },
+      60
+    );
+    if (setup.exitCode !== 0) {
+      throw new Error(`configuring git credentials failed: ${setup.result}`);
+    }
+    const quoted = branch.replace(/'/g, `'\\''`);
+    const maxAttempts = 5;
+    for (let attempt = 1; ; attempt++) {
+      const push = await sandbox.process.executeCommand(
+        `git push --set-upstream origin '${quoted}'`,
+        path,
+        void 0,
+        300
+      );
+      if (push.exitCode === 0) return;
+      const rejected = /non-fast-forward|fetch first|\[rejected\]/i.test(push.result ?? "");
+      if (!rejected || attempt >= maxAttempts) {
+        throw new Error(`git push failed: ${push.result}`);
+      }
+      const rebase = await sandbox.process.executeCommand(
+        `git fetch origin '${quoted}' && git rebase 'origin/${quoted}'`,
+        path,
+        void 0,
+        300
+      );
+      if (rebase.exitCode !== 0) {
+        await sandbox.process.executeCommand("git rebase --abort", path, void 0, 60);
+        throw new Error(
+          `git push failed: branch '${branch}' diverged and auto-rebase hit a conflict: ${rebase.result}`
+        );
+      }
+    }
+  }
+  async openPr(params) {
+    this.requireKey("open a PR");
+    await this.ensureLabel(params.label);
+    const { data: pr } = await this.octokit.rest.pulls.create({
+      owner: this.owner,
+      repo: this.name,
+      title: params.title,
+      head: params.branch,
+      base: this.branch,
+      body: params.body
+    });
+    try {
+      await this.retry(
+        () => this.octokit.rest.issues.addLabels({
+          owner: this.owner,
+          repo: this.name,
+          issue_number: pr.number,
+          labels: [params.label]
+        })
+      );
+    } catch (error) {
+      await this.closePrQuietly(pr.number);
+      throw new Error(
+        `opened PR #${pr.number} but could not label it "${params.label}"; closed it to avoid an unlabeled orphan the loop can't count or claim. Cause: ${error.message ?? String(error)}`
+      );
+    }
+    return pr.html_url;
+  }
+  /** Retries a request a few times; the label call must not be abandoned over a transient error. */
+  async retry(fn, attempts = 3) {
+    let lastError;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    throw lastError;
+  }
+  /** Best-effort PR close used to roll back a partially-created PR; a failure here is swallowed. */
+  async closePrQuietly(prNumber) {
+    try {
+      await this.octokit.rest.pulls.update({
+        owner: this.owner,
+        repo: this.name,
+        pull_number: prNumber,
+        state: "closed"
+      });
+    } catch {
+    }
+  }
+  async ensureLabel(label) {
+    try {
+      await this.octokit.rest.issues.createLabel({
+        owner: this.owner,
+        repo: this.name,
+        name: label,
+        color: "0e8a16",
+        description: "Opened by a control loop"
+      });
+    } catch (error) {
+      if (error.status !== 422) throw error;
+    }
+  }
+  /**
+   * IDs of inline review comments whose thread has been resolved. Thread resolution
+   * is only exposed by GitHub's GraphQL API, which always requires auth — without a
+   * key, nothing is filtered.
+   */
+  async resolvedReviewCommentIds(prNumber) {
+    const ids = /* @__PURE__ */ new Set();
+    if (!this.key) return ids;
+    const result = await this.octokit.graphql(
+      `query ($owner: String!, $name: String!, $number: Int!) {
+        repository(owner: $owner, name: $name) {
+          pullRequest(number: $number) {
+            reviewThreads(first: 100) {
+              nodes { isResolved comments(first: 100) { nodes { databaseId } } }
+            }
+          }
+        }
+      }`,
+      { owner: this.owner, name: this.name, number: prNumber }
+    );
+    for (const thread of result.repository.pullRequest.reviewThreads.nodes) {
+      if (!thread.isResolved) continue;
+      for (const comment of thread.comments.nodes) {
+        if (comment.databaseId !== null) ids.add(comment.databaseId);
+      }
+    }
+    return ids;
+  }
+  requireKey(action) {
+    if (!this.key)
+      throw new Error(`a Github key is required to ${action} on ${this.owner}/${this.name}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Github
+});
+//# sourceMappingURL=github.js.map

package/dist/github.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/github.ts"],
+  "sourcesContent": ["import type { Sandbox } from \"@daytona/sdk\";\nimport { Octokit } from \"octokit\";\n\n/** A human comment on a PR. `file`/`line` are present for inline review comments only. */\nexport interface PrComment {\n  id: number;\n  author: string;\n  body: string;\n  file?: string;\n  line?: number;\n  createdAt: string;\n}\n\n/**\n * Where the code comes from and where the PR goes. Implemented by {@link Github};\n * the interface exists so other forges (GitLab, ...) can slot in later.\n */\nexport interface GitSource {\n  /** Base branch the loop clones from and targets with its PR. */\n  readonly branch: string;\n  /**\n   * Committer email stamped on the loop's commits (the ones that make up the PR).\n   * Optional \u2014 the loop falls back to a default no-reply address when unset.\n   */\n  readonly email?: string;\n  countOpenPrs(label: string): Promise<number>;\n  /** Bodies of the open PRs carrying the loop's label; used to skip already-claimed signals. */\n  listOpenPrBodies(label: string): Promise<string[]>;\n  /** Clones `branch` (defaults to the base branch) into the sandbox at `path`. */\n  cloneInto(sandbox: Sandbox, path: string, branch?: string): Promise<void>;\n  push(sandbox: Sandbox, path: string, branch: string): Promise<void>;\n  openPr(params: { branch: string; title: string; body: string; label: string }): Promise<string>;\n  /** Head branch of the PR and the commit date of its tip, used to skip already-addressed comments. */\n  getPr(prNumber: number): Promise<{ branch: string; headCommittedAt: string }>;\n  /**\n   * Comments on the PR \u2014 inline review comments and PR-level comments \u2014 oldest first.\n   * Inline comments whose review thread has been resolved are excluded.\n   */\n  listPrComments(prNumber: number): Promise<PrComment[]>;\n}\n\nexport type GithubProps = {\n  /** e.g. \"https://github.com/botpress/some-repo.git\" */\n  repo: string;\n  branch: string;\n  /**\n   * GitHub token. Optional for cloning/counting PRs on public repos, but required to\n   * push and open PRs \u2014 a run that reaches the PR stage without one fails there.\n   */\n  key?: string;\n  /**\n   * Committer email stamped on the loop's commits. Optional; set it to attribute the\n   * PR's commits to a specific bot/user account instead of the default no-reply address.\n   */\n  email?: string;\n};\n\nexport class Github implements GitSource {\n  readonly branch: string;\n  readonly email?: string;\n  private readonly repoUrl: string;\n  private readonly owner: string;\n  private readonly name: string;\n  private readonly key?: string;\n  private readonly octokit: Octokit;\n\n  constructor(props: GithubProps) {\n    this.repoUrl = props.repo;\n    this.branch = props.branch;\n    this.email = props.email || undefined;\n    this.key = props.key || undefined;\n    this.octokit = new Octokit({ auth: this.key });\n\n    const match = props.repo.match(/github\\.com[/:]([^/]+)\\/([^/]+?)(?:\\.git)?$/);\n    if (!match) throw new Error(`could not parse owner/repo from \"${props.repo}\"`);\n    this.owner = match[1]!;\n    this.name = match[2]!;\n  }\n\n  async countOpenPrs(label: string): Promise<number> {\n    return (await this.openPrIssues(label)).length;\n  }\n\n  async listOpenPrBodies(label: string): Promise<string[]> {\n    return (await this.openPrIssues(label)).map((issue) => issue.body ?? \"\");\n  }\n\n  // The issues endpoint covers PRs too (a PR is an issue with a `pull_request` key)\n  // and, unlike /pulls, supports filtering by label server-side.\n  private async openPrIssues(label: string) {\n    const issues = await this.octokit.paginate(this.octokit.rest.issues.listForRepo, {\n      owner: this.owner,\n      repo: this.name,\n      labels: label,\n      state: \"open\",\n      per_page: 100,\n    });\n    return issues.filter((issue) => issue.pull_request);\n  }\n\n  async cloneInto(sandbox: Sandbox, path: string, branch?: string): Promise<void> {\n    await sandbox.git.clone(\n      this.repoUrl,\n      path,\n      branch ?? this.branch,\n      undefined,\n      this.key ? \"x-access-token\" : undefined,\n      this.key,\n    );\n  }\n\n  async getPr(prNumber: number): Promise<{ branch: string; headCommittedAt: string }> {\n    const { data: pr } = await this.octokit.rest.pulls.get({\n      owner: this.owner,\n      repo: this.name,\n      pull_number: prNumber,\n    });\n    const { data: commit } = await this.octokit.rest.repos.getCommit({\n      owner: this.owner,\n      repo: this.name,\n      ref: pr.head.sha,\n    });\n    const headCommittedAt = commit.commit.committer?.date ?? pr.created_at;\n    return { branch: pr.head.ref, headCommittedAt };\n  }\n\n  async listPrComments(prNumber: number): Promise<PrComment[]> {\n    const base = { owner: this.owner, repo: this.name, per_page: 100 };\n    // Inline code comments live on the pulls endpoint, PR-level discussion on the\n    // issues endpoint; a complete picture needs both. Thread resolution only exists\n    // in the GraphQL API, so it's fetched separately to drop resolved threads.\n    const [review, issue, resolved] = await Promise.all([\n      this.octokit.paginate(this.octokit.rest.pulls.listReviewComments, {\n        ...base,\n        pull_number: prNumber,\n      }),\n      this.octokit.paginate(this.octokit.rest.issues.listComments, {\n        ...base,\n        issue_number: prNumber,\n      }),\n      this.resolvedReviewCommentIds(prNumber),\n    ]);\n\n    const comments: PrComment[] = [\n      ...review\n        .filter((comment) => !resolved.has(comment.id))\n        .map((comment) => ({\n          id: comment.id,\n          author: comment.user.login,\n          body: comment.body,\n          file: comment.path,\n          line: comment.line ?? comment.original_line ?? undefined,\n          createdAt: comment.created_at,\n        })),\n      ...issue.map((comment) => ({\n        id: comment.id,\n        author: comment.user?.login ?? \"unknown\",\n        body: comment.body ?? \"\",\n        createdAt: comment.created_at,\n      })),\n    ];\n    return comments.sort((a, b) => a.createdAt.localeCompare(b.createdAt));\n  }\n\n  async push(sandbox: Sandbox, path: string, branch: string): Promise<void> {\n    this.requireKey(\"push\");\n    // Daytona's toolbox git is go-git, which rejects committed paths it deems invalid\n    // (e.g. a file named `\\` left behind by an agent) \u2014 pushing 500s with\n    // `invalid path: \"\\\\\"`. The real git binary handles any filename, so push with it.\n    // The token goes through git's credential store via an env var, keeping it off the\n    // command line and out of error output.\n    const setup = await sandbox.process.executeCommand(\n      `printf 'https://x-access-token:%s@github.com\\\\n' \"$GIT_TOKEN\" > ~/.git-credentials && git config --global credential.helper store`,\n      path,\n      { GIT_TOKEN: this.key! },\n      60,\n    );\n    if (setup.exitCode !== 0) {\n      throw new Error(`configuring git credentials failed: ${setup.result}`);\n    }\n    // Push, rebasing onto the remote tip and retrying if the branch moved under us.\n    // Two comment webhooks for the same PR clone the same head independently, so the\n    // second push is rejected non-fast-forward; without this, that run's work would be\n    // silently lost when its sandbox is torn down. Replaying our commits onto the new\n    // tip preserves both updates. A bounded loop guards against a branch churning faster\n    // than we can push.\n    const quoted = branch.replace(/'/g, `'\\\\''`);\n    const maxAttempts = 5;\n    for (let attempt = 1; ; attempt++) {\n      const push = await sandbox.process.executeCommand(\n        `git push --set-upstream origin '${quoted}'`,\n        path,\n        undefined,\n        300,\n      );\n      if (push.exitCode === 0) return;\n\n      const rejected = /non-fast-forward|fetch first|\\[rejected\\]/i.test(push.result ?? \"\");\n      if (!rejected || attempt >= maxAttempts) {\n        throw new Error(`git push failed: ${push.result}`);\n      }\n\n      const rebase = await sandbox.process.executeCommand(\n        `git fetch origin '${quoted}' && git rebase 'origin/${quoted}'`,\n        path,\n        undefined,\n        300,\n      );\n      if (rebase.exitCode !== 0) {\n        // A real content conflict can't be resolved unattended; abort to leave the tree\n        // clean and surface it, rather than force-pushing over the other update.\n        await sandbox.process.executeCommand(\"git rebase --abort\", path, undefined, 60);\n        throw new Error(\n          `git push failed: branch '${branch}' diverged and auto-rebase hit a conflict: ${rebase.result}`,\n        );\n      }\n    }\n  }\n\n  async openPr(params: {\n    branch: string;\n    title: string;\n    body: string;\n    label: string;\n  }): Promise<string> {\n    this.requireKey(\"open a PR\");\n    await this.ensureLabel(params.label);\n    const { data: pr } = await this.octokit.rest.pulls.create({\n      owner: this.owner,\n      repo: this.name,\n      title: params.title,\n      head: params.branch,\n      base: this.branch,\n      body: params.body,\n    });\n\n    // The loop counts and discovers its PRs purely by label (see `openPrIssues`), so a PR\n    // that exists without the label is invisible: the next run would miss it, exceed\n    // `maxOpenPrCount`, and reopen the same signals. Labeling can't be made atomic with\n    // creation (the REST API has no combined call), so retry it to ride out a transient\n    // blip without discarding the agent's work, and if it still fails, close the PR rather\n    // than leave an unlabeled orphan \u2014 the signals stay unclaimed and a later run retries.\n    try {\n      await this.retry(() =>\n        this.octokit.rest.issues.addLabels({\n          owner: this.owner,\n          repo: this.name,\n          issue_number: pr.number,\n          labels: [params.label],\n        }),\n      );\n    } catch (error) {\n      await this.closePrQuietly(pr.number);\n      throw new Error(\n        `opened PR #${pr.number} but could not label it \"${params.label}\"; closed it to avoid an ` +\n          `unlabeled orphan the loop can't count or claim. Cause: ${(error as Error).message ?? String(error)}`,\n      );\n    }\n    return pr.html_url;\n  }\n\n  /** Retries a request a few times; the label call must not be abandoned over a transient error. */\n  private async retry<T>(fn: () => Promise<T>, attempts = 3): Promise<T> {\n    let lastError: unknown;\n    for (let i = 0; i < attempts; i++) {\n      try {\n        return await fn();\n      } catch (error) {\n        lastError = error;\n      }\n    }\n    throw lastError;\n  }\n\n  /** Best-effort PR close used to roll back a partially-created PR; a failure here is swallowed. */\n  private async closePrQuietly(prNumber: number): Promise<void> {\n    try {\n      await this.octokit.rest.pulls.update({\n        owner: this.owner,\n        repo: this.name,\n        pull_number: prNumber,\n        state: \"closed\",\n      });\n    } catch {\n      // Nothing we can do \u2014 the caller is already throwing the underlying labeling error.\n    }\n  }\n\n  private async ensureLabel(label: string): Promise<void> {\n    try {\n      await this.octokit.rest.issues.createLabel({\n        owner: this.owner,\n        repo: this.name,\n        name: label,\n        color: \"0e8a16\",\n        description: \"Opened by a control loop\",\n      });\n    } catch (error) {\n      // 422 = label already exists; anything else is a real failure.\n      if ((error as { status?: number }).status !== 422) throw error;\n    }\n  }\n\n  /**\n   * IDs of inline review comments whose thread has been resolved. Thread resolution\n   * is only exposed by GitHub's GraphQL API, which always requires auth \u2014 without a\n   * key, nothing is filtered.\n   */\n  private async resolvedReviewCommentIds(prNumber: number): Promise<Set<number>> {\n    const ids = new Set<number>();\n    if (!this.key) return ids;\n\n    const result = await this.octokit.graphql<{\n      repository: {\n        pullRequest: {\n          reviewThreads: {\n            nodes: Array<{\n              isResolved: boolean;\n              comments: { nodes: Array<{ databaseId: number | null }> };\n            }>;\n          };\n        };\n      };\n    }>(\n      `query ($owner: String!, $name: String!, $number: Int!) {\n        repository(owner: $owner, name: $name) {\n          pullRequest(number: $number) {\n            reviewThreads(first: 100) {\n              nodes { isResolved comments(first: 100) { nodes { databaseId } } }\n            }\n          }\n        }\n      }`,\n      { owner: this.owner, name: this.name, number: prNumber },\n    );\n\n    for (const thread of result.repository.pullRequest.reviewThreads.nodes) {\n      if (!thread.isResolved) continue;\n      for (const comment of thread.comments.nodes) {\n        if (comment.databaseId !== null) ids.add(comment.databaseId);\n      }\n    }\n    return ids;\n  }\n\n  private requireKey(action: string): void {\n    if (!this.key)\n      throw new Error(`a Github key is required to ${action} on ${this.owner}/${this.name}`);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { ControlLoop } from "./control-loop";
+export { Agent, Claude, Codex, type AgentContext, type ClaudeProps, type CodexProps, } from "./agents";
+export { Github, type GitSource, type GithubProps, type PrComment } from "./github";
+export { RepoHandle, type ExecResult, type GrepMatch } from "./repo-handle";
+export * as actuators from "./actuators";
+export { Actuator, AgentPrActuator, type ActuatorInput, type AgentPrActuatorProps, type CommentActuator, type InstructionBuilder, } from "./actuators";
+export * as pickers from "./pickers";
+export { type Picker } from "./pickers";
+export * as sensors from "./sensors";
+export { type AstGrepMatch, type AstGrepOptions, type GrepOptions, type ReactDoctorDiagnostic, type ReactDoctorOptions, type Sensor, type SensorFn, type SensorScript, } from "./sensors";
+export { type ApplyCommentsResult, type ControlLoopConfig, type ControlLoopOptions, type ControlLoopRunResult, type Signal, type SignalPriority, } from "./types";

package/dist/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  Actuator: () => import_actuators.Actuator,
+  Agent: () => import_agents.Agent,
+  AgentPrActuator: () => import_actuators.AgentPrActuator,
+  Claude: () => import_agents.Claude,
+  Codex: () => import_agents.Codex,
+  ControlLoop: () => import_control_loop.ControlLoop,
+  Github: () => import_github.Github,
+  RepoHandle: () => import_repo_handle.RepoHandle,
+  actuators: () => actuators,
+  pickers: () => pickers,
+  sensors: () => sensors
+});
+module.exports = __toCommonJS(index_exports);
+var import_control_loop = require("./control-loop");
+var import_agents = require("./agents");
+var import_github = require("./github");
+var import_repo_handle = require("./repo-handle");
+var actuators = __toESM(require("./actuators"));
+var import_actuators = require("./actuators");
+var pickers = __toESM(require("./pickers"));
+var import_pickers = require("./pickers");
+var sensors = __toESM(require("./sensors"));
+var import_sensors = require("./sensors");
+var import_types = require("./types");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Actuator,
+  Agent,
+  AgentPrActuator,
+  Claude,
+  Codex,
+  ControlLoop,
+  Github,
+  RepoHandle,
+  actuators,
+  pickers,
+  sensors
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["export { ControlLoop } from \"./control-loop\";\nexport {\n  Agent,\n  Claude,\n  Codex,\n  type AgentContext,\n  type ClaudeProps,\n  type CodexProps,\n} from \"./agents\";\nexport { Github, type GitSource, type GithubProps, type PrComment } from \"./github\";\nexport { RepoHandle, type ExecResult, type GrepMatch } from \"./repo-handle\";\n\nexport * as actuators from \"./actuators\";\nexport {\n  Actuator,\n  AgentPrActuator,\n  type ActuatorInput,\n  type AgentPrActuatorProps,\n  type CommentActuator,\n  type InstructionBuilder,\n} from \"./actuators\";\n\nexport * as pickers from \"./pickers\";\nexport { type Picker } from \"./pickers\";\n\nexport * as sensors from \"./sensors\";\nexport {\n  type AstGrepMatch,\n  type AstGrepOptions,\n  type GrepOptions,\n  type ReactDoctorDiagnostic,\n  type ReactDoctorOptions,\n  type Sensor,\n  type SensorFn,\n  type SensorScript,\n} from \"./sensors\";\n\nexport {\n  type ApplyCommentsResult,\n  type ControlLoopConfig,\n  type ControlLoopOptions,\n  type ControlLoopRunResult,\n  type Signal,\n  type SignalPriority,\n} from \"./types\";\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAA4B;AAC5B,oBAOO;AACP,oBAAyE;AACzE,yBAA4D;AAE5D,gBAA2B;AAC3B,uBAOO;AAEP,cAAyB;AACzB,qBAA4B;AAE5B,cAAyB;AACzB,qBASO;AAEP,mBAOO;",
+  "names": []
+}

package/dist/log.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tiny, dependency-free run logger. It narrates — to stderr — what a control-loop run
+ * is doing to its sandbox, so you can see where the sandbox is at each step. stderr is
+ * used so it never mixes with a caller that parses the loop's return value off stdout.
+ *
+ * Muted with CONTROL_LOOP_SILENT=1; colors follow NO_COLOR and TTY detection.
+ */
+export declare class RunLog {
+    private scope;
+    constructor(label: string);
+    /** Once the sandbox exists, tag every subsequent line with its (short) id. */
+    attach(sandboxId: string): void;
+    /** Wraps an async op: prints "→ label", then "✓ label (elapsed)" — or "✗ label" if it throws. */
+    step<T>(label: string, fn: () => Promise<T>): Promise<T>;
+    /** A neutral status line — counts, picks, and other in-between context. */
+    info(message: string): void;
+    /** The run bowed out early (nothing to do, cap hit). */
+    skip(message: string): void;
+    /** The run's terminal outcome. */
+    finish(message: string): void;
+    private line;
+}

package/dist/log.js

@@ -0,0 +1,87 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+__export(log_exports, {
+  RunLog: () => RunLog
+});
+module.exports = __toCommonJS(log_exports);
+const enabled = process.env.CONTROL_LOOP_SILENT !== "1" && process.env.CONTROL_LOOP_SILENT !== "true";
+const color = enabled && Boolean(process.stderr.isTTY) && !process.env.NO_COLOR;
+const paint = (code) => (text) => color ? `\x1B[${code}m${text}\x1B[0m` : text;
+const dim = paint("2");
+const bold = paint("1");
+const cyan = paint("36");
+const green = paint("32");
+const yellow = paint("33");
+const red = paint("31");
+const magenta = paint("35");
+function elapsed(startMs) {
+  const ms = Date.now() - startMs;
+  return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+}
+const PENDING = "\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7";
+class RunLog {
+  scope = PENDING;
+  constructor(label) {
+    if (!enabled) return;
+    process.stderr.write(`
+${dim("\u2501\u2501")} ${bold("control-loop")} ${dim("\xB7")} ${cyan(label)}
+`);
+  }
+  /** Once the sandbox exists, tag every subsequent line with its (short) id. */
+  attach(sandboxId) {
+    this.scope = sandboxId.slice(0, 8);
+    this.line(magenta("\u25C6"), `sandbox ${bold(this.scope)} ready`);
+  }
+  /** Wraps an async op: prints "→ label", then "✓ label (elapsed)" — or "✗ label" if it throws. */
+  async step(label, fn) {
+    const start = Date.now();
+    this.line(cyan("\u2192"), label);
+    try {
+      const result = await fn();
+      this.line(green("\u2713"), `${label} ${dim(`(${elapsed(start)})`)}`);
+      return result;
+    } catch (error) {
+      this.line(red("\u2717"), `${label} ${dim(`(${elapsed(start)})`)}`);
+      throw error;
+    }
+  }
+  /** A neutral status line — counts, picks, and other in-between context. */
+  info(message) {
+    this.line(dim("\xB7"), dim(message));
+  }
+  /** The run bowed out early (nothing to do, cap hit). */
+  skip(message) {
+    this.line(yellow("\u23ED"), yellow(message));
+  }
+  /** The run's terminal outcome. */
+  finish(message) {
+    this.line(green("\u25CF"), bold(message));
+  }
+  line(symbol, message) {
+    if (!enabled) return;
+    process.stderr.write(`  ${dim(this.scope)}  ${symbol} ${message}
+`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RunLog
+});
+//# sourceMappingURL=log.js.map

package/dist/log.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/log.ts"],
+  "sourcesContent": ["/**\n * Tiny, dependency-free run logger. It narrates \u2014 to stderr \u2014 what a control-loop run\n * is doing to its sandbox, so you can see where the sandbox is at each step. stderr is\n * used so it never mixes with a caller that parses the loop's return value off stdout.\n *\n * Muted with CONTROL_LOOP_SILENT=1; colors follow NO_COLOR and TTY detection.\n */\n\nconst enabled = process.env.CONTROL_LOOP_SILENT !== \"1\" && process.env.CONTROL_LOOP_SILENT !== \"true\";\nconst color = enabled && Boolean(process.stderr.isTTY) && !process.env.NO_COLOR;\n\nconst paint = (code: string) => (text: string) => (color ? `\\x1b[${code}m${text}\\x1b[0m` : text);\nconst dim = paint(\"2\");\nconst bold = paint(\"1\");\nconst cyan = paint(\"36\");\nconst green = paint(\"32\");\nconst yellow = paint(\"33\");\nconst red = paint(\"31\");\nconst magenta = paint(\"35\");\n\nfunction elapsed(startMs: number): string {\n  const ms = Date.now() - startMs;\n  return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;\n}\n\n/** Placeholder scope shown before the sandbox exists (nothing to point at yet). */\nconst PENDING = \"\u00B7\u00B7\u00B7\u00B7\u00B7\u00B7\u00B7\u00B7\";\n\nexport class RunLog {\n  private scope = PENDING;\n\n  constructor(label: string) {\n    if (!enabled) return;\n    process.stderr.write(`\\n${dim(\"\u2501\u2501\")} ${bold(\"control-loop\")} ${dim(\"\u00B7\")} ${cyan(label)}\\n`);\n  }\n\n  /** Once the sandbox exists, tag every subsequent line with its (short) id. */\n  attach(sandboxId: string): void {\n    this.scope = sandboxId.slice(0, 8);\n    this.line(magenta(\"\u25C6\"), `sandbox ${bold(this.scope)} ready`);\n  }\n\n  /** Wraps an async op: prints \"\u2192 label\", then \"\u2713 label (elapsed)\" \u2014 or \"\u2717 label\" if it throws. */\n  async step<T>(label: string, fn: () => Promise<T>): Promise<T> {\n    const start = Date.now();\n    this.line(cyan(\"\u2192\"), label);\n    try {\n      const result = await fn();\n      this.line(green(\"\u2713\"), `${label} ${dim(`(${elapsed(start)})`)}`);\n      return result;\n    } catch (error) {\n      this.line(red(\"\u2717\"), `${label} ${dim(`(${elapsed(start)})`)}`);\n      throw error;\n    }\n  }\n\n  /** A neutral status line \u2014 counts, picks, and other in-between context. */\n  info(message: string): void {\n    this.line(dim(\"\u00B7\"), dim(message));\n  }\n\n  /** The run bowed out early (nothing to do, cap hit). */\n  skip(message: string): void {\n    this.line(yellow(\"\u23ED\"), yellow(message));\n  }\n\n  /** The run's terminal outcome. */\n  finish(message: string): void {\n    this.line(green(\"\u25CF\"), bold(message));\n  }\n\n  private line(symbol: string, message: string): void {\n    if (!enabled) return;\n    process.stderr.write(`  ${dim(this.scope)}  ${symbol} ${message}\\n`);\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,MAAM,UAAU,QAAQ,IAAI,wBAAwB,OAAO,QAAQ,IAAI,wBAAwB;AAC/F,MAAM,QAAQ,WAAW,QAAQ,QAAQ,OAAO,KAAK,KAAK,CAAC,QAAQ,IAAI;AAEvE,MAAM,QAAQ,CAAC,SAAiB,CAAC,SAAkB,QAAQ,QAAQ,IAAI,IAAI,IAAI,YAAY;AAC3F,MAAM,MAAM,MAAM,GAAG;AACrB,MAAM,OAAO,MAAM,GAAG;AACtB,MAAM,OAAO,MAAM,IAAI;AACvB,MAAM,QAAQ,MAAM,IAAI;AACxB,MAAM,SAAS,MAAM,IAAI;AACzB,MAAM,MAAM,MAAM,IAAI;AACtB,MAAM,UAAU,MAAM,IAAI;AAE1B,SAAS,QAAQ,SAAyB;AACxC,QAAM,KAAK,KAAK,IAAI,IAAI;AACxB,SAAO,KAAK,MAAO,GAAG,EAAE,OAAO,IAAI,KAAK,KAAM,QAAQ,CAAC,CAAC;AAC1D;AAGA,MAAM,UAAU;AAET,MAAM,OAAO;AAAA,EACV,QAAQ;AAAA,EAEhB,YAAY,OAAe;AACzB,QAAI,CAAC,QAAS;AACd,YAAQ,OAAO,MAAM;AAAA,EAAK,IAAI,cAAI,CAAC,IAAI,KAAK,cAAc,CAAC,IAAI,IAAI,MAAG,CAAC,IAAI,KAAK,KAAK,CAAC;AAAA,CAAI;AAAA,EAC5F;AAAA;AAAA,EAGA,OAAO,WAAyB;AAC9B,SAAK,QAAQ,UAAU,MAAM,GAAG,CAAC;AACjC,SAAK,KAAK,QAAQ,QAAG,GAAG,WAAW,KAAK,KAAK,KAAK,CAAC,QAAQ;AAAA,EAC7D;AAAA;AAAA,EAGA,MAAM,KAAQ,OAAe,IAAkC;AAC7D,UAAM,QAAQ,KAAK,IAAI;AACvB,SAAK,KAAK,KAAK,QAAG,GAAG,KAAK;AAC1B,QAAI;AACF,YAAM,SAAS,MAAM,GAAG;AACxB,WAAK,KAAK,MAAM,QAAG,GAAG,GAAG,KAAK,IAAI,IAAI,IAAI,QAAQ,KAAK,CAAC,GAAG,CAAC,EAAE;AAC9D,aAAO;AAAA,IACT,SAAS,OAAO;AACd,WAAK,KAAK,IAAI,QAAG,GAAG,GAAG,KAAK,IAAI,IAAI,IAAI,QAAQ,KAAK,CAAC,GAAG,CAAC,EAAE;AAC5D,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA,EAGA,KAAK,SAAuB;AAC1B,SAAK,KAAK,IAAI,MAAG,GAAG,IAAI,OAAO,CAAC;AAAA,EAClC;AAAA;AAAA,EAGA,KAAK,SAAuB;AAC1B,SAAK,KAAK,OAAO,QAAG,GAAG,OAAO,OAAO,CAAC;AAAA,EACxC;AAAA;AAAA,EAGA,OAAO,SAAuB;AAC5B,SAAK,KAAK,MAAM,QAAG,GAAG,KAAK,OAAO,CAAC;AAAA,EACrC;AAAA,EAEQ,KAAK,QAAgB,SAAuB;AAClD,QAAI,CAAC,QAAS;AACd,YAAQ,OAAO,MAAM,KAAK,IAAI,KAAK,KAAK,CAAC,KAAK,MAAM,IAAI,OAAO;AAAA,CAAI;AAAA,EACrE;AACF;",
+  "names": []
+}

package/dist/pickers/busiest-file.d.ts

@@ -0,0 +1,9 @@
+import type { Picker } from "./index";
+/**
+ * Picker: takes every signal belonging to the single busiest file — the file with
+ * the most signals this run. Focuses one run on one file so all its fixes land in a
+ * single, coherent PR. Ties are broken toward the file whose first signal appears
+ * earliest in sensor order. Signals without a `location` have no file to group by and
+ * are ignored (they can never be the busiest file).
+ */
+export declare const busiestFile: <TData = unknown>() => Picker<TData>;

package/dist/pickers/busiest-file.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var busiest_file_exports = {};
+__export(busiest_file_exports, {
+  busiestFile: () => busiestFile
+});
+module.exports = __toCommonJS(busiest_file_exports);
+const busiestFile = () => (signals) => {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const signal of signals) {
+    const file = signal.location?.file;
+    if (file === void 0) continue;
+    const group = byFile.get(file);
+    if (group) {
+      group.push(signal);
+    } else {
+      byFile.set(file, [signal]);
+    }
+  }
+  let winner = [];
+  for (const group of byFile.values()) {
+    if (group.length > winner.length) {
+      winner = group;
+    }
+  }
+  return winner;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  busiestFile
+});
+//# sourceMappingURL=busiest-file.js.map

package/dist/pickers/busiest-file.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/pickers/busiest-file.ts"],
+  "sourcesContent": ["import type { Signal } from \"../types\";\nimport type { Picker } from \"./index\";\n\n/**\n * Picker: takes every signal belonging to the single busiest file \u2014 the file with\n * the most signals this run. Focuses one run on one file so all its fixes land in a\n * single, coherent PR. Ties are broken toward the file whose first signal appears\n * earliest in sensor order. Signals without a `location` have no file to group by and\n * are ignored (they can never be the busiest file).\n */\nexport const busiestFile =\n  <TData = unknown>(): Picker<TData> =>\n  (signals: Signal<TData>[]) => {\n    const byFile = new Map<string, Signal<TData>[]>();\n    for (const signal of signals) {\n      const file = signal.location?.file;\n      if (file === undefined) continue;\n      const group = byFile.get(file);\n      if (group) {\n        group.push(signal);\n      } else {\n        byFile.set(file, [signal]);\n      }\n    }\n\n    let winner: Signal<TData>[] = [];\n    for (const group of byFile.values()) {\n      if (group.length > winner.length) {\n        winner = group;\n      }\n    }\n    return winner;\n  };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUO,MAAM,cACX,MACA,CAAC,YAA6B;AAC5B,QAAM,SAAS,oBAAI,IAA6B;AAChD,aAAW,UAAU,SAAS;AAC5B,UAAM,OAAO,OAAO,UAAU;AAC9B,QAAI,SAAS,OAAW;AACxB,UAAM,QAAQ,OAAO,IAAI,IAAI;AAC7B,QAAI,OAAO;AACT,YAAM,KAAK,MAAM;AAAA,IACnB,OAAO;AACL,aAAO,IAAI,MAAM,CAAC,MAAM,CAAC;AAAA,IAC3B;AAAA,EACF;AAEA,MAAI,SAA0B,CAAC;AAC/B,aAAW,SAAS,OAAO,OAAO,GAAG;AACnC,QAAI,MAAM,SAAS,OAAO,QAAQ;AAChC,eAAS;AAAA,IACX;AAAA,EACF;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/pickers/count.d.ts

@@ -0,0 +1,6 @@
+import type { Picker } from "./index";
+/**
+ * Default picker: takes the first `count` signals in sensor order.
+ * Sort inside your sensor (or write your own picker) to prioritize differently.
+ */
+export declare const count: <TData = unknown>(count: number) => Picker<TData>;

package/dist/pickers/count.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var count_exports = {};
+__export(count_exports, {
+  count: () => count
+});
+module.exports = __toCommonJS(count_exports);
+const count = (count2) => (signals) => signals.slice(0, count2);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  count
+});
+//# sourceMappingURL=count.js.map

package/dist/pickers/count.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/pickers/count.ts"],
+  "sourcesContent": ["import type { Signal } from \"../types\";\nimport type { Picker } from \"./index\";\n\n/**\n * Default picker: takes the first `count` signals in sensor order.\n * Sort inside your sensor (or write your own picker) to prioritize differently.\n */\nexport const count =\n  <TData = unknown>(count: number): Picker<TData> =>\n  (signals: Signal<TData>[]) =>\n    signals.slice(0, count);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOO,MAAM,QACX,CAAkBA,WAClB,CAAC,YACC,QAAQ,MAAM,GAAGA,MAAK;",
+  "names": ["count"]
+}

package/dist/pickers/index.d.ts

@@ -0,0 +1,12 @@
+import type { Signal } from "../types";
+/** Chooses which of the sensed signals to act on this run. */
+export type Picker<TData = unknown> = (signals: Signal<TData>[]) => Promise<Signal<TData>[]> | Signal<TData>[];
+export { count } from "./count";
+export { busiestFile } from "./busiest-file";
+/**
+ * Runs pickers left-to-right, each narrowing the output of the previous — e.g.
+ * `chain(busiestFile(), count(3))` focuses one file, then caps it at 3 signals.
+ * Order matters: every step only sees what the one before it kept. With no steps
+ * it passes the signals through untouched.
+ */
+export declare const chain: <TData = unknown>(...steps: Picker<TData>[]) => Picker<TData>;