@sleepy-ai/cli 0.1.5 → 0.1.7

package/src/task/registry.ts

@@ -1,394 +0,0 @@
-import { Context, Effect, Layer } from "effect"
-import { Database, and, eq, isNull, or, gt, type SQL } from "@/storage"
-import { Bus } from "../bus"
-import { Config } from "../config"
-import type { SessionID } from "../session/schema"
-import { TaskTable, TaskEventTable } from "./task.sql"
-import type { Task, TaskEvent } from "./schema"
-import { Created as TaskCreated, Updated as TaskUpdated, type UpdatedKind } from "./events"
-import { RecoverableError } from "@/tool/recoverable"
-
-const DAY_MS = 24 * 60 * 60 * 1000
-
-// Shared recovery message for every mutate-by-id miss, so the agent learns one
-// pattern. Wrapped in RecoverableError at each call site so the TUI mutes it
-// (agent-recoverable) while the guidance still reaches the model.
-const notFoundMessage = (id: string) =>
-  `Task ${id} not found. Use \`task list\` to see valid task IDs, or \`task create\` to add one.`
-
-type TaskRow = typeof TaskTable.$inferSelect
-type TaskEventRow = typeof TaskEventTable.$inferSelect
-
-function fromTaskRow(row: TaskRow): Task {
-  return {
-    id: row.id,
-    session_id: row.session_id as SessionID,
-    parent_task_id: row.parent_task_id ?? undefined,
-    status: row.status,
-    summary: row.summary,
-    owner: row.owner ?? undefined,
-    created_at: row.created_at,
-    last_event_at: row.last_event_at,
-    ended_at: row.ended_at ?? undefined,
-    cleanup_after: row.cleanup_after ?? undefined,
-  }
-}
-
-function fromEventRow(row: TaskEventRow): TaskEvent {
-  return {
-    id: row.id,
-    task_id: row.task_id,
-    at: row.at,
-    kind: row.kind as TaskEvent["kind"],
-    summary: row.summary ?? undefined,
-  }
-}
-
-function nextChildId(parentId: string | undefined, siblings: string[]): string {
-  const prefix = parentId ? `${parentId}.` : "T"
-  const used = siblings
-    .filter((s) => (parentId ? s.startsWith(prefix) : /^T\d+$/.test(s)))
-    .map((s) => {
-      const tail = s.slice(prefix.length)
-      return /^\d+$/.test(tail) ? Number(tail) : 0
-    })
-  const next = used.length > 0 ? Math.max(...used) + 1 : 1
-  return `${prefix}${next}`
-}
-
-export interface Interface {
-  readonly create: (input: {
-    session_id: SessionID
-    summary: string
-    parent_id?: string
-    owner?: string
-  }) => Effect.Effect<Task>
-
-  readonly list: (input: {
-    session_id?: SessionID
-    status?: Task["status"]
-    owner?: string
-    include_terminal?: boolean
-    include_archived?: boolean
-  }) => Effect.Effect<Task[]>
-
-  readonly get: (input: { session_id: SessionID; id: string }) => Effect.Effect<Task | undefined>
-
-  readonly block: (input: { session_id: SessionID; id: string; event_summary?: string }) => Effect.Effect<Task>
-  readonly unblock: (input: { session_id: SessionID; id: string; event_summary?: string }) => Effect.Effect<Task>
-  readonly done: (input: { session_id: SessionID; id: string; event_summary?: string }) => Effect.Effect<Task>
-  readonly abandon: (input: { session_id: SessionID; id: string; event_summary?: string }) => Effect.Effect<Task>
-  readonly rename: (input: { session_id: SessionID; id: string; summary: string }) => Effect.Effect<Task>
-
-  readonly start: (input: { session_id: SessionID; id: string; owner?: string; event_summary?: string }) => Effect.Effect<Task>
-
-  readonly events: (input: { session_id: SessionID; task_id: string }) => Effect.Effect<TaskEvent[]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/TaskRegistry") {}
-
-export const layer: Layer.Layer<Service, never, Bus.Service | Config.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-    const config = yield* Config.Service
-
-    const cleanupAfter = Effect.fn("TaskRegistry.cleanupAfter")(function* (now: number) {
-      const cfg = yield* config.get()
-      const days = cfg.checkpoint?.task_archive_days ?? cfg.checkpoint?.task_cleanup_days ?? 7
-      return now + days * DAY_MS
-    })
-
-    const insertEvent = (
-      session_id: SessionID,
-      task_id: string,
-      kind: TaskEvent["kind"],
-      summary: string | undefined,
-      now: number,
-    ) => {
-      Database.use((db) =>
-        db
-          .insert(TaskEventTable)
-          .values({ session_id, task_id, at: now, kind, summary: summary ?? null })
-          .run(),
-      )
-    }
-
-    const publishCreated = (task: Task) =>
-      Effect.runFork(bus.publish(TaskCreated, { sessionID: task.session_id, task }))
-
-    const publishUpdated = (task: Task, kind: UpdatedKind) =>
-      Effect.runFork(bus.publish(TaskUpdated, { sessionID: task.session_id, task, kind }))
-
-    const create = Effect.fn("TaskRegistry.create")(function* (input: {
-      session_id: SessionID
-      summary: string
-      parent_id?: string
-      owner?: string
-    }) {
-      const now = Date.now()
-      const siblings = Database.use((db) =>
-        db
-          .select({ id: TaskTable.id })
-          .from(TaskTable)
-          .where(
-            and(
-              eq(TaskTable.session_id, input.session_id),
-              input.parent_id ? eq(TaskTable.parent_task_id, input.parent_id) : isNull(TaskTable.parent_task_id),
-            ),
-          )
-          .all(),
-      )
-      const id = nextChildId(
-        input.parent_id,
-        siblings.map((s) => s.id),
-      )
-
-      const row: TaskRow = {
-        id,
-        session_id: input.session_id,
-        parent_task_id: input.parent_id ?? null,
-        status: "open",
-        summary: input.summary,
-        owner: input.owner ?? null,
-        created_at: now,
-        last_event_at: now,
-        ended_at: null,
-        cleanup_after: null,
-      }
-      Database.use((db) => db.insert(TaskTable).values(row).run())
-      insertEvent(input.session_id, id, "created", undefined, now)
-      const task = fromTaskRow(row)
-      publishCreated(task)
-      return task
-    })
-
-    const list = Effect.fn("TaskRegistry.list")(function* (input: {
-      session_id?: SessionID
-      status?: Task["status"]
-      owner?: string
-      include_terminal?: boolean
-      include_archived?: boolean
-    }) {
-      const now = Date.now()
-      const conds: SQL[] = []
-      if (input.session_id) conds.push(eq(TaskTable.session_id, input.session_id))
-      if (input.status) conds.push(eq(TaskTable.status, input.status))
-      if (input.owner) conds.push(eq(TaskTable.owner, input.owner))
-      if (!input.include_terminal) {
-        const nonTerminal = or(
-          eq(TaskTable.status, "open"),
-          eq(TaskTable.status, "in_progress"),
-          eq(TaskTable.status, "blocked"),
-        )
-        if (nonTerminal) conds.push(nonTerminal)
-      }
-      if (!input.include_archived) {
-        const notArchived = or(isNull(TaskTable.cleanup_after), gt(TaskTable.cleanup_after, now))
-        if (notArchived) conds.push(notArchived)
-      }
-      const where = conds.length > 0 ? and(...conds) : undefined
-      const rows = Database.use((db) =>
-        db.select().from(TaskTable).where(where).orderBy(TaskTable.created_at).all(),
-      )
-      return rows.map(fromTaskRow)
-    })
-
-    const get = Effect.fn("TaskRegistry.get")(function* (input: { session_id: SessionID; id: string }) {
-      const row = Database.use((db) =>
-        db
-          .select()
-          .from(TaskTable)
-          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
-          .get(),
-      )
-      return row ? fromTaskRow(row) : undefined
-    })
-
-    const events = Effect.fn("TaskRegistry.events")(function* (input: { session_id: SessionID; task_id: string }) {
-      const rows = Database.use((db) =>
-        db
-          .select()
-          .from(TaskEventTable)
-          .where(and(eq(TaskEventTable.session_id, input.session_id), eq(TaskEventTable.task_id, input.task_id)))
-          .orderBy(TaskEventTable.at)
-          .all(),
-      )
-      return rows.map(fromEventRow)
-    })
-
-    // block/unblock/done/abandon/rename
-
-    const block = Effect.fn("TaskRegistry.block")(function* (input: {
-      session_id: SessionID
-      id: string
-      event_summary?: string
-    }) {
-      const now = Date.now()
-      Database.use((db) =>
-        db
-          .update(TaskTable)
-          .set({ status: "blocked", last_event_at: now })
-          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
-          .run(),
-      )
-      insertEvent(input.session_id, input.id, "blocked", input.event_summary, now)
-      const updated = yield* get({ session_id: input.session_id, id: input.id })
-      if (!updated) return yield* Effect.die(new RecoverableError(notFoundMessage(input.id)))
-      publishUpdated(updated, "blocked")
-      return updated
-    })
-
-    const unblock = Effect.fn("TaskRegistry.unblock")(function* (input: {
-      session_id: SessionID
-      id: string
-      event_summary?: string
-    }) {
-      const now = Date.now()
-      Database.use((db) =>
-        db
-          .update(TaskTable)
-          .set({ status: "open", last_event_at: now })
-          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
-          .run(),
-      )
-      insertEvent(input.session_id, input.id, "unblocked", input.event_summary, now)
-      const updated = yield* get({ session_id: input.session_id, id: input.id })
-      if (!updated) return yield* Effect.die(new RecoverableError(notFoundMessage(input.id)))
-      publishUpdated(updated, "unblocked")
-      return updated
-    })
-
-    const start = Effect.fn("TaskRegistry.start")(function* (input: {
-      session_id: SessionID
-      id: string
-      owner?: string
-      event_summary?: string
-    }) {
-      const now = Date.now()
-      const existing = yield* get({ session_id: input.session_id, id: input.id })
-      if (!existing) return yield* Effect.die(new RecoverableError(notFoundMessage(input.id)))
-
-      // Terminal states are final. Auto-start makes start() a structural side-effect of
-      // every actor spawn, so a stale/reused task_id (ReAct re-entry, verification rerun,
-      // operator typo colliding with an old TID) must NOT silently resurrect a
-      // done/abandoned task. done()/abandon() stamp ended_at + cleanup_after; start()
-      // does not clear them, so resurrection would leave a self-contradictory row
-      // (status=in_progress yet carrying ended_at/cleanup_after) that list() drops from
-      // the active set the moment the old archive window elapses. No-op and warn instead.
-      if (existing.status === "done" || existing.status === "abandoned") {
-        yield* Effect.logWarning(`refusing to start terminal task ${input.id} (status=${existing.status})`)
-        return existing
-      }
-
-      // Idempotent re-start by the same owner is a no-op: re-emitting `started` would
-      // spam the task_event log and the SSE/TUI stream for zero state change. A
-      // *different* owner is a genuine handoff (replacement actor picking up the task)
-      // and falls through to update owner + re-emit.
-      const owner = input.owner ?? existing.owner
-      if (existing.status === "in_progress" && owner === existing.owner) return existing
-
-      Database.use((db) =>
-        db
-          .update(TaskTable)
-          .set({ status: "in_progress", owner: owner ?? null, last_event_at: now })
-          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
-          .run(),
-      )
-      insertEvent(input.session_id, input.id, "started", input.event_summary, now)
-      const updated = yield* get({ session_id: input.session_id, id: input.id })
-      if (!updated) return yield* Effect.die(new RecoverableError(notFoundMessage(input.id)))
-      publishUpdated(updated, "started")
-      return updated
-    })
-
-    const done = Effect.fn("TaskRegistry.done")(function* (input: {
-      session_id: SessionID
-      id: string
-      event_summary?: string
-    }) {
-      const now = Date.now()
-      const cleanup = yield* cleanupAfter(now)
-      Database.use((db) =>
-        db
-          .update(TaskTable)
-          .set({
-            status: "done",
-            ended_at: now,
-            cleanup_after: cleanup,
-            last_event_at: now,
-          })
-          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
-          .run(),
-      )
-      insertEvent(input.session_id, input.id, "done", input.event_summary, now)
-      const updated = yield* get({ session_id: input.session_id, id: input.id })
-      if (!updated) return yield* Effect.die(new RecoverableError(notFoundMessage(input.id)))
-      publishUpdated(updated, "done")
-      return updated
-    })
-
-    const abandon = Effect.fn("TaskRegistry.abandon")(function* (input: {
-      session_id: SessionID
-      id: string
-      event_summary?: string
-    }) {
-      const now = Date.now()
-      const cleanup = yield* cleanupAfter(now)
-      Database.use((db) =>
-        db
-          .update(TaskTable)
-          .set({
-            status: "abandoned",
-            ended_at: now,
-            cleanup_after: cleanup,
-            last_event_at: now,
-          })
-          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
-          .run(),
-      )
-      insertEvent(input.session_id, input.id, "abandoned", input.event_summary, now)
-      const updated = yield* get({ session_id: input.session_id, id: input.id })
-      if (!updated) return yield* Effect.die(new RecoverableError(notFoundMessage(input.id)))
-      publishUpdated(updated, "abandoned")
-      return updated
-    })
-
-    const rename = Effect.fn("TaskRegistry.rename")(function* (input: {
-      session_id: SessionID
-      id: string
-      summary: string
-    }) {
-      const now = Date.now()
-      Database.use((db) =>
-        db
-          .update(TaskTable)
-          .set({ summary: input.summary, last_event_at: now })
-          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
-          .run(),
-      )
-      insertEvent(input.session_id, input.id, "renamed", input.summary, now)
-      const updated = yield* get({ session_id: input.session_id, id: input.id })
-      if (!updated) return yield* Effect.die(new RecoverableError(notFoundMessage(input.id)))
-      publishUpdated(updated, "renamed")
-      return updated
-    })
-
-    return Service.of({
-      create,
-      list,
-      get,
-      events,
-      block,
-      unblock,
-      done,
-      abandon,
-      rename,
-      start,
-    })
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() => layer.pipe(Layer.provide(Bus.layer), Layer.provide(Config.defaultLayer)))
-
-export * as TaskRegistry from "./registry"

package/src/task/schema.ts

@@ -1,43 +0,0 @@
-import z from "zod"
-import { SessionID } from "../session/schema"
-
-export const TaskID = z.string().regex(/^T\d+(\.\d+)*$/, "Task ID must be Tn or Tn.m...")
-export type TaskID = z.infer<typeof TaskID>
-
-export const TaskStatus = z.enum(["open", "in_progress", "blocked", "done", "abandoned"])
-export type TaskStatus = z.infer<typeof TaskStatus>
-
-export const Task = z.object({
-  id: TaskID,
-  session_id: SessionID.zod,
-  parent_task_id: TaskID.optional(),
-  status: TaskStatus,
-  summary: z.string(),
-  owner: z.string().optional(),
-  created_at: z.number(),
-  last_event_at: z.number(),
-  ended_at: z.number().optional(),
-  cleanup_after: z.number().optional(),
-})
-export type Task = z.infer<typeof Task>
-
-export const TaskEventKind = z.enum([
-  "created",
-  "started",
-  "unstarted",
-  "blocked",
-  "unblocked",
-  "done",
-  "abandoned",
-  "renamed",
-])
-export type TaskEventKind = z.infer<typeof TaskEventKind>
-
-export const TaskEvent = z.object({
-  id: z.number(),
-  task_id: TaskID,
-  at: z.number(),
-  kind: TaskEventKind,
-  summary: z.string().optional(),
-})
-export type TaskEvent = z.infer<typeof TaskEvent>

package/src/task/task.sql.ts

@@ -1,50 +0,0 @@
-import { sqliteTable, text, integer, index, primaryKey, foreignKey } from "drizzle-orm/sqlite-core"
-import { SessionTable } from "../session/session.sql"
-import type { SessionID } from "../session/schema"
-
-export const TaskTable = sqliteTable(
-  "task",
-  {
-    id: text().notNull(),
-    session_id: text()
-      .$type<SessionID>()
-      .notNull()
-      .references(() => SessionTable.id, { onDelete: "cascade" }),
-    parent_task_id: text(),
-    status: text().$type<"open" | "in_progress" | "blocked" | "done" | "abandoned">().notNull(),
-    summary: text().notNull(),
-    owner: text(),
-    created_at: integer().notNull(),
-    last_event_at: integer().notNull(),
-    ended_at: integer(),
-    cleanup_after: integer(),
-  },
-  (table) => [
-    primaryKey({ columns: [table.session_id, table.id] }),
-    index("task_session_idx").on(table.session_id),
-    index("task_parent_idx").on(table.session_id, table.parent_task_id),
-    index("task_status_idx").on(table.status),
-  ],
-)
-
-export const TaskEventTable = sqliteTable(
-  "task_event",
-  {
-    id: integer().primaryKey({ autoIncrement: true }),
-    session_id: text()
-      .$type<SessionID>()
-      .notNull()
-      .references(() => SessionTable.id, { onDelete: "cascade" }),
-    task_id: text().notNull(),
-    at: integer().notNull(),
-    kind: text().notNull(),
-    summary: text(),
-  },
-  (table) => [
-    foreignKey({
-      columns: [table.session_id, table.task_id],
-      foreignColumns: [TaskTable.session_id, TaskTable.id],
-    }).onDelete("cascade"),
-    index("task_event_task_idx").on(table.session_id, table.task_id, table.at),
-  ],
-)

package/src/team/events.ts

@@ -1,22 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { SessionID } from "@/session/schema"
-import z from "zod"
-
-export const TeamCreated = BusEvent.define(
-  "team.created",
-  z.object({
-    teamID: z.string(),
-    creatorSessionID: SessionID.zod,
-  }),
-)
-
-export const TeamMemberJoined = BusEvent.define(
-  "team.member.joined",
-  z.object({
-    teamID: z.string(),
-    sessionID: SessionID.zod,
-    agent: z.string(),
-    role: z.string(),
-  }),
-)
-

package/src/team/index.ts

@@ -1,113 +0,0 @@
-import { Effect, Layer, Context } from "effect"
-import { Bus } from "@/bus"
-import { InstanceState } from "@/effect"
-import { SessionID } from "@/session/schema"
-import type { TeamMember } from "./schema"
-import * as Events from "./events"
-import { Log } from "@/util"
-import * as fs from "fs/promises"
-import path from "path"
-
-const log = Log.create({ service: "team" })
-
-export interface Interface {
-  readonly create: (teamID: string, creatorSessionID: SessionID) => Effect.Effect<void>
-  readonly addMember: (
-    teamID: string,
-    sessionID: SessionID,
-    agent: string,
-    role: string,
-  ) => Effect.Effect<void>
-  readonly removeMember: (teamID: string, sessionID: SessionID) => Effect.Effect<void>
-  readonly getMembers: (teamID: string) => Effect.Effect<TeamMember[]>
-  readonly teamDir: (teamID: string) => Effect.Effect<string>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Team") {}
-
-export const layer: Layer.Layer<Service, never, Bus.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-
-    const resolveTeamDir = (teamID: string) =>
-      Effect.gen(function* () {
-        const ctx = yield* InstanceState.context
-        return path.join(ctx.directory, ".sleepycode", "teams", teamID)
-      })
-
-    const membersFilePath = (teamID: string) =>
-      Effect.map(resolveTeamDir(teamID), (dir) => path.join(dir, "members.json"))
-
-    const readMembersFile = (teamID: string) =>
-      Effect.gen(function* () {
-        const filePath = yield* membersFilePath(teamID)
-        return yield* Effect.promise(async () => {
-          try {
-            const raw = await fs.readFile(filePath, "utf-8")
-            return JSON.parse(raw) as TeamMember[]
-          } catch {
-            return [] as TeamMember[]
-          }
-        })
-      })
-
-    const writeMembersFile = (teamID: string, members: TeamMember[]) =>
-      Effect.gen(function* () {
-        const filePath = yield* membersFilePath(teamID)
-        yield* Effect.promise(() => fs.writeFile(filePath, JSON.stringify(members, null, 2)))
-      })
-
-    const create = Effect.fn("Team.create")(function* (
-      teamID: string,
-      creatorSessionID: SessionID,
-    ) {
-      const dir = yield* resolveTeamDir(teamID)
-      yield* Effect.promise(() => fs.mkdir(dir, { recursive: true }))
-      yield* Effect.promise(() => fs.writeFile(path.join(dir, "members.json"), "[]"))
-      log.info("team created", { teamID })
-      yield* bus.publish(Events.TeamCreated, { teamID, creatorSessionID })
-    })
-
-    const addMember = Effect.fn("Team.addMember")(function* (
-      teamID: string,
-      sessionID: SessionID,
-      agent: string,
-      role: string,
-    ) {
-      const members = yield* readMembersFile(teamID)
-      const existing = members.find((m) => m.sessionID === sessionID)
-      if (!existing) {
-        members.push({ sessionID, agent, role, joinedAt: Date.now() })
-        yield* writeMembersFile(teamID, members)
-        log.info("team member added", { teamID, sessionID, agent, role })
-      }
-    })
-
-    const removeMember = Effect.fn("Team.removeMember")(function* (
-      teamID: string,
-      sessionID: SessionID,
-    ) {
-      const members = yield* readMembersFile(teamID)
-      const filtered = members.filter((m) => m.sessionID !== sessionID)
-      if (filtered.length !== members.length) {
-        yield* writeMembersFile(teamID, filtered)
-        log.info("team member removed", { teamID, sessionID })
-      }
-    })
-
-    const getMembers = Effect.fn("Team.getMembers")(function* (teamID: string) {
-      return yield* readMembersFile(teamID)
-    })
-
-    const teamDir = Effect.fn("Team.teamDir")(function* (teamID: string) {
-      return yield* resolveTeamDir(teamID)
-    })
-
-    return Service.of({ create, addMember, removeMember, getMembers, teamDir })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Bus.defaultLayer))
-
-export * as Team from "./index"

package/src/team/schema.ts

@@ -1,31 +0,0 @@
-import z from "zod"
-import { SessionID } from "@/session/schema"
-
-export const TeamID = z.string().brand("TeamID")
-export type TeamID = z.infer<typeof TeamID>
-
-export const TeamMessage = z.object({
-  id: z.string(),
-  from: SessionID.zod,
-  fromAgent: z.string(),
-  to: SessionID.zod.optional(),
-  content: z.string(),
-  timestamp: z.number(),
-})
-export type TeamMessage = z.infer<typeof TeamMessage>
-
-export const TeamMember = z.object({
-  sessionID: SessionID.zod,
-  agent: z.string(),
-  role: z.string(),
-  joinedAt: z.number(),
-})
-export type TeamMember = z.infer<typeof TeamMember>
-
-export const TeamInfo = z.object({
-  id: TeamID,
-  members: z.array(TeamMember),
-  createdAt: z.number(),
-  directory: z.string(),
-})
-export type TeamInfo = z.infer<typeof TeamInfo>

package/src/temporary.ts

@@ -1,33 +0,0 @@
-import yargs from "yargs"
-import { TuiThreadCommand } from "./cli/cmd/tui/thread"
-import { InstallationVersion } from "./installation/version"
-import { hideBin } from "yargs/helpers"
-import { Log } from "./node"
-
-Log.init({
-  print: false,
-})
-
-const cli = yargs(hideBin(process.argv))
-  .parserConfiguration({ "populate--": true })
-  .scriptName("sleepy")
-  .wrap(100)
-  .help("help", "show help")
-  .alias("help", "h")
-  .version("version", "show version number", InstallationVersion)
-  .alias("version", "v")
-  .option("print-logs", {
-    describe: "print logs to stderr",
-    type: "boolean",
-  })
-  .option("log-level", {
-    describe: "log level",
-    type: "string",
-    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
-  })
-  .option("pure", {
-    describe: "run without external plugins",
-    type: "boolean",
-  })
-  .command(TuiThreadCommand)
-  .parse()