@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/gu.js CHANGED
@@ -1,22 +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/gu.ts
5
- import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
6
- import { join as join7, resolve as resolve5 } from "path";
7
- import process19 from "process";
8
- // ../kit/src/args.ts
9
- import process9 from "process";
10
- import { parseArgs } from "util";
11
-
12
- // ../kit/src/format.ts
13
- import process7 from "process";
14
-
15
- // ../../node_modules/.bun/@kaynooo+utils@3.0.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-rxztfxgv.js
16
- var N = new Map;
17
- var Nt = /\s+\S*$/;
18
- var Y = /\s/;
19
- 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 = "...") {
20
17
  let { suffix: n = "...", includeSuffix: s = false, wordBoundary: o = false } = typeof r === "string" ? { suffix: r } : r;
21
18
  if (t.length <= e)
22
19
  return t;
@@ -27,13 +24,22 @@ function ko(t, e, r = "...") {
27
24
  c = c.trimEnd();
28
25
  return s ? (c + n).slice(0, l) : c + n;
29
26
  }
30
- 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));
31
- 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
+ });
32
40
 
33
41
  // ../kit/src/mode.ts
34
42
  import process2 from "process";
35
- var MODES = new Set(["terminal", "ci", "agent", "pipe"]);
36
- var AGENT_VARIABLES = ["CLAUDECODE", "AI_AGENT"];
37
43
  function isSet(value) {
38
44
  return value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false";
39
45
  }
@@ -50,12 +56,13 @@ function outputMode(stream = process2.stdout, env = process2.env) {
50
56
  function isInteractive(streams = process2) {
51
57
  return streams.stdin?.isTTY === true && streams.stderr?.isTTY === true;
52
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
+ });
53
64
 
54
- // ../kit/src/style.ts
55
- import process6 from "process";
56
-
57
- // ../../node_modules/.bun/@kaynooo+utils@3.0.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
58
- var G2 = /^[a-f0-9]+$/i;
65
+ // ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
59
66
  function b(r) {
60
67
  let e = r.startsWith("#") ? r.slice(1) : r;
61
68
  if (!G2.test(e))
@@ -66,11 +73,6 @@ function b(r) {
66
73
  throw Error(`Invalid hex color length: ${e.length}`);
67
74
  return [Number.parseInt(e.slice(0, 2), 16), Number.parseInt(e.slice(2, 4), 16), Number.parseInt(e.slice(4, 6), 16)];
68
75
  }
69
- 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") => {
70
- let [l, n, c] = b(r);
71
- return [`${e === "fg" ? 38 : 48};2;${l};${n};${c}`, e === "fg" ? 39 : 49];
72
- }, ansi256: (r, e = "fg") => [`${e === "fg" ? 38 : 48};5;${r}`, e === "fg" ? 39 : 49] };
73
- var h = new Set(["", "1", "2", "3", "true"]);
74
76
  function C(r, e = globalThis.process?.env ?? {}) {
75
77
  if (e.FORCE_COLOR !== undefined)
76
78
  return h.has(e.FORCE_COLOR);
@@ -84,7 +86,7 @@ function f(r, e = []) {
84
86
  l += `\x1B[${e[t][0]}m`, n = `\x1B[${e[t][1]}m${n}`;
85
87
  let c = (t) => C(r.stream ?? globalThis.process?.stdout, r.env) ? l + t + n : t, g = new Map;
86
88
  return new Proxy(c, { get(t, i) {
87
- let a = B2[i];
89
+ let a = B[i];
88
90
  if (Array.isArray(a)) {
89
91
  let s = g.get(i);
90
92
  if (s === undefined)
@@ -107,13 +109,21 @@ function f(r, e = []) {
107
109
  function Fe(r = {}) {
108
110
  return f(r);
109
111
  }
110
- 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
+ });
111
122
 
112
- // ../kit/src/theme.ts
113
- import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
114
- import { homedir as homedir2 } from "os";
115
- import { join as join3, resolve as resolve2 } from "path";
116
- 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
+ });
117
127
 
118
128
  // ../kit/src/config.ts
119
129
  import { existsSync } from "fs";
@@ -129,15 +139,21 @@ function findUp(names, from = process3.cwd(), stop = () => false) {
129
139
  return;
130
140
  }
131
141
  }
142
+ var init_config = __esm(() => {
143
+ init_args();
144
+ });
132
145
 
133
146
  // ../kit/src/user-config.ts
134
147
  import { existsSync as existsSync2, readFileSync } from "fs";
135
148
  import { homedir } from "os";
136
- import { join as join2 } from "path";
149
+ import { isAbsolute, join as join2 } from "path";
137
150
  import process4 from "process";
151
+ function xdgFolder(value, fallback) {
152
+ return value !== undefined && isAbsolute(value) ? value : fallback;
153
+ }
138
154
  function configBase(where = {}) {
139
155
  const xdg = where.xdg ?? (where.home === undefined ? process4.env.XDG_CONFIG_HOME : undefined);
140
- return xdg !== undefined && xdg !== "" ? xdg : join2(where.home ?? homedir(), ".config");
156
+ return xdgFolder(xdg, join2(where.home ?? homedir(), ".config"));
141
157
  }
142
158
  function userConfigPath(bin, where = {}) {
143
159
  return join2(configBase(where), "kaynooo-cli", `${bin}.json`);
@@ -160,13 +176,17 @@ function readUserConfig(bin, where = {}, legacy = []) {
160
176
  return {};
161
177
  }
162
178
  }
179
+ var init_user_config = () => {};
163
180
 
164
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";
165
186
  function toLinear(channel) {
166
187
  const value = channel / 255;
167
188
  return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
168
189
  }
169
- 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)));
170
190
  function toOklab(hex) {
171
191
  const [r, g, b] = [1, 3, 5].map((at) => toLinear(Number.parseInt(hex.slice(at, at + 2), 16)));
172
192
  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
@@ -181,7 +201,6 @@ function fromOklab([lightness, a, b]) {
181
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];
182
202
  return `#${channels.map((channel) => fromLinear(channel).toString(16).padStart(2, "0")).join("")}`;
183
203
  }
184
- var ENDS = new Map;
185
204
  function gradientAt(theme, ratio) {
186
205
  if (theme.gradient === undefined)
187
206
  return;
@@ -195,33 +214,11 @@ function gradientAt(theme, ratio) {
195
214
  const [from, to] = ends;
196
215
  return fromOklab(from.map((start, index) => start + (to[index] - start) * at));
197
216
  }
198
- var DEFAULT = {
199
- 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" },
200
- 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" },
201
- accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
202
- bins: {},
203
- gradient: ["#c084fc", "#67e8f9"]
204
- };
205
- 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" };
206
- 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" };
207
- var ASCII = { ok: "+", warn: "!", problem: "x", note: ">", plan: "?", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#", rule: "-", corner: "+", open: "*", leaf: "-", guide: "|" };
208
- var PRESETS = {
209
- default: {},
210
- "high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"], gradient: ["#d8b4fe", "#a5f3fc"] },
211
- mono: { colors: MONO, accents: ["bold"], gradient: undefined },
212
- ascii: { glyphs: ASCII }
213
- };
214
- 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"]);
215
- var HEX = /^#[0-9a-f]{6}$/i;
216
- var CONTROL = /\p{Cc}/u;
217
- var MAX_FILE_BYTES = 64 * 1024;
218
- var SPACES = /\s+/;
219
217
  function isColorSpec(spec) {
220
218
  if (typeof spec === "number")
221
219
  return Number.isInteger(spec) && spec >= 0 && spec <= 255;
222
220
  return typeof spec === "string" && spec.trim() !== "" && spec.trim().split(SPACES).every((token) => STYLES.has(token) || HEX.test(token));
223
221
  }
224
- var CUBE = [0, 95, 135, 175, 215, 255];
225
222
  function cubeLevel(channel) {
226
223
  return CUBE.reduce((best, value, level) => Math.abs(value - channel) < Math.abs(CUBE[best] - channel) ? level : best, 0);
227
224
  }
@@ -329,7 +326,6 @@ function applyFile(theme, file, where, warn) {
329
326
  function endsWalk(home) {
330
327
  return (dir) => dir === resolve2(home) || existsSync3(join3(dir, ".git"));
331
328
  }
332
- var warned = new Set;
333
329
  function warnOnce(message) {
334
330
  if (warned.has(message))
335
331
  return;
@@ -366,8 +362,6 @@ function loadTheme({ env = process5.env, from = process5.cwd(), home = homedir2(
366
362
  }
367
363
  return { theme, sources, preset };
368
364
  }
369
- var current;
370
- var currentKey = "";
371
365
  function activeTheme() {
372
366
  const key = `${process5.cwd()}\x00${process5.env.KIT_THEME ?? ""}\x00${process5.env.XDG_CONFIG_HOME ?? ""}`;
373
367
  if (current === undefined || key !== currentKey) {
@@ -376,9 +370,38 @@ function activeTheme() {
376
370
  }
377
371
  return current;
378
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
+ });
379
402
 
380
403
  // ../kit/src/style.ts
381
- var MARK_WORDS = { ok: "ok:", warn: "warning:", problem: "error:", note: "note:", plan: "would:" };
404
+ import process6 from "process";
382
405
  function takesControlCodes(stream, env = process6.env) {
383
406
  return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb" && outputMode(stream, env) === "terminal";
384
407
  }
@@ -398,17 +421,24 @@ function role(name, stream, env = process6.env) {
398
421
  const colors = paint(stream, env);
399
422
  return takesControlCodes(stream, env) ? tinted(colors, activeTheme().theme.colors[name], env) : colors;
400
423
  }
401
- var STATUS_WORDS = {
402
- passed: ["passed", "success", "succeeded", "ok"],
403
- failed: ["failed", "failure", "error", "errored"],
404
- running: ["running", "in_progress", "started", "holding"],
405
- queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
406
- skipped: ["skipped", "cancelled", "canceled", "manual"]
407
- };
408
- 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
+ });
409
439
 
410
440
  // ../kit/src/format.ts
411
- var UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
441
+ import process7 from "process";
412
442
  function formatSeconds(total) {
413
443
  let rest = Math.max(0, Math.round(total));
414
444
  const amounts = UNITS.map(([unit, size]) => {
@@ -440,10 +470,8 @@ function formatAge(date, now = Date.now()) {
440
470
  return seconds < 60 ? "just now" : `${upTo(formatSeconds(seconds), " ")} ago`;
441
471
  }
442
472
  function truncate(text, width) {
443
- return ko(text, width, { suffix: "\u2026", includeSuffix: true });
473
+ return Ao(text, width, { suffix: "\u2026", includeSuffix: true });
444
474
  }
445
- var LINE_BREAKS = /\s*\n\s*/g;
446
- var ESCAPE = String.fromCharCode(27);
447
475
  function textWidth(text) {
448
476
  return Bun.stringWidth(text);
449
477
  }
@@ -492,14 +520,40 @@ function jsonText(value, replacer, { stream = process7.stdout, env = process7.en
492
520
  function printJson(value) {
493
521
  console.log(jsonText(value));
494
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
+ });
495
532
 
496
533
  // ../kit/src/help.ts
497
534
  import process8 from "process";
498
- var OPTIONAL = /(?<!\x1B)\[[^\]]+\]/g;
499
- var USAGE_PREFIX = /^usage:\s*/i;
500
- var FULL_STOP = /\.$/;
501
535
  function usageLine(usage, colors = paint(process8.stdout)) {
502
- 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));
503
557
  }
504
558
  function helpText(usage, options, colors = paint(process8.stdout), { examples = [], exits = [] } = {}) {
505
559
  return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join(`
@@ -534,7 +588,6 @@ function exampleRows(examples, colors = paint(process8.stdout)) {
534
588
  return [];
535
589
  return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? ` ${example}` : ` ${example[0]} ${colors.dim(`# ${example[1]}`)}`)];
536
590
  }
537
- var MAX_INLINE_CHOICES = 24;
538
591
  function optionRows(options, colors = paint(process8.stdout)) {
539
592
  const rows = Object.entries(options).map(([name, option]) => {
540
593
  const short = option.short === undefined ? " " : `${colors.cyan(`-${option.short}`)}, `;
@@ -549,9 +602,17 @@ function optionRows(options, colors = paint(process8.stdout)) {
549
602
  const width = Math.max(0, ...rows.map((row) => row.width));
550
603
  return rows.map((row) => row.description === "" ? ` ${row.flag}` : ` ${row.flag}${" ".repeat(width - row.width)} ${colors.dim(row.description)}`);
551
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
+ });
552
614
 
553
615
  // ../kit/src/text.ts
554
- var ANSI = /\x1B(?:\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]|\][^\x07\x1B]*(?:\x07|\x1B\\)|[\x40-\x5A\x5C-\x5F])/g;
555
616
  function distance(a, b) {
556
617
  const left = [...a];
557
618
  const right = [...b];
@@ -577,8 +638,12 @@ function closest(name, names) {
577
638
  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
578
639
  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
579
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
+
580
646
  // ../kit/src/input.ts
581
- var WHOLE = /^\d+$/;
582
647
  function wholeNumber(value, name, fallback, min = 1) {
583
648
  if (value === undefined)
584
649
  return fallback;
@@ -587,8 +652,6 @@ function wholeNumber(value, name, fallback, min = 1) {
587
652
  badUsage(`${name.startsWith("<") ? name : `--${name}`} takes a whole number from ${min}, not ${value}`);
588
653
  return number;
589
654
  }
590
- var DURATION = /^(\d+(?:\.\d+)?)(ms|[smhd])?$/;
591
- var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
592
655
  function duration(value, name, fallback, unit = "s") {
593
656
  if (value === undefined)
594
657
  return fallback;
@@ -598,40 +661,27 @@ function duration(value, name, fallback, unit = "s") {
598
661
  badUsage(`--${name} takes a duration such as 30s, 5m, 1h or 7d, not ${value}`);
599
662
  return ms;
600
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
+ });
601
671
 
602
672
  // ../kit/src/args.ts
603
- var DASHES = /^-+/;
673
+ import process9 from "process";
674
+ import { parseArgs } from "util";
604
675
  function jsonOption(holds) {
605
676
  return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
606
677
  }
607
- class Exit extends Error {
608
- code;
609
- hint;
610
- constructor(message, code, hint) {
611
- super(message);
612
- this.code = code;
613
- this.hint = hint;
614
- }
615
- }
616
678
  function fail(message, code = 2, hint) {
617
679
  throw new Exit(message, code, hint);
618
680
  }
619
-
620
- class UsageError extends Exit {
621
- constructor(message, hint) {
622
- super(message, 2, hint);
623
- }
624
- }
625
681
  function badUsage(message) {
626
682
  throw new UsageError(message);
627
683
  }
628
684
 
629
- class HelpShown extends Exit {
630
- constructor() {
631
- super("help shown", 0);
632
- }
633
- }
634
-
635
685
  class Completing {
636
686
  options;
637
687
  positionals;
@@ -642,11 +692,6 @@ class Completing {
642
692
  this.candidates = candidates;
643
693
  }
644
694
  }
645
- var completion = { active: false };
646
- var OUTPUT_OPTIONS = {
647
- color: { type: "string", description: "auto (on a terminal alone), always or never" },
648
- plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
649
- };
650
695
  function applyOutput(color, plain, env = process9.env) {
651
696
  const when = plain === true ? "never" : color ?? "auto";
652
697
  if (when === "auto")
@@ -800,7 +845,6 @@ function parseError(error) {
800
845
  const message = upTo(error instanceof Error ? error.message : String(error), ". ");
801
846
  return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
802
847
  }
803
- var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
804
848
  function nearestOption(message, options, allowNegative) {
805
849
  const typed = UNKNOWN_OPTION.exec(message)?.[1];
806
850
  if (typed === undefined)
@@ -816,6 +860,694 @@ function nearestOption(message, options, allowNegative) {
816
860
  const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
817
861
  return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
818
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/gu.ts
1544
+ import { mkdirSync as mkdirSync3, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
1545
+ import { join as join10, resolve as resolve5 } from "path";
1546
+ import process23 from "process";
1547
+
1548
+ // ../kit/src/index.ts
1549
+ init_args();
1550
+
819
1551
  // ../kit/src/argv.ts
820
1552
  import { readFileSync as readFileSync3, realpathSync } from "fs";
821
1553
  import { resolve as resolve3 } from "path";
@@ -840,14 +1572,26 @@ function scriptArgs(argv = process10.argv.slice(2), cmdline = commandLine(), scr
840
1572
  const after = at === -1 ? [] : cmdline.slice(at + 1);
841
1573
  return after[0] === "--" && after.length === argv.length + 1 && argv.every((word, index) => word === after[index + 1]) ? after : argv;
842
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
+
843
1584
  // ../kit/src/progress.ts
1585
+ init_format();
844
1586
  import process12 from "process";
845
1587
 
846
1588
  // ../kit/src/process.ts
1589
+ import { readFileSync as readFileSync4 } from "fs";
847
1590
  import { constants } from "os";
848
1591
  import process11 from "process";
849
1592
  var KILL_GRACE_MS = 2000;
850
1593
  var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
1594
+ var GROUP_SIGNALS = new Set(["SIGINT", "SIGHUP"]);
851
1595
  function exitCodeOf(code, signal) {
852
1596
  if (code !== null)
853
1597
  return code;
@@ -855,6 +1599,21 @@ function exitCodeOf(code, signal) {
855
1599
  return 128 + signal;
856
1600
  return signal === null ? 129 : 128 + constants.signals[signal];
857
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
+ }
858
1617
  function holdSignals(cleanup) {
859
1618
  let received;
860
1619
  let child;
@@ -873,7 +1632,8 @@ function holdSignals(cleanup) {
873
1632
  function onSignal(signal) {
874
1633
  received = signal;
875
1634
  if (child !== undefined) {
876
- child.kill(signal);
1635
+ if (!GROUP_SIGNALS.has(signal) || !heardTheTerminal(child))
1636
+ child.kill(signal);
877
1637
  return;
878
1638
  }
879
1639
  if (cleanup === undefined)
@@ -886,10 +1646,10 @@ function holdSignals(cleanup) {
886
1646
  process11.on(signal, onSignal);
887
1647
  return held;
888
1648
  }
889
- 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 } = {}) {
890
1650
  const chunks = [];
891
1651
  const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
892
- 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 } : {} });
893
1653
  const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
894
1654
  const timers = [];
895
1655
  const killGroup = (killing) => {
@@ -929,12 +1689,19 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
929
1689
  stop();
930
1690
  continue;
931
1691
  }
1692
+ if (state.truncated)
1693
+ continue;
1694
+ let kept = data;
932
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);
933
1700
  state.truncated = true;
934
- continue;
935
1701
  }
936
- state.kept += data.length;
937
- chunks.push({ stream: name, data });
1702
+ state.kept += kept.length;
1703
+ if (kept.length > 0)
1704
+ chunks.push({ stream: name, data: kept });
938
1705
  }
939
1706
  };
940
1707
  try {
@@ -951,6 +1718,7 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
951
1718
  const joined = () => Buffer.concat(chunks.map(({ data }) => data));
952
1719
  let output;
953
1720
  let text;
1721
+ let stdout;
954
1722
  return {
955
1723
  code: exitCodeOf(proc.exitCode, proc.signalCode),
956
1724
  chunks,
@@ -961,11 +1729,16 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
961
1729
  },
962
1730
  get text() {
963
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();
964
1735
  }
965
1736
  };
966
1737
  }
967
1738
 
968
1739
  // ../kit/src/progress.ts
1740
+ init_style();
1741
+ init_theme();
969
1742
  var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
970
1743
  var FRAME_MS = 200;
971
1744
  var BAR_WIDTH = 20;
@@ -983,10 +1756,14 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
983
1756
  }, print: (text) => void stream.write(`${text}
984
1757
  `), stop: () => {
985
1758
  return;
1759
+ }, pause: () => () => {
1760
+ return;
986
1761
  } };
987
1762
  const write = stream.write.bind(stream);
988
1763
  let frame = 0;
989
1764
  let drawn = false;
1765
+ let paused = false;
1766
+ let stopped = false;
990
1767
  const columns = () => {
991
1768
  const now = stream.getWindowSize?.()[0] ?? stream.columns;
992
1769
  return now === undefined || now === 0 ? 80 : now;
@@ -997,6 +1774,8 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
997
1774
  drawn = false;
998
1775
  };
999
1776
  const draw = () => {
1777
+ if (paused)
1778
+ return;
1000
1779
  const width = columns() - 1;
1001
1780
  const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
1002
1781
  const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
@@ -1008,16 +1787,17 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
1008
1787
  `)}${lines.length > 1 ? `\x1B[${lines.length - 1}A` : ""}\r`);
1009
1788
  drawn = true;
1010
1789
  };
1011
- const timer = setInterval(draw, FRAME_MS);
1790
+ let timer = setInterval(draw, FRAME_MS);
1012
1791
  stream.on?.("resize", draw);
1013
- const restore = interceptOutput(clear);
1014
- const release = swallowInput();
1792
+ let restore = interceptOutput(clear);
1793
+ let release = swallowInput();
1015
1794
  const onExit = () => {
1016
1795
  clear();
1017
1796
  release();
1018
1797
  };
1019
1798
  const signals = holdSignals(stop);
1020
1799
  function stop() {
1800
+ stopped = true;
1021
1801
  clearInterval(timer);
1022
1802
  stream.off?.("resize", draw);
1023
1803
  clear();
@@ -1026,6 +1806,29 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
1026
1806
  process12.off("exit", onExit);
1027
1807
  signals.release();
1028
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
+ }
1029
1832
  timer.unref();
1030
1833
  process12.on("exit", onExit);
1031
1834
  return {
@@ -1036,7 +1839,8 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
1036
1839
  `);
1037
1840
  draw();
1038
1841
  },
1039
- stop
1842
+ stop,
1843
+ pause
1040
1844
  };
1041
1845
  }
1042
1846
  function progressLine(stream = process12.stderr, env = process12.env) {
@@ -1061,6 +1865,7 @@ function progressLine(stream = process12.stderr, env = process12.env) {
1061
1865
  }
1062
1866
  },
1063
1867
  stop: region.stop,
1868
+ pause: region.pause,
1064
1869
  done: (text) => end(marked("ok", text, stream, formatDuration(performance.now() - begun), env)),
1065
1870
  failed: (text) => end(marked("problem", text, stream, undefined, env))
1066
1871
  };
@@ -1149,40 +1954,225 @@ function interceptOutput(clear) {
1149
1954
  }
1150
1955
  };
1151
1956
  }
1957
+
1958
+ // ../kit/src/ci.ts
1959
+ init_style();
1960
+
1961
+ // ../kit/src/tool.ts
1962
+ init_format();
1152
1963
  // ../kit/src/cli.ts
1153
- import { readFileSync as readFileSync4, realpathSync as realpathSync2 } from "fs";
1154
- import { dirname as dirname3, join as join5 } from "path";
1155
- 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
+ }
1156
2138
 
1157
2139
  // ../kit/src/notify.ts
1158
- import process13 from "process";
2140
+ init_format();
2141
+ init_mode();
2142
+ import process17 from "process";
1159
2143
  var NOTIFY_AFTER_MS = 1e4;
1160
2144
  var CANCELLED = 130;
1161
2145
  function base64(text) {
1162
2146
  return Buffer.from(text).toString("base64");
1163
2147
  }
1164
- function notification(title, body, env = process13.env) {
1165
- const id = `kit${process13.pid}`;
2148
+ function notification(title, body, env = process17.env) {
2149
+ const id = `kit${process17.pid}`;
1166
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\\`];
1167
2151
  return codes.map((code) => env.TMUX === undefined || env.TMUX === "" ? code : `\x1BPtmux;${code.replaceAll("\x1B", "\x1B\x1B")}\x1B\\`).join("");
1168
2152
  }
1169
- function notifyEnd(command, code, ms, { stream = process13.stderr, env = process13.env } = {}) {
2153
+ function notifyEnd(command, code, ms, { stream = process17.stderr, env = process17.env } = {}) {
1170
2154
  if (ms < NOTIFY_AFTER_MS || code === CANCELLED || outputMode(stream, env) !== "terminal")
1171
2155
  return;
1172
2156
  stream.write(notification(command, code === 0 ? `done in ${formatDuration(ms)}` : `failed with exit ${code} after ${formatDuration(ms)}`, env));
1173
2157
  }
1174
2158
 
2159
+ // ../kit/src/cli.ts
2160
+ init_style();
2161
+ init_text2();
2162
+
1175
2163
  // ../kit/src/usage.ts
1176
- import { appendFileSync, mkdirSync } from "fs";
1177
- import { homedir as homedir3 } from "os";
1178
- import { dirname as dirname2, isAbsolute, join as join4 } from "path";
1179
- 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";
1180
2168
 
1181
2169
  // ../kit/src/logs.ts
2170
+ init_user_config();
1182
2171
  var DAY_MS = 24 * 60 * 60 * 1000;
1183
2172
  var CLI_FOLDER = "kaynooo-cli";
1184
2173
 
1185
2174
  // ../kit/src/usage.ts
2175
+ init_user_config();
1186
2176
  var UNKNOWN_OPTION2 = /unknown option '(--[a-z][a-z0-9-]*)[=']/;
1187
2177
  var FLAG_NAME = /^(?:--[a-z][a-z0-9-]*|-[a-zA-Z])$/;
1188
2178
  var LONGEST_NAME = 40;
@@ -1190,14 +2180,13 @@ var usageError;
1190
2180
  function noteUsageError(message) {
1191
2181
  usageError = message;
1192
2182
  }
1193
- function stateHome(env = process14.env) {
1194
- const dir = env.XDG_STATE_HOME;
1195
- 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"));
1196
2185
  }
1197
- function usagePath(env = process14.env) {
1198
- return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
2186
+ function usagePath(env = process18.env) {
2187
+ return join7(stateHome(env), CLI_FOLDER, "usage.jsonl");
1199
2188
  }
1200
- function usageRecorded(env = process14.env) {
2189
+ function usageRecorded(env = process18.env) {
1201
2190
  const off = env.KAYNOOO_CLI_NO_USAGE;
1202
2191
  return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
1203
2192
  }
@@ -1206,17 +2195,17 @@ function flagNames(argv) {
1206
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);
1207
2196
  return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
1208
2197
  }
1209
- function usageEntry(bin, command, argv, code, now = new Date) {
2198
+ function usageEntry(bin, command, argv, code, { ms, now = new Date } = {}) {
1210
2199
  const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
1211
2200
  usageError = undefined;
1212
- 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) } };
1213
2202
  }
1214
- function recordUsage(entry, env = process14.env) {
2203
+ function recordUsage(entry, env = process18.env) {
1215
2204
  if (!usageRecorded(env))
1216
2205
  return;
1217
2206
  try {
1218
2207
  const path = usagePath(env);
1219
- mkdirSync(dirname2(path), { recursive: true, mode: 448 });
2208
+ mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
1220
2209
  appendFileSync(path, `${JSON.stringify(entry)}
1221
2210
  `, { mode: 384 });
1222
2211
  } catch {}
@@ -1227,10 +2216,14 @@ var LEVEL_OPTIONS = {
1227
2216
  ...OUTPUT_OPTIONS,
1228
2217
  help: { type: "boolean", short: "h", description: "show this help" }
1229
2218
  };
1230
- 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
+ };
1231
2224
  function printError(prefix, message, hint, cause) {
1232
- const colors = paint(process15.stderr);
1233
- const styled = takesControlCodes(process15.stderr);
2225
+ const colors = paint(process19.stderr);
2226
+ const styled = takesControlCodes(process19.stderr);
1234
2227
  const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
1235
2228
  const under = (label, text, tint) => text === undefined ? "" : `
1236
2229
  ${styled ? tint(label) : `${label}:`} ${text}`;
@@ -1310,6 +2303,19 @@ async function leafCandidates(run, words) {
1310
2303
  const values = name === undefined ? undefined : await completing.candidates[name]?.(typed);
1311
2304
  return values === undefined ? [FILES] : values.map(candidateLine);
1312
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
+ }
1313
2319
  async function printCandidates(found) {
1314
2320
  for (const line of await found)
1315
2321
  console.log(line);
@@ -1320,19 +2326,24 @@ function packageVersion(entry = Bun.main) {
1320
2326
  try {
1321
2327
  resolved = realpathSync2(entry);
1322
2328
  } catch {}
1323
- for (let dir = dirname3(resolved);; dir = dirname3(dir)) {
2329
+ for (let dir = dirname4(resolved);; dir = dirname4(dir)) {
1324
2330
  try {
1325
- const { version } = JSON.parse(readFileSync4(join5(dir, "package.json"), "utf8"));
2331
+ const { version } = JSON.parse(readFileSync6(join8(dir, "package.json"), "utf8"));
1326
2332
  if (typeof version === "string")
1327
2333
  return version;
1328
2334
  } catch {}
1329
- if (dirname3(dir) === dir)
2335
+ if (dirname4(dir) === dir)
1330
2336
  return "0.0.0";
1331
2337
  }
1332
2338
  }
1333
2339
  async function runMain({ name, version, run, redact, usage }, argv = scriptArgs()) {
2340
+ const answered = await askpassClient(argv);
2341
+ if (answered !== undefined)
2342
+ return answered;
1334
2343
  if (argv[0] === COMPLETE)
1335
2344
  return printCandidates(leafCandidates(run, argv.slice(1)));
2345
+ if (argv[0] === COMPLETIONS || argv[0]?.startsWith(`${COMPLETIONS}=`) === true)
2346
+ return printCompletionScript(name, flagValue(argv));
1336
2347
  if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
1337
2348
  console.log(version ?? packageVersion());
1338
2349
  return 0;
@@ -1347,21 +2358,52 @@ async function runMain({ name, version, run, redact, usage }, argv = scriptArgs(
1347
2358
  notifyEnd(name, code, performance.now() - started);
1348
2359
  if (usage !== false) {
1349
2360
  try {
1350
- recordUsage(usageEntry(name, undefined, argv, code));
2361
+ recordUsage(usageEntry(name, undefined, argv, code, { ms: performance.now() - started }));
1351
2362
  } catch {}
1352
2363
  }
1353
2364
  return code;
1354
2365
  }
1355
- // ../kit/src/folders.ts
1356
- 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();
1357
2388
  // ../kit/src/secrets.ts
1358
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"]);
1359
2391
  // ../kit/src/sessions.ts
1360
2392
  var {Glob } = globalThis.Bun;
1361
2393
  var SESSION_FILES = new Glob("*.json");
1362
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
+
1363
2402
  // ../kit/src/watch.ts
1364
- import process16 from "process";
2403
+ init_args();
2404
+ init_input();
2405
+ init_style();
2406
+ import process20 from "process";
1365
2407
  import { format } from "util";
1366
2408
  var CLEAR_SCREEN = "\x1B[H\x1B[2J";
1367
2409
  var DEFAULT_SECONDS = 2;
@@ -1383,7 +2425,7 @@ function withoutWatch(args) {
1383
2425
  }
1384
2426
  return rest;
1385
2427
  }
1386
- 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) {
1387
2429
  const interval = value === "" ? DEFAULT_SECONDS * 1000 : duration(value, "watch", DEFAULT_SECONDS * 1000);
1388
2430
  if (!takesControlCodes(stream))
1389
2431
  badUsage("--watch redraws the screen, so it needs a terminal");
@@ -1391,12 +2433,12 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
1391
2433
  for (let round = 0;round < rounds; round++) {
1392
2434
  const held = [];
1393
2435
  const { log, info } = console;
1394
- const write = process16.stdout.write.bind(process16.stdout);
2436
+ const write = process20.stdout.write.bind(process20.stdout);
1395
2437
  const hold = (...parts) => void held.push(`${format(...parts)}
1396
2438
  `);
1397
2439
  console.log = hold;
1398
2440
  console.info = hold;
1399
- process16.stdout.write = (text) => {
2441
+ process20.stdout.write = (text) => {
1400
2442
  held.push(typeof text === "string" ? text : Buffer.from(text).toString());
1401
2443
  return true;
1402
2444
  };
@@ -1405,7 +2447,7 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
1405
2447
  } finally {
1406
2448
  console.log = log;
1407
2449
  console.info = info;
1408
- process16.stdout.write = write;
2450
+ process20.stdout.write = write;
1409
2451
  }
1410
2452
  stream.write(`${CLEAR_SCREEN}${held.join("")}`);
1411
2453
  await sleep(interval);
@@ -1413,21 +2455,22 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
1413
2455
  return code;
1414
2456
  }
1415
2457
  // ../kit/src/workspace-root.ts
1416
- import { homedir as homedir4 } from "os";
1417
- import { dirname as dirname4, join as join6, resolve as resolve4 } from "path";
1418
- 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";
1419
2462
  function expandHome(path, home) {
1420
2463
  if (path === "~")
1421
2464
  return home;
1422
- return path.startsWith("~/") ? join6(home, path.slice(2)) : path;
2465
+ return path.startsWith("~/") ? join9(home, path.slice(2)) : path;
1423
2466
  }
1424
2467
  function configured(env, home) {
1425
2468
  const folder = readUserConfig("config", { home, xdg: env.XDG_CONFIG_HOME }).workspace;
1426
2469
  return typeof folder === "string" && folder !== "" ? folder : undefined;
1427
2470
  }
1428
- function workspaceRoot({ given, env = process17.env, home = homedir4() } = {}) {
2471
+ function workspaceRoot({ given, env = process21.env, home = homedir5() } = {}) {
1429
2472
  const fromEnv = env.KAYNOOO_WORKSPACE === "" ? undefined : env.KAYNOOO_WORKSPACE;
1430
- 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));
1431
2474
  }
1432
2475
  // src/git.ts
1433
2476
  async function git2(args, env) {
@@ -1439,26 +2482,27 @@ async function git2(args, env) {
1439
2482
  // src/gu.ts
1440
2483
  var USAGE = `gu <path>...: undoes changes to the paths given, keeping what it takes away
1441
2484
 
1442
- By default it discards the unstaged changes of the tracked paths, after saving them as a patch in the git folder (gu/<time>.patch) that \`git apply\` puts back. --staged unstages the paths and loses nothing. --commit undoes the last commit, its changes left staged, and refuses a commit that is already on the upstream or a merge.
1443
- Nothing is discarded without a path: gu alone is a usage error, never "everything". A path with no change is refused with nothing done.`;
2485
+ By default it discards the unstaged changes of the tracked paths, after saving them as a patch in the git folder (\`gu/<time>.patch\`) that \`git apply\` puts back; a file added with git add -N leaves the index and the disk. --staged unstages the paths. --commit undoes the last commit, its changes left staged, refusing one already on the upstream or a merge.
2486
+ Without a path it is a usage error, never "everything"; a path with no change is refused with nothing done.`;
1444
2487
  var EXITS = [[0, "it undid what was asked"], [1, "a path has no change, the commit is pushed or git refused"], [2, "a usage error or outside a git repository"]];
1445
2488
  var OPTIONS = {
1446
2489
  staged: { type: "boolean", short: "s", description: "unstage the paths, the working tree untouched" },
1447
2490
  commit: { type: "boolean", short: "c", description: "undo the last commit, keeping its changes staged" },
1448
2491
  json: jsonOption("{action, paths?, saved?, commit?} of what was undone, saved being the patch of a discard")
1449
2492
  };
1450
- var LITERAL = { ...process19.env, GIT_LITERAL_PATHSPECS: "1" };
2493
+ var LITERAL = { ...process23.env, GIT_LITERAL_PATHSPECS: "1" };
1451
2494
  var PLAIN_PATCH = ["--binary", "--no-ext-diff", "--no-textconv", "--no-color", "--no-relative", "--submodule=short", "--src-prefix=a/", "--dst-prefix=b/"];
1452
2495
  var NOT_A_REPOSITORY = /not a git repository/i;
1453
- async function checked(args) {
2496
+ async function checked(args, standing = "nothing undone") {
1454
2497
  const { code, stdout, stderr } = await git2(args, LITERAL);
2498
+ const command = args[0] === "-C" ? args[2] : args[0];
1455
2499
  if (code !== 0)
1456
- fail(`git ${args[0]} failed, nothing undone:
2500
+ fail(`git ${command} failed, ${standing}:
1457
2501
  ${stderr.trim()}`, NOT_A_REPOSITORY.test(stderr) ? 2 : 1);
1458
2502
  return stdout;
1459
2503
  }
1460
2504
  async function changed(paths, cached) {
1461
- const out = await checked(["diff", ...cached ? ["--cached"] : [], "--name-only", "-z", "--", ...paths]);
2505
+ const out = await checked(["diff", ...cached ? ["--cached"] : [], "--name-only", "--no-relative", "-z", "--", ...paths]);
1462
2506
  return out.split("\x00").filter(Boolean);
1463
2507
  }
1464
2508
  async function undoCommit() {
@@ -1504,20 +2548,29 @@ async function main(argv) {
1504
2548
  return 0;
1505
2549
  }
1506
2550
  const patch = await checked(["diff", ...PLAIN_PATCH, "--", ...positionals]);
1507
- const folder = join7(resolve5((await checked(["rev-parse", "--git-dir"])).trim()), "gu");
1508
- const saved = join7(folder, `${new Date().toISOString().replaceAll(":", "-")}.patch`);
2551
+ const folder = join10(resolve5((await checked(["rev-parse", "--git-dir"])).trim()), "gu");
2552
+ const saved = join10(folder, `${new Date().toISOString().replaceAll(":", "-")}.patch`);
1509
2553
  const top = (await checked(["rev-parse", "--show-toplevel"])).trim();
1510
- mkdirSync2(folder, { recursive: true });
1511
- writeFileSync(saved, patch);
2554
+ mkdirSync3(folder, { recursive: true });
2555
+ writeFileSync3(saved, patch);
1512
2556
  const reverts = await git2(["-C", top, "apply", "--check", "--reverse", "--whitespace=nowarn", saved]);
1513
2557
  if (reverts.code !== 0)
1514
2558
  fail(`the patch saved to ${saved} would not put the change back, nothing discarded:
1515
2559
  ${reverts.stderr.trim()}`, 1);
1516
- await checked(["restore", "--", ...positionals]);
2560
+ const intended = (await checked(["diff", "--name-only", "--no-relative", "--diff-filter=A", "-z", "--", ...positionals])).split("\x00").filter(Boolean);
2561
+ const tracked = paths.filter((path) => !intended.includes(path));
2562
+ const standing = `the change is saved to ${saved}`;
2563
+ if (intended.length > 0) {
2564
+ await checked(["-C", top, "rm", "--cached", "--quiet", "--", ...intended], standing);
2565
+ for (const path of intended)
2566
+ rmSync2(join10(top, path), { force: true });
2567
+ }
2568
+ if (tracked.length > 0)
2569
+ await checked(["-C", top, "restore", "--", ...tracked], standing);
1517
2570
  if (values.json === true)
1518
2571
  printJson({ action: "discard", paths, saved });
1519
2572
  else
1520
2573
  console.log(`discarded ${paths.join(", ")}, saved to ${saved} (git apply puts it back)`);
1521
2574
  return 0;
1522
2575
  }
1523
- process19.exitCode = await runMain({ name: "gu", run: main });
2576
+ process23.exitCode = await runMain({ name: "gu", run: main });