tunacode-cli 0.0.29__tar.gz → 0.0.30__tar.gz

{tunacode_cli-0.0.29/src/tunacode_cli.egg-info → tunacode_cli-0.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.29
+Version: 0.0.30
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tunacode-cli"
-version = "0.0.29"
+version = "0.0.30"
 description = "Your agentic CLI developer."
 keywords = ["cli", "agent", "development", "automation"]
 readme = "README.md"

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/src/tunacode/cli/commands.py

@@ -258,7 +258,8 @@ class ClearCommand(SimpleCommand):
 
         await ui.clear()
         context.state_manager.session.messages = []
-        await ui.success("Message history cleared")
+        context.state_manager.session.files_in_context.clear()
+        await ui.success("Message history and file context cleared")
 
 
 class FixCommand(SimpleCommand):

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/src/tunacode/cli/repl.py

@@ -9,6 +9,7 @@ import json
 import os
 import subprocess
 from asyncio.exceptions import CancelledError
+from pathlib import Path
 
 from prompt_toolkit.application import run_in_terminal
 from prompt_toolkit.application.current import get_app
@@ -164,6 +165,13 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         # Patch any orphaned tool calls from previous requests before proceeding
         patch_tool_messages("Tool execution was interrupted", state_manager)
 
+        # Clear tracking for new request when thoughts are enabled
+        if state_manager.session.show_thoughts:
+            state_manager.session.tool_calls = []
+            # Don't clear files_in_context - keep it cumulative for the session
+            state_manager.session.iteration_count = 0
+            state_manager.session.current_iteration = 0
+
         # Track message start for thoughts display
         start_idx = len(state_manager.session.messages)
 
@@ -177,7 +185,10 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             try:
                 from tunacode.utils.text_utils import expand_file_refs
 
-                text = expand_file_refs(text)
+                text, referenced_files = expand_file_refs(text)
+                # Track the referenced files
+                for file_path in referenced_files:
+                    state_manager.session.files_in_context.add(file_path)
             except ValueError as e:
                 await ui.error(str(e))
                 return
@@ -199,12 +210,22 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 if not results:
                     # Fallback: show that the request was processed
                     await ui.muted("Request completed")
+
+                # Always show files in context after orchestrator response
+                if state_manager.session.files_in_context:
+                    filenames = [
+                        Path(f).name for f in sorted(state_manager.session.files_in_context)
+                    ]
+                    await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
         else:
             # Expand @file references before sending to the agent
             try:
                 from tunacode.utils.text_utils import expand_file_refs
 
-                text = expand_file_refs(text)
+                text, referenced_files = expand_file_refs(text)
+                # Track the referenced files
+                for file_path in referenced_files:
+                    state_manager.session.files_in_context.add(file_path)
             except ValueError as e:
                 await ui.error(str(e))
                 return
@@ -229,9 +250,22 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                     and hasattr(res.result, "output")
                 ):
                     await ui.agent(res.result.output)
+                    # Always show files in context after agent response
+                    if state_manager.session.files_in_context:
+                        # Extract just filenames from full paths for readability
+                        filenames = [
+                            Path(f).name for f in sorted(state_manager.session.files_in_context)
+                        ]
+                        await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
                 else:
                     # Fallback: show that the request was processed
                     await ui.muted("Request completed")
+                    # Show files in context even for empty responses
+                    if state_manager.session.files_in_context:
+                        filenames = [
+                            Path(f).name for f in sorted(state_manager.session.files_in_context)
+                        ]
+                        await ui.muted(f"Files in context: {', '.join(filenames)}")
     except CancelledError:
         await ui.muted("Request cancelled")
     except UserAbortError:

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/src/tunacode/cli/textual_bridge.py

@@ -72,7 +72,10 @@ class TextualAgentBridge:
             try:
                 from tunacode.utils.text_utils import expand_file_refs
 
-                text = expand_file_refs(text)
+                text, referenced_files = expand_file_refs(text)
+                # Track the referenced files
+                for file_path in referenced_files:
+                    self.state_manager.session.files_in_context.add(file_path)
             except ValueError as e:
                 return f"Error: {str(e)}"
 

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/src/tunacode/constants.py

@@ -7,7 +7,7 @@ Centralizes all magic strings, UI text, error messages, and application constant
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.29"
+APP_VERSION = "0.0.30"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/src/tunacode/core/agents/main.py

@@ -38,6 +38,9 @@ def get_model_messages():
 
 
 async def _process_node(node, tool_callback: Optional[ToolCallback], state_manager: StateManager):
+    from tunacode.ui import console as ui
+    from tunacode.utils.token_counter import estimate_tokens
+
     if hasattr(node, "request"):
         state_manager.session.messages.append(node.request)
 
@@ -45,36 +48,47 @@ async def _process_node(node, tool_callback: Optional[ToolCallback], state_manag
         state_manager.session.messages.append({"thought": node.thought})
         # Display thought immediately if show_thoughts is enabled
         if state_manager.session.show_thoughts:
-            from tunacode.ui import console as ui
-
-            await ui.muted(f"💭 THOUGHT: {node.thought}")
+            await ui.muted(f"THOUGHT: {node.thought}")
 
     if hasattr(node, "model_response"):
         state_manager.session.messages.append(node.model_response)
 
-        # Enhanced ReAct thought processing
+        # Enhanced display when thoughts are enabled
         if state_manager.session.show_thoughts:
             import json
             import re
 
-            from tunacode.ui import console as ui
-
+            # Display LLM response content
             for part in node.model_response.parts:
                 if hasattr(part, "content") and isinstance(part.content, str):
                     content = part.content.strip()
 
+                    # Skip empty content
+                    if not content:
+                        continue
+
+                    # Estimate tokens in this response
+                    token_count = estimate_tokens(content)
+
+                    # Display non-JSON content as LLM response
+                    if not content.startswith('{"thought"'):
+                        # Truncate very long responses for display
+                        display_content = content[:500] + "..." if len(content) > 500 else content
+                        await ui.muted(f"\nRESPONSE: {display_content}")
+                        await ui.muted(f"TOKENS: ~{token_count}")
+
                     # Pattern 1: Inline JSON thoughts {"thought": "..."}
                     thought_pattern = r'\{"thought":\s*"([^"]+)"\}'
                     matches = re.findall(thought_pattern, content)
                     for thought in matches:
-                        await ui.muted(f"💭 REASONING: {thought}")
+                        await ui.muted(f"REASONING: {thought}")
 
                     # Pattern 2: Standalone thought JSON objects
                     try:
                         if content.startswith('{"thought"'):
                             thought_obj = json.loads(content)
                             if "thought" in thought_obj:
-                                await ui.muted(f"💭 REASONING: {thought_obj['thought']}")
+                                await ui.muted(f"REASONING: {thought_obj['thought']}")
                     except (json.JSONDecodeError, KeyError):
                         pass
 
@@ -85,36 +99,86 @@ async def _process_node(node, tool_callback: Optional[ToolCallback], state_manag
                         if thought not in [m for m in matches]:  # Avoid duplicates
                             # Clean up escaped characters
                             cleaned_thought = thought.replace('\\"', '"').replace("\\n", " ")
-                            await ui.muted(f"💭 REASONING: {cleaned_thought}")
-
-                    # Pattern 4: Text-based reasoning indicators
-                    reasoning_indicators = [
-                        (r"I need to (.+?)\.", "PLANNING"),
-                        (r"Let me (.+?)\.", "ACTION"),
-                        (r"The output shows (.+?)\.", "OBSERVATION"),
-                        (r"Based on (.+?), I should (.+?)\.", "DECISION"),
-                    ]
-
-                    for pattern, label in reasoning_indicators:
-                        indicator_matches = re.findall(pattern, content, re.IGNORECASE)
-                        for match in indicator_matches:
-                            if isinstance(match, tuple):
-                                match_text = " ".join(match)
-                            else:
-                                match_text = match
-                            await ui.muted(f"🎯 {label}: {match_text}")
-                            break  # Only show first match per pattern
+                            await ui.muted(f"REASONING: {cleaned_thought}")
 
         # Check for tool calls and fallback to JSON parsing if needed
         has_tool_calls = False
         for part in node.model_response.parts:
             if part.part_kind == "tool-call" and tool_callback:
                 has_tool_calls = True
+
+                # Display tool call details when thoughts are enabled
+                if state_manager.session.show_thoughts:
+                    await ui.muted(f"\nTOOL: {part.tool_name}")
+                    if hasattr(part, "args"):
+                        # Check if args is a dictionary before accessing keys
+                        if isinstance(part.args, dict):
+                            # Simplify display based on tool type
+                            if part.tool_name == "read_file" and "file_path" in part.args:
+                                file_path = part.args["file_path"]
+                                filename = Path(file_path).name
+                                await ui.muted(f"Reading: {filename}")
+                            elif part.tool_name == "write_file" and "file_path" in part.args:
+                                file_path = part.args["file_path"]
+                                filename = Path(file_path).name
+                                await ui.muted(f"Writing: {filename}")
+                            elif part.tool_name == "update_file" and "file_path" in part.args:
+                                file_path = part.args["file_path"]
+                                filename = Path(file_path).name
+                                await ui.muted(f"Updating: {filename}")
+                            elif (
+                                part.tool_name in ["run_command", "bash"] and "command" in part.args
+                            ):
+                                command = part.args["command"]
+                                # Truncate long commands
+                                display_cmd = (
+                                    command if len(command) <= 60 else command[:57] + "..."
+                                )
+                                await ui.muted(f"Command: {display_cmd}")
+                            else:
+                                # For other tools, show full args but more compact
+                                args_str = json.dumps(part.args, indent=2)
+                                await ui.muted(f"ARGS: {args_str}")
+                        else:
+                            # If args is not a dict (e.g., a string), just display it as is
+                            await ui.muted(f"ARGS: {part.args}")
+
+                # Track this tool call (moved outside thoughts block)
+                state_manager.session.tool_calls.append(
+                    {
+                        "tool": part.tool_name,
+                        "args": part.args if hasattr(part, "args") else {},
+                        "iteration": state_manager.session.current_iteration,
+                    }
+                )
+
+                # Track files if this is read_file (moved outside thoughts block)
+                if (
+                    part.tool_name == "read_file"
+                    and hasattr(part, "args")
+                    and "file_path" in part.args
+                ):
+                    state_manager.session.files_in_context.add(part.args["file_path"])
+                    # Show files in context when thoughts are enabled
+                    if state_manager.session.show_thoughts:
+                        await ui.muted(
+                            f"\nFILES IN CONTEXT: {list(state_manager.session.files_in_context)}"
+                        )
+
                 await tool_callback(part, node)
+
             elif part.part_kind == "tool-return":
                 obs_msg = f"OBSERVATION[{part.tool_name}]: {part.content[:2_000]}"
                 state_manager.session.messages.append(obs_msg)
 
+                # Display tool return when thoughts are enabled
+                if state_manager.session.show_thoughts:
+                    # Truncate for display
+                    display_content = (
+                        part.content[:200] + "..." if len(part.content) > 200 else part.content
+                    )
+                    await ui.muted(f"TOOL RESULT: {display_content}")
+
         # If no structured tool calls found, try parsing JSON from text content
         if not has_tool_calls and tool_callback:
             for part in node.model_response.parts:
@@ -276,13 +340,13 @@ async def parse_json_tool_calls(
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
 
-                await ui.muted(f"🔧 FALLBACK: Executed {tool_name} via JSON parsing")
+                await ui.muted(f"FALLBACK: Executed {tool_name} via JSON parsing")
 
         except Exception as e:
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
 
-                await ui.error(f"❌ Error executing fallback tool {tool_name}: {str(e)}")
+                await ui.error(f"Error executing fallback tool {tool_name}: {str(e)}")
 
 
 async def extract_and_execute_tool_calls(
@@ -324,13 +388,13 @@ async def extract_and_execute_tool_calls(
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
 
-                    await ui.muted(f"🔧 FALLBACK: Executed {tool_data['tool']} from code block")
+                    await ui.muted(f"FALLBACK: Executed {tool_data['tool']} from code block")
 
         except (json.JSONDecodeError, KeyError, Exception) as e:
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
 
-                await ui.error(f"❌ Error parsing code block tool call: {str(e)}")
+                await ui.error(f"Error parsing code block tool call: {str(e)}")
 
 
 async def process_request(
@@ -349,26 +413,43 @@ async def process_request(
 
     response_state = ResponseState()
 
+    # Reset iteration tracking for this request
+    state_manager.session.iteration_count = 0
+
     async with agent.iter(message, message_history=mh) as agent_run:
         i = 0
         async for node in agent_run:
+            state_manager.session.current_iteration = i + 1
             await _process_node(node, tool_callback, state_manager)
             if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
                 if node.result.output:
                     response_state.has_user_response = True
             i += 1
+            state_manager.session.iteration_count = i
 
             # Display iteration progress if thoughts are enabled
-            if state_manager.session.show_thoughts and i > 1:
+            if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
 
-                await ui.muted(f"🔄 Iteration {i}/{max_iterations}")
+                await ui.muted(f"\nITERATION: {i}/{max_iterations}")
+
+                # Show summary of tools used so far
+                if state_manager.session.tool_calls:
+                    tool_summary = {}
+                    for tc in state_manager.session.tool_calls:
+                        tool_name = tc.get("tool", "unknown")
+                        tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
+
+                    summary_str = ", ".join(
+                        [f"{name}: {count}" for name, count in tool_summary.items()]
+                    )
+                    await ui.muted(f"TOOLS USED: {summary_str}")
 
             if i >= max_iterations:
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
 
-                    await ui.warning(f"⚠️ Reached maximum iterations ({max_iterations})")
+                    await ui.warning(f"Reached maximum iterations ({max_iterations})")
                 break
 
         # If we need to add a fallback response, create a wrapper
@@ -465,12 +546,25 @@ async def process_request(
             class AgentRunWrapper:
                 def __init__(self, wrapped_run, fallback_result):
                     self._wrapped = wrapped_run
-                    self.result = fallback_result
+                    self._result = fallback_result
                     self.response_state = response_state
 
-                def __getattr__(self, name):
+                def __getattribute__(self, name):
+                    # Handle special attributes first to avoid conflicts
+                    if name in ["_wrapped", "_result", "response_state"]:
+                        return object.__getattribute__(self, name)
+
+                    # Explicitly handle 'result' to return our fallback result
+                    if name == "result":
+                        return object.__getattribute__(self, "_result")
+
                     # Delegate all other attributes to the wrapped object
-                    return getattr(self._wrapped, name)
+                    try:
+                        return getattr(object.__getattribute__(self, "_wrapped"), name)
+                    except AttributeError:
+                        raise AttributeError(
+                            f"'{type(self).__name__}' object has no attribute '{name}'"
+                        )
 
             return AgentRunWrapper(agent_run, SimpleResult(comprehensive_output))
 
@@ -481,8 +575,17 @@ async def process_request(
                 self._wrapped = wrapped_run
                 self.response_state = response_state
 
-            def __getattr__(self, name):
+            def __getattribute__(self, name):
+                # Handle special attributes first
+                if name in ["_wrapped", "response_state"]:
+                    return object.__getattribute__(self, name)
+
                 # Delegate all other attributes to the wrapped object
-                return getattr(self._wrapped, name)
+                try:
+                    return getattr(object.__getattribute__(self, "_wrapped"), name)
+                except AttributeError:
+                    raise AttributeError(
+                        f"'{type(self).__name__}' object has no attribute '{name}'"
+                    )
 
         return AgentRunWithState(agent_run)

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/src/tunacode/core/state.py

@@ -30,6 +30,11 @@ class SessionState:
     device_id: Optional[DeviceId] = None
     input_sessions: InputSessions = field(default_factory=dict)
     current_task: Optional[Any] = None
+    # Enhanced tracking for thoughts display
+    files_in_context: set[str] = field(default_factory=set)
+    tool_calls: list[dict[str, Any]] = field(default_factory=list)
+    iteration_count: int = 0
+    current_iteration: int = 0
 
 
 class StateManager:

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/src/tunacode/prompts/system.md

@@ -12,7 +12,7 @@ You MUST follow these rules:
 
 \###Tool Access Rules###
 
-You HAVE the following tools available. USE THEM IMMEDIATELY and CONSTANTLY:
+You HAVE the following tools available. USE THEM WHEN APPROPRIATE:
 
 * `run_command(command: str)` — Execute any shell command in the current working directory
 * `read_file(filepath: str)` — Read any file using RELATIVE paths from current directory
@@ -34,12 +34,23 @@ You HAVE the following tools available. USE THEM IMMEDIATELY and CONSTANTLY:
 
 ---
 
+\###File Reference Rules###
+
+**IMPORTANT**: When the user includes file content marked with "=== FILE REFERENCE: filename ===" headers:
+- This is **reference material only** - the user is showing you existing file content
+- **DO NOT** write or recreate these files - they already exist
+- **DO NOT** use write_file on referenced content unless explicitly asked to modify it
+- **FOCUS** on answering questions or performing tasks related to the referenced files
+- The user uses @ syntax (like `@file.py`) to include file contents for context
+
+---
+
 \###Mandatory Operating Principles###
 
-1. **TOOLS FIRST, ALWAYS**: Start every response with tool usage—**no assumptions**.
+1. **UNDERSTAND CONTEXT**: Check if user is providing @ file references for context vs asking for actions
 2. **USE RELATIVE PATHS**: Always work in the current directory. Use relative paths like `src/`, `cli/`, `core/`, `tools/`, etc. NEVER use absolute paths starting with `/`.
-3. **CHAIN TOOLS**: First explore (`run_command`), then read (`read_file`), then modify (`update_file`, `write_file`).
-4. **ACT IMMEDIATELY**: Don’t describe what to do—**just do it**.
+3. **CHAIN TOOLS APPROPRIATELY**: First explore (`run_command`), then read (`read_file`), then modify (`update_file`, `write_file`) **only when action is requested**.
+4. **ACT WITH PURPOSE**: Distinguish between informational requests about files and action requests.
 5. **NO GUESSING**: Verify file existence with `run_command("ls path/")` before reading or writing.
 6. **ASSUME NOTHING**: Always fetch and verify before responding.
 
@@ -47,10 +58,10 @@ You HAVE the following tools available. USE THEM IMMEDIATELY and CONSTANTLY:
 
 \###Prompt Design Style###
 
-* Be **blunt and direct**. Avoid soft language (e.g., “please,” “let me,” “I think”).
+* Be **blunt and direct**. Avoid soft language (e.g., "please," "let me," "I think").
 * **Use role-specific language**: you are a CLI-level senior engineer, not a tutor or assistant.
 * Write using affirmative imperatives: *Do this. Check that. Show me.*
-* Ask for clarification if needed: “Specify the path.” / “Which class do you mean?”
+* Ask for clarification if needed: "Specify the path." / "Which class do you mean?"
 * Break complex requests into sequenced tool actions.
 
 ---
@@ -69,6 +80,10 @@ You HAVE the following tools available. USE THEM IMMEDIATELY and CONSTANTLY:
 ✅ `run_command("grep -E 'class.*Command' cli/commands.py")`
 ❌ "Available commands usually include..."
 
+**User**: Tell me about @configuration/settings.py
+✅ "The settings.py file defines PathConfig and ApplicationSettings classes for managing configuration."
+❌ `write_file("configuration/settings.py", ...)`
+
 ---
 
 \###Meta Behavior###
@@ -88,13 +103,14 @@ Use the **ReAct** (Reasoning + Action) framework:
 You were created by **tunahorse21**.
 You are not a chatbot.
 You are an autonomous code execution agent.
-You will be penalized for failing to use tools.
+You will be penalized for failing to use tools **when appropriate**.
+When users provide @ file references, they want information, not file creation.
 ---
 
 \###Example###
 
 ```plaintext
-User: What’s the current app version?
+User: What's the current app version?
 
 THINK: {"thought": "I should search for APP_VERSION in the constants file."}
 ACT: run_command("grep -n 'APP_VERSION' constants.py")
@@ -103,3 +119,17 @@ ACT: read_file("constants.py")
 OBSERVE: {"thought": "APP_VERSION is set to '2.4.1'. This is the current version."}
 RESPONSE: "Current version is 2.4.1 (from constants.py)"
 ```
+
+```plaintext
+User: Tell me about @src/main.py
+
+=== FILE REFERENCE: src/main.py ===
+```python
+def main():
+    print("Hello World")
+```
+=== END FILE REFERENCE: src/main.py ===
+
+THINK: {"thought": "User is asking about the referenced file, not asking me to create it."}
+RESPONSE: "The main.py file contains a simple main function that prints 'Hello World'."
+```

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/src/tunacode/utils/text_utils.py

@@ -6,7 +6,7 @@ Includes file extension to language mapping and key formatting functions.
 """
 
 import os
-from typing import Set
+from typing import List, Set, Tuple
 
 
 def key_to_title(key: str, uppercase_words: Set[str] = None) -> str:
@@ -50,14 +50,16 @@ def ext_to_lang(path: str) -> str:
     return "text"
 
 
-def expand_file_refs(text: str) -> str:
+def expand_file_refs(text: str) -> Tuple[str, List[str]]:
     """Expand @file references with file contents wrapped in code fences.
 
     Args:
         text: The input text potentially containing @file references.
 
     Returns:
-        Text with any @file references replaced by the file's contents.
+        Tuple[str, List[str]]: A tuple containing:
+            - Text with any @file references replaced by the file's contents
+            - List of absolute paths of files that were successfully expanded
 
     Raises:
         ValueError: If a referenced file does not exist or is too large.
@@ -69,6 +71,7 @@ def expand_file_refs(text: str) -> str:
                                     MSG_FILE_SIZE_LIMIT)
 
     pattern = re.compile(r"@([\w./_-]+)")
+    expanded_files = []
 
     def replacer(match: re.Match) -> str:
         path = match.group(1)
@@ -81,7 +84,13 @@ def expand_file_refs(text: str) -> str:
         with open(path, "r", encoding="utf-8") as f:
             content = f.read()
 
+        # Track the absolute path of the file
+        abs_path = os.path.abspath(path)
+        expanded_files.append(abs_path)
+
         lang = ext_to_lang(path)
-        return f"```{lang}\n{content}\n```"
+        # Add clear headers to indicate this is a file reference, not code to write
+        return f"\n=== FILE REFERENCE: {path} ===\n```{lang}\n{content}\n```\n=== END FILE REFERENCE: {path} ===\n"
 
-    return pattern.sub(replacer, text)
+    expanded_text = pattern.sub(replacer, text)
+    return expanded_text, expanded_files

tunacode_cli-0.0.30/src/tunacode/utils/token_counter.py

@@ -0,0 +1,23 @@
+"""Simple token counting utility for estimating message sizes."""
+
+
+def estimate_tokens(text: str) -> int:
+    """
+    Estimate token count using a simple character-based approximation.
+
+    This is a rough estimate: ~4 characters per token on average.
+    For more accurate counting, we would need tiktoken or similar.
+    """
+    if not text:
+        return 0
+
+    # Simple approximation: ~4 characters per token
+    # This is roughly accurate for English text
+    return len(text) // 4
+
+
+def format_token_count(count: int) -> str:
+    """Format token count for display."""
+    if count >= 1000:
+        return f"{count:,}"
+    return str(count)

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30/src/tunacode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.29
+Version: 0.0.30
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT

{tunacode_cli-0.0.29 → tunacode_cli-0.0.30}/src/tunacode_cli.egg-info/SOURCES.txt

@@ -73,6 +73,7 @@ src/tunacode/utils/import_cache.py
 src/tunacode/utils/ripgrep.py
 src/tunacode/utils/system.py
 src/tunacode/utils/text_utils.py
+src/tunacode/utils/token_counter.py
 src/tunacode/utils/user_configuration.py
 src/tunacode_cli.egg-info/PKG-INFO
 src/tunacode_cli.egg-info/SOURCES.txt
@@ -87,6 +88,7 @@ tests/test_background_manager.py
 tests/test_config_setup_async.py
 tests/test_fallback_responses.py
 tests/test_fast_glob_search.py
+tests/test_file_reference_context_tracking.py
 tests/test_file_reference_expansion.py
 tests/test_json_tool_parsing.py
 tests/test_orchestrator_file_references.py