@exaudeus/workrail 3.32.0 → 3.34.0

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']);
+const SUPPORTED_PROVIDERS = new Set(['generic', 'gitlab_poll', 'github_issues_poll', 'github_prs_poll']);
 function unquoteYamlScalar(raw) {
     const s = raw.trim();
     if ((s.startsWith('"') && s.endsWith('"')) ||
@@ -304,6 +304,18 @@ function parseTriggersYaml(content) {
                             case 'projectId':
                                 source.projectId = srcValueResult.value;
                                 break;
+                            case 'repo':
+                                source.repo = srcValueResult.value;
+                                break;
+                            case 'excludeAuthors':
+                                source.excludeAuthors = srcValueResult.value;
+                                break;
+                            case 'notLabels':
+                                source.notLabels = srcValueResult.value;
+                                break;
+                            case 'labelFilter':
+                                source.labelFilter = srcValueResult.value;
+                                break;
                             case 'token':
                                 source.token = srcValueResult.value;
                                 break;
@@ -577,54 +589,123 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
         console.warn(`[TriggerStore] Warning: trigger "${rawId}" has autoOpenPR: true but autoCommit is not true. ` +
             `A PR requires a commit -- delivery will be skipped unless autoCommit is also set to true.`);
     }
+    function parsePollIntervalSeconds(raw2, triggerId2) {
+        const intervalRaw = raw2.pollIntervalSeconds?.trim();
+        if (!intervalRaw)
+            return (0, result_js_1.ok)(60);
+        const asNumber = Number(intervalRaw);
+        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: ${intervalRaw})`,
+                triggerId: triggerId2,
+            });
+        }
+        return (0, result_js_1.ok)(asNumber);
+    }
     let pollingSource;
-    if (provider === 'gitlab_poll') {
+    const isPollingProvider = provider === 'gitlab_poll' ||
+        provider === 'github_issues_poll' ||
+        provider === 'github_prs_poll';
+    if (isPollingProvider) {
         if (!raw.source) {
             return (0, result_js_1.err)({ kind: 'missing_field', field: 'source', triggerId: rawId });
         }
         const src = raw.source;
-        const requiredSourceFields = [
-            'baseUrl', 'projectId', 'token', 'events',
-        ];
-        for (const field of requiredSourceFields) {
-            if (!src[field]?.trim()) {
-                return (0, result_js_1.err)({ kind: 'missing_field', field: `source.${field}`, triggerId: rawId });
-            }
+        if (!src.token?.trim()) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.token', triggerId: rawId });
         }
-        const tokenRaw = src.token.trim();
-        const tokenResult = resolveSecret(tokenRaw, rawId, env);
+        const tokenResult = resolveSecret(src.token.trim(), rawId, env);
         if (tokenResult.kind === 'err')
             return tokenResult;
-        const eventsRaw = src.events.trim();
-        const events = eventsRaw.split(/\s+/).filter(Boolean);
+        if (!src.events?.trim()) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.events', triggerId: rawId });
+        }
+        const events = src.events.trim().split(/\s+/).filter(Boolean);
         if (events.length === 0) {
             return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.events (empty)', triggerId: rawId });
         }
-        const intervalRaw = src.pollIntervalSeconds?.trim();
-        let pollIntervalSeconds = 60;
-        if (intervalRaw) {
-            const asNumber = Number(intervalRaw);
-            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: ${intervalRaw})`,
-                    triggerId: rawId,
-                });
+        const intervalResult = parsePollIntervalSeconds(src, rawId);
+        if (intervalResult.kind === 'err')
+            return intervalResult;
+        const pollIntervalSeconds = intervalResult.value;
+        if (provider === 'gitlab_poll') {
+            if (!src.baseUrl?.trim()) {
+                return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.baseUrl', triggerId: rawId });
+            }
+            if (!src.projectId?.trim()) {
+                return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.projectId', triggerId: rawId });
+            }
+            const KNOWN_MR_EVENT_TYPES = new Set([
+                'merge_request.opened',
+                'merge_request.updated',
+                'merge_request.merged',
+                'merge_request.closed',
+            ]);
+            for (const event of events) {
+                if (!KNOWN_MR_EVENT_TYPES.has(event)) {
+                    console.warn(`[TriggerStore] Unknown polling event type '${event}' for trigger '${rawId}' -- ` +
+                        `will match all open MRs as fallback`);
+                }
+                else if (event === 'merge_request.merged' || event === 'merge_request.closed') {
+                    console.warn(`[TriggerStore] Event type '${event}' for trigger '${rawId}' cannot be observed ` +
+                        `with state=opened polling (GitLab only returns open MRs). ` +
+                        `Use a webhook trigger for merge/close events.`);
+                }
+            }
+            pollingSource = {
+                provider: 'gitlab_poll',
+                baseUrl: src.baseUrl.trim(),
+                projectId: src.projectId.trim(),
+                token: tokenResult.value,
+                events,
+                pollIntervalSeconds,
+            };
+        }
+        else {
+            if (!src.repo?.trim()) {
+                return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.repo', triggerId: rawId });
+            }
+            const KNOWN_GITHUB_ISSUE_EVENTS = new Set(['issues.opened', 'issues.updated']);
+            const KNOWN_GITHUB_PR_EVENTS = new Set(['pull_request.opened', 'pull_request.updated']);
+            const knownEvents = provider === 'github_issues_poll' ? KNOWN_GITHUB_ISSUE_EVENTS : KNOWN_GITHUB_PR_EVENTS;
+            for (const event of events) {
+                if (!knownEvents.has(event)) {
+                    console.warn(`[TriggerStore] Unknown GitHub polling event type '${event}' for trigger '${rawId}' -- ` +
+                        `will match all items as fallback`);
+                }
             }
-            pollIntervalSeconds = asNumber;
+            const excludeAuthors = src.excludeAuthors?.trim()
+                ? src.excludeAuthors.trim().split(/\s+/).filter(Boolean)
+                : [];
+            const notLabels = src.notLabels?.trim()
+                ? src.notLabels.trim().split(/\s+/).filter(Boolean)
+                : [];
+            const labelFilter = src.labelFilter?.trim()
+                ? src.labelFilter.trim().split(/\s+/).filter(Boolean)
+                : [];
+            if (excludeAuthors.length === 0) {
+                console.warn(`[TriggerStore] WARNING: trigger '${rawId}' has provider='${provider}' but ` +
+                    `excludeAuthors is not set. If WorkTrain creates issues/PRs under a bot account, ` +
+                    `omitting excludeAuthors will cause infinite self-review loops. ` +
+                    `Set excludeAuthors to your WorkTrain bot account login (e.g. "worktrain-bot").`);
+            }
+            pollingSource = {
+                provider: provider,
+                repo: src.repo.trim(),
+                token: tokenResult.value,
+                events,
+                pollIntervalSeconds,
+                excludeAuthors,
+                notLabels,
+                labelFilter,
+            };
         }
-        pollingSource = {
-            baseUrl: src.baseUrl.trim(),
-            projectId: src.projectId.trim(),
-            token: tokenResult.value,
-            events,
-            pollIntervalSeconds,
-        };
     }
     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 provider='gitlab_poll'. ` +
-            `It will be ignored for this trigger.`);
+            `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.`);
     }
     const trigger = {
         id: (0, types_js_1.asTriggerId)(rawId),

package/dist/trigger/types.d.ts

@@ -25,6 +25,22 @@ export interface GitLabPollingSource {
     readonly events: readonly string[];
     readonly pollIntervalSeconds: number;
 }
+export interface GitHubPollingSource {
+    readonly repo: string;
+    readonly token: string;
+    readonly events: readonly string[];
+    readonly pollIntervalSeconds: number;
+    readonly excludeAuthors: readonly string[];
+    readonly notLabels: readonly string[];
+    readonly labelFilter: readonly string[];
+}
+export type PollingSource = (GitLabPollingSource & {
+    readonly provider: 'gitlab_poll';
+}) | (GitHubPollingSource & {
+    readonly provider: 'github_issues_poll';
+}) | (GitHubPollingSource & {
+    readonly provider: 'github_prs_poll';
+});
 export interface TriggerDefinition {
     readonly id: TriggerId;
     readonly provider: string;
@@ -49,7 +65,7 @@ export interface TriggerDefinition {
         readonly workflowId?: string;
         readonly goal?: string;
     };
-    readonly pollingSource?: GitLabPollingSource;
+    readonly pollingSource?: PollingSource;
     readonly workspaceName?: WorkspaceName;
     readonly soulFile?: string;
 }

package/dist/v2/durable-core/domain/observation-builder.d.ts

@@ -10,6 +10,9 @@ export interface ObservationEventData {
     } | {
         readonly type: 'sha256';
         readonly value: string;
+    } | {
+        readonly type: 'path';
+        readonly value: string;
     };
     readonly confidence: 'low' | 'med' | 'high';
 }

package/dist/v2/durable-core/domain/observation-builder.js

@@ -34,11 +34,11 @@ function anchorsToObservations(anchors) {
                 });
                 break;
             case 'repo_root':
-                if (anchor.value.length > constants_js_1.MAX_OBSERVATION_SHORT_STRING_LENGTH)
+                if (anchor.value.length > constants_js_1.MAX_OBSERVATION_PATH_LENGTH)
                     break;
                 observations.push({
                     key: 'repo_root',
-                    value: { type: 'short_string', value: anchor.value },
+                    value: { type: 'path', value: anchor.value },
                     confidence: 'high',
                 });
                 break;

package/dist/v2/durable-core/domain/prompt-renderer.d.ts

@@ -1,6 +1,6 @@
 import type { Result } from 'neverthrow';
 import type { Workflow } from '../../../types/workflow.js';
-import type { PromptFragment } from '../../../types/workflow-definition.js';
+import type { AssessmentDefinition, PromptFragment } from '../../../types/workflow-definition.js';
 import type { LoadedSessionTruthV2 } from '../../ports/session-event-log-store.port.js';
 import type { LoopPathFrameV1 } from '../schemas/execution-snapshot/index.js';
 import type { NodeId, RunId } from '../ids/index.js';
@@ -8,6 +8,7 @@ export type PromptRenderError = {
     readonly code: 'RENDER_FAILED';
     readonly message: string;
 };
+export declare function formatAssessmentRequirementsForTest(assessments: readonly Pick<AssessmentDefinition, 'id' | 'purpose' | 'dimensions'>[]): readonly string[];
 export declare function assembleFragmentedPrompt(fragments: readonly PromptFragment[], context: Record<string, unknown>): string;
 export interface StepMetadata {
     readonly stepId: string;

package/dist/v2/durable-core/domain/prompt-renderer.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAssessmentRequirementsForTest = formatAssessmentRequirementsForTest;
 exports.assembleFragmentedPrompt = assembleFragmentedPrompt;
 exports.renderPendingPrompt = renderPendingPrompt;
 const neverthrow_1 = require("neverthrow");
@@ -174,6 +175,9 @@ function formatOutputContractRequirements(outputContract) {
             ];
     }
 }
+function formatAssessmentRequirementsForTest(assessments) {
+    return formatAssessmentRequirements(assessments);
+}
 function formatAssessmentRequirements(assessments) {
     if (assessments.length === 0)
         return [];
@@ -190,6 +194,12 @@ function formatAssessmentRequirements(assessments) {
         for (const dimension of assessment.dimensions) {
             requirements.push(`  ${dimension.id} (${dimension.levels.join(' | ')}): ${dimension.purpose}`);
         }
+        const firstDimension = assessment.dimensions[0];
+        const exampleDimValue = firstDimension ? `"${firstDimension.levels[0] ?? 'high'}"` : '"high"';
+        const exampleDimKey = firstDimension ? `"${firstDimension.id}"` : '"dimensionId"';
+        requirements.push(`Canonical format:\n\`\`\`json\n` +
+            `{ "artifacts": [{ "kind": "wr.assessment", "assessmentId": "${assessment.id}", "dimensions": { ${exampleDimKey}: ${exampleDimValue} } }] }\n` +
+            `\`\`\``);
         requirements.push('Use only canonical dimension levels. If the engine rejects the artifact, correct the submitted levels instead of inventing new ones.');
     }
     return requirements;