ocpipe 0.1.0

package/index.ts

@@ -0,0 +1,127 @@
+/**
+ * DSTS: Declarative Self-Improving TypeScript
+ *
+ * A DSPy-inspired SDK for building LLM workflow pipelines with OpenCode.
+ *
+ * @example
+ * ```typescript
+ * import { signature, field, SignatureModule, Pipeline } from './dsts/index.js'
+ * import { z } from 'zod'
+ *
+ * // Define a signature
+ * const ParseIntent = signature({
+ *   doc: 'Parse user intent from description',
+ *   inputs: {
+ *     description: field.string('User description'),
+ *   },
+ *   outputs: {
+ *     intent: field.string('Parsed intent'),
+ *     confidence: field.number('Confidence score'),
+ *   },
+ * })
+ *
+ * // Create a module (types inferred from signature)
+ * class IntentParser extends SignatureModule<typeof ParseIntent> {
+ *   constructor() {
+ *     super(ParseIntent)
+ *   }
+ *
+ *   async forward(input, ctx) {
+ *     const result = await this.predictor.execute(input, ctx)
+ *     return result.data
+ *   }
+ * }
+ *
+ * // Run in a pipeline
+ * const pipeline = new Pipeline({
+ *   name: 'my-workflow',
+ *   defaultModel: { providerID: 'anthropic', modelID: 'claude-sonnet-4-5' },
+ *   defaultAgent: 'general',
+ *   checkpointDir: './ckpt',
+ *   logDir: './logs',
+ * }, createBaseState)
+ *
+ * const result = await pipeline.run(new IntentParser(), { description: 'Hello world' })
+ * ```
+ */
+
+// Signature definition
+export { signature, field, buildOutputSchema } from './signature.js'
+
+// Predict class
+export { Predict } from './predict.js'
+export type { PredictConfig } from './predict.js'
+
+// Module base class
+export { Module, SignatureModule } from './module.js'
+
+// Pipeline orchestrator
+export { Pipeline } from './pipeline.js'
+
+// State management
+export { createSessionId, createBaseState, extendBaseState } from './state.js'
+
+// Agent integration
+export { runAgent, logStep } from './agent.js'
+
+// Response parsing
+export {
+  parseResponse,
+  parseJson,
+  parseJsonFromResponse,
+  tryParseResponse,
+  tryParseJson,
+  extractJsonString,
+  // jq-style patches
+  buildPatchPrompt,
+  buildBatchPatchPrompt,
+  extractPatch,
+  applyJqPatch,
+  // JSON Patch (RFC 6902)
+  buildJsonPatchPrompt,
+  buildBatchJsonPatchPrompt,
+  extractJsonPatch,
+  applyJsonPatch,
+  zodTypeToString,
+  JsonParseError,
+  ValidationError,
+  SchemaValidationError,
+} from './parsing.js'
+export type { JsonPatchOperation } from './parsing.js'
+
+// Testing utilities
+export {
+  MockAgentBackend,
+  createMockContext,
+  generateMockOutputs,
+} from './testing.js'
+export type { MockResponse } from './testing.js'
+
+// Types
+export type {
+  // Core types
+  ModelConfig,
+  ExecutionContext,
+  StepResult,
+  StepRecord,
+  SubPipelineRecord,
+  BaseState,
+  PredictResult,
+  // Signature types
+  FieldConfig,
+  SignatureDef,
+  InferInputs,
+  InferOutputs,
+  // Pipeline types
+  RetryConfig,
+  PipelineConfig,
+  RunOptions,
+  // Agent types
+  RunAgentOptions,
+  RunAgentResult,
+  // Correction types
+  CorrectionMethod,
+  CorrectionConfig,
+  FieldError,
+  TryParseResult,
+} from './types.js'

package/module.ts

@@ -0,0 +1,50 @@
+/**
+ * DSTS SDK Module base class.
+ *
+ * Modules encapsulate logical units of work that use one or more Predictors.
+ */
+
+import type {
+  ExecutionContext,
+  InferInputs,
+  InferOutputs,
+  SignatureDef,
+} from './types.js'
+import { Predict, type PredictConfig } from './predict.js'
+
+/** Module is the abstract base class for composable workflow units. */
+export abstract class Module<I, O> {
+  private predictors: Predict<any>[] = []
+
+  /** predict creates and registers a Predict instance for a signature. */
+  protected predict<S extends SignatureDef<any, any>>(
+    sig: S,
+    config?: PredictConfig,
+  ): Predict<S> {
+    const p = new Predict(sig, config)
+    this.predictors.push(p)
+    return p
+  }
+
+  /** forward is the main execution method to be implemented by subclasses. */
+  abstract forward(input: I, ctx: ExecutionContext): Promise<O>
+
+  /** getPredictors returns all registered predictors (for future optimization). */
+  getPredictors(): Predict<any>[] {
+    return this.predictors
+  }
+}
+
+/** SignatureModule is a Module whose types are derived from a Signature. */
+export abstract class SignatureModule<
+  S extends SignatureDef<any, any>,
+> extends Module<InferInputs<S>, InferOutputs<S>> {
+  protected readonly sig: S
+  protected readonly predictor: Predict<S>
+
+  constructor(sig: S, config?: PredictConfig) {
+    super()
+    this.sig = sig
+    this.predictor = this.predict(sig, config)
+  }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "ocpipe",
+  "version": "0.1.0",
+  "description": "Declarative Self-Improving TypeScript - A DSPy-inspired SDK for building LLM workflow pipelines with OpenCode",
+  "type": "module",
+  "main": "index.ts",
+  "types": "index.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/s4wave/dsts"
+  },
+  "homepage": "https://github.com/s4wave/dsts",
+  "bugs": {
+    "url": "https://github.com/s4wave/dsts/issues"
+  },
+  "license": "MIT",
+  "author": "s4wave",
+  "keywords": [
+    "dspy",
+    "llm",
+    "opencode",
+    "typescript",
+    "ai",
+    "workflow",
+    "pipeline",
+    "bun"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "peerDependencies": {
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "files": [
+    "*.ts",
+    "!*.test.ts",
+    "example/"
+  ]
+}