agent-work-loop 0.0.0 → 0.6.22

package/dist/chunk-UOPWVM2H.js

@@ -0,0 +1,727 @@
+import {
+  LANG_OPTIONS,
+  LANG_VALUES,
+  ask,
+  buildScreens,
+  promptNumber
+} from "./chunk-BUWGQVHT.js";
+import {
+  caps,
+  card,
+  findProjectRoot,
+  makeColors,
+  makeSymbols,
+  signal
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/config.ts
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+
+// src/core/runner.ts
+import { performance } from "perf_hooks";
+import spawn from "cross-spawn";
+var CommandNotFoundError = class extends Error {
+  command;
+  constructor(command) {
+    super(`\uBA85\uB839\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${command}`);
+    this.name = "CommandNotFoundError";
+    this.command = command;
+  }
+};
+function tokenize(cmd) {
+  const tokens = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let match = re.exec(cmd);
+  while (match !== null) {
+    tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+    match = re.exec(cmd);
+  }
+  return tokens;
+}
+function run(spec) {
+  return new Promise((resolve, reject) => {
+    const tokens = spec.args ? [spec.cmd, ...spec.args] : tokenize(spec.cmd);
+    const program = tokens[0];
+    const args = tokens.slice(1);
+    if (!program) {
+      reject(new Error("\uBE48 \uBA85\uB839\uC785\uB2C8\uB2E4."));
+      return;
+    }
+    const start = performance.now();
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let timer;
+    let settled = false;
+    const child = spawn(program, args, {
+      cwd: spec.cwd,
+      // process.env 를 상속하고 spec.env 로 덮어쓴다. PATH 등은 유지된다.
+      env: { ...process.env, ...spec.env },
+      shell: false,
+      signal: spec.signal,
+      windowsHide: true
+    });
+    const clearTimer = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+    };
+    if (spec.timeoutMs !== void 0 && spec.timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+      }, spec.timeoutMs);
+    }
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimer();
+      if (err.code === "ENOENT") {
+        reject(new CommandNotFoundError(program));
+        return;
+      }
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimer();
+      resolve({
+        exitCode: code,
+        stdout,
+        stderr,
+        durationMs: Math.round(performance.now() - start),
+        timedOut
+      });
+    });
+  });
+}
+
+// src/commands/config.ts
+var VERIFY_ORDER = ["typecheck", "lint", "test", "e2e"];
+function resolveProjectRoot(cwd = process.cwd()) {
+  try {
+    return findProjectRoot(cwd);
+  } catch {
+    return null;
+  }
+}
+function isVerifyEntry(v) {
+  if (v === null) {
+    return true;
+  }
+  if (typeof v !== "object") {
+    return false;
+  }
+  const o = v;
+  if (typeof o.cmd !== "string") {
+    return false;
+  }
+  if ("cwd" in o && o.cwd !== void 0 && typeof o.cwd !== "string") {
+    return false;
+  }
+  if ("env" in o && o.env !== void 0 && (typeof o.env !== "object" || o.env === null)) {
+    return false;
+  }
+  return true;
+}
+function validateConfig(obj) {
+  const errors = [];
+  if (typeof obj !== "object" || obj === null) {
+    errors.push("config \uAC00 \uAC1D\uCCB4\uAC00 \uC544\uB2D9\uB2C8\uB2E4");
+    return errors;
+  }
+  const o = obj;
+  if (typeof o.project !== "string" || o.project.trim() === "") {
+    errors.push("project \uAC00 \uC5C6\uC2B5\uB2C8\uB2E4 (\uBB38\uC790\uC5F4 \uD544\uC218)");
+  }
+  if (typeof o.engineVersion !== "string") {
+    errors.push("engineVersion \uC774 \uC5C6\uC2B5\uB2C8\uB2E4 (\uBB38\uC790\uC5F4 \uD544\uC218)");
+  }
+  if (typeof o.verify !== "object" || o.verify === null) {
+    errors.push("verify \uAC00 \uC5C6\uC2B5\uB2C8\uB2E4 (\uAC1D\uCCB4 \uD544\uC218)");
+  } else {
+    const v = o.verify;
+    for (const k of VERIFY_ORDER) {
+      if (k in v && !isVerifyEntry(v[k])) {
+        errors.push(`verify.${k} \uD615\uC2DD \uC624\uB958 (null \uB610\uB294 { "cmd": "..." })`);
+      }
+    }
+  }
+  if ("protectedFiles" in o && (!Array.isArray(o.protectedFiles) || !o.protectedFiles.every((p) => typeof p === "string"))) {
+    errors.push("protectedFiles \uD615\uC2DD \uC624\uB958 (\uBB38\uC790\uC5F4 \uBC30\uC5F4)");
+  }
+  return errors;
+}
+function jsonErrorLocation(text, err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const m = /position (\d+)/.exec(msg);
+  if (m?.[1]) {
+    const line = text.slice(0, Number(m[1])).split("\n").length;
+    return `${msg} (\uC57D ${line}\uBC88\uC9F8 \uC904)`;
+  }
+  return msg;
+}
+function loadConfig(projectRoot) {
+  const p = path.join(projectRoot, ".awl", "config.json");
+  if (!fs.existsSync(p)) {
+    return { config: null, errors: ["config.json \uC774 \uC5C6\uC2B5\uB2C8\uB2E4. awl init \uC744 \uC2E4\uD589\uD558\uC138\uC694."], path: p };
+  }
+  let text;
+  try {
+    text = fs.readFileSync(p, "utf8");
+  } catch (e) {
+    return { config: null, errors: [`config.json \uC744 \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${String(e)}`], path: p };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (e) {
+    return {
+      config: null,
+      errors: [`config.json JSON \uD30C\uC2F1 \uC624\uB958: ${jsonErrorLocation(text, e)}`],
+      path: p
+    };
+  }
+  const errors = validateConfig(parsed);
+  if (errors.length > 0) {
+    return { config: null, errors, path: p };
+  }
+  const raw = parsed;
+  const rv = raw.verify;
+  const config = {
+    project: raw.project,
+    mainLanguage: typeof raw.mainLanguage === "string" ? raw.mainLanguage : "",
+    character: typeof raw.character === "string" ? raw.character : "",
+    engineVersion: raw.engineVersion,
+    ...typeof raw.namingConvention === "string" ? { namingConvention: raw.namingConvention } : {},
+    ...typeof raw.relatedCmd === "string" ? { relatedCmd: raw.relatedCmd } : {},
+    ...Array.isArray(raw.protectedFiles) ? { protectedFiles: raw.protectedFiles } : {},
+    verify: {
+      typecheck: rv.typecheck ?? null,
+      lint: rv.lint ?? null,
+      test: rv.test ?? null,
+      e2e: rv.e2e ?? null
+    }
+  };
+  return { config, errors: [], path: p };
+}
+function requireConfig() {
+  const projectRoot = resolveProjectRoot();
+  if (!projectRoot) {
+    process.stderr.write(
+      `
+  ${signal(caps(), "error")} \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4(.git/.awl \uC5C6\uC74C). awl init \uC744 \uC2E4\uD589\uD558\uC138\uC694.
+`
+    );
+    process.exit(1);
+  }
+  const loaded = loadConfig(projectRoot);
+  if (!loaded.config) {
+    process.stderr.write(`
+  ${signal(caps(), "error")} config \uB97C \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4:
+`);
+    for (const e of loaded.errors) {
+      process.stderr.write(`    - ${e}
+`);
+    }
+    process.exit(1);
+  }
+  return { projectRoot, config: loaded.config };
+}
+function parseVerifyValue(value) {
+  const trimmed = value.trim();
+  if (trimmed === "" || trimmed.toLowerCase() === "null" || trimmed === "none" || trimmed === "-") {
+    return null;
+  }
+  const env = {};
+  let rest = trimmed;
+  const re = /^(\w+)=(\S+)\s+/;
+  let m = re.exec(rest);
+  while (m !== null) {
+    env[m[1]] = m[2];
+    rest = rest.slice(m[0].length);
+    m = re.exec(rest);
+  }
+  return Object.keys(env).length > 0 ? { cmd: rest, env } : { cmd: rest };
+}
+var KNOWN_LANGUAGES = ["typescript", "javascript", "python"];
+var KNOWN_NAMING_CONVENTIONS = ["kebab-case", "camelCase", "snake_case", "PascalCase"];
+var SETTABLE_KEYS = [
+  "project",
+  "mainLanguage",
+  "character",
+  "namingConvention",
+  "relatedCmd",
+  "protectedFiles",
+  ...VERIFY_ORDER.flatMap((n) => [`verify.${n}.cmd`, `verify.${n}.cwd`, `verify.${n}.env`])
+];
+function parseConfigKey(key) {
+  if (key === "project") {
+    return { kind: "project" };
+  }
+  if (key === "mainLanguage") {
+    return { kind: "mainLanguage" };
+  }
+  if (key === "character") {
+    return { kind: "character" };
+  }
+  if (key === "namingConvention") {
+    return { kind: "namingConvention" };
+  }
+  if (key === "relatedCmd") {
+    return { kind: "relatedCmd" };
+  }
+  if (key === "protectedFiles") return { kind: "protectedFiles" };
+  const names = VERIFY_ORDER.join("|");
+  const cmdMatch = new RegExp(`^verify\\.(${names})(?:\\.cmd)?$`).exec(key);
+  if (cmdMatch?.[1]) {
+    return { kind: "verify.cmd", verifyName: cmdMatch[1] };
+  }
+  const cwdMatch = new RegExp(`^verify\\.(${names})\\.cwd$`).exec(key);
+  if (cwdMatch?.[1]) {
+    return { kind: "verify.cwd", verifyName: cwdMatch[1] };
+  }
+  const envMatch = new RegExp(`^verify\\.(${names})\\.env$`).exec(key);
+  if (envMatch?.[1]) {
+    return { kind: "verify.env", verifyName: envMatch[1] };
+  }
+  return null;
+}
+async function verifyCommandExists(entry, cwd) {
+  const first = entry.cmd.split(/\s+/)[0] ?? "";
+  try {
+    const r = await run({ cmd: first, args: ["--version"], env: entry.env, cwd, timeoutMs: 5e3 });
+    return { ok: true, note: `\uC885\uB8CC \uCF54\uB4DC ${r.exitCode}` };
+  } catch (e) {
+    return {
+      ok: false,
+      note: e instanceof CommandNotFoundError ? `\uBA85\uB839\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${first}` : `\uC2E4\uD589 \uC624\uB958: ${String(e)}`
+    };
+  }
+}
+function resolveCwd(projectRoot, cwd) {
+  if (!cwd) {
+    return void 0;
+  }
+  return path.isAbsolute(cwd) ? cwd : path.join(projectRoot, cwd);
+}
+async function applyConfigValue(config, projectRoot, parsed, rawValue, opts) {
+  if (parsed.kind === "project") {
+    const v2 = rawValue.trim();
+    if (v2 === "") {
+      return { ok: false, message: "project \uB294 \uBE44\uC6B8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." };
+    }
+    config.project = v2;
+    return { ok: true, message: `project = ${v2}` };
+  }
+  if (parsed.kind === "mainLanguage") {
+    const v2 = rawValue.trim();
+    if (v2 === "") {
+      return { ok: false, message: "mainLanguage \uB294 \uBE44\uC6B8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." };
+    }
+    config.mainLanguage = v2;
+    if (!KNOWN_LANGUAGES.includes(v2)) {
+      return {
+        ok: true,
+        message: `mainLanguage = ${v2}  (\uACBD\uACE0: \uC54C\uB824\uC9C4 \uAC12\uC774 \uC544\uB2D9\uB2C8\uB2E4 \u2014 ${KNOWN_LANGUAGES.join("/")})`
+      };
+    }
+    return { ok: true, message: `mainLanguage = ${v2}` };
+  }
+  if (parsed.kind === "character") {
+    config.character = rawValue;
+    return { ok: true, message: `character = ${rawValue || "(\uBE44\uC6C0)"}` };
+  }
+  if (parsed.kind === "namingConvention") {
+    const v2 = rawValue.trim();
+    if (v2 === "") {
+      config.namingConvention = void 0;
+      return { ok: true, message: "namingConvention = (\uBE44\uC6C0)" };
+    }
+    config.namingConvention = v2;
+    if (!KNOWN_NAMING_CONVENTIONS.includes(v2)) {
+      return {
+        ok: true,
+        message: `namingConvention = ${v2}  (\uACBD\uACE0: \uC54C\uB824\uC9C4 \uAC12\uC774 \uC544\uB2D9\uB2C8\uB2E4 \u2014 ${KNOWN_NAMING_CONVENTIONS.join("/")})`
+      };
+    }
+    return { ok: true, message: `namingConvention = ${v2}` };
+  }
+  if (parsed.kind === "relatedCmd") {
+    const v2 = rawValue.trim();
+    if (v2 === "") {
+      config.relatedCmd = void 0;
+      return { ok: true, message: "relatedCmd = (\uBE44\uC6C0)" };
+    }
+    if (!v2.includes("{files}")) {
+      return {
+        ok: false,
+        message: "relatedCmd \uC5D0\uB294 {files} \uC790\uB9AC\uD45C\uC2DC\uC790\uAC00 \uC788\uC5B4\uC57C \uD569\uB2C8\uB2E4(\uBCC0\uACBD \uD30C\uC77C \uBAA9\uB85D\uC73C\uB85C \uCE58\uD658\uB429\uB2C8\uB2E4)."
+      };
+    }
+    config.relatedCmd = v2;
+    return { ok: true, message: `relatedCmd = ${v2}` };
+  }
+  if (parsed.kind === "protectedFiles") {
+    let files;
+    try {
+      files = JSON.parse(rawValue);
+    } catch {
+      return { ok: false, message: "protectedFiles \uB294 JSON \uBB38\uC790\uC5F4 \uBC30\uC5F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4." };
+    }
+    if (!Array.isArray(files) || !files.every((file) => typeof file === "string" && file.trim() !== "")) {
+      return { ok: false, message: "protectedFiles \uB294 \uBE44\uC5B4 \uC788\uC9C0 \uC54A\uC740 \uBB38\uC790\uC5F4 \uBC30\uC5F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4." };
+    }
+    config.protectedFiles = files;
+    return { ok: true, message: `protectedFiles = ${files.join(", ") || "(\uBE44\uC6C0)"}` };
+  }
+  const name = parsed.verifyName;
+  if (parsed.kind === "verify.cmd") {
+    const entry = parseVerifyValue(rawValue);
+    const prevCwd = config.verify[name]?.cwd;
+    if (entry) {
+      const check = await verifyCommandExists(entry, resolveCwd(projectRoot, prevCwd));
+      if (!check.ok && !opts.force) {
+        return {
+          ok: false,
+          message: `'${entry.cmd}' \uD655\uC778 \uC2E4\uD328: ${check.note}
+\uADF8\uB798\uB3C4 \uC800\uC7A5\uD558\uB824\uBA74 --force \uB97C \uBD99\uC774\uC138\uC694.`
+        };
+      }
+    }
+    config.verify[name] = entry ? { ...entry, ...prevCwd ? { cwd: prevCwd } : {} } : null;
+    return { ok: true, message: `verify.${name}.cmd = ${entry ? entry.cmd : "null"}` };
+  }
+  const existing = config.verify[name];
+  if (!existing) {
+    return {
+      ok: false,
+      message: `verify.${name} \uC774 \uC124\uC815\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 cmd \uB97C \uC124\uC815\uD558\uC138\uC694: awl config set verify.${name}.cmd "..."`
+    };
+  }
+  if (parsed.kind === "verify.cwd") {
+    const v2 = rawValue.trim();
+    if (v2 === "" || v2.toLowerCase() === "null" || v2 === "-") {
+      existing.cwd = void 0;
+      return { ok: true, message: `verify.${name}.cwd = (\uC5C6\uC74C)` };
+    }
+    const abs = resolveCwd(projectRoot, v2);
+    const dirExists = fs.existsSync(abs) && fs.statSync(abs).isDirectory();
+    let warn = "";
+    if (path.isAbsolute(v2)) {
+      warn += "\n\uACBD\uACE0: \uC808\uB300 \uACBD\uB85C\uC785\uB2C8\uB2E4. \uB2E4\uB978 \uC0AC\uB78C\uC758 \uBA38\uC2E0\uC5D0\uC11C\uB294 \uB2E4\uB978 \uC704\uCE58\uB97C \uAC00\uB9AC\uD0AC \uC218 \uC788\uC2B5\uB2C8\uB2E4.";
+    }
+    if (!dirExists) {
+      if (!opts.force) {
+        return {
+          ok: false,
+          message: `\uB514\uB809\uD1A0\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4: ${abs}
+\uADF8\uB798\uB3C4 \uC800\uC7A5\uD558\uB824\uBA74 --force \uB97C \uBD99\uC774\uC138\uC694.`
+        };
+      }
+      warn += `
+\uACBD\uACE0: \uB514\uB809\uD1A0\uB9AC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4: ${abs} (\uAC15\uC81C \uC800\uC7A5)`;
+    }
+    existing.cwd = v2;
+    return { ok: true, message: `verify.${name}.cwd = ${v2}${warn}` };
+  }
+  const v = rawValue.trim();
+  if (v === "" || v.toLowerCase() === "null" || v === "-") {
+    existing.env = void 0;
+    return { ok: true, message: `verify.${name}.env = (\uC5C6\uC74C)` };
+  }
+  let parsedEnv;
+  try {
+    parsedEnv = JSON.parse(v);
+  } catch (e) {
+    return { ok: false, message: `env \uB294 JSON \uAC1D\uCCB4\uC5EC\uC57C \uD569\uB2C8\uB2E4: ${String(e)}` };
+  }
+  if (typeof parsedEnv !== "object" || parsedEnv === null || Array.isArray(parsedEnv)) {
+    return { ok: false, message: 'env \uB294 JSON \uAC1D\uCCB4\uC5EC\uC57C \uD569\uB2C8\uB2E4 (\uC608: {"NODE_ENV":"test"})' };
+  }
+  existing.env = parsedEnv;
+  return { ok: true, message: `verify.${name}.env = ${v}` };
+}
+function renderConfig(config, c) {
+  const color = makeColors(c.color);
+  const s = makeSymbols(c);
+  const out = [];
+  out.push(`${s.branch} \uC8FC \uC5B8\uC5B4  ${config.mainLanguage || "(\uC5C6\uC74C)"}`);
+  out.push(`${s.branch} \uC131\uACA9     ${config.character || "(\uC5C6\uC74C)"}`);
+  out.push(`${s.branch} \uC5D4\uC9C4     ${config.engineVersion}`);
+  out.push("");
+  for (const k of VERIFY_ORDER) {
+    const entry = config.verify[k];
+    out.push(`${s.branch} ${k.padEnd(10, " ")}${entry ? entry.cmd : "(\uC5C6\uC74C)"}`);
+    if (entry?.cwd) {
+      out.push(`${s.vGuide}   ${s.lastBranch} cwd: ${entry.cwd}`);
+    }
+    if (entry?.env && Object.keys(entry.env).length > 0) {
+      out.push(`${s.vGuide}   ${s.lastBranch} env: ${JSON.stringify(entry.env)}`);
+    }
+  }
+  out.push("");
+  out.push(
+    `${s.lastBranch} ${color.dim('\uBA85\uB839\uC744 \uBC14\uAFB8\uB824\uBA74: awl config set verify.lint.cmd "biome check ."')}`
+  );
+  out.push(`    ${color.dim("\uC9C1\uC811 \uD3B8\uC9D1\uB3C4 \uB429\uB2C8\uB2E4: .awl/config.json")}`);
+  return card(`${config.project} \uC124\uC815`, out, c);
+}
+function writeConfigFile(projectRoot, config) {
+  const p = path.join(projectRoot, ".awl", "config.json");
+  fs.writeFileSync(p, `${JSON.stringify(config, null, 2)}
+`);
+}
+var EDIT_MENU = ["\uADF8\uB300\uB85C \uB454\uB2E4", "\uC8FC \uC5B8\uC5B4", "\uAC80\uC99D \uBA85\uB839\uC5B4", "\uC131\uACA9", "\uD504\uB85C\uC81D\uD2B8 \uC774\uB984"];
+async function editVerifyCommands(rl, config, projectRoot, c) {
+  const screens = buildScreens(projectRoot, true, c);
+  process.stdout.write(`
+${screens.verify}
+`);
+  for (const name of VERIFY_ORDER) {
+    const cur = config.verify[name];
+    const shown = cur ? cur.cmd : "(\uC5C6\uC74C)";
+    const answer = (await ask(rl, `  ${name} [${shown}]: `)).trim();
+    if (answer === "") {
+      continue;
+    }
+    const outcome = await applyConfigValue(
+      config,
+      projectRoot,
+      { kind: "verify.cmd", verifyName: name },
+      answer,
+      { force: false }
+    );
+    process.stdout.write(`  ${outcome.message}
+`);
+  }
+}
+async function editMainLanguage(rl, config, projectRoot, c) {
+  const screens = buildScreens(projectRoot, true, c);
+  process.stdout.write(`
+  \uD604\uC7AC \uC124\uC815: ${config.mainLanguage || "(\uC5C6\uC74C)"}
+`);
+  process.stdout.write(`${screens.lang}
+`);
+  const curIdx = LANG_VALUES.indexOf(config.mainLanguage);
+  const idx = await promptNumber(rl, curIdx >= 0 ? curIdx : 0, LANG_OPTIONS.length);
+  let value = LANG_VALUES[idx] ?? "";
+  if (idx === LANG_OPTIONS.length - 1) {
+    value = (await ask(rl, "  \uC8FC \uC5B8\uC5B4\uB97C \uC785\uB825\uD558\uC138\uC694: ")).trim();
+  }
+  const outcome = await applyConfigValue(config, projectRoot, { kind: "mainLanguage" }, value, {
+    force: false
+  });
+  process.stdout.write(`  ${outcome.message}
+`);
+}
+async function editCharacter(rl, config, projectRoot, c) {
+  const screens = buildScreens(projectRoot, true, c);
+  process.stdout.write(`
+${screens.character}
+`);
+  process.stdout.write(`  \uD604\uC7AC: ${config.character || "(\uBE44\uC6C0)"}
+`);
+  const answer = await ask(rl, "  > ");
+  const outcome = await applyConfigValue(config, projectRoot, { kind: "character" }, answer, {
+    force: false
+  });
+  process.stdout.write(`  ${outcome.message}
+`);
+}
+async function editProjectName(rl, config, projectRoot) {
+  const answer = (await ask(rl, `  \uD504\uB85C\uC81D\uD2B8 \uC774\uB984 [${config.project}]: `)).trim();
+  if (answer === "") {
+    return;
+  }
+  const outcome = await applyConfigValue(config, projectRoot, { kind: "project" }, answer, {
+    force: false
+  });
+  process.stdout.write(`  ${outcome.message}
+`);
+}
+async function interactiveEditMenu(rl, config, projectRoot, c) {
+  process.stdout.write("\n  \uC218\uC815\uD560 \uD56D\uBAA9\uC744 \uACE0\uB974\uC138\uC694.\n\n");
+  for (let i = 0; i < EDIT_MENU.length; i++) {
+    process.stdout.write(`    ${i + 1}  ${EDIT_MENU[i]}
+`);
+  }
+  const idx = await promptNumber(rl, 0, EDIT_MENU.length);
+  if (idx === 0) {
+    return false;
+  }
+  if (idx === 1) {
+    await editMainLanguage(rl, config, projectRoot, c);
+  } else if (idx === 2) {
+    await editVerifyCommands(rl, config, projectRoot, c);
+  } else if (idx === 3) {
+    await editCharacter(rl, config, projectRoot, c);
+  } else if (idx === 4) {
+    await editProjectName(rl, config, projectRoot);
+  }
+  return true;
+}
+async function runConfig() {
+  const projectRoot = resolveProjectRoot();
+  if (!projectRoot) {
+    process.stderr.write(
+      `
+  ${signal(caps(), "error")} \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. awl init \uC744 \uC2E4\uD589\uD558\uC138\uC694.
+`
+    );
+    process.exit(1);
+  }
+  const loaded = loadConfig(projectRoot);
+  if (!loaded.config) {
+    process.stderr.write(`
+  ${signal(caps(), "error")} config.json \uC5D0 \uBB38\uC81C\uAC00 \uC788\uC2B5\uB2C8\uB2E4:
+`);
+    for (const e of loaded.errors) {
+      process.stderr.write(`    - ${e}
+`);
+    }
+    process.exit(1);
+  }
+  const config = loaded.config;
+  const c = caps();
+  process.stdout.write(`${renderConfig(config, c)}
+`);
+  const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+  if (!interactive) {
+    return;
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const changed = await interactiveEditMenu(rl, config, projectRoot, c);
+    if (changed) {
+      writeConfigFile(projectRoot, config);
+      process.stdout.write("\n  \uC800\uC7A5\uD588\uC2B5\uB2C8\uB2E4.\n");
+    } else {
+      process.stdout.write("\n  \uBC14\uB010 \uAC83\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+function renderSettableKeys(config, c) {
+  const color = makeColors(c.color);
+  const currentOf = (key) => {
+    if (key === "project") return config.project;
+    if (key === "mainLanguage") return config.mainLanguage || "(\uC5C6\uC74C)";
+    if (key === "character") return config.character || "(\uC5C6\uC74C)";
+    const m = /^verify\.(typecheck|lint|test|e2e)\.(cmd|cwd|env)$/.exec(key);
+    if (!m?.[1] || !m[2]) return "";
+    const entry = config.verify[m[1]];
+    if (!entry) return "(\uC5C6\uC74C)";
+    if (m[2] === "cmd") return entry.cmd;
+    if (m[2] === "cwd") return entry.cwd ?? "(\uC5C6\uC74C)";
+    return entry.env ? JSON.stringify(entry.env) : "(\uC5C6\uC74C)";
+  };
+  const keyWidth = Math.max(...SETTABLE_KEYS.map((k) => k.length)) + 2;
+  const out = ["", "  \uC124\uC815 \uAC00\uB2A5\uD55C \uD0A4", ""];
+  for (const key of SETTABLE_KEYS) {
+    out.push(`    ${key.padEnd(keyWidth, " ")}${color.dim(currentOf(key))}`);
+  }
+  out.push("");
+  out.push(`  ${color.dim('\uC608: awl config set verify.lint.cmd "biome check ."')}`);
+  return out.join("\n");
+}
+async function runConfigSet(key, value, opts) {
+  const projectRoot = resolveProjectRoot();
+  if (!projectRoot) {
+    process.stderr.write(
+      `
+  ${signal(caps(), "error")} \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. awl init \uC744 \uC2E4\uD589\uD558\uC138\uC694.
+`
+    );
+    process.exit(1);
+  }
+  const loaded = loadConfig(projectRoot);
+  if (!loaded.config) {
+    process.stderr.write(
+      `
+  ${signal(caps(), "error")} config.json \uC5D0 \uBB38\uC81C\uAC00 \uC788\uC5B4 \uC218\uC815\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4:
+`
+    );
+    for (const e of loaded.errors) {
+      process.stderr.write(`    - ${e}
+`);
+    }
+    process.exit(1);
+  }
+  const config = loaded.config;
+  if (!key) {
+    process.stdout.write(`${renderSettableKeys(config, caps())}
+`);
+    return;
+  }
+  const parsed = parseConfigKey(key);
+  if (!parsed) {
+    process.stderr.write(
+      `
+  ${signal(caps(), "error")} \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD0A4\uC785\uB2C8\uB2E4: ${key}
+
+  \uC124\uC815 \uAC00\uB2A5\uD55C \uD0A4:
+`
+    );
+    for (const k of SETTABLE_KEYS) {
+      process.stderr.write(`    ${k}
+`);
+    }
+    process.exit(1);
+  }
+  if (value === void 0) {
+    process.stdout.write(`${renderSettableKeys(config, caps())}
+`);
+    process.stdout.write(`
+  \uAC12\uC744 \uC8FC\uC138\uC694: awl config set ${key} <\uAC12>
+`);
+    return;
+  }
+  const outcome = await applyConfigValue(config, projectRoot, parsed, value, {
+    force: opts.force
+  });
+  if (!outcome.ok) {
+    process.stderr.write(`
+  ${signal(caps(), "error")} ${outcome.message}
+`);
+    process.exit(1);
+  }
+  writeConfigFile(projectRoot, config);
+  process.stdout.write(`  \uC800\uC7A5\uD588\uC2B5\uB2C8\uB2E4: ${outcome.message}
+`);
+}
+
+export {
+  CommandNotFoundError,
+  tokenize,
+  run,
+  VERIFY_ORDER,
+  resolveProjectRoot,
+  validateConfig,
+  loadConfig,
+  requireConfig,
+  parseVerifyValue,
+  KNOWN_LANGUAGES,
+  KNOWN_NAMING_CONVENTIONS,
+  SETTABLE_KEYS,
+  parseConfigKey,
+  applyConfigValue,
+  interactiveEditMenu,
+  runConfig,
+  runConfigSet
+};