wave-agent-sdk 0.0.7 → 0.0.10

package/dist/utils/customCommands.js

@@ -1,7 +1,9 @@
-import { existsSync, readdirSync } from "fs";
+import { existsSync, readdirSync, statSync } from "fs";
 import { join, extname, basename } from "path";
 import { homedir } from "os";
 import { parseMarkdownFile } from "./markdownParser.js";
+import { generateCommandId, getCommandSegments, getNamespace, getDepth, } from "./commandPathResolver.js";
+import { logger } from "./globalLogger.js";
 /**
  * Get the project-specific commands directory
  */
@@ -15,39 +17,82 @@ export function getUserCommandsDir() {
     return join(homedir(), ".wave", "commands");
 }
 /**
- * Scan a directory for markdown command files
+ * Scan a directory for markdown command files with nested directory support
+ * @param dirPath - Root commands directory path
+ * @param maxDepth - Maximum nesting depth to scan (default: 1)
  */
-function scanCommandsDirectory(dirPath) {
+function scanCommandsDirectory(dirPath, maxDepth = 1) {
     if (!existsSync(dirPath)) {
         return [];
     }
+    return scanCommandsDirectoryRecursive(dirPath, dirPath, 0, maxDepth);
+}
+/**
+ * Recursively scan directory for commands with depth control
+ * @param currentPath - Current directory being scanned
+ * @param rootPath - Root commands directory (for relative path calculation)
+ * @param currentDepth - Current nesting depth
+ * @param maxDepth - Maximum allowed depth
+ */
+function scanCommandsDirectoryRecursive(currentPath, rootPath, currentDepth, maxDepth) {
     const commands = [];
     try {
-        const files = readdirSync(dirPath);
-        for (const file of files) {
-            if (extname(file) !== ".md") {
-                continue;
-            }
-            const filePath = join(dirPath, file);
-            const commandName = basename(file, ".md");
+        const entries = readdirSync(currentPath);
+        for (const entryName of entries) {
+            const fullPath = join(currentPath, entryName);
+            let isDirectory = false;
+            let isFile = false;
             try {
-                const { content, config } = parseMarkdownFile(filePath);
-                commands.push({
-                    id: commandName,
-                    name: commandName,
-                    description: config?.description, // Use description from frontmatter
-                    filePath,
-                    content,
-                    config,
-                });
+                const stats = statSync(fullPath);
+                isDirectory = stats.isDirectory();
+                isFile = stats.isFile();
             }
             catch (error) {
-                console.warn(`Failed to load custom command from ${filePath}:`, error);
+                // Skip entries that cannot be stat'd
+                logger.warn(`Cannot access ${fullPath}:`, error);
+                continue;
+            }
+            if (isDirectory) {
+                // Skip subdirectories if we're at max depth
+                if (currentDepth >= maxDepth) {
+                    logger.warn(`Skipping directory ${fullPath}: exceeds maximum nesting depth of ${maxDepth}`);
+                    continue;
+                }
+                // Recursively scan subdirectory
+                const nestedCommands = scanCommandsDirectoryRecursive(fullPath, rootPath, currentDepth + 1, maxDepth);
+                commands.push(...nestedCommands);
+            }
+            else if (isFile && extname(entryName) === ".md") {
+                // Process markdown file
+                try {
+                    const commandId = generateCommandId(fullPath, rootPath);
+                    const segments = getCommandSegments(fullPath, rootPath);
+                    const namespace = getNamespace(segments);
+                    const depth = getDepth(segments);
+                    const { content, config } = parseMarkdownFile(fullPath);
+                    commands.push({
+                        id: commandId,
+                        name: basename(entryName, ".md"),
+                        description: config?.description,
+                        filePath: fullPath,
+                        content,
+                        config,
+                        // Nested command metadata
+                        namespace,
+                        isNested: depth > 0,
+                        depth,
+                        segments,
+                    });
+                }
+                catch (error) {
+                    logger.warn(`Failed to load custom command from ${fullPath}:`, error);
+                }
             }
+            // Skip non-markdown files silently
         }
     }
     catch (error) {
-        console.warn(`Failed to scan commands directory ${dirPath}:`, error);
+        logger.warn(`Failed to scan commands directory ${currentPath}:`, error);
     }
     return commands;
 }

package/dist/utils/fileSearch.d.ts

@@ -0,0 +1,14 @@
+import { type Path } from "glob";
+import type { FileItem } from "../types/fileSearch.js";
+/**
+ * Convert Path objects to FileItem objects
+ */
+export declare const convertPathsToFileItems: (paths: Path[]) => FileItem[];
+/**
+ * Search files and directories using glob patterns
+ */
+export declare const searchFiles: (query: string, options?: {
+    maxResults?: number;
+    workingDirectory?: string;
+}) => Promise<FileItem[]>;
+//# sourceMappingURL=fileSearch.d.ts.map

package/dist/utils/fileSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSearch.d.ts","sourceRoot":"","sources":["../../src/utils/fileSearch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AAE9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAO,IAAI,EAAE,KAAG,QAAQ,EAK/D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,MAAM,EACb,UAAU;IACR,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,KACA,OAAO,CAAC,QAAQ,EAAE,CAmFpB,CAAC"}

package/dist/utils/fileSearch.js

@@ -0,0 +1,88 @@
+import { globIterate } from "glob";
+import { getGlobIgnorePatterns } from "./fileFilter.js";
+/**
+ * Convert Path objects to FileItem objects
+ */
+export const convertPathsToFileItems = (paths) => {
+    return paths.map((pathObj) => ({
+        path: pathObj.relative(),
+        type: pathObj.isDirectory() ? "directory" : "file",
+    }));
+};
+/**
+ * Search files and directories using glob patterns
+ */
+export const searchFiles = async (query, options) => {
+    const { maxResults = 10, workingDirectory = process.cwd() } = options || {};
+    try {
+        const globOptions = {
+            ignore: getGlobIgnorePatterns(workingDirectory),
+            maxDepth: 10,
+            nocase: true, // Case insensitive
+            dot: true, // Include hidden files and directories
+            cwd: workingDirectory, // Specify search root directory
+            withFileTypes: true, // Get Path objects instead of strings
+        };
+        // Build glob patterns based on query
+        let patterns = [];
+        if (!query.trim()) {
+            // When query is empty, show some common file types and directories
+            patterns = [
+                "**/*.{ts,tsx,js,jsx,json,py,java}", // Combine common file extensions
+                "*/", // First level directories
+            ];
+        }
+        else {
+            // Build multiple glob patterns to support more flexible search
+            patterns = [
+                // Match files with filenames containing query
+                `**/*${query}*`,
+                // Match files with query in path (match directory names)
+                `**/${query}*/**/*`,
+                // Match directory names containing query
+                `**/*${query}*/`,
+                // Match directories containing query in path
+                `**/${query}*/`,
+            ];
+        }
+        // Collect results until we reach maxResults
+        const collectedPaths = [];
+        const seenPaths = new Set();
+        // Process each pattern sequentially
+        for (const pattern of patterns) {
+            if (collectedPaths.length >= maxResults) {
+                break;
+            }
+            // Use globIterate to get results one by one
+            const iterator = globIterate(pattern, globOptions);
+            for await (const pathObj of iterator) {
+                if (collectedPaths.length >= maxResults) {
+                    // Stop the iterator when we have enough results
+                    break;
+                }
+                const relativePath = pathObj.relative();
+                if (!seenPaths.has(relativePath)) {
+                    seenPaths.add(relativePath);
+                    collectedPaths.push(pathObj);
+                }
+            }
+        }
+        // Sort collected paths: directories first, then files
+        collectedPaths.sort((a, b) => {
+            const aIsDir = a.isDirectory();
+            const bIsDir = b.isDirectory();
+            if (aIsDir && !bIsDir)
+                return -1;
+            if (!aIsDir && bIsDir)
+                return 1;
+            return a.relative().localeCompare(b.relative());
+        });
+        // Convert to FileItems
+        const fileItems = convertPathsToFileItems(collectedPaths);
+        return fileItems;
+    }
+    catch (error) {
+        console.error("Glob search error:", error);
+        return [];
+    }
+};

package/dist/utils/fileUtils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Reads the first line of a file efficiently using Node.js readline.
+ *
+ * @param {string} filePath - The path to the file.
+ * @return {Promise<string>} - The first non-empty line of the file, or an empty string otherwise.
+ */
+export declare function readFirstLine(filePath: string): Promise<string>;
+/**
+ * Reads a file from the end and returns the last non-empty line.
+ *
+ * This version supports files that end with:
+ *   - "\n" (Unix-style, including modern macOS)
+ *   - "\r\n" (Windows-style)
+ *   - "\r" (older Mac-style, HL7, etc.)
+ *
+ * @param {string} filePath - The path to the file.
+ * @param {number} [minLength=1] - Minimum length for the returned line.
+ * @return {Promise<string>} - The last non-empty line of the file, or an empty string if no non-empty lines found.
+ */
+export declare function getLastLine(filePath: string, minLength?: number): Promise<string>;
+/**
+ * Ensures that a pattern is present in the global git ignore file.
+ *
+ * @param {string} pattern - The pattern to add to global git ignore.
+ */
+export declare function ensureGlobalGitIgnore(pattern: string): Promise<void>;
+//# sourceMappingURL=fileUtils.d.ts.map

package/dist/utils/fileUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileUtils.d.ts","sourceRoot":"","sources":["../../src/utils/fileUtils.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,SAAS,SAAI,GACZ,OAAO,CAAC,MAAM,CAAC,CA8DjB;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqC1E"}

package/dist/utils/fileUtils.js

@@ -0,0 +1,145 @@
+import fs from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+/**
+ * Reads the first line of a file efficiently using Node.js readline.
+ *
+ * @param {string} filePath - The path to the file.
+ * @return {Promise<string>} - The first non-empty line of the file, or an empty string otherwise.
+ */
+export async function readFirstLine(filePath) {
+    const { createInterface } = await import("node:readline");
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({
+        input: fileStream,
+        crlfDelay: Infinity, // Handle \r\n properly
+    });
+    try {
+        for await (const line of rl) {
+            const trimmedLine = line.trim();
+            if (trimmedLine.length > 0) {
+                return trimmedLine;
+            }
+        }
+        return "";
+    }
+    catch {
+        // If reading fails (e.g., file doesn't exist), return empty string
+        return "";
+    }
+    finally {
+        rl.close();
+        fileStream.destroy();
+    }
+}
+/**
+ * Reads a file from the end and returns the last non-empty line.
+ *
+ * This version supports files that end with:
+ *   - "\n" (Unix-style, including modern macOS)
+ *   - "\r\n" (Windows-style)
+ *   - "\r" (older Mac-style, HL7, etc.)
+ *
+ * @param {string} filePath - The path to the file.
+ * @param {number} [minLength=1] - Minimum length for the returned line.
+ * @return {Promise<string>} - The last non-empty line of the file, or an empty string if no non-empty lines found.
+ */
+export async function getLastLine(filePath, minLength = 1) {
+    let fileHandle;
+    try {
+        const stats = await fs.stat(filePath);
+        const fileSize = stats.size;
+        if (fileSize === 0)
+            return "";
+        fileHandle = await fs.open(filePath, "r");
+        const bufferSize = 8 * 1024; // 8KB buffer is usually enough for the last line
+        const buffer = Buffer.alloc(bufferSize);
+        let lineEnd = null;
+        let lineStart = null;
+        let currentPosition = fileSize;
+        while (currentPosition > 0 && lineStart === null) {
+            const readSize = Math.min(bufferSize, currentPosition);
+            currentPosition -= readSize;
+            const { bytesRead } = await fileHandle.read(buffer, 0, readSize, currentPosition);
+            for (let i = bytesRead - 1; i >= 0; i--) {
+                const charCode = buffer[i];
+                if (lineEnd === null) {
+                    // Still looking for the end of the last non-empty line (skip trailing newlines and whitespace)
+                    if (charCode > 32) {
+                        lineEnd = currentPosition + i + 1;
+                    }
+                }
+                else {
+                    // Looking for the start of the line (the newline before it)
+                    if (charCode === 10 || charCode === 13) {
+                        lineStart = currentPosition + i + 1;
+                        break;
+                    }
+                }
+            }
+        }
+        if (lineEnd === null)
+            return "";
+        if (lineStart === null)
+            lineStart = 0;
+        const length = lineEnd - lineStart;
+        if (length < minLength)
+            return "";
+        const resultBuffer = Buffer.alloc(length);
+        await fileHandle.read(resultBuffer, 0, length, lineStart);
+        const result = resultBuffer.toString("utf8").trim();
+        return result.length >= minLength ? result : "";
+    }
+    catch {
+        // If reading fails (e.g., file doesn't exist), return empty string
+        return "";
+    }
+    finally {
+        if (fileHandle) {
+            await fileHandle.close();
+        }
+    }
+}
+/**
+ * Ensures that a pattern is present in the global git ignore file.
+ *
+ * @param {string} pattern - The pattern to add to global git ignore.
+ */
+export async function ensureGlobalGitIgnore(pattern) {
+    try {
+        let globalIgnorePath;
+        try {
+            globalIgnorePath = execSync("git config --get core.excludesfile", {
+                encoding: "utf8",
+            }).trim();
+        }
+        catch {
+            // If not set, use default paths
+            const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(homedir(), ".config");
+            globalIgnorePath = path.join(xdgConfigHome, "git", "ignore");
+        }
+        if (!globalIgnorePath)
+            return;
+        // Ensure directory exists
+        await fs.mkdir(path.dirname(globalIgnorePath), { recursive: true });
+        let content = "";
+        try {
+            content = await fs.readFile(globalIgnorePath, "utf8");
+        }
+        catch {
+            // File doesn't exist
+        }
+        const lines = content.split("\n").map((line) => line.trim());
+        if (!lines.includes(pattern)) {
+            const newContent = content.endsWith("\n") || content === ""
+                ? `${content}${pattern}\n`
+                : `${content}\n${pattern}\n`;
+            await fs.writeFile(globalIgnorePath, newContent, "utf8");
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}

package/dist/utils/globalLogger.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Global Logger Registry for Agent SDK
+ *
+ * Provides zero-overhead logging access for utility functions and services
+ * without requiring parameter passing. Maintains singleton logger instance
+ * accessible across all SDK modules.
+ *
+ * Features:
+ * - Zero overhead when no logger configured (single null check)
+ * - Thread-safe in Node.js single-threaded environment
+ * - Maintains backward compatibility with existing Logger interface
+ * - Direct function delegation when configured
+ */
+import type { Logger } from "../types/core.js";
+/**
+ * Configure the global logger instance used by utility functions and services
+ *
+ * @param logger - Logger instance implementing the Logger interface, or null to disable logging
+ * @returns void
+ *
+ * @example
+ * ```typescript
+ * import { setGlobalLogger } from './utils/globalLogger.js';
+ *
+ * // Configure logger
+ * setGlobalLogger(myLogger);
+ *
+ * // Disable logging
+ * setGlobalLogger(null);
+ * ```
+ */
+export declare function setGlobalLogger(logger: Logger | null): void;
+/**
+ * Reset global logger to unconfigured state
+ * Equivalent to setGlobalLogger(null)
+ *
+ * @example
+ * ```typescript
+ * clearGlobalLogger(); // All subsequent logging calls become no-ops
+ * ```
+ */
+export declare function clearGlobalLogger(): void;
+/**
+ * Check if global logger is currently configured
+ *
+ * @returns true if logger configured, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isLoggerConfigured()) {
+ *   // Perform expensive logging operation
+ *   const debugInfo = generateDebugInfo();
+ *   logger.debug(debugInfo);
+ * }
+ * ```
+ */
+export declare function isLoggerConfigured(): boolean;
+/**
+ * Zero-overhead logging interface
+ *
+ * Performance characteristics:
+ * - Unconfigured: Single null check + early return (near-zero cost)
+ * - Configured: Null check + function delegation
+ * - No object creation or intermediate allocations
+ */
+export declare const logger: {
+    /**
+     * Log debug-level message through global logger
+     * No-op when global logger is null (zero overhead)
+     */
+    readonly debug: (...args: unknown[]) => void;
+    /**
+     * Log info-level message through global logger
+     * No-op when global logger is null (zero overhead)
+     */
+    readonly info: (...args: unknown[]) => void;
+    /**
+     * Log warning-level message through global logger
+     * No-op when global logger is null (zero overhead)
+     */
+    readonly warn: (...args: unknown[]) => void;
+    /**
+     * Log error-level message through global logger
+     * No-op when global logger is null (zero overhead)
+     */
+    readonly error: (...args: unknown[]) => void;
+};
+//# sourceMappingURL=globalLogger.d.ts.map

package/dist/utils/globalLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalLogger.d.ts","sourceRoot":"","sources":["../../src/utils/globalLogger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAa/C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAE3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAMD;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;IACjB;;;OAGG;8BACc,OAAO,EAAE,KAAG,IAAI;IAKjC;;;OAGG;6BACa,OAAO,EAAE,KAAG,IAAI;IAKhC;;;OAGG;6BACa,OAAO,EAAE,KAAG,IAAI;IAKhC;;;OAGG;8BACc,OAAO,EAAE,KAAG,IAAI;CAIzB,CAAC"}

package/dist/utils/globalLogger.js

@@ -0,0 +1,120 @@
+/**
+ * Global Logger Registry for Agent SDK
+ *
+ * Provides zero-overhead logging access for utility functions and services
+ * without requiring parameter passing. Maintains singleton logger instance
+ * accessible across all SDK modules.
+ *
+ * Features:
+ * - Zero overhead when no logger configured (single null check)
+ * - Thread-safe in Node.js single-threaded environment
+ * - Maintains backward compatibility with existing Logger interface
+ * - Direct function delegation when configured
+ */
+/**
+ * Module-level storage for the global logger instance
+ * null = unconfigured (logging calls are no-ops)
+ * Logger = configured (calls are forwarded)
+ */
+let globalLogger = null;
+// =============================================================================
+// Registry Management API
+// =============================================================================
+/**
+ * Configure the global logger instance used by utility functions and services
+ *
+ * @param logger - Logger instance implementing the Logger interface, or null to disable logging
+ * @returns void
+ *
+ * @example
+ * ```typescript
+ * import { setGlobalLogger } from './utils/globalLogger.js';
+ *
+ * // Configure logger
+ * setGlobalLogger(myLogger);
+ *
+ * // Disable logging
+ * setGlobalLogger(null);
+ * ```
+ */
+export function setGlobalLogger(logger) {
+    globalLogger = logger;
+}
+/**
+ * Reset global logger to unconfigured state
+ * Equivalent to setGlobalLogger(null)
+ *
+ * @example
+ * ```typescript
+ * clearGlobalLogger(); // All subsequent logging calls become no-ops
+ * ```
+ */
+export function clearGlobalLogger() {
+    globalLogger = null;
+}
+/**
+ * Check if global logger is currently configured
+ *
+ * @returns true if logger configured, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isLoggerConfigured()) {
+ *   // Perform expensive logging operation
+ *   const debugInfo = generateDebugInfo();
+ *   logger.debug(debugInfo);
+ * }
+ * ```
+ */
+export function isLoggerConfigured() {
+    return globalLogger !== null;
+}
+// =============================================================================
+// Zero-Overhead Logging API
+// =============================================================================
+/**
+ * Zero-overhead logging interface
+ *
+ * Performance characteristics:
+ * - Unconfigured: Single null check + early return (near-zero cost)
+ * - Configured: Null check + function delegation
+ * - No object creation or intermediate allocations
+ */
+export const logger = {
+    /**
+     * Log debug-level message through global logger
+     * No-op when global logger is null (zero overhead)
+     */
+    debug: (...args) => {
+        if (globalLogger === null)
+            return;
+        globalLogger.debug(...args);
+    },
+    /**
+     * Log info-level message through global logger
+     * No-op when global logger is null (zero overhead)
+     */
+    info: (...args) => {
+        if (globalLogger === null)
+            return;
+        globalLogger.info(...args);
+    },
+    /**
+     * Log warning-level message through global logger
+     * No-op when global logger is null (zero overhead)
+     */
+    warn: (...args) => {
+        if (globalLogger === null)
+            return;
+        globalLogger.warn(...args);
+    },
+    /**
+     * Log error-level message through global logger
+     * No-op when global logger is null (zero overhead)
+     */
+    error: (...args) => {
+        if (globalLogger === null)
+            return;
+        globalLogger.error(...args);
+    },
+};

package/dist/utils/largeOutputHandler.d.ts

@@ -0,0 +1,15 @@
+export declare const LARGE_OUTPUT_TOKEN_THRESHOLD = 20000;
+/**
+ * Handle large command output by writing to temporary file when token threshold is exceeded
+ *
+ * Uses token-based threshold (20k tokens) to determine when output should be written to temp file.
+ * This provides accurate estimation of actual token cost for LLM processing.
+ *
+ * @param output - The command output string
+ * @returns Object containing processed content and optional file path
+ */
+export declare function handleLargeOutput(output: string): Promise<{
+    content: string;
+    filePath?: string;
+}>;
+//# sourceMappingURL=largeOutputHandler.d.ts.map

package/dist/utils/largeOutputHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"largeOutputHandler.d.ts","sourceRoot":"","sources":["../../src/utils/largeOutputHandler.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,4BAA4B,QAAQ,CAAC;AAElD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC,CA8BD"}

package/dist/utils/largeOutputHandler.js

@@ -0,0 +1,40 @@
+import { writeFile } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { logger } from "./globalLogger.js";
+import { estimateTokenCount, getTokenUsageDescription, } from "./tokenEstimator.js";
+// Token threshold for writing output to temp file (20k tokens)
+export const LARGE_OUTPUT_TOKEN_THRESHOLD = 20000;
+/**
+ * Handle large command output by writing to temporary file when token threshold is exceeded
+ *
+ * Uses token-based threshold (20k tokens) to determine when output should be written to temp file.
+ * This provides accurate estimation of actual token cost for LLM processing.
+ *
+ * @param output - The command output string
+ * @returns Object containing processed content and optional file path
+ */
+export async function handleLargeOutput(output) {
+    const estimatedTokens = estimateTokenCount(output);
+    // Check token threshold
+    if (estimatedTokens <= LARGE_OUTPUT_TOKEN_THRESHOLD) {
+        return { content: output };
+    }
+    try {
+        // Create temp file for large output
+        const tempFileName = `bash-output-${Date.now()}-${Math.random().toString(36).substr(2, 9)}.txt`;
+        const tempFilePath = join(tmpdir(), tempFileName);
+        await writeFile(tempFilePath, output, "utf8");
+        const sizeKB = Math.round(output.length / 1024);
+        const tokenDescription = getTokenUsageDescription(output, LARGE_OUTPUT_TOKEN_THRESHOLD);
+        return {
+            content: `Large output (${sizeKB} KB, ${tokenDescription}) written to temporary file. Use the Read tool to access the full content.`,
+            filePath: tempFilePath,
+        };
+    }
+    catch (error) {
+        logger.warn(`Failed to write large output to temp file: ${error}`);
+        // Fallback to direct output if temp file creation fails
+        return { content: output };
+    }
+}

package/dist/utils/markdownParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdownParser.d.ts","sourceRoot":"","sources":["../../src/utils/markdownParser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAElE,UAAU,kBAAkB;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,wBAAwB,CAAC;CACnC;AAwDD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CAsCtE;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG;IAClD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAgBA;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iBAAiB,EAAE,GAC3B,MAAM,CAcR"}
+{"version":3,"file":"markdownParser.d.ts","sourceRoot":"","sources":["../../src/utils/markdownParser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAElE,UAAU,kBAAkB;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,wBAAwB,CAAC;CACnC;AA6CD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CA+BtE;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG;IAClD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAgBA;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iBAAiB,EAAE,GAC3B,MAAM,CAcR"}