poe-code 3.0.217 → 3.0.219

package/dist/providers/poe-agent.js

@@ -6035,9 +6035,9 @@ function getOptionalGrepOutputMode(args, key2) {
 function formatDisplayPath(cwd, filePath) {
   return path11.relative(cwd, filePath) || path11.basename(filePath);
 }
-async function sortPathsByModifiedTime(matches2, fs4) {
+async function sortPathsByModifiedTime(matches, fs4) {
   const entries = await Promise.all(
-    matches2.map(async (match) => ({
+    matches.map(async (match) => ({
       path: match,
       mtimeMs: (await fs4.stat(match)).mtimeMs
     }))
@@ -6422,12 +6422,12 @@ var init_poe_agent_plugin_files = __esm({
             allowedPaths,
             getOptionalString(args, "path") ?? "."
           );
-          const matches2 = await globFiles({
+          const matches = await globFiles({
             pattern: getRequiredString(args, "pattern"),
             cwd: searchPath
           });
           const sortedMatches = await sortPathsByModifiedTime(
-            matches2.map((match) => resolveAllowedPath(cwd, allowedPaths, match)),
+            matches.map((match) => resolveAllowedPath(cwd, allowedPaths, match)),
             fs4
           );
           if (sortedMatches.length === 0) {
@@ -18768,6 +18768,12 @@ var init_text = __esm({
         if (format === "markdown") return `*${content}*`;
         return getTheme().muted(content);
       },
+      error(content) {
+        const format = resolveOutputFormat();
+        if (format === "json") return content;
+        if (format === "markdown") return `**${content}**`;
+        return getTheme().error(content);
+      },
       badge(content) {
         const format = resolveOutputFormat();
         if (format === "json") return content;
@@ -23110,6 +23116,9 @@ function cellToAnsi(cell) {
   if (style.dim) {
     painter = painter.dim;
   }
+  if (style.underline) {
+    painter = painter.underline;
+  }
   if (style.fg) {
     painter = applyForegroundColor(painter, style.fg);
   }
@@ -23142,13 +23151,16 @@ function normalizeStyle(style) {
   if (style?.dim !== void 0) {
     next.dim = style.dim;
   }
+  if (style?.underline !== void 0) {
+    next.underline = style.underline;
+  }
   return next;
 }
 function normalizeSize(value) {
   return Math.max(0, Math.floor(value));
 }
 function cellsEqual(left, right) {
-  return left.ch === right.ch && left.style.fg === right.style.fg && left.style.bg === right.style.bg && left.style.bold === right.style.bold && left.style.dim === right.style.dim;
+  return left.ch === right.ch && left.style.fg === right.style.fg && left.style.bg === right.style.bg && left.style.bold === right.style.bold && left.style.dim === right.style.dim && left.style.underline === right.style.underline;
 }
 function applyForegroundColor(instance, color) {
   if (color.startsWith("#")) {
@@ -24158,24 +24170,60 @@ var init_stats_pane = __esm({
 });
 
 // packages/design-system/src/dashboard/keymap.ts
-function createKeymap(overrides) {
+function createKeymap(overrides, options) {
+  const resolvedCommands = options?.commands ?? commands;
+  const resolvedDefaults = options?.defaultBindings ?? defaultBindings;
   const bindings = /* @__PURE__ */ new Map();
-  for (const command of commands) {
-    const keys = overrides?.[command] ?? defaultBindings[command];
-    bindings.set(
-      command,
-      keys.map(parseBinding).filter((binding) => binding !== void 0)
-    );
+  const sequences = /* @__PURE__ */ new Set();
+  let pendingSequence = "";
+  for (const command of resolvedCommands) {
+    const keys = overrides?.[command] ?? resolvedDefaults[command];
+    const commandBindings = keys.map(parseBinding).filter((binding) => binding !== void 0);
+    for (const binding of commandBindings) {
+      if (binding.sequence !== void 0) {
+        sequences.add(binding.sequence);
+      }
+    }
+    bindings.set(command, commandBindings);
   }
   return (event) => {
-    for (const command of commands) {
+    for (const command of resolvedCommands) {
       const commandBindings = bindings.get(command);
-      if (commandBindings?.some((binding) => matches(binding, event))) {
+      if (commandBindings?.some((binding) => matchesSingleKey(binding, event))) {
+        pendingSequence = "";
         return command;
       }
     }
+    const sequenceCommand = resolveSequence(event);
+    if (sequenceCommand !== void 0) {
+      return sequenceCommand;
+    }
     return void 0;
   };
+  function resolveSequence(event) {
+    const token = eventToSequenceToken(event);
+    if (token === void 0) {
+      pendingSequence = "";
+      return void 0;
+    }
+    pendingSequence = `${pendingSequence}${token}`;
+    for (const command of resolvedCommands) {
+      const commandBindings = bindings.get(command);
+      if (commandBindings?.some((binding) => binding.sequence === pendingSequence)) {
+        pendingSequence = "";
+        return command;
+      }
+    }
+    if (hasSequencePrefix(sequences, pendingSequence)) {
+      return void 0;
+    }
+    pendingSequence = token;
+    if (hasSequencePrefix(sequences, pendingSequence)) {
+      return void 0;
+    }
+    pendingSequence = "";
+    return void 0;
+  }
 }
 function parseBinding(binding) {
   const value = binding.trim();
@@ -24208,25 +24256,37 @@ function parseBinding(binding) {
       continue;
     }
   }
-  if (parts.length === 1 && isShiftedCharacter(key2)) {
+  const normalizedKey = normalizeKeyName(key2);
+  if (parts.length === 1 && isShiftedCharacter(normalizedKey)) {
     shift = true;
   }
-  if (key2.length === 1) {
+  if (normalizedKey.length === 1) {
     return {
-      ch: normalizeBindingCharacter(key2, shift),
+      ch: normalizeBindingCharacter(normalizedKey, shift),
+      ctrl,
+      meta,
+      shift
+    };
+  }
+  if (!ctrl && !meta && !shift && !isNamedKey(normalizedKey) && isPrintableSequence(normalizedKey)) {
+    return {
+      sequence: normalizedKey,
       ctrl,
       meta,
       shift
     };
   }
   return {
-    name: key2.toLowerCase(),
+    name: normalizedKey.toLowerCase(),
     ctrl,
     meta,
     shift
   };
 }
-function matches(binding, event) {
+function matchesSingleKey(binding, event) {
+  if (binding.sequence !== void 0) {
+    return false;
+  }
   if (binding.ctrl !== event.ctrl || binding.meta !== event.meta || binding.shift !== event.shift) {
     return false;
   }
@@ -24238,6 +24298,20 @@ function matches(binding, event) {
   }
   return false;
 }
+function eventToSequenceToken(event) {
+  if (event.ctrl || event.meta || event.ch === void 0) {
+    return void 0;
+  }
+  return event.ch;
+}
+function hasSequencePrefix(sequences, prefix) {
+  for (const sequence of sequences) {
+    if (sequence.startsWith(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
 function isShiftedCharacter(value) {
   return value.length === 1 && value.toLowerCase() !== value && value.toUpperCase() === value;
 }
@@ -24247,7 +24321,40 @@ function normalizeBindingCharacter(value, shift) {
   }
   return value.toUpperCase();
 }
-var commands, defaultBindings;
+function normalizeKeyName(value) {
+  if (value.toLowerCase() === "space") {
+    return " ";
+  }
+  if (value === "\u2191") {
+    return "up";
+  }
+  if (value === "\u2193") {
+    return "down";
+  }
+  if (value === "\u2190") {
+    return "left";
+  }
+  if (value === "\u2192") {
+    return "right";
+  }
+  return value;
+}
+function isNamedKey(value) {
+  return namedKeys.has(value.toLowerCase());
+}
+function isPrintableSequence(value) {
+  if (Array.from(value).length <= 1) {
+    return false;
+  }
+  for (const char of value) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === void 0 || codePoint < 32 || codePoint === 127) {
+      return false;
+    }
+  }
+  return true;
+}
+var commands, defaultBindings, namedKeys;
 var init_keymap = __esm({
   "packages/design-system/src/dashboard/keymap.ts"() {
     "use strict";
@@ -24260,6 +24367,22 @@ var init_keymap = __esm({
       retry: ["r"],
       "view-log": ["l"]
     };
+    namedKeys = /* @__PURE__ */ new Set([
+      "backspace",
+      "delete",
+      "down",
+      "end",
+      "enter",
+      "escape",
+      "home",
+      "left",
+      "pagedown",
+      "pageup",
+      "return",
+      "right",
+      "tab",
+      "up"
+    ]);
   }
 });
 
@@ -24581,6 +24704,10 @@ function createTerminalDriver(opts) {
   };
 }
 function toKeypressEvent(str, key2) {
+  const controlCharacter = controlCharacterToKeypress(key2?.sequence);
+  if (controlCharacter !== void 0) {
+    return controlCharacter;
+  }
   const ctrl = key2?.ctrl ?? false;
   const meta = key2?.meta ?? false;
   const shift = key2?.shift ?? false;
@@ -24602,12 +24729,22 @@ function extractPrintableCharacter(str, sequence) {
   if (isPrintableCharacter(str)) {
     return str;
   }
+  if (isSinglePrintableSequence(sequence)) {
+    return sequence;
+  }
   if (sequence === void 0 || sequence.length <= 1 || sequence[0] !== "\x1B") {
     return void 0;
   }
   const candidate = sequence.slice(1);
   return isPrintableCharacter(candidate) ? candidate : void 0;
 }
+function isSinglePrintableSequence(value) {
+  if (value === void 0 || Array.from(value).length !== 1) {
+    return false;
+  }
+  const codePoint = value.codePointAt(0);
+  return codePoint !== void 0 && codePoint >= 32 && codePoint !== 127;
+}
 function isPrintableCharacter(value) {
   if (value === void 0 || Array.from(value).length !== 1) {
     return false;
@@ -24615,6 +24752,23 @@ function isPrintableCharacter(value) {
   const codePoint = value.codePointAt(0);
   return codePoint !== void 0 && codePoint >= 32 && codePoint !== 127;
 }
+function controlCharacterToKeypress(sequence) {
+  if (sequence === "") {
+    return { ch: "/", ctrl: true, meta: false, shift: false };
+  }
+  if (sequence !== void 0 && sequence.length === 1) {
+    const code = sequence.charCodeAt(0);
+    if (code >= 1 && code <= 26 && code !== 9 && code !== 10 && code !== 13) {
+      return {
+        name: String.fromCharCode(code + 96),
+        ctrl: true,
+        meta: false,
+        shift: false
+      };
+    }
+  }
+  return void 0;
+}
 function cursorPositionAnsi(x, y) {
   return `\x1B[${normalizeCoordinate(y) + 1};${normalizeCoordinate(x) + 1}H`;
 }
@@ -24845,6 +24999,158 @@ var init_dashboard2 = __esm({
   }
 });
 
+// packages/design-system/src/explorer/jobs.ts
+var init_jobs2 = __esm({
+  "packages/design-system/src/explorer/jobs.ts"() {
+    "use strict";
+  }
+});
+
+// packages/design-system/src/explorer/layout.ts
+var init_layout2 = __esm({
+  "packages/design-system/src/explorer/layout.ts"() {
+    "use strict";
+  }
+});
+
+// packages/design-system/src/explorer/keymap.ts
+var init_keymap2 = __esm({
+  "packages/design-system/src/explorer/keymap.ts"() {
+    "use strict";
+  }
+});
+
+// packages/design-system/src/explorer/state.ts
+var REGION_HEADER, REGION_LIST, REGION_DETAIL, REGION_FOOTER, REGION_MODAL, REGION_TOAST, REGION_ALL;
+var init_state3 = __esm({
+  "packages/design-system/src/explorer/state.ts"() {
+    "use strict";
+    init_keymap2();
+    REGION_HEADER = 1 << 0;
+    REGION_LIST = 1 << 1;
+    REGION_DETAIL = 1 << 2;
+    REGION_FOOTER = 1 << 3;
+    REGION_MODAL = 1 << 4;
+    REGION_TOAST = 1 << 5;
+    REGION_ALL = REGION_HEADER | REGION_LIST | REGION_DETAIL | REGION_FOOTER | REGION_MODAL | REGION_TOAST;
+  }
+});
+
+// packages/design-system/src/explorer/theme.ts
+var init_theme = __esm({
+  "packages/design-system/src/explorer/theme.ts"() {
+    "use strict";
+  }
+});
+
+// packages/design-system/src/explorer/render/detail.ts
+var init_detail = __esm({
+  "packages/design-system/src/explorer/render/detail.ts"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// packages/design-system/src/explorer/render/footer.ts
+var init_footer2 = __esm({
+  "packages/design-system/src/explorer/render/footer.ts"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// packages/design-system/src/explorer/render/header.ts
+var init_header = __esm({
+  "packages/design-system/src/explorer/render/header.ts"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// packages/design-system/src/explorer/render/list.ts
+var init_list = __esm({
+  "packages/design-system/src/explorer/render/list.ts"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// packages/design-system/src/explorer/render/modal.ts
+var init_modal = __esm({
+  "packages/design-system/src/explorer/render/modal.ts"() {
+    "use strict";
+    init_theme();
+  }
+});
+
+// packages/design-system/src/explorer/render/index.ts
+var init_render2 = __esm({
+  "packages/design-system/src/explorer/render/index.ts"() {
+    "use strict";
+    init_layout2();
+    init_state3();
+    init_theme();
+    init_detail();
+    init_footer2();
+    init_header();
+    init_list();
+    init_modal();
+    init_detail();
+    init_footer2();
+    init_header();
+    init_list();
+    init_modal();
+  }
+});
+
+// packages/design-system/src/explorer/actions.ts
+var init_actions = __esm({
+  "packages/design-system/src/explorer/actions.ts"() {
+    "use strict";
+  }
+});
+
+// packages/design-system/src/explorer/filter.ts
+var init_filter = __esm({
+  "packages/design-system/src/explorer/filter.ts"() {
+    "use strict";
+  }
+});
+
+// packages/design-system/src/explorer/reducer.ts
+var init_reducer = __esm({
+  "packages/design-system/src/explorer/reducer.ts"() {
+    "use strict";
+    init_actions();
+    init_filter();
+    init_state3();
+  }
+});
+
+// packages/design-system/src/explorer/runtime.ts
+var init_runtime3 = __esm({
+  "packages/design-system/src/explorer/runtime.ts"() {
+    "use strict";
+    init_buffer();
+    init_terminal();
+    init_jobs2();
+    init_layout2();
+    init_render2();
+    init_reducer();
+    init_state3();
+  }
+});
+
+// packages/design-system/src/explorer/index.ts
+var init_explorer = __esm({
+  "packages/design-system/src/explorer/index.ts"() {
+    "use strict";
+    init_runtime3();
+    init_state3();
+    init_keymap2();
+  }
+});
+
 // packages/design-system/src/prompts/primitives/cancel.ts
 import chalk9 from "chalk";
 import { isCancel } from "@clack/prompts";
@@ -24936,7 +25242,7 @@ var init_prompts2 = __esm({
 });
 
 // packages/design-system/src/prompts/theme.ts
-var init_theme = __esm({
+var init_theme2 = __esm({
   "packages/design-system/src/prompts/theme.ts"() {
     "use strict";
     init_colors();
@@ -24983,9 +25289,11 @@ var init_src13 = __esm({
     init_acp();
     init_dashboard2();
     init_dashboard2();
+    init_explorer();
+    init_explorer();
     init_prompts2();
     init_prompts2();
-    init_theme();
+    init_theme2();
     init_static();
     init_static();
     init_terminal_markdown();
@@ -26680,8 +26988,8 @@ async function runServiceInstall(definition, context) {
     return true;
   }
   const platformSteps = filterStepsByPlatform(definition.steps, context.platform);
-  for (const step of platformSteps) {
-    await runInstallStep(step, context);
+  for (const step2 of platformSteps) {
+    await runInstallStep(step2, context);
   }
   await definition.check.run(checkContext);
   if (definition.postChecks) {
@@ -26694,8 +27002,8 @@ async function runServiceInstall(definition, context) {
   );
   return true;
 }
-function describeInstallCommand(step) {
-  return `[${step.id}] ${formatCommand(step.command, step.args)}`;
+function describeInstallCommand(step2) {
+  return `[${step2.id}] ${formatCommand(step2.command, step2.args)}`;
 }
 function formatCommand(command, args) {
   return [command, ...args.map(quoteIfNeeded)].join(" ");
@@ -26711,24 +27019,24 @@ function quoteIfNeeded(value) {
 }
 function filterStepsByPlatform(steps, platform) {
   return steps.filter(
-    (step) => !step.platforms || step.platforms.includes(platform)
+    (step2) => !step2.platforms || step2.platforms.includes(platform)
   );
 }
 function logInstallDryRun(definition, context) {
   context.logger(`Dry run: would install ${definition.summary}.`);
   const platformSteps = filterStepsByPlatform(definition.steps, context.platform);
-  for (const step of platformSteps) {
-    context.logger(`Dry run: ${describeInstallCommand(step)}`);
+  for (const step2 of platformSteps) {
+    context.logger(`Dry run: ${describeInstallCommand(step2)}`);
   }
 }
-async function runInstallStep(step, context) {
-  context.logger(`Running ${describeInstallCommand(step)}`);
-  const result = await context.runCommand(step.command, step.args);
+async function runInstallStep(step2, context) {
+  context.logger(`Running ${describeInstallCommand(step2)}`);
+  const result = await context.runCommand(step2.command, step2.args);
   if (result.exitCode !== 0) {
     const stderr = result.stderr.trim();
     const suffix = stderr.length > 0 ? `: ${stderr}` : "";
     throw new Error(
-      `${describeInstallCommand(step)} failed with exit code ${result.exitCode}${suffix}`
+      `${describeInstallCommand(step2)} failed with exit code ${result.exitCode}${suffix}`
     );
   }
 }
@@ -28562,9 +28870,15 @@ import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // packages/toolcraft/src/user-error.ts
 var UserError = class extends Error {
+  constructor(message2, options) {
+    super(message2, options);
+    this.name = "UserError";
+  }
+};
+var ToolcraftBugError = class extends Error {
   constructor(message2) {
     super(message2);
-    this.name = "UserError";
+    this.name = "ToolcraftBugError";
   }
 };
 
@@ -28625,22 +28939,33 @@ function Record(value) {
 function isOptionalSchema(schema) {
   return schema.kind === "optional";
 }
+function getRequiredKeys(schema) {
+  return Object.keys(schema.shape).filter((key2) => !isOptionalSchema(schema.shape[key2])).sort();
+}
 function getRequiredKeyFingerprint(schema) {
-  const requiredKeys = Object.keys(schema.shape).filter((key2) => !isOptionalSchema(schema.shape[key2])).sort();
-  return JSON.stringify(requiredKeys);
+  return getRequiredKeys(schema).join("+");
+}
+function assertUniqueRequiredKeyFingerprints(branches) {
+  const fingerprints = /* @__PURE__ */ new Map();
+  branches.forEach((branch, index) => {
+    const fingerprint = getRequiredKeyFingerprint(branch);
+    const indices = fingerprints.get(fingerprint) ?? [];
+    indices.push(index);
+    fingerprints.set(fingerprint, indices);
+  });
+  for (const [fingerprint, indices] of fingerprints) {
+    if (indices.length > 1) {
+      throw new Error(
+        `Union branches [${indices.join(", ")}] share required-key fingerprint "${fingerprint}". Each branch must require a distinct set of keys.`
+      );
+    }
+  }
 }
 function assertValidBranches2(branches) {
   if (branches.length === 0) {
     throw new Error("Union schema requires at least one branch");
   }
-  const fingerprints = /* @__PURE__ */ new Set();
-  for (const branch of branches) {
-    const fingerprint = getRequiredKeyFingerprint(branch);
-    if (fingerprints.has(fingerprint)) {
-      throw new Error("Union schema branches must have unique required-key fingerprints");
-    }
-    fingerprints.add(fingerprint);
-  }
+  assertUniqueRequiredKeyFingerprints(branches);
 }
 function Union(branches) {
   assertValidBranches2(branches);
@@ -28784,7 +29109,9 @@ function validateRenameMap(rename3) {
   const seenTargets = /* @__PURE__ */ new Map();
   for (const [upstreamName, targetPath] of Object.entries(rename3)) {
     if (targetPath.length === 0) {
-      throw new UserError(`Invalid rename target for upstream tool "${upstreamName}": path cannot be empty.`);
+      throw new UserError(
+        `Invalid rename target for upstream tool "${upstreamName}": path cannot be empty.`
+      );
     }
     if (targetPath.split(".").some((segment) => segment.length === 0)) {
       throw new UserError(
@@ -28994,16 +29321,20 @@ function mergeInheritedMetadata(group, inherited) {
 function materializeGroup(group, inherited) {
   const internal = getInternalGroupConfig(group);
   const mergedInherited = mergeInheritedMetadata(internal, inherited);
-  const materializedChildren = internal.children.map((child) => materializeNode(child, mergedInherited));
+  const materializedChildren = internal.children.map(
+    (child) => materializeNode(child, mergedInherited)
+  );
   let defaultChild;
   if (internal.default !== void 0) {
     const defaultIndex = internal.children.indexOf(internal.default);
     if (defaultIndex === -1) {
-      throw new UserError(`Default command "${internal.default.name}" must be listed in children.`);
+      throw new ToolcraftBugError(
+        `Default command "${internal.default.name}" must be listed in children.`
+      );
     }
     const resolvedDefault = materializedChildren[defaultIndex];
     if (resolvedDefault?.kind !== "command") {
-      throw new UserError(`Default child "${internal.default.name}" must be a command.`);
+      throw new ToolcraftBugError(`Default child "${internal.default.name}" must be a command.`);
     }
     defaultChild = resolvedDefault;
   }
@@ -29042,12 +29373,15 @@ function materializeNode(node, inherited) {
 }
 function defineCommand(config) {
   validateHumanInLoopOnDefine(config);
-  return materializeCommand(createBaseCommand(config), {
-    scope: void 0,
-    humanInLoop: void 0,
-    secrets: {},
-    requires: void 0
-  });
+  return materializeCommand(
+    createBaseCommand(config),
+    {
+      scope: void 0,
+      humanInLoop: void 0,
+      secrets: {},
+      requires: void 0
+    }
+  );
 }
 function defineGroup(config) {
   validateRenameMap(config.rename);