bharatcode 0.1.0__py3-none-any.whl

bharatcode/memory.py

@@ -0,0 +1,286 @@
+"""
+Persistent memory — stores facts across sessions in structured Markdown files.
+Inspired by Claude Code's auto-memory system (MEMORY.md index + topic files).
+
+Storage layout:
+  ~/.bharatcode/memory/
+    MEMORY.md              ← index, always loaded into every system prompt
+    file.md                ← memories tagged "file" (file paths, contents)
+    project.md             ← memories tagged "project" (architecture, decisions)
+    user.md                ← memories tagged "user" (preferences, background)
+    feedback.md            ← memories tagged "feedback" (what to do/avoid)
+    general.md             ← everything else
+    <any_custom_tag>.md    ← agent can use any tag
+
+Each entry in a topic file:
+  - [id=42] [2026-06-08 10:22] content here
+
+MEMORY.md is a one-line-per-entry index pointing to topic files.
+It is loaded verbatim into the system prompt so the model always knows what exists.
+Topic files are loaded fully (budget-capped at ~6K chars total) alongside the index.
+"""
+import json
+from datetime import datetime
+from pathlib import Path
+
+MEMORY_DIR    = Path.home() / ".bharatcode" / "memory"
+MEMORY_INDEX  = MEMORY_DIR / "MEMORY.md"
+_COUNTER_FILE = MEMORY_DIR / ".counter"
+_OLD_JSON     = Path.home() / ".bharatcode" / "memory.json"
+
+
+# ── Internal helpers ──────────────────────────────────────────────────────────
+
+def _ensure() -> None:
+    MEMORY_DIR.mkdir(parents=True, exist_ok=True)
+    if not MEMORY_INDEX.exists():
+        if _OLD_JSON.exists():
+            _migrate_from_json()
+        else:
+            MEMORY_INDEX.write_text("# Memory Index\n\n", encoding="utf-8")
+
+
+def _next_id() -> int:
+    """Global auto-increment counter for memory entry IDs."""
+    try:
+        n = int(_COUNTER_FILE.read_text(encoding="utf-8").strip()) + 1
+    except Exception:
+        n = 1
+    _COUNTER_FILE.write_text(str(n), encoding="utf-8")
+    return n
+
+
+def _tag_file(tag: str) -> Path:
+    safe = "".join(c if c.isalnum() or c in "-_" else "_" for c in tag.lower())
+    return MEMORY_DIR / f"{safe}.md"
+
+
+def _rebuild_index() -> None:
+    """Rewrite MEMORY.md from the current set of topic files."""
+    lines = ["# Memory Index\n"]
+    for md in sorted(MEMORY_DIR.glob("*.md")):
+        if md.name == "MEMORY.md":
+            continue
+        try:
+            content = md.read_text(encoding="utf-8")
+            # first bullet line as description
+            preview = next(
+                (l.strip().lstrip("- ").split("] ", 2)[-1]   # strip [id=N] [ts]
+                 for l in content.splitlines()
+                 if l.strip().startswith("- [")),
+                md.stem,
+            )[:120]
+            lines.append(f"- [{md.stem}]({md.name}) — {preview}")
+        except Exception:
+            lines.append(f"- [{md.stem}]({md.name})")
+    MEMORY_INDEX.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def _migrate_from_json() -> None:
+    """
+    One-time migration: flat memory.json → individual topic .md files.
+    Preserves all entries and assigns sequential IDs.
+    """
+    try:
+        old = json.loads(_OLD_JSON.read_text(encoding="utf-8"))
+    except Exception:
+        old = []
+
+    # Group by tag
+    by_tag: dict[str, list[tuple[int, str, str]]] = {}
+    counter = 0
+    for m in old:
+        counter += 1
+        tag     = m.get("tag", "general")
+        content = (m.get("text") or m.get("content") or "").strip()
+        ts      = (m.get("created") or "")[:16] or "migrated"
+        if content:
+            by_tag.setdefault(tag, []).append((counter, ts, content))
+
+    for tag, entries in by_tag.items():
+        lines = [f"# {tag.title()}\n"]
+        for mid, ts, content in entries:
+            lines.append(f"- [id={mid}] [{ts}] {content}")
+        _tag_file(tag).write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    # Set counter to max ID used
+    _COUNTER_FILE.write_text(str(counter), encoding="utf-8")
+    _rebuild_index()
+
+    # Back up old file
+    try:
+        _OLD_JSON.rename(_OLD_JSON.with_suffix(".json.bak"))
+    except Exception:
+        pass
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+def add_memory(text: str, tag: str = "general") -> dict:
+    """Add a memory entry. Returns dict with id, text, tag, created.
+    Exact-duplicate facts in the same topic file are skipped — the agent
+    saves memory after every task, so without this the store fills with
+    repeats that crowd real facts out of the context budget."""
+    _ensure()
+    ts  = datetime.now().isoformat()
+    ts_short = ts[:16]
+    text = text.strip()
+
+    f = _tag_file(tag)
+    if f.exists() and text:
+        try:
+            if text in f.read_text(encoding="utf-8"):
+                return {"id": -1, "text": text, "tag": tag, "created": ts, "duplicate": True}
+        except Exception:
+            pass
+
+    mid = _next_id()
+    if not f.exists():
+        f.write_text(f"# {tag.title()}\n\n", encoding="utf-8")
+    with open(f, "a", encoding="utf-8") as fp:
+        fp.write(f"- [id={mid}] [{ts_short}] {text}\n")
+
+    _rebuild_index()
+    return {"id": mid, "text": text, "tag": tag, "created": ts}
+
+
+def delete_memory(memory_id: int) -> bool:
+    """Delete a memory entry by its ID. Returns True if found and deleted."""
+    _ensure()
+    marker = f"[id={memory_id}]"
+    for md in MEMORY_DIR.glob("*.md"):
+        if md.name == "MEMORY.md":
+            continue
+        try:
+            content = md.read_text(encoding="utf-8")
+            if marker not in content:
+                continue
+            lines = content.splitlines(keepends=True)
+            new_lines = [l for l in lines if marker not in l]
+            md.write_text("".join(new_lines), encoding="utf-8")
+            _rebuild_index()
+            return True
+        except Exception:
+            pass
+    return False
+
+
+def load_memories() -> list[dict]:
+    """Backward compat — return flat list of {id, text, tag, created} dicts."""
+    _ensure()
+    result = []
+    for md in sorted(MEMORY_DIR.glob("*.md")):
+        if md.name == "MEMORY.md":
+            continue
+        tag = md.stem
+        try:
+            for line in md.read_text(encoding="utf-8").splitlines():
+                if not line.strip().startswith("- [id="):
+                    continue
+                # Parse: - [id=N] [YYYY-MM-DD HH:MM] content
+                rest = line.lstrip("- ")
+                # Extract id
+                id_end = rest.find("]")
+                try:
+                    mid = int(rest[4:id_end])   # rest starts with "[id=N]"
+                except Exception:
+                    mid = 0
+                rest = rest[id_end + 2:].strip()   # skip "] "
+                # Extract timestamp
+                if rest.startswith("["):
+                    ts_end = rest.find("]")
+                    ts = rest[1:ts_end]
+                    rest = rest[ts_end + 2:].strip()
+                else:
+                    ts = ""
+                result.append({"id": mid, "text": rest, "tag": tag, "created": ts})
+        except Exception:
+            pass
+    return result
+
+
+def remember(text: str, tag: str = "project") -> str:
+    """Tool-callable: save a memory and return confirmation."""
+    entry = add_memory(text, tag)
+    if entry.get("duplicate"):
+        return f"Already in memory — skipped duplicate: {text[:80]}"
+    return f"Memory saved (id={entry['id']}): {text[:80]}"
+
+
+def memories_to_context() -> str:
+    """
+    Build the memory section injected into the system prompt.
+    Always includes MEMORY.md index. Then loads all topic files
+    (newest first) up to a ~6K char budget so large memory stores
+    don't flood the context.
+    """
+    _ensure()
+    if not MEMORY_INDEX.exists():
+        return ""
+
+    index = MEMORY_INDEX.read_text(encoding="utf-8").strip()
+    if not index or index == "# Memory Index":
+        return ""
+
+    parts = [f"\n\n## Persistent Memory (from past sessions)\n\n{index}"]
+
+    # Load topic files up to budget — NEWEST entries first within each file,
+    # so when the budget cuts anything it always cuts the OLDEST facts.
+    # (Topic files are append-only: newest entries live at the bottom.)
+    budget = 6000
+    for md in sorted(MEMORY_DIR.glob("*.md"), key=lambda p: p.stat().st_mtime, reverse=True):
+        if md.name == "MEMORY.md":
+            continue
+        if budget <= 0:
+            break
+        try:
+            entry_lines = [
+                l for l in md.read_text(encoding="utf-8").splitlines()
+                if l.strip().startswith("- [id=")
+            ]
+            if not entry_lines:
+                continue
+            entry_lines = entry_lines[::-1][:40]   # newest first, max 40 per topic
+            chunk = f"\n\n### {md.stem} (newest first)\n" + "\n".join(entry_lines)
+            if len(chunk) > budget:
+                chunk = chunk[:budget] + "\n  ...(older entries omitted)"
+            parts.append(chunk)
+            budget -= len(chunk)
+        except Exception:
+            pass
+
+    return "".join(parts)
+
+
+def show_memories(console) -> None:
+    """Pretty-print all memory entries for /memory list."""
+    _ensure()
+    files = [f for f in sorted(MEMORY_DIR.glob("*.md")) if f.name != "MEMORY.md"]
+
+    if not files:
+        console.print("[dim]No memories saved yet. The agent saves memories automatically, "
+                      "or use: /memory add <text>[/dim]")
+        return
+
+    console.print(f"\n[bold]Memory[/bold]  [dim]{MEMORY_DIR}[/dim]\n")
+    total = 0
+    for md in files:
+        try:
+            content = md.read_text(encoding="utf-8").strip()
+            entries = [l for l in content.splitlines() if l.strip().startswith("- [id=")]
+            if not entries:
+                continue
+            console.print(f"  [bold cyan]{md.stem}[/bold cyan]  [dim]({len(entries)} entries)[/dim]")
+            for line in entries:
+                # Parse display: strip [id=N] prefix, keep [ts] and content
+                rest = line.lstrip("- ")
+                id_end = rest.find("]")
+                mid = rest[4:id_end] if rest.startswith("[id=") else "?"
+                rest = rest[id_end + 2:].strip()
+                console.print(f"    [dim]{mid:>4}[/dim]  {rest}")
+                total += 1
+            console.print()
+        except Exception:
+            pass
+
+    console.print(f"[dim]  {total} total entries — /memory del <id> to remove[/dim]\n")

bharatcode/permissions.py

@@ -0,0 +1,99 @@
+"""
+Permission system — inspired by Claude Code's BashPermissionRequest component.
+Ask user allow/deny/always before running bash commands.
+"""
+import json
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+console = Console()
+
+_SESSION_ALWAYS: set[str] = set()   # commands allowed for this session
+_ALWAYS_FILE = Path.home() / ".bharatcode" / "always_allow.json"
+
+def _load_always() -> set[str]:
+    if _ALWAYS_FILE.exists():
+        try:
+            return set(json.loads(_ALWAYS_FILE.read_text()))
+        except Exception:
+            return set()
+    return set()
+
+def _save_always(items: set[str]):
+    _ALWAYS_FILE.parent.mkdir(exist_ok=True)
+    _ALWAYS_FILE.write_text(json.dumps(sorted(items)))
+
+_PERMANENT_ALWAYS: set[str] = _load_always()
+
+def _command_key(cmd: str) -> str:
+    """Normalize a command for matching (first word / verb)."""
+    return cmd.strip().split()[0] if cmd.strip() else ""
+
+def needs_approval(tool_name: str, args: dict, auto_approve: bool = False) -> tuple[bool, str]:
+    """
+    Returns (approved, reason).
+    Safe read-only tools are auto-approved.
+    Bash requires user confirmation unless always-allowed.
+    """
+    if auto_approve:
+        return True, "auto"
+
+    # Read-only tools: always OK
+    if tool_name in ("read_file", "glob", "grep"):
+        return True, "safe"
+
+    # write/edit — auto-approve (user sees the diff anyway)
+    if tool_name in ("write_file", "edit_file"):
+        return True, "safe"
+
+    # bash — check allow lists
+    if tool_name == "bash":
+        cmd = args.get("command", "")
+        key = _command_key(cmd)
+        if key in _PERMANENT_ALWAYS or key in _SESSION_ALWAYS:
+            return True, "always-allowed"
+        return False, "needs-approval"
+
+    return True, "safe"
+
+def ask_permission(tool_name: str, args: dict) -> bool:
+    """
+    Show a permission dialog for bash commands.
+    Returns True if approved.
+    """
+    cmd = args.get("command", "")
+
+    console.print()
+    console.print(Panel(
+        f"[bold yellow]{cmd}[/bold yellow]",
+        title="[bold red] Sylithe Code wants to run a command [/bold red]",
+        border_style="yellow",
+        padding=(0, 1),
+    ))
+    console.print(
+        "  [green]y[/green] Allow once  "
+        "[cyan]s[/cyan] Allow for session  "
+        "[blue]a[/blue] Always allow  "
+        "[red]n[/red] Deny"
+    )
+
+    choice = Prompt.ask("  [dim]Permission[/dim]", choices=["y", "s", "a", "n"], default="y")
+
+    if choice == "n":
+        console.print("  [red]Denied.[/red]")
+        return False
+
+    key = _command_key(cmd)
+
+    if choice == "s":
+        _SESSION_ALWAYS.add(key)
+        console.print(f"  [cyan]Allowed for this session: {key}[/cyan]")
+    elif choice == "a":
+        _PERMANENT_ALWAYS.add(key)
+        _save_always(_PERMANENT_ALWAYS)
+        console.print(f"  [blue]Always allowed: {key}[/blue]")
+
+    console.print()
+    return True

bharatcode/project.py

@@ -0,0 +1,179 @@
+"""
+Project auto-detection — inspired by Claude Code's detectRepository.
+Reads package.json / requirements.txt / pom.xml / build.gradle / go.mod
+and injects project context into every system prompt.
+"""
+import json
+from pathlib import Path
+
+
+def detect_project(cwd: str = ".") -> dict:
+    """Detect project type and metadata from common config files."""
+    root = Path(cwd)
+    info = {
+        "type":     "unknown",
+        "language": "unknown",
+        "name":     root.name,
+        "version":  "",
+        "deps":     [],
+        "scripts":  [],
+        "test_cmd": "",
+        "run_cmd":  "",
+        "framework": "",
+    }
+
+    # Node.js
+    pkg = root / "package.json"
+    if pkg.exists():
+        try:
+            d = json.loads(pkg.read_text(encoding="utf-8"))
+            info.update({
+                "type":     "node",
+                "language": "javascript" if not (root / "tsconfig.json").exists() else "typescript",
+                "name":     d.get("name", root.name),
+                "version":  d.get("version", ""),
+                "deps":     list(d.get("dependencies", {}).keys())[:20],
+                "scripts":  list(d.get("scripts", {}).keys()),
+                "test_cmd": "npm test",
+                "run_cmd":  "npm start",
+                "framework": _detect_node_framework(d),
+            })
+        except Exception:
+            pass
+        return info
+
+    # Python
+    for pyfile in ["requirements.txt", "pyproject.toml", "setup.py", "Pipfile"]:
+        if (root / pyfile).exists():
+            info["type"]     = "python"
+            info["language"] = "python"
+            info["test_cmd"] = "pytest"
+            info["run_cmd"]  = "python app.py"
+
+            if pyfile == "requirements.txt":
+                lines = (root / pyfile).read_text(encoding="utf-8").splitlines()
+                info["deps"] = [l.split("==")[0].split(">=")[0].strip()
+                                for l in lines if l.strip() and not l.startswith("#")][:20]
+                info["framework"] = _detect_python_framework(info["deps"])
+
+            elif pyfile == "pyproject.toml":
+                try:
+                    import tomllib
+                    with open(root / pyfile, "rb") as f:
+                        d = tomllib.load(f)
+                    proj = d.get("project", {})
+                    info["name"]    = proj.get("name", root.name)
+                    info["version"] = proj.get("version", "")
+                    info["deps"]    = [str(d).split("[")[0].split(">=")[0].split("==")[0].strip()
+                                       for d in proj.get("dependencies", [])][:20]
+                    info["framework"] = _detect_python_framework(info["deps"])
+                    scripts = d.get("project", {}).get("scripts", {})
+                    if scripts:
+                        info["run_cmd"] = f"python -m {list(scripts.values())[0]}"
+                except Exception:
+                    pass
+
+            return info
+
+    # Java / Maven
+    if (root / "pom.xml").exists():
+        info.update({
+            "type":     "java",
+            "language": "java",
+            "test_cmd": "mvn test",
+            "run_cmd":  "mvn spring-boot:run",
+            "framework": "Spring Boot",
+        })
+        return info
+
+    # Java / Gradle
+    if (root / "build.gradle").exists() or (root / "build.gradle.kts").exists():
+        kts = (root / "build.gradle.kts").exists()
+        info.update({
+            "type":     "java",
+            "language": "kotlin" if kts else "java",
+            "test_cmd": "./gradlew test",
+            "run_cmd":  "./gradlew bootRun",
+            "framework": "Spring Boot",
+        })
+        return info
+
+    # Go
+    if (root / "go.mod").exists():
+        info.update({
+            "type":     "go",
+            "language": "go",
+            "test_cmd": "go test ./...",
+            "run_cmd":  "go run .",
+        })
+        return info
+
+    # Rust
+    if (root / "Cargo.toml").exists():
+        info.update({
+            "type":     "rust",
+            "language": "rust",
+            "test_cmd": "cargo test",
+            "run_cmd":  "cargo run",
+        })
+        return info
+
+    # Flutter / Dart
+    if (root / "pubspec.yaml").exists():
+        info.update({
+            "type":     "flutter",
+            "language": "dart",
+            "test_cmd": "flutter test",
+            "run_cmd":  "flutter run",
+            "framework": "Flutter",
+        })
+        return info
+
+    return info
+
+
+def _detect_node_framework(pkg: dict) -> str:
+    deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+    if "next" in deps:       return "Next.js"
+    if "react" in deps:      return "React"
+    if "@angular/core" in deps: return "Angular"
+    if "vue" in deps:        return "Vue.js"
+    if "express" in deps:    return "Express.js"
+    if "fastify" in deps:    return "Fastify"
+    if "nestjs" in deps:     return "NestJS"
+    return ""
+
+
+def _detect_python_framework(deps: list[str]) -> str:
+    deps_lower = [d.lower() for d in deps]
+    if "django" in deps_lower:   return "Django"
+    if "flask" in deps_lower:    return "Flask"
+    if "fastapi" in deps_lower:  return "FastAPI"
+    if "streamlit" in deps_lower: return "Streamlit"
+    if "celery" in deps_lower:   return "Celery"
+    return ""
+
+
+def project_context_string(cwd: str = ".") -> str:
+    """Returns a string to inject into the system prompt about this project."""
+    info = detect_project(cwd)
+    if info["type"] == "unknown":
+        return ""
+
+    lines = [f"\n\n## Auto-detected Project Context"]
+    lines.append(f"- **Project**: {info['name']}")
+    lines.append(f"- **Language**: {info['language']}")
+    if info.get("framework"):
+        lines.append(f"- **Framework**: {info['framework']}")
+    if info.get("version"):
+        lines.append(f"- **Version**: {info['version']}")
+    if info.get("test_cmd"):
+        lines.append(f"- **Test command**: `{info['test_cmd']}`")
+    if info.get("run_cmd"):
+        lines.append(f"- **Run command**: `{info['run_cmd']}`")
+    if info.get("deps"):
+        lines.append(f"- **Key dependencies**: {', '.join(info['deps'][:10])}")
+    if info.get("scripts"):
+        lines.append(f"- **Scripts**: {', '.join(info['scripts'][:8])}")
+
+    return "\n".join(lines)

bharatcode/session_storage.py

@@ -0,0 +1,108 @@
+"""
+Session persistence — saves conversation history to JSONL as it happens,
+so sessions survive process crashes and can be resumed in a new terminal.
+
+Storage layout:
+  ~/.bharatcode/sessions/<project_hash>/<session_id>.jsonl
+  ~/.bharatcode/sessions/<project_hash>/latest          ← ID of most recent session
+
+One JSON object per line. Messages appended in real-time so a crash mid-turn
+only loses the in-progress messages, not the whole session.
+"""
+import json
+import uuid
+import hashlib
+from pathlib import Path
+from typing import Optional
+
+_SESSIONS_ROOT = Path.home() / ".bharatcode" / "sessions"
+
+
+# ── Path helpers ──────────────────────────────────────────────────────────────
+
+def _project_dir(project_path: str) -> Path:
+    h = hashlib.md5(str(project_path).encode()).hexdigest()[:10]
+    d = _SESSIONS_ROOT / h
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def new_session_id() -> str:
+    return uuid.uuid4().hex[:12]
+
+
+def session_path(project_path: str, session_id: str) -> Path:
+    return _project_dir(project_path) / f"{session_id}.jsonl"
+
+
+# ── Read / Write ──────────────────────────────────────────────────────────────
+
+def append_messages(path: Path, messages: list[dict]) -> None:
+    """
+    Append messages to the JSONL file. Fire-and-forget — never raises.
+    Called by interactive_mode after each agent turn completes.
+    """
+    if not messages:
+        return
+    try:
+        with open(path, "a", encoding="utf-8") as f:
+            for msg in messages:
+                f.write(json.dumps(msg, ensure_ascii=False) + "\n")
+    except Exception:
+        pass
+
+
+def load_messages(path: Path) -> list[dict]:
+    """Load all valid messages from a JSONL session file."""
+    if not path or not path.exists():
+        return []
+    messages = []
+    try:
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line:
+                try:
+                    messages.append(json.loads(line))
+                except json.JSONDecodeError:
+                    pass
+    except Exception:
+        pass
+    return messages
+
+
+# ── Session discovery ─────────────────────────────────────────────────────────
+
+def save_latest_pointer(project_path: str, session_id: str) -> None:
+    (_project_dir(project_path) / "latest").write_text(session_id, encoding="utf-8")
+
+
+def list_recent(project_path: str, max_n: int = 5) -> list[dict]:
+    """
+    Return metadata for the N most recent sessions for this project.
+    Each entry: {session_id, path, turns, last_message, mtime_str}
+    """
+    d = _project_dir(project_path)
+    results = []
+    for f in sorted(d.glob("*.jsonl"), key=lambda p: p.stat().st_mtime, reverse=True):
+        messages = load_messages(f)
+        if not messages:
+            continue
+        user_msgs = [m for m in messages if m.get("role") == "user"]
+        if not user_msgs:
+            continue
+        last = user_msgs[-1].get("content", "")
+        last_preview = last[:70].replace("\n", " ") if last else ""
+        import datetime
+        mtime = f.stat().st_mtime
+        dt = datetime.datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M")
+        results.append({
+            "session_id":   f.stem,
+            "path":         f,
+            "turns":        len(user_msgs),
+            "last_message": last_preview,
+            "mtime":        mtime,
+            "mtime_str":    dt,
+        })
+        if len(results) >= max_n:
+            break
+    return results