@sverka/sdk 0.0.0 → 0.1.1

package/dist/index.d.mts

@@ -0,0 +1,398 @@
+import { AgentStep, AgentToolRef, Artifact, ArtifactDeclaration, CacheDeclaration, ChangedFile, ComponentStep, CompositionError, Condition, ContextRef, CoreError, CredentialDeclaration, DefinitionGraph, DetectedLanguage, DetectedPackageManager, DiscoveryExplanation, Entry, ExecutorSpec, Expression, Expression as Expression$1, Input, InputLiteral, InputValue, LocalSignal, LocalSignalType, MatrixSpec, MonorepoMarker, MonorepoTool, NetworkPolicy, Operation, Operation as Operation$1, OperationKind, OperationOutcome, OperationSpec, OperationSpec as OperationSpec$1, OutputDeclaration, PackageManagerName, Pipeline, PipelineCallStep, Plan, Plan as Plan$1, PlanContext, PlanMetadata, PlanOperation, PlanningError, Project, ProjectContext, ProposedCheck, Reference, RunPlan, Runtime, Runtime as Runtime$1, RuntimeMode, RuntimeResult, ShellStep, StatusCondition, StepDefinition, StepStatus, Workflow, Workflow as Workflow$1, computePlanId, matrix, parallel, pipeline, run, validatePlan, when, workflow } from "@sverka/workflow";
+import { CheckError, CheckErrorCode, CheckOutput, CheckResolver, CheckResolver as CheckResolver$1, DEFAULT_POLICY, FailOnRule, Finding, Finding as Finding$1, FindingSource, Policy, PolicyConfig, PolicyConfig as PolicyConfig$1, PolicyResult, PolicyResult as PolicyResult$1, ResolvedCheck, Severity, Verdict, Verdict as Verdict$1, computeFingerprint, createBaseline, createBuiltinResolver, createPolicy, evaluatePolicy, extractFindings, filterOnlyNew, loadBaseline, normalizeSarif, saveBaseline, updateBaseline } from "@sverka/verification";
+import { OperationOutcome as OperationOutcome$1 } from "@sverka/runtime";
+//#region src/planner/bind.d.ts
+interface BindRunPlanOptions {
+  readonly graph: DefinitionGraph;
+  readonly entryId: string;
+  readonly inputs?: Readonly<Record<string, InputValue>>;
+}
+/**
+ * Bind a Definition Graph's Entry + user inputs into a concrete RunPlan
+ * that the native engine can execute.
+ */
+export declare function bindRunPlan(options: BindRunPlanOptions): RunPlan;
+/**
+ * Compute the transitive closure of reachable steps from the given roots.
+ * A step is reachable if it is connected to a root by following
+ * `dependencies[].producer` edges backward (i.e. the root's prerequisites).
+ * Returns steps in the original graph order, filtered to reachable steps.
+ */
+export declare function computeReachableSteps(steps: readonly StepDefinition[], roots: readonly string[]): readonly StepDefinition[];
+//#endregion
+//#region src/planner/planner.d.ts
+/**
+ * Top-level entry point for discovery and plan synthesis.
+ */
+interface Planner {
+  discover(options: DiscoverOptions): Promise<ProjectContext>;
+  plan(context: ProjectContext): Promise<PlanProposal>;
+  bindRunPlan(options: BindRunPlanOptions): RunPlan;
+}
+export declare function createPlanner(): Planner;
+interface DiscoverOptions {
+  root: string;
+  baseRef?: string;
+  maxDepth?: number;
+  /**
+   * When true and `root` is a subdirectory of the git repository, detection
+   * signals, languages, and package managers are computed from the subtree
+   * under `root` instead of the whole repository. Use for commands whose
+   * generated steps execute with cwd=`root` (e.g. `init --detect`). Git
+   * metadata (commit, dirty, changedFiles) stays repository-wide.
+   */
+  scopeToRoot?: boolean;
+}
+interface PlanProposal {
+  context: ProjectContext;
+  checks: readonly ProposedCheck[];
+  workflowPath: string | null;
+  notes: readonly string[];
+}
+//#endregion
+//#region src/planner/errors.d.ts
+/**
+ * Base error class for the planner package. All discovery failures throw a
+ * `DiscoveryError` with one of the four `DiscoveryErrorCode` values.
+ */
+export declare class DiscoveryError extends Error {
+  readonly code: DiscoveryErrorCode;
+  readonly cause: unknown;
+  constructor(message: string, code: DiscoveryErrorCode, cause?: unknown);
+}
+type DiscoveryErrorCode = "ROOT_NOT_FOUND" | "GIT_UNAVAILABLE" | "GIT_NOT_A_REPO" | "TRAVERSAL_FAILED" | "INVALID_BASE_REF";
+/**
+ * Planner error for Run Plan binding failures. Spec 13 — Error handling.
+ */
+export declare class PlannerError extends Error {
+  readonly code: PlannerErrorCode;
+  readonly cause: unknown;
+  constructor(message: string, code: PlannerErrorCode, cause?: unknown);
+}
+type PlannerErrorCode = "ENTRY_NOT_FOUND" | "ROOT_NOT_FOUND" | "MISSING_INPUT" | "INVALID_INPUT" | "INVALID_GRAPH" | "INVALID_MATRIX";
+//#endregion
+//#region src/planner/matrix.d.ts
+/**
+ * Expand all matrix steps in a step list into concrete step instances.
+ * Non-matrix steps pass through unchanged.
+ *
+ * - Each matrix step becomes N steps, one per combination (cross-product of
+ *   dimensions, minus exclude, plus include).
+ * - Each expanded step gets `matrixValues` (the concrete bindings) and
+ *   `matrix: undefined` (the spec is consumed).
+ * - Expanded step IDs: `<originalId>[key=val,key=val]` (keys sorted alphabetically).
+ * - Dependencies are rewired: a dependency on a matrix step maps to ALL
+ *   expanded instances (all-to-all, no correlation matching in M1).
+ */
+export declare function expandMatrixSteps(steps: readonly StepDefinition[]): readonly StepDefinition[];
+//#endregion
+//#region src/errors.d.ts
+type SdkErrorCode = "INVALID_INTERPOLATION" | "INVALID_IMAGE" | "CONFIG_NOT_FOUND" | "CONFIG_INVALID" | "CONFIG_LOAD_FAILED" | "CONFIG_PATH_ESCAPE" | "EXECUTION_FAILED";
+export declare class SdkError extends Error {
+  readonly cause?: unknown;
+  readonly code: SdkErrorCode;
+  constructor(message: string, code: SdkErrorCode, cause?: unknown);
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * A type-safe workflow definition for `sverka.config.ts`.
+ */
+interface WorkflowDefinition {
+  /** Workflow name. */
+  name: string;
+  /** The workflow graph. Accepts a Workflow or a bare Operation (wrapped automatically). */
+  workflow: Workflow$1 | Operation$1;
+  /** Optional policy configuration. Defaults to DEFAULT_POLICY. */
+  policy?: PolicyConfig$1;
+}
+/** Options for Sverka plan and execute operations. */
+interface SverkaOptions {
+  /** Root directory. Defaults to process.cwd(). */
+  root?: string;
+  /** Path to sverka.config.ts. Defaults to findConfig(root). */
+  configPath?: string;
+  /** Executor backend. Defaults to "host". */
+  executor?: "host" | "docker";
+  /** Path to baseline file for only-new filtering. */
+  baselinePath?: string;
+  /** Only report findings not in the baseline. Default false. */
+  onlyNew?: boolean;
+  /** Git base ref for changed-file discovery (e.g. "main", "HEAD~1"). */
+  baseRef?: string;
+  /** Optional custom check resolver. Defaults to the built-in resolver. */
+  resolver?: CheckResolver$1;
+}
+/** The Sverka instance returned by createSverka. */
+interface Sverka {
+  plan(options?: SverkaOptions): Promise<PlanResult>;
+  toPlan(options?: SverkaOptions): Promise<Plan$1>;
+  execute(options?: SverkaOptions): Promise<ExecutionResult>;
+}
+/** Result of plan mode. */
+interface PlanResult {
+  /** Discovered project context. */
+  context: ProjectContext;
+  /** Resolved operations from the workflow graph (empty if auto-discovery). */
+  operations: readonly OperationSpec$1[];
+  /** Planner proposal (null if a user config was loaded). */
+  proposal: PlanProposal | null;
+  /** Canonical Plan IR built from the resolved operations. */
+  plan: Plan$1;
+}
+/** Result of execute mode. */
+interface ExecutionResult {
+  /** Findings (empty until check providers exist — wave 11). */
+  findings: readonly Finding$1[];
+  /** Policy evaluation result. */
+  policyResult: PolicyResult$1;
+  /** Final verdict. */
+  verdict: Verdict$1;
+  /** Scheduler execution status. */
+  status: "success" | "failure" | "partial";
+  /**
+   * True when at least one operation failed due to an executor-level runtime
+   * fault (e.g., a binary could not be spawned). Distinguishes runtime errors
+   * from policy/command failures.
+   */
+  runtimeFailure?: boolean;
+  /** Per-operation outcomes (runtime's OperationOutcome with fromCache). */
+  outcomes: ReadonlyMap<string, OperationOutcome$1>;
+  /** Total execution time in ms. */
+  durationMs: number;
+}
+//#endregion
+//#region src/compat/config.d.ts
+/**
+ * Search upward from `root` for sverka.config.ts (then .js). Returns the
+ * path or null. Searches up to 5 parent directories.
+ */
+export declare function findConfig(root: string): Promise<string | null>;
+/**
+ * Dynamically import a sverka.config.ts file and return its default
+ * export as a WorkflowDefinition. Validates the shape.
+ *
+ * Under Bun, .ts files import natively. Under Node, use the .js fallback
+ * (findConfig searches .ts first, then .js).
+ */
+export declare function loadWorkflow(configPath: string, root?: string): Promise<WorkflowDefinition>;
+//#endregion
+//#region src/sverka.d.ts
+/**
+ * Create a Sverka instance with default options pre-applied. Per-call
+ * options override defaults.
+ */
+export declare function createSverka(defaultOptions?: SverkaOptions): Sverka;
+/** Top-level plan convenience function. */
+export declare function plan(options?: SverkaOptions): Promise<PlanResult>;
+/** Top-level toPlan convenience function. Returns the canonical Plan IR. */
+export declare function toPlan(options?: SverkaOptions): Promise<Plan$1>;
+/** Top-level execute convenience function. */
+export declare function execute(options?: SverkaOptions): Promise<ExecutionResult>;
+//#endregion
+//#region src/compat/helpers.d.ts
+/** Name an operation. Sugar for `op.named(name)`. */
+export declare function task(name: string, op: Operation$1): Operation$1;
+/** Type-safe helper for sverka.config.ts. Identity function. */
+export declare function defineWorkflow(definition: WorkflowDefinition): WorkflowDefinition;
+//#endregion
+//#region src/dollar.d.ts
+interface StepBuilder {
+  outputs(outputs: Readonly<Record<string, OutputDeclaration>>): StepBuilder;
+  inputs(inputs: readonly Reference[]): StepBuilder;
+  dependsOn(steps: readonly string[]): StepBuilder;
+  runtime(runtime: Runtime$1): StepBuilder;
+  timeout(ms: number): StepBuilder;
+  condition(ref: Condition): StepBuilder;
+  matrix(spec: MatrixSpec): StepBuilder;
+  interruptible(value?: boolean): StepBuilder;
+  compensate(command: string): StepBuilder;
+  build(pipeline: Pipeline, id: string): ShellStep;
+}
+/**
+ * Create a shell command step builder from a tagged template.
+ * References interpolated in the template are collected and added to the
+ * step's inputs automatically.
+ */
+export declare function $(strings: TemplateStringsArray, ...values: readonly (string | Reference)[]): StepBuilder;
+//#endregion
+//#region src/shell.d.ts
+/**
+ * ShellProxy — callable tagged template + property access (command prefix)
+ * + callable with interpreter string (shell selector).
+ *
+ * - `shell.git`push origin`` → command "git push origin"
+ * - `shell("bash").git`push`` → command "git push" + runtime.shell="bash"
+ * - `shell("pwsh")`Write-Host hi`` → command "Write-Host hi" + runtime.shell="pwsh"
+ */
+interface ShellProxy {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): StepBuilder;
+  (interpreter: string): ShellProxy;
+  readonly git: ShellProxy;
+  readonly npm: ShellProxy;
+  readonly npx: ShellProxy;
+  readonly bun: ShellProxy;
+  readonly pnpm: ShellProxy;
+  readonly yarn: ShellProxy;
+  readonly docker: ShellProxy;
+  readonly make: ShellProxy;
+  readonly cargo: ShellProxy;
+  readonly go: ShellProxy;
+  readonly python: ShellProxy;
+  readonly pip: ShellProxy;
+  readonly [key: string]: ShellProxy;
+}
+/**
+ * Shell proxy export. Provides command-prefix and shell-selector DX.
+ *
+ * @example
+ * const { git, npm, bun, make, docker } = shell;
+ * git`push origin main`.build(p, "push")  // → "git push origin main"
+ * bun`run build`.build(p, "build")        // → "bun run build"
+ *
+ * @example
+ * const bash = shell("bash");
+ * bash.git`push`.build(p, "push")         // → "git push" + runtime.shell="bash"
+ * shell("pwsh")`Write-Host hello`.build(p, "greet")  // → "Write-Host hello" + runtime.shell="pwsh"
+ */
+export declare const shell: ShellProxy;
+//#endregion
+//#region src/artifact.d.ts
+/** Create an artifact output declaration with the given path. */
+export declare function artifact(path: string): OutputDeclaration;
+//#endregion
+//#region src/pipeline.d.ts
+interface PipelineConfig {
+  inputs?: Readonly<Record<string, Input>>;
+  steps?: ReadonlyArray<(pipeline: Pipeline) => void>;
+  entries?: ReadonlyArray<(pipeline: Pipeline) => Entry>;
+}
+/** Create a Pipeline, run step functions, then entry functions. */
+declare function pipeline$1(project: Project, id: string, config: PipelineConfig): Pipeline;
+//#endregion
+//#region src/call-pipeline.d.ts
+interface CallPipelineBuilder {
+  outputs(outputs: Readonly<Record<string, OutputDeclaration>>): CallPipelineBuilder;
+  dependsOn(steps: readonly string[]): CallPipelineBuilder;
+  runtime(runtime: Runtime$1): CallPipelineBuilder;
+  timeout(ms: number): CallPipelineBuilder;
+  condition(ref: Reference): CallPipelineBuilder;
+  interruptible(value: boolean): CallPipelineBuilder;
+  build(pipeline: Pipeline, id: string): PipelineCallStep;
+}
+/**
+ * Create a pipeline-call step builder.
+ * @param callee The callee pipeline id (within the same Project).
+ * @param callInputs Bound inputs for the callee pipeline.
+ */
+export declare function callPipeline(callee: string, callInputs?: Readonly<Record<string, Reference | InputLiteral>>): CallPipelineBuilder;
+//#endregion
+//#region src/component.d.ts
+interface ComponentBuilder {
+  outputs(outputs: Readonly<Record<string, OutputDeclaration>>): ComponentBuilder;
+  dependsOn(steps: readonly string[]): ComponentBuilder;
+  runtime(runtime: Runtime$1): ComponentBuilder;
+  timeout(ms: number): ComponentBuilder;
+  condition(ref: Reference): ComponentBuilder;
+  interruptible(value: boolean): ComponentBuilder;
+  build(pipeline: Pipeline, id: string): ComponentStep;
+}
+/**
+ * Create a component step builder.
+ * @param name The component name (e.g. "deploy").
+ * @param version The component version (e.g. "1.0.0").
+ * @param inputs Bound inputs for the component.
+ */
+export declare function component(name: string, version: string, inputs?: Readonly<Record<string, Reference | InputLiteral>>): ComponentBuilder;
+//#endregion
+//#region src/when.d.ts
+/** Mark a reference, expression, or status condition as a step condition. Returns it unchanged. */
+declare function when$1(cond: Condition): Condition;
+//#endregion
+//#region src/expr.d.ts
+/**
+ * Create a symbolic expression from a tagged template.
+ * Context references produce `${namespace.field}` placeholders while step
+ * references produce `${step.output}` placeholders; both are collected into
+ * `refs` for dependency inference.
+ * String, number, and boolean values are inlined into the template.
+ */
+export declare function expr(strings: TemplateStringsArray, ...values: readonly (string | number | boolean | Reference)[]): Expression$1;
+//#endregion
+//#region src/status.d.ts
+/**
+ * Create a status-based condition.
+ * @example
+ * sh`notify-slack`.condition(status("failure"))
+ */
+export declare function status(s: StepStatus): StatusCondition;
+//#endregion
+//#region src/images.d.ts
+interface ImageRef {
+  readonly ref: string;
+}
+/** Create an ImageRef from a raw OCI reference string. */
+export declare function image(ref: string): ImageRef;
+export declare const images: {
+  node: Record<string, ImageRef> & {
+    readonly [version: number]: ImageRef;
+    readonly latest: ImageRef;
+  };
+  ubuntu: Record<string, ImageRef> & {
+    readonly latest: ImageRef;
+  };
+};
+//#endregion
+//#region src/context.d.ts
+/** Environment variable references: env.CI_TRACE, env.MY_VAR. */
+export declare const env: Record<string, ContextRef>;
+/** Secret references: secrets.NPM_TOKEN. */
+export declare const secrets: Record<string, ContextRef>;
+/** Git metadata references: git.sha, git.branch, git.tag. */
+export declare const git: {
+  sha: ContextRef;
+  branch: ContextRef;
+  tag: ContextRef;
+};
+/** Change request metadata: change.id, change.source, change.target, change.draft. */
+export declare const change: {
+  id: ContextRef;
+  source: ContextRef;
+  target: ContextRef;
+  draft: ContextRef;
+};
+/** Event metadata: event.type. */
+export declare const event: {
+  type: ContextRef;
+};
+/** Run metadata: run.id, run.attempt. */
+declare const run$1: {
+  id: ContextRef;
+  attempt: ContextRef;
+};
+/** Pipeline input references: inputs.environment. */
+export declare const inputs: Record<string, ContextRef>;
+/** Matrix variable references: matrix.node, matrix.os. */
+declare const matrix$1: Record<string, ContextRef>;
+//#endregion
+//#region src/agent.d.ts
+interface AgentStepBuilder {
+  outputs(outputs: Readonly<Record<string, OutputDeclaration>>): AgentStepBuilder;
+  inputs(inputs: readonly Reference[]): AgentStepBuilder;
+  dependsOn(steps: readonly string[]): AgentStepBuilder;
+  tools(...tools: readonly AgentToolRef[]): AgentStepBuilder;
+  engine(engine: string): AgentStepBuilder;
+  model(model: string): AgentStepBuilder;
+  maxTokens(n: number): AgentStepBuilder;
+  build(pipeline: Pipeline, id: string): AgentStep;
+}
+/**
+ * Create an AI agent step builder from a tagged template.
+ * `agent\`Build and test\`` creates a builder with `engine: "default"`.
+ * References interpolated in the template are collected and added to the
+ * step's inputs automatically (same as `$`).
+ */
+export declare function agent(strings: TemplateStringsArray, ...values: readonly (string | Reference)[]): AgentStepBuilder;
+//#endregion
+export { type AgentStepBuilder, type Artifact, type ArtifactDeclaration, type BindRunPlanOptions, type CacheDeclaration, type CallPipelineBuilder, type ChangedFile, CheckError, type CheckErrorCode, type CheckOutput, type CheckResolver, type ComponentBuilder, CompositionError, CoreError, type CredentialDeclaration, DEFAULT_POLICY, type DetectedLanguage, type DetectedPackageManager, type DiscoverOptions, type DiscoveryErrorCode, type DiscoveryExplanation, type ExecutionResult, type ExecutorSpec, type Expression, type FailOnRule, type Finding, type FindingSource, type ImageRef, type LocalSignal, type LocalSignalType, type MonorepoMarker, type NetworkPolicy, type Operation, type OperationKind, type OperationOutcome, type OperationSpec, type PipelineConfig, type Plan, type PlanContext, type PlanMetadata, type PlanOperation, type PlanProposal, type PlanResult, type Planner, type PlannerErrorCode, PlanningError, type Policy, type PolicyConfig, type PolicyResult, type ProjectContext, type ProposedCheck, type ResolvedCheck, type Runtime, type RuntimeMode, type RuntimeResult, type SdkErrorCode, type Severity, type ShellProxy, type StepBuilder, type Sverka, type SverkaOptions, type Verdict, type Workflow, type WorkflowDefinition, computeFingerprint, computePlanId, createBaseline, createBuiltinResolver, createPolicy, evaluatePolicy, extractFindings, filterOnlyNew, loadBaseline, matrix, matrix$1 as matrixContext, normalizeSarif, parallel, pipeline, pipeline$1 as pipelineV0, run, run$1 as runContext, saveBaseline, updateBaseline, validatePlan, when, when$1 as whenV0, workflow };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/planner/bind.ts","../src/planner/planner.ts","../src/planner/errors.ts","../src/planner/matrix.ts","../src/errors.ts","../src/types.ts","../src/compat/config.ts","../src/sverka.ts","../src/compat/helpers.ts","../src/dollar.ts","../src/shell.ts","../src/artifact.ts","../src/pipeline.ts","../src/call-pipeline.ts","../src/component.ts","../src/when.ts","../src/expr.ts","../src/status.ts","../src/images.ts","../src/context.ts","../src/agent.ts"],"mappings":"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"}