effect-cursor-sdk 0.1.1 → 0.2.0

package/README.md

@@ -1,5 +1,7 @@
 # effect-cursor-sdk
 
+![npm](https://img.shields.io/npm/v/effect-cursor-sdk) ![License MIT](https://img.shields.io/github/license/benjamin-kraatz/effect-cursor-sdk) ![CI](https://img.shields.io/github/actions/workflow/status/benjamin-kraatz/effect-cursor-sdk/ci.yml) ![CodeRabbit Pull Request Reviews](https://img.shields.io/coderabbit/prs/github/benjamin-kraatz/effect-cursor-sdk?utm_source=oss&utm_medium=github&utm_campaign=benjamin-kraatz%2Feffect-cursor-sdk&labelColor=171717&color=FF570A&link=https%3A%2F%2Fcoderabbit.ai&label=CodeRabbit+Reviews)
+
 Effect-native access to the new [Cursor SDK](https://cursor.com/docs/sdk/typescript).
 
 `effect-cursor-sdk` wraps `@cursor/sdk` with Effect services, layers, scoped resource management, tagged errors, observability hooks, deterministic mocks, and ready-made runtimes. The upstream SDK remains the source of truth for Cursor-owned types; this package adds Effect ergonomics without creating a parallel model that can drift.
@@ -27,7 +29,7 @@ Effect-native access to the new [Cursor SDK](https://cursor.com/docs/sdk/typescr
 | `Agent.list`, `get`, `listRuns`, `getRun`, messages                              | `CursorInspectionService`                      |
 | `Agent.archive`, `unarchive`, `delete`                                           | `CursorInspectionService`                      |
 | `Cursor.me`, models, repositories                                                | `CursorInspectionService`                      |
-| MCP servers, sub-agents, local/cloud options, model options                      | SDK-owned `AgentOptions` and re-exported types |
+| MCP servers, sub-agents, local/cloud options, model options                      | Defaults via `CursorConfig` / `loadCursorConfig`; merged SDK `AgentOptions` (deprecated at agent entry) |
 | Local run event helpers and platform helpers                                     | Re-exported from `@cursor/sdk`                 |
 
 ## Install
@@ -44,18 +46,44 @@ bun run typecheck
 bun run test
 ```
 
+## Examples
+
+The [`examples`](./examples) directory contains a guided learning path from a
+minimal first script to production-style Effect composition:
+
+| Example | What it demonstrates |
+| --- | --- |
+| [`quickstart`](./examples/quickstart) | First config-first local agent call with `loadCursorConfig`, `agentOptionsFromConfig`, and `collectText`. |
+| [`cli`](./examples/cli) | A small terminal app with `liveRuntime`, offline `makeMockRuntime`, CLI overrides, and tagged error handling. |
+| [`basic-agent-workflow`](./examples/basic-agent-workflow) | Scoped agents, run status listeners, streaming, capability checks, and artifact listing/downloads. |
+| [`advanced-ops-dashboard`](./examples/advanced-ops-dashboard) | Inspection APIs, confirmation-gated lifecycle operations, parallel Effect composition, retries/timeouts, telemetry, redaction, and rich mocks. |
+
+Run all example typechecks from the repo root:
+
+```bash
+bun run examples:typecheck
+```
+
 ## Quick Start
 
+Load environment defaults with `loadCursorConfig`, then create agents with `createFromConfig` (and `scopedFromConfig`, `promptFromConfig`, `resumeFromConfig` as needed). The API key stays in `Redacted` form until the merge step; `AgentOptions.apiKey` remains a plain string at the SDK boundary.
+
 ```ts
-import { CursorAgentService, CursorRunService, liveLayer } from "effect-cursor-sdk";
-import { Effect, Stream } from "effect";
+import {
+  CursorAgentService,
+  CursorRunService,
+  loadCursorConfig,
+  liveLayer,
+} from "effect-cursor-sdk";
+import { Effect } from "effect";
 
 const program = Effect.gen(function* () {
   const agents = yield* CursorAgentService;
   const runs = yield* CursorRunService;
 
-  const agent = yield* agents.create({
-    apiKey: process.env.CURSOR_API_KEY,
+  const config = yield* loadCursorConfig;
+  const agent = yield* agents.createFromConfig(config, {
+    // Override the given config optionally with custom values
     model: { id: "composer-2" },
     local: { cwd: process.cwd() },
   });
@@ -68,56 +96,50 @@ const program = Effect.gen(function* () {
 }).pipe(Effect.provide(liveLayer));
 ```
 
-`AgentOptions.apiKey` is a plain string at the SDK boundary. To keep the key in `Redacted` form until that boundary, read `CURSOR_API_KEY` (and optional `CURSOR_MODEL`, `CURSOR_LOCAL_CWD`) with `loadCursorConfig`, then merge into `AgentOptions` with `agentOptionsFromConfig`.
-In a future version, we might drop the plain `AgentOptions` boundary and require all options to be passed through `CursorConfig` / `loadCursorConfig` / `agentOptionsFromConfig`.
-
 Effect’s default `ConfigProvider` reads `process.env`, so you usually do not need to install a custom provider for this.
 
-### Quick start with `loadCursorConfig`
+If you need full control over the merge into SDK options, you can still call `agentOptionsFromConfig` yourself and pass the result to deprecated `create`; prefer `createFromConfig` in application code.
+
+## Plain `AgentOptions` at the agent boundary (deprecated)
+
+Passing raw `AgentOptions` (for example `apiKey: process.env.CURSOR_API_KEY`) to `create`, `resume`, `prompt`, or `scoped` is **deprecated**. It still works for compatibility, but prefer the config flow above.
 
 ```ts
-import {
-  CursorAgentService,
-  CursorRunService,
-  agentOptionsFromConfig,
-  loadCursorConfig,
-  liveLayer,
-} from "effect-cursor-sdk";
+import { CursorAgentService, CursorRunService, liveLayer } from "effect-cursor-sdk";
 import { Effect } from "effect";
 
-const program = Effect.gen(function* () {
+const legacyProgram = Effect.gen(function* () {
   const agents = yield* CursorAgentService;
   const runs = yield* CursorRunService;
 
-  const config = yield* loadCursorConfig;
-  const agent = yield* agents.create(
-    // Flexible: use the config from the environment, and override with local options.
-    agentOptionsFromConfig(config, {
-      model: { id: "composer-2" },
-      local: { cwd: process.cwd() },
-    }),
-  );
+  const agent = yield* agents.create({
+    apiKey: process.env.CURSOR_API_KEY,
+    model: { id: "composer-2" },
+    local: { cwd: process.cwd() },
+  });
 
   const run = yield* agents.send(agent, "Explain this repository");
   const text = yield* runs.collectText(run);
-
   yield* agents.dispose(agent);
   return text;
 }).pipe(Effect.provide(liveLayer));
 ```
 
+Migrate by replacing `agents.create({ ... })` with `const config = yield* loadCursorConfig` and `agents.createFromConfig(config, { ... })` (or the other `*FromConfig` helpers).
+
 ## Scoped Agents
 
-Prefer `scoped` when an agent should be disposed automatically:
+Prefer `scopedFromConfig` when an agent should be disposed automatically:
 
 ```ts
-import { CursorAgentService, liveLayer } from "effect-cursor-sdk";
+import { CursorAgentService, loadCursorConfig, liveLayer } from "effect-cursor-sdk";
 import { Effect } from "effect";
 
 const program = Effect.scoped(
   Effect.gen(function* () {
     const agents = yield* CursorAgentService;
-    const agent = yield* agents.scoped({
+    const config = yield* loadCursorConfig;
+    const agent = yield* agents.scopedFromConfig(config, {
       model: { id: "composer-2" },
       local: { cwd: process.cwd() },
     });
@@ -129,19 +151,19 @@ const program = Effect.scoped(
 
 ## Cloud Agents
 
-Cloud options are passed through as SDK `AgentOptions`:
+Cloud options are merged as SDK overrides on top of loaded config:
 
 ```ts
-const agent =
-  yield *
-  agents.create({
-    apiKey: process.env.CURSOR_API_KEY,
-    model: { id: "composer-2" },
-    cloud: {
-      repos: [{ url: "https://github.com/your-org/your-repo", startingRef: "main" }],
-      autoCreatePR: true,
-    },
-  });
+const config = yield* loadCursorConfig;
+const agent = yield* agents.createFromConfig(config, {
+  model: { id: "composer-2" },
+  cloud: {
+    repos: [
+      { url: "https://github.com/your-org/your-repo", startingRef: "main" },
+    ],
+    autoCreatePR: true,
+  },
+});
 ```
 
 ## Streaming
@@ -149,18 +171,24 @@ const agent =
 `CursorRunService.streamEvents` preserves SDK event shapes and returns an Effect `Stream`.
 
 ```ts
-const run = yield * agents.send(agent, "Refactor the auth module");
-
-yield *
-  runs
-    .streamEvents(run)
-    .pipe(
-      Stream.runForEach((event) =>
-        event.type === "assistant"
-          ? Effect.sync(() => console.log(event.message.content))
-          : Effect.void,
-      ),
-    );
+import { Effect, Stream } from "effect";
+
+const run = yield* agents.send(agent, "Refactor the auth module");
+
+yield* runs.streamEvents(run).pipe(
+  Stream.runForEach((event) => {
+    if (event.type !== "assistant") {
+      return Effect.void;
+    }
+
+    const text = event.message.content
+      .filter((block) => block.type === "text")
+      .map((block) => block.text)
+      .join("");
+
+    return Effect.sync(() => console.log(text));
+  }),
+);
 ```
 
 ## Inspection And Metadata
@@ -168,13 +196,73 @@ yield *
 Use `CursorInspectionService` for agent/run listings, messages, lifecycle operations, account metadata, model discovery, and connected repositories.
 
 ```ts
-const inspection = yield * CursorInspectionService;
+const inspection = yield* CursorInspectionService;
 
-const agents = yield * inspection.listAgents({ runtime: "cloud", includeArchived: true });
-const models = yield * inspection.listModels();
-const repos = yield * inspection.listRepositories();
+const agents = yield* inspection.listAgents({ runtime: "cloud", includeArchived: true });
+const models = yield* inspection.listModels();
+const repos = yield* inspection.listRepositories();
 ```
 
+## Integrate deeper with Effect
+
+Because every Cursor call is an `Effect`, you compose it like the rest of your program: parallel requests, timeouts, retries, logging, and layers all work the same way.
+
+This agent garden snapshot loads your catalog in parallel, adds a resilient boundary around the batch, logs a safe summary (counts and IDs only — never log API keys), then asks Cursor for a one-shot triage opinion via `promptFromConfig`:
+
+```ts
+import {
+  CursorAgentService,
+  CursorInspectionService,
+  loadCursorConfig,
+  liveLayer,
+} from "effect-cursor-sdk";
+import { Effect, Schedule } from "effect";
+
+const agentGardenSnapshot = Effect.gen(function* () {
+  const inspection = yield* CursorInspectionService;
+  const agents = yield* CursorAgentService;
+  const config = yield* loadCursorConfig;
+
+  const catalog = yield* Effect.all(
+    {
+      cloud: inspection.listAgents({ runtime: "cloud", includeArchived: false }),
+      models: inspection.listModels(),
+      repos: inspection.listRepositories(),
+    },
+    { concurrency: "unbounded" },
+  ).pipe(
+    Effect.retry(
+      Schedule.exponential("150 millis").pipe(Schedule.both(Schedule.recurs(3))),
+    ),
+    Effect.timeout("45 seconds"),
+  );
+
+  yield* Effect.logInfo("Cursor catalog loaded", {
+    cloudAgents: catalog.cloud.items.length,
+    models: catalog.models.length,
+    repos: catalog.repos.length,
+  });
+
+  const triage = yield* agents.promptFromConfig(
+    [
+      "You are helping on-call. Here is non-secret inventory:",
+      `- Cloud agents (ids): ${catalog.cloud.items.map((a) => a.agentId).join(", ") || "(none)"}`,
+      `- Models (ids): ${catalog.models.map((m) => m.id).join(", ") || "(none)"}`,
+      `- Repos (urls): ${catalog.repos.map((r) => r.url).join(", ") || "(none)"}`,
+      "In two short sentences: what should we verify first before trusting automation here?",
+    ].join("\n"),
+    config,
+    {
+      model: { id: "composer-2" },
+    },
+  );
+
+  return triage.result;
+}).pipe(Effect.provide(liveLayer));
+```
+
+Swap `liveLayer` for `mockLayer({ ... })` in tests and the same program shape exercises your orchestration without the network.
+
 ## Errors
 
 SDK failures are mapped into tagged errors such as `CursorAuthenticationError`, `CursorRateLimitError`, `CursorConfigurationError`, `CursorNetworkError`, and `CursorUnsupportedOperationError`. The original SDK error is preserved as `cause`, with safe operation context and retryability where available.
@@ -201,12 +289,13 @@ Never log API keys, MCP credentials, authorization headers, or prompt image data
 Use `mockLayer` for deterministic tests:
 
 ```ts
-import { CursorAgentService, mockLayer } from "effect-cursor-sdk";
+import { CursorAgentService, loadCursorConfig, mockLayer } from "effect-cursor-sdk";
 import { Effect } from "effect";
 
 const testProgram = Effect.gen(function* () {
   const agents = yield* CursorAgentService;
-  const agent = yield* agents.create({ model: { id: "composer-2" } });
+  const config = yield* loadCursorConfig;
+  const agent = yield* agents.createFromConfig(config, { model: { id: "composer-2" } });
   return yield* agents.send(agent, "Hello");
 }).pipe(
   Effect.provide(
@@ -221,7 +310,7 @@ const testProgram = Effect.gen(function* () {
 
 The main exports are:
 
-- `CursorAgentService`
+- `CursorAgentService` (prefer `createFromConfig`, `scopedFromConfig`, `promptFromConfig`, `resumeFromConfig` with `loadCursorConfig`)
 - `CursorRunService`
 - `CursorArtifactService`
 - `CursorInspectionService`