@atolis-hq/wake 0.1.0

package/dist/src/adapters/git/git-workspace-manager.js

@@ -0,0 +1,168 @@
+import { execFile as nodeExecFile } from 'node:child_process';
+import { access, mkdir, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+import { createWakePaths } from '../../lib/paths.js';
+import { branchNameForIssue } from '../../domain/branch-naming.js';
+const execFile = promisify(nodeExecFile);
+// Re-exported for existing callers (this adapter's own use below, plus
+// adapters/runner/stage-prompt.ts and tests) — the canonical definition now
+// lives in domain/branch-naming.ts so core/ can use it without importing a
+// concrete adapter.
+export { branchNameForIssue };
+async function git(args, cwd) {
+    const result = await execFile('git', args, {
+        cwd,
+        env: process.env,
+        encoding: 'utf8',
+        maxBuffer: 1024 * 1024 * 16,
+    });
+    return { stdout: result.stdout.trim(), stderr: result.stderr.trim() };
+}
+async function detectDefaultBranch(repoPath) {
+    await git(['remote', 'set-head', 'origin', '--auto'], repoPath);
+    const { stdout } = await git(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], repoPath);
+    const defaultBranch = stdout.replace(/^origin\//, '');
+    if (defaultBranch.length === 0) {
+        throw new Error(`Unable to detect default branch for ${repoPath}`);
+    }
+    return defaultBranch;
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function defaultRemoteUrlForRepo(repo) {
+    return `https://github.com/${repo}.git`;
+}
+export function buildWorkspaceCloneArgs(input) {
+    return [
+        'clone',
+        '--no-local',
+        '--branch',
+        input.defaultBranch,
+        input.sourceRepoPath,
+        input.workspacePath,
+    ];
+}
+async function tryUpdateFromDefaultBranch(workspacePath) {
+    try {
+        const { stdout: status } = await git(['status', '--porcelain'], workspacePath);
+        if (status.length > 0) {
+            return { mergeConflictDetected: false };
+        }
+        await git(['fetch', 'origin'], workspacePath);
+        const defaultBranch = await detectDefaultBranch(workspacePath);
+        const { stdout: count } = await git(['rev-list', '--count', `HEAD..origin/${defaultBranch}`], workspacePath);
+        if (parseInt(count.trim(), 10) === 0) {
+            return { mergeConflictDetected: false };
+        }
+        const { stdout: upstreamChanges } = await git([
+            'log',
+            '--date=short',
+            '--pretty=format:%h %ad %an <%ae>%n    %s',
+            `HEAD..origin/${defaultBranch}`,
+        ], workspacePath);
+        // Probe for conflicts without touching the index or worktree. A real merge
+        // would need committer identity even with --no-commit on some Git versions.
+        try {
+            await git(['merge-tree', '--write-tree', 'HEAD', `origin/${defaultBranch}`], workspacePath);
+            await git([
+                '-c',
+                'user.email=wake@example.invalid',
+                '-c',
+                'user.name=Wake',
+                'merge',
+                '--no-edit',
+                `origin/${defaultBranch}`,
+            ], workspacePath);
+            return {
+                mergeConflictDetected: false,
+                ...(upstreamChanges.length === 0 ? {} : { upstreamChanges }),
+            };
+        }
+        catch {
+            return { mergeConflictDetected: true };
+        }
+    }
+    catch {
+        // Fetch or branch detection failed — leave workspace as-is, no conflict reported
+        return { mergeConflictDetected: false };
+    }
+}
+export function createGitWorkspaceManager(options) {
+    const paths = createWakePaths(options.wakeRoot);
+    const remoteUrlForRepo = options.remoteUrlForRepo ?? defaultRemoteUrlForRepo;
+    async function ensureCanonicalClone(repo) {
+        const repoPath = paths.repoRoot(repo);
+        const remoteUrl = remoteUrlForRepo(repo);
+        if (await pathExists(repoPath)) {
+            // The canonical clone is only ever touched by one tick at a time, so an
+            // index.lock found here can't be a live concurrent writer - it's a leftover
+            // from a process that was killed mid-git-operation (e.g. a container
+            // restart). Left in place it wedges every future tick on this repo with
+            // "Unable to create index.lock: File exists", so clear it defensively
+            // before running any git command against the clone.
+            await rm(join(repoPath, '.git', 'index.lock'), { force: true });
+            await git(['fetch', 'origin'], repoPath);
+            const defaultBranch = await detectDefaultBranch(repoPath);
+            await git(['checkout', defaultBranch], repoPath);
+            await git(['reset', '--hard', `origin/${defaultBranch}`], repoPath);
+            await git(['clean', '-fdx'], repoPath);
+            return { repoPath, defaultBranch };
+        }
+        else {
+            await mkdir(dirname(repoPath), { recursive: true });
+            await git(['clone', remoteUrl, repoPath], dirname(repoPath));
+            const defaultBranch = await detectDefaultBranch(repoPath);
+            return { repoPath, defaultBranch };
+        }
+    }
+    return {
+        async prepareWorkspace({ workId, repo, issueNumber, }) {
+            // The workspace is keyed by work item; `repo` still drives the clone and
+            // `issueNumber` still names the branch, which stays human-readable and
+            // provider-facing (spec D2).
+            const workspacePath = paths.workspaceDir(workId);
+            if (await pathExists(workspacePath)) {
+                const updateResult = await tryUpdateFromDefaultBranch(workspacePath);
+                return { workspacePath, ...updateResult };
+            }
+            const { repoPath, defaultBranch } = await ensureCanonicalClone(repo);
+            const remoteUrl = remoteUrlForRepo(repo);
+            await mkdir(dirname(workspacePath), { recursive: true });
+            await git(buildWorkspaceCloneArgs({
+                sourceRepoPath: repoPath,
+                workspacePath,
+                defaultBranch,
+            }), dirname(workspacePath));
+            const branch = branchNameForIssue(issueNumber);
+            await git(['remote', 'set-url', 'origin', remoteUrl], workspacePath);
+            await git(['checkout', '-B', branch], workspacePath);
+            return { workspacePath, mergeConflictDetected: false };
+        },
+        async prepareReadOnlyClone({ repo }) {
+            // Refine only reads the issue and, at most, the canonical clone -
+            // it never gets a per-issue branch/workspace of its own (only
+            // 'implement' pays that cost).
+            const { repoPath } = await ensureCanonicalClone(repo);
+            return { workspacePath: repoPath };
+        },
+        async cleanupWorkspace({ workspacePath }) {
+            // On Windows, a just-exited git subprocess (or AV/indexer) can hold a brief
+            // handle on files it touched; a bare rm races that and fails EBUSY/EPERM.
+            // maxRetries/retryDelay make fs.rm retry with backoff instead of throwing.
+            await rm(workspacePath, {
+                recursive: true,
+                force: true,
+                maxRetries: 5,
+                retryDelay: 200,
+            });
+        },
+    };
+}

package/dist/src/adapters/github/github-artifact-verifier.js

@@ -0,0 +1,38 @@
+import { buildResourceUri } from '../../domain/resource-uri.js';
+const githubPrUrlPattern = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/;
+export function createGitHubArtifactVerifier(deps) {
+    return {
+        async verify(artifact, context) {
+            if (artifact.kind !== 'pr') {
+                return null;
+            }
+            const match = githubPrUrlPattern.exec(artifact.url);
+            if (match === null) {
+                return null;
+            }
+            const [, owner, repo, numberStr] = match;
+            if (owner === undefined || repo === undefined || numberStr === undefined) {
+                return null;
+            }
+            // GitHub owner/repo names are case-insensitive, so the URL's rendered
+            // casing (owner/repo, as linked by the agent) can legitimately differ
+            // from the configured context.repo string.
+            if (`${owner}/${repo}`.toLowerCase() !== context.repo.toLowerCase()) {
+                return null;
+            }
+            try {
+                const pr = await deps.client.getPullRequest(owner, repo, Number(numberStr));
+                if (pr.head.ref !== context.branch) {
+                    return null;
+                }
+                // Built from context.repo, not the URL's owner/repo casing, so this
+                // resourceUri exact-matches the one discoverPullRequests/pollWatchedPr
+                // build from the same configured repo string.
+                return { resourceUri: buildResourceUri('github', 'pr', `${context.repo}#${numberStr}`) };
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}

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

@@ -0,0 +1,16 @@
+import { execFile as nodeExecFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFile = promisify(nodeExecFile);
+export async function resolveGitHubToken(deps) {
+    try {
+        const result = await (deps?.execFile ?? execFile)('gh', ['auth', 'token']);
+        const token = String(result.stdout).trim();
+        if (token.length === 0) {
+            throw new Error('empty token');
+        }
+        return token;
+    }
+    catch (error) {
+        throw new Error(`Failed to resolve GitHub token via gh auth token: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

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

@@ -0,0 +1,100 @@
+import { Octokit } from '@octokit/rest';
+export function createGitHubClient(token) {
+    const octokit = new Octokit({ auth: token });
+    return {
+        // `maxResults` is a hard cap on issues returned, not just a page size:
+        // octokit.paginate otherwise walks every page regardless of page size,
+        // which burns GitHub's rate limit (a "fourth budget") on repos with many
+        // 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);
+        },
+        async listComments(owner, repo, issueNumber, perPage) {
+            return octokit.paginate(octokit.rest.issues.listComments, {
+                owner,
+                repo,
+                issue_number: issueNumber,
+                per_page: perPage,
+            });
+        },
+        async createComment(owner, repo, issueNumber, body) {
+            return octokit.rest.issues.createComment({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                body,
+            });
+        },
+        async setLabels(owner, repo, issueNumber, labels) {
+            return octokit.rest.issues.setLabels({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                labels,
+            });
+        },
+        async getPullRequest(owner, repo, pullNumber) {
+            const { data } = await octokit.rest.pulls.get({
+                owner,
+                repo,
+                pull_number: pullNumber,
+            });
+            return data;
+        },
+        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);
+        },
+        async listReviews(owner, repo, pullNumber, perPage) {
+            return octokit.paginate(octokit.rest.pulls.listReviews, {
+                owner,
+                repo,
+                pull_number: pullNumber,
+                per_page: perPage,
+            });
+        },
+        async listReviewComments(owner, repo, pullNumber, perPage) {
+            return octokit.paginate(octokit.rest.pulls.listReviewComments, {
+                owner,
+                repo,
+                pull_number: pullNumber,
+                per_page: perPage,
+            });
+        },
+        async replyToReviewComment(owner, repo, pullNumber, commentId, body) {
+            return octokit.rest.pulls.createReplyForReviewComment({
+                owner,
+                repo,
+                pull_number: pullNumber,
+                comment_id: commentId,
+                body,
+            });
+        },
+    };
+}