@d3lm/lint-preset 1.4.6 → 1.5.1

package/dist/bin/comments.js

@@ -0,0 +1,3215 @@
+#!/usr/bin/env node
+
+// src/comments/cli.ts
+import { existsSync as existsSync4, realpathSync, statSync as statSync3 } from "fs";
+import path5 from "path";
+import { parseArgs } from "util";
+
+// src/comments/agent.ts
+import { spawn } from "child_process";
+import { readFileSync } from "fs";
+import path from "path";
+var CHILD_ENV = "COMMENTS_HOOK_CHILD";
+var DEFAULT_RULES = `
+# Comment rules
+
+## Priorities
+
+When rules pull in different directions, the earlier one wins.
+
+1. Keep code and exact text byte for byte, including every punctuation character in it. That covers code blocks, \`@example\`, code spans, identifiers, string literals like error messages, regexes, globs and other patterns like \`*test*\`, URLs, quoted text, titles, and notation like \`host:port\`.
+2. Keep the meaning. An edit may make a comment clearer, never different.
+3. Follow the style preferences below.
+4. Change as little as possible. Wording that already reads clearly stays, even when a note points at it.
+
+## Layout
+
+- After you finish, the tool rewraps prose paragraphs, list items, and JSDoc tag descriptions. The width is a preferred target. A parenthetical may extend a line up to the configured maximum so it stays together. In longer paragraphs, balanced lines take priority over keeping every parenthetical on one line. The tool also avoids short last lines where possible. Leave these line breaks to the tool, except for the sentence-orphan case below.
+- Don't end a line with the first word of a new sentence, clause, or parenthetical, like \`This\` after a period, \`the\` after a comma, or \`(the\`. Move it to the next line instead.
+- In a paragraph of two lines, the first line ends with a sentence whenever the rest fits on the second line and is no longer than the first. Don't end it with the start of the next sentence, like \`A wrap\` in \`...lay out differently. A wrap\`. Move those words to the second line instead.
+- A comment whose whole text is one paragraph stays on a single line when that line fits a separate, larger single-line width, even past the width. Only a longer comment wraps to the width.
+- Separate paragraphs with an empty comment line.
+- Never split a backtick code span across lines.
+- Keep code blocks, \`@example\`, lists, tables, box drawings, aligned columns, and Markdown hard line breaks (a line that ends with two spaces or a backslash) laid out as they are. List items wrap with their continuation lines indented to the item text, and a JSDoc tag description that doesn't fit continues on the next line without indentation.
+- The tool measures every line, taking the tolerance and the parts it keeps as written into account, and the notes on each comment list what is still wrong. Act on those notes. Don't count columns, and don't apply a stricter limit than the notes show.
+- The maximum is a hard limit for measured prose, including long tokens. If a URL, code span, or other exact text exceeds it, preserve that text and explain the unresolved overflow instead of changing its contents.
+- The tool never rewraps the parts it keeps as written, like a single-line block comment, a paragraph with hard line breaks, or lines that may be laid out by hand. When a note says one of their prose lines is too long, break or shorten it yourself. Exact text and intentional layout win over the width, so keep code, code spans, and the layout in them intact, and if a note can only be fixed by changing them, leave it and say why in your reply.
+
+## Style
+
+These are preferences for comment prose. They never apply to code or exact text (see the priorities above), and a punctuation character on its own is never a reason to edit prose that already reads clearly.
+
+- Write clear sentences that flow. Descriptions read best as complete sentences with a subject and a verb, so prefer "Returns the bytes the guest sent" over a fragment like \`Bytes from the guest.\` or \`Optional.\` Imperative or third-person verb phrases like "Resolve a hostname..." or "Aborts every channel..." are fine, since the preference is against verb-less fragments, not against concise sentences.
+- Prefer plain sentence punctuation. Where a semicolon, an em-dash (\u2014), or a spaced hyphen, en-dash, or double hyphen standing in for one only joins two thoughts, a period, a comma, parentheses, or a word like "and", "so", or "because" usually reads better. Keep the punctuation where it carries meaning or reads more clearly than the alternatives.
+- Prefer a sentence over a "Label: explanation" fragment, like \`...the socket. Optional: without it...\` or \`Default: refuse\` in the middle of prose. A colon is fine where it introduces a list, code block, or example, in a term's definition, in notation, in a quotation, and in a \`Note:\` or \`Optional:\` that starts a comment. A JSDoc tag like \`@note\` or \`@todo\` can replace a label, and \`@default\` fits a default value, not a description.
+- Avoid asterisk emphasis like \`*this*\`, and use plain wording instead. A name or pattern in asterisks, like \`*test*\` or \`*.spec.ts\`, is a pattern, so keep its asterisks and wrap it in a code span, like \`\` \`*test*\` \`\`.
+- Avoid section banner comments, i.e. dividers or headings made of dashes, equals signs, asterisks, or other repeated characters that split a file into visual sections. Let the code structure carry the grouping, or write one short, plain sentence comment (e.g. \`// handlers for control mode\`). Rules that belong to a diagram, a table, a box drawing, a Markdown document, an example, or a legal header aren't banners.
+- Block and JSDoc comments are capitalized and end with punctuation.
+- Never turn a block or JSDoc comment into \`//\` line comments, and never write a run of consecutive \`//\` lines.
+
+## Editing
+
+- Keep the wording unless it goes against a rule above. Then reword as little as needed and keep the meaning.
+- Don't reword anything else unless the instructions below allow it.
+`.trim();
+var DEFAULT_TIMEOUT_SECONDS = 300;
+var DEFAULT_CLAUDE_MODEL = "haiku";
+var KILL_GRACE_MS = 5e3;
+var DRAIN_GRACE_MS = 1e3;
+var RUNNER_COMMANDS = {
+  claude: "claude",
+  codex: "codex",
+  cursor: "cursor-agent"
+};
+var ISSUE_DESCRIPTIONS = {
+  underfill: "ends early, and words from the next line fit on it",
+  widow: "leaves fewer than three words on the last line of its paragraph",
+  unbalanced: "is in a paragraph whose lines are less even than the suggested rewrap",
+  orphan: "may end with the start of a new sentence, clause, or parenthetical, which belongs on the next line (leave it if the period or comma before it is part of an abbreviation, a name, or notation like `No. 3`)",
+  "em-dash": "may use an em-dash to join two thoughts (leave it if it's in a quotation, a title, or a string literal, or reads more clearly than the alternatives)",
+  banner: "may be a section banner (leave it if it's part of a diagram, a table, a box, a Markdown rule, a separator in an example, or legal text)",
+  semicolon: "may join clauses with a semicolon (leave it if it's code, a literal, not a clause join, or reads more clearly than a period or a joining word)",
+  "label-colon": "may use a colon after a label (leave it if it introduces a list or code, defines a term, is notation like a time or `key: value`, or is a `Note:` or `Optional:` that starts the comment)",
+  emphasis: "may use asterisk emphasis (leave the asterisks of a name or pattern like `*test*`, which belongs in a code span with its asterisks)",
+  dash: "may use a spaced hyphen, en-dash, or double hyphen as an em-dash (leave it if it's a range, a CLI argument, arithmetic, code, a term's definition, or reads more clearly than the alternatives)"
+};
+var HINT_MARKER = "possible:";
+function describeIssue(issue, width, maxWidth) {
+  if (issue.type === "overflow") {
+    const limit = maxWidth ?? width;
+    const name = maxWidth === void 0 ? "width" : "maximum";
+    return `line ${issue.line} is ${issue.length} columns, over the ${name} of ${limit}`;
+  }
+  const description = `line ${issue.line} ${ISSUE_DESCRIPTIONS[issue.type]}`;
+  return issue.tier === "hint" ? `${HINT_MARKER} ${description}` : description;
+}
+function describeIssues(paragraph, width, maxWidth) {
+  return paragraph.issues.map((issue) => describeIssue(issue, width, maxWidth));
+}
+function describeComment(comment) {
+  const notes = [];
+  for (const paragraph of comment.paragraphs) {
+    const issues = describeIssues(paragraph, comment.width, comment.maxWidth);
+    if (issues.length > 0 && !paragraph.reflowable) {
+      const range = `lines ${paragraph.startLine}-${paragraph.endLine}`;
+      issues.push(
+        `${range} are kept as written (${paragraph.reason ?? "layout"}), so the tool never rewraps them and any fix to them is yours`
+      );
+    }
+    notes.push(...issues);
+  }
+  const fence = comment.text.includes("```") ? "~~~~" : "```";
+  return [
+    `### ${comment.file}:${comment.startLine}-${comment.endLine} (width ${comment.width}${comment.maxWidth === void 0 ? "" : `, maximum ${comment.maxWidth}`})`,
+    "",
+    ...notes.length > 0 ? notes.map((note2) => `- ${note2}`) : ["- no measured issues; review the wording and flow"],
+    "",
+    `${fence}ts`,
+    comment.text,
+    fence
+  ].join("\n");
+}
+function loadRules(agent, configPath) {
+  let rules = DEFAULT_RULES;
+  if (agent.rules) {
+    const base = configPath ? path.dirname(configPath) : process.cwd();
+    rules = readFileSync(path.resolve(base, agent.rules), "utf8");
+  }
+  return agent.instructions ? `${rules.trimEnd()}
+
+## Instructions
+
+${agent.instructions.trim()}
+` : rules;
+}
+function buildPrompt(options) {
+  return [
+    options.rules.trimEnd(),
+    "",
+    "## Task",
+    "",
+    `Fix the formatting of the comments below, following the rules above. Paths are relative to ${options.root}. Widths include indentation and the comment prefix. The notes under each comment come from the tool's measurements, so never count columns yourself.`,
+    "",
+    "- After you finish, the tool rewraps every prose paragraph as described under Layout, so a layout note on a prose paragraph needs no change from you. Change only the wording there, and leave its line breaks to the tool.",
+    "- A note that a line may end with the start of a sentence, clause, or parenthetical is the exception. Only you can tell whether it does, so if it does, move those words to the start of the next line.",
+    "- Parts kept as written are never rewrapped, and their notes say so. Fix those notes by hand, for example by breaking an overflowing prose line or by turning a long single-line comment into a multi-line one. Keep code, code spans, tables, box drawings, hard line breaks, and other intentional layout in them exactly as they are. If a note can only be fixed by changing those, leave it and say why in your reply.",
+    `- Notes marked \`${HINT_MARKER}\` come from heuristics. If the rule doesn't actually apply, don't change anything for that note.`,
+    "- Notes only point at places worth a look. Review each comment against the rules, and leave it as it is when it already follows them.",
+    "- Edit only these comments. Don't change code, other comments, or other files.",
+    "- When done, reply with one line per comment saying what you changed or why you left it.",
+    "",
+    ...options.comments.map((comment) => describeComment(comment)).flatMap((section) => [section, ""])
+  ].join("\n");
+}
+function shellQuote(value) {
+  return /^[\w./:@=-]+$/.test(value) ? value : `'${value.replaceAll("'", String.raw`'\''`)}'`;
+}
+function buildInvocation(options) {
+  const { agent, prompt, root } = options;
+  const extra = agent.args ?? [];
+  if (agent.command && agent.command.length > 0) {
+    const [command, ...args] = agent.command;
+    const hasPlaceholder = args.some((arg) => arg.includes("{prompt}"));
+    return {
+      command,
+      // a function keeps the prompt as it is, while a string would expand `$&` or `$'` in a comment's text
+      args: args.map((arg) => arg.replaceAll("{prompt}", () => prompt)),
+      stdin: hasPlaceholder ? void 0 : prompt
+    };
+  }
+  const model = agent.model ? ["--model", agent.model] : [];
+  if (options.runner === "claude") {
+    return {
+      command: "claude",
+      args: [
+        "-p",
+        "--no-session-persistence",
+        "--model",
+        agent.model ?? DEFAULT_CLAUDE_MODEL,
+        "--permission-mode",
+        "acceptEdits",
+        "--allowedTools",
+        "Read",
+        "Edit",
+        "Grep",
+        "Glob",
+        ...extra
+      ],
+      stdin: prompt
+    };
+  }
+  if (options.runner === "codex") {
+    return {
+      command: "codex",
+      args: [
+        "exec",
+        "--ephemeral",
+        "--sandbox",
+        "workspace-write",
+        "--cd",
+        root,
+        "-c",
+        "features.hooks=false",
+        ...model,
+        ...extra,
+        "-"
+      ],
+      stdin: prompt
+    };
+  }
+  return {
+    command: "cursor-agent",
+    args: ["-p", "--trust", "--force", "--workspace", root, ...model, ...extra, prompt]
+  };
+}
+function describeAgent(agent, runner) {
+  if (agent.command && agent.command.length > 0) {
+    return path.basename(agent.command[0]);
+  }
+  const model = runner === "claude" ? agent.model ?? DEFAULT_CLAUDE_MODEL : agent.model;
+  return model ? `${RUNNER_COMMANDS[runner]}, model ${model}` : RUNNER_COMMANDS[runner];
+}
+function formatInvocation(invocation) {
+  const args = invocation.args.map((arg) => arg.length > 80 ? "<prompt>" : shellQuote(arg));
+  return [invocation.command, ...args].join(" ");
+}
+function runAgent(invocation, options) {
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_SECONDS;
+  return new Promise((resolve) => {
+    const child = spawn(invocation.command, invocation.args, {
+      cwd: options.root,
+      env: { ...process.env, [CHILD_ENV]: "1" }
+    });
+    const timers = [];
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const settle = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      for (const timer of timers) {
+        clearTimeout(timer);
+      }
+      child.stdout.destroy();
+      child.stderr.destroy();
+      child.unref();
+      resolve({ ...result, output: `${stdout}${stderr}`.trim() });
+    };
+    const finish = (code, signal) => {
+      if (timedOut) {
+        settle({ ok: false, error: `the agent timed out after ${timeout}s` });
+      } else if (code === 0) {
+        settle({ ok: true });
+      } else {
+        settle({ ok: false, error: `the agent exited with code ${code ?? signal}` });
+      }
+    };
+    timers.push(
+      setTimeout(() => {
+        timedOut = true;
+        child.kill();
+        timers.push(
+          setTimeout(
+            () => {
+              child.kill("SIGKILL");
+              finish(null, "SIGKILL");
+            },
+            Math.min(KILL_GRACE_MS, timeout * 1e3)
+          )
+        );
+      }, timeout * 1e3)
+    );
+    child.stdout.setEncoding("utf8").on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8").on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      settle({
+        ok: false,
+        error: error.code === "ENOENT" ? `\`${invocation.command}\` is not installed` : error.message
+      });
+    });
+    child.on("close", finish);
+    child.on("exit", (code, signal) => {
+      timers.push(
+        setTimeout(() => {
+          finish(code, signal);
+        }, DRAIN_GRACE_MS)
+      );
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(invocation.stdin ?? "");
+  });
+}
+
+// src/comments/analyze.ts
+import { parseSync } from "oxc-parser";
+
+// src/comments/style.ts
+var BANNER = /^(?!#{1,6}\s)([-=*#_~+/\\])\1{3,}|([-=*#_~])\2{3,}\s*$/;
+var COLUMN_RULE = /^([-=_~])\1*(?:\s+\1+)+$/;
+var DASH = /(?<!\d)\s[–-]\s(?!\d)|(?<!(?:^|\s)-[\w-]*)\s--\s(?!-)/;
+var SEMICOLON = /;(?:\s|$)/;
+var EMPHASIS = /(?:^|[\s(])(\*\*?)(?=[\p{L}\p{N}])[^*]+?(?<!\s)\1(?=$|[\s)"']|[.,;:!?](?:$|[\s)"']))/u;
+var LIST_MARKER = /^(?:[-*+]|\d+[.)])\s+/;
+var CODE_SPAN = /(?<!`)(`+)(?!`)[\s\S]*?(?<!`)\1(?!`)/g;
+var COLON = /(?<=[\w)\]'"’])(?<!(?:^|[.!?]\s+)(?:[A-Z]{2,}|[Tt]odo|[Ff]ixme|[Hh]ack|[Xx]xx))(?<!\b(?:code|url|entity|[A-Za-z][a-z\d]*[A-Z]\w*|\w*_\w*)):\s+\S/;
+function replaceKeepingLines(text, pattern, replacement) {
+  return text.replaceAll(pattern, (match) => `${replacement}${"\n".repeat(match.split("\n").length - 1)}`);
+}
+function stripNonProse(text) {
+  let stripped = replaceKeepingLines(text, CODE_SPAN, "code");
+  for (let previous = ""; previous !== stripped; ) {
+    previous = stripped;
+    stripped = replaceKeepingLines(stripped, /\{[^{}]*\}/g, "code");
+  }
+  return stripped.replaceAll(/\b[a-z][\w+.-]*:\/\/\S+/gi, "url").replaceAll(/&(?:[a-z][a-z\d]*|#\d+|#x[\da-f]+);/gi, "entity");
+}
+function hasExplanatoryColon(text) {
+  return COLON.test(text.replace(LIST_MARKER, ""));
+}
+function isBanner(text) {
+  const prose = stripNonProse(text.trim());
+  return BANNER.test(prose) && !COLUMN_RULE.test(prose);
+}
+function findStyleIssues(lines) {
+  const issues = [];
+  const prose = stripNonProse(lines.map((line) => line.text.trim()).join("\n"));
+  const proseLines = replaceKeepingLines(prose, /^@\w+\s+(?:code\s+)?(?:\S+\s+-\s+)?/gm, "").split("\n");
+  for (const [position, line] of lines.entries()) {
+    const text = proseLines[position].trim();
+    const report = (type) => {
+      issues.push({ type, index: line.index });
+    };
+    if (isBanner(line.text)) {
+      report("banner");
+    } else {
+      if (SEMICOLON.test(text)) {
+        report("semicolon");
+      }
+      if (text.includes("\u2014")) {
+        report("em-dash");
+      }
+      if (DASH.test(text)) {
+        report("dash");
+      }
+      if (hasExplanatoryColon(text)) {
+        report("label-colon");
+      }
+      if (EMPHASIS.test(text)) {
+        report("emphasis");
+      }
+    }
+  }
+  return issues;
+}
+
+// src/comments/wrap.ts
+var CLAUSE_END = /[.!?,;:]["')\]*_]*$/;
+var SENTENCE_END = /[.!?]["')\]*_]*$/;
+var ABBREVIATIONS = /* @__PURE__ */ new Set([
+  "e.g.",
+  "i.e.",
+  "etc.",
+  "vs.",
+  "cf.",
+  "approx.",
+  "incl.",
+  "resp.",
+  "al.",
+  "viz.",
+  "esp.",
+  "ca.",
+  "fig.",
+  "figs.",
+  "eq.",
+  "vol.",
+  "pp.",
+  "mr.",
+  "mrs.",
+  "ms.",
+  "dr.",
+  "prof.",
+  "st."
+]);
+function isAbbreviation(word) {
+  const bare = word.replace(/^[(["']+/, "").replace(/[)\]"']+$/, "").toLowerCase();
+  return ABBREVIATIONS.has(bare) || /^(?:[a-z]\.){2,}$/.test(bare);
+}
+function findClosingBrace(text, start) {
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    if (text[index] === "{") {
+      depth += 1;
+    } else if (text[index] === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+  return -1;
+}
+function backtickRun(text, start) {
+  let end = start;
+  while (text[end] === "`") {
+    end += 1;
+  }
+  return end - start;
+}
+function findCodeSpanEnd(text, start) {
+  const run = backtickRun(text, start);
+  for (let index = text.indexOf("`", start + run); index !== -1; ) {
+    const length = backtickRun(text, index);
+    if (length === run) {
+      return index + length - 1;
+    }
+    index = text.indexOf("`", index + length);
+  }
+  return -1;
+}
+function tokenize(text) {
+  const tokens = [];
+  let current = "";
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    const close = char === "`" ? findCodeSpanEnd(text, index) : char === "{" ? findClosingBrace(text, index) : -1;
+    if (char === "`" && close === -1) {
+      const run = backtickRun(text, index);
+      current += text.slice(index, index + run);
+      index += run;
+      continue;
+    }
+    if (close !== -1) {
+      current += text.slice(index, close + 1);
+      index = close + 1;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      index += 1;
+      continue;
+    }
+    current += char;
+    index += 1;
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function parentheticalEnd(text) {
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 1;
+      continue;
+    }
+    const close = char === "`" ? findCodeSpanEnd(text, index) : char === "{" ? findClosingBrace(text, index) : -1;
+    if (close !== -1) {
+      index = close;
+    } else if (char === "(") {
+      depth += 1;
+    } else if (char === ")" && --depth === 0) {
+      return index;
+    }
+  }
+  return -1;
+}
+function isParenthetical(token) {
+  return token.startsWith("(") && parentheticalEnd(token) !== -1;
+}
+function parentheticalGroups(tokens, limit) {
+  const groups = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    if (tokens[index].startsWith("(")) {
+      const end = parentheticalEnd(tokens.slice(index).join(" "));
+      let last = index;
+      let length = tokens[index].length;
+      while (length <= end && last + 1 < tokens.length) {
+        length += 1 + tokens[++last].length;
+      }
+      if (end !== -1 && length <= limit) {
+        groups.push({ start: index, end: last + 1 });
+        index = last;
+        continue;
+      }
+    }
+  }
+  return groups;
+}
+function bindParentheticals(tokens, limit) {
+  const groups = new Map(parentheticalGroups(tokens, limit).map((group) => [group.start, group.end]));
+  const units = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const end = groups.get(index) ?? index + 1;
+    units.push(tokens.slice(index, end).join(" "));
+    index = end - 1;
+  }
+  return units;
+}
+function endsClause(token) {
+  return CLAUSE_END.test(token) && !isAbbreviation(token);
+}
+function endsSentence(token) {
+  return SENTENCE_END.test(token) && !isAbbreviation(token);
+}
+function opensAside(token) {
+  return /^[([]/.test(token) && !/[)\]]["'`.,;:!?]*$/.test(token);
+}
+function isOrphan(previous, token) {
+  return opensAside(token) || endsClause(previous) && !CLAUSE_END.test(token);
+}
+function startsBlock(token) {
+  return /^(?:[-*+>]|\d+[.)]|#{1,6})$/.test(token) || /^(?:@[A-Za-z]|`{3}|~{3}|\||<\/?[A-Za-z])/.test(token);
+}
+function bindLineStarts(tokens, startsLine2 = startsBlock) {
+  const units = [];
+  for (const [index, token] of tokens.entries()) {
+    if (units.length > 0 && startsLine2(token, tokens[index + 1])) {
+      units[units.length - 1] += ` ${token}`;
+    } else {
+      units.push(token);
+    }
+  }
+  return units;
+}
+function breaksBefore(previous, last, next, options) {
+  return options.avoidSentenceOrphans && isOrphan(previous, last) || startsBlock(next);
+}
+function lineLength(tokens) {
+  let length = 0;
+  for (const token of tokens) {
+    length += token.length;
+  }
+  return length + Math.max(0, tokens.length - 1);
+}
+function wrapTokens(tokens, firstLimit, restLimit, options) {
+  return wrapFrom(tokens, 0, firstLimit, restLimit, options, Infinity);
+}
+function wrapFrom(tokens, from, firstLimit, restLimit, options, maxLines) {
+  const lines = [];
+  let line = [];
+  let length = 0;
+  for (let index = from; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    while (line.length > 0) {
+      const limit = lines.length === 0 ? firstLimit : restLimit;
+      const nextLength = length + 1 + token.length;
+      const extra = isParenthetical(token) ? options.parentheticalOverflow ?? 0 : 0;
+      if (nextLength <= limit + extra) {
+        break;
+      }
+      const carry = [];
+      while (line.length >= 2 && breaksBefore(line.at(-2) ?? "", line.at(-1) ?? "", carry[0] ?? token, options)) {
+        carry.unshift(line.pop() ?? "");
+      }
+      lines.push(line);
+      if (lines.length >= maxLines) {
+        return lines;
+      }
+      line = carry;
+      length = lineLength(carry);
+    }
+    line.push(token);
+    length = lineLength(line);
+  }
+  if (line.length > 0) {
+    lines.push(line);
+  }
+  return lines;
+}
+var MIN_LAST_LINE_WORDS = 3;
+function hasWidow(lines) {
+  const last = lines.at(-1) ?? [];
+  const words = last.reduce((count, token) => count + (isParenthetical(token) ? tokenize(token).length : 1), 0);
+  return lines.length >= 2 && words < MIN_LAST_LINE_WORDS;
+}
+var FULLNESS_WEIGHT = 0.07;
+var PARENTHETICAL_SPLIT_WEIGHT = 2;
+var MAX_STEP = 15;
+var EXTRA_LINES = 2;
+function fewestLines(starts, target) {
+  const total = starts.length - 1;
+  const fewest = new Int32Array(total + 1);
+  let end = total;
+  for (let index = total - 1; index >= 0; index -= 1) {
+    while (starts[end] - starts[index] - 1 > target) {
+      end -= 1;
+    }
+    fewest[index] = fewest[end] + 1;
+  }
+  return fewest;
+}
+function firstAtMost(values, limit, from) {
+  let low = from;
+  let high = values.length - 1;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (values[middle] <= limit) {
+      high = middle;
+    } else {
+      low = middle + 1;
+    }
+  }
+  return low;
+}
+function costsOfLine(input, target, line, previous, fewest) {
+  const { starts, afterOrphan } = input;
+  const offset = line === 1 ? input.offset : 0;
+  const linesLeft = input.count - line;
+  const last = starts.length - 1 - linesLeft;
+  const base = firstAtMost(fewest, linesLeft, Math.max(line, previous.low + 1));
+  const costs = [];
+  const origins = [];
+  let low = -1;
+  let high = -1;
+  for (let end = base; end <= last; end += 1) {
+    const nearest = Math.min(end - 1, previous.high);
+    if (end > previous.high && starts[end] - starts[nearest] - 1 + offset > target) {
+      break;
+    }
+    let cost = Infinity;
+    let origin = -1;
+    if (!input.blockStarts[end]) {
+      const splitCost = input.splitCosts.get(end) ?? 0;
+      for (let start = nearest; start >= previous.low; start -= 1) {
+        const length = starts[end] - starts[start] - 1 + offset;
+        if (length > target) {
+          break;
+        }
+        const before = previous.costs[start - previous.base];
+        if (before === Infinity || afterOrphan[end] && end - start >= 2) {
+          continue;
+        }
+        const candidate = before + (target - length) ** 2 + splitCost;
+        if (candidate <= cost) {
+          cost = candidate;
+          origin = start;
+        }
+      }
+    }
+    costs.push(cost);
+    origins.push(origin);
+    if (cost !== Infinity) {
+      low = low === -1 ? end : low;
+      high = end;
+    }
+  }
+  return low === -1 ? void 0 : { base, costs, origins, low, high };
+}
+function balanceTokens(tokens, firstLimit, restLimit, count, options, preferredLimit = restLimit, splitCosts = /* @__PURE__ */ new Map()) {
+  const total = tokens.length;
+  const starts = [0];
+  let longest = -Infinity;
+  for (const token of tokens) {
+    starts.push((starts.at(-1) ?? 0) + token.length + 1);
+    longest = Math.max(longest, token.length);
+  }
+  const input = {
+    starts,
+    count,
+    offset: restLimit - firstLimit,
+    blockStarts: tokens.map((token) => startsBlock(token)),
+    afterOrphan: tokens.map((_, index) => {
+      return options.avoidSentenceOrphans && index >= 2 && isOrphan(tokens[index - 2], tokens[index - 1]);
+    }),
+    splitCosts
+  };
+  const targets = [];
+  for (let target = restLimit; target >= Math.max(longest, Math.floor(restLimit / 2)); target -= 1) {
+    targets.push(target);
+  }
+  const most = starts[total] - count + input.offset;
+  let best;
+  for (const target of targets.toReversed()) {
+    const fullness = FULLNESS_WEIGHT * (count - 1) * (preferredLimit - target) ** 2;
+    const spare = (count - 1) * target - most;
+    const least = count > 1 && spare > 0 ? Math.max(spare ** 2 / (count - 1) - 1, 0) : 0;
+    if (best !== void 0 && least + fullness > best.cost) {
+      continue;
+    }
+    const fewest = fewestLines(starts, target);
+    const rows = [{ base: 0, costs: [0], origins: [-1], low: 0, high: 0 }];
+    for (let line = 1; line < count; line += 1) {
+      const row2 = costsOfLine(input, target, line, rows[line - 1], fewest);
+      if (!row2) {
+        break;
+      }
+      rows.push(row2);
+    }
+    if (rows.length < count) {
+      continue;
+    }
+    const row = rows[count - 1];
+    for (let start = row.low; start <= row.high; start += 1) {
+      const score = row.costs[start - row.base] + fullness;
+      const improves = score < (best?.cost ?? Infinity) || score === best?.cost && target > best.target;
+      if (!improves || starts[total] - starts[start] - 1 > target || hasWidow([[], tokens.slice(start)])) {
+        continue;
+      }
+      const breaks = [start];
+      for (let line = count - 1; line > 1; line -= 1) {
+        breaks.unshift(rows[line].origins[breaks[0] - rows[line].base]);
+      }
+      best = { cost: score, target, breaks };
+    }
+  }
+  if (!best) {
+    return void 0;
+  }
+  const bounds = [0, ...best.breaks, total];
+  return bounds.slice(0, -1).map((start, index) => tokens.slice(start, bounds[index + 1]));
+}
+function hasStep(lines, offset = 0) {
+  return lines.some((line, index) => {
+    if (index === 0) {
+      return false;
+    }
+    const before = lineLength(lines[index - 1]) + (index === 1 ? offset : 0);
+    return lineLength(line) - before > MAX_STEP;
+  });
+}
+function splitCostsOf(tokens, limit) {
+  const splitCosts = /* @__PURE__ */ new Map();
+  for (const group of parentheticalGroups(tokens, limit)) {
+    const length = lineLength(tokens.slice(group.start, group.end));
+    for (let at = group.start + 1; at < group.end; at += 1) {
+      splitCosts.set(at, length * PARENTHETICAL_SPLIT_WEIGHT);
+    }
+  }
+  return splitCosts;
+}
+function hasParentheticals(tokens, restLimit, options) {
+  if (options.parentheticalOverflow === void 0) {
+    return false;
+  }
+  return bindParentheticals(tokens, restLimit + options.parentheticalOverflow).some((token) => isParenthetical(token));
+}
+function layoutTokens(tokens, firstLimit, restLimit, options) {
+  const lines = layoutLines(tokens, firstLimit, restLimit, options);
+  const offset = restLimit - firstLimit;
+  if (options.keepFirstLine || options.keepSteps || !hasStep(lines, offset)) {
+    return lines;
+  }
+  const overflow = hasParentheticals(tokens, restLimit, options) ? options.parentheticalOverflow ?? 0 : 0;
+  const splitCosts = overflow > 0 ? splitCostsOf(tokens, restLimit + overflow) : /* @__PURE__ */ new Map();
+  for (let count = lines.length + 1; count <= lines.length + EXTRA_LINES; count += 1) {
+    const even = balanceTokens(
+      tokens,
+      firstLimit + overflow,
+      restLimit + overflow,
+      count,
+      options,
+      restLimit,
+      splitCosts
+    );
+    if (even && !hasStep(even, offset)) {
+      return even;
+    }
+  }
+  return lines;
+}
+function layoutLines(tokens, firstLimit, restLimit, options) {
+  if (options.parentheticalOverflow !== void 0) {
+    const grouped = bindParentheticals(tokens, restLimit + options.parentheticalOverflow);
+    if (grouped.some((token) => isParenthetical(token))) {
+      const minimumLines = Math.max(
+        2,
+        Math.ceil((lineLength(tokens) + 1 + restLimit - firstLimit) / Math.max(1, restLimit + 1))
+      );
+      let preserved = wrapTokens(grouped, firstLimit, restLimit, options);
+      if (minimumLines === 2 && preserved.length > 2) {
+        const wide = wrapTokens(
+          grouped,
+          firstLimit + options.parentheticalOverflow,
+          restLimit + options.parentheticalOverflow,
+          { ...options, parentheticalOverflow: void 0 }
+        );
+        if (wide.length === 2 && !hasWidow(wide)) {
+          preserved = wide;
+        }
+      }
+      if (preserved.length <= 2 && !hasWidow(preserved)) {
+        let cursor = 0;
+        return preserved.map((line) => {
+          const expanded = [];
+          const length = lineLength(line);
+          let used = -1;
+          while (cursor < tokens.length && used < length) {
+            const token = tokens[cursor++];
+            expanded.push(token);
+            used += token.length + 1;
+          }
+          return expanded;
+        });
+      }
+      const splitCosts = splitCostsOf(tokens, restLimit + options.parentheticalOverflow);
+      const preferred = wrapTokens(tokens, firstLimit, restLimit, { ...options, parentheticalOverflow: void 0 });
+      for (let count = minimumLines; count <= Math.max(preferred.length + 1, preserved.length); count += 1) {
+        const balanced2 = balanceTokens(
+          tokens,
+          firstLimit + options.parentheticalOverflow,
+          restLimit + options.parentheticalOverflow,
+          count,
+          options,
+          restLimit,
+          splitCosts
+        );
+        if (balanced2) {
+          return balanced2;
+        }
+      }
+    }
+  }
+  const greedy = wrapTokens(tokens, firstLimit, restLimit, options);
+  if (greedy.length < 2) {
+    return greedy;
+  }
+  if (options.keepFirstLine) {
+    const [head] = greedy;
+    const rest = layoutTokens(tokens.slice(head.length), restLimit, restLimit, { ...options, keepFirstLine: false });
+    const lines = [head, ...rest];
+    if (!hasWidow(lines)) {
+      return lines;
+    }
+  }
+  const balanced = balanceTokens(tokens, firstLimit, restLimit, greedy.length, options);
+  if (balanced) {
+    return balanced;
+  }
+  const stretched = wrapTokens(tokens, firstLimit + options.tolerance, restLimit + options.tolerance, options);
+  return hasWidow(stretched) ? greedy : stretched;
+}
+function breakAfterSentence(lines, firstLimit, restLimit, options) {
+  if (lines.length !== 2 || !options.avoidSentenceOrphans) {
+    return lines;
+  }
+  const tokens = lines.flat();
+  const offset = restLimit - firstLimit;
+  for (let end = tokens.length - 1; end > 0; end -= 1) {
+    const first = tokens.slice(0, end);
+    const second = tokens.slice(end);
+    if (endsSentence(tokens[end - 1]) && !hasWidow([first, second]) && !breaksBefore(tokens[end - 2] ?? "", tokens[end - 1], tokens[end], options) && lineLength(first) <= firstLimit && lineLength(second) <= lineLength(first) + offset) {
+      return [first, second];
+    }
+  }
+  return lines;
+}
+function findLineIssues(lines, firstLimit, restLimit, options) {
+  const issues = [];
+  const tokens = lines.flat();
+  let next = 0;
+  for (const [index, line] of lines.entries()) {
+    const limit = index === 0 ? firstLimit : restLimit;
+    const length = lineLength(line);
+    const start = next;
+    next += line.length;
+    if (line.length > 1 && length > limit + options.tolerance) {
+      issues.push({ type: "overflow", line: index });
+    }
+    if (index === lines.length - 1 || line.length === 0) {
+      continue;
+    }
+    if (options.avoidSentenceOrphans && line.length >= 2 && isOrphan(line.at(-2) ?? "", line.at(-1) ?? "")) {
+      issues.push({ type: "orphan", line: index });
+    }
+    const [expected] = wrapFrom(tokens, start, limit, restLimit, options, 1);
+    if (expected.length > line.length) {
+      issues.push({ type: "underfill", line: index });
+    }
+  }
+  return issues;
+}
+
+// src/comments/analyze.ts
+var ISSUE_TIERS = {
+  overflow: "verdict",
+  underfill: "verdict",
+  widow: "verdict",
+  unbalanced: "verdict",
+  orphan: "hint",
+  banner: "hint",
+  "em-dash": "hint",
+  semicolon: "hint",
+  "label-colon": "hint",
+  emphasis: "hint",
+  dash: "hint"
+};
+var IGNORE_DIRECTIVE = "comments-ignore";
+var FENCE = /^(?:`{3,}(?!.*`)|~{3,})/;
+var JSDOC_TAG = /^@([A-Za-z]+)/;
+var NESTED_LIST_MARKER = /^\s+(?:[-*+]|\d+[.)])\s+/;
+var PROSE_TAGS = /* @__PURE__ */ new Set([
+  "arg",
+  "argument",
+  "deprecated",
+  "description",
+  "exception",
+  "note",
+  "param",
+  "prop",
+  "property",
+  "remarks",
+  "return",
+  "returns",
+  "see",
+  "since",
+  "summary",
+  "template",
+  "throws",
+  "todo",
+  "typeParam",
+  "yields"
+]);
+var CODE_TAGS = /* @__PURE__ */ new Set(["default", "defaultValue", "example"]);
+var NAMED_TAGS = /* @__PURE__ */ new Set(["arg", "argument", "param", "prop", "property", "template", "typeParam"]);
+var LINE_DIRECTIVE = /^\s*(?:(?:eslint|oxlint|stylelint)-(?:disable(?:-next-line|-line)?|enable)\b|eslint-env\b|@ts-(?:ignore|expect-error|nocheck|check)\b|@jsx\w*\b|@vite-ignore\b|[@#]__[A-Z_]+__|@(?:vitest|jest)-environment\b|(?:istanbul|c8|v8)\s+ignore\b|prettier-ignore\b|biome-ignore\b|deno-(?:lint-ignore|fmt-ignore)(?:-file)?\b|tslint:|(?:c[sS]pell|spell-?checker)\s*:|(?:webpack|turbopack)[A-Z][a-zA-Z]*\s*:|vim?:\s|#(?:region|endregion)\b|<reference\s)/;
+var BLOCK_DIRECTIVE = /^\s*(?:eslint\s|globals?\s|exported\s|jshint\s|jslint\s|type\s*:)/;
+var LEGAL_COMMENT = /^!|@license\b|@preserve\b|\bcopyright\s+(?:\(c\)|©|\d{4})/i;
+var DEFINITION = /^(?:``|[\w$.[\]]+(?:[ -][\w$.[\]]+)?)(?: [-–]|:) \S/;
+var BOX_DRAWING = /[\u2500-\u257F]/;
+var TABLE_DELIMITER = /^\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)+\|?$/;
+var ARROWS_OR_RULES = /[▲▼◀▶→←↑↓]|-->|<--|\+-{2,}|-{3,}|={4,}/;
+var HARD_BREAK = /\S {2,}$|(?<!\\)\\(?:\\\\)*$/;
+function isProseLike(statement, source) {
+  if (statement.type === "LabeledStatement") {
+    return source[statement.end - 1] !== ";";
+  }
+  if (statement.type === "EmptyStatement") {
+    return true;
+  }
+  if (statement.type !== "ExpressionStatement") {
+    return false;
+  }
+  let { expression } = statement;
+  while (expression.type === "ParenthesizedExpression") {
+    expression = expression.expression;
+  }
+  if (expression.type === "TaggedTemplateExpression") {
+    return expression.tag.type === "Identifier";
+  }
+  return expression.type === "Identifier" || expression.type === "Literal" || expression.type === "TemplateLiteral";
+}
+function parsesAsStatements(text) {
+  if (!/[()[\]{}=;<>]/.test(text)) {
+    return false;
+  }
+  const source = `async function* comment() {
+${text}
+}`;
+  const { program, errors } = parseSync("comment.tsx", source);
+  const wrapper = program.body.at(0);
+  if (errors.length > 0 || wrapper?.type !== "FunctionDeclaration" || !wrapper.body) {
+    return false;
+  }
+  const statements = wrapper.body.body;
+  return statements.length > 0 && !statements.every((statement) => isProseLike(statement, source));
+}
+var CODE_VALUES = /* @__PURE__ */ new Set([
+  "Literal",
+  "ArrayExpression",
+  "ObjectExpression",
+  "CallExpression",
+  "NewExpression",
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "UnaryExpression",
+  "MemberExpression"
+]);
+function parsesAsProperties(text) {
+  if (!text.includes(":")) {
+    return false;
+  }
+  const { program, errors } = parseSync("comment.ts", `({
+${text}
+})`);
+  const statement = program.body.at(0);
+  if (errors.length > 0 || program.body.length !== 1 || statement?.type !== "ExpressionStatement") {
+    return false;
+  }
+  let { expression } = statement;
+  while (expression.type === "ParenthesizedExpression") {
+    expression = expression.expression;
+  }
+  if (expression.type !== "ObjectExpression" || expression.properties.length === 0) {
+    return false;
+  }
+  const { properties } = expression;
+  if (!properties.every((property) => property.type === "Property" && !property.shorthand && !property.method)) {
+    return false;
+  }
+  return properties.length > 1 || text.trimEnd().endsWith(",") || properties.some((property) => property.type === "Property" && CODE_VALUES.has(property.value.type));
+}
+function isCode(texts) {
+  const text = texts.map((line) => line.replace(LIST_MARKER, "")).join("\n");
+  return parsesAsStatements(text) || parsesAsProperties(text);
+}
+function isCodeLine(text) {
+  return text.endsWith("{") || text.endsWith(";") && (/[()[\]{}=<>]/.test(text) || !/\s/.test(text)) || /^[}\])]/.test(text) || /^(?:const|let|var)\s+[\w$]+\s*[:=]/.test(text) || /^(?:import|export)\s.*(?:\sfrom\s|[{}])/.test(text);
+}
+function layoutReason(prose, raw) {
+  if (prose.startsWith("|") || TABLE_DELIMITER.test(prose)) {
+    return "table row";
+  }
+  if (BOX_DRAWING.test(prose)) {
+    return "box drawing";
+  }
+  if (isBanner(raw)) {
+    return "repeated characters";
+  }
+  return void 0;
+}
+function isMarkup(prose) {
+  return /^#{1,6}\s/.test(prose) || /^\[[^\]]+\]:/.test(prose) || /^<\/?[a-z]/i.test(prose) || /^>(?:\s|$)/.test(prose);
+}
+function mask(text) {
+  return text.replaceAll(/[^\n]/g, "x");
+}
+function maskCode(text) {
+  let masked = text.replaceAll(CODE_SPAN, mask);
+  for (let previous = ""; previous !== masked; ) {
+    previous = masked;
+    masked = masked.replaceAll(/\{[^{}]*\}/g, mask);
+  }
+  return masked;
+}
+function hasAlignedColumns(lines) {
+  const masked = maskCode(lines.map((body) => body.text).join("\n")).split("\n");
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of masked) {
+    const columns = new Set([...line.matchAll(/[^\s.!?][^\S\n]{2,}(?=\S)/g)].map((gap) => gap.index + gap[0].length));
+    if ([...columns].some((column) => seen.has(column))) {
+      return true;
+    }
+    for (const column of columns) {
+      seen.add(column);
+    }
+  }
+  return false;
+}
+function structureOf(lines) {
+  const trimmed = lines.map((line) => line.text.trim()).join("\n");
+  const texts = replaceKeepingLines(trimmed, CODE_SPAN, "``").split("\n");
+  const proseLines = stripNonProse(trimmed).split("\n");
+  if (isCode(lines.map((line) => line.text.trim()))) {
+    return { tier: "code", reason: "code" };
+  }
+  let layout;
+  let codeLike = false;
+  let manual = lines.slice(0, -1).some((line) => line.hardBreak) ? "hard line break" : void 0;
+  for (const [position, line] of texts.entries()) {
+    const prose = proseLines[position].trim();
+    layout ??= layoutReason(prose, lines[position]?.text ?? "");
+    if (isCodeLine(line.trim())) {
+      codeLike = true;
+    } else if (isMarkup(prose)) {
+      manual ??= "markup";
+    } else if ((prose.match(/\|/g)?.length ?? 0) >= 2) {
+      manual ??= "pipes";
+    } else if (ARROWS_OR_RULES.test(prose)) {
+      manual ??= "arrows or rules";
+    }
+  }
+  layout ??= hasAlignedColumns(lines) ? "aligned columns" : void 0;
+  if (layout) {
+    return { tier: "layout", reason: layout };
+  }
+  if (codeLike) {
+    return { tier: "code-like", reason: "code-like line" };
+  }
+  if (texts.filter((text) => DEFINITION.test(text.trim())).length >= 2) {
+    manual ??= "definition-like lines";
+  }
+  return manual ? { tier: "manual", reason: manual } : void 0;
+}
+var FenceTracker = class {
+  _open;
+  isInside() {
+    return this._open !== void 0;
+  }
+  next(text) {
+    const trimmed = text.trim();
+    if (this._open === void 0) {
+      this._open = FENCE.exec(trimmed)?.[0];
+      return this._open !== void 0;
+    }
+    if (trimmed.startsWith(this._open) && new RegExp(`^\\${this._open[0]}+$`).test(trimmed)) {
+      this._open = void 0;
+    }
+    return true;
+  }
+};
+function segment(lines) {
+  const paragraphs = [];
+  const fence = new FenceTracker();
+  let current;
+  let inCodeTag = false;
+  const flush = () => {
+    if (current) {
+      while (current.lines.length > 1 && !current.lines.at(-1)?.text.trim()) {
+        current.lines.pop();
+      }
+      paragraphs.push(current);
+      current = void 0;
+    }
+  };
+  const start = (kind, line, marker = "", reason) => {
+    flush();
+    current = { kind, lines: [line], marker, reason };
+  };
+  for (const line of lines) {
+    const { text } = line;
+    if (inCodeTag) {
+      if (fence.isInside() || !JSDOC_TAG.test(text)) {
+        fence.next(text);
+        current?.lines.push(line);
+        continue;
+      }
+      inCodeTag = false;
+    }
+    if (fence.isInside()) {
+      current?.lines.push(line);
+      fence.next(text);
+      if (!fence.isInside()) {
+        flush();
+      }
+      continue;
+    }
+    if (line.verbatim) {
+      start("code", line, "", "directive");
+      flush();
+      continue;
+    }
+    if (!text.trim()) {
+      flush();
+      continue;
+    }
+    if (fence.next(text)) {
+      start("code", line, "", "code block");
+      continue;
+    }
+    if (/^\s/.test(text)) {
+      const holdsProse = current?.kind === "list" || current?.kind === "tag" && !current.reason;
+      const nested = holdsProse ? NESTED_LIST_MARKER.exec(text) : null;
+      if (nested) {
+        start("list", line, nested[0]);
+      } else if (current && (current.kind === "list" || current.kind === "tag" || current.reason === "indented")) {
+        current.lines.push(line);
+      } else {
+        start("code", line, "", "indented");
+      }
+      continue;
+    }
+    const tag = JSDOC_TAG.exec(text);
+    if (tag) {
+      start("tag", line, "", PROSE_TAGS.has(tag[1]) ? void 0 : `@${tag[1]} tag`);
+      inCodeTag = CODE_TAGS.has(tag[1]);
+      continue;
+    }
+    const marker = LIST_MARKER.exec(text);
+    if (marker) {
+      start("list", line, marker[0]);
+      continue;
+    }
+    if (current && (current.kind === "prose" || current.kind === "tag" || current.kind === "list")) {
+      current.lines.push(line);
+      continue;
+    }
+    start("prose", line);
+  }
+  flush();
+  return paragraphs;
+}
+function startsLine(token, next) {
+  return startsBlock(token) || LINE_DIRECTIVE.test(next === void 0 ? token : `${token} ${next}`);
+}
+function visualLength(text, tabWidth) {
+  return text.replaceAll("	", " ".repeat(tabWidth)).length;
+}
+function sourceLineLength(line, tabWidth) {
+  return visualLength(`${line.prefix}${line.text.trimEnd()}`, tabWidth);
+}
+function overflowIssues(lines, options) {
+  const issues = [];
+  const limit = options.maxWidth ?? options.width + options.tolerance;
+  for (const line of lines) {
+    const length = sourceLineLength(line, options.tabWidth);
+    if (length <= limit) {
+      continue;
+    }
+    if (options.maxWidth !== void 0) {
+      issues.push(lineIssue("overflow", line, options));
+      continue;
+    }
+    const prefixLength = visualLength(`${line.prefix}${/^\s*/.exec(line.text)?.[0] ?? ""}`, options.tabWidth);
+    const tokens = bindLineStarts(tokenize(line.text), startsLine);
+    if (tokens.length > 1 && tokens.every((token) => prefixLength + token.length <= limit)) {
+      issues.push(lineIssue("overflow", line, options));
+    }
+  }
+  return issues;
+}
+function lineIssue(type, line, options) {
+  return { type, tier: ISSUE_TIERS[type], line: line.index + 1, length: sourceLineLength(line, options.tabWidth) };
+}
+function stripBlockSyntax(text) {
+  return text.replace(/^\s*\/\*+/, "").replace(/\*+\/\s*$/, "").replace(/^\s*\*(?=\s|$)/, "");
+}
+function bannerIssues(paragraph, options) {
+  const verbatim = ["code block", "indented", "legal comment"];
+  if (!options.style || paragraph.reason !== void 0 && verbatim.includes(paragraph.reason)) {
+    return [];
+  }
+  const banners = paragraph.lines.filter((line) => {
+    const text = paragraph.kind === "other" ? stripBlockSyntax(line.text) : line.text;
+    return isBanner(text) || paragraph.kind === "other" && /^\s*\/\*{3,}|\*{3,}\/\s*$/.test(line.text);
+  });
+  return banners.map((line) => lineIssue("banner", line, options));
+}
+function styleIssues(paragraph, options) {
+  if (!options.style) {
+    return [];
+  }
+  const byIndex = new Map(paragraph.lines.map((line) => [line.index, line]));
+  const lines = paragraph.lines.map((line) => {
+    return { index: line.index, text: paragraph.kind === "other" ? stripBlockSyntax(line.text) : line.text };
+  });
+  return findStyleIssues(lines).flatMap((issue) => {
+    const line = byIndex.get(issue.index);
+    return line ? [lineIssue(issue.type, line, options)] : [];
+  });
+}
+function bindTagHead(tokens) {
+  let end = 1;
+  if (tokens[end]?.startsWith("{")) {
+    end += 1;
+  }
+  if (NAMED_TAGS.has(tokens[0].slice(1)) && end < tokens.length) {
+    end += 1;
+  }
+  if (tokens[end] === "-") {
+    end += 1;
+  }
+  return [tokens.slice(0, end).join(" "), ...tokens.slice(end)];
+}
+function keptIssues(paragraph, structure, options) {
+  const tier = structure?.tier ?? "manual";
+  return byLine([
+    ...tier === "manual" || tier === "code-like" ? overflowIssues(paragraph.lines, options) : [],
+    ...tier === "code" || tier === "code-like" ? [] : styleIssues(paragraph, options),
+    ...bannerIssues(paragraph, options)
+  ]);
+}
+function byLine(issues) {
+  const unique = new Map(issues.map((issue) => [`${issue.line}:${issue.type}`, issue]));
+  return [...unique.values()].toSorted((a, b) => a.line - b.line);
+}
+function sameLayout(a, b) {
+  return a.length === b.length && a.every((words, position) => words.join(" ") === b[position].join(" "));
+}
+function analyzeParagraph(paragraph, options) {
+  const first = paragraph.lines[0];
+  const last = paragraph.lines.at(-1) ?? first;
+  const base = { kind: paragraph.kind, startLine: first.index + 1, endLine: last.index + 1 };
+  if (paragraph.kind === "code") {
+    return {
+      ...base,
+      reflowable: false,
+      reason: paragraph.reason,
+      issues: bannerIssues(paragraph, options),
+      suggestion: null
+    };
+  }
+  if (paragraph.kind === "tag" && paragraph.reason) {
+    const codeTag = CODE_TAGS.has(JSDOC_TAG.exec(first.text)?.[1] ?? "");
+    const issues2 = codeTag ? [] : overflowIssues(paragraph.lines, options);
+    return { ...base, reflowable: false, reason: paragraph.reason, issues: issues2, suggestion: null };
+  }
+  if (paragraph.kind === "other") {
+    const fence = new FenceTracker();
+    const prose = {
+      ...paragraph,
+      lines: paragraph.lines.filter((line) => !fence.next(stripBlockSyntax(line.text)))
+    };
+    const structure2 = structureOf(
+      prose.lines.map((line) => {
+        return { ...line, text: stripBlockSyntax(line.text) };
+      })
+    );
+    const issues2 = keptIssues(prose, structure2, options);
+    return { ...base, reflowable: false, reason: paragraph.reason, issues: issues2, suggestion: null };
+  }
+  const keep = (structure2) => {
+    const issues2 = keptIssues(paragraph, structure2, options);
+    return { ...base, reflowable: false, reason: structure2.reason, issues: issues2, suggestion: null };
+  };
+  const structure = structureOf(paragraph.lines);
+  if (structure) {
+    return keep(structure);
+  }
+  const prefix = first.prefix;
+  const prefixLength = visualLength(prefix, options.tabWidth);
+  const hang = " ".repeat(paragraph.marker.length);
+  const firstLimit = options.width - prefixLength - paragraph.marker.length;
+  const restLimit = options.width - prefixLength - hang.length;
+  const currentLines = paragraph.lines.map(
+    (line, position) => bindLineStarts(tokenize(position === 0 ? line.text.slice(paragraph.marker.length) : line.text), startsLine)
+  );
+  const tokens = tokenize(currentLines.flat().join(" "));
+  const layoutOptions = {
+    ...options,
+    tolerance: options.maxWidth === void 0 ? options.tolerance : Math.min(options.tolerance, options.maxWidth - options.width),
+    parentheticalOverflow: options.maxWidth === void 0 ? void 0 : options.maxWidth - options.width,
+    keepFirstLine: paragraph.kind === "tag"
+  };
+  const layOut = (from, settings) => {
+    const even2 = layoutTokens(from, firstLimit, restLimit, settings);
+    return { even: even2, wrapped: breakAfterSentence(even2, firstLimit, restLimit, settings) };
+  };
+  const units = bindLineStarts(paragraph.kind === "tag" ? bindTagHead(tokens) : tokens, startsLine);
+  const hardLimit = restLimit + (options.maxWidth === void 0 ? options.tolerance : options.maxWidth - options.width);
+  const written = currentLines.map((words) => ` ${words.join(" ")} `);
+  const staysInLimit = (unit) => {
+    return unit.length <= hardLimit || written.some((line) => line.includes(` ${unit} `));
+  };
+  if (!units.every((unit) => staysInLimit(unit))) {
+    return keep({ tier: "manual", reason: "unbreakable text across lines" });
+  }
+  const bodyOf = (lines) => {
+    return lines.map((words, position) => {
+      const text = `${position === 0 ? paragraph.marker : hang}${words.join(" ")}`;
+      return { ...first, text, verbatim: false, hardBreak: HARD_BREAK.test(text) };
+    });
+  };
+  const settle = (settings) => {
+    let current = units;
+    let { even: even2, wrapped: wrapped2 } = layOut(current, settings);
+    for (; ; ) {
+      const body = bodyOf(wrapped2);
+      const rewrap = structureOf(body);
+      if (!rewrap) {
+        return { even: even2, wrapped: wrapped2 };
+      }
+      const tipping = body.findIndex((_, position) => structureOf(body.slice(0, position + 1)) !== void 0);
+      const start = wrapped2.slice(0, Math.max(tipping, 1)).flat().length;
+      const pair = `${current[start - 1]} ${current[start]}`;
+      if (body.length < 2 || !staysInLimit(pair)) {
+        const reading = rewrap.tier === "code-like" ? "code" : rewrap.reason;
+        return { tier: "manual", reason: `rewrap would read as ${reading}` };
+      }
+      current = current.toSpliced(start - 1, 2, pair);
+      ({ even: even2, wrapped: wrapped2 } = layOut(current, settings));
+    }
+  };
+  const settled = settle(layoutOptions);
+  const layout = "wrapped" in settled ? settled : settle({ ...layoutOptions, keepSteps: true });
+  if (!("wrapped" in layout)) {
+    return keep(layout);
+  }
+  const { even, wrapped } = layout;
+  const matchesLayout = sameLayout(wrapped, currentLines);
+  const lineIssues = [];
+  const overflow = options.maxWidth === void 0 ? [] : overflowIssues(paragraph.lines, options);
+  if (!matchesLayout) {
+    const hasExtraLines = currentLines.length > wrapped.length;
+    if (options.maxWidth === void 0) {
+      overflow.push(...overflowIssues(paragraph.lines, options));
+    }
+    lineIssues.push(
+      ...findLineIssues(currentLines, firstLimit, restLimit, layoutOptions).filter(
+        (issue) => issue.type !== "overflow" && (issue.type !== "underfill" || hasExtraLines)
+      )
+    );
+    if (hasWidow(currentLines) && !hasWidow(wrapped)) {
+      lineIssues.push({ type: "widow", line: currentLines.length - 1 });
+    }
+    if (lineIssues.length === 0 && overflow.length === 0 && (currentLines.length === wrapped.length || options.maxWidth !== void 0)) {
+      const line = wrapped.findIndex((words, position) => words.join(" ") !== currentLines[position]?.join(" "));
+      lineIssues.push({ type: sameLayout(even, currentLines) ? "orphan" : "unbalanced", line: Math.max(line, 0) });
+    }
+  }
+  const suggestion = wrapped.map(
+    (words, position) => `${prefix}${position === 0 ? paragraph.marker : hang}${words.join(" ")}`
+  );
+  const wrapIssues = lineIssues.map((issue) => lineIssue(issue.type, paragraph.lines[issue.line], options));
+  const issues = byLine([...overflow, ...wrapIssues, ...styleIssues(paragraph, options)]);
+  return { ...base, reflowable: true, issues, suggestion };
+}
+function computeLineStarts(source) {
+  const starts = [0];
+  for (let index = 0; index < source.length; index += 1) {
+    if (source.codePointAt(index) === 10) {
+      starts.push(index + 1);
+    }
+  }
+  return starts;
+}
+function lineOf(lineStarts, offset) {
+  let low = 0;
+  let high = lineStarts.length - 1;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (lineStarts[middle] <= offset) {
+      low = middle;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return low;
+}
+function stripCarriageReturn(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function shapeBlock(comment, sourceLines, lineStarts) {
+  const startLine = lineOf(lineStarts, comment.start);
+  const endLine = lineOf(lineStarts, comment.end - 1);
+  const kind = comment.value.startsWith("*") ? "jsdoc" : "block";
+  const lines = sourceLines.slice(startLine, endLine + 1);
+  const wholeComment = (paragraphKind, reason) => {
+    const otherLines = lines.map((text, offset) => {
+      return { index: startLine + offset, prefix: "", text, verbatim: false, hardBreak: false };
+    });
+    return { kind, startLine, endLine, paragraphs: [{ kind: paragraphKind, marker: "", reason, lines: otherLines }] };
+  };
+  const value = comment.value.replace(/^\*/, "");
+  if (LEGAL_COMMENT.test(replaceKeepingLines(comment.value, CODE_SPAN, "``"))) {
+    return wholeComment("code", "legal comment");
+  }
+  if (LINE_DIRECTIVE.test(value) || BLOCK_DIRECTIVE.test(value)) {
+    return wholeComment("code", "directive");
+  }
+  const other = () => {
+    return wholeComment(
+      "other",
+      startLine === endLine ? "single-line block comment" : "unsupported block comment layout"
+    );
+  };
+  if (startLine === endLine || !/^\s*\/\*\*?$/.test(lines[0]) || !/^\s*\*\/$/.test(lines.at(-1) ?? "")) {
+    return other();
+  }
+  const body = [];
+  const inner = lines.slice(1, -1);
+  for (const [offset, line] of inner.entries()) {
+    const match = /^(\s*\*)( ?)(.*)$/.exec(line);
+    if (!match) {
+      return other();
+    }
+    const [, star, space, text] = match;
+    body.push({
+      index: startLine + 1 + offset,
+      prefix: `${star} `,
+      text: text.trimEnd(),
+      verbatim: !space && text.length > 0 || LINE_DIRECTIVE.test(text),
+      hardBreak: HARD_BREAK.test(text)
+    });
+  }
+  return { kind, startLine, endLine, paragraphs: segment(body) };
+}
+function ownsLines(comment, source, lineStarts) {
+  const startLine = lineOf(lineStarts, comment.start);
+  const before = source.slice(lineStarts[startLine], comment.start);
+  const endLine = lineOf(lineStarts, comment.end - 1);
+  const lineEnd = lineStarts[endLine + 1] ?? source.length;
+  const after = source.slice(comment.end, lineEnd);
+  return /^[\t ]*$/.test(before) && /^[\t ]*\r?\n?$/.test(after);
+}
+function singleLineLength(paragraph, options) {
+  const [first] = paragraph.lines;
+  if (paragraph.kind === "other" && paragraph.reason === "single-line block comment") {
+    return sourceLineLength(first, options.tabWidth);
+  }
+  if (paragraph.kind !== "prose" || structureOf(paragraph.lines)) {
+    return Infinity;
+  }
+  const text = tokenize(paragraph.lines.map((line) => line.text).join(" ")).join(" ");
+  return visualLength(first.prefix, options.tabWidth) + text.length;
+}
+var BYTE_ORDER_MARK = "\uFEFF";
+function parseSource(filename, source) {
+  return parseSync(filename, source, filename.endsWith(".js") ? { lang: "jsx" } : void 0);
+}
+function describeFailure(errors, lineStarts) {
+  const [first] = errors;
+  const offset = first.labels.at(0)?.start;
+  return { message: first.message, line: offset === void 0 ? void 0 : lineOf(lineStarts, offset) + 1 };
+}
+function inspectSource(source, filename, options) {
+  if (options.maxWidth !== void 0 && (!Number.isInteger(options.maxWidth) || options.maxWidth < options.width)) {
+    throw new Error("comments: maxWidth must be an integer at least as large as width");
+  }
+  const text = source.startsWith(BYTE_ORDER_MARK) ? source.slice(1) : source;
+  const { program, comments, errors } = parseSource(filename, text);
+  const lineStarts = computeLineStarts(text);
+  if (errors.length > 0 && program.body.length === 0) {
+    return { comments: [], syntaxError: describeFailure(errors, lineStarts) };
+  }
+  const sourceLines = text.split("\n").map((line) => stripCarriageReturn(line));
+  const parsed = comments.filter((comment) => !(comment.start === 0 && text.startsWith("#!")));
+  const reports = [];
+  const blocks = parsed.filter((comment) => {
+    return comment.type === "Block" && ownsLines(comment, text, lineStarts) && !comment.value.includes(IGNORE_DIRECTIVE);
+  });
+  for (const block of blocks) {
+    const shape = shapeBlock(block, sourceLines, lineStarts);
+    const singleLineWidth = Math.max(
+      options.width,
+      Math.min(options.singleLineWidth ?? options.width, options.maxWidth ?? Infinity)
+    );
+    const paragraphOptions = shape.paragraphs.length === 1 && singleLineLength(shape.paragraphs[0], options) <= singleLineWidth ? { ...options, width: singleLineWidth } : options;
+    const lines = sourceLines.slice(shape.startLine, shape.endLine + 1);
+    reports.push({
+      file: filename,
+      kind: shape.kind,
+      startLine: shape.startLine + 1,
+      endLine: shape.endLine + 1,
+      indent: /^[\t ]*/.exec(lines[0])?.[0] ?? "",
+      width: options.width,
+      maxWidth: options.maxWidth,
+      lengths: lines.map((line) => visualLength(line.trimEnd(), options.tabWidth)),
+      text: lines.join("\n"),
+      paragraphs: shape.paragraphs.map((paragraph) => analyzeParagraph(paragraph, paragraphOptions))
+    });
+  }
+  return { comments: reports };
+}
+function isSuspicious(report) {
+  return report.paragraphs.some((paragraph) => paragraph.issues.length > 0);
+}
+function hasVerdictIssues(report) {
+  return report.paragraphs.some((paragraph) => paragraph.issues.some((issue) => issue.tier === "verdict"));
+}
+function rewrapComment(report) {
+  const lines = report.text.split("\n");
+  const paragraphs = report.paragraphs.filter((paragraph) => paragraph.suggestion !== null).toSorted((a, b) => b.startLine - a.startLine);
+  for (const paragraph of paragraphs) {
+    const start = paragraph.startLine - report.startLine;
+    lines.splice(start, paragraph.endLine - paragraph.startLine + 1, ...paragraph.suggestion ?? []);
+  }
+  return lines.join("\n");
+}
+var POSITION_KEYS = /* @__PURE__ */ new Set(["start", "end", "range", "loc"]);
+function codeFingerprint(source, filename) {
+  const { program, errors } = parseSource(filename, source);
+  if (errors.length > 0) {
+    return JSON.stringify({ source, errors: errors.map((error) => error.message) });
+  }
+  return JSON.stringify(
+    program,
+    (key, value) => POSITION_KEYS.has(key) || typeof value === "bigint" ? void 0 : value
+  );
+}
+
+// src/comments/config.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { createRequire } from "module";
+import path2 from "path";
+import { pathToFileURL } from "url";
+var DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"]);
+var CONFIG_FILES = [
+  "comments.config.ts",
+  "comments.config.mts",
+  "comments.config.js",
+  "comments.config.mjs",
+  "comments.config.cjs",
+  ".commentsrc",
+  ".commentsrc.json"
+];
+var PACKAGE_JSON_KEY = "comments";
+function readJson(filepath) {
+  try {
+    return JSON.parse(readFileSync2(filepath, "utf8"));
+  } catch (error) {
+    throw new Error(`comments: failed to parse ${filepath}: ${error.message}`, { cause: error });
+  }
+}
+async function readConfigFile(filepath) {
+  if (filepath.endsWith("rc") || filepath.endsWith(".json")) {
+    return readJson(filepath);
+  }
+  const module = await import(pathToFileURL(filepath).href);
+  return module.default ?? module;
+}
+function assertType(value, type, key, filepath) {
+  const actual = Array.isArray(value) ? "array" : typeof value;
+  if (value !== void 0 && actual !== type) {
+    throw new Error(`comments: \`${key}\` in ${filepath} must be a ${type}, got ${actual}`);
+  }
+}
+function assertStrings(value, key, filepath) {
+  if (Array.isArray(value) && !value.every((item) => typeof item === "string")) {
+    throw new Error(`comments: \`${key}\` in ${filepath} must only hold strings`);
+  }
+}
+function validateConfig(raw, filepath) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`comments: ${filepath} must export an object`);
+  }
+  const config = raw;
+  assertType(config.width, "number", "width", filepath);
+  assertType(config.maxWidth, "number", "maxWidth", filepath);
+  assertType(config.singleLineWidth, "number", "singleLineWidth", filepath);
+  assertType(config.tolerance, "number", "tolerance", filepath);
+  assertType(config.avoidSentenceOrphans, "boolean", "avoidSentenceOrphans", filepath);
+  assertType(config.style, "boolean", "style", filepath);
+  assertType(config.extensions, "array", "extensions", filepath);
+  assertType(config.ignore, "array", "ignore", filepath);
+  assertType(config.agent, "object", "agent", filepath);
+  assertType(config.hook, "object", "hook", filepath);
+  assertStrings(config.extensions, "extensions", filepath);
+  assertStrings(config.ignore, "ignore", filepath);
+  for (const key of ["width", "maxWidth", "singleLineWidth", "tolerance"]) {
+    const value = config[key];
+    const minimum = key === "tolerance" ? 0 : 1;
+    if (value !== void 0 && (!Number.isInteger(value) || value < minimum)) {
+      throw new Error(`comments: \`${key}\` in ${filepath} must be an integer of at least ${minimum}`);
+    }
+  }
+  if (typeof config.width === "number" && typeof config.maxWidth === "number" && config.maxWidth < config.width) {
+    throw new Error(`comments: \`maxWidth\` in ${filepath} must be at least \`width\``);
+  }
+  const agent = config.agent ?? {};
+  if (agent.runner !== void 0 && !["claude", "codex", "cursor"].includes(agent.runner)) {
+    throw new Error(`comments: \`agent.runner\` in ${filepath} must be one of claude, codex, cursor`);
+  }
+  assertType(agent.model, "string", "agent.model", filepath);
+  assertType(agent.args, "array", "agent.args", filepath);
+  assertType(agent.command, "array", "agent.command", filepath);
+  assertType(agent.timeout, "number", "agent.timeout", filepath);
+  assertStrings(agent.args, "agent.args", filepath);
+  assertStrings(agent.command, "agent.command", filepath);
+  if (agent.timeout !== void 0 && !(agent.timeout > 0)) {
+    throw new Error(`comments: \`agent.timeout\` in ${filepath} must be a positive number`);
+  }
+  for (const key of ["batchSize", "maxFiles", "maxAgents"]) {
+    const value = agent[key];
+    if (value !== void 0 && (!Number.isInteger(value) || value < 1)) {
+      throw new Error(`comments: \`agent.${key}\` in ${filepath} must be a positive integer`);
+    }
+  }
+  assertType(agent.rules, "string", "agent.rules", filepath);
+  assertType(agent.instructions, "string", "agent.instructions", filepath);
+  if (agent.scope !== void 0 && agent.scope !== "suspicious" && agent.scope !== "all") {
+    throw new Error(`comments: \`agent.scope\` in ${filepath} must be "suspicious" or "all"`);
+  }
+  const hook = config.hook ?? {};
+  if (hook.mode !== void 0 && !["agent", "report", "off"].includes(hook.mode)) {
+    throw new Error(`comments: \`hook.mode\` in ${filepath} must be one of agent, report, off`);
+  }
+  return config;
+}
+async function loadConfig(cwd, options = {}) {
+  if (options.explicitPath) {
+    const filepath = path2.resolve(cwd, options.explicitPath);
+    return { config: validateConfig(await readConfigFile(filepath), filepath), filepath };
+  }
+  let directory = path2.resolve(cwd);
+  for (; ; ) {
+    for (const name of CONFIG_FILES) {
+      const filepath = path2.join(directory, name);
+      if (existsSync(filepath)) {
+        return { config: validateConfig(await readConfigFile(filepath), filepath), filepath };
+      }
+    }
+    const packageJsonPath = path2.join(directory, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const value = readJson(packageJsonPath)[PACKAGE_JSON_KEY];
+      if (value !== void 0) {
+        return { config: validateConfig(value, packageJsonPath), filepath: packageJsonPath };
+      }
+    }
+    const parent = path2.dirname(directory);
+    if (directory === options.stopDir || parent === directory) {
+      return { config: {} };
+    }
+    directory = parent;
+  }
+}
+var PRETTIER_FILES = [".prettierrc", ".prettierrc.json", ".prettierrc.json5"];
+function readPrettierFile(directory, stopDir) {
+  let current = directory;
+  for (; ; ) {
+    for (const name of PRETTIER_FILES) {
+      const filepath = path2.join(current, name);
+      if (!existsSync(filepath)) {
+        continue;
+      }
+      const text = readFileSync2(filepath, "utf8");
+      const printWidth = /["']?printWidth["']?\s*:\s*(\d+)/.exec(text)?.[1];
+      const tabWidth = /["']?tabWidth["']?\s*:\s*(\d+)/.exec(text)?.[1];
+      return {
+        printWidth: printWidth === void 0 ? void 0 : Number(printWidth),
+        tabWidth: tabWidth === void 0 ? void 0 : Number(tabWidth)
+      };
+    }
+    const packageJsonPath = path2.join(current, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const prettier = readJson(packageJsonPath).prettier;
+      if (prettier && typeof prettier === "object") {
+        return prettier;
+      }
+    }
+    const parent = path2.dirname(current);
+    if (current === stopDir || parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+var PrettierOptionsResolver = class {
+  constructor(_root) {
+    this._root = _root;
+  }
+  _root;
+  _prettier;
+  _cache = /* @__PURE__ */ new Map();
+  async _loadPrettier() {
+    if (this._prettier !== void 0) {
+      return this._prettier;
+    }
+    try {
+      const require2 = createRequire(path2.join(this._root, "package.json"));
+      const resolved = require2.resolve("prettier");
+      this._prettier = await import(pathToFileURL(resolved).href);
+    } catch {
+      this._prettier = null;
+    }
+    return this._prettier;
+  }
+  async resolve(file) {
+    const prettier = await this._loadPrettier();
+    if (prettier) {
+      try {
+        const options2 = await prettier.resolveConfig(file);
+        if (options2) {
+          return options2;
+        }
+      } catch {
+      }
+    }
+    const directory = path2.dirname(file);
+    const cached = this._cache.get(directory);
+    if (cached) {
+      return cached;
+    }
+    const options = readPrettierFile(directory, this._root) ?? {};
+    this._cache.set(directory, options);
+    return options;
+  }
+};
+
+// src/comments/flow.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+var DEFAULT_BATCH_SIZE = 20;
+var DEFAULT_MAX_FILES = 10;
+var DEFAULT_MAX_AGENTS = 6;
+var PROGRESS_INTERVAL_MS = 3e4;
+var LISTED_FILES = 3;
+function withVerdictIssues(analyses) {
+  return analyses.flatMap((analysis) => analysis.comments).filter((comment) => hasVerdictIssues(comment));
+}
+function skippedFiles(analyses) {
+  return analyses.flatMap(({ file, syntaxError }) => syntaxError ? [{ file, syntaxError }] : []);
+}
+function describeSkipped({ file, syntaxError }) {
+  const line = syntaxError.line === void 0 ? "" : ` on line ${syntaxError.line}`;
+  return `skipped ${file} because of a syntax error${line} (${syntaxError.message})`;
+}
+function describeChangedElsewhere(files) {
+  return `${files.length} file(s) that no agent was given changed during the run: ${listFiles(files)}`;
+}
+function changedBetween(before, after) {
+  const files = /* @__PURE__ */ new Set([...before.keys(), ...after.keys()]);
+  return [...files].filter((file) => before.get(file) !== after.get(file)).toSorted();
+}
+function needsAgent(comment) {
+  return comment.paragraphs.some(
+    (paragraph) => paragraph.issues.some((issue) => issue.tier === "hint" || paragraph.suggestion === null)
+  );
+}
+function seconds(milliseconds) {
+  return `${Math.round(milliseconds / 1e3)}s`;
+}
+function listFiles(files) {
+  const more = files.length > LISTED_FILES ? `, and ${files.length - LISTED_FILES} more` : "";
+  return `${files.slice(0, LISTED_FILES).join(", ")}${more}`;
+}
+var SILENT_REPORTER = {
+  start: () => {
+  },
+  agentStarted: () => {
+  },
+  agentFinished: () => {
+  },
+  stop: () => {
+  }
+};
+function createLogReporter(log3, options = {}) {
+  let plan;
+  let heartbeat;
+  let started = 0;
+  let running = 0;
+  let finished = 0;
+  return {
+    start(next) {
+      plan = next;
+      started = Date.now();
+      const count = next.agents.length;
+      const agents = `${count} agent${count > 1 ? "s" : ""} (${next.agent})`;
+      const queueing = count > next.maxAgents ? `, ${next.maxAgents} at a time,` : "";
+      log3(`spawning ${agents}${queueing} for ${next.comments} comment(s) in ${next.files} file(s)`);
+      log3(`  command: ${next.command}`);
+      if (count > 1) {
+        for (const agent of next.agents) {
+          log3(`  ${agent.name}: ${agent.comments} comment(s) in ${listFiles(agent.files)}`);
+        }
+      }
+      heartbeat = setInterval(() => {
+        const queued = count - finished - running;
+        const waiting = count > 1 ? `${count - finished} of ${count} agents` : "the agent";
+        log3(`still waiting for ${waiting}${queued > 0 ? `, ${queued} queued` : ""} (${seconds(Date.now() - started)})`);
+      }, PROGRESS_INTERVAL_MS);
+    },
+    agentStarted(index) {
+      running += 1;
+      if (plan && index >= plan.maxAgents) {
+        log3(`${plan.agents[index].name} started`);
+      }
+    },
+    agentFinished(_index, report) {
+      running -= 1;
+      finished += 1;
+      const count = plan?.agents.length ?? 1;
+      const took = seconds(report.durationMs);
+      const status = report.ok ? `finished in ${took}` : `failed after ${took}`;
+      const progress = count > 1 ? ` (${finished} of ${count} done)` : "";
+      log3(`${report.name} ${status}${progress}${report.ok ? "" : `: ${report.error}`}`);
+      if (report.output && (options.verbose || !report.ok)) {
+        log3(report.output);
+      }
+    },
+    stop() {
+      clearInterval(heartbeat);
+    }
+  };
+}
+function batchFiles(files, batchSize, maxFiles = Infinity) {
+  const total = files.reduce((sum, file) => sum + file.comments.length, 0);
+  const order = files.map((_, index) => index).toSorted((a, b) => files[b].comments.length - files[a].comments.length);
+  const minimum = Math.max(Math.ceil(total / batchSize), Math.ceil(files.length / maxFiles));
+  for (let count = Math.min(files.length, minimum); ; count += 1) {
+    const sizes = Array.from({ length: count }).fill(0);
+    const indices = Array.from({ length: count }, () => []);
+    for (const index of order) {
+      const open = sizes.map((size, batch) => indices[batch].length < maxFiles ? size : Infinity);
+      const smallest = open.indexOf(Math.min(...open));
+      indices[smallest].push(index);
+      sizes[smallest] += files[index].comments.length;
+    }
+    const fits = indices.every((batch, index) => batch.length === 1 || sizes[index] <= batchSize);
+    if (fits || count >= files.length) {
+      return indices.map((batch) => batch.toSorted((a, b) => a - b).map((index) => files[index]));
+    }
+  }
+}
+async function runPool(items, limit, worker) {
+  const results = Array.from({ length: items.length });
+  let next = 0;
+  const lane = async () => {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      results[index] = await worker(items[index], index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => lane()));
+  return results;
+}
+function applyRewraps(analyses, skip) {
+  let count = 0;
+  for (const analysis of analyses) {
+    const comments = analysis.comments.filter((comment) => hasVerdictIssues(comment));
+    if (comments.length === 0 || skip.has(analysis.file)) {
+      continue;
+    }
+    const lines = analysis.source.split("\n");
+    let rewrapped = 0;
+    for (const comment of comments.toReversed()) {
+      const text = rewrapComment(comment);
+      if (text === comment.text) {
+        continue;
+      }
+      const first = lines[comment.startLine - 1];
+      const mark = first.startsWith(BYTE_ORDER_MARK) ? BYTE_ORDER_MARK : "";
+      const ending = first.endsWith("\r") ? "\r" : "";
+      const replacement = text.split("\n").map((line, index) => `${index === 0 ? mark : ""}${line}${ending}`);
+      lines.splice(comment.startLine - 1, comment.endLine - comment.startLine + 1, ...replacement);
+      rewrapped += 1;
+    }
+    const output = lines.join("\n");
+    if (rewrapped === 0 || codeFingerprint(output, analysis.file) !== codeFingerprint(analysis.source, analysis.file)) {
+      continue;
+    }
+    writeFileSync(analysis.absolute, output);
+    count += rewrapped;
+  }
+  return count;
+}
+async function runFlow(project, scope, options) {
+  const reporter = options.reporter ?? SILENT_REPORTER;
+  const analyses = await project.analyze(scope);
+  const measure = async () => {
+    const current = await project.analyze(scope);
+    return { remaining: withVerdictIssues(current), skipped: skippedFiles(current) };
+  };
+  if (options.mode === "report") {
+    return {
+      sentToAgent: 0,
+      codeChanged: [],
+      changedElsewhere: [],
+      remaining: withVerdictIssues(analyses),
+      skipped: skippedFiles(analyses)
+    };
+  }
+  const pending = analyses.map((analysis) => {
+    const selected = options.select === "all" ? analysis.comments : analysis.comments.filter((comment) => needsAgent(comment));
+    return { ...analysis, comments: selected };
+  }).filter((analysis) => analysis.comments.length > 0);
+  const comments = pending.flatMap((analysis) => analysis.comments);
+  if (comments.length === 0) {
+    const rewrapped2 = applyRewraps(analyses, /* @__PURE__ */ new Set());
+    return { sentToAgent: 0, codeChanged: [], changedElsewhere: [], rewrapped: rewrapped2, ...await measure() };
+  }
+  const agentConfig = project.config.agent ?? {};
+  const rules = loadRules(agentConfig, options.configPath);
+  const batches = batchFiles(
+    pending,
+    agentConfig.batchSize ?? DEFAULT_BATCH_SIZE,
+    agentConfig.maxFiles ?? DEFAULT_MAX_FILES
+  );
+  const maxAgents = agentConfig.maxAgents ?? DEFAULT_MAX_AGENTS;
+  const runs = batches.map((batch, index) => {
+    const batchComments = batch.flatMap((analysis) => analysis.comments);
+    const prompt = buildPrompt({ rules, root: project.root, comments: batchComments });
+    const invocation = buildInvocation({ agent: agentConfig, runner: options.runner, prompt, root: project.root });
+    return {
+      name: batches.length > 1 ? `agent ${index + 1}` : "the agent",
+      files: batch.map((analysis) => analysis.file),
+      comments: batchComments.length,
+      invocation
+    };
+  });
+  reporter.start({
+    agent: describeAgent(agentConfig, options.runner),
+    command: formatInvocation(runs[0].invocation),
+    comments: comments.length,
+    files: pending.length,
+    maxAgents,
+    agents: runs.map(({ name, files, comments: comments2 }) => {
+      return { name, files, comments: comments2 };
+    })
+  });
+  const before = project.snapshot();
+  let reports;
+  try {
+    reports = await runPool(runs, maxAgents, async (run, index) => {
+      const start = Date.now();
+      reporter.agentStarted(index);
+      const result = await runAgent(run.invocation, { root: project.root, timeout: agentConfig.timeout });
+      const report = {
+        name: run.name,
+        files: run.files,
+        comments: run.comments,
+        ok: result.ok,
+        error: result.error,
+        output: result.output,
+        durationMs: Date.now() - start
+      };
+      reporter.agentFinished(index, report);
+      return report;
+    });
+  } finally {
+    reporter.stop();
+  }
+  const agentErrors = reports.flatMap((report, index) => {
+    if (report.ok) {
+      return [];
+    }
+    return [reports.length > 1 ? `agent ${index + 1} of ${reports.length}: ${report.error}` : report.error ?? ""];
+  });
+  const after = project.snapshot();
+  const handedOver = new Set(pending.map((analysis) => analysis.file));
+  const changedElsewhere = before && after ? changedBetween(before, after).filter((file) => !handedOver.has(file)) : [];
+  const codeChanged = pending.filter((analysis) => {
+    if (!existsSync2(analysis.absolute)) {
+      return true;
+    }
+    const current = readFileSync3(analysis.absolute, "utf8");
+    return codeFingerprint(current, analysis.file) !== codeFingerprint(analysis.source, analysis.file);
+  }).map((analysis) => analysis.file);
+  const rewrapped = applyRewraps(await project.analyze(scope), new Set(codeChanged));
+  return {
+    sentToAgent: comments.length,
+    agents: runs.length,
+    runs: reports,
+    codeChanged,
+    changedElsewhere,
+    rewrapped,
+    ...await measure(),
+    agentError: agentErrors.length > 0 ? agentErrors.join(", ") : void 0
+  };
+}
+var LISTED_COMMENTS = 5;
+function describeRemaining(remaining) {
+  const listed = remaining.slice(0, LISTED_COMMENTS).map((comment) => {
+    const issues = comment.paragraphs.flatMap((paragraph) => paragraph.issues);
+    const types = new Set(issues.filter((issue) => issue.tier === "verdict").map((issue) => issue.type));
+    return `${comment.file}:${comment.startLine} (${[...types].join(", ")})`;
+  });
+  const more = remaining.length > LISTED_COMMENTS ? `, and ${remaining.length - LISTED_COMMENTS} more` : "";
+  return `${remaining.length} comment(s) still have issues: ${listed.join(", ")}${more}`;
+}
+function describeSummary(summary) {
+  const parts = [];
+  if (summary.sentToAgent > 0) {
+    const agents = (summary.agents ?? 1) > 1 ? `${summary.agents} agents` : "the agent";
+    parts.push(`sent ${summary.sentToAgent} comment(s) to ${agents}`);
+  }
+  if (summary.rewrapped) {
+    parts.push(`rewrapped ${summary.rewrapped} comment(s)`);
+  }
+  if (summary.agentError) {
+    parts.push(`agent failed: ${summary.agentError}`);
+  }
+  if (summary.codeChanged.length > 0) {
+    parts.push(`the agent changed code, not just comments, in ${summary.codeChanged.join(", ")}`);
+  }
+  if (summary.changedElsewhere.length > 0) {
+    parts.push(describeChangedElsewhere(summary.changedElsewhere));
+  }
+  if (summary.remaining.length > 0) {
+    parts.push(describeRemaining(summary.remaining));
+  }
+  parts.push(...summary.skipped.map((skipped) => describeSkipped(skipped)));
+  return parts.length > 0 ? `comments: ${parts.join("; ")}` : void 0;
+}
+
+// src/comments/git.ts
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
+import { readFileSync as readFileSync4, statSync } from "fs";
+import path3 from "path";
+function git(cwd, args) {
+  const result = spawnSync("git", ["-c", "core.quotePath=false", ...args], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 256 * 1024 * 1024
+  });
+  const stdout = result.stdout ?? "";
+  const stderr = result.stderr ?? "";
+  return { ok: result.status === 0, stdout, stderr };
+}
+function gitOrThrow(cwd, args) {
+  const result = git(cwd, args);
+  if (!result.ok) {
+    throw new Error(`comments: \`git ${args.join(" ")}\` failed: ${result.stderr.trim()}`);
+  }
+  return result.stdout;
+}
+function splitPaths(output) {
+  return output.split("\0").filter(Boolean);
+}
+function unquotePath(value) {
+  if (!value.startsWith('"')) {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function findRepoRoot(cwd) {
+  const result = git(cwd, ["rev-parse", "--show-toplevel"]);
+  return result.ok ? result.stdout.trim() : void 0;
+}
+function parseUnifiedDiff(diff) {
+  const changed = /* @__PURE__ */ new Map();
+  let lines;
+  let oldPending = 0;
+  let newPending = 0;
+  for (const line of diff.split("\n")) {
+    if (oldPending > 0 || newPending > 0) {
+      if (line.startsWith("+")) {
+        newPending -= 1;
+      } else if (line.startsWith("-")) {
+        oldPending -= 1;
+      } else if (line.startsWith(" ")) {
+        oldPending -= 1;
+        newPending -= 1;
+      }
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      const target = unquotePath(line.slice(4).replace(/\t$/, ""));
+      if (target === "/dev/null") {
+        lines = void 0;
+        continue;
+      }
+      const file = target.startsWith("b/") ? target.slice(2) : target;
+      lines = /* @__PURE__ */ new Set();
+      changed.set(file, lines);
+      continue;
+    }
+    const hunk = /^@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (!hunk) {
+      continue;
+    }
+    const start = Number(hunk[2]);
+    const count = hunk[3] ? Number(hunk[3]) : 1;
+    oldPending = hunk[1] ? Number(hunk[1]) : 1;
+    newPending = count;
+    if (!lines) {
+      continue;
+    }
+    if (count === 0) {
+      lines.add(start);
+      lines.add(start + 1);
+      continue;
+    }
+    for (let offset = 0; offset < count; offset += 1) {
+      lines.add(start + offset);
+    }
+  }
+  return changed;
+}
+function hasHead(root) {
+  return git(root, ["rev-parse", "--verify", "--quiet", "HEAD"]).ok;
+}
+function listUntrackedFiles(root) {
+  return splitPaths(gitOrThrow(root, ["ls-files", "-z", "--others", "--exclude-standard"]));
+}
+function listFiles2(root, paths = []) {
+  return splitPaths(gitOrThrow(root, ["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...paths]));
+}
+var MAX_HASHED_BYTES = 1024 * 1024;
+function fileState(absolute) {
+  try {
+    const stats = statSync(absolute);
+    if (!stats.isFile()) {
+      return "no file";
+    }
+    return stats.size > MAX_HASHED_BYTES ? `${stats.size} bytes, changed at ${stats.mtimeMs}` : createHash("sha1").update(readFileSync4(absolute)).digest("hex");
+  } catch {
+    return "missing";
+  }
+}
+function snapshotChanges(root) {
+  try {
+    const tracked = hasHead(root) ? splitPaths(gitOrThrow(root, ["diff", "-z", "--name-only", "--no-renames", "HEAD"])) : splitPaths(gitOrThrow(root, ["ls-files", "-z", "--cached"]));
+    const files = /* @__PURE__ */ new Set([...tracked, ...listUntrackedFiles(root)]);
+    return new Map([...files].map((file) => [file, fileState(path3.join(root, file))]));
+  } catch {
+    return void 0;
+  }
+}
+var DIFF_FLAGS = ["diff", "-U0", "--no-color", "--no-ext-diff", "--no-renames", "--src-prefix=a/", "--dst-prefix=b/"];
+function getChangedLines(root, scope = {}) {
+  if (!hasHead(root)) {
+    const files = scope.staged ? splitPaths(gitOrThrow(root, ["diff", "-z", "--cached", "--name-only", "--diff-filter=d"])) : listFiles2(root);
+    return new Map(files.map((file) => [file, "all"]));
+  }
+  let args;
+  if (scope.staged) {
+    args = [...DIFF_FLAGS, "--cached", "HEAD"];
+  } else if (scope.base) {
+    const mergeBase = gitOrThrow(root, ["merge-base", scope.base, "HEAD"]).trim();
+    args = [...DIFF_FLAGS, mergeBase];
+  } else {
+    args = [...DIFF_FLAGS, "HEAD"];
+  }
+  const changed = parseUnifiedDiff(gitOrThrow(root, args));
+  if (!scope.staged) {
+    for (const file of listUntrackedFiles(root)) {
+      changed.set(file, "all");
+    }
+  }
+  return changed;
+}
+
+// src/comments/project.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import path4 from "path";
+var DEFAULT_WIDTH = 80;
+var DEFAULT_MAX_WIDTH = 120;
+var DEFAULT_SINGLE_LINE_WIDTH = 120;
+var DEFAULT_TAB_WIDTH = 2;
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage"]);
+function toPosix(file) {
+  return file.split(path4.sep).join("/");
+}
+function mergeFilter(existing, next) {
+  if (existing === "all" || next === "all") {
+    return "all";
+  }
+  return existing ? /* @__PURE__ */ new Set([...existing, ...next]) : next;
+}
+function walkDirectory(directory, files = []) {
+  const entries = readdirSync(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (!SKIPPED_DIRECTORIES.has(entry.name)) {
+        walkDirectory(path4.join(directory, entry.name), files);
+      }
+    } else if (entry.isFile()) {
+      files.push(path4.join(directory, entry.name));
+    }
+  }
+  return files;
+}
+function overlaps(comment, filter) {
+  if (filter === "all") {
+    return true;
+  }
+  for (let line = comment.startLine; line <= comment.endLine; line += 1) {
+    if (filter.has(line)) {
+      return true;
+    }
+  }
+  return false;
+}
+var Project = class {
+  constructor(root, config, _options) {
+    this.root = root;
+    this.config = config;
+    this._options = _options;
+    this._prettier = new PrettierOptionsResolver(root);
+    this._extensions = new Set(config.extensions ?? DEFAULT_EXTENSIONS);
+  }
+  root;
+  config;
+  _options;
+  _prettier;
+  _extensions;
+  relative(absolute) {
+    return toPosix(path4.relative(this.root, absolute));
+  }
+  _isIncluded(absolute) {
+    if (!this._extensions.has(path4.extname(absolute))) {
+      return false;
+    }
+    const relative = this.relative(absolute);
+    return !(this.config.ignore ?? []).some((pattern) => path4.matchesGlob(relative, pattern));
+  }
+  _filesIn(directory) {
+    if (!this._options.isGitRepo) {
+      return walkDirectory(directory);
+    }
+    return listFiles2(this.root, [path4.relative(this.root, directory) || "."]).map((file) => path4.join(this.root, file));
+  }
+  collect(scope) {
+    const files = /* @__PURE__ */ new Map();
+    const add = (absolute, filter) => {
+      if (this._isIncluded(absolute) && existsSync3(absolute)) {
+        files.set(absolute, mergeFilter(files.get(absolute), filter));
+      }
+    };
+    if (scope.targets && scope.targets.length > 0) {
+      for (const target of scope.targets) {
+        const range = /^(.+):(\d+)(?:-(\d+))?$/.exec(target);
+        const absolute = path4.resolve(this._options.cwd, range ? range[1] : target);
+        if (!existsSync3(absolute)) {
+          throw new Error(`comments: ${target} does not exist`);
+        }
+        if (statSync2(absolute).isDirectory()) {
+          for (const file of this._filesIn(absolute)) {
+            add(file, "all");
+          }
+          continue;
+        }
+        if (!range) {
+          add(absolute, "all");
+          continue;
+        }
+        const start = Number(range[2]);
+        const end = range[3] ? Number(range[3]) : start;
+        add(absolute, new Set(Array.from({ length: Math.max(0, end - start + 1) }, (_, offset) => start + offset)));
+      }
+      return files;
+    }
+    if (scope.repo) {
+      for (const file of this._filesIn(this.root)) {
+        add(file, "all");
+      }
+      return files;
+    }
+    if (!this._options.isGitRepo) {
+      throw new Error("comments: not a git repository, so pass files or directories explicitly");
+    }
+    for (const [file, lines] of getChangedLines(this.root, scope)) {
+      add(path4.join(this.root, file), lines);
+    }
+    return files;
+  }
+  async analyzeFile(absolute, filter = "all") {
+    const source = readFileSync5(absolute, "utf8");
+    const prettier = await this._prettier.resolve(absolute);
+    const file = this.relative(absolute);
+    const width = this._options.width ?? this.config.width ?? prettier.printWidth ?? DEFAULT_WIDTH;
+    const maxWidth = this.config.maxWidth ?? Math.max(width, this.config.tolerance === void 0 ? DEFAULT_MAX_WIDTH : width + this.config.tolerance);
+    const { comments, syntaxError } = inspectSource(source, file, {
+      width,
+      maxWidth,
+      singleLineWidth: this.config.singleLineWidth ?? DEFAULT_SINGLE_LINE_WIDTH,
+      tabWidth: prettier.tabWidth ?? DEFAULT_TAB_WIDTH,
+      tolerance: Math.min(this.config.tolerance ?? 0, maxWidth - width),
+      avoidSentenceOrphans: this.config.avoidSentenceOrphans ?? true,
+      style: this.config.style ?? true
+    });
+    return { file, absolute, source, comments: comments.filter((comment) => overlaps(comment, filter)), syntaxError };
+  }
+  /**
+   * Records the state of every file with uncommitted changes, to compare it with a later
+   * snapshot. Returns `undefined` outside of a git repository, where only reading every
+   * file would show which ones changed.
+   */
+  snapshot() {
+    return this._options.isGitRepo ? snapshotChanges(this.root) : void 0;
+  }
+  async analyze(scope) {
+    const results = [];
+    for (const [absolute, filter] of this.collect(scope)) {
+      results.push(await this.analyzeFile(absolute, filter));
+    }
+    return results.toSorted((a, b) => a.file.localeCompare(b.file));
+  }
+};
+
+// src/comments/terminal.ts
+import {
+  intro,
+  isCancel,
+  isCI,
+  log,
+  note,
+  S_BAR,
+  S_BAR_END,
+  S_RADIO_INACTIVE,
+  S_STEP_ERROR,
+  S_STEP_SUBMIT,
+  select,
+  spinner,
+  unicode,
+  unicodeOr
+} from "@clack/prompts";
+import { spawnSync as spawnSync2 } from "child_process";
+import { Writable } from "stream";
+import { styleText } from "util";
+var FRAMES = unicode ? ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] : ["|", "/", "-", "\\"];
+var FRAME_MS = 80;
+var S_DONE = unicodeOr("\u2714", "\u221A");
+var S_FAILED = unicodeOr("\u2716", "x");
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+var LISTED_REMAINING = 10;
+var CTRL_C = 3;
+var MIN_FILES_WIDTH = 12;
+var ICONS = {
+  queued: ["dim", S_RADIO_INACTIVE],
+  done: ["green", S_DONE],
+  failed: ["red", S_FAILED]
+};
+function isLiveTerminal(output = process.stderr) {
+  return output.isTTY && !isCI() && process.env.TERM !== "dumb";
+}
+function plural(count, noun) {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function formatDuration(milliseconds) {
+  const total = Math.round(milliseconds / 1e3);
+  const minutes = Math.floor(total / 60);
+  return minutes > 0 ? `${minutes}m ${String(total % 60).padStart(2, "0")}s` : `${total}s`;
+}
+function fitFiles(files, width) {
+  for (let shown = files.length; shown > 0; shown -= 1) {
+    const more = files.length - shown;
+    const text = `${files.slice(0, shown).join(", ")}${more > 0 ? `, +${more} more` : ""}`;
+    if (text.length <= width) {
+      return text;
+    }
+  }
+  return width > 1 ? `\u2026${files[0].slice(-(width - 1))}` : "";
+}
+function truncate(text, width) {
+  return text.length > width ? `${text.slice(0, Math.max(width - 1, 0))}\u2026` : text;
+}
+function agentLabel(index) {
+  return `agent ${index + 1}`;
+}
+function formatReply(text, paint) {
+  return text.replaceAll(/\*\*([^*\n]+)\*\*/g, (_, inner) => paint("bold", inner)).replaceAll(/`([^`\n]+)`/g, (_, inner) => paint("cyan", inner));
+}
+var AgentTable = class {
+  constructor(_output, _paint) {
+    this._output = _output;
+    this._paint = _paint;
+  }
+  _output;
+  _paint;
+  _rows = [];
+  _title = "";
+  _drawn = 0;
+  _frame = 0;
+  _startedAt = 0;
+  _timer;
+  _restoreCursor = () => {
+    this._output.write(SHOW_CURSOR);
+  };
+  _interrupt = () => {
+    this._restoreCursor();
+    process.off("exit", this._restoreCursor);
+    process.kill(process.pid, "SIGINT");
+  };
+  start(plan, title) {
+    this._rows = plan.agents.map((agent) => {
+      return { plan: agent, state: "queued" };
+    });
+    this._title = title;
+    this._startedAt = Date.now();
+    process.once("SIGINT", this._interrupt);
+    process.once("exit", this._restoreCursor);
+    this._output.write(`${this._paint("gray", S_BAR)}
+${HIDE_CURSOR}`);
+    this._draw(false);
+    this._timer = setInterval(() => {
+      this._frame = (this._frame + 1) % FRAMES.length;
+      this._draw(false);
+    }, FRAME_MS);
+  }
+  started(index) {
+    this._rows[index].state = "running";
+    this._rows[index].startedAt = Date.now();
+  }
+  finished(index, report) {
+    this._rows[index].state = report.ok ? "done" : "failed";
+    this._rows[index].durationMs = report.durationMs;
+  }
+  stop() {
+    if (this._timer === void 0) {
+      return;
+    }
+    clearInterval(this._timer);
+    this._timer = void 0;
+    this._draw(true);
+    this._restoreCursor();
+    process.off("SIGINT", this._interrupt);
+    process.off("exit", this._restoreCursor);
+  }
+  _draw(final) {
+    const lines = this._render(final);
+    const clear = this._drawn > 0 ? `\x1B[${this._drawn}F\x1B[J` : "";
+    this._output.write(`${clear}${lines.join("\n")}
+`);
+    this._drawn = lines.length;
+  }
+  _count(state) {
+    return this._rows.filter((row) => row.state === state).length;
+  }
+  _render(final) {
+    const columns = Math.max((this._output.columns || 80) - 1, 20);
+    const elapsed = formatDuration(Date.now() - this._startedAt);
+    const failed = this._count("failed");
+    const finished = this._count("done") + failed;
+    let header;
+    if (final) {
+      const outcome = `${plural(this._rows.length, "agent")} finished in ${elapsed}${failed > 0 ? `, ${failed} failed` : ""}`;
+      const symbol = failed > 0 ? this._paint("yellow", S_STEP_ERROR) : this._paint("green", S_STEP_SUBMIT);
+      header = `${symbol}  ${truncate(outcome, columns - 3)}`;
+    } else {
+      const progress = `${finished} of ${this._rows.length} done, ${elapsed}`;
+      const text = truncate(`${this._title}  ${progress}`, columns - 3);
+      header = `${this._paint("magenta", FRAMES[this._frame])}  ${text.replace(progress, this._paint("dim", progress))}`;
+    }
+    return [header, ...this._renderRows(columns, final)];
+  }
+  _renderRows(columns, final) {
+    const bar = this._paint("gray", S_BAR);
+    const nameWidth = agentLabel(this._rows.length - 1).length;
+    const commentsWidth = Math.max(...this._rows.map((row) => plural(row.plan.comments, "comment").length));
+    const statusWidth = Math.max(...this._rows.map((row) => this._status(row).length));
+    const filesWidth = columns - (3 + 2 + nameWidth + 2 + commentsWidth + 2 + statusWidth + 2);
+    const height = (this._output.rows || 24) - 3;
+    const compact = !final && this._rows.length + 1 > height;
+    const visible = this._rows.map((row, index) => {
+      return { row, index };
+    }).filter(({ row }) => !compact || row.state === "running" || row.state === "failed").slice(0, Math.max(height - 1, 1));
+    const lines = visible.map(({ row, index }) => {
+      const status = this._status(row).padEnd(statusWidth);
+      const files = filesWidth >= MIN_FILES_WIDTH ? `  ${this._paint("dim", fitFiles(row.plan.files, filesWidth))}` : "";
+      return [
+        `${bar}  ${this._icon(row)} ${agentLabel(index).padEnd(nameWidth)}`,
+        this._paint("dim", plural(row.plan.comments, "comment").padEnd(commentsWidth)),
+        this._paint(this._statusStyle(row), status)
+      ].join("  ") + files;
+    });
+    if (compact) {
+      const done = this._count("done");
+      const queued = this._count("queued");
+      lines.push(`${bar}  ${this._paint("dim", `${S_DONE} ${done} done, ${S_RADIO_INACTIVE} ${queued} queued`)}`);
+    }
+    return lines;
+  }
+  _icon(row) {
+    if (row.state === "running") {
+      return this._paint("magenta", FRAMES[this._frame]);
+    }
+    const [style, symbol] = ICONS[row.state];
+    return this._paint(style, symbol);
+  }
+  _status(row) {
+    if (row.state === "queued") {
+      return "queued";
+    }
+    if (row.state === "running") {
+      return formatDuration(Date.now() - (row.startedAt ?? this._startedAt));
+    }
+    return formatDuration(row.durationMs ?? 0);
+  }
+  _statusStyle(row) {
+    switch (row.state) {
+      case "running": {
+        return "cyan";
+      }
+      case "failed": {
+        return "red";
+      }
+      default: {
+        return "dim";
+      }
+    }
+  }
+};
+var TerminalUI = class {
+  constructor(_output = process.stderr) {
+    this._output = _output;
+    this._table = new AgentTable(_output, this._paint);
+    this.reporter = {
+      start: (plan) => {
+        const queueing = plan.agents.length > plan.maxAgents ? `, ${plan.maxAgents} at a time` : "";
+        this._stopSpinner(`Found ${plural(plan.comments, "comment")} to review in ${plural(plan.files, "file")}`);
+        this._muteInput();
+        this._table.start(plan, `Running ${plural(plan.agents.length, "agent")} (${plan.agent})${queueing}`);
+      },
+      agentStarted: (index) => {
+        this._table.started(index);
+      },
+      agentFinished: (index, report) => {
+        this._table.finished(index, report);
+      },
+      stop: () => {
+        this._table.stop();
+        this._unmuteInput();
+      }
+    };
+  }
+  _output;
+  reporter;
+  _table;
+  _busy;
+  _muted = false;
+  _paint = (style, text) => {
+    return styleText(style, text, { stream: this._output });
+  };
+  begin(title) {
+    intro(this._paint("inverse", ` ${title} `), { output: this._output });
+    this._startSpinner("Finding comments");
+  }
+  dispose() {
+    this._unmuteInput();
+    this._table.stop();
+    this._stopSpinner();
+  }
+  async finish(summary, options) {
+    const output = this._output;
+    const runs = summary.runs ?? [];
+    if (summary.sentToAgent === 0) {
+      this._stopSpinner("No comment in scope needs an agent");
+      if (summary.rewrapped) {
+        log.info(`Rewrapped ${plural(summary.rewrapped, "comment")} to fix their layout`, { output });
+      }
+      if (summary.remaining.length > 0) {
+        log.warn(this._describeRemaining(summary.remaining), { output });
+      }
+      this._warnSkipped(summary);
+      this._outro(summary.rewrapped ? "Done" : "Nothing to do");
+      return;
+    }
+    for (const [index, run] of runs.entries()) {
+      if (!run.ok) {
+        log.error(`${agentLabel(index)} failed: ${run.error}`, { output });
+      }
+    }
+    if (summary.codeChanged.length > 0) {
+      log.warn(`The agents changed code, not just comments, in ${summary.codeChanged.join(", ")}`, { output });
+    }
+    if (summary.changedElsewhere.length > 0) {
+      const files = plural(summary.changedElsewhere.length, "file");
+      log.warn(`${files} that no agent was given changed during the run: ${summary.changedElsewhere.join(", ")}`, {
+        output
+      });
+    }
+    if (summary.rewrapped) {
+      log.info(`Rewrapped ${plural(summary.rewrapped, "comment")} to fix their layout`, { output });
+    }
+    if (summary.remaining.length > 0) {
+      log.warn(this._describeRemaining(summary.remaining), { output });
+    } else {
+      log.success("Every comment passes the check now", { output });
+    }
+    this._warnSkipped(summary);
+    if (options.verbose) {
+      for (const [index, run] of runs.entries()) {
+        this._showReply(run, index, summary.remaining);
+      }
+    } else if (options.interactive) {
+      await this._browse(runs, summary.remaining);
+    }
+    const clean = summary.remaining.length === 0 && summary.codeChanged.length === 0 && !summary.agentError;
+    this._outro(clean ? "Done" : "Done, but some comments need a look");
+  }
+  _warnSkipped(summary) {
+    for (const skipped of summary.skipped) {
+      const text = describeSkipped(skipped);
+      log.warn(`${text.charAt(0).toUpperCase()}${text.slice(1)}`, { output: this._output });
+    }
+  }
+  /**
+   * Closes the guide like clack's `outro`, which always ends with an empty line.
+   */
+  _outro(message) {
+    this._output.write(`${this._paint("gray", S_BAR)}
+${this._paint("gray", S_BAR_END)}  ${message}
+`);
+  }
+  /**
+   * Keeps the terminal from echoing keys, like `^[[B` for the down arrow, into the output while
+   * it redraws. Raw mode also stops the terminal from turning Ctrl-C into a signal, so the input
+   * handler sends it instead.
+   */
+  _muteInput() {
+    const { stdin } = process;
+    if (!stdin.isTTY || this._muted) {
+      return;
+    }
+    this._muted = true;
+    stdin.setRawMode(true);
+    stdin.on("data", this._discardInput);
+    stdin.resume();
+  }
+  _unmuteInput() {
+    const { stdin } = process;
+    if (!this._muted) {
+      return;
+    }
+    this._muted = false;
+    stdin.off("data", this._discardInput);
+    stdin.setRawMode(false);
+    stdin.pause();
+  }
+  _discardInput = (data) => {
+    if (!data.includes(CTRL_C)) {
+      return;
+    }
+    this._unmuteInput();
+    try {
+      process.kill(0, "SIGINT");
+    } catch {
+      process.kill(process.pid, "SIGINT");
+    }
+  };
+  _startSpinner(message) {
+    this._busy = spinner({ output: this._output, frames: FRAMES, delay: FRAME_MS });
+    this._busy.start(message);
+  }
+  _stopSpinner(message) {
+    if (message === void 0) {
+      this._busy?.clear();
+    } else {
+      this._busy?.stop(message);
+    }
+    this._busy = void 0;
+  }
+  _describeRemaining(remaining) {
+    const locations = remaining.map((comment) => `${comment.file}:${comment.startLine}`);
+    const width = Math.max(...locations.slice(0, LISTED_REMAINING).map((location) => location.length));
+    const listed = remaining.slice(0, LISTED_REMAINING).map((comment, index) => {
+      const issues = comment.paragraphs.flatMap((paragraph) => paragraph.issues);
+      const types = new Set(issues.filter((issue) => issue.tier === "verdict").map((issue) => issue.type));
+      return `  ${locations[index].padEnd(width)}  ${this._paint("dim", [...types].join(", "))}`;
+    });
+    const more = remaining.length > LISTED_REMAINING ? [this._paint("dim", `  and ${remaining.length - LISTED_REMAINING} more`)] : [];
+    return [
+      `${plural(remaining.length, "comment")} still ${remaining.length === 1 ? "has" : "have"} issues`,
+      ...listed,
+      ...more
+    ].join("\n");
+  }
+  _remainingIn(run, remaining) {
+    return remaining.filter((comment) => run.files.includes(comment.file)).length;
+  }
+  _describeRun(run, remaining) {
+    if (!run.ok) {
+      return `failed after ${formatDuration(run.durationMs)}`;
+    }
+    const left = this._remainingIn(run, remaining);
+    return [
+      plural(run.comments, "comment"),
+      formatDuration(run.durationMs),
+      ...left > 0 ? [`${left} still ${left === 1 ? "has" : "have"} issues`] : []
+    ].join(", ");
+  }
+  _showReply(run, index, remaining, output = this._output) {
+    const reply = run.output ? formatReply(run.output, this._paint) : this._paint("dim", "The agent printed nothing.");
+    const error = run.ok ? [] : [this._paint("red", run.error ?? "The agent failed."), ""];
+    const files = this._paint("dim", run.files.join(", "));
+    const title = `${agentLabel(index)}, ${this._describeRun(run, remaining)}`;
+    note([files, "", ...error, reply].join("\n"), title, { output, withGuide: output === this._output });
+  }
+  /**
+   * Opens an agent's reply in `less`, which shows it on the alternate screen and restores the
+   * terminal when it quits, so that opening replies doesn't pile them up in the scrollback.
+   */
+  _openReply(run, index, remaining) {
+    let text = "";
+    const capture = Object.assign(
+      new Writable({
+        write(chunk, _encoding, callback) {
+          text += String(chunk);
+          callback();
+        }
+      }),
+      { columns: this._output.columns || 80 }
+    );
+    this._showReply(run, index, remaining, capture);
+    const prompt = `${agentLabel(index)}, press q to go back`.replaceAll(/[?:.%\\]/g, String.raw`\$&`);
+    const result = spawnSync2("less", ["-R", "-c", "-~", "-+F", "-+E", "-+X", `-Ps${prompt}`], {
+      input: text,
+      stdio: ["pipe", this._output.fd, "inherit"]
+    });
+    if (result.error) {
+      this._showReply(run, index, remaining);
+    }
+  }
+  /**
+   * Erases what a closed `select` prompt left behind, its guide line, message, and choice, plus a
+   * closing guide line when it was cancelled.
+   */
+  _erasePrompt(cancelled) {
+    const lines = cancelled ? 4 : 3;
+    this._output.write(`\x1B[${lines}F\x1B[J`);
+  }
+  async _browse(runs, remaining) {
+    const done = -1;
+    const columns = (this._output.columns || 80) - 1;
+    const nameWidth = agentLabel(runs.length - 1).length;
+    const options = runs.map((run, index) => {
+      const icon = run.ok ? this._paint("green", S_DONE) : this._paint("red", S_FAILED);
+      const hint = this._describeRun(run, remaining);
+      const filesWidth = Math.max(columns - 9 - nameWidth - 2 - (hint.length + 3), MIN_FILES_WIDTH);
+      return {
+        value: index,
+        label: `${icon} ${agentLabel(index).padEnd(nameWidth)}  ${fitFiles(run.files, filesWidth)}`,
+        hint
+      };
+    });
+    let initial = done;
+    for (; ; ) {
+      const choice = await select({
+        message: "Open an agent's reply",
+        options: [...options, { value: done, label: "Done" }],
+        initialValue: initial,
+        output: this._output
+      });
+      this._erasePrompt(isCancel(choice));
+      if (isCancel(choice) || choice === done) {
+        return;
+      }
+      this._openReply(runs[choice], choice, remaining);
+      initial = choice;
+    }
+  }
+};
+
+// src/comments/cli.ts
+var HELP = `
+Usage: comments <command> [targets...] [options]
+
+Finds comments in JavaScript and TypeScript files and measures how their prose fits the configured width.
+Only agent and hook change files, by applying the exact rewrap to comments that still have layout issues.
+
+Commands:
+  list     Print comments in scope with their line lengths, issues, and rewrap suggestions
+  check    Print comments with layout violations and exit with code 1 if any remain
+  wrap     Print the exact rewrap of the comment at each file:line target
+  agent    Hand comments in scope to an agent, then report any that still have issues
+  hook     Stop-hook entry point for agents (reads the hook payload from stdin)
+
+Targets are files, directories, file:line, or file:start-end. Without targets, only comments
+overlapping uncommitted changes (and untracked files) are considered.
+
+Options:
+  --staged          Only consider staged changes
+  --base <ref>      Consider changes since the merge base with <ref>
+  --repo            Consider every file in the repository
+  --suspicious      Only comments with layout issues (overflow, early line ends, last lines of one or two words)
+                    or hints (possible orphans, em-dashes, banners, ...). For agent and hook (the default), only
+                    comments with hints or with issues in parts the tool never rewraps, a triage, not a full review
+  --all             agent, hook: hand every comment in scope to the agent for a full review of its wording
+  --verbose         agent, hook: print every agent's reply (otherwise a terminal offers to open them)
+  --no-interactive  agent: show the agents while they run, then exit without offering to open their replies
+  --json            Print JSON
+  --config <path>   Use this config file instead of searching for one
+  --cwd <dir>       Run as if started in <dir> (targets and --config resolve against it)
+  --host <host>     hook: the agent running the hook (cursor, claude, codex)
+  --runner <name>   agent, hook: the agent CLI to spawn (claude, codex, cursor)
+  --mode <mode>     hook: agent, report, or off
+  -h, --help        Show this help
+
+Config overrides (take precedence over the config file):
+  --width <n>             Preferred comment line length
+  --max-width <n>         Hard limit for prose (default: 120, never below width)
+  --single-line-width <n> Longest line a one-paragraph comment may stay on (default: 120)
+  --tolerance <n>         Legacy hard limit of width + n, unless max-width is set
+  --[no-]orphans          Keep a sentence's first word off the end of a line, and end the first of two lines
+                          with a sentence when the second is no longer than the first (default: on)
+  --[no-]style            Look for possible semicolons, em-dashes, dashes, label colons, emphasis, and banners
+                          as hints (default: on). The agent's rules apply either way
+  --ignore <glob>         Skip matching files, repeatable
+  --model <name>          agent, hook: model for the agent
+  --timeout <seconds>     agent, hook: how long to wait for each agent (default: 300)
+  --batch-size <n>        agent, hook: most comments per agent (default: 20)
+  --max-files <n>         agent, hook: most files per agent (default: 10)
+  --max-agents <n>        agent, hook: most agents running at once (default: 6)
+  --instructions <text>   agent, hook: extra instructions appended to the rules
+`.trim();
+var RUNNERS = /* @__PURE__ */ new Set(["claude", "codex", "cursor"]);
+var MODES = /* @__PURE__ */ new Set(["agent", "report", "off"]);
+var OPTIONS = {
+  tolerance: { type: "string" },
+  orphans: { type: "boolean" },
+  style: { type: "boolean" },
+  ignore: { type: "string", multiple: true },
+  model: { type: "string" },
+  timeout: { type: "string" },
+  "batch-size": { type: "string" },
+  "max-files": { type: "string" },
+  "max-agents": { type: "string" },
+  instructions: { type: "string" },
+  staged: { type: "boolean" },
+  base: { type: "string" },
+  repo: { type: "boolean" },
+  suspicious: { type: "boolean" },
+  all: { type: "boolean" },
+  verbose: { type: "boolean" },
+  interactive: { type: "boolean" },
+  json: { type: "boolean" },
+  width: { type: "string" },
+  "max-width": { type: "string" },
+  "single-line-width": { type: "string" },
+  config: { type: "string" },
+  cwd: { type: "string" },
+  host: { type: "string" },
+  runner: { type: "string" },
+  mode: { type: "string" },
+  help: { type: "boolean", short: "h" }
+};
+function parse(argv) {
+  return parseArgs({ args: [...argv], allowPositionals: true, allowNegative: true, options: OPTIONS });
+}
+function peek(argv) {
+  const { values, positionals } = parseArgs({
+    args: [...argv],
+    allowPositionals: true,
+    allowNegative: true,
+    options: OPTIONS,
+    strict: false
+  });
+  return {
+    command: positionals.at(0),
+    host: typeof values.host === "string" ? values.host : void 0,
+    help: values.help === true
+  };
+}
+function log2(message) {
+  process.stderr.write(`${message}
+`);
+}
+function resolveCwd(directory, source = "--cwd") {
+  const resolved = path5.resolve(directory);
+  if (!existsSync4(resolved) || !statSync3(resolved).isDirectory()) {
+    throw new Error(`comments: ${source} ${directory} is not a directory`);
+  }
+  return realpathSync(resolved);
+}
+function parseInteger(name, value, minimum) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const number = Number(value);
+  if (!Number.isInteger(number) || number < minimum) {
+    throw new Error(`comments: --${name} must be an integer of at least ${minimum}, got ${value}`);
+  }
+  return number;
+}
+function defined(object) {
+  return Object.fromEntries(Object.entries(object).filter(([, value]) => value !== void 0));
+}
+function applyOverrides(config, values) {
+  const overrides = defined({
+    width: parseInteger("width", values.width, 1),
+    maxWidth: parseInteger("max-width", values["max-width"], 1),
+    singleLineWidth: parseInteger("single-line-width", values["single-line-width"], 1),
+    tolerance: parseInteger("tolerance", values.tolerance, 0),
+    avoidSentenceOrphans: values.orphans,
+    style: values.style,
+    ignore: values.ignore ? [...config.ignore ?? [], ...values.ignore] : void 0
+  });
+  const agent = defined({
+    model: values.model,
+    timeout: parseInteger("timeout", values.timeout, 1),
+    batchSize: parseInteger("batch-size", values["batch-size"], 1),
+    maxFiles: parseInteger("max-files", values["max-files"], 1),
+    maxAgents: parseInteger("max-agents", values["max-agents"], 1),
+    instructions: values.instructions
+  });
+  return { ...config, ...overrides, agent: { ...config.agent, ...agent } };
+}
+async function createProject(cwd, values) {
+  const repoRoot = findRepoRoot(cwd);
+  const root = repoRoot ?? cwd;
+  const loaded = await loadConfig(cwd, { explicitPath: values.config, stopDir: root });
+  const config = applyOverrides(loaded.config, values);
+  const project = new Project(root, config, { isGitRepo: repoRoot !== void 0, cwd });
+  return { project, configPath: loaded.filepath };
+}
+function scopeFrom(positionals, values) {
+  return { targets: positionals, staged: values.staged, base: values.base, repo: values.repo };
+}
+function selectFrom(values, project) {
+  if (values.all) {
+    return "all";
+  }
+  return values.suspicious ? "suspicious" : project.config.agent?.scope ?? "suspicious";
+}
+function formatIssue(issue) {
+  return issue.tier === "hint" ? `${issue.type} (hint)` : issue.type;
+}
+function formatComment(comment) {
+  const issueList = comment.paragraphs.flatMap((paragraph) => paragraph.issues);
+  const issues = /* @__PURE__ */ new Map();
+  for (const issue of issueList) {
+    issues.set(issue.line, [...issues.get(issue.line) ?? [], formatIssue(issue)]);
+  }
+  const typesOf = (tier) => {
+    return [...new Set(issueList.filter((issue) => issue.tier === tier).map((issue) => issue.type))];
+  };
+  const verdicts = typesOf("verdict");
+  const hints = typesOf("hint");
+  const labels = [
+    ...verdicts.length > 0 ? [`suspicious: ${verdicts.join(", ")}`] : [],
+    ...hints.length > 0 ? [`hints: ${hints.join(", ")}`] : []
+  ];
+  const status = labels.length > 0 ? labels.join(", ") : "ok";
+  const range = `${comment.startLine}-${comment.endLine}`;
+  const location = comment.startLine === comment.endLine ? comment.startLine : range;
+  const maximum = comment.maxWidth === void 0 ? "" : `, maximum ${comment.maxWidth}`;
+  const output = [`${comment.file}:${location} ${comment.kind}, width ${comment.width}, ${status}${maximum}`];
+  const lines = comment.text.split("\n");
+  const numberWidth = String(comment.endLine).length;
+  for (const [offset, text] of lines.entries()) {
+    const line = comment.startLine + offset;
+    const marks = issues.get(line);
+    const length = String(comment.lengths[offset]).padStart(3);
+    output.push(
+      `  ${String(line).padStart(numberWidth)} ${length} | ${text}${marks ? `  <- ${marks.join(", ")}` : ""}`
+    );
+  }
+  return output.join("\n");
+}
+function printComments(comments, values) {
+  if (values.json) {
+    process.stdout.write(`${JSON.stringify(comments, null, 2)}
+`);
+    return;
+  }
+  for (const comment of comments) {
+    process.stdout.write(`${formatComment(comment)}
+
+`);
+  }
+}
+function commentsOf(analyses) {
+  return analyses.flatMap((analysis) => analysis.comments);
+}
+function hintEmptyScope(analyses, scope) {
+  const isDefaultScope = (scope.targets ?? []).length === 0 && !scope.repo && !scope.base;
+  if (analyses.length === 0 && isDefaultScope) {
+    const changes = scope.staged ? "staged changes" : "uncommitted changes";
+    log2(
+      `comments: no ${changes} in JavaScript or TypeScript files. Pass --repo, --base <ref>, or files to widen the scope.`
+    );
+  }
+}
+function warnSkipped(analyses) {
+  for (const skipped of skippedFiles(analyses)) {
+    log2(`comments: ${describeSkipped(skipped)}`);
+  }
+}
+function parseRunner(value) {
+  if (value !== void 0 && !RUNNERS.has(value)) {
+    throw new Error(`comments: unknown runner ${value}, expected claude, codex, or cursor`);
+  }
+  return value;
+}
+async function runWrap(project, targets, values) {
+  if (targets.length === 0 || targets.some((target) => !/:\d+(?:-\d+)?$/.test(target))) {
+    throw new Error("comments: wrap expects file:line targets, e.g. `comments wrap src/a.ts:12`");
+  }
+  const results = [];
+  for (const target of targets) {
+    const analyses = await project.analyze({ targets: [target] });
+    const comments = commentsOf(analyses);
+    const skipped = skippedFiles(analyses).at(0);
+    if (skipped) {
+      throw new Error(`comments: ${describeSkipped(skipped)}`);
+    }
+    if (comments.length === 0) {
+      throw new Error(`comments: no comment at ${target}`);
+    }
+    for (const comment of comments) {
+      results.push({
+        file: comment.file,
+        startLine: comment.startLine,
+        endLine: comment.endLine,
+        text: rewrapComment(comment)
+      });
+    }
+  }
+  if (values.json) {
+    process.stdout.write(`${JSON.stringify(results, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${results.map((result) => result.text).join("\n\n")}
+`);
+  }
+  return 0;
+}
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return "";
+  }
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function hookOutput(host, message) {
+  if (host === "cursor" || !message) {
+    return "{}";
+  }
+  return JSON.stringify({ systemMessage: message });
+}
+function parsePayload(raw) {
+  const payload = raw.trim() ? JSON.parse(raw) : {};
+  return payload !== null && typeof payload === "object" ? payload : {};
+}
+function payloadDirectory(payload) {
+  const roots = payload.workspace_roots;
+  const candidates = [Array.isArray(roots) ? roots.at(0) : void 0, payload.cwd];
+  return candidates.find((candidate) => typeof candidate === "string" && candidate !== "");
+}
+async function runHook(argv) {
+  const host = peek(argv).host ?? "claude";
+  let message;
+  try {
+    const { values, positionals } = parse(argv);
+    if (!RUNNERS.has(host)) {
+      throw new Error(`comments: unknown host ${host}, expected cursor, claude, or codex`);
+    }
+    const payload = parsePayload(await readStdin());
+    if (process.env[CHILD_ENV] || payload.status !== void 0 && payload.status !== "completed") {
+      return;
+    }
+    const directory = values.cwd ?? payloadDirectory(payload);
+    const source = values.cwd === void 0 ? "the hook directory" : "--cwd";
+    const cwd = directory === void 0 ? process.cwd() : resolveCwd(directory, source);
+    const { project, configPath } = await createProject(cwd, values);
+    const mode = values.mode ?? project.config.hook?.mode ?? "agent";
+    if (!MODES.has(mode)) {
+      throw new Error(`comments: unknown mode ${mode}`);
+    }
+    if (mode === "off") {
+      return;
+    }
+    const summary = await runFlow(project, scopeFrom(positionals.slice(1), values), {
+      mode,
+      select: selectFrom(values, project),
+      runner: parseRunner(values.runner) ?? project.config.agent?.runner ?? host,
+      configPath,
+      reporter: createLogReporter(log2, { verbose: values.verbose })
+    });
+    message = describeSummary(summary);
+  } catch (error) {
+    message = `comments: ${error.message.replace(/^comments: /, "")}`;
+  } finally {
+    if (message) {
+      log2(message);
+    }
+    process.stdout.write(`${hookOutput(host, message)}
+`);
+  }
+}
+async function main(argv) {
+  const peeked = peek(argv);
+  if (peeked.command === "hook" && !peeked.help) {
+    await runHook(argv);
+    return 0;
+  }
+  const { values, positionals } = parse(argv);
+  const [command, ...targets] = positionals;
+  if (values.help || !command || command === "help") {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const cwd = values.cwd ? resolveCwd(values.cwd) : process.cwd();
+  const { project, configPath } = await createProject(cwd, values);
+  const scope = scopeFrom(targets, values);
+  switch (command) {
+    case "list": {
+      const analyses = await project.analyze(scope);
+      const comments = commentsOf(analyses);
+      printComments(values.suspicious ? comments.filter((comment) => isSuspicious(comment)) : comments, values);
+      warnSkipped(analyses);
+      hintEmptyScope(analyses, scope);
+      return 0;
+    }
+    case "check": {
+      const analyses = await project.analyze(scope);
+      const comments = commentsOf(analyses).filter((comment) => hasVerdictIssues(comment));
+      printComments(comments, values);
+      warnSkipped(analyses);
+      hintEmptyScope(analyses, scope);
+      if (!values.json) {
+        log2(comments.length > 0 ? `${comments.length} comment(s) with layout issues` : "all comments fit the width");
+      }
+      return comments.length > 0 ? 1 : 0;
+    }
+    case "wrap": {
+      return runWrap(project, targets, values);
+    }
+    case "agent": {
+      const options = {
+        mode: "agent",
+        select: selectFrom(values, project),
+        runner: parseRunner(values.runner) ?? project.config.agent?.runner ?? "claude",
+        configPath
+      };
+      let summary;
+      if (isLiveTerminal()) {
+        const ui = new TerminalUI();
+        ui.begin("comments agent");
+        try {
+          summary = await runFlow(project, scope, { ...options, reporter: ui.reporter });
+        } catch (error) {
+          ui.dispose();
+          throw error;
+        }
+        await ui.finish(summary, {
+          interactive: process.stdin.isTTY && values.interactive !== false,
+          verbose: values.verbose
+        });
+      } else {
+        summary = await runFlow(project, scope, {
+          ...options,
+          reporter: createLogReporter(log2, { verbose: values.verbose })
+        });
+        log2(describeSummary(summary) ?? "comments: nothing to do");
+      }
+      const failed = summary.remaining.length > 0 || summary.codeChanged.length > 0 || summary.agentError;
+      return failed ? 1 : 0;
+    }
+    default: {
+      log2(`comments: unknown command ${command}
+`);
+      process.stderr.write(HELP);
+      return 2;
+    }
+  }
+}
+
+// src/comments/bin.ts
+try {
+  process.exitCode = await main(process.argv.slice(2));
+} catch (error) {
+  log2(error.message);
+  process.exitCode = 2;
+}
+/**
+ * Legal comments are kept as they are. A comment is legal when it uses the same markers
+ * as bundlers like esbuild (`/*!`, `//!`, `@license`, and `@preserve`), or when it is a
+ * copyright notice like `Copyright (c) 2020 Foo`.
+ */
+// a code span only names a marker, like the `@license` in a comment that explains legal comments
+//# sourceMappingURL=comments.js.map