bharatcode 0.1.0__py3-none-any.whl

bharatcode/cost.py

@@ -0,0 +1,77 @@
+"""
+Session cost tracker — inspired by Claude Code's /cost command.
+Tracks tokens and calculates DeepSeek API cost per session.
+"""
+from dataclasses import dataclass, field
+
+# DeepSeek pricing (USD per 1M tokens) — updated for v4 models
+PRICING = {
+    "deepseek-v4-flash": {
+        "input":        0.27,
+        "input_cache":  0.07,
+        "output":       1.10,
+    },
+    "deepseek-v4-pro": {
+        "input":        0.55,
+        "input_cache":  0.14,
+        "output":       2.19,
+    },
+}
+# Keep old names working for anyone who has them cached in session_cost.model
+PRICING["deepseek-chat"]     = PRICING["deepseek-v4-flash"]
+PRICING["deepseek-reasoner"] = PRICING["deepseek-v4-pro"]
+
+_DEFAULT_MODEL = "deepseek-v4-flash"
+
+@dataclass
+class SessionCost:
+    model:         str   = "deepseek-v4-flash"
+    prompt_tokens: int   = 0
+    output_tokens: int   = 0
+    turns:         int   = 0
+    tool_calls:    int   = 0
+
+    def add(self, prompt: int, output: int):
+        self.prompt_tokens += prompt
+        self.output_tokens += output
+        self.turns        += 1
+
+    def add_tool(self):
+        self.tool_calls += 1
+
+    @property
+    def total_tokens(self) -> int:
+        return self.prompt_tokens + self.output_tokens
+
+    @property
+    def cost_usd(self) -> float:
+        p = PRICING.get(self.model, PRICING[_DEFAULT_MODEL])
+        in_cost  = (self.prompt_tokens / 1_000_000) * p["input"]
+        out_cost = (self.output_tokens / 1_000_000) * p["output"]
+        return in_cost + out_cost
+
+    def display(self, console):
+        from rich.table import Table
+        from rich import box
+
+        price = PRICING.get(self.model, PRICING[_DEFAULT_MODEL])
+        t = Table(box=box.SIMPLE, show_header=False, padding=(0, 1))
+        t.add_column("key",   style="dim",   no_wrap=True)
+        t.add_column("value", style="cyan",  no_wrap=True)
+
+        from .config import model_label
+        t.add_row("Model",          model_label(self.model))
+        t.add_row("Turns",          str(self.turns))
+        t.add_row("Tool calls",     str(self.tool_calls))
+        t.add_row("Input tokens",   f"{self.prompt_tokens:,}")
+        t.add_row("Output tokens",  f"{self.output_tokens:,}")
+        t.add_row("Total tokens",   f"{self.total_tokens:,}")
+        t.add_row("Est. cost",      f"${self.cost_usd:.4f} USD")
+        t.add_row("Input price",    f"${price['input']}/1M tokens")
+        t.add_row("Output price",   f"${price['output']}/1M tokens")
+
+        console.print("\n[bold]Session Cost[/bold]")
+        console.print(t)
+
+# Global session tracker
+session_cost = SessionCost()

bharatcode/diff.py

@@ -0,0 +1,113 @@
+"""
+Diff display — inspired by Claude Code's StructuredDiff + FileEditToolDiff components.
+Shows colored unified diffs when files are written or edited.
+"""
+import difflib
+from pathlib import Path
+from rich.console import Console
+from rich.text import Text
+from rich.panel import Panel
+
+console = Console()
+
+def show_file_diff(path: str, old_content: str, new_content: str):
+    """Show a colored unified diff between old and new file content."""
+    old_lines = old_content.splitlines(keepends=True)
+    new_lines = new_content.splitlines(keepends=True)
+
+    diff = list(difflib.unified_diff(
+        old_lines, new_lines,
+        fromfile=f"a/{path}",
+        tofile=f"b/{path}",
+        lineterm="",
+    ))
+
+    if not diff:
+        return
+
+    rendered = Text()
+    for line in diff:
+        if line.startswith("+++") or line.startswith("---"):
+            rendered.append(line + "\n", style="bold white")
+        elif line.startswith("@@"):
+            rendered.append(line + "\n", style="cyan")
+        elif line.startswith("+"):
+            rendered.append(line + "\n", style="green")
+        elif line.startswith("-"):
+            rendered.append(line + "\n", style="red")
+        else:
+            rendered.append(line + "\n", style="dim")
+
+    added   = sum(1 for l in diff if l.startswith("+") and not l.startswith("+++"))
+    removed = sum(1 for l in diff if l.startswith("-") and not l.startswith("---"))
+
+    title = (
+        f"[white]{path}[/white]  "
+        f"[green]+{added}[/green] [red]-{removed}[/red]"
+    )
+    try:
+        console.print(Panel(rendered, title=title, border_style="dim", padding=(0, 1)))
+    except UnicodeEncodeError:
+        # Terminal can't render the characters (e.g. emoji on Windows cp1252).
+        # Show a plain summary and keep going — never stop the agent.
+        console.print(
+            f"  [dim]{path}  [green]+{added}[/green] [red]-{removed}[/red]"
+            f"  (diff hidden — file contains Unicode/emoji)[/dim]"
+        )
+
+def capture_write(path: str, new_content: str, mode: str = "w") -> str:
+    """Write file with diff display. Supports mode='w' (overwrite) or 'a' (append)."""
+    if not path or not path.strip():
+        return (
+            "Error: 'path' is empty. Provide the full file path. "
+            "For large files write in chunks using mode='a' to append."
+        )
+    if path.strip() in (".", "./", "/", "\\"):
+        return "Error: 'path' must be a file path like 'C:/chhelu 1/analysis/dashboard.html', not a directory."
+    p = Path(path)
+    if p.exists() and p.is_dir():
+        return f"Error: '{path}' is a directory. Provide a full file path including filename."
+
+    from .tools import _read_text_safe
+    old = _read_text_safe(p) if p.exists() else ""
+    p.parent.mkdir(parents=True, exist_ok=True)
+    write_mode = "a" if mode == "a" else "w"
+    with open(p, write_mode, encoding="utf-8") as f:
+        f.write(new_content)
+    full = _read_text_safe(p)
+    if old != full:
+        show_file_diff(path, old, full)
+    total_lines = len(full.splitlines())
+    action = "Appended to" if write_mode == "a" else "Written"
+    return f"{action} {path} ({total_lines} lines total)"
+
+def capture_edit(path: str, old_string: str, new_string: str, replace_all: bool = False) -> str:
+    """Perform edit via tools.edit_file (CRLF-safe, with nearest-match hints
+    on failure) and show a colored diff on success."""
+    from .tools import edit_file as _edit_impl, _read_text_safe
+
+    if not path or not path.strip():
+        return (
+            "Error: 'path' is empty. Provide the full file path. "
+            "Example: edit_file(path='C:/chhelu 1/analysis/site3_report.html', old_string='...', new_string='...')"
+        )
+    p = Path(path)
+    old_content = None
+    if p.exists() and p.is_file():
+        try:
+            old_content = _read_text_safe(p)
+        except Exception:
+            old_content = None
+
+    result = _edit_impl(path, old_string, new_string, replace_all=replace_all)
+
+    if (old_content is not None
+            and not result.startswith("Error")
+            and not result.startswith("File not found")):
+        try:
+            new_content = _read_text_safe(p)
+            if new_content != old_content:
+                show_file_diff(path, old_content, new_content)
+        except Exception:
+            pass
+    return result

bharatcode/hooks.py

@@ -0,0 +1,75 @@
+"""
+Hook system — inspired by Claude Code's PreToolUse / PostToolUse hooks.
+Hooks run before/after every tool call and can block, modify, or log.
+"""
+from typing import Callable, Optional
+from dataclasses import dataclass, field
+
+@dataclass
+class ToolCall:
+    name: str
+    args: dict
+
+@dataclass
+class HookResult:
+    proceed: bool = True          # False = block the tool call
+    modified_args: dict = None    # Optionally change the args
+    message: str = ""             # Message to show user if blocked
+
+PreToolHook  = Callable[[ToolCall], HookResult]
+PostToolHook = Callable[[ToolCall, str], None]   # (tool_call, result)
+
+class HookRegistry:
+    def __init__(self):
+        self._pre:  list[PreToolHook]  = []
+        self._post: list[PostToolHook] = []
+
+    def add_pre(self, hook: PreToolHook):
+        self._pre.append(hook)
+
+    def add_post(self, hook: PostToolHook):
+        self._post.append(hook)
+
+    def run_pre(self, call: ToolCall) -> HookResult:
+        for hook in self._pre:
+            result = hook(call)
+            if not result.proceed:
+                return result
+            if result.modified_args:
+                call.args = result.modified_args
+        return HookResult(proceed=True)
+
+    def run_post(self, call: ToolCall, result: str):
+        for hook in self._post:
+            hook(call, result)
+
+# Global registry
+hooks = HookRegistry()
+
+# ── Built-in Hooks ────────────────────────────────────────────────────────────
+
+def _safety_hook(call: ToolCall) -> HookResult:
+    """Block dangerous bash commands."""
+    if call.name == "bash":
+        cmd = call.args.get("command", "")
+        dangerous = ["rm -rf /", "format c:", "DROP TABLE", "sudo rm -rf"]
+        for d in dangerous:
+            if d in cmd:
+                return HookResult(proceed=False, message=f"Blocked dangerous command: {d}")
+    return HookResult(proceed=True)
+
+def _log_hook(call: ToolCall) -> HookResult:
+    """Log all tool calls to ~/.bharatcode/tool_log.txt"""
+    import datetime
+    from pathlib import Path
+    log_file = Path.home() / ".bharatcode" / "tool_log.txt"
+    log_file.parent.mkdir(exist_ok=True)
+    with open(log_file, "a") as f:
+        ts = datetime.datetime.now().isoformat()
+        first_arg = list(call.args.values())[0] if call.args else ""
+        f.write(f"{ts} {call.name}({str(first_arg)[:60]})\n")
+    return HookResult(proceed=True)
+
+# Register built-in hooks
+hooks.add_pre(_safety_hook)
+hooks.add_pre(_log_hook)

bharatcode/index.py

@@ -0,0 +1,155 @@
+"""
+Project symbol index (Feature 5) — scans the project directory at session start
+and returns a compact file/symbol map injected into the system prompt so the
+agent knows what exists without cold-reading files just to discover structure.
+"""
+import os
+import re
+from pathlib import Path
+
+SKIP_DIRS = {
+    '__pycache__', 'node_modules', '.git', 'dist', 'build',
+    '.venv', 'venv', 'env', 'ENV', 'coverage', '.next',
+    'out', 'target', 'vendor', 'bower_components', '.mypy_cache',
+    '.pytest_cache', '.tox', 'htmlcov', '.eggs', 'site-packages',
+}
+SKIP_EXTS = {
+    '.pyc', '.pyo', '.pyd', '.so', '.dll', '.exe', '.bin',
+    '.lock', '.whl', '.egg', '.png', '.jpg', '.jpeg', '.gif',
+    '.ico', '.svg', '.mp4', '.mp3', '.zip', '.tar', '.gz',
+    '.map', '.wasm', '.db', '.sqlite', '.sqlite3',
+}
+CODE_EXTS   = {'.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.go',
+               '.rs', '.rb', '.php', '.cs', '.cpp', '.c', '.h', '.kt'}
+CONFIG_EXTS = {'.json', '.yaml', '.yml', '.toml', '.ini', '.cfg',
+               '.conf', '.env', '.md', '.txt', '.sh', '.bat'}
+
+
+def _extract_symbols(path: Path) -> list[str]:
+    """Extract top-level class / function names from a source file."""
+    symbols: list[str] = []
+    try:
+        content = path.read_text(encoding='utf-8', errors='replace')
+        ext = path.suffix.lower()
+
+        if ext == '.py':
+            for m in re.finditer(r'^(?:async\s+)?def\s+(\w+)', content, re.MULTILINE):
+                symbols.append(f'def {m.group(1)}')
+            for m in re.finditer(r'^class\s+(\w+)', content, re.MULTILINE):
+                symbols.append(f'class {m.group(1)}')
+
+        elif ext in ('.js', '.ts', '.jsx', '.tsx'):
+            for m in re.finditer(
+                r'^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)',
+                content, re.MULTILINE
+            ):
+                symbols.append(f'fn {m.group(1)}')
+            for m in re.finditer(r'^(?:export\s+)?class\s+(\w+)', content, re.MULTILINE):
+                symbols.append(f'class {m.group(1)}')
+            for m in re.finditer(
+                r'^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(',
+                content, re.MULTILINE
+            ):
+                symbols.append(f'const {m.group(1)}')
+
+        elif ext == '.go':
+            for m in re.finditer(
+                r'^func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)',
+                content, re.MULTILINE
+            ):
+                symbols.append(f'func {m.group(1)}')
+
+        elif ext in ('.java', '.kt'):
+            for m in re.finditer(
+                r'(?:public|private|protected)\s+(?:static\s+)?(?:\w+\s+)+(\w+)\s*\(',
+                content
+            ):
+                symbols.append(f'fn {m.group(1)}')
+            for m in re.finditer(
+                r'(?:class|interface|object)\s+(\w+)',
+                content
+            ):
+                symbols.append(f'class {m.group(1)}')
+
+    except Exception:
+        pass
+
+    seen: set[str] = set()
+    unique: list[str] = []
+    for s in symbols:
+        if s not in seen:
+            seen.add(s)
+            unique.append(s)
+    return unique[:10]
+
+
+def build_project_index(project_path: str, max_files: int = 150) -> str:
+    """
+    Walk the project and return a compact symbol map string.
+    Injected into the system prompt so the model knows what files/symbols
+    exist without having to call list_dir or read files to discover structure.
+    Returns empty string for empty or single-file projects.
+    """
+    import time
+    root       = Path(project_path).resolve()
+    entries:   list[str] = []
+    file_count = 0
+    deadline   = time.monotonic() + 3.0  # 3-second hard cap
+
+    for dirpath, dirnames, filenames in os.walk(root):
+        if time.monotonic() > deadline:
+            entries.append(f"  ... (index timed out — use glob/grep to find files)")
+            break
+
+        dirnames[:] = sorted(
+            d for d in dirnames
+            if d not in SKIP_DIRS and not d.startswith('.')
+        )
+
+        for fname in sorted(filenames):
+            if file_count >= max_files:
+                entries.append(f"  ... (index capped at {max_files} files — use glob/grep)")
+                break
+            if time.monotonic() > deadline:
+                break
+
+            fpath = Path(dirpath) / fname
+            ext   = fpath.suffix.lower()
+
+            if ext in SKIP_EXTS or fpath.name.startswith('.'):
+                continue
+            try:
+                if fpath.stat().st_size > 400_000:
+                    continue
+            except OSError:
+                continue
+
+            try:
+                rel_path = str(fpath.relative_to(root))
+            except ValueError:
+                rel_path = str(fpath)
+
+            if ext in CODE_EXTS:
+                try:
+                    content    = fpath.read_text(encoding='utf-8', errors='replace')
+                    line_count = content.count('\n') + 1
+                    symbols    = _extract_symbols(fpath)
+                    sym_str    = f"  [{', '.join(symbols[:8])}]" if symbols else ""
+                    entries.append(f"  {rel_path}  ({line_count}L){sym_str}")
+                except Exception:
+                    entries.append(f"  {rel_path}")
+            elif ext in CONFIG_EXTS:
+                entries.append(f"  {rel_path}")
+
+            file_count += 1
+
+        if file_count >= max_files:
+            break
+
+    if not entries:
+        return ""
+
+    lines = [f"\n\n## Project Index — {root.name}  ({file_count} files)"]
+    lines.extend(entries)
+    lines.append("\nUse grep to locate a specific symbol before reading its file.")
+    return "\n".join(lines)