@bike4mind/cli 0.2.64-worktree-refactor-extract-search-query-builders.21815 → 0.2.64

package/dist/pathValidation-Cgjh5WQO-DiCZTcq6.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { realpathSync } from "fs";
+import path from "path";
+//#region ../../b4m-core/packages/services/dist/pathValidation-Cgjh5WQO.mjs
+/**
+* Resolves a path to its canonical form, following symlinks.
+* If the path doesn't exist (e.g., file being created), resolves the
+* nearest existing ancestor and appends the remaining segments.
+*/
+function resolveRealPath(filePath) {
+	try {
+		return realpathSync(filePath);
+	} catch {
+		const parentDir = path.dirname(filePath);
+		const basename = path.basename(filePath);
+		if (parentDir === filePath) return filePath;
+		return path.join(resolveRealPath(parentDir), basename);
+	}
+}
+/**
+* Validates if a path is within any of the allowed directories.
+* Always includes process.cwd() as an allowed directory.
+* Resolves symlinks to prevent symlink-based directory escapes.
+*
+* @param filePath - The path to validate (can be relative or absolute)
+* @param allowedDirectories - Optional list of additional allowed directories
+* @returns Object with validation result, resolved path, and matched directory if allowed
+*/
+function isPathAllowed(filePath, allowedDirectories) {
+	const cwd = resolveRealPath(process.cwd());
+	const allAllowed = [cwd, ...(allowedDirectories || []).map((d) => resolveRealPath(d))];
+	const normalizedPath = path.normalize(filePath);
+	const resolvedPath = resolveRealPath(path.isAbsolute(normalizedPath) ? normalizedPath : path.resolve(cwd, normalizedPath));
+	for (const dir of allAllowed) if (resolvedPath === dir || resolvedPath.startsWith(dir + path.sep)) return {
+		allowed: true,
+		resolvedPath,
+		matchedDirectory: dir
+	};
+	return {
+		allowed: false,
+		resolvedPath
+	};
+}
+/**
+* Throws an error if the path is not within allowed directories.
+*
+* @param filePath - The path to validate
+* @param allowedDirectories - Optional list of additional allowed directories
+* @param operation - Description of the operation (for error message), e.g., 'read', 'write', 'delete'
+* @returns The resolved absolute path if allowed
+* @throws Error if path is not within allowed directories
+*/
+function assertPathAllowed(filePath, allowedDirectories, operation = "access") {
+	const result = isPathAllowed(filePath, allowedDirectories);
+	if (!result.allowed) {
+		const cwd = process.cwd();
+		const dirsMsg = allowedDirectories && allowedDirectories.length > 0 ? `Allowed directories: ${[cwd, ...allowedDirectories].join(", ")}` : `Working directory: ${cwd}`;
+		throw new Error(`Access denied: Cannot ${operation} files outside allowed directories. ${dirsMsg}`);
+	}
+	return result.resolvedPath;
+}
+//#endregion
+export { isPathAllowed as n, assertPathAllowed as t };

package/dist/store-Dw1nZX2Y.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import { create } from "zustand";
+//#region src/store/index.ts
+/** Active job statuses (jobs still in progress) */
+const ACTIVE_STATUSES = new Set(["running", "queued"]);
+/** Check if a job status is active (running or queued) */
+function isActiveStatus(status) {
+	return ACTIVE_STATUSES.has(status);
+}
+const useCliStore = create((set) => ({
+	session: null,
+	setSession: (session) => set({ session }),
+	addMessage: (message) => set((state) => {
+		if (!state.session) return state;
+		return { session: {
+			...state.session,
+			messages: [...state.session.messages, message],
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		} };
+	}),
+	pendingMessages: [],
+	addPendingMessage: (message) => set((state) => ({ pendingMessages: [...state.pendingMessages, message] })),
+	updatePendingMessage: (index, message) => set((state) => {
+		const updated = [...state.pendingMessages];
+		updated[index] = message;
+		return { pendingMessages: updated };
+	}),
+	clearPendingMessages: () => set({ pendingMessages: [] }),
+	completePendingMessage: (index, finalMessage) => set((state) => {
+		const pending = [...state.pendingMessages];
+		pending.splice(index, 1);
+		const session = state.session;
+		if (!session) return { pendingMessages: pending };
+		return {
+			pendingMessages: pending,
+			session: {
+				...session,
+				messages: [...session.messages, finalMessage],
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+	}),
+	isThinking: false,
+	setIsThinking: (thinking) => set({ isThinking: thinking }),
+	inputValue: "",
+	setInputValue: (value) => set({ inputValue: value }),
+	clearInput: () => set({
+		inputValue: "",
+		pastedContent: null,
+		pastedLineCount: 0
+	}),
+	pastedContent: null,
+	pastedLineCount: 0,
+	setPastedContent: (content, lineCount) => set({
+		pastedContent: content,
+		pastedLineCount: lineCount,
+		inputValue: content
+	}),
+	clearPaste: () => set({
+		pastedContent: null,
+		pastedLineCount: 0,
+		inputValue: ""
+	}),
+	permissionPrompt: null,
+	permissionQueue: [],
+	enqueuePermissionPrompt: (prompt) => set((state) => {
+		if (!state.permissionPrompt) return { permissionPrompt: prompt };
+		return { permissionQueue: [...state.permissionQueue, prompt] };
+	}),
+	dequeuePermissionPrompt: () => set((state) => {
+		const [next, ...rest] = state.permissionQueue;
+		return {
+			permissionPrompt: next ?? null,
+			permissionQueue: rest
+		};
+	}),
+	userQuestionPrompt: null,
+	userQuestionQueue: [],
+	enqueueUserQuestionPrompt: (prompt) => set((state) => {
+		if (!state.userQuestionPrompt) return { userQuestionPrompt: prompt };
+		return { userQuestionQueue: [...state.userQuestionQueue, prompt] };
+	}),
+	dequeueUserQuestionPrompt: () => set((state) => {
+		const [next, ...rest] = state.userQuestionQueue;
+		return {
+			userQuestionPrompt: next ?? null,
+			userQuestionQueue: rest
+		};
+	}),
+	showConfigEditor: false,
+	setShowConfigEditor: (show) => set({ showConfigEditor: show }),
+	showMcpViewer: false,
+	setShowMcpViewer: (show) => set({ showMcpViewer: show }),
+	autoAcceptEdits: false,
+	toggleAutoAcceptEdits: () => set((state) => ({ autoAcceptEdits: !state.autoAcceptEdits })),
+	exitRequested: false,
+	setExitRequested: (requested) => set({ exitRequested: requested }),
+	backgroundAgents: [],
+	upsertBackgroundAgent: (job) => set((state) => {
+		const existing = state.backgroundAgents.findIndex((j) => j.id === job.id);
+		if (existing >= 0) {
+			const updated = [...state.backgroundAgents];
+			updated[existing] = job;
+			return { backgroundAgents: updated };
+		}
+		return { backgroundAgents: [...state.backgroundAgents, job] };
+	}),
+	cleanupCompletedBackgroundAgents: () => set((state) => ({ backgroundAgents: state.backgroundAgents.filter((j) => isActiveStatus(j.status)) })),
+	completedGroupNotifications: [],
+	addCompletedGroupNotification: (notification, groupDescription) => set((state) => ({ completedGroupNotifications: [...state.completedGroupNotifications, {
+		notification,
+		groupDescription,
+		timestamp: Date.now()
+	}] })),
+	clearCompletedGroupNotifications: () => set({ completedGroupNotifications: [] }),
+	pendingBackgroundTrigger: false,
+	setPendingBackgroundTrigger: (pending) => set({ pendingBackgroundTrigger: pending }),
+	tavernActivityLog: [],
+	addTavernLogEntry: (entry) => set((state) => {
+		const log = [...state.tavernActivityLog, entry];
+		return { tavernActivityLog: log.length > 200 ? log.slice(-200) : log };
+	}),
+	clearTavernActivityLog: () => set({ tavernActivityLog: [] })
+}));
+/** Select only active (running or queued) background agents */
+const selectActiveBackgroundAgents = (state) => state.backgroundAgents.filter((j) => isActiveStatus(j.status));
+//#endregion
+export { useCliStore as n, selectActiveBackgroundAgents as t };

package/dist/store-nZExNOWX.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { n as useCliStore } from "./store-Dw1nZX2Y.mjs";
+export { useCliStore };

package/dist/terminalSetup-rmr1P8KF.mjs

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+import { existsSync, promises } from "fs";
+import { homedir } from "os";
+import path from "path";
+//#region src/utils/terminalSetup.ts
+/**
+* Terminal setup utility for configuring Shift+Enter keybindings.
+*
+* Most terminal emulators send the same byte (\r) for both Enter and Shift+Enter,
+* making them indistinguishable. This utility detects the user's terminal and provides
+* instructions or automatic configuration to make Shift+Enter emit a distinct sequence.
+*
+* Terminals with native Shift+Enter support (no setup needed):
+*   - iTerm2, WezTerm, Ghostty, Kitty
+*
+* Terminals that need configuration:
+*   - VS Code integrated terminal
+*   - Alacritty
+*   - Zed
+*   - macOS Terminal.app
+*/
+const TERMINAL_INFO = {
+	iterm2: {
+		name: "iTerm2",
+		status: "native"
+	},
+	wezterm: {
+		name: "WezTerm",
+		status: "native"
+	},
+	ghostty: {
+		name: "Ghostty",
+		status: "native"
+	},
+	kitty: {
+		name: "Kitty",
+		status: "native"
+	},
+	vscode: {
+		name: "VS Code",
+		status: "configurable"
+	},
+	alacritty: {
+		name: "Alacritty",
+		status: "configurable"
+	},
+	zed: {
+		name: "Zed",
+		status: "manual"
+	},
+	terminal_app: {
+		name: "Terminal.app",
+		status: "manual"
+	},
+	warp: {
+		name: "Warp",
+		status: "manual"
+	},
+	unknown: {
+		name: "Unknown",
+		status: "unknown"
+	}
+};
+/**
+* Detect the current terminal emulator from environment variables.
+*/
+function detectTerminal() {
+	const termProgram = process.env["TERM_PROGRAM"] ?? "";
+	const term = process.env["TERM"] ?? "";
+	if (termProgram === "vscode" || process.env["VSCODE_PID"]) return {
+		id: "vscode",
+		...TERMINAL_INFO.vscode
+	};
+	if (termProgram === "iTerm.app" || process.env["ITERM_SESSION_ID"]) return {
+		id: "iterm2",
+		...TERMINAL_INFO.iterm2
+	};
+	if (termProgram === "WezTerm" || process.env["WEZTERM_PANE"]) return {
+		id: "wezterm",
+		...TERMINAL_INFO.wezterm
+	};
+	if (termProgram === "ghostty" || term === "xterm-ghostty") return {
+		id: "ghostty",
+		...TERMINAL_INFO.ghostty
+	};
+	if (term === "xterm-kitty" || process.env["KITTY_PID"]) return {
+		id: "kitty",
+		...TERMINAL_INFO.kitty
+	};
+	if (termProgram === "Alacritty" || term === "alacritty") return {
+		id: "alacritty",
+		...TERMINAL_INFO.alacritty
+	};
+	if (termProgram === "WarpTerminal" || process.env["WARP_IS_LOCAL_SHELL_SESSION"]) return {
+		id: "warp",
+		...TERMINAL_INFO.warp
+	};
+	if (termProgram === "zed") return {
+		id: "zed",
+		...TERMINAL_INFO.zed
+	};
+	if (termProgram === "Apple_Terminal") return {
+		id: "terminal_app",
+		...TERMINAL_INFO.terminal_app
+	};
+	return {
+		id: "unknown",
+		...TERMINAL_INFO.unknown
+	};
+}
+/**
+* VS Code keybindings.json entry for Shift+Enter → \x1b[13;2u (Kitty protocol)
+*/
+const VSCODE_KEYBINDING = {
+	key: "shift+enter",
+	command: "workbench.action.terminal.sendSequence",
+	args: { text: "\x1B[13;2u" },
+	when: "terminalFocus"
+};
+/**
+* Configure VS Code to send a Kitty-protocol escape sequence for Shift+Enter.
+*/
+async function setupVSCode() {
+	const vscodeDir = [
+		path.join(homedir(), "Library", "Application Support", "Code", "User"),
+		path.join(homedir(), ".config", "Code", "User"),
+		path.join(homedir(), "AppData", "Roaming", "Code", "User")
+	].find((dir) => existsSync(dir));
+	if (!vscodeDir) return {
+		success: false,
+		message: "Could not find VS Code settings directory.\nManually add this to your keybindings.json (Cmd+K Cmd+S → Open Keyboard Shortcuts JSON):\n\n" + JSON.stringify(VSCODE_KEYBINDING, null, 2)
+	};
+	const keybindingsPath = path.join(vscodeDir, "keybindings.json");
+	let keybindings = [];
+	if (existsSync(keybindingsPath)) {
+		const stripped = (await promises.readFile(keybindingsPath, "utf-8")).replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+		try {
+			keybindings = JSON.parse(stripped);
+		} catch {
+			return {
+				success: false,
+				message: "Could not parse keybindings.json. Manually add this entry:\n\n" + JSON.stringify(VSCODE_KEYBINDING, null, 2)
+			};
+		}
+	}
+	if (keybindings.some((binding) => binding["key"] === "shift+enter" && binding["command"] === "workbench.action.terminal.sendSequence" && binding["when"] === "terminalFocus")) return {
+		success: true,
+		message: "VS Code is already configured for Shift+Enter newlines."
+	};
+	keybindings.push(VSCODE_KEYBINDING);
+	await promises.writeFile(keybindingsPath, JSON.stringify(keybindings, null, 2) + "\n", "utf-8");
+	return {
+		success: true,
+		message: `Updated ${keybindingsPath}\nShift+Enter will now insert a newline in the B4M CLI.
+Restart your VS Code terminal for the change to take effect.`
+	};
+}
+/**
+* Alacritty config entry for Shift+Enter → Kitty protocol sequence.
+*/
+const ALACRITTY_TOML_SNIPPET = `
+# B4M CLI: Shift+Enter sends Kitty-protocol sequence for newline
+[[keyboard.bindings]]
+key = "Return"
+mods = "Shift"
+chars = "\\u001b[13;2u"
+`.trim();
+/**
+* Configure Alacritty to send a distinct escape sequence for Shift+Enter.
+*/
+async function setupAlacritty() {
+	const configPaths = [path.join(homedir(), ".config", "alacritty", "alacritty.toml"), path.join(homedir(), ".alacritty.toml")];
+	const existingConfig = configPaths.find((p) => existsSync(p));
+	const configPath = existingConfig ?? configPaths[0];
+	let content = "";
+	if (existingConfig) {
+		content = await promises.readFile(configPath, "utf-8");
+		if (content.includes("[13;2u") || content.includes("\\u001b[13;2u")) return {
+			success: true,
+			message: "Alacritty is already configured for Shift+Enter newlines."
+		};
+	}
+	const newContent = content ? content.trimEnd() + "\n\n" + ALACRITTY_TOML_SNIPPET + "\n" : ALACRITTY_TOML_SNIPPET + "\n";
+	const configDir = path.dirname(configPath);
+	if (!existsSync(configDir)) await promises.mkdir(configDir, { recursive: true });
+	await promises.writeFile(configPath, newContent, "utf-8");
+	return {
+		success: true,
+		message: `Updated ${configPath}\nShift+Enter will now insert a newline in the B4M CLI.
+Restart Alacritty for the change to take effect.`
+	};
+}
+/**
+* Get manual instructions for terminals that can't be auto-configured.
+*/
+function getManualInstructions(terminal) {
+	switch (terminal.id) {
+		case "zed": return "Add this to your Zed keymap.json (Zed → Settings → Open Key Bindings):\n\n" + JSON.stringify([{
+			context: "Terminal",
+			bindings: { "shift-enter": ["terminal::SendText", "\\u001b[13;2u"] }
+		}], null, 2);
+		case "terminal_app": return "macOS Terminal.app cannot send distinct Shift+Enter sequences.\n\nAlternatives:\n  • Use Option+Enter (⌥+Enter) to insert newlines\n  • Type \\ then Enter to insert newlines\n  • Switch to iTerm2, WezTerm, or Ghostty for native Shift+Enter support";
+		case "warp": return "Warp terminal has limited keybinding customization.\n\nAlternatives:\n  • Use Option+Enter (⌥+Enter) to insert newlines\n  • Type \\ then Enter to insert newlines";
+		default: return "Your terminal needs to be configured to send a distinct escape sequence for Shift+Enter.\nConfigure Shift+Enter to send: \\x1b[13;2u (Kitty keyboard protocol)\n\nAlternatives that work in all terminals:\n  • Option/Alt+Enter to insert newlines\n  • Type \\ then Enter to insert newlines";
+	}
+}
+/**
+* Run the terminal setup flow.
+*/
+async function runTerminalSetup() {
+	const terminal = detectTerminal();
+	console.log(`\nDetected terminal: ${terminal.name}\n`);
+	switch (terminal.status) {
+		case "native":
+			console.log(`✅ ${terminal.name} natively supports Shift+Enter for newlines.\nNo configuration needed!
+`);
+			break;
+		case "configurable": {
+			console.log(`Configuring ${terminal.name} for Shift+Enter support...\n`);
+			let result;
+			switch (terminal.id) {
+				case "vscode":
+					result = await setupVSCode();
+					break;
+				case "alacritty":
+					result = await setupAlacritty();
+					break;
+				default: result = {
+					success: false,
+					message: "No auto-configuration available."
+				};
+			}
+			console.log(result.success ? `✅ ${result.message}` : `⚠️  ${result.message}`);
+			console.log();
+			break;
+		}
+		case "manual":
+			console.log(`⚠️  ${terminal.name} requires manual configuration.\n`);
+			console.log(getManualInstructions(terminal));
+			console.log();
+			break;
+		case "unknown":
+			console.log(getManualInstructions(terminal));
+			console.log();
+			break;
+	}
+	console.log("Universal newline methods (work in all terminals):");
+	console.log("  • Option/Alt + Enter — insert newline");
+	console.log("  • \\ + Enter          — insert newline (backslash-escape)");
+	console.log("  • Shift + Enter      — insert newline (if terminal supports Kitty protocol)");
+	console.log();
+}
+//#endregion
+export { runTerminalSetup };