agent-work-loop 0.0.0 → 0.6.22

package/dist/commit-APXIVOSD.js

@@ -0,0 +1,411 @@
+import {
+  protectedFilesMessage
+} from "./chunk-6E7XEQOH.js";
+import {
+  hasApprovedGate1
+} from "./chunk-I77CXOEX.js";
+import {
+  getCriterion,
+  loadState,
+  setCriterion,
+  writeState
+} from "./chunk-4OCSYHYB.js";
+import {
+  loadConfig,
+  resolveProjectRoot,
+  run
+} from "./chunk-UOPWVM2H.js";
+import "./chunk-BUWGQVHT.js";
+import {
+  caps,
+  feedback,
+  makeColors,
+  makeTokens,
+  signal
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/commit.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var STAGED_FILES_NOTICE_THRESHOLD = 5;
+async function git(args, cwd) {
+  const r = await run({ cmd: "git", args, cwd, timeoutMs: 3e4 });
+  return { stdout: r.stdout, stderr: r.stderr, exitCode: r.exitCode };
+}
+function lines(s) {
+  return s.trim().split("\n").map((l) => l.trim()).filter(Boolean);
+}
+async function namesZ(args, cwd) {
+  const out = (await git([...args, "-z"], cwd)).stdout;
+  return out.split("\0").filter((f) => f !== "");
+}
+async function captureSnapshot(cwd) {
+  const created = await git(["stash", "create"], cwd);
+  const sha = created.stdout.trim();
+  if (sha) {
+    return sha;
+  }
+  return (await git(["rev-parse", "HEAD"], cwd)).stdout.trim();
+}
+var AWL_SELF_PREFIXES = [".awl-worktrees/", ".awl/"];
+async function listUntracked(cwd) {
+  const untracked = await namesZ(["ls-files", "--others", "--exclude-standard"], cwd);
+  return untracked.filter((f) => !AWL_SELF_PREFIXES.some((prefix) => f.startsWith(prefix)));
+}
+function sanitizeRefComponent(s) {
+  return s.replace(/[^A-Za-z0-9._-]/g, "_").replace(/\.{2,}/g, "_");
+}
+function baselineRefPath(cwd, ac) {
+  const state = loadState(cwd);
+  const workitem = typeof state.workitem === "string" ? state.workitem : null;
+  const safeAc = sanitizeRefComponent(ac);
+  return workitem ? `refs/awl/baseline/${sanitizeRefComponent(workitem)}/${safeAc}` : `refs/awl/baseline/${safeAc}`;
+}
+async function pinBaselineRef(cwd, ac, sha) {
+  const refPath = baselineRefPath(cwd, ac);
+  const result = await git(["update-ref", refPath, sha], cwd);
+  if (result.exitCode !== 0) {
+    process.stderr.write(
+      `  ${signal(caps(), "warn")} baseline \uBCF4\uD638\uC6A9 git ref(${refPath})\uB97C \uBABB \uB9CC\uB4E4\uC5C8\uC2B5\uB2C8\uB2E4(\uAE30\uB2A5\uC5D4 \uC601\uD5A5 \uC5C6\uC74C): ${result.stderr.trim()}
+`
+    );
+  }
+}
+async function startBaseline(cwd, ac) {
+  const head = (await git(["rev-parse", "HEAD"], cwd)).stdout.trim();
+  const snapshot = await captureSnapshot(cwd);
+  const untracked = await listUntracked(cwd);
+  await pinBaselineRef(cwd, ac, snapshot);
+  return { snapshot, head, untracked };
+}
+async function isolatedCommit(cwd, ac, message, snapshot, untrackedAtStart = [], expectedHead) {
+  const empty = { stagedFiles: [], excludedFiles: [], extraFiles: [] };
+  if (expectedHead !== void 0) {
+    const currentHead = (await git(["rev-parse", "HEAD"], cwd)).stdout.trim();
+    if (currentHead !== expectedHead) {
+      const log = (await git(["log", "--oneline", `${expectedHead}..${currentHead}`], cwd)).stdout.trim();
+      const commits = lines(log);
+      return {
+        committed: false,
+        reason: [
+          `HEAD \uAC00 \uC774 \uC644\uB8CC\uC870\uAC74\uC758 \uBCA0\uC774\uC2A4\uB77C\uC778\uC744 \uC7A1\uC740 \uB4A4 \uB2E4\uB978 \uCEE4\uBC0B ${commits.length}\uAC1C\uB85C \uC774\uB3D9\uD588\uC2B5\uB2C8\uB2E4:`,
+          ...commits.map((c) => `  ${c}`),
+          "\uB2E4\uB978 \uC644\uB8CC\uC870\uAC74\uC744 \uC2E4\uC218\uB85C \uC5EC\uAE30\uC11C \uCEE4\uBC0B\uD588\uB2E4\uBA74 \uADF8\uCABD\uC744 \uB9C8\uC800 \uC815\uB9AC\uD558\uC138\uC694.",
+          "\uC758\uB3C4\uD55C \uAC83\uC774\uBA74(\uB3D9\uC2DC \uC791\uC5C5 \uB4F1) \uC9C0\uAE08 \uC774 \uC6CC\uD0B9\uD2B8\uB9AC\uC758 \uBCC0\uACBD\uC744 \uBA3C\uC800 \uD655\uC778\uD55C \uB4A4",
+          `awl commit ${ac} --start \uB85C \uBCA0\uC774\uC2A4\uB77C\uC778\uC744 \uC0C8\uB85C \uC7A1\uACE0 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694.`
+        ].join("\n"),
+        selfCheckOk: false,
+        ...empty
+      };
+    }
+  }
+  await git(["reset", "-q"], cwd);
+  const diff = (await git(["diff", snapshot], cwd)).stdout;
+  const nowUntracked = await listUntracked(cwd);
+  const newUntracked = nowUntracked.filter((f) => !untrackedAtStart.includes(f));
+  if (diff.trim() === "" && newUntracked.length === 0) {
+    return { committed: false, reason: "\uCEE4\uBC0B\uD560 \uB0B4 \uBCC0\uACBD\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", selfCheckOk: true, ...empty };
+  }
+  if (diff.trim() !== "") {
+    const patchFile = path.join(os.tmpdir(), `awl-commit-${ac}-${process.pid}.patch`);
+    fs.writeFileSync(patchFile, diff);
+    const applied = await git(["apply", "--cached", "--whitespace=nowarn", patchFile], cwd);
+    fs.rmSync(patchFile, { force: true });
+    if (applied.exitCode !== 0) {
+      await git(["reset", "-q"], cwd);
+      return {
+        committed: false,
+        reason: `\uB0B4 \uBCC0\uACBD\uC744 \uC548\uC804\uD558\uAC8C \uBD84\uB9AC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4(hunk \uAC00 \uB0A8\uC758 \uBCC0\uACBD\uACFC \uACB9\uCE60 \uC218 \uC788\uC2B5\uB2C8\uB2E4). \uCEE4\uBC0B\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC0AC\uB78C\uC774 \uD655\uC778\uD558\uC138\uC694.
+${applied.stderr.trim()}`,
+        selfCheckOk: false,
+        ...empty
+      };
+    }
+  }
+  for (const f of newUntracked) {
+    const added = await git(["add", "--", f], cwd);
+    if (added.exitCode !== 0) {
+      await git(["reset", "-q"], cwd);
+      return {
+        committed: false,
+        reason: `\uC0C8 \uD30C\uC77C\uC744 \uC2A4\uD14C\uC774\uC9D5\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${f}
+${added.stderr.trim()}`,
+        selfCheckOk: false,
+        ...empty
+      };
+    }
+  }
+  const stagedFiles = await namesZ(["diff", "--cached", "--name-only"], cwd);
+  const excludedFiles = [
+    ...await namesZ(["diff", "--name-only"], cwd),
+    ...nowUntracked.filter((f) => untrackedAtStart.includes(f))
+  ];
+  const msg = message.includes(ac) ? message : `${message} [${ac}]`;
+  const committed = await git(["commit", "-q", "-m", msg], cwd);
+  if (committed.exitCode !== 0) {
+    await git(["reset", "-q"], cwd);
+    return {
+      committed: false,
+      reason: `\uCEE4\uBC0B \uC2E4\uD328: ${committed.stderr.trim()}`,
+      selfCheckOk: false,
+      stagedFiles,
+      excludedFiles,
+      extraFiles: []
+    };
+  }
+  const commit = (await git(["rev-parse", "HEAD"], cwd)).stdout.trim();
+  const committedFiles = await namesZ(["show", "--name-only", "--format=", commit], cwd);
+  const extraFiles = committedFiles.filter((f) => !stagedFiles.includes(f));
+  return {
+    committed: true,
+    commit,
+    stagedFiles,
+    excludedFiles,
+    selfCheckOk: extraFiles.length === 0,
+    extraFiles
+  };
+}
+function renderCommitSuccess(outcome, c, message) {
+  const color = makeColors(c.color);
+  const head = `
+${feedback(c, "ok", `\uCEE4\uBC0B\uB428: ${makeTokens(c).emphasis(outcome.commit?.slice(0, 10) ?? "")}`, message)}
+`;
+  if (!outcome.selfCheckOk) {
+    return {
+      stdout: head,
+      stderr: `  ${signal(c, "warn")} \uB0B4\uBD80 \uAC80\uC99D \uACBD\uACE0: \uC2A4\uD14C\uC774\uC9D5\uD55C \uD30C\uC77C\uACFC \uC2E4\uC81C \uCEE4\uBC0B \uB0B4\uC6A9\uC774 \uB2E4\uB985\uB2C8\uB2E4: ${outcome.extraFiles.join(", ")}
+`
+    };
+  }
+  return {
+    stdout: `${head}  ${color.dim("\uB0B4\uBD80 \uAC80\uC99D: \uC2A4\uD14C\uC774\uC9D5\uD55C \uB0B4\uC6A9 \uADF8\uB300\uB85C \uCEE4\uBC0B\uB428.")}
+`,
+    stderr: ""
+  };
+}
+function buildRescueGuidance(reason) {
+  if (!reason || !reason.includes("hunk")) {
+    return null;
+  }
+  return [
+    "",
+    "  \uACA9\uB9AC\uB41C \uC6CC\uD06C\uD2B8\uB9AC\uB85C \uC62E\uAE30\uB294 \uBC29\uBC95(\uB0B4 \uBCC0\uACBD\uC744 \uADF8\uB300\uB85C \uB2E4\uB978 \uACF3\uC73C\uB85C \uC774\uB3D9):",
+    '    git stash push -u -m "rescue"          # \uB0B4 \uBCC0\uACBD(\uCD94\uC801+\uBBF8\uCD94\uC801 \uC804\uBD80)\uC744 \uC2A4\uD0DD\uC5D0 \uB2F4\uB294\uB2E4',
+    "    git worktree add ../<\uC0C8-\uB514\uB809\uD1A0\uB9AC> -b <\uC0C8-\uBE0C\uB79C\uCE58>",
+    "    cd ../<\uC0C8-\uB514\uB809\uD1A0\uB9AC> && git stash pop    # \uC62E\uAE34 \uC6CC\uD06C\uD2B8\uB9AC\uC5D0\uC11C \uBCC0\uACBD\uC744 \uBCF5\uC6D0",
+    "  (\uB610\uB294 awl work new <ID> --worktree \uB85C \uC0C8 \uC6CC\uD06C\uC544\uC774\uD15C + \uACA9\uB9AC \uC6CC\uD06C\uD2B8\uB9AC\uB97C \uD55C \uBC88\uC5D0 \uB9CC\uB4E4\uACE0 \uC704 \uC21C\uC11C\uB85C \uC62E\uAE30\uC138\uC694.)"
+  ].join("\n");
+}
+function buildTrailGapWarning(activeWorkitem, c) {
+  if (activeWorkitem) {
+    return null;
+  }
+  return `  ${signal(c, "warn")} \uD65C\uC131 \uC6CC\uD06C\uC544\uC774\uD15C \uC5C6\uC774 \uCEE4\uBC0B\uD569\uB2C8\uB2E4 \u2014 record \uD2B8\uB808\uC77C\uC774 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4. /awl-loop \uAC8C\uC774\uD2B8(work new\u2192gate)\uB97C \uBC1F\uC558\uB294\uC9C0 \uD655\uC778\uD558\uC138\uC694.
+`;
+}
+async function checkBaseDrift(cwd, base, myFiles) {
+  let baseRef = base;
+  if (!baseRef) {
+    const up = await git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], cwd);
+    if (up.exitCode !== 0 || up.stdout.trim() === "") {
+      return null;
+    }
+    baseRef = up.stdout.trim();
+  }
+  const mb = await git(["merge-base", "HEAD", baseRef], cwd);
+  if (mb.exitCode !== 0) {
+    return null;
+  }
+  const mergeBase = mb.stdout.trim();
+  const ahead = Number(
+    (await git(["rev-list", "--count", `${mergeBase}..${baseRef}`], cwd)).stdout.trim() || "0"
+  );
+  if (ahead === 0) {
+    return { ahead: 0, overlap: [], base: baseRef };
+  }
+  const changed = lines((await git(["diff", "--name-only", mergeBase, baseRef], cwd)).stdout);
+  const overlap = changed.filter((f) => myFiles.includes(f));
+  return { ahead, overlap, base: baseRef };
+}
+function requireRoot() {
+  const root = resolveProjectRoot();
+  if (!root) {
+    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);
+  }
+  return root;
+}
+async function runCommit(ac, opts) {
+  const root = requireRoot();
+  const c = caps();
+  const color = makeColors(c.color);
+  const gateState = loadState(root);
+  const gateWorkitem = typeof gateState.workitem === "string" ? gateState.workitem : void 0;
+  if (gateWorkitem && !hasApprovedGate1(gateWorkitem)) {
+    process.stderr.write(
+      `
+  ${signal(c, "warn")} Gate 1 \uC2B9\uC778\uC774 \uBA3C\uC800 \uD544\uC694\uD569\uB2C8\uB2E4. awl record gate \uB85C \uACC4\uD68D\uC744 \uC2B9\uC778\uD55C \uB4A4 \uCEE4\uBC0B\uD558\uC138\uC694.
+`
+    );
+    process.exit(1);
+  }
+  if (!opts.force) {
+    const protection = await protectedFilesMessage(root, loadConfig(root).config?.protectedFiles);
+    if (protection) {
+      process.stderr.write(`
+  ${signal(c, "error")} ${protection}
+`);
+      process.exit(1);
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (opts.start) {
+    const { snapshot: snapshot2, head, untracked } = await startBaseline(root, ac);
+    const existing = getCriterion(loadState(root), ac);
+    const firstBaseline = typeof existing?.firstBaseline === "string" ? existing.firstBaseline : head;
+    const state2 = setCriterion(loadState(root), ac, {
+      status: "in_progress",
+      baseline: head,
+      snapshot: snapshot2,
+      untrackedAtStart: untracked,
+      startedAt: now,
+      firstBaseline
+    });
+    writeState(root, state2);
+    process.stdout.write(`
+  ${ac} \uBCA0\uC774\uC2A4\uB77C\uC778\uC744 \uC7A1\uC558\uC2B5\uB2C8\uB2E4: ${head.slice(0, 10)}
+`);
+    process.stdout.write(
+      `  ${color.dim(`\uC774\uC81C \uC791\uC5C5\uD55C \uB4A4 awl commit ${ac} -m "..." \uB85C \uACA9\uB9AC \uCEE4\uBC0B\uD558\uC138\uC694.`)}
+`
+    );
+    return;
+  }
+  if (!opts.message) {
+    process.stderr.write(
+      `
+  ${signal(c, "error")} \uCEE4\uBC0B \uBA54\uC2DC\uC9C0\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4: awl commit ${ac} -m "..."
+`
+    );
+    process.exit(1);
+  }
+  const state = loadState(root);
+  const crit = getCriterion(state, ac);
+  const snapshot = crit && typeof crit.snapshot === "string" ? crit.snapshot : void 0;
+  if (!snapshot) {
+    const lines2 = [
+      `
+  ${signal(c, "error")} ${ac} \uC758 \uBCA0\uC774\uC2A4\uB77C\uC778\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uB0B4 \uBCC0\uACBD\uC744 \uB0A8\uC758 \uBCC0\uACBD\uACFC \uAD6C\uBD84\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`,
+      "",
+      "  \uC544\uC9C1 \uAD6C\uD604 \uC804\uC774\uBA74 \u2014 \uBA3C\uC800 \uBCA0\uC774\uC2A4\uB77C\uC778\uC744 \uC7A1\uC73C\uC138\uC694:",
+      `      awl commit ${ac} --start`,
+      "",
+      "  \uC774\uBBF8 \uAD6C\uD604\uD588\uB2E4\uBA74 \u2014 \uBCC0\uACBD\uC744 \uC7A0\uAE50 \uCE58\uC6E0\uB2E4\uAC00 \uB418\uB3CC\uB824 \uACA9\uB9AC \uCEE4\uBC0B\uD558\uC138\uC694(\uACA9\uB9AC \uBAA8\uB378 \uC720\uC9C0):",
+      "      git stash push -u",
+      `      awl commit ${ac} --start`,
+      "      git stash pop",
+      `      awl commit ${ac} -m "..."`,
+      ""
+    ];
+    process.stderr.write(`${lines2.join("\n")}
+`);
+    process.exit(1);
+  }
+  const trailWarning = buildTrailGapWarning(gateWorkitem, c);
+  if (trailWarning) {
+    process.stderr.write(trailWarning);
+  }
+  const untrackedAtStart = Array.isArray(crit?.untrackedAtStart) ? crit.untrackedAtStart : [];
+  const expectedHead = typeof crit?.baseline === "string" ? crit.baseline : void 0;
+  const outcome = await isolatedCommit(
+    root,
+    ac,
+    opts.message,
+    snapshot,
+    untrackedAtStart,
+    expectedHead
+  );
+  process.stdout.write("\n");
+  if (outcome.stagedFiles.length > 0) {
+    process.stdout.write("  \uCEE4\uBC0B\uD560 \uB0B4 \uBCC0\uACBD:\n");
+    for (const f of outcome.stagedFiles) {
+      process.stdout.write(`    ${color.green("+")} ${f}
+`);
+    }
+    if (outcome.stagedFiles.length > STAGED_FILES_NOTICE_THRESHOLD) {
+      process.stdout.write(
+        `  ${color.yellow(`\uD30C\uC77C ${outcome.stagedFiles.length}\uAC1C`)} \u2014 \uC774 \uC644\uB8CC\uC870\uAC74\uC758 \uBC94\uC704\uC640 \uC77C\uCE58\uD558\uB294\uC9C0 \uC704 \uBAA9\uB85D\uC744 \uC9C1\uC811 \uD655\uC778\uD558\uC138\uC694.
+`
+      );
+    }
+  }
+  if (outcome.excludedFiles.length > 0) {
+    process.stdout.write(
+      `  ${color.yellow("\uC81C\uC678")}(\uB0A8\uC758 \uBBF8\uCEE4\uBC0B \uBCC0\uACBD, \uC6CC\uD0B9\uD2B8\uB9AC\uC5D0 \uADF8\uB300\uB85C \uB461\uB2C8\uB2E4):
+`
+    );
+    for (const f of outcome.excludedFiles) {
+      process.stdout.write(`    ${color.dim("-")} ${f}
+`);
+    }
+  }
+  if (!outcome.committed) {
+    process.stderr.write(`
+  ${signal(c, "error")} \uCEE4\uBC0B\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. ${outcome.reason}
+`);
+    const guidance = buildRescueGuidance(outcome.reason);
+    if (guidance) {
+      process.stderr.write(`${guidance}
+`);
+    }
+    process.exit(1);
+  }
+  const rendered = renderCommitSuccess(outcome, c, opts.message);
+  process.stdout.write(rendered.stdout);
+  if (rendered.stderr) {
+    process.stderr.write(rendered.stderr);
+  }
+  const drift = await checkBaseDrift(root, opts.base, outcome.stagedFiles);
+  if (drift && drift.ahead > 0) {
+    process.stdout.write(
+      `
+  ${color.yellow("\uACBD\uACE0")}: \uC774 \uBE0C\uB79C\uCE58\uAC00 \uAC08\uB77C\uC9C4 \uB4A4 ${drift.base} \uC5D0 ${drift.ahead}\uAC1C \uCEE4\uBC0B\uC774 \uC313\uC600\uC2B5\uB2C8\uB2E4.
+`
+    );
+    if (drift.overlap.length > 0) {
+      process.stdout.write(`        \uACB9\uCE58\uB294 \uD30C\uC77C: ${drift.overlap.join(", ")}
+`);
+      process.stdout.write("        \uBCD1\uD569 \uC804\uC5D0 \uD655\uC778\uD558\uC138\uC694.\n");
+    }
+  }
+  const newSnap = await captureSnapshot(root);
+  const newUntracked = await listUntracked(root);
+  await pinBaselineRef(root, ac, newSnap);
+  writeState(
+    root,
+    setCriterion(loadState(root), ac, {
+      snapshot: newSnap,
+      baseline: outcome.commit,
+      // baseline 은 다음 격리 커밋의 diff 기준점이라 --start 때 HEAD 로 리셋된다.
+      // commit 은 리셋 안 되는 "이 AC 의 마지막 격리 커밋" 전용 필드 — status 의
+      // 캐노니컬 HEAD 검증(wi8-F3)이 이 값이 HEAD 조상인지 대조한다.
+      commit: outcome.commit,
+      untrackedAtStart: newUntracked
+    })
+  );
+}
+export {
+  buildRescueGuidance,
+  buildTrailGapWarning,
+  captureSnapshot,
+  checkBaseDrift,
+  isolatedCommit,
+  renderCommitSuccess,
+  runCommit,
+  startBaseline
+};

package/dist/config-TFMW7O4T.js

@@ -0,0 +1,34 @@
+import {
+  KNOWN_LANGUAGES,
+  KNOWN_NAMING_CONVENTIONS,
+  SETTABLE_KEYS,
+  VERIFY_ORDER,
+  applyConfigValue,
+  interactiveEditMenu,
+  loadConfig,
+  parseConfigKey,
+  parseVerifyValue,
+  requireConfig,
+  resolveProjectRoot,
+  runConfig,
+  runConfigSet,
+  validateConfig
+} from "./chunk-UOPWVM2H.js";
+import "./chunk-BUWGQVHT.js";
+import "./chunk-7SYRDDTX.js";
+export {
+  KNOWN_LANGUAGES,
+  KNOWN_NAMING_CONVENTIONS,
+  SETTABLE_KEYS,
+  VERIFY_ORDER,
+  applyConfigValue,
+  interactiveEditMenu,
+  loadConfig,
+  parseConfigKey,
+  parseVerifyValue,
+  requireConfig,
+  resolveProjectRoot,
+  runConfig,
+  runConfigSet,
+  validateConfig
+};

package/dist/doctor-BU6HWXE4.js

@@ -0,0 +1,29 @@
+import {
+  collectChecks,
+  computeFileSizeOutliers,
+  detectNamingConvention,
+  detectRecordTrailGap,
+  gitBranch,
+  gitDirtyFiles,
+  gitHasCommits,
+  renderText,
+  runDoctor
+} from "./chunk-CCMG377E.js";
+import "./chunk-TKPHC32G.js";
+import "./chunk-VU6IPRRM.js";
+import "./chunk-I77CXOEX.js";
+import "./chunk-4OCSYHYB.js";
+import "./chunk-UOPWVM2H.js";
+import "./chunk-BUWGQVHT.js";
+import "./chunk-7SYRDDTX.js";
+export {
+  collectChecks,
+  computeFileSizeOutliers,
+  detectNamingConvention,
+  detectRecordTrailGap,
+  gitBranch,
+  gitDirtyFiles,
+  gitHasCommits,
+  renderText,
+  runDoctor
+};

package/dist/evolve-NNQX2A43.js

@@ -0,0 +1,38 @@
+import {
+  GOTCHA_RELATION_TYPES,
+  acquireLock,
+  collectEvolve,
+  gotchaCluster,
+  gotchasBySource,
+  loadGotchaList,
+  migrateDeltasToGotchas,
+  nextGotchaId,
+  normalizeRelations,
+  recordGotcha,
+  releaseLock,
+  runEvolveCollect,
+  runEvolveRecord,
+  writeGeneration
+} from "./chunk-C7TN3LM3.js";
+import "./chunk-F5LHXBH7.js";
+import "./chunk-I77CXOEX.js";
+import "./chunk-4OCSYHYB.js";
+import "./chunk-UOPWVM2H.js";
+import "./chunk-BUWGQVHT.js";
+import "./chunk-7SYRDDTX.js";
+export {
+  GOTCHA_RELATION_TYPES,
+  acquireLock,
+  collectEvolve,
+  gotchaCluster,
+  gotchasBySource,
+  loadGotchaList,
+  migrateDeltasToGotchas,
+  nextGotchaId,
+  normalizeRelations,
+  recordGotcha,
+  releaseLock,
+  runEvolveCollect,
+  runEvolveRecord,
+  writeGeneration
+};

package/dist/feedback-KAXNFMUY.js

@@ -0,0 +1,125 @@
+import {
+  readRecords
+} from "./chunk-I77CXOEX.js";
+import "./chunk-4OCSYHYB.js";
+import "./chunk-UOPWVM2H.js";
+import "./chunk-BUWGQVHT.js";
+import {
+  caps,
+  card,
+  makeColors,
+  signal
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/feedback.ts
+var SEVERITY_RANK = { high: 0, medium: 1, low: 2 };
+function loadAwlFeedback(filter = {}) {
+  let records = readRecords().filter((r) => r.type === "awl-feedback");
+  if (filter.area) {
+    records = records.filter((r) => r.area === filter.area);
+  }
+  if (filter.severity) {
+    records = records.filter((r) => r.severity === filter.severity);
+  }
+  if (filter.since) {
+    const sinceMs = new Date(filter.since).getTime();
+    if (!Number.isNaN(sinceMs)) {
+      records = records.filter((r) => {
+        if (typeof r.at !== "string") {
+          return false;
+        }
+        const atMs = new Date(r.at).getTime();
+        return !Number.isNaN(atMs) && atMs >= sinceMs;
+      });
+    }
+  }
+  return records;
+}
+function isInvalidSince(since) {
+  return typeof since === "string" && since !== "" && Number.isNaN(new Date(since).getTime());
+}
+function buildFeedbackReport(records) {
+  const areas = {};
+  const workitems = /* @__PURE__ */ new Set();
+  for (const r of records) {
+    if (typeof r.workitem === "string") {
+      workitems.add(r.workitem);
+    }
+    const area = typeof r.area === "string" ? r.area : "\uAE30\uD0C0";
+    const g = areas[area] ?? { count: 0, repeated: false, items: [] };
+    g.count += 1;
+    g.items.push(r);
+    areas[area] = g;
+  }
+  for (const g of Object.values(areas)) {
+    g.repeated = g.count >= 2;
+    g.items.sort(
+      (a, b) => (SEVERITY_RANK[String(a.severity)] ?? 3) - (SEVERITY_RANK[String(b.severity)] ?? 3)
+    );
+  }
+  const prioritized = Object.entries(areas).filter(([, g]) => g.count >= 2).sort(([, a], [, b]) => b.count - a.count).map(([area]) => area);
+  return { collectedFrom: workitems.size, areas, prioritized };
+}
+function renderFeedback(report, c) {
+  const color = makeColors(c.color);
+  const entries = Object.entries(report.areas).sort(([, a], [, b]) => b.count - a.count);
+  if (entries.length === 0) {
+    return card(
+      "awl \uC790\uCCB4 \uD53C\uB4DC\uBC31",
+      [
+        "\uC544\uC9C1 \uC218\uC9D1\uB41C awl-feedback \uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
+        "",
+        color.dim(
+          "\uC6CC\uD06C\uC544\uC774\uD15C\uC744 \uB2EB\uC744 \uB54C(evolve) awl \uB3C4\uAD6C \uC790\uCCB4\uAC00 \uBD88\uD3B8\uD588\uB2E4\uBA74 awl record awl-feedback \uC73C\uB85C \uB0A8\uAE30\uC138\uC694."
+        )
+      ],
+      c
+    );
+  }
+  const out = [];
+  for (const [area, g] of entries) {
+    const tag = g.repeated ? `  ${signal(c, "warn")} \uBC18\uBCF5` : "";
+    out.push(`${color.bold(area)}   ${g.count}\uAC74${tag}`);
+    for (const item of g.items) {
+      const wi = typeof item.workitem === "string" ? item.workitem : "?";
+      const sev = String(item.severity ?? "?");
+      out.push(`  ${color.dim("-")} ${String(item.what ?? "")}  ${color.dim(`(${wi}, ${sev})`)}`);
+    }
+    out.push("");
+  }
+  if (report.prioritized.length > 0) {
+    const list = report.prioritized.map((a) => `${a}(${report.areas[a]?.count})`).join(", ");
+    out.push(color.yellow(`2\uD68C \uC774\uC0C1 \uBC18\uBCF5\uB41C area: ${list}`));
+    out.push(
+      color.dim(
+        "\u2192 \uC774 area \uB97C \uC6B0\uC120 \uAC80\uD1A0\uD558\uC138\uC694. \uBB34\uC5C7\uC744 \uACE0\uCE60\uC9C0\uB294 \uC0AC\uB78C\uC774 \uC815\uD569\uB2C8\uB2E4(awl \uC740 \uD310\uB2E8\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4)."
+      )
+    );
+  }
+  return card(`awl \uC790\uCCB4 \uD53C\uB4DC\uBC31 \xB7 \uC6CC\uD06C\uC544\uC774\uD15C ${report.collectedFrom}\uAC1C\uC5D0\uC11C \uC218\uC9D1`, out, c);
+}
+function runFeedback(opts) {
+  if (isInvalidSince(opts.since)) {
+    process.stderr.write(
+      `
+  ${signal(caps(), "warn")} --since '${opts.since}' \uB97C \uB0A0\uC9DC\uB85C \uC77D\uC9C0 \uBABB\uD574 \uBB34\uC2DC\uD569\uB2C8\uB2E4. \uC608: 2026-07-01
+`
+    );
+  }
+  const records = loadAwlFeedback({ area: opts.area, severity: opts.severity, since: opts.since });
+  const report = buildFeedbackReport(records);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${renderFeedback(report, caps())}
+`);
+}
+export {
+  buildFeedbackReport,
+  isInvalidSince,
+  loadAwlFeedback,
+  renderFeedback,
+  runFeedback
+};

package/dist/gotchas-CW4KZDEF.js

@@ -0,0 +1,43 @@
+import {
+  loadGotchaList
+} from "./chunk-C7TN3LM3.js";
+import "./chunk-F5LHXBH7.js";
+import "./chunk-I77CXOEX.js";
+import "./chunk-4OCSYHYB.js";
+import "./chunk-UOPWVM2H.js";
+import "./chunk-BUWGQVHT.js";
+import {
+  caps,
+  card,
+  makeColors
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/gotchas.ts
+function loadGotchas() {
+  return loadGotchaList();
+}
+function renderGotchas(gotchas, c) {
+  const color = makeColors(c.color);
+  if (gotchas.length === 0) {
+    return card("\uD568\uC815", ["\uD568\uC815\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."], c);
+  }
+  const out = [];
+  for (const g of gotchas) {
+    out.push(`${color.dim("\xB7")} ${g.lesson || "(\uC694\uC57D \uC5C6\uC74C)"}`);
+  }
+  return card(`\uD568\uC815 ${gotchas.length}\uAC1C \xB7 \uC544\uC9C1 \uADDC\uCE59 \uC544\uB2D8`, out, c);
+}
+function runGotchas(opts) {
+  const gotchas = loadGotchas();
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(gotchas, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${renderGotchas(gotchas, caps())}
+`);
+}
+export {
+  loadGotchas,
+  runGotchas
+};