1
function createOpencode() {
2
  const host = "127.0.0.1"
3
  const port = 4096
4
  const url = `http://${host}:${port}`
5
  const proc = spawn(`opencode`, [`serve`, `--hostname=${host}`, `--port=${port}`])
6
  const client = createOpencodeClient({ baseUrl: url })

1
        .route("/project", ProjectRoutes())
2
        .route("/pty", PtyRoutes())
3
        .route("/config", ConfigRoutes())
4
        .route("/experimental", ExperimentalRoutes())
5
        .route("/session", SessionRoutes())
6
        .route("/permission", PermissionRoutes())
7
        .route("/question", QuestionRoutes())
8
        .route("/provider", ProviderRoutes())
9
        .route("/", FileRoutes())
10
        .route("/mcp", McpRoutes())
11
        .route("/tui", TuiRoutes())

1
  new Hono()
2
    .get(
3
      "/find",
4
      describeRoute({
5
        summary: "Find text",
6
        description: "Search for text patterns across files in the project using ripgrep.",
7
        operationId: "find.text",
8
        responses: {
9
          200: {
10
            description: "Matches",
11
            content: {
12
              "application/json": {
13
                schema: resolver(Ripgrep.Match.shape.data.array()),
14
              },
15
            },
16
          },
17
        },
18
      }),
19
      validator(
20
        "query",
21
        z.object({
22
          pattern: z.string(),
23
        }),
24
      ),
25
      async (c) => {
26
        const pattern = c.req.valid("query").pattern
27
        const result = await Ripgrep.search({
28
          cwd: Instance.directory,
29
          pattern,
30
          limit: 10,
31
        })
32
        return c.json(result)
33
      },
34
    )

1
  export async function search(input: {
2
    cwd: string
3
    pattern: string
4
    glob?: string[]
5
    limit?: number
6
    follow?: boolean
7
  }) {
8
    const args = [`${await filepath()}`, "--json", "--hidden", "--glob='!.git/*'"]
9
    if (input.follow) args.push("--follow")
10

11
    if (input.glob) {
12
      for (const g of input.glob) {
13
        args.push(`--glob=${g}`)
14
      }
15
    }
16

17
    if (input.limit) {
18
      args.push(`--max-count=${input.limit}`)
19
    }
20

21
    args.push("--")
22
    args.push(input.pattern)
23

24
    const command = args.join(" ")
25
    const result = await $`${{ raw: command }}`.cwd(input.cwd).quiet().nothrow()
26
    if (result.exitCode !== 0) {
27
      return []
28
    }

1
.get(
2
      "/find/file",
3
      describeRoute({
4
        summary: "Find files",
5
        description: "Search for files or directories by name or pattern in the project directory.",
6
        operationId: "find.files",
7
        responses: {
8
          200: {
9
            description: "File paths",
10
            content: {
11
              "application/json": {
12
                schema: resolver(z.string().array()),
13
              },
14
            },
15
          },
16
        },
17
      }),
18
      validator(
19
        "query",
20
        z.object({
21
          query: z.string(),
22
          dirs: z.enum(["true", "false"]).optional(),
23
          type: z.enum(["file", "directory"]).optional(),
24
          limit: z.coerce.number().int().min(1).max(200).optional(),
25
        }),
26
      ),
27
      async (c) => {
28
        const query = c.req.valid("query").query
29
        const dirs = c.req.valid("query").dirs
30
        const type = c.req.valid("query").type
31
        const limit = c.req.valid("query").limit
32
        const results = await File.search({
33
          query,
34
          limit: limit ?? 10,
35
          dirs: dirs !== "false",
36
          type,
37
        })
38
        return c.json(results)
39
      },
40
    )

1
  export async function search(input: { query: string; limit?: number; dirs?: boolean; type?: "file" | "directory" }) {
2
    const query = input.query.trim()
3
    const limit = input.limit ?? 100
4
    const kind = input.type ?? (input.dirs === false ? "file" : "all")
5
    log.info("search", { query, kind })
6

7
    const result = await state().then((x) => x.files())
8

9
    const hidden = (item: string) => {
10
      const normalized = item.replaceAll("\\", "/").replace(/\/+$/, "")
11
      return normalized.split("/").some((p) => p.startsWith(".") && p.length > 1)
12
    }
13
    const preferHidden = query.startsWith(".") || query.includes("/.")
14
    const sortHiddenLast = (items: string[]) => {
15
      if (preferHidden) return items
16
      const visible: string[] = []
17
      const hiddenItems: string[] = []
18
      for (const item of items) {
19
        const isHidden = hidden(item)
20
        if (isHidden) hiddenItems.push(item)
21
        if (!isHidden) visible.push(item)
22
      }
23
      return [...visible, ...hiddenItems]
24
    }
25
    if (!query) {
26
      if (kind === "file") return result.files.slice(0, limit)
27
      return sortHiddenLast(result.dirs.toSorted()).slice(0, limit)
28
    }
29

30
    const items =
31
      kind === "file" ? result.files : kind === "directory" ? result.dirs : [...result.files, ...result.dirs]
32

33
    const searchLimit = kind === "directory" && !preferHidden ? limit * 20 : limit
34
    const sorted = fuzzysort.go(query, items, { limit: searchLimit }).map((r) => r.target)
35
    const output = kind === "directory" ? sortHiddenLast(sorted).slice(0, limit) : sorted
36

37
    log.info("search", { query, kind, results: output.length })
38
    return output
39
  }
40
}