@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/gb.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/gb.ts
5
- import process23 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,208 +860,942 @@ 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
  }
817
- // ../kit/src/argv.ts
818
- import { readFileSync as readFileSync3, realpathSync } from "fs";
819
- import { resolve as resolve3 } from "path";
820
- import process10 from "process";
821
- function commandLine() {
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() {
822
925
  try {
823
- return readFileSync3("/proc/self/cmdline", "utf8").split("\x00").slice(0, -1);
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")));
824
930
  } catch {
825
- return;
931
+ return {};
826
932
  }
827
933
  }
828
- function realPath(word) {
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);
829
941
  try {
830
- return realpathSync(resolve3(word));
831
- } catch {
832
- return;
833
- }
942
+ mkdirSync(dirname2(file), { recursive: true });
943
+ writeFileSync(file, JSON.stringify(all));
944
+ } catch {}
834
945
  }
835
- function scriptArgs(argv = process10.argv.slice(2), cmdline = commandLine(), script = process10.argv[1]) {
836
- const target = script === undefined ? undefined : realPath(script) ?? script;
837
- const at = cmdline === undefined || target === undefined ? -1 : cmdline.findIndex((word, index) => index > 0 && (resolve3(word) === script || realPath(word) === target));
838
- const after = at === -1 ? [] : cmdline.slice(at + 1);
839
- return after[0] === "--" && after.length === argv.length + 1 && argv.every((word, index) => word === after[index + 1]) ? after : argv;
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");
840
955
  }
841
- // ../kit/src/progress.ts
842
- import process12 from "process";
956
+ var init_job = () => {};
843
957
 
844
- // ../kit/src/process.ts
845
- import { constants } from "os";
846
- import process11 from "process";
847
- var KILL_GRACE_MS = 2000;
848
- var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
849
- function exitCodeOf(code, signal) {
850
- if (code !== null)
851
- return code;
852
- if (typeof signal === "number")
853
- return 128 + signal;
854
- return signal === null ? 129 : 128 + constants.signals[signal];
958
+ // ../kit/src/picker/line.ts
959
+ function isEditKey(key) {
960
+ return EDIT_KEYS.has(key);
855
961
  }
856
- function holdSignals(cleanup) {
857
- let received;
858
- let child;
859
- const held = {
860
- get signal() {
861
- return received;
862
- },
863
- forward: (to) => {
864
- child = to;
865
- },
866
- release: () => {
867
- for (const signal of SIGNALS)
868
- process11.off(signal, onSignal);
869
- }
870
- };
871
- function onSignal(signal) {
872
- received = signal;
873
- if (child !== undefined) {
874
- child.kill(signal);
875
- return;
876
- }
877
- if (cleanup === undefined)
878
- return;
879
- held.release();
880
- cleanup(signal);
881
- process11.kill(process11.pid, signal);
882
- }
883
- for (const signal of SIGNALS)
884
- process11.on(signal, onSignal);
885
- return held;
962
+ function endsKills(key) {
963
+ return typeof key !== "object" && !isEditKey(key);
886
964
  }
887
- async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
888
- const chunks = [];
889
- 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 } : {} });
891
- const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
892
- const timers = [];
893
- const killGroup = (killing) => {
894
- if (state.done)
895
- return;
896
- try {
897
- if (grouped)
898
- process11.kill(-proc.pid, killing);
899
- else
900
- proc.kill(killing);
901
- } catch {}
902
- };
903
- const stop = () => {
904
- killGroup("SIGTERM");
905
- timers.push(setTimeout(killGroup, KILL_GRACE_MS, "SIGKILL"));
906
- };
907
- const onAbort = () => stop();
908
- if (timeoutMs !== undefined) {
909
- timers.push(setTimeout(() => {
910
- state.timedOut = true;
911
- stop();
912
- }, timeoutMs));
913
- }
914
- if (signal?.aborted === true)
915
- onAbort();
916
- else
917
- signal?.addEventListener("abort", onAbort, { once: true });
918
- onStart?.({ kill: (killing) => killGroup(killing) });
919
- const drain = async (stream, name) => {
920
- for await (const data of stream) {
921
- if (state.failure !== undefined)
922
- continue;
923
- try {
924
- onChunk?.({ stream: name, data });
925
- } catch (error) {
926
- state.failure = error;
927
- stop();
928
- continue;
929
- }
930
- if (state.kept + data.length > maxBytes) {
931
- state.truncated = true;
932
- continue;
933
- }
934
- state.kept += data.length;
935
- chunks.push({ stream: name, data });
936
- }
937
- };
938
- try {
939
- await Promise.all([drain(proc.stdout, "stdout"), drain(proc.stderr, "stderr")]);
940
- await proc.exited;
941
- } finally {
942
- state.done = true;
943
- for (const timer of timers)
944
- clearTimeout(timer);
945
- signal?.removeEventListener("abort", onAbort);
946
- }
947
- if (state.failure !== undefined)
948
- throw state.failure;
949
- const joined = () => Buffer.concat(chunks.map(({ data }) => data));
950
- let output;
951
- let text;
952
- return {
953
- code: exitCodeOf(proc.exitCode, proc.signalCode),
954
- chunks,
955
- timedOut: state.timedOut,
956
- truncated: state.truncated,
957
- get output() {
958
- return output ??= joined();
959
- },
960
- get text() {
961
- return text ??= (output ??= joined()).toString();
962
- }
963
- };
965
+ function isWord(char) {
966
+ return char !== undefined && WORD_CHARACTER.test(char);
964
967
  }
965
-
966
- // ../kit/src/progress.ts
967
- var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
968
- var FRAME_MS = 200;
969
- var BAR_WIDTH = 20;
970
- var CLEAR_BELOW = "\r\x1B[J";
971
- var ESC = String.fromCharCode(27);
972
- var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
973
- var RESET_STYLE = `${ESC}[0m`;
974
- var CTRL_C = 3;
975
- var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
976
- var CONSOLE_METHODS = ["log", "info", "warn", "error", "debug", "dir", "dirxml", "table", "trace", "group", "groupCollapsed", "count", "timeEnd", "timeLog", "assert"];
977
- function liveRegion(render, stream = process12.stderr, env = process12.env) {
978
- if (!takesControlCodes(stream, env))
979
- return { redraw: () => {
980
- return;
981
- }, print: (text) => void stream.write(`${text}
982
- `), stop: () => {
983
- return;
984
- } };
985
- const write = stream.write.bind(stream);
986
- let frame = 0;
987
- let drawn = false;
988
- const columns = () => {
989
- const now = stream.getWindowSize?.()[0] ?? stream.columns;
990
- return now === undefined || now === 0 ? 80 : now;
991
- };
992
- const clear = () => {
993
- if (drawn)
994
- write(CLEAR_BELOW);
995
- drawn = false;
996
- };
997
- const draw = () => {
998
- const width = columns() - 1;
999
- const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
1000
- const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
1001
- if (lines.length === 0) {
1002
- clear();
1003
- return;
1004
- }
1005
- write(`${CLEAR_BELOW}${lines.join(`
1006
- `)}${lines.length > 1 ? `\x1B[${lines.length - 1}A` : ""}\r`);
1007
- drawn = true;
1008
- };
1009
- const timer = setInterval(draw, FRAME_MS);
1010
- stream.on?.("resize", draw);
1011
- const restore = interceptOutput(clear);
1012
- const release = swallowInput();
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/gb.ts
1544
+ import process26 from "process";
1545
+
1546
+ // ../kit/src/index.ts
1547
+ init_args();
1548
+
1549
+ // ../kit/src/argv.ts
1550
+ import { readFileSync as readFileSync3, realpathSync } from "fs";
1551
+ import { resolve as resolve3 } from "path";
1552
+ import process10 from "process";
1553
+ function commandLine() {
1554
+ try {
1555
+ return readFileSync3("/proc/self/cmdline", "utf8").split("\x00").slice(0, -1);
1556
+ } catch {
1557
+ return;
1558
+ }
1559
+ }
1560
+ function realPath(word) {
1561
+ try {
1562
+ return realpathSync(resolve3(word));
1563
+ } catch {
1564
+ return;
1565
+ }
1566
+ }
1567
+ function scriptArgs(argv = process10.argv.slice(2), cmdline = commandLine(), script = process10.argv[1]) {
1568
+ const target = script === undefined ? undefined : realPath(script) ?? script;
1569
+ const at = cmdline === undefined || target === undefined ? -1 : cmdline.findIndex((word, index) => index > 0 && (resolve3(word) === script || realPath(word) === target));
1570
+ const after = at === -1 ? [] : cmdline.slice(at + 1);
1571
+ return after[0] === "--" && after.length === argv.length + 1 && argv.every((word, index) => word === after[index + 1]) ? after : argv;
1572
+ }
1573
+ // ../kit/src/chart.ts
1574
+ init_format();
1575
+ init_mode();
1576
+ init_style();
1577
+ init_theme();
1578
+ // ../kit/src/ci.ts
1579
+ init_args();
1580
+ init_format();
1581
+
1582
+ // ../kit/src/progress.ts
1583
+ init_format();
1584
+ import process12 from "process";
1585
+
1586
+ // ../kit/src/process.ts
1587
+ import { readFileSync as readFileSync4 } from "fs";
1588
+ import { constants } from "os";
1589
+ import process11 from "process";
1590
+ var KILL_GRACE_MS = 2000;
1591
+ var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
1592
+ var GROUP_SIGNALS = new Set(["SIGINT", "SIGHUP"]);
1593
+ function exitCodeOf(code, signal) {
1594
+ if (code !== null)
1595
+ return code;
1596
+ if (typeof signal === "number")
1597
+ return 128 + signal;
1598
+ return signal === null ? 129 : 128 + constants.signals[signal];
1599
+ }
1600
+ function groupsOf(pid) {
1601
+ try {
1602
+ const stat = readFileSync4(`/proc/${pid}/stat`, "utf8");
1603
+ const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
1604
+ return { group: Number(fields[2]), foreground: Number(fields[5]) };
1605
+ } catch {
1606
+ return;
1607
+ }
1608
+ }
1609
+ function heardTheTerminal(child) {
1610
+ if (child.pid === undefined)
1611
+ return false;
1612
+ const own = groupsOf("self");
1613
+ return own !== undefined && own.group === own.foreground && groupsOf(child.pid)?.group === own.group;
1614
+ }
1615
+ function holdSignals(cleanup) {
1616
+ let received;
1617
+ let child;
1618
+ const held = {
1619
+ get signal() {
1620
+ return received;
1621
+ },
1622
+ forward: (to) => {
1623
+ child = to;
1624
+ },
1625
+ release: () => {
1626
+ for (const signal of SIGNALS)
1627
+ process11.off(signal, onSignal);
1628
+ }
1629
+ };
1630
+ function onSignal(signal) {
1631
+ received = signal;
1632
+ if (child !== undefined) {
1633
+ if (!GROUP_SIGNALS.has(signal) || !heardTheTerminal(child))
1634
+ child.kill(signal);
1635
+ return;
1636
+ }
1637
+ if (cleanup === undefined)
1638
+ return;
1639
+ held.release();
1640
+ cleanup(signal);
1641
+ process11.kill(process11.pid, signal);
1642
+ }
1643
+ for (const signal of SIGNALS)
1644
+ process11.on(signal, onSignal);
1645
+ return held;
1646
+ }
1647
+ async function runCommand(argv, { cwd, env, stdin = "ignore", input, timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
1648
+ const chunks = [];
1649
+ const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
1650
+ 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 } : {} });
1651
+ const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
1652
+ const timers = [];
1653
+ const killGroup = (killing) => {
1654
+ if (state.done)
1655
+ return;
1656
+ try {
1657
+ if (grouped)
1658
+ process11.kill(-proc.pid, killing);
1659
+ else
1660
+ proc.kill(killing);
1661
+ } catch {}
1662
+ };
1663
+ const stop = () => {
1664
+ killGroup("SIGTERM");
1665
+ timers.push(setTimeout(killGroup, KILL_GRACE_MS, "SIGKILL"));
1666
+ };
1667
+ const onAbort = () => stop();
1668
+ if (timeoutMs !== undefined) {
1669
+ timers.push(setTimeout(() => {
1670
+ state.timedOut = true;
1671
+ stop();
1672
+ }, timeoutMs));
1673
+ }
1674
+ if (signal?.aborted === true)
1675
+ onAbort();
1676
+ else
1677
+ signal?.addEventListener("abort", onAbort, { once: true });
1678
+ onStart?.({ kill: (killing) => killGroup(killing) });
1679
+ const drain = async (stream, name) => {
1680
+ for await (const data of stream) {
1681
+ if (state.failure !== undefined)
1682
+ continue;
1683
+ try {
1684
+ onChunk?.({ stream: name, data });
1685
+ } catch (error) {
1686
+ state.failure = error;
1687
+ stop();
1688
+ continue;
1689
+ }
1690
+ if (state.truncated)
1691
+ continue;
1692
+ let kept = data;
1693
+ if (state.kept + data.length > maxBytes) {
1694
+ let cut = maxBytes - state.kept;
1695
+ while (cut > 0 && ((data[cut] ?? 0) & 192) === 128)
1696
+ cut--;
1697
+ kept = data.subarray(0, cut);
1698
+ state.truncated = true;
1699
+ }
1700
+ state.kept += kept.length;
1701
+ if (kept.length > 0)
1702
+ chunks.push({ stream: name, data: kept });
1703
+ }
1704
+ };
1705
+ try {
1706
+ await Promise.all([drain(proc.stdout, "stdout"), drain(proc.stderr, "stderr")]);
1707
+ await proc.exited;
1708
+ } finally {
1709
+ state.done = true;
1710
+ for (const timer of timers)
1711
+ clearTimeout(timer);
1712
+ signal?.removeEventListener("abort", onAbort);
1713
+ }
1714
+ if (state.failure !== undefined)
1715
+ throw state.failure;
1716
+ const joined = () => Buffer.concat(chunks.map(({ data }) => data));
1717
+ let output;
1718
+ let text;
1719
+ let stdout;
1720
+ return {
1721
+ code: exitCodeOf(proc.exitCode, proc.signalCode),
1722
+ chunks,
1723
+ timedOut: state.timedOut,
1724
+ truncated: state.truncated,
1725
+ get output() {
1726
+ return output ??= joined();
1727
+ },
1728
+ get text() {
1729
+ return text ??= (output ??= joined()).toString();
1730
+ },
1731
+ get stdout() {
1732
+ return stdout ??= Buffer.concat(chunks.filter((chunk) => chunk.stream === "stdout").map((chunk) => chunk.data)).toString();
1733
+ }
1734
+ };
1735
+ }
1736
+
1737
+ // ../kit/src/progress.ts
1738
+ init_style();
1739
+ init_theme();
1740
+ var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
1741
+ var FRAME_MS = 200;
1742
+ var BAR_WIDTH = 20;
1743
+ var CLEAR_BELOW = "\r\x1B[J";
1744
+ var ESC = String.fromCharCode(27);
1745
+ var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
1746
+ var RESET_STYLE = `${ESC}[0m`;
1747
+ var CTRL_C = 3;
1748
+ var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
1749
+ var CONSOLE_METHODS = ["log", "info", "warn", "error", "debug", "dir", "dirxml", "table", "trace", "group", "groupCollapsed", "count", "timeEnd", "timeLog", "assert"];
1750
+ function liveRegion(render, stream = process12.stderr, env = process12.env) {
1751
+ if (!takesControlCodes(stream, env))
1752
+ return { redraw: () => {
1753
+ return;
1754
+ }, print: (text) => void stream.write(`${text}
1755
+ `), stop: () => {
1756
+ return;
1757
+ }, pause: () => () => {
1758
+ return;
1759
+ } };
1760
+ const write = stream.write.bind(stream);
1761
+ let frame = 0;
1762
+ let drawn = false;
1763
+ let paused = false;
1764
+ let stopped = false;
1765
+ const columns = () => {
1766
+ const now = stream.getWindowSize?.()[0] ?? stream.columns;
1767
+ return now === undefined || now === 0 ? 80 : now;
1768
+ };
1769
+ const clear = () => {
1770
+ if (drawn)
1771
+ write(CLEAR_BELOW);
1772
+ drawn = false;
1773
+ };
1774
+ const draw = () => {
1775
+ if (paused)
1776
+ return;
1777
+ const width = columns() - 1;
1778
+ const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
1779
+ const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
1780
+ if (lines.length === 0) {
1781
+ clear();
1782
+ return;
1783
+ }
1784
+ write(`${CLEAR_BELOW}${lines.join(`
1785
+ `)}${lines.length > 1 ? `\x1B[${lines.length - 1}A` : ""}\r`);
1786
+ drawn = true;
1787
+ };
1788
+ let timer = setInterval(draw, FRAME_MS);
1789
+ stream.on?.("resize", draw);
1790
+ let restore = interceptOutput(clear);
1791
+ let release = swallowInput();
1013
1792
  const onExit = () => {
1014
1793
  clear();
1015
1794
  release();
1016
1795
  };
1017
1796
  const signals = holdSignals(stop);
1018
1797
  function stop() {
1798
+ stopped = true;
1019
1799
  clearInterval(timer);
1020
1800
  stream.off?.("resize", draw);
1021
1801
  clear();
@@ -1024,6 +1804,29 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
1024
1804
  process12.off("exit", onExit);
1025
1805
  signals.release();
1026
1806
  }
1807
+ function pause() {
1808
+ if (paused || stopped)
1809
+ return () => {
1810
+ return;
1811
+ };
1812
+ paused = true;
1813
+ clearInterval(timer);
1814
+ stream.off?.("resize", draw);
1815
+ clear();
1816
+ restore();
1817
+ release();
1818
+ return () => {
1819
+ if (!paused || stopped)
1820
+ return;
1821
+ paused = false;
1822
+ timer = setInterval(draw, FRAME_MS);
1823
+ timer.unref();
1824
+ stream.on?.("resize", draw);
1825
+ restore = interceptOutput(clear);
1826
+ release = swallowInput();
1827
+ draw();
1828
+ };
1829
+ }
1027
1830
  timer.unref();
1028
1831
  process12.on("exit", onExit);
1029
1832
  return {
@@ -1034,7 +1837,8 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
1034
1837
  `);
1035
1838
  draw();
1036
1839
  },
1037
- stop
1840
+ stop,
1841
+ pause
1038
1842
  };
1039
1843
  }
1040
1844
  function progressLine(stream = process12.stderr, env = process12.env) {
@@ -1059,6 +1863,7 @@ function progressLine(stream = process12.stderr, env = process12.env) {
1059
1863
  }
1060
1864
  },
1061
1865
  stop: region.stop,
1866
+ pause: region.pause,
1062
1867
  done: (text) => end(marked("ok", text, stream, formatDuration(performance.now() - begun), env)),
1063
1868
  failed: (text) => end(marked("problem", text, stream, undefined, env))
1064
1869
  };
@@ -1140,716 +1945,550 @@ function interceptOutput(clear) {
1140
1945
  Reflect.set(target, name, wrapper);
1141
1946
  return { target, name, original, wrapper };
1142
1947
  });
1143
- return () => {
1144
- for (const { target, name, original, wrapper } of wrapped) {
1145
- if (Reflect.get(target, name) === wrapper)
1146
- Reflect.set(target, name, original);
1948
+ return () => {
1949
+ for (const { target, name, original, wrapper } of wrapped) {
1950
+ if (Reflect.get(target, name) === wrapper)
1951
+ Reflect.set(target, name, original);
1952
+ }
1953
+ };
1954
+ }
1955
+
1956
+ // ../kit/src/ci.ts
1957
+ init_style();
1958
+
1959
+ // ../kit/src/tool.ts
1960
+ init_format();
1961
+ // ../kit/src/cli.ts
1962
+ init_args();
1963
+ import { readFileSync as readFileSync6, realpathSync as realpathSync2 } from "fs";
1964
+ import { dirname as dirname4, join as join8 } from "path";
1965
+ import process19 from "process";
1966
+
1967
+ // ../kit/src/askpass.ts
1968
+ import { chmodSync, mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
1969
+ import { tmpdir } from "os";
1970
+ import { join as join6 } from "path";
1971
+ import process16 from "process";
1972
+ var SOCKET_VARIABLE = "KAYNOOO_ASKPASS_SOCKET";
1973
+ var ECHOED = /username|yes\/no/i;
1974
+ var quoted = (text) => `'${text.replaceAll("'", `'\\''`)}'`;
1975
+ function askpass(pause = () => () => {
1976
+ return;
1977
+ }) {
1978
+ if (process16.stdin.isTTY !== true || process16.stderr.isTTY !== true || process16.argv[1] === undefined)
1979
+ return;
1980
+ const dir = mkdtempSync(join6(tmpdir(), "kaynooo-askpass-"));
1981
+ const socketPath = join6(dir, "socket");
1982
+ const script = join6(dir, "askpass");
1983
+ let turn = Promise.resolve();
1984
+ const answer = async ({ prompt, notice }) => {
1985
+ const resume = pause();
1986
+ try {
1987
+ if (notice === true) {
1988
+ process16.stderr.write(`${prompt.trim()}
1989
+ `);
1990
+ return {};
1991
+ }
1992
+ await Promise.resolve().then(() => init_prompt());
1993
+ return { answer: await input2(prompt.trim(), { mask: !ECHOED.test(prompt) }) };
1994
+ } finally {
1995
+ resume();
1996
+ }
1997
+ };
1998
+ const respond = async (socket, request) => {
1999
+ const { promise, resolve } = Promise.withResolvers();
2000
+ const previous = turn;
2001
+ let reply = {};
2002
+ turn = promise;
2003
+ await previous;
2004
+ try {
2005
+ reply = await answer(request);
2006
+ } catch {} finally {
2007
+ socket.end(`${JSON.stringify(reply)}
2008
+ `);
2009
+ resolve();
2010
+ }
2011
+ };
2012
+ const server = Bun.listen({
2013
+ unix: socketPath,
2014
+ socket: {
2015
+ open: (socket) => {
2016
+ socket.data = { buffered: "" };
2017
+ },
2018
+ data: (socket, chunk) => {
2019
+ const before = socket.data.buffered;
2020
+ socket.data.buffered += chunk.toString();
2021
+ if (before.includes(`
2022
+ `) || !socket.data.buffered.includes(`
2023
+ `))
2024
+ return;
2025
+ respond(socket, JSON.parse(socket.data.buffered));
2026
+ }
2027
+ }
2028
+ });
2029
+ writeFileSync2(script, `#!/bin/sh
2030
+ ${SOCKET_VARIABLE}=${quoted(socketPath)} exec ${quoted(process16.execPath)} --no-env-file --config=/dev/null ${quoted(process16.argv[1])} "$@"
2031
+ `);
2032
+ chmodSync(script, 448);
2033
+ return {
2034
+ env: { GIT_ASKPASS: script, SSH_ASKPASS: script, SSH_ASKPASS_REQUIRE: "force" },
2035
+ close: () => {
2036
+ server.stop(true);
2037
+ rmSync(dir, { recursive: true, force: true });
1147
2038
  }
1148
2039
  };
1149
2040
  }
1150
- // ../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";
2041
+ async function askpassClient(argv) {
2042
+ const socketPath = process16.env[SOCKET_VARIABLE];
2043
+ if (socketPath === undefined)
2044
+ return;
2045
+ const request = { prompt: argv[0] ?? "", ...process16.env.SSH_ASKPASS_PROMPT === "none" ? { notice: true } : {} };
2046
+ const { promise, resolve } = Promise.withResolvers();
2047
+ let received = "";
2048
+ try {
2049
+ await Bun.connect({
2050
+ unix: socketPath,
2051
+ socket: {
2052
+ open: (socket) => void socket.write(`${JSON.stringify(request)}
2053
+ `),
2054
+ data: (_, chunk) => {
2055
+ received += chunk.toString();
2056
+ },
2057
+ close: () => resolve(received),
2058
+ error: () => resolve("")
2059
+ }
2060
+ });
2061
+ } catch {
2062
+ return 1;
2063
+ }
2064
+ const reply = await promise;
2065
+ if (reply === "")
2066
+ return 1;
2067
+ const { answer } = JSON.parse(reply);
2068
+ if (request.notice === true)
2069
+ return 0;
2070
+ if (answer === undefined)
2071
+ return 1;
2072
+ process16.stdout.write(`${answer}
2073
+ `);
2074
+ return 0;
2075
+ }
2076
+
2077
+ // ../kit/src/completions.ts
2078
+ var COMPLETION_SHELLS = ["fish", "bash", "zsh"];
2079
+ 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'
2080
+ set -l tokens (commandline -xpc 2>/dev/null; or commandline -opc)
2081
+ set -l current (commandline -ct)
2082
+ for line in ($bin __complete $tokens[2..-1] $current 2>/dev/null)
2083
+ if test "$line" = __files__
2084
+ __fish_complete_path $current
2085
+ else
2086
+ echo $line
2087
+ end
2088
+ end
2089
+ end`;
2090
+ var BASH_FUNCTION = `__kaynooo_cli_complete() {
2091
+ local IFS=$'\\n' cur=\${COMP_WORDS[COMP_CWORD]} line words=
2092
+ local -a lines
2093
+ COMPREPLY=()
2094
+ lines=($("\${COMP_WORDS[0]}" __complete "\${COMP_WORDS[@]:1:COMP_CWORD}" 2>/dev/null))
2095
+ for line in "\${lines[@]}"; do
2096
+ if [[ $line == __files__ ]]; then
2097
+ COMPREPLY+=($(compgen -f -- "$cur"))
2098
+ else
2099
+ words+="\${line%%$'\\t'*}"$'\\n'
2100
+ fi
2101
+ done
2102
+ COMPREPLY+=($(compgen -W "$words" -- "$cur"))
2103
+ }`;
2104
+ var ZSH_FUNCTION = `__kaynooo_cli_complete() {
2105
+ local line
2106
+ local -a described plain
2107
+ for line in \${(f)"$("\${words[1]}" __complete "\${(@)words[2,CURRENT]}" 2>/dev/null)"}; do
2108
+ if [[ $line == __files__ ]]; then
2109
+ _files
2110
+ elif [[ $line == *$'\\t'* ]]; then
2111
+ described+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}")
2112
+ else
2113
+ plain+=("$line")
2114
+ fi
2115
+ done
2116
+ (( \${#described} )) && _describe -V value described
2117
+ (( \${#plain} )) && compadd -- "\${plain[@]}"
2118
+ return 0
2119
+ }`;
2120
+ function completionScript(shell, bins, header = `# Generated by \`${bins[0]} --completions ${shell}\``) {
2121
+ if (shell === "fish")
2122
+ return `${header}
2123
+ ${FISH_FUNCTION}
2124
+ ${bins.map((bin) => `complete -c ${bin} -f -a '(__kaynooo_cli_complete ${bin})'
2125
+ `).join("")}`;
2126
+ if (shell === "bash")
2127
+ return `${header}
2128
+ ${BASH_FUNCTION}
2129
+ complete -F __kaynooo_cli_complete ${bins.join(" ")}
2130
+ `;
2131
+ return `${header}
2132
+ ${ZSH_FUNCTION}
2133
+ compdef __kaynooo_cli_complete ${bins.join(" ")}
2134
+ `;
2135
+ }
1154
2136
 
1155
2137
  // ../kit/src/notify.ts
1156
- import process13 from "process";
2138
+ init_format();
2139
+ init_mode();
2140
+ import process17 from "process";
1157
2141
  var NOTIFY_AFTER_MS = 1e4;
1158
2142
  var CANCELLED = 130;
1159
2143
  function base64(text) {
1160
2144
  return Buffer.from(text).toString("base64");
1161
2145
  }
1162
- function notification(title, body, env = process13.env) {
1163
- const id = `kit${process13.pid}`;
2146
+ function notification(title, body, env = process17.env) {
2147
+ const id = `kit${process17.pid}`;
1164
2148
  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
2149
  return codes.map((code) => env.TMUX === undefined || env.TMUX === "" ? code : `\x1BPtmux;${code.replaceAll("\x1B", "\x1B\x1B")}\x1B\\`).join("");
1166
2150
  }
1167
- function notifyEnd(command, code, ms, { stream = process13.stderr, env = process13.env } = {}) {
2151
+ function notifyEnd(command, code, ms, { stream = process17.stderr, env = process17.env } = {}) {
1168
2152
  if (ms < NOTIFY_AFTER_MS || code === CANCELLED || outputMode(stream, env) !== "terminal")
1169
2153
  return;
1170
2154
  stream.write(notification(command, code === 0 ? `done in ${formatDuration(ms)}` : `failed with exit ${code} after ${formatDuration(ms)}`, env));
1171
2155
  }
1172
2156
 
2157
+ // ../kit/src/cli.ts
2158
+ init_style();
2159
+ init_text2();
2160
+
1173
2161
  // ../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";
2162
+ import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
2163
+ import { homedir as homedir4 } from "os";
2164
+ import { dirname as dirname3, join as join7 } from "path";
2165
+ import process18 from "process";
1178
2166
 
1179
2167
  // ../kit/src/logs.ts
2168
+ init_user_config();
1180
2169
  var DAY_MS = 24 * 60 * 60 * 1000;
1181
2170
  var CLI_FOLDER = "kaynooo-cli";
1182
2171
 
1183
2172
  // ../kit/src/usage.ts
2173
+ init_user_config();
1184
2174
  var UNKNOWN_OPTION2 = /unknown option '(--[a-z][a-z0-9-]*)[=']/;
1185
2175
  var FLAG_NAME = /^(?:--[a-z][a-z0-9-]*|-[a-zA-Z])$/;
1186
- var LONGEST_NAME = 40;
1187
- var usageError;
1188
- function noteUsageError(message) {
1189
- usageError = message;
1190
- }
1191
- function stateHome(env = process14.env) {
1192
- const dir = env.XDG_STATE_HOME;
1193
- return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
1194
- }
1195
- function usagePath(env = process14.env) {
1196
- return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
1197
- }
1198
- function usageRecorded(env = process14.env) {
1199
- const off = env.KAYNOOO_CLI_NO_USAGE;
1200
- return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
1201
- }
1202
- function flagNames(argv) {
1203
- const end = argv.indexOf("--");
1204
- 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
- return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
1206
- }
1207
- function usageEntry(bin, command, argv, code, now = new Date) {
1208
- const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
1209
- usageError = undefined;
1210
- return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
1211
- }
1212
- function recordUsage(entry, env = process14.env) {
1213
- if (!usageRecorded(env))
1214
- return;
1215
- try {
1216
- const path = usagePath(env);
1217
- mkdirSync(dirname2(path), { recursive: true, mode: 448 });
1218
- appendFileSync(path, `${JSON.stringify(entry)}
1219
- `, { mode: 384 });
1220
- } catch {}
1221
- }
1222
-
1223
- // ../kit/src/cli.ts
1224
- var LEVEL_OPTIONS = {
1225
- ...OUTPUT_OPTIONS,
1226
- help: { type: "boolean", short: "h", description: "show this help" }
1227
- };
1228
- var TOP_OPTIONS = { ...LEVEL_OPTIONS, version: { type: "boolean", short: "v", description: "print the version" } };
1229
- function printError(prefix, message, hint, cause) {
1230
- const colors = paint(process15.stderr);
1231
- const styled = takesControlCodes(process15.stderr);
1232
- const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
1233
- const under = (label, text, tint) => text === undefined ? "" : `
1234
- ${styled ? tint(label) : `${label}:`} ${text}`;
1235
- console.error(`${head} ${message}${under("cause", cause, colors.dim)}${under("hint", hint, colors.yellow)}`);
1236
- }
1237
- function runHint(command, effect) {
1238
- return `run \`${command}\`${effect === undefined ? "" : ` to ${effect}`}`;
1239
- }
1240
- function printJsonError(message, hint, cause) {
1241
- console.error(JSON.stringify({ error: message, ...hint === undefined ? {} : { hint }, ...cause === undefined ? {} : { cause } }));
1242
- }
1243
- function wantsJson(argv) {
1244
- const end = argv.indexOf("--");
1245
- return (end === -1 ? argv : argv.slice(0, end)).includes("--json");
1246
- }
1247
- function reportThrown(prefix, error, redact = (text) => text, json = false) {
1248
- if (error instanceof HelpShown)
1249
- return 0;
1250
- const help = error instanceof UsageError ? `run ${prefix} --help for its options` : undefined;
1251
- const named = error instanceof Error && !(error instanceof Exit) && error.name !== "Error" ? `${error.name}: ${error.message}` : undefined;
1252
- const cause = error instanceof Error && error.cause instanceof Error ? redact(error.cause.message) : undefined;
1253
- if (error instanceof Exit && error.code === 2)
1254
- noteUsageError(error.message);
1255
- const report = json ? printJsonError : (message, hint, causeText) => printError(prefix, message, hint, causeText);
1256
- report(redact(named ?? (error instanceof Error ? error.message : String(error))), error instanceof Exit ? error.hint ?? help : undefined, cause);
1257
- return error instanceof Exit ? error.code : 1;
1258
- }
1259
- var COMPLETE = "__complete";
1260
- var FILES = "__files__";
1261
- async function completingOf(run) {
1262
- completion.active = true;
1263
- try {
1264
- await run([]);
1265
- } catch (error) {
1266
- if (error instanceof Completing)
1267
- return error;
1268
- } finally {
1269
- completion.active = false;
1270
- }
1271
- return new Completing({});
1272
- }
1273
- function candidateLine(candidate) {
1274
- return typeof candidate === "string" ? candidate : candidate.join("\t");
1275
- }
1276
- function positionalBeingTyped(before, { options, positionals }) {
1277
- const takesValue = (word) => !word.includes("=") && Object.entries(options).some(([name, { short, type }]) => type === "string" && (word === `--${name}` || word === `-${short}`));
1278
- const typed = [];
1279
- let at = 0;
1280
- while (at < before.length) {
1281
- const word = before[at];
1282
- if (word === "--") {
1283
- typed.push(...before.slice(at + 1));
1284
- break;
1285
- }
1286
- if (!word.startsWith("-"))
1287
- typed.push(word);
1288
- else if (takesValue(word))
1289
- at++;
1290
- at++;
1291
- }
1292
- const last = positionals.at(-1);
1293
- if (typed.length < positionals.length)
1294
- return { name: positionals[typed.length], typed };
1295
- return { name: last?.replace("]", "").endsWith("...") === true ? last : undefined, typed };
1296
- }
1297
- async function leafCandidates(run, words) {
1298
- const completing = await completingOf(run);
1299
- if ((words.at(-1) ?? "").startsWith("-"))
1300
- return Object.entries(completing.options).map(([name, option]) => option.description === undefined ? `--${name}` : `--${name} ${option.description}`);
1301
- const flag = words.at(-2);
1302
- const option = flag?.startsWith("-") === true ? Object.entries(completing.options).find(([name, { short }]) => flag === `--${name}` || flag === `-${short}`)?.[1] : undefined;
1303
- const { name, typed } = positionalBeingTyped(words.slice(0, -1), completing);
1304
- if (option?.type === "string") {
1305
- const values = option.choices === undefined ? await option.candidates?.(typed) : option.choices;
1306
- return values === undefined ? [FILES] : values.map(candidateLine);
1307
- }
1308
- const values = name === undefined ? undefined : await completing.candidates[name]?.(typed);
1309
- return values === undefined ? [FILES] : values.map(candidateLine);
1310
- }
1311
- async function printCandidates(found) {
1312
- for (const line of await found)
1313
- console.log(line);
1314
- return 0;
1315
- }
1316
- function packageVersion(entry = Bun.main) {
1317
- let resolved = entry;
1318
- try {
1319
- resolved = realpathSync2(entry);
1320
- } catch {}
1321
- for (let dir = dirname3(resolved);; dir = dirname3(dir)) {
1322
- try {
1323
- const { version } = JSON.parse(readFileSync4(join5(dir, "package.json"), "utf8"));
1324
- if (typeof version === "string")
1325
- return version;
1326
- } catch {}
1327
- if (dirname3(dir) === dir)
1328
- return "0.0.0";
1329
- }
1330
- }
1331
- async function runMain({ name, version, run, redact, usage }, argv = scriptArgs()) {
1332
- if (argv[0] === COMPLETE)
1333
- return printCandidates(leafCandidates(run, argv.slice(1)));
1334
- if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
1335
- console.log(version ?? packageVersion());
1336
- return 0;
1337
- }
1338
- let code;
1339
- const started = performance.now();
1340
- try {
1341
- code = await run(argv);
1342
- } catch (error) {
1343
- code = reportThrown(name, error, redact, wantsJson(argv));
1344
- }
1345
- notifyEnd(name, code, performance.now() - started);
1346
- if (usage !== false) {
1347
- try {
1348
- recordUsage(usageEntry(name, undefined, argv, code));
1349
- } catch {}
1350
- }
1351
- return code;
1352
- }
1353
- // ../kit/src/folders.ts
1354
- var SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
1355
- // ../kit/src/secrets.ts
1356
- var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
1357
- // ../kit/src/sessions.ts
1358
- var {Glob } = globalThis.Bun;
1359
- var SESSION_FILES = new Glob("*.json");
1360
- var ACCOUNT_DIRS = new Glob("*/sessions");
1361
- // ../kit/src/watch.ts
1362
- import process16 from "process";
1363
- import { format } from "util";
1364
- var CLEAR_SCREEN = "\x1B[H\x1B[2J";
1365
- var DEFAULT_SECONDS = 2;
1366
- var ATTACHED_SHORT = /^-w./;
1367
- var INTERVAL = /^\d+(?:\.\d+)?(?:ms|[smh])?$/;
1368
- function watchOption(what) {
1369
- return { type: "string", short: "w", optional: { bare: "", accepts: INTERVAL }, description: `redraw ${what} every 2s, or every interval given (500ms, 5s), until ctrl-c` };
1370
- }
1371
- function withoutWatch(args) {
1372
- const rest = [];
1373
- for (let at = 0;at < args.length; at++) {
1374
- const arg = args[at];
1375
- if (arg === "--watch" || arg === "-w") {
1376
- if (args[at + 1] !== undefined && INTERVAL.test(args[at + 1]))
1377
- at++;
1378
- } else if (!arg.startsWith("--watch=") && !ATTACHED_SHORT.test(arg)) {
1379
- rest.push(arg);
1380
- }
1381
- }
1382
- return rest;
1383
- }
1384
- async function watching(value, step, stream = process16.stdout, sleep = Bun.sleep, rounds = Number.POSITIVE_INFINITY) {
1385
- const interval = value === "" ? DEFAULT_SECONDS * 1000 : duration(value, "watch", DEFAULT_SECONDS * 1000);
1386
- if (!takesControlCodes(stream))
1387
- badUsage("--watch redraws the screen, so it needs a terminal");
1388
- let code = 0;
1389
- for (let round = 0;round < rounds; round++) {
1390
- const held = [];
1391
- const { log, info } = console;
1392
- const write = process16.stdout.write.bind(process16.stdout);
1393
- const hold = (...parts) => void held.push(`${format(...parts)}
1394
- `);
1395
- console.log = hold;
1396
- console.info = hold;
1397
- process16.stdout.write = (text) => {
1398
- held.push(typeof text === "string" ? text : Buffer.from(text).toString());
1399
- return true;
1400
- };
1401
- try {
1402
- code = await step();
1403
- } finally {
1404
- console.log = log;
1405
- console.info = info;
1406
- process16.stdout.write = write;
1407
- }
1408
- stream.write(`${CLEAR_SCREEN}${held.join("")}`);
1409
- await sleep(interval);
1410
- }
1411
- return code;
1412
- }
1413
- // ../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";
1417
- function expandHome(path, home) {
1418
- if (path === "~")
1419
- return home;
1420
- return path.startsWith("~/") ? join6(home, path.slice(2)) : path;
1421
- }
1422
- function configured(env, home) {
1423
- const folder = readUserConfig("config", { home, xdg: env.XDG_CONFIG_HOME }).workspace;
1424
- return typeof folder === "string" && folder !== "" ? folder : undefined;
1425
- }
1426
- function workspaceRoot({ given, env = process17.env, home = homedir4() } = {}) {
1427
- const fromEnv = env.KAYNOOO_WORKSPACE === "" ? undefined : env.KAYNOOO_WORKSPACE;
1428
- return resolve4(expandHome(given ?? fromEnv ?? configured(env, home) ?? join6(home, "Workspace"), home));
1429
- }
1430
- // src/branch.ts
1431
- import { basename } from "path";
1432
- import process22 from "process";
1433
-
1434
- // ../kit/src/picker/line.ts
1435
- var EDIT_KEYS = new Set(["left", "right", "wordleft", "wordright", "linestart", "lineend", "erase", "delete", "word", "killword", "killnext", "clear", "killend", "yank"]);
1436
- var BACKWARD_KILLS = new Set(["word", "killword", "clear"]);
1437
- var FORWARD_KILLS = new Set(["killnext", "killend"]);
1438
- function isEditKey(key) {
1439
- return EDIT_KEYS.has(key);
1440
- }
1441
- function endsKills(key) {
1442
- return typeof key !== "object" && !isEditKey(key);
2176
+ var LONGEST_NAME = 40;
2177
+ var usageError;
2178
+ function noteUsageError(message) {
2179
+ usageError = message;
1443
2180
  }
1444
- var WORD_CHARACTER = /[\p{L}\p{N}_]/u;
1445
- var SPACE = /\s/;
1446
- function isWord(char) {
1447
- return char !== undefined && WORD_CHARACTER.test(char);
2181
+ function stateHome(env = process18.env) {
2182
+ return xdgFolder(env.XDG_STATE_HOME, join7(homedir4(), ".local", "state"));
1448
2183
  }
1449
- function wordStart(chars, from) {
1450
- let at = from;
1451
- while (at > 0 && !isWord(chars[at - 1]))
1452
- at--;
1453
- while (at > 0 && isWord(chars[at - 1]))
1454
- at--;
1455
- return at;
2184
+ function usagePath(env = process18.env) {
2185
+ return join7(stateHome(env), CLI_FOLDER, "usage.jsonl");
1456
2186
  }
1457
- function wordEnd(chars, from) {
1458
- let at = from;
1459
- while (at < chars.length && !isWord(chars[at]))
1460
- at++;
1461
- while (at < chars.length && isWord(chars[at]))
1462
- at++;
1463
- return at;
2187
+ function usageRecorded(env = process18.env) {
2188
+ const off = env.KAYNOOO_CLI_NO_USAGE;
2189
+ return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
1464
2190
  }
1465
- function spacedStart(chars, from) {
1466
- let at = from;
1467
- while (at > 0 && SPACE.test(chars[at - 1] ?? ""))
1468
- at--;
1469
- while (at > 0 && !SPACE.test(chars[at - 1] ?? ""))
1470
- at--;
1471
- return at;
2191
+ function flagNames(argv) {
2192
+ const end = argv.indexOf("--");
2193
+ const names = (end === -1 ? argv : argv.slice(0, end)).filter((word) => word.startsWith("-") && word !== "-").map((word) => word.includes("=") ? word.slice(0, word.indexOf("=")) : word);
2194
+ return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
1472
2195
  }
1473
- function cut(chars, from, to) {
1474
- return { text: [...chars.slice(0, from), ...chars.slice(to)].join(""), caret: from };
2196
+ function usageEntry(bin, command, argv, code, { ms, now = new Date } = {}) {
2197
+ const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
2198
+ usageError = undefined;
2199
+ return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown }, ...ms === undefined ? {} : { ms: Math.round(ms) } };
1475
2200
  }
1476
- function insert(chars, at, text) {
1477
- const typed = [...text];
1478
- return { text: [...chars.slice(0, at), ...typed, ...chars.slice(at)].join(""), caret: at + typed.length };
2201
+ function recordUsage(entry, env = process18.env) {
2202
+ if (!usageRecorded(env))
2203
+ return;
2204
+ try {
2205
+ const path = usagePath(env);
2206
+ mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
2207
+ appendFileSync(path, `${JSON.stringify(entry)}
2208
+ `, { mode: 384 });
2209
+ } catch {}
1479
2210
  }
1480
- function editLine(line, key) {
1481
- const { killed = "", chained = false } = line;
1482
- const chars = [...line.text];
1483
- const at = Math.min(Math.max(line.caret, 0), chars.length);
1484
- const edited = edit(chars, at, key, killed);
1485
- if (typeof key === "object" || !BACKWARD_KILLS.has(key) && !FORWARD_KILLS.has(key))
1486
- return line.killed === undefined ? edited : { ...edited, killed };
1487
- const taken = chars.slice(edited.caret, edited.caret + chars.length - [...edited.text].length).join("");
1488
- if (taken === "")
1489
- return { ...edited, killed, chained };
1490
- if (!chained)
1491
- return { ...edited, killed: taken, chained: true };
1492
- return { ...edited, killed: BACKWARD_KILLS.has(key) ? taken + killed : killed + taken, chained: true };
2211
+
2212
+ // ../kit/src/cli.ts
2213
+ var LEVEL_OPTIONS = {
2214
+ ...OUTPUT_OPTIONS,
2215
+ help: { type: "boolean", short: "h", description: "show this help" }
2216
+ };
2217
+ var TOP_OPTIONS = {
2218
+ ...LEVEL_OPTIONS,
2219
+ version: { type: "boolean", short: "v", description: "print the version" },
2220
+ completions: { type: "string", choices: COMPLETION_SHELLS, description: "print the shell completion script" }
2221
+ };
2222
+ function printError(prefix, message, hint, cause) {
2223
+ const colors = paint(process19.stderr);
2224
+ const styled = takesControlCodes(process19.stderr);
2225
+ const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
2226
+ const under = (label, text, tint) => text === undefined ? "" : `
2227
+ ${styled ? tint(label) : `${label}:`} ${text}`;
2228
+ console.error(`${head} ${message}${under("cause", cause, colors.dim)}${under("hint", hint, colors.yellow)}`);
1493
2229
  }
1494
- function edit(chars, at, key, killed) {
1495
- const text = chars.join("");
1496
- if (typeof key === "object")
1497
- return insert(chars, at, key.text);
1498
- switch (key) {
1499
- case "left":
1500
- return { text, caret: Math.max(at - 1, 0) };
1501
- case "right":
1502
- return { text, caret: Math.min(at + 1, chars.length) };
1503
- case "wordleft":
1504
- return { text, caret: wordStart(chars, at) };
1505
- case "wordright":
1506
- return { text, caret: wordEnd(chars, at) };
1507
- case "linestart":
1508
- return { text, caret: 0 };
1509
- case "lineend":
1510
- return { text, caret: chars.length };
1511
- case "erase":
1512
- return cut(chars, Math.max(at - 1, 0), at);
1513
- case "delete":
1514
- return cut(chars, at, Math.min(at + 1, chars.length));
1515
- case "word":
1516
- return cut(chars, spacedStart(chars, at), at);
1517
- case "killword":
1518
- return cut(chars, wordStart(chars, at), at);
1519
- case "killnext":
1520
- return cut(chars, at, wordEnd(chars, at));
1521
- case "clear":
1522
- return cut(chars, 0, at);
1523
- case "killend":
1524
- return cut(chars, at, chars.length);
1525
- case "yank":
1526
- return insert(chars, at, killed);
1527
- }
2230
+ function runHint(command, effect) {
2231
+ return `run \`${command}\`${effect === undefined ? "" : ` to ${effect}`}`;
1528
2232
  }
1529
- function visible({ text, caret }, room) {
1530
- const chars = [...text];
1531
- const at = Math.min(Math.max(caret, 0), chars.length);
1532
- const cells = at === chars.length ? [...chars, " "] : chars;
1533
- const widths = cells.map((char) => Bun.stringWidth(char));
1534
- const width = (from, to) => widths.slice(from, to).reduce((sum, size) => sum + size, 0);
1535
- const fits = (from, to) => (from > 0 ? 1 : 0) + width(from, to) + (to < cells.length ? 1 : 0) <= room;
1536
- let start = at;
1537
- let end = at + 1;
1538
- while (start > 0 && fits(start - 1, end))
1539
- start--;
1540
- while (end < cells.length && fits(start, end + 1))
1541
- end++;
1542
- const left = start > 0 ? "\u2026" : "";
1543
- const right = end < cells.length ? "\u2026" : "";
1544
- 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) };
2233
+ function printJsonError(message, hint, cause) {
2234
+ console.error(JSON.stringify({ error: message, ...hint === undefined ? {} : { hint }, ...cause === undefined ? {} : { cause } }));
1545
2235
  }
1546
-
1547
- // ../kit/src/picker/score.ts
1548
- var MATCH = 16;
1549
- var CONSECUTIVE = 12;
1550
- var BOUNDARY = 10;
1551
- var PREFIX = 8;
1552
- var GAP = 1;
1553
- var BOUNDARY_AFTER = new Set([" ", "/", "-", "_", ".", ":", "\\", "(", "[", ",", "\t"]);
1554
- var UPPER = /\p{Lu}/u;
1555
- var LOWER = /\p{Ll}/u;
1556
- var NONE = Number.NEGATIVE_INFINITY;
1557
- function startsWord(text, index) {
1558
- if (index === 0)
1559
- return true;
1560
- const before = text[index - 1];
1561
- return BOUNDARY_AFTER.has(before) || LOWER.test(before) && UPPER.test(text[index]);
2236
+ function wantsJson(argv) {
2237
+ const end = argv.indexOf("--");
2238
+ return (end === -1 ? argv : argv.slice(0, end)).includes("--json");
1562
2239
  }
1563
- function fuzzy(query, text) {
1564
- if (query === "")
1565
- return { score: 0, positions: [] };
1566
- const exact = query !== query.toLowerCase();
1567
- const needle = exact ? query : query.toLowerCase();
1568
- const haystack = exact ? text : text.toLowerCase();
1569
- if (haystack.length !== text.length || needle.length > haystack.length)
1570
- return;
1571
- const width = haystack.length;
1572
- const best = Array.from({ length: needle.length }, () => new Array(width).fill(NONE));
1573
- const from = Array.from({ length: needle.length }, () => new Array(width).fill(-1));
1574
- for (let j = 0;j < needle.length; j++) {
1575
- let run = NONE;
1576
- let runAt = -1;
1577
- for (let i = j;i < width; i++) {
1578
- if (j > 0 && i - 2 >= j - 1) {
1579
- const candidate = best[j - 1][i - 2] + (i - 2) * GAP;
1580
- if (candidate > run) {
1581
- run = candidate;
1582
- runAt = i - 2;
1583
- }
1584
- }
1585
- if (haystack[i] !== needle[j])
1586
- continue;
1587
- const here = MATCH + (startsWord(text, i) ? BOUNDARY : 0) + (i === 0 ? PREFIX : 0);
1588
- if (j === 0) {
1589
- best[0][i] = here - i * GAP;
1590
- continue;
1591
- }
1592
- const joined = best[j - 1][i - 1] + CONSECUTIVE;
1593
- const skipped = run - (i - 1) * GAP;
1594
- if (joined > NONE && joined >= skipped) {
1595
- best[j][i] = joined + here;
1596
- from[j][i] = i - 1;
1597
- } else if (skipped > NONE) {
1598
- best[j][i] = skipped + here;
1599
- from[j][i] = runAt;
1600
- }
1601
- }
1602
- }
1603
- const last = best[needle.length - 1];
1604
- let end = -1;
1605
- for (let i = 0;i < width; i++) {
1606
- if (last[i] > NONE && (end === -1 || last[i] > last[end]))
1607
- end = i;
1608
- }
1609
- if (end === -1)
1610
- return;
1611
- const positions = [];
1612
- for (let j = needle.length - 1, i = end;j >= 0; j--) {
1613
- positions.unshift(i);
1614
- i = from[j][i];
1615
- }
1616
- return { score: last[end], positions };
2240
+ function reportThrown(prefix, error, redact = (text) => text, json = false) {
2241
+ if (error instanceof HelpShown)
2242
+ return 0;
2243
+ const help = error instanceof UsageError ? `run ${prefix} --help for its options` : undefined;
2244
+ const named = error instanceof Error && !(error instanceof Exit) && error.name !== "Error" ? `${error.name}: ${error.message}` : undefined;
2245
+ const cause = error instanceof Error && error.cause instanceof Error ? redact(error.cause.message) : undefined;
2246
+ if (error instanceof Exit && error.code === 2)
2247
+ noteUsageError(error.message);
2248
+ const report = json ? printJsonError : (message, hint, causeText) => printError(prefix, message, hint, causeText);
2249
+ report(redact(named ?? (error instanceof Error ? error.message : String(error))), error instanceof Exit ? error.hint ?? help : undefined, cause);
2250
+ return error instanceof Exit ? error.code : 1;
1617
2251
  }
1618
- function rank(query, lines) {
1619
- if (query === "")
1620
- return lines.map((_, index) => ({ index, positions: [] }));
1621
- const found = [];
1622
- for (const [index, line] of lines.entries()) {
1623
- const match = fuzzy(query, line);
1624
- if (match !== undefined)
1625
- found.push({ index, positions: match.positions, score: match.score });
2252
+ var COMPLETE = "__complete";
2253
+ var FILES = "__files__";
2254
+ async function completingOf(run) {
2255
+ completion.active = true;
2256
+ try {
2257
+ await run([]);
2258
+ } catch (error) {
2259
+ if (error instanceof Completing)
2260
+ return error;
2261
+ } finally {
2262
+ completion.active = false;
1626
2263
  }
1627
- return found.sort((a, b) => b.score - a.score || lines[a.index].length - lines[b.index].length || a.index - b.index);
2264
+ return new Completing({});
1628
2265
  }
1629
-
1630
- // ../kit/src/picker/state.ts
1631
- var CONTROL2 = /[\x00-\x1F\x7F-\x9F]/g;
1632
- var IS_CONTROL = /[\x00-\x1F\x7F-\x9F]/;
1633
- var SGR = /^\x1B\[[0-9;]*m$/;
1634
- var RESET = /^\x1B\[0?m$/;
1635
- var COLUMN_GAP = 2;
1636
- var PASTE_START = "\x1B[200~";
1637
- var PASTE_END = "\x1B[201~";
1638
- var KEY_SEQUENCES = /\x1B\[<[0-9;]*[A-Za-z]|\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|\x1B[\s\S]|[\s\S]/gu;
1639
- var MOUSE = /^\x1B\[<(\d+);\d+;\d+[a-z]$/i;
1640
- var WHEEL_LINES = 3;
1641
- var KEYS = {
1642
- "\x1B[A": "up",
1643
- "\x1BOA": "up",
1644
- "\x10": "up",
1645
- "\x1B[B": "down",
1646
- "\x1BOB": "down",
1647
- "\x0E": "down",
1648
- "\x1B[5~": "pageup",
1649
- "\x1B[6~": "pagedown",
1650
- "\x1B[H": "home",
1651
- "\x1B[1~": "home",
1652
- "\x1BOH": "home",
1653
- "\x1B[F": "end",
1654
- "\x1B[4~": "end",
1655
- "\x1BOF": "end",
1656
- "\r": "enter",
1657
- "\n": "enter",
1658
- "\x03": "cancel",
1659
- "\x1B": "cancel",
1660
- "\x1B[D": "left",
1661
- "\x1BOD": "left",
1662
- "\x1B[C": "right",
1663
- "\x1BOC": "right",
1664
- "\x1B[1;5D": "wordleft",
1665
- "\x1B[1;3D": "wordleft",
1666
- "\x1Bb": "wordleft",
1667
- "\x1B[1;5C": "wordright",
1668
- "\x1B[1;3C": "wordright",
1669
- "\x1Bf": "wordright",
1670
- "\x01": "linestart",
1671
- "\x05": "lineend",
1672
- "\x7F": "erase",
1673
- "\x1B[3~": "delete",
1674
- "\b": "killword",
1675
- "\x1B\x7F": "killword",
1676
- "\x1B[3;5~": "killnext",
1677
- "\x1Bd": "killnext",
1678
- "\x15": "clear",
1679
- "\v": "killend",
1680
- "\x17": "word",
1681
- "\x19": "yank",
1682
- "\x1A": "suspend",
1683
- "\t": "tab",
1684
- "\x1F": "help",
1685
- "\x1BOP": "help",
1686
- "\x1B[11~": "help"
1687
- };
1688
- var CTRL_KEY = /^ctrl-[abd-gkln-z]$/;
1689
- function repeat(value, count) {
1690
- return Array.from({ length: count }).fill(value);
2266
+ function candidateLine(candidate) {
2267
+ return typeof candidate === "string" ? candidate : candidate.join("\t");
1691
2268
  }
1692
- function styled(line) {
1693
- let text = "";
1694
- const styles = [];
1695
- let active = "";
1696
- let colored = false;
1697
- let last = 0;
1698
- function add(chunk) {
1699
- const flat = chunk.replace(CONTROL2, " ");
1700
- text += flat;
1701
- colored ||= active !== "" && flat !== "";
1702
- styles.push(...repeat(active, flat.length));
1703
- }
1704
- for (const found of line.matchAll(ANSI)) {
1705
- add(line.slice(last, found.index));
1706
- last = found.index + found[0].length;
1707
- if (SGR.test(found[0]))
1708
- active = RESET.test(found[0]) ? "" : active + found[0];
2269
+ function positionalBeingTyped(before, { options, positionals }) {
2270
+ const takesValue = (word) => !word.includes("=") && Object.entries(options).some(([name, { short, type }]) => type === "string" && (word === `--${name}` || word === `-${short}`));
2271
+ const typed = [];
2272
+ let at = 0;
2273
+ while (at < before.length) {
2274
+ const word = before[at];
2275
+ if (word === "--") {
2276
+ typed.push(...before.slice(at + 1));
2277
+ break;
2278
+ }
2279
+ if (!word.startsWith("-"))
2280
+ typed.push(word);
2281
+ else if (takesValue(word))
2282
+ at++;
2283
+ at++;
1709
2284
  }
1710
- add(line.slice(last));
1711
- return { text, styles: colored ? styles : undefined };
2285
+ const last = positionals.at(-1);
2286
+ if (typed.length < positionals.length)
2287
+ return { name: positionals[typed.length], typed };
2288
+ return { name: last?.replace("]", "").endsWith("...") === true ? last : undefined, typed };
1712
2289
  }
1713
- function lay(rows, searched) {
1714
- const parsed = rows.map((row) => row.cells.map(styled));
1715
- const widths = (parsed[0] ?? []).map((_, column) => Math.max(...parsed.map((cells) => Bun.stringWidth(cells[column]?.text ?? ""))));
1716
- return parsed.map((cells, at) => {
1717
- let text = "";
1718
- const styles = [];
1719
- let colored = false;
1720
- let searchEnd = 0;
1721
- for (const [column, cell] of cells.entries()) {
1722
- const last = column === cells.length - 1;
1723
- const shown = cells.length > 1 && last ? cell.text.trimEnd() : cell.text;
1724
- text += shown;
1725
- colored ||= cell.styles !== undefined;
1726
- styles.push(...cell.styles?.slice(0, shown.length) ?? repeat("", shown.length));
1727
- if (column < searched)
1728
- searchEnd = cells.length > 1 ? text.trimEnd().length : text.length;
1729
- if (!last) {
1730
- const pad = widths[column] - Bun.stringWidth(cell.text) + COLUMN_GAP;
1731
- text += " ".repeat(pad);
1732
- styles.push(...repeat("", pad));
1733
- }
1734
- }
1735
- return { text, styles: colored ? styles : undefined, searchable: rows[at].search ?? text.slice(0, searchEnd) };
1736
- });
2290
+ async function leafCandidates(run, words) {
2291
+ const completing = await completingOf(run);
2292
+ if ((words.at(-1) ?? "").startsWith("-"))
2293
+ return Object.entries(completing.options).map(([name, option]) => option.description === undefined ? `--${name}` : `--${name} ${option.description}`);
2294
+ const flag = words.at(-2);
2295
+ const option = flag?.startsWith("-") === true ? Object.entries(completing.options).find(([name, { short }]) => flag === `--${name}` || flag === `-${short}`)?.[1] : undefined;
2296
+ const { name, typed } = positionalBeingTyped(words.slice(0, -1), completing);
2297
+ if (option?.type === "string") {
2298
+ const values = option.choices === undefined ? await option.candidates?.(typed) : option.choices;
2299
+ return values === undefined ? [FILES] : values.map(candidateLine);
2300
+ }
2301
+ const values = name === undefined ? undefined : await completing.candidates[name]?.(typed);
2302
+ return values === undefined ? [FILES] : values.map(candidateLine);
1737
2303
  }
1738
- function parseKeys(input, paste = { active: false }, ctrls = []) {
1739
- const codes = new Map(ctrls.map((name) => [String.fromCharCode(name.codePointAt(name.length - 1) - 96), name]));
1740
- return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => {
1741
- const wheel = MOUSE.exec(sequence)?.[1];
1742
- if (wheel !== undefined)
1743
- return repeat(wheel === "64" ? "up" : "down", wheel === "64" || wheel === "65" ? WHEEL_LINES : 0);
1744
- const named = codes.get(sequence);
1745
- const key = named === undefined ? KEYS[sequence] : { ctrl: named };
1746
- if (sequence === PASTE_START || sequence === PASTE_END) {
1747
- paste.active = sequence === PASTE_START;
1748
- return [];
1749
- }
1750
- if (paste.active && (sequence === "\r" || sequence === `
1751
- `))
1752
- return [];
1753
- if (key !== undefined)
1754
- return [key];
1755
- return IS_CONTROL.test(sequence) || sequence.startsWith("\x1B") ? [] : [{ text: sequence }];
1756
- });
2304
+ var COMPLETIONS = "--completions";
2305
+ function flagValue([flag = "", ...rest]) {
2306
+ return flag.includes("=") ? [flag.slice(flag.indexOf("=") + 1), ...rest] : rest;
1757
2307
  }
1758
- function createState(rows, { multi = false, prompt = "> ", query = "", header = "", expect = [], searched = Number.POSITIVE_INFINITY } = {}) {
1759
- 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 };
1760
- return withRows(state, rows);
2308
+ function printCompletionScript(name, args) {
2309
+ const shell = COMPLETION_SHELLS.find((each) => each === args[0]);
2310
+ if (shell === undefined || args.length !== 1) {
2311
+ printError(name, `${COMPLETIONS} takes one of ${COMPLETION_SHELLS.join(", ")}`, `${name} ${COMPLETIONS} fish`);
2312
+ return 2;
2313
+ }
2314
+ console.log(completionScript(shell, [name]).trimEnd());
2315
+ return 0;
1761
2316
  }
1762
- function withRows(state, rows, header = state.header) {
1763
- const cells = rows.map((row) => typeof row === "string" ? { hidden: [], cells: [row] } : row);
1764
- const laid = lay(cells, state.searched);
1765
- const searchable = laid.map((row) => row.searchable);
1766
- const matches = rank(state.query, searchable);
1767
- 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 };
2317
+ async function printCandidates(found) {
2318
+ for (const line of await found)
2319
+ console.log(line);
2320
+ return 0;
1768
2321
  }
1769
- function withQuery(state, key) {
1770
- const { text, caret, killed = "", chained = false } = editLine({ text: state.query, caret: state.caret, killed: state.killed, chained: state.chained }, key);
1771
- return text === state.query ? { ...state, caret, killed, chained } : { ...state, query: text, caret, killed, chained, matches: rank(text, state.searchable), cursor: 0 };
2322
+ function packageVersion(entry = Bun.main) {
2323
+ let resolved = entry;
2324
+ try {
2325
+ resolved = realpathSync2(entry);
2326
+ } catch {}
2327
+ for (let dir = dirname4(resolved);; dir = dirname4(dir)) {
2328
+ try {
2329
+ const { version } = JSON.parse(readFileSync6(join8(dir, "package.json"), "utf8"));
2330
+ if (typeof version === "string")
2331
+ return version;
2332
+ } catch {}
2333
+ if (dirname4(dir) === dir)
2334
+ return "0.0.0";
2335
+ }
1772
2336
  }
1773
- function move(state, by) {
1774
- return { ...state, cursor: Math.max(0, Math.min(state.matches.length - 1, state.cursor + by)) };
2337
+ async function runMain({ name, version, run, redact, usage }, argv = scriptArgs()) {
2338
+ const answered = await askpassClient(argv);
2339
+ if (answered !== undefined)
2340
+ return answered;
2341
+ if (argv[0] === COMPLETE)
2342
+ return printCandidates(leafCandidates(run, argv.slice(1)));
2343
+ if (argv[0] === COMPLETIONS || argv[0]?.startsWith(`${COMPLETIONS}=`) === true)
2344
+ return printCompletionScript(name, flagValue(argv));
2345
+ if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
2346
+ console.log(version ?? packageVersion());
2347
+ return 0;
2348
+ }
2349
+ let code;
2350
+ const started = performance.now();
2351
+ try {
2352
+ code = await run(argv);
2353
+ } catch (error) {
2354
+ code = reportThrown(name, error, redact, wantsJson(argv));
2355
+ }
2356
+ notifyEnd(name, code, performance.now() - started);
2357
+ if (usage !== false) {
2358
+ try {
2359
+ recordUsage(usageEntry(name, undefined, argv, code, { ms: performance.now() - started }));
2360
+ } catch {}
2361
+ }
2362
+ return code;
1775
2363
  }
1776
- function highlighted(state) {
1777
- return state.matches[state.cursor]?.index;
2364
+
2365
+ // ../kit/src/index.ts
2366
+ init_config();
2367
+
2368
+ // ../kit/src/excerpt.ts
2369
+ init_text2();
2370
+
2371
+ // ../kit/src/index.ts
2372
+ init_folders();
2373
+ init_format();
2374
+
2375
+ // ../kit/src/git.ts
2376
+ init_args();
2377
+ // ../kit/src/limit.ts
2378
+ init_args();
2379
+
2380
+ // ../kit/src/index.ts
2381
+ init_mode();
2382
+
2383
+ // ../kit/src/report.ts
2384
+ init_style();
2385
+ init_text2();
2386
+ // ../kit/src/secrets.ts
2387
+ var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
2388
+ var NOT_PASSWORDS = new Set(["compass", "encompass", "bypass", "overpass", "underpass", "surpass", "trespass"]);
2389
+ // ../kit/src/sessions.ts
2390
+ var {Glob } = globalThis.Bun;
2391
+ var SESSION_FILES = new Glob("*.json");
2392
+ var ACCOUNT_DIRS = new Glob("*/sessions");
2393
+
2394
+ // ../kit/src/index.ts
2395
+ init_style();
2396
+ init_text2();
2397
+ init_theme();
2398
+ init_user_config();
2399
+
2400
+ // ../kit/src/watch.ts
2401
+ init_args();
2402
+ init_input();
2403
+ init_style();
2404
+ import process20 from "process";
2405
+ import { format } from "util";
2406
+ var CLEAR_SCREEN = "\x1B[H\x1B[2J";
2407
+ var DEFAULT_SECONDS = 2;
2408
+ var ATTACHED_SHORT = /^-w./;
2409
+ var INTERVAL = /^\d+(?:\.\d+)?(?:ms|[smh])?$/;
2410
+ function watchOption(what) {
2411
+ return { type: "string", short: "w", optional: { bare: "", accepts: INTERVAL }, description: `redraw ${what} every 2s, or every interval given (500ms, 5s), until ctrl-c` };
1778
2412
  }
1779
- function press(state, key) {
1780
- if (state.done !== undefined)
1781
- return state;
1782
- if (state.chained && endsKills(key))
1783
- state = { ...state, chained: false };
1784
- if (state.help)
1785
- return { ...state, help: false };
1786
- if (typeof key === "object") {
1787
- if ("text" in key)
1788
- return withQuery(state, key);
1789
- return state.expect.includes(key.ctrl) ? { ...state, done: "accept", key: key.ctrl } : state;
2413
+ function withoutWatch(args) {
2414
+ const rest = [];
2415
+ for (let at = 0;at < args.length; at++) {
2416
+ const arg = args[at];
2417
+ if (arg === "--watch" || arg === "-w") {
2418
+ if (args[at + 1] !== undefined && INTERVAL.test(args[at + 1]))
2419
+ at++;
2420
+ } else if (!arg.startsWith("--watch=") && !ATTACHED_SHORT.test(arg)) {
2421
+ rest.push(arg);
2422
+ }
1790
2423
  }
1791
- if (isEditKey(key))
1792
- return withQuery(state, key);
1793
- switch (key) {
1794
- case "up":
1795
- return move(state, -1);
1796
- case "down":
1797
- return move(state, 1);
1798
- case "pageup":
1799
- return move(state, -state.page);
1800
- case "pagedown":
1801
- return move(state, state.page);
1802
- case "home":
1803
- return move(state, -state.matches.length);
1804
- case "end":
1805
- return move(state, state.matches.length);
1806
- case "cancel":
1807
- return { ...state, done: "cancel" };
1808
- case "help":
1809
- return { ...state, help: true };
1810
- case "suspend":
1811
- return state;
1812
- case "enter":
1813
- return state.matches.length === 0 && state.marked.size === 0 ? state : { ...state, done: "accept" };
1814
- case "tab": {
1815
- const at = highlighted(state);
1816
- if (!state.multi || at === undefined)
1817
- return state;
1818
- const marked = new Set(state.marked);
1819
- if (!marked.delete(at))
1820
- marked.add(at);
1821
- return move({ ...state, marked }, 1);
2424
+ return rest;
2425
+ }
2426
+ async function watching(value, step, stream = process20.stdout, sleep = Bun.sleep, rounds = Number.POSITIVE_INFINITY) {
2427
+ const interval = value === "" ? DEFAULT_SECONDS * 1000 : duration(value, "watch", DEFAULT_SECONDS * 1000);
2428
+ if (!takesControlCodes(stream))
2429
+ badUsage("--watch redraws the screen, so it needs a terminal");
2430
+ let code = 0;
2431
+ for (let round = 0;round < rounds; round++) {
2432
+ const held = [];
2433
+ const { log, info } = console;
2434
+ const write = process20.stdout.write.bind(process20.stdout);
2435
+ const hold = (...parts) => void held.push(`${format(...parts)}
2436
+ `);
2437
+ console.log = hold;
2438
+ console.info = hold;
2439
+ process20.stdout.write = (text) => {
2440
+ held.push(typeof text === "string" ? text : Buffer.from(text).toString());
2441
+ return true;
2442
+ };
2443
+ try {
2444
+ code = await step();
2445
+ } finally {
2446
+ console.log = log;
2447
+ console.info = info;
2448
+ process20.stdout.write = write;
1822
2449
  }
2450
+ stream.write(`${CLEAR_SCREEN}${held.join("")}`);
2451
+ await sleep(interval);
1823
2452
  }
2453
+ return code;
1824
2454
  }
1825
- function chosen(state) {
1826
- if (state.marked.size > 0)
1827
- return state.rows.filter((_, index) => state.marked.has(index));
1828
- const at = highlighted(state);
1829
- return at === undefined ? [] : [state.rows[at]];
2455
+ // ../kit/src/workspace-root.ts
2456
+ init_user_config();
2457
+ import { homedir as homedir5 } from "os";
2458
+ import { dirname as dirname5, join as join9, resolve as resolve4 } from "path";
2459
+ import process21 from "process";
2460
+ function expandHome(path, home) {
2461
+ if (path === "~")
2462
+ return home;
2463
+ return path.startsWith("~/") ? join9(home, path.slice(2)) : path;
2464
+ }
2465
+ function configured(env, home) {
2466
+ const folder = readUserConfig("config", { home, xdg: env.XDG_CONFIG_HOME }).workspace;
2467
+ return typeof folder === "string" && folder !== "" ? folder : undefined;
2468
+ }
2469
+ function workspaceRoot({ given, env = process21.env, home = homedir5() } = {}) {
2470
+ const fromEnv = env.KAYNOOO_WORKSPACE === "" ? undefined : env.KAYNOOO_WORKSPACE;
2471
+ return resolve4(expandHome(given ?? fromEnv ?? configured(env, home) ?? join9(home, "Workspace"), home));
1830
2472
  }
2473
+ // src/branch.ts
2474
+ import { basename } from "path";
2475
+ import process25 from "process";
2476
+
2477
+ // ../kit/src/picker.ts
2478
+ init_folders();
2479
+ init_state();
1831
2480
 
1832
2481
  // ../kit/src/picker/terminal.ts
2482
+ init_args();
2483
+ init_job();
2484
+ init_redraw();
2485
+ init_style();
1833
2486
  import { openSync } from "fs";
1834
- import process21 from "process";
2487
+ import process24 from "process";
1835
2488
  import tty from "tty";
1836
2489
 
1837
- // ../kit/src/job.ts
1838
- import process19 from "process";
1839
- function stopJob() {
1840
- process19.kill(0, "SIGTSTP");
1841
- }
1842
-
1843
- // ../kit/src/redraw.ts
1844
- var SYNC_START = "\x1B[?2026h";
1845
- var SYNC_END = "\x1B[?2026l";
1846
- function overwrite(lines, columns) {
1847
- return lines.map((line) => textWidth(line) % columns === 0 ? `\x1B[2K${line}` : `${line}\x1B[K`).join(`
1848
- `);
1849
- }
1850
-
1851
2490
  // ../kit/src/picker/preview.ts
1852
- import process20 from "process";
2491
+ import process23 from "process";
1853
2492
 
1854
2493
  // ../kit/src/shell.ts
1855
2494
  var SEPARATORS = new Set([`
@@ -1860,6 +2499,7 @@ var COMMENT_PREFIXES = new Set([";", "&", "|", "(", ")"]);
1860
2499
  var SAFE_WORD = /^[\w@%+=:,./-]+$/;
1861
2500
  var DOUBLE_QUOTED_ESCAPES = new Set(["$", "`", '"', "\\"]);
1862
2501
  var KEYWORDS = new Set(["then", "do", "else", "if", "elif", "while", "until", "!", "{", "}"]);
2502
+ var FISH_COMBINERS = new Set(["and", "or", "not"]);
1863
2503
  var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ash", "ksh", "fish", "csh", "tcsh", "nu", "xonsh", "elvish", "pwsh", "powershell"]);
1864
2504
  var SCANNED_PROGRAMS = new Set(["su", "runuser", "flock"]);
1865
2505
  var COMMAND_STRING_PROGRAMS = new Set([...SHELLS, ...SCANNED_PROGRAMS]);
@@ -1871,6 +2511,7 @@ var FIND_EXEC = new Set(["-exec", "-execdir", "-ok", "-okdir"]);
1871
2511
  function wrapper(short = "", long = [], operands = 0, runsString = false) {
1872
2512
  return { short, long, operands, runsString };
1873
2513
  }
2514
+ var RUNNER = { ...wrapper(), afterDashes: true };
1874
2515
  var WRAPPERS = new Map([
1875
2516
  ["command", wrapper()],
1876
2517
  ["builtin", wrapper()],
@@ -1892,7 +2533,23 @@ var WRAPPERS = new Map([
1892
2533
  ["parallel", wrapper("jnNSaIPlLdTsC", ["--jobs", "--max-args", "--max-replace-args", "--sshlogin", "--arg-file", "--delimiter", "--colsep"], 0, true)],
1893
2534
  ["unbuffer", wrapper()],
1894
2535
  ["systemd-run", wrapper("puEMH", ["--property", "--unit", "--description", "--slice", "--setenv", "--machine", "--host", "--uid", "--gid", "--working-directory", "--nice", "--service-type"])],
1895
- ["xargs", wrapper("IndsEaPL", ["--max-args", "--max-procs", "--max-chars", "--delimiter", "--arg-file", "--eof", "--max-lines", "--process-slot-var"])]
2536
+ ["xargs", wrapper("IndsEaPL", ["--max-args", "--max-procs", "--max-chars", "--delimiter", "--arg-file", "--eof", "--max-lines", "--process-slot-var"])],
2537
+ ["strace", wrapper("abeEIoOpPsSuUX", ["--trace", "--output", "--attach", "--string-limit", "--user", "--env", "--columns", "--trace-path", "--signal", "--status", "--summary-sort-by", "--summary-columns", "--const-print-style", "--interruptible", "--detach-on"])],
2538
+ ["ltrace", wrapper("aeFlnopsuxX", ["--output", "--user", "--library", "--config", "--align", "--indent"])],
2539
+ ["taskset", wrapper("", [], 1)],
2540
+ ["fakeroot", wrapper("lsib", ["--lib", "--faked"])],
2541
+ ["sshpass", wrapper("pfdP")],
2542
+ ["coproc", wrapper()],
2543
+ ["proxychains", wrapper("f")],
2544
+ ["proxychains4", wrapper("f")],
2545
+ ["torsocks", wrapper("upaP", ["--user", "--pass", "--address", "--port"])],
2546
+ ["chrt", wrapper("TPD", ["--sched-runtime", "--sched-period", "--sched-deadline"], 1)],
2547
+ ["unshare", wrapper("SGRw", ["--setuid", "--setgid", "--root", "--wd", "--map-user", "--map-group", "--map-users", "--map-groups", "--propagation", "--setgroups"])],
2548
+ ["nsenter", wrapper("tSG", ["--target", "--setuid", "--setgid"])],
2549
+ ["out", RUNNER],
2550
+ ["slot", RUNNER],
2551
+ ["waitfor", RUNNER],
2552
+ ["base", RUNNER]
1896
2553
  ]);
1897
2554
  function shellQuote(word) {
1898
2555
  return SAFE_WORD.test(word) && !word.startsWith("=") ? word : `'${word.replaceAll("'", "'\\''")}'`;
@@ -1918,7 +2575,7 @@ async function runPreview(template, line, signal, hidden = []) {
1918
2575
  ${previewCommand(template, line, hidden)}`], { stdin: "ignore", stdout: "pipe", stderr: "ignore", detached: true });
1919
2576
  const stop = () => {
1920
2577
  try {
1921
- process20.kill(-proc.pid, "SIGKILL");
2578
+ process23.kill(-proc.pid, "SIGKILL");
1922
2579
  } catch {
1923
2580
  proc.kill();
1924
2581
  }
@@ -1943,7 +2600,12 @@ ${previewCommand(template, line, hidden)}`], { stdin: "ignore", stdout: "pipe",
1943
2600
  return signal.aborted ? [] : previewLines(Buffer.concat(chunks).subarray(0, PREVIEW_BYTES).toString());
1944
2601
  }
1945
2602
 
2603
+ // ../kit/src/picker/terminal.ts
2604
+ init_state();
2605
+
1946
2606
  // ../kit/src/picker/view.ts
2607
+ init_line();
2608
+ init_state();
1947
2609
  var MIN_HEIGHT = 4;
1948
2610
  var PREVIEW_MIN_COLUMNS = 80;
1949
2611
  var PREVIEW_MIN_ROWS = 10;
@@ -2076,7 +2738,7 @@ function openTerminal() {
2076
2738
  return fail("no terminal to read keys from (/dev/tty)");
2077
2739
  }
2078
2740
  const keys = Bun.file("/dev/tty").stream().getReader();
2079
- const out = process21.stderr;
2741
+ const out = process24.stderr;
2080
2742
  let resize;
2081
2743
  async function read(onChunk) {
2082
2744
  const decoder = new TextDecoder;
@@ -2265,9 +2927,9 @@ async function select(rows, settings, terminal = openTerminal()) {
2265
2927
  const ended = new Promise((resolve) => {
2266
2928
  finish = resolve;
2267
2929
  });
2268
- process21.once("exit", restore);
2930
+ process24.once("exit", restore);
2269
2931
  for (const signal of SIGNALS2)
2270
- process21.once(signal, stop);
2932
+ process24.once(signal, stop);
2271
2933
  try {
2272
2934
  terminal.write(`${PASTE_ON}${MOUSE_ON}`);
2273
2935
  terminal.listen(onChunk, () => draw(true));
@@ -2280,8 +2942,8 @@ async function select(rows, settings, terminal = openTerminal()) {
2280
2942
  await ended;
2281
2943
  } finally {
2282
2944
  for (const signal of SIGNALS2)
2283
- process21.off(signal, stop);
2284
- process21.off("exit", restore);
2945
+ process24.off(signal, stop);
2946
+ process24.off("exit", restore);
2285
2947
  restore();
2286
2948
  }
2287
2949
  return state.done === "accept" ? { rows: chosen(state), key: state.key, query: state.query } : undefined;
@@ -2293,7 +2955,9 @@ async function previewOf(preview, hidden, signal) {
2293
2955
  return [error instanceof Error ? error.message : String(error)];
2294
2956
  }
2295
2957
  }
2958
+
2296
2959
  // ../kit/src/picker.ts
2960
+ init_score();
2297
2961
  function table2(rows) {
2298
2962
  const widths = rows[0]?.cells.map((_, index) => Math.max(...rows.map((row) => Bun.stringWidth(row.cells[index])))) ?? [];
2299
2963
  return rows.map((row) => [
@@ -2328,14 +2992,14 @@ function list(rows) {
2328
2992
  }
2329
2993
 
2330
2994
  // src/branch.ts
2331
- var usage2 = `gb [branch]
2995
+ var usage2 = `gb [branch]: picks a git branch and switches to it
2332
2996
  gb -
2333
2997
  gb -c <name>
2334
2998
  gb -d <branch>
2335
2999
 
2336
- Without a branch, picks one when a terminal is attached: the branches last checked out first, as the reflog has them, then the other local ones, then the remote ones with no local branch yet. The header says where HEAD stands, each row how its branch stands against its upstream and whether it is merged into the base. enter switches to it (a remote one gets its local tracking branch), ctrl-n creates a branch named after the query, ctrl-d deletes the highlighted local branch with \`git branch -d\`, which refuses one not merged yet, and ctrl-r fetches, prunes and lists again. Without a terminal it lists the branches instead.
2337
- \`gb <branch>\` switches without the picker, a bare name finding the remote branch it would create. \`gb -\` goes back to the previous branch, \`gb -c <name>\` creates one and switches to it, \`gb -d <branch>\` deletes a local one.
2338
- A branch checked out in another worktree cannot be switched to: gb prints that worktree's path on stdout and a hint on stderr, since a command cannot change its parent shell's folder.`;
3000
+ Without a branch, on a terminal, picks one: the recently checked out first, then the other local ones, then the remote ones with no local branch yet (enter switches, ctrl-n creates, ctrl-d deletes a merged local branch with \`git branch -d\`, ctrl-r fetches and prunes); without a terminal it lists them.
3001
+ \`gb <branch>\` switches without the picker, \`gb -\` goes back to the previous branch, \`gb -c <name>\` creates one and switches to it, \`gb -d <branch>\` deletes a local one.
3002
+ A branch checked out in another worktree cannot be switched to: gb prints that worktree's path, since a command cannot change its shell's folder.`;
2339
3003
  var EXITS = [[0, "it switched, created, deleted or listed"], ["git", "the code of the git command it ran, when that failed"], [1, "there is no branch by that name or nothing was picked"], [2, "outside a git repository or a usage error"]];
2340
3004
  var options = {
2341
3005
  create: { type: "boolean", short: "c", description: "create the branch named by the rest of the line and switch to it" },
@@ -2478,7 +3142,7 @@ async function fetched() {
2478
3142
  const success = await proc.exited === 0;
2479
3143
  return header(branches(base()), read(["branch", "--show-current"]), success ? "" : "fetch failed");
2480
3144
  }
2481
- function listed2(all) {
3145
+ function listed3(all) {
2482
3146
  list([
2483
3147
  ...all.map((branch) => ({
2484
3148
  label: branch.name,
@@ -2505,7 +3169,7 @@ async function hidden(flag, rest) {
2505
3169
  return 0;
2506
3170
  }
2507
3171
  if (flag === "--list") {
2508
- listed2(load().all);
3172
+ listed3(load().all);
2509
3173
  return 0;
2510
3174
  }
2511
3175
  if (flag === "--names") {
@@ -2552,7 +3216,7 @@ async function gb(args) {
2552
3216
  if (parsed.values.json === true)
2553
3217
  printJson(all);
2554
3218
  else
2555
- console.log(table2(all.map(row)).map((line) => takesControlCodes(process22.stdout) ? line : Bun.stripANSI(line)).join(`
3219
+ console.log(table2(all.map(row)).map((line) => takesControlCodes(process25.stdout) ? line : Bun.stripANSI(line)).join(`
2556
3220
  `));
2557
3221
  return 0;
2558
3222
  }
@@ -2609,4 +3273,4 @@ async function finish(command, typed, emitting) {
2609
3273
  }
2610
3274
 
2611
3275
  // src/gb.ts
2612
- process23.exitCode = await runMain({ name: "gb", run: gb });
3276
+ process26.exitCode = await runMain({ name: "gb", run: gb });