@ryan_nookpi/pi-extension-ask-user-question 0.2.0 → 0.2.2

package/README.md

@@ -1,43 +1,90 @@
 # @ryan_nookpi/pi-extension-ask-user-question
 
-Interactive multi-question form tool for pi.
+pi에서 `ask_user_question` 도구를 추가해, 사용자에게 여러 질문을 한 번에 구조화해서 받을 수 있게 해주는 익스텐션입니다.
 
-After installation, pi can use the `ask_user_question` tool to collect structured input from the user with:
-
-- `radio` questions for single choice
-- `checkbox` questions for multiple choice
-- `text` questions for free-form answers
-- optional `Other...` inputs for custom answers
-
-## Install
+## 설치
 
 ```bash
 pi install npm:@ryan_nookpi/pi-extension-ask-user-question
 ```
 
-## Example
+## 무엇을 할 수 있나
+
+- `radio`: 하나만 고르는 단일 선택 질문
+- `checkbox`: 여러 개를 고르는 복수 선택 질문
+- `text`: 자유 입력 질문
+- `allowOther: true`: 선택지 외 값을 직접 입력하는 `기타...` 경로 제공
+- 여러 질문을 한 번의 폼으로 묶어 입력 받기
+
+## 언제 쓰면 좋은가
+
+- 요구사항이 모호해서 확인이 필요할 때
+- 여러 선택지 중 하나를 고르게 해야 할 때
+- 선호도, 배포 환경, 옵션 조합 등을 한 번에 수집할 때
+- 일반 텍스트 질문보다 구조화된 응답이 필요할 때
+
+## 파라미터 가이드
+
+### 최상위 필드
+
+- `title`: 폼 상단 제목
+- `description`: 폼 설명/안내 문구
+- `questions`: 질문 배열
+
+### 질문 필드
+
+- `id`: 질문 식별자
+- `type`: `radio` | `checkbox` | `text`
+- `prompt`: 사용자에게 보여줄 질문 문구
+- `label`: 탭에 표시할 짧은 이름. 생략하면 `Q1`, `Q2`처럼 자동 생성
+- `options`: `radio`/`checkbox`에서 사용할 선택지 목록
+- `allowOther`: `기타...` 직접 입력 허용 여부
+- `required`: 필수 응답 여부
+- `placeholder`: `text` 입력창 플레이스홀더
+- `default`: 기본값. `radio`/`text`는 문자열, `checkbox`는 문자열 배열
+
+### 옵션 필드
+
+- `value`: 실제 반환값
+- `label`: 화면에 보이는 문구
+- `description`: 선택지 아래 보조 설명
+
+## 예시
 
 ```json
 {
-  "title": "Deployment settings",
-  "description": "Need a few decisions before continuing.",
+  "title": "배포 설정 확인",
+  "description": "진행 전에 몇 가지 선택이 필요합니다.",
   "questions": [
     {
       "id": "env",
       "type": "radio",
-      "prompt": "Which environment should I use?",
+      "prompt": "어느 환경에 배포할까요?",
       "options": [
-        { "value": "staging", "label": "Staging" },
-        { "value": "prod", "label": "Production" }
+        { "value": "staging", "label": "스테이징" },
+        { "value": "prod", "label": "프로덕션" }
+      ]
+    },
+    {
+      "id": "targets",
+      "type": "checkbox",
+      "prompt": "이번에 함께 반영할 항목은 무엇인가요?",
+      "options": [
+        { "value": "web", "label": "웹" },
+        { "value": "admin", "label": "어드민" }
       ]
     },
     {
       "id": "notes",
       "type": "text",
-      "prompt": "Anything else I should know?",
+      "prompt": "추가로 알아야 할 점이 있나요?",
       "required": false,
-      "placeholder": "Optional notes"
+      "placeholder": "선택 사항"
     }
   ]
 }
 ```
+
+## 반환 형태
+
+응답은 각 질문의 `id` 기준으로 정리되어 반환됩니다. 취소 시에는 `cancelled: true`가 내려오고, 완료 시에는 질문별 답변 목록이 포함됩니다.

package/controller.test.ts

@@ -112,7 +112,7 @@ describe("ask-user-question/controller", () => {
 		setup.controller.handleInput("\r");
 		expect(setup.controller.getState()).toMatchObject({ otherMode: true, otherQuestionId: "radio" });
 		expect(setup.editor.getText()).toBe("saved");
-		expect(setup.controller.render(80).join("\n")).toContain("Your answer:");
+		expect(setup.controller.render(80).join("\n")).toContain("직접 입력:");
 
 		setup.controller.handleInput("x");
 		setup.controller.handleInput("\t");

package/index.test.ts

@@ -21,7 +21,7 @@ describe("ask-user-question extension", () => {
 		expect(AskUserQuestionParams).toBeTruthy();
 		expect(errorResult("boom").content[0].text).toBe("boom");
 		expect(normalizeQuestions([{ id: "x", type: "text", prompt: "Q" }])[0].label).toBe("Q1");
-		expect(buildRenderCallText({ questions: [{ id: "x", type: "text", prompt: "Q" }] }, theme)).toContain("1 question");
+		expect(buildRenderCallText({ questions: [{ id: "x", type: "text", prompt: "Q" }] }, theme)).toContain("1개 문항");
 		expect(buildRenderResultText({ content: [{ type: "text", text: "plain" }] }, theme)).toBe("plain");
 	});
 
@@ -44,9 +44,9 @@ describe("ask-user-question extension", () => {
 		} as unknown as ExtensionContext);
 
 		expect(noUi).toMatchObject({
-			content: [{ type: "text", text: "Error: UI not available (running in non-interactive mode)" }],
+			content: [{ type: "text", text: "오류: UI를 사용할 수 없습니다. 현재 비대화형 모드에서 실행 중입니다." }],
 		});
-		expect(noQuestions).toMatchObject({ content: [{ type: "text", text: "Error: No questions provided" }] });
+		expect(noQuestions).toMatchObject({ content: [{ type: "text", text: "오류: 질문이 제공되지 않았습니다." }] });
 	});
 
 	it("returns cancelled and successful execution results", async () => {
@@ -103,7 +103,7 @@ describe("ask-user-question extension", () => {
 			} as unknown as ExtensionContext,
 		);
 
-		expect(cancelledResult).toMatchObject({ content: [{ type: "text", text: "User cancelled the form" }] });
+		expect(cancelledResult).toMatchObject({ content: [{ type: "text", text: "사용자가 입력 폼을 취소했습니다" }] });
 		expect(successResult).toMatchObject({ content: [{ type: "text", text: "Q1: hello\nQ2: a" }] });
 		expect(
 			tool.renderCall({ title: "Title", questions: [{ id: "x", type: "text", prompt: "Q" }] }, theme),

package/index.ts

@@ -13,25 +13,25 @@ import { AskUserQuestionParams } from "./schema.ts";
 import { normalizeQuestions } from "./state.ts";
 import type { AskUserQuestionParamsInput, FormResult, Question } from "./types.ts";
 
-const TOOL_DESCRIPTION = `Ask the user one or more questions using an interactive form. Supports three question types:
-- **radio**: Single-select from predefined options (like multiple choice)
-- **checkbox**: Multi-select from options (pick all that apply)
-- **text**: Free-form text input
+const TOOL_DESCRIPTION = `인터랙티브 폼으로 사용자에게 하나 이상의 질문을 묻습니다. 지원하는 질문 유형은 다음 세 가지입니다:
+- **radio**: 미리 정의된 보기 중 하나를 고르는 단일 선택
+- **checkbox**: 여러 보기를 동시에 고르는 복수 선택
+- **text**: 자유롭게 입력하는 텍스트 답변
 
-Each radio/checkbox question can include an "Other..." option that lets the user type a custom answer.
+radio/checkbox 질문에는 사용자가 직접 값을 입력할 수 있는 "기타..." 옵션을 포함할 수 있습니다.
 
-Use this tool when you need user input to proceed — for clarifying requirements, getting preferences, confirming decisions, or choosing between alternatives. Prefer this over asking plain-text questions in your response.`;
+요구사항을 확인하거나, 선호도를 물어보거나, 구현 방향에 대한 결정을 받아야 할 때 사용하세요. 일반 텍스트로 질문을 던지는 대신 이 도구를 우선 사용합니다.`;
 
 const PROMPT_GUIDELINES = [
-	"Use ask_user_question instead of asking questions in plain text when you need structured user input.",
-	"Prefer radio for single-choice, checkbox for multi-choice, text for open-ended answers.",
-	"Always include an 'Other' escape hatch (allowOther: true) unless the options are exhaustive.",
-	"Group related questions in a single call rather than making multiple separate calls.",
+	"구조화된 사용자 입력이 필요하면 일반 텍스트 질문 대신 ask_user_question을 사용하세요.",
+	"단일 선택은 radio, 복수 선택은 checkbox, 서술형 답변은 text를 우선 사용하세요.",
+	"선택지가 완전히 닫혀 있지 않다면 allowOther: true로 '기타' 입력 경로를 열어두세요.",
+	"관련 질문은 여러 번 나누지 말고 한 번의 호출에 묶어 전달하세요.",
 ];
 
 function buildCancelledResponse(result: FormResult) {
 	return {
-		content: [{ type: "text" as const, text: "User cancelled the form" }],
+		content: [{ type: "text" as const, text: "사용자가 입력 폼을 취소했습니다" }],
 		details: result,
 	};
 }
@@ -49,19 +49,19 @@ export { AskUserQuestionParams, buildRenderCallText, buildRenderResultText, erro
 export default function askUserQuestion(pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "ask_user_question",
-		label: "Ask User",
+		label: "사용자 질문",
 		description: TOOL_DESCRIPTION,
-		promptSnippet: "Ask the user interactive questions with radio, checkbox, or text inputs",
+		promptSnippet: "radio, checkbox, text 입력을 사용하는 인터랙티브 질문 폼 열기",
 		promptGuidelines: PROMPT_GUIDELINES,
 		parameters: AskUserQuestionParams,
 		async execute(_toolCallId, rawParams, _signal, _onUpdate, ctx) {
 			if (!ctx.hasUI) {
-				return errorResult("Error: UI not available (running in non-interactive mode)");
+				return errorResult("오류: UI를 사용할 수 없습니다. 현재 비대화형 모드에서 실행 중입니다.");
 			}
 
 			const params = rawParams as AskUserQuestionParamsInput;
 			if (!params.questions.length) {
-				return errorResult("Error: No questions provided");
+				return errorResult("오류: 질문이 제공되지 않았습니다.");
 			}
 
 			const questions = normalizeQuestions(params.questions as Question[]);

package/output.test.ts

@@ -40,7 +40,7 @@ describe("ask-user-question/output", () => {
 	});
 
 	it("formats successful result content", () => {
-		expect(formatResultContent(formResult)).toBe("One: (wrote) custom\nTwo: (none selected)\nThree: (empty)");
+		expect(formatResultContent(formResult)).toBe("One: (직접 입력) custom\nTwo: (선택 없음)\nThree: (비어 있음)");
 		expect(
 			formatResultContent({
 				...formResult,
@@ -62,8 +62,8 @@ describe("ask-user-question/output", () => {
 	it("builds render-call summaries", () => {
 		expect(
 			buildRenderCallText({ title: "Title", questions: [{ id: "x", type: "radio", prompt: "Q" }] }, theme),
-		).toContain("Title 1 question (radio)");
-		expect(buildRenderCallText({}, theme)).toContain("0 questions");
+		).toContain("Title 1개 문항 (radio)");
+		expect(buildRenderCallText({}, theme)).toContain("0개 문항");
 		expect(renderCall({ title: "Title", questions: [] }, theme)).toBeTruthy();
 	});
 
@@ -72,9 +72,9 @@ describe("ask-user-question/output", () => {
 		expect(buildRenderResultText({ content: [{ type: "text" }] }, theme)).toBe("");
 		expect(buildRenderResultText({ content: [{ type: "image", text: "ignored" }] }, theme)).toBe("");
 		expect(buildRenderResultText({}, theme)).toBe("");
-		expect(buildRenderResultText({ details: { ...formResult, cancelled: true } }, theme)).toBe("Cancelled");
+		expect(buildRenderResultText({ details: { ...formResult, cancelled: true } }, theme)).toBe("취소됨");
 		expect(buildRenderResultText({ details: formResult }, theme)).toBe(
-			"✓ One: (wrote) custom\n✓ Two: (none)\n✓ Three: (empty)",
+			"✓ One: (직접 입력) custom\n✓ Two: (선택 없음)\n✓ Three: (비어 있음)",
 		);
 		expect(
 			buildRenderResultText(

package/output.ts

@@ -19,14 +19,14 @@ export function formatResultContent(result: FormResult): string {
 			const question = result.questions.find((candidate) => candidate.id === answer.id);
 			const label = question?.label || answer.id;
 			if (answer.type === "radio") {
-				const prefix = answer.wasCustom ? "(wrote) " : "";
+				const prefix = answer.wasCustom ? "(직접 입력) " : "";
 				return `${label}: ${prefix}${answer.value}`;
 			}
 			if (answer.type === "checkbox") {
 				const values = Array.isArray(answer.value) ? answer.value : [answer.value];
-				return values.length === 0 ? `${label}: (none selected)` : `${label}: ${values.join(", ")}`;
+				return values.length === 0 ? `${label}: (선택 없음)` : `${label}: ${values.join(", ")}`;
 			}
-			return `${label}: ${answer.value || "(empty)"}`;
+			return `${label}: ${answer.value || "(비어 있음)"}`;
 		})
 		.join("\n");
 }
@@ -37,7 +37,7 @@ export function buildRenderCallText(args: { questions?: Question[]; title?: stri
 	if (args.title) {
 		text += `${theme.fg("accent", args.title)} `;
 	}
-	text += theme.fg("muted", `${questions.length} question${questions.length !== 1 ? "s" : ""}`);
+	text += theme.fg("muted", `${questions.length}개 문항`);
 	const types = [...new Set(questions.map((question) => question.type))].join(", ");
 	if (types) {
 		text += theme.fg("dim", ` (${types})`);
@@ -56,7 +56,7 @@ export function buildRenderResultText(
 	}
 
 	if (details.cancelled) {
-		return theme.fg("warning", "Cancelled");
+		return theme.fg("warning", "취소됨");
 	}
 
 	return details.answers
@@ -64,15 +64,15 @@ export function buildRenderResultText(
 			const question = details.questions.find((candidate) => candidate.id === answer.id);
 			const label = question?.label || answer.id;
 			if (answer.type === "radio") {
-				const prefix = answer.wasCustom ? theme.fg("dim", "(wrote) ") : "";
+				const prefix = answer.wasCustom ? theme.fg("dim", "(직접 입력) ") : "";
 				return `${theme.fg("success", SYM.check)} ${theme.fg("accent", label)}: ${prefix}${answer.value}`;
 			}
 			if (answer.type === "checkbox") {
 				const values = Array.isArray(answer.value) ? answer.value : [answer.value];
-				const display = values.length ? values.join(", ") : theme.fg("dim", "(none)");
+				const display = values.length ? values.join(", ") : theme.fg("dim", "(선택 없음)");
 				return `${theme.fg("success", SYM.check)} ${theme.fg("accent", label)}: ${display}`;
 			}
-			return `${theme.fg("success", SYM.check)} ${theme.fg("accent", label)}: ${answer.value || theme.fg("dim", "(empty)")}`;
+			return `${theme.fg("success", SYM.check)} ${theme.fg("accent", label)}: ${answer.value || theme.fg("dim", "(비어 있음)")}`;
 		})
 		.join("\n");
 }

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "@ryan_nookpi/pi-extension-ask-user-question",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "AskUserQuestion tool extension for pi.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Jonghakseo/pi-extension.git",
+    "directory": "packages/ask-user-question"
+  },
+  "bugs": {
+    "url": "https://github.com/Jonghakseo/pi-extension/issues"
+  },
+  "homepage": "https://github.com/Jonghakseo/pi-extension/tree/main/packages/ask-user-question#readme",
   "type": "module",
   "keywords": [
     "pi-package"

package/schema.ts

@@ -2,36 +2,35 @@ import { StringEnum } from "@mariozechner/pi-ai";
 import { Type } from "@sinclair/typebox";
 
 export const OptionSchema = Type.Object({
-	value: Type.String({ description: "Value returned when selected" }),
-	label: Type.String({ description: "Display label" }),
-	description: Type.Optional(Type.String({ description: "Help text shown below the label" })),
+	value: Type.String({ description: "선택 시 반환할 값" }),
+	label: Type.String({ description: "화면에 표시할 라벨" }),
+	description: Type.Optional(Type.String({ description: "옵션 아래에 표시할 보조 설명" })),
 });
 
 export const QuestionSchema = Type.Object({
-	id: Type.String({ description: "Unique identifier for this question" }),
+	id: Type.String({ description: "질문 고유 식별자" }),
 	type: StringEnum(["radio", "checkbox", "text"] as const, {
-		description: "Question type: radio (single-select), checkbox (multi-select), or text (free input)",
+		description: "질문 유형: radio(단일 선택), checkbox(복수 선택), text(자유 입력)",
 	}),
-	prompt: Type.String({ description: "The question text to display" }),
-	label: Type.Optional(Type.String({ description: "Short label for tab bar (defaults to Q1, Q2...)" })),
-	options: Type.Optional(Type.Array(OptionSchema, { description: "Options for radio/checkbox types" })),
+	prompt: Type.String({ description: "사용자에게 표시할 질문 문구" }),
+	label: Type.Optional(Type.String({ description: "탭 바에 표시할 짧은 라벨(기본값: Q1, Q2...)" })),
+	options: Type.Optional(Type.Array(OptionSchema, { description: "radio/checkbox용 선택지 목록" })),
 	allowOther: Type.Optional(
-		Type.Boolean({ description: "Add an 'Other...' option with text input (default: true for radio/checkbox)" }),
+		Type.Boolean({ description: "'기타...' 직접 입력 옵션 추가 여부 (radio/checkbox 기본값: true)" }),
 	),
-	required: Type.Optional(Type.Boolean({ description: "Whether an answer is required (default: true)" })),
-	placeholder: Type.Optional(Type.String({ description: "Placeholder for text inputs" })),
+	required: Type.Optional(Type.Boolean({ description: "응답 필수 여부 (기본값: true)" })),
+	placeholder: Type.Optional(Type.String({ description: "text 입력 시 표시할 플레이스홀더" })),
 	default: Type.Optional(
 		Type.Union([Type.String(), Type.Array(Type.String())], {
-			description: "Default value(s). String for radio/text, string[] for checkbox",
+			description: "기본값. radio/text는 문자열, checkbox는 문자열 배열",
 		}),
 	),
 });
 
 export const AskUserQuestionParams = Type.Object({
-	title: Type.Optional(Type.String({ description: "Form title displayed at the top" })),
-	description: Type.Optional(Type.String({ description: "Brief context or instructions shown under the title" })),
+	title: Type.Optional(Type.String({ description: "폼 상단에 표시할 제목" })),
+	description: Type.Optional(Type.String({ description: "폼 상단에 표시할 안내 문구" })),
 	questions: Type.Array(QuestionSchema, {
-		description:
-			"One or more questions to ask. Use radio for single-select, checkbox for multi-select, text for free input",
+		description: "질문 목록. radio는 단일 선택, checkbox는 복수 선택, text는 자유 입력",
 	}),
 });

package/view.test.ts

@@ -52,10 +52,10 @@ describe("ask-user-question/view", () => {
 		const input = createInput({ currentTab: 2 });
 		const output = renderForm(input).join("\n");
 
-		expect(output).toContain("Review & Submit");
+		expect(output).toContain("검토 및 제출");
 		expect(output).toContain("Q1:");
-		expect(output).toContain("Required: Q1, Q2");
-		expect(output).toContain("Tab/←→ navigate questions • Enter submit • Esc cancel");
+		expect(output).toContain("필수 응답: Q1, Q2");
+		expect(output).toContain("Tab/←→ 질문 이동 • Enter 제출 • Esc 취소");
 	});
 
 	it("renders radio questions including descriptions and other-mode editor", () => {
@@ -80,12 +80,12 @@ describe("ask-user-question/view", () => {
 			}),
 		).join("\n");
 
-		expect(output).toContain("**Pick one** [single-select]");
+		expect(output).toContain("**Pick one** [단일 선택]");
 		expect(output).toContain("Alpha");
 		expect(output).toContain("first");
-		expect(output).toContain("Other: custom");
-		expect(output).toContain("Your answer:");
-		expect(output).toContain("Enter submit • Esc go back");
+		expect(output).toContain("기타: custom");
+		expect(output).toContain("직접 입력:");
+		expect(output).toContain("Enter 제출 • Esc 돌아가기");
 	});
 
 	it("renders checkbox and text questions with placeholders and text footer", () => {
@@ -110,17 +110,17 @@ describe("ask-user-question/view", () => {
 		const checkboxOutput = renderForm(createInput({ questions, answerState, editorLines: [], editorText: "" })).join(
 			"\n",
 		);
-		expect(checkboxOutput).toContain("**Pick many** [multi-select]");
-		expect(checkboxOutput).toContain("Other: custom option");
-		expect(checkboxOutput).toContain("Space toggle");
+		expect(checkboxOutput).toContain("**Pick many** [복수 선택]");
+		expect(checkboxOutput).toContain("기타: custom option");
+		expect(checkboxOutput).toContain("Space 토글");
 
 		const textOutput = renderForm(
 			createInput({ questions, answerState, currentTab: 1, editorLines: ["typed line"], editorText: "" }),
 		).join("\n");
-		expect(textOutput).toContain("**Explain** [text]");
+		expect(textOutput).toContain("**Explain** [텍스트]");
 		expect(textOutput).toContain("Type here");
 		expect(textOutput).toContain("typed line");
-		expect(textOutput).toContain("Tab/←→ navigate • Enter submit • Esc cancel");
+		expect(textOutput).toContain("Tab/←→ 이동 • Enter 제출 • Esc 취소");
 	});
 
 	it("renders answered submit states and optional question variants", () => {
@@ -152,27 +152,27 @@ describe("ask-user-question/view", () => {
 		answerState.textAnswers.set("text", "filled");
 
 		const submitOutput = renderForm(createInput({ questions, answerState, currentTab: 3 })).join("\n");
-		expect(submitOutput).toContain("Press Enter to submit");
+		expect(submitOutput).toContain("Enter로 제출");
 		expect(submitOutput).toContain("Alpha");
 		expect(submitOutput).toContain("b");
 		expect(submitOutput).toContain("filled");
 
 		const radioOutput = renderForm(createInput({ questions, answerState, currentTab: 0, cursorIdx: 0 })).join("\n");
 		expect(radioOutput).toContain("❯ ◉ Alpha");
-		expect(radioOutput).toContain("Enter select • Esc cancel");
-		expect(radioOutput).not.toContain("Other...");
+		expect(radioOutput).toContain("Enter 선택 • Esc 취소");
+		expect(radioOutput).not.toContain("기타...");
 
 		const checkboxOutput = renderForm(createInput({ questions, answerState, currentTab: 1, cursorIdx: 0 })).join("\n");
 		expect(checkboxOutput).toContain("☑ Beta");
 		expect(checkboxOutput).toContain("desc");
-		expect(checkboxOutput).toContain("Enter next");
+		expect(checkboxOutput).toContain("Enter 다음");
 
 		const textOutput = renderForm(
 			createInput({ questions, answerState, currentTab: 2, editorLines: ["filled"], editorText: "filled" }),
 		).join("\n");
 		expect(textOutput).toContain("filled");
-		expect(textOutput).toContain("Enter submit • Esc cancel");
-		expect(textOutput).not.toContain("*required");
+		expect(textOutput).toContain("Enter 제출 • Esc 취소");
+		expect(textOutput).not.toContain("*필수");
 	});
 
 	it("covers direct helper branches for invalid tabs and compact variants", () => {
@@ -198,7 +198,7 @@ describe("ask-user-question/view", () => {
 		submitInput.answerState.radioAnswers.set("radio", { value: "custom", label: "custom", wasCustom: true });
 		submitInput.answerState.checkCustom.set("check", "custom");
 		renderSubmitTab(submitInput, (text) => submitLines.push(text), 80);
-		expect(submitLines.join("\n")).toContain("(wrote) custom");
+		expect(submitLines.join("\n")).toContain("(직접 입력) custom");
 
 		const unansweredLines: string[] = [];
 		const unansweredInput = createInput({
@@ -207,7 +207,7 @@ describe("ask-user-question/view", () => {
 		});
 		unansweredInput.answerState.checkAnswers.delete("check");
 		renderSubmitTab(unansweredInput, (text) => unansweredLines.push(text), 80);
-		expect(unansweredLines.join("\n")).toContain("(unanswered)");
+		expect(unansweredLines.join("\n")).toContain("(미응답)");
 
 		const output = renderForm(createInput({ currentTab: 99 }));
 		expect(output.length).toBeGreaterThanOrEqual(2);
@@ -233,7 +233,7 @@ describe("ask-user-question/view", () => {
 			80,
 		);
 		expect(radioLines.join("\n")).toContain("❯ ◉ Alpha");
-		expect(radioLines.join("\n")).toContain("Other...");
+		expect(radioLines.join("\n")).toContain("기타...");
 		const radioSelectedLines: string[] = [];
 		renderQuestion(
 			createInput({
@@ -264,8 +264,8 @@ describe("ask-user-question/view", () => {
 			}),
 		).join("\n");
 		expect(checkboxOutput).toContain("☐ Alpha");
-		expect(checkboxOutput).toContain("Other...");
-		expect(checkboxOutput).toContain("Enter submit • Esc cancel");
+		expect(checkboxOutput).toContain("기타...");
+		expect(checkboxOutput).toContain("Enter 제출 • Esc 취소");
 		checkboxState.checkAnswers.set("check", new Set(["a"]));
 		const checkboxOtherCursor = renderForm(
 			createInput({
@@ -278,7 +278,7 @@ describe("ask-user-question/view", () => {
 			}),
 		).join("\n");
 		expect(checkboxOtherCursor).toContain("☑ Alpha");
-		expect(checkboxOtherCursor).toContain("❯ ☐ Other...");
+		expect(checkboxOtherCursor).toContain("❯ ☐ 기타...");
 		const checkboxLines: string[] = [];
 		renderQuestion(
 			createInput({
@@ -319,7 +319,7 @@ describe("ask-user-question/view", () => {
 				editorLines: [],
 			}),
 		).join("\n");
-		expect(radioFooterOutput).toContain("Enter select • Esc cancel");
+		expect(radioFooterOutput).toContain("Enter 선택 • Esc 취소");
 		const textOutput = renderForm(
 			createInput({
 				title: undefined,
@@ -330,8 +330,8 @@ describe("ask-user-question/view", () => {
 				editorText: "",
 			}),
 		).join("\n");
-		expect(textOutput).toContain("**Only** [text]");
-		expect(textOutput).toContain("Enter submit • Esc cancel");
-		expect(textOutput).not.toContain("*required");
+		expect(textOutput).toContain("**Only** [텍스트]");
+		expect(textOutput).toContain("Enter 제출 • Esc 취소");
+		expect(textOutput).not.toContain("*필수");
 	});
 });

package/view.ts

@@ -14,7 +14,7 @@ function createLineHelpers(width: number, theme: RenderFormInput["theme"]) {
 
 export function renderSubmitTab(input: RenderFormInput, add: (text: string) => void, maxWidth: number): void {
 	const { questions, answerState, theme } = input;
-	add(` ${theme.fg("accent", theme.bold("Review & Submit"))}`);
+	add(` ${theme.fg("accent", theme.bold("검토 및 제출"))}`);
 	add("");
 
 	for (const question of questions) {
@@ -22,10 +22,10 @@ export function renderSubmitTab(input: RenderFormInput, add: (text: string) => v
 		if (question.type === "radio") {
 			const answer = answerState.radioAnswers.get(question.id);
 			if (answer) {
-				const prefix = answer.wasCustom ? theme.fg("dim", "(wrote) ") : "";
+				const prefix = answer.wasCustom ? theme.fg("dim", "(직접 입력) ") : "";
 				add(` ${label} ${prefix}${answer.label}`);
 			} else {
-				add(` ${label} ${theme.fg("warning", "(unanswered)")}`);
+				add(` ${label} ${theme.fg("warning", "(미응답)")}`);
 			}
 			continue;
 		}
@@ -34,8 +34,8 @@ export function renderSubmitTab(input: RenderFormInput, add: (text: string) => v
 			const selected = answerState.checkAnswers.get(question.id) ?? new Set<string>();
 			const custom = answerState.checkCustom.get(question.id)?.trim();
 			const values = [...selected];
-			if (custom) values.push(`${theme.fg("dim", "(wrote)")} ${custom}`);
-			add(` ${label} ${values.length ? values.join(", ") : theme.fg("warning", "(unanswered)")}`);
+			if (custom) values.push(`${theme.fg("dim", "(직접 입력)")} ${custom}`);
+			add(` ${label} ${values.length ? values.join(", ") : theme.fg("warning", "(미응답)")}`);
 			continue;
 		}
 
@@ -43,23 +43,23 @@ export function renderSubmitTab(input: RenderFormInput, add: (text: string) => v
 		if (answer) {
 			add(` ${label} ${truncateToWidth(answer, maxWidth - visibleWidth(question.label) - 5)}`);
 		} else {
-			add(` ${label} ${theme.fg("warning", "(unanswered)")}`);
+			add(` ${label} ${theme.fg("warning", "(미응답)")}`);
 		}
 	}
 
 	add("");
 	if (allRequiredAnswered(answerState, questions)) {
-		add(` ${theme.fg("success", "Press Enter to submit")}`);
+		add(` ${theme.fg("success", "Enter로 제출")}`);
 	} else {
 		const missing = questions
 			.filter((question) => question.required && !isAnswered(answerState, question))
 			.map((question) => question.label)
 			.join(", ");
-		add(` ${theme.fg("warning", `Required: ${missing}`)}`);
+		add(` ${theme.fg("warning", `필수 응답: ${missing}`)}`);
 	}
 
 	add("");
-	add(theme.fg("dim", " Tab/←→ navigate questions • Enter submit • Esc cancel"));
+	add(theme.fg("dim", " Tab/←→ 질문 이동 • Enter 제출 • Esc 취소"));
 }
 
 export function renderTabBar(input: RenderFormInput, add: (text: string) => void): void {
@@ -76,7 +76,7 @@ export function renderTabBar(input: RenderFormInput, add: (text: string) => void
 	}
 
 	const submitActive = currentTab === questions.length;
-	const submitText = ` ${SYM.submit} Submit `;
+	const submitText = ` ${SYM.submit} 제출 `;
 	tabs.push(
 		submitActive
 			? theme.bg("selectedBg", theme.fg("text", submitText))
@@ -93,13 +93,13 @@ export function renderQuestion(input: RenderFormInput, add: (text: string) => vo
 
 	const typeTag =
 		question.type === "radio"
-			? input.theme.fg("dim", "[single-select]")
+			? input.theme.fg("dim", "[단일 선택]")
 			: question.type === "checkbox"
-				? input.theme.fg("dim", "[multi-select]")
-				: input.theme.fg("dim", "[text]");
+				? input.theme.fg("dim", "[복수 선택]")
+				: input.theme.fg("dim", "[텍스트]");
 
 	add(` ${input.theme.fg("text", input.theme.bold(question.prompt))} ${typeTag}`);
-	if (question.required) add(` ${input.theme.fg("warning", "*required")}`);
+	if (question.required) add(` ${input.theme.fg("warning", "*필수")}`);
 	add("");
 
 	if (question.type === "radio") {
@@ -119,7 +119,7 @@ export function renderQuestion(input: RenderFormInput, add: (text: string) => vo
 			const isSelected = selected?.wasCustom === true;
 			const bullet = isSelected ? input.theme.fg("accent", SYM.radioOn) : input.theme.fg("dim", SYM.radioOff);
 			const pointer = isCursor ? input.theme.fg("accent", SYM.pointer) : " ";
-			const label = isSelected ? `Other: ${selected.label}` : "Other...";
+			const label = isSelected ? `기타: ${selected.label}` : "기타...";
 			add(` ${pointer} ${bullet} ${input.theme.fg(isCursor ? "accent" : "muted", label)}`);
 		}
 	}
@@ -141,14 +141,14 @@ export function renderQuestion(input: RenderFormInput, add: (text: string) => vo
 			const custom = input.answerState.checkCustom.get(question.id)?.trim();
 			const box = custom ? input.theme.fg("accent", SYM.checkOn) : input.theme.fg("dim", SYM.checkOff);
 			const pointer = isCursor ? input.theme.fg("accent", SYM.pointer) : " ";
-			const label = custom ? `Other: ${custom}` : "Other...";
+			const label = custom ? `기타: ${custom}` : "기타...";
 			add(` ${pointer} ${box} ${input.theme.fg(isCursor ? "accent" : "muted", label)}`);
 		}
 	}
 
 	if (input.otherMode) {
 		add("");
-		add(` ${input.theme.fg("muted", "  Your answer:")}`);
+		add(` ${input.theme.fg("muted", "  직접 입력:")}`);
 		for (const line of input.editorLines) add(`   ${line}`);
 		return;
 	}
@@ -172,22 +172,22 @@ export function renderFooter(input: RenderFormInput, add: (text: string) => void
 	if (!question) return;
 	add("");
 	if (input.otherMode) {
-		add(input.theme.fg("dim", " Enter submit • Esc go back"));
+		add(input.theme.fg("dim", " Enter 제출 • Esc 돌아가기"));
 		return;
 	}
 	if (question.type === "text") {
-		const nav = input.questions.length > 1 ? "Tab/←→ navigate • " : "";
-		add(input.theme.fg("dim", ` ${nav}Enter submit • Esc cancel`));
+		const nav = input.questions.length > 1 ? "Tab/←→ 이동 • " : "";
+		add(input.theme.fg("dim", ` ${nav}Enter 제출 • Esc 취소`));
 		return;
 	}
 	if (question.type === "checkbox") {
-		const nav = input.questions.length > 1 ? "Tab/←→ navigate • " : "";
-		const enterAction = input.questions.length > 1 ? "next" : "submit";
-		add(input.theme.fg("dim", ` ↑↓ navigate • Space toggle • ${nav}Enter ${enterAction} • Esc cancel`));
+		const nav = input.questions.length > 1 ? "Tab/←→ 이동 • " : "";
+		const enterAction = input.questions.length > 1 ? "다음" : "제출";
+		add(input.theme.fg("dim", ` ↑↓ 이동 • Space 토글 • ${nav}Enter ${enterAction} • Esc 취소`));
 		return;
 	}
-	const nav = input.questions.length > 1 ? "Tab/←→ navigate • " : "";
-	add(input.theme.fg("dim", ` ↑↓ navigate • ${nav}Enter select • Esc cancel`));
+	const nav = input.questions.length > 1 ? "Tab/←→ 이동 • " : "";
+	add(input.theme.fg("dim", ` ↑↓ 이동 • ${nav}Enter 선택 • Esc 취소`));
 }
 
 export function renderForm(input: RenderFormInput): string[] {