@boboddy/sdk 0.1.0-alpha → 0.1.2-alpha

package/dist/definitions/pipelines/index.d.ts

@@ -1 +1,2 @@
 export * from "./define-pipeline";
+export * from "./pipeline-definitions-client";

package/dist/definitions/pipelines/index.js

@@ -132,10 +132,52 @@ function definePipeline(config) {
     }))
   };
 }
+// src/definitions/pipelines/pipeline-definitions-client.ts
+function createPipelineDefinitionsClient(baseUrl) {
+  const base = baseUrl.replace(/\/$/, "");
+  async function doFetch(path, method, headers, body) {
+    const requestHeaders = { ...headers };
+    if (body !== undefined) {
+      requestHeaders["Content-Type"] = "application/json";
+    }
+    const response = await fetch(`${base}${path}`, {
+      method,
+      headers: requestHeaders,
+      ...body !== undefined ? { body: JSON.stringify(body) } : {}
+    });
+    if (!response.ok) {
+      const err = await response.json().catch(() => null);
+      throw new Error(err?.title ?? `HTTP ${String(response.status)} ${method} ${path}`);
+    }
+    return response.json().catch(() => null);
+  }
+  return buildPipelineDefinitionsClient(base, doFetch);
+}
+var buildPipelineDefinitionsClient = (_base, doFetch) => ({
+  listByProjectId: async (projectId, options) => {
+    const path = `/api/linear-pipeline-definitions?projectId=${encodeURIComponent(projectId)}`;
+    const result = await doFetch(path, "GET", options?.headers ?? {});
+    return result ?? [];
+  },
+  create: async (body, options) => {
+    const result = await doFetch("/api/linear-pipeline-definitions", "POST", options?.headers ?? {}, body);
+    return result;
+  },
+  update: async (pipelineId, body, options) => {
+    await doFetch(`/api/linear-pipeline-definitions/${pipelineId}`, "PUT", options?.headers ?? {}, body);
+  },
+  addStep: async (pipelineId, body, options) => {
+    await doFetch(`/api/linear-pipeline-definitions/${pipelineId}/steps`, "POST", options?.headers ?? {}, body);
+  },
+  removeStep: async (pipelineId, stepId, options) => {
+    await doFetch(`/api/linear-pipeline-definitions/${pipelineId}/steps/${stepId}`, "DELETE", options?.headers ?? {});
+  }
+});
 export {
   stepOutput,
   fromSignal,
   fromPipelineInput,
   definePipeline,
+  createPipelineDefinitionsClient,
   Rule
 };

package/dist/definitions/pipelines/pipeline-definitions-client.d.ts

@@ -0,0 +1,56 @@
+import type { SerializedAdvancementPolicy } from "../advancement-policies/define-advancement-policy";
+type RequestOptions = {
+    headers?: Record<string, unknown>;
+};
+export type PipelineStepCreateInput = {
+    stepDefinitionId: string;
+    stepDefinitionVersion: number;
+    key: string;
+    name: string;
+    description: string | null;
+    position: number;
+    inputBindingsJson: Record<string, unknown>;
+    timeoutSeconds: number | null;
+    retryPolicyJson: null;
+    advancementPolicyDefinition: SerializedAdvancementPolicy;
+};
+export type CreatePipelineInput = {
+    projectId: string;
+    key: string;
+    name: string;
+    description: string | null;
+    version: number;
+    status: "draft" | "active" | "archived";
+    stepDefinitions: PipelineStepCreateInput[];
+};
+export type UpdatePipelineInput = {
+    projectId: string;
+    key: string;
+    name: string;
+    description: string | null;
+    version: number;
+    status: "draft" | "active" | "archived";
+};
+export type ExistingPipelineStep = {
+    id: string;
+    key: string;
+};
+export type ExistingPipeline = {
+    id: string;
+    key: string;
+    version: number;
+    status: string;
+    steps: ExistingPipelineStep[];
+};
+export declare function createPipelineDefinitionsClient(baseUrl: string): ReturnType<typeof buildPipelineDefinitionsClient>;
+declare const buildPipelineDefinitionsClient: (_base: string, doFetch: (path: string, method: string, headers: Record<string, string>, body?: unknown) => Promise<unknown>) => {
+    listByProjectId: (projectId: string, options?: RequestOptions) => Promise<ExistingPipeline[]>;
+    create: (body: CreatePipelineInput, options?: RequestOptions) => Promise<{
+        id: string;
+        key: string;
+    }>;
+    update: (pipelineId: string, body: UpdatePipelineInput, options?: RequestOptions) => Promise<void>;
+    addStep: (pipelineId: string, body: PipelineStepCreateInput, options?: RequestOptions) => Promise<void>;
+    removeStep: (pipelineId: string, stepId: string, options?: RequestOptions) => Promise<void>;
+};
+export {};

package/dist/definitions/steps/define-step.d.ts

@@ -1,4 +1,5 @@
 import type { ZodType } from "zod";
+import type { AnyStepFeature, FeatureResultExtensions, FeatureSignalKeys } from "./step-features";
 type OpenCodeMcpServers = Record<string, {
     type: "local";
     command: string[];
@@ -59,6 +60,7 @@ export type DefineStepInput<TInput extends ZodType = ZodType, TResult extends Zo
     result?: TResult;
     signals?: SignalSpecInput<TResult["_output"]>[];
     computedSignals?: StepComputedSignalSpec[];
+    features?: AnyStepFeature[];
     mcpServers?: OpenCodeMcpServers | null;
     status?: "draft" | "active";
 };
@@ -99,7 +101,8 @@ type ExtractSignalKey<T> = T extends {
     sourcePath: infer S extends string;
 } ? S : string;
 export type SignalKeysOf<TSignals extends readonly unknown[]> = TSignals extends readonly (infer S)[] ? ExtractSignalKey<S> : string;
-export declare function defineStep<TInput extends ZodType = ZodType, TResult extends ZodType = ZodType, const TSignals extends ReadonlyArray<SignalSpecInput<TResult["_output"]>> = never[]>(config: Omit<DefineStepInput<TInput, TResult>, "signals"> & {
+export declare function defineStep<TInput extends ZodType = ZodType, TResult extends ZodType = ZodType, const TSignals extends ReadonlyArray<SignalSpecInput<TResult["_output"]>> = never[], const TFeatures extends ReadonlyArray<AnyStepFeature> = never[]>(config: Omit<DefineStepInput<TInput, TResult>, "signals" | "features"> & {
     signals?: TSignals;
-}): TypedStepDefinitionSpec<TInput["_output"], TResult["_output"], SignalKeysOf<TSignals>>;
+    features?: TFeatures;
+}): TypedStepDefinitionSpec<TInput["_output"], TResult["_output"] & FeatureResultExtensions<TFeatures>, SignalKeysOf<TSignals> | FeatureSignalKeys<TFeatures>>;
 export {};

package/dist/definitions/steps/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./define-step";
 export * from "./step-definitions-client";
+export * from "./step-features";