@churivibhav/reqex 0.1.0

package/dist/cli.js

@@ -0,0 +1,1936 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/cli.ts
+import path4 from "path";
+import process2 from "process";
+import { createNodeApp } from "@rezi-ui/node";
+
+// src/config/keybindings.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var VSCODE_DEFAULTS = {
+  F5: "request.send",
+  "ctrl+enter": "request.send",
+  "alt+enter": "request.send",
+  tab: "pane.focusNext",
+  "shift+tab": "pane.focusPrev",
+  "ctrl+1": "pane.focusFiles",
+  "ctrl+2": "pane.focusEditor",
+  "ctrl+3": "pane.focusResponse",
+  "alt+1": "pane.focusFiles",
+  "alt+2": "pane.focusEditor",
+  "alt+3": "pane.focusResponse",
+  "ctrl+b": "sidebar.toggle",
+  "ctrl+p": "palette.files",
+  "ctrl+shift+p": "palette.commands",
+  F2: "palette.commands",
+  "ctrl+s": "file.save",
+  "ctrl+e": "env.switcher",
+  F11: "pane.zoom",
+  z: "pane.zoom",
+  F1: "help.show",
+  "?": "help.show",
+  "ctrl+/": "keybindings.show",
+  escape: "overlay.close",
+  "ctrl+q": "app.quit",
+  "ctrl+x": "request.cancel",
+  "ctrl+shift+c": "response.copy",
+  "ctrl+f": "response.search",
+  "ctrl+tab": "response.tab.next",
+  "ctrl+shift+tab": "response.tab.prev"
+};
+var VIM_DEFAULTS = {
+  ...VSCODE_DEFAULTS,
+  "ctrl+w h": "pane.focusFiles",
+  "ctrl+w l": "pane.focusResponse",
+  "ctrl+w k": "pane.focusEditor"
+};
+var COMMAND_LABELS = {
+  "request.send": "Send request",
+  "request.cancel": "Cancel request",
+  "pane.focusNext": "Focus next pane",
+  "pane.focusPrev": "Focus previous pane",
+  "pane.focusFiles": "Focus files pane",
+  "pane.focusEditor": "Focus editor pane",
+  "pane.focusResponse": "Focus response pane",
+  "sidebar.toggle": "Toggle sidebar",
+  "file.save": "Save file",
+  "env.switcher": "Environment switcher",
+  "env.selectNext": "Next environment",
+  "env.selectPrev": "Previous environment",
+  "env.apply": "Apply environment",
+  "overlay.close": "Close overlay",
+  "app.quit": "Quit",
+  "palette.commands": "Command palette",
+  "palette.files": "Open file",
+  "help.show": "Help",
+  "keybindings.show": "Show keybindings",
+  "pane.zoom": "Zoom pane",
+  "response.tab.next": "Next response tab",
+  "response.tab.prev": "Previous response tab",
+  "response.copy": "Copy response",
+  "response.search": "Search response",
+  "editor.searchNext": "Find next in editor"
+};
+var CHORD_PART_LABELS = {
+  ctrl: "Ctrl",
+  shift: "Shift",
+  alt: "Alt",
+  meta: "Meta",
+  escape: "Esc",
+  tab: "Tab",
+  enter: "Enter",
+  space: "Space",
+  backspace: "Backspace",
+  delete: "Delete",
+  up: "Up",
+  down: "Down",
+  left: "Left",
+  right: "Right"
+};
+function formatKeyChord(key) {
+  if (/^F\d+$/u.test(key)) {
+    return key;
+  }
+  if (key.length === 1) {
+    return key === "?" ? "?" : key.toUpperCase();
+  }
+  return key.split("+").map((part) => CHORD_PART_LABELS[part] ?? part.toUpperCase()).join("+");
+}
+function buildKeybindingsViewLines(bindings, maxLines) {
+  const byCommand = /* @__PURE__ */ new Map();
+  for (const [key, command] of Object.entries(bindings)) {
+    const keys = byCommand.get(command) ?? [];
+    keys.push(key);
+    byCommand.set(command, keys);
+  }
+  const rows = [...byCommand.entries()].map(([command, keys]) => {
+    const formattedKeys = keys.sort((a, b) => a.localeCompare(b)).map(formatKeyChord).join(" / ");
+    const label = COMMAND_LABELS[command] ?? command;
+    return { label, row: `${formattedKeys.padEnd(28)}  ${label}` };
+  }).sort((a, b) => a.label.localeCompare(b.label)).map((entry) => entry.row);
+  if (maxLines !== void 0 && rows.length > maxLines) {
+    const hidden = rows.length - maxLines + 1;
+    return [...rows.slice(0, maxLines - 1), `\u2026 ${hidden} more`];
+  }
+  return rows;
+}
+function getConfigDir() {
+  if (process.env.REQEX_CONFIG_DIR) {
+    return process.env.REQEX_CONFIG_DIR;
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "reqex");
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "reqex");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+  return path.join(xdg, "reqex");
+}
+function getProjectConfigDir(workspaceRoot) {
+  return path.join(workspaceRoot, ".reqex");
+}
+function readJsonIfExists(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function loadKeybindings(workspaceRoot) {
+  const userConfig = readJsonIfExists(path.join(getConfigDir(), "keybindings.json"));
+  const projectConfig = readJsonIfExists(
+    path.join(getProjectConfigDir(workspaceRoot), "keybindings.json")
+  );
+  const preset = projectConfig?.preset ?? userConfig?.preset ?? "vscode";
+  const defaults = preset === "vim" ? VIM_DEFAULTS : VSCODE_DEFAULTS;
+  return {
+    preset,
+    bindings: {
+      ...defaults,
+      ...userConfig?.bindings,
+      ...projectConfig?.bindings
+    }
+  };
+}
+function watchKeybindings(workspaceRoot, onChange) {
+  const dirs = [getConfigDir(), getProjectConfigDir(workspaceRoot)];
+  const watchers = dirs.map((dir) => {
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+    return fs.watch(dir, { persistent: false }, () => onChange());
+  });
+  return () => {
+    for (const watcher of watchers) {
+      watcher.close();
+    }
+  };
+}
+var FOOTER_HINTS = {
+  editor: ["F5 Send", "Ctrl+S Save", "Tab Panes", "F2 Palette"],
+  response: ["Tab Panes", "Ctrl+Shift+C Copy", "F5 Send", "F2 Palette"],
+  files: ["Enter Open", "Tab Panes", "Ctrl+P Files", "F2 Palette"],
+  overlay: ["\u2191\u2193 Navigate", "Enter Select", "Esc Close"],
+  sending: ["Ctrl+X Cancel", "Tab Panes", "Ctrl+Q Quit"]
+};
+function footerHints(context) {
+  let hints;
+  if (context.overlay !== "none") {
+    hints = FOOTER_HINTS.overlay;
+  } else if (context.sending) {
+    hints = FOOTER_HINTS.sending;
+  } else {
+    hints = FOOTER_HINTS[context.focusPane] ?? FOOTER_HINTS.editor;
+  }
+  const leftBudget = 48;
+  const maxWidth = Math.max(20, context.viewportWidth - leftBudget);
+  let text = hints.join(" \xB7 ");
+  if (text.length > maxWidth) {
+    text = `${text.slice(0, maxWidth - 1)}\u2026`;
+  }
+  return text;
+}
+var HELP_HINT_LINES = [
+  "F5 Send request under cursor",
+  "Tab / Shift+Tab Cycle panes",
+  "Ctrl+S Save file",
+  "Ctrl+E Environment switcher",
+  "F2 / Ctrl+Shift+P Command palette",
+  "Ctrl+Shift+C Copy response tab",
+  "Ctrl+X Cancel request \xB7 Ctrl+Q Quit",
+  "Ctrl+/ Full keybindings \xB7 F1 Quick help"
+];
+
+// src/engine/io-provider.ts
+import { cli, io } from "httpyac";
+var promptHandler = async () => void 0;
+function setPromptHandler(handler) {
+  promptHandler = handler;
+}
+function initEngineProviders() {
+  cli.initFileProvider();
+  io.userInteractionProvider.isTrusted = () => true;
+  io.userInteractionProvider.showNote = async (message) => {
+    const result = await promptHandler({ kind: "confirm", message });
+    return result === true;
+  };
+  io.userInteractionProvider.showInputPrompt = async (message, defaultValue, masked) => {
+    const result = await promptHandler({
+      kind: "input",
+      message,
+      defaultValue,
+      masked: masked ?? false
+    });
+    return typeof result === "string" ? result : void 0;
+  };
+  io.userInteractionProvider.showListPrompt = async (message, values) => {
+    const result = await promptHandler({ kind: "list", message, values });
+    return typeof result === "string" ? result : void 0;
+  };
+  io.userInteractionProvider.showInformationMessage = async (message) => {
+    await promptHandler({ kind: "confirm", message });
+    return void 0;
+  };
+  io.userInteractionProvider.showWarnMessage = async (message) => {
+    await promptHandler({ kind: "confirm", message });
+    return void 0;
+  };
+  io.userInteractionProvider.showErrorMessage = async (message) => {
+    await promptHandler({ kind: "confirm", message });
+    return void 0;
+  };
+}
+
+// src/engine/region-resolver.ts
+function resolveRegionAtLine(regions, line) {
+  const candidates = regions.filter(
+    (region) => region.hasRequest && !region.isGlobal && region.startLine <= line && line <= region.endLine
+  );
+  if (candidates.length === 0) {
+    return null;
+  }
+  return candidates.reduce((best, current) => {
+    const bestSpan = best.endLine - best.startLine;
+    const currentSpan = current.endLine - current.startLine;
+    if (currentSpan < bestSpan) {
+      return current;
+    }
+    if (currentSpan === bestSpan && current.startLine > best.startLine) {
+      return current;
+    }
+    return best;
+  });
+}
+var HTTP_METHOD_PREFIX = /^\s*(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|CONNECT|TRACE|GRAPHQL)\b/u;
+function markerColumnAfterMethod(line) {
+  const match = HTTP_METHOD_PREFIX.exec(line);
+  return match ? match[0].length : 0;
+}
+function buildRegionDiagnostics(regions, activeRegionId, fileLines) {
+  const markers = [];
+  for (const region of regions) {
+    if (!region.hasRequest || region.isGlobal) {
+      continue;
+    }
+    const isActive = region.id === activeRegionId;
+    const line = fileLines[region.startLine] ?? "";
+    const markerCol = markerColumnAfterMethod(line);
+    markers.push({
+      line: region.startLine,
+      startColumn: markerCol,
+      endColumn: markerCol + 1,
+      severity: isActive ? "hint" : "info",
+      message: `${region.method ?? "REQ"} ${region.name}`
+    });
+  }
+  return markers;
+}
+
+// src/engine/store.ts
+import { store as httpyacStoreModule } from "httpyac";
+var store = new httpyacStoreModule.HttpFileStore();
+var versions = /* @__PURE__ */ new Map();
+function toRegion(region) {
+  return {
+    id: region.id,
+    name: region.symbol.name,
+    method: region.request?.method,
+    url: region.request?.url,
+    startLine: region.symbol.startLine,
+    endLine: region.symbol.endLine,
+    isGlobal: region.isGlobal(),
+    hasRequest: Boolean(region.request)
+  };
+}
+function bumpParseVersion(filePath) {
+  const next = (versions.get(filePath) ?? 0) + 1;
+  versions.set(filePath, next);
+  return next;
+}
+function getParseVersion(filePath) {
+  return versions.get(filePath) ?? 0;
+}
+async function parseFile(filePath, getText, workingDir, version) {
+  const parseVersion = version ?? getParseVersion(filePath);
+  const httpFile = await store.getOrCreate(filePath, getText, parseVersion, {
+    workingDir
+  });
+  const regions = httpFile.httpRegions.map(toRegion);
+  return {
+    path: filePath,
+    regions,
+    version: parseVersion
+  };
+}
+function getHttpFile(filePath) {
+  return store.get(filePath);
+}
+function getHttpRegion(filePath, regionId) {
+  const httpFile = store.get(filePath);
+  return httpFile?.httpRegions.find((region) => region.id === regionId);
+}
+
+// src/engine/send.ts
+import { getEnvironments, getVariables, send } from "httpyac";
+function formatBody(body) {
+  if (body === void 0 || body === null) {
+    return "";
+  }
+  if (typeof body === "string") {
+    return body;
+  }
+  if (Buffer.isBuffer(body)) {
+    return body.toString("utf8");
+  }
+  try {
+    return JSON.stringify(body, null, 2);
+  } catch {
+    return String(body);
+  }
+}
+function prettyBody(response) {
+  if (!response) {
+    return "";
+  }
+  if (response.prettyPrintBody) {
+    return response.prettyPrintBody;
+  }
+  return formatBody(response.body);
+}
+function toHeaders(response) {
+  if (!response?.headers) {
+    return [];
+  }
+  return Object.entries(response.headers).map(([name, value]) => ({
+    name,
+    value: Array.isArray(value) ? value.join(", ") : String(value ?? "")
+  }));
+}
+function toTestResults(region) {
+  if (!region.testResults) {
+    return [];
+  }
+  return region.testResults.map((result) => ({
+    message: result.message,
+    status: result.status,
+    detail: result.error?.displayMessage
+  }));
+}
+async function sendRegion(options) {
+  const httpFile = getHttpFile(options.filePath);
+  const httpRegion = getHttpRegion(options.filePath, options.regionId);
+  if (!httpFile || !httpRegion) {
+    return {
+      headers: [],
+      body: "",
+      prettyBody: "",
+      testResults: [],
+      error: "Request region not found"
+    };
+  }
+  delete httpRegion.response;
+  delete httpRegion.testResults;
+  let capturedResponse;
+  const logResponse = async (response) => {
+    capturedResponse = response;
+  };
+  try {
+    await send({
+      httpFile,
+      httpRegion,
+      activeEnvironment: options.activeEnvironment,
+      variables: options.variables,
+      logResponse
+    });
+    const response = capturedResponse ?? httpRegion.response;
+    return {
+      statusCode: response?.statusCode,
+      statusMessage: response?.statusMessage,
+      protocol: response?.protocol,
+      headers: toHeaders(response),
+      body: formatBody(response?.body),
+      prettyBody: prettyBody(response),
+      durationMs: response?.timings?.total,
+      testResults: toTestResults(httpRegion)
+    };
+  } catch (error) {
+    return {
+      headers: [],
+      body: "",
+      prettyBody: "",
+      testResults: toTestResults(httpRegion),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function listEnvironments(filePath) {
+  const httpFile = getHttpFile(filePath);
+  if (!httpFile) {
+    return [];
+  }
+  return getEnvironments({ httpFile });
+}
+async function listVariables(filePath, activeEnvironment) {
+  const httpFile = getHttpFile(filePath);
+  if (!httpFile) {
+    return {};
+  }
+  return getVariables({ httpFile, activeEnvironment });
+}
+
+// src/keymap/dispatcher.ts
+function buildBindingMap(bindings, execute) {
+  const map = {};
+  for (const [key, command] of Object.entries(bindings)) {
+    map[key] = () => execute(command);
+  }
+  return map;
+}
+function commandFromPaletteId(id) {
+  const known = {
+    "request.send": "request.send",
+    "request.cancel": "request.cancel",
+    "file.save": "file.save",
+    "env.switcher": "env.switcher",
+    "palette.commands": "palette.commands",
+    "help.show": "help.show",
+    "keybindings.show": "keybindings.show",
+    "pane.zoom": "pane.zoom",
+    "sidebar.toggle": "sidebar.toggle"
+  };
+  return known[id] ?? null;
+}
+var COMMAND_ITEMS = [
+  { id: "request.send", label: "Send Request", description: "Send request under cursor", shortcut: "F5" },
+  { id: "request.cancel", label: "Cancel Request", description: "Cancel in-flight request", shortcut: "Ctrl+X" },
+  { id: "file.save", label: "Save File", description: "Write editor to disk", shortcut: "Ctrl+S" },
+  { id: "env.switcher", label: "Switch Environment", description: "Choose active environment", shortcut: "Ctrl+E" },
+  { id: "sidebar.toggle", label: "Toggle Sidebar", description: "Show/hide file tree", shortcut: "Ctrl+B" },
+  { id: "pane.zoom", label: "Zoom Pane", description: "Zoom focused pane", shortcut: "F11" },
+  { id: "help.show", label: "Help", description: "Show quick help", shortcut: "F1" },
+  { id: "keybindings.show", label: "Keybindings", description: "Show all keybindings", shortcut: "Ctrl+/" }
+];
+
+// src/workspace/index.ts
+import { readFile, writeFile } from "fs/promises";
+import chokidar from "chokidar";
+import { EventEmitter } from "events";
+
+// src/workspace/discovery.ts
+import { readdir, stat } from "fs/promises";
+import path2 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".reqex",
+  "dist",
+  ".cursor"
+]);
+var FILE_KINDS = [
+  { ext: ".http", kind: "http" },
+  { ext: ".rest", kind: "rest" },
+  { ext: ".env", kind: "env" },
+  { ext: ".env.json", kind: "env-json" }
+];
+function classifyFile(filePath) {
+  const base = path2.basename(filePath);
+  for (const { ext, kind } of FILE_KINDS) {
+    if (base === ext || base.endsWith(ext)) {
+      return kind;
+    }
+  }
+  if (base.endsWith(".env.json")) {
+    return "env-json";
+  }
+  return null;
+}
+async function discoverFileTree(rootDir) {
+  return discoverDirectory(rootDir, rootDir);
+}
+async function discoverDirectory(rootDir, currentDir) {
+  let entries;
+  try {
+    entries = await readdir(currentDir);
+  } catch {
+    return [];
+  }
+  entries.sort((a, b) => a.localeCompare(b));
+  const nodes = [];
+  for (const entry of entries) {
+    if (entry.startsWith(".") && entry !== ".env" && !entry.endsWith(".env.json")) {
+      if (SKIP_DIRS.has(entry)) {
+        continue;
+      }
+    }
+    const fullPath = path2.join(currentDir, entry);
+    let entryStat;
+    try {
+      entryStat = await stat(fullPath);
+    } catch {
+      continue;
+    }
+    if (entryStat.isDirectory()) {
+      if (SKIP_DIRS.has(entry)) {
+        continue;
+      }
+      const children = await discoverDirectory(rootDir, fullPath);
+      if (children.length > 0) {
+        nodes.push({
+          name: entry,
+          path: fullPath,
+          kind: "directory",
+          children
+        });
+      }
+      continue;
+    }
+    const fileKind = classifyFile(fullPath);
+    if (!fileKind) {
+      continue;
+    }
+    nodes.push({
+      name: entry,
+      path: fullPath,
+      kind: "file",
+      fileKind
+    });
+  }
+  return nodes;
+}
+function flattenFiles(nodes) {
+  const files = [];
+  for (const node of nodes) {
+    if (node.kind === "file") {
+      files.push(node);
+    } else if (node.children) {
+      files.push(...flattenFiles(node.children));
+    }
+  }
+  return files;
+}
+
+// src/workspace/index.ts
+var Workspace = class extends EventEmitter {
+  rootDir;
+  watcher = null;
+  tree = [];
+  constructor(rootDir) {
+    super();
+    this.rootDir = rootDir;
+  }
+  async open() {
+    this.tree = await discoverFileTree(this.rootDir);
+    await this.startWatcher();
+    this.emitChange({ type: "ready" });
+    return this.tree;
+  }
+  getTree() {
+    return this.tree;
+  }
+  async refresh() {
+    this.tree = await discoverFileTree(this.rootDir);
+    return this.tree;
+  }
+  async readFile(filePath) {
+    return readFile(filePath, "utf8");
+  }
+  async writeFile(filePath, content) {
+    await writeFile(filePath, content, "utf8");
+  }
+  async close() {
+    await this.watcher?.close();
+    this.watcher = null;
+  }
+  async startWatcher() {
+    await this.watcher?.close();
+    this.watcher = chokidar.watch(this.rootDir, {
+      ignoreInitial: true,
+      ignored: [
+        /(^|[/\\])\../,
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/dist/**"
+      ],
+      awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 }
+    });
+    const handle = async (type, path5) => {
+      try {
+        this.tree = await discoverFileTree(this.rootDir);
+        this.emitChange({ type, path: path5 });
+      } catch (error) {
+        this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    this.watcher.on("add", (path5) => void handle("add", path5));
+    this.watcher.on("change", (path5) => void handle("change", path5));
+    this.watcher.on("unlink", (path5) => void handle("unlink", path5));
+    this.watcher.on("error", (error) => {
+      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+    });
+  }
+  emitChange(event) {
+    this.emit("change", event);
+  }
+};
+
+// src/state/types.ts
+var FOCUS_PANES = ["files", "editor", "response"];
+var RESPONSE_TABS = [
+  "pretty",
+  "raw",
+  "headers",
+  "variables",
+  "tests"
+];
+function createInitialState(workspaceRoot) {
+  return {
+    workspaceRoot,
+    fileTree: [],
+    expandedPaths: [],
+    selectedFilePath: null,
+    fileContent: "",
+    fileLines: [""],
+    dirty: false,
+    parseVersion: 0,
+    parsedFile: null,
+    activeRegion: null,
+    responseEditor: {
+      scrollTop: 0,
+      scrollLeft: 0,
+      cursor: { line: 0, column: 0 },
+      selection: null
+    },
+    resultGeneration: 0,
+    editor: {
+      cursor: { line: 0, column: 0 },
+      selection: null,
+      scrollTop: 0,
+      scrollLeft: 0,
+      searchQuery: ""
+    },
+    request: {
+      sending: false,
+      error: null,
+      result: null,
+      activeEnvironment: [],
+      environments: [],
+      variables: {}
+    },
+    ui: {
+      focusPane: "editor",
+      zoomPane: null,
+      sidebarVisible: true,
+      layoutMode: "three-pane",
+      viewportWidth: 120,
+      viewportHeight: 40,
+      overlay: "none",
+      responseTab: "pretty",
+      splitSizes: [22, 40, 38],
+      envSelectedIndex: 0,
+      commandPalette: { open: false, query: "", selectedIndex: 0 },
+      pendingPrompt: null,
+      statusMessage: null,
+      gitBranch: null
+    },
+    settings: {
+      keymapPreset: "vscode",
+      keybindings: {}
+    }
+  };
+}
+function linesFromContent(content) {
+  if (content.length === 0) {
+    return [""];
+  }
+  return content.split(/\r?\n/u);
+}
+function contentFromLines(lines) {
+  return lines.join("\n");
+}
+function resolveLayoutMode(width) {
+  if (width < 80) {
+    return "stacked";
+  }
+  if (width < 120) {
+    return "sidebar-overlay";
+  }
+  return "three-pane";
+}
+function nextPane(current) {
+  const index = FOCUS_PANES.indexOf(current);
+  return FOCUS_PANES[(index + 1) % FOCUS_PANES.length] ?? "editor";
+}
+function prevPane(current) {
+  const index = FOCUS_PANES.indexOf(current);
+  return FOCUS_PANES[(index + FOCUS_PANES.length - 1) % FOCUS_PANES.length] ?? "editor";
+}
+function nextResponseTab(current) {
+  const index = RESPONSE_TABS.indexOf(current);
+  return RESPONSE_TABS[(index + 1) % RESPONSE_TABS.length] ?? "pretty";
+}
+function prevResponseTab(current) {
+  const index = RESPONSE_TABS.indexOf(current);
+  return RESPONSE_TABS[(index + RESPONSE_TABS.length - 1) % RESPONSE_TABS.length] ?? "pretty";
+}
+
+// src/state/send-controller.ts
+function createSendController() {
+  let sendGeneration = 0;
+  return {
+    beginSend() {
+      sendGeneration += 1;
+      return sendGeneration;
+    },
+    cancelSend() {
+      sendGeneration += 1;
+      return sendGeneration;
+    },
+    isCurrent(generation) {
+      return generation === sendGeneration;
+    }
+  };
+}
+
+// src/state/commands.ts
+function createCommandContext(deps) {
+  setPromptHandler(async (request) => {
+    return new Promise((resolve) => {
+      deps.update((state) => ({
+        ...state,
+        ui: {
+          ...state.ui,
+          overlay: "none",
+          pendingPrompt: {
+            kind: request.kind,
+            message: request.message,
+            values: request.kind === "list" ? request.values : void 0,
+            defaultValue: request.kind === "input" ? request.defaultValue : void 0,
+            masked: request.kind === "input" ? request.masked : void 0
+          }
+        }
+      }));
+      promptResolvers.push(resolve);
+    });
+  });
+  const promptResolvers = [];
+  const sendController = createSendController();
+  const resolvePrompt = (value) => {
+    const resolver = promptResolvers.pop();
+    resolver?.(value);
+    deps.update((state) => ({
+      ...state,
+      ui: { ...state.ui, pendingPrompt: null }
+    }));
+  };
+  const openFile = async (path5) => {
+    const content = await deps.workspace.readFile(path5);
+    const lines = linesFromContent(content);
+    const parsed = await parseFile(path5, async () => content, deps.workspace.rootDir);
+    const environments = await listEnvironments(path5);
+    const variables = await listVariables(path5, [...deps.getState().request.activeEnvironment]);
+    const activeRegion = resolveRegionAtLine(parsed.regions, 0);
+    deps.update((state) => ({
+      ...state,
+      selectedFilePath: path5,
+      fileContent: content,
+      fileLines: lines,
+      dirty: false,
+      parseVersion: parsed.version,
+      parsedFile: parsed,
+      activeRegion,
+      editor: {
+        ...state.editor,
+        cursor: { line: activeRegion?.startLine ?? 0, column: 0 },
+        selection: null,
+        scrollTop: activeRegion?.startLine ?? 0
+      },
+      request: {
+        ...state.request,
+        error: null,
+        result: null,
+        environments,
+        variables
+      },
+      ui: {
+        ...state.ui,
+        focusPane: "editor",
+        statusMessage: null
+      }
+    }));
+  };
+  const refreshWorkspace = async () => {
+    const tree = await deps.workspace.refresh();
+    deps.update((state) => ({ ...state, fileTree: tree }));
+  };
+  const saveFile = async () => {
+    const state = deps.getState();
+    if (!state.selectedFilePath || !state.dirty) {
+      return;
+    }
+    const content = contentFromLines(state.fileLines);
+    await deps.workspace.writeFile(state.selectedFilePath, content);
+    const version = bumpParseVersion(state.selectedFilePath);
+    const parsed = await parseFile(
+      state.selectedFilePath,
+      async () => content,
+      deps.workspace.rootDir,
+      version
+    );
+    const activeRegion = state.activeRegion ? parsed.regions.find((region) => region.id === state.activeRegion?.id) ?? resolveRegionAtLine(parsed.regions, state.editor.cursor.line) : resolveRegionAtLine(parsed.regions, state.editor.cursor.line);
+    deps.update((s) => ({
+      ...s,
+      fileContent: content,
+      dirty: false,
+      parsedFile: parsed,
+      activeRegion: activeRegion ?? null,
+      ui: { ...s.ui, statusMessage: "Saved" }
+    }));
+  };
+  const runSend = async () => {
+    const state = deps.getState();
+    if (!state.selectedFilePath || !state.parsedFile) {
+      return;
+    }
+    const region = resolveRegionAtLine(state.parsedFile.regions, state.editor.cursor.line);
+    if (!region) {
+      deps.update((s) => ({
+        ...s,
+        request: { ...s.request, error: "No request region under cursor" },
+        ui: { ...s.ui, focusPane: "response" }
+      }));
+      return;
+    }
+    const gen = sendController.beginSend();
+    deps.update((s) => ({
+      ...s,
+      activeRegion: region,
+      request: { ...s.request, sending: true, error: null, result: null },
+      responseEditor: {
+        scrollTop: 0,
+        scrollLeft: 0,
+        cursor: { line: 0, column: 0 },
+        selection: null
+      },
+      resultGeneration: s.resultGeneration + 1,
+      ui: { ...s.ui, focusPane: "response", responseTab: "pretty" }
+    }));
+    await new Promise((resolve) => setImmediate(resolve));
+    const result = await sendRegion({
+      filePath: state.selectedFilePath,
+      regionId: region.id,
+      workingDir: deps.workspace.rootDir,
+      activeEnvironment: [...state.request.activeEnvironment],
+      variables: state.request.variables
+    });
+    if (!sendController.isCurrent(gen)) {
+      return;
+    }
+    const variables = await listVariables(state.selectedFilePath, [
+      ...deps.getState().request.activeEnvironment
+    ]);
+    if (!sendController.isCurrent(gen)) {
+      return;
+    }
+    deps.update((s) => ({
+      ...s,
+      request: {
+        ...s.request,
+        sending: false,
+        result,
+        error: result.error ?? null,
+        variables
+      }
+    }));
+  };
+  const focusPane = (pane) => {
+    deps.update((state) => ({
+      ...state,
+      ui: { ...state.ui, focusPane: pane }
+    }));
+  };
+  const execute = (command) => {
+    const state = deps.getState();
+    switch (command) {
+      case "request.send":
+        void runSend();
+        break;
+      case "request.cancel":
+        if (!state.request.sending) {
+          break;
+        }
+        sendController.cancelSend();
+        deps.update((s) => ({
+          ...s,
+          request: {
+            ...s.request,
+            sending: false,
+            error: "Request cancelled",
+            result: null
+          },
+          ui: { ...s.ui, statusMessage: "Request cancelled" }
+        }));
+        break;
+      case "pane.focusNext":
+        focusPane(nextPane(state.ui.focusPane));
+        break;
+      case "pane.focusPrev":
+        focusPane(prevPane(state.ui.focusPane));
+        break;
+      case "pane.focusFiles":
+        focusPane("files");
+        break;
+      case "pane.focusEditor":
+        focusPane("editor");
+        break;
+      case "pane.focusResponse":
+        focusPane("response");
+        break;
+      case "sidebar.toggle":
+        deps.update((s) => ({
+          ...s,
+          ui: { ...s.ui, sidebarVisible: !s.ui.sidebarVisible }
+        }));
+        break;
+      case "file.save":
+        void saveFile();
+        break;
+      case "env.switcher":
+        deps.update((s) => ({
+          ...s,
+          ui: {
+            ...s.ui,
+            overlay: s.ui.overlay === "env" ? "none" : "env",
+            envSelectedIndex: Math.max(
+              0,
+              s.request.environments.indexOf(s.request.activeEnvironment.join(",")) || 0
+            )
+          }
+        }));
+        break;
+      case "env.selectNext":
+        if (state.ui.overlay === "env") {
+          deps.update((s) => ({
+            ...s,
+            ui: {
+              ...s.ui,
+              envSelectedIndex: Math.min(
+                s.request.environments.length,
+                s.ui.envSelectedIndex + 1
+              )
+            }
+          }));
+        }
+        break;
+      case "env.selectPrev":
+        if (state.ui.overlay === "env") {
+          deps.update((s) => ({
+            ...s,
+            ui: {
+              ...s.ui,
+              envSelectedIndex: Math.max(0, s.ui.envSelectedIndex - 1)
+            }
+          }));
+        }
+        break;
+      case "env.apply": {
+        const envName = state.request.environments[state.ui.envSelectedIndex];
+        void (async () => {
+          const activeEnvironment = envName ? [envName] : [];
+          const variables = state.selectedFilePath ? await listVariables(state.selectedFilePath, activeEnvironment) : {};
+          deps.update((s) => ({
+            ...s,
+            request: { ...s.request, activeEnvironment, variables },
+            ui: { ...s.ui, overlay: "none" }
+          }));
+        })();
+        break;
+      }
+      case "overlay.close":
+        deps.update((s) => ({
+          ...s,
+          ui: {
+            ...s.ui,
+            overlay: "none",
+            commandPalette: { ...s.ui.commandPalette, open: false },
+            pendingPrompt: null
+          }
+        }));
+        resolvePrompt(void 0);
+        break;
+      case "app.quit":
+        deps.quit();
+        break;
+      case "palette.commands":
+        deps.update((s) => ({
+          ...s,
+          ui: {
+            ...s.ui,
+            overlay: "commandPalette",
+            commandPalette: { open: true, query: "", selectedIndex: 0 }
+          }
+        }));
+        break;
+      case "palette.files": {
+        const files = flattenFiles(state.fileTree).filter((node) => node.kind === "file");
+        const first = files[0]?.path;
+        if (first) {
+          void openFile(first);
+        }
+        break;
+      }
+      case "help.show":
+        deps.update((s) => ({
+          ...s,
+          ui: { ...s.ui, overlay: s.ui.overlay === "help" ? "none" : "help" }
+        }));
+        break;
+      case "keybindings.show":
+        deps.update((s) => ({
+          ...s,
+          ui: {
+            ...s.ui,
+            overlay: s.ui.overlay === "keybindings" ? "none" : "keybindings"
+          }
+        }));
+        break;
+      case "pane.zoom":
+        deps.update((s) => ({
+          ...s,
+          ui: {
+            ...s.ui,
+            zoomPane: s.ui.zoomPane ? null : s.ui.focusPane
+          }
+        }));
+        break;
+      case "response.tab.next":
+        deps.update((s) => ({
+          ...s,
+          ui: { ...s.ui, responseTab: nextResponseTab(s.ui.responseTab) }
+        }));
+        break;
+      case "response.tab.prev":
+        deps.update((s) => ({
+          ...s,
+          ui: { ...s.ui, responseTab: prevResponseTab(s.ui.responseTab) }
+        }));
+        break;
+      case "response.copy":
+        deps.update((s) => ({
+          ...s,
+          ui: { ...s.ui, statusMessage: "Copy requested (see clipboard handler)" }
+        }));
+        break;
+      case "response.search":
+        deps.update((s) => ({
+          ...s,
+          ui: { ...s.ui, focusPane: "response", responseTab: "pretty" }
+        }));
+        break;
+      case "editor.searchNext":
+        break;
+      default:
+        break;
+    }
+  };
+  const context = {
+    get state() {
+      return deps.getState();
+    },
+    update: deps.update,
+    runSend,
+    openFile,
+    saveFile,
+    refreshWorkspace,
+    reloadKeybindings: deps.reloadKeybindings,
+    quit: deps.quit,
+    execute
+  };
+  return context;
+}
+
+// src/ui/app-view.ts
+import path3 from "path";
+import {
+  rgb,
+  ui
+} from "@rezi-ui/core";
+
+// src/utils/http-syntax.ts
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE",
+  "GRAPHQL"
+]);
+function tokenizeHttpLine(line, _context) {
+  const tokens = [];
+  const methodMatch = /^\s*(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|CONNECT|TRACE|GRAPHQL)\b/u.exec(
+    line
+  );
+  if (methodMatch) {
+    const method = methodMatch[1] ?? "";
+    tokens.push({ text: method, kind: "keyword" });
+    const rest = line.slice(methodMatch[0].length);
+    if (rest.length > 0) {
+      tokens.push({ text: rest, kind: "string" });
+    }
+    return tokens;
+  }
+  if (/^\s*#/u.test(line)) {
+    return [{ text: line, kind: "comment" }];
+  }
+  if (/^\s*\/\//u.test(line)) {
+    return [{ text: line, kind: "comment" }];
+  }
+  if (/^\s*@/u.test(line)) {
+    return [{ text: line, kind: "type" }];
+  }
+  const headerMatch = /^\s*([!#$%&'*+\-.^_`|~0-9A-Za-z]+)(\s*:\s*)(.*)$/u.exec(line);
+  if (headerMatch) {
+    tokens.push({ text: headerMatch[1] ?? "", kind: "function" });
+    tokens.push({ text: headerMatch[2] ?? "", kind: "operator" });
+    tokens.push({ text: headerMatch[3] ?? "", kind: "string" });
+    return tokens;
+  }
+  const words = line.split(/(\s+)/u);
+  for (const word of words) {
+    if (KEYWORDS.has(word)) {
+      tokens.push({ text: word, kind: "keyword" });
+    } else if (word.length > 0) {
+      tokens.push({ text: word, kind: "plain" });
+    }
+  }
+  return tokens.length > 0 ? tokens : [{ text: line, kind: "plain" }];
+}
+function prettyJsonIfPossible(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return text;
+  }
+  try {
+    return JSON.stringify(JSON.parse(trimmed), null, 2);
+  } catch {
+    return text;
+  }
+}
+function statusTone(statusCode) {
+  if (!statusCode) {
+    return "cyan";
+  }
+  if (statusCode >= 200 && statusCode < 300) {
+    return "green";
+  }
+  if (statusCode >= 400 && statusCode < 500) {
+    return "yellow";
+  }
+  if (statusCode >= 500) {
+    return "red";
+  }
+  return "cyan";
+}
+
+// src/ui/app-view.ts
+function paneStyle(focused) {
+  return focused ? { fg: rgb(180, 220, 255), bold: true } : { fg: rgb(120, 120, 120) };
+}
+function renderFileTree(state, deps) {
+  return ui.panel(
+    {
+      id: "pane-files",
+      title: state.ui.focusPane === "files" ? "\u25CF Files" : "Files",
+      style: paneStyle(state.ui.focusPane === "files")
+    },
+    [
+      ui.tree({
+        id: "file-tree",
+        data: state.fileTree,
+        expanded: state.expandedPaths,
+        selected: state.selectedFilePath ?? void 0,
+        getKey: (node) => node.path,
+        getChildren: (node) => node.kind === "directory" ? node.children : void 0,
+        onChange: (node, expanded) => deps.onTreeToggle(node, expanded),
+        onSelect: (node) => deps.onTreeSelect(node),
+        onPress: (node) => deps.onTreePress(node),
+        renderNode: (node, _depth, nodeState) => ui.row({ gap: 1 }, [
+          ui.text(nodeState.selected ? `\u25B8 ${node.name}` : node.name, {
+            style: nodeState.selected ? { fg: rgb(255, 220, 120), bold: true } : state.dirty && node.path === state.selectedFilePath ? { fg: rgb(255, 180, 80) } : void 0
+          })
+        ]),
+        flex: 1,
+        minHeight: 8
+      })
+    ]
+  );
+}
+function renderEditor(state, deps, readOnly) {
+  const activeRegion = state.activeRegion ?? (state.parsedFile ? resolveRegionAtLine(state.parsedFile.regions, state.editor.cursor.line) : null);
+  const titleParts = [
+    state.ui.focusPane === "editor" ? "\u25CF Editor" : "Editor",
+    state.selectedFilePath ? state.selectedFilePath.split("/").pop() : "No file",
+    state.dirty ? " \u25CF" : "",
+    activeRegion ? ` | ${activeRegion.method ?? "?"} ${activeRegion.name}` : ""
+  ];
+  const diagnostics = state.parsedFile ? buildRegionDiagnostics(
+    state.parsedFile.regions,
+    activeRegion?.id ?? null,
+    state.fileLines
+  ) : [];
+  return ui.panel(
+    {
+      id: "pane-editor",
+      title: titleParts.join(""),
+      style: paneStyle(state.ui.focusPane === "editor")
+    },
+    [
+      ui.codeEditor({
+        id: "editor",
+        lines: state.fileLines,
+        cursor: state.editor.cursor,
+        selection: state.editor.selection,
+        scrollTop: state.editor.scrollTop,
+        scrollLeft: state.editor.scrollLeft,
+        readOnly,
+        lineNumbers: true,
+        syntaxLanguage: "plain",
+        tokenizeLine: tokenizeHttpLine,
+        diagnostics,
+        onChange: (lines, cursor) => deps.onEditorChange(lines, cursor),
+        onSelectionChange: deps.onEditorSelection,
+        onScroll: deps.onEditorScroll,
+        flex: 1,
+        minHeight: 8
+      })
+    ]
+  );
+}
+function responseScrollProps(state, deps) {
+  return {
+    scrollTop: state.responseEditor.scrollTop,
+    scrollLeft: state.responseEditor.scrollLeft,
+    onScroll: deps.onResponseScroll
+  };
+}
+function responseCursorProps(state, deps) {
+  return {
+    cursor: state.responseEditor.cursor,
+    selection: state.responseEditor.selection,
+    onChange: (_lines, cursor) => {
+      deps.onResponseChange(cursor);
+    },
+    onSelectionChange: deps.onResponseSelection
+  };
+}
+function renderResponseBody(state, deps) {
+  const result = state.request.result;
+  const scroll = responseScrollProps(state, deps);
+  const cursor = responseCursorProps(state, deps);
+  const gen = state.resultGeneration;
+  if (state.request.sending) {
+    return ui.center(ui.spinner({ label: "Waiting for response\u2026" }));
+  }
+  if (state.request.error && !result) {
+    return ui.errorDisplay(state.request.error);
+  }
+  if (!result) {
+    return ui.empty("No response", {
+      description: "Press F5 to send the request under cursor"
+    });
+  }
+  switch (state.ui.responseTab) {
+    case "headers":
+      return ui.table({
+        id: `response-headers-${gen}`,
+        columns: [
+          { key: "name", header: "Header", width: 24 },
+          { key: "value", header: "Value", flex: 1 }
+        ],
+        data: [...result.headers],
+        getRowKey: (row) => row.name,
+        flex: 1,
+        minHeight: 6
+      });
+    case "raw":
+      return ui.codeEditor({
+        id: `response-raw-${gen}`,
+        lines: result.body ? result.body.split("\n") : [""],
+        readOnly: true,
+        lineNumbers: true,
+        syntaxLanguage: "plain",
+        ...cursor,
+        ...scroll,
+        flex: 1
+      });
+    case "variables":
+      return ui.codeEditor({
+        id: `response-vars-${gen}`,
+        lines: [JSON.stringify(state.request.variables, null, 2)],
+        readOnly: true,
+        syntaxLanguage: "json",
+        ...cursor,
+        ...scroll,
+        flex: 1
+      });
+    case "tests":
+      return ui.column({ gap: 1, flex: 1 }, [
+        ...result.testResults.map(
+          (test) => ui.text(`${test.status === "SUCCESS" ? "\u2713" : "\u2717"} ${test.message}`, {
+            style: {
+              fg: test.status === "SUCCESS" ? rgb(120, 220, 120) : test.status === "SKIPPED" ? rgb(220, 220, 120) : rgb(220, 120, 120)
+            }
+          })
+        )
+      ]);
+    case "pretty":
+    default:
+      return ui.codeEditor({
+        id: `response-pretty-${gen}`,
+        lines: prettyJsonIfPossible(result.prettyBody || result.body).split("\n"),
+        readOnly: true,
+        lineNumbers: true,
+        syntaxLanguage: "json",
+        searchQuery: state.editor.searchQuery || void 0,
+        ...cursor,
+        ...scroll,
+        flex: 1
+      });
+  }
+}
+function renderResponse(state, deps) {
+  const result = state.request.result;
+  const statusLine = state.request.sending || !result ? null : `${result.protocol ?? "HTTP"} ${result.statusCode ?? "?"} ${result.statusMessage ?? ""} \xB7 ${result.durationMs ?? "?"} ms`;
+  const tabItems = [
+    { key: "pretty", label: "Pretty" },
+    { key: "raw", label: "Raw" },
+    { key: "headers", label: "Headers" },
+    { key: "variables", label: "Vars" },
+    { key: "tests", label: "Tests" }
+  ];
+  return ui.panel(
+    {
+      id: "pane-response",
+      title: state.ui.focusPane === "response" ? "\u25CF Response" : "Response",
+      style: paneStyle(state.ui.focusPane === "response")
+    },
+    [
+      ui.row({ gap: 2 }, [
+        state.request.sending ? ui.spinner({ label: "Sending request\u2026" }) : ui.text(statusLine ?? "Ready", {
+          style: { fg: rgb(...statusColor(result?.statusCode)), bold: true }
+        }),
+        result?.error && !state.request.sending ? ui.badge(result.error, { variant: "error" }) : null
+      ]),
+      ui.row({ gap: 1 }, [
+        ...tabItems.map(
+          (tab) => ui.button({
+            id: `tab-${tab.key}`,
+            label: tab.label,
+            disabled: state.request.sending,
+            onPress: () => deps.onResponseTab(tab.key)
+          })
+        )
+      ]),
+      renderResponseBody(state, deps)
+    ]
+  );
+}
+function statusColor(code) {
+  const tone = statusTone(code);
+  switch (tone) {
+    case "green":
+      return [120, 220, 140];
+    case "yellow":
+      return [240, 200, 100];
+    case "red":
+      return [240, 120, 120];
+    default:
+      return [140, 200, 240];
+  }
+}
+function renderMainLayout(state, deps) {
+  const layoutMode = resolveLayoutMode(state.ui.viewportWidth);
+  const zoom = state.ui.zoomPane;
+  if (zoom) {
+    if (zoom === "files") return renderFileTree(state, deps);
+    if (zoom === "editor") return renderEditor(state, deps, false);
+    return renderResponse(state, deps);
+  }
+  if (layoutMode === "stacked") {
+    const pane = state.ui.focusPane === "files" ? renderFileTree(state, deps) : state.ui.focusPane === "response" ? renderResponse(state, deps) : renderEditor(state, deps, false);
+    return pane;
+  }
+  if (layoutMode === "sidebar-overlay") {
+    return ui.row({ gap: 1, flex: 1 }, [
+      state.ui.sidebarVisible ? ui.box({ width: 28, flex: 0 }, [renderFileTree(state, deps)]) : null,
+      ui.column({ gap: 1, flex: 1 }, [
+        renderEditor(state, deps, false),
+        renderResponse(state, deps)
+      ])
+    ]);
+  }
+  return ui.column({ gap: 1, flex: 1 }, [
+    ui.splitPane(
+      {
+        id: "main-split",
+        direction: "horizontal",
+        sizes: [...state.ui.splitSizes],
+        minSizes: [18, 24, 24],
+        onChange: deps.onSplitChange
+      },
+      [
+        renderFileTree(state, deps),
+        renderEditor(state, deps, false),
+        renderResponse(state, deps)
+      ]
+    )
+  ]);
+}
+function renderFooter(state) {
+  const env = state.request.activeEnvironment.length > 0 ? state.request.activeEnvironment.join(",") : "none";
+  const dirName = path3.basename(state.workspaceRoot);
+  const branch = state.ui.gitBranch ?? "\u2014";
+  const fileName = state.selectedFilePath ? path3.basename(state.selectedFilePath) : null;
+  const hints = footerHints({
+    focusPane: state.ui.focusPane,
+    overlay: state.ui.overlay,
+    viewportWidth: state.ui.viewportWidth,
+    sending: state.request.sending
+  });
+  return ui.statusBar({
+    id: "status-bar",
+    left: [
+      ui.text(dirName, { style: { fg: rgb(180, 220, 255), bold: true } }),
+      ui.text(` \u2387 ${branch}`, { style: { fg: rgb(160, 220, 160) } }),
+      fileName ? ui.text(` | ${fileName}`) : null,
+      state.dirty ? ui.text(" \u25CF", { style: { fg: rgb(255, 180, 80) } }) : null,
+      ui.text(` | env: ${env}`, { style: { fg: rgb(160, 200, 255) } }),
+      state.ui.statusMessage ? ui.text(` | ${state.ui.statusMessage}`) : null
+    ].filter(Boolean),
+    right: [ui.text(hints)]
+  });
+}
+function renderOverlayContent(state, deps) {
+  switch (state.ui.overlay) {
+    case "env":
+      return ui.modal({
+        id: "env-modal",
+        title: "Environment",
+        content: ui.column({ gap: 1 }, [
+          ui.text("Select environment (Enter to apply, Esc to close)"),
+          ui.text("(none)", {
+            style: state.ui.envSelectedIndex === 0 ? { fg: rgb(255, 220, 120), bold: true } : void 0
+          }),
+          ...state.request.environments.map(
+            (env, index) => ui.text(env, {
+              style: index + 1 === state.ui.envSelectedIndex ? { fg: rgb(255, 220, 120), bold: true } : void 0
+            })
+          )
+        ]),
+        onClose: deps.onOverlayClose,
+        width: 50,
+        height: 16
+      });
+    case "help":
+      return ui.modal({
+        id: "help-modal",
+        title: "reqex help",
+        content: ui.column({ gap: 1 }, HELP_HINT_LINES.map((line) => ui.text(line))),
+        onClose: deps.onOverlayClose,
+        width: 70,
+        height: 14
+      });
+    case "keybindings": {
+      const maxLines = Math.max(8, Math.min(26, state.ui.viewportHeight - 8));
+      const lines = buildKeybindingsViewLines(
+        state.settings.keybindings,
+        maxLines
+      );
+      return ui.modal({
+        id: "keybindings-modal",
+        title: "Keybindings",
+        content: ui.column({ gap: 0 }, lines.map((line) => ui.text(line))),
+        onClose: deps.onOverlayClose,
+        width: 72,
+        height: Math.min(maxLines + 4, 28)
+      });
+    }
+    case "commandPalette":
+      return ui.center(
+        ui.commandPalette({
+          id: "command-palette",
+          open: true,
+          query: state.ui.commandPalette.query,
+          selectedIndex: state.ui.commandPalette.selectedIndex,
+          sources: [
+            {
+              id: "commands",
+              name: "Commands",
+              getItems: (query) => COMMAND_ITEMS.filter(
+                (item) => item.label.toLowerCase().includes(query.toLowerCase())
+              ).map((item) => ({
+                id: item.id,
+                label: item.label,
+                description: item.description,
+                shortcut: item.shortcut,
+                sourceId: "commands"
+              }))
+            }
+          ],
+          onChange: deps.onCommandPaletteChange,
+          onSelect: (item) => deps.onCommandPaletteSelect(item.id),
+          onClose: deps.onOverlayClose,
+          onSelectionChange: deps.onCommandPaletteSelectionChange,
+          width: 60
+        })
+      );
+    default:
+      return ui.text("");
+  }
+}
+function renderApp(state, deps) {
+  const base = ui.column({ gap: 1, flex: 1 }, [
+    renderMainLayout(state, deps),
+    renderFooter(state)
+  ]);
+  if (state.ui.overlay === "none") {
+    return base;
+  }
+  return ui.layers([
+    base,
+    ui.layer({
+      id: "overlay-layer",
+      modal: true,
+      backdrop: "dim",
+      closeOnEscape: true,
+      onClose: deps.onOverlayClose,
+      content: renderOverlayContent(state, deps)
+    })
+  ]);
+}
+function focusPaneId(pane) {
+  switch (pane) {
+    case "files":
+      return "pane-files";
+    case "editor":
+      return "pane-editor";
+    case "response":
+      return "pane-response";
+  }
+}
+
+// src/utils/clipboard.ts
+import clipboard from "clipboardy";
+async function copyToClipboard(text) {
+  try {
+    await clipboard.write(text);
+    return true;
+  } catch {
+    if (process.stdout.write(`\x1B]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`)) {
+      return true;
+    }
+    return false;
+  }
+}
+function disableFlowControl() {
+  if (process.stdin.isTTY) {
+    try {
+      process.stdin.setRawMode?.(true);
+    } catch {
+    }
+  }
+}
+
+// src/utils/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function getGitBranch(root) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["-C", root, "rev-parse", "--abbrev-ref", "HEAD"],
+      { timeout: 2e3 }
+    );
+    const branch = stdout.trim();
+    return branch.length > 0 ? branch : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/cli.ts
+async function main() {
+  initEngineProviders();
+  const workspaceRoot = path4.resolve(process2.argv[2] ?? process2.cwd());
+  const workspace = new Workspace(workspaceRoot);
+  const tree = await workspace.open();
+  let currentState = createInitialState(workspaceRoot);
+  currentState = {
+    ...currentState,
+    fileTree: tree,
+    expandedPaths: tree.filter((n) => n.kind === "directory").map((n) => n.path),
+    ui: {
+      ...currentState.ui,
+      gitBranch: await getGitBranch(workspaceRoot)
+    }
+  };
+  let app = null;
+  let bus = null;
+  const refreshGitBranch = async () => {
+    const branch = await getGitBranch(workspaceRoot);
+    app?.update((prev) => ({
+      ...prev,
+      ui: { ...prev.ui, gitBranch: branch }
+    }));
+  };
+  const reloadKeybindings = () => {
+    if (!app || !bus) {
+      return;
+    }
+    const loaded = loadKeybindings(workspaceRoot);
+    app.keys({
+      ...buildBindingMap(loaded.bindings, (command) => {
+        if (command === "response.copy") {
+          void handleCopy(app, currentState);
+        }
+        bus.execute(command);
+      }),
+      enter: {
+        handler: () => bus.execute("env.apply"),
+        when: (ctx) => ctx.state.ui.overlay === "env",
+        description: "Apply selected environment"
+      },
+      up: {
+        handler: () => {
+          if (currentState.ui.overlay === "env") {
+            bus.execute("env.selectPrev");
+          }
+        },
+        when: (ctx) => ctx.state.ui.overlay === "env" || ctx.state.ui.overlay === "commandPalette"
+      },
+      down: {
+        handler: () => {
+          if (currentState.ui.overlay === "env") {
+            bus.execute("env.selectNext");
+          }
+        },
+        when: (ctx) => ctx.state.ui.overlay === "env" || ctx.state.ui.overlay === "commandPalette"
+      }
+    });
+    app.update((state) => ({
+      ...state,
+      settings: {
+        keymapPreset: loaded.preset,
+        keybindings: loaded.bindings
+      }
+    }));
+  };
+  bus = createCommandContext({
+    workspace,
+    getState: () => currentState,
+    update: (updater) => {
+      app?.update((prev) => {
+        currentState = typeof updater === "function" ? updater(prev) : updater;
+        return currentState;
+      });
+    },
+    quit: () => {
+      void workspace.close().finally(() => {
+        app?.stop().finally(() => process2.exit(0));
+      });
+    },
+    reloadKeybindings
+  });
+  app = createNodeApp({ initialState: currentState });
+  reloadKeybindings();
+  disableFlowControl();
+  const stopWatch = watchKeybindings(workspaceRoot, reloadKeybindings);
+  workspace.on("change", () => {
+    void bus.refreshWorkspace();
+    void refreshGitBranch();
+  });
+  app.view(
+    (state) => renderApp(state, {
+      onEditorChange: (lines, cursor) => {
+        app?.update((prev) => {
+          const activeRegion = prev.parsedFile ? resolveRegionAtLine(prev.parsedFile.regions, cursor.line) : null;
+          return {
+            ...prev,
+            fileLines: [...lines],
+            dirty: contentFromLines(lines) !== prev.fileContent,
+            activeRegion,
+            ui: { ...prev.ui, focusPane: "editor" },
+            editor: { ...prev.editor, cursor }
+          };
+        });
+      },
+      onEditorSelection: (selection) => {
+        app?.update((prev) => {
+          const cursorLine = selection?.active.line ?? prev.editor.cursor.line;
+          const activeRegion = prev.parsedFile ? resolveRegionAtLine(prev.parsedFile.regions, cursorLine) : null;
+          return {
+            ...prev,
+            activeRegion,
+            ui: { ...prev.ui, focusPane: "editor" },
+            editor: {
+              ...prev.editor,
+              selection,
+              cursor: selection?.active ?? prev.editor.cursor
+            }
+          };
+        });
+      },
+      onEditorScroll: (scrollTop, scrollLeft) => {
+        app?.update((prev) => ({
+          ...prev,
+          editor: { ...prev.editor, scrollTop, scrollLeft }
+        }));
+      },
+      onTreeSelect: (node) => {
+        if (node.kind === "file") {
+          void bus.openFile(node.path);
+        }
+      },
+      onTreeToggle: (node, expanded) => {
+        app?.update((prev) => ({
+          ...prev,
+          expandedPaths: expanded ? [...prev.expandedPaths, node.path] : prev.expandedPaths.filter((p) => p !== node.path)
+        }));
+      },
+      onTreePress: (node) => {
+        if (node.kind === "file") {
+          void bus.openFile(node.path);
+        }
+      },
+      onResponseTab: (tab) => {
+        app?.update((prev) => ({
+          ...prev,
+          ui: { ...prev.ui, responseTab: tab },
+          responseEditor: {
+            ...prev.responseEditor,
+            scrollTop: 0,
+            scrollLeft: 0,
+            cursor: { line: 0, column: 0 },
+            selection: null
+          }
+        }));
+      },
+      onResponseScroll: (scrollTop, scrollLeft) => {
+        app?.update((prev) => ({
+          ...prev,
+          responseEditor: { ...prev.responseEditor, scrollTop, scrollLeft }
+        }));
+      },
+      onResponseSelection: (selection) => {
+        app?.update((prev) => ({
+          ...prev,
+          ui: { ...prev.ui, focusPane: "response" },
+          responseEditor: {
+            ...prev.responseEditor,
+            selection,
+            cursor: selection?.active ?? prev.responseEditor.cursor
+          }
+        }));
+      },
+      onResponseChange: (cursor) => {
+        app?.update((prev) => ({
+          ...prev,
+          ui: { ...prev.ui, focusPane: "response" },
+          responseEditor: { ...prev.responseEditor, cursor }
+        }));
+      },
+      onSplitChange: (sizes) => {
+        if (sizes.length === 3) {
+          app?.update((prev) => ({
+            ...prev,
+            ui: { ...prev.ui, splitSizes: [sizes[0], sizes[1], sizes[2]] }
+          }));
+        }
+      },
+      onCommandPaletteChange: (query) => {
+        app?.update((prev) => ({
+          ...prev,
+          ui: {
+            ...prev.ui,
+            commandPalette: { ...prev.ui.commandPalette, query, selectedIndex: 0 }
+          }
+        }));
+      },
+      onCommandPaletteSelectionChange: (index) => {
+        app?.update((prev) => ({
+          ...prev,
+          ui: {
+            ...prev.ui,
+            commandPalette: { ...prev.ui.commandPalette, selectedIndex: index }
+          }
+        }));
+      },
+      onCommandPaletteSelect: (id) => {
+        bus?.execute("overlay.close");
+        const command = commandFromPaletteId(id);
+        if (command && command !== "palette.commands") {
+          bus?.execute(command);
+        }
+      },
+      onOverlayClose: () => {
+        bus?.execute("overlay.close");
+      },
+      onEnvSelect: (index) => {
+        app?.update((prev) => ({
+          ...prev,
+          ui: { ...prev.ui, envSelectedIndex: index }
+        }));
+      },
+      onResponseSearch: (query) => {
+        app?.update((prev) => ({
+          ...prev,
+          editor: { ...prev.editor, searchQuery: query }
+        }));
+      }
+    })
+  );
+  app.onEvent((event) => handleUiEvent(event, app));
+  const files = flattenFiles(tree).filter((node) => node.kind === "file");
+  if (files[0]) {
+    await bus.openFile(files[0].path);
+  }
+  await app.run();
+  stopWatch();
+}
+async function handleCopy(app, state) {
+  const result = state.request.result;
+  if (!result) {
+    return;
+  }
+  let text = result.body;
+  if (state.ui.responseTab === "pretty") {
+    text = result.prettyBody || result.body;
+  } else if (state.ui.responseTab === "headers") {
+    text = result.headers.map((h) => `${h.name}: ${h.value}`).join("\n");
+  }
+  const ok = await copyToClipboard(text);
+  app.update((prev) => ({
+    ...prev,
+    ui: { ...prev.ui, statusMessage: ok ? "Copied" : "Copy failed" }
+  }));
+}
+function handleUiEvent(event, app) {
+  if (event.kind === "engine" && event.event.kind === "resize") {
+    const resize = event.event;
+    app.update((prev) => ({
+      ...prev,
+      ui: {
+        ...prev.ui,
+        viewportWidth: resize.cols,
+        viewportHeight: resize.rows,
+        layoutMode: resolveLayoutMode(resize.cols),
+        sidebarVisible: resolveLayoutMode(resize.cols) === "sidebar-overlay" ? prev.ui.sidebarVisible : true
+      }
+    }));
+    return;
+  }
+  if (event.kind !== "engine" || event.event.kind !== "mouse") {
+    return;
+  }
+  const { x, y } = event.event;
+  const panes = [
+    { id: "pane-files", pane: "files" },
+    { id: "pane-editor", pane: "editor" },
+    { id: "pane-response", pane: "response" }
+  ];
+  for (const entry of panes) {
+    const rect = app.measureElement(entry.id);
+    if (!rect) {
+      continue;
+    }
+    if (x >= rect.x && x < rect.x + rect.w && y >= rect.y && y < rect.y + rect.h) {
+      app.update((prev) => ({
+        ...prev,
+        ui: { ...prev.ui, focusPane: entry.pane }
+      }));
+      break;
+    }
+  }
+}
+void main().catch((error) => {
+  console.error(error);
+  process2.exit(1);
+});
+export {
+  focusPaneId
+};
+//# sourceMappingURL=cli.js.map