@kaynooo/cli-git 0.16.1 → 0.18.0
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 +5 -4
- package/dist/gb.js +1728 -1143
- package/dist/gc.js +1173 -178
- package/dist/gcl.js +1165 -181
- package/dist/gd.js +1152 -183
- package/dist/gf.js +1172 -182
- package/dist/gm.js +1799 -1172
- package/dist/gp.js +1183 -188
- package/dist/gst.js +1149 -185
- package/dist/gu.js +1152 -178
- package/package.json +5 -5
package/dist/gc.js
CHANGED
|
@@ -1,20 +1,19 @@
|
|
|
1
1
|
#!/usr/bin/env -S bun --no-env-file --config=/dev/null
|
|
2
2
|
// @bun
|
|
3
|
+
var __esm = (fn, res, err) => () => {
|
|
4
|
+
if (fn)
|
|
5
|
+
try {
|
|
6
|
+
res = fn(fn = 0);
|
|
7
|
+
} catch (e) {
|
|
8
|
+
err = [e];
|
|
9
|
+
}
|
|
10
|
+
if (err)
|
|
11
|
+
throw err[0];
|
|
12
|
+
return res;
|
|
13
|
+
};
|
|
3
14
|
|
|
4
|
-
//
|
|
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", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
|
|
646
|
-
plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
|
|
647
|
-
};
|
|
648
695
|
function applyOutput(color, plain, env = process9.env) {
|
|
649
696
|
const when = plain === true ? "never" : color ?? "auto";
|
|
650
697
|
if (when === "auto")
|
|
@@ -798,7 +845,6 @@ function parseError(error) {
|
|
|
798
845
|
const message = upTo(error instanceof Error ? error.message : String(error), ". ");
|
|
799
846
|
return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
|
|
800
847
|
}
|
|
801
|
-
var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
|
|
802
848
|
function nearestOption(message, options, allowNegative) {
|
|
803
849
|
const typed = UNKNOWN_OPTION.exec(message)?.[1];
|
|
804
850
|
if (typed === undefined)
|
|
@@ -814,6 +860,694 @@ function nearestOption(message, options, allowNegative) {
|
|
|
814
860
|
const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
|
|
815
861
|
return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
|
|
816
862
|
}
|
|
863
|
+
var DASHES, EXIT, Exit, UsageError, HelpShown, completion, OUTPUT_OPTIONS, UNKNOWN_OPTION;
|
|
864
|
+
var init_args = __esm(() => {
|
|
865
|
+
init_format();
|
|
866
|
+
init_help();
|
|
867
|
+
init_text2();
|
|
868
|
+
init_help();
|
|
869
|
+
init_input();
|
|
870
|
+
DASHES = /^-+/;
|
|
871
|
+
EXIT = Symbol.for("@kaynooo/cli-kit/Exit");
|
|
872
|
+
Exit = class Exit extends Error {
|
|
873
|
+
code;
|
|
874
|
+
hint;
|
|
875
|
+
[EXIT] = true;
|
|
876
|
+
constructor(message, code, hint) {
|
|
877
|
+
super(message);
|
|
878
|
+
this.code = code;
|
|
879
|
+
this.hint = hint;
|
|
880
|
+
}
|
|
881
|
+
static [Symbol.hasInstance](value) {
|
|
882
|
+
if (this !== Exit)
|
|
883
|
+
return Function.prototype[Symbol.hasInstance].call(this, value);
|
|
884
|
+
return typeof value === "object" && value !== null && value[EXIT] === true;
|
|
885
|
+
}
|
|
886
|
+
};
|
|
887
|
+
UsageError = class UsageError extends Exit {
|
|
888
|
+
constructor(message, hint) {
|
|
889
|
+
super(message, 2, hint);
|
|
890
|
+
}
|
|
891
|
+
};
|
|
892
|
+
HelpShown = class HelpShown extends Exit {
|
|
893
|
+
constructor() {
|
|
894
|
+
super("help shown", 0);
|
|
895
|
+
}
|
|
896
|
+
};
|
|
897
|
+
completion = { active: false };
|
|
898
|
+
OUTPUT_OPTIONS = {
|
|
899
|
+
color: { type: "string", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
|
|
900
|
+
plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
|
|
901
|
+
};
|
|
902
|
+
UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
|
|
903
|
+
});
|
|
904
|
+
|
|
905
|
+
// ../kit/src/folders.ts
|
|
906
|
+
import { homedir as homedir3 } from "os";
|
|
907
|
+
import { join as join4 } from "path";
|
|
908
|
+
import process13 from "process";
|
|
909
|
+
function cacheFolder({ home = homedir3(), env = process13.env } = {}) {
|
|
910
|
+
return xdgFolder(env.XDG_CACHE_HOME, join4(home, ".cache"));
|
|
911
|
+
}
|
|
912
|
+
var SKIPPED_FOLDERS;
|
|
913
|
+
var init_folders = __esm(() => {
|
|
914
|
+
init_user_config();
|
|
915
|
+
SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
|
|
916
|
+
});
|
|
917
|
+
|
|
918
|
+
// ../kit/src/answers.ts
|
|
919
|
+
import { mkdirSync, readFileSync as readFileSync5, writeFileSync } from "fs";
|
|
920
|
+
import { dirname as dirname2, join as join5 } from "path";
|
|
921
|
+
function answersFile() {
|
|
922
|
+
return join5(cacheFolder(), "kaynooo-cli", "answers.json");
|
|
923
|
+
}
|
|
924
|
+
function stored() {
|
|
925
|
+
try {
|
|
926
|
+
const parsed = JSON.parse(readFileSync5(answersFile(), "utf-8"));
|
|
927
|
+
if (typeof parsed !== "object" || parsed === null)
|
|
928
|
+
return {};
|
|
929
|
+
return Object.fromEntries(Object.entries(parsed).filter((entry) => Array.isArray(entry[1]) && entry[1].every((answer) => typeof answer === "string")));
|
|
930
|
+
} catch {
|
|
931
|
+
return {};
|
|
932
|
+
}
|
|
933
|
+
}
|
|
934
|
+
function earlierAnswers(key) {
|
|
935
|
+
return stored()[key] ?? [];
|
|
936
|
+
}
|
|
937
|
+
function rememberAnswer(key, answer) {
|
|
938
|
+
const all = stored();
|
|
939
|
+
const file = answersFile();
|
|
940
|
+
all[key] = [answer, ...(all[key] ?? []).filter((earlier) => earlier !== answer)].slice(0, KEPT);
|
|
941
|
+
try {
|
|
942
|
+
mkdirSync(dirname2(file), { recursive: true });
|
|
943
|
+
writeFileSync(file, JSON.stringify(all));
|
|
944
|
+
} catch {}
|
|
945
|
+
}
|
|
946
|
+
var KEPT = 50;
|
|
947
|
+
var init_answers = __esm(() => {
|
|
948
|
+
init_folders();
|
|
949
|
+
});
|
|
950
|
+
|
|
951
|
+
// ../kit/src/job.ts
|
|
952
|
+
import process14 from "process";
|
|
953
|
+
function stopJob() {
|
|
954
|
+
process14.kill(0, "SIGTSTP");
|
|
955
|
+
}
|
|
956
|
+
var init_job = () => {};
|
|
957
|
+
|
|
958
|
+
// ../kit/src/picker/line.ts
|
|
959
|
+
function isEditKey(key) {
|
|
960
|
+
return EDIT_KEYS.has(key);
|
|
961
|
+
}
|
|
962
|
+
function endsKills(key) {
|
|
963
|
+
return typeof key !== "object" && !isEditKey(key);
|
|
964
|
+
}
|
|
965
|
+
function isWord(char) {
|
|
966
|
+
return char !== undefined && WORD_CHARACTER.test(char);
|
|
967
|
+
}
|
|
968
|
+
function wordStart(chars, from) {
|
|
969
|
+
let at = from;
|
|
970
|
+
while (at > 0 && !isWord(chars[at - 1]))
|
|
971
|
+
at--;
|
|
972
|
+
while (at > 0 && isWord(chars[at - 1]))
|
|
973
|
+
at--;
|
|
974
|
+
return at;
|
|
975
|
+
}
|
|
976
|
+
function wordEnd(chars, from) {
|
|
977
|
+
let at = from;
|
|
978
|
+
while (at < chars.length && !isWord(chars[at]))
|
|
979
|
+
at++;
|
|
980
|
+
while (at < chars.length && isWord(chars[at]))
|
|
981
|
+
at++;
|
|
982
|
+
return at;
|
|
983
|
+
}
|
|
984
|
+
function spacedStart(chars, from) {
|
|
985
|
+
let at = from;
|
|
986
|
+
while (at > 0 && SPACE.test(chars[at - 1] ?? ""))
|
|
987
|
+
at--;
|
|
988
|
+
while (at > 0 && !SPACE.test(chars[at - 1] ?? ""))
|
|
989
|
+
at--;
|
|
990
|
+
return at;
|
|
991
|
+
}
|
|
992
|
+
function cut(chars, from, to) {
|
|
993
|
+
return { text: [...chars.slice(0, from), ...chars.slice(to)].join(""), caret: from };
|
|
994
|
+
}
|
|
995
|
+
function insert(chars, at, text) {
|
|
996
|
+
const typed = [...text];
|
|
997
|
+
return { text: [...chars.slice(0, at), ...typed, ...chars.slice(at)].join(""), caret: at + typed.length };
|
|
998
|
+
}
|
|
999
|
+
function editLine(line, key) {
|
|
1000
|
+
const { killed = "", chained = false } = line;
|
|
1001
|
+
const chars = [...line.text];
|
|
1002
|
+
const at = Math.min(Math.max(line.caret, 0), chars.length);
|
|
1003
|
+
const edited = edit(chars, at, key, killed);
|
|
1004
|
+
if (typeof key === "object" || !BACKWARD_KILLS.has(key) && !FORWARD_KILLS.has(key))
|
|
1005
|
+
return line.killed === undefined ? edited : { ...edited, killed };
|
|
1006
|
+
const taken = chars.slice(edited.caret, edited.caret + chars.length - [...edited.text].length).join("");
|
|
1007
|
+
if (taken === "")
|
|
1008
|
+
return { ...edited, killed, chained };
|
|
1009
|
+
if (!chained)
|
|
1010
|
+
return { ...edited, killed: taken, chained: true };
|
|
1011
|
+
return { ...edited, killed: BACKWARD_KILLS.has(key) ? taken + killed : killed + taken, chained: true };
|
|
1012
|
+
}
|
|
1013
|
+
function edit(chars, at, key, killed) {
|
|
1014
|
+
const text = chars.join("");
|
|
1015
|
+
if (typeof key === "object")
|
|
1016
|
+
return insert(chars, at, key.text);
|
|
1017
|
+
switch (key) {
|
|
1018
|
+
case "left":
|
|
1019
|
+
return { text, caret: Math.max(at - 1, 0) };
|
|
1020
|
+
case "right":
|
|
1021
|
+
return { text, caret: Math.min(at + 1, chars.length) };
|
|
1022
|
+
case "wordleft":
|
|
1023
|
+
return { text, caret: wordStart(chars, at) };
|
|
1024
|
+
case "wordright":
|
|
1025
|
+
return { text, caret: wordEnd(chars, at) };
|
|
1026
|
+
case "linestart":
|
|
1027
|
+
return { text, caret: 0 };
|
|
1028
|
+
case "lineend":
|
|
1029
|
+
return { text, caret: chars.length };
|
|
1030
|
+
case "erase":
|
|
1031
|
+
return cut(chars, Math.max(at - 1, 0), at);
|
|
1032
|
+
case "delete":
|
|
1033
|
+
return cut(chars, at, Math.min(at + 1, chars.length));
|
|
1034
|
+
case "word":
|
|
1035
|
+
return cut(chars, spacedStart(chars, at), at);
|
|
1036
|
+
case "killword":
|
|
1037
|
+
return cut(chars, wordStart(chars, at), at);
|
|
1038
|
+
case "killnext":
|
|
1039
|
+
return cut(chars, at, wordEnd(chars, at));
|
|
1040
|
+
case "clear":
|
|
1041
|
+
return cut(chars, 0, at);
|
|
1042
|
+
case "killend":
|
|
1043
|
+
return cut(chars, at, chars.length);
|
|
1044
|
+
case "yank":
|
|
1045
|
+
return insert(chars, at, killed);
|
|
1046
|
+
}
|
|
1047
|
+
}
|
|
1048
|
+
function visible({ text, caret }, room) {
|
|
1049
|
+
const chars = [...text];
|
|
1050
|
+
const at = Math.min(Math.max(caret, 0), chars.length);
|
|
1051
|
+
const cells = at === chars.length ? [...chars, " "] : chars;
|
|
1052
|
+
const widths = cells.map((char) => Bun.stringWidth(char));
|
|
1053
|
+
const width = (from, to) => widths.slice(from, to).reduce((sum, size) => sum + size, 0);
|
|
1054
|
+
const fits = (from, to) => (from > 0 ? 1 : 0) + width(from, to) + (to < cells.length ? 1 : 0) <= room;
|
|
1055
|
+
let start = at;
|
|
1056
|
+
let end = at + 1;
|
|
1057
|
+
while (start > 0 && fits(start - 1, end))
|
|
1058
|
+
start--;
|
|
1059
|
+
while (end < cells.length && fits(start, end + 1))
|
|
1060
|
+
end++;
|
|
1061
|
+
const left = start > 0 ? "\u2026" : "";
|
|
1062
|
+
const right = end < cells.length ? "\u2026" : "";
|
|
1063
|
+
return { before: left + chars.slice(start, at).join(""), at: chars[at], after: chars.slice(at + 1, end).join("") + right, column: left.length + width(start, at) };
|
|
1064
|
+
}
|
|
1065
|
+
var EDIT_KEYS, BACKWARD_KILLS, FORWARD_KILLS, WORD_CHARACTER, SPACE;
|
|
1066
|
+
var init_line = __esm(() => {
|
|
1067
|
+
EDIT_KEYS = new Set(["left", "right", "wordleft", "wordright", "linestart", "lineend", "erase", "delete", "word", "killword", "killnext", "clear", "killend", "yank"]);
|
|
1068
|
+
BACKWARD_KILLS = new Set(["word", "killword", "clear"]);
|
|
1069
|
+
FORWARD_KILLS = new Set(["killnext", "killend"]);
|
|
1070
|
+
WORD_CHARACTER = /[\p{L}\p{N}_]/u;
|
|
1071
|
+
SPACE = /\s/;
|
|
1072
|
+
});
|
|
1073
|
+
|
|
1074
|
+
// ../kit/src/picker/score.ts
|
|
1075
|
+
function startsWord(text, index) {
|
|
1076
|
+
if (index === 0)
|
|
1077
|
+
return true;
|
|
1078
|
+
const before = text[index - 1];
|
|
1079
|
+
return BOUNDARY_AFTER.has(before) || LOWER.test(before) && UPPER.test(text[index]);
|
|
1080
|
+
}
|
|
1081
|
+
function fuzzy(query, text) {
|
|
1082
|
+
if (query === "")
|
|
1083
|
+
return { score: 0, positions: [] };
|
|
1084
|
+
const exact = query !== query.toLowerCase();
|
|
1085
|
+
const needle = exact ? query : query.toLowerCase();
|
|
1086
|
+
const haystack = exact ? text : text.toLowerCase();
|
|
1087
|
+
if (haystack.length !== text.length || needle.length > haystack.length)
|
|
1088
|
+
return;
|
|
1089
|
+
const width = haystack.length;
|
|
1090
|
+
const best = Array.from({ length: needle.length }, () => new Array(width).fill(NONE));
|
|
1091
|
+
const from = Array.from({ length: needle.length }, () => new Array(width).fill(-1));
|
|
1092
|
+
for (let j = 0;j < needle.length; j++) {
|
|
1093
|
+
let run = NONE;
|
|
1094
|
+
let runAt = -1;
|
|
1095
|
+
for (let i = j;i < width; i++) {
|
|
1096
|
+
if (j > 0 && i - 2 >= j - 1) {
|
|
1097
|
+
const candidate = best[j - 1][i - 2] + (i - 2) * GAP;
|
|
1098
|
+
if (candidate > run) {
|
|
1099
|
+
run = candidate;
|
|
1100
|
+
runAt = i - 2;
|
|
1101
|
+
}
|
|
1102
|
+
}
|
|
1103
|
+
if (haystack[i] !== needle[j])
|
|
1104
|
+
continue;
|
|
1105
|
+
const here = MATCH + (startsWord(text, i) ? BOUNDARY : 0) + (i === 0 ? PREFIX : 0);
|
|
1106
|
+
if (j === 0) {
|
|
1107
|
+
best[0][i] = here - i * GAP;
|
|
1108
|
+
continue;
|
|
1109
|
+
}
|
|
1110
|
+
const joined = best[j - 1][i - 1] + CONSECUTIVE;
|
|
1111
|
+
const skipped = run - (i - 1) * GAP;
|
|
1112
|
+
if (joined > NONE && joined >= skipped) {
|
|
1113
|
+
best[j][i] = joined + here;
|
|
1114
|
+
from[j][i] = i - 1;
|
|
1115
|
+
} else if (skipped > NONE) {
|
|
1116
|
+
best[j][i] = skipped + here;
|
|
1117
|
+
from[j][i] = runAt;
|
|
1118
|
+
}
|
|
1119
|
+
}
|
|
1120
|
+
}
|
|
1121
|
+
const last = best[needle.length - 1];
|
|
1122
|
+
let end = -1;
|
|
1123
|
+
for (let i = 0;i < width; i++) {
|
|
1124
|
+
if (last[i] > NONE && (end === -1 || last[i] > last[end]))
|
|
1125
|
+
end = i;
|
|
1126
|
+
}
|
|
1127
|
+
if (end === -1)
|
|
1128
|
+
return;
|
|
1129
|
+
const positions = [];
|
|
1130
|
+
for (let j = needle.length - 1, i = end;j >= 0; j--) {
|
|
1131
|
+
positions.unshift(i);
|
|
1132
|
+
i = from[j][i];
|
|
1133
|
+
}
|
|
1134
|
+
return { score: last[end], positions };
|
|
1135
|
+
}
|
|
1136
|
+
function rank(query, lines) {
|
|
1137
|
+
if (query === "")
|
|
1138
|
+
return lines.map((_, index) => ({ index, positions: [] }));
|
|
1139
|
+
const found = [];
|
|
1140
|
+
for (const [index, line] of lines.entries()) {
|
|
1141
|
+
const match = fuzzy(query, line);
|
|
1142
|
+
if (match !== undefined)
|
|
1143
|
+
found.push({ index, positions: match.positions, score: match.score });
|
|
1144
|
+
}
|
|
1145
|
+
return found.sort((a, b) => b.score - a.score || lines[a.index].length - lines[b.index].length || a.index - b.index);
|
|
1146
|
+
}
|
|
1147
|
+
var MATCH = 16, CONSECUTIVE = 12, BOUNDARY = 10, PREFIX = 8, GAP = 1, BOUNDARY_AFTER, UPPER, LOWER, NONE;
|
|
1148
|
+
var init_score = __esm(() => {
|
|
1149
|
+
BOUNDARY_AFTER = new Set([" ", "/", "-", "_", ".", ":", "\\", "(", "[", ",", "\t"]);
|
|
1150
|
+
UPPER = /\p{Lu}/u;
|
|
1151
|
+
LOWER = /\p{Ll}/u;
|
|
1152
|
+
NONE = Number.NEGATIVE_INFINITY;
|
|
1153
|
+
});
|
|
1154
|
+
|
|
1155
|
+
// ../kit/src/picker/state.ts
|
|
1156
|
+
function repeat(value, count) {
|
|
1157
|
+
return Array.from({ length: count }).fill(value);
|
|
1158
|
+
}
|
|
1159
|
+
function styled(line) {
|
|
1160
|
+
let text = "";
|
|
1161
|
+
const styles = [];
|
|
1162
|
+
let active = "";
|
|
1163
|
+
let colored = false;
|
|
1164
|
+
let last = 0;
|
|
1165
|
+
function add(chunk) {
|
|
1166
|
+
const flat = chunk.replace(CONTROL2, " ");
|
|
1167
|
+
text += flat;
|
|
1168
|
+
colored ||= active !== "" && flat !== "";
|
|
1169
|
+
styles.push(...repeat(active, flat.length));
|
|
1170
|
+
}
|
|
1171
|
+
for (const found of line.matchAll(ANSI)) {
|
|
1172
|
+
add(line.slice(last, found.index));
|
|
1173
|
+
last = found.index + found[0].length;
|
|
1174
|
+
if (SGR.test(found[0]))
|
|
1175
|
+
active = RESET.test(found[0]) ? "" : active + found[0];
|
|
1176
|
+
}
|
|
1177
|
+
add(line.slice(last));
|
|
1178
|
+
return { text, styles: colored ? styles : undefined };
|
|
1179
|
+
}
|
|
1180
|
+
function lay(rows, searched) {
|
|
1181
|
+
const parsed = rows.map((row) => row.cells.map(styled));
|
|
1182
|
+
const widths = (parsed[0] ?? []).map((_, column) => Math.max(...parsed.map((cells) => Bun.stringWidth(cells[column]?.text ?? ""))));
|
|
1183
|
+
return parsed.map((cells, at) => {
|
|
1184
|
+
let text = "";
|
|
1185
|
+
const styles = [];
|
|
1186
|
+
let colored = false;
|
|
1187
|
+
let searchEnd = 0;
|
|
1188
|
+
for (const [column, cell] of cells.entries()) {
|
|
1189
|
+
const last = column === cells.length - 1;
|
|
1190
|
+
const shown = cells.length > 1 && last ? cell.text.trimEnd() : cell.text;
|
|
1191
|
+
text += shown;
|
|
1192
|
+
colored ||= cell.styles !== undefined;
|
|
1193
|
+
styles.push(...cell.styles?.slice(0, shown.length) ?? repeat("", shown.length));
|
|
1194
|
+
if (column < searched)
|
|
1195
|
+
searchEnd = cells.length > 1 ? text.trimEnd().length : text.length;
|
|
1196
|
+
if (!last) {
|
|
1197
|
+
const pad = widths[column] - Bun.stringWidth(cell.text) + COLUMN_GAP;
|
|
1198
|
+
text += " ".repeat(pad);
|
|
1199
|
+
styles.push(...repeat("", pad));
|
|
1200
|
+
}
|
|
1201
|
+
}
|
|
1202
|
+
return { text, styles: colored ? styles : undefined, searchable: rows[at].search ?? text.slice(0, searchEnd) };
|
|
1203
|
+
});
|
|
1204
|
+
}
|
|
1205
|
+
function parseKeys(input, paste = { active: false }, ctrls = []) {
|
|
1206
|
+
const codes = new Map(ctrls.map((name) => [String.fromCharCode(name.codePointAt(name.length - 1) - 96), name]));
|
|
1207
|
+
return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => {
|
|
1208
|
+
const wheel = MOUSE.exec(sequence)?.[1];
|
|
1209
|
+
if (wheel !== undefined)
|
|
1210
|
+
return repeat(wheel === "64" ? "up" : "down", wheel === "64" || wheel === "65" ? WHEEL_LINES : 0);
|
|
1211
|
+
const named = codes.get(sequence);
|
|
1212
|
+
const key = named === undefined ? KEYS[sequence] : { ctrl: named };
|
|
1213
|
+
if (sequence === PASTE_START || sequence === PASTE_END) {
|
|
1214
|
+
paste.active = sequence === PASTE_START;
|
|
1215
|
+
return [];
|
|
1216
|
+
}
|
|
1217
|
+
if (paste.active && (sequence === "\r" || sequence === `
|
|
1218
|
+
`))
|
|
1219
|
+
return [];
|
|
1220
|
+
if (key !== undefined)
|
|
1221
|
+
return [key];
|
|
1222
|
+
return IS_CONTROL.test(sequence) || sequence.startsWith("\x1B") ? [] : [{ text: sequence }];
|
|
1223
|
+
});
|
|
1224
|
+
}
|
|
1225
|
+
function createState(rows, { multi = false, prompt = "> ", query = "", header = "", expect = [], searched = Number.POSITIVE_INFINITY } = {}) {
|
|
1226
|
+
const state = { rows: [], items: [], styles: [], searchable: [], searched, header, expect, key: "", status: "", query, caret: [...query].length, killed: "", chained: false, matches: [], cursor: 0, help: false, page: 10, marked: new Set, multi, prompt, done: undefined };
|
|
1227
|
+
return withRows(state, rows);
|
|
1228
|
+
}
|
|
1229
|
+
function withRows(state, rows, header = state.header) {
|
|
1230
|
+
const cells = rows.map((row) => typeof row === "string" ? { hidden: [], cells: [row] } : row);
|
|
1231
|
+
const laid = lay(cells, state.searched);
|
|
1232
|
+
const searchable = laid.map((row) => row.searchable);
|
|
1233
|
+
const matches = rank(state.query, searchable);
|
|
1234
|
+
return { ...state, rows: cells, items: laid.map((row) => row.text), styles: laid.map((row) => row.styles), searchable, header, matches, cursor: Math.max(0, Math.min(matches.length - 1, state.cursor)), marked: new Set };
|
|
1235
|
+
}
|
|
1236
|
+
function withQuery(state, key) {
|
|
1237
|
+
const { text, caret, killed = "", chained = false } = editLine({ text: state.query, caret: state.caret, killed: state.killed, chained: state.chained }, key);
|
|
1238
|
+
return text === state.query ? { ...state, caret, killed, chained } : { ...state, query: text, caret, killed, chained, matches: rank(text, state.searchable), cursor: 0 };
|
|
1239
|
+
}
|
|
1240
|
+
function move(state, by) {
|
|
1241
|
+
return { ...state, cursor: Math.max(0, Math.min(state.matches.length - 1, state.cursor + by)) };
|
|
1242
|
+
}
|
|
1243
|
+
function highlighted(state) {
|
|
1244
|
+
return state.matches[state.cursor]?.index;
|
|
1245
|
+
}
|
|
1246
|
+
function press(state, key) {
|
|
1247
|
+
if (state.done !== undefined)
|
|
1248
|
+
return state;
|
|
1249
|
+
if (state.chained && endsKills(key))
|
|
1250
|
+
state = { ...state, chained: false };
|
|
1251
|
+
if (state.help)
|
|
1252
|
+
return { ...state, help: false };
|
|
1253
|
+
if (typeof key === "object") {
|
|
1254
|
+
if ("text" in key)
|
|
1255
|
+
return withQuery(state, key);
|
|
1256
|
+
return state.expect.includes(key.ctrl) ? { ...state, done: "accept", key: key.ctrl } : state;
|
|
1257
|
+
}
|
|
1258
|
+
if (isEditKey(key))
|
|
1259
|
+
return withQuery(state, key);
|
|
1260
|
+
switch (key) {
|
|
1261
|
+
case "up":
|
|
1262
|
+
return move(state, -1);
|
|
1263
|
+
case "down":
|
|
1264
|
+
return move(state, 1);
|
|
1265
|
+
case "pageup":
|
|
1266
|
+
return move(state, -state.page);
|
|
1267
|
+
case "pagedown":
|
|
1268
|
+
return move(state, state.page);
|
|
1269
|
+
case "home":
|
|
1270
|
+
return move(state, -state.matches.length);
|
|
1271
|
+
case "end":
|
|
1272
|
+
return move(state, state.matches.length);
|
|
1273
|
+
case "cancel":
|
|
1274
|
+
return { ...state, done: "cancel" };
|
|
1275
|
+
case "help":
|
|
1276
|
+
return { ...state, help: true };
|
|
1277
|
+
case "suspend":
|
|
1278
|
+
return state;
|
|
1279
|
+
case "enter":
|
|
1280
|
+
return state.matches.length === 0 && state.marked.size === 0 ? state : { ...state, done: "accept" };
|
|
1281
|
+
case "tab": {
|
|
1282
|
+
const at = highlighted(state);
|
|
1283
|
+
if (!state.multi || at === undefined)
|
|
1284
|
+
return state;
|
|
1285
|
+
const marked = new Set(state.marked);
|
|
1286
|
+
if (!marked.delete(at))
|
|
1287
|
+
marked.add(at);
|
|
1288
|
+
return move({ ...state, marked }, 1);
|
|
1289
|
+
}
|
|
1290
|
+
}
|
|
1291
|
+
}
|
|
1292
|
+
function chosen(state) {
|
|
1293
|
+
if (state.marked.size > 0)
|
|
1294
|
+
return state.rows.filter((_, index) => state.marked.has(index));
|
|
1295
|
+
const at = highlighted(state);
|
|
1296
|
+
return at === undefined ? [] : [state.rows[at]];
|
|
1297
|
+
}
|
|
1298
|
+
var CONTROL2, IS_CONTROL, SGR, RESET, COLUMN_GAP = 2, PASTE_START = "\x1B[200~", PASTE_END = "\x1B[201~", KEY_SEQUENCES, MOUSE, WHEEL_LINES = 3, KEYS, CTRL_KEY;
|
|
1299
|
+
var init_state = __esm(() => {
|
|
1300
|
+
init_text2();
|
|
1301
|
+
init_line();
|
|
1302
|
+
init_score();
|
|
1303
|
+
CONTROL2 = /[\x00-\x1F\x7F-\x9F]/g;
|
|
1304
|
+
IS_CONTROL = /[\x00-\x1F\x7F-\x9F]/;
|
|
1305
|
+
SGR = /^\x1B\[[0-9;]*m$/;
|
|
1306
|
+
RESET = /^\x1B\[0?m$/;
|
|
1307
|
+
KEY_SEQUENCES = /\x1B\[<[0-9;]*[A-Za-z]|\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|\x1B[\s\S]|[\s\S]/gu;
|
|
1308
|
+
MOUSE = /^\x1B\[<(\d+);\d+;\d+[a-z]$/i;
|
|
1309
|
+
KEYS = {
|
|
1310
|
+
"\x1B[A": "up",
|
|
1311
|
+
"\x1BOA": "up",
|
|
1312
|
+
"\x10": "up",
|
|
1313
|
+
"\x1B[B": "down",
|
|
1314
|
+
"\x1BOB": "down",
|
|
1315
|
+
"\x0E": "down",
|
|
1316
|
+
"\x1B[5~": "pageup",
|
|
1317
|
+
"\x1B[6~": "pagedown",
|
|
1318
|
+
"\x1B[H": "home",
|
|
1319
|
+
"\x1B[1~": "home",
|
|
1320
|
+
"\x1BOH": "home",
|
|
1321
|
+
"\x1B[F": "end",
|
|
1322
|
+
"\x1B[4~": "end",
|
|
1323
|
+
"\x1BOF": "end",
|
|
1324
|
+
"\r": "enter",
|
|
1325
|
+
"\n": "enter",
|
|
1326
|
+
"\x03": "cancel",
|
|
1327
|
+
"\x1B": "cancel",
|
|
1328
|
+
"\x1B[D": "left",
|
|
1329
|
+
"\x1BOD": "left",
|
|
1330
|
+
"\x1B[C": "right",
|
|
1331
|
+
"\x1BOC": "right",
|
|
1332
|
+
"\x1B[1;5D": "wordleft",
|
|
1333
|
+
"\x1B[1;3D": "wordleft",
|
|
1334
|
+
"\x1Bb": "wordleft",
|
|
1335
|
+
"\x1B[1;5C": "wordright",
|
|
1336
|
+
"\x1B[1;3C": "wordright",
|
|
1337
|
+
"\x1Bf": "wordright",
|
|
1338
|
+
"\x01": "linestart",
|
|
1339
|
+
"\x05": "lineend",
|
|
1340
|
+
"\x7F": "erase",
|
|
1341
|
+
"\x1B[3~": "delete",
|
|
1342
|
+
"\b": "killword",
|
|
1343
|
+
"\x1B\x7F": "killword",
|
|
1344
|
+
"\x1B[3;5~": "killnext",
|
|
1345
|
+
"\x1Bd": "killnext",
|
|
1346
|
+
"\x15": "clear",
|
|
1347
|
+
"\v": "killend",
|
|
1348
|
+
"\x17": "word",
|
|
1349
|
+
"\x19": "yank",
|
|
1350
|
+
"\x1A": "suspend",
|
|
1351
|
+
"\t": "tab",
|
|
1352
|
+
"\x1F": "help",
|
|
1353
|
+
"\x1BOP": "help",
|
|
1354
|
+
"\x1B[11~": "help"
|
|
1355
|
+
};
|
|
1356
|
+
CTRL_KEY = /^ctrl-[abd-gkln-z]$/;
|
|
1357
|
+
});
|
|
1358
|
+
|
|
1359
|
+
// ../kit/src/redraw.ts
|
|
1360
|
+
function overwrite(lines, columns) {
|
|
1361
|
+
return lines.map((line) => textWidth(line) % columns === 0 ? `\x1B[2K${line}` : `${line}\x1B[K`).join(`
|
|
1362
|
+
`);
|
|
1363
|
+
}
|
|
1364
|
+
function rowsTaken(lines, columns) {
|
|
1365
|
+
return lines.reduce((rows, line) => rows + Math.max(1, Math.ceil(textWidth(line) / columns)), 0);
|
|
1366
|
+
}
|
|
1367
|
+
var SYNC_START = "\x1B[?2026h", SYNC_END = "\x1B[?2026l";
|
|
1368
|
+
var init_redraw = __esm(() => {
|
|
1369
|
+
init_format();
|
|
1370
|
+
});
|
|
1371
|
+
|
|
1372
|
+
// ../kit/src/prompt.ts
|
|
1373
|
+
import process15 from "process";
|
|
1374
|
+
function readKeys(input, paste = { active: false }) {
|
|
1375
|
+
return parseKeys(input, paste).filter((key) => typeof key === "object" ? "text" in key : PROMPT_KEYS.has(key) || isEditKey(key));
|
|
1376
|
+
}
|
|
1377
|
+
function roomAfter(question, columns) {
|
|
1378
|
+
return Math.max(columns - textWidth(`? ${question} `) % columns - 1, 1);
|
|
1379
|
+
}
|
|
1380
|
+
function withCaret(colors, line, room, dim = false) {
|
|
1381
|
+
const { before, at, after } = visible(line, room);
|
|
1382
|
+
const tone = dim ? colors.dim : (text) => text;
|
|
1383
|
+
return `${tone(before)}${at === undefined ? colors.dim("\u2588") : colors.inverse(at)}${tone(after)}`;
|
|
1384
|
+
}
|
|
1385
|
+
function sharedStart(texts) {
|
|
1386
|
+
const [first = [], ...rest] = texts.map((text) => [...text]);
|
|
1387
|
+
let length = first.length;
|
|
1388
|
+
for (const chars of rest) {
|
|
1389
|
+
const differs = chars.findIndex((char, index) => char !== first[index]);
|
|
1390
|
+
length = Math.min(length, differs === -1 ? chars.length : differs);
|
|
1391
|
+
}
|
|
1392
|
+
return first.slice(0, length).join("");
|
|
1393
|
+
}
|
|
1394
|
+
function listed2(colors, found, columns) {
|
|
1395
|
+
const shared = sharedStart(found);
|
|
1396
|
+
const cut = Math.max(shared.lastIndexOf("/"), shared.lastIndexOf(" ")) + 1;
|
|
1397
|
+
const names = found.slice(0, MAX_LISTED).map((each) => each.slice(cut));
|
|
1398
|
+
const more = found.length > MAX_LISTED ? ` \u2026 ${found.length - MAX_LISTED} more` : "";
|
|
1399
|
+
return ` ${colors.dim(truncate(names.join(" ") + more, Math.max(columns - 3, 1)))}`;
|
|
1400
|
+
}
|
|
1401
|
+
async function input2(question, { default: fallback, mask = false, validate, history, complete, ...settings } = {}) {
|
|
1402
|
+
let line = { text: "", caret: 0 };
|
|
1403
|
+
let invalid;
|
|
1404
|
+
let completions = [];
|
|
1405
|
+
const remembered = history === undefined || mask ? undefined : history;
|
|
1406
|
+
const earlier = remembered === undefined ? [] : earlierAnswers(remembered);
|
|
1407
|
+
let recalled = -1;
|
|
1408
|
+
let draft = line;
|
|
1409
|
+
const taken = () => line.text === "" ? fallback ?? "" : line.text;
|
|
1410
|
+
const shown = () => mask ? "*".repeat([...taken()].length) : taken();
|
|
1411
|
+
const accepted = await ask(question, settings, (colors, state, { columns }) => {
|
|
1412
|
+
if (state !== "asking")
|
|
1413
|
+
return [answer(colors, question, state, shown())];
|
|
1414
|
+
const typed = line.text === "" ? { text: shown(), caret: [...shown()].length } : { text: shown(), caret: line.caret };
|
|
1415
|
+
return [`${colors.cyan("?")} ${question} ${withCaret(colors, typed, roomAfter(question, columns), line.text === "")}`, ...invalid === undefined ? [] : [` ${colors.red(invalid)}`], ...completions.length > 1 ? [listed2(colors, completions, columns)] : []];
|
|
1416
|
+
}, (key) => {
|
|
1417
|
+
if (key === "cancel")
|
|
1418
|
+
return "cancel";
|
|
1419
|
+
invalid = undefined;
|
|
1420
|
+
completions = [];
|
|
1421
|
+
if (line.chained === true && endsKills(key))
|
|
1422
|
+
line = { ...line, chained: false };
|
|
1423
|
+
if (key === "tab") {
|
|
1424
|
+
const chars = [...line.text];
|
|
1425
|
+
const before = chars.slice(0, line.caret).join("");
|
|
1426
|
+
const found = complete?.(before) ?? [];
|
|
1427
|
+
const filled = sharedStart(found);
|
|
1428
|
+
if ([...filled].length > [...before].length)
|
|
1429
|
+
line = { ...line, text: filled + chars.slice(line.caret).join(""), caret: [...filled].length };
|
|
1430
|
+
else
|
|
1431
|
+
completions = found;
|
|
1432
|
+
return;
|
|
1433
|
+
}
|
|
1434
|
+
if (key === "enter") {
|
|
1435
|
+
invalid = validate?.(taken());
|
|
1436
|
+
return invalid === undefined ? "enter" : undefined;
|
|
1437
|
+
}
|
|
1438
|
+
if (key === "up" || key === "down") {
|
|
1439
|
+
const to = Math.min(Math.max(recalled + (key === "up" ? 1 : -1), -1), earlier.length - 1);
|
|
1440
|
+
if (recalled === -1)
|
|
1441
|
+
draft = line;
|
|
1442
|
+
recalled = to;
|
|
1443
|
+
const shown = to === -1 ? draft : { text: earlier[to], caret: [...earlier[to]].length };
|
|
1444
|
+
line = { ...shown, killed: line.killed ?? "" };
|
|
1445
|
+
return;
|
|
1446
|
+
}
|
|
1447
|
+
const edit = { home: "linestart", end: "lineend" }[key] ?? key;
|
|
1448
|
+
if (typeof edit === "object" || isEditKey(edit))
|
|
1449
|
+
line = editLine(line, edit);
|
|
1450
|
+
return;
|
|
1451
|
+
});
|
|
1452
|
+
if (!accepted)
|
|
1453
|
+
return;
|
|
1454
|
+
if (remembered !== undefined && taken() !== "")
|
|
1455
|
+
rememberAnswer(remembered, taken());
|
|
1456
|
+
return taken();
|
|
1457
|
+
}
|
|
1458
|
+
function answer(colors, question, state, picked) {
|
|
1459
|
+
return state === "enter" ? `${colors.green("\u2713")} ${question} ${colors.cyan(picked)}` : `${colors.red("\u2717")} ${question} ${colors.dim("cancelled")}`;
|
|
1460
|
+
}
|
|
1461
|
+
async function ask(question, { hint, terminal = process15 }, render, press) {
|
|
1462
|
+
const { stdin, stderr } = terminal;
|
|
1463
|
+
if (!isInteractive(terminal))
|
|
1464
|
+
fail(`cannot ask "${question}" off a terminal`, 2, hint);
|
|
1465
|
+
const colors = paint(stderr);
|
|
1466
|
+
let current = "asking";
|
|
1467
|
+
let outcome;
|
|
1468
|
+
const columns = () => stderr.columns || 80;
|
|
1469
|
+
const draw = (state, last = false) => {
|
|
1470
|
+
const frame = render(colors, state, { columns: columns(), rows: stderr.rows || 24 });
|
|
1471
|
+
const rows = rowsTaken(frame, columns());
|
|
1472
|
+
stderr.write(`${SYNC_START}\r${overwrite(frame, columns())}\x1B[0J${last || rows < 2 ? "" : `\x1B[${rows - 1}A`}${last ? "" : "\r"}${SYNC_END}`);
|
|
1473
|
+
current = state;
|
|
1474
|
+
};
|
|
1475
|
+
const redraw = () => draw(current);
|
|
1476
|
+
const paste = { active: false };
|
|
1477
|
+
const stop = terminal.stop ?? (terminal === process15 ? stopJob : undefined);
|
|
1478
|
+
const suspend = () => {
|
|
1479
|
+
if (stop === undefined)
|
|
1480
|
+
return;
|
|
1481
|
+
stderr.write("\x1B[0J\x1B[?25h\x1B[?2004l");
|
|
1482
|
+
stdin.setRawMode(false);
|
|
1483
|
+
stop();
|
|
1484
|
+
stdin.setRawMode(true);
|
|
1485
|
+
stderr.write("\x1B[?25l\x1B[?2004h");
|
|
1486
|
+
};
|
|
1487
|
+
try {
|
|
1488
|
+
stderr.on?.("resize", redraw);
|
|
1489
|
+
stdin.setRawMode(true);
|
|
1490
|
+
stdin.resume();
|
|
1491
|
+
stderr.write("\x1B[?25l\x1B[?2004h");
|
|
1492
|
+
draw("asking");
|
|
1493
|
+
return await new Promise((resolve) => {
|
|
1494
|
+
function onData(data) {
|
|
1495
|
+
for (const key of readKeys(data.toString(), paste)) {
|
|
1496
|
+
if (key === "suspend") {
|
|
1497
|
+
suspend();
|
|
1498
|
+
continue;
|
|
1499
|
+
}
|
|
1500
|
+
const pressed = press(key);
|
|
1501
|
+
if (pressed !== undefined) {
|
|
1502
|
+
settle(pressed);
|
|
1503
|
+
return;
|
|
1504
|
+
}
|
|
1505
|
+
}
|
|
1506
|
+
draw("asking");
|
|
1507
|
+
}
|
|
1508
|
+
function onEnd() {
|
|
1509
|
+
settle("cancel");
|
|
1510
|
+
}
|
|
1511
|
+
function settle(settled) {
|
|
1512
|
+
outcome = settled;
|
|
1513
|
+
stdin.off("data", onData);
|
|
1514
|
+
stdin.off("end", onEnd);
|
|
1515
|
+
resolve(settled === "enter");
|
|
1516
|
+
}
|
|
1517
|
+
stdin.on("data", onData);
|
|
1518
|
+
stdin.on("end", onEnd);
|
|
1519
|
+
});
|
|
1520
|
+
} finally {
|
|
1521
|
+
stderr.off?.("resize", redraw);
|
|
1522
|
+
draw(outcome ?? "cancel", true);
|
|
1523
|
+
stderr.write(`
|
|
1524
|
+
\x1B[?25h\x1B[?2004l`);
|
|
1525
|
+
stdin.setRawMode(false);
|
|
1526
|
+
stdin.pause();
|
|
1527
|
+
}
|
|
1528
|
+
}
|
|
1529
|
+
var PROMPT_KEYS, MAX_LISTED = 12;
|
|
1530
|
+
var init_prompt = __esm(() => {
|
|
1531
|
+
init_answers();
|
|
1532
|
+
init_args();
|
|
1533
|
+
init_format();
|
|
1534
|
+
init_job();
|
|
1535
|
+
init_mode();
|
|
1536
|
+
init_line();
|
|
1537
|
+
init_state();
|
|
1538
|
+
init_redraw();
|
|
1539
|
+
init_style();
|
|
1540
|
+
PROMPT_KEYS = new Set(["up", "down", "pageup", "pagedown", "home", "end", "enter", "cancel", "suspend", "tab"]);
|
|
1541
|
+
});
|
|
1542
|
+
|
|
1543
|
+
// src/gc.ts
|
|
1544
|
+
import { copyFileSync, existsSync as existsSync4, realpathSync as realpathSync3, renameSync, rmSync as rmSync2 } from "fs";
|
|
1545
|
+
import { basename, dirname as dirname6, isAbsolute as isAbsolute2, join as join10, relative } from "path";
|
|
1546
|
+
import process23 from "process";
|
|
1547
|
+
|
|
1548
|
+
// ../kit/src/index.ts
|
|
1549
|
+
init_args();
|
|
1550
|
+
|
|
817
1551
|
// ../kit/src/argv.ts
|
|
818
1552
|
import { readFileSync as readFileSync3, realpathSync } from "fs";
|
|
819
1553
|
import { resolve as resolve3 } from "path";
|
|
@@ -838,14 +1572,26 @@ function scriptArgs(argv = process10.argv.slice(2), cmdline = commandLine(), scr
|
|
|
838
1572
|
const after = at === -1 ? [] : cmdline.slice(at + 1);
|
|
839
1573
|
return after[0] === "--" && after.length === argv.length + 1 && argv.every((word, index) => word === after[index + 1]) ? after : argv;
|
|
840
1574
|
}
|
|
1575
|
+
// ../kit/src/chart.ts
|
|
1576
|
+
init_format();
|
|
1577
|
+
init_mode();
|
|
1578
|
+
init_style();
|
|
1579
|
+
init_theme();
|
|
1580
|
+
// ../kit/src/ci.ts
|
|
1581
|
+
init_args();
|
|
1582
|
+
init_format();
|
|
1583
|
+
|
|
841
1584
|
// ../kit/src/progress.ts
|
|
1585
|
+
init_format();
|
|
842
1586
|
import process12 from "process";
|
|
843
1587
|
|
|
844
1588
|
// ../kit/src/process.ts
|
|
1589
|
+
import { readFileSync as readFileSync4 } from "fs";
|
|
845
1590
|
import { constants } from "os";
|
|
846
1591
|
import process11 from "process";
|
|
847
1592
|
var KILL_GRACE_MS = 2000;
|
|
848
1593
|
var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
|
|
1594
|
+
var GROUP_SIGNALS = new Set(["SIGINT", "SIGHUP"]);
|
|
849
1595
|
function exitCodeOf(code, signal) {
|
|
850
1596
|
if (code !== null)
|
|
851
1597
|
return code;
|
|
@@ -853,6 +1599,21 @@ function exitCodeOf(code, signal) {
|
|
|
853
1599
|
return 128 + signal;
|
|
854
1600
|
return signal === null ? 129 : 128 + constants.signals[signal];
|
|
855
1601
|
}
|
|
1602
|
+
function groupsOf(pid) {
|
|
1603
|
+
try {
|
|
1604
|
+
const stat = readFileSync4(`/proc/${pid}/stat`, "utf8");
|
|
1605
|
+
const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
|
|
1606
|
+
return { group: Number(fields[2]), foreground: Number(fields[5]) };
|
|
1607
|
+
} catch {
|
|
1608
|
+
return;
|
|
1609
|
+
}
|
|
1610
|
+
}
|
|
1611
|
+
function heardTheTerminal(child) {
|
|
1612
|
+
if (child.pid === undefined)
|
|
1613
|
+
return false;
|
|
1614
|
+
const own = groupsOf("self");
|
|
1615
|
+
return own !== undefined && own.group === own.foreground && groupsOf(child.pid)?.group === own.group;
|
|
1616
|
+
}
|
|
856
1617
|
function holdSignals(cleanup) {
|
|
857
1618
|
let received;
|
|
858
1619
|
let child;
|
|
@@ -871,7 +1632,8 @@ function holdSignals(cleanup) {
|
|
|
871
1632
|
function onSignal(signal) {
|
|
872
1633
|
received = signal;
|
|
873
1634
|
if (child !== undefined) {
|
|
874
|
-
|
|
1635
|
+
if (!GROUP_SIGNALS.has(signal) || !heardTheTerminal(child))
|
|
1636
|
+
child.kill(signal);
|
|
875
1637
|
return;
|
|
876
1638
|
}
|
|
877
1639
|
if (cleanup === undefined)
|
|
@@ -884,10 +1646,10 @@ function holdSignals(cleanup) {
|
|
|
884
1646
|
process11.on(signal, onSignal);
|
|
885
1647
|
return held;
|
|
886
1648
|
}
|
|
887
|
-
async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
|
|
1649
|
+
async function runCommand(argv, { cwd, env, stdin = "ignore", input, timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
|
|
888
1650
|
const chunks = [];
|
|
889
1651
|
const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
|
|
890
|
-
const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
|
|
1652
|
+
const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin: input === undefined ? stdin : new TextEncoder().encode(input), stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
|
|
891
1653
|
const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
|
|
892
1654
|
const timers = [];
|
|
893
1655
|
const killGroup = (killing) => {
|
|
@@ -927,12 +1689,19 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
927
1689
|
stop();
|
|
928
1690
|
continue;
|
|
929
1691
|
}
|
|
1692
|
+
if (state.truncated)
|
|
1693
|
+
continue;
|
|
1694
|
+
let kept = data;
|
|
930
1695
|
if (state.kept + data.length > maxBytes) {
|
|
1696
|
+
let cut = maxBytes - state.kept;
|
|
1697
|
+
while (cut > 0 && ((data[cut] ?? 0) & 192) === 128)
|
|
1698
|
+
cut--;
|
|
1699
|
+
kept = data.subarray(0, cut);
|
|
931
1700
|
state.truncated = true;
|
|
932
|
-
continue;
|
|
933
1701
|
}
|
|
934
|
-
state.kept +=
|
|
935
|
-
|
|
1702
|
+
state.kept += kept.length;
|
|
1703
|
+
if (kept.length > 0)
|
|
1704
|
+
chunks.push({ stream: name, data: kept });
|
|
936
1705
|
}
|
|
937
1706
|
};
|
|
938
1707
|
try {
|
|
@@ -949,6 +1718,7 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
949
1718
|
const joined = () => Buffer.concat(chunks.map(({ data }) => data));
|
|
950
1719
|
let output;
|
|
951
1720
|
let text;
|
|
1721
|
+
let stdout;
|
|
952
1722
|
return {
|
|
953
1723
|
code: exitCodeOf(proc.exitCode, proc.signalCode),
|
|
954
1724
|
chunks,
|
|
@@ -959,11 +1729,16 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
959
1729
|
},
|
|
960
1730
|
get text() {
|
|
961
1731
|
return text ??= (output ??= joined()).toString();
|
|
1732
|
+
},
|
|
1733
|
+
get stdout() {
|
|
1734
|
+
return stdout ??= Buffer.concat(chunks.filter((chunk) => chunk.stream === "stdout").map((chunk) => chunk.data)).toString();
|
|
962
1735
|
}
|
|
963
1736
|
};
|
|
964
1737
|
}
|
|
965
1738
|
|
|
966
1739
|
// ../kit/src/progress.ts
|
|
1740
|
+
init_style();
|
|
1741
|
+
init_theme();
|
|
967
1742
|
var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
|
|
968
1743
|
var FRAME_MS = 200;
|
|
969
1744
|
var BAR_WIDTH = 20;
|
|
@@ -981,10 +1756,14 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
|
|
|
981
1756
|
}, print: (text) => void stream.write(`${text}
|
|
982
1757
|
`), stop: () => {
|
|
983
1758
|
return;
|
|
1759
|
+
}, pause: () => () => {
|
|
1760
|
+
return;
|
|
984
1761
|
} };
|
|
985
1762
|
const write = stream.write.bind(stream);
|
|
986
1763
|
let frame = 0;
|
|
987
1764
|
let drawn = false;
|
|
1765
|
+
let paused = false;
|
|
1766
|
+
let stopped = false;
|
|
988
1767
|
const columns = () => {
|
|
989
1768
|
const now = stream.getWindowSize?.()[0] ?? stream.columns;
|
|
990
1769
|
return now === undefined || now === 0 ? 80 : now;
|
|
@@ -995,6 +1774,8 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
|
|
|
995
1774
|
drawn = false;
|
|
996
1775
|
};
|
|
997
1776
|
const draw = () => {
|
|
1777
|
+
if (paused)
|
|
1778
|
+
return;
|
|
998
1779
|
const width = columns() - 1;
|
|
999
1780
|
const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
|
|
1000
1781
|
const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
|
|
@@ -1006,16 +1787,17 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
|
|
|
1006
1787
|
`)}${lines.length > 1 ? `\x1B[${lines.length - 1}A` : ""}\r`);
|
|
1007
1788
|
drawn = true;
|
|
1008
1789
|
};
|
|
1009
|
-
|
|
1790
|
+
let timer = setInterval(draw, FRAME_MS);
|
|
1010
1791
|
stream.on?.("resize", draw);
|
|
1011
|
-
|
|
1012
|
-
|
|
1792
|
+
let restore = interceptOutput(clear);
|
|
1793
|
+
let release = swallowInput();
|
|
1013
1794
|
const onExit = () => {
|
|
1014
1795
|
clear();
|
|
1015
1796
|
release();
|
|
1016
1797
|
};
|
|
1017
1798
|
const signals = holdSignals(stop);
|
|
1018
1799
|
function stop() {
|
|
1800
|
+
stopped = true;
|
|
1019
1801
|
clearInterval(timer);
|
|
1020
1802
|
stream.off?.("resize", draw);
|
|
1021
1803
|
clear();
|
|
@@ -1024,6 +1806,29 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
|
|
|
1024
1806
|
process12.off("exit", onExit);
|
|
1025
1807
|
signals.release();
|
|
1026
1808
|
}
|
|
1809
|
+
function pause() {
|
|
1810
|
+
if (paused || stopped)
|
|
1811
|
+
return () => {
|
|
1812
|
+
return;
|
|
1813
|
+
};
|
|
1814
|
+
paused = true;
|
|
1815
|
+
clearInterval(timer);
|
|
1816
|
+
stream.off?.("resize", draw);
|
|
1817
|
+
clear();
|
|
1818
|
+
restore();
|
|
1819
|
+
release();
|
|
1820
|
+
return () => {
|
|
1821
|
+
if (!paused || stopped)
|
|
1822
|
+
return;
|
|
1823
|
+
paused = false;
|
|
1824
|
+
timer = setInterval(draw, FRAME_MS);
|
|
1825
|
+
timer.unref();
|
|
1826
|
+
stream.on?.("resize", draw);
|
|
1827
|
+
restore = interceptOutput(clear);
|
|
1828
|
+
release = swallowInput();
|
|
1829
|
+
draw();
|
|
1830
|
+
};
|
|
1831
|
+
}
|
|
1027
1832
|
timer.unref();
|
|
1028
1833
|
process12.on("exit", onExit);
|
|
1029
1834
|
return {
|
|
@@ -1034,7 +1839,8 @@ function liveRegion(render, stream = process12.stderr, env = process12.env) {
|
|
|
1034
1839
|
`);
|
|
1035
1840
|
draw();
|
|
1036
1841
|
},
|
|
1037
|
-
stop
|
|
1842
|
+
stop,
|
|
1843
|
+
pause
|
|
1038
1844
|
};
|
|
1039
1845
|
}
|
|
1040
1846
|
function progressLine(stream = process12.stderr, env = process12.env) {
|
|
@@ -1059,6 +1865,7 @@ function progressLine(stream = process12.stderr, env = process12.env) {
|
|
|
1059
1865
|
}
|
|
1060
1866
|
},
|
|
1061
1867
|
stop: region.stop,
|
|
1868
|
+
pause: region.pause,
|
|
1062
1869
|
done: (text) => end(marked("ok", text, stream, formatDuration(performance.now() - begun), env)),
|
|
1063
1870
|
failed: (text) => end(marked("problem", text, stream, undefined, env))
|
|
1064
1871
|
};
|
|
@@ -1147,10 +1954,127 @@ function interceptOutput(clear) {
|
|
|
1147
1954
|
}
|
|
1148
1955
|
};
|
|
1149
1956
|
}
|
|
1957
|
+
|
|
1958
|
+
// ../kit/src/ci.ts
|
|
1959
|
+
init_style();
|
|
1960
|
+
|
|
1961
|
+
// ../kit/src/tool.ts
|
|
1962
|
+
init_format();
|
|
1150
1963
|
// ../kit/src/cli.ts
|
|
1151
|
-
|
|
1152
|
-
import {
|
|
1153
|
-
import
|
|
1964
|
+
init_args();
|
|
1965
|
+
import { readFileSync as readFileSync6, realpathSync as realpathSync2 } from "fs";
|
|
1966
|
+
import { dirname as dirname4, join as join8 } from "path";
|
|
1967
|
+
import process19 from "process";
|
|
1968
|
+
|
|
1969
|
+
// ../kit/src/askpass.ts
|
|
1970
|
+
import { chmodSync, mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
|
|
1971
|
+
import { tmpdir } from "os";
|
|
1972
|
+
import { join as join6 } from "path";
|
|
1973
|
+
import process16 from "process";
|
|
1974
|
+
var SOCKET_VARIABLE = "KAYNOOO_ASKPASS_SOCKET";
|
|
1975
|
+
var ECHOED = /username|yes\/no/i;
|
|
1976
|
+
var quoted = (text) => `'${text.replaceAll("'", `'\\''`)}'`;
|
|
1977
|
+
function askpass(pause = () => () => {
|
|
1978
|
+
return;
|
|
1979
|
+
}) {
|
|
1980
|
+
if (process16.stdin.isTTY !== true || process16.stderr.isTTY !== true || process16.argv[1] === undefined)
|
|
1981
|
+
return;
|
|
1982
|
+
const dir = mkdtempSync(join6(tmpdir(), "kaynooo-askpass-"));
|
|
1983
|
+
const socketPath = join6(dir, "socket");
|
|
1984
|
+
const script = join6(dir, "askpass");
|
|
1985
|
+
let turn = Promise.resolve();
|
|
1986
|
+
const answer = async ({ prompt, notice }) => {
|
|
1987
|
+
const resume = pause();
|
|
1988
|
+
try {
|
|
1989
|
+
if (notice === true) {
|
|
1990
|
+
process16.stderr.write(`${prompt.trim()}
|
|
1991
|
+
`);
|
|
1992
|
+
return {};
|
|
1993
|
+
}
|
|
1994
|
+
await Promise.resolve().then(() => init_prompt());
|
|
1995
|
+
return { answer: await input2(prompt.trim(), { mask: !ECHOED.test(prompt) }) };
|
|
1996
|
+
} finally {
|
|
1997
|
+
resume();
|
|
1998
|
+
}
|
|
1999
|
+
};
|
|
2000
|
+
const respond = async (socket, request) => {
|
|
2001
|
+
const { promise, resolve } = Promise.withResolvers();
|
|
2002
|
+
const previous = turn;
|
|
2003
|
+
let reply = {};
|
|
2004
|
+
turn = promise;
|
|
2005
|
+
await previous;
|
|
2006
|
+
try {
|
|
2007
|
+
reply = await answer(request);
|
|
2008
|
+
} catch {} finally {
|
|
2009
|
+
socket.end(`${JSON.stringify(reply)}
|
|
2010
|
+
`);
|
|
2011
|
+
resolve();
|
|
2012
|
+
}
|
|
2013
|
+
};
|
|
2014
|
+
const server = Bun.listen({
|
|
2015
|
+
unix: socketPath,
|
|
2016
|
+
socket: {
|
|
2017
|
+
open: (socket) => {
|
|
2018
|
+
socket.data = { buffered: "" };
|
|
2019
|
+
},
|
|
2020
|
+
data: (socket, chunk) => {
|
|
2021
|
+
const before = socket.data.buffered;
|
|
2022
|
+
socket.data.buffered += chunk.toString();
|
|
2023
|
+
if (before.includes(`
|
|
2024
|
+
`) || !socket.data.buffered.includes(`
|
|
2025
|
+
`))
|
|
2026
|
+
return;
|
|
2027
|
+
respond(socket, JSON.parse(socket.data.buffered));
|
|
2028
|
+
}
|
|
2029
|
+
}
|
|
2030
|
+
});
|
|
2031
|
+
writeFileSync2(script, `#!/bin/sh
|
|
2032
|
+
${SOCKET_VARIABLE}=${quoted(socketPath)} exec ${quoted(process16.execPath)} --no-env-file --config=/dev/null ${quoted(process16.argv[1])} "$@"
|
|
2033
|
+
`);
|
|
2034
|
+
chmodSync(script, 448);
|
|
2035
|
+
return {
|
|
2036
|
+
env: { GIT_ASKPASS: script, SSH_ASKPASS: script, SSH_ASKPASS_REQUIRE: "force" },
|
|
2037
|
+
close: () => {
|
|
2038
|
+
server.stop(true);
|
|
2039
|
+
rmSync(dir, { recursive: true, force: true });
|
|
2040
|
+
}
|
|
2041
|
+
};
|
|
2042
|
+
}
|
|
2043
|
+
async function askpassClient(argv) {
|
|
2044
|
+
const socketPath = process16.env[SOCKET_VARIABLE];
|
|
2045
|
+
if (socketPath === undefined)
|
|
2046
|
+
return;
|
|
2047
|
+
const request = { prompt: argv[0] ?? "", ...process16.env.SSH_ASKPASS_PROMPT === "none" ? { notice: true } : {} };
|
|
2048
|
+
const { promise, resolve } = Promise.withResolvers();
|
|
2049
|
+
let received = "";
|
|
2050
|
+
try {
|
|
2051
|
+
await Bun.connect({
|
|
2052
|
+
unix: socketPath,
|
|
2053
|
+
socket: {
|
|
2054
|
+
open: (socket) => void socket.write(`${JSON.stringify(request)}
|
|
2055
|
+
`),
|
|
2056
|
+
data: (_, chunk) => {
|
|
2057
|
+
received += chunk.toString();
|
|
2058
|
+
},
|
|
2059
|
+
close: () => resolve(received),
|
|
2060
|
+
error: () => resolve("")
|
|
2061
|
+
}
|
|
2062
|
+
});
|
|
2063
|
+
} catch {
|
|
2064
|
+
return 1;
|
|
2065
|
+
}
|
|
2066
|
+
const reply = await promise;
|
|
2067
|
+
if (reply === "")
|
|
2068
|
+
return 1;
|
|
2069
|
+
const { answer } = JSON.parse(reply);
|
|
2070
|
+
if (request.notice === true)
|
|
2071
|
+
return 0;
|
|
2072
|
+
if (answer === undefined)
|
|
2073
|
+
return 1;
|
|
2074
|
+
process16.stdout.write(`${answer}
|
|
2075
|
+
`);
|
|
2076
|
+
return 0;
|
|
2077
|
+
}
|
|
1154
2078
|
|
|
1155
2079
|
// ../kit/src/completions.ts
|
|
1156
2080
|
var COMPLETION_SHELLS = ["fish", "bash", "zsh"];
|
|
@@ -1213,34 +2137,42 @@ compdef __kaynooo_cli_complete ${bins.join(" ")}
|
|
|
1213
2137
|
}
|
|
1214
2138
|
|
|
1215
2139
|
// ../kit/src/notify.ts
|
|
1216
|
-
|
|
2140
|
+
init_format();
|
|
2141
|
+
init_mode();
|
|
2142
|
+
import process17 from "process";
|
|
1217
2143
|
var NOTIFY_AFTER_MS = 1e4;
|
|
1218
2144
|
var CANCELLED = 130;
|
|
1219
2145
|
function base64(text) {
|
|
1220
2146
|
return Buffer.from(text).toString("base64");
|
|
1221
2147
|
}
|
|
1222
|
-
function notification(title, body, env =
|
|
1223
|
-
const id = `kit${
|
|
2148
|
+
function notification(title, body, env = process17.env) {
|
|
2149
|
+
const id = `kit${process17.pid}`;
|
|
1224
2150
|
const codes = [`\x1B]99;i=${id}:d=0:o=unfocused:e=1;${base64(title)}\x1B\\`, `\x1B]99;i=${id}:p=body:e=1;${base64(body)}\x1B\\`];
|
|
1225
2151
|
return codes.map((code) => env.TMUX === undefined || env.TMUX === "" ? code : `\x1BPtmux;${code.replaceAll("\x1B", "\x1B\x1B")}\x1B\\`).join("");
|
|
1226
2152
|
}
|
|
1227
|
-
function notifyEnd(command, code, ms, { stream =
|
|
2153
|
+
function notifyEnd(command, code, ms, { stream = process17.stderr, env = process17.env } = {}) {
|
|
1228
2154
|
if (ms < NOTIFY_AFTER_MS || code === CANCELLED || outputMode(stream, env) !== "terminal")
|
|
1229
2155
|
return;
|
|
1230
2156
|
stream.write(notification(command, code === 0 ? `done in ${formatDuration(ms)}` : `failed with exit ${code} after ${formatDuration(ms)}`, env));
|
|
1231
2157
|
}
|
|
1232
2158
|
|
|
2159
|
+
// ../kit/src/cli.ts
|
|
2160
|
+
init_style();
|
|
2161
|
+
init_text2();
|
|
2162
|
+
|
|
1233
2163
|
// ../kit/src/usage.ts
|
|
1234
|
-
import { appendFileSync, mkdirSync } from "fs";
|
|
1235
|
-
import { homedir as
|
|
1236
|
-
import { dirname as
|
|
1237
|
-
import
|
|
2164
|
+
import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
|
|
2165
|
+
import { homedir as homedir4 } from "os";
|
|
2166
|
+
import { dirname as dirname3, join as join7 } from "path";
|
|
2167
|
+
import process18 from "process";
|
|
1238
2168
|
|
|
1239
2169
|
// ../kit/src/logs.ts
|
|
2170
|
+
init_user_config();
|
|
1240
2171
|
var DAY_MS = 24 * 60 * 60 * 1000;
|
|
1241
2172
|
var CLI_FOLDER = "kaynooo-cli";
|
|
1242
2173
|
|
|
1243
2174
|
// ../kit/src/usage.ts
|
|
2175
|
+
init_user_config();
|
|
1244
2176
|
var UNKNOWN_OPTION2 = /unknown option '(--[a-z][a-z0-9-]*)[=']/;
|
|
1245
2177
|
var FLAG_NAME = /^(?:--[a-z][a-z0-9-]*|-[a-zA-Z])$/;
|
|
1246
2178
|
var LONGEST_NAME = 40;
|
|
@@ -1248,14 +2180,13 @@ var usageError;
|
|
|
1248
2180
|
function noteUsageError(message) {
|
|
1249
2181
|
usageError = message;
|
|
1250
2182
|
}
|
|
1251
|
-
function stateHome(env =
|
|
1252
|
-
|
|
1253
|
-
return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
|
|
2183
|
+
function stateHome(env = process18.env) {
|
|
2184
|
+
return xdgFolder(env.XDG_STATE_HOME, join7(homedir4(), ".local", "state"));
|
|
1254
2185
|
}
|
|
1255
|
-
function usagePath(env =
|
|
1256
|
-
return
|
|
2186
|
+
function usagePath(env = process18.env) {
|
|
2187
|
+
return join7(stateHome(env), CLI_FOLDER, "usage.jsonl");
|
|
1257
2188
|
}
|
|
1258
|
-
function usageRecorded(env =
|
|
2189
|
+
function usageRecorded(env = process18.env) {
|
|
1259
2190
|
const off = env.KAYNOOO_CLI_NO_USAGE;
|
|
1260
2191
|
return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
|
|
1261
2192
|
}
|
|
@@ -1264,17 +2195,17 @@ function flagNames(argv) {
|
|
|
1264
2195
|
const names = (end === -1 ? argv : argv.slice(0, end)).filter((word) => word.startsWith("-") && word !== "-").map((word) => word.includes("=") ? word.slice(0, word.indexOf("=")) : word);
|
|
1265
2196
|
return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
|
|
1266
2197
|
}
|
|
1267
|
-
function usageEntry(bin, command, argv, code, now = new Date) {
|
|
2198
|
+
function usageEntry(bin, command, argv, code, { ms, now = new Date } = {}) {
|
|
1268
2199
|
const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
|
|
1269
2200
|
usageError = undefined;
|
|
1270
|
-
return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
|
|
2201
|
+
return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown }, ...ms === undefined ? {} : { ms: Math.round(ms) } };
|
|
1271
2202
|
}
|
|
1272
|
-
function recordUsage(entry, env =
|
|
2203
|
+
function recordUsage(entry, env = process18.env) {
|
|
1273
2204
|
if (!usageRecorded(env))
|
|
1274
2205
|
return;
|
|
1275
2206
|
try {
|
|
1276
2207
|
const path = usagePath(env);
|
|
1277
|
-
|
|
2208
|
+
mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
|
|
1278
2209
|
appendFileSync(path, `${JSON.stringify(entry)}
|
|
1279
2210
|
`, { mode: 384 });
|
|
1280
2211
|
} catch {}
|
|
@@ -1291,8 +2222,8 @@ var TOP_OPTIONS = {
|
|
|
1291
2222
|
completions: { type: "string", choices: COMPLETION_SHELLS, description: "print the shell completion script" }
|
|
1292
2223
|
};
|
|
1293
2224
|
function printError(prefix, message, hint, cause) {
|
|
1294
|
-
const colors = paint(
|
|
1295
|
-
const styled = takesControlCodes(
|
|
2225
|
+
const colors = paint(process19.stderr);
|
|
2226
|
+
const styled = takesControlCodes(process19.stderr);
|
|
1296
2227
|
const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
|
|
1297
2228
|
const under = (label, text, tint) => text === undefined ? "" : `
|
|
1298
2229
|
${styled ? tint(label) : `${label}:`} ${text}`;
|
|
@@ -1395,17 +2326,20 @@ function packageVersion(entry = Bun.main) {
|
|
|
1395
2326
|
try {
|
|
1396
2327
|
resolved = realpathSync2(entry);
|
|
1397
2328
|
} catch {}
|
|
1398
|
-
for (let dir =
|
|
2329
|
+
for (let dir = dirname4(resolved);; dir = dirname4(dir)) {
|
|
1399
2330
|
try {
|
|
1400
|
-
const { version } = JSON.parse(
|
|
2331
|
+
const { version } = JSON.parse(readFileSync6(join8(dir, "package.json"), "utf8"));
|
|
1401
2332
|
if (typeof version === "string")
|
|
1402
2333
|
return version;
|
|
1403
2334
|
} catch {}
|
|
1404
|
-
if (
|
|
2335
|
+
if (dirname4(dir) === dir)
|
|
1405
2336
|
return "0.0.0";
|
|
1406
2337
|
}
|
|
1407
2338
|
}
|
|
1408
2339
|
async function runMain({ name, version, run, redact, usage }, argv = scriptArgs()) {
|
|
2340
|
+
const answered = await askpassClient(argv);
|
|
2341
|
+
if (answered !== undefined)
|
|
2342
|
+
return answered;
|
|
1409
2343
|
if (argv[0] === COMPLETE)
|
|
1410
2344
|
return printCandidates(leafCandidates(run, argv.slice(1)));
|
|
1411
2345
|
if (argv[0] === COMPLETIONS || argv[0]?.startsWith(`${COMPLETIONS}=`) === true)
|
|
@@ -1424,21 +2358,52 @@ async function runMain({ name, version, run, redact, usage }, argv = scriptArgs(
|
|
|
1424
2358
|
notifyEnd(name, code, performance.now() - started);
|
|
1425
2359
|
if (usage !== false) {
|
|
1426
2360
|
try {
|
|
1427
|
-
recordUsage(usageEntry(name, undefined, argv, code));
|
|
2361
|
+
recordUsage(usageEntry(name, undefined, argv, code, { ms: performance.now() - started }));
|
|
1428
2362
|
} catch {}
|
|
1429
2363
|
}
|
|
1430
2364
|
return code;
|
|
1431
2365
|
}
|
|
1432
|
-
|
|
1433
|
-
|
|
2366
|
+
|
|
2367
|
+
// ../kit/src/index.ts
|
|
2368
|
+
init_config();
|
|
2369
|
+
|
|
2370
|
+
// ../kit/src/excerpt.ts
|
|
2371
|
+
init_text2();
|
|
2372
|
+
|
|
2373
|
+
// ../kit/src/index.ts
|
|
2374
|
+
init_folders();
|
|
2375
|
+
init_format();
|
|
2376
|
+
|
|
2377
|
+
// ../kit/src/git.ts
|
|
2378
|
+
init_args();
|
|
2379
|
+
// ../kit/src/limit.ts
|
|
2380
|
+
init_args();
|
|
2381
|
+
|
|
2382
|
+
// ../kit/src/index.ts
|
|
2383
|
+
init_mode();
|
|
2384
|
+
|
|
2385
|
+
// ../kit/src/report.ts
|
|
2386
|
+
init_style();
|
|
2387
|
+
init_text2();
|
|
1434
2388
|
// ../kit/src/secrets.ts
|
|
1435
2389
|
var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
|
|
2390
|
+
var NOT_PASSWORDS = new Set(["compass", "encompass", "bypass", "overpass", "underpass", "surpass", "trespass"]);
|
|
1436
2391
|
// ../kit/src/sessions.ts
|
|
1437
2392
|
var {Glob } = globalThis.Bun;
|
|
1438
2393
|
var SESSION_FILES = new Glob("*.json");
|
|
1439
2394
|
var ACCOUNT_DIRS = new Glob("*/sessions");
|
|
2395
|
+
|
|
2396
|
+
// ../kit/src/index.ts
|
|
2397
|
+
init_style();
|
|
2398
|
+
init_text2();
|
|
2399
|
+
init_theme();
|
|
2400
|
+
init_user_config();
|
|
2401
|
+
|
|
1440
2402
|
// ../kit/src/watch.ts
|
|
1441
|
-
|
|
2403
|
+
init_args();
|
|
2404
|
+
init_input();
|
|
2405
|
+
init_style();
|
|
2406
|
+
import process20 from "process";
|
|
1442
2407
|
import { format } from "util";
|
|
1443
2408
|
var CLEAR_SCREEN = "\x1B[H\x1B[2J";
|
|
1444
2409
|
var DEFAULT_SECONDS = 2;
|
|
@@ -1460,7 +2425,7 @@ function withoutWatch(args) {
|
|
|
1460
2425
|
}
|
|
1461
2426
|
return rest;
|
|
1462
2427
|
}
|
|
1463
|
-
async function watching(value, step, stream =
|
|
2428
|
+
async function watching(value, step, stream = process20.stdout, sleep = Bun.sleep, rounds = Number.POSITIVE_INFINITY) {
|
|
1464
2429
|
const interval = value === "" ? DEFAULT_SECONDS * 1000 : duration(value, "watch", DEFAULT_SECONDS * 1000);
|
|
1465
2430
|
if (!takesControlCodes(stream))
|
|
1466
2431
|
badUsage("--watch redraws the screen, so it needs a terminal");
|
|
@@ -1468,12 +2433,12 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
|
|
|
1468
2433
|
for (let round = 0;round < rounds; round++) {
|
|
1469
2434
|
const held = [];
|
|
1470
2435
|
const { log, info } = console;
|
|
1471
|
-
const write =
|
|
2436
|
+
const write = process20.stdout.write.bind(process20.stdout);
|
|
1472
2437
|
const hold = (...parts) => void held.push(`${format(...parts)}
|
|
1473
2438
|
`);
|
|
1474
2439
|
console.log = hold;
|
|
1475
2440
|
console.info = hold;
|
|
1476
|
-
|
|
2441
|
+
process20.stdout.write = (text) => {
|
|
1477
2442
|
held.push(typeof text === "string" ? text : Buffer.from(text).toString());
|
|
1478
2443
|
return true;
|
|
1479
2444
|
};
|
|
@@ -1482,7 +2447,7 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
|
|
|
1482
2447
|
} finally {
|
|
1483
2448
|
console.log = log;
|
|
1484
2449
|
console.info = info;
|
|
1485
|
-
|
|
2450
|
+
process20.stdout.write = write;
|
|
1486
2451
|
}
|
|
1487
2452
|
stream.write(`${CLEAR_SCREEN}${held.join("")}`);
|
|
1488
2453
|
await sleep(interval);
|
|
@@ -1490,21 +2455,22 @@ async function watching(value, step, stream = process16.stdout, sleep = Bun.slee
|
|
|
1490
2455
|
return code;
|
|
1491
2456
|
}
|
|
1492
2457
|
// ../kit/src/workspace-root.ts
|
|
1493
|
-
|
|
1494
|
-
import {
|
|
1495
|
-
import
|
|
2458
|
+
init_user_config();
|
|
2459
|
+
import { homedir as homedir5 } from "os";
|
|
2460
|
+
import { dirname as dirname5, join as join9, resolve as resolve4 } from "path";
|
|
2461
|
+
import process21 from "process";
|
|
1496
2462
|
function expandHome(path, home) {
|
|
1497
2463
|
if (path === "~")
|
|
1498
2464
|
return home;
|
|
1499
|
-
return path.startsWith("~/") ?
|
|
2465
|
+
return path.startsWith("~/") ? join9(home, path.slice(2)) : path;
|
|
1500
2466
|
}
|
|
1501
2467
|
function configured(env, home) {
|
|
1502
2468
|
const folder = readUserConfig("config", { home, xdg: env.XDG_CONFIG_HOME }).workspace;
|
|
1503
2469
|
return typeof folder === "string" && folder !== "" ? folder : undefined;
|
|
1504
2470
|
}
|
|
1505
|
-
function workspaceRoot({ given, env =
|
|
2471
|
+
function workspaceRoot({ given, env = process21.env, home = homedir5() } = {}) {
|
|
1506
2472
|
const fromEnv = env.KAYNOOO_WORKSPACE === "" ? undefined : env.KAYNOOO_WORKSPACE;
|
|
1507
|
-
return resolve4(expandHome(given ?? fromEnv ?? configured(env, home) ??
|
|
2473
|
+
return resolve4(expandHome(given ?? fromEnv ?? configured(env, home) ?? join9(home, "Workspace"), home));
|
|
1508
2474
|
}
|
|
1509
2475
|
// src/git.ts
|
|
1510
2476
|
async function git2(args, env) {
|
|
@@ -1567,9 +2533,9 @@ function commitMessageViolation(message) {
|
|
|
1567
2533
|
}
|
|
1568
2534
|
|
|
1569
2535
|
// src/gc.ts
|
|
1570
|
-
var USAGE = `gc <title> [-m <line>]... [--ticket <line>]... -- <path>...: commits exactly the paths given, its message checked before anything is staged
|
|
2536
|
+
var USAGE = `gc <title> [-m <line>]... [--ticket <line>]... -- <path>...: commits exactly the paths given, its message checked before anything is staged; a merge, cherry-pick or revert in progress is refused, as git commits it only whole
|
|
1571
2537
|
|
|
1572
|
-
Exits 0 when it committed, 1 when the message is refused or git fails (nothing is committed), 2 on a usage error or outside a git repository, 128 plus the signal when interrupted.`;
|
|
2538
|
+
Exits 0 when it committed, 1 when the message is refused, a merge, cherry-pick or revert is in progress, or git fails (nothing is committed, the index is put back as it was), 2 on a usage error or outside a git repository, 128 plus the signal when interrupted.`;
|
|
1573
2539
|
var OPTIONS = {
|
|
1574
2540
|
message: { type: "string", short: "m", multiple: true, description: "a line on what changed, at most two" },
|
|
1575
2541
|
ticket: { type: "string", multiple: true, description: "a ticket line, `#<n> - <title>` (`owner/repo#<n> - <title>` across repositories) copied verbatim from the ticket" },
|
|
@@ -1578,7 +2544,9 @@ var OPTIONS = {
|
|
|
1578
2544
|
};
|
|
1579
2545
|
var RENAME = /^[RC]\d*$/;
|
|
1580
2546
|
var NOT_A_REPOSITORY = /not a git repository/i;
|
|
1581
|
-
var
|
|
2547
|
+
var TRAILING_SLASHES = /\/+$/;
|
|
2548
|
+
var SEQUENCES = [["MERGE_HEAD", "a merge", "gm --continue"], ["CHERRY_PICK_HEAD", "a cherry-pick", "git cherry-pick --continue"], ["REVERT_HEAD", "a revert", "git revert --continue"]];
|
|
2549
|
+
var LITERAL = { ...process23.env, GIT_LITERAL_PATHSPECS: "1" };
|
|
1582
2550
|
function messageOf(title, lines, tickets) {
|
|
1583
2551
|
return [title, lines.join(`
|
|
1584
2552
|
`), tickets.join(`
|
|
@@ -1594,27 +2562,49 @@ ${stderr.trim()}`, NOT_A_REPOSITORY.test(stderr) ? 2 : 1);
|
|
|
1594
2562
|
return stdout;
|
|
1595
2563
|
}
|
|
1596
2564
|
async function stagedElsewhere(paths) {
|
|
1597
|
-
const [all, given] = await Promise.all([checked(["diff", "--cached", "--name-only", "-z"]), checked(["diff", "--cached", "--name-only", "-z", "--", ...paths])]);
|
|
2565
|
+
const [all, given] = await Promise.all([checked(["diff", "--cached", "--name-only", "--no-relative", "-z"]), checked(["diff", "--cached", "--name-only", "--no-relative", "-z", "--", ...paths])]);
|
|
1598
2566
|
const ours = new Set(given.split("\x00"));
|
|
1599
2567
|
return all.split("\x00").filter((path) => path !== "" && !ours.has(path));
|
|
1600
2568
|
}
|
|
2569
|
+
function onDisk(path) {
|
|
2570
|
+
try {
|
|
2571
|
+
return join10(realpathSync3(dirname6(path)), basename(path));
|
|
2572
|
+
} catch {
|
|
2573
|
+
return path;
|
|
2574
|
+
}
|
|
2575
|
+
}
|
|
1601
2576
|
async function renameSources(paths) {
|
|
1602
|
-
const
|
|
2577
|
+
const [top = "", prefix = ""] = (await checked(["rev-parse", "--show-toplevel", "--show-prefix"])).split(`
|
|
2578
|
+
`);
|
|
2579
|
+
const specs = paths.map((path) => (isAbsolute2(path) ? relative(top, onDisk(path)) : join10(prefix, path)).replace(TRAILING_SLASHES, "") || ".");
|
|
2580
|
+
const covered = (name) => specs.some((spec) => spec === "." || name === spec || name.startsWith(`${spec}/`));
|
|
2581
|
+
const fields = (await checked(["diff", "--cached", "-M", "--name-status", "--no-relative", "-z"])).split("\x00");
|
|
1603
2582
|
const sources = [];
|
|
1604
2583
|
for (let i = 0;i < fields.length; i++) {
|
|
1605
2584
|
if (!RENAME.test(fields[i] ?? ""))
|
|
1606
2585
|
continue;
|
|
1607
2586
|
const from = fields[i + 1] ?? "";
|
|
1608
2587
|
const to = fields[i + 2] ?? "";
|
|
1609
|
-
if (
|
|
1610
|
-
sources.push(from);
|
|
2588
|
+
if (covered(to) && !covered(from))
|
|
2589
|
+
sources.push(relative(prefix, from));
|
|
1611
2590
|
i += 2;
|
|
1612
2591
|
}
|
|
1613
2592
|
return sources;
|
|
1614
2593
|
}
|
|
1615
|
-
async function
|
|
1616
|
-
const
|
|
1617
|
-
|
|
2594
|
+
async function inProgress() {
|
|
2595
|
+
const found = await Promise.all(SEQUENCES.map(async ([ref]) => (await git2(["rev-parse", "-q", "--verify", ref])).code === 0));
|
|
2596
|
+
return SEQUENCES.find((_, i) => found[i]);
|
|
2597
|
+
}
|
|
2598
|
+
async function snapshotIndex() {
|
|
2599
|
+
const index = (await checked(["rev-parse", "--path-format=absolute", "--git-path", "index"])).trim();
|
|
2600
|
+
const copy = `${index}.gc-${process23.pid}`;
|
|
2601
|
+
const existed = existsSync4(index);
|
|
2602
|
+
if (existed)
|
|
2603
|
+
copyFileSync(index, copy);
|
|
2604
|
+
return {
|
|
2605
|
+
restore: () => existed ? renameSync(copy, index) : rmSync2(index, { force: true }),
|
|
2606
|
+
drop: () => rmSync2(copy, { force: true })
|
|
2607
|
+
};
|
|
1618
2608
|
}
|
|
1619
2609
|
function fileLine(line) {
|
|
1620
2610
|
const [letter = "", from = "", to] = line.split("\t");
|
|
@@ -1645,6 +2635,9 @@ ${USAGE}`);
|
|
|
1645
2635
|
const violation = commitMessageViolation(message);
|
|
1646
2636
|
if (violation !== null)
|
|
1647
2637
|
fail(`nothing staged: ${violation}`, 1);
|
|
2638
|
+
const sequence = await inProgress();
|
|
2639
|
+
if (sequence !== undefined)
|
|
2640
|
+
fail(`nothing staged: ${sequence[1]} is in progress, which git commits only whole`, 1, runHint(sequence[2], `finish ${sequence[1]}`));
|
|
1648
2641
|
const statuses = await Promise.all(given.map(async (path) => checked(["status", "--porcelain", "--untracked-files=all", "--", path])));
|
|
1649
2642
|
const unchanged = given.filter((_, i) => statuses[i] === "");
|
|
1650
2643
|
const addable = given.filter((_, i) => !(statuses[i] ?? "").trimEnd().split(`
|
|
@@ -1656,18 +2649,19 @@ ${USAGE}`);
|
|
|
1656
2649
|
const others = await stagedElsewhere(paths);
|
|
1657
2650
|
if (others.length > 0)
|
|
1658
2651
|
fail(`nothing staged: the index already holds ${others.join(", ")}, which this commit would carry along`, 1, runHint(`git restore --staged -- ${others.join(" ")}`, "unstage them, or name them in the paths too"));
|
|
2652
|
+
const index = await snapshotIndex();
|
|
1659
2653
|
const signals = holdSignals();
|
|
1660
2654
|
try {
|
|
1661
2655
|
if (addable.length > 0)
|
|
1662
2656
|
await checked(["add", "--", ...addable]);
|
|
1663
2657
|
if (signals.signal !== undefined) {
|
|
1664
|
-
|
|
2658
|
+
index.restore();
|
|
1665
2659
|
return exitCodeOf(null, signals.signal);
|
|
1666
2660
|
}
|
|
1667
2661
|
const commit = await git2(["commit", "--only", "--cleanup=whitespace", "-m", message, "--", ...paths.map((path) => `:(literal)${path}`)]);
|
|
1668
2662
|
if (commit.code !== 0) {
|
|
1669
|
-
|
|
1670
|
-
const refusal = `git commit failed, the
|
|
2663
|
+
index.restore();
|
|
2664
|
+
const refusal = `git commit failed, the index was put back as it was:
|
|
1671
2665
|
${(commit.stderr + commit.stdout).trim()}`;
|
|
1672
2666
|
if (values.json === true)
|
|
1673
2667
|
fail(refusal, 1);
|
|
@@ -1689,7 +2683,8 @@ ${(commit.stderr + commit.stdout).trim()}`;
|
|
|
1689
2683
|
}
|
|
1690
2684
|
return signals.signal === undefined ? 0 : exitCodeOf(null, signals.signal);
|
|
1691
2685
|
} finally {
|
|
2686
|
+
index.drop();
|
|
1692
2687
|
signals.release();
|
|
1693
2688
|
}
|
|
1694
2689
|
}
|
|
1695
|
-
|
|
2690
|
+
process23.exitCode = await runMain({ name: "gc", run: main });
|