@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.
- package/README.md +4 -4
- package/dist/gb.js +1627 -963
- package/dist/gc.js +1253 -179
- package/dist/gcl.js +1245 -182
- package/dist/gd.js +1232 -184
- package/dist/gf.js +1252 -183
- package/dist/gm.js +1802 -1096
- package/dist/gp.js +1233 -182
- package/dist/gst.js +1229 -186
- package/dist/gu.js +1232 -179
- package/package.json +5 -5
package/dist/gp.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
|
-
//
|
|
5
|
-
|
|
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
|
|
29
|
-
var
|
|
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
|
-
//
|
|
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 =
|
|
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
|
|
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
|
-
//
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
673
|
+
import process9 from "process";
|
|
674
|
+
import { parseArgs } from "util";
|
|
602
675
|
function jsonOption(holds) {
|
|
603
676
|
return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
|
|
604
677
|
}
|
|
605
|
-
class Exit extends Error {
|
|
606
|
-
code;
|
|
607
|
-
hint;
|
|
608
|
-
constructor(message, code, hint) {
|
|
609
|
-
super(message);
|
|
610
|
-
this.code = code;
|
|
611
|
-
this.hint = hint;
|
|
612
|
-
}
|
|
613
|
-
}
|
|
614
678
|
function fail(message, code = 2, hint) {
|
|
615
679
|
throw new Exit(message, code, hint);
|
|
616
680
|
}
|
|
617
|
-
|
|
618
|
-
class UsageError extends Exit {
|
|
619
|
-
constructor(message, hint) {
|
|
620
|
-
super(message, 2, hint);
|
|
621
|
-
}
|
|
622
|
-
}
|
|
623
681
|
function badUsage(message) {
|
|
624
682
|
throw new UsageError(message);
|
|
625
683
|
}
|
|
626
684
|
|
|
627
|
-
class HelpShown extends Exit {
|
|
628
|
-
constructor() {
|
|
629
|
-
super("help shown", 0);
|
|
630
|
-
}
|
|
631
|
-
}
|
|
632
|
-
|
|
633
685
|
class Completing {
|
|
634
686
|
options;
|
|
635
687
|
positionals;
|
|
@@ -640,11 +692,6 @@ class Completing {
|
|
|
640
692
|
this.candidates = candidates;
|
|
641
693
|
}
|
|
642
694
|
}
|
|
643
|
-
var completion = { active: false };
|
|
644
|
-
var OUTPUT_OPTIONS = {
|
|
645
|
-
color: { type: "string", description: "auto (on a terminal alone), always or never" },
|
|
646
|
-
plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
|
|
647
|
-
};
|
|
648
695
|
function applyOutput(color, plain, env = process9.env) {
|
|
649
696
|
const when = plain === true ? "never" : color ?? "auto";
|
|
650
697
|
if (when === "auto")
|
|
@@ -798,7 +845,6 @@ function parseError(error) {
|
|
|
798
845
|
const message = upTo(error instanceof Error ? error.message : String(error), ". ");
|
|
799
846
|
return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
|
|
800
847
|
}
|
|
801
|
-
var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
|
|
802
848
|
function nearestOption(message, options, allowNegative) {
|
|
803
849
|
const typed = UNKNOWN_OPTION.exec(message)?.[1];
|
|
804
850
|
if (typed === undefined)
|
|
@@ -814,6 +860,692 @@ function nearestOption(message, options, allowNegative) {
|
|
|
814
860
|
const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
|
|
815
861
|
return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
|
|
816
862
|
}
|
|
863
|
+
var DASHES, EXIT, Exit, UsageError, HelpShown, completion, OUTPUT_OPTIONS, UNKNOWN_OPTION;
|
|
864
|
+
var init_args = __esm(() => {
|
|
865
|
+
init_format();
|
|
866
|
+
init_help();
|
|
867
|
+
init_text2();
|
|
868
|
+
init_help();
|
|
869
|
+
init_input();
|
|
870
|
+
DASHES = /^-+/;
|
|
871
|
+
EXIT = Symbol.for("@kaynooo/cli-kit/Exit");
|
|
872
|
+
Exit = class Exit extends Error {
|
|
873
|
+
code;
|
|
874
|
+
hint;
|
|
875
|
+
[EXIT] = true;
|
|
876
|
+
constructor(message, code, hint) {
|
|
877
|
+
super(message);
|
|
878
|
+
this.code = code;
|
|
879
|
+
this.hint = hint;
|
|
880
|
+
}
|
|
881
|
+
static [Symbol.hasInstance](value) {
|
|
882
|
+
if (this !== Exit)
|
|
883
|
+
return Function.prototype[Symbol.hasInstance].call(this, value);
|
|
884
|
+
return typeof value === "object" && value !== null && value[EXIT] === true;
|
|
885
|
+
}
|
|
886
|
+
};
|
|
887
|
+
UsageError = class UsageError extends Exit {
|
|
888
|
+
constructor(message, hint) {
|
|
889
|
+
super(message, 2, hint);
|
|
890
|
+
}
|
|
891
|
+
};
|
|
892
|
+
HelpShown = class HelpShown extends Exit {
|
|
893
|
+
constructor() {
|
|
894
|
+
super("help shown", 0);
|
|
895
|
+
}
|
|
896
|
+
};
|
|
897
|
+
completion = { active: false };
|
|
898
|
+
OUTPUT_OPTIONS = {
|
|
899
|
+
color: { type: "string", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
|
|
900
|
+
plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
|
|
901
|
+
};
|
|
902
|
+
UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
|
|
903
|
+
});
|
|
904
|
+
|
|
905
|
+
// ../kit/src/folders.ts
|
|
906
|
+
import { homedir as homedir3 } from "os";
|
|
907
|
+
import { join as join4 } from "path";
|
|
908
|
+
import process13 from "process";
|
|
909
|
+
function cacheFolder({ home = homedir3(), env = process13.env } = {}) {
|
|
910
|
+
return xdgFolder(env.XDG_CACHE_HOME, join4(home, ".cache"));
|
|
911
|
+
}
|
|
912
|
+
var SKIPPED_FOLDERS;
|
|
913
|
+
var init_folders = __esm(() => {
|
|
914
|
+
init_user_config();
|
|
915
|
+
SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
|
|
916
|
+
});
|
|
917
|
+
|
|
918
|
+
// ../kit/src/answers.ts
|
|
919
|
+
import { mkdirSync, readFileSync as readFileSync5, writeFileSync } from "fs";
|
|
920
|
+
import { dirname as dirname2, join as join5 } from "path";
|
|
921
|
+
function answersFile() {
|
|
922
|
+
return join5(cacheFolder(), "kaynooo-cli", "answers.json");
|
|
923
|
+
}
|
|
924
|
+
function stored() {
|
|
925
|
+
try {
|
|
926
|
+
const parsed = JSON.parse(readFileSync5(answersFile(), "utf-8"));
|
|
927
|
+
if (typeof parsed !== "object" || parsed === null)
|
|
928
|
+
return {};
|
|
929
|
+
return Object.fromEntries(Object.entries(parsed).filter((entry) => Array.isArray(entry[1]) && entry[1].every((answer) => typeof answer === "string")));
|
|
930
|
+
} catch {
|
|
931
|
+
return {};
|
|
932
|
+
}
|
|
933
|
+
}
|
|
934
|
+
function earlierAnswers(key) {
|
|
935
|
+
return stored()[key] ?? [];
|
|
936
|
+
}
|
|
937
|
+
function rememberAnswer(key, answer) {
|
|
938
|
+
const all = stored();
|
|
939
|
+
const file = answersFile();
|
|
940
|
+
all[key] = [answer, ...(all[key] ?? []).filter((earlier) => earlier !== answer)].slice(0, KEPT);
|
|
941
|
+
try {
|
|
942
|
+
mkdirSync(dirname2(file), { recursive: true });
|
|
943
|
+
writeFileSync(file, JSON.stringify(all));
|
|
944
|
+
} catch {}
|
|
945
|
+
}
|
|
946
|
+
var KEPT = 50;
|
|
947
|
+
var init_answers = __esm(() => {
|
|
948
|
+
init_folders();
|
|
949
|
+
});
|
|
950
|
+
|
|
951
|
+
// ../kit/src/job.ts
|
|
952
|
+
import process14 from "process";
|
|
953
|
+
function stopJob() {
|
|
954
|
+
process14.kill(0, "SIGTSTP");
|
|
955
|
+
}
|
|
956
|
+
var init_job = () => {};
|
|
957
|
+
|
|
958
|
+
// ../kit/src/picker/line.ts
|
|
959
|
+
function isEditKey(key) {
|
|
960
|
+
return EDIT_KEYS.has(key);
|
|
961
|
+
}
|
|
962
|
+
function endsKills(key) {
|
|
963
|
+
return typeof key !== "object" && !isEditKey(key);
|
|
964
|
+
}
|
|
965
|
+
function isWord(char) {
|
|
966
|
+
return char !== undefined && WORD_CHARACTER.test(char);
|
|
967
|
+
}
|
|
968
|
+
function wordStart(chars, from) {
|
|
969
|
+
let at = from;
|
|
970
|
+
while (at > 0 && !isWord(chars[at - 1]))
|
|
971
|
+
at--;
|
|
972
|
+
while (at > 0 && isWord(chars[at - 1]))
|
|
973
|
+
at--;
|
|
974
|
+
return at;
|
|
975
|
+
}
|
|
976
|
+
function wordEnd(chars, from) {
|
|
977
|
+
let at = from;
|
|
978
|
+
while (at < chars.length && !isWord(chars[at]))
|
|
979
|
+
at++;
|
|
980
|
+
while (at < chars.length && isWord(chars[at]))
|
|
981
|
+
at++;
|
|
982
|
+
return at;
|
|
983
|
+
}
|
|
984
|
+
function spacedStart(chars, from) {
|
|
985
|
+
let at = from;
|
|
986
|
+
while (at > 0 && SPACE.test(chars[at - 1] ?? ""))
|
|
987
|
+
at--;
|
|
988
|
+
while (at > 0 && !SPACE.test(chars[at - 1] ?? ""))
|
|
989
|
+
at--;
|
|
990
|
+
return at;
|
|
991
|
+
}
|
|
992
|
+
function cut(chars, from, to) {
|
|
993
|
+
return { text: [...chars.slice(0, from), ...chars.slice(to)].join(""), caret: from };
|
|
994
|
+
}
|
|
995
|
+
function insert(chars, at, text) {
|
|
996
|
+
const typed = [...text];
|
|
997
|
+
return { text: [...chars.slice(0, at), ...typed, ...chars.slice(at)].join(""), caret: at + typed.length };
|
|
998
|
+
}
|
|
999
|
+
function editLine(line, key) {
|
|
1000
|
+
const { killed = "", chained = false } = line;
|
|
1001
|
+
const chars = [...line.text];
|
|
1002
|
+
const at = Math.min(Math.max(line.caret, 0), chars.length);
|
|
1003
|
+
const edited = edit(chars, at, key, killed);
|
|
1004
|
+
if (typeof key === "object" || !BACKWARD_KILLS.has(key) && !FORWARD_KILLS.has(key))
|
|
1005
|
+
return line.killed === undefined ? edited : { ...edited, killed };
|
|
1006
|
+
const taken = chars.slice(edited.caret, edited.caret + chars.length - [...edited.text].length).join("");
|
|
1007
|
+
if (taken === "")
|
|
1008
|
+
return { ...edited, killed, chained };
|
|
1009
|
+
if (!chained)
|
|
1010
|
+
return { ...edited, killed: taken, chained: true };
|
|
1011
|
+
return { ...edited, killed: BACKWARD_KILLS.has(key) ? taken + killed : killed + taken, chained: true };
|
|
1012
|
+
}
|
|
1013
|
+
function edit(chars, at, key, killed) {
|
|
1014
|
+
const text = chars.join("");
|
|
1015
|
+
if (typeof key === "object")
|
|
1016
|
+
return insert(chars, at, key.text);
|
|
1017
|
+
switch (key) {
|
|
1018
|
+
case "left":
|
|
1019
|
+
return { text, caret: Math.max(at - 1, 0) };
|
|
1020
|
+
case "right":
|
|
1021
|
+
return { text, caret: Math.min(at + 1, chars.length) };
|
|
1022
|
+
case "wordleft":
|
|
1023
|
+
return { text, caret: wordStart(chars, at) };
|
|
1024
|
+
case "wordright":
|
|
1025
|
+
return { text, caret: wordEnd(chars, at) };
|
|
1026
|
+
case "linestart":
|
|
1027
|
+
return { text, caret: 0 };
|
|
1028
|
+
case "lineend":
|
|
1029
|
+
return { text, caret: chars.length };
|
|
1030
|
+
case "erase":
|
|
1031
|
+
return cut(chars, Math.max(at - 1, 0), at);
|
|
1032
|
+
case "delete":
|
|
1033
|
+
return cut(chars, at, Math.min(at + 1, chars.length));
|
|
1034
|
+
case "word":
|
|
1035
|
+
return cut(chars, spacedStart(chars, at), at);
|
|
1036
|
+
case "killword":
|
|
1037
|
+
return cut(chars, wordStart(chars, at), at);
|
|
1038
|
+
case "killnext":
|
|
1039
|
+
return cut(chars, at, wordEnd(chars, at));
|
|
1040
|
+
case "clear":
|
|
1041
|
+
return cut(chars, 0, at);
|
|
1042
|
+
case "killend":
|
|
1043
|
+
return cut(chars, at, chars.length);
|
|
1044
|
+
case "yank":
|
|
1045
|
+
return insert(chars, at, killed);
|
|
1046
|
+
}
|
|
1047
|
+
}
|
|
1048
|
+
function visible({ text, caret }, room) {
|
|
1049
|
+
const chars = [...text];
|
|
1050
|
+
const at = Math.min(Math.max(caret, 0), chars.length);
|
|
1051
|
+
const cells = at === chars.length ? [...chars, " "] : chars;
|
|
1052
|
+
const widths = cells.map((char) => Bun.stringWidth(char));
|
|
1053
|
+
const width = (from, to) => widths.slice(from, to).reduce((sum, size) => sum + size, 0);
|
|
1054
|
+
const fits = (from, to) => (from > 0 ? 1 : 0) + width(from, to) + (to < cells.length ? 1 : 0) <= room;
|
|
1055
|
+
let start = at;
|
|
1056
|
+
let end = at + 1;
|
|
1057
|
+
while (start > 0 && fits(start - 1, end))
|
|
1058
|
+
start--;
|
|
1059
|
+
while (end < cells.length && fits(start, end + 1))
|
|
1060
|
+
end++;
|
|
1061
|
+
const left = start > 0 ? "\u2026" : "";
|
|
1062
|
+
const right = end < cells.length ? "\u2026" : "";
|
|
1063
|
+
return { before: left + chars.slice(start, at).join(""), at: chars[at], after: chars.slice(at + 1, end).join("") + right, column: left.length + width(start, at) };
|
|
1064
|
+
}
|
|
1065
|
+
var EDIT_KEYS, BACKWARD_KILLS, FORWARD_KILLS, WORD_CHARACTER, SPACE;
|
|
1066
|
+
var init_line = __esm(() => {
|
|
1067
|
+
EDIT_KEYS = new Set(["left", "right", "wordleft", "wordright", "linestart", "lineend", "erase", "delete", "word", "killword", "killnext", "clear", "killend", "yank"]);
|
|
1068
|
+
BACKWARD_KILLS = new Set(["word", "killword", "clear"]);
|
|
1069
|
+
FORWARD_KILLS = new Set(["killnext", "killend"]);
|
|
1070
|
+
WORD_CHARACTER = /[\p{L}\p{N}_]/u;
|
|
1071
|
+
SPACE = /\s/;
|
|
1072
|
+
});
|
|
1073
|
+
|
|
1074
|
+
// ../kit/src/picker/score.ts
|
|
1075
|
+
function startsWord(text, index) {
|
|
1076
|
+
if (index === 0)
|
|
1077
|
+
return true;
|
|
1078
|
+
const before = text[index - 1];
|
|
1079
|
+
return BOUNDARY_AFTER.has(before) || LOWER.test(before) && UPPER.test(text[index]);
|
|
1080
|
+
}
|
|
1081
|
+
function fuzzy(query, text) {
|
|
1082
|
+
if (query === "")
|
|
1083
|
+
return { score: 0, positions: [] };
|
|
1084
|
+
const exact = query !== query.toLowerCase();
|
|
1085
|
+
const needle = exact ? query : query.toLowerCase();
|
|
1086
|
+
const haystack = exact ? text : text.toLowerCase();
|
|
1087
|
+
if (haystack.length !== text.length || needle.length > haystack.length)
|
|
1088
|
+
return;
|
|
1089
|
+
const width = haystack.length;
|
|
1090
|
+
const best = Array.from({ length: needle.length }, () => new Array(width).fill(NONE));
|
|
1091
|
+
const from = Array.from({ length: needle.length }, () => new Array(width).fill(-1));
|
|
1092
|
+
for (let j = 0;j < needle.length; j++) {
|
|
1093
|
+
let run = NONE;
|
|
1094
|
+
let runAt = -1;
|
|
1095
|
+
for (let i = j;i < width; i++) {
|
|
1096
|
+
if (j > 0 && i - 2 >= j - 1) {
|
|
1097
|
+
const candidate = best[j - 1][i - 2] + (i - 2) * GAP;
|
|
1098
|
+
if (candidate > run) {
|
|
1099
|
+
run = candidate;
|
|
1100
|
+
runAt = i - 2;
|
|
1101
|
+
}
|
|
1102
|
+
}
|
|
1103
|
+
if (haystack[i] !== needle[j])
|
|
1104
|
+
continue;
|
|
1105
|
+
const here = MATCH + (startsWord(text, i) ? BOUNDARY : 0) + (i === 0 ? PREFIX : 0);
|
|
1106
|
+
if (j === 0) {
|
|
1107
|
+
best[0][i] = here - i * GAP;
|
|
1108
|
+
continue;
|
|
1109
|
+
}
|
|
1110
|
+
const joined = best[j - 1][i - 1] + CONSECUTIVE;
|
|
1111
|
+
const skipped = run - (i - 1) * GAP;
|
|
1112
|
+
if (joined > NONE && joined >= skipped) {
|
|
1113
|
+
best[j][i] = joined + here;
|
|
1114
|
+
from[j][i] = i - 1;
|
|
1115
|
+
} else if (skipped > NONE) {
|
|
1116
|
+
best[j][i] = skipped + here;
|
|
1117
|
+
from[j][i] = runAt;
|
|
1118
|
+
}
|
|
1119
|
+
}
|
|
1120
|
+
}
|
|
1121
|
+
const last = best[needle.length - 1];
|
|
1122
|
+
let end = -1;
|
|
1123
|
+
for (let i = 0;i < width; i++) {
|
|
1124
|
+
if (last[i] > NONE && (end === -1 || last[i] > last[end]))
|
|
1125
|
+
end = i;
|
|
1126
|
+
}
|
|
1127
|
+
if (end === -1)
|
|
1128
|
+
return;
|
|
1129
|
+
const positions = [];
|
|
1130
|
+
for (let j = needle.length - 1, i = end;j >= 0; j--) {
|
|
1131
|
+
positions.unshift(i);
|
|
1132
|
+
i = from[j][i];
|
|
1133
|
+
}
|
|
1134
|
+
return { score: last[end], positions };
|
|
1135
|
+
}
|
|
1136
|
+
function rank(query, lines) {
|
|
1137
|
+
if (query === "")
|
|
1138
|
+
return lines.map((_, index) => ({ index, positions: [] }));
|
|
1139
|
+
const found = [];
|
|
1140
|
+
for (const [index, line] of lines.entries()) {
|
|
1141
|
+
const match = fuzzy(query, line);
|
|
1142
|
+
if (match !== undefined)
|
|
1143
|
+
found.push({ index, positions: match.positions, score: match.score });
|
|
1144
|
+
}
|
|
1145
|
+
return found.sort((a, b) => b.score - a.score || lines[a.index].length - lines[b.index].length || a.index - b.index);
|
|
1146
|
+
}
|
|
1147
|
+
var MATCH = 16, CONSECUTIVE = 12, BOUNDARY = 10, PREFIX = 8, GAP = 1, BOUNDARY_AFTER, UPPER, LOWER, NONE;
|
|
1148
|
+
var init_score = __esm(() => {
|
|
1149
|
+
BOUNDARY_AFTER = new Set([" ", "/", "-", "_", ".", ":", "\\", "(", "[", ",", "\t"]);
|
|
1150
|
+
UPPER = /\p{Lu}/u;
|
|
1151
|
+
LOWER = /\p{Ll}/u;
|
|
1152
|
+
NONE = Number.NEGATIVE_INFINITY;
|
|
1153
|
+
});
|
|
1154
|
+
|
|
1155
|
+
// ../kit/src/picker/state.ts
|
|
1156
|
+
function repeat(value, count) {
|
|
1157
|
+
return Array.from({ length: count }).fill(value);
|
|
1158
|
+
}
|
|
1159
|
+
function styled(line) {
|
|
1160
|
+
let text = "";
|
|
1161
|
+
const styles = [];
|
|
1162
|
+
let active = "";
|
|
1163
|
+
let colored = false;
|
|
1164
|
+
let last = 0;
|
|
1165
|
+
function add(chunk) {
|
|
1166
|
+
const flat = chunk.replace(CONTROL2, " ");
|
|
1167
|
+
text += flat;
|
|
1168
|
+
colored ||= active !== "" && flat !== "";
|
|
1169
|
+
styles.push(...repeat(active, flat.length));
|
|
1170
|
+
}
|
|
1171
|
+
for (const found of line.matchAll(ANSI)) {
|
|
1172
|
+
add(line.slice(last, found.index));
|
|
1173
|
+
last = found.index + found[0].length;
|
|
1174
|
+
if (SGR.test(found[0]))
|
|
1175
|
+
active = RESET.test(found[0]) ? "" : active + found[0];
|
|
1176
|
+
}
|
|
1177
|
+
add(line.slice(last));
|
|
1178
|
+
return { text, styles: colored ? styles : undefined };
|
|
1179
|
+
}
|
|
1180
|
+
function lay(rows, searched) {
|
|
1181
|
+
const parsed = rows.map((row) => row.cells.map(styled));
|
|
1182
|
+
const widths = (parsed[0] ?? []).map((_, column) => Math.max(...parsed.map((cells) => Bun.stringWidth(cells[column]?.text ?? ""))));
|
|
1183
|
+
return parsed.map((cells, at) => {
|
|
1184
|
+
let text = "";
|
|
1185
|
+
const styles = [];
|
|
1186
|
+
let colored = false;
|
|
1187
|
+
let searchEnd = 0;
|
|
1188
|
+
for (const [column, cell] of cells.entries()) {
|
|
1189
|
+
const last = column === cells.length - 1;
|
|
1190
|
+
const shown = cells.length > 1 && last ? cell.text.trimEnd() : cell.text;
|
|
1191
|
+
text += shown;
|
|
1192
|
+
colored ||= cell.styles !== undefined;
|
|
1193
|
+
styles.push(...cell.styles?.slice(0, shown.length) ?? repeat("", shown.length));
|
|
1194
|
+
if (column < searched)
|
|
1195
|
+
searchEnd = cells.length > 1 ? text.trimEnd().length : text.length;
|
|
1196
|
+
if (!last) {
|
|
1197
|
+
const pad = widths[column] - Bun.stringWidth(cell.text) + COLUMN_GAP;
|
|
1198
|
+
text += " ".repeat(pad);
|
|
1199
|
+
styles.push(...repeat("", pad));
|
|
1200
|
+
}
|
|
1201
|
+
}
|
|
1202
|
+
return { text, styles: colored ? styles : undefined, searchable: rows[at].search ?? text.slice(0, searchEnd) };
|
|
1203
|
+
});
|
|
1204
|
+
}
|
|
1205
|
+
function parseKeys(input, paste = { active: false }, ctrls = []) {
|
|
1206
|
+
const codes = new Map(ctrls.map((name) => [String.fromCharCode(name.codePointAt(name.length - 1) - 96), name]));
|
|
1207
|
+
return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => {
|
|
1208
|
+
const wheel = MOUSE.exec(sequence)?.[1];
|
|
1209
|
+
if (wheel !== undefined)
|
|
1210
|
+
return repeat(wheel === "64" ? "up" : "down", wheel === "64" || wheel === "65" ? WHEEL_LINES : 0);
|
|
1211
|
+
const named = codes.get(sequence);
|
|
1212
|
+
const key = named === undefined ? KEYS[sequence] : { ctrl: named };
|
|
1213
|
+
if (sequence === PASTE_START || sequence === PASTE_END) {
|
|
1214
|
+
paste.active = sequence === PASTE_START;
|
|
1215
|
+
return [];
|
|
1216
|
+
}
|
|
1217
|
+
if (paste.active && (sequence === "\r" || sequence === `
|
|
1218
|
+
`))
|
|
1219
|
+
return [];
|
|
1220
|
+
if (key !== undefined)
|
|
1221
|
+
return [key];
|
|
1222
|
+
return IS_CONTROL.test(sequence) || sequence.startsWith("\x1B") ? [] : [{ text: sequence }];
|
|
1223
|
+
});
|
|
1224
|
+
}
|
|
1225
|
+
function createState(rows, { multi = false, prompt = "> ", query = "", header = "", expect = [], searched = Number.POSITIVE_INFINITY } = {}) {
|
|
1226
|
+
const state = { rows: [], items: [], styles: [], searchable: [], searched, header, expect, key: "", status: "", query, caret: [...query].length, killed: "", chained: false, matches: [], cursor: 0, help: false, page: 10, marked: new Set, multi, prompt, done: undefined };
|
|
1227
|
+
return withRows(state, rows);
|
|
1228
|
+
}
|
|
1229
|
+
function withRows(state, rows, header = state.header) {
|
|
1230
|
+
const cells = rows.map((row) => typeof row === "string" ? { hidden: [], cells: [row] } : row);
|
|
1231
|
+
const laid = lay(cells, state.searched);
|
|
1232
|
+
const searchable = laid.map((row) => row.searchable);
|
|
1233
|
+
const matches = rank(state.query, searchable);
|
|
1234
|
+
return { ...state, rows: cells, items: laid.map((row) => row.text), styles: laid.map((row) => row.styles), searchable, header, matches, cursor: Math.max(0, Math.min(matches.length - 1, state.cursor)), marked: new Set };
|
|
1235
|
+
}
|
|
1236
|
+
function withQuery(state, key) {
|
|
1237
|
+
const { text, caret, killed = "", chained = false } = editLine({ text: state.query, caret: state.caret, killed: state.killed, chained: state.chained }, key);
|
|
1238
|
+
return text === state.query ? { ...state, caret, killed, chained } : { ...state, query: text, caret, killed, chained, matches: rank(text, state.searchable), cursor: 0 };
|
|
1239
|
+
}
|
|
1240
|
+
function move(state, by) {
|
|
1241
|
+
return { ...state, cursor: Math.max(0, Math.min(state.matches.length - 1, state.cursor + by)) };
|
|
1242
|
+
}
|
|
1243
|
+
function highlighted(state) {
|
|
1244
|
+
return state.matches[state.cursor]?.index;
|
|
1245
|
+
}
|
|
1246
|
+
function press(state, key) {
|
|
1247
|
+
if (state.done !== undefined)
|
|
1248
|
+
return state;
|
|
1249
|
+
if (state.chained && endsKills(key))
|
|
1250
|
+
state = { ...state, chained: false };
|
|
1251
|
+
if (state.help)
|
|
1252
|
+
return { ...state, help: false };
|
|
1253
|
+
if (typeof key === "object") {
|
|
1254
|
+
if ("text" in key)
|
|
1255
|
+
return withQuery(state, key);
|
|
1256
|
+
return state.expect.includes(key.ctrl) ? { ...state, done: "accept", key: key.ctrl } : state;
|
|
1257
|
+
}
|
|
1258
|
+
if (isEditKey(key))
|
|
1259
|
+
return withQuery(state, key);
|
|
1260
|
+
switch (key) {
|
|
1261
|
+
case "up":
|
|
1262
|
+
return move(state, -1);
|
|
1263
|
+
case "down":
|
|
1264
|
+
return move(state, 1);
|
|
1265
|
+
case "pageup":
|
|
1266
|
+
return move(state, -state.page);
|
|
1267
|
+
case "pagedown":
|
|
1268
|
+
return move(state, state.page);
|
|
1269
|
+
case "home":
|
|
1270
|
+
return move(state, -state.matches.length);
|
|
1271
|
+
case "end":
|
|
1272
|
+
return move(state, state.matches.length);
|
|
1273
|
+
case "cancel":
|
|
1274
|
+
return { ...state, done: "cancel" };
|
|
1275
|
+
case "help":
|
|
1276
|
+
return { ...state, help: true };
|
|
1277
|
+
case "suspend":
|
|
1278
|
+
return state;
|
|
1279
|
+
case "enter":
|
|
1280
|
+
return state.matches.length === 0 && state.marked.size === 0 ? state : { ...state, done: "accept" };
|
|
1281
|
+
case "tab": {
|
|
1282
|
+
const at = highlighted(state);
|
|
1283
|
+
if (!state.multi || at === undefined)
|
|
1284
|
+
return state;
|
|
1285
|
+
const marked = new Set(state.marked);
|
|
1286
|
+
if (!marked.delete(at))
|
|
1287
|
+
marked.add(at);
|
|
1288
|
+
return move({ ...state, marked }, 1);
|
|
1289
|
+
}
|
|
1290
|
+
}
|
|
1291
|
+
}
|
|
1292
|
+
function chosen(state) {
|
|
1293
|
+
if (state.marked.size > 0)
|
|
1294
|
+
return state.rows.filter((_, index) => state.marked.has(index));
|
|
1295
|
+
const at = highlighted(state);
|
|
1296
|
+
return at === undefined ? [] : [state.rows[at]];
|
|
1297
|
+
}
|
|
1298
|
+
var CONTROL2, IS_CONTROL, SGR, RESET, COLUMN_GAP = 2, PASTE_START = "\x1B[200~", PASTE_END = "\x1B[201~", KEY_SEQUENCES, MOUSE, WHEEL_LINES = 3, KEYS, CTRL_KEY;
|
|
1299
|
+
var init_state = __esm(() => {
|
|
1300
|
+
init_text2();
|
|
1301
|
+
init_line();
|
|
1302
|
+
init_score();
|
|
1303
|
+
CONTROL2 = /[\x00-\x1F\x7F-\x9F]/g;
|
|
1304
|
+
IS_CONTROL = /[\x00-\x1F\x7F-\x9F]/;
|
|
1305
|
+
SGR = /^\x1B\[[0-9;]*m$/;
|
|
1306
|
+
RESET = /^\x1B\[0?m$/;
|
|
1307
|
+
KEY_SEQUENCES = /\x1B\[<[0-9;]*[A-Za-z]|\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|\x1B[\s\S]|[\s\S]/gu;
|
|
1308
|
+
MOUSE = /^\x1B\[<(\d+);\d+;\d+[a-z]$/i;
|
|
1309
|
+
KEYS = {
|
|
1310
|
+
"\x1B[A": "up",
|
|
1311
|
+
"\x1BOA": "up",
|
|
1312
|
+
"\x10": "up",
|
|
1313
|
+
"\x1B[B": "down",
|
|
1314
|
+
"\x1BOB": "down",
|
|
1315
|
+
"\x0E": "down",
|
|
1316
|
+
"\x1B[5~": "pageup",
|
|
1317
|
+
"\x1B[6~": "pagedown",
|
|
1318
|
+
"\x1B[H": "home",
|
|
1319
|
+
"\x1B[1~": "home",
|
|
1320
|
+
"\x1BOH": "home",
|
|
1321
|
+
"\x1B[F": "end",
|
|
1322
|
+
"\x1B[4~": "end",
|
|
1323
|
+
"\x1BOF": "end",
|
|
1324
|
+
"\r": "enter",
|
|
1325
|
+
"\n": "enter",
|
|
1326
|
+
"\x03": "cancel",
|
|
1327
|
+
"\x1B": "cancel",
|
|
1328
|
+
"\x1B[D": "left",
|
|
1329
|
+
"\x1BOD": "left",
|
|
1330
|
+
"\x1B[C": "right",
|
|
1331
|
+
"\x1BOC": "right",
|
|
1332
|
+
"\x1B[1;5D": "wordleft",
|
|
1333
|
+
"\x1B[1;3D": "wordleft",
|
|
1334
|
+
"\x1Bb": "wordleft",
|
|
1335
|
+
"\x1B[1;5C": "wordright",
|
|
1336
|
+
"\x1B[1;3C": "wordright",
|
|
1337
|
+
"\x1Bf": "wordright",
|
|
1338
|
+
"\x01": "linestart",
|
|
1339
|
+
"\x05": "lineend",
|
|
1340
|
+
"\x7F": "erase",
|
|
1341
|
+
"\x1B[3~": "delete",
|
|
1342
|
+
"\b": "killword",
|
|
1343
|
+
"\x1B\x7F": "killword",
|
|
1344
|
+
"\x1B[3;5~": "killnext",
|
|
1345
|
+
"\x1Bd": "killnext",
|
|
1346
|
+
"\x15": "clear",
|
|
1347
|
+
"\v": "killend",
|
|
1348
|
+
"\x17": "word",
|
|
1349
|
+
"\x19": "yank",
|
|
1350
|
+
"\x1A": "suspend",
|
|
1351
|
+
"\t": "tab",
|
|
1352
|
+
"\x1F": "help",
|
|
1353
|
+
"\x1BOP": "help",
|
|
1354
|
+
"\x1B[11~": "help"
|
|
1355
|
+
};
|
|
1356
|
+
CTRL_KEY = /^ctrl-[abd-gkln-z]$/;
|
|
1357
|
+
});
|
|
1358
|
+
|
|
1359
|
+
// ../kit/src/redraw.ts
|
|
1360
|
+
function overwrite(lines, columns) {
|
|
1361
|
+
return lines.map((line) => textWidth(line) % columns === 0 ? `\x1B[2K${line}` : `${line}\x1B[K`).join(`
|
|
1362
|
+
`);
|
|
1363
|
+
}
|
|
1364
|
+
function rowsTaken(lines, columns) {
|
|
1365
|
+
return lines.reduce((rows, line) => rows + Math.max(1, Math.ceil(textWidth(line) / columns)), 0);
|
|
1366
|
+
}
|
|
1367
|
+
var SYNC_START = "\x1B[?2026h", SYNC_END = "\x1B[?2026l";
|
|
1368
|
+
var init_redraw = __esm(() => {
|
|
1369
|
+
init_format();
|
|
1370
|
+
});
|
|
1371
|
+
|
|
1372
|
+
// ../kit/src/prompt.ts
|
|
1373
|
+
import process15 from "process";
|
|
1374
|
+
function readKeys(input, paste = { active: false }) {
|
|
1375
|
+
return parseKeys(input, paste).filter((key) => typeof key === "object" ? "text" in key : PROMPT_KEYS.has(key) || isEditKey(key));
|
|
1376
|
+
}
|
|
1377
|
+
function roomAfter(question, columns) {
|
|
1378
|
+
return Math.max(columns - textWidth(`? ${question} `) % columns - 1, 1);
|
|
1379
|
+
}
|
|
1380
|
+
function withCaret(colors, line, room, dim = false) {
|
|
1381
|
+
const { before, at, after } = visible(line, room);
|
|
1382
|
+
const tone = dim ? colors.dim : (text) => text;
|
|
1383
|
+
return `${tone(before)}${at === undefined ? colors.dim("\u2588") : colors.inverse(at)}${tone(after)}`;
|
|
1384
|
+
}
|
|
1385
|
+
function sharedStart(texts) {
|
|
1386
|
+
const [first = [], ...rest] = texts.map((text) => [...text]);
|
|
1387
|
+
let length = first.length;
|
|
1388
|
+
for (const chars of rest) {
|
|
1389
|
+
const differs = chars.findIndex((char, index) => char !== first[index]);
|
|
1390
|
+
length = Math.min(length, differs === -1 ? chars.length : differs);
|
|
1391
|
+
}
|
|
1392
|
+
return first.slice(0, length).join("");
|
|
1393
|
+
}
|
|
1394
|
+
function listed2(colors, found, columns) {
|
|
1395
|
+
const shared = sharedStart(found);
|
|
1396
|
+
const cut = Math.max(shared.lastIndexOf("/"), shared.lastIndexOf(" ")) + 1;
|
|
1397
|
+
const names = found.slice(0, MAX_LISTED).map((each) => each.slice(cut));
|
|
1398
|
+
const more = found.length > MAX_LISTED ? ` \u2026 ${found.length - MAX_LISTED} more` : "";
|
|
1399
|
+
return ` ${colors.dim(truncate(names.join(" ") + more, Math.max(columns - 3, 1)))}`;
|
|
1400
|
+
}
|
|
1401
|
+
async function input2(question, { default: fallback, mask = false, validate, history, complete, ...settings } = {}) {
|
|
1402
|
+
let line = { text: "", caret: 0 };
|
|
1403
|
+
let invalid;
|
|
1404
|
+
let completions = [];
|
|
1405
|
+
const remembered = history === undefined || mask ? undefined : history;
|
|
1406
|
+
const earlier = remembered === undefined ? [] : earlierAnswers(remembered);
|
|
1407
|
+
let recalled = -1;
|
|
1408
|
+
let draft = line;
|
|
1409
|
+
const taken = () => line.text === "" ? fallback ?? "" : line.text;
|
|
1410
|
+
const shown = () => mask ? "*".repeat([...taken()].length) : taken();
|
|
1411
|
+
const accepted = await ask(question, settings, (colors, state, { columns }) => {
|
|
1412
|
+
if (state !== "asking")
|
|
1413
|
+
return [answer(colors, question, state, shown())];
|
|
1414
|
+
const typed = line.text === "" ? { text: shown(), caret: [...shown()].length } : { text: shown(), caret: line.caret };
|
|
1415
|
+
return [`${colors.cyan("?")} ${question} ${withCaret(colors, typed, roomAfter(question, columns), line.text === "")}`, ...invalid === undefined ? [] : [` ${colors.red(invalid)}`], ...completions.length > 1 ? [listed2(colors, completions, columns)] : []];
|
|
1416
|
+
}, (key) => {
|
|
1417
|
+
if (key === "cancel")
|
|
1418
|
+
return "cancel";
|
|
1419
|
+
invalid = undefined;
|
|
1420
|
+
completions = [];
|
|
1421
|
+
if (line.chained === true && endsKills(key))
|
|
1422
|
+
line = { ...line, chained: false };
|
|
1423
|
+
if (key === "tab") {
|
|
1424
|
+
const chars = [...line.text];
|
|
1425
|
+
const before = chars.slice(0, line.caret).join("");
|
|
1426
|
+
const found = complete?.(before) ?? [];
|
|
1427
|
+
const filled = sharedStart(found);
|
|
1428
|
+
if ([...filled].length > [...before].length)
|
|
1429
|
+
line = { ...line, text: filled + chars.slice(line.caret).join(""), caret: [...filled].length };
|
|
1430
|
+
else
|
|
1431
|
+
completions = found;
|
|
1432
|
+
return;
|
|
1433
|
+
}
|
|
1434
|
+
if (key === "enter") {
|
|
1435
|
+
invalid = validate?.(taken());
|
|
1436
|
+
return invalid === undefined ? "enter" : undefined;
|
|
1437
|
+
}
|
|
1438
|
+
if (key === "up" || key === "down") {
|
|
1439
|
+
const to = Math.min(Math.max(recalled + (key === "up" ? 1 : -1), -1), earlier.length - 1);
|
|
1440
|
+
if (recalled === -1)
|
|
1441
|
+
draft = line;
|
|
1442
|
+
recalled = to;
|
|
1443
|
+
const shown = to === -1 ? draft : { text: earlier[to], caret: [...earlier[to]].length };
|
|
1444
|
+
line = { ...shown, killed: line.killed ?? "" };
|
|
1445
|
+
return;
|
|
1446
|
+
}
|
|
1447
|
+
const edit = { home: "linestart", end: "lineend" }[key] ?? key;
|
|
1448
|
+
if (typeof edit === "object" || isEditKey(edit))
|
|
1449
|
+
line = editLine(line, edit);
|
|
1450
|
+
return;
|
|
1451
|
+
});
|
|
1452
|
+
if (!accepted)
|
|
1453
|
+
return;
|
|
1454
|
+
if (remembered !== undefined && taken() !== "")
|
|
1455
|
+
rememberAnswer(remembered, taken());
|
|
1456
|
+
return taken();
|
|
1457
|
+
}
|
|
1458
|
+
function answer(colors, question, state, picked) {
|
|
1459
|
+
return state === "enter" ? `${colors.green("\u2713")} ${question} ${colors.cyan(picked)}` : `${colors.red("\u2717")} ${question} ${colors.dim("cancelled")}`;
|
|
1460
|
+
}
|
|
1461
|
+
async function ask(question, { hint, terminal = process15 }, render, press) {
|
|
1462
|
+
const { stdin, stderr } = terminal;
|
|
1463
|
+
if (!isInteractive(terminal))
|
|
1464
|
+
fail(`cannot ask "${question}" off a terminal`, 2, hint);
|
|
1465
|
+
const colors = paint(stderr);
|
|
1466
|
+
let current = "asking";
|
|
1467
|
+
let outcome;
|
|
1468
|
+
const columns = () => stderr.columns || 80;
|
|
1469
|
+
const draw = (state, last = false) => {
|
|
1470
|
+
const frame = render(colors, state, { columns: columns(), rows: stderr.rows || 24 });
|
|
1471
|
+
const rows = rowsTaken(frame, columns());
|
|
1472
|
+
stderr.write(`${SYNC_START}\r${overwrite(frame, columns())}\x1B[0J${last || rows < 2 ? "" : `\x1B[${rows - 1}A`}${last ? "" : "\r"}${SYNC_END}`);
|
|
1473
|
+
current = state;
|
|
1474
|
+
};
|
|
1475
|
+
const redraw = () => draw(current);
|
|
1476
|
+
const paste = { active: false };
|
|
1477
|
+
const stop = terminal.stop ?? (terminal === process15 ? stopJob : undefined);
|
|
1478
|
+
const suspend = () => {
|
|
1479
|
+
if (stop === undefined)
|
|
1480
|
+
return;
|
|
1481
|
+
stderr.write("\x1B[0J\x1B[?25h\x1B[?2004l");
|
|
1482
|
+
stdin.setRawMode(false);
|
|
1483
|
+
stop();
|
|
1484
|
+
stdin.setRawMode(true);
|
|
1485
|
+
stderr.write("\x1B[?25l\x1B[?2004h");
|
|
1486
|
+
};
|
|
1487
|
+
try {
|
|
1488
|
+
stderr.on?.("resize", redraw);
|
|
1489
|
+
stdin.setRawMode(true);
|
|
1490
|
+
stdin.resume();
|
|
1491
|
+
stderr.write("\x1B[?25l\x1B[?2004h");
|
|
1492
|
+
draw("asking");
|
|
1493
|
+
return await new Promise((resolve) => {
|
|
1494
|
+
function onData(data) {
|
|
1495
|
+
for (const key of readKeys(data.toString(), paste)) {
|
|
1496
|
+
if (key === "suspend") {
|
|
1497
|
+
suspend();
|
|
1498
|
+
continue;
|
|
1499
|
+
}
|
|
1500
|
+
const pressed = press(key);
|
|
1501
|
+
if (pressed !== undefined) {
|
|
1502
|
+
settle(pressed);
|
|
1503
|
+
return;
|
|
1504
|
+
}
|
|
1505
|
+
}
|
|
1506
|
+
draw("asking");
|
|
1507
|
+
}
|
|
1508
|
+
function onEnd() {
|
|
1509
|
+
settle("cancel");
|
|
1510
|
+
}
|
|
1511
|
+
function settle(settled) {
|
|
1512
|
+
outcome = settled;
|
|
1513
|
+
stdin.off("data", onData);
|
|
1514
|
+
stdin.off("end", onEnd);
|
|
1515
|
+
resolve(settled === "enter");
|
|
1516
|
+
}
|
|
1517
|
+
stdin.on("data", onData);
|
|
1518
|
+
stdin.on("end", onEnd);
|
|
1519
|
+
});
|
|
1520
|
+
} finally {
|
|
1521
|
+
stderr.off?.("resize", redraw);
|
|
1522
|
+
draw(outcome ?? "cancel", true);
|
|
1523
|
+
stderr.write(`
|
|
1524
|
+
\x1B[?25h\x1B[?2004l`);
|
|
1525
|
+
stdin.setRawMode(false);
|
|
1526
|
+
stdin.pause();
|
|
1527
|
+
}
|
|
1528
|
+
}
|
|
1529
|
+
var PROMPT_KEYS, MAX_LISTED = 12;
|
|
1530
|
+
var init_prompt = __esm(() => {
|
|
1531
|
+
init_answers();
|
|
1532
|
+
init_args();
|
|
1533
|
+
init_format();
|
|
1534
|
+
init_job();
|
|
1535
|
+
init_mode();
|
|
1536
|
+
init_line();
|
|
1537
|
+
init_state();
|
|
1538
|
+
init_redraw();
|
|
1539
|
+
init_style();
|
|
1540
|
+
PROMPT_KEYS = new Set(["up", "down", "pageup", "pagedown", "home", "end", "enter", "cancel", "suspend", "tab"]);
|
|
1541
|
+
});
|
|
1542
|
+
|
|
1543
|
+
// src/gp.ts
|
|
1544
|
+
import process24 from "process";
|
|
1545
|
+
|
|
1546
|
+
// ../kit/src/index.ts
|
|
1547
|
+
init_args();
|
|
1548
|
+
|
|
817
1549
|
// ../kit/src/argv.ts
|
|
818
1550
|
import { readFileSync as readFileSync3, realpathSync } from "fs";
|
|
819
1551
|
import { resolve as resolve3 } from "path";
|
|
@@ -838,14 +1570,26 @@ function scriptArgs(argv = process10.argv.slice(2), cmdline = commandLine(), scr
|
|
|
838
1570
|
const after = at === -1 ? [] : cmdline.slice(at + 1);
|
|
839
1571
|
return after[0] === "--" && after.length === argv.length + 1 && argv.every((word, index) => word === after[index + 1]) ? after : argv;
|
|
840
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
|
+
|
|
841
1582
|
// ../kit/src/progress.ts
|
|
1583
|
+
init_format();
|
|
842
1584
|
import process12 from "process";
|
|
843
1585
|
|
|
844
1586
|
// ../kit/src/process.ts
|
|
1587
|
+
import { readFileSync as readFileSync4 } from "fs";
|
|
845
1588
|
import { constants } from "os";
|
|
846
1589
|
import process11 from "process";
|
|
847
1590
|
var KILL_GRACE_MS = 2000;
|
|
848
1591
|
var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
|
|
1592
|
+
var GROUP_SIGNALS = new Set(["SIGINT", "SIGHUP"]);
|
|
849
1593
|
function exitCodeOf(code, signal) {
|
|
850
1594
|
if (code !== null)
|
|
851
1595
|
return code;
|
|
@@ -853,6 +1597,21 @@ function exitCodeOf(code, signal) {
|
|
|
853
1597
|
return 128 + signal;
|
|
854
1598
|
return signal === null ? 129 : 128 + constants.signals[signal];
|
|
855
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
|
+
}
|
|
856
1615
|
function holdSignals(cleanup) {
|
|
857
1616
|
let received;
|
|
858
1617
|
let child;
|
|
@@ -871,7 +1630,8 @@ function holdSignals(cleanup) {
|
|
|
871
1630
|
function onSignal(signal) {
|
|
872
1631
|
received = signal;
|
|
873
1632
|
if (child !== undefined) {
|
|
874
|
-
|
|
1633
|
+
if (!GROUP_SIGNALS.has(signal) || !heardTheTerminal(child))
|
|
1634
|
+
child.kill(signal);
|
|
875
1635
|
return;
|
|
876
1636
|
}
|
|
877
1637
|
if (cleanup === undefined)
|
|
@@ -884,10 +1644,10 @@ function holdSignals(cleanup) {
|
|
|
884
1644
|
process11.on(signal, onSignal);
|
|
885
1645
|
return held;
|
|
886
1646
|
}
|
|
887
|
-
async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
|
|
1647
|
+
async function runCommand(argv, { cwd, env, stdin = "ignore", input, timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
|
|
888
1648
|
const chunks = [];
|
|
889
1649
|
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 } : {} });
|
|
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 } : {} });
|
|
891
1651
|
const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
|
|
892
1652
|
const timers = [];
|
|
893
1653
|
const killGroup = (killing) => {
|
|
@@ -927,12 +1687,19 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
927
1687
|
stop();
|
|
928
1688
|
continue;
|
|
929
1689
|
}
|
|
1690
|
+
if (state.truncated)
|
|
1691
|
+
continue;
|
|
1692
|
+
let kept = data;
|
|
930
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);
|
|
931
1698
|
state.truncated = true;
|
|
932
|
-
continue;
|
|
933
1699
|
}
|
|
934
|
-
state.kept +=
|
|
935
|
-
|
|
1700
|
+
state.kept += kept.length;
|
|
1701
|
+
if (kept.length > 0)
|
|
1702
|
+
chunks.push({ stream: name, data: kept });
|
|
936
1703
|
}
|
|
937
1704
|
};
|
|
938
1705
|
try {
|
|
@@ -949,6 +1716,7 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
949
1716
|
const joined = () => Buffer.concat(chunks.map(({ data }) => data));
|
|
950
1717
|
let output;
|
|
951
1718
|
let text;
|
|
1719
|
+
let stdout;
|
|
952
1720
|
return {
|
|
953
1721
|
code: exitCodeOf(proc.exitCode, proc.signalCode),
|
|
954
1722
|
chunks,
|
|
@@ -959,11 +1727,16 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
959
1727
|
},
|
|
960
1728
|
get text() {
|
|
961
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();
|
|
962
1733
|
}
|
|
963
1734
|
};
|
|
964
1735
|
}
|
|
965
1736
|
|
|
966
1737
|
// ../kit/src/progress.ts
|
|
1738
|
+
init_style();
|
|
1739
|
+
init_theme();
|
|
967
1740
|
var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
|
|
968
1741
|
var FRAME_MS = 200;
|
|
969
1742
|
var BAR_WIDTH = 20;
|
|
@@ -981,10 +1754,14 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
|
|
|
981
1754
|
}, print: (text) => void stream.write(`${text}
|
|
982
1755
|
`), stop: () => {
|
|
983
1756
|
return;
|
|
1757
|
+
}, pause: () => () => {
|
|
1758
|
+
return;
|
|
984
1759
|
} };
|
|
985
1760
|
const write = stream.write.bind(stream);
|
|
986
1761
|
let frame = 0;
|
|
987
1762
|
let drawn = false;
|
|
1763
|
+
let paused = false;
|
|
1764
|
+
let stopped = false;
|
|
988
1765
|
const columns = () => {
|
|
989
1766
|
const now = stream.getWindowSize?.()[0] ?? stream.columns;
|
|
990
1767
|
return now === undefined || now === 0 ? 80 : now;
|
|
@@ -995,6 +1772,8 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
|
|
|
995
1772
|
drawn = false;
|
|
996
1773
|
};
|
|
997
1774
|
const draw = () => {
|
|
1775
|
+
if (paused)
|
|
1776
|
+
return;
|
|
998
1777
|
const width = columns() - 1;
|
|
999
1778
|
const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
|
|
1000
1779
|
const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
|
|
@@ -1006,16 +1785,17 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
|
|
|
1006
1785
|
`)}${lines.length > 1 ? `\x1B[${lines.length - 1}A` : ""}\r`);
|
|
1007
1786
|
drawn = true;
|
|
1008
1787
|
};
|
|
1009
|
-
|
|
1788
|
+
let timer = setInterval(draw, FRAME_MS);
|
|
1010
1789
|
stream.on?.("resize", draw);
|
|
1011
|
-
|
|
1012
|
-
|
|
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
|
};
|
|
@@ -1147,40 +1952,225 @@ function interceptOutput(clear) {
|
|
|
1147
1952
|
}
|
|
1148
1953
|
};
|
|
1149
1954
|
}
|
|
1955
|
+
|
|
1956
|
+
// ../kit/src/ci.ts
|
|
1957
|
+
init_style();
|
|
1958
|
+
|
|
1959
|
+
// ../kit/src/tool.ts
|
|
1960
|
+
init_format();
|
|
1150
1961
|
// ../kit/src/cli.ts
|
|
1151
|
-
|
|
1152
|
-
import {
|
|
1153
|
-
import
|
|
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 });
|
|
2038
|
+
}
|
|
2039
|
+
};
|
|
2040
|
+
}
|
|
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
|
-
|
|
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 =
|
|
1163
|
-
const id = `kit${
|
|
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 =
|
|
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
|
|
1176
|
-
import { dirname as
|
|
1177
|
-
import
|
|
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
2176
|
var LONGEST_NAME = 40;
|
|
@@ -1188,14 +2178,13 @@ var usageError;
|
|
|
1188
2178
|
function noteUsageError(message) {
|
|
1189
2179
|
usageError = message;
|
|
1190
2180
|
}
|
|
1191
|
-
function stateHome(env =
|
|
1192
|
-
|
|
1193
|
-
return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
|
|
2181
|
+
function stateHome(env = process18.env) {
|
|
2182
|
+
return xdgFolder(env.XDG_STATE_HOME, join7(homedir4(), ".local", "state"));
|
|
1194
2183
|
}
|
|
1195
|
-
function usagePath(env =
|
|
1196
|
-
return
|
|
2184
|
+
function usagePath(env = process18.env) {
|
|
2185
|
+
return join7(stateHome(env), CLI_FOLDER, "usage.jsonl");
|
|
1197
2186
|
}
|
|
1198
|
-
function usageRecorded(env =
|
|
2187
|
+
function usageRecorded(env = process18.env) {
|
|
1199
2188
|
const off = env.KAYNOOO_CLI_NO_USAGE;
|
|
1200
2189
|
return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
|
|
1201
2190
|
}
|
|
@@ -1204,17 +2193,17 @@ function flagNames(argv) {
|
|
|
1204
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);
|
|
1205
2194
|
return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
|
|
1206
2195
|
}
|
|
1207
|
-
function usageEntry(bin, command, argv, code, now = new Date) {
|
|
2196
|
+
function usageEntry(bin, command, argv, code, { ms, now = new Date } = {}) {
|
|
1208
2197
|
const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
|
|
1209
2198
|
usageError = undefined;
|
|
1210
|
-
return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
|
|
2199
|
+
return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown }, ...ms === undefined ? {} : { ms: Math.round(ms) } };
|
|
1211
2200
|
}
|
|
1212
|
-
function recordUsage(entry, env =
|
|
2201
|
+
function recordUsage(entry, env = process18.env) {
|
|
1213
2202
|
if (!usageRecorded(env))
|
|
1214
2203
|
return;
|
|
1215
2204
|
try {
|
|
1216
2205
|
const path = usagePath(env);
|
|
1217
|
-
|
|
2206
|
+
mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
|
|
1218
2207
|
appendFileSync(path, `${JSON.stringify(entry)}
|
|
1219
2208
|
`, { mode: 384 });
|
|
1220
2209
|
} catch {}
|
|
@@ -1225,10 +2214,14 @@ var LEVEL_OPTIONS = {
|
|
|
1225
2214
|
...OUTPUT_OPTIONS,
|
|
1226
2215
|
help: { type: "boolean", short: "h", description: "show this help" }
|
|
1227
2216
|
};
|
|
1228
|
-
var TOP_OPTIONS = {
|
|
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
|
+
};
|
|
1229
2222
|
function printError(prefix, message, hint, cause) {
|
|
1230
|
-
const colors = paint(
|
|
1231
|
-
const styled = takesControlCodes(
|
|
2223
|
+
const colors = paint(process19.stderr);
|
|
2224
|
+
const styled = takesControlCodes(process19.stderr);
|
|
1232
2225
|
const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
|
|
1233
2226
|
const under = (label, text, tint) => text === undefined ? "" : `
|
|
1234
2227
|
${styled ? tint(label) : `${label}:`} ${text}`;
|
|
@@ -1308,6 +2301,19 @@ async function leafCandidates(run, words) {
|
|
|
1308
2301
|
const values = name === undefined ? undefined : await completing.candidates[name]?.(typed);
|
|
1309
2302
|
return values === undefined ? [FILES] : values.map(candidateLine);
|
|
1310
2303
|
}
|
|
2304
|
+
var COMPLETIONS = "--completions";
|
|
2305
|
+
function flagValue([flag = "", ...rest]) {
|
|
2306
|
+
return flag.includes("=") ? [flag.slice(flag.indexOf("=") + 1), ...rest] : rest;
|
|
2307
|
+
}
|
|
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;
|
|
2316
|
+
}
|
|
1311
2317
|
async function printCandidates(found) {
|
|
1312
2318
|
for (const line of await found)
|
|
1313
2319
|
console.log(line);
|
|
@@ -1318,19 +2324,24 @@ function packageVersion(entry = Bun.main) {
|
|
|
1318
2324
|
try {
|
|
1319
2325
|
resolved = realpathSync2(entry);
|
|
1320
2326
|
} catch {}
|
|
1321
|
-
for (let dir =
|
|
2327
|
+
for (let dir = dirname4(resolved);; dir = dirname4(dir)) {
|
|
1322
2328
|
try {
|
|
1323
|
-
const { version } = JSON.parse(
|
|
2329
|
+
const { version } = JSON.parse(readFileSync6(join8(dir, "package.json"), "utf8"));
|
|
1324
2330
|
if (typeof version === "string")
|
|
1325
2331
|
return version;
|
|
1326
2332
|
} catch {}
|
|
1327
|
-
if (
|
|
2333
|
+
if (dirname4(dir) === dir)
|
|
1328
2334
|
return "0.0.0";
|
|
1329
2335
|
}
|
|
1330
2336
|
}
|
|
1331
2337
|
async function runMain({ name, version, run, redact, usage }, argv = scriptArgs()) {
|
|
2338
|
+
const answered = await askpassClient(argv);
|
|
2339
|
+
if (answered !== undefined)
|
|
2340
|
+
return answered;
|
|
1332
2341
|
if (argv[0] === COMPLETE)
|
|
1333
2342
|
return printCandidates(leafCandidates(run, argv.slice(1)));
|
|
2343
|
+
if (argv[0] === COMPLETIONS || argv[0]?.startsWith(`${COMPLETIONS}=`) === true)
|
|
2344
|
+
return printCompletionScript(name, flagValue(argv));
|
|
1334
2345
|
if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
|
|
1335
2346
|
console.log(version ?? packageVersion());
|
|
1336
2347
|
return 0;
|
|
@@ -1345,21 +2356,52 @@ async function runMain({ name, version, run, redact, usage }, argv = scriptArgs(
|
|
|
1345
2356
|
notifyEnd(name, code, performance.now() - started);
|
|
1346
2357
|
if (usage !== false) {
|
|
1347
2358
|
try {
|
|
1348
|
-
recordUsage(usageEntry(name, undefined, argv, code));
|
|
2359
|
+
recordUsage(usageEntry(name, undefined, argv, code, { ms: performance.now() - started }));
|
|
1349
2360
|
} catch {}
|
|
1350
2361
|
}
|
|
1351
2362
|
return code;
|
|
1352
2363
|
}
|
|
1353
|
-
|
|
1354
|
-
|
|
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();
|
|
1355
2386
|
// ../kit/src/secrets.ts
|
|
1356
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"]);
|
|
1357
2389
|
// ../kit/src/sessions.ts
|
|
1358
2390
|
var {Glob } = globalThis.Bun;
|
|
1359
2391
|
var SESSION_FILES = new Glob("*.json");
|
|
1360
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
|
+
|
|
1361
2400
|
// ../kit/src/watch.ts
|
|
1362
|
-
|
|
2401
|
+
init_args();
|
|
2402
|
+
init_input();
|
|
2403
|
+
init_style();
|
|
2404
|
+
import process20 from "process";
|
|
1363
2405
|
import { format } from "util";
|
|
1364
2406
|
var CLEAR_SCREEN = "\x1B[H\x1B[2J";
|
|
1365
2407
|
var DEFAULT_SECONDS = 2;
|
|
@@ -1381,7 +2423,7 @@ function withoutWatch(args) {
|
|
|
1381
2423
|
}
|
|
1382
2424
|
return rest;
|
|
1383
2425
|
}
|
|
1384
|
-
async function watching(value, step, stream =
|
|
2426
|
+
async function watching(value, step, stream = process20.stdout, sleep = Bun.sleep, rounds = Number.POSITIVE_INFINITY) {
|
|
1385
2427
|
const interval = value === "" ? DEFAULT_SECONDS * 1000 : duration(value, "watch", DEFAULT_SECONDS * 1000);
|
|
1386
2428
|
if (!takesControlCodes(stream))
|
|
1387
2429
|
badUsage("--watch redraws the screen, so it needs a terminal");
|
|
@@ -1389,12 +2431,12 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
|
|
|
1389
2431
|
for (let round = 0;round < rounds; round++) {
|
|
1390
2432
|
const held = [];
|
|
1391
2433
|
const { log, info } = console;
|
|
1392
|
-
const write =
|
|
2434
|
+
const write = process20.stdout.write.bind(process20.stdout);
|
|
1393
2435
|
const hold = (...parts) => void held.push(`${format(...parts)}
|
|
1394
2436
|
`);
|
|
1395
2437
|
console.log = hold;
|
|
1396
2438
|
console.info = hold;
|
|
1397
|
-
|
|
2439
|
+
process20.stdout.write = (text) => {
|
|
1398
2440
|
held.push(typeof text === "string" ? text : Buffer.from(text).toString());
|
|
1399
2441
|
return true;
|
|
1400
2442
|
};
|
|
@@ -1403,7 +2445,7 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
|
|
|
1403
2445
|
} finally {
|
|
1404
2446
|
console.log = log;
|
|
1405
2447
|
console.info = info;
|
|
1406
|
-
|
|
2448
|
+
process20.stdout.write = write;
|
|
1407
2449
|
}
|
|
1408
2450
|
stream.write(`${CLEAR_SCREEN}${held.join("")}`);
|
|
1409
2451
|
await sleep(interval);
|
|
@@ -1411,21 +2453,22 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
|
|
|
1411
2453
|
return code;
|
|
1412
2454
|
}
|
|
1413
2455
|
// ../kit/src/workspace-root.ts
|
|
1414
|
-
|
|
1415
|
-
import {
|
|
1416
|
-
import
|
|
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";
|
|
1417
2460
|
function expandHome(path, home) {
|
|
1418
2461
|
if (path === "~")
|
|
1419
2462
|
return home;
|
|
1420
|
-
return path.startsWith("~/") ?
|
|
2463
|
+
return path.startsWith("~/") ? join9(home, path.slice(2)) : path;
|
|
1421
2464
|
}
|
|
1422
2465
|
function configured(env, home) {
|
|
1423
2466
|
const folder = readUserConfig("config", { home, xdg: env.XDG_CONFIG_HOME }).workspace;
|
|
1424
2467
|
return typeof folder === "string" && folder !== "" ? folder : undefined;
|
|
1425
2468
|
}
|
|
1426
|
-
function workspaceRoot({ given, env =
|
|
2469
|
+
function workspaceRoot({ given, env = process21.env, home = homedir5() } = {}) {
|
|
1427
2470
|
const fromEnv = env.KAYNOOO_WORKSPACE === "" ? undefined : env.KAYNOOO_WORKSPACE;
|
|
1428
|
-
return resolve4(expandHome(given ?? fromEnv ?? configured(env, home) ??
|
|
2471
|
+
return resolve4(expandHome(given ?? fromEnv ?? configured(env, home) ?? join9(home, "Workspace"), home));
|
|
1429
2472
|
}
|
|
1430
2473
|
// src/git.ts
|
|
1431
2474
|
async function git2(args, env) {
|
|
@@ -1436,8 +2479,8 @@ async function git2(args, env) {
|
|
|
1436
2479
|
|
|
1437
2480
|
// src/repos.ts
|
|
1438
2481
|
import { readdir } from "fs/promises";
|
|
1439
|
-
import { join as
|
|
1440
|
-
import
|
|
2482
|
+
import { join as join10, relative, resolve as resolve5 } from "path";
|
|
2483
|
+
import process23 from "process";
|
|
1441
2484
|
|
|
1442
2485
|
// src/status.ts
|
|
1443
2486
|
var AHEAD_BEHIND = /\+(\d+) -(\d+)/;
|
|
@@ -1533,7 +2576,7 @@ async function reposUnder(root, depth = DEPTH) {
|
|
|
1533
2576
|
found.push(dir);
|
|
1534
2577
|
if (left === 0)
|
|
1535
2578
|
return;
|
|
1536
|
-
await Promise.all(entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && !SKIPPED.has(entry.name)).map(async (entry) => walk(
|
|
2579
|
+
await Promise.all(entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && !SKIPPED.has(entry.name)).map(async (entry) => walk(join10(dir, entry.name), left - 1)));
|
|
1537
2580
|
}
|
|
1538
2581
|
await walk(resolve5(root), depth);
|
|
1539
2582
|
return found.sort();
|
|
@@ -1543,14 +2586,14 @@ async function toplevelOf(dir) {
|
|
|
1543
2586
|
return read.code === 0 ? read.stdout.trim() : undefined;
|
|
1544
2587
|
}
|
|
1545
2588
|
async function reposOf(roots) {
|
|
1546
|
-
const starts = roots.length > 0 ? roots : [await toplevelOf(".") ??
|
|
2589
|
+
const starts = roots.length > 0 ? roots : [await toplevelOf(".") ?? process23.cwd()];
|
|
1547
2590
|
const found = await Promise.all(starts.map(async (root) => reposUnder(root)));
|
|
1548
2591
|
return [...new Set(found.flat())].sort();
|
|
1549
2592
|
}
|
|
1550
2593
|
async function repoState(dir) {
|
|
1551
2594
|
const [read, log] = await Promise.all([git2(["-C", dir, "status", "--porcelain=v2", "--branch"]), git2(["-C", dir, "log", "-1", "--format=%h%x00%s"])]);
|
|
1552
2595
|
const [sha, title = ""] = log.code === 0 && log.stdout.trim() !== "" ? log.stdout.trim().split("\x00") : [];
|
|
1553
|
-
return { path: relative(
|
|
2596
|
+
return { path: relative(process23.cwd(), dir) || ".", dir, status: read.code === 0 ? parseStatus(read.stdout) : null, head: sha === undefined ? null : { sha, title } };
|
|
1554
2597
|
}
|
|
1555
2598
|
function trackingOf(status) {
|
|
1556
2599
|
if (status.upstream === null)
|
|
@@ -1586,7 +2629,7 @@ async function dirsOf(positionals, all) {
|
|
|
1586
2629
|
}
|
|
1587
2630
|
|
|
1588
2631
|
// src/gp.ts
|
|
1589
|
-
var USAGE = `gp [dir]...: pushes the current branch of the repository, or of each dir
|
|
2632
|
+
var USAGE = `gp [dir]...: pushes the current branch of the repository, or of each dir, when it is ahead of its upstream or has none yet
|
|
1590
2633
|
|
|
1591
2634
|
--repos pushes every repository at and below the current one's toplevel, or below each dir given, the way gst --repos lists them. A detached HEAD, a branch with nothing to push and a repository with no remote are skipped, saying so; the pushes run one after another.
|
|
1592
2635
|
What follows -- goes to every git push as is (gp -- --tags, gp -- --force-with-lease), and a branch with nothing ahead is then pushed too.`;
|
|
@@ -1613,7 +2656,7 @@ async function unpushed(dir, branch) {
|
|
|
1613
2656
|
const count = await git2(["-C", dir, "rev-list", "--count", branch, "--not", "--remotes"]);
|
|
1614
2657
|
return count.code === 0 ? Number(count.stdout.trim()) : null;
|
|
1615
2658
|
}
|
|
1616
|
-
async function push(repo, { dryRun, extra }) {
|
|
2659
|
+
async function push(repo, { dryRun, extra, env }) {
|
|
1617
2660
|
const { path, dir, status } = repo;
|
|
1618
2661
|
const skipped = (reason, branch = null) => ({ path, branch, remote: null, commits: null, outcome: "skipped", reason });
|
|
1619
2662
|
if (status === null)
|
|
@@ -1625,6 +2668,8 @@ async function push(repo, { dryRun, extra }) {
|
|
|
1625
2668
|
let remote;
|
|
1626
2669
|
let commits;
|
|
1627
2670
|
if (upstream === null) {
|
|
2671
|
+
if ((await git2(["-C", dir, "rev-parse", "--verify", "--quiet", "HEAD"])).code !== 0)
|
|
2672
|
+
return skipped("no commit yet, nothing to push", branch);
|
|
1628
2673
|
const name = await remoteFor(dir);
|
|
1629
2674
|
if (name === undefined)
|
|
1630
2675
|
return skipped("no upstream, and no origin remote to push to", branch);
|
|
@@ -1640,20 +2685,20 @@ async function push(repo, { dryRun, extra }) {
|
|
|
1640
2685
|
}
|
|
1641
2686
|
if (dryRun)
|
|
1642
2687
|
return { path, branch, remote, commits, outcome: "would-push" };
|
|
1643
|
-
const pushed = await git2(["-C", dir, ...args]);
|
|
2688
|
+
const pushed = await git2(["-C", dir, ...args], env);
|
|
1644
2689
|
return pushed.code === 0 ? { path, branch, remote, commits, outcome: "pushed" } : { path, branch, remote, commits, outcome: "refused", reason: whyRefused(pushed.stderr) };
|
|
1645
2690
|
}
|
|
1646
2691
|
function line(result) {
|
|
1647
|
-
const { dim } = paint(
|
|
2692
|
+
const { dim } = paint(process24.stdout);
|
|
1648
2693
|
const sent = result.commits === null ? "" : `, ${result.commits} ${result.commits === 1 ? "commit" : "commits"}`;
|
|
1649
2694
|
const what = `${result.branch} -> ${result.remote}${sent}`;
|
|
1650
2695
|
const said = {
|
|
1651
|
-
pushed: () => marked("ok", `pushed ${what}`,
|
|
2696
|
+
pushed: () => marked("ok", `pushed ${what}`, process24.stdout),
|
|
1652
2697
|
"would-push": () => `would push ${what}`,
|
|
1653
2698
|
skipped: () => dim(result.reason ?? "skipped"),
|
|
1654
|
-
refused: () => marked("problem", `${result.branch === null ? "" : `${result.branch}: `}${result.reason ?? "refused"}`,
|
|
2699
|
+
refused: () => marked("problem", `${result.branch === null ? "" : `${result.branch}: `}${result.reason ?? "refused"}`, process24.stdout)
|
|
1655
2700
|
}[result.outcome];
|
|
1656
|
-
return [role("path",
|
|
2701
|
+
return [role("path", process24.stdout)(result.path), said()];
|
|
1657
2702
|
}
|
|
1658
2703
|
async function main(argv) {
|
|
1659
2704
|
const { values, positionals, rest = [] } = parse(argv, USAGE, OPTIONS, { positionals: ["[dir]..."], rest: true, exits: EXITS, replaces: "git push, git push -u origin <branch> and a git -C <repo> push per nested repository", examples: ["gp", ["gp --repos", "every repository nested in this one"], ["gp --repos --dry-run", "what would go out"], ["gp . ../other", "this repository and a sibling"], ["gp -- --force-with-lease", "flags for git push"]] });
|
|
@@ -1661,15 +2706,21 @@ async function main(argv) {
|
|
|
1661
2706
|
const repos = await Promise.all(dirs.map(repoState));
|
|
1662
2707
|
const results = [];
|
|
1663
2708
|
const progress = progressLine();
|
|
1664
|
-
|
|
1665
|
-
|
|
1666
|
-
|
|
2709
|
+
const prompts = askpass(progress.pause);
|
|
2710
|
+
const env = prompts === undefined ? undefined : { ...process24.env, ...prompts.env };
|
|
2711
|
+
try {
|
|
2712
|
+
for (const [at, repo] of repos.entries()) {
|
|
2713
|
+
progress.update(repos.length > 1 ? { step: `pushing ${repo.path}`, done: at, total: repos.length, unit: "repositories" } : { step: `pushing ${repo.path}` });
|
|
2714
|
+
results.push(await push(repo, { dryRun: values["dry-run"] === true, extra: rest, env }));
|
|
2715
|
+
}
|
|
2716
|
+
} finally {
|
|
2717
|
+
prompts?.close();
|
|
2718
|
+
progress.stop();
|
|
1667
2719
|
}
|
|
1668
|
-
progress.stop();
|
|
1669
2720
|
if (values.json === true)
|
|
1670
2721
|
printJson(results);
|
|
1671
2722
|
else
|
|
1672
2723
|
console.log(table(results.map(line)));
|
|
1673
2724
|
return results.some((result) => result.outcome === "refused") ? 1 : 0;
|
|
1674
2725
|
}
|
|
1675
|
-
|
|
2726
|
+
process24.exitCode = await runMain({ name: "gp", run: main });
|