@kaynooo/cli-code 0.15.1 → 0.17.2
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 +22 -21
- package/dist/cli.js +879 -270
- package/package.json +10 -16
- package/dist/hotspots-cli.js +0 -1661
- package/dist/peek-cli.js +0 -1885
- package/dist/todo-scan-cli.js +0 -1654
package/dist/cli.js
CHANGED
|
@@ -1,21 +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 ct = /[aeiou]y$/;
|
|
15
|
-
var N = new Map;
|
|
16
|
-
var Ot = /(?:leaf|loaf|thief|wolf|half|calf|elf|sheaf|scarf|dwarf|hoof|wharf)$/;
|
|
17
|
-
var Gt = /(?:knife|life|wife)$/;
|
|
18
|
-
function K(t, e, { plural: r, zero: n = "singular" } = {}) {
|
|
15
|
+
// ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-rkhsft4a.js
|
|
16
|
+
function G(t, e, { plural: r, zero: n = "singular" } = {}) {
|
|
19
17
|
if (e === 1 || e === 0 && n === "singular")
|
|
20
18
|
return t;
|
|
21
19
|
if (r !== undefined)
|
|
@@ -28,12 +26,10 @@ function K(t, e, { plural: r, zero: n = "singular" } = {}) {
|
|
|
28
26
|
return `${t.slice(0, -1)}ves`;
|
|
29
27
|
return Gt.test(t) ? `${t.slice(0, -2)}ves` : `${t}s`;
|
|
30
28
|
}
|
|
31
|
-
function
|
|
32
|
-
return `${t} ${
|
|
29
|
+
function bo(t, e, { zero: r = "plural", ...n } = {}) {
|
|
30
|
+
return `${t} ${G(e, t, { ...n, zero: r })}`;
|
|
33
31
|
}
|
|
34
|
-
|
|
35
|
-
var Y = /\s/;
|
|
36
|
-
function ko(t, e, r = "...") {
|
|
32
|
+
function Ao(t, e, r = "...") {
|
|
37
33
|
let { suffix: n = "...", includeSuffix: s = false, wordBoundary: o = false } = typeof r === "string" ? { suffix: r } : r;
|
|
38
34
|
if (t.length <= e)
|
|
39
35
|
return t;
|
|
@@ -44,13 +40,25 @@ function ko(t, e, r = "...") {
|
|
|
44
40
|
c = c.trimEnd();
|
|
45
41
|
return s ? (c + n).slice(0, l) : c + n;
|
|
46
42
|
}
|
|
47
|
-
var
|
|
48
|
-
var
|
|
43
|
+
var ct, N, Ot, Gt, Nt, Y, be, W;
|
|
44
|
+
var init_chunk_rkhsft4a = __esm(() => {
|
|
45
|
+
ct = /[aeiou]y$/;
|
|
46
|
+
N = new Map;
|
|
47
|
+
Ot = /(?:leaf|loaf|thief|wolf|half|calf|elf|sheaf|scarf|dwarf|hoof|wharf)$/;
|
|
48
|
+
Gt = /(?:knife|life|wife)$/;
|
|
49
|
+
Nt = /\s+\S*$/;
|
|
50
|
+
Y = /\s/;
|
|
51
|
+
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));
|
|
52
|
+
W = new Map;
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
// ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/text.js
|
|
56
|
+
var init_text = __esm(() => {
|
|
57
|
+
init_chunk_rkhsft4a();
|
|
58
|
+
});
|
|
49
59
|
|
|
50
60
|
// ../kit/src/mode.ts
|
|
51
61
|
import process2 from "process";
|
|
52
|
-
var MODES = new Set(["terminal", "ci", "agent", "pipe"]);
|
|
53
|
-
var AGENT_VARIABLES = ["CLAUDECODE", "AI_AGENT"];
|
|
54
62
|
function isSet(value) {
|
|
55
63
|
return value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false";
|
|
56
64
|
}
|
|
@@ -64,14 +72,13 @@ function outputMode(stream = process2.stdout, env = process2.env) {
|
|
|
64
72
|
return "terminal";
|
|
65
73
|
return isSet(env.CI) ? "ci" : "pipe";
|
|
66
74
|
}
|
|
75
|
+
var MODES, AGENT_VARIABLES;
|
|
76
|
+
var init_mode = __esm(() => {
|
|
77
|
+
MODES = new Set(["terminal", "ci", "agent", "pipe"]);
|
|
78
|
+
AGENT_VARIABLES = ["CLAUDECODE", "AI_AGENT"];
|
|
79
|
+
});
|
|
67
80
|
|
|
68
|
-
//
|
|
69
|
-
import { resolve as resolve3 } from "path";
|
|
70
|
-
import process6 from "process";
|
|
71
|
-
import { pathToFileURL } from "url";
|
|
72
|
-
|
|
73
|
-
// ../../node_modules/.bun/@kaynooo+utils@3.0.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
|
|
74
|
-
var G2 = /^[a-f0-9]+$/i;
|
|
81
|
+
// ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
|
|
75
82
|
function b(r) {
|
|
76
83
|
let e = r.startsWith("#") ? r.slice(1) : r;
|
|
77
84
|
if (!G2.test(e))
|
|
@@ -82,11 +89,6 @@ function b(r) {
|
|
|
82
89
|
throw Error(`Invalid hex color length: ${e.length}`);
|
|
83
90
|
return [Number.parseInt(e.slice(0, 2), 16), Number.parseInt(e.slice(2, 4), 16), Number.parseInt(e.slice(4, 6), 16)];
|
|
84
91
|
}
|
|
85
|
-
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") => {
|
|
86
|
-
let [l, n, c] = b(r);
|
|
87
|
-
return [`${e === "fg" ? 38 : 48};2;${l};${n};${c}`, e === "fg" ? 39 : 49];
|
|
88
|
-
}, ansi256: (r, e = "fg") => [`${e === "fg" ? 38 : 48};5;${r}`, e === "fg" ? 39 : 49] };
|
|
89
|
-
var h = new Set(["", "1", "2", "3", "true"]);
|
|
90
92
|
function C(r, e = globalThis.process?.env ?? {}) {
|
|
91
93
|
if (e.FORCE_COLOR !== undefined)
|
|
92
94
|
return h.has(e.FORCE_COLOR);
|
|
@@ -100,7 +102,7 @@ function f(r, e = []) {
|
|
|
100
102
|
l += `\x1B[${e[t][0]}m`, n = `\x1B[${e[t][1]}m${n}`;
|
|
101
103
|
let c = (t) => C(r.stream ?? globalThis.process?.stdout, r.env) ? l + t + n : t, g = new Map;
|
|
102
104
|
return new Proxy(c, { get(t, i) {
|
|
103
|
-
let a =
|
|
105
|
+
let a = B[i];
|
|
104
106
|
if (Array.isArray(a)) {
|
|
105
107
|
let s = g.get(i);
|
|
106
108
|
if (s === undefined)
|
|
@@ -123,13 +125,21 @@ function f(r, e = []) {
|
|
|
123
125
|
function Fe(r = {}) {
|
|
124
126
|
return f(r);
|
|
125
127
|
}
|
|
126
|
-
var
|
|
128
|
+
var G2, B, h, o;
|
|
129
|
+
var init_chunk_x450vn3m = __esm(() => {
|
|
130
|
+
G2 = /^[a-f0-9]+$/i;
|
|
131
|
+
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") => {
|
|
132
|
+
let [l, n, c] = b(r);
|
|
133
|
+
return [`${e === "fg" ? 38 : 48};2;${l};${n};${c}`, e === "fg" ? 39 : 49];
|
|
134
|
+
}, ansi256: (r, e = "fg") => [`${e === "fg" ? 38 : 48};5;${r}`, e === "fg" ? 39 : 49] };
|
|
135
|
+
h = new Set(["", "1", "2", "3", "true"]);
|
|
136
|
+
o = Fe();
|
|
137
|
+
});
|
|
127
138
|
|
|
128
|
-
//
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
import process5 from "process";
|
|
139
|
+
// ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/tools/colors.js
|
|
140
|
+
var init_colors = __esm(() => {
|
|
141
|
+
init_chunk_x450vn3m();
|
|
142
|
+
});
|
|
133
143
|
|
|
134
144
|
// ../kit/src/config.ts
|
|
135
145
|
import { existsSync } from "fs";
|
|
@@ -145,15 +155,21 @@ function findUp(names, from = process3.cwd(), stop = () => false) {
|
|
|
145
155
|
return;
|
|
146
156
|
}
|
|
147
157
|
}
|
|
158
|
+
var init_config = __esm(() => {
|
|
159
|
+
init_args();
|
|
160
|
+
});
|
|
148
161
|
|
|
149
162
|
// ../kit/src/user-config.ts
|
|
150
163
|
import { existsSync as existsSync2, readFileSync } from "fs";
|
|
151
164
|
import { homedir } from "os";
|
|
152
|
-
import { join as join2 } from "path";
|
|
165
|
+
import { isAbsolute, join as join2 } from "path";
|
|
153
166
|
import process4 from "process";
|
|
167
|
+
function xdgFolder(value, fallback) {
|
|
168
|
+
return value !== undefined && isAbsolute(value) ? value : fallback;
|
|
169
|
+
}
|
|
154
170
|
function configBase(where = {}) {
|
|
155
171
|
const xdg = where.xdg ?? (where.home === undefined ? process4.env.XDG_CONFIG_HOME : undefined);
|
|
156
|
-
return xdg
|
|
172
|
+
return xdgFolder(xdg, join2(where.home ?? homedir(), ".config"));
|
|
157
173
|
}
|
|
158
174
|
function userConfigPath(bin, where = {}) {
|
|
159
175
|
return join2(configBase(where), "kaynooo-cli", `${bin}.json`);
|
|
@@ -180,36 +196,49 @@ function configuredNumber(bin, key, fallback, where = {}, legacy = []) {
|
|
|
180
196
|
const value = readUserConfig(bin, where, legacy)[key];
|
|
181
197
|
return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
|
|
182
198
|
}
|
|
199
|
+
var init_user_config = () => {};
|
|
183
200
|
|
|
184
201
|
// ../kit/src/theme.ts
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
}
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
202
|
+
import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
|
|
203
|
+
import { homedir as homedir2 } from "os";
|
|
204
|
+
import { join as join3, resolve as resolve2 } from "path";
|
|
205
|
+
import process5 from "process";
|
|
206
|
+
function toLinear(channel) {
|
|
207
|
+
const value = channel / 255;
|
|
208
|
+
return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
|
|
209
|
+
}
|
|
210
|
+
function toOklab(hex) {
|
|
211
|
+
const [r, g, b] = [1, 3, 5].map((at) => toLinear(Number.parseInt(hex.slice(at, at + 2), 16)));
|
|
212
|
+
const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
|
|
213
|
+
const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
|
|
214
|
+
const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
|
|
215
|
+
return [0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s, 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s, 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s];
|
|
216
|
+
}
|
|
217
|
+
function fromOklab([lightness, a, b]) {
|
|
218
|
+
const l = (lightness + 0.3963377774 * a + 0.2158037573 * b) ** 3;
|
|
219
|
+
const m = (lightness - 0.1055613458 * a - 0.0638541728 * b) ** 3;
|
|
220
|
+
const s = (lightness - 0.0894841775 * a - 1.291485548 * b) ** 3;
|
|
221
|
+
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];
|
|
222
|
+
return `#${channels.map((channel) => fromLinear(channel).toString(16).padStart(2, "0")).join("")}`;
|
|
223
|
+
}
|
|
224
|
+
function gradientAt(theme, ratio) {
|
|
225
|
+
if (theme.gradient === undefined)
|
|
226
|
+
return;
|
|
227
|
+
const key = theme.gradient.join();
|
|
228
|
+
let ends = ENDS.get(key);
|
|
229
|
+
if (ends === undefined) {
|
|
230
|
+
ends = [toOklab(theme.gradient[0]), toOklab(theme.gradient[1])];
|
|
231
|
+
ENDS.set(key, ends);
|
|
232
|
+
}
|
|
233
|
+
const at = Math.min(1, Math.max(0, ratio));
|
|
234
|
+
const [from, to] = ends;
|
|
235
|
+
return fromOklab(from.map((start, index) => start + (to[index] - start) * at));
|
|
236
|
+
}
|
|
207
237
|
function isColorSpec(spec) {
|
|
208
238
|
if (typeof spec === "number")
|
|
209
239
|
return Number.isInteger(spec) && spec >= 0 && spec <= 255;
|
|
210
240
|
return typeof spec === "string" && spec.trim() !== "" && spec.trim().split(SPACES).every((token) => STYLES.has(token) || HEX.test(token));
|
|
211
241
|
}
|
|
212
|
-
var CUBE = [0, 95, 135, 175, 215, 255];
|
|
213
242
|
function cubeLevel(channel) {
|
|
214
243
|
return CUBE.reduce((best, value, level) => Math.abs(value - channel) < Math.abs(CUBE[best] - channel) ? level : best, 0);
|
|
215
244
|
}
|
|
@@ -234,6 +263,9 @@ function tinted(colors, spec, env = process5.env) {
|
|
|
234
263
|
return chain[token] ?? chain;
|
|
235
264
|
}, colors);
|
|
236
265
|
}
|
|
266
|
+
function shaded(theme, colors, glyph, cells, width, env = process5.env) {
|
|
267
|
+
return Array.from({ length: cells }, (_, index) => tinted(colors, gradientAt(theme, width <= 1 ? 0 : index / (width - 1)) ?? theme.colors.accent, env)(glyph)).join("");
|
|
268
|
+
}
|
|
237
269
|
function isRecord(value) {
|
|
238
270
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
239
271
|
}
|
|
@@ -314,7 +346,6 @@ function applyFile(theme, file, where, warn) {
|
|
|
314
346
|
function endsWalk(home) {
|
|
315
347
|
return (dir) => dir === resolve2(home) || existsSync3(join3(dir, ".git"));
|
|
316
348
|
}
|
|
317
|
-
var warned = new Set;
|
|
318
349
|
function warnOnce(message) {
|
|
319
350
|
if (warned.has(message))
|
|
320
351
|
return;
|
|
@@ -351,8 +382,6 @@ function loadTheme({ env = process5.env, from = process5.cwd(), home = homedir2(
|
|
|
351
382
|
}
|
|
352
383
|
return { theme, sources, preset };
|
|
353
384
|
}
|
|
354
|
-
var current;
|
|
355
|
-
var currentKey = "";
|
|
356
385
|
function activeTheme() {
|
|
357
386
|
const key = `${process5.cwd()}\x00${process5.env.KIT_THEME ?? ""}\x00${process5.env.XDG_CONFIG_HOME ?? ""}`;
|
|
358
387
|
if (current === undefined || key !== currentKey) {
|
|
@@ -361,9 +390,40 @@ function activeTheme() {
|
|
|
361
390
|
}
|
|
362
391
|
return current;
|
|
363
392
|
}
|
|
393
|
+
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 = "";
|
|
394
|
+
var init_theme = __esm(() => {
|
|
395
|
+
init_config();
|
|
396
|
+
init_user_config();
|
|
397
|
+
ENDS = new Map;
|
|
398
|
+
DEFAULT = {
|
|
399
|
+
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" },
|
|
400
|
+
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" },
|
|
401
|
+
accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
|
|
402
|
+
bins: {},
|
|
403
|
+
gradient: ["#c084fc", "#67e8f9"]
|
|
404
|
+
};
|
|
405
|
+
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" };
|
|
406
|
+
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" };
|
|
407
|
+
ASCII = { ok: "+", warn: "!", problem: "x", note: ">", plan: "?", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#", rule: "-", corner: "+", open: "*", leaf: "-", guide: "|" };
|
|
408
|
+
PRESETS = {
|
|
409
|
+
default: {},
|
|
410
|
+
"high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"], gradient: ["#d8b4fe", "#a5f3fc"] },
|
|
411
|
+
mono: { colors: MONO, accents: ["bold"], gradient: undefined },
|
|
412
|
+
ascii: { glyphs: ASCII }
|
|
413
|
+
};
|
|
414
|
+
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"]);
|
|
415
|
+
HEX = /^#[0-9a-f]{6}$/i;
|
|
416
|
+
CONTROL = /\p{Cc}/u;
|
|
417
|
+
MAX_FILE_BYTES = 64 * 1024;
|
|
418
|
+
SPACES = /\s+/;
|
|
419
|
+
CUBE = [0, 95, 135, 175, 215, 255];
|
|
420
|
+
warned = new Set;
|
|
421
|
+
});
|
|
364
422
|
|
|
365
423
|
// ../kit/src/style.ts
|
|
366
|
-
|
|
424
|
+
import { resolve as resolve3 } from "path";
|
|
425
|
+
import process6 from "process";
|
|
426
|
+
import { pathToFileURL } from "url";
|
|
367
427
|
function takesControlCodes(stream, env = process6.env) {
|
|
368
428
|
return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb" && outputMode(stream, env) === "terminal";
|
|
369
429
|
}
|
|
@@ -386,14 +446,6 @@ function role(name, stream, env = process6.env) {
|
|
|
386
446
|
const colors = paint(stream, env);
|
|
387
447
|
return takesControlCodes(stream, env) ? tinted(colors, activeTheme().theme.colors[name], env) : colors;
|
|
388
448
|
}
|
|
389
|
-
var STATUS_WORDS = {
|
|
390
|
-
passed: ["passed", "success", "succeeded", "ok"],
|
|
391
|
-
failed: ["failed", "failure", "error", "errored"],
|
|
392
|
-
running: ["running", "in_progress", "started", "holding"],
|
|
393
|
-
queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
|
|
394
|
-
skipped: ["skipped", "cancelled", "canceled", "manual"]
|
|
395
|
-
};
|
|
396
|
-
var STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
|
|
397
449
|
function header(bin, context, stream, env = process6.env) {
|
|
398
450
|
if (!takesControlCodes(stream, env))
|
|
399
451
|
return "";
|
|
@@ -420,9 +472,24 @@ function hyperlink(text, url, stream, env = process6.env) {
|
|
|
420
472
|
function fileLink(text, path, stream, from = process6.cwd(), env = process6.env) {
|
|
421
473
|
return hyperlink(text, pathToFileURL(resolve3(from, path)).href, stream, env);
|
|
422
474
|
}
|
|
475
|
+
var MARK_WORDS, STATUS_WORDS, STATUS_OF;
|
|
476
|
+
var init_style = __esm(() => {
|
|
477
|
+
init_colors();
|
|
478
|
+
init_mode();
|
|
479
|
+
init_theme();
|
|
480
|
+
MARK_WORDS = { ok: "ok:", warn: "warning:", problem: "error:", note: "note:", plan: "would:" };
|
|
481
|
+
STATUS_WORDS = {
|
|
482
|
+
passed: ["passed", "success", "succeeded", "ok"],
|
|
483
|
+
failed: ["failed", "failure", "error", "errored"],
|
|
484
|
+
running: ["running", "in_progress", "started", "holding"],
|
|
485
|
+
queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
|
|
486
|
+
skipped: ["skipped", "cancelled", "canceled", "manual"]
|
|
487
|
+
};
|
|
488
|
+
STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
|
|
489
|
+
});
|
|
423
490
|
|
|
424
491
|
// ../kit/src/format.ts
|
|
425
|
-
|
|
492
|
+
import process7 from "process";
|
|
426
493
|
function formatSeconds(total) {
|
|
427
494
|
let rest = Math.max(0, Math.round(total));
|
|
428
495
|
const amounts = UNITS.map(([unit, size]) => {
|
|
@@ -439,15 +506,16 @@ function formatSeconds(total) {
|
|
|
439
506
|
function formatDuration(ms) {
|
|
440
507
|
return ms < 60000 ? `${(Math.max(0, ms) / 1000).toFixed(1)}s` : formatSeconds(ms / 1000);
|
|
441
508
|
}
|
|
509
|
+
function formatElapsed(ms) {
|
|
510
|
+
return formatSeconds(Math.floor(Math.max(0, ms) / 1000));
|
|
511
|
+
}
|
|
442
512
|
function upTo(text, separator) {
|
|
443
513
|
const end = text.indexOf(separator);
|
|
444
514
|
return end === -1 ? text : text.slice(0, end);
|
|
445
515
|
}
|
|
446
516
|
function truncate(text, width) {
|
|
447
|
-
return
|
|
517
|
+
return Ao(text, width, { suffix: "\u2026", includeSuffix: true });
|
|
448
518
|
}
|
|
449
|
-
var LINE_BREAKS = /\s*\n\s*/g;
|
|
450
|
-
var ESCAPE = String.fromCharCode(27);
|
|
451
519
|
function textWidth(text) {
|
|
452
520
|
return Bun.stringWidth(text);
|
|
453
521
|
}
|
|
@@ -496,14 +564,40 @@ function jsonText(value, replacer, { stream = process7.stdout, env = process7.en
|
|
|
496
564
|
function printJson(value) {
|
|
497
565
|
console.log(jsonText(value));
|
|
498
566
|
}
|
|
567
|
+
var UNITS, LINE_BREAKS, ESCAPE;
|
|
568
|
+
var init_format = __esm(() => {
|
|
569
|
+
init_text();
|
|
570
|
+
init_mode();
|
|
571
|
+
init_style();
|
|
572
|
+
UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
|
|
573
|
+
LINE_BREAKS = /\s*\n\s*/g;
|
|
574
|
+
ESCAPE = String.fromCharCode(27);
|
|
575
|
+
});
|
|
499
576
|
|
|
500
577
|
// ../kit/src/help.ts
|
|
501
578
|
import process8 from "process";
|
|
502
|
-
var OPTIONAL = /(?<!\x1B)\[[^\]]+\]/g;
|
|
503
|
-
var USAGE_PREFIX = /^usage:\s*/i;
|
|
504
|
-
var FULL_STOP = /\.$/;
|
|
505
579
|
function usageLine(usage, colors = paint(process8.stdout)) {
|
|
506
|
-
|
|
580
|
+
const lines = usage.replace(USAGE_PREFIX, "").split(`
|
|
581
|
+
`);
|
|
582
|
+
const blank = lines.indexOf("");
|
|
583
|
+
const synopses = blank === -1 ? lines : lines.slice(0, blank);
|
|
584
|
+
const details = blank === -1 ? [] : lines.slice(blank + 1);
|
|
585
|
+
const colon = synopses[0].indexOf(": ");
|
|
586
|
+
const inline = synopses[0].slice(colon + 2);
|
|
587
|
+
const summary = colon === -1 ? details.shift() : `${inline.charAt(0).toUpperCase()}${inline.slice(1)}`;
|
|
588
|
+
if (colon !== -1)
|
|
589
|
+
synopses[0] = synopses[0].slice(0, colon);
|
|
590
|
+
const head = `${colors.bold("Usage:")} ${synopses.map((line) => line.replaceAll(OPTIONAL, (part) => colors.dim(part))).join(`
|
|
591
|
+
`)}`;
|
|
592
|
+
const lead = summary === undefined ? [] : ["", colors.bold(prose(summary, colors))];
|
|
593
|
+
const rest = details.length === 0 ? [] : ["", ...details.map((line) => prose(line, colors))];
|
|
594
|
+
return [head, ...lead, ...rest].join(`
|
|
595
|
+
`);
|
|
596
|
+
}
|
|
597
|
+
function prose(line, colors) {
|
|
598
|
+
if (colors.cyan("x") === "x")
|
|
599
|
+
return line;
|
|
600
|
+
return line.replaceAll(PROSE_MARKS, (match, code, flag) => code === undefined ? colors.cyan(flag ?? match) : colors.bold(code));
|
|
507
601
|
}
|
|
508
602
|
function helpText(usage, options, colors = paint(process8.stdout), { examples = [], exits = [] } = {}) {
|
|
509
603
|
return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join(`
|
|
@@ -538,7 +632,6 @@ function exampleRows(examples, colors = paint(process8.stdout)) {
|
|
|
538
632
|
return [];
|
|
539
633
|
return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? ` ${example}` : ` ${example[0]} ${colors.dim(`# ${example[1]}`)}`)];
|
|
540
634
|
}
|
|
541
|
-
var MAX_INLINE_CHOICES = 24;
|
|
542
635
|
function optionRows(options, colors = paint(process8.stdout)) {
|
|
543
636
|
const rows = Object.entries(options).map(([name, option]) => {
|
|
544
637
|
const short = option.short === undefined ? " " : `${colors.cyan(`-${option.short}`)}, `;
|
|
@@ -553,6 +646,15 @@ function optionRows(options, colors = paint(process8.stdout)) {
|
|
|
553
646
|
const width = Math.max(0, ...rows.map((row) => row.width));
|
|
554
647
|
return rows.map((row) => row.description === "" ? ` ${row.flag}` : ` ${row.flag}${" ".repeat(width - row.width)} ${colors.dim(row.description)}`);
|
|
555
648
|
}
|
|
649
|
+
var OPTIONAL, USAGE_PREFIX, FULL_STOP, PROSE_MARKS, MAX_INLINE_CHOICES = 24;
|
|
650
|
+
var init_help = __esm(() => {
|
|
651
|
+
init_mode();
|
|
652
|
+
init_style();
|
|
653
|
+
OPTIONAL = /(?<!\x1B)\[[^\]]+\]/g;
|
|
654
|
+
USAGE_PREFIX = /^usage:\s*/i;
|
|
655
|
+
FULL_STOP = /\.$/;
|
|
656
|
+
PROSE_MARKS = /`([^`\n]+)`|(?<![\w-])(--[a-z][\w-]*|-[a-z](?![\w-]))/gi;
|
|
657
|
+
});
|
|
556
658
|
|
|
557
659
|
// ../kit/src/text.ts
|
|
558
660
|
function distance(a, b) {
|
|
@@ -580,9 +682,10 @@ function closest(name, names) {
|
|
|
580
682
|
const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
|
|
581
683
|
return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
|
|
582
684
|
}
|
|
685
|
+
var init_text2 = () => {};
|
|
686
|
+
|
|
583
687
|
// ../kit/src/input.ts
|
|
584
688
|
import { fstatSync } from "fs";
|
|
585
|
-
var WHOLE = /^\d+$/;
|
|
586
689
|
function wholeNumber(value, name, fallback, min = 1) {
|
|
587
690
|
if (value === undefined)
|
|
588
691
|
return fallback;
|
|
@@ -591,8 +694,6 @@ function wholeNumber(value, name, fallback, min = 1) {
|
|
|
591
694
|
badUsage(`${name.startsWith("<") ? name : `--${name}`} takes a whole number from ${min}, not ${value}`);
|
|
592
695
|
return number;
|
|
593
696
|
}
|
|
594
|
-
var DURATION = /^(\d+(?:\.\d+)?)(ms|[smhd])?$/;
|
|
595
|
-
var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
|
|
596
697
|
function duration(value, name, fallback, unit = "s") {
|
|
597
698
|
if (value === undefined)
|
|
598
699
|
return fallback;
|
|
@@ -606,40 +707,27 @@ function isStdinPiped() {
|
|
|
606
707
|
const stat = fstatSync(0);
|
|
607
708
|
return stat.isFIFO() || stat.isFile();
|
|
608
709
|
}
|
|
710
|
+
var WHOLE, DURATION, UNIT_MS;
|
|
711
|
+
var init_input = __esm(() => {
|
|
712
|
+
init_args();
|
|
713
|
+
WHOLE = /^\d+$/;
|
|
714
|
+
DURATION = /^(\d+(?:\.\d+)?)(ms|[smhd])?$/;
|
|
715
|
+
UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
|
|
716
|
+
});
|
|
609
717
|
|
|
610
718
|
// ../kit/src/args.ts
|
|
611
|
-
|
|
719
|
+
import process9 from "process";
|
|
720
|
+
import { parseArgs } from "util";
|
|
612
721
|
function jsonOption(holds) {
|
|
613
722
|
return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
|
|
614
723
|
}
|
|
615
|
-
class Exit extends Error {
|
|
616
|
-
code;
|
|
617
|
-
hint;
|
|
618
|
-
constructor(message, code, hint) {
|
|
619
|
-
super(message);
|
|
620
|
-
this.code = code;
|
|
621
|
-
this.hint = hint;
|
|
622
|
-
}
|
|
623
|
-
}
|
|
624
724
|
function fail(message, code = 2, hint) {
|
|
625
725
|
throw new Exit(message, code, hint);
|
|
626
726
|
}
|
|
627
|
-
|
|
628
|
-
class UsageError extends Exit {
|
|
629
|
-
constructor(message, hint) {
|
|
630
|
-
super(message, 2, hint);
|
|
631
|
-
}
|
|
632
|
-
}
|
|
633
727
|
function badUsage(message) {
|
|
634
728
|
throw new UsageError(message);
|
|
635
729
|
}
|
|
636
730
|
|
|
637
|
-
class HelpShown extends Exit {
|
|
638
|
-
constructor() {
|
|
639
|
-
super("help shown", 0);
|
|
640
|
-
}
|
|
641
|
-
}
|
|
642
|
-
|
|
643
731
|
class Completing {
|
|
644
732
|
options;
|
|
645
733
|
positionals;
|
|
@@ -650,11 +738,6 @@ class Completing {
|
|
|
650
738
|
this.candidates = candidates;
|
|
651
739
|
}
|
|
652
740
|
}
|
|
653
|
-
var completion = { active: false };
|
|
654
|
-
var OUTPUT_OPTIONS = {
|
|
655
|
-
color: { type: "string", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
|
|
656
|
-
plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
|
|
657
|
-
};
|
|
658
741
|
function applyOutput(color, plain, env = process9.env) {
|
|
659
742
|
const when = plain === true ? "never" : color ?? "auto";
|
|
660
743
|
if (when === "auto")
|
|
@@ -808,7 +891,6 @@ function parseError(error) {
|
|
|
808
891
|
const message = upTo(error instanceof Error ? error.message : String(error), ". ");
|
|
809
892
|
return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
|
|
810
893
|
}
|
|
811
|
-
var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
|
|
812
894
|
function nearestOption(message, options, allowNegative) {
|
|
813
895
|
const typed = UNKNOWN_OPTION.exec(message)?.[1];
|
|
814
896
|
if (typed === undefined)
|
|
@@ -824,6 +906,66 @@ function nearestOption(message, options, allowNegative) {
|
|
|
824
906
|
const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
|
|
825
907
|
return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
|
|
826
908
|
}
|
|
909
|
+
var DASHES, EXIT, Exit, UsageError, HelpShown, completion, OUTPUT_OPTIONS, UNKNOWN_OPTION;
|
|
910
|
+
var init_args = __esm(() => {
|
|
911
|
+
init_format();
|
|
912
|
+
init_help();
|
|
913
|
+
init_text2();
|
|
914
|
+
init_help();
|
|
915
|
+
init_input();
|
|
916
|
+
DASHES = /^-+/;
|
|
917
|
+
EXIT = Symbol.for("@kaynooo/cli-kit/Exit");
|
|
918
|
+
Exit = class Exit extends Error {
|
|
919
|
+
code;
|
|
920
|
+
hint;
|
|
921
|
+
[EXIT] = true;
|
|
922
|
+
constructor(message, code, hint) {
|
|
923
|
+
super(message);
|
|
924
|
+
this.code = code;
|
|
925
|
+
this.hint = hint;
|
|
926
|
+
}
|
|
927
|
+
static [Symbol.hasInstance](value) {
|
|
928
|
+
if (this !== Exit)
|
|
929
|
+
return Function.prototype[Symbol.hasInstance].call(this, value);
|
|
930
|
+
return typeof value === "object" && value !== null && value[EXIT] === true;
|
|
931
|
+
}
|
|
932
|
+
};
|
|
933
|
+
UsageError = class UsageError extends Exit {
|
|
934
|
+
constructor(message, hint) {
|
|
935
|
+
super(message, 2, hint);
|
|
936
|
+
}
|
|
937
|
+
};
|
|
938
|
+
HelpShown = class HelpShown extends Exit {
|
|
939
|
+
constructor() {
|
|
940
|
+
super("help shown", 0);
|
|
941
|
+
}
|
|
942
|
+
};
|
|
943
|
+
completion = { active: false };
|
|
944
|
+
OUTPUT_OPTIONS = {
|
|
945
|
+
color: { type: "string", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
|
|
946
|
+
plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
|
|
947
|
+
};
|
|
948
|
+
UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
|
|
949
|
+
});
|
|
950
|
+
|
|
951
|
+
// ../kit/src/folders.ts
|
|
952
|
+
function ignoredFolders(extra = [], where = {}) {
|
|
953
|
+
const configured = readUserConfig("config", where).ignore;
|
|
954
|
+
const names = Array.isArray(configured) ? configured.filter((name) => typeof name === "string" && name !== "") : [];
|
|
955
|
+
return new Set([...SKIPPED_FOLDERS, ...extra, ...names]);
|
|
956
|
+
}
|
|
957
|
+
var SKIPPED_FOLDERS;
|
|
958
|
+
var init_folders = __esm(() => {
|
|
959
|
+
init_user_config();
|
|
960
|
+
SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
|
|
961
|
+
});
|
|
962
|
+
|
|
963
|
+
// src/cli.ts
|
|
964
|
+
import process21 from "process";
|
|
965
|
+
|
|
966
|
+
// ../kit/src/index.ts
|
|
967
|
+
init_args();
|
|
968
|
+
|
|
827
969
|
// ../kit/src/argv.ts
|
|
828
970
|
import { readFileSync as readFileSync3, realpathSync } from "fs";
|
|
829
971
|
import { resolve as resolve4 } from "path";
|
|
@@ -848,10 +990,26 @@ function scriptArgs(argv = process10.argv.slice(2), cmdline = commandLine(), scr
|
|
|
848
990
|
const after = at === -1 ? [] : cmdline.slice(at + 1);
|
|
849
991
|
return after[0] === "--" && after.length === argv.length + 1 && argv.every((word, index) => word === after[index + 1]) ? after : argv;
|
|
850
992
|
}
|
|
993
|
+
// ../kit/src/chart.ts
|
|
994
|
+
init_format();
|
|
995
|
+
init_mode();
|
|
996
|
+
init_style();
|
|
997
|
+
init_theme();
|
|
998
|
+
// ../kit/src/ci.ts
|
|
999
|
+
init_args();
|
|
1000
|
+
init_format();
|
|
1001
|
+
|
|
1002
|
+
// ../kit/src/progress.ts
|
|
1003
|
+
init_format();
|
|
1004
|
+
import process12 from "process";
|
|
1005
|
+
|
|
851
1006
|
// ../kit/src/process.ts
|
|
1007
|
+
import { readFileSync as readFileSync4 } from "fs";
|
|
852
1008
|
import { constants } from "os";
|
|
853
1009
|
import process11 from "process";
|
|
854
1010
|
var KILL_GRACE_MS = 2000;
|
|
1011
|
+
var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
|
|
1012
|
+
var GROUP_SIGNALS = new Set(["SIGINT", "SIGHUP"]);
|
|
855
1013
|
function exitCodeOf(code, signal) {
|
|
856
1014
|
if (code !== null)
|
|
857
1015
|
return code;
|
|
@@ -859,10 +1017,57 @@ function exitCodeOf(code, signal) {
|
|
|
859
1017
|
return 128 + signal;
|
|
860
1018
|
return signal === null ? 129 : 128 + constants.signals[signal];
|
|
861
1019
|
}
|
|
862
|
-
|
|
1020
|
+
function groupsOf(pid) {
|
|
1021
|
+
try {
|
|
1022
|
+
const stat = readFileSync4(`/proc/${pid}/stat`, "utf8");
|
|
1023
|
+
const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
|
|
1024
|
+
return { group: Number(fields[2]), foreground: Number(fields[5]) };
|
|
1025
|
+
} catch {
|
|
1026
|
+
return;
|
|
1027
|
+
}
|
|
1028
|
+
}
|
|
1029
|
+
function heardTheTerminal(child) {
|
|
1030
|
+
if (child.pid === undefined)
|
|
1031
|
+
return false;
|
|
1032
|
+
const own = groupsOf("self");
|
|
1033
|
+
return own !== undefined && own.group === own.foreground && groupsOf(child.pid)?.group === own.group;
|
|
1034
|
+
}
|
|
1035
|
+
function holdSignals(cleanup) {
|
|
1036
|
+
let received;
|
|
1037
|
+
let child;
|
|
1038
|
+
const held = {
|
|
1039
|
+
get signal() {
|
|
1040
|
+
return received;
|
|
1041
|
+
},
|
|
1042
|
+
forward: (to) => {
|
|
1043
|
+
child = to;
|
|
1044
|
+
},
|
|
1045
|
+
release: () => {
|
|
1046
|
+
for (const signal of SIGNALS)
|
|
1047
|
+
process11.off(signal, onSignal);
|
|
1048
|
+
}
|
|
1049
|
+
};
|
|
1050
|
+
function onSignal(signal) {
|
|
1051
|
+
received = signal;
|
|
1052
|
+
if (child !== undefined) {
|
|
1053
|
+
if (!GROUP_SIGNALS.has(signal) || !heardTheTerminal(child))
|
|
1054
|
+
child.kill(signal);
|
|
1055
|
+
return;
|
|
1056
|
+
}
|
|
1057
|
+
if (cleanup === undefined)
|
|
1058
|
+
return;
|
|
1059
|
+
held.release();
|
|
1060
|
+
cleanup(signal);
|
|
1061
|
+
process11.kill(process11.pid, signal);
|
|
1062
|
+
}
|
|
1063
|
+
for (const signal of SIGNALS)
|
|
1064
|
+
process11.on(signal, onSignal);
|
|
1065
|
+
return held;
|
|
1066
|
+
}
|
|
1067
|
+
async function runCommand(argv, { cwd, env, stdin = "ignore", input, timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
|
|
863
1068
|
const chunks = [];
|
|
864
1069
|
const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
|
|
865
|
-
const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
|
|
1070
|
+
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 } : {} });
|
|
866
1071
|
const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
|
|
867
1072
|
const timers = [];
|
|
868
1073
|
const killGroup = (killing) => {
|
|
@@ -902,12 +1107,19 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
902
1107
|
stop();
|
|
903
1108
|
continue;
|
|
904
1109
|
}
|
|
1110
|
+
if (state.truncated)
|
|
1111
|
+
continue;
|
|
1112
|
+
let kept = data;
|
|
905
1113
|
if (state.kept + data.length > maxBytes) {
|
|
1114
|
+
let cut = maxBytes - state.kept;
|
|
1115
|
+
while (cut > 0 && ((data[cut] ?? 0) & 192) === 128)
|
|
1116
|
+
cut--;
|
|
1117
|
+
kept = data.subarray(0, cut);
|
|
906
1118
|
state.truncated = true;
|
|
907
|
-
continue;
|
|
908
1119
|
}
|
|
909
|
-
state.kept +=
|
|
910
|
-
|
|
1120
|
+
state.kept += kept.length;
|
|
1121
|
+
if (kept.length > 0)
|
|
1122
|
+
chunks.push({ stream: name, data: kept });
|
|
911
1123
|
}
|
|
912
1124
|
};
|
|
913
1125
|
try {
|
|
@@ -924,6 +1136,7 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
924
1136
|
const joined = () => Buffer.concat(chunks.map(({ data }) => data));
|
|
925
1137
|
let output;
|
|
926
1138
|
let text;
|
|
1139
|
+
let stdout;
|
|
927
1140
|
return {
|
|
928
1141
|
code: exitCodeOf(proc.exitCode, proc.signalCode),
|
|
929
1142
|
chunks,
|
|
@@ -934,19 +1147,281 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
934
1147
|
},
|
|
935
1148
|
get text() {
|
|
936
1149
|
return text ??= (output ??= joined()).toString();
|
|
1150
|
+
},
|
|
1151
|
+
get stdout() {
|
|
1152
|
+
return stdout ??= Buffer.concat(chunks.filter((chunk) => chunk.stream === "stdout").map((chunk) => chunk.data)).toString();
|
|
937
1153
|
}
|
|
938
1154
|
};
|
|
939
1155
|
}
|
|
940
1156
|
|
|
941
1157
|
// ../kit/src/progress.ts
|
|
1158
|
+
init_style();
|
|
1159
|
+
init_theme();
|
|
1160
|
+
var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
|
|
1161
|
+
var FRAME_MS = 200;
|
|
1162
|
+
var BAR_WIDTH = 20;
|
|
1163
|
+
var CLEAR_BELOW = "\r\x1B[J";
|
|
942
1164
|
var ESC = String.fromCharCode(27);
|
|
943
1165
|
var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
|
|
944
1166
|
var RESET_STYLE = `${ESC}[0m`;
|
|
1167
|
+
var CTRL_C = 3;
|
|
945
1168
|
var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
|
|
1169
|
+
var CONSOLE_METHODS = ["log", "info", "warn", "error", "debug", "dir", "dirxml", "table", "trace", "group", "groupCollapsed", "count", "timeEnd", "timeLog", "assert"];
|
|
1170
|
+
function liveRegion(render, stream = process12.stderr, env = process12.env) {
|
|
1171
|
+
if (!takesControlCodes(stream, env))
|
|
1172
|
+
return { redraw: () => {
|
|
1173
|
+
return;
|
|
1174
|
+
}, print: (text) => void stream.write(`${text}
|
|
1175
|
+
`), stop: () => {
|
|
1176
|
+
return;
|
|
1177
|
+
}, pause: () => () => {
|
|
1178
|
+
return;
|
|
1179
|
+
} };
|
|
1180
|
+
const write = stream.write.bind(stream);
|
|
1181
|
+
let frame = 0;
|
|
1182
|
+
let drawn = false;
|
|
1183
|
+
let paused = false;
|
|
1184
|
+
let stopped = false;
|
|
1185
|
+
const columns = () => {
|
|
1186
|
+
const now = stream.getWindowSize?.()[0] ?? stream.columns;
|
|
1187
|
+
return now === undefined || now === 0 ? 80 : now;
|
|
1188
|
+
};
|
|
1189
|
+
const clear = () => {
|
|
1190
|
+
if (drawn)
|
|
1191
|
+
write(CLEAR_BELOW);
|
|
1192
|
+
drawn = false;
|
|
1193
|
+
};
|
|
1194
|
+
const draw = () => {
|
|
1195
|
+
if (paused)
|
|
1196
|
+
return;
|
|
1197
|
+
const width = columns() - 1;
|
|
1198
|
+
const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
|
|
1199
|
+
const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
|
|
1200
|
+
if (lines.length === 0) {
|
|
1201
|
+
clear();
|
|
1202
|
+
return;
|
|
1203
|
+
}
|
|
1204
|
+
write(`${CLEAR_BELOW}${lines.join(`
|
|
1205
|
+
`)}${lines.length > 1 ? `\x1B[${lines.length - 1}A` : ""}\r`);
|
|
1206
|
+
drawn = true;
|
|
1207
|
+
};
|
|
1208
|
+
let timer = setInterval(draw, FRAME_MS);
|
|
1209
|
+
stream.on?.("resize", draw);
|
|
1210
|
+
let restore = interceptOutput(clear);
|
|
1211
|
+
let release = swallowInput();
|
|
1212
|
+
const onExit = () => {
|
|
1213
|
+
clear();
|
|
1214
|
+
release();
|
|
1215
|
+
};
|
|
1216
|
+
const signals = holdSignals(stop);
|
|
1217
|
+
function stop() {
|
|
1218
|
+
stopped = true;
|
|
1219
|
+
clearInterval(timer);
|
|
1220
|
+
stream.off?.("resize", draw);
|
|
1221
|
+
clear();
|
|
1222
|
+
restore();
|
|
1223
|
+
release();
|
|
1224
|
+
process12.off("exit", onExit);
|
|
1225
|
+
signals.release();
|
|
1226
|
+
}
|
|
1227
|
+
function pause() {
|
|
1228
|
+
if (paused || stopped)
|
|
1229
|
+
return () => {
|
|
1230
|
+
return;
|
|
1231
|
+
};
|
|
1232
|
+
paused = true;
|
|
1233
|
+
clearInterval(timer);
|
|
1234
|
+
stream.off?.("resize", draw);
|
|
1235
|
+
clear();
|
|
1236
|
+
restore();
|
|
1237
|
+
release();
|
|
1238
|
+
return () => {
|
|
1239
|
+
if (!paused || stopped)
|
|
1240
|
+
return;
|
|
1241
|
+
paused = false;
|
|
1242
|
+
timer = setInterval(draw, FRAME_MS);
|
|
1243
|
+
timer.unref();
|
|
1244
|
+
stream.on?.("resize", draw);
|
|
1245
|
+
restore = interceptOutput(clear);
|
|
1246
|
+
release = swallowInput();
|
|
1247
|
+
draw();
|
|
1248
|
+
};
|
|
1249
|
+
}
|
|
1250
|
+
timer.unref();
|
|
1251
|
+
process12.on("exit", onExit);
|
|
1252
|
+
return {
|
|
1253
|
+
redraw: draw,
|
|
1254
|
+
print: (text) => {
|
|
1255
|
+
clear();
|
|
1256
|
+
write(`${text}
|
|
1257
|
+
`);
|
|
1258
|
+
draw();
|
|
1259
|
+
},
|
|
1260
|
+
stop,
|
|
1261
|
+
pause
|
|
1262
|
+
};
|
|
1263
|
+
}
|
|
1264
|
+
function progressLine(stream = process12.stderr, env = process12.env) {
|
|
1265
|
+
const colors = paint(stream, env);
|
|
1266
|
+
const write = stream.write.bind(stream);
|
|
1267
|
+
const begun = performance.now();
|
|
1268
|
+
let started = begun;
|
|
1269
|
+
let current;
|
|
1270
|
+
const region = liveRegion((spinner) => current === undefined ? [] : [tintedParts(progressParts(current, spinner, performance.now() - started), colors)], stream, env);
|
|
1271
|
+
const end = (line) => {
|
|
1272
|
+
region.stop();
|
|
1273
|
+
write(`${line}
|
|
1274
|
+
`);
|
|
1275
|
+
};
|
|
1276
|
+
return {
|
|
1277
|
+
update: (progress) => {
|
|
1278
|
+
const step = current?.step;
|
|
1279
|
+
current = progress;
|
|
1280
|
+
if (progress.step !== step) {
|
|
1281
|
+
started = performance.now();
|
|
1282
|
+
region.redraw();
|
|
1283
|
+
}
|
|
1284
|
+
},
|
|
1285
|
+
stop: region.stop,
|
|
1286
|
+
pause: region.pause,
|
|
1287
|
+
done: (text) => end(marked("ok", text, stream, formatDuration(performance.now() - begun), env)),
|
|
1288
|
+
failed: (text) => end(marked("problem", text, stream, undefined, env))
|
|
1289
|
+
};
|
|
1290
|
+
}
|
|
1291
|
+
function progressParts({ step, done, total, unit }, spinner, ms) {
|
|
1292
|
+
const { theme } = activeTheme();
|
|
1293
|
+
const parts = [{ text: spinner, tint: (colors) => tinted(colors, theme.colors.accent) }, { text: ` ${step}`, tint: () => plain }];
|
|
1294
|
+
if (total !== undefined && total > 0) {
|
|
1295
|
+
const counted = Math.min(done ?? 0, total);
|
|
1296
|
+
const filled = Math.round(counted / total * BAR_WIDTH);
|
|
1297
|
+
parts.push({ text: " ", tint: () => plain }, { text: theme.glyphs.bar.repeat(filled), tint: (colors) => () => shaded(theme, colors, theme.glyphs.bar, filled, BAR_WIDTH) }, { text: theme.glyphs.bar.repeat(BAR_WIDTH - filled), tint: (colors) => colors.dim }, { text: ` ${counted}/${total}${unit === undefined ? "" : ` ${unit}`}`, tint: (colors) => colors.dim });
|
|
1298
|
+
}
|
|
1299
|
+
parts.push({ text: ` ${formatElapsed(ms)}`, tint: (colors) => colors.dim });
|
|
1300
|
+
return parts;
|
|
1301
|
+
}
|
|
1302
|
+
function plain(text) {
|
|
1303
|
+
return text;
|
|
1304
|
+
}
|
|
1305
|
+
function tintedParts(parts, colors) {
|
|
1306
|
+
return parts.map(({ text, tint }) => tint(colors)(text)).join("");
|
|
1307
|
+
}
|
|
1308
|
+
function cutToWidth(line, width) {
|
|
1309
|
+
if (Bun.stringWidth(line) <= width)
|
|
1310
|
+
return line;
|
|
1311
|
+
let room = width;
|
|
1312
|
+
let kept = "";
|
|
1313
|
+
let index = 0;
|
|
1314
|
+
let linked = false;
|
|
1315
|
+
while (index < line.length) {
|
|
1316
|
+
ESCAPE_CODE.lastIndex = index;
|
|
1317
|
+
const escape = ESCAPE_CODE.exec(line);
|
|
1318
|
+
if (escape !== null) {
|
|
1319
|
+
kept += escape[0];
|
|
1320
|
+
linked ||= escape[0].startsWith(`${ESC}]`);
|
|
1321
|
+
index = ESCAPE_CODE.lastIndex;
|
|
1322
|
+
continue;
|
|
1323
|
+
}
|
|
1324
|
+
const char = String.fromCodePoint(line.codePointAt(index));
|
|
1325
|
+
const columns = Bun.stringWidth(char);
|
|
1326
|
+
if (columns > room)
|
|
1327
|
+
break;
|
|
1328
|
+
kept += char;
|
|
1329
|
+
room -= columns;
|
|
1330
|
+
index += char.length;
|
|
1331
|
+
}
|
|
1332
|
+
return `${kept}${RESET_STYLE}${linked ? CLOSE_LINK : ""}`;
|
|
1333
|
+
}
|
|
1334
|
+
function swallowInput() {
|
|
1335
|
+
const input = process12.stdin;
|
|
1336
|
+
if (!input.isTTY)
|
|
1337
|
+
return () => {
|
|
1338
|
+
return;
|
|
1339
|
+
};
|
|
1340
|
+
const onData = (data) => {
|
|
1341
|
+
if (data.includes(CTRL_C))
|
|
1342
|
+
process12.kill(process12.pid, "SIGINT");
|
|
1343
|
+
};
|
|
1344
|
+
input.setRawMode(true);
|
|
1345
|
+
input.on("data", onData);
|
|
1346
|
+
input.resume();
|
|
1347
|
+
let released = false;
|
|
1348
|
+
return () => {
|
|
1349
|
+
if (released)
|
|
1350
|
+
return;
|
|
1351
|
+
released = true;
|
|
1352
|
+
input.off("data", onData);
|
|
1353
|
+
input.pause();
|
|
1354
|
+
input.setRawMode(false);
|
|
1355
|
+
};
|
|
1356
|
+
}
|
|
1357
|
+
function interceptOutput(clear) {
|
|
1358
|
+
const targets = [...CONSOLE_METHODS.map((name) => [console, name]), [process12.stdout, "write"], [process12.stderr, "write"]];
|
|
1359
|
+
const wrapped = targets.map(([target, name]) => {
|
|
1360
|
+
const original = Reflect.get(target, name);
|
|
1361
|
+
const wrapper = (...args) => {
|
|
1362
|
+
clear();
|
|
1363
|
+
return original.apply(target, args);
|
|
1364
|
+
};
|
|
1365
|
+
Reflect.set(target, name, wrapper);
|
|
1366
|
+
return { target, name, original, wrapper };
|
|
1367
|
+
});
|
|
1368
|
+
return () => {
|
|
1369
|
+
for (const { target, name, original, wrapper } of wrapped) {
|
|
1370
|
+
if (Reflect.get(target, name) === wrapper)
|
|
1371
|
+
Reflect.set(target, name, original);
|
|
1372
|
+
}
|
|
1373
|
+
};
|
|
1374
|
+
}
|
|
1375
|
+
|
|
1376
|
+
// ../kit/src/ci.ts
|
|
1377
|
+
init_style();
|
|
1378
|
+
|
|
1379
|
+
// ../kit/src/tool.ts
|
|
1380
|
+
init_format();
|
|
946
1381
|
// ../kit/src/cli.ts
|
|
947
|
-
|
|
1382
|
+
init_args();
|
|
1383
|
+
import { readFileSync as readFileSync5, realpathSync as realpathSync2 } from "fs";
|
|
948
1384
|
import { dirname as dirname3, join as join5 } from "path";
|
|
949
|
-
import
|
|
1385
|
+
import process16 from "process";
|
|
1386
|
+
|
|
1387
|
+
// ../kit/src/askpass.ts
|
|
1388
|
+
import process13 from "process";
|
|
1389
|
+
var SOCKET_VARIABLE = "KAYNOOO_ASKPASS_SOCKET";
|
|
1390
|
+
async function askpassClient(argv) {
|
|
1391
|
+
const socketPath = process13.env[SOCKET_VARIABLE];
|
|
1392
|
+
if (socketPath === undefined)
|
|
1393
|
+
return;
|
|
1394
|
+
const request = { prompt: argv[0] ?? "", ...process13.env.SSH_ASKPASS_PROMPT === "none" ? { notice: true } : {} };
|
|
1395
|
+
const { promise, resolve } = Promise.withResolvers();
|
|
1396
|
+
let received = "";
|
|
1397
|
+
try {
|
|
1398
|
+
await Bun.connect({
|
|
1399
|
+
unix: socketPath,
|
|
1400
|
+
socket: {
|
|
1401
|
+
open: (socket) => void socket.write(`${JSON.stringify(request)}
|
|
1402
|
+
`),
|
|
1403
|
+
data: (_, chunk) => {
|
|
1404
|
+
received += chunk.toString();
|
|
1405
|
+
},
|
|
1406
|
+
close: () => resolve(received),
|
|
1407
|
+
error: () => resolve("")
|
|
1408
|
+
}
|
|
1409
|
+
});
|
|
1410
|
+
} catch {
|
|
1411
|
+
return 1;
|
|
1412
|
+
}
|
|
1413
|
+
const reply = await promise;
|
|
1414
|
+
if (reply === "")
|
|
1415
|
+
return 1;
|
|
1416
|
+
const { answer } = JSON.parse(reply);
|
|
1417
|
+
if (request.notice === true)
|
|
1418
|
+
return 0;
|
|
1419
|
+
if (answer === undefined)
|
|
1420
|
+
return 1;
|
|
1421
|
+
process13.stdout.write(`${answer}
|
|
1422
|
+
`);
|
|
1423
|
+
return 0;
|
|
1424
|
+
}
|
|
950
1425
|
|
|
951
1426
|
// ../kit/src/completions.ts
|
|
952
1427
|
var COMPLETION_SHELLS = ["fish", "bash", "zsh"];
|
|
@@ -1009,34 +1484,42 @@ compdef __kaynooo_cli_complete ${bins.join(" ")}
|
|
|
1009
1484
|
}
|
|
1010
1485
|
|
|
1011
1486
|
// ../kit/src/notify.ts
|
|
1012
|
-
|
|
1487
|
+
init_format();
|
|
1488
|
+
init_mode();
|
|
1489
|
+
import process14 from "process";
|
|
1013
1490
|
var NOTIFY_AFTER_MS = 1e4;
|
|
1014
1491
|
var CANCELLED = 130;
|
|
1015
1492
|
function base64(text) {
|
|
1016
1493
|
return Buffer.from(text).toString("base64");
|
|
1017
1494
|
}
|
|
1018
|
-
function notification(title, body, env =
|
|
1019
|
-
const id = `kit${
|
|
1495
|
+
function notification(title, body, env = process14.env) {
|
|
1496
|
+
const id = `kit${process14.pid}`;
|
|
1020
1497
|
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\\`];
|
|
1021
1498
|
return codes.map((code) => env.TMUX === undefined || env.TMUX === "" ? code : `\x1BPtmux;${code.replaceAll("\x1B", "\x1B\x1B")}\x1B\\`).join("");
|
|
1022
1499
|
}
|
|
1023
|
-
function notifyEnd(command, code, ms, { stream =
|
|
1500
|
+
function notifyEnd(command, code, ms, { stream = process14.stderr, env = process14.env } = {}) {
|
|
1024
1501
|
if (ms < NOTIFY_AFTER_MS || code === CANCELLED || outputMode(stream, env) !== "terminal")
|
|
1025
1502
|
return;
|
|
1026
1503
|
stream.write(notification(command, code === 0 ? `done in ${formatDuration(ms)}` : `failed with exit ${code} after ${formatDuration(ms)}`, env));
|
|
1027
1504
|
}
|
|
1028
1505
|
|
|
1506
|
+
// ../kit/src/cli.ts
|
|
1507
|
+
init_style();
|
|
1508
|
+
init_text2();
|
|
1509
|
+
|
|
1029
1510
|
// ../kit/src/usage.ts
|
|
1030
1511
|
import { appendFileSync, mkdirSync } from "fs";
|
|
1031
1512
|
import { homedir as homedir3 } from "os";
|
|
1032
|
-
import { dirname as dirname2,
|
|
1033
|
-
import
|
|
1513
|
+
import { dirname as dirname2, join as join4 } from "path";
|
|
1514
|
+
import process15 from "process";
|
|
1034
1515
|
|
|
1035
1516
|
// ../kit/src/logs.ts
|
|
1517
|
+
init_user_config();
|
|
1036
1518
|
var DAY_MS = 24 * 60 * 60 * 1000;
|
|
1037
1519
|
var CLI_FOLDER = "kaynooo-cli";
|
|
1038
1520
|
|
|
1039
1521
|
// ../kit/src/usage.ts
|
|
1522
|
+
init_user_config();
|
|
1040
1523
|
var UNKNOWN_OPTION2 = /unknown option '(--[a-z][a-z0-9-]*)[=']/;
|
|
1041
1524
|
var FLAG_NAME = /^(?:--[a-z][a-z0-9-]*|-[a-zA-Z])$/;
|
|
1042
1525
|
var LONGEST_NAME = 40;
|
|
@@ -1044,14 +1527,13 @@ var usageError;
|
|
|
1044
1527
|
function noteUsageError(message) {
|
|
1045
1528
|
usageError = message;
|
|
1046
1529
|
}
|
|
1047
|
-
function stateHome(env =
|
|
1048
|
-
|
|
1049
|
-
return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
|
|
1530
|
+
function stateHome(env = process15.env) {
|
|
1531
|
+
return xdgFolder(env.XDG_STATE_HOME, join4(homedir3(), ".local", "state"));
|
|
1050
1532
|
}
|
|
1051
|
-
function usagePath(env =
|
|
1533
|
+
function usagePath(env = process15.env) {
|
|
1052
1534
|
return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
|
|
1053
1535
|
}
|
|
1054
|
-
function usageRecorded(env =
|
|
1536
|
+
function usageRecorded(env = process15.env) {
|
|
1055
1537
|
const off = env.KAYNOOO_CLI_NO_USAGE;
|
|
1056
1538
|
return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
|
|
1057
1539
|
}
|
|
@@ -1060,12 +1542,12 @@ function flagNames(argv) {
|
|
|
1060
1542
|
const names = (end === -1 ? argv : argv.slice(0, end)).filter((word) => word.startsWith("-") && word !== "-").map((word) => word.includes("=") ? word.slice(0, word.indexOf("=")) : word);
|
|
1061
1543
|
return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
|
|
1062
1544
|
}
|
|
1063
|
-
function usageEntry(bin, command, argv, code, now = new Date) {
|
|
1545
|
+
function usageEntry(bin, command, argv, code, { ms, now = new Date } = {}) {
|
|
1064
1546
|
const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
|
|
1065
1547
|
usageError = undefined;
|
|
1066
|
-
return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
|
|
1548
|
+
return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown }, ...ms === undefined ? {} : { ms: Math.round(ms) } };
|
|
1067
1549
|
}
|
|
1068
|
-
function recordUsage(entry, env =
|
|
1550
|
+
function recordUsage(entry, env = process15.env) {
|
|
1069
1551
|
if (!usageRecorded(env))
|
|
1070
1552
|
return;
|
|
1071
1553
|
try {
|
|
@@ -1120,6 +1602,10 @@ function takeOutputFlags(argv) {
|
|
|
1120
1602
|
async function resolveSummary(summary) {
|
|
1121
1603
|
return typeof summary === "string" ? summary : summary();
|
|
1122
1604
|
}
|
|
1605
|
+
function lookup({ commands, aliases }, word) {
|
|
1606
|
+
const name = aliases !== undefined && Object.hasOwn(aliases, word) ? aliases[word] ?? word : word;
|
|
1607
|
+
return Object.hasOwn(commands, name) ? commands[name] : undefined;
|
|
1608
|
+
}
|
|
1123
1609
|
function scopeOf(commands, extra, aliases) {
|
|
1124
1610
|
return { commands: typeof commands === "function" ? {} : commands, lazy: [...typeof commands === "function" ? [commands] : [], ...extra === undefined ? [] : [extra]], aliases };
|
|
1125
1611
|
}
|
|
@@ -1159,8 +1645,8 @@ async function help2({ path, header, summary: lazySummary, commands, defaultComm
|
|
|
1159
1645
|
`);
|
|
1160
1646
|
}
|
|
1161
1647
|
function printError(prefix, message, hint, cause) {
|
|
1162
|
-
const colors = paint(
|
|
1163
|
-
const styled = takesControlCodes(
|
|
1648
|
+
const colors = paint(process16.stderr);
|
|
1649
|
+
const styled = takesControlCodes(process16.stderr);
|
|
1164
1650
|
const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
|
|
1165
1651
|
const under = (label, text, tint) => text === undefined ? "" : `
|
|
1166
1652
|
${styled ? tint(label) : `${label}:`} ${text}`;
|
|
@@ -1203,23 +1689,23 @@ async function dispatch(level, typed, { version, redact }) {
|
|
|
1203
1689
|
}
|
|
1204
1690
|
}
|
|
1205
1691
|
if (name === undefined && level.path.length > 1) {
|
|
1206
|
-
console.error(await help2(await expand(level, [...level.path.slice(1), ...argv]),
|
|
1692
|
+
console.error(await help2(await expand(level, [...level.path.slice(1), ...argv]), process16.stderr));
|
|
1207
1693
|
return 2;
|
|
1208
1694
|
}
|
|
1209
1695
|
if (name === undefined || name === "help" || name === "--help" || name === "-h") {
|
|
1210
|
-
console.log(await help2(await expand(level, [...level.path.slice(1), ...argv]),
|
|
1696
|
+
console.log(await help2(await expand(level, [...level.path.slice(1), ...argv]), process16.stdout));
|
|
1211
1697
|
return 0;
|
|
1212
1698
|
}
|
|
1213
1699
|
if (level.path.length === 1 && (name === "--version" || name === "-v")) {
|
|
1214
1700
|
console.log(version);
|
|
1215
1701
|
return 0;
|
|
1216
1702
|
}
|
|
1217
|
-
let command = level
|
|
1703
|
+
let command = lookup(level, name);
|
|
1218
1704
|
let rest = args;
|
|
1219
1705
|
let ran = name;
|
|
1220
1706
|
if (command === undefined && level.lazy.length > 0) {
|
|
1221
1707
|
level = await expand(level, [...level.path.slice(1), ...argv]);
|
|
1222
|
-
command = level
|
|
1708
|
+
command = lookup(level, name);
|
|
1223
1709
|
}
|
|
1224
1710
|
if (command === undefined && level.defaultCommand !== undefined) {
|
|
1225
1711
|
command = level.commands[level.defaultCommand];
|
|
@@ -1299,18 +1785,19 @@ async function leafCandidates(run, words) {
|
|
|
1299
1785
|
async function candidates(scope, defaultCommand, words, before = []) {
|
|
1300
1786
|
const [word = "", ...rest] = words;
|
|
1301
1787
|
const listing = rest.length === 0 && !word.startsWith("-");
|
|
1302
|
-
let { commands
|
|
1303
|
-
let command =
|
|
1788
|
+
let { commands } = scope;
|
|
1789
|
+
let command = lookup(scope, word);
|
|
1304
1790
|
if (listing || command === undefined) {
|
|
1305
|
-
|
|
1306
|
-
|
|
1791
|
+
const expanded = await expand(scope, [...before, ...words]);
|
|
1792
|
+
commands = expanded.commands;
|
|
1793
|
+
command = lookup(expanded, word);
|
|
1307
1794
|
}
|
|
1308
1795
|
if (listing) {
|
|
1309
1796
|
const own = await Promise.all(Object.entries(shown(commands)).map(async ([name, { summary }]) => `${name} ${await resolveSummary(summary)}`));
|
|
1310
1797
|
const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
|
|
1311
1798
|
const values = fallback !== undefined && "run" in fallback ? await leafCandidates(fallback.run, [word]) : [];
|
|
1312
1799
|
const valueOf = (line) => line.slice(0, line.includes("\t") ? line.indexOf("\t") : undefined);
|
|
1313
|
-
return [...own, ...values.filter((line) => line !== FILES && !(valueOf(line)
|
|
1800
|
+
return [...own, ...values.filter((line) => line !== FILES && !Object.hasOwn(commands, valueOf(line)))];
|
|
1314
1801
|
}
|
|
1315
1802
|
if (command === undefined) {
|
|
1316
1803
|
const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
|
|
@@ -1343,7 +1830,7 @@ function packageVersion(entry = Bun.main) {
|
|
|
1343
1830
|
} catch {}
|
|
1344
1831
|
for (let dir = dirname3(resolved);; dir = dirname3(dir)) {
|
|
1345
1832
|
try {
|
|
1346
|
-
const { version } = JSON.parse(
|
|
1833
|
+
const { version } = JSON.parse(readFileSync5(join5(dir, "package.json"), "utf8"));
|
|
1347
1834
|
if (typeof version === "string")
|
|
1348
1835
|
return version;
|
|
1349
1836
|
} catch {}
|
|
@@ -1353,6 +1840,9 @@ function packageVersion(entry = Bun.main) {
|
|
|
1353
1840
|
}
|
|
1354
1841
|
async function runCli(cli, argv = scriptArgs()) {
|
|
1355
1842
|
const version = cli.version ?? packageVersion();
|
|
1843
|
+
const answered = await askpassClient(argv);
|
|
1844
|
+
if (answered !== undefined)
|
|
1845
|
+
return answered;
|
|
1356
1846
|
if (argv[0] === COMPLETE)
|
|
1357
1847
|
return printCandidates(candidates(scopeOf(cli.commands, cli.extraCommands, cli.aliases), cli.defaultCommand, argv.slice(1)));
|
|
1358
1848
|
if (argv[0] === COMPLETIONS || argv[0]?.startsWith(`${COMPLETIONS}=`) === true)
|
|
@@ -1363,7 +1853,7 @@ async function runCli(cli, argv = scriptArgs()) {
|
|
|
1363
1853
|
notifyEnd(command === undefined ? cli.name : `${cli.name} ${command}`, code, performance.now() - started);
|
|
1364
1854
|
if (cli.usage !== false) {
|
|
1365
1855
|
try {
|
|
1366
|
-
recordUsage(usageEntry(cli.name, command, argv, code));
|
|
1856
|
+
recordUsage(usageEntry(cli.name, command, argv, code, { ms: performance.now() - started }));
|
|
1367
1857
|
} catch {}
|
|
1368
1858
|
}
|
|
1369
1859
|
return code;
|
|
@@ -1372,8 +1862,7 @@ function commandPath(scope, argv) {
|
|
|
1372
1862
|
const path = [];
|
|
1373
1863
|
let level = scope;
|
|
1374
1864
|
for (const word of argv.filter((each) => !each.startsWith("-"))) {
|
|
1375
|
-
const
|
|
1376
|
-
const command = Object.hasOwn(level.commands, name) ? level.commands[name] : undefined;
|
|
1865
|
+
const command = lookup(level, word);
|
|
1377
1866
|
if (command === undefined)
|
|
1378
1867
|
break;
|
|
1379
1868
|
path.push(word);
|
|
@@ -1383,38 +1872,21 @@ function commandPath(scope, argv) {
|
|
|
1383
1872
|
}
|
|
1384
1873
|
return path.length === 0 ? undefined : path.join(" ");
|
|
1385
1874
|
}
|
|
1386
|
-
|
|
1387
|
-
|
|
1388
|
-
|
|
1389
|
-
|
|
1390
|
-
|
|
1391
|
-
|
|
1392
|
-
|
|
1393
|
-
|
|
1394
|
-
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
|
|
1398
|
-
|
|
1399
|
-
} catch (error) {
|
|
1400
|
-
code = reportThrown(name, error, redact, wantsJson(argv));
|
|
1401
|
-
}
|
|
1402
|
-
notifyEnd(name, code, performance.now() - started);
|
|
1403
|
-
if (usage !== false) {
|
|
1404
|
-
try {
|
|
1405
|
-
recordUsage(usageEntry(name, undefined, argv, code));
|
|
1406
|
-
} catch {}
|
|
1407
|
-
}
|
|
1408
|
-
return code;
|
|
1409
|
-
}
|
|
1410
|
-
// ../kit/src/folders.ts
|
|
1411
|
-
var SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
|
|
1412
|
-
function ignoredFolders(extra = [], where = {}) {
|
|
1413
|
-
const configured = readUserConfig("config", where).ignore;
|
|
1414
|
-
const names = Array.isArray(configured) ? configured.filter((name) => typeof name === "string" && name !== "") : [];
|
|
1415
|
-
return new Set([...SKIPPED_FOLDERS, ...extra, ...names]);
|
|
1416
|
-
}
|
|
1875
|
+
|
|
1876
|
+
// ../kit/src/index.ts
|
|
1877
|
+
init_config();
|
|
1878
|
+
|
|
1879
|
+
// ../kit/src/excerpt.ts
|
|
1880
|
+
init_text2();
|
|
1881
|
+
|
|
1882
|
+
// ../kit/src/index.ts
|
|
1883
|
+
init_folders();
|
|
1884
|
+
init_format();
|
|
1885
|
+
|
|
1886
|
+
// ../kit/src/git.ts
|
|
1887
|
+
init_args();
|
|
1417
1888
|
// ../kit/src/limit.ts
|
|
1889
|
+
init_args();
|
|
1418
1890
|
function limitOptions(fallback) {
|
|
1419
1891
|
return {
|
|
1420
1892
|
limit: { type: "string", short: "n", description: `show at most this many rows, the rest counted (${fallback})` },
|
|
@@ -1435,24 +1907,50 @@ function capped(rows, limit) {
|
|
|
1435
1907
|
const more = rows.length - limit;
|
|
1436
1908
|
return more > 0 ? { shown: rows.slice(0, limit), footer: moreFooter(more) } : { shown: [...rows], footer: undefined };
|
|
1437
1909
|
}
|
|
1910
|
+
|
|
1911
|
+
// ../kit/src/index.ts
|
|
1912
|
+
init_mode();
|
|
1913
|
+
|
|
1914
|
+
// ../kit/src/report.ts
|
|
1915
|
+
init_style();
|
|
1916
|
+
init_text2();
|
|
1438
1917
|
// ../kit/src/secrets.ts
|
|
1439
1918
|
var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
|
|
1919
|
+
var NOT_PASSWORDS = new Set(["compass", "encompass", "bypass", "overpass", "underpass", "surpass", "trespass"]);
|
|
1440
1920
|
// ../kit/src/sessions.ts
|
|
1441
1921
|
var {Glob } = globalThis.Bun;
|
|
1442
1922
|
var SESSION_FILES = new Glob("*.json");
|
|
1443
1923
|
var ACCOUNT_DIRS = new Glob("*/sessions");
|
|
1924
|
+
|
|
1925
|
+
// ../kit/src/index.ts
|
|
1926
|
+
init_style();
|
|
1927
|
+
init_text2();
|
|
1928
|
+
init_theme();
|
|
1929
|
+
init_user_config();
|
|
1930
|
+
|
|
1931
|
+
// ../kit/src/watch.ts
|
|
1932
|
+
init_args();
|
|
1933
|
+
init_input();
|
|
1934
|
+
init_style();
|
|
1935
|
+
// ../kit/src/workspace-root.ts
|
|
1936
|
+
init_user_config();
|
|
1444
1937
|
// src/hotspots.ts
|
|
1445
1938
|
import { basename, join as join7 } from "path";
|
|
1446
|
-
import
|
|
1939
|
+
import process18 from "process";
|
|
1447
1940
|
|
|
1448
1941
|
// src/churn.ts
|
|
1942
|
+
import { availableParallelism } from "os";
|
|
1449
1943
|
var SOURCE = /\.(?:[cm]?[jt]sx?|vue|svelte|astro|kay|py|go|rs|rb|php|java|kt|swift|cs|c|cc|cpp|h|hpp|scala|dart|lua|sh|zsh|fish)$/;
|
|
1450
1944
|
var TESTS = /(?:^|\/)(?:tests?|__tests__|spec|e2e|__mocks__|fixtures)\/|\.(?:test|spec|bench)\.[^/]+$|(?:^|\/)test_[^/]+$|_test\.(?:go|py)$/;
|
|
1451
1945
|
var GENERATED = /(?:^|\/)(?:dist|build|out|generated|\.nuxt|\.output|\.next)\/|\.min\.[cm]?js$|\.d\.ts$|\.(?:generated|gen)\.[^/]+$|\.pb\.go$|\.snap$/;
|
|
1452
1946
|
var LEADING_NEWLINE = /^\n/;
|
|
1947
|
+
var COMMITS_PER_RUN = 500;
|
|
1948
|
+
var MOST_RUNS = Math.max(1, Math.min(4, Math.floor(availableParallelism() / 2)));
|
|
1949
|
+
var COMMIT_START = 1;
|
|
1950
|
+
var LOG_FORMAT = ["--no-renames", "--numstat", "--format=%x01%ct%x02%ae", "-z"];
|
|
1453
1951
|
var GENERATED_HEADER = /@generated|generated by|do not edit/i;
|
|
1454
1952
|
var DECISION = /\b(?:if|elif|elsif|for|foreach|while|until|case|when|catch|except|rescue|match|guard|and|or)\b|&&|\|\||\?\?|\s\?(?![,):.?])/g;
|
|
1455
|
-
var COMMENT_OR_STRING = /(\/\*[\s\S]*?\*\/|\/\/[^\n]*|^[ \t]*#[^\n]*)|'(?:\\.|[^'\\\n])*'|"(?:\\.|[^"\\\n])*"|`(?:\\.|[^`\\])*`/gm;
|
|
1953
|
+
var COMMENT_OR_STRING = /(\/\*[\s\S]*?\*\/|\/\/[^\n]*|^[ \t]*#[^\n]*)|"""[\s\S]*?"""|'''[\s\S]*?'''|'(?:\\.|[^'\\\n])*'|"(?:\\.|[^"\\\n])*"|`(?:\\.|[^`\\])*`/gm;
|
|
1456
1954
|
function isCandidate(path) {
|
|
1457
1955
|
return SOURCE.test(path) && !TESTS.test(path) && !GENERATED.test(path);
|
|
1458
1956
|
}
|
|
@@ -1462,14 +1960,40 @@ function isGenerated(text) {
|
|
|
1462
1960
|
function complexityOf(text) {
|
|
1463
1961
|
return 1 + (text.replace(COMMENT_OR_STRING, (_, comment) => comment === undefined ? '""' : "").match(DECISION)?.length ?? 0);
|
|
1464
1962
|
}
|
|
1465
|
-
async function
|
|
1466
|
-
const
|
|
1467
|
-
|
|
1963
|
+
async function readLog(cwd, commits, onProgress) {
|
|
1964
|
+
const runs = Math.min(MOST_RUNS, Math.ceil(commits.length / COMMITS_PER_RUN));
|
|
1965
|
+
const size = Math.ceil(commits.length / runs);
|
|
1966
|
+
let read = 0;
|
|
1967
|
+
const logs = await Promise.all(Array.from({ length: runs }, async (_, run) => runCommand(["git", "log", "--no-walk=unsorted", "--stdin", ...LOG_FORMAT], {
|
|
1968
|
+
cwd,
|
|
1969
|
+
input: `${commits.slice(run * size, (run + 1) * size).join(`
|
|
1970
|
+
`)}
|
|
1971
|
+
`,
|
|
1972
|
+
onChunk: ({ stream, data }) => {
|
|
1973
|
+
if (stream !== "stdout" || onProgress === undefined)
|
|
1974
|
+
return;
|
|
1975
|
+
for (const byte of data) {
|
|
1976
|
+
if (byte === COMMIT_START)
|
|
1977
|
+
read++;
|
|
1978
|
+
}
|
|
1979
|
+
onProgress(read, commits.length);
|
|
1980
|
+
}
|
|
1981
|
+
})));
|
|
1982
|
+
return logs.some((log) => log.code !== 0) ? undefined : logs.map((log) => log.text).join("");
|
|
1983
|
+
}
|
|
1984
|
+
async function churnSince(cwd, since, { bulk, halfLifeMs, now = Date.now(), onProgress }) {
|
|
1985
|
+
const [listed, top] = await Promise.all([runCommand(["git", "rev-list", `--since=${since}`, "HEAD"], { cwd }), runCommand(["git", "rev-parse", "--show-prefix"], { cwd })]);
|
|
1986
|
+
if (listed.code !== 0 || top.code !== 0)
|
|
1987
|
+
return;
|
|
1988
|
+
const commits = listed.text.split(`
|
|
1989
|
+
`).filter(Boolean);
|
|
1990
|
+
const log = commits.length === 0 ? "" : await readLog(cwd, commits, onProgress);
|
|
1991
|
+
if (log === undefined)
|
|
1468
1992
|
return;
|
|
1469
1993
|
const prefix = top.text.trim();
|
|
1470
1994
|
const churn = new Map;
|
|
1471
1995
|
const authors = new Map;
|
|
1472
|
-
for (const commit of log.
|
|
1996
|
+
for (const commit of log.split("\x01").slice(1)) {
|
|
1473
1997
|
const [head = "", ...entries] = commit.split("\x00");
|
|
1474
1998
|
const [stamp = "", author = ""] = head.split("\x02");
|
|
1475
1999
|
const all = entries.map((entry) => entry.replace(LEADING_NEWLINE, "")).filter((entry) => entry !== "").map((entry) => {
|
|
@@ -1589,11 +2113,9 @@ var DEFAULT_BULK = configuredNumber("hotspots", "bulk", 25);
|
|
|
1589
2113
|
var DAY_MS2 = 86400000;
|
|
1590
2114
|
var DEFAULT_HALF_LIFE = "90d";
|
|
1591
2115
|
var DEFAULT_COUNT = configuredNumber("hotspots", "limit", 20);
|
|
1592
|
-
var USAGE = `hotspots [options] [dir]: ranks the source files under dir (here by default) by complexity times churn, the ones both hard to read and often edited first, honouring .gitignore
|
|
2116
|
+
var USAGE = `src hotspots [options] [dir]: ranks the source files under dir (here by default) by complexity times churn, the ones both hard to read and often edited first, honouring .gitignore
|
|
1593
2117
|
|
|
1594
|
-
Complexity is the count of decision points in the file
|
|
1595
|
-
|
|
1596
|
-
Lists at most ${DEFAULT_COUNT} files, the count of the rest after them (--limit <n>, --full for all); --json is never cut unless --limit is given.`;
|
|
2118
|
+
Complexity is the count of decision points in the file plus one, churn the commits touching it since --since, score their product. A commit counts for less the older it is, and one touching more files than --bulk, a format or rename sweep, is left out. Each file also shows its lines changed, its author count ("solo" when one author wrote every change) and its most complex declaration. Test files and generated or built files are left out unless --all.`;
|
|
1597
2119
|
var EXITS = [[0, "it ranked the files"], [1, "no file has commits in the window"], [2, "a usage error or outside a git repository"]];
|
|
1598
2120
|
var OPTIONS = {
|
|
1599
2121
|
since: { type: "string", short: "s", description: `only count the commits since this date, as git reads it (${DEFAULT_SINCE})` },
|
|
@@ -1607,31 +2129,37 @@ var OPTIONS = {
|
|
|
1607
2129
|
var HOT = 0.66;
|
|
1608
2130
|
var WARM = 0.33;
|
|
1609
2131
|
async function hotspots(args) {
|
|
1610
|
-
const { values, positionals } = parse(args, USAGE, OPTIONS, { exits: EXITS, positionals: ["[dir]"], replaces: "guessing which files are worth splitting first", examples: ["hotspots", 'hotspots src --since "3 months ago" --limit 10'] });
|
|
2132
|
+
const { values, positionals } = parse(args, USAGE, OPTIONS, { exits: EXITS, positionals: ["[dir]"], replaces: "guessing which files are worth splitting first", examples: ["hotspots", 'src hotspots src --since "3 months ago" --limit 10'] });
|
|
1611
2133
|
if (positionals.length > 1)
|
|
1612
2134
|
badUsage("give one folder");
|
|
1613
2135
|
const count = limitOf(values, DEFAULT_COUNT);
|
|
1614
|
-
const cwd =
|
|
2136
|
+
const cwd = process18.cwd();
|
|
1615
2137
|
const bulk = Number(values.bulk ?? DEFAULT_BULK);
|
|
1616
2138
|
if (!Number.isInteger(bulk) || bulk < 1)
|
|
1617
2139
|
badUsage(`--bulk takes a number of files, not ${values.bulk}`);
|
|
1618
2140
|
const halfLifeMs = values["half-life"] === "0" ? 0 : duration(values["half-life"], "half-life", 90 * DAY_MS2);
|
|
1619
|
-
const
|
|
1620
|
-
if (churn === undefined)
|
|
1621
|
-
fail("not a git repository, churn comes from its log");
|
|
2141
|
+
const progress = progressLine();
|
|
1622
2142
|
const ranked = [];
|
|
1623
|
-
|
|
1624
|
-
|
|
1625
|
-
|
|
1626
|
-
|
|
1627
|
-
|
|
1628
|
-
|
|
1629
|
-
|
|
1630
|
-
|
|
1631
|
-
|
|
1632
|
-
|
|
2143
|
+
try {
|
|
2144
|
+
progress.update({ step: "reading the git log" });
|
|
2145
|
+
const churn = await churnSince(cwd, values.since ?? DEFAULT_SINCE, { bulk, halfLifeMs, onProgress: (done, total) => progress.update({ step: "reading the git log", done, total, unit: "commits" }) });
|
|
2146
|
+
if (churn === undefined)
|
|
2147
|
+
fail("not a git repository, churn comes from its log");
|
|
2148
|
+
const listed = (await listFiles(positionals[0] === undefined ? [] : [positionals[0]], cwd)).filter((path) => churn.has(path) && (values.all === true || isCandidate(path)));
|
|
2149
|
+
for (const [done, path] of listed.entries()) {
|
|
2150
|
+
progress.update({ step: "measuring the files", done, total: listed.length, unit: "files" });
|
|
2151
|
+
const touched = churn.get(path);
|
|
2152
|
+
const text = await readText(join7(cwd, path));
|
|
2153
|
+
if (text === undefined || values.all !== true && isGenerated(text))
|
|
2154
|
+
continue;
|
|
2155
|
+
const complexity = complexityOf(text);
|
|
2156
|
+
const worst = worstUnit(text, path);
|
|
2157
|
+
ranked.push({ path, score: Math.round(complexity * (values["by-lines"] === true ? touched.linesWeight : touched.weight)), churn: touched.commits, recent: Math.round(touched.weight * 10) / 10, changed: touched.lines, authors: touched.authors, solo: touched.authors === 1, complexity, worst: worst === undefined ? undefined : { name: worst.name, line: worst.line, complexity: worst.complexity }, lines: text.split(`
|
|
1633
2158
|
`).length - (text.endsWith(`
|
|
1634
2159
|
`) ? 1 : 0) });
|
|
2160
|
+
}
|
|
2161
|
+
} finally {
|
|
2162
|
+
progress.stop();
|
|
1635
2163
|
}
|
|
1636
2164
|
if (ranked.length === 0)
|
|
1637
2165
|
fail("no file with commits in that window", 1);
|
|
@@ -1642,8 +2170,8 @@ async function hotspots(args) {
|
|
|
1642
2170
|
printJson(shown);
|
|
1643
2171
|
return 0;
|
|
1644
2172
|
}
|
|
1645
|
-
const colors = paint(
|
|
1646
|
-
const path = role("path",
|
|
2173
|
+
const colors = paint(process18.stdout);
|
|
2174
|
+
const path = role("path", process18.stdout);
|
|
1647
2175
|
const top = shown.reduce((highest, row) => Math.max(highest, row.score), 0);
|
|
1648
2176
|
const heat = (score, text) => {
|
|
1649
2177
|
if (top > 0 && score >= top * HOT)
|
|
@@ -1651,7 +2179,7 @@ async function hotspots(args) {
|
|
|
1651
2179
|
return top > 0 && score >= top * WARM ? colors.yellow(text) : text;
|
|
1652
2180
|
};
|
|
1653
2181
|
printHeader("hotspots", `${basename(cwd)} \xB7 since ${values.since ?? DEFAULT_SINCE}`);
|
|
1654
|
-
console.log(table([["rank", "score", "churn", "recent", "changed", "authors", "complexity", "lines", "file", "most complex declaration"], ...shown.map((row) => [colors.dim(String(row.rank)), heat(row.score, String(row.score)), ...[row.churn, row.recent, row.changed].map(String), row.solo ? colors.dim("1 solo") : String(row.authors), ...[row.complexity, row.lines].map(String), fileLink(path(row.path), row.path,
|
|
2182
|
+
console.log(table([["rank", "score", "churn", "recent", "changed", "authors", "complexity", "lines", "file", "most complex declaration"], ...shown.map((row) => [colors.dim(String(row.rank)), heat(row.score, String(row.score)), ...[row.churn, row.recent, row.changed].map(String), row.solo ? colors.dim("1 solo") : String(row.authors), ...[row.complexity, row.lines].map(String), fileLink(path(row.path), row.path, process18.stdout, cwd), row.worst === undefined ? "" : `${row.worst.name} (${row.worst.complexity}, line ${row.worst.line})`])], { header: true, align: ["right", "right", "right", "right", "right", "right", "right", "right", "left", "left"] }));
|
|
1655
2183
|
if (footer !== undefined)
|
|
1656
2184
|
console.log(footer);
|
|
1657
2185
|
return 0;
|
|
@@ -1660,7 +2188,8 @@ async function hotspots(args) {
|
|
|
1660
2188
|
// src/peek.ts
|
|
1661
2189
|
import { realpathSync as realpathSync3 } from "fs";
|
|
1662
2190
|
import { isAbsolute as isAbsolute2, join as join8, relative as relative2, resolve as resolve5, sep } from "path";
|
|
1663
|
-
import
|
|
2191
|
+
import process19 from "process";
|
|
2192
|
+
init_text();
|
|
1664
2193
|
|
|
1665
2194
|
// src/source.ts
|
|
1666
2195
|
var LOCATION = /^(?:\.\/)?([^\s:()]+)(?::(\d+)(?::\d+)?|\((\d+),\d+\))(?=[:\s)]|$)/;
|
|
@@ -1671,7 +2200,7 @@ var MODIFIERS = new RegExp(String.raw`^(?:(?:${MODIFIER_WORDS})+${RETURN_TYPE})?
|
|
|
1671
2200
|
var MEMBER = new RegExp(String.raw`^(?:(?:${MODIFIER_WORDS})+${RETURN_TYPE})?[#\w$]+\s*(?:<[^>]*>\s*)?\(`);
|
|
1672
2201
|
var RECEIVER = /^(?:\([^)]*\)\s*)?/;
|
|
1673
2202
|
var STAR = /^\*?\s*/;
|
|
1674
|
-
var HOLDS_MEMBERS = /\b(?:class|interface|trait|impl|
|
|
2203
|
+
var HOLDS_MEMBERS = /\b(?:(?:class|interface|trait|struct|enum)\s|impl[\s<]|(?:record|extension|protocol|object)\s+[A-Z]|companion\s+object\b)/;
|
|
1675
2204
|
var CALL_KEYWORDS = /^(?:if|for|while|switch|catch|return|await|throw|new|else|do|try|super|typeof)\b/;
|
|
1676
2205
|
var LEADING = /^(?:\/\/|\/\*|\*|#(?!!)|@)/;
|
|
1677
2206
|
var LOCAL_BINDING = /^(?:const|let|var)\s/;
|
|
@@ -1682,6 +2211,12 @@ var INDENTED = /\.(?:py|yml|yaml)$/i;
|
|
|
1682
2211
|
var INDENT = /^\s*/;
|
|
1683
2212
|
var CONTINUES = /(?:[=(,[{:?|&+\-*/<>]|=>)$/;
|
|
1684
2213
|
var BODY_OPENER = /\s*\{\s*$/;
|
|
2214
|
+
var PROPERTY_FUNCTION = /^[#\w$]+\s*(?:[?!]?:[^=]*)?[:=]\s*(?:async\s+)?(?:function\b|(?:<[^>]*>\s*)?(?:\([^)]*\)|[\w$]+)\s*(?::[^=]+)?=>|(?:<[^>]*>\s*)?\($)/;
|
|
2215
|
+
var OBJECT_POSITION = /(?:[=(,[:?]|\|\||&&|\breturn|\bdefault)\s*$|\bnew\s+[\w$.]+(?:<[^>]*>)?\s*\([^()]*\)\s*$/;
|
|
2216
|
+
var CASE_LABEL = /(?:^|[\s;{])(?:case\b.*|default\s*):\s*$/;
|
|
2217
|
+
var REGEX_BEFORE = /(?:^|[(,=:[!&|?{};]|\b(?:return|typeof|case|throw|yield|await|in|of))\s*$/;
|
|
2218
|
+
var RUST_CHAR = /^'(?:\\(?:u\{[\da-f]{1,6}\}|x[\da-f]{2}|.)|[^'\\])'/i;
|
|
2219
|
+
var RUST = /\.rs$/i;
|
|
1685
2220
|
var LONGEST_DEFINITION = 400;
|
|
1686
2221
|
var LONGEST_SIGNATURE = 160;
|
|
1687
2222
|
function indentOf2(line) {
|
|
@@ -1690,20 +2225,47 @@ function indentOf2(line) {
|
|
|
1690
2225
|
function escaped(name) {
|
|
1691
2226
|
return name.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
|
|
1692
2227
|
}
|
|
1693
|
-
function declares(line, name) {
|
|
2228
|
+
function declares(line, name, inMembers = true) {
|
|
1694
2229
|
const text = line.trim();
|
|
1695
2230
|
const word = new RegExp(String.raw`^${escaped(name)}\b`);
|
|
1696
2231
|
if (DECLARATION.test(text)) {
|
|
1697
2232
|
const rest = text.replace(DECLARATION, "").replace(RECEIVER, "");
|
|
1698
2233
|
return word.test(rest.replace(STAR, ""));
|
|
1699
2234
|
}
|
|
1700
|
-
|
|
2235
|
+
if (!inMembers || line === text || CALL_KEYWORDS.test(text))
|
|
2236
|
+
return false;
|
|
2237
|
+
const named = text.replace(MODIFIERS, "");
|
|
2238
|
+
return word.test(named) && (MEMBER.test(text) && (text.endsWith("{") || text.endsWith(":")) || PROPERTY_FUNCTION.test(named));
|
|
2239
|
+
}
|
|
2240
|
+
function regexEnd(line, start) {
|
|
2241
|
+
let inClass = false;
|
|
2242
|
+
for (let i = start + 1;i < line.length; i++) {
|
|
2243
|
+
const char = line[i];
|
|
2244
|
+
if (char === "\\")
|
|
2245
|
+
i++;
|
|
2246
|
+
else if (char === "[")
|
|
2247
|
+
inClass = true;
|
|
2248
|
+
else if (char === "]")
|
|
2249
|
+
inClass = false;
|
|
2250
|
+
else if (char === "/" && !inClass)
|
|
2251
|
+
return i;
|
|
2252
|
+
}
|
|
2253
|
+
return -1;
|
|
1701
2254
|
}
|
|
1702
|
-
function
|
|
1703
|
-
let braces = 0;
|
|
1704
|
-
let parens = 0;
|
|
2255
|
+
function codeChars(line, quote, rust, each) {
|
|
1705
2256
|
for (let i = 0;i < line.length; i++) {
|
|
1706
2257
|
const char = line[i] ?? "";
|
|
2258
|
+
if (quote.open === "/*") {
|
|
2259
|
+
if (rust && char === "/" && line[i + 1] === "*") {
|
|
2260
|
+
quote.depth++;
|
|
2261
|
+
i++;
|
|
2262
|
+
} else if (char === "*" && line[i + 1] === "/") {
|
|
2263
|
+
quote.depth--;
|
|
2264
|
+
quote.open = quote.depth === 0 ? "" : "/*";
|
|
2265
|
+
i++;
|
|
2266
|
+
}
|
|
2267
|
+
continue;
|
|
2268
|
+
}
|
|
1707
2269
|
if (quote.open !== "") {
|
|
1708
2270
|
if (char === "\\")
|
|
1709
2271
|
i++;
|
|
@@ -1713,9 +2275,30 @@ function depthChange(line, quote) {
|
|
|
1713
2275
|
}
|
|
1714
2276
|
if (char === "/" && line[i + 1] === "/")
|
|
1715
2277
|
break;
|
|
1716
|
-
if (char ===
|
|
2278
|
+
if (char === "/" && line[i + 1] === "*") {
|
|
2279
|
+
quote.open = "/*";
|
|
2280
|
+
quote.depth = 1;
|
|
2281
|
+
i++;
|
|
2282
|
+
continue;
|
|
2283
|
+
}
|
|
2284
|
+
const regex = char === "/" && !rust && REGEX_BEFORE.test(line.slice(0, i)) ? regexEnd(line, i) : -1;
|
|
2285
|
+
if (regex !== -1)
|
|
2286
|
+
i = regex;
|
|
2287
|
+
else if (rust && char === "'")
|
|
2288
|
+
i += (RUST_CHAR.exec(line.slice(i))?.[0].length ?? 1) - 1;
|
|
2289
|
+
else if (char === '"' || char === "'" || char === "`")
|
|
1717
2290
|
quote.open = char;
|
|
1718
|
-
else
|
|
2291
|
+
else
|
|
2292
|
+
each(char, i);
|
|
2293
|
+
}
|
|
2294
|
+
if (quote.open !== "`" && quote.open !== "/*")
|
|
2295
|
+
quote.open = "";
|
|
2296
|
+
}
|
|
2297
|
+
function depthChange(line, quote, rust) {
|
|
2298
|
+
let braces = 0;
|
|
2299
|
+
let parens = 0;
|
|
2300
|
+
codeChars(line, quote, rust, (char) => {
|
|
2301
|
+
if (char === "{")
|
|
1719
2302
|
braces++;
|
|
1720
2303
|
else if (char === "}")
|
|
1721
2304
|
braces--;
|
|
@@ -1723,11 +2306,36 @@ function depthChange(line, quote) {
|
|
|
1723
2306
|
parens++;
|
|
1724
2307
|
else if (char === ")" || char === "]")
|
|
1725
2308
|
parens--;
|
|
1726
|
-
}
|
|
1727
|
-
if (quote.open !== "`")
|
|
1728
|
-
quote.open = "";
|
|
2309
|
+
});
|
|
1729
2310
|
return { braces, parens };
|
|
1730
2311
|
}
|
|
2312
|
+
function memberLines(lines, path) {
|
|
2313
|
+
const everywhere = lines.map(() => true);
|
|
2314
|
+
if (INDENTED.test(path))
|
|
2315
|
+
return everywhere;
|
|
2316
|
+
const quote = { open: "", depth: 0 };
|
|
2317
|
+
const rust = RUST.test(path);
|
|
2318
|
+
const open = [];
|
|
2319
|
+
let previous = "";
|
|
2320
|
+
let lost = false;
|
|
2321
|
+
const members = lines.map((line) => {
|
|
2322
|
+
const inMembers = open.at(-1) === true;
|
|
2323
|
+
codeChars(line, quote, rust, (char, index) => {
|
|
2324
|
+
if (char === "}") {
|
|
2325
|
+
lost ||= open.pop() === undefined;
|
|
2326
|
+
return;
|
|
2327
|
+
}
|
|
2328
|
+
if (char !== "{")
|
|
2329
|
+
return;
|
|
2330
|
+
const before = (line.slice(0, index).trim() === "" ? previous : line.slice(0, index)).trimEnd();
|
|
2331
|
+
open.push(HOLDS_MEMBERS.test(before) || OBJECT_POSITION.test(before) && !CASE_LABEL.test(before));
|
|
2332
|
+
});
|
|
2333
|
+
if (line.trim() !== "")
|
|
2334
|
+
previous = line;
|
|
2335
|
+
return inMembers;
|
|
2336
|
+
});
|
|
2337
|
+
return lost || open.length > 0 || quote.open !== "" ? everywhere : members;
|
|
2338
|
+
}
|
|
1731
2339
|
function endOf(lines, start, path) {
|
|
1732
2340
|
const last = Math.min(lines.length - 1, start + LONGEST_DEFINITION - 1);
|
|
1733
2341
|
if (INDENTED.test(path)) {
|
|
@@ -1742,13 +2350,14 @@ function endOf(lines, start, path) {
|
|
|
1742
2350
|
}
|
|
1743
2351
|
return end;
|
|
1744
2352
|
}
|
|
1745
|
-
const quote = { open: "" };
|
|
2353
|
+
const quote = { open: "", depth: 0 };
|
|
2354
|
+
const rust = RUST.test(path);
|
|
1746
2355
|
let braces = 0;
|
|
1747
2356
|
let parens = 0;
|
|
1748
2357
|
let opened = false;
|
|
1749
2358
|
for (let i = start;i <= last; i++) {
|
|
1750
2359
|
const line = lines[i] ?? "";
|
|
1751
|
-
const change = depthChange(line, quote);
|
|
2360
|
+
const change = depthChange(line, quote, rust);
|
|
1752
2361
|
opened ||= change.braces > 0 || line.includes("{");
|
|
1753
2362
|
braces += change.braces;
|
|
1754
2363
|
parens += change.parens;
|
|
@@ -1766,9 +2375,10 @@ function leadingStart(lines, start) {
|
|
|
1766
2375
|
function definitions(text, path, name) {
|
|
1767
2376
|
const lines = text.split(`
|
|
1768
2377
|
`);
|
|
2378
|
+
const members = memberLines(lines, path);
|
|
1769
2379
|
const spans = [];
|
|
1770
2380
|
for (let i = 0;i < lines.length; i++) {
|
|
1771
|
-
if (!declares(lines[i] ?? "", name))
|
|
2381
|
+
if (!declares(lines[i] ?? "", name, members[i]))
|
|
1772
2382
|
continue;
|
|
1773
2383
|
const end = endOf(lines, i, path);
|
|
1774
2384
|
spans.push({ path, from: leadingStart(lines, i) + 1, to: end + 1 });
|
|
@@ -1837,17 +2447,15 @@ function locations(text) {
|
|
|
1837
2447
|
}
|
|
1838
2448
|
|
|
1839
2449
|
// src/peek.ts
|
|
1840
|
-
var USAGE2 = `peek [options] <file[:from-to]>...: prints files or line spans with their line numbers, several in one call
|
|
2450
|
+
var USAGE2 = `src peek [options] <file[:from-to]>...: prints files or line spans with their line numbers, several in one call
|
|
1841
2451
|
|
|
1842
|
-
peek src/a.ts:120-140 src/b.ts:1-40 the spans, src/a.ts:120 the one line, src/a.ts the whole file
|
|
1843
|
-
peek --def <symbol> [path...] the whole declaration of the symbol, its comments included, --def again for more symbols
|
|
1844
|
-
peek --refs <symbol> [path...] the lines naming the symbol, grouped by file, --defs-first printing its declarations before
|
|
1845
|
-
peek --outline <file>... the declarations and class members, a Markdown file's headings
|
|
1846
|
-
peek --around <regex> [-C 3] [path...] the lines around each match, overlapping ones merged
|
|
1847
|
-
<output> | peek [-C 3] the lines around each path:line the output opens a line with (errs, rg -n, grep -n, tsc, linters)
|
|
1848
|
-
The paths default to the files git keeps here (
|
|
1849
|
-
--refs lists at most 100 lines and --around prints at most 20 spans, the count of the rest after them (--limit <n>, --full for all).
|
|
1850
|
-
--json prints spans as [{path, from, to, lines}], --refs as [{path, line, text}] ({definitions, references} with --defs-first), --outline as [{path, line, depth, text}], the lines never cut and the rows never counted off unless --limit is given.`;
|
|
2452
|
+
src peek src/a.ts:120-140 src/b.ts:1-40 the spans, src/a.ts:120 the one line, src/a.ts the whole file
|
|
2453
|
+
src peek --def <symbol> [path...] the whole declaration of the symbol, its comments included, --def again for more symbols
|
|
2454
|
+
src peek --refs <symbol> [path...] the lines naming the symbol, grouped by file, --defs-first printing its declarations before
|
|
2455
|
+
src peek --outline <file>... the declarations and class members, a Markdown file's headings
|
|
2456
|
+
src peek --around <regex> [-C 3] [path...] the lines around each match, overlapping ones merged
|
|
2457
|
+
<output> | src peek [-C 3] the lines around each path:line the output opens a line with (errs, rg -n, grep -n, tsc, linters)
|
|
2458
|
+
The paths default to the files git keeps here (\`.gitignore\` holds).`;
|
|
1851
2459
|
var EXITS2 = [[0, "it printed something"], [1, "nothing is found, a file cannot be read or a span starts past the end"], [2, "a usage error or a path outside the repository"]];
|
|
1852
2460
|
var REFS_LIMIT = 100;
|
|
1853
2461
|
var AROUND_LIMIT = 20;
|
|
@@ -1860,7 +2468,7 @@ var OPTIONS2 = {
|
|
|
1860
2468
|
"defs-first": { type: "boolean", description: "with --refs, print the symbol's declarations before its lines" },
|
|
1861
2469
|
context: { type: "string", short: "C", description: "lines on each side of an --around match or a piped location (3)" },
|
|
1862
2470
|
...limitOptions(REFS_LIMIT),
|
|
1863
|
-
json: jsonOption()
|
|
2471
|
+
json: jsonOption("spans [{path, from, to, lines}], --refs [{path, line, text}] ({definitions, references} with --defs-first), --outline [{path, line, depth, text}]")
|
|
1864
2472
|
};
|
|
1865
2473
|
var TARGET = /^(.+?):(\d+)(?:-(\d+))?$/;
|
|
1866
2474
|
var LONGEST_LINE = 300;
|
|
@@ -1869,13 +2477,13 @@ function cut(text) {
|
|
|
1869
2477
|
return text.length > LONGEST_LINE ? `${text.slice(0, LONGEST_LINE - 1)}\u2026` : text;
|
|
1870
2478
|
}
|
|
1871
2479
|
async function readableRoot() {
|
|
1872
|
-
const ran = await runCommand(["git", "rev-parse", "--show-toplevel"], { cwd:
|
|
1873
|
-
return realpathSync3(ran.code === 0 ? ran.text.trim() :
|
|
2480
|
+
const ran = await runCommand(["git", "rev-parse", "--show-toplevel"], { cwd: process19.cwd() });
|
|
2481
|
+
return realpathSync3(ran.code === 0 ? ran.text.trim() : process19.cwd());
|
|
1874
2482
|
}
|
|
1875
2483
|
async function isOutside(path) {
|
|
1876
2484
|
let real;
|
|
1877
2485
|
try {
|
|
1878
|
-
real = realpathSync3(resolve5(
|
|
2486
|
+
real = realpathSync3(resolve5(process19.cwd(), path));
|
|
1879
2487
|
} catch {
|
|
1880
2488
|
return false;
|
|
1881
2489
|
}
|
|
@@ -1889,7 +2497,7 @@ async function checkInside(path) {
|
|
|
1889
2497
|
async function pipedSpans(text, context) {
|
|
1890
2498
|
const spans = [];
|
|
1891
2499
|
for (const [path, numbers] of locations(text)) {
|
|
1892
|
-
const source = await isOutside(path) ? undefined : await readText(resolve5(
|
|
2500
|
+
const source = await isOutside(path) ? undefined : await readText(resolve5(process19.cwd(), path));
|
|
1893
2501
|
if (source !== undefined)
|
|
1894
2502
|
spans.push(...spansAround(path, source.replace(TRAILING_NEWLINE2, "").split(`
|
|
1895
2503
|
`).length, numbers, context));
|
|
@@ -1898,7 +2506,7 @@ async function pipedSpans(text, context) {
|
|
|
1898
2506
|
}
|
|
1899
2507
|
async function textOf(path) {
|
|
1900
2508
|
await checkInside(path);
|
|
1901
|
-
const text = await readText(resolve5(
|
|
2509
|
+
const text = await readText(resolve5(process19.cwd(), path));
|
|
1902
2510
|
if (text === undefined)
|
|
1903
2511
|
fail(`cannot read ${path} (missing, binary or too large)`, 1);
|
|
1904
2512
|
return text;
|
|
@@ -1950,14 +2558,14 @@ async function spanOf(target) {
|
|
|
1950
2558
|
if (from < 1 || to < from)
|
|
1951
2559
|
badUsage(`${target}: a span reads <file>:<from>-<to>, from 1 and from <= to`);
|
|
1952
2560
|
if (from > count)
|
|
1953
|
-
fail(`${path} has ${
|
|
2561
|
+
fail(`${path} has ${bo(count, "line")}, ${target} starts past the end`, 1);
|
|
1954
2562
|
return { path, from, to: Math.min(to, count) };
|
|
1955
2563
|
}
|
|
1956
2564
|
async function* sources(paths) {
|
|
1957
2565
|
for (const path of paths)
|
|
1958
2566
|
await checkInside(path);
|
|
1959
|
-
for (const path of await listFiles(paths,
|
|
1960
|
-
const text = await readText(join8(
|
|
2567
|
+
for (const path of await listFiles(paths, process19.cwd())) {
|
|
2568
|
+
const text = await readText(join8(process19.cwd(), path));
|
|
1961
2569
|
if (text !== undefined)
|
|
1962
2570
|
yield { path, text };
|
|
1963
2571
|
}
|
|
@@ -1981,7 +2589,7 @@ async function definitionsOf(symbols, paths) {
|
|
|
1981
2589
|
return [...found.values()].flat();
|
|
1982
2590
|
}
|
|
1983
2591
|
async function peek(args) {
|
|
1984
|
-
const { values, positionals } = parse(args, USAGE2, OPTIONS2, { exits: EXITS2, positionals: ["[target...]"], replaces: "sed -n N,Mp, grep -n chains and whole-file reads", examples: [["peek src/a.ts:120-140 src/b.ts:1-40", "two spans in one call"], ["peek --def parseArgs src", "a whole declaration"]] });
|
|
2592
|
+
const { values, positionals } = parse(args, USAGE2, OPTIONS2, { exits: EXITS2, positionals: ["[target...]"], replaces: "sed -n N,Mp, grep -n chains and whole-file reads", examples: [["src peek src/a.ts:120-140 src/b.ts:1-40", "two spans in one call"], ["src peek --def parseArgs src", "a whole declaration"]] });
|
|
1985
2593
|
const modes = [values.def?.length === 0 ? undefined : values.def, values.refs, values.outline, values.around].filter((mode) => mode !== undefined && mode !== false);
|
|
1986
2594
|
const json = values.json === true;
|
|
1987
2595
|
if (values["defs-first"] === true && values.refs === undefined)
|
|
@@ -2058,7 +2666,7 @@ async function peek(args) {
|
|
|
2058
2666
|
|
|
2059
2667
|
// src/todo-scan.ts
|
|
2060
2668
|
import { join as join9 } from "path";
|
|
2061
|
-
import
|
|
2669
|
+
import process20 from "process";
|
|
2062
2670
|
|
|
2063
2671
|
// src/todo.ts
|
|
2064
2672
|
var COMMENT = /(?<![:\w/])\/\/|\/\*|<!--|(?:^|\s)(?:#|--)(?=\s)|^\s*\*(?=\s|$)/;
|
|
@@ -2066,13 +2674,20 @@ var MARKUP = /\.(?:md|mdx|markdown|html?|xml)$/i;
|
|
|
2066
2674
|
var MARKUP_COMMENT = /<!--/;
|
|
2067
2675
|
var CLOSERS = /\s*(?:\*\/|-->)\s*$/;
|
|
2068
2676
|
var MARKER = /^(?:@|\[)?(TODO|FIXME|HACK|XXX)\b/;
|
|
2069
|
-
var QUOTES = ["'", '"', "`"];
|
|
2677
|
+
var QUOTES = new Set(["'", '"', "`"]);
|
|
2070
2678
|
var ESCAPE2 = /\\./g;
|
|
2071
2679
|
var AFTER_FIRST_LINE = /\n[\s\S]*/;
|
|
2072
2680
|
var REF = /(?<![\w./-])(\w[\w.-]*\/(?!\.+#)[\w.][\w.-]*)#(\d+)\b/g;
|
|
2681
|
+
var FILE_ANCHOR = /\.(?:md|mdx|markdown|txt|rst|adoc|html?)$/i;
|
|
2073
2682
|
function isQuoted(line, index) {
|
|
2074
|
-
|
|
2075
|
-
|
|
2683
|
+
let open;
|
|
2684
|
+
for (const char of line.slice(0, index).replaceAll(ESCAPE2, "")) {
|
|
2685
|
+
if (open === undefined && QUOTES.has(char))
|
|
2686
|
+
open = char;
|
|
2687
|
+
else if (char === open)
|
|
2688
|
+
open = undefined;
|
|
2689
|
+
}
|
|
2690
|
+
return open !== undefined;
|
|
2076
2691
|
}
|
|
2077
2692
|
var BLAME_HEADER = /^[0-9a-f]{40} \d+ (\d+)/;
|
|
2078
2693
|
var DAY_S = 86400;
|
|
@@ -2084,7 +2699,7 @@ async function commitTimes(path, cwd) {
|
|
|
2084
2699
|
const bySha = new Map;
|
|
2085
2700
|
let sha = "";
|
|
2086
2701
|
let line = 0;
|
|
2087
|
-
for (const row of
|
|
2702
|
+
for (const row of blamed.stdout.split(`
|
|
2088
2703
|
`)) {
|
|
2089
2704
|
const header = BLAME_HEADER.exec(row);
|
|
2090
2705
|
if (header !== null) {
|
|
@@ -2118,15 +2733,12 @@ function marksIn(text, path) {
|
|
|
2118
2733
|
continue;
|
|
2119
2734
|
const body = line.slice(opener.index + opener[0].length).replace(CLOSERS, "").trim();
|
|
2120
2735
|
const marker = MARKER.exec(body)?.[1];
|
|
2121
|
-
const refs = [...body.matchAll(REF)].map((found) => ({ repo: found[1] ?? "", number: Number(found[2]) }));
|
|
2736
|
+
const refs = [...body.matchAll(REF)].filter((found) => !FILE_ANCHOR.test(found[1] ?? "")).map((found) => ({ repo: found[1] ?? "", number: Number(found[2]) }));
|
|
2122
2737
|
if (marker !== undefined || refs.length > 0)
|
|
2123
2738
|
marks.push({ path, line: i + 1, kind: marker ?? "ref", text: body, refs });
|
|
2124
2739
|
}
|
|
2125
2740
|
return marks;
|
|
2126
2741
|
}
|
|
2127
|
-
function stdoutOf(chunks) {
|
|
2128
|
-
return Buffer.concat(chunks.filter((chunk) => chunk.stream === "stdout").map((chunk) => chunk.data)).toString();
|
|
2129
|
-
}
|
|
2130
2742
|
function refKey(ref) {
|
|
2131
2743
|
return `${ref.repo}#${ref.number}`;
|
|
2132
2744
|
}
|
|
@@ -2135,7 +2747,7 @@ async function lookUpOnGitHub(repo, numbers, cwd) {
|
|
|
2135
2747
|
for (const ran of await Promise.all(numbers.map(async (number) => ({ number, ran: await runCommand(["gh", "api", `repos/${repo}/issues/${number}`, "--jq", ".state"], { cwd }) })))) {
|
|
2136
2748
|
if (ran.ran.code !== 0)
|
|
2137
2749
|
return ran.ran.text.trim().replace(AFTER_FIRST_LINE, "");
|
|
2138
|
-
states.set(refKey({ repo, number: Number(ran.number) }),
|
|
2750
|
+
states.set(refKey({ repo, number: Number(ran.number) }), ran.ran.stdout.trim());
|
|
2139
2751
|
}
|
|
2140
2752
|
return states;
|
|
2141
2753
|
}
|
|
@@ -2155,7 +2767,7 @@ async function lookUp(refs, cwd) {
|
|
|
2155
2767
|
}
|
|
2156
2768
|
continue;
|
|
2157
2769
|
}
|
|
2158
|
-
const parsed = JSON.parse(
|
|
2770
|
+
const parsed = JSON.parse(ran.stdout);
|
|
2159
2771
|
for (const issue of Array.isArray(parsed) ? parsed : [parsed])
|
|
2160
2772
|
lookup.states.set(refKey({ repo, number: issue.number }), issue.state);
|
|
2161
2773
|
}
|
|
@@ -2163,13 +2775,10 @@ async function lookUp(refs, cwd) {
|
|
|
2163
2775
|
}
|
|
2164
2776
|
|
|
2165
2777
|
// src/todo-scan.ts
|
|
2166
|
-
var USAGE3 = `todo-scan [options] [path...]: lists the TODO, FIXME, HACK, XXX and owner/repo#N comments under the paths (here by default), each as <file>:<line>: <comment>, honouring .gitignore
|
|
2167
|
-
|
|
2168
|
-
--older <duration> keeps only the comments whose line last changed longer ago than that (30d, 12w, 6m: git blame dates each one, a file git cannot blame is left out) and shows each one's age.
|
|
2778
|
+
var USAGE3 = `src todo-scan [options] [path...]: lists the TODO, FIXME, HACK, XXX and owner/repo#N comments under the paths (here by default), each as <file>:<line>: <comment>, honouring .gitignore
|
|
2169
2779
|
|
|
2170
|
-
--
|
|
2171
|
-
|
|
2172
|
-
Lists at most 100 comments, the count of the rest after them (--limit <n>, --full for all); --json is never cut unless --limit is given.`;
|
|
2780
|
+
--older <duration> keeps the comments whose line last changed longer ago than that (\`30d\`, \`12w\`, \`6m\`, dated by git blame) and shows each one's age.
|
|
2781
|
+
--stale keeps the comments naming a closed issue, looked up with \`ft\`, or \`gh\` for a GitHub repository, and exits 1 when it finds one.`;
|
|
2173
2782
|
var EXITS3 = [[0, "it listed the comments or found no stale one"], [1, "--stale finds one"], [2, "a usage error or when --stale could not look a repository up (ft and gh both failed)"]];
|
|
2174
2783
|
var LIST_LIMIT = 100;
|
|
2175
2784
|
var DAY_MS3 = 86400000;
|
|
@@ -2186,8 +2795,8 @@ function printLines(lines, footer) {
|
|
|
2186
2795
|
`));
|
|
2187
2796
|
}
|
|
2188
2797
|
async function todoScan(args) {
|
|
2189
|
-
const { values, positionals } = parse(args, USAGE3, OPTIONS3, { exits: EXITS3, positionals: ["[path...]"], replaces: "grep -rn TODO, then opening each issue it names", examples: ["todo-scan src", ["todo-scan --stale", "only the comments naming a closed issue"]] });
|
|
2190
|
-
const cwd =
|
|
2798
|
+
const { values, positionals } = parse(args, USAGE3, OPTIONS3, { exits: EXITS3, positionals: ["[path...]"], replaces: "grep -rn TODO, then opening each issue it names", examples: ["src todo-scan src", ["src todo-scan --stale", "only the comments naming a closed issue"]] });
|
|
2799
|
+
const cwd = process20.cwd();
|
|
2191
2800
|
const limit = limitOf(values, LIST_LIMIT);
|
|
2192
2801
|
const found = [];
|
|
2193
2802
|
for (const path of await listFiles(positionals, cwd)) {
|
|
@@ -2225,7 +2834,7 @@ async function todoScan(args) {
|
|
|
2225
2834
|
}
|
|
2226
2835
|
|
|
2227
2836
|
// src/cli.ts
|
|
2228
|
-
|
|
2837
|
+
process21.exitCode = await runCli({
|
|
2229
2838
|
name: "src",
|
|
2230
2839
|
about: "reads and ranks the source of a folder: line spans, TODO comments and the files worth splitting",
|
|
2231
2840
|
replaces: "sed -n N,Mp, grep -n chains and grep -rn TODO",
|