@sleepy-ai/cli 0.1.6 → 0.1.7

package/src/server/routes/instance/file.ts

@@ -1,190 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { File } from "@/file"
-import { Ripgrep } from "@/file/ripgrep"
-import { LSP } from "@/lsp"
-import { Instance } from "@/project/instance"
-import { lazy } from "@/util/lazy"
-import { jsonRequest } from "./trace"
-
-export const FileRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/find",
-      describeRoute({
-        summary: "Find text",
-        description: "Search for text patterns across files in the project using ripgrep.",
-        operationId: "find.text",
-        responses: {
-          200: {
-            description: "Matches",
-            content: {
-              "application/json": {
-                schema: resolver(Ripgrep.Match.shape.data.array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          pattern: z.string(),
-        }),
-      ),
-      async (c) =>
-        jsonRequest("FileRoutes.findText", c, function* () {
-          const pattern = c.req.valid("query").pattern
-          const svc = yield* Ripgrep.Service
-          const result = yield* svc.search({ cwd: Instance.directory, pattern, limit: 10 })
-          return result.items
-        }),
-    )
-    .get(
-      "/find/file",
-      describeRoute({
-        summary: "Find files",
-        description: "Search for files or directories by name or pattern in the project directory.",
-        operationId: "find.files",
-        responses: {
-          200: {
-            description: "File paths",
-            content: {
-              "application/json": {
-                schema: resolver(z.string().array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          query: z.string(),
-          dirs: z.enum(["true", "false"]).optional(),
-          type: z.enum(["file", "directory"]).optional(),
-          limit: z.coerce.number().int().min(1).max(200).optional(),
-        }),
-      ),
-      async (c) =>
-        jsonRequest("FileRoutes.findFile", c, function* () {
-          const query = c.req.valid("query")
-          const svc = yield* File.Service
-          return yield* svc.search({
-            query: query.query,
-            limit: query.limit ?? 10,
-            dirs: query.dirs !== "false",
-            type: query.type,
-          })
-        }),
-    )
-    .get(
-      "/find/symbol",
-      describeRoute({
-        summary: "Find symbols",
-        description: "Search for workspace symbols like functions, classes, and variables using LSP.",
-        operationId: "find.symbols",
-        responses: {
-          200: {
-            description: "Symbols",
-            content: {
-              "application/json": {
-                schema: resolver(LSP.Symbol.array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          query: z.string(),
-        }),
-      ),
-      async (c) => {
-        return c.json([])
-      },
-    )
-    .get(
-      "/file",
-      describeRoute({
-        summary: "List files",
-        description: "List files and directories in a specified path.",
-        operationId: "file.list",
-        responses: {
-          200: {
-            description: "Files and directories",
-            content: {
-              "application/json": {
-                schema: resolver(File.Node.array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          path: z.string(),
-        }),
-      ),
-      async (c) =>
-        jsonRequest("FileRoutes.list", c, function* () {
-          const svc = yield* File.Service
-          return yield* svc.list(c.req.valid("query").path)
-        }),
-    )
-    .get(
-      "/file/content",
-      describeRoute({
-        summary: "Read file",
-        description: "Read the content of a specified file.",
-        operationId: "file.read",
-        responses: {
-          200: {
-            description: "File content",
-            content: {
-              "application/json": {
-                schema: resolver(File.Content),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          path: z.string(),
-        }),
-      ),
-      async (c) =>
-        jsonRequest("FileRoutes.read", c, function* () {
-          const svc = yield* File.Service
-          return yield* svc.read(c.req.valid("query").path)
-        }),
-    )
-    .get(
-      "/file/status",
-      describeRoute({
-        summary: "Get file status",
-        description: "Get the git status of all files in the project.",
-        operationId: "file.status",
-        responses: {
-          200: {
-            description: "File status",
-            content: {
-              "application/json": {
-                schema: resolver(File.Info.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) =>
-        jsonRequest("FileRoutes.status", c, function* () {
-          const svc = yield* File.Service
-          return yield* svc.status()
-        }),
-    ),
-)

package/src/server/routes/instance/httpapi/config.ts

@@ -1,51 +0,0 @@
-import { Config } from "@/config"
-import { Provider } from "@/provider"
-import { Effect, Layer } from "effect"
-import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-
-const root = "/config"
-
-export const ConfigApi = HttpApi.make("config")
-  .add(
-    HttpApiGroup.make("config")
-      .add(
-        HttpApiEndpoint.get("providers", `${root}/providers`, {
-          success: Provider.ConfigProvidersResult,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "config.providers",
-            summary: "List config providers",
-            description: "Get a list of all configured AI providers and their default models.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "config",
-          description: "Experimental HttpApi config routes.",
-        }),
-      ),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )
-
-export const configHandlers = Layer.unwrap(
-  Effect.gen(function* () {
-    const svc = yield* Provider.Service
-
-    const providers = Effect.fn("ConfigHttpApi.providers")(function* () {
-      const providers = yield* svc.list()
-      return {
-        providers: Object.values(providers),
-        default: Provider.defaultModelIDs(providers),
-      }
-    })
-
-    return HttpApiBuilder.group(ConfigApi, "config", (handlers) => handlers.handle("providers", providers))
-  }),
-).pipe(Layer.provide(Provider.defaultLayer), Layer.provide(Config.defaultLayer))

package/src/server/routes/instance/httpapi/permission.ts

@@ -1,72 +0,0 @@
-import { Permission } from "@/permission"
-import { PermissionID } from "@/permission/schema"
-import { Effect, Layer, Schema } from "effect"
-import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-
-const root = "/permission"
-
-export const PermissionApi = HttpApi.make("permission")
-  .add(
-    HttpApiGroup.make("permission")
-      .add(
-        HttpApiEndpoint.get("list", root, {
-          success: Schema.Array(Permission.Request),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "permission.list",
-            summary: "List pending permissions",
-            description: "Get all pending permission requests across all sessions.",
-          }),
-        ),
-        HttpApiEndpoint.post("reply", `${root}/:requestID/reply`, {
-          params: { requestID: PermissionID },
-          payload: Permission.ReplyBody,
-          success: Schema.Boolean,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "permission.reply",
-            summary: "Respond to permission request",
-            description: "Approve or deny a permission request from the AI assistant.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "permission",
-          description: "Experimental HttpApi permission routes.",
-        }),
-      ),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )
-
-export const permissionHandlers = Layer.unwrap(
-  Effect.gen(function* () {
-    const svc = yield* Permission.Service
-
-    const list = Effect.fn("PermissionHttpApi.list")(function* () {
-      return yield* svc.list()
-    })
-
-    const reply = Effect.fn("PermissionHttpApi.reply")(function* (ctx: {
-      params: { requestID: PermissionID }
-      payload: Permission.ReplyBody
-    }) {
-      yield* svc.reply({
-        requestID: ctx.params.requestID,
-        reply: ctx.payload.reply,
-        message: ctx.payload.message,
-      })
-      return true
-    })
-
-    return HttpApiBuilder.group(PermissionApi, "permission", (handlers) =>
-      handlers.handle("list", list).handle("reply", reply),
-    )
-  }),
-).pipe(Layer.provide(Permission.defaultLayer))

package/src/server/routes/instance/httpapi/project.ts

@@ -1,62 +0,0 @@
-import { Instance } from "@/project/instance"
-import { Project } from "@/project"
-import { Effect, Layer, Schema } from "effect"
-import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-
-const root = "/project"
-
-export const ProjectApi = HttpApi.make("project")
-  .add(
-    HttpApiGroup.make("project")
-      .add(
-        HttpApiEndpoint.get("list", root, {
-          success: Schema.Array(Project.Info),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "project.list",
-            summary: "List all projects",
-            description: "Get a list of projects that have been opened with OpenCode.",
-          }),
-        ),
-        HttpApiEndpoint.get("current", `${root}/current`, {
-          success: Project.Info,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "project.current",
-            summary: "Get current project",
-            description: "Retrieve the currently active project that OpenCode is working with.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "project",
-          description: "Experimental HttpApi project routes.",
-        }),
-      ),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )
-
-export const projectHandlers = Layer.unwrap(
-  Effect.gen(function* () {
-    const svc = yield* Project.Service
-
-    const list = Effect.fn("ProjectHttpApi.list")(function* () {
-      return yield* svc.list()
-    })
-
-    const current = Effect.fn("ProjectHttpApi.current")(function* () {
-      return Instance.project
-    })
-
-    return HttpApiBuilder.group(ProjectApi, "project", (handlers) =>
-      handlers.handle("list", list).handle("current", current),
-    )
-  }),
-).pipe(Layer.provide(Project.defaultLayer))

package/src/server/routes/instance/httpapi/provider.ts

@@ -1,142 +0,0 @@
-import { ProviderAuth } from "@/provider"
-import { Config } from "@/config"
-import { ModelsDev } from "@/provider"
-import { Provider } from "@/provider"
-import { ProviderID } from "@/provider/schema"
-import { mapValues } from "remeda"
-import { Effect, Layer, Schema } from "effect"
-import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-
-const root = "/provider"
-
-export const ProviderApi = HttpApi.make("provider")
-  .add(
-    HttpApiGroup.make("provider")
-      .add(
-        HttpApiEndpoint.get("list", root, {
-          success: Provider.ListResult,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "provider.list",
-            summary: "List providers",
-            description: "Get a list of all available AI providers, including both available and connected ones.",
-          }),
-        ),
-        HttpApiEndpoint.get("auth", `${root}/auth`, {
-          success: ProviderAuth.Methods,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "provider.auth",
-            summary: "Get provider auth methods",
-            description: "Retrieve available authentication methods for all AI providers.",
-          }),
-        ),
-        HttpApiEndpoint.post("authorize", `${root}/:providerID/oauth/authorize`, {
-          params: { providerID: ProviderID },
-          payload: ProviderAuth.AuthorizeInput,
-          success: ProviderAuth.Authorization,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "provider.oauth.authorize",
-            summary: "Start OAuth authorization",
-            description: "Start the OAuth authorization flow for a provider.",
-          }),
-        ),
-        HttpApiEndpoint.post("callback", `${root}/:providerID/oauth/callback`, {
-          params: { providerID: ProviderID },
-          payload: ProviderAuth.CallbackInput,
-          success: Schema.Boolean,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "provider.oauth.callback",
-            summary: "Handle OAuth callback",
-            description: "Handle the OAuth callback from a provider after user authorization.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "provider",
-          description: "Experimental HttpApi provider routes.",
-        }),
-      ),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )
-
-export const providerHandlers = Layer.unwrap(
-  Effect.gen(function* () {
-    const cfg = yield* Config.Service
-    const provider = yield* Provider.Service
-    const svc = yield* ProviderAuth.Service
-
-    const list = Effect.fn("ProviderHttpApi.list")(function* () {
-      const config = yield* cfg.get()
-      const all = yield* Effect.promise(() => ModelsDev.get())
-      const disabled = new Set(config.disabled_providers ?? [])
-      const enabled = config.enabled_providers ? new Set(config.enabled_providers) : undefined
-      const filtered: Record<string, (typeof all)[string]> = {}
-      for (const [key, value] of Object.entries(all)) {
-        if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) {
-          filtered[key] = value
-        }
-      }
-      const connected = yield* provider.list()
-      const providers = Object.assign(
-        mapValues(filtered, (item) => Provider.fromModelsDevProvider(item)),
-        connected,
-      )
-      return {
-        all: Object.values(providers),
-        default: Provider.defaultModelIDs(providers),
-        connected: Object.keys(connected),
-      }
-    })
-
-    const auth = Effect.fn("ProviderHttpApi.auth")(function* () {
-      return yield* svc.methods()
-    })
-
-    const authorize = Effect.fn("ProviderHttpApi.authorize")(function* (ctx: {
-      params: { providerID: ProviderID }
-      payload: ProviderAuth.AuthorizeInput
-    }) {
-      const result = yield* svc
-        .authorize({
-          providerID: ctx.params.providerID,
-          method: ctx.payload.method,
-          inputs: ctx.payload.inputs,
-        })
-        .pipe(Effect.catch(() => Effect.fail(new HttpApiError.BadRequest({}))))
-      if (!result) return yield* new HttpApiError.BadRequest({})
-      return result
-    })
-
-    const callback = Effect.fn("ProviderHttpApi.callback")(function* (ctx: {
-      params: { providerID: ProviderID }
-      payload: ProviderAuth.CallbackInput
-    }) {
-      yield* svc
-        .callback({
-          providerID: ctx.params.providerID,
-          method: ctx.payload.method,
-          code: ctx.payload.code,
-        })
-        .pipe(Effect.catch(() => Effect.fail(new HttpApiError.BadRequest({}))))
-      return true
-    })
-
-    return HttpApiBuilder.group(ProviderApi, "provider", (handlers) =>
-      handlers.handle("list", list).handle("auth", auth).handle("authorize", authorize).handle("callback", callback),
-    )
-  }),
-).pipe(
-  Layer.provide(ProviderAuth.defaultLayer),
-  Layer.provide(Provider.defaultLayer),
-  Layer.provide(Config.defaultLayer),
-)

package/src/server/routes/instance/httpapi/question.ts

@@ -1,121 +0,0 @@
-import { Question } from "@/question"
-import { QuestionID } from "@/question/schema"
-import { Effect, Layer, Schema } from "effect"
-import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-
-const root = "/question"
-
-export const QuestionApi = HttpApi.make("question")
-  .add(
-    HttpApiGroup.make("question")
-      .add(
-        HttpApiEndpoint.get("list", root, {
-          success: Schema.Array(Question.Request),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "question.list",
-            summary: "List pending questions",
-            description: "Get all pending question requests across all sessions.",
-          }),
-        ),
-        HttpApiEndpoint.post("reply", `${root}/:requestID/reply`, {
-          params: { requestID: QuestionID },
-          payload: Question.Reply,
-          success: Schema.Boolean,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "question.reply",
-            summary: "Reply to question request",
-            description: "Provide answers to a question request from the AI assistant.",
-          }),
-        ),
-        HttpApiEndpoint.post("reject", `${root}/:requestID/reject`, {
-          params: { requestID: QuestionID },
-          success: Schema.Boolean,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "question.reject",
-            summary: "Reject question request",
-            description: "Reject a question request from the AI assistant.",
-          }),
-        ),
-        HttpApiEndpoint.get("neverAsk", `${root}/never-ask`, {
-          success: Schema.Boolean,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "question.neverAsk",
-            summary: "Get never-ask state",
-            description:
-              "Whether the question tool auto-resolves to a [Never-Ask] directive instead of blocking for a user.",
-          }),
-        ),
-        HttpApiEndpoint.post("setNeverAsk", `${root}/never-ask`, {
-          payload: Schema.Struct({ enabled: Schema.Boolean }),
-          success: Schema.Boolean,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "question.setNeverAsk",
-            summary: "Set never-ask state",
-            description:
-              "Enable or disable never-ask: the question tool stays visible but returns a [Never-Ask] directive so the model resolves decisions itself.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "question",
-          description: "Question routes.",
-        }),
-      ),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode HttpApi",
-      version: "0.0.1",
-      description: "Effect HttpApi surface for instance routes.",
-    }),
-  )
-
-export const questionHandlers = Layer.unwrap(
-  Effect.gen(function* () {
-    const svc = yield* Question.Service
-
-    const list = Effect.fn("QuestionHttpApi.list")(function* () {
-      return yield* svc.list()
-    })
-
-    const reply = Effect.fn("QuestionHttpApi.reply")(function* (ctx: {
-      params: { requestID: QuestionID }
-      payload: Question.Reply
-    }) {
-      yield* svc.reply({
-        requestID: ctx.params.requestID,
-        answers: ctx.payload.answers,
-      })
-      return true
-    })
-
-    const reject = Effect.fn("QuestionHttpApi.reject")(function* (ctx: { params: { requestID: QuestionID } }) {
-      yield* svc.reject(ctx.params.requestID)
-      return true
-    })
-
-    const neverAsk = Effect.fn("QuestionHttpApi.neverAsk")(function* () {
-      return yield* svc.neverAsk()
-    })
-
-    const setNeverAsk = Effect.fn("QuestionHttpApi.setNeverAsk")(function* (ctx: { payload: { enabled: boolean } }) {
-      yield* svc.setNeverAsk(ctx.payload.enabled)
-      return yield* svc.neverAsk()
-    })
-
-    return HttpApiBuilder.group(QuestionApi, "question", (handlers) =>
-      handlers
-        .handle("list", list)
-        .handle("reply", reply)
-        .handle("reject", reject)
-        .handle("neverAsk", neverAsk)
-        .handle("setNeverAsk", setNeverAsk),
-    )
-  }),
-).pipe(Layer.provide(Question.defaultLayer))