@narumitw/pi-btw 0.58.1 → 0.59.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. package/README.md +2 -0
  2. package/dist/index.ts +284 -365
  3. package/dist/index.ts.map +3 -3
  4. package/package.json +52 -53
  5. package/src/bring-to-main.ts +494 -547
  6. package/src/btw.ts +814 -856
  7. package/src/fullscreen-ui.ts +673 -674
  8. package/src/keybindings.ts +228 -270
  9. package/src/main-tree-picker.ts +309 -318
  10. package/src/menu.ts +416 -454
  11. package/src/settings.ts +203 -219
  12. package/src/side-thread.ts +173 -201
  13. package/src/text.ts +21 -23
  14. package/src/transcript-markdown.ts +65 -0
  15. package/src/transcript-pager.ts +611 -662
package/src/menu.ts CHANGED
@@ -1,509 +1,471 @@
1
- import type {
2
- ExtensionCommandContext,
3
- KeybindingsManager,
4
- Theme,
5
- } from "@earendil-works/pi-coding-agent";
1
+ import type { ExtensionCommandContext, KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
6
2
  import type { Component, TUI } from "@earendil-works/pi-tui";
7
3
  import type { MenuContext, RunMenuResult } from "@narumitw/pi-tui-kit";
8
4
  import {
9
- BTW_SHORTCUT_ACTIONS,
10
- type BtwShortcutAction,
11
- normalizeBtwKey,
12
- resolveBtwShortcuts,
13
- validateBtwShortcutEdit,
5
+ BTW_SHORTCUT_ACTIONS,
6
+ type BtwShortcutAction,
7
+ normalizeBtwKey,
8
+ resolveBtwShortcuts,
9
+ validateBtwShortcutEdit,
14
10
  } from "./keybindings.js";
15
11
  import {
16
- type BtwSettings,
17
- type BtwSettingsPatch,
18
- btwSettingsPath,
19
- effectiveFullscreenCopyOnSelect,
20
- effectiveRememberThinkingLevelChanges,
21
- readBtwSettings,
22
- type UpdateBtwSettingsOptions,
23
- updateBtwSettings,
12
+ type BtwSettings,
13
+ type BtwSettingsPatch,
14
+ btwSettingsPath,
15
+ effectiveFullscreenCopyOnSelect,
16
+ effectiveRememberThinkingLevelChanges,
17
+ readBtwSettings,
18
+ type UpdateBtwSettingsOptions,
19
+ updateBtwSettings,
24
20
  } from "./settings.js";
25
21
  import { BTW_THINKING_LEVELS, type BtwThinkingLevel } from "./side-thread.js";
26
22
  import { formatKeyLabel, sanitizeSingleLine } from "./text.js";
27
23
 
28
24
  interface BtwMenuState {
29
- kind: "valid" | "invalid";
30
- settings: BtwSettings;
31
- reason?: string;
25
+ kind: "valid" | "invalid";
26
+ settings: BtwSettings;
27
+ reason?: string;
32
28
  }
33
29
 
34
30
  export interface BtwResumeThreadSummary {
35
- id: string;
36
- title: string;
37
- questionCount: number;
31
+ id: string;
32
+ title: string;
33
+ questionCount: number;
38
34
  }
39
35
 
40
36
  export interface ShowBtwCommandMenuOptions {
41
- currentThinkingLevel: BtwThinkingLevel;
42
- availableThinkingLevels: readonly BtwThinkingLevel[];
43
- resumeThreads?: readonly BtwResumeThreadSummary[];
44
- settingsPath?: string;
45
- readSettings?: typeof readBtwSettings;
46
- updateSettings?: (
47
- patch: BtwSettingsPatch,
48
- options: UpdateBtwSettingsOptions,
49
- ) => Promise<BtwSettings>;
37
+ currentThinkingLevel: BtwThinkingLevel;
38
+ availableThinkingLevels: readonly BtwThinkingLevel[];
39
+ resumeThreads?: readonly BtwResumeThreadSummary[];
40
+ settingsPath?: string;
41
+ readSettings?: typeof readBtwSettings;
42
+ updateSettings?: (patch: BtwSettingsPatch, options: UpdateBtwSettingsOptions) => Promise<BtwSettings>;
50
43
  }
51
44
 
52
- export type BtwCommandMenuResult =
53
- | "start"
54
- | "tree"
55
- | "closed"
56
- | { kind: "resume"; threadId: string };
45
+ export type BtwCommandMenuResult = "start" | "tree" | "closed" | { kind: "resume"; threadId: string };
57
46
 
58
47
  type BtwMenuScreen = "main" | "resume" | "settings" | "invalid" | "shortcut" | "shortcut-input";
59
48
  type BtwMenuAction =
60
- | "start"
61
- | "start-tree"
62
- | "resume"
63
- | "set-thinking"
64
- | "set-remember"
65
- | "set-fullscreen-copy"
66
- | "edit-shortcut"
67
- | "save-shortcut"
68
- | "reset-shortcut";
49
+ | "start"
50
+ | "start-tree"
51
+ | "resume"
52
+ | "set-thinking"
53
+ | "set-remember"
54
+ | "set-fullscreen-copy"
55
+ | "edit-shortcut"
56
+ | "save-shortcut"
57
+ | "reset-shortcut";
69
58
  const SAME_AS_MAIN_THREAD = "Same as main thread";
70
59
  type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
71
60
 
72
61
  type BtwCustomFactory<T> = (
73
- tui: TUI,
74
- theme: Theme,
75
- keybindings: KeybindingsManager,
76
- done: (result: T) => void,
62
+ tui: TUI,
63
+ theme: Theme,
64
+ keybindings: KeybindingsManager,
65
+ done: (result: T) => void,
77
66
  ) => Component;
78
67
 
79
68
  export async function showBtwCommandMenu(
80
- ctx: ExtensionCommandContext,
81
- options: ShowBtwCommandMenuOptions,
69
+ ctx: ExtensionCommandContext,
70
+ options: ShowBtwCommandMenuOptions,
82
71
  ): Promise<BtwCommandMenuResult> {
83
- if (ctx.mode !== "tui") return "closed";
84
- const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
85
- if (ctx.signal?.aborted) return "closed";
86
- const settingsPath = options.settingsPath ?? btwSettingsPath();
87
- const readSettings = options.readSettings ?? readBtwSettings;
88
- const updateSettings = options.updateSettings ?? updateBtwSettings;
89
- const levels =
90
- options.availableThinkingLevels.length > 0
91
- ? [...options.availableThinkingLevels]
92
- : (["off"] satisfies BtwThinkingLevel[]);
93
- const displaySettingsPath = sanitizeSingleLine(settingsPath);
94
- const resumeThreads = options.resumeThreads ?? [];
95
- let startSelected = false;
96
- let treeSelected = false;
97
- let resumedThreadId: string | undefined;
98
- let keybindings: KeybindingsManager | undefined;
99
- let shortcut: BtwShortcutAction = "exit";
100
- const shortcutLabels: Record<BtwShortcutAction, string> = {
101
- exit: "Exit shortcut",
102
- cycleThinkingLevel: "Cycle thinking level shortcut",
103
- bringToMain: "Bring to main shortcut",
104
- };
105
- const shortcutValue = (settings: BtwSettings, action: BtwShortcutAction): string => {
106
- if (!keybindings) return "Default";
107
- const effective = resolveBtwShortcuts(
108
- settings.keybindings,
109
- keybindings,
110
- effectiveFullscreenCopyOnSelect(settings),
111
- );
112
- const configured = settings.keybindings?.[action];
113
- if (configured !== undefined && !effective.keys[action].includes(configured)) {
114
- return `Fallback (${effective.label(action)}; saved ${formatKeyLabel(configured)})`;
115
- }
116
- const source =
117
- configured === undefined
118
- ? action === "cycleThinkingLevel"
119
- ? "Inherit Pi"
120
- : "Default"
121
- : "Custom";
122
- return `${source} (${effective.label(action)})`;
123
- };
124
- const saveShortcut = async (
125
- state: BtwMenuState,
126
- value: string | undefined,
127
- signal: AbortSignal,
128
- ) => {
129
- if (!keybindings || state.kind !== "valid" || signal.aborted)
130
- return { kind: "rejected" } as const;
131
- const action = shortcut;
132
- const manager = keybindings;
133
- const validate = (settings: BtwSettings) =>
134
- validateBtwShortcutEdit(
135
- action,
136
- value,
137
- settings.keybindings ?? {},
138
- manager,
139
- effectiveFullscreenCopyOnSelect(settings),
140
- );
141
- const error = validate(state.settings);
142
- if (error) {
143
- notifySafely(ctx, error, "error");
144
- return { kind: "rejected" } as const;
145
- }
146
- try {
147
- await updateSettings(
148
- { keybindings: { [action]: value === undefined ? undefined : normalizeBtwKey(value) } },
149
- {
150
- settingsPath,
151
- signal,
152
- validateCurrent: (settings) => {
153
- const conflict = validate(settings);
154
- if (conflict) throw new Error(conflict);
155
- },
156
- },
157
- );
158
- if (signal.aborted) return { kind: "rejected" } as const;
159
- notifySafely(ctx, "Pi BTW shortcut saved; applies when opening or resuming BTW.", "info");
160
- return { kind: "back" } as const;
161
- } catch (error) {
162
- if (!signal.aborted) notifySaveFailure(ctx, error);
163
- return { kind: "rejected" } as const;
164
- }
165
- };
72
+ if (ctx.mode !== "tui") return "closed";
73
+ const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
74
+ if (ctx.signal?.aborted) return "closed";
75
+ const settingsPath = options.settingsPath ?? btwSettingsPath();
76
+ const readSettings = options.readSettings ?? readBtwSettings;
77
+ const updateSettings = options.updateSettings ?? updateBtwSettings;
78
+ const levels =
79
+ options.availableThinkingLevels.length > 0
80
+ ? [...options.availableThinkingLevels]
81
+ : (["off"] satisfies BtwThinkingLevel[]);
82
+ const displaySettingsPath = sanitizeSingleLine(settingsPath);
83
+ const resumeThreads = options.resumeThreads ?? [];
84
+ let startSelected = false;
85
+ let treeSelected = false;
86
+ let resumedThreadId: string | undefined;
87
+ let keybindings: KeybindingsManager | undefined;
88
+ let shortcut: BtwShortcutAction = "exit";
89
+ const shortcutLabels: Record<BtwShortcutAction, string> = {
90
+ exit: "Exit shortcut",
91
+ cycleThinkingLevel: "Cycle thinking level shortcut",
92
+ bringToMain: "Bring to main shortcut",
93
+ };
94
+ const shortcutValue = (settings: BtwSettings, action: BtwShortcutAction): string => {
95
+ if (!keybindings) return "Default";
96
+ const effective = resolveBtwShortcuts(settings.keybindings, keybindings, effectiveFullscreenCopyOnSelect(settings));
97
+ const configured = settings.keybindings?.[action];
98
+ if (configured !== undefined && !effective.keys[action].includes(configured)) {
99
+ return `Fallback (${effective.label(action)}; saved ${formatKeyLabel(configured)})`;
100
+ }
101
+ const source = configured === undefined ? (action === "cycleThinkingLevel" ? "Inherit Pi" : "Default") : "Custom";
102
+ return `${source} (${effective.label(action)})`;
103
+ };
104
+ const saveShortcut = async (state: BtwMenuState, value: string | undefined, signal: AbortSignal) => {
105
+ if (!keybindings || state.kind !== "valid" || signal.aborted) return { kind: "rejected" } as const;
106
+ const action = shortcut;
107
+ const manager = keybindings;
108
+ const validate = (settings: BtwSettings) =>
109
+ validateBtwShortcutEdit(
110
+ action,
111
+ value,
112
+ settings.keybindings ?? {},
113
+ manager,
114
+ effectiveFullscreenCopyOnSelect(settings),
115
+ );
116
+ const error = validate(state.settings);
117
+ if (error) {
118
+ notifySafely(ctx, error, "error");
119
+ return { kind: "rejected" } as const;
120
+ }
121
+ try {
122
+ await updateSettings(
123
+ { keybindings: { [action]: value === undefined ? undefined : normalizeBtwKey(value) } },
124
+ {
125
+ settingsPath,
126
+ signal,
127
+ validateCurrent: (settings) => {
128
+ const conflict = validate(settings);
129
+ if (conflict) throw new Error(conflict);
130
+ },
131
+ },
132
+ );
133
+ if (signal.aborted) return { kind: "rejected" } as const;
134
+ notifySafely(ctx, "Pi BTW shortcut saved; applies when opening or resuming BTW.", "info");
135
+ return { kind: "back" } as const;
136
+ } catch (error) {
137
+ if (!signal.aborted) notifySaveFailure(ctx, error);
138
+ return { kind: "rejected" } as const;
139
+ }
140
+ };
166
141
 
167
- const loadState = async (): Promise<BtwMenuState> => {
168
- const loaded = await readSettings(settingsPath);
169
- if (loaded.kind === "invalid") {
170
- return { kind: "invalid", settings: {}, reason: loaded.reason };
171
- }
172
- return { kind: "valid", settings: loaded.kind === "loaded" ? loaded.settings : {} };
173
- };
174
- const currentMainThinkingLevel = clampToAvailableThinkingLevel(
175
- options.currentThinkingLevel,
176
- levels,
177
- );
178
- const displayThinkingLevel = (settings: BtwSettings): string =>
179
- settings.thinkingLevel === undefined
180
- ? SAME_AS_MAIN_THREAD
181
- : clampToAvailableThinkingLevel(settings.thinkingLevel, levels);
182
- const displayThinkingSummary = (settings: BtwSettings): string =>
183
- settings.thinkingLevel === undefined
184
- ? `${SAME_AS_MAIN_THREAD} (currently ${currentMainThinkingLevel})`
185
- : displayThinkingLevel(settings);
186
- const displayRememberSummary = (settings: BtwSettings): string => {
187
- const value = effectiveRememberThinkingLevelChanges(settings) ? "On" : "Off";
188
- return settings.thinkingLevel === undefined ? `${value} (fixed levels only)` : value;
189
- };
142
+ const loadState = async (): Promise<BtwMenuState> => {
143
+ const loaded = await readSettings(settingsPath);
144
+ if (loaded.kind === "invalid") {
145
+ return { kind: "invalid", settings: {}, reason: loaded.reason };
146
+ }
147
+ return { kind: "valid", settings: loaded.kind === "loaded" ? loaded.settings : {} };
148
+ };
149
+ const currentMainThinkingLevel = clampToAvailableThinkingLevel(options.currentThinkingLevel, levels);
150
+ const displayThinkingLevel = (settings: BtwSettings): string =>
151
+ settings.thinkingLevel === undefined
152
+ ? SAME_AS_MAIN_THREAD
153
+ : clampToAvailableThinkingLevel(settings.thinkingLevel, levels);
154
+ const displayThinkingSummary = (settings: BtwSettings): string =>
155
+ settings.thinkingLevel === undefined
156
+ ? `${SAME_AS_MAIN_THREAD} (currently ${currentMainThinkingLevel})`
157
+ : displayThinkingLevel(settings);
158
+ const displayRememberSummary = (settings: BtwSettings): string => {
159
+ const value = effectiveRememberThinkingLevelChanges(settings) ? "On" : "Off";
160
+ return settings.thinkingLevel === undefined ? `${value} (fixed levels only)` : value;
161
+ };
190
162
 
191
- const menu = defineMenu<BtwMenuState, BtwMenuScreen, BtwMenuAction, MenuContext>({
192
- start: "main",
193
- screens: {
194
- main: ({ state }) => ({
195
- kind: "actions",
196
- title: "Pi BTW",
197
- lines: [
198
- `Thinking: ${displayThinkingSummary(state.settings)} · Remember changes: ${displayRememberSummary(state.settings)}`,
199
- `Copy on select: ${effectiveFullscreenCopyOnSelect(state.settings) ? "On" : "Off"}`,
200
- ],
201
- items: [
202
- {
203
- id: "start",
204
- label: "Start side thread",
205
- description: "Open an empty side thread",
206
- action: "start",
207
- },
208
- {
209
- id: "start-tree",
210
- label: "Start from main thread tree…",
211
- description: "Choose context without switching the main branch",
212
- action: "start-tree",
213
- },
214
- ...(resumeThreads.length > 0
215
- ? [
216
- {
217
- id: "resume" as const,
218
- label: "Resume side thread",
219
- description: "Continue an in-memory side thread",
220
- to: "resume" as const,
221
- },
222
- ]
223
- : []),
224
- {
225
- id: "settings",
226
- label: "Settings",
227
- description: "Choose thinking, keybindings, and selection copying",
228
- to: state.kind === "invalid" ? "invalid" : "settings",
229
- },
230
- ],
231
- hint: "close",
232
- }),
233
- resume: () => ({
234
- kind: "choice",
235
- title: "Resume BTW side thread",
236
- enableSearch: true,
237
- items: resumeThreads.map((thread) => ({
238
- id: thread.id,
239
- label: thread.title,
240
- description: `${thread.questionCount} ${thread.questionCount === 1 ? "question" : "questions"}`,
241
- })),
242
- action: "resume",
243
- viewportSize: 10,
244
- hint: "back",
245
- }),
246
- settings: ({ state }) => ({
247
- kind: "settings",
248
- title: "Pi BTW Settings",
249
- lines: [`User settings · ${displaySettingsPath}`],
250
- items: [
251
- {
252
- id: "thinkingLevel",
253
- label: "Thinking level",
254
- description: `Set the starting level for future pi-btw side threads. Currently ${currentMainThinkingLevel}.`,
255
- currentValue: displayThinkingLevel(state.settings),
256
- values: [SAME_AS_MAIN_THREAD, ...levels],
257
- action: "set-thinking",
258
- },
259
- {
260
- id: "rememberThinkingLevelChanges",
261
- label: "Remember thinking level changes",
262
- description: "Save shortcut changes for fixed thinking levels to pi-btw.json.",
263
- currentValue: effectiveRememberThinkingLevelChanges(state.settings) ? "On" : "Off",
264
- values: ["On", "Off"],
265
- action: "set-remember",
266
- },
267
- {
268
- id: "fullscreenCopyOnSelect",
269
- label: "Copy selection automatically",
270
- description:
271
- "Copy mouse selections immediately instead of with the configured copy key.",
272
- currentValue: effectiveFullscreenCopyOnSelect(state.settings) ? "On" : "Off",
273
- values: ["On", "Off"],
274
- action: "set-fullscreen-copy",
275
- },
276
- ...BTW_SHORTCUT_ACTIONS.map((action) => ({
277
- id: action,
278
- label: shortcutLabels[action],
279
- description:
280
- "Edit a BTW-only key combination or restore its default. Ctrl+C always hard-cancels.",
281
- currentValue: shortcutValue(state.settings, action),
282
- action: "edit-shortcut" as const,
283
- })),
284
- ],
285
- }),
286
- shortcut: ({ state }) => ({
287
- kind: "actions",
288
- title: shortcutLabels[shortcut],
289
- lines: [shortcutValue(state.settings, shortcut), "Ctrl+C always hard-cancels BTW."],
290
- items: [
291
- { id: "edit", label: "Edit key combination…", to: "shortcut-input" },
292
- { id: "reset", label: "Restore default", action: "reset-shortcut" },
293
- ],
294
- hint: "back",
295
- }),
296
- "shortcut-input": () => ({
297
- kind: "input",
298
- title: shortcutLabels[shortcut],
299
- lines: ["Type a key name, not the shortcut itself. For example: ctrl+q or f6."],
300
- placeholder: "Key combination",
301
- action: "save-shortcut",
302
- hint: "back",
303
- }),
304
- invalid: ({ state }) => ({
305
- kind: "detail",
306
- title: "Pi BTW Settings · Read only",
307
- lines: [
308
- `Invalid settings file. Fix ${displaySettingsPath} before saving.`,
309
- sanitizeSingleLine(state.reason ?? "The settings file is invalid."),
310
- ],
311
- hint: "back",
312
- }),
313
- },
314
- actions: {
315
- "edit-shortcut": ({ itemId }) => {
316
- if (!BTW_SHORTCUT_ACTIONS.includes(itemId as BtwShortcutAction))
317
- return { kind: "rejected" };
318
- shortcut = itemId as BtwShortcutAction;
319
- return { kind: "to", screen: "shortcut" };
320
- },
321
- "save-shortcut": ({ state, value, signal }) =>
322
- saveShortcut(state, value?.trim() ?? "", signal),
323
- "reset-shortcut": ({ state, signal }) => saveShortcut(state, undefined, signal),
324
- start: async () => {
325
- startSelected = true;
326
- return { kind: "close" };
327
- },
328
- "start-tree": async () => {
329
- treeSelected = true;
330
- return { kind: "close" };
331
- },
332
- resume: async ({ itemId }: { itemId: string }) => {
333
- if (!resumeThreads.some((thread) => thread.id === itemId)) {
334
- return { kind: "rejected" } as const;
335
- }
336
- resumedThreadId = itemId;
337
- return { kind: "close" } as const;
338
- },
339
- "set-thinking": async ({ value, signal }) => {
340
- if (!value) return { kind: "rejected" };
341
- const patch =
342
- value === SAME_AS_MAIN_THREAD
343
- ? ({ thinkingLevel: undefined } satisfies BtwSettingsPatch)
344
- : levels.includes(value as BtwThinkingLevel)
345
- ? ({ thinkingLevel: value as BtwThinkingLevel } satisfies BtwSettingsPatch)
346
- : undefined;
347
- if (!patch) return { kind: "rejected" };
348
- try {
349
- await updateSettings(patch, { settingsPath, signal });
350
- if (signal.aborted) return { kind: "rejected" };
351
- notifySafely(ctx, `Pi BTW thinking level: ${value}.`, "info");
352
- return { kind: "stay" };
353
- } catch (error) {
354
- if (!signal.aborted) notifySaveFailure(ctx, error);
355
- return { kind: "rejected" };
356
- }
357
- },
358
- "set-remember": async ({ value, signal }) => {
359
- if (value !== "On" && value !== "Off") return { kind: "rejected" };
360
- try {
361
- await updateSettings(
362
- { rememberThinkingLevelChanges: value === "On" },
363
- { settingsPath, signal },
364
- );
365
- if (signal.aborted) return { kind: "rejected" };
366
- notifySafely(ctx, `Remember thinking level changes: ${value}.`, "info");
367
- return { kind: "stay" };
368
- } catch (error) {
369
- if (!signal.aborted) notifySaveFailure(ctx, error);
370
- return { kind: "rejected" };
371
- }
372
- },
373
- "set-fullscreen-copy": async ({ value, signal }) => {
374
- if (value !== "On" && value !== "Off") return { kind: "rejected" };
375
- try {
376
- await updateSettings(
377
- { fullscreenCopyOnSelect: value === "On" },
378
- { settingsPath, signal },
379
- );
380
- if (signal.aborted) return { kind: "rejected" };
381
- notifySafely(ctx, `Copy selection automatically: ${value}.`, "info");
382
- return { kind: "stay" };
383
- } catch (error) {
384
- if (!signal.aborted) notifySaveFailure(ctx, error);
385
- return { kind: "rejected" };
386
- }
387
- },
388
- },
389
- });
163
+ const menu = defineMenu<BtwMenuState, BtwMenuScreen, BtwMenuAction, MenuContext>({
164
+ start: "main",
165
+ screens: {
166
+ main: ({ state }) => ({
167
+ kind: "actions",
168
+ title: "Pi BTW",
169
+ lines: [
170
+ `Thinking: ${displayThinkingSummary(state.settings)} · Remember changes: ${displayRememberSummary(state.settings)}`,
171
+ `Copy on select: ${effectiveFullscreenCopyOnSelect(state.settings) ? "On" : "Off"}`,
172
+ ],
173
+ items: [
174
+ {
175
+ id: "start",
176
+ label: "Start side thread",
177
+ description: "Open an empty side thread",
178
+ action: "start",
179
+ },
180
+ {
181
+ id: "start-tree",
182
+ label: "Start from main thread tree…",
183
+ description: "Choose context without switching the main branch",
184
+ action: "start-tree",
185
+ },
186
+ ...(resumeThreads.length > 0
187
+ ? [
188
+ {
189
+ id: "resume" as const,
190
+ label: "Resume side thread",
191
+ description: "Continue an in-memory side thread",
192
+ to: "resume" as const,
193
+ },
194
+ ]
195
+ : []),
196
+ {
197
+ id: "settings",
198
+ label: "Settings",
199
+ description: "Choose thinking, keybindings, and selection copying",
200
+ to: state.kind === "invalid" ? "invalid" : "settings",
201
+ },
202
+ ],
203
+ hint: "close",
204
+ }),
205
+ resume: () => ({
206
+ kind: "choice",
207
+ title: "Resume BTW side thread",
208
+ enableSearch: true,
209
+ items: resumeThreads.map((thread) => ({
210
+ id: thread.id,
211
+ label: thread.title,
212
+ description: `${thread.questionCount} ${thread.questionCount === 1 ? "question" : "questions"}`,
213
+ })),
214
+ action: "resume",
215
+ viewportSize: 10,
216
+ hint: "back",
217
+ }),
218
+ settings: ({ state }) => ({
219
+ kind: "settings",
220
+ title: "Pi BTW Settings",
221
+ lines: [`User settings · ${displaySettingsPath}`],
222
+ items: [
223
+ {
224
+ id: "thinkingLevel",
225
+ label: "Thinking level",
226
+ description: `Set the starting level for future pi-btw side threads. Currently ${currentMainThinkingLevel}.`,
227
+ currentValue: displayThinkingLevel(state.settings),
228
+ values: [SAME_AS_MAIN_THREAD, ...levels],
229
+ action: "set-thinking",
230
+ },
231
+ {
232
+ id: "rememberThinkingLevelChanges",
233
+ label: "Remember thinking level changes",
234
+ description: "Save shortcut changes for fixed thinking levels to pi-btw.json.",
235
+ currentValue: effectiveRememberThinkingLevelChanges(state.settings) ? "On" : "Off",
236
+ values: ["On", "Off"],
237
+ action: "set-remember",
238
+ },
239
+ {
240
+ id: "fullscreenCopyOnSelect",
241
+ label: "Copy selection automatically",
242
+ description: "Copy mouse selections immediately instead of with the configured copy key.",
243
+ currentValue: effectiveFullscreenCopyOnSelect(state.settings) ? "On" : "Off",
244
+ values: ["On", "Off"],
245
+ action: "set-fullscreen-copy",
246
+ },
247
+ ...BTW_SHORTCUT_ACTIONS.map((action) => ({
248
+ id: action,
249
+ label: shortcutLabels[action],
250
+ description: "Edit a BTW-only key combination or restore its default. Ctrl+C always hard-cancels.",
251
+ currentValue: shortcutValue(state.settings, action),
252
+ action: "edit-shortcut" as const,
253
+ })),
254
+ ],
255
+ }),
256
+ shortcut: ({ state }) => ({
257
+ kind: "actions",
258
+ title: shortcutLabels[shortcut],
259
+ lines: [shortcutValue(state.settings, shortcut), "Ctrl+C always hard-cancels BTW."],
260
+ items: [
261
+ { id: "edit", label: "Edit key combination…", to: "shortcut-input" },
262
+ { id: "reset", label: "Restore default", action: "reset-shortcut" },
263
+ ],
264
+ hint: "back",
265
+ }),
266
+ "shortcut-input": () => ({
267
+ kind: "input",
268
+ title: shortcutLabels[shortcut],
269
+ lines: ["Type a key name, not the shortcut itself. For example: ctrl+q or f6."],
270
+ placeholder: "Key combination",
271
+ action: "save-shortcut",
272
+ hint: "back",
273
+ }),
274
+ invalid: ({ state }) => ({
275
+ kind: "detail",
276
+ title: "Pi BTW Settings · Read only",
277
+ lines: [
278
+ `Invalid settings file. Fix ${displaySettingsPath} before saving.`,
279
+ sanitizeSingleLine(state.reason ?? "The settings file is invalid."),
280
+ ],
281
+ hint: "back",
282
+ }),
283
+ },
284
+ actions: {
285
+ "edit-shortcut": ({ itemId }) => {
286
+ if (!BTW_SHORTCUT_ACTIONS.includes(itemId as BtwShortcutAction)) return { kind: "rejected" };
287
+ shortcut = itemId as BtwShortcutAction;
288
+ return { kind: "to", screen: "shortcut" };
289
+ },
290
+ "save-shortcut": ({ state, value, signal }) => saveShortcut(state, value?.trim() ?? "", signal),
291
+ "reset-shortcut": ({ state, signal }) => saveShortcut(state, undefined, signal),
292
+ start: async () => {
293
+ startSelected = true;
294
+ return { kind: "close" };
295
+ },
296
+ "start-tree": async () => {
297
+ treeSelected = true;
298
+ return { kind: "close" };
299
+ },
300
+ resume: async ({ itemId }: { itemId: string }) => {
301
+ if (!resumeThreads.some((thread) => thread.id === itemId)) {
302
+ return { kind: "rejected" } as const;
303
+ }
304
+ resumedThreadId = itemId;
305
+ return { kind: "close" } as const;
306
+ },
307
+ "set-thinking": async ({ value, signal }) => {
308
+ if (!value) return { kind: "rejected" };
309
+ const patch =
310
+ value === SAME_AS_MAIN_THREAD
311
+ ? ({ thinkingLevel: undefined } satisfies BtwSettingsPatch)
312
+ : levels.includes(value as BtwThinkingLevel)
313
+ ? ({ thinkingLevel: value as BtwThinkingLevel } satisfies BtwSettingsPatch)
314
+ : undefined;
315
+ if (!patch) return { kind: "rejected" };
316
+ try {
317
+ await updateSettings(patch, { settingsPath, signal });
318
+ if (signal.aborted) return { kind: "rejected" };
319
+ notifySafely(ctx, `Pi BTW thinking level: ${value}.`, "info");
320
+ return { kind: "stay" };
321
+ } catch (error) {
322
+ if (!signal.aborted) notifySaveFailure(ctx, error);
323
+ return { kind: "rejected" };
324
+ }
325
+ },
326
+ "set-remember": async ({ value, signal }) => {
327
+ if (value !== "On" && value !== "Off") return { kind: "rejected" };
328
+ try {
329
+ await updateSettings({ rememberThinkingLevelChanges: value === "On" }, { settingsPath, signal });
330
+ if (signal.aborted) return { kind: "rejected" };
331
+ notifySafely(ctx, `Remember thinking level changes: ${value}.`, "info");
332
+ return { kind: "stay" };
333
+ } catch (error) {
334
+ if (!signal.aborted) notifySaveFailure(ctx, error);
335
+ return { kind: "rejected" };
336
+ }
337
+ },
338
+ "set-fullscreen-copy": async ({ value, signal }) => {
339
+ if (value !== "On" && value !== "Off") return { kind: "rejected" };
340
+ try {
341
+ await updateSettings({ fullscreenCopyOnSelect: value === "On" }, { settingsPath, signal });
342
+ if (signal.aborted) return { kind: "rejected" };
343
+ notifySafely(ctx, `Copy selection automatically: ${value}.`, "info");
344
+ return { kind: "stay" };
345
+ } catch (error) {
346
+ if (!signal.aborted) notifySaveFailure(ctx, error);
347
+ return { kind: "rejected" };
348
+ }
349
+ },
350
+ },
351
+ });
390
352
 
391
- const result = await runBtwMenuPreservingEditor(
392
- ctx,
393
- (menuContext) => runMenu(menuContext, menu, { getState: loadState }),
394
- (manager) => {
395
- keybindings = manager;
396
- },
397
- );
398
- if (result.kind !== "closed" || result.reason !== "close") return "closed";
399
- if (resumedThreadId) return { kind: "resume", threadId: resumedThreadId };
400
- if (treeSelected) return "tree";
401
- return startSelected ? "start" : "closed";
353
+ const result = await runBtwMenuPreservingEditor(
354
+ ctx,
355
+ (menuContext) => runMenu(menuContext, menu, { getState: loadState }),
356
+ (manager) => {
357
+ keybindings = manager;
358
+ },
359
+ );
360
+ if (result.kind !== "closed" || result.reason !== "close") return "closed";
361
+ if (resumedThreadId) return { kind: "resume", threadId: resumedThreadId };
362
+ if (treeSelected) return "tree";
363
+ return startSelected ? "start" : "closed";
402
364
  }
403
365
 
404
366
  export async function showBtwCustomPreservingEditor<T>(
405
- ctx: ExtensionCommandContext,
406
- factory: BtwCustomFactory<T>,
367
+ ctx: ExtensionCommandContext,
368
+ factory: BtwCustomFactory<T>,
407
369
  ): Promise<T | undefined> {
408
- let liveEditorText = ctx.ui.getEditorText();
409
- let completed = false;
410
- const result = await ctx.ui.custom<T>((tui, theme, keybindings, done) =>
411
- factory(tui, theme, keybindings, (value) => {
412
- try {
413
- liveEditorText = ctx.ui.getEditorText();
414
- } catch {
415
- // Keep completion finite if session replacement invalidates the editor context.
416
- }
417
- completed = true;
418
- done(value);
419
- }),
420
- );
421
- if (completed) {
422
- try {
423
- if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
424
- } catch {
425
- // A replaced context owns a different editor and must not receive stale restoration.
426
- }
427
- }
428
- return result;
370
+ let liveEditorText = ctx.ui.getEditorText();
371
+ let completed = false;
372
+ const result = await ctx.ui.custom<T>((tui, theme, keybindings, done) =>
373
+ factory(tui, theme, keybindings, (value) => {
374
+ try {
375
+ liveEditorText = ctx.ui.getEditorText();
376
+ } catch {
377
+ // Keep completion finite if session replacement invalidates the editor context.
378
+ }
379
+ completed = true;
380
+ done(value);
381
+ }),
382
+ );
383
+ if (completed) {
384
+ try {
385
+ if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
386
+ } catch {
387
+ // A replaced context owns a different editor and must not receive stale restoration.
388
+ }
389
+ }
390
+ return result;
429
391
  }
430
392
 
431
393
  export async function runBtwMenuPreservingEditor(
432
- ctx: ExtensionCommandContext,
433
- run: (menuContext: MenuContext) => Promise<RunMenuResult>,
434
- onKeybindings?: (keybindings: KeybindingsManager) => void,
394
+ ctx: ExtensionCommandContext,
395
+ run: (menuContext: MenuContext) => Promise<RunMenuResult>,
396
+ onKeybindings?: (keybindings: KeybindingsManager) => void,
435
397
  ): Promise<RunMenuResult> {
436
- let liveEditorText = ctx.ui.getEditorText();
437
- let completed = false;
438
- const ui = new Proxy(ctx.ui, {
439
- get(target, property) {
440
- if (property === "custom") {
441
- return <Value>(factory: BtwCustomFactory<Value>, customOptions?: BtwCustomOptions) =>
442
- target.custom<Value>((tui, theme, keybindings, done) => {
443
- onKeybindings?.(keybindings);
444
- return factory(tui, theme, keybindings, (value) => {
445
- try {
446
- liveEditorText = target.getEditorText();
447
- } catch {
448
- // Keep completion finite if session replacement invalidates the editor context.
449
- }
450
- completed = true;
451
- done(value);
452
- });
453
- }, customOptions);
454
- }
455
- const value = Reflect.get(target, property, target) as unknown;
456
- return typeof value === "function" ? value.bind(target) : value;
457
- },
458
- });
459
- const result = await run({ mode: ctx.mode, hasUI: ctx.hasUI, ui });
460
- if (result.kind !== "stale" && completed) {
461
- try {
462
- if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
463
- } catch {
464
- // A replaced context owns a different editor and must not receive stale restoration.
465
- }
466
- }
467
- return result;
398
+ let liveEditorText = ctx.ui.getEditorText();
399
+ let completed = false;
400
+ const ui = new Proxy(ctx.ui, {
401
+ get(target, property) {
402
+ if (property === "custom") {
403
+ return <Value>(factory: BtwCustomFactory<Value>, customOptions?: BtwCustomOptions) =>
404
+ target.custom<Value>((tui, theme, keybindings, done) => {
405
+ onKeybindings?.(keybindings);
406
+ return factory(tui, theme, keybindings, (value) => {
407
+ try {
408
+ liveEditorText = target.getEditorText();
409
+ } catch {
410
+ // Keep completion finite if session replacement invalidates the editor context.
411
+ }
412
+ completed = true;
413
+ done(value);
414
+ });
415
+ }, customOptions);
416
+ }
417
+ const value = Reflect.get(target, property, target) as unknown;
418
+ return typeof value === "function" ? value.bind(target) : value;
419
+ },
420
+ });
421
+ const result = await run({ mode: ctx.mode, hasUI: ctx.hasUI, ui });
422
+ if (result.kind !== "stale" && completed) {
423
+ try {
424
+ if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
425
+ } catch {
426
+ // A replaced context owns a different editor and must not receive stale restoration.
427
+ }
428
+ }
429
+ return result;
468
430
  }
469
431
 
470
432
  function clampToAvailableThinkingLevel(
471
- requested: BtwThinkingLevel,
472
- available: readonly BtwThinkingLevel[],
433
+ requested: BtwThinkingLevel,
434
+ available: readonly BtwThinkingLevel[],
473
435
  ): BtwThinkingLevel {
474
- if (available.includes(requested)) return requested;
475
- const requestedIndex = BTW_THINKING_LEVELS.indexOf(requested);
476
- for (let index = requestedIndex; index < BTW_THINKING_LEVELS.length; index += 1) {
477
- const candidate = BTW_THINKING_LEVELS[index];
478
- if (candidate && available.includes(candidate)) return candidate;
479
- }
480
- for (let index = requestedIndex - 1; index >= 0; index -= 1) {
481
- const candidate = BTW_THINKING_LEVELS[index];
482
- if (candidate && available.includes(candidate)) return candidate;
483
- }
484
- return available[0] ?? "off";
436
+ if (available.includes(requested)) return requested;
437
+ const requestedIndex = BTW_THINKING_LEVELS.indexOf(requested);
438
+ for (let index = requestedIndex; index < BTW_THINKING_LEVELS.length; index += 1) {
439
+ const candidate = BTW_THINKING_LEVELS[index];
440
+ if (candidate && available.includes(candidate)) return candidate;
441
+ }
442
+ for (let index = requestedIndex - 1; index >= 0; index -= 1) {
443
+ const candidate = BTW_THINKING_LEVELS[index];
444
+ if (candidate && available.includes(candidate)) return candidate;
445
+ }
446
+ return available[0] ?? "off";
485
447
  }
486
448
 
487
449
  function notifySaveFailure(ctx: ExtensionCommandContext, error: unknown): void {
488
- notifySafely(
489
- ctx,
490
- `Pi BTW settings were not saved; the previous value remains active: ${formatError(error)}`,
491
- "error",
492
- );
450
+ notifySafely(
451
+ ctx,
452
+ `Pi BTW settings were not saved; the previous value remains active: ${formatError(error)}`,
453
+ "error",
454
+ );
493
455
  }
494
456
 
495
457
  function notifySafely(
496
- ctx: ExtensionCommandContext,
497
- message: string,
498
- level: Parameters<ExtensionCommandContext["ui"]["notify"]>[1],
458
+ ctx: ExtensionCommandContext,
459
+ message: string,
460
+ level: Parameters<ExtensionCommandContext["ui"]["notify"]>[1],
499
461
  ): void {
500
- try {
501
- ctx.ui.notify(sanitizeSingleLine(message), level);
502
- } catch {
503
- // A completed save remains valid if its command context was replaced before notification.
504
- }
462
+ try {
463
+ ctx.ui.notify(sanitizeSingleLine(message), level);
464
+ } catch {
465
+ // A completed save remains valid if its command context was replaced before notification.
466
+ }
505
467
  }
506
468
 
507
469
  function formatError(error: unknown): string {
508
- return error instanceof Error ? error.message : String(error);
470
+ return error instanceof Error ? error.message : String(error);
509
471
  }