@boboddy/sdk 0.3.1 → 0.4.2

package/dist/client.js

@@ -1069,7 +1069,7 @@ class StepExecutions extends HeyApiClient {
 class PipelineDefinitions extends HeyApiClient {
   createPipelineDefinition(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-definitions",
+      url: "/api/pipeline-definitions",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -1079,7 +1079,7 @@ class PipelineDefinitions extends HeyApiClient {
   }
   upsertPipelineDefinition(options) {
     return (options.client ?? this.client).put({
-      url: "/api/linear-pipeline-definitions",
+      url: "/api/pipeline-definitions",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -1088,14 +1088,14 @@ class PipelineDefinitions extends HeyApiClient {
     });
   }
   archivePipelineDefinition(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/archive", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-definitions/{pipelineDefinitionId}/archive", ...options });
   }
   unarchivePipelineDefinition(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/unarchive", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-definitions/{pipelineDefinitionId}/unarchive", ...options });
   }
   addPipelineStep(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/steps",
+      url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -1104,11 +1104,11 @@ class PipelineDefinitions extends HeyApiClient {
     });
   }
   removePipelineStep(options) {
-    return (options.client ?? this.client).delete({ url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/steps/{linearPipelineStepDefinitionId}", ...options });
+    return (options.client ?? this.client).delete({ url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}", ...options });
   }
   updatePipelineStep(options) {
     return (options.client ?? this.client).put({
-      url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/steps/{linearPipelineStepDefinitionId}",
+      url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -1118,7 +1118,7 @@ class PipelineDefinitions extends HeyApiClient {
   }
   setPipelineStepAdvancementPolicy(options) {
     return (options.client ?? this.client).put({
-      url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/steps/{linearPipelineStepDefinitionId}/advancement-policy",
+      url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}/advancement-policy",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -1127,20 +1127,20 @@ class PipelineDefinitions extends HeyApiClient {
     });
   }
   getPipelineDefinition(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-definitions/{pipelineDefinitionId}", ...options });
   }
   listPipelineDefinitions(options) {
-    return (options.client ?? this.client).get({ url: "/api/projects/{projectId}/linear-pipeline-definitions", ...options });
+    return (options.client ?? this.client).get({ url: "/api/projects/{projectId}/pipeline-definitions", ...options });
   }
 }
 
 class PipelineExecutions extends HeyApiClient {
   listPipelineExecutions(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions", ...options });
   }
   createPipelineExecution(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-executions",
+      url: "/api/pipeline-executions",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -1149,17 +1149,17 @@ class PipelineExecutions extends HeyApiClient {
     });
   }
   startPipelineExecution(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/start", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-executions/{pipelineExecutionId}/start", ...options });
   }
   queueFirstPipelineStepRun(options) {
-    return (options.client ?? this.client).post({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/step-runs/first", ...options });
+    return (options.client ?? this.client).post({ url: "/api/pipeline-executions/{pipelineExecutionId}/step-runs/first", ...options });
   }
   markPipelineStepRunRunning(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/step-runs/{linearPipelineStepRunId}/running", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-executions/{pipelineExecutionId}/step-runs/{pipelineStepRunId}/running", ...options });
   }
   applyPipelineStepResult(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/step-runs/{linearPipelineStepRunId}/results",
+      url: "/api/pipeline-executions/{pipelineExecutionId}/step-runs/{pipelineStepRunId}/results",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -1169,7 +1169,17 @@ class PipelineExecutions extends HeyApiClient {
   }
   acceptPipelineStepRun(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/step-runs/{linearPipelineStepRunId}/accept",
+      url: "/api/pipeline-executions/{pipelineExecutionId}/step-runs/{pipelineStepRunId}/accept",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  acceptPipelineCohort(options) {
+    return (options.client ?? this.client).post({
+      url: "/api/pipeline-executions/{pipelineExecutionId}/cohorts/{originNodeDefinitionId}/accept",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -1179,7 +1189,7 @@ class PipelineExecutions extends HeyApiClient {
   }
   rerunPipelineExecution(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/rerun",
+      url: "/api/pipeline-executions/{pipelineExecutionId}/rerun",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -1188,19 +1198,32 @@ class PipelineExecutions extends HeyApiClient {
     });
   }
   cancelPipelineExecution(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/cancel", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-executions/{pipelineExecutionId}/cancel", ...options });
+  }
+  cancelPipelineExecutions(options) {
+    return (options.client ?? this.client).put({
+      url: "/api/pipeline-executions/batch/cancel",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
   }
   getPipelineExecution(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/{pipelineExecutionId}", ...options });
+  }
+  getPipelineExecutionRoutedChain(options) {
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/{pipelineExecutionId}/routed-chain", ...options });
   }
   countPipelineExecutionsByPipeline(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions/counts/by-pipeline", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/counts/by-pipeline", ...options });
   }
   listPipelineDefinitionStepRollups(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions/step-rollups/by-definition/{linearPipelineDefinitionId}", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/step-rollups/by-definition/{pipelineDefinitionId}", ...options });
   }
   listPipelineDefinitionStepRuns(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions/step-runs/by-definition/{linearPipelineDefinitionId}", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/step-runs/by-definition/{pipelineDefinitionId}", ...options });
   }
 }
 
@@ -1211,6 +1234,19 @@ class WorkItems extends HeyApiClient {
   getWorkItem(options) {
     return (options.client ?? this.client).get({ url: "/api/work-items/{workItemId}", ...options });
   }
+  editWorkItem(options) {
+    return (options.client ?? this.client).patch({
+      url: "/api/work-items/{workItemId}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  listWorkItemChildren(options) {
+    return (options.client ?? this.client).get({ url: "/api/work-items/{workItemId}/children", ...options });
+  }
   createWorkItem(options) {
     return (options.client ?? this.client).post({
       url: "/api/work-items",
@@ -1261,6 +1297,16 @@ class WorkItems extends HeyApiClient {
       }
     });
   }
+  setWorkItemParent(options) {
+    return (options.client ?? this.client).patch({
+      url: "/api/work-items/{workItemId}/parent",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
 }
 
 class WorkItemComments extends HeyApiClient {
@@ -1302,6 +1348,25 @@ class WorkItemComments extends HeyApiClient {
   }
 }
 
+class WorkItemBlocks extends HeyApiClient {
+  listWorkItemBlocks(options) {
+    return (options.client ?? this.client).get({ url: "/api/work-item-blocks", ...options });
+  }
+  createWorkItemBlock(options) {
+    return (options.client ?? this.client).post({
+      url: "/api/work-item-blocks",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  deleteWorkItemBlock(options) {
+    return (options.client ?? this.client).delete({ url: "/api/work-item-blocks/{blockId}", ...options });
+  }
+}
+
 class ProjectContext extends HeyApiClient {
   listProjectContextEntries(options) {
     return (options.client ?? this.client).get({ url: "/api/projects/{projectId}/context-entries", ...options });
@@ -1510,6 +1575,10 @@ class BoboddyClient extends HeyApiClient {
   get workItemComments() {
     return this._workItemComments ??= new WorkItemComments({ client: this.client });
   }
+  _workItemBlocks;
+  get workItemBlocks() {
+    return this._workItemBlocks ??= new WorkItemBlocks({ client: this.client });
+  }
   _projectContext;
   get projectContext() {
     return this._projectContext ??= new ProjectContext({ client: this.client });
@@ -1670,6 +1739,7 @@ export {
   createBoboddyClient,
   WorkItems,
   WorkItemComments,
+  WorkItemBlocks,
   Username,
   UserNotifications,
   StepExecutions,

package/dist/definitions/advancement-policies/cohort-advancement-policy.d.ts

@@ -0,0 +1,117 @@
+/** Restricted outcome domain for both `advanceEach` and `advanceAll`. */
+export declare const cohortAdvancementEventTypeValues: readonly ["continue", "block"];
+export type CohortAdvancementEventType = (typeof cohortAdvancementEventTypeValues)[number];
+export type StepSignalsListConditionOperator = "equal" | "notEqual" | "lessThan" | "lessThanInclusive" | "greaterThan" | "greaterThanInclusive" | "in" | "notIn" | "contains" | "doesNotContain";
+export type StepSignalsListTransformOp = {
+    op: "pluck";
+    signalKey: string;
+} | {
+    op: "filter";
+    operator: StepSignalsListConditionOperator;
+    value: unknown;
+} | {
+    op: "sortBy";
+    direction: "asc" | "desc";
+} | {
+    op: "unique";
+};
+export type StepSignalsListReducerOp = {
+    op: "count";
+} | {
+    op: "sum";
+} | {
+    op: "avg";
+} | {
+    op: "min";
+} | {
+    op: "max";
+} | {
+    op: "booleanAll";
+} | {
+    op: "booleanAny";
+} | {
+    op: "join";
+    separator: string;
+} | {
+    op: "first";
+} | {
+    op: "last";
+};
+/** Wire-format `ctx.stepSignalsList`-derived value, hoisted onto the `cohortGate` node. */
+export type SerializedStepSignalsListDefinition = {
+    key: string;
+    ops: StepSignalsListTransformOp[];
+    reducer: StepSignalsListReducerOp;
+};
+/**
+ * An inline `ctx.stepSignalsList`-derived token, embedded in a rule's
+ * condition tree at the position a signal key would normally go. At
+ * serialize time, hoisted into the `cohortGate` node's
+ * `stepSignalsListDefinitions` and replaced by its bare `key` — the same
+ * "author inline, hoist, replace with bare key" discipline
+ * `extractInlineComputedSignals` already runs for `Computed.*`.
+ */
+export type InlineStepSignalsListValue<TKey extends string = string> = {
+    readonly _tag: "step_signals_list";
+    readonly key: TKey;
+    readonly ops: StepSignalsListTransformOp[];
+    readonly reducer: StepSignalsListReducerOp;
+};
+/**
+ * A leaf condition, restricted to the cohort's own fact vocabulary: a bare
+ * fact name (`branchOutcomes.total()`/`.count(outcome)`, or a
+ * `ctx.stepSignalsList`-derived key) or an inline `InlineStepSignalsListValue`
+ * token (hoisted at serialize time). `value` may itself be a dynamic
+ * fact-reference (`{ fact: "branchCount" }`) — the same
+ * json-rules-engine-native mechanism `branchOutcomes.every()` compiles to.
+ */
+export type CohortSignalCondition = {
+    readonly _tag: "signal";
+    signal: string | InlineStepSignalsListValue;
+    operator: StepSignalsListConditionOperator;
+    value: unknown;
+};
+export type CohortAllCondition = {
+    readonly _tag: "all";
+    conditions: CohortRuleCondition[];
+};
+export type CohortAnyCondition = {
+    readonly _tag: "any";
+    conditions: CohortRuleCondition[];
+};
+export type CohortRuleCondition = CohortSignalCondition | CohortAllCondition | CohortAnyCondition;
+export type CohortRule = {
+    readonly _tag: "rule";
+    mode: "all" | "any";
+    conditions: CohortRuleCondition[];
+    outcome: CohortAdvancementEventType;
+    outcomeJson?: Record<string, unknown> | null;
+};
+export type SerializedCohortRule = {
+    conditions: Record<string, unknown>;
+    event: {
+        type: CohortAdvancementEventType;
+        params?: Record<string, unknown>;
+    };
+};
+/** Serialized shape expected by core's `CohortAdvancementPolicyDefinition`. */
+export type SerializedCohortAdvancementPolicy = {
+    rules: SerializedCohortRule[];
+    defaultEventType: CohortAdvancementEventType;
+    defaultEventParamsJson: Record<string, unknown> | null;
+};
+export type CohortAdvancementPolicy = {
+    default: CohortAdvancementEventType;
+    defaultParamsJson?: Record<string, unknown> | null;
+    rules?: CohortRule[];
+};
+/** Serializes an authored `CohortAdvancementPolicy` (`advanceEach`/`advanceAll`) to its wire shape. */
+export declare function serializeCohortAdvancementPolicy(policy: CohortAdvancementPolicy | undefined): SerializedCohortAdvancementPolicy;
+/**
+ * Walks a `CohortAdvancementPolicy`'s rules tree, extracts every inline
+ * `ctx.stepSignalsList`-derived token embedded in a `CohortSignalCondition
+ * .signal` position, dedupes by key, and returns the resulting
+ * `stepSignalsListDefinitions` — the `cohortGate` node's counterpart to
+ * `extractInlineComputedSignals`.
+ */
+export declare function extractInlineStepSignalsListDefinitions(policy: CohortAdvancementPolicy | undefined): SerializedStepSignalsListDefinition[];

package/dist/definitions/advancement-policies/cohort-fluent-rules.d.ts

@@ -0,0 +1,126 @@
+import { type CohortAdvancementEventType, type CohortRule, type CohortRuleCondition, type CohortSignalCondition, type StepSignalsListConditionOperator } from "./cohort-advancement-policy";
+declare const LEAF_BRAND: unique symbol;
+declare const GROUP_BRAND: unique symbol;
+/**
+ * A leaf condition + outcome attacher for the cohort scope
+ * (`advanceEach`/`advanceAll`). Built by `signal(key).<op>(value)`,
+ * `stepSignalsList.pluck(...).<reducer>()`, or `branchOutcomes.total()`/
+ * `.count(...)` chained with a comparator. Nestable inside `all()`/`any()`,
+ * or terminable with `.then(outcome)` — restricted to `continue`/`block`
+ * (AC4: no `route`/`complete`, unlike a regular step's `RuleLeaf`).
+ */
+export interface CohortRuleLeaf {
+    readonly [LEAF_BRAND]: CohortSignalCondition;
+    then(outcome: CohortAdvancementEventType, paramsJson?: Record<string, unknown>): CohortRule;
+}
+/** A grouped condition + outcome attacher. Built by `all(...)` or `any(...)`. */
+export interface CohortRuleGroup {
+    readonly [GROUP_BRAND]: {
+        mode: "all" | "any";
+        conditions: CohortRuleCondition[];
+    };
+    then(outcome: CohortAdvancementEventType, paramsJson?: Record<string, unknown>): CohortRule;
+}
+type CohortNestable = CohortRuleLeaf | CohortRuleGroup;
+/**
+ * A comparator-bound reference into the cohort scope's facts — a branch's
+ * own signal (`advanceEach`), a `branchOutcomes.total()`/`.count(outcome)`
+ * aggregate, or a `stepSignalsList` reducer's result (`advanceAll`).
+ * Calling any comparator produces a `CohortRuleLeaf`.
+ */
+export interface CohortSignalRef<TValue = unknown> {
+    eq(value: TValue): CohortRuleLeaf;
+    ne(value: TValue): CohortRuleLeaf;
+    gt(value: number): CohortRuleLeaf;
+    gte(value: number): CohortRuleLeaf;
+    lt(value: number): CohortRuleLeaf;
+    lte(value: number): CohortRuleLeaf;
+    in(values: ReadonlyArray<TValue>): CohortRuleLeaf;
+    notIn(values: ReadonlyArray<TValue>): CohortRuleLeaf;
+    contains(value: unknown): CohortRuleLeaf;
+    doesNotContain(value: unknown): CohortRuleLeaf;
+}
+type SignalValue<TSignalKeys extends string, TSignalTypeMap extends Partial<Record<string, unknown>>, K extends TSignalKeys> = K extends keyof TSignalTypeMap ? TSignalTypeMap[K] : unknown;
+/**
+ * `advanceEach`'s callback context: one fan-out branch's own step result,
+ * evaluated the same way a regular step's `.advance()` evaluates its own
+ * signals (`evaluateBranchAgainstPolicy` — the same shared rules-engine
+ * pass, just restricted to `continue`/`block`). No `route`/`complete`, and
+ * — unlike `.advance()`'s `AdvanceCtx` — no `avg`/`sum`/`min`/`max`/`count`/
+ * `booleanAny`/`booleanAll` computed-signal factories: core's `fanOut` node
+ * config has no `computedSignalDefinitions` field to hoist them onto and
+ * `evaluateBranchAgainstPolicy` never resolves them, so exposing them here
+ * would silently produce dead wire fields. A later ticket can add that
+ * support to core first, then extend this ctx to match.
+ */
+export interface AdvanceEachCtx<TSignalKeys extends string = string, TSignalTypeMap extends Partial<Record<string, unknown>> = Record<string, unknown>> {
+    signal<K extends TSignalKeys>(key: K): CohortSignalRef<SignalValue<TSignalKeys, TSignalTypeMap, K>>;
+    stepSignals: {
+        [K in TSignalKeys]: CohortSignalRef<SignalValue<TSignalKeys, TSignalTypeMap, K>>;
+    };
+    all(...refs: CohortNestable[]): CohortRuleGroup;
+    any(...refs: CohortNestable[]): CohortRuleGroup;
+}
+export interface AdvanceEachResult {
+    default: CohortAdvancementEventType;
+    rules?: CohortRule[];
+}
+export declare function makeAdvanceEachCtx<TSignalKeys extends string, TSignalTypeMap extends Partial<Record<string, unknown>> = Record<string, unknown>>(): AdvanceEachCtx<TSignalKeys, TSignalTypeMap>;
+/** The 4-value branch outcome classification (mirrors core's `branchOutcomeValues`). */
+export declare const branchOutcomeValues: readonly ["continue", "block", "error", "abandoned"];
+export type BranchOutcome = (typeof branchOutcomeValues)[number];
+/**
+ * A `ctx.stepSignalsList`-derived op-list builder: seeded by `.pluck(key)`,
+ * optionally narrowed/reshaped by `.filter()`/`.sortBy()`/`.unique()`, then
+ * finalized by exactly one reducer into a comparator-bound
+ * `CohortSignalRef` — the same "author fluently, hoist to a serializable
+ * definition" shape `Computed.*` uses, but resolved server-side against a
+ * cohort's real per-branch signals (`resolveStepSignalsListValue`) rather
+ * than a single step's own signals.
+ */
+export interface StepSignalsListValueRef {
+    filter(operator: StepSignalsListConditionOperator, value: unknown): StepSignalsListValueRef;
+    sortBy(direction?: "asc" | "desc"): StepSignalsListValueRef;
+    unique(): StepSignalsListValueRef;
+    count(): CohortSignalRef;
+    sum(): CohortSignalRef;
+    avg(): CohortSignalRef;
+    min(): CohortSignalRef;
+    max(): CohortSignalRef;
+    booleanAll(): CohortSignalRef;
+    booleanAny(): CohortSignalRef;
+    join(separator?: string): CohortSignalRef;
+    first(): CohortSignalRef;
+    last(): CohortSignalRef;
+}
+/**
+ * `advanceAll`'s callback context: the whole cohort's aggregate branch
+ * outcomes (`branchOutcomes`) and any per-branch signal aggregation
+ * (`stepSignalsList`) — evaluated exactly once per cohort
+ * (`evaluateCohortAgainstPolicy`). Restricted to `continue`/`block`, no
+ * `stepSignals`/`route` (this is a whole-cohort decision, not one step's
+ * own).
+ */
+export interface AdvanceAllCtx {
+    branchOutcomes: {
+        /** The cohort's total branch count. Compiles to fact `branchCount`. */
+        total(): CohortSignalRef<number>;
+        /** A single outcome's count across the cohort. Compiles to fact `${outcome}Count`. */
+        count(outcome: BranchOutcome): CohortSignalRef<number>;
+        /** True iff every branch resolved to this outcome. */
+        every(outcome: BranchOutcome): CohortRuleLeaf;
+        /** True iff at least one branch resolved to this outcome. */
+        some(outcome: BranchOutcome): CohortRuleLeaf;
+    };
+    stepSignalsList: {
+        pluck(signalKey: string): StepSignalsListValueRef;
+    };
+    all(...refs: CohortNestable[]): CohortRuleGroup;
+    any(...refs: CohortNestable[]): CohortRuleGroup;
+}
+export interface AdvanceAllResult {
+    default: CohortAdvancementEventType;
+    rules?: CohortRule[];
+}
+export declare function makeAdvanceAllCtx(): AdvanceAllCtx;
+export {};

package/dist/definitions/advancement-policies/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./define-advancement-policy";
 export * from "./fluent-rules";
+export * from "./cohort-advancement-policy";
+export * from "./cohort-fluent-rules";