@atolis-hq/wake 0.1.0

package/dist/src/core/control-plane.js

@@ -0,0 +1,127 @@
+export function createControlPlane(deps) {
+    let running = true;
+    let lastStatus;
+    let lastIntakeStatus;
+    let lastRunnerStatus;
+    let consecutiveIdleTicks = 0;
+    let consecutiveIntakeIdleTicks = 0;
+    let consecutiveRunnerIdleTicks = 0;
+    const maxIntervalMs = deps.maxIntervalMs ?? deps.intervalMs * 16;
+    function nextSleepMs(consecutiveTicks) {
+        const backoffMs = deps.intervalMs * 2 ** Math.min(consecutiveTicks, 20);
+        return Math.min(backoffMs, maxIntervalMs);
+    }
+    async function isPaused() {
+        return Boolean(await deps.isPaused());
+    }
+    function logStatus(message, status, last) {
+        if (status !== last) {
+            deps.logger.info(message);
+        }
+        return status;
+    }
+    async function runLoopOnce(input) {
+        if (await isPaused()) {
+            const status = 'paused';
+            if (input.label === 'intake') {
+                lastIntakeStatus = logStatus('[wake] intake status=paused', status, lastIntakeStatus);
+            }
+            else {
+                lastRunnerStatus = logStatus('[wake] runner status=paused', status, lastRunnerStatus);
+            }
+            return { status: 'paused' };
+        }
+        const result = await input.run();
+        const status = result?.status ?? 'unknown';
+        if (input.label === 'intake') {
+            lastIntakeStatus = logStatus(`[wake] intake status=${status}`, status, lastIntakeStatus);
+        }
+        else {
+            lastRunnerStatus = logStatus(`[wake] runner status=${status}`, status, lastRunnerStatus);
+        }
+        return result;
+    }
+    async function startLoop(input) {
+        while (running) {
+            let result;
+            try {
+                result = await runLoopOnce({ run: input.run, label: input.label });
+            }
+            catch (error) {
+                deps.logger.error(error instanceof Error ? error.message : String(error));
+            }
+            if (!running) {
+                break;
+            }
+            const status = result?.status;
+            if (status === 'processed') {
+                input.setIdleTicks(0);
+            }
+            else {
+                await deps.sleep(nextSleepMs(input.getIdleTicks()));
+                input.setIdleTicks(input.getIdleTicks() + 1);
+            }
+        }
+    }
+    return {
+        stop() {
+            running = false;
+        },
+        async runOnce() {
+            if (await isPaused()) {
+                if (lastStatus !== 'paused') {
+                    deps.logger.info('[wake] status=paused');
+                    lastStatus = 'paused';
+                }
+                return { status: 'paused' };
+            }
+            const result = await deps.tickRunner.runTick();
+            const status = result?.status ?? 'unknown';
+            if (status !== lastStatus) {
+                deps.logger.info(`[wake] status=${status}`);
+                lastStatus = status;
+            }
+            return result;
+        },
+        async start() {
+            if (deps.tickRunner.runIntakeTick !== undefined &&
+                deps.tickRunner.runRunnerTick !== undefined) {
+                await Promise.all([
+                    startLoop({
+                        run: deps.tickRunner.runIntakeTick,
+                        label: 'intake',
+                        getIdleTicks: () => consecutiveIntakeIdleTicks,
+                        setIdleTicks: (value) => { consecutiveIntakeIdleTicks = value; },
+                    }),
+                    startLoop({
+                        run: deps.tickRunner.runRunnerTick,
+                        label: 'runner',
+                        getIdleTicks: () => consecutiveRunnerIdleTicks,
+                        setIdleTicks: (value) => { consecutiveRunnerIdleTicks = value; },
+                    }),
+                ]);
+                return;
+            }
+            while (running) {
+                let result;
+                try {
+                    result = await this.runOnce();
+                }
+                catch (error) {
+                    deps.logger.error(error instanceof Error ? error.message : String(error));
+                }
+                if (!running) {
+                    break;
+                }
+                const status = result?.status;
+                if (status === 'processed') {
+                    consecutiveIdleTicks = 0;
+                }
+                else {
+                    await deps.sleep(nextSleepMs(consecutiveIdleTicks));
+                    consecutiveIdleTicks += 1;
+                }
+            }
+        },
+    };
+}

package/dist/src/core/lifecycle-service.js

@@ -0,0 +1,8 @@
+import { builtInDefaultWorkflowDefinition, nextStage } from '../domain/workflows.js';
+export function createLifecycleService() {
+    return {
+        nextStageFromSentinel(stage, sentinel, workflow = builtInDefaultWorkflowDefinition) {
+            return nextStage(stage, sentinel, workflow);
+        },
+    };
+}

package/dist/src/core/policy-engine.js

@@ -0,0 +1,200 @@
+import { awaitingApprovalRunnerSentinel, failedRunnerSentinel, } from '../domain/stages.js';
+import { builtInDefaultWorkflowDefinition, chooseAction as chooseWorkflowAction } from '../domain/workflows.js';
+function isAwaitingApproval(issue) {
+    const context = issue.context;
+    return context.lastRunSentinel === awaitingApprovalRunnerSentinel;
+}
+// Commands are matched as a token at the start of a (trimmed) line, not as a
+// substring anywhere in the body — so "I have *not* /approved this yet" or a
+// quoted reply containing /approved does not approve the gate.
+const approvedCommandPattern = /^\/approved\b/i;
+const changesCommandPattern = /^\/changes\b/i;
+const questionCommandPattern = /^\/question\b/i;
+function matchesCommand(body, pattern) {
+    return body
+        .split(/\r?\n/)
+        .some((line) => pattern.test(line.trim()));
+}
+function labelsAndAssigneesQualify(input) {
+    if (input.requiredLabels.length === 0 && input.requiredAssignees.length === 0) {
+        return false;
+    }
+    const labels = new Set(input.labels);
+    const assignees = new Set(input.assignees);
+    if (input.requiredLabels.some((label) => !labels.has(label))) {
+        return false;
+    }
+    if (input.ignoredLabels.some((label) => labels.has(label))) {
+        return false;
+    }
+    if (input.requiredAssignees.length > 0 && !input.requiredAssignees.some((login) => assignees.has(login))) {
+        return false;
+    }
+    return true;
+}
+function latestUnhandledHumanComment(issue) {
+    const context = issue.context;
+    const handledCommentId = typeof context.lastHandledCommentId === 'string'
+        ? context.lastHandledCommentId
+        : undefined;
+    // Only consider human comments that appear after the last bot comment.
+    // A human /approved posted before Wake's approval-request comment must not
+    // be re-consumed as approval for a later awaiting-approval cycle.
+    const lastBotIndex = issue.comments.reduce((acc, c, i) => (c.isBotAuthored ? i : acc), -1);
+    const humanCommentsAfterBot = issue.comments
+        .slice(lastBotIndex + 1)
+        .filter((c) => !c.isBotAuthored);
+    const latestHumanComment = humanCommentsAfterBot.at(-1);
+    if (latestHumanComment === undefined || latestHumanComment.id === handledCommentId) {
+        return undefined;
+    }
+    return latestHumanComment;
+}
+export function createPolicyEngine() {
+    return {
+        isEligible(issue, config) {
+            if (issue.issue.state !== 'open') {
+                return false;
+            }
+            // Defense-in-depth: the issues source filters PR-shaped items at poll
+            // time, so no NEW projection can ever have isPullRequest: true. But a
+            // pre-existing state/<workId>.json written by a pre-this-branch
+            // version of Wake could still hold isPullRequest: true, since the old
+            // fold created projections regardless of eligibility.
+            if (issue.issue.isPullRequest) {
+                return false;
+            }
+            return labelsAndAssigneesQualify({
+                labels: issue.issue.labels,
+                assignees: issue.issue.assignees,
+                requiredLabels: config.sources.github.policy.requiredLabels,
+                ignoredLabels: config.sources.github.policy.ignoredLabels,
+                requiredAssignees: config.sources.github.policy.requiredAssignees,
+            });
+        },
+        needsWakeAction(issue, workflow = builtInDefaultWorkflowDefinition) {
+            const context = issue.context;
+            const handledCommentId = typeof context.lastHandledCommentId === 'string'
+                ? context.lastHandledCommentId
+                : undefined;
+            const lastCompletedAction = typeof context.lastCompletedAction === 'string'
+                ? context.lastCompletedAction
+                : undefined;
+            const lastRunSentinel = typeof context.lastRunSentinel === 'string'
+                ? context.lastRunSentinel
+                : undefined;
+            const lastFailureClass = typeof context.lastFailureClass === 'string'
+                ? context.lastFailureClass
+                : undefined;
+            if (issue.wake.lastRunId === undefined) {
+                return true;
+            }
+            if (issue.latestComment !== undefined &&
+                !issue.latestComment.isBotAuthored &&
+                issue.latestComment.id !== handledCommentId) {
+                return true;
+            }
+            if (isAwaitingApproval(issue)) {
+                return false;
+            }
+            if (lastRunSentinel === failedRunnerSentinel && lastFailureClass !== 'quota') {
+                return false;
+            }
+            if (lastRunSentinel === 'BLOCKED') {
+                return false;
+            }
+            if (lastFailureClass === 'quota') {
+                return true;
+            }
+            const workflowAction = chooseWorkflowAction(issue, workflow);
+            return workflowAction !== null && lastCompletedAction !== workflowAction.action;
+        },
+        chooseAction(issue, workflow = builtInDefaultWorkflowDefinition) {
+            return chooseWorkflowAction(issue, workflow)?.action ?? null;
+        },
+        chooseRetryActionAfterHumanReply(issue) {
+            const context = issue.context;
+            const failed = context.lastRunSentinel === failedRunnerSentinel;
+            const blocked = context.lastRunSentinel === 'BLOCKED';
+            if (failed && context.lastFailureClass === 'quota') {
+                return typeof context.lastRunAction === 'string' ? context.lastRunAction : null;
+            }
+            if (!blocked && !failed) {
+                return null;
+            }
+            if (latestUnhandledHumanComment(issue) === undefined) {
+                return null;
+            }
+            return typeof context.lastRunAction === 'string' ? context.lastRunAction : null;
+        },
+        resolveApprovalTransition(issue) {
+            if (!isAwaitingApproval(issue)) {
+                return null;
+            }
+            const context = issue.context;
+            const pendingAction = typeof context.pendingApprovalAction === 'string'
+                ? context.pendingApprovalAction
+                : undefined;
+            // No new human comment since the last handled one; stay idle instead of
+            // falling through to the LLM while awaiting explicit approval feedback.
+            const latestHumanComment = latestUnhandledHumanComment(issue);
+            if (latestHumanComment === undefined) {
+                return null;
+            }
+            if (pendingAction === undefined) {
+                return null;
+            }
+            const approved = matchesCommand(latestHumanComment.body, approvedCommandPattern);
+            const changesRequested = matchesCommand(latestHumanComment.body, changesCommandPattern);
+            const questionAsked = matchesCommand(latestHumanComment.body, questionCommandPattern);
+            // Neither an explicit /approved, /changes, nor /question: treat this as
+            // conversation, not a decision. Stay idle rather than re-running the
+            // pending action off the back of an unmarked clarifying question (S2).
+            // The comment stays unhandled, so it's reconsidered on the next tick and
+            // by a human who follows up with an explicit command.
+            if (!approved && !changesRequested && !questionAsked) {
+                return null;
+            }
+            return { approved, pendingAction };
+        },
+        qualifiesForMint(unresolved, config) {
+            const resourceUri = unresolved.sourceRefs.resourceUri;
+            if (resourceUri === undefined) {
+                return false;
+            }
+            const kind = resourceUri.split(':')[1];
+            if (kind === 'issue') {
+                // Real github source stamps payload.ticket (sourceEventType
+                // 'ticket.upsert'); the fake ticketing harness stamps payload.issue
+                // (sourceEventType 'fake.issue.upsert') — the same dual-key
+                // recognition projection-updater.ts's createProjectionFromIssueEvent
+                // already applies when folding these into a projection. Qualification
+                // must accept both or the fake never qualifies anything, which would
+                // silently defeat every fixture that exercises minting through it.
+                const ticket = (unresolved.payload.ticket ?? unresolved.payload.issue);
+                if (ticket === undefined) {
+                    return false;
+                }
+                return labelsAndAssigneesQualify({
+                    labels: Array.isArray(ticket.labels) ? ticket.labels : [],
+                    assignees: Array.isArray(ticket.assignees) ? ticket.assignees : [],
+                    requiredLabels: config.sources.github.policy.requiredLabels,
+                    ignoredLabels: config.sources.github.policy.ignoredLabels,
+                    requiredAssignees: config.sources.github.policy.requiredAssignees,
+                });
+            }
+            if (kind === 'pr') {
+                if (!config.sources.github.pullRequests.enabled) {
+                    return false;
+                }
+                const pr = unresolved.payload.pr;
+                const requiredAuthors = config.sources.github.pullRequests.policy.requiredAuthors;
+                if (requiredAuthors.length === 0 || typeof pr?.author !== 'string') {
+                    return false;
+                }
+                return requiredAuthors.includes(pr.author);
+            }
+            return false;
+        },
+    };
+}