minovative-mind-cli 2.9.1 → 2.11.0

package/dist/utils/contextPrompts.d.ts

@@ -1,12 +1,12 @@
 /**
- * @fileoverview Utility functions for preparing and sanitizing context-related
+ * @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,29 +1,30 @@
 /**
- * @fileoverview Utility functions for preparing and sanitizing context-related
+ * @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}
 
@@ -34,28 +35,162 @@ ${context.projectTree}
 ${context.summary}
 `;
     if (context.webSearchSummary) {
-        injection += `
+        base += `
 ## Web Search Findings
 ${context.webSearchSummary}
 `;
     }
-    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}"`;
+    const changeHistory = changeLogger.getHistory();
+    if (changeHistory.length > 0) {
+        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}]` : '';
+            base += `- [${timeStr}] ${changeSet.description}${statusSuffix}\n`;
+            if (changeSet.changes && changeSet.changes.length > 0) {
+                for (const fileChange of changeSet.changes) {
+                    base += `  - ${fileChange.action}: ${fileChange.filePath}\n`;
+                }
             }
-            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;
+    }
+    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}`;
     }
-    injection += `</project_context>`;
-    return injection;
+    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.

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;