minovative-mind-cli 2.10.0 → 2.11.0

package/dist/utils/analysisRunner.js

@@ -10,17 +10,52 @@ const LANGUAGE_ALIASES = {
     js: 'node',
     javascript: 'node',
     node: 'node',
+    cjs: 'node',
+    mjs: 'node',
     ts: 'ts-node',
     typescript: 'ts-node',
     'ts-node': 'ts-node',
+    tsx: 'ts-node',
+    mts: 'ts-node',
+    cts: 'ts-node',
     py: 'python',
+    py3: 'python',
     python: 'python',
+    python3: 'python',
     sh: 'bash',
     bash: 'bash',
+    shell: 'bash',
+    zsh: 'bash',
     go: 'go',
+    golang: 'go',
     rs: 'rust',
     rust: 'rust',
+    rustc: 'rust',
+    c: 'c',
+    cpp: 'cpp',
+    'c++': 'cpp',
+    cc: 'cpp',
+    cxx: 'cpp',
+    cplusplus: 'cpp',
+    rb: 'ruby',
+    ruby: 'ruby',
+    php: 'php',
+    java: 'java',
 };
+/** Supported canonical language names list. */
+export const SUPPORTED_LANGUAGES = [
+    'node',
+    'ts-node',
+    'python',
+    'bash',
+    'go',
+    'rust',
+    'c',
+    'cpp',
+    'ruby',
+    'php',
+    'java',
+];
 /**
  * Normalizes user/AI provided language string to a standard runtime identifier.
  */
@@ -28,6 +63,135 @@ export function normalizeLanguage(lang) {
     const key = lang.toLowerCase().trim();
     return LANGUAGE_ALIASES[key] || key;
 }
+/**
+ * Detects programming language heuristic markers directly from script source code syntax.
+ * Useful when language is omitted or set to 'auto'.
+ *
+ * @param code - The source code to analyze.
+ * @returns Detected runtime identifier (e.g., 'python', 'rust', 'go', 'cpp', 'c', 'bash', 'ruby', 'php', 'java', 'ts-node', 'node').
+ */
+export function detectLanguageFromCode(code) {
+    const trimmed = code.trim();
+    if (!trimmed)
+        return 'node';
+    // Shebang check
+    if (trimmed.startsWith('#!')) {
+        const firstLine = trimmed.split('\n')[0].toLowerCase();
+        if (firstLine.includes('python'))
+            return 'python';
+        if (firstLine.includes('bash') || firstLine.includes('sh') || firstLine.includes('zsh'))
+            return 'bash';
+        if (firstLine.includes('node'))
+            return 'node';
+        if (firstLine.includes('ruby'))
+            return 'ruby';
+        if (firstLine.includes('php'))
+            return 'php';
+    }
+    // PHP marker
+    if (trimmed.startsWith('<?php') || trimmed.includes('<?php')) {
+        return 'php';
+    }
+    // Rust markers
+    if (/\b(fn\s+main\s*\(|println!\s*\(|eprintln!\s*\(|use\s+std::|impl\s+[A-Z]\w*|pub\s+fn\b|match\s+\w+\s*\{)/.test(code)) {
+        return 'rust';
+    }
+    // Go markers
+    if (/\bpackage\s+main\b/.test(code) ||
+        (/\bfunc\s+main\s*\(/.test(code) && /\bimport\s+(\(|")/.test(code))) {
+        return 'go';
+    }
+    // C++ markers
+    if (/#\s*include\s*<(iostream|vector|string|memory|algorithm|map|set|utility)>/.test(code) ||
+        /\bstd::(cout|cin|cerr|endl|vector|string|make_unique|make_shared)\b/.test(code) ||
+        /\btemplate\s*<\s*typename\b/.test(code)) {
+        return 'cpp';
+    }
+    // C markers
+    if (/#\s*include\s*<(stdio\.h|stdlib\.h|string\.h|unistd\.h|math\.h)>/.test(code) ||
+        (/\bprintf\s*\(/.test(code) && /\bint\s+main\s*\(/.test(code))) {
+        return 'c';
+    }
+    // Java markers
+    if (/\bpublic\s+class\s+[A-Z]\w*/.test(code) ||
+        /\bpublic\s+static\s+void\s+main\s*\(/.test(code) ||
+        /\bSystem\.(out|err)\.println\b/.test(code)) {
+        return 'java';
+    }
+    // Python markers
+    if (/\b(def\s+[a-zA-Z_]\w*\s*\(|import\s+[a-zA-Z_]\w*|from\s+[a-zA-Z_]\w*\s+import|if\s+__name__\s*==\s*['"]__main__['"])/.test(code) ||
+        (/:\s*$/.test(trimmed) && /\b(elif|except|finally|pass|yield)\b/.test(code))) {
+        return 'python';
+    }
+    // Ruby markers
+    if (/\b(def\s+[a-zA-Z_]\w*(\s*\(|\s*\n)|puts\s+|require_relative\s+|attr_accessor\s+:)/.test(code) &&
+        /\bend\b/.test(code)) {
+        return 'ruby';
+    }
+    // TypeScript markers
+    if (/\b(interface\s+[A-Z]\w*|type\s+[A-Z]\w*\s*=|:\s*(string|number|boolean|Record<|Array<|Promise<|void|unknown|never)\b|as\s+const\b)/.test(code)) {
+        return 'ts-node';
+    }
+    // Bash markers
+    if (/\b(echo\s+['"].*['"]|if\s+\[\s+.*\s+\];\s*then|fi\b|done\b|export\s+[A-Z_]+=\S+)/.test(code) &&
+        !code.includes('console.log')) {
+        return 'bash';
+    }
+    return 'node';
+}
+/**
+ * Detects the dominant programming language / runtime for a workspace based on project manifest files.
+ *
+ * @param workspaceRoot - Path to the workspace root directory.
+ * @returns Detected runtime identifier (e.g., 'rust', 'go', 'python', 'cpp', 'ts-node', 'node').
+ */
+export async function detectProjectRuntime(workspaceRoot) {
+    const probeFiles = [
+        { file: 'Cargo.toml', runtime: 'rust' },
+        { file: 'go.mod', runtime: 'go' },
+        { file: 'pyproject.toml', runtime: 'python' },
+        { file: 'requirements.txt', runtime: 'python' },
+        { file: 'Pipfile', runtime: 'python' },
+        { file: 'setup.py', runtime: 'python' },
+        { file: 'CMakeLists.txt', runtime: 'cpp' },
+        { file: 'Gemfile', runtime: 'ruby' },
+        { file: 'composer.json', runtime: 'php' },
+        { file: 'pom.xml', runtime: 'java' },
+        { file: 'build.gradle', runtime: 'java' },
+        { file: 'tsconfig.json', runtime: 'ts-node' },
+        { file: 'package.json', runtime: 'node' },
+    ];
+    for (const { file, runtime } of probeFiles) {
+        try {
+            await fs.access(path.join(workspaceRoot, file));
+            return runtime;
+        }
+        catch {
+            // Continue searching
+        }
+    }
+    return 'node';
+}
+/**
+ * Resolves the effective runtime language by combining explicit language input,
+ * source code syntax heuristics, and workspace project manifests.
+ *
+ * @param workspaceRoot - Path to workspace root directory.
+ * @param language - Optional language parameter passed by user/agent.
+ * @param code - Optional source code string to inspect.
+ */
+export async function resolveEffectiveRuntime(workspaceRoot, language, code) {
+    if (language && language.toLowerCase().trim() !== 'auto') {
+        return normalizeLanguage(language);
+    }
+    if (code && code.trim()) {
+        const detectedFromCode = detectLanguageFromCode(code);
+        if (detectedFromCode !== 'node') {
+            return detectedFromCode;
+        }
+    }
+    return detectProjectRuntime(workspaceRoot);
+}
 /**
  * Detects whether the workspace package.json specifies `"type": "module"`.
  * Returns `'module'` or `'commonjs'`.
@@ -72,6 +236,11 @@ export async function resolveScriptExtension(workspaceRoot, language, code) {
         bash: '.sh',
         go: '.go',
         rust: '.rs',
+        c: '.c',
+        cpp: '.cpp',
+        ruby: '.rb',
+        php: '.php',
+        java: '.java',
     };
     return defaultExts[normLang] || '.js';
 }
@@ -89,6 +258,7 @@ function buildTempPath(code, ext) {
  */
 function buildCommand(language, scriptPath) {
     const normLang = normalizeLanguage(language);
+    const binExt = os.platform() === 'win32' ? '.exe' : '';
     switch (normLang) {
         case 'node':
             return `node "${scriptPath}"`;
@@ -101,10 +271,23 @@ function buildCommand(language, scriptPath) {
         case 'go':
             return `go run "${scriptPath}"`;
         case 'rust': {
-            const binExt = os.platform() === 'win32' ? '.exe' : '';
             const binPath = scriptPath.replace(/\.rs$/, binExt);
             return `rustc "${scriptPath}" -o "${binPath}" && "${binPath}"`;
         }
+        case 'c': {
+            const binPath = scriptPath.replace(/\.c$/, binExt);
+            return `gcc "${scriptPath}" -o "${binPath}" && "${binPath}"`;
+        }
+        case 'cpp': {
+            const binPath = scriptPath.replace(/\.cpp$/, binExt);
+            return `g++ -std=c++17 "${scriptPath}" -o "${binPath}" && "${binPath}"`;
+        }
+        case 'ruby':
+            return `ruby "${scriptPath}"`;
+        case 'php':
+            return `php "${scriptPath}"`;
+        case 'java':
+            return `java "${scriptPath}"`;
         default:
             return null;
     }
@@ -134,30 +317,39 @@ function truncateOutput(text, max) {
 export async function runEphemeralScript(workspaceRoot, language, code, options) {
     const timeoutMs = options?.timeoutMs ?? 60_000;
     const maxOutputChars = options?.maxOutputChars ?? 100_000;
-    const normLang = normalizeLanguage(language);
+    const normLang = await resolveEffectiveRuntime(workspaceRoot, language, code);
     const ext = await resolveScriptExtension(workspaceRoot, normLang, code);
     const scriptPath = buildTempPath(code, ext);
     const cmd = buildCommand(normLang, scriptPath);
     if (!cmd) {
         return {
             stdout: '',
-            stderr: `Unsupported language runtime: "${language}". Supported: node, ts-node, python, bash, go, rust`,
+            stderr: `Unsupported language runtime: "${language}". Supported: ${SUPPORTED_LANGUAGES.join(', ')}`,
             exitCode: 1,
         };
     }
     // Collect all temp files created so we can clean them up unconditionally
     const tempFiles = [scriptPath];
+    const binExt = os.platform() === 'win32' ? '.exe' : '';
     if (normLang === 'rust') {
-        const binExt = os.platform() === 'win32' ? '.exe' : '';
         tempFiles.push(scriptPath.replace(/\.rs$/, binExt));
+        tempFiles.push(scriptPath.replace(/\.rs$/, '.pdb'));
+    }
+    else if (normLang === 'c') {
+        tempFiles.push(scriptPath.replace(/\.c$/, binExt));
+    }
+    else if (normLang === 'cpp') {
+        tempFiles.push(scriptPath.replace(/\.cpp$/, binExt));
     }
     try {
         await fs.writeFile(scriptPath, code, 'utf-8');
+        const mergedEnv = options?.env ? { ...process.env, ...options.env } : process.env;
         const { stdout, stderr } = await execAsync(cmd, {
             cwd: workspaceRoot,
             timeout: timeoutMs,
             maxBuffer: 1024 * 1024, // 1 MB buffer
             signal: options?.abortSignal,
+            env: mergedEnv,
         });
         return {
             stdout: truncateOutput(stdout.trim(), maxOutputChars),
@@ -170,6 +362,9 @@ export async function runEphemeralScript(workspaceRoot, language, code, options)
         if (err.name === 'AbortError' || err.message?.includes('abort')) {
             return { stdout: '', stderr: 'Analysis script aborted by user.', exitCode: 130 };
         }
+        if (err.killed && err.signal === 'SIGTERM') {
+            return { stdout: '', stderr: `Execution timed out after ${timeoutMs}ms.`, exitCode: 124 };
+        }
         const stdout = truncateOutput((err.stdout || '').trim(), maxOutputChars);
         const stderr = truncateOutput((err.stderr || '').trim(), maxOutputChars);
         const exitCode = typeof err.code === 'number' ? err.code : 1;
@@ -179,7 +374,7 @@ export async function runEphemeralScript(workspaceRoot, language, code, options)
         // Guarantee temp file cleanup regardless of success or failure
         for (const tmpFile of tempFiles) {
             try {
-                await fs.rm(tmpFile, { force: true });
+                await fs.rm(tmpFile, { force: true, recursive: true });
             }
             catch {
                 // Ignore cleanup errors — temp files will be reaped by the OS eventually

package/dist/utils/contextPrompts.d.ts

@@ -1,12 +1,12 @@
 /**
  * @file Utility functions for preparing and sanitizing context-related
  * injection strings to be sent to the AI model. Includes handling of CDATA block
- * formatting to prevent nesting or breaking XML-like structure.
+ * formatting, character/token budgeting, and lightweight AST-scoped context extraction.
  */
 import { ContextAgentResult } from '../services/contextAgent.js';
 /**
  * Sanitizes file content string to prevent nesting or breakout issues when wrapped in CDATA.
- * Replaces occurrences of "]]>" with an escaped equivalent containing a zero-width space.
+ * Replaces occurrences of "]]\u200B>" with an escaped equivalent containing a zero-width space.
  *
  * @param content The raw content string to sanitize.
  * @returns The sanitized string safe to place inside a CDATA section.
@@ -17,7 +17,23 @@ export declare function sanitizeForCDATA(content: string): string;
  * This is used to inject project profiles, directories, summary, and relevant files'
  * content into the prompt context for the LLM.
  *
+ * Supports an optional character budget constraint to prevent oversized prompts.
+ *
  * @param context The collected context data from ContextAgent.
+ * @param maxChars Optional maximum character budget for the generated prompt injection.
  * @returns A formatted string containing project profile, structure, investigation summaries, and relevant file contents.
  */
-export declare function buildContextInjection(context: ContextAgentResult): string;
+export declare function buildContextInjection(context: ContextAgentResult, maxChars?: number): string;
+/**
+ * Constructs a lightweight, AST-scoped XML/Markdown-like project context string from ContextAgentResult.
+ * Uses `extractDeclarationsOutline` to replace full implementation bodies in relevant files with
+ * compact declarations outlines (types, interfaces, class skeletons, function signatures),
+ * drastically conserving context tokens during orchestration and sub-agent dispatch.
+ *
+ * Supports an optional character budget constraint.
+ *
+ * @param context The collected context data from ContextAgent.
+ * @param maxChars Optional maximum character budget for the generated prompt injection.
+ * @returns A formatted string containing project profile, structure, investigation summaries, and AST-scoped file outlines.
+ */
+export declare function buildScopedContextInjection(context: ContextAgentResult, maxChars?: number): string;

package/dist/utils/contextPrompts.js

@@ -1,30 +1,30 @@
 /**
  * @file Utility functions for preparing and sanitizing context-related
  * injection strings to be sent to the AI model. Includes handling of CDATA block
- * formatting to prevent nesting or breaking XML-like structure.
+ * formatting, character/token budgeting, and lightweight AST-scoped context extraction.
  */
 import { changeLogger } from '../services/changeLogger.js';
+import { extractDeclarationsOutline } from './symbolExtractor.js';
 /**
  * Sanitizes file content string to prevent nesting or breakout issues when wrapped in CDATA.
- * Replaces occurrences of "]]>" with an escaped equivalent containing a zero-width space.
+ * Replaces occurrences of "]]\u200B>" with an escaped equivalent containing a zero-width space.
  *
  * @param content The raw content string to sanitize.
  * @returns The sanitized string safe to place inside a CDATA section.
  */
 export function sanitizeForCDATA(content) {
-    // Prevent CDATA breakout by escaping ]]\\u200B>
+    // Prevent CDATA breakout by escaping ]]>
     return content.replace(new RegExp('\\]\\]>', 'g'), ']]\\\\u200B>');
 }
 /**
- * Constructs a structured XML/Markdown-like project context string from ContextAgentResult.
- * This is used to inject project profiles, directories, summary, and relevant files'
- * content into the prompt context for the LLM.
+ * Formats the base context header (project profile, directory tree, investigation summary,
+ * web search findings, and recent changesets).
  *
  * @param context The collected context data from ContextAgent.
- * @returns A formatted string containing project profile, structure, investigation summaries, and relevant file contents.
+ * @returns Base markdown/XML context string before file sections.
  */
-export function buildContextInjection(context) {
-    let injection = `<project_context>
+function buildBaseContext(context) {
+    let base = `<project_context>
 ## Project Profile
 ${context.projectType}
 
@@ -35,44 +35,162 @@ ${context.projectTree}
 ${context.summary}
 `;
     if (context.webSearchSummary) {
-        injection += `
+        base += `
 ## Web Search Findings
 ${context.webSearchSummary}
 `;
     }
     const changeHistory = changeLogger.getHistory();
     if (changeHistory.length > 0) {
-        injection += `
+        base += `
 ## Recent Workspace Changes Log (Current / Recent Sessions)
 `;
         for (const changeSet of changeHistory) {
             const timeStr = new Date(changeSet.timestamp).toISOString();
             const statusSuffix = changeSet.status ? ` [${changeSet.status}]` : '';
-            injection += `- [${timeStr}] ${changeSet.description}${statusSuffix}\n`;
+            base += `- [${timeStr}] ${changeSet.description}${statusSuffix}\n`;
             if (changeSet.changes && changeSet.changes.length > 0) {
                 for (const fileChange of changeSet.changes) {
-                    injection += `  - ${fileChange.action}: ${fileChange.filePath}\n`;
+                    base += `  - ${fileChange.action}: ${fileChange.filePath}\n`;
                 }
             }
         }
     }
-    if (context.relevantFiles.size > 0) {
-        injection += `\n## Relevant File Contents\n`;
-        for (const [filePath, contentObj] of context.relevantFiles.entries()) {
-            const contentText = contentObj.text;
-            let aliasAttr = '';
-            if (filePath.startsWith('@')) {
-                const slashIndex = filePath.indexOf('/');
-                const alias = slashIndex === -1 ? filePath.substring(1) : filePath.substring(1, slashIndex);
-                aliasAttr = ` workspace="${alias}"`;
-            }
-            injection += `<workspace_file path="${filePath}"${aliasAttr}>
+    return base;
+}
+/**
+ * Formats a single file entry wrapped in XML workspace_file and CDATA tags.
+ *
+ * @param filePath Path or alias of the file.
+ * @param contentText File content or declarations outline.
+ * @param scoped Whether this content represents an AST-scoped outline.
+ * @returns Formatted workspace_file block.
+ */
+function formatWorkspaceFileBlock(filePath, contentText, scoped = false) {
+    let aliasAttr = '';
+    if (filePath.startsWith('@')) {
+        const slashIndex = filePath.indexOf('/');
+        const alias = slashIndex === -1 ? filePath.substring(1) : filePath.substring(1, slashIndex);
+        aliasAttr = ` workspace="${alias}"`;
+    }
+    const scopedAttr = scoped ? ' scoped="outline"' : '';
+    return `<workspace_file path="${filePath}"${aliasAttr}${scopedAttr}>
 <content_data><![CDATA[
 ${sanitizeForCDATA(contentText)}
 ]]\\u200B></content_data>
 </workspace_file>\n`;
+}
+/**
+ * Assembles and injects relevant file contents into the context injection string,
+ * adhering to character/token budget constraints if specified.
+ *
+ * @param baseContext The base header context string.
+ * @param relevantFiles Map of file paths to their content objects.
+ * @param maxChars Optional maximum total character budget for the entire injection.
+ * @param useScopedOutline If true, extracts compact AST declarations outlines instead of raw contents.
+ * @returns The complete context injection string.
+ */
+function assembleContextWithFiles(baseContext, relevantFiles, maxChars, useScopedOutline = false) {
+    const closingTag = '</project_context>';
+    const hasBudget = typeof maxChars === 'number' && maxChars > 0;
+    // If no files are present, return base context closed
+    if (!relevantFiles || relevantFiles.size === 0) {
+        let result = `${baseContext.trimEnd()}\n${closingTag}`;
+        if (hasBudget && result.length > maxChars) {
+            const budgetForBase = Math.max(0, maxChars - closingTag.length - 1);
+            result = `${baseContext.slice(0, budgetForBase).trimEnd()}\n${closingTag}`;
+        }
+        return result;
+    }
+    let injection = baseContext;
+    // If base context itself exceeds budget, prune base context first
+    if (hasBudget && injection.length + closingTag.length > maxChars) {
+        const budgetForBase = Math.max(0, maxChars - closingTag.length - 1);
+        return `${injection.slice(0, budgetForBase).trimEnd()}\n${closingTag}`;
+    }
+    const filesHeader = '\n## Relevant File Contents\n';
+    if (hasBudget && injection.length + filesHeader.length + closingTag.length > maxChars) {
+        return `${injection.trimEnd()}\n${closingTag}`;
+    }
+    injection += filesHeader;
+    const fileEntries = Array.from(relevantFiles.entries());
+    const truncationNotice = '\n\n... [Content truncated to fit token budget] ...';
+    const safetyAllowance = 1; // for newline before closing tag
+    for (let i = 0; i < fileEntries.length; i++) {
+        const [filePath, contentObj] = fileEntries[i];
+        let contentText = contentObj.text;
+        if (useScopedOutline) {
+            contentText = extractDeclarationsOutline(contentText, filePath) || contentText;
+        }
+        if (!hasBudget) {
+            injection += formatWorkspaceFileBlock(filePath, contentText, useScopedOutline);
+            continue;
+        }
+        const remainingFilesCount = fileEntries.length - i - 1;
+        const omissionNoticeEstimate = remainingFilesCount > 0
+            ? `<!-- ${remainingFilesCount} additional relevant file(s) omitted to stay within token budget -->\n`.length
+            : 0;
+        const remainingBudgetForThisFile = maxChars - injection.length - closingTag.length - omissionNoticeEstimate - safetyAllowance;
+        const fullBlock = formatWorkspaceFileBlock(filePath, contentText, useScopedOutline);
+        if (fullBlock.length <= remainingBudgetForThisFile) {
+            injection += fullBlock;
+            continue;
         }
+        // Try partial/truncated block
+        const emptyBlock = formatWorkspaceFileBlock(filePath, '', useScopedOutline);
+        const wrapperOverhead = emptyBlock.length;
+        const availableContentChars = remainingBudgetForThisFile - wrapperOverhead - truncationNotice.length;
+        let includedTruncated = false;
+        if (availableContentChars > 50) {
+            const truncatedContent = contentText.slice(0, availableContentChars) + truncationNotice;
+            injection += formatWorkspaceFileBlock(filePath, truncatedContent, useScopedOutline);
+            includedTruncated = true;
+        }
+        const remainingFiles = fileEntries.length - (includedTruncated ? i + 1 : i);
+        if (remainingFiles > 0) {
+            const notice = `<!-- ${remainingFiles} additional relevant file(s) omitted to stay within token budget -->\n`;
+            if (injection.length + notice.length + closingTag.length + safetyAllowance <= maxChars) {
+                injection += notice;
+            }
+        }
+        break;
     }
-    injection += `</project_context>`;
-    return injection;
+    let result = `${injection.trimEnd()}\n${closingTag}`;
+    // Final hard boundary guard
+    if (hasBudget && result.length > maxChars) {
+        const keepChars = Math.max(0, maxChars - closingTag.length - 1);
+        result = `${result.slice(0, keepChars).trimEnd()}\n${closingTag}`;
+    }
+    return result;
+}
+/**
+ * Constructs a structured XML/Markdown-like project context string from ContextAgentResult.
+ * This is used to inject project profiles, directories, summary, and relevant files'
+ * content into the prompt context for the LLM.
+ *
+ * Supports an optional character budget constraint to prevent oversized prompts.
+ *
+ * @param context The collected context data from ContextAgent.
+ * @param maxChars Optional maximum character budget for the generated prompt injection.
+ * @returns A formatted string containing project profile, structure, investigation summaries, and relevant file contents.
+ */
+export function buildContextInjection(context, maxChars) {
+    const baseContext = buildBaseContext(context);
+    return assembleContextWithFiles(baseContext, context.relevantFiles, maxChars, false);
+}
+/**
+ * Constructs a lightweight, AST-scoped XML/Markdown-like project context string from ContextAgentResult.
+ * Uses `extractDeclarationsOutline` to replace full implementation bodies in relevant files with
+ * compact declarations outlines (types, interfaces, class skeletons, function signatures),
+ * drastically conserving context tokens during orchestration and sub-agent dispatch.
+ *
+ * Supports an optional character budget constraint.
+ *
+ * @param context The collected context data from ContextAgent.
+ * @param maxChars Optional maximum character budget for the generated prompt injection.
+ * @returns A formatted string containing project profile, structure, investigation summaries, and AST-scoped file outlines.
+ */
+export function buildScopedContextInjection(context, maxChars) {
+    const baseContext = buildBaseContext(context);
+    return assembleContextWithFiles(baseContext, context.relevantFiles, maxChars, true);
 }

package/dist/utils/historyPrompt.d.ts

@@ -12,11 +12,102 @@ export interface HistoryTextOptions {
     initialValue?: string;
     /** An array of previous commands or strings to allow navigation through. */
     history?: string[];
+    /** Maximum number of history entries to keep in memory for navigation. Defaults to 100. */
+    maxHistoryLength?: number;
     /** Callback to validate the user input. */
     validate?: (value: string) => string | Error | undefined;
 }
 /**
- * A custom text prompt that supports command history navigation using Up/Down arrow keys.
+ * Configuration options for dynamic token budget calculation.
+ */
+export interface TokenBudgetConfig {
+    /** Total maximum tokens available in the context window (e.g., 1_000_000 for Gemini 1.5 Pro). */
+    totalBudget: number;
+    /** Tokens reserved for model generation/output. Defaults to 8,192. */
+    reservedForOutput?: number;
+    /** Tokens reserved for system instructions. Defaults to 4,096. */
+    systemPromptBudget?: number;
+    /** Percentage of remaining tokens to reserve as safety headroom (0.0 to 1.0). Defaults to 0.1 (10%). */
+    safetyMarginPct?: number;
+}
+/**
+ * Resulting token allocations across prompt components.
+ */
+export interface TokenBudgetAllocation {
+    /** Maximum tokens allocated for file context and workspace tree. */
+    contextBudget: number;
+    /** Maximum tokens allocated for conversation history. */
+    historyBudget: number;
+    /** Tokens reserved for model output generation. */
+    outputBudget: number;
+    /** Tokens reserved for system prompt & directives. */
+    systemBudget: number;
+    /** Headroom tokens reserved for safety / uncounted overhead. */
+    safetyMargin: number;
+}
+/**
+ * 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 declare function estimateTokenCount(text: string | null | undefined): number;
+/**
+ * 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 declare function calculateDynamicTokenBudget(config: TokenBudgetConfig): TokenBudgetAllocation;
+/**
+ * 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 declare function pruneTextToTokenBudget(text: string, maxTokens: number, options?: {
+    /** Marker to append/prepend indicating truncation. */
+    truncationMarker?: string;
+    /** If true, prunes from the start (keeping the end). If false, prunes from the end (keeping the start). */
+    fromStart?: boolean;
+}): string;
+/**
+ * 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 declare function optimizeHistoryForContext(history: string[] | undefined, maxEntries?: number): string[];
+/**
+ * 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 declare function formatHistoryWithTokenBudget(history: Array<{
+    role: string;
+    text?: string;
+    parts?: any[];
+}>, maxTokens?: number, options?: {
+    /** Minimum number of recent turns to always keep regardless of budget if possible. Defaults to 2. */
+    keepRecentTurns?: number;
+    /** Custom label prefix for user turns. Defaults to "User". */
+    userLabel?: string;
+    /** Custom label prefix for assistant/model turns. Defaults to "Assistant". */
+    modelLabel?: string;
+}): string;
+/**
+ * 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.