@miaws/miaw 1.18.5 → 1.18.6

package/test/cli/run/footer.width.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { footerWidthPolicy } from "@/cli/cmd/run/footer.width"
-
-describe("run footer width", () => {
-  test("preserves shared dialog and statusline breakpoints", () => {
-    const narrow = footerWidthPolicy(79)
-    expect(narrow.dialog.narrow).toBe(true)
-    expect(narrow.statusline.showActivityMeta).toBe(false)
-    expect(narrow.statusline.showCommandHint).toBe(true)
-    expect(narrow.statusline.showContextHints).toBe(false)
-    expect(narrow.statusline.contextHintLimit).toBe(0)
-    expect(narrow.statusline.showModel).toBe(false)
-
-    const command = footerWidthPolicy(65)
-    expect(command.statusline.showCommandHint).toBe(false)
-
-    const commandHint = footerWidthPolicy(66)
-    expect(commandHint.statusline.showCommandHint).toBe(true)
-
-    const compact = footerWidthPolicy(80)
-    expect(compact.dialog.narrow).toBe(false)
-    expect(compact.statusline.showActivityMeta).toBe(true)
-    expect(compact.statusline.showContextHints).toBe(true)
-    expect(compact.statusline.contextHintLimit).toBe(1)
-    expect(compact.statusline.showModel).toBe(false)
-
-    const model = footerWidthPolicy(120)
-    expect(model.statusline.contextHintLimit).toBe(2)
-    expect(model.statusline.showModel).toBe(true)
-
-    const spacious = footerWidthPolicy(150)
-    expect(spacious.statusline.contextHintLimit).toBeUndefined()
-    expect(spacious.statusline.showModel).toBe(true)
-  })
-})

package/test/cli/run/permission.shared.test.ts

@@ -1,144 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { PermissionRequest } from "@miaw/sdk/v2"
-import {
-  createPermissionBodyState,
-  permissionAlwaysLines,
-  permissionCancel,
-  permissionEscape,
-  permissionInfo,
-  permissionReject,
-  permissionRun,
-} from "@/cli/cmd/run/permission.shared"
-
-function req(input: Partial<PermissionRequest> = {}): PermissionRequest {
-  return {
-    id: "perm-1",
-    sessionID: "session-1",
-    permission: "read",
-    patterns: [],
-    metadata: {},
-    always: [],
-    ...input,
-  }
-}
-
-describe("run permission shared", () => {
-  test("replies immediately for allow once", () => {
-    const out = permissionRun(createPermissionBodyState("perm-1"), "perm-1", "once")
-
-    expect(out.reply).toEqual({
-      requestID: "perm-1",
-      reply: "once",
-    })
-  })
-
-  test("requires confirmation for allow always", () => {
-    const next = permissionRun(createPermissionBodyState("perm-1"), "perm-1", "always")
-    expect(next.state.stage).toBe("always")
-    expect(next.state.selected).toBe("confirm")
-    expect(next.reply).toBeUndefined()
-
-    expect(permissionRun(next.state, "perm-1", "confirm").reply).toEqual({
-      requestID: "perm-1",
-      reply: "always",
-    })
-
-    expect(permissionRun(next.state, "perm-1", "cancel").state).toMatchObject({
-      stage: "permission",
-      selected: "always",
-    })
-  })
-
-  test("builds trimmed reject replies and stage transitions", () => {
-    const next = permissionRun(createPermissionBodyState("perm-1"), "perm-1", "reject")
-    expect(next.state.stage).toBe("reject")
-
-    const out = permissionReject({ ...next.state, message: "  use rg  " }, "perm-1")
-    expect(out).toEqual({
-      requestID: "perm-1",
-      reply: "reject",
-      message: "use rg",
-    })
-
-    expect(permissionCancel(next.state)).toMatchObject({
-      stage: "permission",
-      selected: "reject",
-    })
-
-    expect(permissionEscape(createPermissionBodyState("perm-1"))).toMatchObject({
-      stage: "reject",
-      selected: "reject",
-    })
-
-    expect(permissionEscape({ ...next.state, stage: "always", selected: "confirm" })).toMatchObject({
-      stage: "permission",
-      selected: "always",
-    })
-  })
-
-  test("maps supported permission types into display info", () => {
-    expect(
-      permissionInfo(
-        req({
-          permission: "bash",
-          metadata: {
-            input: {
-              command: "git status --short",
-            },
-          },
-        }),
-      ),
-    ).toMatchObject({
-      title: "Shell command",
-      lines: ["$ git status --short"],
-    })
-
-    expect(
-      permissionInfo(
-        req({
-          permission: "task",
-          metadata: {
-            description: "investigate stream",
-            subagent_type: "general",
-          },
-        }),
-      ),
-    ).toMatchObject({
-      title: "General Task",
-      lines: ["◉ investigate stream"],
-    })
-
-    expect(
-      permissionInfo(
-        req({
-          permission: "external_directory",
-          patterns: ["/tmp/work/**/*.ts", "/tmp/work/**/*.tsx"],
-        }),
-      ),
-    ).toMatchObject({
-      title: "Access external directory /tmp/work",
-      lines: ["- /tmp/work/**/*.ts", "- /tmp/work/**/*.tsx"],
-    })
-
-    expect(permissionInfo(req({ permission: "doom_loop" }))).toMatchObject({
-      title: "Continue after repeated failures",
-    })
-
-    expect(permissionInfo(req({ permission: "custom_tool" }))).toMatchObject({
-      title: "Call tool custom_tool",
-      lines: ["Tool: custom_tool"],
-    })
-  })
-
-  test("formats always-allow copy for wildcard and explicit patterns", () => {
-    expect(permissionAlwaysLines(req({ permission: "bash", always: ["*"] }))).toEqual([
-      "This will allow bash until Miaw is restarted.",
-    ])
-
-    expect(permissionAlwaysLines(req({ always: ["src/**/*.ts", "src/**/*.tsx"] }))).toEqual([
-      "This will allow the following patterns until Miaw is restarted.",
-      "- src/**/*.ts",
-      "- src/**/*.tsx",
-    ])
-  })
-})

package/test/cli/run/prompt.editor.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { realignEditorPromptParts, resolveEditorSlashValue } from "@/cli/cmd/run/prompt.editor"
-import type { RunPromptPart } from "@/cli/cmd/run/types"
-
-describe("run prompt editor helpers", () => {
-  test("strips the local /editor command from the initial editor text", () => {
-    expect(resolveEditorSlashValue("/editor")).toBe("")
-    expect(resolveEditorSlashValue("/editor draft message")).toBe("draft message")
-    expect(resolveEditorSlashValue("/editor first line\nsecond line")).toBe("first line\nsecond line")
-  })
-
-  test("realigns file and agent parts after external editing", () => {
-    const filePart = {
-      type: "file",
-      mime: "text/plain",
-      filename: "src/app.ts",
-      url: "file:///src/app.ts",
-      source: {
-        type: "file",
-        path: "src/app.ts",
-        text: {
-          start: 0,
-          end: 11,
-          value: "@src/app.ts",
-        },
-      },
-    } satisfies RunPromptPart
-    const agentPart = {
-      type: "agent",
-      name: "helper",
-      source: {
-        start: 12,
-        end: 19,
-        value: "@helper",
-      },
-    } satisfies RunPromptPart
-    const parts = [filePart, agentPart]
-
-    expect(realignEditorPromptParts("Please check @helper before @src/app.ts", parts)).toEqual([
-      {
-        ...filePart,
-        source: {
-          ...filePart.source,
-          text: {
-            ...filePart.source.text,
-            start: 28,
-            end: 39,
-            value: "@src/app.ts",
-          },
-        },
-      },
-      {
-        ...agentPart,
-        source: {
-          start: 13,
-          end: 20,
-          value: "@helper",
-        },
-      },
-    ])
-  })
-
-  test("drops parts whose virtual text was deleted", () => {
-    const filePart = {
-      type: "file",
-      mime: "text/plain",
-      filename: "src/app.ts",
-      url: "file:///src/app.ts",
-      source: {
-        type: "file",
-        path: "src/app.ts",
-        text: {
-          start: 0,
-          end: 11,
-          value: "@src/app.ts",
-        },
-      },
-    } satisfies RunPromptPart
-    const agentPart = {
-      type: "agent",
-      name: "helper",
-      source: {
-        start: 12,
-        end: 19,
-        value: "@helper",
-      },
-    } satisfies RunPromptPart
-    const parts = [filePart, agentPart]
-
-    expect(realignEditorPromptParts("Only @helper remains", parts)).toEqual([
-      {
-        ...agentPart,
-        source: {
-          start: 5,
-          end: 12,
-          value: "@helper",
-        },
-      },
-    ])
-  })
-})

package/test/cli/run/prompt.shared.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  createPromptHistory,
-  isExitCommand,
-  isNewCommand,
-  movePromptHistory,
-  pushPromptHistory,
-} from "@/cli/cmd/run/prompt.shared"
-import type { RunPrompt } from "@/cli/cmd/run/types"
-
-function prompt(text: string, parts: RunPrompt["parts"] = []): RunPrompt {
-  return { text, parts }
-}
-
-describe("run prompt shared", () => {
-  test("filters blank prompts and dedupes consecutive history", () => {
-    const out = createPromptHistory([prompt("   "), prompt("one"), prompt("one"), prompt("two"), prompt("one")])
-
-    expect(out.items.map((item) => item.text)).toEqual(["one", "two", "one"])
-    expect(out.index).toBeNull()
-    expect(out.draft).toBe("")
-  })
-
-  test("push ignores blanks and dedupes only the latest item", () => {
-    const base = createPromptHistory([prompt("one")])
-
-    expect(pushPromptHistory(base, prompt("   ")).items.map((item) => item.text)).toEqual(["one"])
-    expect(pushPromptHistory(base, prompt("one")).items.map((item) => item.text)).toEqual(["one"])
-    expect(pushPromptHistory(base, prompt("two")).items.map((item) => item.text)).toEqual(["one", "two"])
-  })
-
-  test("moves through history only at input boundaries and restores draft", () => {
-    const base = createPromptHistory([prompt("one"), prompt("two")])
-
-    expect(movePromptHistory(base, -1, "draft", 1)).toEqual({
-      state: base,
-      apply: false,
-    })
-
-    const up = movePromptHistory(base, -1, "draft", 0)
-    expect(up.apply).toBe(true)
-    expect(up.text).toBe("two")
-    expect(up.cursor).toBe(0)
-    expect(up.state.index).toBe(1)
-    expect(up.state.draft).toBe("draft")
-
-    const older = movePromptHistory(up.state, -1, "two", 0)
-    expect(older.apply).toBe(true)
-    expect(older.text).toBe("one")
-    expect(older.cursor).toBe(0)
-    expect(older.state.index).toBe(0)
-
-    const newer = movePromptHistory(older.state, 1, "one", 3)
-    expect(newer.apply).toBe(true)
-    expect(newer.text).toBe("two")
-    expect(newer.cursor).toBe(3)
-    expect(newer.state.index).toBe(1)
-
-    const draft = movePromptHistory(newer.state, 1, "two", 3)
-    expect(draft.apply).toBe(true)
-    expect(draft.text).toBe("draft")
-    expect(draft.cursor).toBe(5)
-    expect(draft.state.index).toBeNull()
-  })
-
-  test("uses display-width cursors for history restoration", () => {
-    const base = createPromptHistory([prompt("one"), prompt("中文")])
-
-    const latest = movePromptHistory(base, -1, "草稿", 0)
-    expect(latest.apply).toBe(true)
-    expect(latest.text).toBe("中文")
-    expect(latest.cursor).toBe(0)
-
-    const older = movePromptHistory(latest.state, -1, "中文", 0)
-    expect(older.apply).toBe(true)
-    expect(older.text).toBe("one")
-    expect(older.cursor).toBe(0)
-
-    const newer = movePromptHistory(older.state, 1, "one", Bun.stringWidth("one"))
-    expect(newer.apply).toBe(true)
-    expect(newer.text).toBe("中文")
-    expect(newer.cursor).toBe(Bun.stringWidth("中文"))
-
-    const draft = movePromptHistory(newer.state, 1, "中文", Bun.stringWidth("中文"))
-    expect(draft.apply).toBe(true)
-    expect(draft.text).toBe("草稿")
-    expect(draft.cursor).toBe(Bun.stringWidth("草稿"))
-  })
-
-  test("recognizes exit commands", () => {
-    expect(isExitCommand("/exit")).toBe(true)
-    expect(isExitCommand(" /Quit ")).toBe(true)
-    expect(isExitCommand("/quit now")).toBe(false)
-  })
-
-  test("recognizes the new-session command", () => {
-    expect(isNewCommand("/new")).toBe(true)
-    expect(isNewCommand(" /NEW ")).toBe(true)
-    expect(isNewCommand("/new now")).toBe(false)
-  })
-})

package/test/cli/run/question.shared.test.ts

@@ -1,115 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { QuestionRequest } from "@miaw/sdk/v2"
-import {
-  createQuestionBodyState,
-  questionConfirm,
-  questionReject,
-  questionSave,
-  questionSelect,
-  questionSetSelected,
-  questionStoreCustom,
-  questionSubmit,
-  questionSync,
-} from "@/cli/cmd/run/question.shared"
-
-function req(input: Partial<QuestionRequest> = {}): QuestionRequest {
-  return {
-    id: "question-1",
-    sessionID: "session-1",
-    questions: [
-      {
-        question: "Mode?",
-        header: "Mode",
-        options: [{ label: "chunked", description: "Incremental output" }],
-        multiple: false,
-      },
-    ],
-    ...input,
-  }
-}
-
-describe("run question shared", () => {
-  test("replies immediately for a single-select question", () => {
-    const out = questionSelect(createQuestionBodyState("question-1"), req())
-
-    expect(out.reply).toEqual({
-      requestID: "question-1",
-      answers: [["chunked"]],
-    })
-  })
-
-  test("advances multi-question flows and submits from confirm", () => {
-    const ask = req({
-      questions: [
-        {
-          question: "Mode?",
-          header: "Mode",
-          options: [{ label: "chunked", description: "Incremental output" }],
-          multiple: false,
-        },
-        {
-          question: "Output?",
-          header: "Output",
-          options: [
-            { label: "yes", description: "Show tool output" },
-            { label: "no", description: "Hide tool output" },
-          ],
-          multiple: false,
-        },
-      ],
-    })
-
-    let state = questionSelect(createQuestionBodyState("question-1"), ask).state
-    expect(state.tab).toBe(1)
-
-    state = questionSetSelected(state, 1)
-    state = questionSelect(state, ask).state
-    expect(questionConfirm(ask, state)).toBe(true)
-    expect(questionSubmit(ask, state)).toEqual({
-      requestID: "question-1",
-      answers: [["chunked"], ["no"]],
-    })
-  })
-
-  test("toggles answers for multiple-choice questions", () => {
-    const ask = req({
-      questions: [
-        {
-          question: "Tags?",
-          header: "Tags",
-          options: [{ label: "bug", description: "Bug fix" }],
-          multiple: true,
-        },
-      ],
-    })
-
-    let state = questionSelect(createQuestionBodyState("question-1"), ask).state
-    expect(state.answers).toEqual([["bug"]])
-
-    state = questionSelect(state, ask).state
-    expect(state.answers).toEqual([[]])
-  })
-
-  test("stores and submits custom answers", () => {
-    let state = questionSetSelected(createQuestionBodyState("question-1"), 1)
-    let next = questionSelect(state, req())
-    expect(next.state.editing).toBe(true)
-
-    state = questionStoreCustom(next.state, 0, "  custom mode  ")
-    next = questionSave(state, req())
-    expect(next.reply).toEqual({
-      requestID: "question-1",
-      answers: [["custom mode"]],
-    })
-  })
-
-  test("resets state when the request id changes and builds reject payloads", () => {
-    const state = questionSetSelected(createQuestionBodyState("question-1"), 1)
-
-    expect(questionSync(state, "question-1")).toBe(state)
-    expect(questionSync(state, "question-2")).toEqual(createQuestionBodyState("question-2"))
-    expect(questionReject(req())).toEqual({
-      requestID: "question-1",
-    })
-  })
-})

package/test/cli/run/run-process.test.ts

@@ -1,84 +0,0 @@
-// Subprocess integration tests for `miaw run` (non-interactive mode).
-// These exercise the real CLI binary against a TestLLMServer running in the
-// same process. See `test/lib/cli-process.ts` for the harness — each test uses
-// `miaw.run(message, opts?)` to spawn `bun src/index.ts run ...` with
-// `MIAW_CONFIG_CONTENT` providing the test provider config inline.
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { cliIt } from "../../lib/cli-process"
-
-describe("miaw run (non-interactive subprocess)", () => {
-  // Happy path: prompt completes, output reaches stdout, process exits 0.
-  // If this fails, all the others likely will too — debug here first.
-  cliIt.concurrent(
-    "exits 0 and writes the response to stdout on a successful prompt",
-    ({ llm, miaw }) =>
-      Effect.gen(function* () {
-        yield* llm.text("hello from the test llm")
-        const result = yield* miaw.run("say hi")
-        miaw.expectExit(result, 0)
-        expect(result.stdout).toContain("hello from the test llm")
-      }),
-    60_000,
-  )
-
-  // Regression for #27371: an unknown model used to hang the process forever
-  // waiting on a session.status === idle event that never arrived. The fix
-  // makes the SDK call surface an error promptly so the process exits nonzero.
-  // We assert nonzero exit AND wall-clock under the harness timeout — a hang
-  // would expire the timeout and produce a different (signal-killed) failure.
-  cliIt.concurrent(
-    "exits nonzero promptly when the model is unknown (regression for #27371)",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        const result = yield* miaw.run("say hi", {
-          model: "test/nonexistent-model",
-          timeoutMs: 15_000,
-        })
-        expect(result.exitCode).not.toBe(0)
-        expect(result.durationMs).toBeLessThan(15_000)
-      }),
-    30_000,
-  )
-
-  // Locks in the current behavior: when the LLM stream errors mid-response
-  // (the prompt was accepted, then the upstream provider failed), miaw
-  // emits a session.error event and the process exits 0 today.
-  //
-  // This is debatable — a future cleanup might flip it to exit 1. If you're
-  // changing this expectation, do it deliberately and say so in the PR.
-  cliIt.concurrent(
-    "mid-stream LLM error still exits 0 today (contract lock-in)",
-    ({ llm, miaw }) =>
-      Effect.gen(function* () {
-        yield* llm.fail("upstream provider exploded mid-stream")
-        const result = yield* miaw.run("trigger midstream error", { timeoutMs: 30_000 })
-        expect(result.exitCode).toBe(0)
-      }),
-    60_000,
-  )
-
-  // --format json puts one JSON object per line on stdout for each emitted
-  // event. Consumers (CI scripts, tooling) parse this stream. Asserts the
-  // shape so a future event-emit change has to update this expectation.
-  cliIt.concurrent(
-    "--format json emits parseable line-delimited JSON to stdout",
-    ({ llm, miaw }) =>
-      Effect.gen(function* () {
-        yield* llm.text("structured output")
-        const result = yield* miaw.run("say hi", { format: "json" })
-        miaw.expectExit(result, 0)
-
-        const events = miaw.parseJsonEvents(result.stdout)
-        expect(events.length).toBeGreaterThan(0)
-        for (const evt of events) {
-          expect(typeof evt.type).toBe("string")
-          expect(typeof evt.sessionID).toBe("string")
-        }
-        // At least one `text` event should appear with the LLM's response.
-        const text = events.find((e) => e.type === "text")
-        expect(text).toBeDefined()
-      }),
-    60_000,
-  )
-})