refactor: unwrap Question namespace + fix script to emit "." for index.ts (#22992)

packages/opencode/script/unwrap-and-self-reexport.ts

@@ -207,10 +207,15 @@ const rewrittenBody = dedented.map(rewriteLine)
 
 // Assemble the new file. Collapse multiple trailing blank lines so the
 // self-reexport sits cleanly at the end.
+//
+// When the file is itself `index.ts`, prefer `"."` over `"./index"` — both are
+// valid but `"."` matches the existing convention in the codebase (e.g.
+// pty/index.ts, file/index.ts, etc.) and avoids referencing "index" literally.
 const basename = path.basename(absPath, ".ts")
+const reexportSource = basename === "index" ? "." : `./${basename}`
 const assembled = [...before, ...rewrittenBody, ...after].join("\n")
 const trimmed = assembled.replace(/\s+$/g, "")
-const output = `${trimmed}\n\nexport * as ${nsName} from "./${basename}"\n`
+const output = `${trimmed}\n\nexport * as ${nsName} from "${reexportSource}"\n`
 
 if (dryRun) {
   console.log(`--- dry run: ${path.relative(process.cwd(), absPath)} ---`)
@@ -218,7 +223,7 @@ if (dryRun) {
   console.log(`body lines:     ${body.length}`)
   console.log(`declared names: ${Array.from(declaredNames).join(", ") || "(none)"}`)
   console.log(`self-refs rewr: ${rewriteCount}`)
-  console.log(`self-reexport:  export * as ${nsName} from "./${basename}"`)
+  console.log(`self-reexport:  export * as ${nsName} from "${reexportSource}"`)
   console.log(`output preview (last 10 lines):`)
   const outputLines = output.split("\n")
   for (const l of outputLines.slice(Math.max(0, outputLines.length - 10))) {
@@ -231,7 +236,7 @@ fs.writeFileSync(absPath, output)
 console.log(`unwrapped ${path.relative(process.cwd(), absPath)} → ${nsName}`)
 console.log(`  body lines:      ${body.length}`)
 console.log(`  self-refs rewr:  ${rewriteCount}`)
-console.log(`  self-reexport:   export * as ${nsName} from "./${basename}"`)
+console.log(`  self-reexport:   export * as ${nsName} from "${reexportSource}"`)
 console.log("")
 console.log("Next: verify with")
 console.log("  bunx --bun tsgo --noEmit")

packages/opencode/src/question/index.ts

@@ -8,23 +8,22 @@ import { Log } from "@/util"
 import { withStatics } from "@/util/schema"
 import { QuestionID } from "./schema"
 
-export namespace Question {
+const log = Log.create({ service: "question" })
-  const log = Log.create({ service: "question" })
 
-  // Schemas
+// Schemas
 
-  export class Option extends Schema.Class<Option>("QuestionOption")({
+export class Option extends Schema.Class<Option>("QuestionOption")({
   label: Schema.String.annotate({
     description: "Display text (1-5 words, concise)",
   }),
   description: Schema.String.annotate({
     description: "Explanation of choice",
   }),
-  }) {
+}) {
   static readonly zod = zod(this)
-  }
+}
 
-  const base = {
+const base = {
   question: Schema.String.annotate({
     description: "Complete question",
   }),
@@ -37,87 +36,87 @@ export namespace Question {
   multiple: Schema.optional(Schema.Boolean).annotate({
     description: "Allow selecting multiple choices",
   }),
-  }
+}
 
-  export class Info extends Schema.Class<Info>("QuestionInfo")({
+export class Info extends Schema.Class<Info>("QuestionInfo")({
   ...base,
   custom: Schema.optional(Schema.Boolean).annotate({
     description: "Allow typing a custom answer (default: true)",
   }),
-  }) {
+}) {
   static readonly zod = zod(this)
-  }
+}
 
-  export class Prompt extends Schema.Class<Prompt>("QuestionPrompt")(base) {
+export class Prompt extends Schema.Class<Prompt>("QuestionPrompt")(base) {
   static readonly zod = zod(this)
-  }
+}
 
-  export class Tool extends Schema.Class<Tool>("QuestionTool")({
+export class Tool extends Schema.Class<Tool>("QuestionTool")({
   messageID: MessageID,
   callID: Schema.String,
-  }) {
+}) {
   static readonly zod = zod(this)
-  }
+}
 
-  export class Request extends Schema.Class<Request>("QuestionRequest")({
+export class Request extends Schema.Class<Request>("QuestionRequest")({
   id: QuestionID,
   sessionID: SessionID,
   questions: Schema.Array(Info).annotate({
     description: "Questions to ask",
   }),
   tool: Schema.optional(Tool),
-  }) {
+}) {
   static readonly zod = zod(this)
-  }
+}
 
-  export const Answer = Schema.Array(Schema.String)
+export const Answer = Schema.Array(Schema.String)
   .annotate({ identifier: "QuestionAnswer" })
   .pipe(withStatics((s) => ({ zod: zod(s) })))
-  export type Answer = Schema.Schema.Type<typeof Answer>
+export type Answer = Schema.Schema.Type<typeof Answer>
 
-  export class Reply extends Schema.Class<Reply>("QuestionReply")({
+export class Reply extends Schema.Class<Reply>("QuestionReply")({
   answers: Schema.Array(Answer).annotate({
     description: "User answers in order of questions (each answer is an array of selected labels)",
   }),
-  }) {
+}) {
   static readonly zod = zod(this)
-  }
+}
 
-  class Replied extends Schema.Class<Replied>("QuestionReplied")({
+class Replied extends Schema.Class<Replied>("QuestionReplied")({
   sessionID: SessionID,
   requestID: QuestionID,
   answers: Schema.Array(Answer),
-  }) {}
+}) {}
 
-  class Rejected extends Schema.Class<Rejected>("QuestionRejected")({
+class Rejected extends Schema.Class<Rejected>("QuestionRejected")({
   sessionID: SessionID,
   requestID: QuestionID,
-  }) {}
+}) {}
 
-  export const Event = {
+export const Event = {
   Asked: BusEvent.define("question.asked", Request.zod),
   Replied: BusEvent.define("question.replied", zod(Replied)),
   Rejected: BusEvent.define("question.rejected", zod(Rejected)),
-  }
+}
 
-  export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionRejectedError", {}) {
+export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionRejectedError", {}) {
   override get message() {
     return "The user dismissed this question"
   }
-  }
+}
 
-  interface PendingEntry {
+interface PendingEntry {
   info: Request
   deferred: Deferred.Deferred<ReadonlyArray<Answer>, RejectedError>
-  }
+}
 
-  interface State {
+interface State {
   pending: Map<QuestionID, PendingEntry>
-  }
+}
 
-  // Service
+// Service
 
-  export interface Interface {
+export interface Interface {
   readonly ask: (input: {
     sessionID: SessionID
     questions: ReadonlyArray<Info>
@@ -126,11 +125,11 @@ export namespace Question {
   readonly reply: (input: { requestID: QuestionID; answers: ReadonlyArray<Answer> }) => Effect.Effect<void>
   readonly reject: (requestID: QuestionID) => Effect.Effect<void>
   readonly list: () => Effect.Effect<ReadonlyArray<Request>>
-  }
+}
 
-  export class Service extends Context.Service<Service, Interface>()("@opencode/Question") {}
+export class Service extends Context.Service<Service, Interface>()("@opencode/Question") {}
 
-  export const layer = Layer.effect(
+export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const bus = yield* Bus.Service
@@ -223,7 +222,8 @@ export namespace Question {
 
     return Service.of({ ask, reply, reject, list })
   }),
-  )
+)
 
-  export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
+export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
-}
+
+export * as Question from "."