@kilocode/protocol 0.0.0-stage → 0.0.0-v2-9

package/dist/groups/websearch.js

@@ -0,0 +1,34 @@
+import { Location } from "@opencode/schema/location";
+import { WebSearch } from "@opencode/schema/websearch";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
+import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const WebSearchGroup = HttpApiGroup.make("server.websearch")
+    .add(HttpApiEndpoint.get("websearch.providers", "/api/websearch/provider", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(WebSearch.Provider)),
+    error: ServiceUnavailableError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "websearch.providers",
+    summary: "List web search providers",
+    description: "Return the registered web search providers.",
+})))
+    .add(HttpApiEndpoint.post("websearch.query", "/api/websearch", {
+    query: LocationQuery,
+    payload: Schema.Struct(WebSearch.Input.fields),
+    success: Location.response(WebSearch.Response),
+    error: [InvalidRequestError, ServiceUnavailableError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "websearch.query",
+    summary: "Search the web",
+    description: "Run one web search through the selected provider. Specify a provider to override the configured default.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "websearch",
+    description: "Location-scoped web search routes.",
+}));

package/dist/groups/worktree.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
+import { ProjectNotFoundError } from "../errors.js";
+declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.TaggedStruct<"WorktreeError", {
+    readonly name: Schema.Literal<"WorktreeError">;
+    readonly data: Schema.Struct<{
+        readonly message: Schema.String;
+        readonly forceRequired: Schema.optional<Schema.Boolean>;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorktreeError extends WorktreeError_base {
+}
+export declare const WorktreeGroup: HttpApiGroup.HttpApiGroup<"server.worktree", HttpApiEndpoint.HttpApiEndpoint<"worktree.create", "POST", "/api/worktree", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly from: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Trim>>, Schema.optionalKey<Schema.Trim>, never, never>;
+    readonly directory: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.list", "GET", "/api/worktree", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>>>, Schema.toCodecJson<typeof ProjectNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.refresh", "POST", "/api/worktree/refresh", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.remove", "DELETE", "/api/worktree", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly force: Schema.Boolean;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never>, false>;
+export {};

package/dist/groups/worktree.js

@@ -0,0 +1,52 @@
+import { Worktree } from "@opencode/schema/worktree";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import { Project } from "@opencode/schema/project";
+import { ProjectNotFoundError } from "../errors.js";
+const root = "/api/worktree";
+export class WorktreeError extends Schema.TaggedError()("WorktreeError", {
+    name: Schema.Literal("WorktreeError"),
+    data: Schema.Struct({
+        message: Schema.String,
+        forceRequired: Schema.optional(Schema.Boolean),
+    }),
+}, { httpApiStatus: 400 }) {
+}
+export const WorktreeGroup = HttpApiGroup.make("server.worktree")
+    .add(HttpApiEndpoint.get("worktree.list", root, {
+    query: Schema.Struct({ projectID: Project.ID }),
+    success: Worktree.List,
+    error: ProjectNotFoundError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "worktree.list",
+    summary: "List worktrees",
+    description: "Return the project's saved worktree inventory without loading configuration or running discovery.",
+})))
+    .add(HttpApiEndpoint.post("worktree.create", root, {
+    payload: Worktree.CreateInput,
+    success: Worktree.Info,
+    error: [WorktreeError, ProjectNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "worktree.create",
+    summary: "Create worktree",
+    description: "Load the project's canonical configuration, create a local worktree using its selected strategy, then run the project's setup script.",
+})))
+    .add(HttpApiEndpoint.delete("worktree.remove", root, {
+    payload: Worktree.RemoveInput,
+    success: HttpApiSchema.NoContent,
+    error: [WorktreeError, ProjectNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "worktree.remove",
+    summary: "Remove worktree",
+    description: "Load the project's canonical configuration and remove a saved worktree using its recorded strategy.",
+})))
+    .add(HttpApiEndpoint.post("worktree.refresh", `${root}/refresh`, {
+    payload: Schema.Struct({ projectID: Project.ID }),
+    success: HttpApiSchema.NoContent,
+    error: [WorktreeError, ProjectNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "worktree.refresh",
+    summary: "Refresh worktrees",
+    description: "Load the project's canonical configuration, discover worktrees across known checkout roots using all available strategies, and reconcile saved state.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "worktree", description: "Project-based worktree management routes." }));

package/dist/middleware/authorization.d.ts

@@ -0,0 +1,13 @@
+import { HttpApiMiddleware } from "effect/http-api";
+import { UnauthorizedError } from "../errors.js";
+declare const Authorization_base: HttpApiMiddleware.ServiceClass<Authorization, "@opencode/HttpApiAuthorization", {
+    requires: never;
+    provides: never;
+    error: typeof UnauthorizedError;
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<never, typeof UnauthorizedError, never>>;
+export declare class Authorization extends Authorization_base {
+}
+export {};

package/dist/middleware/authorization.js

@@ -0,0 +1,6 @@
+import { HttpApiMiddleware } from "effect/http-api";
+import { UnauthorizedError } from "../errors.js";
+export class Authorization extends HttpApiMiddleware.Service()("@opencode/HttpApiAuthorization", {
+    error: UnauthorizedError,
+}) {
+}

package/dist/middleware/schema-error.d.ts

@@ -0,0 +1,13 @@
+import { HttpApiMiddleware } from "effect/http-api";
+import { InvalidRequestError } from "../errors.js";
+declare const SchemaErrorMiddleware_base: HttpApiMiddleware.ServiceClass<SchemaErrorMiddleware, "@opencode/HttpApiSchemaError", {
+    requires: never;
+    provides: never;
+    error: typeof InvalidRequestError;
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<never, typeof InvalidRequestError, never>>;
+export declare class SchemaErrorMiddleware extends SchemaErrorMiddleware_base {
+}
+export {};

package/dist/middleware/schema-error.js

@@ -0,0 +1,4 @@
+import { HttpApiMiddleware } from "effect/http-api";
+import { InvalidRequestError } from "../errors.js";
+export class SchemaErrorMiddleware extends HttpApiMiddleware.Service()("@opencode/HttpApiSchemaError", { error: InvalidRequestError }) {
+}