@allternit/gizzi-code 1.0.0 → 1.0.1

package/src/commands.ts

@@ -0,0 +1,209 @@
+/**
+ * Command registry and execution
+ */
+
+import { log } from './runtime/util/log.js'
+
+export interface Command {
+  name: string
+  description: string
+  aliases?: string[]
+  args?: CommandArg[]
+  options?: CommandOption[]
+  handler: (ctx: CommandContext) => Promise<void> | void
+  hidden?: boolean
+  requiresAuth?: boolean
+}
+
+export interface CommandArg {
+  name: string
+  description: string
+  required?: boolean
+  default?: string
+}
+
+export interface CommandOption {
+  name: string
+  alias?: string
+  description: string
+  type?: 'string' | 'number' | 'boolean'
+  default?: unknown
+}
+
+export interface CommandContext {
+  args: string[]
+  options: Record<string, unknown>
+  flags: Record<string, boolean>
+  cwd: string
+  sessionId?: string
+}
+
+// Command registry
+const commands = new Map<string, Command>()
+const aliases = new Map<string, string>()
+
+export function registerCommand(command: Command): void {
+  if (commands.has(command.name)) {
+    log('warn', `Command ${command.name} already registered, overwriting`)
+  }
+  
+  commands.set(command.name, command)
+  
+  // Register aliases
+  command.aliases?.forEach(alias => {
+    if (aliases.has(alias)) {
+      log('warn', `Alias ${alias} already registered`)
+    }
+    aliases.set(alias, command.name)
+  })
+  
+  log('debug', `Registered command: ${command.name}`)
+}
+
+export function unregisterCommand(name: string): void {
+  const cmd = commands.get(name)
+  if (cmd) {
+    cmd.aliases?.forEach(alias => aliases.delete(alias))
+    commands.delete(name)
+  }
+}
+
+export function getCommand(name: string): Command | undefined {
+  // Check direct match
+  const direct = commands.get(name)
+  if (direct) return direct
+  
+  // Check alias
+  const aliased = aliases.get(name)
+  if (aliased) return commands.get(aliased)
+  
+  return undefined
+}
+
+export function getAllCommands(): Command[] {
+  return Array.from(commands.values())
+}
+
+export function getVisibleCommands(): Command[] {
+  return getAllCommands().filter(cmd => !cmd.hidden)
+}
+
+export function hasCommand(name: string): boolean {
+  return commands.has(name) || aliases.has(name)
+}
+
+// Command execution
+export async function executeCommand(
+  name: string,
+  ctx: Partial<CommandContext> = {}
+): Promise<void> {
+  const command = getCommand(name)
+  
+  if (!command) {
+    throw new Error(`Unknown command: ${name}`)
+  }
+  
+  const fullContext: CommandContext = {
+    args: ctx.args || [],
+    options: ctx.options || {},
+    flags: ctx.flags || {},
+    cwd: ctx.cwd || process.cwd(),
+    sessionId: ctx.sessionId,
+  }
+  
+  log('info', `Executing command: ${name}`, { args: fullContext.args })
+  
+  try {
+    await command.handler(fullContext)
+  } catch (error) {
+    log('error', `Command ${name} failed`, error)
+    throw error
+  }
+}
+
+// Command parsing
+export function parseCommandLine(argv: string[]): {
+  command: string
+  args: string[]
+  options: Record<string, unknown>
+  flags: Record<string, boolean>
+} {
+  const [command, ...rest] = argv
+  const args: string[] = []
+  const options: Record<string, unknown> = {}
+  const flags: Record<string, boolean> = {}
+  
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i]
+    
+    if (arg.startsWith('--')) {
+      const [key, value] = arg.slice(2).split('=', 2)
+      if (value !== undefined) {
+        options[key] = value
+      } else if (i + 1 < rest.length && !rest[i + 1].startsWith('-')) {
+        options[key] = rest[++i]
+      } else {
+        flags[key] = true
+      }
+    } else if (arg.startsWith('-') && arg.length > 1) {
+      const flag = arg.slice(1)
+      flags[flag] = true
+    } else {
+      args.push(arg)
+    }
+  }
+  
+  return { command, args, options, flags }
+}
+
+// Help generation
+export function generateHelp(command?: Command): string {
+  if (command) {
+    let help = `${command.name}`
+    
+    if (command.aliases?.length) {
+      help += ` (${command.aliases.join(', ')})`
+    }
+    
+    help += `\n\n${command.description}\n`
+    
+    if (command.args?.length) {
+      help += '\nArguments:\n'
+      command.args.forEach(arg => {
+        const req = arg.required ? '' : ' (optional)'
+        help += `  ${arg.name}${req} - ${arg.description}\n`
+      })
+    }
+    
+    if (command.options?.length) {
+      help += '\nOptions:\n'
+      command.options.forEach(opt => {
+        const alias = opt.alias ? `-${opt.alias}, ` : ''
+        help += `  ${alias}--${opt.name} - ${opt.description}\n`
+      })
+    }
+    
+    return help
+  }
+  
+  // General help
+  let help = 'Available commands:\n\n'
+  getVisibleCommands().forEach(cmd => {
+    help += `  ${cmd.name.padEnd(20)} ${cmd.description}\n`
+  })
+  
+  return help
+}
+
+// Default export
+export default {
+  registerCommand,
+  unregisterCommand,
+  getCommand,
+  getAllCommands,
+  getVisibleCommands,
+  hasCommand,
+  executeCommand,
+  parseCommandLine,
+  generateHelp,
+}

package/src/context/QueuedMessageContext.tsx

@@ -0,0 +1,63 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { Box } from '@/ink.js';
+type QueuedMessageContextValue = {
+  isQueued: boolean;
+  isFirst: boolean;
+  /** Width reduction for container padding (e.g., 4 for paddingX={2}) */
+  paddingWidth: number;
+};
+const QueuedMessageContext = React.createContext<QueuedMessageContextValue | undefined>(undefined);
+export function useQueuedMessage() {
+  return React.useContext(QueuedMessageContext);
+}
+const PADDING_X = 2;
+type Props = {
+  isFirst: boolean;
+  useBriefLayout?: boolean;
+  children: React.ReactNode;
+};
+export function QueuedMessageProvider(t0) {
+  const $ = _c(9);
+  const {
+    isFirst,
+    useBriefLayout,
+    children
+  } = t0;
+  const padding = useBriefLayout ? 0 : PADDING_X;
+  const t1 = padding * 2;
+  let t2;
+  if ($[0] !== isFirst || $[1] !== t1) {
+    t2 = {
+      isQueued: true,
+      isFirst,
+      paddingWidth: t1
+    };
+    $[0] = isFirst;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const value = t2;
+  let t3;
+  if ($[3] !== children || $[4] !== padding) {
+    t3 = <Box paddingX={padding}>{children}</Box>;
+    $[3] = children;
+    $[4] = padding;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] !== t3 || $[7] !== value) {
+    t4 = <QueuedMessageContext.Provider value={value}>{t3}</QueuedMessageContext.Provider>;
+    $[6] = t3;
+    $[7] = value;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  return t4;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/context/fpsMetrics.tsx

@@ -0,0 +1,30 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useContext } from 'react';
+import type { FpsMetrics } from '../utils/fpsTracker.js';
+type FpsMetricsGetter = () => FpsMetrics | undefined;
+const FpsMetricsContext = createContext<FpsMetricsGetter | undefined>(undefined);
+type Props = {
+  getFpsMetrics: FpsMetricsGetter;
+  children: React.ReactNode;
+};
+export function FpsMetricsProvider(t0) {
+  const $ = _c(3);
+  const {
+    getFpsMetrics,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== children || $[1] !== getFpsMetrics) {
+    t1 = <FpsMetricsContext.Provider value={getFpsMetrics}>{children}</FpsMetricsContext.Provider>;
+    $[0] = children;
+    $[1] = getFpsMetrics;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+export function useFpsMetrics() {
+  return useContext(FpsMetricsContext);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsImNyZWF0ZUNvbnRleHQiLCJ1c2VDb250ZXh0IiwiRnBzTWV0cmljcyIsIkZwc01ldHJpY3NHZXR0ZXIiLCJGcHNNZXRyaWNzQ29udGV4dCIsInVuZGVmaW5lZCIsIlByb3BzIiwiZ2V0RnBzTWV0cmljcyIsImNoaWxkcmVuIiwiUmVhY3ROb2RlIiwiRnBzTWV0cmljc1Byb3ZpZGVyIiwidDAiLCIkIiwiX2MiLCJ0MSIsInVzZUZwc01ldHJpY3MiXSwic291cmNlcyI6WyJmcHNNZXRyaWNzLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QsIHsgY3JlYXRlQ29udGV4dCwgdXNlQ29udGV4dCB9IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHR5cGUgeyBGcHNNZXRyaWNzIH0gZnJvbSAnLi4vdXRpbHMvZnBzVHJhY2tlci5qcydcblxudHlwZSBGcHNNZXRyaWNzR2V0dGVyID0gKCkgPT4gRnBzTWV0cmljcyB8IHVuZGVmaW5lZFxuXG5jb25zdCBGcHNNZXRyaWNzQ29udGV4dCA9IGNyZWF0ZUNvbnRleHQ8RnBzTWV0cmljc0dldHRlciB8IHVuZGVmaW5lZD4odW5kZWZpbmVkKVxuXG50eXBlIFByb3BzID0ge1xuICBnZXRGcHNNZXRyaWNzOiBGcHNNZXRyaWNzR2V0dGVyXG4gIGNoaWxkcmVuOiBSZWFjdC5SZWFjdE5vZGVcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIEZwc01ldHJpY3NQcm92aWRlcih7XG4gIGdldEZwc01ldHJpY3MsXG4gIGNoaWxkcmVuLFxufTogUHJvcHMpOiBSZWFjdC5SZWFjdE5vZGUge1xuICByZXR1cm4gKFxuICAgIDxGcHNNZXRyaWNzQ29udGV4dC5Qcm92aWRlciB2YWx1ZT17Z2V0RnBzTWV0cmljc30+XG4gICAgICB7Y2hpbGRyZW59XG4gICAgPC9GcHNNZXRyaWNzQ29udGV4dC5Qcm92aWRlcj5cbiAgKVxufVxuXG5leHBvcnQgZnVuY3Rpb24gdXNlRnBzTWV0cmljcygpOiBGcHNNZXRyaWNzR2V0dGVyIHwgdW5kZWZpbmVkIHtcbiAgcmV0dXJuIHVzZUNvbnRleHQoRnBzTWV0cmljc0NvbnRleHQpXG59XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPQSxLQUFLLElBQUlDLGFBQWEsRUFBRUMsVUFBVSxRQUFRLE9BQU87QUFDeEQsY0FBY0MsVUFBVSxRQUFRLHdCQUF3QjtBQUV4RCxLQUFLQyxnQkFBZ0IsR0FBRyxHQUFHLEdBQUdELFVBQVUsR0FBRyxTQUFTO0FBRXBELE1BQU1FLGlCQUFpQixHQUFHSixhQUFhLENBQUNHLGdCQUFnQixHQUFHLFNBQVMsQ0FBQyxDQUFDRSxTQUFTLENBQUM7QUFFaEYsS0FBS0MsS0FBSyxHQUFHO0VBQ1hDLGFBQWEsRUFBRUosZ0JBQWdCO0VBQy9CSyxRQUFRLEVBQUVULEtBQUssQ0FBQ1UsU0FBUztBQUMzQixDQUFDO0FBRUQsT0FBTyxTQUFBQyxtQkFBQUMsRUFBQTtFQUFBLE1BQUFDLENBQUEsR0FBQUMsRUFBQTtFQUE0QjtJQUFBTixhQUFBO0lBQUFDO0VBQUEsSUFBQUcsRUFHM0I7RUFBQSxJQUFBRyxFQUFBO0VBQUEsSUFBQUYsQ0FBQSxRQUFBSixRQUFBLElBQUFJLENBQUEsUUFBQUwsYUFBQTtJQUVKTyxFQUFBLCtCQUFtQ1AsS0FBYSxDQUFiQSxjQUFZLENBQUMsQ0FDN0NDLFNBQU8sQ0FDViw2QkFBNkI7SUFBQUksQ0FBQSxNQUFBSixRQUFBO0lBQUFJLENBQUEsTUFBQUwsYUFBQTtJQUFBSyxDQUFBLE1BQUFFLEVBQUE7RUFBQTtJQUFBQSxFQUFBLEdBQUFGLENBQUE7RUFBQTtFQUFBLE9BRjdCRSxFQUU2QjtBQUFBO0FBSWpDLE9BQU8sU0FBQUMsY0FBQTtFQUFBLE9BQ0VkLFVBQVUsQ0FBQ0csaUJBQWlCLENBQUM7QUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/src/context/mailbox.tsx

@@ -0,0 +1,38 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useContext, useMemo } from 'react';
+import { Mailbox } from '../utils/mailbox.js';
+const MailboxContext = createContext<Mailbox | undefined>(undefined);
+type Props = {
+  children: React.ReactNode;
+};
+export function MailboxProvider(t0) {
+  const $ = _c(3);
+  const {
+    children
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = new Mailbox();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const mailbox = t1;
+  let t2;
+  if ($[1] !== children) {
+    t2 = <MailboxContext.Provider value={mailbox}>{children}</MailboxContext.Provider>;
+    $[1] = children;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  return t2;
+}
+export function useMailbox() {
+  const mailbox = useContext(MailboxContext);
+  if (!mailbox) {
+    throw new Error("useMailbox must be used within a MailboxProvider");
+  }
+  return mailbox;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsImNyZWF0ZUNvbnRleHQiLCJ1c2VDb250ZXh0IiwidXNlTWVtbyIsIk1haWxib3giLCJNYWlsYm94Q29udGV4dCIsInVuZGVmaW5lZCIsIlByb3BzIiwiY2hpbGRyZW4iLCJSZWFjdE5vZGUiLCJNYWlsYm94UHJvdmlkZXIiLCJ0MCIsIiQiLCJfYyIsInQxIiwiU3ltYm9sIiwiZm9yIiwibWFpbGJveCIsInQyIiwidXNlTWFpbGJveCIsIkVycm9yIl0sInNvdXJjZXMiOlsibWFpbGJveC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0LCB7IGNyZWF0ZUNvbnRleHQsIHVzZUNvbnRleHQsIHVzZU1lbW8gfSBmcm9tICdyZWFjdCdcbmltcG9ydCB7IE1haWxib3ggfSBmcm9tICcuLi91dGlscy9tYWlsYm94LmpzJ1xuXG5jb25zdCBNYWlsYm94Q29udGV4dCA9IGNyZWF0ZUNvbnRleHQ8TWFpbGJveCB8IHVuZGVmaW5lZD4odW5kZWZpbmVkKVxuXG50eXBlIFByb3BzID0ge1xuICBjaGlsZHJlbjogUmVhY3QuUmVhY3ROb2RlXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBNYWlsYm94UHJvdmlkZXIoeyBjaGlsZHJlbiB9OiBQcm9wcyk6IFJlYWN0LlJlYWN0Tm9kZSB7XG4gIGNvbnN0IG1haWxib3ggPSB1c2VNZW1vKCgpID0+IG5ldyBNYWlsYm94KCksIFtdKVxuICByZXR1cm4gKFxuICAgIDxNYWlsYm94Q29udGV4dC5Qcm92aWRlciB2YWx1ZT17bWFpbGJveH0+XG4gICAgICB7Y2hpbGRyZW59XG4gICAgPC9NYWlsYm94Q29udGV4dC5Qcm92aWRlcj5cbiAgKVxufVxuXG5leHBvcnQgZnVuY3Rpb24gdXNlTWFpbGJveCgpOiBNYWlsYm94IHtcbiAgY29uc3QgbWFpbGJveCA9IHVzZUNvbnRleHQoTWFpbGJveENvbnRleHQpXG4gIGlmICghbWFpbGJveCkge1xuICAgIHRocm93IG5ldyBFcnJvcigndXNlTWFpbGJveCBtdXN0IGJlIHVzZWQgd2l0aGluIGEgTWFpbGJveFByb3ZpZGVyJylcbiAgfVxuICByZXR1cm4gbWFpbGJveFxufVxuIl0sIm1hcHBpbmdzIjoiO0FBQUEsT0FBT0EsS0FBSyxJQUFJQyxhQUFhLEVBQUVDLFVBQVUsRUFBRUMsT0FBTyxRQUFRLE9BQU87QUFDakUsU0FBU0MsT0FBTyxRQUFRLHFCQUFxQjtBQUU3QyxNQUFNQyxjQUFjLEdBQUdKLGFBQWEsQ0FBQ0csT0FBTyxHQUFHLFNBQVMsQ0FBQyxDQUFDRSxTQUFTLENBQUM7QUFFcEUsS0FBS0MsS0FBSyxHQUFHO0VBQ1hDLFFBQVEsRUFBRVIsS0FBSyxDQUFDUyxTQUFTO0FBQzNCLENBQUM7QUFFRCxPQUFPLFNBQUFDLGdCQUFBQyxFQUFBO0VBQUEsTUFBQUMsQ0FBQSxHQUFBQyxFQUFBO0VBQXlCO0lBQUFMO0VBQUEsSUFBQUcsRUFBbUI7RUFBQSxJQUFBRyxFQUFBO0VBQUEsSUFBQUYsQ0FBQSxRQUFBRyxNQUFBLENBQUFDLEdBQUE7SUFDbkJGLEVBQUEsT0FBSVYsT0FBTyxDQUFDLENBQUM7SUFBQVEsQ0FBQSxNQUFBRSxFQUFBO0VBQUE7SUFBQUEsRUFBQSxHQUFBRixDQUFBO0VBQUE7RUFBM0MsTUFBQUssT0FBQSxHQUE4QkgsRUFBYTtFQUFLLElBQUFJLEVBQUE7RUFBQSxJQUFBTixDQUFBLFFBQUFKLFFBQUE7SUFFOUNVLEVBQUEsNEJBQWdDRCxLQUFPLENBQVBBLFFBQU0sQ0FBQyxDQUNwQ1QsU0FBTyxDQUNWLDBCQUEwQjtJQUFBSSxDQUFBLE1BQUFKLFFBQUE7SUFBQUksQ0FBQSxNQUFBTSxFQUFBO0VBQUE7SUFBQUEsRUFBQSxHQUFBTixDQUFBO0VBQUE7RUFBQSxPQUYxQk0sRUFFMEI7QUFBQTtBQUk5QixPQUFPLFNBQUFDLFdBQUE7RUFDTCxNQUFBRixPQUFBLEdBQWdCZixVQUFVLENBQUNHLGNBQWMsQ0FBQztFQUMxQyxJQUFJLENBQUNZLE9BQU87SUFDVixNQUFNLElBQUlHLEtBQUssQ0FBQyxrREFBa0QsQ0FBQztFQUFBO0VBQ3BFLE9BQ01ILE9BQU87QUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/src/context/modalContext.tsx

@@ -0,0 +1,58 @@
+import { c as _c } from "react/compiler-runtime";
+import { createContext, type RefObject, useContext } from 'react';
+import type { ScrollBoxHandle } from '@/ink/components/ScrollBox.js';
+
+/**
+ * Set by FullscreenLayout when rendering content in its `modal` slot —
+ * the absolute-positioned bottom-anchored pane for slash-command dialogs.
+ * Consumers use this to:
+ *
+ * - Suppress top-level framing — `Pane` skips its full-terminal-width
+ *   `Divider` (FullscreenLayout already draws the ▔ divider).
+ * - Size Select pagination to the available rows — the modal's inner
+ *   area is smaller than the terminal (rows minus transcript peek minus
+ *   divider), so components that cap their visible option count from
+ *   `useTerminalSize().rows` would overflow without this context.
+ * - Reset scroll on tab switch — Tabs keys its ScrollBox by
+ *   `selectedTabIndex`, remounting on tab switch so scrollTop resets to 0
+ *   without scrollTo() timing games.
+ *
+ * null = not inside the modal slot.
+ */
+type ModalCtx = {
+  rows: number;
+  columns: number;
+  scrollRef: RefObject<ScrollBoxHandle | null> | null;
+};
+export const ModalContext = createContext<ModalCtx | null>(null);
+export function useIsInsideModal() {
+  return useContext(ModalContext) !== null;
+}
+
+/**
+ * Available content rows/columns when inside a Modal, else falls back to
+ * the provided terminal size. Use instead of `useTerminalSize()` when a
+ * component caps its visible content height — the modal's inner area is
+ * smaller than the terminal.
+ */
+export function useModalOrTerminalSize(fallback: { rows: number; columns: number }) {
+  const $ = _c(3);
+  const ctx = useContext(ModalContext);
+  let t0;
+  if ($[0] !== ctx || $[1] !== fallback) {
+    t0 = ctx ? {
+      rows: ctx.rows,
+      columns: ctx.columns
+    } : fallback;
+    $[0] = ctx;
+    $[1] = fallback;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+export function useModalScrollRef() {
+  return useContext(ModalContext)?.scrollRef ?? null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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