@atolis-hq/wake 0.1.16 → 0.1.18

package/README.md

@@ -1,12 +1,16 @@
 # Wake
 
-Wake is a local autonomous agent control plane for software development. It
-watches the work channels your team already uses, such as GitHub Issues,
-decides each item's next lifecycle step with deterministic rules, and launches
-local coding-agent CLIs only when agentic execution is actually needed.
+Wake is a control plane for autonomous software engineering. It watches the
+channels your team already uses, coordinates agent activity and involves humans
+when needed, and keeps the durable record attached to the work instead of the
+terminal session that happened to run it.
 
-Wake is the control plane and decision-maker. It launches and manages local
-agent sessions for each unit of agentic work.
+Create an issue, assign Wake, and keep doing your own work. Wake investigates,
+asks for input when human judgment matters, proposes a plan, launches local
+coding-agent CLIs to implement changes, opens pull requests, and carries the
+conversation forward wherever the work is already happening.
+
+Wake owns coordination. Coding agents execute the work.
 
 ## The Problem
 
@@ -27,10 +31,11 @@ out of the token-burning path wherever possible.
 
 ## Vision
 
-Wake should make reliable, resumable, token-aware local agent execution
+Wake should make reliable, resumable, token-aware autonomous engineering
 practical. The default operating model is asynchronous and channel-driven: work
-enters and progresses through durable external systems, while execution happens
-locally in an inspectable workspace or sandbox.
+enters through durable external systems, Wake keeps humans in the loop at useful
+decision points, and execution happens locally in an inspectable workspace or
+sandbox.
 
 Wake is not trying to replace coding agents, issue trackers, or source control.
 It coordinates across them. Over time it should become the layer that picks

package/dist/src/adapters/github/github-client.js

@@ -1,6 +1,8 @@
 import { Octokit } from '@octokit/rest';
+import { createEtagCache, fetchPaginatedWithEtag, fetchSingleWithEtag, } from './github-etag-cache.js';
 export function createGitHubClient(token) {
     const octokit = new Octokit({ auth: token });
+    const etagCache = createEtagCache();
     return {
         async getAuthenticatedLogin() {
             const { data } = await octokit.rest.users.getAuthenticated();
@@ -12,27 +14,31 @@ export function createGitHubClient(token) {
         // issues. Stop paginating as soon as the cap is reached.
         async listIssues(owner, repo, maxResults, since) {
             const perPage = Math.min(maxResults, 100);
-            const results = [];
-            for await (const { data } of octokit.paginate.iterator(octokit.rest.issues.listForRepo, {
-                owner,
-                repo,
-                state: 'all',
-                per_page: perPage,
-                ...(since === undefined ? {} : { since }),
-            })) {
-                results.push(...data);
-                if (results.length >= maxResults) {
-                    break;
-                }
-            }
-            return results.slice(0, maxResults);
+            return fetchPaginatedWithEtag({
+                cache: etagCache,
+                cacheKey: `issues:${owner}/${repo}`,
+                maxResults,
+                pages: (headers) => octokit.paginate.iterator(octokit.rest.issues.listForRepo, {
+                    owner,
+                    repo,
+                    state: 'all',
+                    per_page: perPage,
+                    ...(since === undefined ? {} : { since }),
+                    ...(headers === undefined ? {} : { headers }),
+                }),
+            });
         },
         async listComments(owner, repo, issueNumber, perPage) {
-            return octokit.paginate(octokit.rest.issues.listComments, {
-                owner,
-                repo,
-                issue_number: issueNumber,
-                per_page: perPage,
+            return fetchPaginatedWithEtag({
+                cache: etagCache,
+                cacheKey: `issue-comments:${owner}/${repo}#${issueNumber}`,
+                pages: (headers) => octokit.paginate.iterator(octokit.rest.issues.listComments, {
+                    owner,
+                    repo,
+                    issue_number: issueNumber,
+                    per_page: perPage,
+                    ...(headers === undefined ? {} : { headers }),
+                }),
             });
         },
         async createComment(owner, repo, issueNumber, body) {
@@ -60,10 +66,18 @@ export function createGitHubClient(token) {
             return data;
         },
         async getRequiredStatusChecks(owner, repo, branch) {
-            const { data } = await octokit.rest.repos.getBranch({
-                owner,
-                repo,
-                branch,
+            const data = await fetchSingleWithEtag({
+                cache: etagCache,
+                cacheKey: `required-status-checks:${owner}/${repo}@${branch}`,
+                request: async (headers) => {
+                    const response = await octokit.rest.repos.getBranch({
+                        owner,
+                        repo,
+                        branch,
+                        ...(headers === undefined ? {} : { headers }),
+                    });
+                    return { data: response.data, headers: response.headers ?? {} };
+                },
             });
             const requiredStatusChecks = data.protection?.required_status_checks;
             return {
@@ -74,52 +88,77 @@ export function createGitHubClient(token) {
             };
         },
         async listCheckRunsForRef(owner, repo, ref) {
-            const { data } = await octokit.rest.checks.listForRef({
-                owner,
-                repo,
-                ref,
-                per_page: 100,
+            const data = await fetchSingleWithEtag({
+                cache: etagCache,
+                cacheKey: `check-runs:${owner}/${repo}@${ref}`,
+                request: async (headers) => {
+                    const response = await octokit.rest.checks.listForRef({
+                        owner,
+                        repo,
+                        ref,
+                        per_page: 100,
+                        ...(headers === undefined ? {} : { headers }),
+                    });
+                    return { data: response.data, headers: response.headers ?? {} };
+                },
             });
             return data.check_runs;
         },
         async getCombinedStatusForRef(owner, repo, ref) {
-            const { data } = await octokit.rest.repos.getCombinedStatusForRef({
-                owner,
-                repo,
-                ref,
+            const data = await fetchSingleWithEtag({
+                cache: etagCache,
+                cacheKey: `combined-status:${owner}/${repo}@${ref}`,
+                request: async (headers) => {
+                    const response = await octokit.rest.repos.getCombinedStatusForRef({
+                        owner,
+                        repo,
+                        ref,
+                        ...(headers === undefined ? {} : { headers }),
+                    });
+                    return { data: response.data, headers: response.headers ?? {} };
+                },
             });
             return data.statuses;
         },
         async listPullRequests(owner, repo, maxResults) {
             const perPage = Math.min(maxResults, 100);
-            const results = [];
-            for await (const { data } of octokit.paginate.iterator(octokit.rest.pulls.list, {
-                owner,
-                repo,
-                state: 'open',
-                per_page: perPage,
-            })) {
-                results.push(...data);
-                if (results.length >= maxResults) {
-                    break;
-                }
-            }
-            return results.slice(0, maxResults);
+            return fetchPaginatedWithEtag({
+                cache: etagCache,
+                cacheKey: `pulls:${owner}/${repo}`,
+                maxResults,
+                pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.list, {
+                    owner,
+                    repo,
+                    state: 'open',
+                    per_page: perPage,
+                    ...(headers === undefined ? {} : { headers }),
+                }),
+            });
         },
         async listReviews(owner, repo, pullNumber, perPage) {
-            return octokit.paginate(octokit.rest.pulls.listReviews, {
-                owner,
-                repo,
-                pull_number: pullNumber,
-                per_page: perPage,
+            return fetchPaginatedWithEtag({
+                cache: etagCache,
+                cacheKey: `pr-reviews:${owner}/${repo}#${pullNumber}`,
+                pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listReviews, {
+                    owner,
+                    repo,
+                    pull_number: pullNumber,
+                    per_page: perPage,
+                    ...(headers === undefined ? {} : { headers }),
+                }),
             });
         },
         async listReviewComments(owner, repo, pullNumber, perPage) {
-            return octokit.paginate(octokit.rest.pulls.listReviewComments, {
-                owner,
-                repo,
-                pull_number: pullNumber,
-                per_page: perPage,
+            return fetchPaginatedWithEtag({
+                cache: etagCache,
+                cacheKey: `pr-review-comments:${owner}/${repo}#${pullNumber}`,
+                pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listReviewComments, {
+                    owner,
+                    repo,
+                    pull_number: pullNumber,
+                    per_page: perPage,
+                    ...(headers === undefined ? {} : { headers }),
+                }),
             });
         },
         async replyToReviewComment(owner, repo, pullNumber, commentId, body) {

package/dist/src/adapters/github/github-etag-cache.js

@@ -0,0 +1,57 @@
+export function createEtagCache() {
+    return new Map();
+}
+function isNotModifiedError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'status' in error &&
+        error.status === 304);
+}
+export async function fetchSingleWithEtag(input) {
+    const cached = input.cache.get(input.cacheKey);
+    try {
+        const response = await input.request(cached === undefined ? undefined : { 'if-none-match': cached.etag });
+        if (typeof response.headers.etag === 'string') {
+            input.cache.set(input.cacheKey, { etag: response.headers.etag, data: response.data });
+        }
+        return response.data;
+    }
+    catch (error) {
+        if (isNotModifiedError(error) && cached !== undefined) {
+            return cached.data;
+        }
+        throw error;
+    }
+}
+export async function fetchPaginatedWithEtag(input) {
+    const cached = input.cache.get(input.cacheKey);
+    const results = [];
+    let pageCount = 0;
+    let lastHeaders = {};
+    try {
+        for await (const page of input.pages(cached === undefined ? undefined : { 'if-none-match': cached.etag })) {
+            pageCount += 1;
+            lastHeaders = page.headers;
+            results.push(...page.data);
+            if (input.maxResults !== undefined && results.length >= input.maxResults) {
+                break;
+            }
+        }
+    }
+    catch (error) {
+        if (isNotModifiedError(error) && cached !== undefined) {
+            return input.maxResults === undefined ? cached.data : cached.data.slice(0, input.maxResults);
+        }
+        throw error;
+    }
+    const truncated = input.maxResults !== undefined && results.length > input.maxResults
+        ? results.slice(0, input.maxResults)
+        : results;
+    if (pageCount <= 1 && typeof lastHeaders.etag === 'string') {
+        input.cache.set(input.cacheKey, { etag: lastHeaders.etag, data: truncated });
+    }
+    else {
+        input.cache.delete(input.cacheKey);
+    }
+    return truncated;
+}

package/dist/src/version.js

@@ -1 +1 @@
-export const wakeVersion = "0.1.16+g97c5859";
+export const wakeVersion = "0.1.18+g6b6248c";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {