minovative-mind-cli 2.10.0 → 2.11.0

package/dist/utils/historyPrompt.js

@@ -1,5 +1,167 @@
 import { TextPrompt } from '@clack/core';
 import pc from 'picocolors';
+/**
+ * Approximate token count for a given text string using character and word heuristics.
+ * Defaults to a safe ratio of ~3.8 characters per token for multi-language code and text.
+ *
+ * @param text The input string to estimate.
+ * @returns Estimated number of tokens.
+ */
+export function estimateTokenCount(text) {
+    if (!text)
+        return 0;
+    const length = text.length;
+    if (length === 0)
+        return 0;
+    // Code and structured JSON typically have slightly higher token density (fewer chars/token)
+    // than plain English prose. 3.8 chars/token provides a conservative and safe ceiling.
+    return Math.ceil(length / 3.8);
+}
+/**
+ * Calculates dynamic token budget distributions for context injection, history retention,
+ * and system prompts based on the overall context window size.
+ *
+ * @param config Configuration parameters for the token budget.
+ * @returns An object containing granular token allocations.
+ */
+export function calculateDynamicTokenBudget(config) {
+    const { totalBudget, reservedForOutput = 8192, systemPromptBudget = 4096, safetyMarginPct = 0.1, } = config;
+    const rawAvailable = Math.max(0, totalBudget - reservedForOutput - systemPromptBudget);
+    const safetyMargin = Math.round(rawAvailable * Math.min(Math.max(safetyMarginPct, 0), 0.5));
+    const usableBudget = Math.max(0, rawAvailable - safetyMargin);
+    // Allocate 60% of usable budget to workspace context (files, tree, tools) and 40% to conversation history
+    const contextBudget = Math.round(usableBudget * 0.6);
+    const historyBudget = usableBudget - contextBudget;
+    return {
+        contextBudget,
+        historyBudget,
+        outputBudget: reservedForOutput,
+        systemBudget: systemPromptBudget,
+        safetyMargin,
+    };
+}
+/**
+ * Prunes a text string so that its estimated token count does not exceed the specified maximum.
+ *
+ * @param text The text to prune.
+ * @param maxTokens Maximum allowable tokens for this text.
+ * @param options Pruning options.
+ * @returns Pruned string, with an optional truncation marker.
+ */
+export function pruneTextToTokenBudget(text, maxTokens, options) {
+    if (!text || maxTokens <= 0)
+        return '';
+    const currentEstimated = estimateTokenCount(text);
+    if (currentEstimated <= maxTokens) {
+        return text;
+    }
+    const maxChars = Math.floor(maxTokens * 3.8);
+    const marker = options?.truncationMarker ?? '\n... [Context truncated to fit token budget] ...\n';
+    const effectiveMaxChars = Math.max(0, maxChars - marker.length);
+    if (options?.fromStart) {
+        const keepSlice = text.slice(text.length - effectiveMaxChars);
+        return `${marker}${keepSlice}`;
+    }
+    const keepSlice = text.slice(0, effectiveMaxChars);
+    return `${keepSlice}${marker}`;
+}
+/**
+ * Optimizes an array of history strings by trimming whitespace, deduplicating consecutive items,
+ * removing empty entries, and capping the array length to a maximum threshold.
+ *
+ * @param history Raw array of history entries.
+ * @param maxEntries Maximum number of entries to retain. Defaults to 100.
+ * @returns Cleaned and bounded array of history entries.
+ */
+export function optimizeHistoryForContext(history, maxEntries = 100) {
+    if (!history || !Array.isArray(history))
+        return [];
+    const cleaned = [];
+    for (let i = 0; i < history.length; i++) {
+        const entry = history[i]?.trim();
+        if (!entry)
+            continue;
+        // Deduplicate consecutive identical entries
+        if (cleaned.length > 0 && cleaned[cleaned.length - 1] === entry) {
+            continue;
+        }
+        cleaned.push(entry);
+    }
+    if (cleaned.length > maxEntries) {
+        return cleaned.slice(cleaned.length - maxEntries);
+    }
+    return cleaned;
+}
+/**
+ * Formats a list of conversation turns into a unified history context string, dynamically
+ * pruning older turns if the total estimated tokens exceed the allocated budget.
+ *
+ * @param history Array of conversation turns with role and text content.
+ * @param maxTokens Maximum allowable tokens for the formatted history.
+ * @param options Formatting options.
+ * @returns Formatted and budget-constrained conversation history string.
+ */
+export function formatHistoryWithTokenBudget(history, maxTokens = 16384, options) {
+    if (!history || history.length === 0 || maxTokens <= 0)
+        return '';
+    const keepRecent = options?.keepRecentTurns ?? 2;
+    const userLabel = options?.userLabel ?? 'User';
+    const modelLabel = options?.modelLabel ?? 'Assistant';
+    // Extract plain text for each turn
+    const turns = [];
+    for (const item of history) {
+        const label = item.role === 'user' ? userLabel : modelLabel;
+        let text = item.text || '';
+        if (!text && Array.isArray(item.parts)) {
+            text = item.parts
+                .map((p) => {
+                if (typeof p === 'string')
+                    return p;
+                if (p.text)
+                    return p.text;
+                if (p.functionCall)
+                    return `[Tool Call: ${p.functionCall.name}]`;
+                if (p.functionResponse)
+                    return `[Tool Result: ${p.functionResponse.name}]`;
+                return '';
+            })
+                .filter(Boolean)
+                .join('\n');
+        }
+        text = text.trim();
+        if (text) {
+            turns.push({
+                label,
+                text,
+                tokens: estimateTokenCount(`${label}: ${text}\n`),
+            });
+        }
+    }
+    if (turns.length === 0)
+        return '';
+    // Build from the newest turns backwards to prioritize recent context
+    const selectedTurns = [];
+    let consumedTokens = 0;
+    let isTruncated = false;
+    for (let i = turns.length - 1; i >= 0; i--) {
+        const turn = turns[i];
+        const formatted = `${turn.label}: ${turn.text}`;
+        const turnTokens = turn.tokens;
+        if (consumedTokens + turnTokens <= maxTokens || selectedTurns.length < keepRecent) {
+            selectedTurns.unshift(formatted);
+            consumedTokens += turnTokens;
+        }
+        else {
+            isTruncated = true;
+            break;
+        }
+    }
+    let result = selectedTurns.join('\n\n');
+    if (isTruncated) {
+        result = `[Older conversation history pruned to fit token budget]\n\n${result}`;
+    }
+    return result;
+}
 // Emulate clack/prompts styling characters
 const S_BAR = '│';
 const S_BAR_END = '└';
@@ -23,13 +185,15 @@ function symbol(state) {
     }
 }
 /**
- * A custom text prompt that supports command history navigation using Up/Down arrow keys.
+ * A custom text prompt that supports command history navigation using Up/Down arrow keys
+ * with memory bounds and dynamic input optimization.
  *
  * @param opts - The configuration options for the prompt.
  * @returns A promise that resolves to the user's input string or a symbol if cancelled.
  */
 export const historyText = (opts) => {
-    const history = opts.history || [];
+    const maxLen = opts.maxHistoryLength ?? 100;
+    const history = optimizeHistoryForContext(opts.history || [], maxLen);
     let historyIndex = -1;
     const prompt = new TextPrompt({
         validate: opts.validate,

package/dist/utils/symbolExtractor.d.ts

@@ -31,3 +31,15 @@ export declare function extractSymbolMetadata(content: string, filePath: string,
  * @returns The filtered source string containing only the matched symbol blocks and omission markers
  */
 export declare function extractSymbols(content: string, filePath: string, targetElements: string[]): string;
+/**
+ * Extracts a compact declarations outline (type/interface definitions, class skeletons,
+ * and function signatures without full implementation bodies) across TypeScript/JavaScript,
+ * Python, Go, and Rust.
+ *
+ * This dramatically reduces token usage when injecting multi-file context into prompts.
+ *
+ * @param content - Raw source code content
+ * @param filePath - File path used to infer language and syntax rules
+ * @returns Compact declarations outline string
+ */
+export declare function extractDeclarationsOutline(content: string, filePath: string): string;