@scarn/sdk 0.0.0-stage → 0.0.0

package/dist/chunk-zpqyjgb4.js

@@ -0,0 +1,49 @@
+// @bun
+import {
+  string,
+  number,
+  int,
+  unknown,
+  array,
+  object,
+  discriminatedUnion,
+  record,
+  _enum,
+  literal,
+  preprocess
+} from "./chunk-dnn39qt4.js";
+
+// src/health-checks.ts
+var healthCheckSeverityValues2 = ["required", "warn"];
+var healthCheckBaseSchema = object({
+  name: string().trim().min(1).optional(),
+  severity: _enum(healthCheckSeverityValues2).default("required"),
+  timeoutSeconds: number().gt(0).max(3600).default(15),
+  serialGroup: string().trim().min(1).optional()
+});
+var toolHealthCheckSchema2 = healthCheckBaseSchema.extend({
+  kind: literal("tool").default("tool"),
+  tool: string().trim().min(1),
+  mcp: string().trim().min(1).optional(),
+  args: record(string(), unknown()).optional()
+}).strict();
+var cliHealthCheckSchema2 = healthCheckBaseSchema.extend({
+  kind: literal("cli"),
+  command: array(string().min(1)).min(1),
+  expectExitCode: int().default(0)
+}).strict();
+function injectDefaultKind(value) {
+  if (typeof value === "object" && value !== null && !("kind" in value)) {
+    return { ...value, kind: "tool" };
+  }
+  return value;
+}
+var healthCheckSchema2 = preprocess(injectDefaultKind, discriminatedUnion("kind", [toolHealthCheckSchema2, cliHealthCheckSchema2]));
+var healthChecksSchema2 = array(healthCheckSchema2);
+var stepToolHealthCheckSchema2 = toolHealthCheckSchema2.omit({ mcp: true }).strict();
+var stepHealthChecksInputSchema2 = array(preprocess(injectDefaultKind, discriminatedUnion("kind", [
+  stepToolHealthCheckSchema2,
+  cliHealthCheckSchema2
+])));
+
+export { healthCheckSeverityValues2, toolHealthCheckSchema2, cliHealthCheckSchema2, healthCheckSchema2, healthChecksSchema2, stepToolHealthCheckSchema2, stepHealthChecksInputSchema2 };

package/dist/client.d.ts

@@ -0,0 +1,4 @@
+import { ScarnClient } from "./generated";
+export * from "./task-plane-client";
+export * from "./generated/";
+export declare function createScarnClient(baseUrl: string): ScarnClient;

package/dist/client.js

@@ -0,0 +1,57 @@
+// @bun
+import {
+  createTaskPlaneClient2,
+  createScarnClient2
+} from "./chunk-tfm5hjzm.js";
+import {
+  Api2,
+  Projects2,
+  StepDefinitions2,
+  Tasks2,
+  TaskRuns2,
+  PipelineDefinitions2,
+  PipelineExecutions2,
+  WorkItems2,
+  Conversations2,
+  WorkItemComments2,
+  WorkItemCommentDrafts2,
+  WorkItemBlocks2,
+  ProjectArtifacts2,
+  UserNotifications2,
+  NotificationRules2,
+  StepDefinitionTemplates2,
+  ProjectIntegrations2,
+  GitHubIntegrations2,
+  ProjectInvites2,
+  Billing2,
+  Username2,
+  Secrets2,
+  ScarnClient2
+} from "./chunk-ynk2bjae.js";
+export {
+  Api2 as Api,
+  Billing2 as Billing,
+  Conversations2 as Conversations,
+  GitHubIntegrations2 as GitHubIntegrations,
+  NotificationRules2 as NotificationRules,
+  PipelineDefinitions2 as PipelineDefinitions,
+  PipelineExecutions2 as PipelineExecutions,
+  ProjectArtifacts2 as ProjectArtifacts,
+  ProjectIntegrations2 as ProjectIntegrations,
+  ProjectInvites2 as ProjectInvites,
+  Projects2 as Projects,
+  ScarnClient2 as ScarnClient,
+  Secrets2 as Secrets,
+  StepDefinitionTemplates2 as StepDefinitionTemplates,
+  StepDefinitions2 as StepDefinitions,
+  TaskRuns2 as TaskRuns,
+  Tasks2 as Tasks,
+  UserNotifications2 as UserNotifications,
+  Username2 as Username,
+  WorkItemBlocks2 as WorkItemBlocks,
+  WorkItemCommentDrafts2 as WorkItemCommentDrafts,
+  WorkItemComments2 as WorkItemComments,
+  WorkItems2 as WorkItems,
+  createScarnClient2 as createScarnClient,
+  createTaskPlaneClient2 as createTaskPlaneClient
+};

package/dist/contracts/artifact-markers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The artifact marker wire format, shared by the SDK (`Artifact.embed` /
+ * `Artifact.link` and definition validation) and core (draft resolution and
+ * rendering):
+ *
+ * - `![caption](artifact:signal/<stepKey>/<signalKey>)` / `[label](...)`
+ *   point at a declared artifact signal and are required.
+ * - `![caption](artifact:<name-or-glob>)` / `[label](...)` point at any file
+ *   under `artifactsDir` and are optional.
+ *
+ * Text inside `[...]` escapes `\`, `[` and `]` with a backslash. A ref with
+ * whitespace or `<`/`>` is wrapped in `<...>`; otherwise `\`, `(` and `)` are
+ * backslash-escaped.
+ */
+export declare const ARTIFACT_MARKER_SCHEME = "artifact:";
+export type ArtifactMarkerKind = "embed" | "link";
+export type ArtifactMarkerRef = {
+    readonly type: "signal";
+    readonly stepKey: string;
+    readonly signalKey: string;
+} | {
+    readonly type: "path";
+    readonly pattern: string;
+};
+/** A marker found in a piece of text. `start`/`end` are string offsets. */
+export type ArtifactMarkerMatch = {
+    readonly kind: ArtifactMarkerKind;
+    /** The caption (embed) or label (link), unescaped. */
+    readonly text: string;
+    /** Everything after `artifact:`, unescaped. */
+    readonly rawRef: string;
+    readonly ref: ArtifactMarkerRef;
+    readonly start: number;
+    readonly end: number;
+};
+/** Splits the part after `artifact:` into a signal or path ref. */
+export declare function parseArtifactMarkerRef(rawRef: string): ArtifactMarkerRef;
+export declare function formatArtifactMarkerRef(ref: ArtifactMarkerRef): string;
+/** Builds a marker string. `text` is the caption (embed) or label (link). */
+export declare function buildArtifactMarker(kind: ArtifactMarkerKind, ref: ArtifactMarkerRef, text: string): string;
+/** Every artifact marker in `text`, in order. Other links are ignored. */
+export declare function findArtifactMarkers(text: string): ArtifactMarkerMatch[];

package/dist/contracts/artifact-markers.js

@@ -0,0 +1,15 @@
+// @bun
+import {
+  ARTIFACT_MARKER_SCHEME2,
+  parseArtifactMarkerRef2,
+  formatArtifactMarkerRef2,
+  buildArtifactMarker2,
+  findArtifactMarkers2
+} from "../chunk-631ffb6r.js";
+export {
+  ARTIFACT_MARKER_SCHEME2 as ARTIFACT_MARKER_SCHEME,
+  buildArtifactMarker2 as buildArtifactMarker,
+  findArtifactMarkers2 as findArtifactMarkers,
+  formatArtifactMarkerRef2 as formatArtifactMarkerRef,
+  parseArtifactMarkerRef2 as parseArtifactMarkerRef
+};

package/dist/contracts/artifacts.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Artifact contract shared by the SDK, the opencode plugin, the worker and
+ * core. Everything here works on JSON Schema only (the `x-scarn-artifact`
+ * keyword), never on Zod schemas, so the server can use it without knowing
+ * how a step was authored.
+ */
+import { z } from "zod";
+export declare const artifactKindSchema: z.ZodEnum<{
+    generic: "generic";
+    "playwright-trace": "playwright-trace";
+    video: "video";
+    image: "image";
+}>;
+export type ArtifactKind = z.infer<typeof artifactKindSchema>;
+export declare const ARTIFACT_SCHEMA_KEYWORD = "x-scarn-artifact";
+export type ArtifactSchemaKeyword = {
+    readonly accept: readonly string[];
+};
+/** A JSON Schema node. `true` / `false` are the boolean schema forms. */
+export type ArtifactJsonSchemaNode = boolean | {
+    readonly [key: string]: unknown;
+};
+/** A declared artifact field in a step's result schema. */
+export type ArtifactField = {
+    /**
+     * Dot path of the field. Array items appear as `[]`, e.g. `shots[]` or
+     * `runs[].video`.
+     */
+    readonly path: string;
+    /** Lower-case extensions with a leading dot. Empty accepts any file. */
+    readonly accept: readonly string[];
+    readonly nullable: boolean;
+    readonly description: string | null;
+    /** True when the field sits inside an array, which v1 does not support. */
+    readonly inArray: boolean;
+};
+export declare const artifactPlatforms: readonly ["github", "jira", "bitbucket"];
+export type ArtifactPlatform = (typeof artifactPlatforms)[number];
+/**
+ * Extensions each platform can show inline in a comment. Anything else is
+ * linked to its Scarn artifact page. GitHub and Bitbucket link everything
+ * in v1.
+ */
+export declare const EMBEDDABLE_ARTIFACT_EXTENSIONS: Readonly<Record<ArtifactPlatform, readonly string[]>>;
+export declare function isEmbeddableArtifactExtension(platform: ArtifactPlatform, extension: string): boolean;
+/** The lower-cased extension of a file name, with its dot; `""` when none. */
+export declare function artifactFileExtension(fileName: string): string;
+/** Whether a file name matches an `accept` list. An empty list accepts any file. */
+export declare function artifactAcceptsFile(accept: readonly string[], fileName: string): boolean;
+/** Reads the `x-scarn-artifact` keyword on this exact node. */
+export declare function readArtifactKeyword(node: ArtifactJsonSchemaNode): ArtifactSchemaKeyword | null;
+export type ArtifactNodeMatch = ArtifactSchemaKeyword & {
+    readonly nullable: boolean;
+    readonly description: string | null;
+};
+/**
+ * Matches a node that is an artifact field, either directly or as
+ * `anyOf: [<artifact>, { type: "null" }]` (Zod's `.nullable()`).
+ */
+export declare function matchArtifactNode(node: ArtifactJsonSchemaNode): ArtifactNodeMatch | null;
+/**
+ * Every artifact field declared in a result schema: walks object
+ * properties, `anyOf` / `oneOf` / `allOf` branches, local `$ref`s and array
+ * items. Fields inside arrays are returned with `inArray: true`; v1 rejects
+ * them at definition time.
+ */
+export declare function findArtifactFields(schema: ArtifactJsonSchemaNode | null | undefined): ArtifactField[];

package/dist/contracts/artifacts.js

@@ -0,0 +1,25 @@
+// @bun
+import {
+  artifactKindSchema2,
+  ARTIFACT_SCHEMA_KEYWORD2,
+  artifactPlatforms2,
+  EMBEDDABLE_ARTIFACT_EXTENSIONS2,
+  isEmbeddableArtifactExtension2,
+  artifactFileExtension2,
+  artifactAcceptsFile2,
+  readArtifactKeyword2,
+  matchArtifactNode2,
+  findArtifactFields2
+} from "../chunk-56e4kp0a.js";
+export {
+  ARTIFACT_SCHEMA_KEYWORD2 as ARTIFACT_SCHEMA_KEYWORD,
+  EMBEDDABLE_ARTIFACT_EXTENSIONS2 as EMBEDDABLE_ARTIFACT_EXTENSIONS,
+  artifactAcceptsFile2 as artifactAcceptsFile,
+  artifactFileExtension2 as artifactFileExtension,
+  artifactKindSchema2 as artifactKindSchema,
+  artifactPlatforms2 as artifactPlatforms,
+  findArtifactFields2 as findArtifactFields,
+  isEmbeddableArtifactExtension2 as isEmbeddableArtifactExtension,
+  matchArtifactNode2 as matchArtifactNode,
+  readArtifactKeyword2 as readArtifactKeyword
+};

package/dist/contracts/pipeline-document/built-ins.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Built-in error names and the schemas of built-in values: wait results,
+ * the input a `reply` wait takes, and caught errors.
+ */
+import type { JsonSchema } from "./json";
+export declare const BUILT_IN_ERRORS: readonly ["Scarn.All", "Scarn.StepFailed", "Scarn.HealthCheckFailed", "Scarn.Timeout", "Scarn.HeartbeatTimeout", "Scarn.MaxRunsExceeded", "Scarn.MaxTurnsExceeded", "Scarn.ConditionError", "Scarn.ArgsError"];
+/** The errors a wait node can raise, so the only names its `catch` may use. */
+export declare const WAIT_ERRORS: readonly ["Scarn.All", "Scarn.MaxRunsExceeded", "Scarn.ArgsError"];
+/**
+ * The result of a `wait` node with `for: decision`: the chosen action's key
+ * and the person's text. With no actions (an invalid node) `action` is any
+ * string, so only the missing actions are reported.
+ */
+export declare function decisionResultSchema(actions: readonly {
+    key: string;
+}[]): JsonSchema;
+/** The result of a `wait` node with `for: reply`; `replied: false` is "continue without reply". */
+export declare const REPLY_RESULT_SCHEMA: JsonSchema;
+/** The result of a conversation step (a step with no result schema): the conversation and the agent's last message. */
+export declare const CONVERSATION_RESULT_SCHEMA: JsonSchema;
+/** What every transition into a `reply` wait must pass. */
+export declare const REPLY_INPUT_SCHEMA: JsonSchema;
+export declare const ERROR_SCHEMA: JsonSchema;

package/dist/contracts/pipeline-document/conditions/operators.d.ts

@@ -0,0 +1,8 @@
+/** Condition operator and computed-function names, shared by schema, evaluator and validator. */
+export declare const COMPARISON_OPERATORS: readonly ["equal", "notEqual", "lessThan", "lessThanInclusive", "greaterThan", "greaterThanInclusive"];
+export declare const CONDITION_OPERATORS: readonly ["equal", "notEqual", "lessThan", "lessThanInclusive", "greaterThan", "greaterThanInclusive", "exists", "isEmpty", "contains", "startsWith", "endsWith", "matches", "before", "after", "some", "every", "none"];
+export declare const COMPUTED_FUNCTIONS: readonly ["sum", "avg", "min", "max", "count"];
+export declare const ORDERING_OPERATORS: Set<string>;
+export declare const STRING_OPERATORS: Set<string>;
+export declare const DATE_OPERATORS: Set<string>;
+export declare const LIST_OPERATORS: Set<string>;

package/dist/contracts/pipeline-document/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The pipeline document contract: what a pipeline JSON document is. Logic
+ * that works on documents (validation, evaluation) lives in
+ * `@scarn/shared-core/pipelines`.
+ */
+export * from "./json";
+export * from "./schema";
+export * from "./routes";
+export * from "./conditions/operators";
+export * from "./step-contract";
+export * from "./built-ins";

package/dist/contracts/pipeline-document/index.js

@@ -0,0 +1,97 @@
+// @bun
+import {
+  isJsonObject2,
+  jsonPointer2,
+  deepEqual2,
+  COMPARISON_OPERATORS2,
+  CONDITION_OPERATORS2,
+  COMPUTED_FUNCTIONS2,
+  ORDERING_OPERATORS2,
+  STRING_OPERATORS2,
+  DATE_OPERATORS2,
+  LIST_OPERATORS2,
+  NODE_ID_PATTERN2,
+  ALIAS_PATTERN2,
+  literalSchema2,
+  listSchema2,
+  argValueSchema2,
+  computedSourceSchema2,
+  conditionSchema2,
+  toleratedFailuresSchema2,
+  eachSchema2,
+  routeSchema2,
+  otherwiseSchema2,
+  startSchema2,
+  MATCH_MODES2,
+  nextSchema2,
+  retrySchema2,
+  catchSchema2,
+  stepNodeSchema2,
+  DEFAULT_MAX_TURNS2,
+  DECISION_BODY_MODES2,
+  decisionActionSchema2,
+  waitNodeSchema2,
+  succeedNodeSchema2,
+  failNodeSchema2,
+  nodeSchema2,
+  pipelineDocumentSchema2,
+  pipelineDocumentJsonSchema2,
+  routeEntries2,
+  routeAt2
+} from "../../chunk-4vehh3dq.js";
+import {
+  BUILT_IN_ERRORS2,
+  WAIT_ERRORS2,
+  decisionResultSchema2,
+  REPLY_RESULT_SCHEMA2,
+  CONVERSATION_RESULT_SCHEMA2,
+  REPLY_INPUT_SCHEMA2,
+  ERROR_SCHEMA2
+} from "../../chunk-5mmj03ah.js";
+export {
+  ALIAS_PATTERN2 as ALIAS_PATTERN,
+  BUILT_IN_ERRORS2 as BUILT_IN_ERRORS,
+  COMPARISON_OPERATORS2 as COMPARISON_OPERATORS,
+  COMPUTED_FUNCTIONS2 as COMPUTED_FUNCTIONS,
+  CONDITION_OPERATORS2 as CONDITION_OPERATORS,
+  CONVERSATION_RESULT_SCHEMA2 as CONVERSATION_RESULT_SCHEMA,
+  DATE_OPERATORS2 as DATE_OPERATORS,
+  DECISION_BODY_MODES2 as DECISION_BODY_MODES,
+  DEFAULT_MAX_TURNS2 as DEFAULT_MAX_TURNS,
+  ERROR_SCHEMA2 as ERROR_SCHEMA,
+  LIST_OPERATORS2 as LIST_OPERATORS,
+  MATCH_MODES2 as MATCH_MODES,
+  NODE_ID_PATTERN2 as NODE_ID_PATTERN,
+  ORDERING_OPERATORS2 as ORDERING_OPERATORS,
+  REPLY_INPUT_SCHEMA2 as REPLY_INPUT_SCHEMA,
+  REPLY_RESULT_SCHEMA2 as REPLY_RESULT_SCHEMA,
+  STRING_OPERATORS2 as STRING_OPERATORS,
+  WAIT_ERRORS2 as WAIT_ERRORS,
+  argValueSchema2 as argValueSchema,
+  catchSchema2 as catchSchema,
+  computedSourceSchema2 as computedSourceSchema,
+  conditionSchema2 as conditionSchema,
+  decisionActionSchema2 as decisionActionSchema,
+  decisionResultSchema2 as decisionResultSchema,
+  deepEqual2 as deepEqual,
+  eachSchema2 as eachSchema,
+  failNodeSchema2 as failNodeSchema,
+  isJsonObject2 as isJsonObject,
+  jsonPointer2 as jsonPointer,
+  listSchema2 as listSchema,
+  literalSchema2 as literalSchema,
+  nextSchema2 as nextSchema,
+  nodeSchema2 as nodeSchema,
+  otherwiseSchema2 as otherwiseSchema,
+  pipelineDocumentJsonSchema2 as pipelineDocumentJsonSchema,
+  pipelineDocumentSchema2 as pipelineDocumentSchema,
+  retrySchema2 as retrySchema,
+  routeAt2 as routeAt,
+  routeEntries2 as routeEntries,
+  routeSchema2 as routeSchema,
+  startSchema2 as startSchema,
+  stepNodeSchema2 as stepNodeSchema,
+  succeedNodeSchema2 as succeedNodeSchema,
+  toleratedFailuresSchema2 as toleratedFailuresSchema,
+  waitNodeSchema2 as waitNodeSchema
+};

package/dist/contracts/pipeline-document/json.d.ts

@@ -0,0 +1,35 @@
+/**
+ * JSON value and JSON Schema types shared across the package, plus small
+ * helpers for JSON pointers and structural equality.
+ */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export interface JsonSchemaObject {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: JsonSchema;
+    items?: JsonSchema;
+    prefixItems?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    enum?: JsonValue[];
+    const?: JsonValue;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    definitions?: Record<string, JsonSchema>;
+    title?: string;
+    description?: string;
+    format?: string;
+    [key: string]: unknown;
+}
+export type JsonSchema = boolean | JsonSchemaObject;
+export declare function isJsonObject(value: JsonValue | undefined): value is JsonObject;
+/** Builds an RFC 6901 JSON pointer such as `/nodes/fix/next/routes/1/args/plan`. */
+export declare function jsonPointer(segments: readonly (string | number)[]): string;
+export declare function deepEqual(left: JsonValue | undefined, right: JsonValue | undefined): boolean;

package/dist/contracts/pipeline-document/routes.d.ts

@@ -0,0 +1,16 @@
+/** Reading the routes of a node's `next` object. */
+import type { Next, Otherwise, Route } from "./schema";
+export type RouteKind = "route" | "otherwise";
+/** One entry of a `next` object: a route, or the `otherwise` route. */
+export interface RouteEntry {
+    kind: RouteKind;
+    /** The route's index in `routes`, or 0 for `otherwise`. */
+    index: number;
+    route: Route | Otherwise;
+    /** Where the entry sits inside the `next` object. */
+    pointer: ["routes", number] | ["otherwise"];
+}
+/** Every route of `next` in order, with `otherwise` last. */
+export declare function routeEntries(next: Next | undefined): RouteEntry[];
+/** The route a `kind` and `index` name, if `next` has it. */
+export declare function routeAt(next: Next | undefined, kind: RouteKind, index: number): Route | Otherwise | undefined;