@kaynooo/cli-git 0.16.0 → 0.17.3

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.
Files changed (11) hide show
  1. package/README.md +4 -4
  2. package/dist/gb.js +1627 -963
  3. package/dist/gc.js +1253 -179
  4. package/dist/gcl.js +1245 -182
  5. package/dist/gd.js +1232 -184
  6. package/dist/gf.js +1252 -183
  7. package/dist/gm.js +1802 -1096
  8. package/dist/gp.js +1233 -182
  9. package/dist/gst.js +1229 -186
  10. package/dist/gu.js +1232 -179
  11. package/package.json +5 -5
package/dist/gc.js CHANGED
@@ -1,20 +1,19 @@
1
1
  #!/usr/bin/env -S bun --no-env-file --config=/dev/null
2
2
  // @bun
3
+ var __esm = (fn, res, err) => () => {
4
+ if (fn)
5
+ try {
6
+ res = fn(fn = 0);
7
+ } catch (e) {
8
+ err = [e];
9
+ }
10
+ if (err)
11
+ throw err[0];
12
+ return res;
13
+ };
3
14
 
4
- // src/gc.ts
5
- import process19 from "process";
6
- // ../kit/src/args.ts
7
- import process9 from "process";
8
- import { parseArgs } from "util";
9
-
10
- // ../kit/src/format.ts
11
- import process7 from "process";
12
-
13
- // ../../node_modules/.bun/@kaynooo+utils@3.0.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-rxztfxgv.js
14
- var N = new Map;
15
- var Nt = /\s+\S*$/;
16
- var Y = /\s/;
17
- function ko(t, e, r = "...") {
15
+ // ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-rkhsft4a.js
16
+ function Ao(t, e, r = "...") {
18
17
  let { suffix: n = "...", includeSuffix: s = false, wordBoundary: o = false } = typeof r === "string" ? { suffix: r } : r;
19
18
  if (t.length <= e)
20
19
  return t;
@@ -25,13 +24,22 @@ function ko(t, e, r = "...") {
25
24
  c = c.trimEnd();
26
25
  return s ? (c + n).slice(0, l) : c + n;
27
26
  }
28
- var be = new Map(["\u20AC", "", "\u201A", "\u0192", "\u201E", "\u2026", "\u2020", "\u2021", "\u02C6", "\u2030", "\u0160", "\u2039", "\u0152", "", "\u017D", "", "", "\u2018", "\u2019", "\u201C", "\u201D", "\u2022", "\u2013", "\u2014", "\u02DC", "\u2122", "\u0161", "\u203A", "\u0153", "", "\u017E", "\u0178"].map((t, e) => [t, 128 + e]).filter(([t]) => t));
29
- var z = new Map;
27
+ var N, Nt, Y, be, W;
28
+ var init_chunk_rkhsft4a = __esm(() => {
29
+ N = new Map;
30
+ Nt = /\s+\S*$/;
31
+ Y = /\s/;
32
+ be = new Map(["\u20AC", "", "\u201A", "\u0192", "\u201E", "\u2026", "\u2020", "\u2021", "\u02C6", "\u2030", "\u0160", "\u2039", "\u0152", "", "\u017D", "", "", "\u2018", "\u2019", "\u201C", "\u201D", "\u2022", "\u2013", "\u2014", "\u02DC", "\u2122", "\u0161", "\u203A", "\u0153", "", "\u017E", "\u0178"].map((t, e) => [t, 128 + e]).filter(([t]) => t));
33
+ W = new Map;
34
+ });
35
+
36
+ // ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/text.js
37
+ var init_text = __esm(() => {
38
+ init_chunk_rkhsft4a();
39
+ });
30
40
 
31
41
  // ../kit/src/mode.ts
32
42
  import process2 from "process";
33
- var MODES = new Set(["terminal", "ci", "agent", "pipe"]);
34
- var AGENT_VARIABLES = ["CLAUDECODE", "AI_AGENT"];
35
43
  function isSet(value) {
36
44
  return value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false";
37
45
  }
@@ -48,12 +56,13 @@ function outputMode(stream = process2.stdout, env = process2.env) {
48
56
  function isInteractive(streams = process2) {
49
57
  return streams.stdin?.isTTY === true && streams.stderr?.isTTY === true;
50
58
  }
59
+ var MODES, AGENT_VARIABLES;
60
+ var init_mode = __esm(() => {
61
+ MODES = new Set(["terminal", "ci", "agent", "pipe"]);
62
+ AGENT_VARIABLES = ["CLAUDECODE", "AI_AGENT"];
63
+ });
51
64
 
52
- // ../kit/src/style.ts
53
- import process6 from "process";
54
-
55
- // ../../node_modules/.bun/@kaynooo+utils@3.0.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
56
- var G2 = /^[a-f0-9]+$/i;
65
+ // ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
57
66
  function b(r) {
58
67
  let e = r.startsWith("#") ? r.slice(1) : r;
59
68
  if (!G2.test(e))
@@ -64,11 +73,6 @@ function b(r) {
64
73
  throw Error(`Invalid hex color length: ${e.length}`);
65
74
  return [Number.parseInt(e.slice(0, 2), 16), Number.parseInt(e.slice(2, 4), 16), Number.parseInt(e.slice(4, 6), 16)];
66
75
  }
67
- var B2 = { reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29], black: [30, 39], red: [31, 39], green: [32, 39], yellow: [33, 39], blue: [34, 39], magenta: [35, 39], cyan: [36, 39], white: [37, 39], gray: [90, 39], grey: [90, 39], blackBright: [90, 39], redBright: [91, 39], greenBright: [92, 39], yellowBright: [93, 39], blueBright: [94, 39], magentaBright: [95, 39], cyanBright: [96, 39], whiteBright: [97, 39], bgBlack: [40, 49], bgRed: [41, 49], bgGreen: [42, 49], bgYellow: [43, 49], bgBlue: [44, 49], bgMagenta: [45, 49], bgCyan: [46, 49], bgWhite: [47, 49], bgBlackBright: [100, 49], bgRedBright: [101, 49], bgGreenBright: [102, 49], bgYellowBright: [103, 49], bgBlueBright: [104, 49], bgMagentaBright: [105, 49], bgCyanBright: [106, 49], bgWhiteBright: [107, 49], rgb: (r, e, l, n = "fg") => [`${n === "fg" ? 38 : 48};2;${r};${e};${l}`, n === "fg" ? 39 : 49], hex: (r, e = "fg") => {
68
- let [l, n, c] = b(r);
69
- return [`${e === "fg" ? 38 : 48};2;${l};${n};${c}`, e === "fg" ? 39 : 49];
70
- }, ansi256: (r, e = "fg") => [`${e === "fg" ? 38 : 48};5;${r}`, e === "fg" ? 39 : 49] };
71
- var h = new Set(["", "1", "2", "3", "true"]);
72
76
  function C(r, e = globalThis.process?.env ?? {}) {
73
77
  if (e.FORCE_COLOR !== undefined)
74
78
  return h.has(e.FORCE_COLOR);
@@ -82,7 +86,7 @@ function f(r, e = []) {
82
86
  l += `\x1B[${e[t][0]}m`, n = `\x1B[${e[t][1]}m${n}`;
83
87
  let c = (t) => C(r.stream ?? globalThis.process?.stdout, r.env) ? l + t + n : t, g = new Map;
84
88
  return new Proxy(c, { get(t, i) {
85
- let a = B2[i];
89
+ let a = B[i];
86
90
  if (Array.isArray(a)) {
87
91
  let s = g.get(i);
88
92
  if (s === undefined)
@@ -105,13 +109,21 @@ function f(r, e = []) {
105
109
  function Fe(r = {}) {
106
110
  return f(r);
107
111
  }
108
- var o = Fe();
112
+ var G2, B, h, o;
113
+ var init_chunk_x450vn3m = __esm(() => {
114
+ G2 = /^[a-f0-9]+$/i;
115
+ B = { reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29], black: [30, 39], red: [31, 39], green: [32, 39], yellow: [33, 39], blue: [34, 39], magenta: [35, 39], cyan: [36, 39], white: [37, 39], gray: [90, 39], grey: [90, 39], blackBright: [90, 39], redBright: [91, 39], greenBright: [92, 39], yellowBright: [93, 39], blueBright: [94, 39], magentaBright: [95, 39], cyanBright: [96, 39], whiteBright: [97, 39], bgBlack: [40, 49], bgRed: [41, 49], bgGreen: [42, 49], bgYellow: [43, 49], bgBlue: [44, 49], bgMagenta: [45, 49], bgCyan: [46, 49], bgWhite: [47, 49], bgBlackBright: [100, 49], bgRedBright: [101, 49], bgGreenBright: [102, 49], bgYellowBright: [103, 49], bgBlueBright: [104, 49], bgMagentaBright: [105, 49], bgCyanBright: [106, 49], bgWhiteBright: [107, 49], rgb: (r, e, l, n = "fg") => [`${n === "fg" ? 38 : 48};2;${r};${e};${l}`, n === "fg" ? 39 : 49], hex: (r, e = "fg") => {
116
+ let [l, n, c] = b(r);
117
+ return [`${e === "fg" ? 38 : 48};2;${l};${n};${c}`, e === "fg" ? 39 : 49];
118
+ }, ansi256: (r, e = "fg") => [`${e === "fg" ? 38 : 48};5;${r}`, e === "fg" ? 39 : 49] };
119
+ h = new Set(["", "1", "2", "3", "true"]);
120
+ o = Fe();
121
+ });
109
122
 
110
- // ../kit/src/theme.ts
111
- import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
112
- import { homedir as homedir2 } from "os";
113
- import { join as join3, resolve as resolve2 } from "path";
114
- import process5 from "process";
123
+ // ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/tools/colors.js
124
+ var init_colors = __esm(() => {
125
+ init_chunk_x450vn3m();
126
+ });
115
127
 
116
128
  // ../kit/src/config.ts
117
129
  import { existsSync } from "fs";
@@ -127,15 +139,21 @@ function findUp(names, from = process3.cwd(), stop = () => false) {
127
139
  return;
128
140
  }
129
141
  }
142
+ var init_config = __esm(() => {
143
+ init_args();
144
+ });
130
145
 
131
146
  // ../kit/src/user-config.ts
132
147
  import { existsSync as existsSync2, readFileSync } from "fs";
133
148
  import { homedir } from "os";
134
- import { join as join2 } from "path";
149
+ import { isAbsolute, join as join2 } from "path";
135
150
  import process4 from "process";
151
+ function xdgFolder(value, fallback) {
152
+ return value !== undefined && isAbsolute(value) ? value : fallback;
153
+ }
136
154
  function configBase(where = {}) {
137
155
  const xdg = where.xdg ?? (where.home === undefined ? process4.env.XDG_CONFIG_HOME : undefined);
138
- return xdg !== undefined && xdg !== "" ? xdg : join2(where.home ?? homedir(), ".config");
156
+ return xdgFolder(xdg, join2(where.home ?? homedir(), ".config"));
139
157
  }
140
158
  function userConfigPath(bin, where = {}) {
141
159
  return join2(configBase(where), "kaynooo-cli", `${bin}.json`);
@@ -158,13 +176,17 @@ function readUserConfig(bin, where = {}, legacy = []) {
158
176
  return {};
159
177
  }
160
178
  }
179
+ var init_user_config = () => {};
161
180
 
162
181
  // ../kit/src/theme.ts
182
+ import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
183
+ import { homedir as homedir2 } from "os";
184
+ import { join as join3, resolve as resolve2 } from "path";
185
+ import process5 from "process";
163
186
  function toLinear(channel) {
164
187
  const value = channel / 255;
165
188
  return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
166
189
  }
167
- var fromLinear = (value) => Math.round(255 * Math.min(1, Math.max(0, value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055)));
168
190
  function toOklab(hex) {
169
191
  const [r, g, b] = [1, 3, 5].map((at) => toLinear(Number.parseInt(hex.slice(at, at + 2), 16)));
170
192
  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
@@ -179,7 +201,6 @@ function fromOklab([lightness, a, b]) {
179
201
  const channels = [4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s, -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s, -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s];
180
202
  return `#${channels.map((channel) => fromLinear(channel).toString(16).padStart(2, "0")).join("")}`;
181
203
  }
182
- var ENDS = new Map;
183
204
  function gradientAt(theme, ratio) {
184
205
  if (theme.gradient === undefined)
185
206
  return;
@@ -193,33 +214,11 @@ function gradientAt(theme, ratio) {
193
214
  const [from, to] = ends;
194
215
  return fromOklab(from.map((start, index) => start + (to[index] - start) * at));
195
216
  }
196
- var DEFAULT = {
197
- colors: { accent: "cyan", id: "yellow", path: "blue", label: "dim", value: "bold", ok: "green", warn: "yellow", problem: "red", note: "dim", plan: "magenta", passed: "green", failed: "red", running: "cyan", queued: "yellow", skipped: "dim" },
198
- glyphs: { ok: "\u2713", warn: "\u25B2", problem: "\u2717", note: "\u203A", plan: "\u25C7", passed: "\u2713", failed: "\u2717", running: "\u25CF", queued: "\u25CB", skipped: "-", bar: "\u2501", rule: "\u2500", corner: "\u256D", open: "\u2022", leaf: "\xB7", guide: "\u2502" },
199
- accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
200
- bins: {},
201
- gradient: ["#c084fc", "#67e8f9"]
202
- };
203
- var BRIGHT = { accent: "cyanBright", id: "yellowBright", path: "blueBright", label: "white", value: "bold whiteBright", ok: "greenBright", warn: "yellowBright", problem: "redBright", note: "white", plan: "magentaBright", passed: "greenBright", failed: "redBright", running: "cyanBright", queued: "yellowBright", skipped: "white" };
204
- var MONO = { accent: "bold", id: "bold", path: "underline", label: "dim", value: "bold", ok: "bold", warn: "bold", problem: "bold", note: "dim", plan: "dim", passed: "bold", failed: "bold", running: "bold", queued: "dim", skipped: "dim" };
205
- var ASCII = { ok: "+", warn: "!", problem: "x", note: ">", plan: "?", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#", rule: "-", corner: "+", open: "*", leaf: "-", guide: "|" };
206
- var PRESETS = {
207
- default: {},
208
- "high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"], gradient: ["#d8b4fe", "#a5f3fc"] },
209
- mono: { colors: MONO, accents: ["bold"], gradient: undefined },
210
- ascii: { glyphs: ASCII }
211
- };
212
- var STYLES = new Set(["bold", "dim", "italic", "underline", "inverse", "strikethrough", "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray", "grey", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright"]);
213
- var HEX = /^#[0-9a-f]{6}$/i;
214
- var CONTROL = /\p{Cc}/u;
215
- var MAX_FILE_BYTES = 64 * 1024;
216
- var SPACES = /\s+/;
217
217
  function isColorSpec(spec) {
218
218
  if (typeof spec === "number")
219
219
  return Number.isInteger(spec) && spec >= 0 && spec <= 255;
220
220
  return typeof spec === "string" && spec.trim() !== "" && spec.trim().split(SPACES).every((token) => STYLES.has(token) || HEX.test(token));
221
221
  }
222
- var CUBE = [0, 95, 135, 175, 215, 255];
223
222
  function cubeLevel(channel) {
224
223
  return CUBE.reduce((best, value, level) => Math.abs(value - channel) < Math.abs(CUBE[best] - channel) ? level : best, 0);
225
224
  }
@@ -327,7 +326,6 @@ function applyFile(theme, file, where, warn) {
327
326
  function endsWalk(home) {
328
327
  return (dir) => dir === resolve2(home) || existsSync3(join3(dir, ".git"));
329
328
  }
330
- var warned = new Set;
331
329
  function warnOnce(message) {
332
330
  if (warned.has(message))
333
331
  return;
@@ -364,8 +362,6 @@ function loadTheme({ env = process5.env, from = process5.cwd(), home = homedir2(
364
362
  }
365
363
  return { theme, sources, preset };
366
364
  }
367
- var current;
368
- var currentKey = "";
369
365
  function activeTheme() {
370
366
  const key = `${process5.cwd()}\x00${process5.env.KIT_THEME ?? ""}\x00${process5.env.XDG_CONFIG_HOME ?? ""}`;
371
367
  if (current === undefined || key !== currentKey) {
@@ -374,9 +370,38 @@ function activeTheme() {
374
370
  }
375
371
  return current;
376
372
  }
373
+ var fromLinear = (value) => Math.round(255 * Math.min(1, Math.max(0, value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055))), ENDS, DEFAULT, BRIGHT, MONO, ASCII, PRESETS, STYLES, HEX, CONTROL, MAX_FILE_BYTES, SPACES, CUBE, warned, current, currentKey = "";
374
+ var init_theme = __esm(() => {
375
+ init_config();
376
+ init_user_config();
377
+ ENDS = new Map;
378
+ DEFAULT = {
379
+ colors: { accent: "cyan", id: "yellow", path: "blue", label: "dim", value: "bold", ok: "green", warn: "yellow", problem: "red", note: "dim", plan: "magenta", passed: "green", failed: "red", running: "cyan", queued: "yellow", skipped: "dim" },
380
+ glyphs: { ok: "\u2713", warn: "\u25B2", problem: "\u2717", note: "\u203A", plan: "\u25C7", passed: "\u2713", failed: "\u2717", running: "\u25CF", queued: "\u25CB", skipped: "-", bar: "\u2501", rule: "\u2500", corner: "\u256D", open: "\u2022", leaf: "\xB7", guide: "\u2502" },
381
+ accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
382
+ bins: {},
383
+ gradient: ["#c084fc", "#67e8f9"]
384
+ };
385
+ BRIGHT = { accent: "cyanBright", id: "yellowBright", path: "blueBright", label: "white", value: "bold whiteBright", ok: "greenBright", warn: "yellowBright", problem: "redBright", note: "white", plan: "magentaBright", passed: "greenBright", failed: "redBright", running: "cyanBright", queued: "yellowBright", skipped: "white" };
386
+ MONO = { accent: "bold", id: "bold", path: "underline", label: "dim", value: "bold", ok: "bold", warn: "bold", problem: "bold", note: "dim", plan: "dim", passed: "bold", failed: "bold", running: "bold", queued: "dim", skipped: "dim" };
387
+ ASCII = { ok: "+", warn: "!", problem: "x", note: ">", plan: "?", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#", rule: "-", corner: "+", open: "*", leaf: "-", guide: "|" };
388
+ PRESETS = {
389
+ default: {},
390
+ "high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"], gradient: ["#d8b4fe", "#a5f3fc"] },
391
+ mono: { colors: MONO, accents: ["bold"], gradient: undefined },
392
+ ascii: { glyphs: ASCII }
393
+ };
394
+ STYLES = new Set(["bold", "dim", "italic", "underline", "inverse", "strikethrough", "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray", "grey", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright"]);
395
+ HEX = /^#[0-9a-f]{6}$/i;
396
+ CONTROL = /\p{Cc}/u;
397
+ MAX_FILE_BYTES = 64 * 1024;
398
+ SPACES = /\s+/;
399
+ CUBE = [0, 95, 135, 175, 215, 255];
400
+ warned = new Set;
401
+ });
377
402
 
378
403
  // ../kit/src/style.ts
379
- var MARK_WORDS = { ok: "ok:", warn: "warning:", problem: "error:", note: "note:", plan: "would:" };
404
+ import process6 from "process";
380
405
  function takesControlCodes(stream, env = process6.env) {
381
406
  return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb" && outputMode(stream, env) === "terminal";
382
407
  }
@@ -396,17 +421,24 @@ function role(name, stream, env = process6.env) {
396
421
  const colors = paint(stream, env);
397
422
  return takesControlCodes(stream, env) ? tinted(colors, activeTheme().theme.colors[name], env) : colors;
398
423
  }
399
- var STATUS_WORDS = {
400
- passed: ["passed", "success", "succeeded", "ok"],
401
- failed: ["failed", "failure", "error", "errored"],
402
- running: ["running", "in_progress", "started", "holding"],
403
- queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
404
- skipped: ["skipped", "cancelled", "canceled", "manual"]
405
- };
406
- var STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
424
+ var MARK_WORDS, STATUS_WORDS, STATUS_OF;
425
+ var init_style = __esm(() => {
426
+ init_colors();
427
+ init_mode();
428
+ init_theme();
429
+ MARK_WORDS = { ok: "ok:", warn: "warning:", problem: "error:", note: "note:", plan: "would:" };
430
+ STATUS_WORDS = {
431
+ passed: ["passed", "success", "succeeded", "ok"],
432
+ failed: ["failed", "failure", "error", "errored"],
433
+ running: ["running", "in_progress", "started", "holding"],
434
+ queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
435
+ skipped: ["skipped", "cancelled", "canceled", "manual"]
436
+ };
437
+ STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
438
+ });
407
439
 
408
440
  // ../kit/src/format.ts
409
- var UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
441
+ import process7 from "process";
410
442
  function formatSeconds(total) {
411
443
  let rest = Math.max(0, Math.round(total));
412
444
  const amounts = UNITS.map(([unit, size]) => {
@@ -438,10 +470,8 @@ function formatAge(date, now = Date.now()) {
438
470
  return seconds < 60 ? "just now" : `${upTo(formatSeconds(seconds), " ")} ago`;
439
471
  }
440
472
  function truncate(text, width) {
441
- return ko(text, width, { suffix: "\u2026", includeSuffix: true });
473
+ return Ao(text, width, { suffix: "\u2026", includeSuffix: true });
442
474
  }
443
- var LINE_BREAKS = /\s*\n\s*/g;
444
- var ESCAPE = String.fromCharCode(27);
445
475
  function textWidth(text) {
446
476
  return Bun.stringWidth(text);
447
477
  }
@@ -490,14 +520,40 @@ function jsonText(value, replacer, { stream = process7.stdout, env = process7.en
490
520
  function printJson(value) {
491
521
  console.log(jsonText(value));
492
522
  }
523
+ var UNITS, LINE_BREAKS, ESCAPE;
524
+ var init_format = __esm(() => {
525
+ init_text();
526
+ init_mode();
527
+ init_style();
528
+ UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
529
+ LINE_BREAKS = /\s*\n\s*/g;
530
+ ESCAPE = String.fromCharCode(27);
531
+ });
493
532
 
494
533
  // ../kit/src/help.ts
495
534
  import process8 from "process";
496
- var OPTIONAL = /(?<!\x1B)\[[^\]]+\]/g;
497
- var USAGE_PREFIX = /^usage:\s*/i;
498
- var FULL_STOP = /\.$/;
499
535
  function usageLine(usage, colors = paint(process8.stdout)) {
500
- return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
536
+ const lines = usage.replace(USAGE_PREFIX, "").split(`
537
+ `);
538
+ const blank = lines.indexOf("");
539
+ const synopses = blank === -1 ? lines : lines.slice(0, blank);
540
+ const details = blank === -1 ? [] : lines.slice(blank + 1);
541
+ const colon = synopses[0].indexOf(": ");
542
+ const inline = synopses[0].slice(colon + 2);
543
+ const summary = colon === -1 ? details.shift() : `${inline.charAt(0).toUpperCase()}${inline.slice(1)}`;
544
+ if (colon !== -1)
545
+ synopses[0] = synopses[0].slice(0, colon);
546
+ const head = `${colors.bold("Usage:")} ${synopses.map((line) => line.replaceAll(OPTIONAL, (part) => colors.dim(part))).join(`
547
+ `)}`;
548
+ const lead = summary === undefined ? [] : ["", colors.bold(prose(summary, colors))];
549
+ const rest = details.length === 0 ? [] : ["", ...details.map((line) => prose(line, colors))];
550
+ return [head, ...lead, ...rest].join(`
551
+ `);
552
+ }
553
+ function prose(line, colors) {
554
+ if (colors.cyan("x") === "x")
555
+ return line;
556
+ return line.replaceAll(PROSE_MARKS, (match, code, flag) => code === undefined ? colors.cyan(flag ?? match) : colors.bold(code));
501
557
  }
502
558
  function helpText(usage, options, colors = paint(process8.stdout), { examples = [], exits = [] } = {}) {
503
559
  return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join(`
@@ -532,7 +588,6 @@ function exampleRows(examples, colors = paint(process8.stdout)) {
532
588
  return [];
533
589
  return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? ` ${example}` : ` ${example[0]} ${colors.dim(`# ${example[1]}`)}`)];
534
590
  }
535
- var MAX_INLINE_CHOICES = 24;
536
591
  function optionRows(options, colors = paint(process8.stdout)) {
537
592
  const rows = Object.entries(options).map(([name, option]) => {
538
593
  const short = option.short === undefined ? " " : `${colors.cyan(`-${option.short}`)}, `;
@@ -547,9 +602,17 @@ function optionRows(options, colors = paint(process8.stdout)) {
547
602
  const width = Math.max(0, ...rows.map((row) => row.width));
548
603
  return rows.map((row) => row.description === "" ? ` ${row.flag}` : ` ${row.flag}${" ".repeat(width - row.width)} ${colors.dim(row.description)}`);
549
604
  }
605
+ var OPTIONAL, USAGE_PREFIX, FULL_STOP, PROSE_MARKS, MAX_INLINE_CHOICES = 24;
606
+ var init_help = __esm(() => {
607
+ init_mode();
608
+ init_style();
609
+ OPTIONAL = /(?<!\x1B)\[[^\]]+\]/g;
610
+ USAGE_PREFIX = /^usage:\s*/i;
611
+ FULL_STOP = /\.$/;
612
+ PROSE_MARKS = /`([^`\n]+)`|(?<![\w-])(--[a-z][\w-]*|-[a-z](?![\w-]))/gi;
613
+ });
550
614
 
551
615
  // ../kit/src/text.ts
552
- var ANSI = /\x1B(?:\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]|\][^\x07\x1B]*(?:\x07|\x1B\\)|[\x40-\x5A\x5C-\x5F])/g;
553
616
  function distance(a, b) {
554
617
  const left = [...a];
555
618
  const right = [...b];
@@ -575,8 +638,12 @@ function closest(name, names) {
575
638
  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
576
639
  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
577
640
  }
641
+ var ANSI;
642
+ var init_text2 = __esm(() => {
643
+ ANSI = /\x1B(?:\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]|\][^\x07\x1B]*(?:\x07|\x1B\\)|[\x40-\x5A\x5C-\x5F])/g;
644
+ });
645
+
578
646
  // ../kit/src/input.ts
579
- var WHOLE = /^\d+$/;
580
647
  function wholeNumber(value, name, fallback, min = 1) {
581
648
  if (value === undefined)
582
649
  return fallback;
@@ -585,8 +652,6 @@ function wholeNumber(value, name, fallback, min = 1) {
585
652
  badUsage(`${name.startsWith("<") ? name : `--${name}`} takes a whole number from ${min}, not ${value}`);
586
653
  return number;
587
654
  }
588
- var DURATION = /^(\d+(?:\.\d+)?)(ms|[smhd])?$/;
589
- var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
590
655
  function duration(value, name, fallback, unit = "s") {
591
656
  if (value === undefined)
592
657
  return fallback;
@@ -596,40 +661,27 @@ function duration(value, name, fallback, unit = "s") {
596
661
  badUsage(`--${name} takes a duration such as 30s, 5m, 1h or 7d, not ${value}`);
597
662
  return ms;
598
663
  }
664
+ var WHOLE, DURATION, UNIT_MS;
665
+ var init_input = __esm(() => {
666
+ init_args();
667
+ WHOLE = /^\d+$/;
668
+ DURATION = /^(\d+(?:\.\d+)?)(ms|[smhd])?$/;
669
+ UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
670
+ });
599
671
 
600
672
  // ../kit/src/args.ts
601
- var DASHES = /^-+/;
673
+ import process9 from "process";
674
+ import { parseArgs } from "util";
602
675
  function jsonOption(holds) {
603
676
  return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
604
677
  }
605
- class Exit extends Error {
606
- code;
607
- hint;
608
- constructor(message, code, hint) {
609
- super(message);
610
- this.code = code;
611
- this.hint = hint;
612
- }
613
- }
614
678
  function fail(message, code = 2, hint) {
615
679
  throw new Exit(message, code, hint);
616
680
  }
617
-
618
- class UsageError extends Exit {
619
- constructor(message, hint) {
620
- super(message, 2, hint);
621
- }
622
- }
623
681
  function badUsage(message) {
624
682
  throw new UsageError(message);
625
683
  }
626
684
 
627
- class HelpShown extends Exit {
628
- constructor() {
629
- super("help shown", 0);
630
- }
631
- }
632
-
633
685
  class Completing {
634
686
  options;
635
687
  positionals;
@@ -640,11 +692,6 @@ class Completing {
640
692
  this.candidates = candidates;
641
693
  }
642
694
  }
643
- var completion = { active: false };
644
- var OUTPUT_OPTIONS = {
645
- color: { type: "string", description: "auto (on a terminal alone), always or never" },
646
- plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
647
- };
648
695
  function applyOutput(color, plain, env = process9.env) {
649
696
  const when = plain === true ? "never" : color ?? "auto";
650
697
  if (when === "auto")
@@ -798,7 +845,6 @@ function parseError(error) {
798
845
  const message = upTo(error instanceof Error ? error.message : String(error), ". ");
799
846
  return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
800
847
  }
801
- var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
802
848
  function nearestOption(message, options, allowNegative) {
803
849
  const typed = UNKNOWN_OPTION.exec(message)?.[1];
804
850
  if (typed === undefined)
@@ -814,6 +860,694 @@ function nearestOption(message, options, allowNegative) {
814
860
  const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
815
861
  return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
816
862
  }
863
+ var DASHES, EXIT, Exit, UsageError, HelpShown, completion, OUTPUT_OPTIONS, UNKNOWN_OPTION;
864
+ var init_args = __esm(() => {
865
+ init_format();
866
+ init_help();
867
+ init_text2();
868
+ init_help();
869
+ init_input();
870
+ DASHES = /^-+/;
871
+ EXIT = Symbol.for("@kaynooo/cli-kit/Exit");
872
+ Exit = class Exit extends Error {
873
+ code;
874
+ hint;
875
+ [EXIT] = true;
876
+ constructor(message, code, hint) {
877
+ super(message);
878
+ this.code = code;
879
+ this.hint = hint;
880
+ }
881
+ static [Symbol.hasInstance](value) {
882
+ if (this !== Exit)
883
+ return Function.prototype[Symbol.hasInstance].call(this, value);
884
+ return typeof value === "object" && value !== null && value[EXIT] === true;
885
+ }
886
+ };
887
+ UsageError = class UsageError extends Exit {
888
+ constructor(message, hint) {
889
+ super(message, 2, hint);
890
+ }
891
+ };
892
+ HelpShown = class HelpShown extends Exit {
893
+ constructor() {
894
+ super("help shown", 0);
895
+ }
896
+ };
897
+ completion = { active: false };
898
+ OUTPUT_OPTIONS = {
899
+ color: { type: "string", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
900
+ plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
901
+ };
902
+ UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
903
+ });
904
+
905
+ // ../kit/src/folders.ts
906
+ import { homedir as homedir3 } from "os";
907
+ import { join as join4 } from "path";
908
+ import process13 from "process";
909
+ function cacheFolder({ home = homedir3(), env = process13.env } = {}) {
910
+ return xdgFolder(env.XDG_CACHE_HOME, join4(home, ".cache"));
911
+ }
912
+ var SKIPPED_FOLDERS;
913
+ var init_folders = __esm(() => {
914
+ init_user_config();
915
+ SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
916
+ });
917
+
918
+ // ../kit/src/answers.ts
919
+ import { mkdirSync, readFileSync as readFileSync5, writeFileSync } from "fs";
920
+ import { dirname as dirname2, join as join5 } from "path";
921
+ function answersFile() {
922
+ return join5(cacheFolder(), "kaynooo-cli", "answers.json");
923
+ }
924
+ function stored() {
925
+ try {
926
+ const parsed = JSON.parse(readFileSync5(answersFile(), "utf-8"));
927
+ if (typeof parsed !== "object" || parsed === null)
928
+ return {};
929
+ return Object.fromEntries(Object.entries(parsed).filter((entry) => Array.isArray(entry[1]) && entry[1].every((answer) => typeof answer === "string")));
930
+ } catch {
931
+ return {};
932
+ }
933
+ }
934
+ function earlierAnswers(key) {
935
+ return stored()[key] ?? [];
936
+ }
937
+ function rememberAnswer(key, answer) {
938
+ const all = stored();
939
+ const file = answersFile();
940
+ all[key] = [answer, ...(all[key] ?? []).filter((earlier) => earlier !== answer)].slice(0, KEPT);
941
+ try {
942
+ mkdirSync(dirname2(file), { recursive: true });
943
+ writeFileSync(file, JSON.stringify(all));
944
+ } catch {}
945
+ }
946
+ var KEPT = 50;
947
+ var init_answers = __esm(() => {
948
+ init_folders();
949
+ });
950
+
951
+ // ../kit/src/job.ts
952
+ import process14 from "process";
953
+ function stopJob() {
954
+ process14.kill(0, "SIGTSTP");
955
+ }
956
+ var init_job = () => {};
957
+
958
+ // ../kit/src/picker/line.ts
959
+ function isEditKey(key) {
960
+ return EDIT_KEYS.has(key);
961
+ }
962
+ function endsKills(key) {
963
+ return typeof key !== "object" && !isEditKey(key);
964
+ }
965
+ function isWord(char) {
966
+ return char !== undefined && WORD_CHARACTER.test(char);
967
+ }
968
+ function wordStart(chars, from) {
969
+ let at = from;
970
+ while (at > 0 && !isWord(chars[at - 1]))
971
+ at--;
972
+ while (at > 0 && isWord(chars[at - 1]))
973
+ at--;
974
+ return at;
975
+ }
976
+ function wordEnd(chars, from) {
977
+ let at = from;
978
+ while (at < chars.length && !isWord(chars[at]))
979
+ at++;
980
+ while (at < chars.length && isWord(chars[at]))
981
+ at++;
982
+ return at;
983
+ }
984
+ function spacedStart(chars, from) {
985
+ let at = from;
986
+ while (at > 0 && SPACE.test(chars[at - 1] ?? ""))
987
+ at--;
988
+ while (at > 0 && !SPACE.test(chars[at - 1] ?? ""))
989
+ at--;
990
+ return at;
991
+ }
992
+ function cut(chars, from, to) {
993
+ return { text: [...chars.slice(0, from), ...chars.slice(to)].join(""), caret: from };
994
+ }
995
+ function insert(chars, at, text) {
996
+ const typed = [...text];
997
+ return { text: [...chars.slice(0, at), ...typed, ...chars.slice(at)].join(""), caret: at + typed.length };
998
+ }
999
+ function editLine(line, key) {
1000
+ const { killed = "", chained = false } = line;
1001
+ const chars = [...line.text];
1002
+ const at = Math.min(Math.max(line.caret, 0), chars.length);
1003
+ const edited = edit(chars, at, key, killed);
1004
+ if (typeof key === "object" || !BACKWARD_KILLS.has(key) && !FORWARD_KILLS.has(key))
1005
+ return line.killed === undefined ? edited : { ...edited, killed };
1006
+ const taken = chars.slice(edited.caret, edited.caret + chars.length - [...edited.text].length).join("");
1007
+ if (taken === "")
1008
+ return { ...edited, killed, chained };
1009
+ if (!chained)
1010
+ return { ...edited, killed: taken, chained: true };
1011
+ return { ...edited, killed: BACKWARD_KILLS.has(key) ? taken + killed : killed + taken, chained: true };
1012
+ }
1013
+ function edit(chars, at, key, killed) {
1014
+ const text = chars.join("");
1015
+ if (typeof key === "object")
1016
+ return insert(chars, at, key.text);
1017
+ switch (key) {
1018
+ case "left":
1019
+ return { text, caret: Math.max(at - 1, 0) };
1020
+ case "right":
1021
+ return { text, caret: Math.min(at + 1, chars.length) };
1022
+ case "wordleft":
1023
+ return { text, caret: wordStart(chars, at) };
1024
+ case "wordright":
1025
+ return { text, caret: wordEnd(chars, at) };
1026
+ case "linestart":
1027
+ return { text, caret: 0 };
1028
+ case "lineend":
1029
+ return { text, caret: chars.length };
1030
+ case "erase":
1031
+ return cut(chars, Math.max(at - 1, 0), at);
1032
+ case "delete":
1033
+ return cut(chars, at, Math.min(at + 1, chars.length));
1034
+ case "word":
1035
+ return cut(chars, spacedStart(chars, at), at);
1036
+ case "killword":
1037
+ return cut(chars, wordStart(chars, at), at);
1038
+ case "killnext":
1039
+ return cut(chars, at, wordEnd(chars, at));
1040
+ case "clear":
1041
+ return cut(chars, 0, at);
1042
+ case "killend":
1043
+ return cut(chars, at, chars.length);
1044
+ case "yank":
1045
+ return insert(chars, at, killed);
1046
+ }
1047
+ }
1048
+ function visible({ text, caret }, room) {
1049
+ const chars = [...text];
1050
+ const at = Math.min(Math.max(caret, 0), chars.length);
1051
+ const cells = at === chars.length ? [...chars, " "] : chars;
1052
+ const widths = cells.map((char) => Bun.stringWidth(char));
1053
+ const width = (from, to) => widths.slice(from, to).reduce((sum, size) => sum + size, 0);
1054
+ const fits = (from, to) => (from > 0 ? 1 : 0) + width(from, to) + (to < cells.length ? 1 : 0) <= room;
1055
+ let start = at;
1056
+ let end = at + 1;
1057
+ while (start > 0 && fits(start - 1, end))
1058
+ start--;
1059
+ while (end < cells.length && fits(start, end + 1))
1060
+ end++;
1061
+ const left = start > 0 ? "\u2026" : "";
1062
+ const right = end < cells.length ? "\u2026" : "";
1063
+ return { before: left + chars.slice(start, at).join(""), at: chars[at], after: chars.slice(at + 1, end).join("") + right, column: left.length + width(start, at) };
1064
+ }
1065
+ var EDIT_KEYS, BACKWARD_KILLS, FORWARD_KILLS, WORD_CHARACTER, SPACE;
1066
+ var init_line = __esm(() => {
1067
+ EDIT_KEYS = new Set(["left", "right", "wordleft", "wordright", "linestart", "lineend", "erase", "delete", "word", "killword", "killnext", "clear", "killend", "yank"]);
1068
+ BACKWARD_KILLS = new Set(["word", "killword", "clear"]);
1069
+ FORWARD_KILLS = new Set(["killnext", "killend"]);
1070
+ WORD_CHARACTER = /[\p{L}\p{N}_]/u;
1071
+ SPACE = /\s/;
1072
+ });
1073
+
1074
+ // ../kit/src/picker/score.ts
1075
+ function startsWord(text, index) {
1076
+ if (index === 0)
1077
+ return true;
1078
+ const before = text[index - 1];
1079
+ return BOUNDARY_AFTER.has(before) || LOWER.test(before) && UPPER.test(text[index]);
1080
+ }
1081
+ function fuzzy(query, text) {
1082
+ if (query === "")
1083
+ return { score: 0, positions: [] };
1084
+ const exact = query !== query.toLowerCase();
1085
+ const needle = exact ? query : query.toLowerCase();
1086
+ const haystack = exact ? text : text.toLowerCase();
1087
+ if (haystack.length !== text.length || needle.length > haystack.length)
1088
+ return;
1089
+ const width = haystack.length;
1090
+ const best = Array.from({ length: needle.length }, () => new Array(width).fill(NONE));
1091
+ const from = Array.from({ length: needle.length }, () => new Array(width).fill(-1));
1092
+ for (let j = 0;j < needle.length; j++) {
1093
+ let run = NONE;
1094
+ let runAt = -1;
1095
+ for (let i = j;i < width; i++) {
1096
+ if (j > 0 && i - 2 >= j - 1) {
1097
+ const candidate = best[j - 1][i - 2] + (i - 2) * GAP;
1098
+ if (candidate > run) {
1099
+ run = candidate;
1100
+ runAt = i - 2;
1101
+ }
1102
+ }
1103
+ if (haystack[i] !== needle[j])
1104
+ continue;
1105
+ const here = MATCH + (startsWord(text, i) ? BOUNDARY : 0) + (i === 0 ? PREFIX : 0);
1106
+ if (j === 0) {
1107
+ best[0][i] = here - i * GAP;
1108
+ continue;
1109
+ }
1110
+ const joined = best[j - 1][i - 1] + CONSECUTIVE;
1111
+ const skipped = run - (i - 1) * GAP;
1112
+ if (joined > NONE && joined >= skipped) {
1113
+ best[j][i] = joined + here;
1114
+ from[j][i] = i - 1;
1115
+ } else if (skipped > NONE) {
1116
+ best[j][i] = skipped + here;
1117
+ from[j][i] = runAt;
1118
+ }
1119
+ }
1120
+ }
1121
+ const last = best[needle.length - 1];
1122
+ let end = -1;
1123
+ for (let i = 0;i < width; i++) {
1124
+ if (last[i] > NONE && (end === -1 || last[i] > last[end]))
1125
+ end = i;
1126
+ }
1127
+ if (end === -1)
1128
+ return;
1129
+ const positions = [];
1130
+ for (let j = needle.length - 1, i = end;j >= 0; j--) {
1131
+ positions.unshift(i);
1132
+ i = from[j][i];
1133
+ }
1134
+ return { score: last[end], positions };
1135
+ }
1136
+ function rank(query, lines) {
1137
+ if (query === "")
1138
+ return lines.map((_, index) => ({ index, positions: [] }));
1139
+ const found = [];
1140
+ for (const [index, line] of lines.entries()) {
1141
+ const match = fuzzy(query, line);
1142
+ if (match !== undefined)
1143
+ found.push({ index, positions: match.positions, score: match.score });
1144
+ }
1145
+ return found.sort((a, b) => b.score - a.score || lines[a.index].length - lines[b.index].length || a.index - b.index);
1146
+ }
1147
+ var MATCH = 16, CONSECUTIVE = 12, BOUNDARY = 10, PREFIX = 8, GAP = 1, BOUNDARY_AFTER, UPPER, LOWER, NONE;
1148
+ var init_score = __esm(() => {
1149
+ BOUNDARY_AFTER = new Set([" ", "/", "-", "_", ".", ":", "\\", "(", "[", ",", "\t"]);
1150
+ UPPER = /\p{Lu}/u;
1151
+ LOWER = /\p{Ll}/u;
1152
+ NONE = Number.NEGATIVE_INFINITY;
1153
+ });
1154
+
1155
+ // ../kit/src/picker/state.ts
1156
+ function repeat(value, count) {
1157
+ return Array.from({ length: count }).fill(value);
1158
+ }
1159
+ function styled(line) {
1160
+ let text = "";
1161
+ const styles = [];
1162
+ let active = "";
1163
+ let colored = false;
1164
+ let last = 0;
1165
+ function add(chunk) {
1166
+ const flat = chunk.replace(CONTROL2, " ");
1167
+ text += flat;
1168
+ colored ||= active !== "" && flat !== "";
1169
+ styles.push(...repeat(active, flat.length));
1170
+ }
1171
+ for (const found of line.matchAll(ANSI)) {
1172
+ add(line.slice(last, found.index));
1173
+ last = found.index + found[0].length;
1174
+ if (SGR.test(found[0]))
1175
+ active = RESET.test(found[0]) ? "" : active + found[0];
1176
+ }
1177
+ add(line.slice(last));
1178
+ return { text, styles: colored ? styles : undefined };
1179
+ }
1180
+ function lay(rows, searched) {
1181
+ const parsed = rows.map((row) => row.cells.map(styled));
1182
+ const widths = (parsed[0] ?? []).map((_, column) => Math.max(...parsed.map((cells) => Bun.stringWidth(cells[column]?.text ?? ""))));
1183
+ return parsed.map((cells, at) => {
1184
+ let text = "";
1185
+ const styles = [];
1186
+ let colored = false;
1187
+ let searchEnd = 0;
1188
+ for (const [column, cell] of cells.entries()) {
1189
+ const last = column === cells.length - 1;
1190
+ const shown = cells.length > 1 && last ? cell.text.trimEnd() : cell.text;
1191
+ text += shown;
1192
+ colored ||= cell.styles !== undefined;
1193
+ styles.push(...cell.styles?.slice(0, shown.length) ?? repeat("", shown.length));
1194
+ if (column < searched)
1195
+ searchEnd = cells.length > 1 ? text.trimEnd().length : text.length;
1196
+ if (!last) {
1197
+ const pad = widths[column] - Bun.stringWidth(cell.text) + COLUMN_GAP;
1198
+ text += " ".repeat(pad);
1199
+ styles.push(...repeat("", pad));
1200
+ }
1201
+ }
1202
+ return { text, styles: colored ? styles : undefined, searchable: rows[at].search ?? text.slice(0, searchEnd) };
1203
+ });
1204
+ }
1205
+ function parseKeys(input, paste = { active: false }, ctrls = []) {
1206
+ const codes = new Map(ctrls.map((name) => [String.fromCharCode(name.codePointAt(name.length - 1) - 96), name]));
1207
+ return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => {
1208
+ const wheel = MOUSE.exec(sequence)?.[1];
1209
+ if (wheel !== undefined)
1210
+ return repeat(wheel === "64" ? "up" : "down", wheel === "64" || wheel === "65" ? WHEEL_LINES : 0);
1211
+ const named = codes.get(sequence);
1212
+ const key = named === undefined ? KEYS[sequence] : { ctrl: named };
1213
+ if (sequence === PASTE_START || sequence === PASTE_END) {
1214
+ paste.active = sequence === PASTE_START;
1215
+ return [];
1216
+ }
1217
+ if (paste.active && (sequence === "\r" || sequence === `
1218
+ `))
1219
+ return [];
1220
+ if (key !== undefined)
1221
+ return [key];
1222
+ return IS_CONTROL.test(sequence) || sequence.startsWith("\x1B") ? [] : [{ text: sequence }];
1223
+ });
1224
+ }
1225
+ function createState(rows, { multi = false, prompt = "> ", query = "", header = "", expect = [], searched = Number.POSITIVE_INFINITY } = {}) {
1226
+ const state = { rows: [], items: [], styles: [], searchable: [], searched, header, expect, key: "", status: "", query, caret: [...query].length, killed: "", chained: false, matches: [], cursor: 0, help: false, page: 10, marked: new Set, multi, prompt, done: undefined };
1227
+ return withRows(state, rows);
1228
+ }
1229
+ function withRows(state, rows, header = state.header) {
1230
+ const cells = rows.map((row) => typeof row === "string" ? { hidden: [], cells: [row] } : row);
1231
+ const laid = lay(cells, state.searched);
1232
+ const searchable = laid.map((row) => row.searchable);
1233
+ const matches = rank(state.query, searchable);
1234
+ return { ...state, rows: cells, items: laid.map((row) => row.text), styles: laid.map((row) => row.styles), searchable, header, matches, cursor: Math.max(0, Math.min(matches.length - 1, state.cursor)), marked: new Set };
1235
+ }
1236
+ function withQuery(state, key) {
1237
+ const { text, caret, killed = "", chained = false } = editLine({ text: state.query, caret: state.caret, killed: state.killed, chained: state.chained }, key);
1238
+ return text === state.query ? { ...state, caret, killed, chained } : { ...state, query: text, caret, killed, chained, matches: rank(text, state.searchable), cursor: 0 };
1239
+ }
1240
+ function move(state, by) {
1241
+ return { ...state, cursor: Math.max(0, Math.min(state.matches.length - 1, state.cursor + by)) };
1242
+ }
1243
+ function highlighted(state) {
1244
+ return state.matches[state.cursor]?.index;
1245
+ }
1246
+ function press(state, key) {
1247
+ if (state.done !== undefined)
1248
+ return state;
1249
+ if (state.chained && endsKills(key))
1250
+ state = { ...state, chained: false };
1251
+ if (state.help)
1252
+ return { ...state, help: false };
1253
+ if (typeof key === "object") {
1254
+ if ("text" in key)
1255
+ return withQuery(state, key);
1256
+ return state.expect.includes(key.ctrl) ? { ...state, done: "accept", key: key.ctrl } : state;
1257
+ }
1258
+ if (isEditKey(key))
1259
+ return withQuery(state, key);
1260
+ switch (key) {
1261
+ case "up":
1262
+ return move(state, -1);
1263
+ case "down":
1264
+ return move(state, 1);
1265
+ case "pageup":
1266
+ return move(state, -state.page);
1267
+ case "pagedown":
1268
+ return move(state, state.page);
1269
+ case "home":
1270
+ return move(state, -state.matches.length);
1271
+ case "end":
1272
+ return move(state, state.matches.length);
1273
+ case "cancel":
1274
+ return { ...state, done: "cancel" };
1275
+ case "help":
1276
+ return { ...state, help: true };
1277
+ case "suspend":
1278
+ return state;
1279
+ case "enter":
1280
+ return state.matches.length === 0 && state.marked.size === 0 ? state : { ...state, done: "accept" };
1281
+ case "tab": {
1282
+ const at = highlighted(state);
1283
+ if (!state.multi || at === undefined)
1284
+ return state;
1285
+ const marked = new Set(state.marked);
1286
+ if (!marked.delete(at))
1287
+ marked.add(at);
1288
+ return move({ ...state, marked }, 1);
1289
+ }
1290
+ }
1291
+ }
1292
+ function chosen(state) {
1293
+ if (state.marked.size > 0)
1294
+ return state.rows.filter((_, index) => state.marked.has(index));
1295
+ const at = highlighted(state);
1296
+ return at === undefined ? [] : [state.rows[at]];
1297
+ }
1298
+ var CONTROL2, IS_CONTROL, SGR, RESET, COLUMN_GAP = 2, PASTE_START = "\x1B[200~", PASTE_END = "\x1B[201~", KEY_SEQUENCES, MOUSE, WHEEL_LINES = 3, KEYS, CTRL_KEY;
1299
+ var init_state = __esm(() => {
1300
+ init_text2();
1301
+ init_line();
1302
+ init_score();
1303
+ CONTROL2 = /[\x00-\x1F\x7F-\x9F]/g;
1304
+ IS_CONTROL = /[\x00-\x1F\x7F-\x9F]/;
1305
+ SGR = /^\x1B\[[0-9;]*m$/;
1306
+ RESET = /^\x1B\[0?m$/;
1307
+ KEY_SEQUENCES = /\x1B\[<[0-9;]*[A-Za-z]|\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|\x1B[\s\S]|[\s\S]/gu;
1308
+ MOUSE = /^\x1B\[<(\d+);\d+;\d+[a-z]$/i;
1309
+ KEYS = {
1310
+ "\x1B[A": "up",
1311
+ "\x1BOA": "up",
1312
+ "\x10": "up",
1313
+ "\x1B[B": "down",
1314
+ "\x1BOB": "down",
1315
+ "\x0E": "down",
1316
+ "\x1B[5~": "pageup",
1317
+ "\x1B[6~": "pagedown",
1318
+ "\x1B[H": "home",
1319
+ "\x1B[1~": "home",
1320
+ "\x1BOH": "home",
1321
+ "\x1B[F": "end",
1322
+ "\x1B[4~": "end",
1323
+ "\x1BOF": "end",
1324
+ "\r": "enter",
1325
+ "\n": "enter",
1326
+ "\x03": "cancel",
1327
+ "\x1B": "cancel",
1328
+ "\x1B[D": "left",
1329
+ "\x1BOD": "left",
1330
+ "\x1B[C": "right",
1331
+ "\x1BOC": "right",
1332
+ "\x1B[1;5D": "wordleft",
1333
+ "\x1B[1;3D": "wordleft",
1334
+ "\x1Bb": "wordleft",
1335
+ "\x1B[1;5C": "wordright",
1336
+ "\x1B[1;3C": "wordright",
1337
+ "\x1Bf": "wordright",
1338
+ "\x01": "linestart",
1339
+ "\x05": "lineend",
1340
+ "\x7F": "erase",
1341
+ "\x1B[3~": "delete",
1342
+ "\b": "killword",
1343
+ "\x1B\x7F": "killword",
1344
+ "\x1B[3;5~": "killnext",
1345
+ "\x1Bd": "killnext",
1346
+ "\x15": "clear",
1347
+ "\v": "killend",
1348
+ "\x17": "word",
1349
+ "\x19": "yank",
1350
+ "\x1A": "suspend",
1351
+ "\t": "tab",
1352
+ "\x1F": "help",
1353
+ "\x1BOP": "help",
1354
+ "\x1B[11~": "help"
1355
+ };
1356
+ CTRL_KEY = /^ctrl-[abd-gkln-z]$/;
1357
+ });
1358
+
1359
+ // ../kit/src/redraw.ts
1360
+ function overwrite(lines, columns) {
1361
+ return lines.map((line) => textWidth(line) % columns === 0 ? `\x1B[2K${line}` : `${line}\x1B[K`).join(`
1362
+ `);
1363
+ }
1364
+ function rowsTaken(lines, columns) {
1365
+ return lines.reduce((rows, line) => rows + Math.max(1, Math.ceil(textWidth(line) / columns)), 0);
1366
+ }
1367
+ var SYNC_START = "\x1B[?2026h", SYNC_END = "\x1B[?2026l";
1368
+ var init_redraw = __esm(() => {
1369
+ init_format();
1370
+ });
1371
+
1372
+ // ../kit/src/prompt.ts
1373
+ import process15 from "process";
1374
+ function readKeys(input, paste = { active: false }) {
1375
+ return parseKeys(input, paste).filter((key) => typeof key === "object" ? "text" in key : PROMPT_KEYS.has(key) || isEditKey(key));
1376
+ }
1377
+ function roomAfter(question, columns) {
1378
+ return Math.max(columns - textWidth(`? ${question} `) % columns - 1, 1);
1379
+ }
1380
+ function withCaret(colors, line, room, dim = false) {
1381
+ const { before, at, after } = visible(line, room);
1382
+ const tone = dim ? colors.dim : (text) => text;
1383
+ return `${tone(before)}${at === undefined ? colors.dim("\u2588") : colors.inverse(at)}${tone(after)}`;
1384
+ }
1385
+ function sharedStart(texts) {
1386
+ const [first = [], ...rest] = texts.map((text) => [...text]);
1387
+ let length = first.length;
1388
+ for (const chars of rest) {
1389
+ const differs = chars.findIndex((char, index) => char !== first[index]);
1390
+ length = Math.min(length, differs === -1 ? chars.length : differs);
1391
+ }
1392
+ return first.slice(0, length).join("");
1393
+ }
1394
+ function listed2(colors, found, columns) {
1395
+ const shared = sharedStart(found);
1396
+ const cut = Math.max(shared.lastIndexOf("/"), shared.lastIndexOf(" ")) + 1;
1397
+ const names = found.slice(0, MAX_LISTED).map((each) => each.slice(cut));
1398
+ const more = found.length > MAX_LISTED ? ` \u2026 ${found.length - MAX_LISTED} more` : "";
1399
+ return ` ${colors.dim(truncate(names.join(" ") + more, Math.max(columns - 3, 1)))}`;
1400
+ }
1401
+ async function input2(question, { default: fallback, mask = false, validate, history, complete, ...settings } = {}) {
1402
+ let line = { text: "", caret: 0 };
1403
+ let invalid;
1404
+ let completions = [];
1405
+ const remembered = history === undefined || mask ? undefined : history;
1406
+ const earlier = remembered === undefined ? [] : earlierAnswers(remembered);
1407
+ let recalled = -1;
1408
+ let draft = line;
1409
+ const taken = () => line.text === "" ? fallback ?? "" : line.text;
1410
+ const shown = () => mask ? "*".repeat([...taken()].length) : taken();
1411
+ const accepted = await ask(question, settings, (colors, state, { columns }) => {
1412
+ if (state !== "asking")
1413
+ return [answer(colors, question, state, shown())];
1414
+ const typed = line.text === "" ? { text: shown(), caret: [...shown()].length } : { text: shown(), caret: line.caret };
1415
+ return [`${colors.cyan("?")} ${question} ${withCaret(colors, typed, roomAfter(question, columns), line.text === "")}`, ...invalid === undefined ? [] : [` ${colors.red(invalid)}`], ...completions.length > 1 ? [listed2(colors, completions, columns)] : []];
1416
+ }, (key) => {
1417
+ if (key === "cancel")
1418
+ return "cancel";
1419
+ invalid = undefined;
1420
+ completions = [];
1421
+ if (line.chained === true && endsKills(key))
1422
+ line = { ...line, chained: false };
1423
+ if (key === "tab") {
1424
+ const chars = [...line.text];
1425
+ const before = chars.slice(0, line.caret).join("");
1426
+ const found = complete?.(before) ?? [];
1427
+ const filled = sharedStart(found);
1428
+ if ([...filled].length > [...before].length)
1429
+ line = { ...line, text: filled + chars.slice(line.caret).join(""), caret: [...filled].length };
1430
+ else
1431
+ completions = found;
1432
+ return;
1433
+ }
1434
+ if (key === "enter") {
1435
+ invalid = validate?.(taken());
1436
+ return invalid === undefined ? "enter" : undefined;
1437
+ }
1438
+ if (key === "up" || key === "down") {
1439
+ const to = Math.min(Math.max(recalled + (key === "up" ? 1 : -1), -1), earlier.length - 1);
1440
+ if (recalled === -1)
1441
+ draft = line;
1442
+ recalled = to;
1443
+ const shown = to === -1 ? draft : { text: earlier[to], caret: [...earlier[to]].length };
1444
+ line = { ...shown, killed: line.killed ?? "" };
1445
+ return;
1446
+ }
1447
+ const edit = { home: "linestart", end: "lineend" }[key] ?? key;
1448
+ if (typeof edit === "object" || isEditKey(edit))
1449
+ line = editLine(line, edit);
1450
+ return;
1451
+ });
1452
+ if (!accepted)
1453
+ return;
1454
+ if (remembered !== undefined && taken() !== "")
1455
+ rememberAnswer(remembered, taken());
1456
+ return taken();
1457
+ }
1458
+ function answer(colors, question, state, picked) {
1459
+ return state === "enter" ? `${colors.green("\u2713")} ${question} ${colors.cyan(picked)}` : `${colors.red("\u2717")} ${question} ${colors.dim("cancelled")}`;
1460
+ }
1461
+ async function ask(question, { hint, terminal = process15 }, render, press) {
1462
+ const { stdin, stderr } = terminal;
1463
+ if (!isInteractive(terminal))
1464
+ fail(`cannot ask "${question}" off a terminal`, 2, hint);
1465
+ const colors = paint(stderr);
1466
+ let current = "asking";
1467
+ let outcome;
1468
+ const columns = () => stderr.columns || 80;
1469
+ const draw = (state, last = false) => {
1470
+ const frame = render(colors, state, { columns: columns(), rows: stderr.rows || 24 });
1471
+ const rows = rowsTaken(frame, columns());
1472
+ stderr.write(`${SYNC_START}\r${overwrite(frame, columns())}\x1B[0J${last || rows < 2 ? "" : `\x1B[${rows - 1}A`}${last ? "" : "\r"}${SYNC_END}`);
1473
+ current = state;
1474
+ };
1475
+ const redraw = () => draw(current);
1476
+ const paste = { active: false };
1477
+ const stop = terminal.stop ?? (terminal === process15 ? stopJob : undefined);
1478
+ const suspend = () => {
1479
+ if (stop === undefined)
1480
+ return;
1481
+ stderr.write("\x1B[0J\x1B[?25h\x1B[?2004l");
1482
+ stdin.setRawMode(false);
1483
+ stop();
1484
+ stdin.setRawMode(true);
1485
+ stderr.write("\x1B[?25l\x1B[?2004h");
1486
+ };
1487
+ try {
1488
+ stderr.on?.("resize", redraw);
1489
+ stdin.setRawMode(true);
1490
+ stdin.resume();
1491
+ stderr.write("\x1B[?25l\x1B[?2004h");
1492
+ draw("asking");
1493
+ return await new Promise((resolve) => {
1494
+ function onData(data) {
1495
+ for (const key of readKeys(data.toString(), paste)) {
1496
+ if (key === "suspend") {
1497
+ suspend();
1498
+ continue;
1499
+ }
1500
+ const pressed = press(key);
1501
+ if (pressed !== undefined) {
1502
+ settle(pressed);
1503
+ return;
1504
+ }
1505
+ }
1506
+ draw("asking");
1507
+ }
1508
+ function onEnd() {
1509
+ settle("cancel");
1510
+ }
1511
+ function settle(settled) {
1512
+ outcome = settled;
1513
+ stdin.off("data", onData);
1514
+ stdin.off("end", onEnd);
1515
+ resolve(settled === "enter");
1516
+ }
1517
+ stdin.on("data", onData);
1518
+ stdin.on("end", onEnd);
1519
+ });
1520
+ } finally {
1521
+ stderr.off?.("resize", redraw);
1522
+ draw(outcome ?? "cancel", true);
1523
+ stderr.write(`
1524
+ \x1B[?25h\x1B[?2004l`);
1525
+ stdin.setRawMode(false);
1526
+ stdin.pause();
1527
+ }
1528
+ }
1529
+ var PROMPT_KEYS, MAX_LISTED = 12;
1530
+ var init_prompt = __esm(() => {
1531
+ init_answers();
1532
+ init_args();
1533
+ init_format();
1534
+ init_job();
1535
+ init_mode();
1536
+ init_line();
1537
+ init_state();
1538
+ init_redraw();
1539
+ init_style();
1540
+ PROMPT_KEYS = new Set(["up", "down", "pageup", "pagedown", "home", "end", "enter", "cancel", "suspend", "tab"]);
1541
+ });
1542
+
1543
+ // src/gc.ts
1544
+ import { copyFileSync, existsSync as existsSync4, realpathSync as realpathSync3, renameSync, rmSync as rmSync2 } from "fs";
1545
+ import { basename, dirname as dirname6, isAbsolute as isAbsolute2, join as join10, relative } from "path";
1546
+ import process23 from "process";
1547
+
1548
+ // ../kit/src/index.ts
1549
+ init_args();
1550
+
817
1551
  // ../kit/src/argv.ts
818
1552
  import { readFileSync as readFileSync3, realpathSync } from "fs";
819
1553
  import { resolve as resolve3 } from "path";
@@ -838,14 +1572,26 @@ function scriptArgs(argv = process10.argv.slice(2), cmdline = commandLine(), scr
838
1572
  const after = at === -1 ? [] : cmdline.slice(at + 1);
839
1573
  return after[0] === "--" && after.length === argv.length + 1 && argv.every((word, index) => word === after[index + 1]) ? after : argv;
840
1574
  }
1575
+ // ../kit/src/chart.ts
1576
+ init_format();
1577
+ init_mode();
1578
+ init_style();
1579
+ init_theme();
1580
+ // ../kit/src/ci.ts
1581
+ init_args();
1582
+ init_format();
1583
+
841
1584
  // ../kit/src/progress.ts
1585
+ init_format();
842
1586
  import process12 from "process";
843
1587
 
844
1588
  // ../kit/src/process.ts
1589
+ import { readFileSync as readFileSync4 } from "fs";
845
1590
  import { constants } from "os";
846
1591
  import process11 from "process";
847
1592
  var KILL_GRACE_MS = 2000;
848
1593
  var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
1594
+ var GROUP_SIGNALS = new Set(["SIGINT", "SIGHUP"]);
849
1595
  function exitCodeOf(code, signal) {
850
1596
  if (code !== null)
851
1597
  return code;
@@ -853,6 +1599,21 @@ function exitCodeOf(code, signal) {
853
1599
  return 128 + signal;
854
1600
  return signal === null ? 129 : 128 + constants.signals[signal];
855
1601
  }
1602
+ function groupsOf(pid) {
1603
+ try {
1604
+ const stat = readFileSync4(`/proc/${pid}/stat`, "utf8");
1605
+ const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
1606
+ return { group: Number(fields[2]), foreground: Number(fields[5]) };
1607
+ } catch {
1608
+ return;
1609
+ }
1610
+ }
1611
+ function heardTheTerminal(child) {
1612
+ if (child.pid === undefined)
1613
+ return false;
1614
+ const own = groupsOf("self");
1615
+ return own !== undefined && own.group === own.foreground && groupsOf(child.pid)?.group === own.group;
1616
+ }
856
1617
  function holdSignals(cleanup) {
857
1618
  let received;
858
1619
  let child;
@@ -871,7 +1632,8 @@ function holdSignals(cleanup) {
871
1632
  function onSignal(signal) {
872
1633
  received = signal;
873
1634
  if (child !== undefined) {
874
- child.kill(signal);
1635
+ if (!GROUP_SIGNALS.has(signal) || !heardTheTerminal(child))
1636
+ child.kill(signal);
875
1637
  return;
876
1638
  }
877
1639
  if (cleanup === undefined)
@@ -884,10 +1646,10 @@ function holdSignals(cleanup) {
884
1646
  process11.on(signal, onSignal);
885
1647
  return held;
886
1648
  }
887
- async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
1649
+ async function runCommand(argv, { cwd, env, stdin = "ignore", input, timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
888
1650
  const chunks = [];
889
1651
  const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
890
- const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
1652
+ const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin: input === undefined ? stdin : new TextEncoder().encode(input), stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
891
1653
  const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
892
1654
  const timers = [];
893
1655
  const killGroup = (killing) => {
@@ -927,12 +1689,19 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
927
1689
  stop();
928
1690
  continue;
929
1691
  }
1692
+ if (state.truncated)
1693
+ continue;
1694
+ let kept = data;
930
1695
  if (state.kept + data.length > maxBytes) {
1696
+ let cut = maxBytes - state.kept;
1697
+ while (cut > 0 && ((data[cut] ?? 0) & 192) === 128)
1698
+ cut--;
1699
+ kept = data.subarray(0, cut);
931
1700
  state.truncated = true;
932
- continue;
933
1701
  }
934
- state.kept += data.length;
935
- chunks.push({ stream: name, data });
1702
+ state.kept += kept.length;
1703
+ if (kept.length > 0)
1704
+ chunks.push({ stream: name, data: kept });
936
1705
  }
937
1706
  };
938
1707
  try {
@@ -949,6 +1718,7 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
949
1718
  const joined = () => Buffer.concat(chunks.map(({ data }) => data));
950
1719
  let output;
951
1720
  let text;
1721
+ let stdout;
952
1722
  return {
953
1723
  code: exitCodeOf(proc.exitCode, proc.signalCode),
954
1724
  chunks,
@@ -959,11 +1729,16 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
959
1729
  },
960
1730
  get text() {
961
1731
  return text ??= (output ??= joined()).toString();
1732
+ },
1733
+ get stdout() {
1734
+ return stdout ??= Buffer.concat(chunks.filter((chunk) => chunk.stream === "stdout").map((chunk) => chunk.data)).toString();
962
1735
  }
963
1736
  };
964
1737
  }
965
1738
 
966
1739
  // ../kit/src/progress.ts
1740
+ init_style();
1741
+ init_theme();
967
1742
  var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
968
1743
  var FRAME_MS = 200;
969
1744
  var BAR_WIDTH = 20;
@@ -981,10 +1756,14 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
981
1756
  }, print: (text) => void stream.write(`${text}
982
1757
  `), stop: () => {
983
1758
  return;
1759
+ }, pause: () => () => {
1760
+ return;
984
1761
  } };
985
1762
  const write = stream.write.bind(stream);
986
1763
  let frame = 0;
987
1764
  let drawn = false;
1765
+ let paused = false;
1766
+ let stopped = false;
988
1767
  const columns = () => {
989
1768
  const now = stream.getWindowSize?.()[0] ?? stream.columns;
990
1769
  return now === undefined || now === 0 ? 80 : now;
@@ -995,6 +1774,8 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
995
1774
  drawn = false;
996
1775
  };
997
1776
  const draw = () => {
1777
+ if (paused)
1778
+ return;
998
1779
  const width = columns() - 1;
999
1780
  const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
1000
1781
  const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
@@ -1006,16 +1787,17 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
1006
1787
  `)}${lines.length > 1 ? `\x1B[${lines.length - 1}A` : ""}\r`);
1007
1788
  drawn = true;
1008
1789
  };
1009
- const timer = setInterval(draw, FRAME_MS);
1790
+ let timer = setInterval(draw, FRAME_MS);
1010
1791
  stream.on?.("resize", draw);
1011
- const restore = interceptOutput(clear);
1012
- const release = swallowInput();
1792
+ let restore = interceptOutput(clear);
1793
+ let release = swallowInput();
1013
1794
  const onExit = () => {
1014
1795
  clear();
1015
1796
  release();
1016
1797
  };
1017
1798
  const signals = holdSignals(stop);
1018
1799
  function stop() {
1800
+ stopped = true;
1019
1801
  clearInterval(timer);
1020
1802
  stream.off?.("resize", draw);
1021
1803
  clear();
@@ -1024,6 +1806,29 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
1024
1806
  process12.off("exit", onExit);
1025
1807
  signals.release();
1026
1808
  }
1809
+ function pause() {
1810
+ if (paused || stopped)
1811
+ return () => {
1812
+ return;
1813
+ };
1814
+ paused = true;
1815
+ clearInterval(timer);
1816
+ stream.off?.("resize", draw);
1817
+ clear();
1818
+ restore();
1819
+ release();
1820
+ return () => {
1821
+ if (!paused || stopped)
1822
+ return;
1823
+ paused = false;
1824
+ timer = setInterval(draw, FRAME_MS);
1825
+ timer.unref();
1826
+ stream.on?.("resize", draw);
1827
+ restore = interceptOutput(clear);
1828
+ release = swallowInput();
1829
+ draw();
1830
+ };
1831
+ }
1027
1832
  timer.unref();
1028
1833
  process12.on("exit", onExit);
1029
1834
  return {
@@ -1034,7 +1839,8 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
1034
1839
  `);
1035
1840
  draw();
1036
1841
  },
1037
- stop
1842
+ stop,
1843
+ pause
1038
1844
  };
1039
1845
  }
1040
1846
  function progressLine(stream = process12.stderr, env = process12.env) {
@@ -1059,6 +1865,7 @@ function progressLine(stream = process12.stderr, env = process12.env) {
1059
1865
  }
1060
1866
  },
1061
1867
  stop: region.stop,
1868
+ pause: region.pause,
1062
1869
  done: (text) => end(marked("ok", text, stream, formatDuration(performance.now() - begun), env)),
1063
1870
  failed: (text) => end(marked("problem", text, stream, undefined, env))
1064
1871
  };
@@ -1147,40 +1954,225 @@ function interceptOutput(clear) {
1147
1954
  }
1148
1955
  };
1149
1956
  }
1957
+
1958
+ // ../kit/src/ci.ts
1959
+ init_style();
1960
+
1961
+ // ../kit/src/tool.ts
1962
+ init_format();
1150
1963
  // ../kit/src/cli.ts
1151
- import { readFileSync as readFileSync4, realpathSync as realpathSync2 } from "fs";
1152
- import { dirname as dirname3, join as join5 } from "path";
1153
- import process15 from "process";
1964
+ init_args();
1965
+ import { readFileSync as readFileSync6, realpathSync as realpathSync2 } from "fs";
1966
+ import { dirname as dirname4, join as join8 } from "path";
1967
+ import process19 from "process";
1968
+
1969
+ // ../kit/src/askpass.ts
1970
+ import { chmodSync, mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
1971
+ import { tmpdir } from "os";
1972
+ import { join as join6 } from "path";
1973
+ import process16 from "process";
1974
+ var SOCKET_VARIABLE = "KAYNOOO_ASKPASS_SOCKET";
1975
+ var ECHOED = /username|yes\/no/i;
1976
+ var quoted = (text) => `'${text.replaceAll("'", `'\\''`)}'`;
1977
+ function askpass(pause = () => () => {
1978
+ return;
1979
+ }) {
1980
+ if (process16.stdin.isTTY !== true || process16.stderr.isTTY !== true || process16.argv[1] === undefined)
1981
+ return;
1982
+ const dir = mkdtempSync(join6(tmpdir(), "kaynooo-askpass-"));
1983
+ const socketPath = join6(dir, "socket");
1984
+ const script = join6(dir, "askpass");
1985
+ let turn = Promise.resolve();
1986
+ const answer = async ({ prompt, notice }) => {
1987
+ const resume = pause();
1988
+ try {
1989
+ if (notice === true) {
1990
+ process16.stderr.write(`${prompt.trim()}
1991
+ `);
1992
+ return {};
1993
+ }
1994
+ await Promise.resolve().then(() => init_prompt());
1995
+ return { answer: await input2(prompt.trim(), { mask: !ECHOED.test(prompt) }) };
1996
+ } finally {
1997
+ resume();
1998
+ }
1999
+ };
2000
+ const respond = async (socket, request) => {
2001
+ const { promise, resolve } = Promise.withResolvers();
2002
+ const previous = turn;
2003
+ let reply = {};
2004
+ turn = promise;
2005
+ await previous;
2006
+ try {
2007
+ reply = await answer(request);
2008
+ } catch {} finally {
2009
+ socket.end(`${JSON.stringify(reply)}
2010
+ `);
2011
+ resolve();
2012
+ }
2013
+ };
2014
+ const server = Bun.listen({
2015
+ unix: socketPath,
2016
+ socket: {
2017
+ open: (socket) => {
2018
+ socket.data = { buffered: "" };
2019
+ },
2020
+ data: (socket, chunk) => {
2021
+ const before = socket.data.buffered;
2022
+ socket.data.buffered += chunk.toString();
2023
+ if (before.includes(`
2024
+ `) || !socket.data.buffered.includes(`
2025
+ `))
2026
+ return;
2027
+ respond(socket, JSON.parse(socket.data.buffered));
2028
+ }
2029
+ }
2030
+ });
2031
+ writeFileSync2(script, `#!/bin/sh
2032
+ ${SOCKET_VARIABLE}=${quoted(socketPath)} exec ${quoted(process16.execPath)} --no-env-file --config=/dev/null ${quoted(process16.argv[1])} "$@"
2033
+ `);
2034
+ chmodSync(script, 448);
2035
+ return {
2036
+ env: { GIT_ASKPASS: script, SSH_ASKPASS: script, SSH_ASKPASS_REQUIRE: "force" },
2037
+ close: () => {
2038
+ server.stop(true);
2039
+ rmSync(dir, { recursive: true, force: true });
2040
+ }
2041
+ };
2042
+ }
2043
+ async function askpassClient(argv) {
2044
+ const socketPath = process16.env[SOCKET_VARIABLE];
2045
+ if (socketPath === undefined)
2046
+ return;
2047
+ const request = { prompt: argv[0] ?? "", ...process16.env.SSH_ASKPASS_PROMPT === "none" ? { notice: true } : {} };
2048
+ const { promise, resolve } = Promise.withResolvers();
2049
+ let received = "";
2050
+ try {
2051
+ await Bun.connect({
2052
+ unix: socketPath,
2053
+ socket: {
2054
+ open: (socket) => void socket.write(`${JSON.stringify(request)}
2055
+ `),
2056
+ data: (_, chunk) => {
2057
+ received += chunk.toString();
2058
+ },
2059
+ close: () => resolve(received),
2060
+ error: () => resolve("")
2061
+ }
2062
+ });
2063
+ } catch {
2064
+ return 1;
2065
+ }
2066
+ const reply = await promise;
2067
+ if (reply === "")
2068
+ return 1;
2069
+ const { answer } = JSON.parse(reply);
2070
+ if (request.notice === true)
2071
+ return 0;
2072
+ if (answer === undefined)
2073
+ return 1;
2074
+ process16.stdout.write(`${answer}
2075
+ `);
2076
+ return 0;
2077
+ }
2078
+
2079
+ // ../kit/src/completions.ts
2080
+ var COMPLETION_SHELLS = ["fish", "bash", "zsh"];
2081
+ var FISH_FUNCTION = `functions -q __kaynooo_cli_complete; or function __kaynooo_cli_complete --argument-names bin --description 'what a @kaynooo/cli-kit bin offers for the word being typed'
2082
+ set -l tokens (commandline -xpc 2>/dev/null; or commandline -opc)
2083
+ set -l current (commandline -ct)
2084
+ for line in ($bin __complete $tokens[2..-1] $current 2>/dev/null)
2085
+ if test "$line" = __files__
2086
+ __fish_complete_path $current
2087
+ else
2088
+ echo $line
2089
+ end
2090
+ end
2091
+ end`;
2092
+ var BASH_FUNCTION = `__kaynooo_cli_complete() {
2093
+ local IFS=$'\\n' cur=\${COMP_WORDS[COMP_CWORD]} line words=
2094
+ local -a lines
2095
+ COMPREPLY=()
2096
+ lines=($("\${COMP_WORDS[0]}" __complete "\${COMP_WORDS[@]:1:COMP_CWORD}" 2>/dev/null))
2097
+ for line in "\${lines[@]}"; do
2098
+ if [[ $line == __files__ ]]; then
2099
+ COMPREPLY+=($(compgen -f -- "$cur"))
2100
+ else
2101
+ words+="\${line%%$'\\t'*}"$'\\n'
2102
+ fi
2103
+ done
2104
+ COMPREPLY+=($(compgen -W "$words" -- "$cur"))
2105
+ }`;
2106
+ var ZSH_FUNCTION = `__kaynooo_cli_complete() {
2107
+ local line
2108
+ local -a described plain
2109
+ for line in \${(f)"$("\${words[1]}" __complete "\${(@)words[2,CURRENT]}" 2>/dev/null)"}; do
2110
+ if [[ $line == __files__ ]]; then
2111
+ _files
2112
+ elif [[ $line == *$'\\t'* ]]; then
2113
+ described+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}")
2114
+ else
2115
+ plain+=("$line")
2116
+ fi
2117
+ done
2118
+ (( \${#described} )) && _describe -V value described
2119
+ (( \${#plain} )) && compadd -- "\${plain[@]}"
2120
+ return 0
2121
+ }`;
2122
+ function completionScript(shell, bins, header = `# Generated by \`${bins[0]} --completions ${shell}\``) {
2123
+ if (shell === "fish")
2124
+ return `${header}
2125
+ ${FISH_FUNCTION}
2126
+ ${bins.map((bin) => `complete -c ${bin} -f -a '(__kaynooo_cli_complete ${bin})'
2127
+ `).join("")}`;
2128
+ if (shell === "bash")
2129
+ return `${header}
2130
+ ${BASH_FUNCTION}
2131
+ complete -F __kaynooo_cli_complete ${bins.join(" ")}
2132
+ `;
2133
+ return `${header}
2134
+ ${ZSH_FUNCTION}
2135
+ compdef __kaynooo_cli_complete ${bins.join(" ")}
2136
+ `;
2137
+ }
1154
2138
 
1155
2139
  // ../kit/src/notify.ts
1156
- import process13 from "process";
2140
+ init_format();
2141
+ init_mode();
2142
+ import process17 from "process";
1157
2143
  var NOTIFY_AFTER_MS = 1e4;
1158
2144
  var CANCELLED = 130;
1159
2145
  function base64(text) {
1160
2146
  return Buffer.from(text).toString("base64");
1161
2147
  }
1162
- function notification(title, body, env = process13.env) {
1163
- const id = `kit${process13.pid}`;
2148
+ function notification(title, body, env = process17.env) {
2149
+ const id = `kit${process17.pid}`;
1164
2150
  const codes = [`\x1B]99;i=${id}:d=0:o=unfocused:e=1;${base64(title)}\x1B\\`, `\x1B]99;i=${id}:p=body:e=1;${base64(body)}\x1B\\`];
1165
2151
  return codes.map((code) => env.TMUX === undefined || env.TMUX === "" ? code : `\x1BPtmux;${code.replaceAll("\x1B", "\x1B\x1B")}\x1B\\`).join("");
1166
2152
  }
1167
- function notifyEnd(command, code, ms, { stream = process13.stderr, env = process13.env } = {}) {
2153
+ function notifyEnd(command, code, ms, { stream = process17.stderr, env = process17.env } = {}) {
1168
2154
  if (ms < NOTIFY_AFTER_MS || code === CANCELLED || outputMode(stream, env) !== "terminal")
1169
2155
  return;
1170
2156
  stream.write(notification(command, code === 0 ? `done in ${formatDuration(ms)}` : `failed with exit ${code} after ${formatDuration(ms)}`, env));
1171
2157
  }
1172
2158
 
2159
+ // ../kit/src/cli.ts
2160
+ init_style();
2161
+ init_text2();
2162
+
1173
2163
  // ../kit/src/usage.ts
1174
- import { appendFileSync, mkdirSync } from "fs";
1175
- import { homedir as homedir3 } from "os";
1176
- import { dirname as dirname2, isAbsolute, join as join4 } from "path";
1177
- import process14 from "process";
2164
+ import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
2165
+ import { homedir as homedir4 } from "os";
2166
+ import { dirname as dirname3, join as join7 } from "path";
2167
+ import process18 from "process";
1178
2168
 
1179
2169
  // ../kit/src/logs.ts
2170
+ init_user_config();
1180
2171
  var DAY_MS = 24 * 60 * 60 * 1000;
1181
2172
  var CLI_FOLDER = "kaynooo-cli";
1182
2173
 
1183
2174
  // ../kit/src/usage.ts
2175
+ init_user_config();
1184
2176
  var UNKNOWN_OPTION2 = /unknown option '(--[a-z][a-z0-9-]*)[=']/;
1185
2177
  var FLAG_NAME = /^(?:--[a-z][a-z0-9-]*|-[a-zA-Z])$/;
1186
2178
  var LONGEST_NAME = 40;
@@ -1188,14 +2180,13 @@ var usageError;
1188
2180
  function noteUsageError(message) {
1189
2181
  usageError = message;
1190
2182
  }
1191
- function stateHome(env = process14.env) {
1192
- const dir = env.XDG_STATE_HOME;
1193
- return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
2183
+ function stateHome(env = process18.env) {
2184
+ return xdgFolder(env.XDG_STATE_HOME, join7(homedir4(), ".local", "state"));
1194
2185
  }
1195
- function usagePath(env = process14.env) {
1196
- return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
2186
+ function usagePath(env = process18.env) {
2187
+ return join7(stateHome(env), CLI_FOLDER, "usage.jsonl");
1197
2188
  }
1198
- function usageRecorded(env = process14.env) {
2189
+ function usageRecorded(env = process18.env) {
1199
2190
  const off = env.KAYNOOO_CLI_NO_USAGE;
1200
2191
  return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
1201
2192
  }
@@ -1204,17 +2195,17 @@ function flagNames(argv) {
1204
2195
  const names = (end === -1 ? argv : argv.slice(0, end)).filter((word) => word.startsWith("-") && word !== "-").map((word) => word.includes("=") ? word.slice(0, word.indexOf("=")) : word);
1205
2196
  return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
1206
2197
  }
1207
- function usageEntry(bin, command, argv, code, now = new Date) {
2198
+ function usageEntry(bin, command, argv, code, { ms, now = new Date } = {}) {
1208
2199
  const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
1209
2200
  usageError = undefined;
1210
- return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
2201
+ return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown }, ...ms === undefined ? {} : { ms: Math.round(ms) } };
1211
2202
  }
1212
- function recordUsage(entry, env = process14.env) {
2203
+ function recordUsage(entry, env = process18.env) {
1213
2204
  if (!usageRecorded(env))
1214
2205
  return;
1215
2206
  try {
1216
2207
  const path = usagePath(env);
1217
- mkdirSync(dirname2(path), { recursive: true, mode: 448 });
2208
+ mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
1218
2209
  appendFileSync(path, `${JSON.stringify(entry)}
1219
2210
  `, { mode: 384 });
1220
2211
  } catch {}
@@ -1225,10 +2216,14 @@ var LEVEL_OPTIONS = {
1225
2216
  ...OUTPUT_OPTIONS,
1226
2217
  help: { type: "boolean", short: "h", description: "show this help" }
1227
2218
  };
1228
- var TOP_OPTIONS = { ...LEVEL_OPTIONS, version: { type: "boolean", short: "v", description: "print the version" } };
2219
+ var TOP_OPTIONS = {
2220
+ ...LEVEL_OPTIONS,
2221
+ version: { type: "boolean", short: "v", description: "print the version" },
2222
+ completions: { type: "string", choices: COMPLETION_SHELLS, description: "print the shell completion script" }
2223
+ };
1229
2224
  function printError(prefix, message, hint, cause) {
1230
- const colors = paint(process15.stderr);
1231
- const styled = takesControlCodes(process15.stderr);
2225
+ const colors = paint(process19.stderr);
2226
+ const styled = takesControlCodes(process19.stderr);
1232
2227
  const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
1233
2228
  const under = (label, text, tint) => text === undefined ? "" : `
1234
2229
  ${styled ? tint(label) : `${label}:`} ${text}`;
@@ -1308,6 +2303,19 @@ async function leafCandidates(run, words) {
1308
2303
  const values = name === undefined ? undefined : await completing.candidates[name]?.(typed);
1309
2304
  return values === undefined ? [FILES] : values.map(candidateLine);
1310
2305
  }
2306
+ var COMPLETIONS = "--completions";
2307
+ function flagValue([flag = "", ...rest]) {
2308
+ return flag.includes("=") ? [flag.slice(flag.indexOf("=") + 1), ...rest] : rest;
2309
+ }
2310
+ function printCompletionScript(name, args) {
2311
+ const shell = COMPLETION_SHELLS.find((each) => each === args[0]);
2312
+ if (shell === undefined || args.length !== 1) {
2313
+ printError(name, `${COMPLETIONS} takes one of ${COMPLETION_SHELLS.join(", ")}`, `${name} ${COMPLETIONS} fish`);
2314
+ return 2;
2315
+ }
2316
+ console.log(completionScript(shell, [name]).trimEnd());
2317
+ return 0;
2318
+ }
1311
2319
  async function printCandidates(found) {
1312
2320
  for (const line of await found)
1313
2321
  console.log(line);
@@ -1318,19 +2326,24 @@ function packageVersion(entry = Bun.main) {
1318
2326
  try {
1319
2327
  resolved = realpathSync2(entry);
1320
2328
  } catch {}
1321
- for (let dir = dirname3(resolved);; dir = dirname3(dir)) {
2329
+ for (let dir = dirname4(resolved);; dir = dirname4(dir)) {
1322
2330
  try {
1323
- const { version } = JSON.parse(readFileSync4(join5(dir, "package.json"), "utf8"));
2331
+ const { version } = JSON.parse(readFileSync6(join8(dir, "package.json"), "utf8"));
1324
2332
  if (typeof version === "string")
1325
2333
  return version;
1326
2334
  } catch {}
1327
- if (dirname3(dir) === dir)
2335
+ if (dirname4(dir) === dir)
1328
2336
  return "0.0.0";
1329
2337
  }
1330
2338
  }
1331
2339
  async function runMain({ name, version, run, redact, usage }, argv = scriptArgs()) {
2340
+ const answered = await askpassClient(argv);
2341
+ if (answered !== undefined)
2342
+ return answered;
1332
2343
  if (argv[0] === COMPLETE)
1333
2344
  return printCandidates(leafCandidates(run, argv.slice(1)));
2345
+ if (argv[0] === COMPLETIONS || argv[0]?.startsWith(`${COMPLETIONS}=`) === true)
2346
+ return printCompletionScript(name, flagValue(argv));
1334
2347
  if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
1335
2348
  console.log(version ?? packageVersion());
1336
2349
  return 0;
@@ -1345,21 +2358,52 @@ async function runMain({ name, version, run, redact, usage }, argv = scriptArgs(
1345
2358
  notifyEnd(name, code, performance.now() - started);
1346
2359
  if (usage !== false) {
1347
2360
  try {
1348
- recordUsage(usageEntry(name, undefined, argv, code));
2361
+ recordUsage(usageEntry(name, undefined, argv, code, { ms: performance.now() - started }));
1349
2362
  } catch {}
1350
2363
  }
1351
2364
  return code;
1352
2365
  }
1353
- // ../kit/src/folders.ts
1354
- var SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
2366
+
2367
+ // ../kit/src/index.ts
2368
+ init_config();
2369
+
2370
+ // ../kit/src/excerpt.ts
2371
+ init_text2();
2372
+
2373
+ // ../kit/src/index.ts
2374
+ init_folders();
2375
+ init_format();
2376
+
2377
+ // ../kit/src/git.ts
2378
+ init_args();
2379
+ // ../kit/src/limit.ts
2380
+ init_args();
2381
+
2382
+ // ../kit/src/index.ts
2383
+ init_mode();
2384
+
2385
+ // ../kit/src/report.ts
2386
+ init_style();
2387
+ init_text2();
1355
2388
  // ../kit/src/secrets.ts
1356
2389
  var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
2390
+ var NOT_PASSWORDS = new Set(["compass", "encompass", "bypass", "overpass", "underpass", "surpass", "trespass"]);
1357
2391
  // ../kit/src/sessions.ts
1358
2392
  var {Glob } = globalThis.Bun;
1359
2393
  var SESSION_FILES = new Glob("*.json");
1360
2394
  var ACCOUNT_DIRS = new Glob("*/sessions");
2395
+
2396
+ // ../kit/src/index.ts
2397
+ init_style();
2398
+ init_text2();
2399
+ init_theme();
2400
+ init_user_config();
2401
+
1361
2402
  // ../kit/src/watch.ts
1362
- import process16 from "process";
2403
+ init_args();
2404
+ init_input();
2405
+ init_style();
2406
+ import process20 from "process";
1363
2407
  import { format } from "util";
1364
2408
  var CLEAR_SCREEN = "\x1B[H\x1B[2J";
1365
2409
  var DEFAULT_SECONDS = 2;
@@ -1381,7 +2425,7 @@ function withoutWatch(args) {
1381
2425
  }
1382
2426
  return rest;
1383
2427
  }
1384
- async function watching(value, step, stream = process16.stdout, sleep = Bun.sleep, rounds = Number.POSITIVE_INFINITY) {
2428
+ async function watching(value, step, stream = process20.stdout, sleep = Bun.sleep, rounds = Number.POSITIVE_INFINITY) {
1385
2429
  const interval = value === "" ? DEFAULT_SECONDS * 1000 : duration(value, "watch", DEFAULT_SECONDS * 1000);
1386
2430
  if (!takesControlCodes(stream))
1387
2431
  badUsage("--watch redraws the screen, so it needs a terminal");
@@ -1389,12 +2433,12 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
1389
2433
  for (let round = 0;round < rounds; round++) {
1390
2434
  const held = [];
1391
2435
  const { log, info } = console;
1392
- const write = process16.stdout.write.bind(process16.stdout);
2436
+ const write = process20.stdout.write.bind(process20.stdout);
1393
2437
  const hold = (...parts) => void held.push(`${format(...parts)}
1394
2438
  `);
1395
2439
  console.log = hold;
1396
2440
  console.info = hold;
1397
- process16.stdout.write = (text) => {
2441
+ process20.stdout.write = (text) => {
1398
2442
  held.push(typeof text === "string" ? text : Buffer.from(text).toString());
1399
2443
  return true;
1400
2444
  };
@@ -1403,7 +2447,7 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
1403
2447
  } finally {
1404
2448
  console.log = log;
1405
2449
  console.info = info;
1406
- process16.stdout.write = write;
2450
+ process20.stdout.write = write;
1407
2451
  }
1408
2452
  stream.write(`${CLEAR_SCREEN}${held.join("")}`);
1409
2453
  await sleep(interval);
@@ -1411,21 +2455,22 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
1411
2455
  return code;
1412
2456
  }
1413
2457
  // ../kit/src/workspace-root.ts
1414
- import { homedir as homedir4 } from "os";
1415
- import { dirname as dirname4, join as join6, resolve as resolve4 } from "path";
1416
- import process17 from "process";
2458
+ init_user_config();
2459
+ import { homedir as homedir5 } from "os";
2460
+ import { dirname as dirname5, join as join9, resolve as resolve4 } from "path";
2461
+ import process21 from "process";
1417
2462
  function expandHome(path, home) {
1418
2463
  if (path === "~")
1419
2464
  return home;
1420
- return path.startsWith("~/") ? join6(home, path.slice(2)) : path;
2465
+ return path.startsWith("~/") ? join9(home, path.slice(2)) : path;
1421
2466
  }
1422
2467
  function configured(env, home) {
1423
2468
  const folder = readUserConfig("config", { home, xdg: env.XDG_CONFIG_HOME }).workspace;
1424
2469
  return typeof folder === "string" && folder !== "" ? folder : undefined;
1425
2470
  }
1426
- function workspaceRoot({ given, env = process17.env, home = homedir4() } = {}) {
2471
+ function workspaceRoot({ given, env = process21.env, home = homedir5() } = {}) {
1427
2472
  const fromEnv = env.KAYNOOO_WORKSPACE === "" ? undefined : env.KAYNOOO_WORKSPACE;
1428
- return resolve4(expandHome(given ?? fromEnv ?? configured(env, home) ?? join6(home, "Workspace"), home));
2473
+ return resolve4(expandHome(given ?? fromEnv ?? configured(env, home) ?? join9(home, "Workspace"), home));
1429
2474
  }
1430
2475
  // src/git.ts
1431
2476
  async function git2(args, env) {
@@ -1488,9 +2533,9 @@ function commitMessageViolation(message) {
1488
2533
  }
1489
2534
 
1490
2535
  // src/gc.ts
1491
- var USAGE = `gc <title> [-m <line>]... [--ticket <line>]... -- <path>...: commits exactly the paths given, its message checked before anything is staged
2536
+ var USAGE = `gc <title> [-m <line>]... [--ticket <line>]... -- <path>...: commits exactly the paths given, its message checked before anything is staged; a merge, cherry-pick or revert in progress is refused, as git commits it only whole
1492
2537
 
1493
- Exits 0 when it committed, 1 when the message is refused or git fails (nothing is committed), 2 on a usage error or outside a git repository, 128 plus the signal when interrupted.`;
2538
+ Exits 0 when it committed, 1 when the message is refused, a merge, cherry-pick or revert is in progress, or git fails (nothing is committed, the index is put back as it was), 2 on a usage error or outside a git repository, 128 plus the signal when interrupted.`;
1494
2539
  var OPTIONS = {
1495
2540
  message: { type: "string", short: "m", multiple: true, description: "a line on what changed, at most two" },
1496
2541
  ticket: { type: "string", multiple: true, description: "a ticket line, `#<n> - <title>` (`owner/repo#<n> - <title>` across repositories) copied verbatim from the ticket" },
@@ -1499,7 +2544,9 @@ var OPTIONS = {
1499
2544
  };
1500
2545
  var RENAME = /^[RC]\d*$/;
1501
2546
  var NOT_A_REPOSITORY = /not a git repository/i;
1502
- var LITERAL = { ...process19.env, GIT_LITERAL_PATHSPECS: "1" };
2547
+ var TRAILING_SLASHES = /\/+$/;
2548
+ var SEQUENCES = [["MERGE_HEAD", "a merge", "gm --continue"], ["CHERRY_PICK_HEAD", "a cherry-pick", "git cherry-pick --continue"], ["REVERT_HEAD", "a revert", "git revert --continue"]];
2549
+ var LITERAL = { ...process23.env, GIT_LITERAL_PATHSPECS: "1" };
1503
2550
  function messageOf(title, lines, tickets) {
1504
2551
  return [title, lines.join(`
1505
2552
  `), tickets.join(`
@@ -1515,27 +2562,49 @@ ${stderr.trim()}`, NOT_A_REPOSITORY.test(stderr) ? 2 : 1);
1515
2562
  return stdout;
1516
2563
  }
1517
2564
  async function stagedElsewhere(paths) {
1518
- const [all, given] = await Promise.all([checked(["diff", "--cached", "--name-only", "-z"]), checked(["diff", "--cached", "--name-only", "-z", "--", ...paths])]);
2565
+ const [all, given] = await Promise.all([checked(["diff", "--cached", "--name-only", "--no-relative", "-z"]), checked(["diff", "--cached", "--name-only", "--no-relative", "-z", "--", ...paths])]);
1519
2566
  const ours = new Set(given.split("\x00"));
1520
2567
  return all.split("\x00").filter((path) => path !== "" && !ours.has(path));
1521
2568
  }
2569
+ function onDisk(path) {
2570
+ try {
2571
+ return join10(realpathSync3(dirname6(path)), basename(path));
2572
+ } catch {
2573
+ return path;
2574
+ }
2575
+ }
1522
2576
  async function renameSources(paths) {
1523
- const fields = (await checked(["diff", "--cached", "-M", "--name-status", "-z"])).split("\x00");
2577
+ const [top = "", prefix = ""] = (await checked(["rev-parse", "--show-toplevel", "--show-prefix"])).split(`
2578
+ `);
2579
+ const specs = paths.map((path) => (isAbsolute2(path) ? relative(top, onDisk(path)) : join10(prefix, path)).replace(TRAILING_SLASHES, "") || ".");
2580
+ const covered = (name) => specs.some((spec) => spec === "." || name === spec || name.startsWith(`${spec}/`));
2581
+ const fields = (await checked(["diff", "--cached", "-M", "--name-status", "--no-relative", "-z"])).split("\x00");
1524
2582
  const sources = [];
1525
2583
  for (let i = 0;i < fields.length; i++) {
1526
2584
  if (!RENAME.test(fields[i] ?? ""))
1527
2585
  continue;
1528
2586
  const from = fields[i + 1] ?? "";
1529
2587
  const to = fields[i + 2] ?? "";
1530
- if (paths.includes(to) && !paths.includes(from))
1531
- sources.push(from);
2588
+ if (covered(to) && !covered(from))
2589
+ sources.push(relative(prefix, from));
1532
2590
  i += 2;
1533
2591
  }
1534
2592
  return sources;
1535
2593
  }
1536
- async function unstage(paths) {
1537
- const hasHead = (await git2(["rev-parse", "--verify", "-q", "HEAD"], LITERAL)).code === 0;
1538
- await git2(hasHead ? ["reset", "-q", "--", ...paths] : ["rm", "-r", "-q", "--cached", "--", ...paths], LITERAL);
2594
+ async function inProgress() {
2595
+ const found = await Promise.all(SEQUENCES.map(async ([ref]) => (await git2(["rev-parse", "-q", "--verify", ref])).code === 0));
2596
+ return SEQUENCES.find((_, i) => found[i]);
2597
+ }
2598
+ async function snapshotIndex() {
2599
+ const index = (await checked(["rev-parse", "--path-format=absolute", "--git-path", "index"])).trim();
2600
+ const copy = `${index}.gc-${process23.pid}`;
2601
+ const existed = existsSync4(index);
2602
+ if (existed)
2603
+ copyFileSync(index, copy);
2604
+ return {
2605
+ restore: () => existed ? renameSync(copy, index) : rmSync2(index, { force: true }),
2606
+ drop: () => rmSync2(copy, { force: true })
2607
+ };
1539
2608
  }
1540
2609
  function fileLine(line) {
1541
2610
  const [letter = "", from = "", to] = line.split("\t");
@@ -1566,6 +2635,9 @@ ${USAGE}`);
1566
2635
  const violation = commitMessageViolation(message);
1567
2636
  if (violation !== null)
1568
2637
  fail(`nothing staged: ${violation}`, 1);
2638
+ const sequence = await inProgress();
2639
+ if (sequence !== undefined)
2640
+ fail(`nothing staged: ${sequence[1]} is in progress, which git commits only whole`, 1, runHint(sequence[2], `finish ${sequence[1]}`));
1569
2641
  const statuses = await Promise.all(given.map(async (path) => checked(["status", "--porcelain", "--untracked-files=all", "--", path])));
1570
2642
  const unchanged = given.filter((_, i) => statuses[i] === "");
1571
2643
  const addable = given.filter((_, i) => !(statuses[i] ?? "").trimEnd().split(`
@@ -1577,18 +2649,19 @@ ${USAGE}`);
1577
2649
  const others = await stagedElsewhere(paths);
1578
2650
  if (others.length > 0)
1579
2651
  fail(`nothing staged: the index already holds ${others.join(", ")}, which this commit would carry along`, 1, runHint(`git restore --staged -- ${others.join(" ")}`, "unstage them, or name them in the paths too"));
2652
+ const index = await snapshotIndex();
1580
2653
  const signals = holdSignals();
1581
2654
  try {
1582
2655
  if (addable.length > 0)
1583
2656
  await checked(["add", "--", ...addable]);
1584
2657
  if (signals.signal !== undefined) {
1585
- await unstage(paths);
2658
+ index.restore();
1586
2659
  return exitCodeOf(null, signals.signal);
1587
2660
  }
1588
2661
  const commit = await git2(["commit", "--only", "--cleanup=whitespace", "-m", message, "--", ...paths.map((path) => `:(literal)${path}`)]);
1589
2662
  if (commit.code !== 0) {
1590
- await unstage(paths);
1591
- const refusal = `git commit failed, the paths were unstaged:
2663
+ index.restore();
2664
+ const refusal = `git commit failed, the index was put back as it was:
1592
2665
  ${(commit.stderr + commit.stdout).trim()}`;
1593
2666
  if (values.json === true)
1594
2667
  fail(refusal, 1);
@@ -1610,7 +2683,8 @@ ${(commit.stderr + commit.stdout).trim()}`;
1610
2683
  }
1611
2684
  return signals.signal === undefined ? 0 : exitCodeOf(null, signals.signal);
1612
2685
  } finally {
2686
+ index.drop();
1613
2687
  signals.release();
1614
2688
  }
1615
2689
  }
1616
- process19.exitCode = await runMain({ name: "gc", run: main });
2690
+ process23.exitCode = await runMain({ name: "gc", run: main });