ashishcode 0.1.0

package/src/utils/execFileNoThrow.ts

@@ -0,0 +1,150 @@
+// This file represents useful wrappers over node:child_process
+// These wrappers ease error handling and cross-platform compatbility
+// By using execa, Windows automatically gets shell escaping + BAT / CMD handling
+
+import { type ExecaError, execa } from 'execa'
+import { getCwd } from '../utils/cwd.js'
+import { logError } from './log.js'
+
+export { execSyncWithDefaults_DEPRECATED } from './execFileNoThrowPortable.js'
+
+const MS_IN_SECOND = 1000
+const SECONDS_IN_MINUTE = 60
+
+type ExecFileOptions = {
+  abortSignal?: AbortSignal
+  timeout?: number
+  preserveOutputOnError?: boolean
+  // Setting useCwd=false avoids circular dependencies during initialization
+  // getCwd() -> PersistentShell -> logEvent() -> execFileNoThrow
+  useCwd?: boolean
+  env?: NodeJS.ProcessEnv
+  stdin?: 'ignore' | 'inherit' | 'pipe'
+  input?: string
+}
+
+export function execFileNoThrow(
+  file: string,
+  args: string[],
+  options: ExecFileOptions = {
+    timeout: 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    preserveOutputOnError: true,
+    useCwd: true,
+  },
+): Promise<{ stdout: string; stderr: string; code: number; error?: string }> {
+  return execFileNoThrowWithCwd(file, args, {
+    abortSignal: options.abortSignal,
+    timeout: options.timeout,
+    preserveOutputOnError: options.preserveOutputOnError,
+    cwd: options.useCwd ? getCwd() : undefined,
+    env: options.env,
+    stdin: options.stdin,
+    input: options.input,
+  })
+}
+
+type ExecFileWithCwdOptions = {
+  abortSignal?: AbortSignal
+  timeout?: number
+  preserveOutputOnError?: boolean
+  maxBuffer?: number
+  cwd?: string
+  env?: NodeJS.ProcessEnv
+  shell?: boolean | string | undefined
+  stdin?: 'ignore' | 'inherit' | 'pipe'
+  input?: string
+}
+
+type ExecaResultWithError = {
+  shortMessage?: string
+  signal?: string
+}
+
+/**
+ * Extracts a human-readable error message from an execa result.
+ *
+ * Priority order:
+ * 1. shortMessage - execa's human-readable error (e.g., "Command failed with exit code 1: ...")
+ *    This is preferred because it already includes signal info when a process is killed,
+ *    making it more informative than just the signal name.
+ * 2. signal - the signal that killed the process (e.g., "SIGTERM")
+ * 3. errorCode - fallback to just the numeric exit code
+ */
+function getErrorMessage(
+  result: ExecaResultWithError,
+  errorCode: number,
+): string {
+  if (result.shortMessage) {
+    return result.shortMessage
+  }
+  if (typeof result.signal === 'string') {
+    return result.signal
+  }
+  return String(errorCode)
+}
+
+/**
+ * execFile, but always resolves (never throws)
+ */
+export function execFileNoThrowWithCwd(
+  file: string,
+  args: string[],
+  {
+    abortSignal,
+    timeout: finalTimeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    preserveOutputOnError: finalPreserveOutput = true,
+    cwd: finalCwd,
+    env: finalEnv,
+    maxBuffer,
+    shell,
+    stdin: finalStdin,
+    input: finalInput,
+  }: ExecFileWithCwdOptions = {
+    timeout: 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    preserveOutputOnError: true,
+    maxBuffer: 1_000_000,
+  },
+): Promise<{ stdout: string; stderr: string; code: number; error?: string }> {
+  return new Promise(resolve => {
+    // Use execa for cross-platform .bat/.cmd compatibility on Windows
+    execa(file, args, {
+      maxBuffer,
+      signal: abortSignal,
+      timeout: finalTimeout,
+      cwd: finalCwd,
+      env: finalEnv,
+      shell,
+      stdin: finalStdin,
+      input: finalInput,
+      reject: false, // Don't throw on non-zero exit codes
+    })
+      .then(result => {
+        if (result.failed) {
+          if (finalPreserveOutput) {
+            const errorCode = result.exitCode ?? 1
+            void resolve({
+              stdout: result.stdout || '',
+              stderr: result.stderr || '',
+              code: errorCode,
+              error: getErrorMessage(
+                result as unknown as ExecaResultWithError,
+                errorCode,
+              ),
+            })
+          } else {
+            void resolve({ stdout: '', stderr: '', code: result.exitCode ?? 1 })
+          }
+        } else {
+          void resolve({
+            stdout: result.stdout,
+            stderr: result.stderr,
+            code: 0,
+          })
+        }
+      })
+      .catch((error: ExecaError) => {
+        logError(error)
+        void resolve({ stdout: '', stderr: '', code: 1 })
+      })
+  })
+}

package/src/utils/execFileNoThrowPortable.ts

@@ -0,0 +1,89 @@
+import { type Options as ExecaOptions, execaSync } from 'execa'
+import { getCwd } from '../utils/cwd.js'
+import { slowLogging } from './slowOperations.js'
+
+const MS_IN_SECOND = 1000
+const SECONDS_IN_MINUTE = 60
+
+type ExecSyncOptions = {
+  abortSignal?: AbortSignal
+  timeout?: number
+  input?: string
+  stdio?: ExecaOptions['stdio']
+}
+
+/**
+ * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
+ * Sync exec calls block the event loop and cause performance issues.
+ */
+export function execSyncWithDefaults_DEPRECATED(command: string): string | null
+/**
+ * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
+ * Sync exec calls block the event loop and cause performance issues.
+ */
+export function execSyncWithDefaults_DEPRECATED(
+  command: string,
+  options: ExecSyncOptions,
+): string | null
+/**
+ * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
+ * Sync exec calls block the event loop and cause performance issues.
+ */
+export function execSyncWithDefaults_DEPRECATED(
+  command: string,
+  abortSignal: AbortSignal,
+  timeout?: number,
+): string | null
+/**
+ * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
+ * Sync exec calls block the event loop and cause performance issues.
+ */
+export function execSyncWithDefaults_DEPRECATED(
+  command: string,
+  optionsOrAbortSignal?: ExecSyncOptions | AbortSignal,
+  timeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+): string | null {
+  let options: ExecSyncOptions
+
+  if (optionsOrAbortSignal === undefined) {
+    // No second argument - use defaults
+    options = {}
+  } else if (optionsOrAbortSignal instanceof AbortSignal) {
+    // Old signature - second argument is AbortSignal
+    options = {
+      abortSignal: optionsOrAbortSignal,
+      timeout,
+    }
+  } else {
+    // New signature - second argument is options object
+    options = optionsOrAbortSignal
+  }
+
+  const {
+    abortSignal,
+    timeout: finalTimeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+    input,
+    stdio = ['ignore', 'pipe', 'pipe'],
+  } = options
+
+  abortSignal?.throwIfAborted()
+  using _ = slowLogging`exec: ${command.slice(0, 200)}`
+  try {
+    const result = execaSync(command, {
+      env: process.env,
+      maxBuffer: 1_000_000,
+      timeout: finalTimeout,
+      cwd: getCwd(),
+      stdio,
+      shell: true, // execSync typically runs shell commands
+      reject: false, // Don't throw on non-zero exit codes
+      input,
+    })
+    if (!result.stdout) {
+      return null
+    }
+    return result.stdout.trim() || null
+  } catch {
+    return null
+  }
+}

package/src/utils/execSyncWrapper.ts

@@ -0,0 +1,38 @@
+import {
+  type ExecSyncOptions,
+  type ExecSyncOptionsWithBufferEncoding,
+  type ExecSyncOptionsWithStringEncoding,
+  execSync as nodeExecSync,
+} from 'child_process'
+import { slowLogging } from './slowOperations.js'
+
+/**
+ * @deprecated Use async alternatives when possible. Sync exec calls block the event loop.
+ *
+ * Wrapped execSync with slow operation logging.
+ * Use this instead of child_process execSync directly to detect performance issues.
+ *
+ * @example
+ * import { execSync_DEPRECATED } from './execSyncWrapper.js'
+ * const result = execSync_DEPRECATED('git status', { encoding: 'utf8' })
+ */
+export function execSync_DEPRECATED(command: string): Buffer
+export function execSync_DEPRECATED(
+  command: string,
+  options: ExecSyncOptionsWithStringEncoding,
+): string
+export function execSync_DEPRECATED(
+  command: string,
+  options: ExecSyncOptionsWithBufferEncoding,
+): Buffer
+export function execSync_DEPRECATED(
+  command: string,
+  options?: ExecSyncOptions,
+): Buffer | string
+export function execSync_DEPRECATED(
+  command: string,
+  options?: ExecSyncOptions,
+): Buffer | string {
+  using _ = slowLogging`execSync: ${command.slice(0, 100)}`
+  return nodeExecSync(command, options)
+}

package/src/utils/exportRenderer.tsx

@@ -0,0 +1,98 @@
+import React, { useRef } from 'react';
+import stripAnsi from 'strip-ansi';
+import { Messages } from '../components/Messages.js';
+import { KeybindingProvider } from '../keybindings/KeybindingContext.js';
+import { loadKeybindingsSyncWithWarnings } from '../keybindings/loadUserBindings.js';
+import type { KeybindingContextName } from '../keybindings/types.js';
+import { AppStateProvider } from '../state/AppState.js';
+import type { Tools } from '../Tool.js';
+import type { Message } from '../types/message.js';
+import { renderToAnsiString } from './staticRender.js';
+
+/**
+ * Minimal keybinding provider for static/headless renders.
+ * Provides keybinding context without the ChordInterceptor (which uses useInput
+ * and would hang in headless renders with no stdin).
+ */
+function StaticKeybindingProvider({
+  children
+}: {
+  children: React.ReactNode;
+}): React.ReactNode {
+  const {
+    bindings
+  } = loadKeybindingsSyncWithWarnings();
+  const pendingChordRef = useRef(null);
+  const handlerRegistryRef = useRef(new Map());
+  const activeContexts = useRef(new Set<KeybindingContextName>()).current;
+  return <KeybindingProvider bindings={bindings} pendingChordRef={pendingChordRef} pendingChord={null} setPendingChord={() => {}} activeContexts={activeContexts} registerActiveContext={() => {}} unregisterActiveContext={() => {}} handlerRegistryRef={handlerRegistryRef}>
+      {children}
+    </KeybindingProvider>;
+}
+
+// Upper-bound how many NormalizedMessages a Message can produce.
+// normalizeMessages splits one Message with N content blocks into N
+// NormalizedMessages — 1:1 with block count. String content = 1 block.
+// AttachmentMessage etc. have no .message and normalize to ≤1.
+function normalizedUpperBound(m: Message): number {
+  if (!('message' in m)) return 1;
+  const c = m.message.content;
+  return Array.isArray(c) ? c.length : 1;
+}
+
+/**
+ * Streams rendered messages in chunks, ANSI codes preserved. Each chunk is a
+ * fresh renderToAnsiString — yoga layout tree + Ink's screen buffer are sized
+ * to the tallest CHUNK instead of the full session. Measured (Mar 2026,
+ * 538-msg session): −55% plateau RSS vs a single full render. The sink owns
+ * the output — write to stdout for `[` dump-to-scrollback, appendFile for `v`.
+ *
+ * Messages.renderRange slices AFTER normalize→group→collapse, so tool-call
+ * grouping stays correct across chunk seams; buildMessageLookups runs on
+ * the full normalized array so tool_use↔tool_result resolves regardless of
+ * which chunk each landed in.
+ */
+export async function streamRenderedMessages(messages: Message[], tools: Tools, sink: (ansiChunk: string) => void | Promise<void>, {
+  columns,
+  verbose = false,
+  chunkSize = 40,
+  onProgress
+}: {
+  columns?: number;
+  verbose?: boolean;
+  chunkSize?: number;
+  onProgress?: (rendered: number) => void;
+} = {}): Promise<void> {
+  const renderChunk = (range: readonly [number, number]) => renderToAnsiString(<AppStateProvider>
+        <StaticKeybindingProvider>
+          <Messages messages={messages} tools={tools} commands={[]} verbose={verbose} toolJSX={null} toolUseConfirmQueue={[]} inProgressToolUseIDs={new Set()} isMessageSelectorVisible={false} conversationId="export" screen="prompt" streamingToolUses={[]} showAllInTranscript={true} isLoading={false} renderRange={range} />
+        </StaticKeybindingProvider>
+      </AppStateProvider>, columns);
+
+  // renderRange indexes into the post-collapse array whose length we can't
+  // see from here — normalize splits each Message into one NormalizedMessage
+  // per content block (unbounded per message), collapse merges some back.
+  // Ceiling is the exact normalize output count + chunkSize so the loop
+  // always reaches the empty slice where break fires (collapse only shrinks).
+  let ceiling = chunkSize;
+  for (const m of messages) ceiling += normalizedUpperBound(m);
+  for (let offset = 0; offset < ceiling; offset += chunkSize) {
+    const ansi = await renderChunk([offset, offset + chunkSize]);
+    if (stripAnsi(ansi).trim() === '') break;
+    await sink(ansi);
+    onProgress?.(offset + chunkSize);
+  }
+}
+
+/**
+ * Renders messages to a plain text string suitable for export.
+ * Uses the same React rendering logic as the interactive UI.
+ */
+export async function renderMessagesToPlainText(messages: Message[], tools: Tools = [], columns?: number): Promise<string> {
+  const parts: string[] = [];
+  await streamRenderedMessages(messages, tools, chunk => void parts.push(stripAnsi(chunk)), {
+    columns
+  });
+  return parts.join('');
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useRef","stripAnsi","Messages","KeybindingProvider","loadKeybindingsSyncWithWarnings","KeybindingContextName","AppStateProvider","Tools","Message","renderToAnsiString","StaticKeybindingProvider","children","ReactNode","bindings","pendingChordRef","handlerRegistryRef","Map","activeContexts","Set","current","normalizedUpperBound","m","c","message","content","Array","isArray","length","streamRenderedMessages","messages","tools","sink","ansiChunk","Promise","columns","verbose","chunkSize","onProgress","rendered","renderChunk","range","ceiling","offset","ansi","trim","renderMessagesToPlainText","parts","chunk","push","join"],"sources":["exportRenderer.tsx"],"sourcesContent":["import React, { useRef } from 'react'\nimport stripAnsi from 'strip-ansi'\nimport { Messages } from '../components/Messages.js'\nimport { KeybindingProvider } from '../keybindings/KeybindingContext.js'\nimport { loadKeybindingsSyncWithWarnings } from '../keybindings/loadUserBindings.js'\nimport type { KeybindingContextName } from '../keybindings/types.js'\nimport { AppStateProvider } from '../state/AppState.js'\nimport type { Tools } from '../Tool.js'\nimport type { Message } from '../types/message.js'\nimport { renderToAnsiString } from './staticRender.js'\n\n/**\n * Minimal keybinding provider for static/headless renders.\n * Provides keybinding context without the ChordInterceptor (which uses useInput\n * and would hang in headless renders with no stdin).\n */\nfunction StaticKeybindingProvider({\n  children,\n}: {\n  children: React.ReactNode\n}): React.ReactNode {\n  const { bindings } = loadKeybindingsSyncWithWarnings()\n  const pendingChordRef = useRef(null)\n  const handlerRegistryRef = useRef(new Map())\n  const activeContexts = useRef(new Set<KeybindingContextName>()).current\n\n  return (\n    <KeybindingProvider\n      bindings={bindings}\n      pendingChordRef={pendingChordRef}\n      pendingChord={null}\n      setPendingChord={() => {}}\n      activeContexts={activeContexts}\n      registerActiveContext={() => {}}\n      unregisterActiveContext={() => {}}\n      handlerRegistryRef={handlerRegistryRef}\n    >\n      {children}\n    </KeybindingProvider>\n  )\n}\n\n// Upper-bound how many NormalizedMessages a Message can produce.\n// normalizeMessages splits one Message with N content blocks into N\n// NormalizedMessages — 1:1 with block count. String content = 1 block.\n// AttachmentMessage etc. have no .message and normalize to ≤1.\nfunction normalizedUpperBound(m: Message): number {\n  if (!('message' in m)) return 1\n  const c = m.message.content\n  return Array.isArray(c) ? c.length : 1\n}\n\n/**\n * Streams rendered messages in chunks, ANSI codes preserved. Each chunk is a\n * fresh renderToAnsiString — yoga layout tree + Ink's screen buffer are sized\n * to the tallest CHUNK instead of the full session. Measured (Mar 2026,\n * 538-msg session): −55% plateau RSS vs a single full render. The sink owns\n * the output — write to stdout for `[` dump-to-scrollback, appendFile for `v`.\n *\n * Messages.renderRange slices AFTER normalize→group→collapse, so tool-call\n * grouping stays correct across chunk seams; buildMessageLookups runs on\n * the full normalized array so tool_use↔tool_result resolves regardless of\n * which chunk each landed in.\n */\nexport async function streamRenderedMessages(\n  messages: Message[],\n  tools: Tools,\n  sink: (ansiChunk: string) => void | Promise<void>,\n  {\n    columns,\n    verbose = false,\n    chunkSize = 40,\n    onProgress,\n  }: {\n    columns?: number\n    verbose?: boolean\n    chunkSize?: number\n    onProgress?: (rendered: number) => void\n  } = {},\n): Promise<void> {\n  const renderChunk = (range: readonly [number, number]) =>\n    renderToAnsiString(\n      <AppStateProvider>\n        <StaticKeybindingProvider>\n          <Messages\n            messages={messages}\n            tools={tools}\n            commands={[]}\n            verbose={verbose}\n            toolJSX={null}\n            toolUseConfirmQueue={[]}\n            inProgressToolUseIDs={new Set()}\n            isMessageSelectorVisible={false}\n            conversationId=\"export\"\n            screen=\"prompt\"\n            streamingToolUses={[]}\n            showAllInTranscript={true}\n            isLoading={false}\n            renderRange={range}\n          />\n        </StaticKeybindingProvider>\n      </AppStateProvider>,\n      columns,\n    )\n\n  // renderRange indexes into the post-collapse array whose length we can't\n  // see from here — normalize splits each Message into one NormalizedMessage\n  // per content block (unbounded per message), collapse merges some back.\n  // Ceiling is the exact normalize output count + chunkSize so the loop\n  // always reaches the empty slice where break fires (collapse only shrinks).\n  let ceiling = chunkSize\n  for (const m of messages) ceiling += normalizedUpperBound(m)\n  for (let offset = 0; offset < ceiling; offset += chunkSize) {\n    const ansi = await renderChunk([offset, offset + chunkSize])\n    if (stripAnsi(ansi).trim() === '') break\n    await sink(ansi)\n    onProgress?.(offset + chunkSize)\n  }\n}\n\n/**\n * Renders messages to a plain text string suitable for export.\n * Uses the same React rendering logic as the interactive UI.\n */\nexport async function renderMessagesToPlainText(\n  messages: Message[],\n  tools: Tools = [],\n  columns?: number,\n): Promise<string> {\n  const parts: string[] = []\n  await streamRenderedMessages(\n    messages,\n    tools,\n    chunk => void parts.push(stripAnsi(chunk)),\n    { columns },\n  )\n  return parts.join('')\n}\n"],"mappings":"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","ignoreList":[]}

package/src/utils/extraUsage.ts

@@ -0,0 +1,23 @@
+import { isClaudeAISubscriber } from './auth.js'
+import { has1mContext } from './context.js'
+
+export function isBilledAsExtraUsage(
+  model: string | null,
+  isFastMode: boolean,
+  isOpus1mMerged: boolean,
+): boolean {
+  if (!isClaudeAISubscriber()) return false
+  if (isFastMode) return true
+  if (model === null || !has1mContext(model)) return false
+
+  const m = model
+    .toLowerCase()
+    .replace(/\[1m\]$/, '')
+    .trim()
+  const isOpus46 = m === 'opus' || m.includes('opus-4-6')
+  const isSonnet46 = m === 'sonnet' || m.includes('sonnet-4-6')
+
+  if (isOpus46 && isOpus1mMerged) return false
+
+  return isOpus46 || isSonnet46
+}