dexto 1.3.0 → 1.5.0

package/dist/cli/ink-cli/utils/textUtils.js

@@ -0,0 +1,248 @@
+/**
+ * Unicode-aware text utilities for terminal rendering
+ *
+ * These utilities work at the code-point level rather than UTF-16 code units,
+ * so that surrogate-pair emoji count as one "column".
+ */
+import stripAnsi from 'strip-ansi';
+import stringWidth from 'string-width';
+// Cache for code points to reduce GC pressure
+const codePointsCache = new Map();
+const MAX_STRING_LENGTH_TO_CACHE = 1000;
+/**
+ * Convert a string to an array of code points (handles surrogate pairs correctly)
+ */
+export function toCodePoints(str) {
+    // ASCII fast path - check if all chars are ASCII (0-127)
+    let isAscii = true;
+    for (let i = 0; i < str.length; i++) {
+        if (str.charCodeAt(i) > 127) {
+            isAscii = false;
+            break;
+        }
+    }
+    if (isAscii) {
+        return str.split('');
+    }
+    // Cache short strings
+    // We return a copy ([...cached]) to prevent callers from mutating the cache.
+    // This has O(n) overhead but n is bounded by MAX_STRING_LENGTH_TO_CACHE (1000).
+    if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+        const cached = codePointsCache.get(str);
+        if (cached) {
+            return [...cached];
+        }
+    }
+    const result = Array.from(str);
+    // Cache result
+    if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+        codePointsCache.set(str, result);
+    }
+    return result;
+}
+/**
+ * Get the code-point length of a string
+ */
+export function cpLen(str) {
+    return toCodePoints(str).length;
+}
+/**
+ * Slice a string by code-point indices
+ */
+export function cpSlice(str, start, end) {
+    const arr = toCodePoints(str).slice(start, end);
+    return arr.join('');
+}
+/**
+ * Strip characters that can break terminal rendering.
+ *
+ * Characters stripped:
+ * - ANSI escape sequences
+ * - C0 control chars (0x00-0x1F) except CR/LF/TAB
+ * - C1 control chars (0x80-0x9F)
+ *
+ * Characters preserved:
+ * - All printable Unicode including emojis
+ * - CR/LF (0x0D/0x0A) - needed for line breaks
+ * - TAB (0x09)
+ */
+export function stripUnsafeCharacters(str) {
+    const strippedAnsi = stripAnsi(str);
+    return toCodePoints(strippedAnsi)
+        .filter((char) => {
+        const code = char.codePointAt(0);
+        if (code === undefined)
+            return false;
+        // Preserve CR/LF/TAB for line handling
+        if (code === 0x0a || code === 0x0d || code === 0x09)
+            return true;
+        // Remove C0 control chars (except CR/LF/TAB)
+        if (code >= 0x00 && code <= 0x1f)
+            return false;
+        // Remove DEL control char
+        if (code === 0x7f)
+            return false;
+        // Remove C1 control chars (0x80-0x9f)
+        if (code >= 0x80 && code <= 0x9f)
+            return false;
+        // Preserve all other characters including Unicode/emojis
+        return true;
+    })
+        .join('');
+}
+// String width caching for performance optimization
+const stringWidthCache = new Map();
+/**
+ * Cached version of stringWidth function for better performance
+ */
+export function getCachedStringWidth(str) {
+    // ASCII printable chars have width 1
+    if (/^[\x20-\x7E]*$/.test(str)) {
+        return str.length;
+    }
+    if (stringWidthCache.has(str)) {
+        return stringWidthCache.get(str);
+    }
+    const width = stringWidth(str);
+    stringWidthCache.set(str, width);
+    return width;
+}
+/**
+ * Clear the string width cache
+ */
+export function clearStringWidthCache() {
+    stringWidthCache.clear();
+}
+// Word character detection helpers
+// These accept string | undefined to safely handle array bounds access (chars[i] may be undefined)
+export const isWordCharStrict = (char) => char !== undefined && /[\w\p{L}\p{N}]/u.test(char);
+export const isWhitespace = (char) => char !== undefined && /\s/.test(char);
+export const isCombiningMark = (char) => char !== undefined && /\p{M}/u.test(char);
+export const isWordCharWithCombining = (char) => isWordCharStrict(char) || isCombiningMark(char);
+// Get the script of a character (simplified for common scripts)
+export const getCharScript = (char) => {
+    if (!char)
+        return 'other';
+    if (/[\p{Script=Latin}]/u.test(char))
+        return 'latin';
+    if (/[\p{Script=Han}]/u.test(char))
+        return 'han';
+    if (/[\p{Script=Arabic}]/u.test(char))
+        return 'arabic';
+    if (/[\p{Script=Hiragana}]/u.test(char))
+        return 'hiragana';
+    if (/[\p{Script=Katakana}]/u.test(char))
+        return 'katakana';
+    if (/[\p{Script=Cyrillic}]/u.test(char))
+        return 'cyrillic';
+    return 'other';
+};
+export const isDifferentScript = (char1, char2) => {
+    if (!isWordCharStrict(char1) || !isWordCharStrict(char2))
+        return false;
+    return getCharScript(char1) !== getCharScript(char2);
+};
+// Initialize segmenter for word boundary detection
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'word' });
+/**
+ * Find previous word boundary in a line
+ */
+export function findPrevWordBoundary(line, cursorCol) {
+    const codePoints = toCodePoints(line);
+    // Convert cursorCol (CP index) to string index
+    const prefix = codePoints.slice(0, cursorCol).join('');
+    const cursorIdx = prefix.length;
+    let targetIdx = 0;
+    for (const seg of segmenter.segment(line)) {
+        if (seg.index >= cursorIdx)
+            break;
+        if (seg.isWordLike) {
+            targetIdx = seg.index;
+        }
+    }
+    return toCodePoints(line.slice(0, targetIdx)).length;
+}
+/**
+ * Find next word boundary in a line
+ */
+export function findNextWordBoundary(line, cursorCol) {
+    const codePoints = toCodePoints(line);
+    const prefix = codePoints.slice(0, cursorCol).join('');
+    const cursorIdx = prefix.length;
+    let targetIdx = line.length;
+    for (const seg of segmenter.segment(line)) {
+        const segEnd = seg.index + seg.segment.length;
+        if (segEnd > cursorIdx) {
+            if (seg.isWordLike) {
+                targetIdx = segEnd;
+                break;
+            }
+        }
+    }
+    return toCodePoints(line.slice(0, targetIdx)).length;
+}
+/**
+ * Find next word start within a line, starting from col
+ */
+export function findNextWordStartInLine(line, col) {
+    const chars = toCodePoints(line);
+    let i = col;
+    if (i >= chars.length)
+        return null;
+    const currentChar = chars[i];
+    // Skip current word/sequence based on character type
+    if (isWordCharStrict(currentChar)) {
+        while (i < chars.length && isWordCharWithCombining(chars[i])) {
+            if (i + 1 < chars.length &&
+                isWordCharStrict(chars[i + 1]) &&
+                isDifferentScript(chars[i], chars[i + 1])) {
+                i++;
+                break;
+            }
+            i++;
+        }
+    }
+    else if (!isWhitespace(currentChar)) {
+        while (i < chars.length && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
+            i++;
+        }
+    }
+    // Skip whitespace
+    while (i < chars.length && isWhitespace(chars[i])) {
+        i++;
+    }
+    return i < chars.length ? i : null;
+}
+/**
+ * Find previous word start within a line
+ */
+export function findPrevWordStartInLine(line, col) {
+    const chars = toCodePoints(line);
+    let i = col;
+    if (i <= 0)
+        return null;
+    i--;
+    // Skip whitespace moving backwards
+    while (i >= 0 && isWhitespace(chars[i])) {
+        i--;
+    }
+    if (i < 0)
+        return null;
+    if (isWordCharStrict(chars[i])) {
+        while (i >= 0 && isWordCharStrict(chars[i])) {
+            if (i - 1 >= 0 &&
+                isWordCharStrict(chars[i - 1]) &&
+                isDifferentScript(chars[i], chars[i - 1])) {
+                return i;
+            }
+            i--;
+        }
+        return i + 1;
+    }
+    else {
+        while (i >= 0 && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
+            i--;
+        }
+        return i + 1;
+    }
+}

package/dist/cli/ink-cli/utils/toolUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tool utility functions for CLI
+ */
+/**
+ * Check if a tool is an edit or write file tool.
+ * Used for "accept all edits" mode which auto-approves these tools.
+ */
+export declare function isEditWriteTool(toolName: string | undefined): boolean;
+//# sourceMappingURL=toolUtils.d.ts.map

package/dist/cli/ink-cli/utils/toolUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolUtils.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/utils/toolUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CASrE"}

package/dist/cli/ink-cli/utils/toolUtils.js

@@ -0,0 +1,15 @@
+/**
+ * Tool utility functions for CLI
+ */
+/**
+ * Check if a tool is an edit or write file tool.
+ * Used for "accept all edits" mode which auto-approves these tools.
+ */
+export function isEditWriteTool(toolName) {
+    return (toolName === 'internal--edit_file' ||
+        toolName === 'internal--write_file' ||
+        toolName === 'custom--write_file' ||
+        toolName === 'custom--edit_file' ||
+        toolName === 'edit_file' ||
+        toolName === 'write_file');
+}

package/dist/cli/utils/api-key-setup.d.ts

@@ -1,10 +1,60 @@
 import type { LLMProvider } from '@dexto/core';
+export interface ApiKeySetupResult {
+    success: boolean;
+    apiKey?: string;
+    cancelled?: boolean;
+    skipped?: boolean;
+    error?: string;
+}
 /**
  * Interactively prompts the user to set up an API key for a specific provider.
- * Used when config validation detects a missing API key for a configured provider.
- * Only handles environment variable setup - does not modify config files.
- * Exits the process if user cancels or setup fails.
+ * Includes browser auto-open, format validation with hints, and API key verification.
+ *
  * @param provider - The specific provider that needs API key setup
+ * @param options - Configuration options
+ * @returns Result indicating success, cancellation, or error
  */
-export declare function interactiveApiKeySetup(provider: LLMProvider): Promise<void>;
+export declare function interactiveApiKeySetup(provider: LLMProvider, options?: {
+    exitOnCancel?: boolean;
+    skipVerification?: boolean;
+    model?: string;
+}): Promise<ApiKeySetupResult>;
+/**
+ * Quick check if an API key is already configured for a provider
+ */
+export declare function hasApiKeyConfigured(provider: LLMProvider): boolean;
+/**
+ * Result when user is prompted about pending API key setup
+ */
+export interface PendingSetupPromptResult {
+    action: 'setup' | 'skip' | 'cancel';
+    apiKey?: string;
+}
+/**
+ * Prompts user about pending API key setup from a previous incomplete setup.
+ * This is shown when user previously skipped API key setup and is now trying to run dexto.
+ *
+ * @param provider - The provider that needs API key setup
+ * @param model - The model configured for the provider
+ * @returns Result indicating which action the user chose
+ */
+export declare function promptForPendingApiKey(provider: LLMProvider, model: string): Promise<PendingSetupPromptResult>;
+/**
+ * Result when user is prompted about missing API key for a specific agent
+ */
+export interface AgentApiKeyPromptResult {
+    action: 'add-key' | 'use-default' | 'cancel';
+    apiKey?: string;
+}
+/**
+ * Prompts user when loading a specific agent that requires an API key they don't have.
+ * Offers options to add the API key, continue with their default LLM, or cancel.
+ *
+ * @param agentProvider - The provider the agent requires
+ * @param agentModel - The model the agent uses
+ * @param userProvider - The user's default provider (from preferences)
+ * @param userModel - The user's default model (from preferences)
+ * @returns Result indicating which action the user chose
+ */
+export declare function promptForMissingAgentApiKey(agentProvider: LLMProvider, agentModel: string, userProvider: LLMProvider, userModel: string): Promise<AgentApiKeyPromptResult>;
 //# sourceMappingURL=api-key-setup.d.ts.map

package/dist/cli/utils/api-key-setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-key-setup.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/api-key-setup.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAU/C;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA0HjF"}
+{"version":3,"file":"api-key-setup.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/api-key-setup.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAe/C,MAAM,WAAW,iBAAiB;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CACxC,QAAQ,EAAE,WAAW,EACrB,OAAO,GAAE;IACL,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CACb,GACP,OAAO,CAAC,iBAAiB,CAAC,CAuK5B;AAsMD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAGlE;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CACxC,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CAkEnC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,QAAQ,CAAC;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAsB,2BAA2B,CAC7C,aAAa,EAAE,WAAW,EAC1B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,WAAW,EACzB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,uBAAuB,CAAC,CAiGlC"}