@opencode/client 0.0.0-dev-19626 → 0.0.0-dev-19628

package/dist/effect/api/api.d.ts

@@ -2523,40 +2523,31 @@ export interface ReferenceApi<E = never> {
     readonly list: ReferenceListOperation<E>;
 }
 export type WorktreeListInput = {
-    readonly location?: {
-        readonly directory?: string | undefined;
-    } | undefined;
+    readonly projectID: Project.ID;
 };
 export type WorktreeListOutput = Worktree.List;
-export type WorktreeListOperation<E = never> = (input?: WorktreeListInput) => Effect.Effect<WorktreeListOutput, E>;
+export type WorktreeListOperation<E = never> = (input: WorktreeListInput) => Effect.Effect<WorktreeListOutput, E>;
 export type WorktreeCreateInput = {
-    readonly location?: {
-        readonly directory?: string | undefined;
-    } | undefined;
-    readonly strategy?: Worktree.StrategyID | undefined;
+    readonly projectID: Project.ID;
     readonly from?: AbsolutePath | undefined;
     readonly branch?: string | undefined;
     readonly directory?: AbsolutePath | undefined;
     readonly name?: string | undefined;
 };
 export type WorktreeCreateOutput = Worktree.Info;
-export type WorktreeCreateOperation<E = never> = (input?: WorktreeCreateInput) => Effect.Effect<WorktreeCreateOutput, E>;
+export type WorktreeCreateOperation<E = never> = (input: WorktreeCreateInput) => Effect.Effect<WorktreeCreateOutput, E>;
 export type WorktreeRemoveInput = {
-    readonly location?: {
-        readonly directory?: string | undefined;
-    } | undefined;
+    readonly projectID: Project.ID;
     readonly directory: AbsolutePath;
     readonly force: boolean;
 };
 export type WorktreeRemoveOutput = void;
 export type WorktreeRemoveOperation<E = never> = (input: WorktreeRemoveInput) => Effect.Effect<WorktreeRemoveOutput, E>;
 export type WorktreeRefreshInput = {
-    readonly location?: {
-        readonly directory?: string | undefined;
-    } | undefined;
+    readonly projectID: Project.ID;
 };
 export type WorktreeRefreshOutput = void;
-export type WorktreeRefreshOperation<E = never> = (input?: WorktreeRefreshInput) => Effect.Effect<WorktreeRefreshOutput, E>;
+export type WorktreeRefreshOperation<E = never> = (input: WorktreeRefreshInput) => Effect.Effect<WorktreeRefreshOutput, E>;
 export interface WorktreeApi<E = never> {
     readonly list: WorktreeListOperation<E>;
     readonly create: WorktreeCreateOperation<E>;

package/dist/effect/client.d.ts

@@ -2431,13 +2431,13 @@ export declare const make: (options?: {
         list: (input?: import("./api.js").ReferenceListInput) => Effect.Effect<import("./api.js").ReferenceListOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
     };
     worktree: {
-        list: (input?: import("./api.js").WorktreeListInput) => Effect.Effect<readonly {
+        list: (input: import("./api.js").WorktreeListInput) => Effect.Effect<readonly {
             readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
             readonly strategy?: string | undefined;
-        }[], import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
-        create: (input?: import("./api.js").WorktreeCreateInput) => Effect.Effect<import("@opencode/schema/worktree").Info, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
-        remove: (input: import("./api.js").WorktreeRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
-        refresh: (input?: import("./api.js").WorktreeRefreshInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+        }[], import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+        create: (input: import("./api.js").WorktreeCreateInput) => Effect.Effect<import("@opencode/schema/worktree").Info, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+        remove: (input: import("./api.js").WorktreeRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+        refresh: (input: import("./api.js").WorktreeRefreshInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | import("effect/Schema").SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
     };
     vcs: {
         get: (input?: import("./api.js").VcsGetInput) => Effect.Effect<import("./api.js").VcsGetOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;

package/dist/effect/generated/client.d.ts

@@ -2430,13 +2430,13 @@ export declare const make: (options?: {
         list: (input?: ReferenceListInput) => Effect.Effect<ReferenceListOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
     };
     worktree: {
-        list: (input?: WorktreeListInput) => Effect.Effect<readonly {
+        list: (input: WorktreeListInput) => Effect.Effect<readonly {
             readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
             readonly strategy?: string | undefined;
-        }[], import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | HttpClientError.HttpClientError, never>;
-        create: (input?: WorktreeCreateInput) => Effect.Effect<import("@opencode/schema/worktree").Info, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | HttpClientError.HttpClientError, never>;
-        remove: (input: WorktreeRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | HttpClientError.HttpClientError, never>;
-        refresh: (input?: WorktreeRefreshInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | HttpClientError.HttpClientError, never>;
+        }[], import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
+        create: (input: WorktreeCreateInput) => Effect.Effect<import("@opencode/schema/worktree").Info, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | Schema.SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | HttpClientError.HttpClientError, never>;
+        remove: (input: WorktreeRemoveInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | Schema.SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | HttpClientError.HttpClientError, never>;
+        refresh: (input: WorktreeRefreshInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").ProjectNotFoundError | Schema.SchemaError | import("@opencode/protocol/groups/worktree").WorktreeError | ClientError | HttpClientError.HttpClientError, never>;
     };
     vcs: {
         get: (input?: VcsGetInput) => Effect.Effect<VcsGetOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;

package/dist/effect/generated/client.js

@@ -492,22 +492,20 @@ const adaptGroupShell = (raw) => ({
 });
 const EndpointReferenceList = (raw) => (input) => preserveEffect()(raw["reference.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupReference = (raw) => ({ list: EndpointReferenceList(raw) });
-const EndpointWorktreeList = (raw) => (input) => preserveEffect()(raw["worktree.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+const EndpointWorktreeList = (raw) => (input) => preserveEffect()(raw["worktree.list"]({ query: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointWorktreeCreate = (raw) => (input) => preserveEffect()(raw["worktree.create"]({
-    query: { location: input?.["location"] },
     payload: {
-        strategy: input?.["strategy"],
-        from: input?.["from"],
-        branch: input?.["branch"],
-        directory: input?.["directory"],
-        name: input?.["name"],
+        projectID: input["projectID"],
+        from: input["from"],
+        branch: input["branch"],
+        directory: input["directory"],
+        name: input["name"],
     },
 }).pipe(Effect.mapError(mapClientError)));
 const EndpointWorktreeRemove = (raw) => (input) => preserveEffect()(raw["worktree.remove"]({
-    query: { location: input["location"] },
-    payload: { directory: input["directory"], force: input["force"] },
+    payload: { projectID: input["projectID"], directory: input["directory"], force: input["force"] },
 }).pipe(Effect.mapError(mapClientError)));
-const EndpointWorktreeRefresh = (raw) => (input) => preserveEffect()(raw["worktree.refresh"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+const EndpointWorktreeRefresh = (raw) => (input) => preserveEffect()(raw["worktree.refresh"]({ payload: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupWorktree = (raw) => ({
     list: EndpointWorktreeList(raw),
     create: EndpointWorktreeCreate(raw),

package/dist/promise/client.d.ts

@@ -218,10 +218,10 @@ export declare function make(options: ClientOptions): {
         list: (input?: import("./index.js").ReferenceListInput, requestOptions?: OpenCode.RequestOptions) => Promise<import("./index.js").ReferenceListOutput>;
     };
     worktree: {
-        list: (input?: import("./index.js").WorktreeListInput, requestOptions?: OpenCode.RequestOptions) => Promise<import("./index.js").WorktreeList>;
-        create: (input?: import("./index.js").WorktreeCreateInput, requestOptions?: OpenCode.RequestOptions) => Promise<import("./index.js").WorktreeInfo>;
+        list: (input: import("./index.js").WorktreeListInput, requestOptions?: OpenCode.RequestOptions) => Promise<import("./index.js").WorktreeList>;
+        create: (input: import("./index.js").WorktreeCreateInput, requestOptions?: OpenCode.RequestOptions) => Promise<import("./index.js").WorktreeInfo>;
         remove: (input: import("./index.js").WorktreeRemoveInput, requestOptions?: OpenCode.RequestOptions) => Promise<void>;
-        refresh: (input?: import("./index.js").WorktreeRefreshInput, requestOptions?: OpenCode.RequestOptions) => Promise<void>;
+        refresh: (input: import("./index.js").WorktreeRefreshInput, requestOptions?: OpenCode.RequestOptions) => Promise<void>;
     };
     vcs: {
         get: (input?: import("./index.js").VcsGetInput, requestOptions?: OpenCode.RequestOptions) => Promise<import("./index.js").VcsGetOutput>;

package/dist/promise/generated/client.d.ts

@@ -225,10 +225,10 @@ export declare function make(options: ClientOptions): {
         list: (input?: ReferenceListInput, requestOptions?: RequestOptions) => Promise<ReferenceListOutput>;
     };
     worktree: {
-        list: (input?: WorktreeListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").WorktreeList>;
-        create: (input?: WorktreeCreateInput, requestOptions?: RequestOptions) => Promise<import("./types.js").WorktreeInfo>;
+        list: (input: WorktreeListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").WorktreeList>;
+        create: (input: WorktreeCreateInput, requestOptions?: RequestOptions) => Promise<import("./types.js").WorktreeInfo>;
         remove: (input: WorktreeRemoveInput, requestOptions?: RequestOptions) => Promise<void>;
-        refresh: (input?: WorktreeRefreshInput, requestOptions?: RequestOptions) => Promise<void>;
+        refresh: (input: WorktreeRefreshInput, requestOptions?: RequestOptions) => Promise<void>;
     };
     vcs: {
         get: (input?: VcsGetInput, requestOptions?: RequestOptions) => Promise<VcsGetOutput>;

package/dist/promise/generated/client.js

@@ -1204,41 +1204,39 @@ export function make(options) {
             list: (input, requestOptions) => request({
                 method: "GET",
                 path: `/api/worktree`,
-                query: { location: input?.["location"] },
+                query: { projectID: input["projectID"] },
                 successStatus: 200,
-                declaredStatuses: [400, 401],
+                declaredStatuses: [400, 401, 404],
                 empty: false,
             }, requestOptions),
             create: (input, requestOptions) => request({
                 method: "POST",
                 path: `/api/worktree`,
-                query: { location: input?.["location"] },
                 body: {
-                    strategy: input?.["strategy"],
-                    from: input?.["from"],
-                    branch: input?.["branch"],
-                    directory: input?.["directory"],
-                    name: input?.["name"],
+                    projectID: input["projectID"],
+                    from: input["from"],
+                    branch: input["branch"],
+                    directory: input["directory"],
+                    name: input["name"],
                 },
                 successStatus: 200,
-                declaredStatuses: [400, 401],
+                declaredStatuses: [400, 401, 404],
                 empty: false,
             }, requestOptions),
             remove: (input, requestOptions) => request({
                 method: "DELETE",
                 path: `/api/worktree`,
-                query: { location: input["location"] },
-                body: { directory: input["directory"], force: input["force"] },
+                body: { projectID: input["projectID"], directory: input["directory"], force: input["force"] },
                 successStatus: 204,
-                declaredStatuses: [400, 401],
+                declaredStatuses: [400, 401, 404],
                 empty: true,
             }, requestOptions),
             refresh: (input, requestOptions) => request({
                 method: "POST",
                 path: `/api/worktree/refresh`,
-                query: { location: input?.["location"] },
+                body: { projectID: input["projectID"] },
                 successStatus: 204,
-                declaredStatuses: [400, 401],
+                declaredStatuses: [400, 401, 404],
                 empty: true,
             }, requestOptions),
         },

package/dist/promise/generated/types.d.ts

@@ -8141,49 +8141,42 @@ export type ReferenceListOutput = {
     data: Array<ReferenceInfo>;
 };
 export type WorktreeListInput = {
-    readonly location?: {
-        readonly location?: {
-            readonly directory?: string | undefined;
-        } | undefined;
-    }["location"];
+    readonly projectID: {
+        readonly projectID: string;
+    }["projectID"];
 };
 export type WorktreeListOutput = WorktreeList;
 export type WorktreeCreateInput = {
-    readonly location?: {
-        readonly location?: {
-            readonly directory?: string | undefined;
-        } | undefined;
-    }["location"];
-    readonly strategy?: {
-        readonly strategy?: string;
+    readonly projectID: {
+        readonly projectID: string;
         readonly from?: string;
         readonly branch?: string;
         readonly directory?: string;
         readonly name?: string;
-    }["strategy"];
+    }["projectID"];
     readonly from?: {
-        readonly strategy?: string;
+        readonly projectID: string;
         readonly from?: string;
         readonly branch?: string;
         readonly directory?: string;
         readonly name?: string;
     }["from"];
     readonly branch?: {
-        readonly strategy?: string;
+        readonly projectID: string;
         readonly from?: string;
         readonly branch?: string;
         readonly directory?: string;
         readonly name?: string;
     }["branch"];
     readonly directory?: {
-        readonly strategy?: string;
+        readonly projectID: string;
         readonly from?: string;
         readonly branch?: string;
         readonly directory?: string;
         readonly name?: string;
     }["directory"];
     readonly name?: {
-        readonly strategy?: string;
+        readonly projectID: string;
         readonly from?: string;
         readonly branch?: string;
         readonly directory?: string;
@@ -8192,27 +8185,27 @@ export type WorktreeCreateInput = {
 };
 export type WorktreeCreateOutput = WorktreeInfo;
 export type WorktreeRemoveInput = {
-    readonly location?: {
-        readonly location?: {
-            readonly directory?: string | undefined;
-        } | undefined;
-    }["location"];
+    readonly projectID: {
+        readonly projectID: string;
+        readonly directory: string;
+        readonly force: boolean;
+    }["projectID"];
     readonly directory: {
+        readonly projectID: string;
         readonly directory: string;
         readonly force: boolean;
     }["directory"];
     readonly force: {
+        readonly projectID: string;
         readonly directory: string;
         readonly force: boolean;
     }["force"];
 };
 export type WorktreeRemoveOutput = void;
 export type WorktreeRefreshInput = {
-    readonly location?: {
-        readonly location?: {
-            readonly directory?: string | undefined;
-        } | undefined;
-    }["location"];
+    readonly projectID: {
+        readonly projectID: string;
+    }["projectID"];
 };
 export type WorktreeRefreshOutput = void;
 export type VcsGetInput = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/client",
-  "version": "0.0.0-dev-19626",
+  "version": "0.0.0-dev-19628",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -57,8 +57,8 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode/schema": "0.0.0-dev-19626",
-    "@opencode/protocol": "0.0.0-dev-19626"
+    "@opencode/schema": "0.0.0-dev-19628",
+    "@opencode/protocol": "0.0.0-dev-19628"
   },
   "peerDependencies": {
     "effect": "4.0.0-rc.112",
@@ -74,7 +74,7 @@
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/httpapi-codegen": "0.0.0-dev-19626",
+    "@opencode/httpapi-codegen": "0.0.0-dev-19628",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",