@exaudeus/workrail 3.43.0 → 3.44.0

package/dist/trigger/polling-scheduler.js

@@ -1,8 +1,46 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PollingScheduler = void 0;
 const gitlab_poller_js_1 = require("./adapters/gitlab-poller.js");
 const github_poller_js_1 = require("./adapters/github-poller.js");
+const github_queue_poller_js_1 = require("./adapters/github-queue-poller.js");
+const github_queue_config_js_1 = require("./github-queue-config.js");
+const fs = __importStar(require("node:fs/promises"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
 function isPollingTrigger(trigger) {
     return trigger.pollingSource !== undefined;
 }
@@ -78,6 +116,9 @@ class PollingScheduler {
             case 'github_prs_poll':
                 await this.doPollGitHub(trigger, triggerId, pollStartAt, lastPollAt, trigger.pollingSource, 'prs');
                 break;
+            case 'github_queue_poll':
+                await this.doPollGitHubQueue(trigger, triggerId, trigger.pollingSource);
+                break;
             default: {
                 const _exhaustive = trigger.pollingSource;
                 console.warn(`[PollingScheduler] Unknown provider '${String(_exhaustive.provider)}' ` +
@@ -150,6 +191,111 @@ class PollingScheduler {
             console.log(`[PollingScheduler] Dispatched ${newIds.length} new event(s) for trigger '${triggerId}'`);
         }
     }
+    async doPollGitHubQueue(trigger, triggerId, source) {
+        const cycleStart = Date.now();
+        const configResult = await (0, github_queue_config_js_1.loadQueueConfig)();
+        if (configResult.kind === 'err') {
+            console.warn(`[QueuePoll] Failed to load queue config for trigger '${triggerId}': ${configResult.error}. Skipping cycle.`);
+            return;
+        }
+        const queueConfig = configResult.value;
+        if (queueConfig === null)
+            return;
+        if (queueConfig.type !== 'assignee') {
+            console.error(`[QueuePoll] Queue type '${queueConfig.type}' is not implemented. Only 'assignee' is supported. Skipping cycle.`);
+            await appendQueuePollLog({ event: 'poll_cycle_complete', triggerId, reason: 'not_implemented', queueType: queueConfig.type, ts: new Date().toISOString() });
+            return;
+        }
+        const sessionsDir = path.join(os.homedir(), '.workrail', 'daemon-sessions');
+        const activeSessions = await countActiveSessions(sessionsDir);
+        if (activeSessions >= queueConfig.maxTotalConcurrentSessions) {
+            console.log(`[QueuePoll] Skipping cycle: active sessions (${activeSessions}) >= maxTotalConcurrentSessions (${queueConfig.maxTotalConcurrentSessions}).`);
+            await appendQueuePollLog({ event: 'poll_cycle_skipped', triggerId, reason: 'max_concurrency_reached', activeSessions, maxTotalConcurrentSessions: queueConfig.maxTotalConcurrentSessions, ts: new Date().toISOString() });
+            return;
+        }
+        const fetchResult = await (0, github_queue_poller_js_1.pollGitHubQueueIssues)(source, queueConfig, this.fetchFn);
+        if (fetchResult.kind === 'err') {
+            console.warn(`[QueuePoll] GitHub API error for trigger '${triggerId}': ${fetchResult.error.kind}. Skipping cycle.`);
+            return;
+        }
+        const issues = fetchResult.value;
+        console.log(`[QueuePoll] cycle start repo=${source.repo} issues_fetched=${issues.length}`);
+        const candidates = [];
+        const skipped = [];
+        for (const issue of issues) {
+            const issueLabels = issue.labels.map((l) => l.name);
+            const excludedLabel = queueConfig.excludeLabels.find((el) => issueLabels.includes(el));
+            if (excludedLabel) {
+                skipped.push({ issue, reason: `excluded_label: ${excludedLabel}` });
+                continue;
+            }
+            if (issueLabels.includes('worktrain:in-progress')) {
+                skipped.push({ issue, reason: 'active_session_or_in_progress' });
+                continue;
+            }
+            if (/sess_[a-z0-9]+/.test(issue.body)) {
+                skipped.push({ issue, reason: 'active_session_or_in_progress' });
+                continue;
+            }
+            const idempotencyStatus = await (0, github_queue_poller_js_1.checkIdempotency)(issue.number, sessionsDir);
+            if (idempotencyStatus === 'active') {
+                skipped.push({ issue, reason: 'active_session' });
+                continue;
+            }
+            const maturity = (0, github_queue_poller_js_1.inferMaturity)(issue.body);
+            candidates.push({ issue, maturity });
+        }
+        const MATURITY_RANK = { ready: 0, specced: 1, idea: 2 };
+        candidates.sort((a, b) => {
+            const rankDiff = (MATURITY_RANK[a.maturity] ?? 2) - (MATURITY_RANK[b.maturity] ?? 2);
+            return rankDiff !== 0 ? rankDiff : a.issue.number - b.issue.number;
+        });
+        for (const { issue, reason } of skipped) {
+            console.log(`[QueuePoll] skipped #${issue.number} "${issue.title}" reason=${reason}`);
+            await appendQueuePollLog({ event: 'task_skipped', issueNumber: issue.number, title: issue.title, reason, ts: new Date().toISOString() });
+        }
+        if (candidates.length === 0) {
+            console.log('[QueuePoll] No actionable issues found in this poll cycle.');
+            await appendQueuePollLog({ event: 'poll_cycle_complete', selected: 0, skipped: skipped.length, elapsed: Date.now() - cycleStart, ts: new Date().toISOString() });
+            return;
+        }
+        const top = candidates[0];
+        const upstreamSpecUrl = extractUpstreamSpecUrl(top.issue.body);
+        const taskCandidate = {
+            issueNumber: top.issue.number,
+            title: top.issue.title,
+            body: top.issue.body,
+            url: top.issue.url,
+            inferredMaturity: top.maturity,
+            ...(upstreamSpecUrl !== undefined ? { upstreamSpecUrl } : {}),
+            queueConfigType: queueConfig.type,
+        };
+        const workflowTrigger = {
+            workflowId: trigger.workflowId,
+            goal: top.issue.title,
+            workspacePath: trigger.workspacePath,
+            context: { taskCandidate },
+            ...(trigger.referenceUrls !== undefined ? { referenceUrls: trigger.referenceUrls } : {}),
+            ...(trigger.agentConfig !== undefined ? { agentConfig: trigger.agentConfig } : {}),
+            ...(trigger.soulFile !== undefined ? { soulFile: trigger.soulFile } : {}),
+            botIdentity: {
+                name: queueConfig.botName ?? 'worktrain',
+                email: queueConfig.botEmail ?? 'worktrain@users.noreply.github.com',
+            },
+        };
+        const maturityReason = describeMaturityReason(top.maturity);
+        console.log(`[QueuePoll] selected #${top.issue.number} "${top.issue.title}" maturity=${top.maturity} reason="${maturityReason}"`);
+        await appendQueuePollLog({ event: 'task_selected', issueNumber: top.issue.number, title: top.issue.title, maturity: top.maturity, reason: maturityReason, ts: new Date().toISOString() });
+        this.router.dispatch(workflowTrigger);
+        for (let i = 1; i < candidates.length; i++) {
+            const { issue, maturity } = candidates[i];
+            console.log(`[QueuePoll] skipped #${issue.number} "${issue.title}" reason=lower_priority_${maturity}`);
+            await appendQueuePollLog({ event: 'task_skipped', issueNumber: issue.number, title: issue.title, inferredMaturity: maturity, reason: `lower_priority_${maturity}`, ts: new Date().toISOString() });
+        }
+        const elapsed = Date.now() - cycleStart;
+        console.log(`[QueuePoll] cycle complete selected=1 skipped=${skipped.length + candidates.length - 1} elapsed=${elapsed}ms`);
+        await appendQueuePollLog({ event: 'poll_cycle_complete', selected: 1, skipped: skipped.length + candidates.length - 1, elapsed, ts: new Date().toISOString() });
+    }
 }
 exports.PollingScheduler = PollingScheduler;
 function buildGitLabWorkflowTrigger(trigger, mr) {
@@ -232,12 +378,12 @@ function interpolateGoalFromPayload(trigger, payload) {
     return template.replace(/\{\{([^}]+)\}\}/g, (_, token) => resolved.get(token) ?? trigger.goal);
 }
 function extractDotPath(obj, rawPath) {
-    let path = rawPath.trim();
-    if (path.startsWith('$.'))
-        path = path.slice(2);
-    else if (path.startsWith('$'))
-        path = path.slice(1);
-    const segments = path.split('.');
+    let dotPath = rawPath.trim();
+    if (dotPath.startsWith('$.'))
+        dotPath = dotPath.slice(2);
+    else if (dotPath.startsWith('$'))
+        dotPath = dotPath.slice(1);
+    const segments = dotPath.split('.');
     let current = obj;
     for (const segment of segments) {
         if (segment.includes('[') || current === null || typeof current !== 'object') {
@@ -247,3 +393,36 @@ function extractDotPath(obj, rawPath) {
     }
     return current;
 }
+async function countActiveSessions(sessionsDir) {
+    try {
+        const files = await fs.readdir(sessionsDir);
+        return files.filter((f) => f.endsWith('.json')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function appendQueuePollLog(entry) {
+    const logPath = path.join(os.homedir(), '.workrail', 'queue-poll.jsonl');
+    try {
+        await fs.appendFile(logPath, JSON.stringify(entry) + '\n', 'utf8');
+    }
+    catch (e) {
+        console.warn(`[QueuePoll] Failed to write queue-poll.jsonl: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function extractUpstreamSpecUrl(body) {
+    const specLineMatch = /upstream_spec:\s*(https?:\/\/\S+)/i.exec(body);
+    if (specLineMatch?.[1])
+        return specLineMatch[1];
+    const firstPara = body.split(/\n\s*\n/)[0] ?? '';
+    const urlMatch = /(https?:\/\/\S+)/.exec(firstPara);
+    return urlMatch?.[1];
+}
+function describeMaturityReason(maturity) {
+    switch (maturity) {
+        case 'ready': return 'has upstream spec URL';
+        case 'specced': return 'has acceptance criteria or checklist';
+        case 'idea': return 'maturity=idea, no upstream spec';
+    }
+}

package/dist/trigger/trigger-store.js

@@ -41,7 +41,7 @@ const path = __importStar(require("node:path"));
 const fs = __importStar(require("node:fs/promises"));
 const result_js_1 = require("../runtime/result.js");
 const types_js_1 = require("./types.js");
-const SUPPORTED_PROVIDERS = new Set(['generic', 'gitlab_poll', 'github_issues_poll', 'github_prs_poll']);
+const SUPPORTED_PROVIDERS = new Set(['generic', 'gitlab_poll', 'github_issues_poll', 'github_prs_poll', 'github_queue_poll']);
 function unquoteYamlScalar(raw) {
     const s = raw.trim();
     if ((s.startsWith('"') && s.endsWith('"')) ||
@@ -754,10 +754,43 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
             };
         }
     }
+    else if (provider === 'github_queue_poll') {
+        if (!raw.source) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source', triggerId: rawId });
+        }
+        const queueSrc = raw.source;
+        if (!queueSrc.repo?.trim()) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.repo', triggerId: rawId });
+        }
+        if (!queueSrc.token?.trim()) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.token', triggerId: rawId });
+        }
+        const queueTokenResult = resolveSecret(queueSrc.token.trim(), rawId, env);
+        if (queueTokenResult.kind === 'err')
+            return queueTokenResult;
+        let queuePollIntervalSeconds = 300;
+        if (queueSrc.pollIntervalSeconds?.trim()) {
+            const asNumber = Number(queueSrc.pollIntervalSeconds.trim());
+            if (!Number.isInteger(asNumber) || asNumber <= 0) {
+                return (0, result_js_1.err)({
+                    kind: 'invalid_field_value',
+                    field: `source.pollIntervalSeconds (must be a positive integer, got: ${queueSrc.pollIntervalSeconds})`,
+                    triggerId: rawId,
+                });
+            }
+            queuePollIntervalSeconds = asNumber;
+        }
+        pollingSource = {
+            provider: 'github_queue_poll',
+            repo: queueSrc.repo.trim(),
+            token: queueTokenResult.value,
+            pollIntervalSeconds: queuePollIntervalSeconds,
+        };
+    }
     else if (raw.source) {
         console.warn(`[TriggerStore] WARNING: trigger '${rawId}' has provider='${provider}' but also ` +
             `defines a source: block. The source: block is only used for polling providers ` +
-            `(gitlab_poll, github_issues_poll, github_prs_poll). It will be ignored for this trigger.`);
+            `(gitlab_poll, github_issues_poll, github_prs_poll, github_queue_poll). It will be ignored for this trigger.`);
     }
     const trigger = {
         id: (0, types_js_1.asTriggerId)(rawId),

package/dist/trigger/types.d.ts

@@ -34,12 +34,28 @@ export interface GitHubPollingSource {
     readonly notLabels: readonly string[];
     readonly labelFilter: readonly string[];
 }
+export interface GitHubQueuePollingSource {
+    readonly repo: string;
+    readonly token: string;
+    readonly pollIntervalSeconds: number;
+}
+export interface TaskCandidate {
+    readonly issueNumber: number;
+    readonly title: string;
+    readonly body: string;
+    readonly url: string;
+    readonly inferredMaturity: 'idea' | 'specced' | 'ready';
+    readonly upstreamSpecUrl?: string;
+    readonly queueConfigType: 'assignee' | 'label' | 'mention' | 'query';
+}
 export type PollingSource = (GitLabPollingSource & {
     readonly provider: 'gitlab_poll';
 }) | (GitHubPollingSource & {
     readonly provider: 'github_issues_poll';
 }) | (GitHubPollingSource & {
     readonly provider: 'github_prs_poll';
+}) | (GitHubQueuePollingSource & {
+    readonly provider: 'github_queue_poll';
 });
 export interface TriggerDefinition {
     readonly id: TriggerId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "3.43.0",
+  "version": "3.44.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {