@staff0rd/assist 0.1112.6 → 0.1112.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -6,7 +6,7 @@ import { Command } from "commander";
6
6
  // package.json
7
7
  var package_default = {
8
8
  name: "@staff0rd/assist",
9
- version: "0.1112.6",
9
+ version: "0.1112.8",
10
10
  type: "module",
11
11
  main: "dist/index.js",
12
12
  bin: {
@@ -22613,12 +22613,12 @@ async function startChainedSession(label, start2) {
22613
22613
  }
22614
22614
 
22615
22615
  // src/commands/backlog/propose/startProposedRun.ts
22616
- function startProposedRun(id, startOn) {
22616
+ function startProposedRun(id, startOn, cwd = process.cwd()) {
22617
22617
  const itemId2 = formatItemId(id);
22618
22618
  const args = ["backlog", "run", itemId2];
22619
22619
  return startChainedSession(
22620
22620
  `a backlog run session for ${itemId2}`,
22621
- () => startOn ? requestAssistSession(args, startOn.cwd, { node: startOn.node }) : requestAssistSession(args, process.cwd())
22621
+ () => startOn ? requestAssistSession(args, startOn.cwd, { node: startOn.node }) : requestAssistSession(args, cwd)
22622
22622
  );
22623
22623
  }
22624
22624
 
@@ -25485,7 +25485,7 @@ function registerUpdateFieldCommand(cmd) {
25485
25485
  }
25486
25486
 
25487
25487
  // src/commands/backlog/updatePlan.ts
25488
- import chalk111 from "chalk";
25488
+ import chalk112 from "chalk";
25489
25489
 
25490
25490
  // src/commands/backlog/updatePlan/planUpdateSchema.ts
25491
25491
  import { z as z18 } from "zod";
@@ -25672,6 +25672,28 @@ async function reviewPlanUpdate(item, phases) {
25672
25672
  return { autostart: false };
25673
25673
  }
25674
25674
 
25675
+ // src/commands/backlog/updatePlan/startPlanRun.ts
25676
+ import chalk111 from "chalk";
25677
+ function itemRepoCwd(origin) {
25678
+ if (!origin || origin === getOrigin()) return process.cwd();
25679
+ const baseDir = expandTilde(loadConfig().clone.baseDir);
25680
+ return resolveRepoLocation(origin, void 0, baseDir).cwd;
25681
+ }
25682
+ async function startPlanRun(item, approval) {
25683
+ if (!approval.autostart) return;
25684
+ if (approval.startOn) return startProposedRun(item.id, approval.startOn);
25685
+ const cwd = itemRepoCwd(item.origin);
25686
+ if (!cwd) {
25687
+ console.log(
25688
+ chalk111.yellow(
25689
+ `Not starting a run: no clone of ${item.origin} was found. Run \`assist backlog run ${formatItemId(item.id)}\` from a clone of it.`
25690
+ )
25691
+ );
25692
+ return;
25693
+ }
25694
+ await startProposedRun(item.id, void 0, cwd);
25695
+ }
25696
+
25675
25697
  // src/commands/backlog/updatePlan.ts
25676
25698
  async function updatePlan(id, options2) {
25677
25699
  const { phases } = await readPlanUpdate(options2.json);
@@ -25681,11 +25703,11 @@ async function updatePlan(id, options2) {
25681
25703
  const approval = await reviewPlanUpdate(item, phases);
25682
25704
  await replacePlan(orm, item.id, phases, item.currentPhase);
25683
25705
  console.log(
25684
- chalk111.green(
25706
+ chalk112.green(
25685
25707
  `Replaced the plan on item ${formatItemId(item.id)} with ${phases.length} phase${phases.length === 1 ? "" : "s"}.`
25686
25708
  )
25687
25709
  );
25688
- if (approval.autostart) await startProposedRun(item.id, approval.startOn);
25710
+ await startPlanRun(item, approval);
25689
25711
  }
25690
25712
 
25691
25713
  // src/commands/backlog/registerUpdateCommands.ts
@@ -25717,7 +25739,7 @@ async function web2(options2) {
25717
25739
  }
25718
25740
 
25719
25741
  // src/commands/backlog/show.ts
25720
- import chalk117 from "chalk";
25742
+ import chalk118 from "chalk";
25721
25743
 
25722
25744
  // src/commands/backlog/shortenGithubIssue.ts
25723
25745
  var SHORTHAND = /^([^/\s]+)\/([^/\s]+)#(\d+)$/;
@@ -25732,7 +25754,7 @@ function shortenGithubIssue(githubIssue, origin) {
25732
25754
  }
25733
25755
 
25734
25756
  // src/commands/backlog/show/printActivity.ts
25735
- import chalk113 from "chalk";
25757
+ import chalk114 from "chalk";
25736
25758
 
25737
25759
  // src/commands/backlog/groupActivityRefs.ts
25738
25760
  var ACTIVITY_COMMIT_LIMIT = 10;
@@ -25752,7 +25774,7 @@ function groupActivityRefs(refs, commitLimit = ACTIVITY_COMMIT_LIMIT) {
25752
25774
  }
25753
25775
 
25754
25776
  // src/commands/backlog/show/printRef.ts
25755
- import chalk112 from "chalk";
25777
+ import chalk113 from "chalk";
25756
25778
 
25757
25779
  // src/commands/backlog/refLabel.ts
25758
25780
  function refLabel(ref) {
@@ -25773,9 +25795,9 @@ function refLabel(ref) {
25773
25795
 
25774
25796
  // src/commands/backlog/show/printRef.ts
25775
25797
  function printRef(ref) {
25776
- const url = ref.url ? ` ${chalk112.dim(ref.url)}` : "";
25777
- const approvedAt = isUnlock(ref) && ref.createdAt ? ` ${chalk112.dim(ref.createdAt)}` : "";
25778
- console.log(` ${chalk112.cyan(ref.kind)} ${refLabel(ref)}${url}${approvedAt}`);
25798
+ const url = ref.url ? ` ${chalk113.dim(ref.url)}` : "";
25799
+ const approvedAt = isUnlock(ref) && ref.createdAt ? ` ${chalk113.dim(ref.createdAt)}` : "";
25800
+ console.log(` ${chalk113.cyan(ref.kind)} ${refLabel(ref)}${url}${approvedAt}`);
25779
25801
  }
25780
25802
  function isUnlock(ref) {
25781
25803
  return ref.kind === "docs-unlock" || ref.kind === "schema-unlock";
@@ -25806,14 +25828,14 @@ function printActivity(item, options2 = {}) {
25806
25828
  ...sessions
25807
25829
  ];
25808
25830
  if (ordered.length === 0) return;
25809
- console.log(chalk113.bold("Activity"));
25831
+ console.log(chalk114.bold("Activity"));
25810
25832
  for (const unlock of unlocks) printRef(unlock);
25811
25833
  for (const design of designs) printRef(design);
25812
25834
  for (const branch2 of branches) printRef(branch2);
25813
25835
  for (const commit2 of commits2) printRef(commit2);
25814
25836
  if (overflowCommits.length > 0) {
25815
25837
  console.log(
25816
- ` ${chalk113.dim(`\u2026 and ${overflowCommits.length} more commits (--all-commits to show)`)}`
25838
+ ` ${chalk114.dim(`\u2026 and ${overflowCommits.length} more commits (--all-commits to show)`)}`
25817
25839
  );
25818
25840
  }
25819
25841
  for (const pr of prs2) printRef(pr);
@@ -25823,20 +25845,20 @@ function printActivity(item, options2 = {}) {
25823
25845
  }
25824
25846
 
25825
25847
  // src/commands/backlog/show/printLinks.ts
25826
- import chalk114 from "chalk";
25848
+ import chalk115 from "chalk";
25827
25849
  function printSection(heading2, links2, targets, label) {
25828
25850
  if (links2.length === 0) return;
25829
- console.log(chalk114.bold(heading2));
25851
+ console.log(chalk115.bold(heading2));
25830
25852
  for (const link3 of links2) {
25831
25853
  const target = targets.find((i) => i.id === link3.targetId);
25832
25854
  const prefix2 = label(link3);
25833
25855
  if (target) {
25834
25856
  console.log(
25835
- ` ${prefix2}${formatItemId(target.id)} ${target.name} ${chalk114.dim(`(${target.status})`)}`
25857
+ ` ${prefix2}${formatItemId(target.id)} ${target.name} ${chalk115.dim(`(${target.status})`)}`
25836
25858
  );
25837
25859
  } else {
25838
25860
  console.log(
25839
- ` ${prefix2}${formatItemId(link3.targetId)} ${chalk114.dim("(not found)")}`
25861
+ ` ${prefix2}${formatItemId(link3.targetId)} ${chalk115.dim("(not found)")}`
25840
25862
  );
25841
25863
  }
25842
25864
  }
@@ -25853,7 +25875,7 @@ async function printLinks(orm, item) {
25853
25875
  "Links",
25854
25876
  links2.filter((l) => l.type !== "docs-refresh"),
25855
25877
  targets,
25856
- (link3) => `${link3.type === "depends-on" ? chalk114.red(link3.type) : chalk114.blue(link3.type)} `
25878
+ (link3) => `${link3.type === "depends-on" ? chalk115.red(link3.type) : chalk115.blue(link3.type)} `
25857
25879
  );
25858
25880
  printSection(
25859
25881
  "Refreshes docs for",
@@ -25864,18 +25886,18 @@ async function printLinks(orm, item) {
25864
25886
  }
25865
25887
 
25866
25888
  // src/commands/backlog/show/printPlan.ts
25867
- import chalk116 from "chalk";
25889
+ import chalk117 from "chalk";
25868
25890
 
25869
25891
  // src/commands/backlog/show/printPhaseTasks.ts
25870
- import chalk115 from "chalk";
25892
+ import chalk116 from "chalk";
25871
25893
  function printPhaseTasks(phase) {
25872
25894
  for (const task of phase.tasks) {
25873
25895
  console.log(` - ${task.task}`);
25874
25896
  }
25875
25897
  if (phase.manualChecks && phase.manualChecks.length > 0) {
25876
- console.log(` ${chalk115.dim("Manual checks:")}`);
25898
+ console.log(` ${chalk116.dim("Manual checks:")}`);
25877
25899
  for (const check2 of phase.manualChecks) {
25878
- console.log(` ${chalk115.dim(`- ${check2}`)}`);
25900
+ console.log(` ${chalk116.dim(`- ${check2}`)}`);
25879
25901
  }
25880
25902
  }
25881
25903
  }
@@ -25883,16 +25905,16 @@ function printPhaseTasks(phase) {
25883
25905
  // src/commands/backlog/show/printPlan.ts
25884
25906
  function phaseHeader(index3, name2, isCurrent) {
25885
25907
  const phaseNumber = index3 + 1;
25886
- const marker2 = isCurrent ? chalk116.green("\u25B6 ") : " ";
25887
- const label = isCurrent ? chalk116.green.bold(`Phase ${phaseNumber}: ${name2}`) : `${chalk116.bold(`Phase ${phaseNumber}:`)} ${name2}`;
25908
+ const marker2 = isCurrent ? chalk117.green("\u25B6 ") : " ";
25909
+ const label = isCurrent ? chalk117.green.bold(`Phase ${phaseNumber}: ${name2}`) : `${chalk117.bold(`Phase ${phaseNumber}:`)} ${name2}`;
25888
25910
  return `${marker2}${label}`;
25889
25911
  }
25890
25912
  function printPhaseSessions(sessions) {
25891
25913
  if (sessions.length === 0) return;
25892
- console.log(` ${chalk116.dim("Sessions:")}`);
25914
+ console.log(` ${chalk117.dim("Sessions:")}`);
25893
25915
  for (const s of sessions) {
25894
25916
  console.log(
25895
- ` ${chalk116.dim(`- ${s.hostname} / ${s.osUser} / ${s.claudeSessionId}`)}`
25917
+ ` ${chalk117.dim(`- ${s.hostname} / ${s.osUser} / ${s.claudeSessionId}`)}`
25896
25918
  );
25897
25919
  }
25898
25920
  }
@@ -25917,7 +25939,7 @@ function printPlan(item) {
25917
25939
  if (!item.plan || item.plan.length === 0) return;
25918
25940
  const plan2 = item.plan;
25919
25941
  const reviewIdx = reviewPhaseIndex(plan2);
25920
- console.log(chalk116.bold("Plan"));
25942
+ console.log(chalk117.bold("Plan"));
25921
25943
  for (const [i, phase] of plan2.entries()) {
25922
25944
  const isCurrent = item.currentPhase === i + 1;
25923
25945
  const sessions = (item.phaseSessions ?? []).filter(
@@ -25931,23 +25953,23 @@ function printPlan(item) {
25931
25953
 
25932
25954
  // src/commands/backlog/show.ts
25933
25955
  function printHeader(item) {
25934
- console.log(chalk117.bold(`${formatItemId(item.id)} ${item.name}`));
25956
+ console.log(chalk118.bold(`${formatItemId(item.id)} ${item.name}`));
25935
25957
  console.log(
25936
- `${chalk117.dim("Type:")} ${item.type} ${chalk117.dim("Status:")} ${item.status}`
25958
+ `${chalk118.dim("Type:")} ${item.type} ${chalk118.dim("Status:")} ${item.status}`
25937
25959
  );
25938
25960
  if (item.jiraKey) {
25939
- console.log(`${chalk117.dim("Jira:")} ${item.jiraKey}`);
25961
+ console.log(`${chalk118.dim("Jira:")} ${item.jiraKey}`);
25940
25962
  }
25941
25963
  if (item.githubIssue) {
25942
25964
  console.log(
25943
- `${chalk117.dim("GitHub:")} ${shortenGithubIssue(item.githubIssue, item.origin)}`
25965
+ `${chalk118.dim("GitHub:")} ${shortenGithubIssue(item.githubIssue, item.origin)}`
25944
25966
  );
25945
25967
  }
25946
25968
  console.log();
25947
25969
  }
25948
25970
  function printAcceptanceCriteria(criteria) {
25949
25971
  if (criteria.length === 0) return;
25950
- console.log(chalk117.bold("Acceptance Criteria"));
25972
+ console.log(chalk118.bold("Acceptance Criteria"));
25951
25973
  for (const [i, ac] of criteria.entries()) {
25952
25974
  console.log(` ${i + 1}. ${ac}`);
25953
25975
  }
@@ -25956,7 +25978,7 @@ function printAcceptanceCriteria(criteria) {
25956
25978
  function printComments(item) {
25957
25979
  const entries = item.comments ?? [];
25958
25980
  if (entries.length === 0) return;
25959
- console.log(chalk117.bold("Comments"));
25981
+ console.log(chalk118.bold("Comments"));
25960
25982
  for (const entry of entries) {
25961
25983
  console.log(` ${formatComment(entry)}`);
25962
25984
  }
@@ -25968,7 +25990,7 @@ async function show(id, options2 = {}) {
25968
25990
  const { orm, item } = found;
25969
25991
  printHeader(item);
25970
25992
  if (item.description) {
25971
- console.log(chalk117.bold("Description"));
25993
+ console.log(chalk118.bold("Description"));
25972
25994
  console.log(renderMarkdownTerminal(item.description));
25973
25995
  console.log();
25974
25996
  }
@@ -27466,11 +27488,11 @@ function assertCliExists(cli) {
27466
27488
  }
27467
27489
 
27468
27490
  // src/commands/permitCliReads/colorize.ts
27469
- import chalk118 from "chalk";
27491
+ import chalk119 from "chalk";
27470
27492
  function colorize(plainOutput) {
27471
27493
  return plainOutput.split("\n").map((line) => {
27472
- if (line.startsWith(" R ")) return chalk118.green(line);
27473
- if (line.startsWith(" W ")) return chalk118.red(line);
27494
+ if (line.startsWith(" R ")) return chalk119.green(line);
27495
+ if (line.startsWith(" W ")) return chalk119.red(line);
27474
27496
  return line;
27475
27497
  }).join("\n");
27476
27498
  }
@@ -27763,7 +27785,7 @@ async function permitCliReads(cli, options2 = { noCache: false }) {
27763
27785
  }
27764
27786
 
27765
27787
  // src/commands/deny/denyAdd.ts
27766
- import chalk119 from "chalk";
27788
+ import chalk120 from "chalk";
27767
27789
 
27768
27790
  // src/commands/deny/loadDenyConfig.ts
27769
27791
  function loadDenyConfig(global) {
@@ -27783,16 +27805,16 @@ function loadDenyConfig(global) {
27783
27805
  function denyAdd(pattern2, message4, options2) {
27784
27806
  const { deny: deny2, saveDeny } = loadDenyConfig(options2.node);
27785
27807
  if (deny2.some((r) => r.pattern === pattern2)) {
27786
- console.log(chalk119.yellow(`Deny rule already exists for: ${pattern2}`));
27808
+ console.log(chalk120.yellow(`Deny rule already exists for: ${pattern2}`));
27787
27809
  return;
27788
27810
  }
27789
27811
  deny2.push({ pattern: pattern2, message: message4 });
27790
27812
  saveDeny(deny2);
27791
- console.log(chalk119.green(`Added deny rule: ${pattern2} \u2192 ${message4}`));
27813
+ console.log(chalk120.green(`Added deny rule: ${pattern2} \u2192 ${message4}`));
27792
27814
  }
27793
27815
 
27794
27816
  // src/commands/deny/denyList.ts
27795
- import chalk120 from "chalk";
27817
+ import chalk121 from "chalk";
27796
27818
  function denyList() {
27797
27819
  const globalRaw = loadGlobalConfigRaw();
27798
27820
  const projectRaw = loadProjectConfig();
@@ -27803,7 +27825,7 @@ function denyList() {
27803
27825
  projectDeny.length > 0 ? projectDeny : void 0
27804
27826
  );
27805
27827
  if (!merged || merged.length === 0) {
27806
- console.log(chalk120.dim("No deny rules configured."));
27828
+ console.log(chalk121.dim("No deny rules configured."));
27807
27829
  return;
27808
27830
  }
27809
27831
  const projectPatterns = new Set(projectDeny.map((r) => r.pattern));
@@ -27811,23 +27833,23 @@ function denyList() {
27811
27833
  for (const rule of merged) {
27812
27834
  const inProject = projectPatterns.has(rule.pattern);
27813
27835
  const inGlobal = globalPatterns.has(rule.pattern);
27814
- const label = inProject && inGlobal ? chalk120.dim(" (project, overrides global)") : inGlobal ? chalk120.dim(" (global)") : "";
27815
- console.log(`${chalk120.red(rule.pattern)} \u2192 ${rule.message}${label}`);
27836
+ const label = inProject && inGlobal ? chalk121.dim(" (project, overrides global)") : inGlobal ? chalk121.dim(" (global)") : "";
27837
+ console.log(`${chalk121.red(rule.pattern)} \u2192 ${rule.message}${label}`);
27816
27838
  }
27817
27839
  }
27818
27840
 
27819
27841
  // src/commands/deny/denyRemove.ts
27820
- import chalk121 from "chalk";
27842
+ import chalk122 from "chalk";
27821
27843
  function denyRemove(pattern2, options2) {
27822
27844
  const { deny: deny2, saveDeny } = loadDenyConfig(options2.node);
27823
27845
  const index3 = deny2.findIndex((r) => r.pattern === pattern2);
27824
27846
  if (index3 === -1) {
27825
- console.log(chalk121.yellow(`No deny rule found for: ${pattern2}`));
27847
+ console.log(chalk122.yellow(`No deny rule found for: ${pattern2}`));
27826
27848
  return;
27827
27849
  }
27828
27850
  deny2.splice(index3, 1);
27829
27851
  saveDeny(deny2.length > 0 ? deny2 : void 0);
27830
- console.log(chalk121.green(`Removed deny rule: ${pattern2}`));
27852
+ console.log(chalk122.green(`Removed deny rule: ${pattern2}`));
27831
27853
  }
27832
27854
 
27833
27855
  // src/commands/registerDeny.ts
@@ -27860,7 +27882,7 @@ function registerCliHook(program) {
27860
27882
 
27861
27883
  // src/commands/codeComment/codeCommentConfirm.ts
27862
27884
  import { existsSync as existsSync60, readFileSync as readFileSync43, unlinkSync as unlinkSync9, writeFileSync as writeFileSync30 } from "fs";
27863
- import chalk122 from "chalk";
27885
+ import chalk123 from "chalk";
27864
27886
 
27865
27887
  // src/shared/isHashCommentFile.ts
27866
27888
  import path35 from "path";
@@ -27932,12 +27954,12 @@ function codeCommentConfirm(pin2) {
27932
27954
  sweepRestrictedDir();
27933
27955
  const state = readPinState(pin2);
27934
27956
  if (!state) {
27935
- console.error(chalk122.red(`No pending comment for pin: ${pin2}`));
27957
+ console.error(chalk123.red(`No pending comment for pin: ${pin2}`));
27936
27958
  process.exitCode = 1;
27937
27959
  return;
27938
27960
  }
27939
27961
  if (!existsSync60(state.file)) {
27940
- console.error(chalk122.red(`Target file no longer exists: ${state.file}`));
27962
+ console.error(chalk123.red(`Target file no longer exists: ${state.file}`));
27941
27963
  process.exitCode = 1;
27942
27964
  return;
27943
27965
  }
@@ -27946,7 +27968,7 @@ function codeCommentConfirm(pin2) {
27946
27968
  const index3 = state.line - 1;
27947
27969
  if (index3 > lines.length) {
27948
27970
  console.error(
27949
- chalk122.red(
27971
+ chalk123.red(
27950
27972
  `Line ${state.line} is beyond the end of ${state.file} (${lines.length} lines).`
27951
27973
  )
27952
27974
  );
@@ -27960,14 +27982,14 @@ function codeCommentConfirm(pin2) {
27960
27982
  writeFileSync30(state.file, lines.join("\n"));
27961
27983
  unlinkSync9(getPinStatePath(pin2));
27962
27984
  console.log(
27963
- chalk122.green(
27985
+ chalk123.green(
27964
27986
  `Inserted "${marker2} ${state.text}" at ${state.file}:${state.line}`
27965
27987
  )
27966
27988
  );
27967
27989
  }
27968
27990
 
27969
27991
  // src/commands/codeComment/codeCommentSet.ts
27970
- import chalk123 from "chalk";
27992
+ import chalk124 from "chalk";
27971
27993
 
27972
27994
  // src/commands/codeComment/validateCommentText.ts
27973
27995
  var MAX_COMMENT_LENGTH = 50;
@@ -28101,7 +28123,7 @@ function generatePin() {
28101
28123
  async function codeCommentSet(file, line, text19) {
28102
28124
  const lineNumber = Number.parseInt(line, 10);
28103
28125
  if (!Number.isInteger(lineNumber) || lineNumber < 1) {
28104
- console.error(chalk123.red(`Invalid line number: ${line}`));
28126
+ console.error(chalk124.red(`Invalid line number: ${line}`));
28105
28127
  process.exitCode = 1;
28106
28128
  return;
28107
28129
  }
@@ -28109,20 +28131,20 @@ async function codeCommentSet(file, line, text19) {
28109
28131
  const marker2 = hash ? "#" : "//";
28110
28132
  const validation = validateCommentText(text19, hash);
28111
28133
  if (!validation.ok) {
28112
- console.error(chalk123.red(`Refused: ${validation.reason}`));
28113
- console.error(chalk123.red("No pin issued."));
28134
+ console.error(chalk124.red(`Refused: ${validation.reason}`));
28135
+ console.error(chalk124.red("No pin issued."));
28114
28136
  process.exitCode = 1;
28115
28137
  return;
28116
28138
  }
28117
28139
  console.error(
28118
- chalk123.yellow.bold(
28140
+ chalk124.yellow.bold(
28119
28141
  "THIS IS YOUR LAST CHANCE TO RECONSIDER BEFORE INVOLVING A HUMAN.\nRequesting this pin pages a real person to approve a comment. DO NOT WASTE THEIR TIME.\nYou had BETTER BE RIGHT that this comment is genuinely necessary.\n\nComments are a last resort, not a habit. Almost every comment you reach for is a sign\nthe code should be clearer instead. Before a human is pulled in, ask whether a better\nname, a smaller function, or a test would make the comment redundant. ONLY if you are\ncertain this one line earns its keep should you proceed to the confirm step below."
28120
28142
  )
28121
28143
  );
28122
28144
  const { delivered, node } = await issuePin(file, lineNumber, validation.text);
28123
28145
  if (!delivered) {
28124
28146
  console.error(
28125
- chalk123.red(
28147
+ chalk124.red(
28126
28148
  "Could not deliver the confirmation pin via notification.\nThe comment cannot be confirmed until the notification channel works."
28127
28149
  )
28128
28150
  );
@@ -28132,7 +28154,7 @@ async function codeCommentSet(file, line, text19) {
28132
28154
  console.log(
28133
28155
  `A confirmation pin was sent to your desktop notifications${node ? ` on ${node}, the node controlling this session` : ""}.
28134
28156
  To insert "${marker2} ${validation.text}" at ${file}:${lineNumber}, run in this session:
28135
- ${chalk123.cyan(" assist code-comment confirm <PIN>")}
28157
+ ${chalk124.cyan(" assist code-comment confirm <PIN>")}
28136
28158
  using the pin from that notification.`
28137
28159
  );
28138
28160
  }
@@ -28611,7 +28633,7 @@ function buildCommitMessage(subject, refs) {
28611
28633
 
28612
28634
  // src/shared/warnIfUnexpectedBranch.ts
28613
28635
  import { execSync as execSync26 } from "child_process";
28614
- import chalk124 from "chalk";
28636
+ import chalk125 from "chalk";
28615
28637
 
28616
28638
  // src/shared/upstreamBranch.ts
28617
28639
  import { execSync as execSync25 } from "child_process";
@@ -28637,7 +28659,7 @@ function warnIfUnexpectedBranch(config) {
28637
28659
  if (upstreamBranch() === expected) return;
28638
28660
  const line = "\u2500".repeat(64);
28639
28661
  console.warn(
28640
- chalk124.yellow.bold(
28662
+ chalk125.yellow.bold(
28641
28663
  [
28642
28664
  "",
28643
28665
  line,
@@ -29139,15 +29161,15 @@ function registerCommit(program) {
29139
29161
  }
29140
29162
 
29141
29163
  // src/commands/complexity/analyze.ts
29142
- import chalk133 from "chalk";
29164
+ import chalk134 from "chalk";
29143
29165
 
29144
29166
  // src/commands/complexity/cyclomatic.ts
29145
- import chalk126 from "chalk";
29167
+ import chalk127 from "chalk";
29146
29168
 
29147
29169
  // src/commands/complexity/shared.ts
29148
29170
  import fs27 from "fs";
29149
29171
  import path41 from "path";
29150
- import chalk125 from "chalk";
29172
+ import chalk126 from "chalk";
29151
29173
  import ts5 from "typescript";
29152
29174
 
29153
29175
  // src/commands/complexity/findSourceFiles.ts
@@ -29403,7 +29425,7 @@ function createSourceFromFile(filePath) {
29403
29425
  function withSourceFiles(pattern2, callback, extraIgnore = []) {
29404
29426
  const files = findSourceFiles(pattern2, ".", extraIgnore);
29405
29427
  if (files.length === 0) {
29406
- console.log(chalk125.yellow("No files found matching pattern"));
29428
+ console.log(chalk126.yellow("No files found matching pattern"));
29407
29429
  return void 0;
29408
29430
  }
29409
29431
  return callback(files);
@@ -29436,11 +29458,11 @@ async function cyclomatic(pattern2 = "**/*.ts", options2 = {}) {
29436
29458
  results.sort((a, b) => b.complexity - a.complexity);
29437
29459
  for (const { file, name: name2, complexity } of results) {
29438
29460
  const exceedsThreshold = options2.threshold !== void 0 && complexity > options2.threshold;
29439
- const color = exceedsThreshold ? chalk126.red : chalk126.white;
29440
- console.log(`${color(`${file}:${name2}`)} \u2192 ${chalk126.cyan(complexity)}`);
29461
+ const color = exceedsThreshold ? chalk127.red : chalk127.white;
29462
+ console.log(`${color(`${file}:${name2}`)} \u2192 ${chalk127.cyan(complexity)}`);
29441
29463
  }
29442
29464
  console.log(
29443
- chalk126.dim(
29465
+ chalk127.dim(
29444
29466
  `
29445
29467
  Analyzed ${results.length} functions across ${files.length} files`
29446
29468
  )
@@ -29452,7 +29474,7 @@ Analyzed ${results.length} functions across ${files.length} files`
29452
29474
  }
29453
29475
 
29454
29476
  // src/commands/complexity/halstead.ts
29455
- import chalk127 from "chalk";
29477
+ import chalk128 from "chalk";
29456
29478
  async function halstead(pattern2 = "**/*.ts", options2 = {}) {
29457
29479
  withSourceFiles(pattern2, (files) => {
29458
29480
  const results = [];
@@ -29467,13 +29489,13 @@ async function halstead(pattern2 = "**/*.ts", options2 = {}) {
29467
29489
  results.sort((a, b) => b.metrics.effort - a.metrics.effort);
29468
29490
  for (const { file, name: name2, metrics } of results) {
29469
29491
  const exceedsThreshold = options2.threshold !== void 0 && metrics.volume > options2.threshold;
29470
- const color = exceedsThreshold ? chalk127.red : chalk127.white;
29492
+ const color = exceedsThreshold ? chalk128.red : chalk128.white;
29471
29493
  console.log(
29472
- `${color(`${file}:${name2}`)} \u2192 volume: ${chalk127.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk127.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk127.magenta(metrics.effort.toFixed(1))}`
29494
+ `${color(`${file}:${name2}`)} \u2192 volume: ${chalk128.cyan(metrics.volume.toFixed(1))}, difficulty: ${chalk128.yellow(metrics.difficulty.toFixed(1))}, effort: ${chalk128.magenta(metrics.effort.toFixed(1))}`
29473
29495
  );
29474
29496
  }
29475
29497
  console.log(
29476
- chalk127.dim(
29498
+ chalk128.dim(
29477
29499
  `
29478
29500
  Analyzed ${results.length} functions across ${files.length} files`
29479
29501
  )
@@ -29559,15 +29581,15 @@ function collectFileMetrics(files) {
29559
29581
  }
29560
29582
 
29561
29583
  // src/commands/complexity/maintainability/displayMaintainabilityResults.ts
29562
- import chalk131 from "chalk";
29584
+ import chalk132 from "chalk";
29563
29585
 
29564
29586
  // src/commands/complexity/maintainability/formatResultLine.ts
29565
- import chalk128 from "chalk";
29587
+ import chalk129 from "chalk";
29566
29588
  function formatResultLine(entry, failing) {
29567
29589
  const { file, avgMaintainability, minMaintainability, override } = entry;
29568
- const name2 = failing ? chalk128.red(file) : chalk128.white(file);
29569
- const suffix = override !== void 0 ? chalk128.magenta(` (override: ${override})`) : "";
29570
- return `${name2} \u2192 avg: ${chalk128.cyan(avgMaintainability.toFixed(1))}, min: ${chalk128.yellow(minMaintainability.toFixed(1))}${suffix}`;
29590
+ const name2 = failing ? chalk129.red(file) : chalk129.white(file);
29591
+ const suffix = override !== void 0 ? chalk129.magenta(` (override: ${override})`) : "";
29592
+ return `${name2} \u2192 avg: ${chalk129.cyan(avgMaintainability.toFixed(1))}, min: ${chalk129.yellow(minMaintainability.toFixed(1))}${suffix}`;
29571
29593
  }
29572
29594
 
29573
29595
  // src/commands/complexity/maintainability/getMaintainabilityGitState.ts
@@ -29618,38 +29640,38 @@ function getMaintainabilityGitState() {
29618
29640
 
29619
29641
  // src/commands/complexity/maintainability/printMaintainabilityFailure.ts
29620
29642
  import path43 from "path";
29621
- import chalk129 from "chalk";
29643
+ import chalk130 from "chalk";
29622
29644
  var extractTemplate = "assist refactor extract <file> <functionName> <destination> --apply";
29623
29645
  function remediationLine(entry) {
29624
- return ` ${chalk129.bold(entry.file)}
29646
+ return ` ${chalk130.bold(entry.file)}
29625
29647
  Pick a responsibility and extract it:
29626
- ${chalk129.cyan(extractTemplate)}`;
29648
+ ${chalk130.cyan(extractTemplate)}`;
29627
29649
  }
29628
29650
  function cheatLine(entry, gitState) {
29629
29651
  const shrank = gitState.shrunkFiles.has(path43.resolve(entry.file));
29630
29652
  if (!shrank || gitState.newFileCreated) return "";
29631
29653
  return `
29632
- ${chalk129.red("\u2717 You shrank existing lines in this file without creating a new file. That cannot clear the gate \u2014 extract a responsibility to a new file.")}`;
29654
+ ${chalk130.red("\u2717 You shrank existing lines in this file without creating a new file. That cannot clear the gate \u2014 extract a responsibility to a new file.")}`;
29633
29655
  }
29634
29656
  function printMaintainabilityFailure(failing, gitState) {
29635
29657
  const blocks = failing.map((entry) => `${remediationLine(entry)}${cheatLine(entry, gitState)}`).join("\n");
29636
29658
  console.error(
29637
- chalk129.red(
29659
+ chalk130.red(
29638
29660
  `
29639
29661
  Fail: ${failing.length} file(s) below threshold \u2192 extract a responsibility to a new file.
29640
29662
 
29641
29663
  ${blocks}
29642
29664
 
29643
- ${chalk129.bold("Diagnose and fix one file at a time.")} Only a new file (Write) or 'assist refactor extract' clears this gate \u2014 editing the existing lines does not.`
29665
+ ${chalk130.bold("Diagnose and fix one file at a time.")} Only a new file (Write) or 'assist refactor extract' clears this gate \u2014 editing the existing lines does not.`
29644
29666
  )
29645
29667
  );
29646
29668
  }
29647
29669
 
29648
29670
  // src/commands/complexity/maintainability/printMaintainabilityFormula.ts
29649
- import chalk130 from "chalk";
29671
+ import chalk131 from "chalk";
29650
29672
  var MI_FORMULA = "171 - 5.2*ln(HalsteadVolume) - 0.23*CyclomaticComplexity - 16.2*ln(SLOC), clamped 0-100";
29651
29673
  function printMaintainabilityFormula() {
29652
- console.log(chalk130.dim(MI_FORMULA));
29674
+ console.log(chalk131.dim(MI_FORMULA));
29653
29675
  }
29654
29676
 
29655
29677
  // src/commands/complexity/maintainability/displayMaintainabilityResults.ts
@@ -29658,7 +29680,7 @@ function displayMaintainabilityResults(results, threshold, gitState = getMaintai
29658
29680
  if (!gating) {
29659
29681
  printMaintainabilityFormula();
29660
29682
  for (const entry of results) console.log(formatResultLine(entry, false));
29661
- console.log(chalk131.dim(`
29683
+ console.log(chalk132.dim(`
29662
29684
  Analyzed ${results.length} files`));
29663
29685
  return;
29664
29686
  }
@@ -29667,14 +29689,14 @@ Analyzed ${results.length} files`));
29667
29689
  return limit !== void 0 && r.minMaintainability < limit;
29668
29690
  });
29669
29691
  if (failing.length === 0) {
29670
- console.log(chalk131.green("All files pass maintainability threshold"));
29692
+ console.log(chalk132.green("All files pass maintainability threshold"));
29671
29693
  }
29672
29694
  const passingOverrides = results.filter(
29673
29695
  (r) => r.override !== void 0 && !failing.includes(r)
29674
29696
  );
29675
29697
  for (const entry of passingOverrides)
29676
29698
  console.log(formatResultLine(entry, false));
29677
- console.log(chalk131.dim(`
29699
+ console.log(chalk132.dim(`
29678
29700
  Analyzed ${results.length} files`));
29679
29701
  if (failing.length > 0) {
29680
29702
  printMaintainabilityFailure(failing, gitState);
@@ -29697,7 +29719,7 @@ async function maintainability(pattern2 = "**/*.ts", options2 = {}) {
29697
29719
 
29698
29720
  // src/commands/complexity/sloc.ts
29699
29721
  import fs29 from "fs";
29700
- import chalk132 from "chalk";
29722
+ import chalk133 from "chalk";
29701
29723
  async function sloc(pattern2 = "**/*.ts", options2 = {}) {
29702
29724
  withSourceFiles(pattern2, (files) => {
29703
29725
  const results = [];
@@ -29713,12 +29735,12 @@ async function sloc(pattern2 = "**/*.ts", options2 = {}) {
29713
29735
  results.sort((a, b) => b.lines - a.lines);
29714
29736
  for (const { file, lines } of results) {
29715
29737
  const exceedsThreshold = options2.threshold !== void 0 && lines > options2.threshold;
29716
- const color = exceedsThreshold ? chalk132.red : chalk132.white;
29717
- console.log(`${color(file)} \u2192 ${chalk132.cyan(lines)} lines`);
29738
+ const color = exceedsThreshold ? chalk133.red : chalk133.white;
29739
+ console.log(`${color(file)} \u2192 ${chalk133.cyan(lines)} lines`);
29718
29740
  }
29719
29741
  const total2 = results.reduce((sum3, r) => sum3 + r.lines, 0);
29720
29742
  console.log(
29721
- chalk132.dim(`
29743
+ chalk133.dim(`
29722
29744
  Total: ${total2} lines across ${files.length} files`)
29723
29745
  );
29724
29746
  if (hasViolation) {
@@ -29732,25 +29754,25 @@ async function analyze(pattern2) {
29732
29754
  const searchPattern = pattern2.includes("*") || pattern2.includes("/") ? pattern2 : `**/${pattern2}`;
29733
29755
  const files = findSourceFiles(searchPattern);
29734
29756
  if (files.length === 0) {
29735
- console.log(chalk133.yellow("No files found matching pattern"));
29757
+ console.log(chalk134.yellow("No files found matching pattern"));
29736
29758
  return;
29737
29759
  }
29738
29760
  if (files.length === 1) {
29739
29761
  const file = files[0];
29740
- console.log(chalk133.bold.underline("SLOC"));
29762
+ console.log(chalk134.bold.underline("SLOC"));
29741
29763
  await sloc(file);
29742
29764
  console.log();
29743
- console.log(chalk133.bold.underline("Cyclomatic Complexity"));
29765
+ console.log(chalk134.bold.underline("Cyclomatic Complexity"));
29744
29766
  await cyclomatic(file);
29745
29767
  console.log();
29746
- console.log(chalk133.bold.underline("Halstead Metrics"));
29768
+ console.log(chalk134.bold.underline("Halstead Metrics"));
29747
29769
  await halstead(file);
29748
29770
  console.log();
29749
- console.log(chalk133.bold.underline("Maintainability Index"));
29771
+ console.log(chalk134.bold.underline("Maintainability Index"));
29750
29772
  await maintainability(file);
29751
29773
  console.log();
29752
29774
  console.log(
29753
- chalk133.dim(
29775
+ chalk134.dim(
29754
29776
  "To improve the maintainability index, extract functions and logic out of this file into separate, smaller modules. Collapsing whitespace or removing comments is not the goal."
29755
29777
  )
29756
29778
  );
@@ -29785,7 +29807,7 @@ function registerComplexity(program) {
29785
29807
  }
29786
29808
 
29787
29809
  // src/commands/configList.ts
29788
- import chalk134 from "chalk";
29810
+ import chalk135 from "chalk";
29789
29811
  import { stringify as stringifyYaml2 } from "yaml";
29790
29812
  async function configList() {
29791
29813
  const config = maskConfigSecrets(
@@ -29793,7 +29815,7 @@ async function configList() {
29793
29815
  describeConfigNode(assistConfigSchema)
29794
29816
  );
29795
29817
  console.log(
29796
- chalk134.dim(
29818
+ chalk135.dim(
29797
29819
  "# Only the keys that are set; run assist config keys for every key and its default"
29798
29820
  )
29799
29821
  );
@@ -29801,7 +29823,7 @@ async function configList() {
29801
29823
  }
29802
29824
 
29803
29825
  // src/commands/config/configGet.ts
29804
- import chalk135 from "chalk";
29826
+ import chalk136 from "chalk";
29805
29827
 
29806
29828
  // src/commands/config/formatConfigDefault.ts
29807
29829
  function formatConfigDefault(leaf) {
@@ -29839,7 +29861,7 @@ function printUnset(key) {
29839
29861
  (candidate) => candidate.key === key
29840
29862
  );
29841
29863
  if (!leaf) {
29842
- console.error(chalk135.red(`Key "${key}" is not set`));
29864
+ console.error(chalk136.red(`Key "${key}" is not set`));
29843
29865
  process.exit(1);
29844
29866
  }
29845
29867
  console.log(
@@ -29847,16 +29869,16 @@ function printUnset(key) {
29847
29869
  );
29848
29870
  const help = configHelpForKey(key);
29849
29871
  if (help) console.log(`${help.note}
29850
- ${chalk135.green(help.setter)}`);
29872
+ ${chalk136.green(help.setter)}`);
29851
29873
  }
29852
29874
 
29853
29875
  // src/commands/config/configImportRepos.ts
29854
- import chalk139 from "chalk";
29876
+ import chalk140 from "chalk";
29855
29877
 
29856
29878
  // src/commands/config/exitWithConfigErrors.ts
29857
- import chalk136 from "chalk";
29879
+ import chalk137 from "chalk";
29858
29880
  function exitWithConfigErrors(errors) {
29859
- for (const error of errors) console.error(chalk136.red(error));
29881
+ for (const error of errors) console.error(chalk137.red(error));
29860
29882
  process.exit(1);
29861
29883
  }
29862
29884
 
@@ -29912,27 +29934,27 @@ function isPlainObject5(value) {
29912
29934
  }
29913
29935
 
29914
29936
  // src/commands/config/printRepoConfigImportPlan.ts
29915
- import chalk138 from "chalk";
29937
+ import chalk139 from "chalk";
29916
29938
 
29917
29939
  // src/commands/config/formatConfigLeafChange.ts
29918
- import chalk137 from "chalk";
29940
+ import chalk138 from "chalk";
29919
29941
  function show2(key, value) {
29920
29942
  return JSON.stringify(maskConfigKeySecrets(key, value));
29921
29943
  }
29922
29944
  function formatConfigLeafChange(change) {
29923
29945
  const to = show2(change.key, change.to);
29924
- return "from" in change ? chalk137.yellow(
29946
+ return "from" in change ? chalk138.yellow(
29925
29947
  ` ~ ${change.key}: ${show2(change.key, change.from)} \u2192 ${to}`
29926
- ) : chalk137.green(` + ${change.key}: ${to}`);
29948
+ ) : chalk138.green(` + ${change.key}: ${to}`);
29927
29949
  }
29928
29950
 
29929
29951
  // src/commands/config/printRepoConfigImportPlan.ts
29930
29952
  function printRepoConfigImportPlan(plans) {
29931
29953
  for (const plan2 of plans) {
29932
- const target = plan2.dbKey === plan2.ymlKey ? "" : chalk138.dim(` \u2192 ${plan2.dbKey}`);
29933
- console.log(chalk138.bold(`repos.${plan2.ymlKey}${target}`));
29954
+ const target = plan2.dbKey === plan2.ymlKey ? "" : chalk139.dim(` \u2192 ${plan2.dbKey}`);
29955
+ console.log(chalk139.bold(`repos.${plan2.ymlKey}${target}`));
29934
29956
  if (plan2.changes.length === 0)
29935
- console.log(chalk138.dim(" already in the shared db"));
29957
+ console.log(chalk139.dim(" already in the shared db"));
29936
29958
  for (const change of plan2.changes)
29937
29959
  console.log(formatConfigLeafChange(change));
29938
29960
  }
@@ -29965,7 +29987,7 @@ async function configImportRepos() {
29965
29987
  saveGlobalConfig(rest);
29966
29988
  const keys = changed.reduce((n, plan2) => n + plan2.changes.length, 0);
29967
29989
  console.log(
29968
- chalk139.green(
29990
+ chalk140.green(
29969
29991
  `Imported ${keys} key(s) across ${changed.length} repo(s) and removed repos: from ~/.assist.yml`
29970
29992
  )
29971
29993
  );
@@ -29975,7 +29997,7 @@ function isPlainObject6(value) {
29975
29997
  }
29976
29998
 
29977
29999
  // src/commands/config/configImportUser.ts
29978
- import chalk141 from "chalk";
30000
+ import chalk142 from "chalk";
29979
30001
 
29980
30002
  // src/commands/config/planValue.ts
29981
30003
  import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
@@ -30037,14 +30059,14 @@ function planUserConfigImport(ymlRaw, userDb, keys) {
30037
30059
  }
30038
30060
 
30039
30061
  // src/commands/config/printUserConfigImportPlan.ts
30040
- import chalk140 from "chalk";
30062
+ import chalk141 from "chalk";
30041
30063
  function printUserConfigImportPlan(plan2) {
30042
- console.log(chalk140.bold("~/.assist.yml \u2192 user (db)"));
30064
+ console.log(chalk141.bold("~/.assist.yml \u2192 user (db)"));
30043
30065
  for (const key of plan2.missing)
30044
- console.log(chalk140.dim(` ${key}: not in ~/.assist.yml`));
30066
+ console.log(chalk141.dim(` ${key}: not in ~/.assist.yml`));
30045
30067
  if (plan2.imported.length > 0 && plan2.changes.length === 0)
30046
30068
  console.log(
30047
- chalk140.dim(` ${plan2.imported.join(", ")}: already in user (db)`)
30069
+ chalk141.dim(` ${plan2.imported.join(", ")}: already in user (db)`)
30048
30070
  );
30049
30071
  for (const change of plan2.changes)
30050
30072
  console.log(formatConfigLeafChange(change));
@@ -30084,24 +30106,24 @@ async function configImportUser(keys) {
30084
30106
  )
30085
30107
  );
30086
30108
  console.log(
30087
- chalk141.green(
30109
+ chalk142.green(
30088
30110
  `Imported ${plan2.imported.join(", ")} into user (db) and removed it from ~/.assist.yml`
30089
30111
  )
30090
30112
  );
30091
30113
  }
30092
30114
 
30093
30115
  // src/commands/config/configKeys.ts
30094
- import chalk142 from "chalk";
30116
+ import chalk143 from "chalk";
30095
30117
  function configKeys(filter) {
30096
30118
  const leaves2 = describeConfigLeaves(assistConfigSchema);
30097
30119
  const matches = filter ? leaves2.filter(matching(filter)) : leaves2;
30098
30120
  if (matches.length === 0) {
30099
- console.error(chalk142.red(`No config key matches "${filter}"`));
30121
+ console.error(chalk143.red(`No config key matches "${filter}"`));
30100
30122
  process.exit(1);
30101
30123
  }
30102
30124
  console.log(headline(matches.length, leaves2.length, filter));
30103
30125
  console.log(
30104
- chalk142.dim(
30126
+ chalk143.dim(
30105
30127
  "Defaults come from the schema; assist config list shows what is set."
30106
30128
  )
30107
30129
  );
@@ -30117,13 +30139,13 @@ function matching(filter) {
30117
30139
  return (leaf) => leaf.key.toLowerCase().includes(needle);
30118
30140
  }
30119
30141
  function headline(shown, total2, filter) {
30120
- return filter ? chalk142.bold(`${shown} of ${total2} config keys matching "${filter}"`) : chalk142.bold(`${total2} config keys`);
30142
+ return filter ? chalk143.bold(`${shown} of ${total2} config keys matching "${filter}"`) : chalk143.bold(`${total2} config keys`);
30121
30143
  }
30122
30144
  function formatLeaf(leaf, help) {
30123
30145
  const meta = [typeText(leaf), `default: ${formatConfigDefault(leaf)}`];
30124
30146
  if (leaf.secret) meta.push("secret");
30125
- const lines = [`${chalk142.cyan(leaf.key)} ${chalk142.dim(meta.join(" "))}`];
30126
- if (help) lines.push(` ${help.note}`, ` ${chalk142.green(help.setter)}`);
30147
+ const lines = [`${chalk143.cyan(leaf.key)} ${chalk143.dim(meta.join(" "))}`];
30148
+ if (help) lines.push(` ${help.note}`, ` ${chalk143.green(help.setter)}`);
30127
30149
  return lines;
30128
30150
  }
30129
30151
  function typeText(leaf) {
@@ -30134,7 +30156,7 @@ function typeText(leaf) {
30134
30156
  }
30135
30157
 
30136
30158
  // src/commands/config/configSet.ts
30137
- import chalk145 from "chalk";
30159
+ import chalk146 from "chalk";
30138
30160
 
30139
30161
  // src/commands/config/coerceCliConfigValue.ts
30140
30162
  function coerceCliConfigValue(key, raw) {
@@ -30176,19 +30198,19 @@ function resolveRepoTarget(key, value, repo) {
30176
30198
  }
30177
30199
 
30178
30200
  // src/commands/config/setDbBackedConfigKey.ts
30179
- import chalk143 from "chalk";
30201
+ import chalk144 from "chalk";
30180
30202
  async function setDbBackedConfigKey(key, value, useRepo) {
30181
30203
  if (useRepo) exitWithConfigErrors([dbBackedRepoError(key)]);
30182
30204
  await dbBackedConfigKeys[key].write(await getDb(), value);
30183
- console.log(chalk143.green(`Set ${key} = ${JSON.stringify(value)} (user (db))`));
30205
+ console.log(chalk144.green(`Set ${key} = ${JSON.stringify(value)} (user (db))`));
30184
30206
  }
30185
30207
 
30186
30208
  // src/commands/config/setFileConfigKey.ts
30187
- import chalk144 from "chalk";
30209
+ import chalk145 from "chalk";
30188
30210
  async function setFileConfigKey({ key, useRepo, repoName, node, user }, coerced) {
30189
30211
  const target = useRepo ? `${configScopeNames.repo}: ${await applyRepoOrExit(key, coerced, repoName)}` : user ? await applyUserOrExit(key, coerced) : applyOrExit(key, coerced, node);
30190
30212
  const shown = JSON.stringify(maskConfigKeySecrets(key, coerced));
30191
- console.log(chalk144.green(`Set ${key} = ${shown} (${target})`));
30213
+ console.log(chalk145.green(`Set ${key} = ${shown} (${target})`));
30192
30214
  }
30193
30215
  function applyOrExit(key, coerced, node) {
30194
30216
  const result = applyConfigSet(key, coerced, node);
@@ -30224,7 +30246,7 @@ async function configSet(key, value, options2 = {}) {
30224
30246
  if (scopeError) exitWithConfigErrors([scopeError]);
30225
30247
  const resolved = resolveRepoTarget(key, value, options2.repo);
30226
30248
  if (resolved.value === void 0) {
30227
- console.error(chalk145.red(`Missing required argument for '${resolved.key}'`));
30249
+ console.error(chalk146.red(`Missing required argument for '${resolved.key}'`));
30228
30250
  process.exit(1);
30229
30251
  }
30230
30252
  const coercion = coerceCliConfigValue(resolved.key, resolved.value);
@@ -30242,7 +30264,7 @@ async function configSet(key, value, options2 = {}) {
30242
30264
  }
30243
30265
 
30244
30266
  // src/commands/config/configUnset.ts
30245
- import chalk148 from "chalk";
30267
+ import chalk149 from "chalk";
30246
30268
 
30247
30269
  // src/commands/config/resolveRepoUnsetTarget.ts
30248
30270
  function resolveRepoUnsetTarget(key, repo) {
@@ -30255,17 +30277,17 @@ function resolveRepoUnsetTarget(key, repo) {
30255
30277
  }
30256
30278
 
30257
30279
  // src/commands/config/unsetDbBackedConfigKey.ts
30258
- import chalk146 from "chalk";
30280
+ import chalk147 from "chalk";
30259
30281
  async function unsetDbBackedConfigKey(key, useRepo) {
30260
30282
  if (useRepo) exitWithConfigErrors([dbBackedRepoError(key)]);
30261
30283
  const removed = await dbBackedConfigKeys[key].unset(await getDb());
30262
30284
  console.log(
30263
- removed ? chalk146.green(`Unset ${key} (user (db))`) : chalk146.yellow(`${key} is not set in user (db)`)
30285
+ removed ? chalk147.green(`Unset ${key} (user (db))`) : chalk147.yellow(`${key} is not set in user (db)`)
30264
30286
  );
30265
30287
  }
30266
30288
 
30267
30289
  // src/commands/config/unsetFileConfigKey.ts
30268
- import chalk147 from "chalk";
30290
+ import chalk148 from "chalk";
30269
30291
  async function unsetFileConfigKey({
30270
30292
  key,
30271
30293
  useRepo,
@@ -30276,10 +30298,10 @@ async function unsetFileConfigKey({
30276
30298
  const result = useRepo ? await applySharedRepoConfigUnset(key, repoName) : user ? await applyUserConfigUnset(key) : applyConfigUnset(key, node);
30277
30299
  if (!result.ok) exitWithConfigErrors(result.errors);
30278
30300
  if (!result.removed) {
30279
- console.log(chalk147.yellow(`${key} is not set in ${targetLabel(result)}`));
30301
+ console.log(chalk148.yellow(`${key} is not set in ${targetLabel(result)}`));
30280
30302
  return;
30281
30303
  }
30282
- console.log(chalk147.green(`Unset ${key} (${targetLabel(result)})`));
30304
+ console.log(chalk148.green(`Unset ${key} (${targetLabel(result)})`));
30283
30305
  }
30284
30306
  function targetLabel(result) {
30285
30307
  if (result.target === "repo")
@@ -30293,7 +30315,7 @@ async function configUnset(key, options2 = {}) {
30293
30315
  if (scopeError) exitWithConfigErrors([scopeError]);
30294
30316
  const resolved = resolveRepoUnsetTarget(key, options2.repo);
30295
30317
  if (resolved.key === void 0) {
30296
- console.error(chalk148.red("Missing required argument 'key'"));
30318
+ console.error(chalk149.red("Missing required argument 'key'"));
30297
30319
  process.exit(1);
30298
30320
  return;
30299
30321
  }
@@ -30351,7 +30373,7 @@ function registerConfig(program) {
30351
30373
  }
30352
30374
 
30353
30375
  // src/commands/browser/browserInspect.ts
30354
- import chalk150 from "chalk";
30376
+ import chalk151 from "chalk";
30355
30377
 
30356
30378
  // src/commands/browser/formatInspectMatches.ts
30357
30379
  function formatInspectMatches({ matches, total: total2 }, query) {
@@ -30368,7 +30390,7 @@ function formatInspectMatches({ matches, total: total2 }, query) {
30368
30390
  }
30369
30391
 
30370
30392
  // src/commands/browser/requestTab.ts
30371
- import chalk149 from "chalk";
30393
+ import chalk150 from "chalk";
30372
30394
 
30373
30395
  // src/commands/browser/requestBrowser.ts
30374
30396
  var CLI_TIMEOUT_MS = 5e4;
@@ -30401,7 +30423,7 @@ async function requestBrowser(server, request) {
30401
30423
 
30402
30424
  // src/commands/browser/requestTab.ts
30403
30425
  function fail6(message4) {
30404
- console.error(chalk149.red(`Error: ${message4}`));
30426
+ console.error(chalk150.red(`Error: ${message4}`));
30405
30427
  process.exit(1);
30406
30428
  }
30407
30429
  async function requestTab(server, request) {
@@ -30420,7 +30442,7 @@ async function requestTab(server, request) {
30420
30442
  async function browserInspect(selector, options2) {
30421
30443
  if (!selector === !options2.text) {
30422
30444
  console.error(
30423
- chalk150.red("Error: pass either a <selector> or --text <text>, not both")
30445
+ chalk151.red("Error: pass either a <selector> or --text <text>, not both")
30424
30446
  );
30425
30447
  process.exit(1);
30426
30448
  }
@@ -30436,7 +30458,7 @@ async function browserInspect(selector, options2) {
30436
30458
 
30437
30459
  // src/commands/browser/browserRun.ts
30438
30460
  import { readFileSync as readFileSync45 } from "fs";
30439
- import chalk151 from "chalk";
30461
+ import chalk152 from "chalk";
30440
30462
 
30441
30463
  // src/commands/browser/formatRunOutcome.ts
30442
30464
  function formatRunOutcome(run5) {
@@ -30458,7 +30480,7 @@ async function browserRun(options2) {
30458
30480
  code = readFileSync45(options2.file, "utf8");
30459
30481
  } catch (error) {
30460
30482
  console.error(
30461
- chalk151.red(
30483
+ chalk152.red(
30462
30484
  `Error: cannot read ${options2.file}: ${error.message}`
30463
30485
  )
30464
30486
  );
@@ -30475,7 +30497,7 @@ async function browserRun(options2) {
30475
30497
  console.log(message4);
30476
30498
  return;
30477
30499
  }
30478
- console.error(chalk151.red(message4));
30500
+ console.error(chalk152.red(message4));
30479
30501
  process.exit(1);
30480
30502
  }
30481
30503
 
@@ -30542,7 +30564,7 @@ function parseTopCount(value) {
30542
30564
  }
30543
30565
 
30544
30566
  // src/commands/browser/browserConsole.ts
30545
- import chalk152 from "chalk";
30567
+ import chalk153 from "chalk";
30546
30568
 
30547
30569
  // src/commands/browser/formatConsoleEntries.ts
30548
30570
  var pad = (value, width2 = 2) => String(value).padStart(width2, "0");
@@ -30570,7 +30592,7 @@ function formatConsoleEntries({
30570
30592
  // src/commands/browser/browserConsole.ts
30571
30593
  async function browserConsole(options2) {
30572
30594
  if (options2.all && options2.url) {
30573
- console.error(chalk152.red("Error: pass either --url or --all, not both"));
30595
+ console.error(chalk153.red("Error: pass either --url or --all, not both"));
30574
30596
  process.exit(1);
30575
30597
  }
30576
30598
  const result = await requestTab(options2.server, {
@@ -30660,7 +30682,7 @@ function registerBrowser(program) {
30660
30682
 
30661
30683
  // src/commands/extension/extension.ts
30662
30684
  import { cp } from "fs/promises";
30663
- import chalk153 from "chalk";
30685
+ import chalk154 from "chalk";
30664
30686
  var WSL_WINDOWS_DIR = "/mnt/c/tools/extension";
30665
30687
  var WSL_WINDOWS_PATH = String.raw`C:\tools\extension`;
30666
30688
  async function loadPath(source) {
@@ -30670,23 +30692,23 @@ async function loadPath(source) {
30670
30692
  return WSL_WINDOWS_PATH;
30671
30693
  } catch {
30672
30694
  console.log(
30673
- chalk153.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
30695
+ chalk154.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
30674
30696
  );
30675
30697
  return source;
30676
30698
  }
30677
30699
  }
30678
30700
  async function extension() {
30679
30701
  const path118 = await loadPath(extensionDir());
30680
- console.log(chalk153.bold("assist \u2014 GitHub browser extension"));
30681
- console.log(chalk153.dim(`load the unpacked extension from ${path118}`));
30702
+ console.log(chalk154.bold("assist \u2014 GitHub browser extension"));
30703
+ console.log(chalk154.dim(`load the unpacked extension from ${path118}`));
30682
30704
  }
30683
30705
 
30684
30706
  // src/commands/extension/printExtensionUrl.ts
30685
- import chalk154 from "chalk";
30707
+ import chalk155 from "chalk";
30686
30708
  async function printExtensionUrl() {
30687
30709
  const { updateUrl, latest: latest2 } = await fetchLatestSignedExtension();
30688
30710
  if (!latest2) {
30689
- console.log(chalk154.red(`no signed build found in ${updateUrl}`));
30711
+ console.log(chalk155.red(`no signed build found in ${updateUrl}`));
30690
30712
  process.exitCode = 1;
30691
30713
  return;
30692
30714
  }
@@ -30697,7 +30719,7 @@ async function printExtensionUrl() {
30697
30719
  import { rm as rm2 } from "fs/promises";
30698
30720
  import { homedir as homedir24, tmpdir as tmpdir4 } from "os";
30699
30721
  import { join as join76 } from "path";
30700
- import chalk156 from "chalk";
30722
+ import chalk157 from "chalk";
30701
30723
 
30702
30724
  // src/commands/extension/copySignedXpi.ts
30703
30725
  import { copyFile } from "fs/promises";
@@ -30722,7 +30744,7 @@ async function findSignedXpi(dir) {
30722
30744
 
30723
30745
  // src/commands/extension/signedAddonInstallPath.ts
30724
30746
  import { cp as cp2 } from "fs/promises";
30725
- import chalk155 from "chalk";
30747
+ import chalk156 from "chalk";
30726
30748
  var WSL_WINDOWS_XPI = "/mnt/c/tools/assist-extension.xpi";
30727
30749
  var WSL_WINDOWS_PATH2 = String.raw`C:\tools\assist-extension.xpi`;
30728
30750
  async function signedAddonInstallPath(xpi) {
@@ -30732,7 +30754,7 @@ async function signedAddonInstallPath(xpi) {
30732
30754
  return WSL_WINDOWS_PATH2;
30733
30755
  } catch {
30734
30756
  console.log(
30735
- chalk155.yellow(`could not copy the add-on to ${WSL_WINDOWS_PATH2}`)
30757
+ chalk156.yellow(`could not copy the add-on to ${WSL_WINDOWS_PATH2}`)
30736
30758
  );
30737
30759
  return xpi;
30738
30760
  }
@@ -30825,15 +30847,15 @@ async function signExtension() {
30825
30847
  const source = extensionDir();
30826
30848
  const problem = signPreflightProblem(source);
30827
30849
  if (problem) {
30828
- console.log(chalk156.red(problem.message));
30829
- console.log(chalk156.dim(problem.hint));
30850
+ console.log(chalk157.red(problem.message));
30851
+ console.log(chalk157.dim(problem.hint));
30830
30852
  process.exitCode = 1;
30831
30853
  return;
30832
30854
  }
30833
30855
  const { version: version2 } = package_default;
30834
30856
  await stageExtension(source, STAGING_DIR, version2);
30835
30857
  await rm2(ARTIFACTS_DIR, { recursive: true, force: true });
30836
- console.log(chalk156.bold(`signing version ${version2} for self-distribution`));
30858
+ console.log(chalk157.bold(`signing version ${version2} for self-distribution`));
30837
30859
  const { done: done2 } = spawnInherit("npx", [
30838
30860
  "--yes",
30839
30861
  "web-ext",
@@ -30843,13 +30865,13 @@ async function signExtension() {
30843
30865
  "--channel=unlisted"
30844
30866
  ]);
30845
30867
  if (await done2 !== 0) {
30846
- console.log(chalk156.red("web-ext sign failed"));
30868
+ console.log(chalk157.red("web-ext sign failed"));
30847
30869
  process.exitCode = 1;
30848
30870
  return;
30849
30871
  }
30850
30872
  const xpi = await findSignedXpi(ARTIFACTS_DIR);
30851
30873
  if (!xpi) {
30852
- console.log(chalk156.red(`web-ext wrote no .xpi into ${ARTIFACTS_DIR}`));
30874
+ console.log(chalk157.red(`web-ext wrote no .xpi into ${ARTIFACTS_DIR}`));
30853
30875
  process.exitCode = 1;
30854
30876
  return;
30855
30877
  }
@@ -30857,7 +30879,7 @@ async function signExtension() {
30857
30879
  const path118 = await signedAddonInstallPath(
30858
30880
  await copySignedXpi(xpi, ARTIFACTS_DIR)
30859
30881
  );
30860
- console.log(chalk156.dim(`install the signed add-on from ${path118}`));
30882
+ console.log(chalk157.dim(`install the signed add-on from ${path118}`));
30861
30883
  }
30862
30884
 
30863
30885
  // src/commands/registerExtension.ts
@@ -30918,11 +30940,11 @@ async function dropRetiredTables(exec3) {
30918
30940
  }
30919
30941
 
30920
30942
  // src/commands/db/reportRetiredTables.ts
30921
- import chalk157 from "chalk";
30943
+ import chalk158 from "chalk";
30922
30944
  function reportRetiredTables(tables) {
30923
30945
  for (const table of tables) {
30924
30946
  console.error(
30925
- chalk157.yellow(
30947
+ chalk158.yellow(
30926
30948
  `Retired table ${table.name} still exists (${table.rows} rows). Run \`assist db drop-retired\` to drop it.`
30927
30949
  )
30928
30950
  );
@@ -30930,40 +30952,40 @@ function reportRetiredTables(tables) {
30930
30952
  }
30931
30953
 
30932
30954
  // src/commands/db/reportMigrationStatus.ts
30933
- import chalk158 from "chalk";
30955
+ import chalk159 from "chalk";
30934
30956
  function reportApplied(applied) {
30935
30957
  if (applied.length === 0) {
30936
- console.error(chalk158.green("Database is up to date; nothing to apply."));
30958
+ console.error(chalk159.green("Database is up to date; nothing to apply."));
30937
30959
  return;
30938
30960
  }
30939
30961
  for (const migration of applied) {
30940
30962
  console.error(
30941
- chalk158.green(`Applied migration ${migration.id} (${migration.name}).`)
30963
+ chalk159.green(`Applied migration ${migration.id} (${migration.name}).`)
30942
30964
  );
30943
30965
  }
30944
30966
  }
30945
30967
  function reportMigrationStatus(status2) {
30946
30968
  if (status2.state === "in-sync") {
30947
30969
  console.error(
30948
- chalk158.green(`In sync at migration ${status2.version} (latest).`)
30970
+ chalk159.green(`In sync at migration ${status2.version} (latest).`)
30949
30971
  );
30950
30972
  return;
30951
30973
  }
30952
30974
  if (status2.state === "behind") {
30953
30975
  console.error(
30954
- chalk158.yellow(
30976
+ chalk159.yellow(
30955
30977
  `Behind: applied ${status2.applied}, build expects ${status2.expected}.`
30956
30978
  )
30957
30979
  );
30958
30980
  console.error(
30959
- chalk158.yellow(
30981
+ chalk159.yellow(
30960
30982
  `Pending: ${status2.pending.join(", ")}. Run \`assist db migrate\`.`
30961
30983
  )
30962
30984
  );
30963
30985
  return;
30964
30986
  }
30965
30987
  console.error(
30966
- chalk158.red(
30988
+ chalk159.red(
30967
30989
  `Ahead: applied ${status2.applied}, build knows ${status2.expected}. Update assist.`
30968
30990
  )
30969
30991
  );
@@ -31005,7 +31027,7 @@ function registerDb(program) {
31005
31027
 
31006
31028
  // src/commands/deploy/redirect.ts
31007
31029
  import { existsSync as existsSync64, readFileSync as readFileSync46, writeFileSync as writeFileSync33 } from "fs";
31008
- import chalk159 from "chalk";
31030
+ import chalk160 from "chalk";
31009
31031
  var TRAILING_SLASH_SCRIPT = ` <script>
31010
31032
  if (!window.location.pathname.endsWith('/')) {
31011
31033
  window.location.href = \`\${window.location.pathname}/\${window.location.search}\${window.location.hash}\`;
@@ -31014,23 +31036,23 @@ var TRAILING_SLASH_SCRIPT = ` <script>
31014
31036
  function redirect() {
31015
31037
  const indexPath = "index.html";
31016
31038
  if (!existsSync64(indexPath)) {
31017
- console.log(chalk159.yellow("No index.html found"));
31039
+ console.log(chalk160.yellow("No index.html found"));
31018
31040
  return;
31019
31041
  }
31020
31042
  const content = readFileSync46(indexPath, "utf8");
31021
31043
  if (content.includes("window.location.pathname.endsWith('/')")) {
31022
- console.log(chalk159.dim("Trailing slash script already present"));
31044
+ console.log(chalk160.dim("Trailing slash script already present"));
31023
31045
  return;
31024
31046
  }
31025
31047
  const headCloseIndex = content.indexOf("</head>");
31026
31048
  if (headCloseIndex === -1) {
31027
- console.log(chalk159.red("Could not find </head> tag in index.html"));
31049
+ console.log(chalk160.red("Could not find </head> tag in index.html"));
31028
31050
  return;
31029
31051
  }
31030
31052
  const newContent = `${content.slice(0, headCloseIndex) + TRAILING_SLASH_SCRIPT}
31031
31053
  ${content.slice(headCloseIndex)}`;
31032
31054
  writeFileSync33(indexPath, newContent);
31033
- console.log(chalk159.green("Added trailing slash redirect to index.html"));
31055
+ console.log(chalk160.green("Added trailing slash redirect to index.html"));
31034
31056
  }
31035
31057
 
31036
31058
  // src/commands/registerDeploy.ts
@@ -31083,7 +31105,7 @@ function isCompletedWeek(weekId, today) {
31083
31105
  }
31084
31106
 
31085
31107
  // src/commands/devlog/list/printWeekHeader.ts
31086
- import chalk160 from "chalk";
31108
+ import chalk161 from "chalk";
31087
31109
  function formatVersions(entry) {
31088
31110
  const { firstVersion: first, lastVersion: last } = entry;
31089
31111
  if (!first || !last) return first ?? last;
@@ -31091,19 +31113,19 @@ function formatVersions(entry) {
31091
31113
  }
31092
31114
  function describeEntry(entry) {
31093
31115
  const versions = formatVersions(entry);
31094
- const title = entry.title ?? chalk160.dim("untitled");
31095
- return versions ? `${chalk160.green(versions)} ${title}` : title;
31116
+ const title = entry.title ?? chalk161.dim("untitled");
31117
+ return versions ? `${chalk161.green(versions)} ${title}` : title;
31096
31118
  }
31097
31119
  function describeWeek({ skipped, inProgress, entry }) {
31098
- if (skipped) return chalk160.dim("skipped");
31120
+ if (skipped) return chalk161.dim("skipped");
31099
31121
  if (entry) return describeEntry(entry);
31100
- if (inProgress) return chalk160.dim("in progress");
31101
- return chalk160.red("\u26A0 dev entry missing");
31122
+ if (inProgress) return chalk161.dim("in progress");
31123
+ return chalk161.red("\u26A0 dev entry missing");
31102
31124
  }
31103
31125
  function printWeekHeader(week, state) {
31104
31126
  const { start: start2, end } = isoWeekRange(week);
31105
31127
  console.log(
31106
- `${chalk160.bold.blue(week)} ${chalk160.dim(`${start2} \u2013 ${end}`)} ${describeWeek(state)}`
31128
+ `${chalk161.bold.blue(week)} ${chalk161.dim(`${start2} \u2013 ${end}`)} ${describeWeek(state)}`
31107
31129
  );
31108
31130
  }
31109
31131
 
@@ -31149,12 +31171,12 @@ function localToday() {
31149
31171
  }
31150
31172
 
31151
31173
  // src/commands/devlog/resolveDevDir.ts
31152
- import chalk161 from "chalk";
31174
+ import chalk162 from "chalk";
31153
31175
  function resolveDevDir() {
31154
31176
  const dir = loadConfig().devlog?.dir?.trim();
31155
31177
  if (!dir) {
31156
31178
  const setter = devlogConfigHelp.find((e) => e.key === "devlog.dir")?.setter;
31157
- console.error(chalk161.red(`devlog.dir is not set. Set it with: ${setter}`));
31179
+ console.error(chalk162.red(`devlog.dir is not set. Set it with: ${setter}`));
31158
31180
  process.exit(1);
31159
31181
  }
31160
31182
  return expandTilde(dir);
@@ -31223,7 +31245,7 @@ function findTargetWeek(weeks, { lastWeek, skip: skip3, today }) {
31223
31245
  }
31224
31246
 
31225
31247
  // src/commands/devlog/shared.ts
31226
- import chalk162 from "chalk";
31248
+ import chalk163 from "chalk";
31227
31249
 
31228
31250
  // src/shared/getRepoName.ts
31229
31251
  import { existsSync as existsSync65, readFileSync as readFileSync48 } from "fs";
@@ -31251,21 +31273,21 @@ function getRepoName() {
31251
31273
  function printCommitsWithFiles(commits2, ignore3, verbose) {
31252
31274
  for (const commit2 of commits2) {
31253
31275
  console.log(
31254
- ` ${chalk162.dim(commit2.date)} ${chalk162.yellow(commit2.hash)} ${commit2.message}`
31276
+ ` ${chalk163.dim(commit2.date)} ${chalk163.yellow(commit2.hash)} ${commit2.message}`
31255
31277
  );
31256
31278
  if (verbose) {
31257
31279
  const visibleFiles = commit2.files.filter(
31258
31280
  (file) => !ignore3.some((p) => file.startsWith(p))
31259
31281
  );
31260
31282
  for (const file of visibleFiles) {
31261
- console.log(` ${chalk162.dim(file)}`);
31283
+ console.log(` ${chalk163.dim(file)}`);
31262
31284
  }
31263
31285
  }
31264
31286
  }
31265
31287
  }
31266
31288
 
31267
31289
  // src/commands/devlog/list/resolveListAfterDate.ts
31268
- import chalk163 from "chalk";
31290
+ import chalk164 from "chalk";
31269
31291
  var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
31270
31292
  function resolveListAfterDate(options2, today) {
31271
31293
  if (options2.since) return addDays(resolveSinceDate(options2.since), -1);
@@ -31277,7 +31299,7 @@ function resolveSinceDate(since) {
31277
31299
  if (isValidWeek(since)) return isoWeekRange(since).start;
31278
31300
  if (DATE_PATTERN.test(since)) return since;
31279
31301
  console.log(
31280
- chalk163.red("Invalid --since. Use YYYY-MM-DD or YYYY-Www (e.g. 2026-W33)")
31302
+ chalk164.red("Invalid --since. Use YYYY-MM-DD or YYYY-Www (e.g. 2026-W33)")
31281
31303
  );
31282
31304
  process.exit(1);
31283
31305
  }
@@ -31330,7 +31352,7 @@ function loadDevWeeks(repoName, devDir) {
31330
31352
  }
31331
31353
 
31332
31354
  // src/commands/devlog/next/displayNextEntry.ts
31333
- import chalk165 from "chalk";
31355
+ import chalk166 from "chalk";
31334
31356
 
31335
31357
  // src/commands/devlog/resolveVersionSource.ts
31336
31358
  import { execFileSync as execFileSync9 } from "child_process";
@@ -31430,17 +31452,17 @@ function withVersions(commits2, source, hasTags) {
31430
31452
  }
31431
31453
 
31432
31454
  // src/commands/devlog/next/printCommits.ts
31433
- import chalk164 from "chalk";
31455
+ import chalk165 from "chalk";
31434
31456
  function printCommits(commits2, ignore3, verbose) {
31435
31457
  for (const commit2 of commits2) {
31436
- const version2 = commit2.version ? ` ${chalk164.cyan(commit2.version)}` : "";
31458
+ const version2 = commit2.version ? ` ${chalk165.cyan(commit2.version)}` : "";
31437
31459
  console.log(
31438
- ` ${chalk164.dim(commit2.date)} ${chalk164.yellow(commit2.hash)}${version2} ${commit2.message}`
31460
+ ` ${chalk165.dim(commit2.date)} ${chalk165.yellow(commit2.hash)}${version2} ${commit2.message}`
31439
31461
  );
31440
31462
  if (!verbose) continue;
31441
31463
  for (const file of commit2.files) {
31442
31464
  if (!ignore3.some((p) => file.startsWith(p))) {
31443
- console.log(` ${chalk164.dim(file)}`);
31465
+ console.log(` ${chalk165.dim(file)}`);
31444
31466
  }
31445
31467
  }
31446
31468
  }
@@ -31455,7 +31477,7 @@ function versionRange(commits2) {
31455
31477
  return first === last ? first : `${first} \u2013 ${last}`;
31456
31478
  }
31457
31479
  function printField(label, value) {
31458
- console.log(`${chalk165.bold(`${label}:`)} ${value}`);
31480
+ console.log(`${chalk166.bold(`${label}:`)} ${value}`);
31459
31481
  }
31460
31482
  function displayNextEntry(ctx, week, commits2) {
31461
31483
  const versioned = withVersions(
@@ -31465,7 +31487,7 @@ function displayNextEntry(ctx, week, commits2) {
31465
31487
  );
31466
31488
  const { start: start2, end } = isoWeekRange(week);
31467
31489
  printField("name", ctx.repoName);
31468
- printField("week", chalk165.bold.blue(week));
31490
+ printField("week", chalk166.bold.blue(week));
31469
31491
  printField("range", `${start2} \u2013 ${end}`);
31470
31492
  const dates = commits2.map((c) => c.date).sort();
31471
31493
  if (dates.length > 0) printField("dates", `${dates[0]} \u2013 ${dates.at(-1)}`);
@@ -31475,7 +31497,7 @@ function displayNextEntry(ctx, week, commits2) {
31475
31497
  }
31476
31498
  function logNoCommits(lastWeek) {
31477
31499
  console.log(
31478
- chalk165.dim(
31500
+ chalk166.dim(
31479
31501
  lastWeek ? `No completed weeks with commits after ${lastWeek}` : "No completed weeks with commits found"
31480
31502
  )
31481
31503
  );
@@ -31508,7 +31530,7 @@ function next2(options2) {
31508
31530
 
31509
31531
  // src/commands/devlog/posted/posted.ts
31510
31532
  import { readFileSync as readFileSync49, writeFileSync as writeFileSync34 } from "fs";
31511
- import chalk166 from "chalk";
31533
+ import chalk167 from "chalk";
31512
31534
 
31513
31535
  // src/commands/devlog/posted/setFrontmatterSlack.ts
31514
31536
  var FRONTMATTER = /^---\n[\s\S]*?\n(?=---(?:\n|$))/;
@@ -31524,7 +31546,7 @@ function setFrontmatterSlack(contents, value) {
31524
31546
 
31525
31547
  // src/commands/devlog/posted/posted.ts
31526
31548
  function fail7(message4) {
31527
- console.error(chalk166.red(message4));
31549
+ console.error(chalk167.red(message4));
31528
31550
  process.exit(1);
31529
31551
  }
31530
31552
  function readEntry(path118) {
@@ -31552,11 +31574,11 @@ function posted(week, permalink, options2 = {}) {
31552
31574
  const updated2 = setFrontmatterSlack(readEntry(path118), value);
31553
31575
  if (updated2 === null) fail7(`${path118} has no YAML frontmatter`);
31554
31576
  writeFileSync34(path118, updated2);
31555
- console.log(chalk166.green(`Recorded slack: ${value} in ${path118}`));
31577
+ console.log(chalk167.green(`Recorded slack: ${value} in ${path118}`));
31556
31578
  }
31557
31579
 
31558
31580
  // src/commands/devlog/skip.ts
31559
- import chalk167 from "chalk";
31581
+ import chalk168 from "chalk";
31560
31582
  var SKIP_WEEKS_KEY = "devlog.skipWeeks";
31561
31583
  async function loadRepoSkipWeeks(cwd) {
31562
31584
  const { block } = await resolveSharedRepoBlock(await getDb(), void 0, cwd);
@@ -31565,12 +31587,12 @@ async function loadRepoSkipWeeks(cwd) {
31565
31587
  }
31566
31588
  async function skip2(week, cwd = process.cwd()) {
31567
31589
  if (!isValidWeek(week)) {
31568
- console.log(chalk167.red("Invalid week. Use YYYY-Www (e.g. 2026-W33)"));
31590
+ console.log(chalk168.red("Invalid week. Use YYYY-Www (e.g. 2026-W33)"));
31569
31591
  process.exit(1);
31570
31592
  }
31571
31593
  const existing = await loadRepoSkipWeeks(cwd);
31572
31594
  if (existing.includes(week)) {
31573
- console.log(chalk167.yellow(`${week} is already in ${SKIP_WEEKS_KEY}`));
31595
+ console.log(chalk168.yellow(`${week} is already in ${SKIP_WEEKS_KEY}`));
31574
31596
  return;
31575
31597
  }
31576
31598
  const result = await applySharedRepoConfigSet(
@@ -31580,11 +31602,11 @@ async function skip2(week, cwd = process.cwd()) {
31580
31602
  cwd
31581
31603
  );
31582
31604
  if (!result.ok) {
31583
- console.log(chalk167.red(result.errors.join("\n")));
31605
+ console.log(chalk168.red(result.errors.join("\n")));
31584
31606
  process.exit(1);
31585
31607
  }
31586
31608
  console.log(
31587
- chalk167.green(
31609
+ chalk168.green(
31588
31610
  `Added ${week} to ${SKIP_WEEKS_KEY} for repos.${result.label} (repo db)`
31589
31611
  )
31590
31612
  );
@@ -31592,7 +31614,7 @@ async function skip2(week, cwd = process.cwd()) {
31592
31614
 
31593
31615
  // src/commands/devlog/slack/slack.ts
31594
31616
  import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync37 } from "fs";
31595
- import chalk168 from "chalk";
31617
+ import chalk169 from "chalk";
31596
31618
 
31597
31619
  // src/commands/slack/postSlackMessage.ts
31598
31620
  import { mkdirSync as mkdirSync23, writeFileSync as writeFileSync36 } from "fs";
@@ -31851,7 +31873,7 @@ function unpostedWeeks(repoName, devDir) {
31851
31873
 
31852
31874
  // src/commands/devlog/slack/slack.ts
31853
31875
  function fail8(message4) {
31854
- console.error(chalk168.red(message4));
31876
+ console.error(chalk169.red(message4));
31855
31877
  process.exit(1);
31856
31878
  }
31857
31879
  function writeParts(channel, parts2) {
@@ -31901,7 +31923,7 @@ async function slack2(week) {
31901
31923
  // src/commands/devlog/write.ts
31902
31924
  import { mkdirSync as mkdirSync25, writeFileSync as writeFileSync38 } from "fs";
31903
31925
  import { dirname as dirname36 } from "path";
31904
- import chalk169 from "chalk";
31926
+ import chalk170 from "chalk";
31905
31927
 
31906
31928
  // src/commands/devlog/write/devEntryInputSchema.ts
31907
31929
  import { z as z19 } from "zod";
@@ -31979,7 +32001,7 @@ function parseInput(raw) {
31979
32001
  try {
31980
32002
  return JSON.parse(raw);
31981
32003
  } catch (error) {
31982
- console.error(chalk169.red(`Invalid JSON on stdin: ${String(error)}`));
32004
+ console.error(chalk170.red(`Invalid JSON on stdin: ${String(error)}`));
31983
32005
  process.exit(1);
31984
32006
  }
31985
32007
  }
@@ -31987,7 +32009,7 @@ async function write() {
31987
32009
  const result = devEntryInputSchema.safeParse(parseInput(await readStdin()));
31988
32010
  if (!result.success) {
31989
32011
  for (const issue of result.error.issues) {
31990
- console.error(chalk169.red(`${issue.path.join(".")}: ${issue.message}`));
32012
+ console.error(chalk170.red(`${issue.path.join(".")}: ${issue.message}`));
31991
32013
  }
31992
32014
  process.exit(1);
31993
32015
  }
@@ -31996,7 +32018,7 @@ async function write() {
31996
32018
  const path118 = devEntryPath(repoName, result.data.week, devDir);
31997
32019
  mkdirSync25(dirname36(path118), { recursive: true });
31998
32020
  writeFileSync38(path118, formatDevEntry(repoName, result.data));
31999
- console.log(chalk169.green(`Wrote ${path118}`));
32021
+ console.log(chalk170.green(`Wrote ${path118}`));
32000
32022
  }
32001
32023
 
32002
32024
  // src/commands/devlog/registerDevlogEntryCommands.ts
@@ -32056,11 +32078,11 @@ function getRepoStatus(lastPush, lastWeek, today) {
32056
32078
  }
32057
32079
 
32058
32080
  // src/commands/devlog/repos/printReposTable.ts
32059
- import chalk170 from "chalk";
32081
+ import chalk171 from "chalk";
32060
32082
  function colorStatus(status2) {
32061
- if (status2 === "missing") return chalk170.red(status2);
32062
- if (status2 === "outdated") return chalk170.yellow(status2);
32063
- return chalk170.green(status2);
32083
+ if (status2 === "missing") return chalk171.red(status2);
32084
+ if (status2 === "outdated") return chalk171.yellow(status2);
32085
+ return chalk171.green(status2);
32064
32086
  }
32065
32087
  function formatRow(row2, nameWidth) {
32066
32088
  const week = (row2.lastWeek ?? "-").padEnd(9);
@@ -32074,8 +32096,8 @@ function printReposTable(rows) {
32074
32096
  "Last Week".padEnd(9),
32075
32097
  "Status"
32076
32098
  ].join(" ");
32077
- console.log(chalk170.dim(header));
32078
- console.log(chalk170.dim("-".repeat(header.length)));
32099
+ console.log(chalk171.dim(header));
32100
+ console.log(chalk171.dim("-".repeat(header.length)));
32079
32101
  for (const row2 of rows) {
32080
32102
  console.log(formatRow(row2, nameWidth));
32081
32103
  }
@@ -32129,9 +32151,9 @@ function repos(options2) {
32129
32151
  }
32130
32152
 
32131
32153
  // src/commands/devlog/version.ts
32132
- import chalk171 from "chalk";
32154
+ import chalk172 from "chalk";
32133
32155
  function printField2(label, value) {
32134
- console.log(`${chalk171.bold(`${label}:`)} ${value ?? chalk171.dim("none")}`);
32156
+ console.log(`${chalk172.bold(`${label}:`)} ${value ?? chalk172.dim("none")}`);
32135
32157
  }
32136
32158
  function version() {
32137
32159
  const devDir = resolveDevDir();
@@ -32167,10 +32189,10 @@ function registerDevlog(program) {
32167
32189
 
32168
32190
  // src/commands/docs/docsConfirm.ts
32169
32191
  import { unlinkSync as unlinkSync10 } from "fs";
32170
- import chalk173 from "chalk";
32192
+ import chalk174 from "chalk";
32171
32193
 
32172
32194
  // src/commands/backlog/findPhaseUnlockItem.ts
32173
- import chalk172 from "chalk";
32195
+ import chalk173 from "chalk";
32174
32196
  async function findPhaseUnlockItem(itemId2, phase) {
32175
32197
  const found = await findOneItem(String(itemId2));
32176
32198
  if (!found) {
@@ -32180,7 +32202,7 @@ async function findPhaseUnlockItem(itemId2, phase) {
32180
32202
  const label = `${formatItemId(itemId2)} ${found.item.name}`;
32181
32203
  if ((found.item.currentPhase ?? 1) !== phase) {
32182
32204
  console.error(
32183
- chalk172.red(
32205
+ chalk173.red(
32184
32206
  `${label} has moved on from phase ${phase} since the unlock was requested. Nothing was approved; request a new unlock from the current phase.`
32185
32207
  )
32186
32208
  );
@@ -32229,7 +32251,7 @@ async function docsConfirm(pin2) {
32229
32251
  sweepRestrictedDir();
32230
32252
  const state = readDocsUnlockPinState(pin2);
32231
32253
  if (!state) {
32232
- console.error(chalk173.red(`No pending docs unlock for pin: ${pin2}`));
32254
+ console.error(chalk174.red(`No pending docs unlock for pin: ${pin2}`));
32233
32255
  process.exitCode = 1;
32234
32256
  return;
32235
32257
  }
@@ -32238,14 +32260,14 @@ async function docsConfirm(pin2) {
32238
32260
  if (!found) return;
32239
32261
  await recordDocsUnlock(found.orm, state.itemId, state.phase);
32240
32262
  console.log(
32241
- chalk173.green(
32263
+ chalk174.green(
32242
32264
  `Approved docs changes for phase ${state.phase} of ${found.label}. Its sessions may edit and commit docs pages and screenshots until the item moves on from that phase or is done or won't-do.`
32243
32265
  )
32244
32266
  );
32245
32267
  }
32246
32268
 
32247
32269
  // src/commands/docs/docsUnlock.ts
32248
- import chalk174 from "chalk";
32270
+ import chalk175 from "chalk";
32249
32271
 
32250
32272
  // src/commands/notify/issueUnlockPin.ts
32251
32273
  import { randomInt as randomInt2 } from "crypto";
@@ -32273,7 +32295,7 @@ async function issueUnlockPin({
32273
32295
 
32274
32296
  // src/commands/docs/docsUnlock.ts
32275
32297
  function fail9(message4) {
32276
- console.error(chalk174.red(message4));
32298
+ console.error(chalk175.red(message4));
32277
32299
  process.exitCode = 1;
32278
32300
  }
32279
32301
  async function docsUnlock() {
@@ -32306,7 +32328,7 @@ async function docsUnlock() {
32306
32328
  console.log(
32307
32329
  `A confirmation pin was sent to the user's desktop notifications${node ? ` on ${node}, the node controlling this session` : ""}.
32308
32330
  To let this phase of ${label} edit docs pages and screenshots, the user runs in this session:
32309
- ${chalk174.cyan(" assist docs confirm <PIN>")}
32331
+ ${chalk175.cyan(" assist docs confirm <PIN>")}
32310
32332
  Wait for the user to confirm before editing docs.`
32311
32333
  );
32312
32334
  }
@@ -32333,11 +32355,11 @@ function registerDocs(parent) {
32333
32355
 
32334
32356
  // src/commands/schema/schemaConfirm.ts
32335
32357
  import { unlinkSync as unlinkSync12 } from "fs";
32336
- import chalk176 from "chalk";
32358
+ import chalk177 from "chalk";
32337
32359
 
32338
32360
  // src/commands/schema/approveSchemaUnlock.ts
32339
32361
  import { mkdirSync as mkdirSync27, writeFileSync as writeFileSync40 } from "fs";
32340
- import chalk175 from "chalk";
32362
+ import chalk176 from "chalk";
32341
32363
 
32342
32364
  // src/commands/schema/schemaHarnessLabel.ts
32343
32365
  function schemaHarnessLabel(harness) {
@@ -32358,7 +32380,7 @@ async function approveItemPhase({
32358
32380
  title: `Database schema files unlocked by PIN for phase ${phase} (${schemaHarnessLabel(harness)})`
32359
32381
  });
32360
32382
  console.log(
32361
- chalk175.green(
32383
+ chalk176.green(
32362
32384
  `Approved schema changes for phase ${phase} of ${found.label} on ${schemaHarnessLabel(harness)}. Its ${schemaHarnessLabel(harness)} sessions may edit and commit database schema files until the item moves on from that phase or is done or won't-do.`
32363
32385
  )
32364
32386
  );
@@ -32370,7 +32392,7 @@ function approveSession({ harness, conversationId }) {
32370
32392
  mkdirSync27(getSchemaSessionApprovalDir(), { recursive: true });
32371
32393
  writeFileSync40(path118, JSON.stringify(scope));
32372
32394
  console.log(
32373
- chalk175.green(
32395
+ chalk176.green(
32374
32396
  `Approved schema changes for ${schemaHarnessLabel(harness)} session ${conversationId}. It may edit and commit database schema files until the session ends.`
32375
32397
  )
32376
32398
  );
@@ -32432,13 +32454,13 @@ async function schemaConfirm(pin2) {
32432
32454
  sweepRestrictedDir();
32433
32455
  const state = readSchemaUnlockPinState(pin2);
32434
32456
  if (!state) {
32435
- console.error(chalk176.red(`No pending schema unlock for pin: ${pin2}`));
32457
+ console.error(chalk177.red(`No pending schema unlock for pin: ${pin2}`));
32436
32458
  process.exitCode = 1;
32437
32459
  return;
32438
32460
  }
32439
32461
  if (scopeMismatch(state, currentExecutionIdentity())) {
32440
32462
  console.error(
32441
- chalk176.red(
32463
+ chalk177.red(
32442
32464
  "This pin was issued for a different session. Nothing was approved; confirm it in the session that requested it, or request a new unlock here."
32443
32465
  )
32444
32466
  );
@@ -32450,12 +32472,12 @@ async function schemaConfirm(pin2) {
32450
32472
  }
32451
32473
 
32452
32474
  // src/commands/schema/schemaUnlock.ts
32453
- import chalk178 from "chalk";
32475
+ import chalk179 from "chalk";
32454
32476
 
32455
32477
  // src/commands/schema/resolveSchemaUnlockScope.ts
32456
- import chalk177 from "chalk";
32478
+ import chalk178 from "chalk";
32457
32479
  function fail10(message4) {
32458
- console.error(chalk177.red(message4));
32480
+ console.error(chalk178.red(message4));
32459
32481
  process.exitCode = 1;
32460
32482
  return void 0;
32461
32483
  }
@@ -32505,7 +32527,7 @@ async function schemaUnlock() {
32505
32527
  });
32506
32528
  if (!delivered) {
32507
32529
  console.error(
32508
- chalk178.red(
32530
+ chalk179.red(
32509
32531
  "Could not deliver the confirmation pin via notification.\nSchema files cannot be unlocked until the notification channel works."
32510
32532
  )
32511
32533
  );
@@ -32515,7 +32537,7 @@ async function schemaUnlock() {
32515
32537
  console.log(
32516
32538
  `A confirmation pin was sent to the user's desktop notifications${node ? ` on ${node}, the node controlling this session` : ""}.
32517
32539
  To let ${scope.scope} change database schema files, the user runs in this session:
32518
- ${chalk178.cyan(" assist schema confirm <PIN>")}
32540
+ ${chalk179.cyan(" assist schema confirm <PIN>")}
32519
32541
  Wait for the user to confirm before changing the schema.`
32520
32542
  );
32521
32543
  }
@@ -32543,7 +32565,7 @@ function registerSchema(parent) {
32543
32565
  // src/commands/dotnet/checkBuildLocks.ts
32544
32566
  import { closeSync as closeSync6, openSync as openSync7, readdirSync as readdirSync14 } from "fs";
32545
32567
  import { join as join83 } from "path";
32546
- import chalk179 from "chalk";
32568
+ import chalk180 from "chalk";
32547
32569
  var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "packages"]);
32548
32570
  function isLockedDll(debugDir) {
32549
32571
  let files;
@@ -32590,14 +32612,14 @@ function checkBuildLocks(startDir) {
32590
32612
  const locked = findFirstLockedDll(startDir ?? getSearchRoot());
32591
32613
  if (locked) {
32592
32614
  console.error(
32593
- chalk179.red("Build output locked (is VS debugging?): ") + locked
32615
+ chalk180.red("Build output locked (is VS debugging?): ") + locked
32594
32616
  );
32595
32617
  process.exit(1);
32596
32618
  }
32597
32619
  }
32598
32620
  async function checkBuildLocksCommand() {
32599
32621
  checkBuildLocks();
32600
- console.log(chalk179.green("No build locks detected"));
32622
+ console.log(chalk180.green("No build locks detected"));
32601
32623
  }
32602
32624
 
32603
32625
  // src/commands/dotnet/buildTree.ts
@@ -32696,30 +32718,30 @@ function escapeRegex(s) {
32696
32718
  }
32697
32719
 
32698
32720
  // src/commands/dotnet/printTree.ts
32699
- import chalk180 from "chalk";
32721
+ import chalk181 from "chalk";
32700
32722
  function printNodes(nodes, prefix2) {
32701
32723
  for (let i = 0; i < nodes.length; i++) {
32702
32724
  const isLast = i === nodes.length - 1;
32703
32725
  const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
32704
32726
  const childPrefix = isLast ? " " : "\u2502 ";
32705
32727
  const isMissing = nodes[i].relativePath.startsWith("[MISSING]");
32706
- const label = isMissing ? chalk180.red(nodes[i].relativePath) : nodes[i].relativePath;
32728
+ const label = isMissing ? chalk181.red(nodes[i].relativePath) : nodes[i].relativePath;
32707
32729
  console.log(`${prefix2}${connector}${label}`);
32708
32730
  printNodes(nodes[i].children, prefix2 + childPrefix);
32709
32731
  }
32710
32732
  }
32711
32733
  function printTree(tree, totalCount, solutions) {
32712
- console.log(chalk180.bold("\nProject Dependency Tree"));
32713
- console.log(chalk180.cyan(tree.relativePath));
32734
+ console.log(chalk181.bold("\nProject Dependency Tree"));
32735
+ console.log(chalk181.cyan(tree.relativePath));
32714
32736
  printNodes(tree.children, "");
32715
- console.log(chalk180.dim(`
32737
+ console.log(chalk181.dim(`
32716
32738
  ${totalCount} projects total (including root)`));
32717
- console.log(chalk180.bold("\nSolution Membership"));
32739
+ console.log(chalk181.bold("\nSolution Membership"));
32718
32740
  if (solutions.length === 0) {
32719
- console.log(chalk180.yellow(" Not found in any .sln"));
32741
+ console.log(chalk181.yellow(" Not found in any .sln"));
32720
32742
  } else {
32721
32743
  for (const sln of solutions) {
32722
- console.log(` ${chalk180.green(sln)}`);
32744
+ console.log(` ${chalk181.green(sln)}`);
32723
32745
  }
32724
32746
  }
32725
32747
  console.log();
@@ -32748,16 +32770,16 @@ function printJson(tree, totalCount, solutions) {
32748
32770
  // src/commands/dotnet/resolveCsproj.ts
32749
32771
  import { existsSync as existsSync68 } from "fs";
32750
32772
  import path46 from "path";
32751
- import chalk181 from "chalk";
32773
+ import chalk182 from "chalk";
32752
32774
  function resolveCsproj(csprojPath) {
32753
32775
  const resolved = path46.resolve(csprojPath);
32754
32776
  if (!existsSync68(resolved)) {
32755
- console.error(chalk181.red(`File not found: ${resolved}`));
32777
+ console.error(chalk182.red(`File not found: ${resolved}`));
32756
32778
  process.exit(1);
32757
32779
  }
32758
32780
  const repoRoot3 = findRepoRoot(path46.dirname(resolved));
32759
32781
  if (!repoRoot3) {
32760
- console.error(chalk181.red("Could not find git repository root"));
32782
+ console.error(chalk182.red("Could not find git repository root"));
32761
32783
  process.exit(1);
32762
32784
  }
32763
32785
  return { resolved, repoRoot: repoRoot3 };
@@ -32807,12 +32829,12 @@ function getChangedCsFiles(scope) {
32807
32829
  }
32808
32830
 
32809
32831
  // src/commands/dotnet/inSln.ts
32810
- import chalk182 from "chalk";
32832
+ import chalk183 from "chalk";
32811
32833
  async function inSln(csprojPath) {
32812
32834
  const { resolved, repoRoot: repoRoot3 } = resolveCsproj(csprojPath);
32813
32835
  const solutions = findContainingSolutions(resolved, repoRoot3);
32814
32836
  if (solutions.length === 0) {
32815
- console.log(chalk182.yellow("Not found in any .sln file"));
32837
+ console.log(chalk183.yellow("Not found in any .sln file"));
32816
32838
  process.exit(1);
32817
32839
  }
32818
32840
  for (const sln of solutions) {
@@ -32821,7 +32843,7 @@ async function inSln(csprojPath) {
32821
32843
  }
32822
32844
 
32823
32845
  // src/commands/dotnet/inspect.ts
32824
- import chalk188 from "chalk";
32846
+ import chalk189 from "chalk";
32825
32847
 
32826
32848
  // src/shared/formatElapsed.ts
32827
32849
  function formatElapsed(ms) {
@@ -32833,12 +32855,12 @@ function formatElapsed(ms) {
32833
32855
  }
32834
32856
 
32835
32857
  // src/commands/dotnet/displayIssues.ts
32836
- import chalk183 from "chalk";
32858
+ import chalk184 from "chalk";
32837
32859
  var SEVERITY_COLOR = {
32838
- ERROR: chalk183.red,
32839
- WARNING: chalk183.yellow,
32840
- SUGGESTION: chalk183.cyan,
32841
- HINT: chalk183.dim
32860
+ ERROR: chalk184.red,
32861
+ WARNING: chalk184.yellow,
32862
+ SUGGESTION: chalk184.cyan,
32863
+ HINT: chalk184.dim
32842
32864
  };
32843
32865
  function groupByFile(issues) {
32844
32866
  const byFile = /* @__PURE__ */ new Map();
@@ -32854,15 +32876,15 @@ function groupByFile(issues) {
32854
32876
  }
32855
32877
  function displayIssues(issues) {
32856
32878
  for (const [file, fileIssues] of groupByFile(issues)) {
32857
- console.log(chalk183.bold(file));
32879
+ console.log(chalk184.bold(file));
32858
32880
  for (const issue of fileIssues.sort((a, b) => a.line - b.line)) {
32859
- const color = SEVERITY_COLOR[issue.severity] ?? chalk183.white;
32881
+ const color = SEVERITY_COLOR[issue.severity] ?? chalk184.white;
32860
32882
  console.log(
32861
- ` ${chalk183.dim(`${issue.line}:`)} ${color(issue.severity)} [${issue.typeId}] ${issue.message}`
32883
+ ` ${chalk184.dim(`${issue.line}:`)} ${color(issue.severity)} [${issue.typeId}] ${issue.message}`
32862
32884
  );
32863
32885
  }
32864
32886
  }
32865
- console.log(chalk183.dim(`
32887
+ console.log(chalk184.dim(`
32866
32888
  ${issues.length} issue(s) found`));
32867
32889
  }
32868
32890
 
@@ -32921,12 +32943,12 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
32921
32943
  // src/commands/dotnet/resolveSolution.ts
32922
32944
  import { existsSync as existsSync69 } from "fs";
32923
32945
  import path47 from "path";
32924
- import chalk185 from "chalk";
32946
+ import chalk186 from "chalk";
32925
32947
 
32926
32948
  // src/commands/dotnet/findSolution.ts
32927
32949
  import { readdirSync as readdirSync16 } from "fs";
32928
32950
  import { dirname as dirname37, join as join84 } from "path";
32929
- import chalk184 from "chalk";
32951
+ import chalk185 from "chalk";
32930
32952
  function findSlnInDir(dir) {
32931
32953
  try {
32932
32954
  return readdirSync16(dir).filter((f) => f.endsWith(".sln")).map((f) => join84(dir, f));
@@ -32942,17 +32964,17 @@ function findSolution() {
32942
32964
  const slnFiles = findSlnInDir(current2);
32943
32965
  if (slnFiles.length === 1) return slnFiles[0];
32944
32966
  if (slnFiles.length > 1) {
32945
- console.error(chalk184.red(`Multiple .sln files found in ${current2}:`));
32967
+ console.error(chalk185.red(`Multiple .sln files found in ${current2}:`));
32946
32968
  for (const f of slnFiles) console.error(` ${f}`);
32947
32969
  console.error(
32948
- chalk184.yellow("Specify which one: assist dotnet inspect <sln>")
32970
+ chalk185.yellow("Specify which one: assist dotnet inspect <sln>")
32949
32971
  );
32950
32972
  process.exit(1);
32951
32973
  }
32952
32974
  if (current2 === ceiling) break;
32953
32975
  current2 = dirname37(current2);
32954
32976
  }
32955
- console.error(chalk184.red("No .sln file found between cwd and repo root"));
32977
+ console.error(chalk185.red("No .sln file found between cwd and repo root"));
32956
32978
  process.exit(1);
32957
32979
  }
32958
32980
 
@@ -32961,7 +32983,7 @@ function resolveSolution(sln) {
32961
32983
  if (sln) {
32962
32984
  const resolved = path47.resolve(sln);
32963
32985
  if (!existsSync69(resolved)) {
32964
- console.error(chalk185.red(`Solution file not found: ${resolved}`));
32986
+ console.error(chalk186.red(`Solution file not found: ${resolved}`));
32965
32987
  process.exit(1);
32966
32988
  }
32967
32989
  return resolved;
@@ -33003,14 +33025,14 @@ import { execSync as execSync40 } from "child_process";
33003
33025
  import { existsSync as existsSync70, readFileSync as readFileSync56, unlinkSync as unlinkSync13 } from "fs";
33004
33026
  import { tmpdir as tmpdir5 } from "os";
33005
33027
  import path48 from "path";
33006
- import chalk186 from "chalk";
33028
+ import chalk187 from "chalk";
33007
33029
  function assertJbInstalled() {
33008
33030
  try {
33009
33031
  execSync40("jb inspectcode --version", { stdio: "pipe" });
33010
33032
  } catch {
33011
- console.error(chalk186.red("jb is not installed. Install with:"));
33033
+ console.error(chalk187.red("jb is not installed. Install with:"));
33012
33034
  console.error(
33013
- chalk186.yellow(" dotnet tool install -g JetBrains.ReSharper.GlobalTools")
33035
+ chalk187.yellow(" dotnet tool install -g JetBrains.ReSharper.GlobalTools")
33014
33036
  );
33015
33037
  process.exit(1);
33016
33038
  }
@@ -33028,11 +33050,11 @@ function runInspectCode(slnPath, include, swea) {
33028
33050
  if (error && typeof error === "object" && "stderr" in error) {
33029
33051
  process.stderr.write(error.stderr);
33030
33052
  }
33031
- console.error(chalk186.red("jb inspectcode failed"));
33053
+ console.error(chalk187.red("jb inspectcode failed"));
33032
33054
  process.exit(1);
33033
33055
  }
33034
33056
  if (!existsSync70(reportPath)) {
33035
- console.error(chalk186.red("Report file not generated"));
33057
+ console.error(chalk187.red("Report file not generated"));
33036
33058
  process.exit(1);
33037
33059
  }
33038
33060
  const xml = readFileSync56(reportPath, "utf8");
@@ -33042,7 +33064,7 @@ function runInspectCode(slnPath, include, swea) {
33042
33064
 
33043
33065
  // src/commands/dotnet/runRoslynInspect.ts
33044
33066
  import { execSync as execSync41 } from "child_process";
33045
- import chalk187 from "chalk";
33067
+ import chalk188 from "chalk";
33046
33068
  function resolveMsbuildPath() {
33047
33069
  const { run: run5 } = loadConfig();
33048
33070
  const configs = resolveRunConfigs(run5, runConfigBaseDir());
@@ -33054,9 +33076,9 @@ function assertMsbuildInstalled() {
33054
33076
  try {
33055
33077
  execSync41(`"${msbuild}" -version`, { stdio: "pipe" });
33056
33078
  } catch {
33057
- console.error(chalk187.red(`msbuild not found at: ${msbuild}`));
33079
+ console.error(chalk188.red(`msbuild not found at: ${msbuild}`));
33058
33080
  console.error(
33059
- chalk187.yellow(
33081
+ chalk188.yellow(
33060
33082
  "Configure it via a 'build' run entry in .claude/assist.yml or add msbuild to PATH."
33061
33083
  )
33062
33084
  );
@@ -33103,17 +33125,17 @@ function runEngine(resolved, changedFiles2, options2) {
33103
33125
  // src/commands/dotnet/inspect.ts
33104
33126
  function logScope(changedFiles2) {
33105
33127
  if (changedFiles2 === null) {
33106
- console.log(chalk188.dim("Inspecting full solution..."));
33128
+ console.log(chalk189.dim("Inspecting full solution..."));
33107
33129
  } else {
33108
33130
  console.log(
33109
- chalk188.dim(`Inspecting ${changedFiles2.length} changed file(s)...`)
33131
+ chalk189.dim(`Inspecting ${changedFiles2.length} changed file(s)...`)
33110
33132
  );
33111
33133
  }
33112
33134
  }
33113
33135
  function reportResults(issues, elapsed) {
33114
33136
  if (issues.length > 0) displayIssues(issues);
33115
- else console.log(chalk188.green("No issues found"));
33116
- console.log(chalk188.dim(`Completed in ${formatElapsed(elapsed)}`));
33137
+ else console.log(chalk189.green("No issues found"));
33138
+ console.log(chalk189.dim(`Completed in ${formatElapsed(elapsed)}`));
33117
33139
  if (issues.length > 0) process.exit(1);
33118
33140
  }
33119
33141
  async function inspect(sln, options2) {
@@ -33124,7 +33146,7 @@ async function inspect(sln, options2) {
33124
33146
  const scope = parseScope(options2.scope);
33125
33147
  const changedFiles2 = getChangedCsFiles(scope);
33126
33148
  if (changedFiles2 !== null && changedFiles2.length === 0) {
33127
- console.log(chalk188.green("No changed .cs files found"));
33149
+ console.log(chalk189.green("No changed .cs files found"));
33128
33150
  return;
33129
33151
  }
33130
33152
  logScope(changedFiles2);
@@ -34012,25 +34034,25 @@ function fetchRepoCommitAuthors(org, repo, since) {
34012
34034
  }
34013
34035
 
34014
34036
  // src/commands/github/printCountTable.ts
34015
- import chalk189 from "chalk";
34037
+ import chalk190 from "chalk";
34016
34038
  function printCountTable(labelHeader, rows) {
34017
34039
  const labelWidth = Math.max(
34018
34040
  labelHeader.length,
34019
34041
  ...rows.map((row2) => row2.label.length)
34020
34042
  );
34021
34043
  const header = `${labelHeader.padEnd(labelWidth)} Commits`;
34022
- console.log(chalk189.dim(header));
34023
- console.log(chalk189.dim("-".repeat(header.length)));
34044
+ console.log(chalk190.dim(header));
34045
+ console.log(chalk190.dim("-".repeat(header.length)));
34024
34046
  for (const row2 of rows) {
34025
34047
  console.log(`${row2.label.padEnd(labelWidth)} ${row2.count}`);
34026
34048
  }
34027
34049
  }
34028
34050
 
34029
34051
  // src/commands/github/printRepoAuthorBreakdown.ts
34030
- import chalk190 from "chalk";
34052
+ import chalk191 from "chalk";
34031
34053
  function printRepoAuthorBreakdown(repos2) {
34032
34054
  for (const repo of repos2) {
34033
- console.log(chalk190.bold(repo.name));
34055
+ console.log(chalk191.bold(repo.name));
34034
34056
  const authorWidth = Math.max(
34035
34057
  0,
34036
34058
  ...repo.authors.map((a) => a.author.length)
@@ -34104,10 +34126,10 @@ function parseSinceDate(value) {
34104
34126
  }
34105
34127
 
34106
34128
  // src/commands/github/issue/fixStructure/applyAndVerifySubtree.ts
34107
- import chalk192 from "chalk";
34129
+ import chalk193 from "chalk";
34108
34130
 
34109
34131
  // src/commands/github/issue/fixStructure/applyFixStructurePlan.ts
34110
- import chalk191 from "chalk";
34132
+ import chalk192 from "chalk";
34111
34133
 
34112
34134
  // src/commands/github/issue/fixStructure/removeIssueLabels.ts
34113
34135
  var MUTATION2 = `mutation($labelableId: ID!, $labelIds: [ID!]!) {
@@ -34144,7 +34166,7 @@ function writeLineNow(line) {
34144
34166
  // src/commands/github/issue/fixStructure/applyFixStructurePlan.ts
34145
34167
  function applyFixStructurePlan(plan2) {
34146
34168
  for (const entry of plan2.entries) {
34147
- const where = chalk191.cyan(`${entry.issue.repo}#${entry.issue.number}`);
34169
+ const where = chalk192.cyan(`${entry.issue.repo}#${entry.issue.number}`);
34148
34170
  const { typeChange, labelRemovals } = entry;
34149
34171
  if (typeChange) {
34150
34172
  writeLineNow(
@@ -34414,12 +34436,12 @@ function planSubtree(root2, context) {
34414
34436
  function applyAndVerifySubtree(target, plan2, context) {
34415
34437
  if (plan2.typeChangeCount === 0 && plan2.labelRemovalCount === 0) return;
34416
34438
  applyFixStructurePlan(plan2);
34417
- writeLineNow(chalk192.dim("Re-walking the subtree to confirm"));
34439
+ writeLineNow(chalk193.dim("Re-walking the subtree to confirm"));
34418
34440
  assertNoResidualDrift(
34419
34441
  planSubtree(fetchRootIssue(target), context),
34420
34442
  context.chain
34421
34443
  );
34422
- writeLineNow(chalk192.green("Subtree normalised"));
34444
+ writeLineNow(chalk193.green("Subtree normalised"));
34423
34445
  }
34424
34446
 
34425
34447
  // src/commands/github/issue/fixStructure/assertChainTypesExist.ts
@@ -34455,22 +34477,22 @@ function parseTypeChain(value) {
34455
34477
  }
34456
34478
 
34457
34479
  // src/commands/github/issue/fixStructure/printFixStructurePlan.ts
34458
- import chalk193 from "chalk";
34480
+ import chalk194 from "chalk";
34459
34481
  function annotate(entry) {
34460
34482
  const notes = [];
34461
34483
  if (entry.level === null) {
34462
- notes.push(chalk193.red("deeper than the leaf level"));
34484
+ notes.push(chalk194.red("deeper than the leaf level"));
34463
34485
  } else if (entry.typeChange) {
34464
34486
  notes.push(
34465
- chalk193.yellow(
34487
+ chalk194.yellow(
34466
34488
  `${entry.typeChange.from ?? "no type"} -> ${entry.typeChange.to}`
34467
34489
  )
34468
34490
  );
34469
34491
  } else {
34470
- notes.push(chalk193.dim(entry.issue.typeName ?? "no type"));
34492
+ notes.push(chalk194.dim(entry.issue.typeName ?? "no type"));
34471
34493
  }
34472
34494
  for (const label of entry.labelRemovals) {
34473
- notes.push(chalk193.yellow(`-${label.name}`));
34495
+ notes.push(chalk194.yellow(`-${label.name}`));
34474
34496
  }
34475
34497
  return notes;
34476
34498
  }
@@ -34478,22 +34500,22 @@ function formatCount(count10, noun) {
34478
34500
  return `${count10} ${noun}${count10 === 1 ? "" : "s"}`;
34479
34501
  }
34480
34502
  function printFixStructurePlan(plan2, chain2, apply) {
34481
- writeLineNow(chalk193.dim(`chain: ${chain2.join(" > ")}`));
34503
+ writeLineNow(chalk194.dim(`chain: ${chain2.join(" > ")}`));
34482
34504
  for (const entry of plan2.entries) {
34483
34505
  const indent4 = " ".repeat(entry.issue.depth);
34484
- const name2 = chalk193.cyan(`${entry.issue.repo}#${entry.issue.number}`);
34506
+ const name2 = chalk194.cyan(`${entry.issue.repo}#${entry.issue.number}`);
34485
34507
  writeLineNow(
34486
34508
  `${indent4}${name2} ${entry.issue.title} [${annotate(entry).join(", ")}]`
34487
34509
  );
34488
34510
  }
34489
34511
  if (plan2.typeChangeCount === 0 && plan2.labelRemovalCount === 0) {
34490
- writeLineNow(chalk193.green("Nothing to change"));
34512
+ writeLineNow(chalk194.green("Nothing to change"));
34491
34513
  return;
34492
34514
  }
34493
34515
  writeLineNow(
34494
34516
  `${formatCount(plan2.typeChangeCount, "type change")}, ${formatCount(plan2.labelRemovalCount, "label removal")} planned`
34495
34517
  );
34496
- if (!apply) writeLineNow(chalk193.dim("Dry run \u2014 nothing written"));
34518
+ if (!apply) writeLineNow(chalk194.dim("Dry run \u2014 nothing written"));
34497
34519
  }
34498
34520
 
34499
34521
  // src/commands/github/issue/parseRepoSlug.ts
@@ -35894,25 +35916,25 @@ function registerGithub(program) {
35894
35916
  import { Option } from "commander";
35895
35917
 
35896
35918
  // src/commands/inbox/list.ts
35897
- import chalk194 from "chalk";
35919
+ import chalk195 from "chalk";
35898
35920
  async function list3() {
35899
35921
  const messages2 = await listInboxMessages(await getDb());
35900
35922
  if (messages2.length === 0) {
35901
- console.log(chalk194.dim("No flagged messages; run assist inbox scan"));
35923
+ console.log(chalk195.dim("No flagged messages; run assist inbox scan"));
35902
35924
  return;
35903
35925
  }
35904
35926
  for (const message4 of messages2) {
35905
35927
  const when = (message4.receivedAt ?? message4.flaggedAt).toISOString();
35906
35928
  console.log(
35907
- `${chalk194.dim(when)} ${chalk194.cyan(message4.source)} ${chalk194.bold(message4.sender)}`
35929
+ `${chalk195.dim(when)} ${chalk195.cyan(message4.source)} ${chalk195.bold(message4.sender)}`
35908
35930
  );
35909
35931
  console.log(` ${message4.summary}`);
35910
- console.log(` ${chalk194.dim(message4.link)}`);
35932
+ console.log(` ${chalk195.dim(message4.link)}`);
35911
35933
  }
35912
35934
  }
35913
35935
 
35914
35936
  // src/commands/inbox/scan.ts
35915
- import chalk195 from "chalk";
35937
+ import chalk196 from "chalk";
35916
35938
 
35917
35939
  // src/shared/formatTokens.ts
35918
35940
  function formatTokens(n) {
@@ -36325,7 +36347,7 @@ async function runInboxScan(orm, {
36325
36347
  async function scan(options2 = {}) {
36326
36348
  const blocker = inboxScanBlocker(options2.harness);
36327
36349
  if (blocker) {
36328
- console.error(chalk195.red(blocker));
36350
+ console.error(chalk196.red(blocker));
36329
36351
  process.exitCode = 1;
36330
36352
  return;
36331
36353
  }
@@ -36338,7 +36360,7 @@ async function scan(options2 = {}) {
36338
36360
  )
36339
36361
  });
36340
36362
  console.log(
36341
- `Flagged ${flagged} message(s) needing a reply, ${chalk195.bold(added)} new. ${chalk195.dim(formatScanUsage(usage))}`
36363
+ `Flagged ${flagged} message(s) needing a reply, ${chalk196.bold(added)} new. ${chalk196.dim(formatScanUsage(usage))}`
36342
36364
  );
36343
36365
  }
36344
36366
 
@@ -36358,7 +36380,7 @@ function registerInbox(program) {
36358
36380
  }
36359
36381
 
36360
36382
  // src/commands/jira/acceptanceCriteria.ts
36361
- import chalk196 from "chalk";
36383
+ import chalk197 from "chalk";
36362
36384
 
36363
36385
  // src/commands/jira/adfToText.ts
36364
36386
  function renderInline(node) {
@@ -36425,7 +36447,7 @@ function acceptanceCriteria(issueKey) {
36425
36447
  const parsed = fetchIssue(issueKey, field);
36426
36448
  const acValue = parsed?.fields?.[field];
36427
36449
  if (!acValue) {
36428
- console.log(chalk196.yellow(`No acceptance criteria found on ${issueKey}.`));
36450
+ console.log(chalk197.yellow(`No acceptance criteria found on ${issueKey}.`));
36429
36451
  return;
36430
36452
  }
36431
36453
  if (typeof acValue === "string") {
@@ -36491,14 +36513,14 @@ async function jiraAuth() {
36491
36513
  }
36492
36514
 
36493
36515
  // src/commands/jira/viewIssue.ts
36494
- import chalk197 from "chalk";
36516
+ import chalk198 from "chalk";
36495
36517
  function viewIssue2(issueKey) {
36496
36518
  const parsed = fetchIssue(issueKey, "summary,description");
36497
36519
  const fields = parsed?.fields;
36498
36520
  const summary = fields?.summary;
36499
36521
  const description = fields?.description;
36500
36522
  if (summary) {
36501
- console.log(chalk197.bold(summary));
36523
+ console.log(chalk198.bold(summary));
36502
36524
  }
36503
36525
  if (description) {
36504
36526
  if (summary) console.log();
@@ -36512,7 +36534,7 @@ function viewIssue2(issueKey) {
36512
36534
  }
36513
36535
  if (!summary && !description) {
36514
36536
  console.log(
36515
- chalk197.yellow(`No summary or description found on ${issueKey}.`)
36537
+ chalk198.yellow(`No summary or description found on ${issueKey}.`)
36516
36538
  );
36517
36539
  }
36518
36540
  }
@@ -36543,7 +36565,7 @@ function registerRefineLaunch(program, resumeFlag) {
36543
36565
  }
36544
36566
 
36545
36567
  // src/commands/launchPrSkill.ts
36546
- import chalk199 from "chalk";
36568
+ import chalk200 from "chalk";
36547
36569
 
36548
36570
  // src/commands/review/checkoutPr.ts
36549
36571
  import { execFileSync as execFileSync19 } from "child_process";
@@ -37249,7 +37271,7 @@ function worktreeHoldingBranch(cwd, branch2) {
37249
37271
  }
37250
37272
 
37251
37273
  // src/commands/review/failCheckout.ts
37252
- import chalk198 from "chalk";
37274
+ import chalk199 from "chalk";
37253
37275
 
37254
37276
  // src/commands/review/azCliProblem.ts
37255
37277
  import { execFileSync as execFileSync18 } from "child_process";
@@ -37302,14 +37324,14 @@ function failCheckout(number, headRef, stale, from, checkout) {
37302
37324
  gitSyncOrNull(process.cwd(), ["checkout", "--quiet", from]);
37303
37325
  if (headRef && stale === "local-work")
37304
37326
  console.error(
37305
- chalk198.red(
37327
+ chalk199.red(
37306
37328
  `Local branch ${headRef} has commits that are not on the remote and cannot fast-forward to PR #${number}'s head; push or reset ${headRef}, then retry.`
37307
37329
  )
37308
37330
  );
37309
37331
  const problem = checkout.file === "az" ? azCliProblem() : null;
37310
- if (problem) console.error(chalk198.red(problem));
37332
+ if (problem) console.error(chalk199.red(problem));
37311
37333
  console.error(
37312
- chalk198.red(`${checkout.file} ${checkout.args.join(" ")} failed; aborting.`)
37334
+ chalk199.red(`${checkout.file} ${checkout.args.join(" ")} failed; aborting.`)
37313
37335
  );
37314
37336
  process.exit(1);
37315
37337
  }
@@ -37363,7 +37385,7 @@ async function launchPrSkill({
37363
37385
  const adapter = harnessAdapter(harness);
37364
37386
  const blocker = launchBlocker(adapter, feature, resumeSessionId);
37365
37387
  if (blocker) {
37366
- console.error(chalk199.red(blocker));
37388
+ console.error(chalk200.red(blocker));
37367
37389
  process.exitCode = 1;
37368
37390
  return;
37369
37391
  }
@@ -37521,18 +37543,18 @@ function registerList(program) {
37521
37543
  }
37522
37544
 
37523
37545
  // src/commands/litellm/listModels.ts
37524
- import chalk201 from "chalk";
37546
+ import chalk202 from "chalk";
37525
37547
 
37526
37548
  // src/commands/litellm/resolveLitellmConfig.ts
37527
- import chalk200 from "chalk";
37549
+ import chalk201 from "chalk";
37528
37550
  function resolveLitellmConfig() {
37529
37551
  const { config, missing } = readLitellmConfig();
37530
37552
  if (!config) {
37531
- console.error(chalk200.red("LiteLLM is not configured"));
37553
+ console.error(chalk201.red("LiteLLM is not configured"));
37532
37554
  for (const key of missing) {
37533
37555
  const entry = litellmConfigHelp.find((help) => help.key === key);
37534
37556
  console.error(
37535
- chalk200.red(` ${key} is not set. Set it with: ${entry?.setter}`)
37557
+ chalk201.red(` ${key} is not set. Set it with: ${entry?.setter}`)
37536
37558
  );
37537
37559
  }
37538
37560
  process.exit(1);
@@ -37558,13 +37580,13 @@ async function listModels(options2) {
37558
37580
  } catch (error) {
37559
37581
  const reason4 = error instanceof Error ? error.message : String(error);
37560
37582
  console.error(
37561
- chalk201.red(`Failed to reach LiteLLM at ${baseUrl2}: ${reason4}`)
37583
+ chalk202.red(`Failed to reach LiteLLM at ${baseUrl2}: ${reason4}`)
37562
37584
  );
37563
37585
  process.exit(1);
37564
37586
  }
37565
37587
  const body = await response.text();
37566
37588
  if (!response.ok) {
37567
- console.error(chalk201.red(`LiteLLM returned ${response.status}: ${body}`));
37589
+ console.error(chalk202.red(`LiteLLM returned ${response.status}: ${body}`));
37568
37590
  process.exit(1);
37569
37591
  }
37570
37592
  if (options2.json) {
@@ -37584,15 +37606,15 @@ function registerLitellm(program) {
37584
37606
  // src/commands/mermaidExport.ts
37585
37607
  import { mkdirSync as mkdirSync30, readdirSync as readdirSync17 } from "fs";
37586
37608
  import { resolve as resolve24 } from "path";
37587
- import chalk204 from "chalk";
37609
+ import chalk205 from "chalk";
37588
37610
 
37589
37611
  // src/commands/mermaid/exportFile.ts
37590
37612
  import { readFileSync as readFileSync58, writeFileSync as writeFileSync43 } from "fs";
37591
37613
  import { basename as basename23, extname as extname4, resolve as resolve23 } from "path";
37592
- import chalk203 from "chalk";
37614
+ import chalk204 from "chalk";
37593
37615
 
37594
37616
  // src/commands/mermaid/renderBlock.ts
37595
- import chalk202 from "chalk";
37617
+ import chalk203 from "chalk";
37596
37618
  async function renderBlock(krokiUrl, source) {
37597
37619
  const response = await fetch(`${krokiUrl}/mermaid/svg`, {
37598
37620
  method: "POST",
@@ -37601,7 +37623,7 @@ async function renderBlock(krokiUrl, source) {
37601
37623
  });
37602
37624
  if (!response.ok) {
37603
37625
  console.error(
37604
- chalk202.red(
37626
+ chalk203.red(
37605
37627
  `Kroki request failed: ${response.status} ${response.statusText}`
37606
37628
  )
37607
37629
  );
@@ -37619,19 +37641,19 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
37619
37641
  if (onlyIndex !== void 0) {
37620
37642
  if (onlyIndex < 1 || onlyIndex > blocks.length) {
37621
37643
  console.error(
37622
- chalk203.red(
37644
+ chalk204.red(
37623
37645
  `${file}: --index ${onlyIndex} out of range (file has ${blocks.length} diagram(s))`
37624
37646
  )
37625
37647
  );
37626
37648
  process.exit(1);
37627
37649
  }
37628
37650
  console.log(
37629
- chalk203.gray(
37651
+ chalk204.gray(
37630
37652
  `${file} \u2014 rendering diagram ${onlyIndex} of ${blocks.length}`
37631
37653
  )
37632
37654
  );
37633
37655
  } else {
37634
- console.log(chalk203.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
37656
+ console.log(chalk204.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
37635
37657
  }
37636
37658
  for (const [i, source] of blocks.entries()) {
37637
37659
  const idx = i + 1;
@@ -37639,7 +37661,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
37639
37661
  const outPath = resolve23(outDir, `${stem}-${idx}.svg`);
37640
37662
  const svg = await renderBlock(krokiUrl, source);
37641
37663
  writeFileSync43(outPath, svg, "utf8");
37642
- console.log(chalk203.green(` \u2192 ${outPath}`));
37664
+ console.log(chalk204.green(` \u2192 ${outPath}`));
37643
37665
  }
37644
37666
  }
37645
37667
  function extractMermaidBlocks(markdown) {
@@ -37655,18 +37677,18 @@ async function mermaidExport(file, options2 = {}) {
37655
37677
  if (options2.index !== void 0) {
37656
37678
  if (!Number.isInteger(options2.index) || options2.index < 1) {
37657
37679
  console.error(
37658
- chalk204.red(`--index must be a positive integer (got ${options2.index})`)
37680
+ chalk205.red(`--index must be a positive integer (got ${options2.index})`)
37659
37681
  );
37660
37682
  process.exit(1);
37661
37683
  }
37662
37684
  if (!file) {
37663
- console.error(chalk204.red("--index requires a file argument"));
37685
+ console.error(chalk205.red("--index requires a file argument"));
37664
37686
  process.exit(1);
37665
37687
  }
37666
37688
  }
37667
37689
  const files = file ? [file] : readdirSync17(process.cwd()).filter((name2) => name2.toLowerCase().endsWith(".md")).sort();
37668
37690
  if (files.length === 0) {
37669
- console.log(chalk204.gray("No markdown files found in current directory."));
37691
+ console.log(chalk205.gray("No markdown files found in current directory."));
37670
37692
  return;
37671
37693
  }
37672
37694
  for (const f of files) {
@@ -37812,7 +37834,7 @@ function extractToSave(details, cwd = process.cwd()) {
37812
37834
  }
37813
37835
 
37814
37836
  // src/commands/miro/keptTexts.ts
37815
- import chalk205 from "chalk";
37837
+ import chalk206 from "chalk";
37816
37838
 
37817
37839
  // src/commands/miro/applyIgnore.ts
37818
37840
  function applyIgnore(texts, ignore3) {
@@ -37851,7 +37873,7 @@ function warnUnmatched(file, unmatched) {
37851
37873
  if (unmatched.length === 0) return;
37852
37874
  const entries = unmatched.map((entry) => ` - ${entry}`).join("\n");
37853
37875
  console.error(
37854
- chalk205.yellow(
37876
+ chalk206.yellow(
37855
37877
  `${unmatched.length} ${unmatched.length === 1 ? "entry" : "entries"} in ${file} matched no box text:
37856
37878
  ${entries}`
37857
37879
  )
@@ -38052,7 +38074,7 @@ function readMiroItems(file) {
38052
38074
  }
38053
38075
 
38054
38076
  // src/commands/miro/resolveExtractOptions.ts
38055
- import chalk206 from "chalk";
38077
+ import chalk207 from "chalk";
38056
38078
 
38057
38079
  // src/commands/miro/extractLayers.ts
38058
38080
  function extractsIn(layer) {
@@ -38130,7 +38152,7 @@ function resolveExtractOptions(name2, options2, paths) {
38130
38152
  paths.cwd,
38131
38153
  paths.globalConfigPath
38132
38154
  );
38133
- console.error(chalk206.dim(`Extract "${name2}" from ${resolved.from}`));
38155
+ console.error(chalk207.dim(`Extract "${name2}" from ${resolved.from}`));
38134
38156
  return resolved.options;
38135
38157
  }
38136
38158
 
@@ -38235,7 +38257,7 @@ function registerMiro(program) {
38235
38257
  import { mkdir as mkdir6 } from "fs/promises";
38236
38258
  import { createServer as createServer2 } from "http";
38237
38259
  import { dirname as dirname43 } from "path";
38238
- import chalk208 from "chalk";
38260
+ import chalk209 from "chalk";
38239
38261
 
38240
38262
  // src/commands/netcap/corsHeaders.ts
38241
38263
  var corsHeaders = {
@@ -38314,7 +38336,7 @@ function createNetcapHandler(options2) {
38314
38336
  import { cp as cp4, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
38315
38337
  import { networkInterfaces } from "os";
38316
38338
  import { join as join91 } from "path";
38317
- import chalk207 from "chalk";
38339
+ import chalk208 from "chalk";
38318
38340
 
38319
38341
  // src/commands/netcap/netcapExtensionDir.ts
38320
38342
  import { dirname as dirname42, join as join90 } from "path";
@@ -38358,7 +38380,7 @@ async function prepareExtensionForLoad(port, filter = "") {
38358
38380
  const host = lanIPv4();
38359
38381
  if (!host) {
38360
38382
  console.log(
38361
- chalk207.yellow("could not determine the WSL IP for the extension")
38383
+ chalk208.yellow("could not determine the WSL IP for the extension")
38362
38384
  );
38363
38385
  await configureBackground(source, "127.0.0.1", port, filter);
38364
38386
  return source;
@@ -38369,7 +38391,7 @@ async function prepareExtensionForLoad(port, filter = "") {
38369
38391
  return WSL_WINDOWS_PATH3;
38370
38392
  } catch {
38371
38393
  console.log(
38372
- chalk207.yellow(`could not copy extension to ${WSL_WINDOWS_PATH3}`)
38394
+ chalk208.yellow(`could not copy extension to ${WSL_WINDOWS_PATH3}`)
38373
38395
  );
38374
38396
  return source;
38375
38397
  }
@@ -38402,30 +38424,30 @@ async function netcap(options2) {
38402
38424
  let count10 = 0;
38403
38425
  const handler = createNetcapHandler({
38404
38426
  outPath,
38405
- onPing: () => console.log(chalk208.dim("ping from extension")),
38427
+ onPing: () => console.log(chalk209.dim("ping from extension")),
38406
38428
  onCapture: (entry) => {
38407
38429
  count10 += 1;
38408
38430
  console.log(
38409
- chalk208.green(`captured #${count10}`),
38410
- chalk208.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
38431
+ chalk209.green(`captured #${count10}`),
38432
+ chalk209.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
38411
38433
  );
38412
38434
  }
38413
38435
  });
38414
38436
  const server = createServer2(handler);
38415
38437
  server.listen(port, () => {
38416
38438
  console.log(
38417
- chalk208.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
38439
+ chalk209.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
38418
38440
  );
38419
- console.log(chalk208.dim(`appending captures to ${outPath}`));
38441
+ console.log(chalk209.dim(`appending captures to ${outPath}`));
38420
38442
  if (filter)
38421
- console.log(chalk208.dim(`forwarding only URLs matching "${filter}"`));
38422
- console.log(chalk208.dim(`load the unpacked extension from ${extensionPath}`));
38423
- console.log(chalk208.dim("press Ctrl-C to stop"));
38443
+ console.log(chalk209.dim(`forwarding only URLs matching "${filter}"`));
38444
+ console.log(chalk209.dim(`load the unpacked extension from ${extensionPath}`));
38445
+ console.log(chalk209.dim("press Ctrl-C to stop"));
38424
38446
  });
38425
38447
  process.on("SIGINT", () => {
38426
38448
  server.close();
38427
38449
  console.log(
38428
- chalk208.bold(
38450
+ chalk209.bold(
38429
38451
  `
38430
38452
  netcap stopped \u2014 captured ${count10} ${count10 === 1 ? "entry" : "entries"} to ${outPath}`
38431
38453
  )
@@ -38437,7 +38459,7 @@ netcap stopped \u2014 captured ${count10} ${count10 === 1 ? "entry" : "entries"}
38437
38459
  // src/commands/netcap/netcapExtract.ts
38438
38460
  import { writeFileSync as writeFileSync45 } from "fs";
38439
38461
  import { join as join94 } from "path";
38440
- import chalk209 from "chalk";
38462
+ import chalk210 from "chalk";
38441
38463
 
38442
38464
  // src/commands/netcap/extractPostsFromCapture.ts
38443
38465
  import { readFileSync as readFileSync61 } from "fs";
@@ -38885,8 +38907,8 @@ function netcapExtract(file) {
38885
38907
  writeFileSync45(outFile, `${JSON.stringify(posts, null, 2)}
38886
38908
  `);
38887
38909
  console.log(
38888
- chalk209.green(`extracted ${posts.length} posts`),
38889
- chalk209.dim(`-> ${outFile}`)
38910
+ chalk210.green(`extracted ${posts.length} posts`),
38911
+ chalk210.dim(`-> ${outFile}`)
38890
38912
  );
38891
38913
  }
38892
38914
 
@@ -38907,7 +38929,7 @@ function registerNetcap(program) {
38907
38929
  }
38908
38930
 
38909
38931
  // src/commands/news/add.ts
38910
- import chalk210 from "chalk";
38932
+ import chalk211 from "chalk";
38911
38933
  import enquirer8 from "enquirer";
38912
38934
  async function add2(url) {
38913
38935
  if (!url) {
@@ -38928,25 +38950,25 @@ async function add2(url) {
38928
38950
  }
38929
38951
  const added = await addFeed(await getDb(), url);
38930
38952
  if (!added) {
38931
- console.log(chalk210.yellow("Feed already exists"));
38953
+ console.log(chalk211.yellow("Feed already exists"));
38932
38954
  return;
38933
38955
  }
38934
- console.log(chalk210.green(`Added feed: ${url}`));
38956
+ console.log(chalk211.green(`Added feed: ${url}`));
38935
38957
  }
38936
38958
 
38937
38959
  // src/commands/news/list.ts
38938
- import chalk211 from "chalk";
38960
+ import chalk212 from "chalk";
38939
38961
  async function list4() {
38940
38962
  const urls = await listFeeds(await getDb());
38941
38963
  if (urls.length === 0) {
38942
- console.log(chalk211.dim("No feeds; add one with assist news add <url>"));
38964
+ console.log(chalk212.dim("No feeds; add one with assist news add <url>"));
38943
38965
  return;
38944
38966
  }
38945
38967
  for (const url of urls) console.log(url);
38946
38968
  }
38947
38969
 
38948
38970
  // src/commands/news/remove.ts
38949
- import chalk212 from "chalk";
38971
+ import chalk213 from "chalk";
38950
38972
 
38951
38973
  // src/commands/backlog/removeFeed.ts
38952
38974
  import { eq as eq56 } from "drizzle-orm";
@@ -38959,10 +38981,10 @@ async function removeFeed(db, url) {
38959
38981
  async function remove(url) {
38960
38982
  const removed = await removeFeed(await getDb(), url);
38961
38983
  if (!removed) {
38962
- console.log(chalk212.yellow(`No feed matches ${url}`));
38984
+ console.log(chalk213.yellow(`No feed matches ${url}`));
38963
38985
  return;
38964
38986
  }
38965
- console.log(chalk212.green(`Removed feed: ${url}`));
38987
+ console.log(chalk213.green(`Removed feed: ${url}`));
38966
38988
  }
38967
38989
 
38968
38990
  // src/commands/registerNews.ts
@@ -39014,7 +39036,7 @@ function registerPiHook(program) {
39014
39036
  }
39015
39037
 
39016
39038
  // src/commands/prompts/printPromptsTable.ts
39017
- import chalk213 from "chalk";
39039
+ import chalk214 from "chalk";
39018
39040
  function truncate3(str, max) {
39019
39041
  if (str.length <= max) return str;
39020
39042
  return `${str.slice(0, max - 1)}\u2026`;
@@ -39032,14 +39054,14 @@ function printPromptsTable(rows) {
39032
39054
  "Command".padEnd(commandWidth),
39033
39055
  "Repos"
39034
39056
  ].join(" ");
39035
- console.log(chalk213.dim(header));
39036
- console.log(chalk213.dim("-".repeat(header.length)));
39057
+ console.log(chalk214.dim(header));
39058
+ console.log(chalk214.dim("-".repeat(header.length)));
39037
39059
  for (const row2 of rows) {
39038
39060
  const count10 = String(row2.count).padStart(countWidth);
39039
39061
  const tool = row2.tool.padEnd(toolWidth);
39040
39062
  const command = truncate3(row2.command, 60).padEnd(commandWidth);
39041
39063
  console.log(
39042
- `${chalk213.yellow(count10)} ${tool} ${command} ${chalk213.dim(row2.repos)}`
39064
+ `${chalk214.yellow(count10)} ${tool} ${command} ${chalk214.dim(row2.repos)}`
39043
39065
  );
39044
39066
  }
39045
39067
  }
@@ -39077,13 +39099,13 @@ import { execSync as execSync44 } from "child_process";
39077
39099
  import enquirer9 from "enquirer";
39078
39100
 
39079
39101
  // src/commands/prs/prs/displayPaginated/printPr.ts
39080
- import chalk214 from "chalk";
39102
+ import chalk215 from "chalk";
39081
39103
  var STATUS_MAP = {
39082
- MERGED: (pr) => pr.mergedAt ? { label: chalk214.magenta("merged"), date: pr.mergedAt } : null,
39083
- CLOSED: (pr) => pr.closedAt ? { label: chalk214.red("closed"), date: pr.closedAt } : null
39104
+ MERGED: (pr) => pr.mergedAt ? { label: chalk215.magenta("merged"), date: pr.mergedAt } : null,
39105
+ CLOSED: (pr) => pr.closedAt ? { label: chalk215.red("closed"), date: pr.closedAt } : null
39084
39106
  };
39085
39107
  function defaultStatus(pr) {
39086
- return { label: chalk214.green("opened"), date: pr.createdAt };
39108
+ return { label: chalk215.green("opened"), date: pr.createdAt };
39087
39109
  }
39088
39110
  function getStatus(pr) {
39089
39111
  return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -39092,11 +39114,11 @@ function formatDate2(dateStr) {
39092
39114
  return new Date(dateStr).toISOString().split("T")[0];
39093
39115
  }
39094
39116
  function formatPrHeader(pr, status2) {
39095
- return `${chalk214.cyan(`#${pr.number}`)} ${pr.title} ${chalk214.dim(`(${pr.author.login},`)} ${status2.label} ${chalk214.dim(`${formatDate2(status2.date)})`)}`;
39117
+ return `${chalk215.cyan(`#${pr.number}`)} ${pr.title} ${chalk215.dim(`(${pr.author.login},`)} ${status2.label} ${chalk215.dim(`${formatDate2(status2.date)})`)}`;
39096
39118
  }
39097
39119
  function logPrDetails(pr) {
39098
39120
  console.log(
39099
- chalk214.dim(` ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
39121
+ chalk215.dim(` ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
39100
39122
  );
39101
39123
  console.log();
39102
39124
  }
@@ -39664,13 +39686,13 @@ function agentFooter(unresolvedCount) {
39664
39686
  }
39665
39687
 
39666
39688
  // src/commands/prs/listComments/commentStyle.ts
39667
- import chalk215 from "chalk";
39689
+ import chalk216 from "chalk";
39668
39690
  var plain = (text19) => text19;
39669
39691
  function colouredState(state) {
39670
39692
  const label = `[${state}]`;
39671
- if (state === "APPROVED") return chalk215.green(label);
39672
- if (state === "CHANGES_REQUESTED") return chalk215.red(label);
39673
- return chalk215.yellow(label);
39693
+ if (state === "APPROVED") return chalk216.green(label);
39694
+ if (state === "CHANGES_REQUESTED") return chalk216.red(label);
39695
+ return chalk216.yellow(label);
39674
39696
  }
39675
39697
  function commentStyle() {
39676
39698
  if (isAgentHarness()) {
@@ -39684,9 +39706,9 @@ function commentStyle() {
39684
39706
  };
39685
39707
  }
39686
39708
  return {
39687
- cyan: chalk215.cyan,
39688
- bold: chalk215.bold,
39689
- dim: chalk215.dim,
39709
+ cyan: chalk216.cyan,
39710
+ bold: chalk216.bold,
39711
+ dim: chalk216.dim,
39690
39712
  state: colouredState,
39691
39713
  diffHunk: true,
39692
39714
  agent: false
@@ -41164,16 +41186,16 @@ function buildPrsStatusReport(repoArguments, now = Date.now()) {
41164
41186
  }
41165
41187
 
41166
41188
  // src/commands/prs/status/printPrsStatus.ts
41167
- import chalk217 from "chalk";
41189
+ import chalk218 from "chalk";
41168
41190
 
41169
41191
  // src/commands/prs/status/printPrStatus.ts
41170
- import chalk216 from "chalk";
41192
+ import chalk217 from "chalk";
41171
41193
  function flags(pr) {
41172
41194
  const markers = [];
41173
41195
  if (pr.isDraft) markers.push("draft");
41174
41196
  if (pr.isDoNotMerge) markers.push("do not merge");
41175
41197
  if (pr.isBot) markers.push("bot");
41176
- return markers.length ? ` ${chalk216.yellow(`[${markers.join(", ")}]`)}` : "";
41198
+ return markers.length ? ` ${chalk217.yellow(`[${markers.join(", ")}]`)}` : "";
41177
41199
  }
41178
41200
  function updated(pr) {
41179
41201
  return pr.ageHours === null ? "updated unknown" : `updated ${pr.age} ago`;
@@ -41187,35 +41209,35 @@ function reviewLine(pr) {
41187
41209
  function checkLines(pr) {
41188
41210
  const lines = [];
41189
41211
  if (pr.checks.failing.length) {
41190
- lines.push(chalk216.red(`failing: ${pr.checks.failing.join(", ")}`));
41212
+ lines.push(chalk217.red(`failing: ${pr.checks.failing.join(", ")}`));
41191
41213
  }
41192
41214
  if (pr.checks.pending.length) {
41193
- lines.push(chalk216.yellow(`pending: ${pr.checks.pending.join(", ")}`));
41215
+ lines.push(chalk217.yellow(`pending: ${pr.checks.pending.join(", ")}`));
41194
41216
  }
41195
41217
  return lines;
41196
41218
  }
41197
41219
  function threadsLine(pr) {
41198
41220
  if (pr.unresolvedThreads === null) {
41199
- return chalk216.dim("unresolved comments: unknown");
41221
+ return chalk217.dim("unresolved comments: unknown");
41200
41222
  }
41201
41223
  if (pr.unresolvedThreads === 0) return null;
41202
- return chalk216.yellow(`unresolved comments: ${pr.unresolvedThreads}`);
41224
+ return chalk217.yellow(`unresolved comments: ${pr.unresolvedThreads}`);
41203
41225
  }
41204
41226
  function mergeableLine(pr) {
41205
- if (pr.mergeable === "CONFLICTING") return chalk216.red("conflicting");
41227
+ if (pr.mergeable === "CONFLICTING") return chalk217.red("conflicting");
41206
41228
  if (pr.mergeable === "MERGEABLE") return null;
41207
- return chalk216.dim(`mergeable: ${pr.mergeable.toLowerCase()}`);
41229
+ return chalk217.dim(`mergeable: ${pr.mergeable.toLowerCase()}`);
41208
41230
  }
41209
41231
  function printPrStatus(pr) {
41210
41232
  console.log(
41211
- ` ${chalk216.cyan(`#${pr.number}`)} ${pr.title} ${chalk216.dim(`(${pr.author}, ${updated(pr)})`)}${flags(pr)}`
41233
+ ` ${chalk217.cyan(`#${pr.number}`)} ${pr.title} ${chalk217.dim(`(${pr.author}, ${updated(pr)})`)}${flags(pr)}`
41212
41234
  );
41213
41235
  const details = [
41214
41236
  reviewLine(pr),
41215
41237
  ...checkLines(pr),
41216
41238
  threadsLine(pr),
41217
41239
  mergeableLine(pr),
41218
- chalk216.dim(pr.url)
41240
+ chalk217.dim(pr.url)
41219
41241
  ];
41220
41242
  for (const detail of details) {
41221
41243
  if (detail) console.log(` ${detail}`);
@@ -41226,17 +41248,17 @@ function printPrStatus(pr) {
41226
41248
  function printPrsStatus(report) {
41227
41249
  for (const repo of report.repos) {
41228
41250
  const count10 = repo.pullRequests.length;
41229
- console.log(`${chalk217.bold(repo.repo)} ${chalk217.dim(`(${count10} open)`)}`);
41251
+ console.log(`${chalk218.bold(repo.repo)} ${chalk218.dim(`(${count10} open)`)}`);
41230
41252
  for (const pr of repo.pullRequests) {
41231
41253
  printPrStatus(pr);
41232
41254
  }
41233
- if (count10 === 0) console.log(chalk217.dim(" no open pull requests"));
41255
+ if (count10 === 0) console.log(chalk218.dim(" no open pull requests"));
41234
41256
  console.log();
41235
41257
  }
41236
41258
  if (report.errors.length === 0) return;
41237
- console.log(chalk217.bold("Errors"));
41259
+ console.log(chalk218.bold("Errors"));
41238
41260
  for (const failure2 of report.errors) {
41239
- console.log(` ${chalk217.red(failure2.repo)}: ${failure2.error}`);
41261
+ console.log(` ${chalk218.red(failure2.repo)}: ${failure2.error}`);
41240
41262
  }
41241
41263
  console.log();
41242
41264
  }
@@ -41464,10 +41486,10 @@ function registerPrs(program) {
41464
41486
  }
41465
41487
 
41466
41488
  // src/commands/ravendb/ravendbAuth.ts
41467
- import chalk223 from "chalk";
41489
+ import chalk224 from "chalk";
41468
41490
 
41469
41491
  // src/shared/createConnectionAuth.ts
41470
- import chalk218 from "chalk";
41492
+ import chalk219 from "chalk";
41471
41493
  function listConnections(connections, format2) {
41472
41494
  if (connections.length === 0) {
41473
41495
  console.log("No connections configured.");
@@ -41480,7 +41502,7 @@ function listConnections(connections, format2) {
41480
41502
  function removeConnection(connections, name2, save) {
41481
41503
  const filtered = connections.filter((c) => c.name !== name2);
41482
41504
  if (filtered.length === connections.length) {
41483
- console.error(chalk218.red(`Connection "${name2}" not found.`));
41505
+ console.error(chalk219.red(`Connection "${name2}" not found.`));
41484
41506
  process.exit(1);
41485
41507
  }
41486
41508
  save(filtered);
@@ -41526,15 +41548,15 @@ function saveConnections(connections) {
41526
41548
  }
41527
41549
 
41528
41550
  // src/commands/ravendb/promptConnection.ts
41529
- import chalk221 from "chalk";
41551
+ import chalk222 from "chalk";
41530
41552
 
41531
41553
  // src/commands/ravendb/selectOpSecret.ts
41532
- import chalk220 from "chalk";
41554
+ import chalk221 from "chalk";
41533
41555
  import Enquirer2 from "enquirer";
41534
41556
 
41535
41557
  // src/commands/ravendb/searchItems.ts
41536
41558
  import { execSync as execSync51 } from "child_process";
41537
- import chalk219 from "chalk";
41559
+ import chalk220 from "chalk";
41538
41560
  function opExec(args) {
41539
41561
  return execSync51(`op ${args}`, {
41540
41562
  encoding: "utf8",
@@ -41547,7 +41569,7 @@ function searchItems(search2) {
41547
41569
  items3 = JSON.parse(opExec("item list --format=json"));
41548
41570
  } catch {
41549
41571
  console.error(
41550
- chalk219.red(
41572
+ chalk220.red(
41551
41573
  "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
41552
41574
  )
41553
41575
  );
@@ -41561,7 +41583,7 @@ function getItemFields(itemId2) {
41561
41583
  const item = JSON.parse(opExec(`item get "${itemId2}" --format=json`));
41562
41584
  return item.fields.filter((f) => f.reference && f.label);
41563
41585
  } catch {
41564
- console.error(chalk219.red("Failed to get item details from 1Password."));
41586
+ console.error(chalk220.red("Failed to get item details from 1Password."));
41565
41587
  process.exit(1);
41566
41588
  }
41567
41589
  }
@@ -41580,7 +41602,7 @@ async function selectOpSecret(searchTerm) {
41580
41602
  }).run();
41581
41603
  const items3 = searchItems(search2);
41582
41604
  if (items3.length === 0) {
41583
- console.error(chalk220.red(`No items found matching "${search2}".`));
41605
+ console.error(chalk221.red(`No items found matching "${search2}".`));
41584
41606
  process.exit(1);
41585
41607
  }
41586
41608
  const itemId2 = await selectOne(
@@ -41589,7 +41611,7 @@ async function selectOpSecret(searchTerm) {
41589
41611
  );
41590
41612
  const fields = getItemFields(itemId2);
41591
41613
  if (fields.length === 0) {
41592
- console.error(chalk220.red("No fields with references found on this item."));
41614
+ console.error(chalk221.red("No fields with references found on this item."));
41593
41615
  process.exit(1);
41594
41616
  }
41595
41617
  const ref = await selectOne(
@@ -41603,7 +41625,7 @@ async function selectOpSecret(searchTerm) {
41603
41625
  async function promptConnection(existingNames) {
41604
41626
  const name2 = await promptInput("name", "Connection name:");
41605
41627
  if (existingNames.includes(name2)) {
41606
- console.error(chalk221.red(`Connection "${name2}" already exists.`));
41628
+ console.error(chalk222.red(`Connection "${name2}" already exists.`));
41607
41629
  process.exit(1);
41608
41630
  }
41609
41631
  const url = await promptInput(
@@ -41612,22 +41634,22 @@ async function promptConnection(existingNames) {
41612
41634
  );
41613
41635
  const database = await promptInput("database", "Database name:");
41614
41636
  if (!name2 || !url || !database) {
41615
- console.error(chalk221.red("All fields are required."));
41637
+ console.error(chalk222.red("All fields are required."));
41616
41638
  process.exit(1);
41617
41639
  }
41618
41640
  const apiKeyRef = await selectOpSecret();
41619
- console.log(chalk221.dim(`Using: ${apiKeyRef}`));
41641
+ console.log(chalk222.dim(`Using: ${apiKeyRef}`));
41620
41642
  return { name: name2, url, database, apiKeyRef };
41621
41643
  }
41622
41644
 
41623
41645
  // src/commands/ravendb/ravendbSetConnection.ts
41624
- import chalk222 from "chalk";
41646
+ import chalk223 from "chalk";
41625
41647
  function ravendbSetConnection(name2) {
41626
41648
  const raw = loadGlobalConfigRaw();
41627
41649
  const ravendb = raw.ravendb ?? {};
41628
41650
  const connections = ravendb.connections ?? [];
41629
41651
  if (!connections.some((c) => c.name === name2)) {
41630
- console.error(chalk222.red(`Connection "${name2}" not found.`));
41652
+ console.error(chalk223.red(`Connection "${name2}" not found.`));
41631
41653
  console.error(
41632
41654
  `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
41633
41655
  );
@@ -41643,16 +41665,16 @@ function ravendbSetConnection(name2) {
41643
41665
  var ravendbAuth = createConnectionAuth({
41644
41666
  load: loadConnections,
41645
41667
  save: saveConnections,
41646
- format: (c) => `${chalk223.bold(c.name)} ${c.url} db=${c.database} key=${c.apiKeyRef}`,
41668
+ format: (c) => `${chalk224.bold(c.name)} ${c.url} db=${c.database} key=${c.apiKeyRef}`,
41647
41669
  promptNew: promptConnection,
41648
41670
  onFirst: (c) => ravendbSetConnection(c.name)
41649
41671
  });
41650
41672
 
41651
41673
  // src/commands/ravendb/ravendbCollections.ts
41652
- import chalk227 from "chalk";
41674
+ import chalk228 from "chalk";
41653
41675
 
41654
41676
  // src/commands/ravendb/ravenFetch.ts
41655
- import chalk225 from "chalk";
41677
+ import chalk226 from "chalk";
41656
41678
 
41657
41679
  // src/commands/ravendb/getAccessToken.ts
41658
41680
  var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -41689,10 +41711,10 @@ ${errorText}`
41689
41711
 
41690
41712
  // src/commands/ravendb/resolveOpSecret.ts
41691
41713
  import { execSync as execSync52 } from "child_process";
41692
- import chalk224 from "chalk";
41714
+ import chalk225 from "chalk";
41693
41715
  function resolveOpSecret(reference) {
41694
41716
  if (!reference.startsWith("op://")) {
41695
- console.error(chalk224.red(`Invalid secret reference: must start with op://`));
41717
+ console.error(chalk225.red(`Invalid secret reference: must start with op://`));
41696
41718
  process.exit(1);
41697
41719
  }
41698
41720
  try {
@@ -41702,7 +41724,7 @@ function resolveOpSecret(reference) {
41702
41724
  }).trim();
41703
41725
  } catch {
41704
41726
  console.error(
41705
- chalk224.red(
41727
+ chalk225.red(
41706
41728
  "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
41707
41729
  )
41708
41730
  );
@@ -41729,7 +41751,7 @@ async function ravenFetch(connection, path118) {
41729
41751
  if (!response.ok) {
41730
41752
  const body = await response.text();
41731
41753
  console.error(
41732
- chalk225.red(`RavenDB error: ${response.status} ${response.statusText}`)
41754
+ chalk226.red(`RavenDB error: ${response.status} ${response.statusText}`)
41733
41755
  );
41734
41756
  console.error(body.substring(0, 500));
41735
41757
  process.exit(1);
@@ -41738,7 +41760,7 @@ async function ravenFetch(connection, path118) {
41738
41760
  }
41739
41761
 
41740
41762
  // src/commands/ravendb/resolveConnection.ts
41741
- import chalk226 from "chalk";
41763
+ import chalk227 from "chalk";
41742
41764
  function loadRavendb() {
41743
41765
  const raw = loadGlobalConfigRaw();
41744
41766
  const ravendb = raw.ravendb;
@@ -41752,7 +41774,7 @@ function resolveConnection(name2) {
41752
41774
  const connectionName = name2 ?? defaultConnection;
41753
41775
  if (!connectionName) {
41754
41776
  console.error(
41755
- chalk226.red(
41777
+ chalk227.red(
41756
41778
  "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
41757
41779
  )
41758
41780
  );
@@ -41760,7 +41782,7 @@ function resolveConnection(name2) {
41760
41782
  }
41761
41783
  const connection = connections.find((c) => c.name === connectionName);
41762
41784
  if (!connection) {
41763
- console.error(chalk226.red(`Connection "${connectionName}" not found.`));
41785
+ console.error(chalk227.red(`Connection "${connectionName}" not found.`));
41764
41786
  console.error(
41765
41787
  `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
41766
41788
  );
@@ -41791,15 +41813,15 @@ async function ravendbCollections(connectionName) {
41791
41813
  return;
41792
41814
  }
41793
41815
  for (const c of collections) {
41794
- console.log(`${chalk227.bold(c.Name)} ${c.CountOfDocuments} docs`);
41816
+ console.log(`${chalk228.bold(c.Name)} ${c.CountOfDocuments} docs`);
41795
41817
  }
41796
41818
  }
41797
41819
 
41798
41820
  // src/commands/ravendb/ravendbQuery.ts
41799
- import chalk229 from "chalk";
41821
+ import chalk230 from "chalk";
41800
41822
 
41801
41823
  // src/commands/ravendb/fetchAllPages.ts
41802
- import chalk228 from "chalk";
41824
+ import chalk229 from "chalk";
41803
41825
 
41804
41826
  // src/commands/ravendb/buildQueryPath.ts
41805
41827
  function buildQueryPath(opts) {
@@ -41837,7 +41859,7 @@ async function fetchAllPages(connection, opts) {
41837
41859
  allResults.push(...results);
41838
41860
  start2 += results.length;
41839
41861
  process.stderr.write(
41840
- `\r${chalk228.dim(`Fetched ${allResults.length}/${totalResults}`)}`
41862
+ `\r${chalk229.dim(`Fetched ${allResults.length}/${totalResults}`)}`
41841
41863
  );
41842
41864
  if (start2 >= totalResults) break;
41843
41865
  if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -41852,7 +41874,7 @@ async function fetchAllPages(connection, opts) {
41852
41874
  async function ravendbQuery(connectionName, collection, options2) {
41853
41875
  const resolved = resolveArgs(connectionName, collection);
41854
41876
  if (!resolved.collection && !options2.query) {
41855
- console.error(chalk229.red("Provide a collection name or --query filter."));
41877
+ console.error(chalk230.red("Provide a collection name or --query filter."));
41856
41878
  process.exit(1);
41857
41879
  }
41858
41880
  const { collection: col } = resolved;
@@ -41887,7 +41909,7 @@ function registerRavendb(program) {
41887
41909
  }
41888
41910
 
41889
41911
  // src/commands/releases/releasesConfigure.ts
41890
- import chalk231 from "chalk";
41912
+ import chalk232 from "chalk";
41891
41913
 
41892
41914
  // src/commands/config/parseRepoScopeFlag.ts
41893
41915
  var REPO_SCOPE_FLAGS = {
@@ -41958,26 +41980,26 @@ function readStreamsInput(source) {
41958
41980
  }
41959
41981
 
41960
41982
  // src/commands/releases/reportDerivedStreams.ts
41961
- import chalk230 from "chalk";
41983
+ import chalk231 from "chalk";
41962
41984
  function printDerived(stream) {
41963
41985
  const environments = stream.nodes.flatMap((n) => n.environment ?? []);
41964
41986
  const steps = stream.nodes.filter((n) => !n.environment);
41965
41987
  console.log(
41966
- `${chalk230.bold(stream.name)} ${chalk230.dim(`${stream.repo} \xB7 ${stream.workflow}`)}`
41988
+ `${chalk231.bold(stream.name)} ${chalk231.dim(`${stream.repo} \xB7 ${stream.workflow}`)}`
41967
41989
  );
41968
41990
  console.log(
41969
- ` environments: ${environments.join(", ") || chalk230.dim("none")}`
41991
+ ` environments: ${environments.join(", ") || chalk231.dim("none")}`
41970
41992
  );
41971
41993
  if (steps.length > 0)
41972
41994
  console.log(
41973
41995
  ` steps: ${steps.map((n) => `${n.id} [${n.kind ?? "step"}]`).join(", ")}`
41974
41996
  );
41975
41997
  const edges = stream.edges.map(([from, to]) => `${from} \u2192 ${to}`);
41976
- console.log(` edges: ${edges.join(", ") || chalk230.dim("none")}`);
41998
+ console.log(` edges: ${edges.join(", ") || chalk231.dim("none")}`);
41977
41999
  }
41978
42000
  function reportDerivedStreams(streams, target) {
41979
42001
  for (const stream of streams) printDerived(stream);
41980
- console.log(chalk230.dim(`Written to ${target}`));
42002
+ console.log(chalk231.dim(`Written to ${target}`));
41981
42003
  }
41982
42004
 
41983
42005
  // src/commands/releases/withCurrentRepo.ts
@@ -42068,8 +42090,8 @@ async function writeReleaseStreams(incoming, scope) {
42068
42090
 
42069
42091
  // src/commands/releases/releasesConfigure.ts
42070
42092
  function fail11(message4, details = []) {
42071
- console.error(chalk231.red(message4));
42072
- for (const detail of details) console.error(chalk231.red(` ${detail}`));
42093
+ console.error(chalk232.red(message4));
42094
+ for (const detail of details) console.error(chalk232.red(` ${detail}`));
42073
42095
  process.exitCode = 1;
42074
42096
  }
42075
42097
  function reportWritten(incoming, target) {
@@ -42102,23 +42124,23 @@ async function releasesConfigure(options2 = {}) {
42102
42124
  }
42103
42125
 
42104
42126
  // src/commands/releases/releasesList.ts
42105
- import chalk232 from "chalk";
42127
+ import chalk233 from "chalk";
42106
42128
  function describeNode(node) {
42107
42129
  if (node.environment) return `${node.id} \u2192 ${node.environment}`;
42108
42130
  return `${node.id} (${node.kind ?? "step"})`;
42109
42131
  }
42110
42132
  function printStream(stream) {
42111
- console.log(`${chalk232.bold(stream.name)} ${chalk232.dim(stream.repo)}`);
42112
- console.log(chalk232.dim(` workflow: ${stream.workflow}`));
42133
+ console.log(`${chalk233.bold(stream.name)} ${chalk233.dim(stream.repo)}`);
42134
+ console.log(chalk233.dim(` workflow: ${stream.workflow}`));
42113
42135
  for (const node of stream.nodes) console.log(` ${describeNode(node)}`);
42114
42136
  for (const [from, to] of stream.edges)
42115
- console.log(chalk232.dim(` ${from} \u2192 ${to}`));
42137
+ console.log(chalk233.dim(` ${from} \u2192 ${to}`));
42116
42138
  }
42117
42139
  function releasesList() {
42118
42140
  const streams = loadConfig().releases?.streams ?? [];
42119
42141
  if (streams.length === 0) {
42120
42142
  console.log(
42121
- chalk232.dim("No release streams configured under releases.streams.")
42143
+ chalk233.dim("No release streams configured under releases.streams.")
42122
42144
  );
42123
42145
  return;
42124
42146
  }
@@ -42166,7 +42188,7 @@ function coverage() {
42166
42188
 
42167
42189
  // src/commands/lint/lint/runFileNameCheck.ts
42168
42190
  import path54 from "path";
42169
- import chalk234 from "chalk";
42191
+ import chalk235 from "chalk";
42170
42192
 
42171
42193
  // src/commands/lint/lint/checkFileNames.ts
42172
42194
  import fs32 from "fs";
@@ -42246,7 +42268,7 @@ function checkFileNames() {
42246
42268
  }
42247
42269
 
42248
42270
  // src/commands/lint/lint/fixFileNameViolations.ts
42249
- import chalk233 from "chalk";
42271
+ import chalk234 from "chalk";
42250
42272
 
42251
42273
  // src/commands/lint/lint/applyMoves.ts
42252
42274
  import fs33 from "fs";
@@ -42331,25 +42353,25 @@ function fixFileNameViolations(moves) {
42331
42353
  const start2 = performance.now();
42332
42354
  const project = createLintProject();
42333
42355
  const cwd = process.cwd();
42334
- applyMoves(project, moves, cwd, (line) => console.log(chalk233.green(line)));
42356
+ applyMoves(project, moves, cwd, (line) => console.log(chalk234.green(line)));
42335
42357
  const ms = (performance.now() - start2).toFixed(0);
42336
- console.log(chalk233.dim(` Done in ${ms}ms`));
42358
+ console.log(chalk234.dim(` Done in ${ms}ms`));
42337
42359
  }
42338
42360
 
42339
42361
  // src/commands/lint/lint/runFileNameCheck.ts
42340
42362
  function reportViolations(violations) {
42341
- console.error(chalk234.red("\nFile name check failed:\n"));
42363
+ console.error(chalk235.red("\nFile name check failed:\n"));
42342
42364
  console.error(
42343
- chalk234.red(
42365
+ chalk235.red(
42344
42366
  " Files without classes or React components should not start with a capital letter.\n"
42345
42367
  )
42346
42368
  );
42347
42369
  for (const violation of violations) {
42348
- console.error(chalk234.red(` ${violation.filePath}`));
42349
- console.error(chalk234.gray(` Rename to: ${violation.suggestedName}
42370
+ console.error(chalk235.red(` ${violation.filePath}`));
42371
+ console.error(chalk235.gray(` Rename to: ${violation.suggestedName}
42350
42372
  `));
42351
42373
  }
42352
- console.error(chalk234.dim(" Run with -f to auto-fix.\n"));
42374
+ console.error(chalk235.dim(" Run with -f to auto-fix.\n"));
42353
42375
  }
42354
42376
  function runFileNameCheck(fix = false) {
42355
42377
  const violations = checkFileNames();
@@ -42378,17 +42400,17 @@ function runFileNameCheck(fix = false) {
42378
42400
  import fs35 from "fs";
42379
42401
 
42380
42402
  // src/commands/lint/shared.ts
42381
- import chalk235 from "chalk";
42403
+ import chalk236 from "chalk";
42382
42404
  function reportViolations2(violations, checkName2, errorMessage3, successMessage) {
42383
42405
  if (violations.length > 0) {
42384
- console.error(chalk235.red(`
42406
+ console.error(chalk236.red(`
42385
42407
  ${checkName2} failed:
42386
42408
  `));
42387
- console.error(chalk235.red(` ${errorMessage3}
42409
+ console.error(chalk236.red(` ${errorMessage3}
42388
42410
  `));
42389
42411
  for (const violation of violations) {
42390
- console.error(chalk235.red(` ${violation.filePath}:${violation.line}`));
42391
- console.error(chalk235.gray(` ${violation.content}
42412
+ console.error(chalk236.red(` ${violation.filePath}:${violation.line}`));
42413
+ console.error(chalk236.gray(` ${violation.content}
42392
42414
  `));
42393
42415
  }
42394
42416
  return false;
@@ -42615,7 +42637,7 @@ import { execSync as execSync54 } from "child_process";
42615
42637
  import { existsSync as existsSync77, mkdirSync as mkdirSync33, unlinkSync as unlinkSync17, writeFileSync as writeFileSync48 } from "fs";
42616
42638
  import { tmpdir as tmpdir8 } from "os";
42617
42639
  import { join as join98, resolve as resolve28 } from "path";
42618
- import chalk236 from "chalk";
42640
+ import chalk237 from "chalk";
42619
42641
 
42620
42642
  // src/commands/screenshot/captureWindowPs1.ts
42621
42643
  var captureWindowPs1 = `
@@ -42766,22 +42788,22 @@ function screenshot(processName) {
42766
42788
  const config = loadConfig();
42767
42789
  const outputDir = resolve28(config.screenshot.outputDir);
42768
42790
  const outputPath = buildOutputPath(outputDir, processName);
42769
- console.log(chalk236.gray(`Capturing window for process "${processName}" ...`));
42791
+ console.log(chalk237.gray(`Capturing window for process "${processName}" ...`));
42770
42792
  try {
42771
42793
  runPowerShellScript(processName, outputPath);
42772
- console.log(chalk236.green(`Screenshot saved: ${outputPath}`));
42794
+ console.log(chalk237.green(`Screenshot saved: ${outputPath}`));
42773
42795
  } catch (error) {
42774
42796
  const msg = error instanceof Error ? error.message : String(error);
42775
- console.error(chalk236.red(`Failed to capture screenshot: ${msg}`));
42797
+ console.error(chalk237.red(`Failed to capture screenshot: ${msg}`));
42776
42798
  process.exit(1);
42777
42799
  }
42778
42800
  }
42779
42801
 
42780
42802
  // src/commands/statusLine.ts
42781
- import chalk239 from "chalk";
42803
+ import chalk240 from "chalk";
42782
42804
 
42783
42805
  // src/commands/buildLimitsSegment.ts
42784
- import chalk237 from "chalk";
42806
+ import chalk238 from "chalk";
42785
42807
 
42786
42808
  // src/shared/rateLimitLevel.ts
42787
42809
  var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -42819,9 +42841,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
42819
42841
 
42820
42842
  // src/commands/buildLimitsSegment.ts
42821
42843
  var LEVEL_COLOR = {
42822
- ok: chalk237.green,
42823
- warn: chalk237.yellow,
42824
- over: chalk237.red
42844
+ ok: chalk238.green,
42845
+ warn: chalk238.yellow,
42846
+ over: chalk238.red
42825
42847
  };
42826
42848
  function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
42827
42849
  const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -42917,7 +42939,7 @@ async function relayUsage(claudeSessionId, transcriptPath, usedPct) {
42917
42939
  }
42918
42940
 
42919
42941
  // src/commands/colorizePercent.ts
42920
- import chalk238 from "chalk";
42942
+ import chalk239 from "chalk";
42921
42943
 
42922
42944
  // src/shared/contextLevel.ts
42923
42945
  var THRESHOLDS = {
@@ -42937,16 +42959,16 @@ function colorizePercent(pct) {
42937
42959
  const label = `${Math.round(pct)}%`;
42938
42960
  switch (contextLevel(pct)) {
42939
42961
  case "red":
42940
- return chalk238.red(label);
42962
+ return chalk239.red(label);
42941
42963
  case "yellow":
42942
- return chalk238.yellow(label);
42964
+ return chalk239.yellow(label);
42943
42965
  default:
42944
42966
  return label;
42945
42967
  }
42946
42968
  }
42947
42969
 
42948
42970
  // src/commands/statusLine.ts
42949
- chalk239.level = 3;
42971
+ chalk240.level = 3;
42950
42972
  function formatNumber(num) {
42951
42973
  return num.toLocaleString("en-US");
42952
42974
  }
@@ -42958,7 +42980,7 @@ async function statusLine() {
42958
42980
  const usedPct = data.context_window.used_percentage ?? 0;
42959
42981
  const dir = data.workspace?.current_dir ?? data.cwd;
42960
42982
  const branch2 = dir ? readGitBranch(dir) : null;
42961
- const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk239.cyan(branch2)} | ` : "";
42983
+ const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk240.cyan(branch2)} | ` : "";
42962
42984
  const limitsSegment = process.env.ASSIST_SESSION === "1" ? "" : buildLimitsSegment(data.rate_limits);
42963
42985
  console.log(
42964
42986
  `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${limitsSegment}`
@@ -43066,7 +43088,7 @@ import { spawn as spawn11 } from "child_process";
43066
43088
  import * as path57 from "path";
43067
43089
 
43068
43090
  // src/commands/refactor/logViolations.ts
43069
- import chalk240 from "chalk";
43091
+ import chalk241 from "chalk";
43070
43092
  var DEFAULT_MAX_LINES2 = 100;
43071
43093
  function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
43072
43094
  if (violations.length === 0) {
@@ -43075,43 +43097,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
43075
43097
  }
43076
43098
  return;
43077
43099
  }
43078
- console.error(chalk240.red(`
43100
+ console.error(chalk241.red(`
43079
43101
  Refactor check failed:
43080
43102
  `));
43081
- console.error(chalk240.red(` The following files exceed ${maxLines} lines:
43103
+ console.error(chalk241.red(` The following files exceed ${maxLines} lines:
43082
43104
  `));
43083
43105
  for (const violation of violations) {
43084
- console.error(chalk240.red(` ${violation.file} (${violation.lines} lines)`));
43106
+ console.error(chalk241.red(` ${violation.file} (${violation.lines} lines)`));
43085
43107
  }
43086
43108
  console.error(
43087
- chalk240.yellow(
43109
+ chalk241.yellow(
43088
43110
  `
43089
43111
  Each file needs to be sensibly refactored, or if there is no sensible
43090
43112
  way to refactor it, ignore it with:
43091
43113
  `
43092
43114
  )
43093
43115
  );
43094
- console.error(chalk240.gray(` assist refactor ignore <file>
43116
+ console.error(chalk241.gray(` assist refactor ignore <file>
43095
43117
  `));
43096
43118
  if (isAgentHarness()) {
43097
- console.error(chalk240.cyan(`
43119
+ console.error(chalk241.cyan(`
43098
43120
  ## Extracting Code to New Files
43099
43121
  `));
43100
43122
  console.error(
43101
- chalk240.cyan(
43123
+ chalk241.cyan(
43102
43124
  ` When extracting logic from one file to another, consider where the extracted code belongs:
43103
43125
  `
43104
43126
  )
43105
43127
  );
43106
43128
  console.error(
43107
- chalk240.cyan(
43129
+ chalk241.cyan(
43108
43130
  ` 1. Keep related logic together: If the extracted code is tightly coupled to the
43109
43131
  original file's domain, create a new folder containing both the original and extracted files.
43110
43132
  `
43111
43133
  )
43112
43134
  );
43113
43135
  console.error(
43114
- chalk240.cyan(
43136
+ chalk241.cyan(
43115
43137
  ` 2. Share common utilities: If the extracted code can be reused across multiple
43116
43138
  domains, move it to a common/shared folder.
43117
43139
  `
@@ -43267,7 +43289,7 @@ async function check(pattern2, options2) {
43267
43289
 
43268
43290
  // src/commands/refactor/extract.ts
43269
43291
  import path65 from "path";
43270
- import chalk243 from "chalk";
43292
+ import chalk244 from "chalk";
43271
43293
 
43272
43294
  // src/commands/refactor/extract/applyExtraction.ts
43273
43295
  import { SyntaxKind as SyntaxKind8 } from "ts-morph";
@@ -43875,23 +43897,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
43875
43897
 
43876
43898
  // src/commands/refactor/extract/displayPlan.ts
43877
43899
  import path61 from "path";
43878
- import chalk241 from "chalk";
43900
+ import chalk242 from "chalk";
43879
43901
  function section(title) {
43880
43902
  return `
43881
- ${chalk241.cyan(title)}`;
43903
+ ${chalk242.cyan(title)}`;
43882
43904
  }
43883
43905
  function displayImporters(plan2, cwd) {
43884
43906
  if (plan2.importersToUpdate.length === 0) return;
43885
43907
  console.log(section("Update importers:"));
43886
43908
  for (const imp of plan2.importersToUpdate) {
43887
43909
  const rel = path61.relative(cwd, imp.file.getFilePath());
43888
- console.log(` ${chalk241.dim(rel)}: \u2192 import from "${imp.relPath}"`);
43910
+ console.log(` ${chalk242.dim(rel)}: \u2192 import from "${imp.relPath}"`);
43889
43911
  }
43890
43912
  }
43891
43913
  function displayPlan(functionName, relDest, plan2, cwd) {
43892
- console.log(chalk241.bold(`Extract: ${functionName} \u2192 ${relDest}
43914
+ console.log(chalk242.bold(`Extract: ${functionName} \u2192 ${relDest}
43893
43915
  `));
43894
- console.log(` ${chalk241.cyan("Functions to move:")}`);
43916
+ console.log(` ${chalk242.cyan("Functions to move:")}`);
43895
43917
  for (const name2 of plan2.extractedNames) {
43896
43918
  console.log(` ${name2}`);
43897
43919
  }
@@ -43925,7 +43947,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
43925
43947
 
43926
43948
  // src/commands/refactor/extract/loadProjectFile.ts
43927
43949
  import path64 from "path";
43928
- import chalk242 from "chalk";
43950
+ import chalk243 from "chalk";
43929
43951
  import { Project as Project4 } from "ts-morph";
43930
43952
 
43931
43953
  // src/commands/refactor/extract/findTsConfig.ts
@@ -44017,7 +44039,7 @@ function loadProjectFile(file) {
44017
44039
  });
44018
44040
  const sourceFile = project.getSourceFile(sourcePath);
44019
44041
  if (!sourceFile) {
44020
- console.log(chalk242.red(`File not found in project: ${file}`));
44042
+ console.log(chalk243.red(`File not found in project: ${file}`));
44021
44043
  process.exit(1);
44022
44044
  }
44023
44045
  return { project, sourceFile };
@@ -44040,19 +44062,19 @@ async function extract(file, functionName, destination, options2 = {}) {
44040
44062
  displayPlan(functionName, relDest, plan2, cwd);
44041
44063
  if (options2.apply) {
44042
44064
  await applyExtraction(functionName, sourceFile, destPath, plan2, project);
44043
- console.log(chalk243.green("\nExtraction complete"));
44065
+ console.log(chalk244.green("\nExtraction complete"));
44044
44066
  } else {
44045
- console.log(chalk243.dim("\nDry run. Use --apply to execute."));
44067
+ console.log(chalk244.dim("\nDry run. Use --apply to execute."));
44046
44068
  }
44047
44069
  }
44048
44070
 
44049
44071
  // src/commands/refactor/ignore.ts
44050
44072
  import fs42 from "fs";
44051
- import chalk244 from "chalk";
44073
+ import chalk245 from "chalk";
44052
44074
  var REFACTOR_YML_PATH2 = "refactor.yml";
44053
44075
  function ignore2(file) {
44054
44076
  if (!fs42.existsSync(file)) {
44055
- console.error(chalk244.red(`Error: File does not exist: ${file}`));
44077
+ console.error(chalk245.red(`Error: File does not exist: ${file}`));
44056
44078
  process.exit(1);
44057
44079
  }
44058
44080
  const content = fs42.readFileSync(file, "utf8");
@@ -44068,7 +44090,7 @@ function ignore2(file) {
44068
44090
  fs42.writeFileSync(REFACTOR_YML_PATH2, entry);
44069
44091
  }
44070
44092
  console.log(
44071
- chalk244.green(
44093
+ chalk245.green(
44072
44094
  `Added ${file} to refactor ignore list (max ${maxLines} lines)`
44073
44095
  )
44074
44096
  );
@@ -44077,12 +44099,12 @@ function ignore2(file) {
44077
44099
  // src/commands/refactor/rename.ts
44078
44100
  import fs45 from "fs";
44079
44101
  import path71 from "path";
44080
- import chalk247 from "chalk";
44102
+ import chalk248 from "chalk";
44081
44103
 
44082
44104
  // src/commands/refactor/rename/applyRename.ts
44083
44105
  import fs44 from "fs";
44084
44106
  import path67 from "path";
44085
- import chalk245 from "chalk";
44107
+ import chalk246 from "chalk";
44086
44108
 
44087
44109
  // src/commands/refactor/restructure/computeRewrites.ts
44088
44110
  import path66 from "path";
@@ -44188,13 +44210,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
44188
44210
  const updatedContents = applyRewrites(rewrites);
44189
44211
  for (const [file, content] of updatedContents) {
44190
44212
  fs44.writeFileSync(file, content, "utf8");
44191
- console.log(chalk245.cyan(` Updated imports in ${path67.relative(cwd, file)}`));
44213
+ console.log(chalk246.cyan(` Updated imports in ${path67.relative(cwd, file)}`));
44192
44214
  }
44193
44215
  const destDir = path67.dirname(destPath);
44194
44216
  if (!fs44.existsSync(destDir)) fs44.mkdirSync(destDir, { recursive: true });
44195
44217
  fs44.renameSync(sourcePath, destPath);
44196
44218
  console.log(
44197
- chalk245.white(
44219
+ chalk246.white(
44198
44220
  ` Moved ${path67.relative(cwd, sourcePath)} \u2192 ${path67.relative(cwd, destPath)}`
44199
44221
  )
44200
44222
  );
@@ -44344,16 +44366,16 @@ function computeRenameRewrites(sourcePath, destPath) {
44344
44366
 
44345
44367
  // src/commands/refactor/rename/printRenamePreview.ts
44346
44368
  import path70 from "path";
44347
- import chalk246 from "chalk";
44369
+ import chalk247 from "chalk";
44348
44370
  function printRenamePreview(rewrites, cwd) {
44349
44371
  for (const rewrite of rewrites) {
44350
44372
  console.log(
44351
- chalk246.dim(
44373
+ chalk247.dim(
44352
44374
  ` ${path70.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
44353
44375
  )
44354
44376
  );
44355
44377
  }
44356
- console.log(chalk246.dim("Dry run. Use --apply to execute."));
44378
+ console.log(chalk247.dim("Dry run. Use --apply to execute."));
44357
44379
  }
44358
44380
 
44359
44381
  // src/commands/refactor/rename.ts
@@ -44364,20 +44386,20 @@ async function rename(source, destination, options2 = {}) {
44364
44386
  const relSource = path71.relative(cwd, sourcePath);
44365
44387
  const relDest = path71.relative(cwd, destPath);
44366
44388
  if (!fs45.existsSync(sourcePath)) {
44367
- console.log(chalk247.red(`File not found: ${source}`));
44389
+ console.log(chalk248.red(`File not found: ${source}`));
44368
44390
  process.exit(1);
44369
44391
  }
44370
44392
  if (destPath !== sourcePath && fs45.existsSync(destPath)) {
44371
- console.log(chalk247.red(`Destination already exists: ${destination}`));
44393
+ console.log(chalk248.red(`Destination already exists: ${destination}`));
44372
44394
  process.exit(1);
44373
44395
  }
44374
- console.log(chalk247.bold(`Rename: ${relSource} \u2192 ${relDest}`));
44375
- console.log(chalk247.dim("Loading project..."));
44376
- console.log(chalk247.dim("Scanning imports across the project..."));
44396
+ console.log(chalk248.bold(`Rename: ${relSource} \u2192 ${relDest}`));
44397
+ console.log(chalk248.dim("Loading project..."));
44398
+ console.log(chalk248.dim("Scanning imports across the project..."));
44377
44399
  const rewrites = computeRenameRewrites(sourcePath, destPath);
44378
44400
  const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
44379
44401
  console.log(
44380
- chalk247.dim(
44402
+ chalk248.dim(
44381
44403
  `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
44382
44404
  )
44383
44405
  );
@@ -44386,11 +44408,11 @@ async function rename(source, destination, options2 = {}) {
44386
44408
  return;
44387
44409
  }
44388
44410
  applyRename(rewrites, sourcePath, destPath, cwd);
44389
- console.log(chalk247.green("Done"));
44411
+ console.log(chalk248.green("Done"));
44390
44412
  }
44391
44413
 
44392
44414
  // src/commands/refactor/renameSymbol.ts
44393
- import chalk248 from "chalk";
44415
+ import chalk249 from "chalk";
44394
44416
 
44395
44417
  // src/commands/refactor/renameSymbol/findSymbol.ts
44396
44418
  import { SyntaxKind as SyntaxKind19 } from "ts-morph";
@@ -44436,34 +44458,34 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
44436
44458
  const { project, sourceFile } = loadProjectFile(file);
44437
44459
  const symbol = findSymbol(sourceFile, oldName);
44438
44460
  if (!symbol) {
44439
- console.log(chalk248.red(`Symbol "${oldName}" not found in ${file}`));
44461
+ console.log(chalk249.red(`Symbol "${oldName}" not found in ${file}`));
44440
44462
  process.exit(1);
44441
44463
  }
44442
44464
  const grouped = groupReferences(symbol, cwd);
44443
44465
  const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
44444
44466
  console.log(
44445
- chalk248.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
44467
+ chalk249.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
44446
44468
  `)
44447
44469
  );
44448
44470
  for (const [refFile, lines] of grouped) {
44449
44471
  console.log(
44450
- ` ${chalk248.dim(refFile)}: lines ${chalk248.cyan(lines.join(", "))}`
44472
+ ` ${chalk249.dim(refFile)}: lines ${chalk249.cyan(lines.join(", "))}`
44451
44473
  );
44452
44474
  }
44453
44475
  if (options2.apply) {
44454
44476
  symbol.rename(newName);
44455
44477
  await project.save();
44456
- console.log(chalk248.green(`
44478
+ console.log(chalk249.green(`
44457
44479
  Renamed ${oldName} \u2192 ${newName}`));
44458
44480
  } else {
44459
- console.log(chalk248.dim("\nDry run. Use --apply to execute."));
44481
+ console.log(chalk249.dim("\nDry run. Use --apply to execute."));
44460
44482
  }
44461
44483
  }
44462
44484
 
44463
44485
  // src/commands/refactor/restructure.ts
44464
44486
  import fs47 from "fs";
44465
44487
  import path92 from "path";
44466
- import chalk258 from "chalk";
44488
+ import chalk259 from "chalk";
44467
44489
 
44468
44490
  // src/commands/refactor/restructure/buildPlan.ts
44469
44491
  import path82 from "path";
@@ -44800,7 +44822,7 @@ function buildPlan3(scopeRoot, files, ignored = [], pinnedModules = []) {
44800
44822
  }
44801
44823
 
44802
44824
  // src/commands/refactor/restructure/checkPlan.ts
44803
- import chalk253 from "chalk";
44825
+ import chalk254 from "chalk";
44804
44826
 
44805
44827
  // src/commands/refactor/restructure/applyCommand.ts
44806
44828
  import path83 from "path";
@@ -44811,13 +44833,13 @@ function applyCommand(scopeRoot) {
44811
44833
 
44812
44834
  // src/commands/refactor/restructure/displayDrift.ts
44813
44835
  import path84 from "path";
44814
- import chalk249 from "chalk";
44836
+ import chalk250 from "chalk";
44815
44837
  var shownMoves = 20;
44816
44838
  function displayDrift(plan2, listMoves) {
44817
44839
  const rel = (file) => path84.relative(process.cwd(), file);
44818
44840
  if (plan2.moves.length > 0) {
44819
44841
  console.log(
44820
- chalk249.red(
44842
+ chalk250.red(
44821
44843
  `${plan2.moves.length} file(s) drift from the plan${listMoves ? ":" : "."}`
44822
44844
  )
44823
44845
  );
@@ -44825,17 +44847,17 @@ function displayDrift(plan2, listMoves) {
44825
44847
  for (const move2 of plan2.moves.slice(0, shownMoves))
44826
44848
  console.log(` ${rel(move2.from)} \u2192 ${rel(move2.to)}`);
44827
44849
  if (plan2.moves.length > shownMoves)
44828
- console.log(chalk249.dim(` \u2026and ${plan2.moves.length - shownMoves} more`));
44850
+ console.log(chalk250.dim(` \u2026and ${plan2.moves.length - shownMoves} more`));
44829
44851
  }
44830
44852
  }
44831
- for (const error of plan2.errors) console.log(chalk249.red(error));
44853
+ for (const error of plan2.errors) console.log(chalk250.red(error));
44832
44854
  }
44833
44855
 
44834
44856
  // src/commands/refactor/restructure/displayLayoutLimits.ts
44835
- import chalk252 from "chalk";
44857
+ import chalk253 from "chalk";
44836
44858
 
44837
44859
  // src/commands/refactor/restructure/displayDeepChains.ts
44838
- import chalk250 from "chalk";
44860
+ import chalk251 from "chalk";
44839
44861
  var shownChains = 10;
44840
44862
  function formatChain(chain2) {
44841
44863
  const folders = chain2.folders.map((f) => `${f.name} (${f.files})`).join(" > ");
@@ -44845,28 +44867,28 @@ function displayDeepChains(chains, maxDepth) {
44845
44867
  if (chains.length === 0) return;
44846
44868
  const tooDeep = chains.reduce((sum3, c) => sum3 + c.tooDeep, 0);
44847
44869
  console.log(
44848
- chalk250.red(
44870
+ chalk251.red(
44849
44871
  `
44850
44872
  Plan exceeds restructure.maxDepth ${maxDepth}: ${tooDeep} file(s) deeper.`
44851
44873
  )
44852
44874
  );
44853
44875
  console.log(
44854
- chalk250.bold(
44876
+ chalk251.bold(
44855
44877
  "Deep chains, as folder (files beneath), most files too deep first:"
44856
44878
  )
44857
44879
  );
44858
44880
  for (const chain2 of chains.slice(0, shownChains))
44859
44881
  console.log(formatChain(chain2));
44860
44882
  if (chains.length > shownChains)
44861
- console.log(chalk250.dim(` \u2026and ${chains.length - shownChains} more`));
44883
+ console.log(chalk251.dim(` \u2026and ${chains.length - shownChains} more`));
44862
44884
  }
44863
44885
 
44864
44886
  // src/commands/refactor/restructure/displayLongPaths.ts
44865
- import chalk251 from "chalk";
44887
+ import chalk252 from "chalk";
44866
44888
  function displayLongPaths(longPaths, maxPathLength) {
44867
44889
  if (longPaths.length === 0) return;
44868
44890
  console.log(
44869
- chalk251.red(
44891
+ chalk252.red(
44870
44892
  `
44871
44893
  Plan exceeds restructure.maxPathLength ${maxPathLength}: ${longPaths.length} repo-relative path(s) longer.`
44872
44894
  )
@@ -44894,7 +44916,7 @@ function displayLayoutLimits(limits, apply) {
44894
44916
  displayDeepChains(limits.chains, limits.maxDepth);
44895
44917
  displayLongPaths(limits.longPaths, limits.maxPathLength);
44896
44918
  console.log("");
44897
- for (const line of pinSteps(apply)) console.log(chalk252.yellow(line));
44919
+ for (const line of pinSteps(apply)) console.log(chalk253.yellow(line));
44898
44920
  }
44899
44921
 
44900
44922
  // src/commands/refactor/restructure/checkPlan.ts
@@ -44906,14 +44928,14 @@ function checkPlan(plan2, limits) {
44906
44928
  if (exceeds || plan2.errors.length > 0) process.exit(1);
44907
44929
  if (plan2.moves.length > 0) {
44908
44930
  console.log(
44909
- chalk253.yellow(
44931
+ chalk254.yellow(
44910
44932
  `
44911
44933
  Run \`${apply}\` to move the files and rewrite their imports.`
44912
44934
  )
44913
44935
  );
44914
44936
  process.exit(1);
44915
44937
  }
44916
- console.log(chalk253.green("Layout matches the restructure plan"));
44938
+ console.log(chalk254.green("Layout matches the restructure plan"));
44917
44939
  }
44918
44940
 
44919
44941
  // src/commands/refactor/restructure/findDeepChains.ts
@@ -44983,15 +45005,15 @@ function partitionIgnored(files) {
44983
45005
  }
44984
45006
 
44985
45007
  // src/commands/refactor/restructure/runPlan.ts
44986
- import chalk257 from "chalk";
45008
+ import chalk258 from "chalk";
44987
45009
 
44988
45010
  // src/commands/refactor/restructure/applyPlan.ts
44989
- import chalk255 from "chalk";
45011
+ import chalk256 from "chalk";
44990
45012
 
44991
45013
  // src/commands/refactor/restructure/executePlan.ts
44992
45014
  import fs46 from "fs";
44993
45015
  import path88 from "path";
44994
- import chalk254 from "chalk";
45016
+ import chalk255 from "chalk";
44995
45017
  function relPath(file) {
44996
45018
  return path88.relative(process.cwd(), file);
44997
45019
  }
@@ -45008,14 +45030,14 @@ function moveFiles(moves) {
45008
45030
  fs46.mkdirSync(path88.dirname(move2.to), { recursive: true });
45009
45031
  fs46.renameSync(staging, move2.to);
45010
45032
  console.log(
45011
- chalk254.white(` Moved ${relPath(move2.from)} \u2192 ${relPath(move2.to)}`)
45033
+ chalk255.white(` Moved ${relPath(move2.from)} \u2192 ${relPath(move2.to)}`)
45012
45034
  );
45013
45035
  }
45014
45036
  }
45015
45037
  function removeIfEmpty(dir) {
45016
45038
  if (!fs46.existsSync(dir) || fs46.readdirSync(dir).length > 0) return false;
45017
45039
  fs46.rmdirSync(dir);
45018
- console.log(chalk254.dim(` Removed empty directory ${relPath(dir)}`));
45040
+ console.log(chalk255.dim(` Removed empty directory ${relPath(dir)}`));
45019
45041
  return true;
45020
45042
  }
45021
45043
  function removeEmptyDirectories(dirs, scopeRoot) {
@@ -45028,7 +45050,7 @@ function removeEmptyDirectories(dirs, scopeRoot) {
45028
45050
  function executePlan(plan2) {
45029
45051
  for (const [file, content] of applyRewrites(plan2.rewrites)) {
45030
45052
  fs46.writeFileSync(file, content, "utf8");
45031
- console.log(chalk254.cyan(` Rewrote imports in ${relPath(file)}`));
45053
+ console.log(chalk255.cyan(` Rewrote imports in ${relPath(file)}`));
45032
45054
  }
45033
45055
  moveFiles(plan2.moves);
45034
45056
  removeEmptyDirectories(
@@ -45040,17 +45062,17 @@ function executePlan(plan2) {
45040
45062
  // src/commands/refactor/restructure/applyPlan.ts
45041
45063
  function applyPlan(plan2) {
45042
45064
  if (plan2.errors.length > 0) {
45043
- console.log(chalk255.red("\nResolve the errors above before applying."));
45065
+ console.log(chalk256.red("\nResolve the errors above before applying."));
45044
45066
  process.exit(1);
45045
45067
  }
45046
- console.log(chalk255.bold("\nApplying changes..."));
45068
+ console.log(chalk256.bold("\nApplying changes..."));
45047
45069
  executePlan(plan2);
45048
- console.log(chalk255.green("\nRestructuring complete"));
45070
+ console.log(chalk256.green("\nRestructuring complete"));
45049
45071
  }
45050
45072
 
45051
45073
  // src/commands/refactor/restructure/displayPlan.ts
45052
45074
  import path91 from "path";
45053
- import chalk256 from "chalk";
45075
+ import chalk257 from "chalk";
45054
45076
 
45055
45077
  // src/commands/refactor/restructure/computeDepthStats.ts
45056
45078
  import path89 from "path";
@@ -45101,17 +45123,17 @@ function relPath2(filePath) {
45101
45123
  }
45102
45124
  function displayMoves(plan2) {
45103
45125
  if (plan2.moves.length === 0) return;
45104
- console.log(chalk256.bold("\nFile moves:"));
45126
+ console.log(chalk257.bold("\nFile moves:"));
45105
45127
  for (const move2 of plan2.moves) {
45106
45128
  console.log(
45107
- ` ${chalk256.red(relPath2(move2.from))} \u2192 ${chalk256.green(relPath2(move2.to))}`
45129
+ ` ${chalk257.red(relPath2(move2.from))} \u2192 ${chalk257.green(relPath2(move2.to))}`
45108
45130
  );
45109
- console.log(chalk256.dim(` ${move2.reason}`));
45131
+ console.log(chalk257.dim(` ${move2.reason}`));
45110
45132
  }
45111
45133
  }
45112
45134
  function displayTree(plan2) {
45113
45135
  console.log(
45114
- chalk256.bold(`
45136
+ chalk257.bold(`
45115
45137
  Resulting tree (${relPath2(plan2.scopeRoot) || "."}/):`)
45116
45138
  );
45117
45139
  for (const line of formatTree(plan2.targets.values(), plan2.scopeRoot))
@@ -45122,15 +45144,15 @@ function displayDepthStats(plan2) {
45122
45144
  plan2.targets.values(),
45123
45145
  plan2.scopeRoot
45124
45146
  );
45125
- console.log(chalk256.bold(`
45147
+ console.log(chalk257.bold(`
45126
45148
  Depth (max ${max}):`));
45127
45149
  for (const depth of [...distribution.keys()].sort((a, b) => a - b))
45128
45150
  console.log(` ${depth}: ${distribution.get(depth)} file(s)`);
45129
45151
  }
45130
45152
  function displayErrors(errors) {
45131
45153
  if (errors.length === 0) return;
45132
- console.log(chalk256.red("\nErrors:"));
45133
- for (const error of errors) console.log(chalk256.red(` ${error}`));
45154
+ console.log(chalk257.red("\nErrors:"));
45155
+ for (const error of errors) console.log(chalk257.red(` ${error}`));
45134
45156
  }
45135
45157
  function displayPlan2(plan2) {
45136
45158
  displayMoves(plan2);
@@ -45139,7 +45161,7 @@ function displayPlan2(plan2) {
45139
45161
  displayErrors(plan2.errors);
45140
45162
  const rewrittenFiles = new Set(plan2.rewrites.map((r) => r.file)).size;
45141
45163
  console.log(
45142
- chalk256.dim(
45164
+ chalk257.dim(
45143
45165
  `
45144
45166
  Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten across ${rewrittenFiles} file(s), ${plan2.errors.length} error(s)`
45145
45167
  )
@@ -45151,11 +45173,11 @@ function runPlan(plan2, limits, apply) {
45151
45173
  displayPlan2(plan2);
45152
45174
  displayLayoutLimits(limits, applyCommand(plan2.scopeRoot));
45153
45175
  if (plan2.moves.length === 0 && plan2.errors.length === 0) {
45154
- console.log(chalk257.green("No restructuring needed"));
45176
+ console.log(chalk258.green("No restructuring needed"));
45155
45177
  return;
45156
45178
  }
45157
45179
  if (!apply) {
45158
- console.log(chalk257.dim("\nDry run. Use --apply to execute."));
45180
+ console.log(chalk258.dim("\nDry run. Use --apply to execute."));
45159
45181
  return;
45160
45182
  }
45161
45183
  applyPlan(plan2);
@@ -45165,14 +45187,14 @@ function runPlan(plan2, limits, apply) {
45165
45187
  async function restructure(root2, options2 = {}) {
45166
45188
  const scopeRoot = path92.resolve(root2 ?? "src");
45167
45189
  if (!fs47.existsSync(scopeRoot) || !fs47.statSync(scopeRoot).isDirectory()) {
45168
- console.log(chalk258.red(`Not a directory: ${root2 ?? "src"}`));
45190
+ console.log(chalk259.red(`Not a directory: ${root2 ?? "src"}`));
45169
45191
  process.exit(1);
45170
45192
  }
45171
45193
  const found = [];
45172
45194
  walkSourceFiles(scopeRoot, found);
45173
45195
  const { scoped, ignored } = partitionIgnored(found);
45174
45196
  if (scoped.length === 0) {
45175
- console.log(chalk258.yellow("No files found under root"));
45197
+ console.log(chalk259.yellow("No files found under root"));
45176
45198
  return;
45177
45199
  }
45178
45200
  const {
@@ -45245,7 +45267,7 @@ async function checkoutPrSession(number, { harness, skill } = {}) {
45245
45267
  }
45246
45268
 
45247
45269
  // src/commands/review/highLevel/configureHighLevelReview.ts
45248
- import chalk262 from "chalk";
45270
+ import chalk263 from "chalk";
45249
45271
 
45250
45272
  // src/commands/config/promptConfigScope.ts
45251
45273
  import Enquirer3 from "enquirer";
@@ -45271,7 +45293,7 @@ async function promptConfigScope() {
45271
45293
  }
45272
45294
 
45273
45295
  // src/commands/config/resolveConfigKeyAnswer.ts
45274
- import chalk259 from "chalk";
45296
+ import chalk260 from "chalk";
45275
45297
  async function resolveConfigKeyAnswer(question, supplied) {
45276
45298
  if (supplied !== void 0) return coerceSupplied(question.key, supplied);
45277
45299
  for (; ; ) {
@@ -45279,7 +45301,7 @@ async function resolveConfigKeyAnswer(question, supplied) {
45279
45301
  if (answer === "") return void 0;
45280
45302
  const coercion = coerceCliConfigValue(question.key, answer);
45281
45303
  if (coercion.ok) return coercion.value;
45282
- console.error(chalk259.red(coercion.error));
45304
+ console.error(chalk260.red(coercion.error));
45283
45305
  }
45284
45306
  }
45285
45307
  function coerceSupplied(key, supplied) {
@@ -45359,7 +45381,7 @@ function suggestGlobs(current2, proposed) {
45359
45381
  }
45360
45382
 
45361
45383
  // src/commands/review/highLevel/parseConfigureAnswers.ts
45362
- import chalk260 from "chalk";
45384
+ import chalk261 from "chalk";
45363
45385
  function parseConfigureAnswers(answers) {
45364
45386
  const known = Object.values(highLevelConfigKeys);
45365
45387
  const parsed = {};
@@ -45377,12 +45399,12 @@ function answersCoverEveryKey(answers) {
45377
45399
  return Object.values(highLevelConfigKeys).every((key) => key in answers);
45378
45400
  }
45379
45401
  function exitWith(message4) {
45380
- console.error(chalk260.red(`Error: ${message4}.`));
45402
+ console.error(chalk261.red(`Error: ${message4}.`));
45381
45403
  process.exit(1);
45382
45404
  }
45383
45405
 
45384
45406
  // src/commands/review/highLevel/proposeHighLevelGlobs.ts
45385
- import chalk261 from "chalk";
45407
+ import chalk262 from "chalk";
45386
45408
 
45387
45409
  // src/commands/review/highLevel/buildGlobProposalPrompt.ts
45388
45410
  function buildGlobProposalPrompt(tree) {
@@ -45478,7 +45500,7 @@ async function proposeHighLevelGlobs(cwd = process.cwd()) {
45478
45500
  const harness = resolveOneShotHarness();
45479
45501
  const label = harnessLabel(harness);
45480
45502
  console.log(
45481
- chalk261.dim(`Asking ${label} to propose globs from the repo's own tree...`)
45503
+ chalk262.dim(`Asking ${label} to propose globs from the repo's own tree...`)
45482
45504
  );
45483
45505
  try {
45484
45506
  const output = await runOneShotPrompt(
@@ -45489,9 +45511,9 @@ async function proposeHighLevelGlobs(cwd = process.cwd()) {
45489
45511
  return parseProposedGlobs(output);
45490
45512
  } catch (error) {
45491
45513
  if (error instanceof OneShotUnavailableError)
45492
- console.log(chalk261.yellow(error.message));
45514
+ console.log(chalk262.yellow(error.message));
45493
45515
  console.log(
45494
- chalk261.yellow(
45516
+ chalk262.yellow(
45495
45517
  `${label} proposed nothing; answer each key from its current value.`
45496
45518
  )
45497
45519
  );
@@ -45538,14 +45560,14 @@ async function configureHighLevelReview(options2 = {}) {
45538
45560
  function reportConfigured(result) {
45539
45561
  for (const write2 of result.written)
45540
45562
  console.log(
45541
- chalk262.green(`Set ${write2.key} = ${JSON.stringify(write2.value)}`)
45563
+ chalk263.green(`Set ${write2.key} = ${JSON.stringify(write2.value)}`)
45542
45564
  );
45543
- for (const key of result.skipped) console.log(chalk262.dim(`Left ${key} unset`));
45544
- console.log(chalk262.dim(`Written to ${result.target}`));
45565
+ for (const key of result.skipped) console.log(chalk263.dim(`Left ${key} unset`));
45566
+ console.log(chalk263.dim(`Written to ${result.target}`));
45545
45567
  }
45546
45568
 
45547
45569
  // src/commands/review/highLevel/announceSavedReview.ts
45548
- import chalk263 from "chalk";
45570
+ import chalk264 from "chalk";
45549
45571
  function savedMessage(subject) {
45550
45572
  const head = subject.headSha.slice(0, 7);
45551
45573
  if (subject.draft)
@@ -45556,10 +45578,10 @@ function savedMessage(subject) {
45556
45578
  }
45557
45579
  function announceSavedReview(subject, force) {
45558
45580
  const message4 = savedMessage(subject);
45559
- if (message4) console.log(chalk263.dim(message4));
45581
+ if (message4) console.log(chalk264.dim(message4));
45560
45582
  else if (force)
45561
45583
  console.log(
45562
- chalk263.dim(
45584
+ chalk264.dim(
45563
45585
  `Discarding any review saved for ${subject.headSha.slice(0, 7)} and starting fresh (--force).`
45564
45586
  )
45565
45587
  );
@@ -46939,55 +46961,55 @@ async function openHighLevelOverlay(sessionId2, subject, onRestart = async () =>
46939
46961
  }
46940
46962
 
46941
46963
  // src/commands/review/highLevel/printHighLevelChecklist.ts
46942
- import chalk268 from "chalk";
46964
+ import chalk269 from "chalk";
46943
46965
 
46944
46966
  // src/commands/review/highLevel/formatCriticalDiffs.ts
46945
- import chalk264 from "chalk";
46967
+ import chalk265 from "chalk";
46946
46968
  var PATCH_LINE_COLOURS = {
46947
- "+": chalk264.green,
46948
- "-": chalk264.red,
46949
- "@": chalk264.cyan
46969
+ "+": chalk265.green,
46970
+ "-": chalk265.red,
46971
+ "@": chalk265.cyan
46950
46972
  };
46951
46973
  function formatPatch(patch2) {
46952
46974
  return patch2.split("\n").map(
46953
- (line) => ` ${(PATCH_LINE_COLOURS[line[0] ?? ""] ?? chalk264.dim)(line)}`
46975
+ (line) => ` ${(PATCH_LINE_COLOURS[line[0] ?? ""] ?? chalk265.dim)(line)}`
46954
46976
  );
46955
46977
  }
46956
46978
  function formatDiff(diff3) {
46957
46979
  return [
46958
46980
  "",
46959
- ` ${chalk264.bold(diff3.path)} ${chalk264.dim(`(${diff3.status})`)} ${chalk264.green(`+${diff3.additions}`)} ${chalk264.red(`-${diff3.deletions}`)}`,
46960
- ...diff3.patch === null ? [` ${chalk264.dim(`no diff available; see ${diff3.diffUrl}`)}`] : formatPatch(diff3.patch)
46981
+ ` ${chalk265.bold(diff3.path)} ${chalk265.dim(`(${diff3.status})`)} ${chalk265.green(`+${diff3.additions}`)} ${chalk265.red(`-${diff3.deletions}`)}`,
46982
+ ...diff3.patch === null ? [` ${chalk265.dim(`no diff available; see ${diff3.diffUrl}`)}`] : formatPatch(diff3.patch)
46961
46983
  ];
46962
46984
  }
46963
46985
  function formatCriticalDiffs(diffs, criticalPaths) {
46964
46986
  if (criticalPaths.length === 0)
46965
- return `${chalk264.bold.underline("Critical diffs")}
46966
- ${chalk264.dim("review.highLevel.criticalPaths is empty, so no diffs are shown")}`;
46987
+ return `${chalk265.bold.underline("Critical diffs")}
46988
+ ${chalk265.dim("review.highLevel.criticalPaths is empty, so no diffs are shown")}`;
46967
46989
  if (diffs.length === 0)
46968
- return `${chalk264.bold.underline("Critical diffs")}
46969
- ${chalk264.dim(`no changed file matches ${criticalPaths.join(", ")}`)}`;
46990
+ return `${chalk265.bold.underline("Critical diffs")}
46991
+ ${chalk265.dim(`no changed file matches ${criticalPaths.join(", ")}`)}`;
46970
46992
  return [
46971
- chalk264.bold.underline("Critical diffs"),
46993
+ chalk265.bold.underline("Critical diffs"),
46972
46994
  ...diffs.flatMap(formatDiff)
46973
46995
  ].join("\n");
46974
46996
  }
46975
46997
 
46976
46998
  // src/commands/review/highLevel/formatHighLevelChecklist.ts
46977
- import chalk265 from "chalk";
46999
+ import chalk266 from "chalk";
46978
47000
  var MARKERS = {
46979
- pass: () => chalk265.green("\u2714"),
46980
- fail: () => chalk265.red("\u2718"),
46981
- manual: () => chalk265.yellow("\u25A1")
47001
+ pass: () => chalk266.green("\u2714"),
47002
+ fail: () => chalk266.red("\u2718"),
47003
+ manual: () => chalk266.yellow("\u25A1")
46982
47004
  };
46983
47005
  function formatCheck(check2) {
46984
- const title = check2.status === "fail" ? chalk265.red(check2.title) : chalk265.bold(check2.title);
47006
+ const title = check2.status === "fail" ? chalk266.red(check2.title) : chalk266.bold(check2.title);
46985
47007
  return ` ${MARKERS[check2.status]()} ${title}
46986
- ${chalk265.dim(check2.reason)}`;
47008
+ ${chalk266.dim(check2.reason)}`;
46987
47009
  }
46988
47010
  function formatGroup(heading2, checks2) {
46989
47011
  if (checks2.length === 0) return [];
46990
- return ["", chalk265.bold.underline(heading2), ...checks2.map(formatCheck)];
47012
+ return ["", chalk266.bold.underline(heading2), ...checks2.map(formatCheck)];
46991
47013
  }
46992
47014
  function formatHighLevelChecklist(checks2) {
46993
47015
  const deterministic = checks2.filter(
@@ -46996,7 +47018,7 @@ function formatHighLevelChecklist(checks2) {
46996
47018
  const failed3 = deterministic.filter(
46997
47019
  (check2) => check2.status === "fail"
46998
47020
  ).length;
46999
- const summary = failed3 === 0 ? chalk265.green(`All ${deterministic.length} deterministic checks pass`) : chalk265.red(
47021
+ const summary = failed3 === 0 ? chalk266.green(`All ${deterministic.length} deterministic checks pass`) : chalk266.red(
47000
47022
  `${failed3} of ${deterministic.length} deterministic checks fail`
47001
47023
  );
47002
47024
  return [
@@ -47011,37 +47033,37 @@ function formatHighLevelChecklist(checks2) {
47011
47033
  }
47012
47034
 
47013
47035
  // src/commands/review/highLevel/formatHighLevelStructure.ts
47014
- import chalk266 from "chalk";
47036
+ import chalk267 from "chalk";
47015
47037
  var STATUS_MARKERS = {
47016
- added: () => chalk266.green("A"),
47017
- removed: () => chalk266.red("D"),
47018
- modified: () => chalk266.yellow("M")
47038
+ added: () => chalk267.green("A"),
47039
+ removed: () => chalk267.red("D"),
47040
+ modified: () => chalk267.yellow("M")
47019
47041
  };
47020
47042
  function counts(additions, deletions) {
47021
- return `${chalk266.green(`+${additions}`)} ${chalk266.red(`-${deletions}`)}`;
47043
+ return `${chalk267.green(`+${additions}`)} ${chalk267.red(`-${deletions}`)}`;
47022
47044
  }
47023
47045
  function formatNode(node, indent4) {
47024
47046
  if (node.kind === "file")
47025
47047
  return [
47026
- `${indent4}${STATUS_MARKERS[node.status]()} ${node.name} ${chalk266.dim(counts(node.additions, node.deletions))}`
47048
+ `${indent4}${STATUS_MARKERS[node.status]()} ${node.name} ${chalk267.dim(counts(node.additions, node.deletions))}`
47027
47049
  ];
47028
47050
  const dir = node;
47029
47051
  return [
47030
- `${indent4}${chalk266.bold(`${dir.name}/`)} ${chalk266.dim(counts(dir.additions, dir.deletions))}`,
47052
+ `${indent4}${chalk267.bold(`${dir.name}/`)} ${chalk267.dim(counts(dir.additions, dir.deletions))}`,
47031
47053
  ...dir.children.flatMap((child) => formatNode(child, `${indent4} `))
47032
47054
  ];
47033
47055
  }
47034
47056
  function formatHighLevelStructure(structure) {
47035
47057
  const summary = `${structure.added} added \xB7 ${structure.removed} deleted \xB7 ${structure.modified} modified \xB7 ${counts(structure.additions, structure.deletions)}`;
47036
47058
  return [
47037
- chalk266.bold.underline("Structure"),
47059
+ chalk267.bold.underline("Structure"),
47038
47060
  ` ${summary}`,
47039
47061
  ...structure.tree.flatMap((node) => formatNode(node, " "))
47040
47062
  ].join("\n");
47041
47063
  }
47042
47064
 
47043
47065
  // src/commands/review/highLevel/formatHighLevelTests.ts
47044
- import chalk267 from "chalk";
47066
+ import chalk268 from "chalk";
47045
47067
  function changeMarker(change) {
47046
47068
  if (change === "added") return "A";
47047
47069
  if (change === "modified") return "M";
@@ -47050,22 +47072,22 @@ function changeMarker(change) {
47050
47072
  function formatNode2(node, depth) {
47051
47073
  const indent4 = " ".repeat(depth + 2);
47052
47074
  if (node.kind === "it")
47053
- return [`${indent4}${chalk267.dim(changeMarker(node.change))} ${node.name}`];
47075
+ return [`${indent4}${chalk268.dim(changeMarker(node.change))} ${node.name}`];
47054
47076
  return [
47055
- `${indent4}${chalk267.bold(node.name)}`,
47077
+ `${indent4}${chalk268.bold(node.name)}`,
47056
47078
  ...node.children.flatMap((child) => formatNode2(child, depth + 1))
47057
47079
  ];
47058
47080
  }
47059
47081
  function formatHighLevelTests(files, testPaths) {
47060
- const heading2 = chalk267.bold.underline("Changed tests");
47082
+ const heading2 = chalk268.bold.underline("Changed tests");
47061
47083
  if (files.length === 0)
47062
47084
  return `${heading2}
47063
- ${chalk267.dim(`no changed test in files matching ${testPaths.join(", ")}`)}`;
47085
+ ${chalk268.dim(`no changed test in files matching ${testPaths.join(", ")}`)}`;
47064
47086
  return [
47065
47087
  heading2,
47066
47088
  ...files.flatMap((file) => [
47067
47089
  "",
47068
- ` ${chalk267.bold(file.path)} ${chalk267.dim(`(${file.status})`)}`,
47090
+ ` ${chalk268.bold(file.path)} ${chalk268.dim(`(${file.status})`)}`,
47069
47091
  ...file.tests.flatMap((node) => formatNode2(node, 0))
47070
47092
  ])
47071
47093
  ].join("\n");
@@ -47079,10 +47101,10 @@ function highLevelChangedFileCount(structure) {
47079
47101
  // src/commands/review/highLevel/printHighLevelChecklist.ts
47080
47102
  function printHighLevelChecklist(subject) {
47081
47103
  console.log(
47082
- chalk268.bold(
47104
+ chalk269.bold(
47083
47105
  `High-level review of ${subject.repo}#${subject.prNumber} \u2014 ${subject.title}`
47084
47106
  ),
47085
- chalk268.dim(
47107
+ chalk269.dim(
47086
47108
  `\xB7 ${highLevelChangedFileCount(subject.structure)} changed files`
47087
47109
  )
47088
47110
  );
@@ -47096,12 +47118,12 @@ function printHighLevelChecklist(subject) {
47096
47118
  console.log("");
47097
47119
  console.log(formatHighLevelTests(subject.tests, subject.testPaths));
47098
47120
  console.log(
47099
- chalk268.dim(
47121
+ chalk269.dim(
47100
47122
  "\nManual items are for the reviewer to judge; see docs/high-level-review.md."
47101
47123
  )
47102
47124
  );
47103
47125
  console.log(
47104
- chalk268.dim(
47126
+ chalk269.dim(
47105
47127
  "Run this inside an assist session to step through the checklist in the web overlay."
47106
47128
  )
47107
47129
  );
@@ -47147,7 +47169,7 @@ async function runHighLevelReview(number, options2 = {}) {
47147
47169
 
47148
47170
  // src/commands/review/reviewPr.ts
47149
47171
  import { basename as basename28 } from "path";
47150
- import chalk271 from "chalk";
47172
+ import chalk272 from "chalk";
47151
47173
 
47152
47174
  // src/commands/review/resolveSynthesisHarness.ts
47153
47175
  var DEFAULT_SYNTHESIS_HARNESS = "claude";
@@ -48576,18 +48598,18 @@ function partitionFindingsByDiff(findings2, index3) {
48576
48598
  }
48577
48599
 
48578
48600
  // src/commands/review/warnOutOfDiff.ts
48579
- import chalk269 from "chalk";
48601
+ import chalk270 from "chalk";
48580
48602
  function warnOutOfDiff(outOfDiff) {
48581
48603
  if (outOfDiff.length === 0) return;
48582
48604
  console.warn(
48583
- chalk269.yellow(
48605
+ chalk270.yellow(
48584
48606
  `Moved ${outOfDiff.length} finding(s) whose lines fall outside the PR diff into the review body (GitHub cannot anchor a comment on these):`
48585
48607
  )
48586
48608
  );
48587
48609
  for (const finding of outOfDiff) {
48588
48610
  const range = finding.startLine !== void 0 ? `${finding.startLine}-${finding.line}` : `${finding.line}`;
48589
48611
  console.warn(
48590
- ` ${chalk269.yellow("\xB7")} ${finding.title} ${chalk269.dim(
48612
+ ` ${chalk270.yellow("\xB7")} ${finding.title} ${chalk270.dim(
48591
48613
  `(${finding.file}:${range})`
48592
48614
  )}`
48593
48615
  );
@@ -48612,18 +48634,18 @@ function selectInDiffFindings(lineBound, prDiff) {
48612
48634
  }
48613
48635
 
48614
48636
  // src/commands/review/warnUnlocated.ts
48615
- import chalk270 from "chalk";
48637
+ import chalk271 from "chalk";
48616
48638
  function warnUnlocated(unlocated) {
48617
48639
  if (unlocated.length === 0) return;
48618
48640
  console.warn(
48619
- chalk270.yellow(
48641
+ chalk271.yellow(
48620
48642
  `Moved ${unlocated.length} finding(s) without a parseable file:line into the review body:`
48621
48643
  )
48622
48644
  );
48623
48645
  for (const finding of unlocated) {
48624
- const where = finding.location || chalk270.dim("missing");
48646
+ const where = finding.location || chalk271.dim("missing");
48625
48647
  console.warn(
48626
- ` ${chalk270.yellow("\xB7")} ${finding.title} ${chalk270.dim(`(${where})`)}`
48648
+ ` ${chalk271.yellow("\xB7")} ${finding.title} ${chalk271.dim(`(${where})`)}`
48627
48649
  );
48628
48650
  }
48629
48651
  }
@@ -48753,7 +48775,7 @@ function runPostSynthesis(synthesisPath, prInfo, options2) {
48753
48775
  async function reviewPr(repoRoot3, options2) {
48754
48776
  const blocker = synthesisBlocker(resolveSynthesisHarness());
48755
48777
  if (blocker) {
48756
- console.error(chalk271.red(blocker));
48778
+ console.error(chalk272.red(blocker));
48757
48779
  process.exitCode = 1;
48758
48780
  return;
48759
48781
  }
@@ -48837,7 +48859,7 @@ function validateHighLevel(options2) {
48837
48859
  }
48838
48860
 
48839
48861
  // src/commands/review/sessionBlocked.ts
48840
- import chalk272 from "chalk";
48862
+ import chalk273 from "chalk";
48841
48863
 
48842
48864
  // src/commands/review/reviewSessionFeature.ts
48843
48865
  function reviewSessionFeature(options2) {
@@ -48853,7 +48875,7 @@ function sessionBlocked(options2) {
48853
48875
  if (!feature) return false;
48854
48876
  const blocker = launchBlocker(harnessAdapter(options2.harness), feature);
48855
48877
  if (!blocker) return false;
48856
- console.error(chalk272.red(blocker));
48878
+ console.error(chalk273.red(blocker));
48857
48879
  process.exitCode = 1;
48858
48880
  return true;
48859
48881
  }
@@ -48986,7 +49008,7 @@ function registerReview(program) {
48986
49008
 
48987
49009
  // src/commands/rules/indexRules.ts
48988
49010
  import path96 from "path";
48989
- import chalk273 from "chalk";
49011
+ import chalk274 from "chalk";
48990
49012
 
48991
49013
  // src/commands/rules/updateScopedRulesIndex.ts
48992
49014
  import { existsSync as existsSync81, readFileSync as readFileSync71, writeFileSync as writeFileSync51 } from "fs";
@@ -49073,24 +49095,24 @@ function indexRules() {
49073
49095
  const rootFile = path96.relative(process.cwd(), path96.join(root2, "CLAUDE.md"));
49074
49096
  if (directories.length === 0) {
49075
49097
  console.log(
49076
- chalk273.gray(`No directories carry their own \`## Rules\` under ${root2}`)
49098
+ chalk274.gray(`No directories carry their own \`## Rules\` under ${root2}`)
49077
49099
  );
49078
49100
  return;
49079
49101
  }
49080
49102
  console.log(`Recorded in ${rootFile || "CLAUDE.md"}`);
49081
49103
  for (const directory of directories)
49082
- console.log(` ${chalk273.cyan(directory)}`);
49104
+ console.log(` ${chalk274.cyan(directory)}`);
49083
49105
  }
49084
49106
 
49085
49107
  // src/commands/rules/listRules.ts
49086
49108
  import path97 from "path";
49087
- import chalk274 from "chalk";
49109
+ import chalk275 from "chalk";
49088
49110
  function listRules(target, options2 = {}) {
49089
49111
  const resolved = path97.resolve(target ?? process.cwd());
49090
49112
  const rules2 = readScopedRules(resolved);
49091
49113
  if (rules2.length === 0) {
49092
49114
  const label = path97.relative(process.cwd(), resolved) || ".";
49093
- console.log(chalk274.gray(`No rules in scope for ${label}`));
49115
+ console.log(chalk275.gray(`No rules in scope for ${label}`));
49094
49116
  return;
49095
49117
  }
49096
49118
  const base = findRepoRoot(scopeDirectory(resolved));
@@ -49100,21 +49122,21 @@ function listRules(target, options2 = {}) {
49100
49122
  if (rule.source !== shown) {
49101
49123
  shown = rule.source;
49102
49124
  console.log(
49103
- chalk274.dim(base ? path97.relative(base, rule.source) : rule.source)
49125
+ chalk275.dim(base ? path97.relative(base, rule.source) : rule.source)
49104
49126
  );
49105
49127
  }
49106
49128
  console.log(
49107
- ` ${chalk274.cyan(rule.code.padEnd(width2))} ${rule.title ?? rule.text}`
49129
+ ` ${chalk275.cyan(rule.code.padEnd(width2))} ${rule.title ?? rule.text}`
49108
49130
  );
49109
49131
  if (options2.full && rule.title)
49110
- console.log(` ${" ".repeat(width2)} ${chalk274.dim(rule.text)}`);
49132
+ console.log(` ${" ".repeat(width2)} ${chalk275.dim(rule.text)}`);
49111
49133
  }
49112
49134
  }
49113
49135
 
49114
49136
  // src/commands/rules/addRule.ts
49115
49137
  import { existsSync as existsSync83, readFileSync as readFileSync73, writeFileSync as writeFileSync52 } from "fs";
49116
49138
  import path99 from "path";
49117
- import chalk275 from "chalk";
49139
+ import chalk276 from "chalk";
49118
49140
 
49119
49141
  // src/commands/rules/insertRuleBullet.ts
49120
49142
  function ruleBullet({ code, title, text: text19 }) {
@@ -49173,7 +49195,7 @@ function read3(file) {
49173
49195
  function addRule(text19, options2) {
49174
49196
  const rule = text19.trim();
49175
49197
  if (rule === "") {
49176
- console.error(chalk275.red("Rule text is required"));
49198
+ console.error(chalk276.red("Rule text is required"));
49177
49199
  process.exitCode = 1;
49178
49200
  return;
49179
49201
  }
@@ -49191,14 +49213,14 @@ function addRule(text19, options2) {
49191
49213
  );
49192
49214
  updateScopedRulesIndex(root2);
49193
49215
  console.log(
49194
- `Added ${chalk275.cyan(code)} to ${path99.relative(process.cwd(), target) || target}`
49216
+ `Added ${chalk276.cyan(code)} to ${path99.relative(process.cwd(), target) || target}`
49195
49217
  );
49196
49218
  }
49197
49219
 
49198
49220
  // src/commands/rules/addUserRule.ts
49199
- import chalk276 from "chalk";
49221
+ import chalk277 from "chalk";
49200
49222
  function fail12(message4) {
49201
- console.error(chalk276.red(message4));
49223
+ console.error(chalk277.red(message4));
49202
49224
  process.exitCode = 1;
49203
49225
  }
49204
49226
  function asRules(value) {
@@ -49217,7 +49239,7 @@ async function addToUserDb(rule) {
49217
49239
  rule
49218
49240
  ]);
49219
49241
  if (!result.ok) return fail12(result.errors.join("\n"));
49220
- console.log(`Added ${chalk276.cyan(rule.title)} to advice.rules in user (db)`);
49242
+ console.log(`Added ${chalk277.cyan(rule.title)} to advice.rules in user (db)`);
49221
49243
  }
49222
49244
  function addToUserNode(rule, globalConfigPath) {
49223
49245
  const advice = loadGlobalConfigRaw(globalConfigPath).advice;
@@ -49230,7 +49252,7 @@ function addToUserNode(rule, globalConfigPath) {
49230
49252
  );
49231
49253
  if (!result.ok) return fail12(result.errors.join("\n"));
49232
49254
  console.log(
49233
- `Added ${chalk276.cyan(rule.title)} to advice.rules in user (node) (${globalConfigFileLabel(globalConfigPath)})`
49255
+ `Added ${chalk277.cyan(rule.title)} to advice.rules in user (node) (${globalConfigFileLabel(globalConfigPath)})`
49234
49256
  );
49235
49257
  }
49236
49258
  async function addUserRule(text19, options2, globalConfigPath = getGlobalConfigPath()) {
@@ -49285,7 +49307,7 @@ function registerRules(program) {
49285
49307
  }
49286
49308
 
49287
49309
  // src/commands/seq/seqAuth.ts
49288
- import chalk278 from "chalk";
49310
+ import chalk279 from "chalk";
49289
49311
 
49290
49312
  // src/commands/seq/loadConnections.ts
49291
49313
  function loadConnections2() {
@@ -49314,10 +49336,10 @@ function setDefaultConnection(name2) {
49314
49336
  }
49315
49337
 
49316
49338
  // src/shared/assertUniqueName.ts
49317
- import chalk277 from "chalk";
49339
+ import chalk278 from "chalk";
49318
49340
  function assertUniqueName(existingNames, name2) {
49319
49341
  if (existingNames.includes(name2)) {
49320
- console.error(chalk277.red(`Connection "${name2}" already exists.`));
49342
+ console.error(chalk278.red(`Connection "${name2}" already exists.`));
49321
49343
  process.exit(1);
49322
49344
  }
49323
49345
  }
@@ -49335,16 +49357,16 @@ async function promptConnection2(existingNames) {
49335
49357
  var seqAuth = createConnectionAuth({
49336
49358
  load: loadConnections2,
49337
49359
  save: saveConnections2,
49338
- format: (c) => `${chalk278.bold(c.name)} ${c.url}`,
49360
+ format: (c) => `${chalk279.bold(c.name)} ${c.url}`,
49339
49361
  promptNew: promptConnection2,
49340
49362
  onFirst: (c) => setDefaultConnection(c.name)
49341
49363
  });
49342
49364
 
49343
49365
  // src/commands/seq/seqQuery.ts
49344
- import chalk282 from "chalk";
49366
+ import chalk283 from "chalk";
49345
49367
 
49346
49368
  // src/commands/seq/fetchSeq.ts
49347
- import chalk279 from "chalk";
49369
+ import chalk280 from "chalk";
49348
49370
  async function fetchSeq(conn, path118, params) {
49349
49371
  const url = `${conn.url}${path118}?${params}`;
49350
49372
  const response = await fetch(url, {
@@ -49355,7 +49377,7 @@ async function fetchSeq(conn, path118, params) {
49355
49377
  });
49356
49378
  if (!response.ok) {
49357
49379
  const body = await response.text();
49358
- console.error(chalk279.red(`Seq returned ${response.status}: ${body}`));
49380
+ console.error(chalk280.red(`Seq returned ${response.status}: ${body}`));
49359
49381
  process.exit(1);
49360
49382
  }
49361
49383
  return response;
@@ -49414,23 +49436,23 @@ async function fetchSeqEvents(conn, params) {
49414
49436
  }
49415
49437
 
49416
49438
  // src/commands/seq/formatEvent.ts
49417
- import chalk280 from "chalk";
49439
+ import chalk281 from "chalk";
49418
49440
  function levelColor(level) {
49419
49441
  switch (level) {
49420
49442
  case "Fatal":
49421
- return chalk280.bgRed.white;
49443
+ return chalk281.bgRed.white;
49422
49444
  case "Error":
49423
- return chalk280.red;
49445
+ return chalk281.red;
49424
49446
  case "Warning":
49425
- return chalk280.yellow;
49447
+ return chalk281.yellow;
49426
49448
  case "Information":
49427
- return chalk280.cyan;
49449
+ return chalk281.cyan;
49428
49450
  case "Debug":
49429
- return chalk280.gray;
49451
+ return chalk281.gray;
49430
49452
  case "Verbose":
49431
- return chalk280.dim;
49453
+ return chalk281.dim;
49432
49454
  default:
49433
- return chalk280.white;
49455
+ return chalk281.white;
49434
49456
  }
49435
49457
  }
49436
49458
  function levelAbbrev(level) {
@@ -49471,12 +49493,12 @@ function formatTimestamp(iso) {
49471
49493
  function formatEvent(event) {
49472
49494
  const color = levelColor(event.Level);
49473
49495
  const abbrev = levelAbbrev(event.Level);
49474
- const ts10 = chalk280.dim(formatTimestamp(event.Timestamp));
49496
+ const ts10 = chalk281.dim(formatTimestamp(event.Timestamp));
49475
49497
  const msg = renderMessage(event);
49476
49498
  const lines = [`${ts10} ${color(`[${abbrev}]`)} ${msg}`];
49477
49499
  if (event.Exception) {
49478
49500
  for (const line of event.Exception.split("\n")) {
49479
- lines.push(chalk280.red(` ${line}`));
49501
+ lines.push(chalk281.red(` ${line}`));
49480
49502
  }
49481
49503
  }
49482
49504
  return lines.join("\n");
@@ -49509,11 +49531,11 @@ function rejectTimestampFilter(filter) {
49509
49531
  }
49510
49532
 
49511
49533
  // src/shared/resolveNamedConnection.ts
49512
- import chalk281 from "chalk";
49534
+ import chalk282 from "chalk";
49513
49535
  function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
49514
49536
  if (connections.length === 0) {
49515
49537
  console.error(
49516
- chalk281.red(
49538
+ chalk282.red(
49517
49539
  `No ${kind} connections configured. Run '${authCommand}' first.`
49518
49540
  )
49519
49541
  );
@@ -49522,7 +49544,7 @@ function resolveNamedConnection(connections, requested, defaultName, kind, authC
49522
49544
  const target = requested ?? defaultName ?? connections[0].name;
49523
49545
  const connection = connections.find((c) => c.name === target);
49524
49546
  if (!connection) {
49525
- console.error(chalk281.red(`${kind} connection "${target}" not found.`));
49547
+ console.error(chalk282.red(`${kind} connection "${target}" not found.`));
49526
49548
  process.exit(1);
49527
49549
  }
49528
49550
  return connection;
@@ -49551,7 +49573,7 @@ async function seqQuery(filter, options2) {
49551
49573
  new URLSearchParams({ filter, count: String(count10) })
49552
49574
  );
49553
49575
  if (events.length === 0) {
49554
- console.log(chalk282.yellow("No events found."));
49576
+ console.log(chalk283.yellow("No events found."));
49555
49577
  return;
49556
49578
  }
49557
49579
  if (options2.json) {
@@ -49562,11 +49584,11 @@ async function seqQuery(filter, options2) {
49562
49584
  for (const event of chronological) {
49563
49585
  console.log(formatEvent(event));
49564
49586
  }
49565
- console.log(chalk282.dim(`
49587
+ console.log(chalk283.dim(`
49566
49588
  ${events.length} events`));
49567
49589
  if (events.length >= count10) {
49568
49590
  console.log(
49569
- chalk282.yellow(
49591
+ chalk283.yellow(
49570
49592
  `Results limited to ${count10}. Use --count to retrieve more.`
49571
49593
  )
49572
49594
  );
@@ -49574,10 +49596,10 @@ ${events.length} events`));
49574
49596
  }
49575
49597
 
49576
49598
  // src/shared/setNamedDefaultConnection.ts
49577
- import chalk283 from "chalk";
49599
+ import chalk284 from "chalk";
49578
49600
  function setNamedDefaultConnection(connections, name2, setDefault, kind) {
49579
49601
  if (!connections.find((c) => c.name === name2)) {
49580
- console.error(chalk283.red(`Connection "${name2}" not found.`));
49602
+ console.error(chalk284.red(`Connection "${name2}" not found.`));
49581
49603
  process.exit(1);
49582
49604
  }
49583
49605
  setDefault(name2);
@@ -49828,7 +49850,7 @@ function registerSlack(program) {
49828
49850
  }
49829
49851
 
49830
49852
  // src/commands/sql/sqlAuth.ts
49831
- import chalk285 from "chalk";
49853
+ import chalk286 from "chalk";
49832
49854
 
49833
49855
  // src/commands/sql/loadConnections.ts
49834
49856
  function loadConnections3() {
@@ -49857,7 +49879,7 @@ function setDefaultConnection2(name2) {
49857
49879
  }
49858
49880
 
49859
49881
  // src/commands/sql/promptConnection.ts
49860
- import chalk284 from "chalk";
49882
+ import chalk285 from "chalk";
49861
49883
  async function promptConnection3(existingNames) {
49862
49884
  const name2 = await promptInput("name", "Connection name:", "default");
49863
49885
  assertUniqueName(existingNames, name2);
@@ -49865,7 +49887,7 @@ async function promptConnection3(existingNames) {
49865
49887
  const portStr = await promptInput("port", "Port:", "1433");
49866
49888
  const port = Number.parseInt(portStr, 10);
49867
49889
  if (!Number.isFinite(port)) {
49868
- console.error(chalk284.red(`Invalid port "${portStr}".`));
49890
+ console.error(chalk285.red(`Invalid port "${portStr}".`));
49869
49891
  process.exit(1);
49870
49892
  }
49871
49893
  const user = await promptInput("user", "User:");
@@ -49878,13 +49900,13 @@ async function promptConnection3(existingNames) {
49878
49900
  var sqlAuth = createConnectionAuth({
49879
49901
  load: loadConnections3,
49880
49902
  save: saveConnections3,
49881
- format: (c) => `${chalk285.bold(c.name)} ${c.server}:${c.port}/${c.database} (${c.user})`,
49903
+ format: (c) => `${chalk286.bold(c.name)} ${c.server}:${c.port}/${c.database} (${c.user})`,
49882
49904
  promptNew: promptConnection3,
49883
49905
  onFirst: (c) => setDefaultConnection2(c.name)
49884
49906
  });
49885
49907
 
49886
49908
  // src/commands/sql/printTable.ts
49887
- import chalk286 from "chalk";
49909
+ import chalk287 from "chalk";
49888
49910
  function formatCell(value) {
49889
49911
  if (value === null || value === void 0) return "";
49890
49912
  if (value instanceof Date) return value.toISOString();
@@ -49893,7 +49915,7 @@ function formatCell(value) {
49893
49915
  }
49894
49916
  function printTable(rows) {
49895
49917
  if (rows.length === 0) {
49896
- console.log(chalk286.yellow("(no rows)"));
49918
+ console.log(chalk287.yellow("(no rows)"));
49897
49919
  return;
49898
49920
  }
49899
49921
  const columns = Object.keys(rows[0]);
@@ -49901,13 +49923,13 @@ function printTable(rows) {
49901
49923
  (col) => Math.max(col.length, ...rows.map((r) => formatCell(r[col]).length))
49902
49924
  );
49903
49925
  const header = columns.map((c, i) => c.padEnd(widths[i])).join(" ");
49904
- console.log(chalk286.dim(header));
49905
- console.log(chalk286.dim("-".repeat(header.length)));
49926
+ console.log(chalk287.dim(header));
49927
+ console.log(chalk287.dim("-".repeat(header.length)));
49906
49928
  for (const row2 of rows) {
49907
49929
  const line = columns.map((c, i) => formatCell(row2[c]).padEnd(widths[i])).join(" ");
49908
49930
  console.log(line);
49909
49931
  }
49910
- console.log(chalk286.dim(`
49932
+ console.log(chalk287.dim(`
49911
49933
  ${rows.length} row${rows.length === 1 ? "" : "s"}`));
49912
49934
  }
49913
49935
 
@@ -49967,7 +49989,7 @@ async function sqlColumns(table, connectionName) {
49967
49989
  }
49968
49990
 
49969
49991
  // src/commands/sql/sqlMutate.ts
49970
- import chalk287 from "chalk";
49992
+ import chalk288 from "chalk";
49971
49993
 
49972
49994
  // src/commands/sql/isMutation.ts
49973
49995
  var MUTATION_KEYWORDS = [
@@ -50001,7 +50023,7 @@ function isMutation(sql33) {
50001
50023
  async function sqlMutate(query, connectionName) {
50002
50024
  if (!isMutation(query)) {
50003
50025
  console.error(
50004
- chalk287.red(
50026
+ chalk288.red(
50005
50027
  "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
50006
50028
  )
50007
50029
  );
@@ -50011,18 +50033,18 @@ async function sqlMutate(query, connectionName) {
50011
50033
  const pool = await sqlConnect(conn);
50012
50034
  try {
50013
50035
  const result = await pool.request().query(query);
50014
- console.log(chalk287.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
50036
+ console.log(chalk288.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
50015
50037
  } finally {
50016
50038
  await pool.close();
50017
50039
  }
50018
50040
  }
50019
50041
 
50020
50042
  // src/commands/sql/sqlQuery.ts
50021
- import chalk288 from "chalk";
50043
+ import chalk289 from "chalk";
50022
50044
  async function sqlQuery(query, connectionName) {
50023
50045
  if (isMutation(query)) {
50024
50046
  console.error(
50025
- chalk288.red(
50047
+ chalk289.red(
50026
50048
  "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
50027
50049
  )
50028
50050
  );
@@ -50037,7 +50059,7 @@ async function sqlQuery(query, connectionName) {
50037
50059
  printTable(rows);
50038
50060
  } else {
50039
50061
  console.log(
50040
- chalk288.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
50062
+ chalk289.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
50041
50063
  );
50042
50064
  }
50043
50065
  } finally {
@@ -50529,7 +50551,7 @@ function syncPi(claudeDir, options2) {
50529
50551
  // src/commands/sync/syncSettings.ts
50530
50552
  import * as fs58 from "fs";
50531
50553
  import * as path113 from "path";
50532
- import chalk289 from "chalk";
50554
+ import chalk290 from "chalk";
50533
50555
  async function syncSettings(claudeDir, targetBase, options2) {
50534
50556
  const source = path113.join(claudeDir, "settings.json");
50535
50557
  const target = path113.join(targetBase, "settings.json");
@@ -50548,7 +50570,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
50548
50570
  if (mergedContent !== normalizedTarget) {
50549
50571
  if (!options2?.yes) {
50550
50572
  console.log(
50551
- chalk289.yellow(
50573
+ chalk290.yellow(
50552
50574
  "\n\u26A0\uFE0F Warning: settings.json differs from existing file"
50553
50575
  )
50554
50576
  );
@@ -50556,7 +50578,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
50556
50578
  printDiff(targetContent, mergedContent);
50557
50579
  printAutoConfirmHint();
50558
50580
  const confirm = await promptConfirm(
50559
- chalk289.red("Overwrite existing settings.json?"),
50581
+ chalk290.red("Overwrite existing settings.json?"),
50560
50582
  false
50561
50583
  );
50562
50584
  if (!confirm) {
@@ -50624,17 +50646,17 @@ function registerSync(program) {
50624
50646
  }
50625
50647
 
50626
50648
  // src/commands/testflight/testflightAdd.ts
50627
- import chalk290 from "chalk";
50649
+ import chalk291 from "chalk";
50628
50650
  async function testflightAdd(email, options2) {
50629
50651
  try {
50630
50652
  const config = readTestflightConfig(loadConfig());
50631
50653
  const { message: message4, waiting: waiting2 } = await addTesterOutcome(config, email, {
50632
50654
  internal: options2.internal
50633
50655
  });
50634
- console.log(waiting2 ? chalk290.yellow(message4) : chalk290.green(message4));
50656
+ console.log(waiting2 ? chalk291.yellow(message4) : chalk291.green(message4));
50635
50657
  } catch (error) {
50636
50658
  if (!(error instanceof TestflightError)) throw error;
50637
- console.error(chalk290.red(error.message));
50659
+ console.error(chalk291.red(error.message));
50638
50660
  process.exit(1);
50639
50661
  }
50640
50662
  }
@@ -53563,18 +53585,18 @@ function registerRun(program) {
53563
53585
  }
53564
53586
 
53565
53587
  // src/commands/sessions/nodes/formatLink.ts
53566
- import chalk291 from "chalk";
53588
+ import chalk292 from "chalk";
53567
53589
  var STATE_COLOURS = {
53568
- connected: chalk291.green,
53569
- connecting: chalk291.yellow,
53570
- disconnected: chalk291.red,
53571
- "version-blocked": chalk291.red
53590
+ connected: chalk292.green,
53591
+ connecting: chalk292.yellow,
53592
+ disconnected: chalk292.red,
53593
+ "version-blocked": chalk292.red
53572
53594
  };
53573
53595
  function formatLink(link3) {
53574
- const colour = STATE_COLOURS[link3.state] ?? chalk291.white;
53596
+ const colour = STATE_COLOURS[link3.state] ?? chalk292.white;
53575
53597
  const peer = link3.peerVersion ? ` peer ${link3.peerVersion}` : "";
53576
53598
  const error = link3.error ? `
53577
- ${chalk291.dim(`last error${link3.errorAt ? ` ${link3.errorAt}` : ""}: ${link3.error}`)}` : "";
53599
+ ${chalk292.dim(`last error${link3.errorAt ? ` ${link3.errorAt}` : ""}: ${link3.error}`)}` : "";
53578
53600
  return ` ${link3.name} ${colour(link3.state)} ${link3.url}${peer}${error}`;
53579
53601
  }
53580
53602
 
@@ -62414,7 +62436,7 @@ async function closeSession2() {
62414
62436
  }
62415
62437
 
62416
62438
  // src/commands/sessions/nodes/listNodes.ts
62417
- import chalk292 from "chalk";
62439
+ import chalk293 from "chalk";
62418
62440
  async function nodesReport() {
62419
62441
  const live = await queryNodes();
62420
62442
  if (live)
@@ -62431,10 +62453,10 @@ async function listNodes(options2) {
62431
62453
  console.log(JSON.stringify(report, null, 2));
62432
62454
  return;
62433
62455
  }
62434
- console.log(`${report.local} ${chalk292.dim("(this node)")}`);
62456
+ console.log(`${report.local} ${chalk293.dim("(this node)")}`);
62435
62457
  if (!report.daemonRunning)
62436
- console.log(chalk292.dim(" daemon not running; showing configured links"));
62437
- if (report.links.length === 0) console.log(chalk292.dim(" no links"));
62458
+ console.log(chalk293.dim(" daemon not running; showing configured links"));
62459
+ if (report.links.length === 0) console.log(chalk293.dim(" no links"));
62438
62460
  for (const link3 of report.links) console.log(formatLink(link3));
62439
62461
  }
62440
62462
 
@@ -62456,7 +62478,7 @@ async function findUnlinkedWindowsNode(health2, platform = detectPlatform()) {
62456
62478
  }
62457
62479
 
62458
62480
  // src/commands/sessions/nodes/printReport.ts
62459
- import chalk293 from "chalk";
62481
+ import chalk294 from "chalk";
62460
62482
  function printReport(report) {
62461
62483
  if (report.links.length === 0) {
62462
62484
  console.log(`${report.local} has no links`);
@@ -62470,11 +62492,11 @@ function printReport(report) {
62470
62492
  for (const diagnosis of report.links) printDiagnosis(diagnosis);
62471
62493
  }
62472
62494
  function printDiagnosis(diagnosis) {
62473
- console.log(`${chalk293.bold(diagnosis.name)} ${chalk293.dim(diagnosis.url)}`);
62495
+ console.log(`${chalk294.bold(diagnosis.name)} ${chalk294.dim(diagnosis.url)}`);
62474
62496
  for (const hop of diagnosis.hops) {
62475
- const mark = hop.ok ? chalk293.green("\u2713") : chalk293.red("\u2717");
62497
+ const mark = hop.ok ? chalk294.green("\u2713") : chalk294.red("\u2717");
62476
62498
  console.log(` ${mark} ${hop.hop.padEnd(9)} ${hop.detail ?? hop.error}`);
62477
- if (hop.remediation) console.log(` ${chalk293.yellow(hop.remediation)}`);
62499
+ if (hop.remediation) console.log(` ${chalk294.yellow(hop.remediation)}`);
62478
62500
  }
62479
62501
  }
62480
62502
 
@@ -62546,14 +62568,14 @@ function registerDiagnoseCommands(nodes, calledBy5) {
62546
62568
  }
62547
62569
 
62548
62570
  // src/commands/sessions/nodes/linkNode.ts
62549
- import chalk296 from "chalk";
62571
+ import chalk297 from "chalk";
62550
62572
 
62551
62573
  // src/commands/sessions/nodes/notifyDaemonLinks.ts
62552
- import chalk294 from "chalk";
62574
+ import chalk295 from "chalk";
62553
62575
  async function notifyDaemonLinks() {
62554
62576
  if (!await isDaemonRunning()) {
62555
62577
  console.log(
62556
- chalk294.yellow(
62578
+ chalk295.yellow(
62557
62579
  "The sessions daemon is not running; it loads the links when it starts."
62558
62580
  )
62559
62581
  );
@@ -62561,11 +62583,11 @@ async function notifyDaemonLinks() {
62561
62583
  }
62562
62584
  try {
62563
62585
  await sendToDaemonAwaitAck({ type: "reload-links" });
62564
- console.log(chalk294.dim("The sessions daemon reloaded its links."));
62586
+ console.log(chalk295.dim("The sessions daemon reloaded its links."));
62565
62587
  } catch (error) {
62566
62588
  const message4 = error instanceof Error ? error.message : String(error);
62567
62589
  console.log(
62568
- chalk294.yellow(
62590
+ chalk295.yellow(
62569
62591
  `Could not notify the sessions daemon (${message4}); run \`assist daemon restart\` to apply the change.`
62570
62592
  )
62571
62593
  );
@@ -62573,7 +62595,7 @@ async function notifyDaemonLinks() {
62573
62595
  }
62574
62596
 
62575
62597
  // src/commands/sessions/nodes/readLinks.ts
62576
- import chalk295 from "chalk";
62598
+ import chalk296 from "chalk";
62577
62599
 
62578
62600
  // src/commands/sessions/nodes/writeLinks.ts
62579
62601
  async function writeLinks(links2) {
@@ -62596,7 +62618,7 @@ async function readLinks() {
62596
62618
  await writeLinks(links2);
62597
62619
  const dropped = stored.filter((link3) => !link3.url).map((link3) => link3.name);
62598
62620
  console.log(
62599
- chalk295.yellow(`Removed ${dropped.join(", ")}: ${SSH_LINK_RETIRED}`)
62621
+ chalk296.yellow(`Removed ${dropped.join(", ")}: ${SSH_LINK_RETIRED}`)
62600
62622
  );
62601
62623
  return links2;
62602
62624
  }
@@ -62652,7 +62674,7 @@ async function linkNode(name2, url, options2) {
62652
62674
  throw new Error(`${name2} is this node; link to a different node`);
62653
62675
  const link3 = await buildLink(name2, url, options2);
62654
62676
  await writeLinks([...others, link3]);
62655
- console.log(chalk296.green(`Linked ${name2} (${link3.url})`));
62677
+ console.log(chalk297.green(`Linked ${name2} (${link3.url})`));
62656
62678
  await notifyDaemonLinks();
62657
62679
  }
62658
62680
 
@@ -62835,16 +62857,16 @@ function registerPeerActionCommands(nodes, calledBy5) {
62835
62857
  }
62836
62858
 
62837
62859
  // src/commands/sessions/nodes/unlinkNode.ts
62838
- import chalk297 from "chalk";
62860
+ import chalk298 from "chalk";
62839
62861
  async function unlinkNode(name2) {
62840
62862
  const links2 = await readLinks();
62841
62863
  const remaining = links2.filter((link3) => link3.name !== name2);
62842
62864
  if (remaining.length === links2.length) {
62843
- console.log(chalk297.yellow(`No link named ${name2}`));
62865
+ console.log(chalk298.yellow(`No link named ${name2}`));
62844
62866
  return;
62845
62867
  }
62846
62868
  await writeLinks(remaining);
62847
- console.log(chalk297.green(`Unlinked ${name2}`));
62869
+ console.log(chalk298.green(`Unlinked ${name2}`));
62848
62870
  await notifyDaemonLinks();
62849
62871
  }
62850
62872
 
@@ -63093,10 +63115,10 @@ function createProgram() {
63093
63115
  }
63094
63116
 
63095
63117
  // src/reportCliError.ts
63096
- import chalk298 from "chalk";
63118
+ import chalk299 from "chalk";
63097
63119
  function reportCliError(error) {
63098
63120
  if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError || error instanceof MiroExtractError || error instanceof MissingDatabaseUrlError) {
63099
- console.error(chalk298.red(error.message));
63121
+ console.error(chalk299.red(error.message));
63100
63122
  } else {
63101
63123
  console.error(error);
63102
63124
  }