@boboddy/sdk 0.0.16-alpha → 0.1.1-alpha

package/dist/definitions/pipelines/index.js

@@ -0,0 +1,183 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/definitions/advancement-policies/define-advancement-policy.ts
+function signal(signal2, operator, value) {
+  return { _tag: "signal", signal: signal2, operator, value };
+}
+function all(conditions, outcome) {
+  if (outcome === undefined) {
+    return { _tag: "all", conditions };
+  }
+  return { _tag: "rule", mode: "all", conditions, outcome };
+}
+function any(conditions, outcome) {
+  if (outcome === undefined) {
+    return { _tag: "any", conditions };
+  }
+  return { _tag: "rule", mode: "any", conditions, outcome };
+}
+function when(signal2, operator, value, outcome) {
+  return {
+    _tag: "rule",
+    mode: "all",
+    conditions: [{ _tag: "signal", signal: signal2, operator, value }],
+    outcome
+  };
+}
+var Rule = { signal, all, any, when };
+function resolveOutcome(outcome) {
+  if (typeof outcome === "string") {
+    return { type: outcome, params: null };
+  }
+  return { type: outcome.outcome, params: outcome.outcomeJson ?? null };
+}
+function serializeCondition(condition) {
+  if (condition._tag === "signal") {
+    return {
+      fact: condition.signal,
+      operator: condition.operator,
+      value: condition.value
+    };
+  }
+  if (condition._tag === "all") {
+    return { all: condition.conditions.map(serializeCondition) };
+  }
+  return { any: condition.conditions.map(serializeCondition) };
+}
+function serializeRule(rule) {
+  const resolved = resolveOutcome(rule.outcome);
+  return {
+    conditions: { [rule.mode]: rule.conditions.map(serializeCondition) },
+    event: {
+      type: resolved.type,
+      ...resolved.params ? { params: resolved.params } : {}
+    }
+  };
+}
+function serializeAdvancementPolicy(policy) {
+  if (!policy) {
+    return {
+      rulesJson: { rules: [] },
+      defaultEventType: "continue",
+      defaultEventParamsJson: null,
+      allowedEventTypes: ["continue"]
+    };
+  }
+  const defaultResolved = resolveOutcome(policy.defaultOutcome);
+  const outcomeSet = new Set([defaultResolved.type]);
+  const serializedRules = (policy.rules ?? []).map((rule) => {
+    outcomeSet.add(resolveOutcome(rule.outcome).type);
+    return serializeRule(rule);
+  });
+  return {
+    rulesJson: { rules: serializedRules },
+    defaultEventType: defaultResolved.type,
+    defaultEventParamsJson: defaultResolved.params,
+    allowedEventTypes: [...outcomeSet]
+  };
+}
+
+// src/definitions/pipelines/define-pipeline.ts
+function fromPipelineInput(_schema, path) {
+  return { source: "pipeline_input", path };
+}
+function fromSignal(step, signalKey) {
+  return { source: "step_signal", step, signalKey };
+}
+function stepOutput(step) {
+  return { source: "step_output", step };
+}
+function serializeBinding(binding) {
+  if (binding.source === "pipeline_input") {
+    return { source: "pipeline_input", path: binding.path };
+  }
+  if (binding.source === "step_signal") {
+    return {
+      source: "step_signal",
+      stepKey: binding.step.key,
+      signalKey: binding.signalKey
+    };
+  }
+  return { source: "step_output", stepKey: binding.step.key };
+}
+function definePipeline(config) {
+  const steps = config.steps;
+  return {
+    key: config.key,
+    name: config.name,
+    description: config.description ?? null,
+    version: config.version ?? 1,
+    status: config.status ?? "active",
+    steps: steps.map((stepConfig, index) => ({
+      stepKey: stepConfig.step.key,
+      stepName: stepConfig.step.name,
+      stepDescription: stepConfig.step.description,
+      position: index + 1,
+      inputBindingsJson: Object.fromEntries(Object.entries(stepConfig.input ?? {}).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)])),
+      timeoutSeconds: stepConfig.timeout ?? null,
+      advancementPolicyDefinition: serializeAdvancementPolicy(stepConfig.advancement)
+    }))
+  };
+}
+// 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/{define-step.d.ts → definitions/steps/define-step.d.ts}

@@ -21,10 +21,10 @@ type OpenCodeMcpServers = Record<string, {
     enabled: boolean;
 }>;
 type SignalTypeStr = "string" | "number" | "boolean" | "object" | "array";
-type DotPaths<T, D extends readonly unknown[] = []> = D["length"] extends 4 ? string : unknown extends T ? string : T extends readonly unknown[] ? string : T extends object ? {
+export type DotPaths<T, D extends readonly unknown[] = []> = D["length"] extends 4 ? string : unknown extends T ? string : T extends readonly unknown[] ? string : T extends object ? {
     [K in keyof T & string]: K | (NonNullable<T[K]> extends object ? `${K}.${DotPaths<NonNullable<T[K]>, [...D, unknown]> & string}` : never);
 }[keyof T & string] : string;
-type TypeAtPath<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof NonNullable<T> ? TypeAtPath<NonNullable<NonNullable<T>[K]>, Rest> : unknown : P extends keyof NonNullable<T> ? NonNullable<T>[P] : unknown;
+export type TypeAtPath<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof NonNullable<T> ? TypeAtPath<NonNullable<NonNullable<T>[K]>, Rest> : unknown : P extends keyof NonNullable<T> ? NonNullable<T>[P] : unknown;
 type ToSignalType<T> = string extends T ? SignalTypeStr : [T] extends [string] ? "string" : [T] extends [number] ? "number" : [T] extends [boolean] ? "boolean" : [T] extends [readonly unknown[]] ? "array" : [T] extends [object] ? "object" : SignalTypeStr;
 type SignalSpecInput<TOutput> = {
     [P in DotPaths<TOutput>]: {
@@ -88,5 +88,18 @@ export type StepDefinitionSpec = {
     }>;
     opencodeMcpJson: OpenCodeMcpServers | null;
 };
-export declare function defineStep<TInput extends ZodType = ZodType, TResult extends ZodType = ZodType>(config: DefineStepInput<TInput, TResult>): StepDefinitionSpec;
+export type TypedStepDefinitionSpec<TInput = unknown, TResult = unknown, TSignalKeys extends string = string> = StepDefinitionSpec & {
+    readonly __inputType: TInput;
+    readonly __resultType: TResult;
+    readonly __signalKeys: TSignalKeys;
+};
+type ExtractSignalKey<T> = T extends {
+    key: infer K extends string;
+} ? K : 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"> & {
+    signals?: TSignals;
+}): TypedStepDefinitionSpec<TInput["_output"], TResult["_output"], SignalKeysOf<TSignals>>;
 export {};

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

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