devagent-cli 3.2.1__py3-none-any.whl

devagent/utils/logger.py

@@ -0,0 +1,94 @@
+"""
+Structured JSON logger — writes every agent step to logs/run.json.
+
+Tracks: thoughts, actions, observations, reviews, test results,
+latency, model info, and benchmark performance.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+class AgentLogger:
+    """Append-only JSON logger that writes each step as an object in an array."""
+
+    def __init__(self, log_dir: str = "logs"):
+        self._log_dir = Path(log_dir)
+        self._log_dir.mkdir(parents=True, exist_ok=True)
+        self._log_file = self._log_dir / "run.json"
+        self._entries: list[dict[str, Any]] = []
+
+    def log_step(
+        self,
+        step: int,
+        thought: str,
+        action: str,
+        observation: str,
+        review: str,
+        test_result: str,
+        status: str,
+        *,
+        latency: float = 0.0,
+        model: str = "",
+        patch_summary: str = "",
+    ) -> None:
+        """Log a complete agent iteration step."""
+        entry = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "step": step,
+            "thought": thought,
+            "action": action,
+            "observation": observation[:2000],
+            "review": review,
+            "test_result": test_result[:2000],
+            "latency": f"{latency:.2f}s" if latency else "",
+            "model": model,
+            "patch": patch_summary,
+            "status": status,
+        }
+        self._entries.append(entry)
+        self._flush()
+        self._print_step(entry)
+
+    def log_event(self, event: str, data: dict[str, Any] | None = None) -> None:
+        """Log a freeform event (startup, shutdown, error, etc.)."""
+        entry = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "event": event,
+            **(data or {}),
+        }
+        self._entries.append(entry)
+        self._flush()
+
+    def _flush(self) -> None:
+        """Write the full log array to disk."""
+        try:
+            self._log_file.write_text(
+                json.dumps(self._entries, indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
+        except Exception as exc:  # noqa: BLE001
+            print(f"[LOGGER ERROR] {exc}")
+
+    @staticmethod
+    def _print_step(entry: dict[str, Any]) -> None:
+        """Pretty-print a step to the console."""
+        print("\n" + "=" * 60)
+        print(f"  STEP {entry['step']}  |  STATUS: {entry['status']}")
+        print("=" * 60)
+        print(f"  THOUGHT:     {entry['thought']}")
+        print(f"  ACTION:      {entry['action']}")
+        print(f"  OBSERVATION: {entry['observation'][:1500]}")
+        if entry.get("review"):
+            print(f"  REVIEW:      {entry['review']}")
+        if entry.get("patch"):
+            print(f"  PATCH:       {entry['patch'][:200]}")
+        if entry.get("latency"):
+            print(f"  LATENCY:     {entry['latency']}")
+        print(f"  TEST RESULT: {entry['test_result'][:1500]}")
+        print("=" * 60)

devagent/utils/metrics.py

@@ -0,0 +1,130 @@
+"""
+Metrics collector — tracks latency, retries, token estimates, and benchmark results.
+
+All metrics are stored in-memory and flushed to disk on demand.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class StepMetrics:
+    """Metrics for a single agent step."""
+    step: int = 0
+    action: str = ""
+    latency_s: float = 0.0
+    prompt_chars: int = 0
+    response_chars: int = 0
+    estimated_tokens: int = 0  # rough: chars / 4
+    status: str = ""
+
+
+@dataclass
+class RunMetrics:
+    """Aggregated metrics for an entire agent run."""
+
+    model: str = ""
+    task: str = ""
+    start_time: float = field(default_factory=time.time)
+    end_time: float = 0.0
+    total_steps: int = 0
+    retries: int = 0
+    successes: int = 0
+    failures: int = 0
+    total_latency_s: float = 0.0
+    total_estimated_tokens: int = 0
+    steps: list[StepMetrics] = field(default_factory=list)
+
+    # ── Recording ─────────────────────────────────────────────────────────
+
+    def record_step(
+        self,
+        step: int,
+        action: str,
+        latency_s: float,
+        prompt_chars: int,
+        response_chars: int,
+        status: str,
+    ) -> StepMetrics:
+        """Record metrics for a single step."""
+        estimated_tokens = (prompt_chars + response_chars) // 4
+        sm = StepMetrics(
+            step=step,
+            action=action,
+            latency_s=round(latency_s, 3),
+            prompt_chars=prompt_chars,
+            response_chars=response_chars,
+            estimated_tokens=estimated_tokens,
+            status=status,
+        )
+        self.steps.append(sm)
+        self.total_steps += 1
+        self.total_latency_s += latency_s
+        self.total_estimated_tokens += estimated_tokens
+        if status == "success":
+            self.successes += 1
+        elif status == "fail":
+            self.failures += 1
+        return sm
+
+    def finalize(self) -> None:
+        """Mark the run as complete."""
+        self.end_time = time.time()
+
+    # ── Reporting ─────────────────────────────────────────────────────────
+
+    def summary(self) -> dict[str, Any]:
+        """Return a JSON-serialisable summary."""
+        elapsed = (self.end_time or time.time()) - self.start_time
+        return {
+            "model": self.model,
+            "task": self.task[:100],
+            "total_steps": self.total_steps,
+            "retries": self.retries,
+            "successes": self.successes,
+            "failures": self.failures,
+            "total_latency_s": round(self.total_latency_s, 2),
+            "wall_time_s": round(elapsed, 2),
+            "total_estimated_tokens": self.total_estimated_tokens,
+            "avg_step_latency_s": round(
+                self.total_latency_s / max(self.total_steps, 1), 2
+            ),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        }
+
+    def save(self, log_dir: str) -> str:
+        """Save metrics to disk."""
+        path = Path(log_dir)
+        path.mkdir(parents=True, exist_ok=True)
+        out_file = path / "metrics.json"
+        try:
+            out_file.write_text(
+                json.dumps(self.summary(), indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
+            return str(out_file)
+        except Exception as exc:
+            print(f"[METRICS ERROR] {exc}")
+            return ""
+
+
+class Timer:
+    """Simple context-manager timer."""
+
+    def __init__(self) -> None:
+        self.start = 0.0
+        self.elapsed = 0.0
+
+    def __enter__(self) -> "Timer":
+        self.start = time.time()
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.elapsed = time.time() - self.start

devagent_cli-3.2.1.dist-info/METADATA

@@ -0,0 +1,480 @@
+Metadata-Version: 2.4
+Name: devagent-cli
+Version: 3.2.1
+Summary: Professional Local autonomous coding agent powered by Ollama
+Author: Vedant Jadhav
+License: MIT
+Keywords: ai,agent,coding,ollama,local,devagent,devagent-cli
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich
+Requires-Dist: pytest
+Requires-Dist: requests
+Requires-Dist: ollama
+Requires-Dist: faiss-cpu
+Provides-Extra: semantic
+Requires-Dist: sentence-transformers; extra == "semantic"
+Provides-Extra: lint
+Requires-Dist: flake8; extra == "lint"
+Dynamic: license-file
+
+<div align="center">
+
+# 🧠 DevAgent
+
+### A Lightweight Local Open-Source Miniature of Claude Code CLI
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.11+](https://img.shields.io/badge/Python-3.11+-3776AB.svg?logo=python&logoColor=white)](https://www.python.org/)
+[![Ollama](https://img.shields.io/badge/Ollama-Local%20LLM-black.svg?logo=ollama)](https://ollama.ai)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
+[![GitHub stars](https://img.shields.io/github/stars/VedantJadhav701/Developer-Code-Intelligence-Agent?style=social)](https://github.com/VedantJadhav701/Developer-Code-Intelligence-Agent)
+
+**A production-grade local coding agent that finds bugs, writes patches, reviews its own code, and validates with tests — all offline, all local, zero API costs.**
+
+[Quick Start](#-quick-start) •
+[Architecture](#-architecture) •
+[Benchmarks](#-benchmarks) •
+[Roadmap](#-roadmap) •
+[Contributing](#-contributing)
+
+---
+
+</div>
+
+## 🤔 Why DevAgent?
+
+Most AI coding tools are **chatbots** — they suggest code, you copy-paste, you pray.
+
+DevAgent is a **real agent** with a retrieval-first, tool-grounded architecture:
+
+| | Chatbot | DevAgent |
+|---|---|---|
+| Searches your codebase | ❌ | ✅ ripgrep + semantic search |
+| Retrieves relevant code | ❌ | ✅ FAISS embeddings |
+| Plans before coding | ❌ | ✅ Planner layer |
+| Generates patches | ❌ | ✅ Unified diffs |
+| Reviews its own output | ❌ | ✅ Self-critique loop |
+| Runs your tests | ❌ | ✅ pytest integration |
+| Retries on failure | ❌ | ✅ Up to N iterations |
+| Works in sandbox | ❌ | ✅ Isolated workspace |
+| Works offline | ❌ | ✅ 100% local via Ollama |
+| Costs money | 💸 | ✅ Free forever |
+
+> **Philosophy:** Execution > Reasoning. Tools > Hallucination. Retrieval > Huge Context. Reliability > Intelligence.
+
+---
+
+## ✨ Features
+
+🔁 **ReAct Loop** — Thought → Action → Observation → Fix → Review → Test cycle
+
+🧠 **Planner** — LLM generates an action plan before coding
+
+🔍 **Semantic Search** — FAISS + sentence-transformers code retrieval
+
+🔎 **Code Search** — ripgrep-powered with cross-platform fallback
+
+📝 **Self-Review** — LLM critiques its own fixes, revises until approved
+
+🩹 **Patch Engine** — Line-level unified diffs instead of full file rewrites
+
+🧪 **Test-Driven** — Runs pytest after every fix, retries on failure
+
+🏖️ **Sandbox Mode** — Agent works in an isolated copy, applies changes only on success
+
+📊 **Benchmarks** — 5 built-in benchmark suites with automated evaluation
+
+📈 **Metrics** — Latency, token estimates, retries, and performance tracking
+
+📋 **Full Audit Trail** — Every step logged to `logs/run.json`
+
+🔒 **100% Offline** — Runs on Ollama with small models (2-4 GB)
+
+⚡ **Low Resource** — Works on RTX 3050 (4 GB VRAM) / 16 GB RAM
+
+---
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- [Python 3.11+](https://www.python.org/downloads/)
+- [Ollama](https://ollama.ai) installed and running
+
+### Install & Setup
+
+```bash
+# 1. Clone
+git clone https://github.com/VedantJadhav701/Developer-Code-Intelligence-Agent.git
+cd Developer-Code-Intelligence-Agent
+
+# 2. Install
+pip install devagent-cli  # (Coming soon to PyPI)
+# Or locally: pip install -e .
+
+# 3. Verify System (CRITICAL)
+# This checks your Python environment, Ollama connection, and dependencies
+devagent doctor
+
+# 4. Pull the model
+ollama pull qwen2.5-coder:3b
+
+# 5. Run!
+devagent run --task "Fix the divide-by-zero bug" --root ./demo_project
+```
+
+### CLI Subcommands
+
+| Command | Description |
+|---|---|
+| `devagent run` | Execute a coding task on a project |
+| `devagent benchmark` | Run the automated benchmark suite |
+| `devagent doctor` | Check system health and dependencies |
+| `devagent models` | List available Ollama models |
+| `devagent version` | Show current version |
+
+### ✨ New: Trust & Safety
+
+#### 🛡️ Reliability Hardening (v3.2.1+)
+DevAgent is now built for **Enterprise-grade reliability** in complex projects:
+- **Path Anchoring**: Automatically corrects "root hallucinations." If the agent targets a file in a subdirectory but assumes it's at the root, the system auto-anchors it to the correct project location.
+- **Forensic Test Detection**: Built-in intelligence to "see through" environment noise. It detects successful test runs even if unrelated parts of the repository have collection errors.
+- **Confidence Scoring**: Every fix is graded (0-100%) based on test results, surgical precision, and self-review quality.
+
+#### 🕹️ Interactive Mode
+Run with `--interactive` (or `-i`) to review diffs before they are applied to your project.
+```bash
+devagent run --task "Fix bug" --interactive
+```
+
+---
+
+## 🏗️ Architecture
+
+```mermaid
+graph TD
+    CLI[DevAgent CLI] --> Orchestrator[ReAct Orchestrator]
+    Orchestrator --> Memory[Working Memory]
+    Orchestrator --> Retrieval[Semantic Retrieval FAISS]
+    Orchestrator --> Tools[Tool Suite: pytest, ripgrep, git]
+    Orchestrator --> Reviewer[Self-Review Loop]
+    Reviewer --> Patch[Surgical Patch Engine]
+    Patch --> Sandbox[Sandbox Environment]
+```
+
+No API keys. No sign-ups. No cloud.
+
+### Optional: Enable Semantic Search
+
+```bash
+pip install faiss-cpu sentence-transformers
+```
+
+Without these, DevAgent falls back to keyword search — still fully functional.
+
+---
+
+## 🎬 Demo
+
+```
+ ____              _                    _
+|  _ \  _____   __/ \   __ _  ___ _ __ | |_
+| | | |/ _ \ \ / / _ \ / _` |/ _ \ '_ \| __|
+| |_| |  __/\ V / ___ \ (_| |  __/ | | | |_
+|____/ \___| \_/_/   \_\__, |\___|_| |_|\__|
+                       |___/
+
++==========================================================+
+|        DEVELOPER CODE INTELLIGENCE AGENT                 |
+|        Model: qwen2.5-coder:3b                          |
+|        Sandbox: OFF                                      |
++==========================================================+
+
+  [PLAN] LIKELY_FILES: calculator.py
+  1. search_code: divide
+  2. read_file: calculator.py
+  3. run_tests
+
+  ----------------------------------------
+  ITERATION 1/5
+  ----------------------------------------
+  [TOOL] Executing: search_code(divide)
+  >> Found: calculator.py:10:def divide(a, b)
+  [REVIEW] #1: APPROVED
+  >> Tests: 5 passed ✓
+
+  [OK]  AGENT COMPLETED SUCCESSFULLY
+
+  Status:     success
+  Steps used: 1/5
+  Patches:    1
+  Time:       8.2s
+```
+
+---
+
+## 🏗️ Architecture
+
+```
+                    ┌─────────────────────────────┐
+                    │       CLI (main.py)          │
+                    │  --task --root --model       │
+                    │  --sandbox --benchmark       │
+                    │  --auto-commit --auto-push   │
+                    └──────────┬──────────────────┘
+                               │
+                    ┌──────────▼──────────────────┐
+                    │     Planner Layer            │
+                    │  Identifies files + strategy │
+                    └──────────┬──────────────────┘
+                               │
+                    ┌──────────▼──────────────────┐
+                    │  Retrieval Layer (Memory)    │
+                    │  FAISS + Sentence-Transformers│
+                    │  Chunk → Embed → Top-K       │
+                    └──────────┬──────────────────┘
+                               │
+                    ┌──────────▼──────────────────┐
+                    │     ReAct Agent Loop         │
+                    │                              │
+                    │  1. THOUGHT   (LLM)          │
+                    │  2. ACTION    (Tool)          │
+                    │  3. OBSERVATION               │
+                    │  4. FIX       (LLM)          │
+                    │  5. REVIEW    (LLM)          │
+                    │  6. PATCH     (Diff Engine)   │
+                    │  7. TEST      (pytest)        │
+                    │                              │
+                    │  if FAIL → retry              │
+                    │  if PASS → done ✓            │
+                    └──┬──────────────┬───────────┘
+                       │              │
+              ┌────────▼──┐    ┌──────▼──────┐
+              │   Tools   │    │   Ollama    │
+              │           │    │  (Local)    │
+              │ • search  │    │             │
+              │ • semantic│    │ qwen2.5-    │
+              │ • read    │    │  coder:3b   │
+              │ • patch   │    │ phi3:mini   │
+              │ • pytest  │    │ mistral:7b  │
+              │ • flake8  │    │             │
+              │ • git_diff│    └─────────────┘
+              │ • sandbox │
+              └───────────┘
+```
+
+### 9-Layer Architecture
+
+| Layer | Module | Purpose |
+|---|---|---|
+| 1. CLI | `main.py` | Argument parsing, mode selection, banner |
+| 2. Planner | `app/planner.py` | Task interpretation, file identification |
+| 3. Retrieval | `app/memory.py` | FAISS index, semantic chunking, Top-K search |
+| 4. Tools | `tools/*` | 8 real tools: search, semantic_search, read, write, test, lint, git, sandbox |
+| 5. Agent | `app/agent.py` | ReAct orchestration loop |
+| 6. Review | `app/reviewer.py` | Self-critique with APPROVED/REVISE |
+| 7. Validation | `tools/test_runner.py` | pytest + flake8 execution feedback |
+| 8. Logging | `utils/logger.py` | Structured JSON audit trail |
+| 9. Safety | `app/sandbox.py` | Isolated workspace, path validation |
+
+---
+
+## 📁 Project Structure
+
+```
+Developer-Code-Intelligence-Agent/
+├── app/
+│   ├── agent.py            # Core ReAct agent engine
+│   ├── planner.py          # Task planning layer
+│   ├── reviewer.py         # Self-review module
+│   ├── llm.py              # Ollama integration
+│   ├── memory.py           # FAISS retrieval + working memory
+│   ├── patcher.py          # Unified diff patch engine
+│   ├── sandbox.py          # Sandbox workspace manager
+│   └── state.py            # Shared state dataclass
+├── tools/
+│   ├── search.py           # Code search (ripgrep + fallbacks)
+│   ├── semantic_search.py  # FAISS semantic search
+│   ├── file_ops.py         # Safe file read/write
+│   ├── test_runner.py      # pytest runner
+│   ├── linter.py           # flake8 linter
+│   ├── git_tools.py        # Git diff/commit/push
+│   └── benchmark_runner.py # Benchmark evaluation
+├── utils/
+│   ├── logger.py           # Structured JSON logger
+│   ├── config.py           # Centralized configuration
+│   └── metrics.py          # Performance metrics
+├── benchmarks/
+│   ├── divide_by_zero/     # Benchmark: zero division guard
+│   ├── missing_validation/ # Benchmark: input validation
+│   ├── syntax_error/       # Benchmark: syntax fix
+│   ├── import_bug/         # Benchmark: wrong import
+│   └── edge_case/          # Benchmark: empty list handling
+├── demo_project/           # Sample buggy project
+├── docs/
+│   └── USER_GUIDE.md       # Full usage guide
+├── main.py                 # CLI entry point
+├── devagent.py             # Global CLI wrapper
+├── devagent.bat            # Windows global shortcut
+├── requirements.txt
+├── CONTRIBUTING.md
+├── CHANGELOG.md
+├── CODE_OF_CONDUCT.md
+├── SECURITY.md
+├── LICENSE
+└── README.md
+```
+
+---
+
+## 💻 CLI Reference
+
+```bash
+python main.py --task "TASK" --root ./project [OPTIONS]
+```
+
+| Flag | Default | Description |
+|---|---|---|
+| `--task`, `-t` | *(required)* | The coding task for the agent |
+| `--root`, `-r` | `.` | Project root directory |
+| `--model` | `qwen2.5-coder:3b` | Any Ollama model |
+| `--max-steps`, `-m` | `5` | Max ReAct iterations |
+| `--benchmark` | off | Run benchmark suite |
+| `--sandbox` | off | Run in isolated sandbox |
+| `--auto-commit` | off | Git commit on success |
+| `--auto-push` | off | Git push after commit |
+| `--verbose`, `-v` | off | Verbose output |
+
+### Examples
+
+```bash
+# Fix a specific bug
+python main.py -t "Fix the TypeError in user_service.py" -r ./backend
+
+# Run in sandbox mode (safe — doesn't touch real files until success)
+python main.py -t "Fix divide-by-zero bug" -r ./project --sandbox
+
+# Auto-commit changes on success
+python main.py -t "Add input validation" -r ./api --auto-commit
+
+# Use a stronger model
+python main.py -t "Refactor auth middleware" -r ./server --model mistral:7b
+
+# Run benchmarks
+python main.py --benchmark
+
+# More retries for complex tasks
+python main.py -t "Make all tests pass" -r ./project --max-steps 10
+```
+
+> 📖 **[Full User Guide →](docs/USER_GUIDE.md)**
+
+---
+
+## 📊 Benchmarks
+
+DevAgent includes 5 built-in benchmarks to evaluate agent performance:
+
+| Benchmark | Bug Type | Difficulty |
+|---|---|---|
+| `divide_by_zero` | Missing guard clause | Easy |
+| `missing_validation` | No input validation | Medium |
+| `syntax_error` | Broken syntax | Medium |
+| `import_bug` | Wrong module name | Easy |
+| `edge_case` | Empty list crash | Medium |
+
+Run benchmarks:
+
+```bash
+python main.py --benchmark
+python main.py --benchmark --model phi3:mini
+```
+
+---
+
+## 🔧 Supported Models
+
+| Model | Size | Speed | Quality | Best For |
+|---|---|---|---|---|
+| `qwen2.5-coder:3b` | 1.9 GB | ⚡ Fast | ★★★★ | **Default — best for code** |
+| `qwen2.5:3b` | 1.9 GB | ⚡ Fast | ★★★☆ | General fallback |
+| `phi3:mini` | 2.2 GB | ⚡ Fast | ★★★☆ | Good reasoning |
+| `qwen3:4b` | 2.5 GB | ⚡ Fast | ★★★★ | Better understanding |
+| `gemma2:2b` | 1.6 GB | ⚡⚡ | ★★☆☆ | Ultra-low resource |
+| `mistral:7b` | 4.4 GB | 🐢 | ★★★★★ | Best quality (8GB+ RAM) |
+
+---
+
+## 🗺️ Roadmap
+
+### ✅ Completed (v2.0)
+
+- [x] Core ReAct agent loop
+- [x] Self-review module
+- [x] Tool system (9 tools)
+- [x] Planner layer
+- [x] Semantic retrieval (FAISS)
+- [x] Patch engine (unified diffs)
+- [x] Sandbox mode
+- [x] Benchmark system (5 suites)
+- [x] Metrics + structured logging
+- [x] Git integration
+- [x] CLI with all flags
+
+### 🔜 Coming Next
+
+- [ ] **Multi-file support** — Agent works across multiple files simultaneously
+- [ ] **Language support** — JavaScript, TypeScript, Go, Rust
+- [ ] **Plugin system** — Custom tools via YAML/Python
+- [ ] **Watch mode** — Auto-fix on test failure (`--watch`)
+- [ ] **VS Code extension** — Run agent from your editor
+- [ ] **Conversation memory** — Learn from past runs
+- [ ] **Multi-agent mode** — Planner + Coder + Reviewer + Evaluator agents
+
+---
+
+## 🤝 Contributing
+
+We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+```bash
+git checkout -b feature/your-feature
+# ... make changes ...
+python -m pytest demo_project/ -v
+git commit -m "feat: your feature"
+git push origin feature/your-feature
+```
+
+**Good first issues** are tagged and waiting:
+[Browse good first issues →](https://github.com/VedantJadhav701/Developer-Code-Intelligence-Agent/labels/good%20first%20issue)
+
+---
+
+## 📜 License
+
+MIT — use it however you want. See [LICENSE](LICENSE).
+
+---
+
+## ⭐ Star History
+
+If DevAgent helps you, give it a star! It helps others discover the project.
+
+[![Star History Chart](https://api.star-history.com/svg?repos=VedantJadhav701/Developer-Code-Intelligence-Agent&type=Date)](https://star-history.com/#VedantJadhav701/Developer-Code-Intelligence-Agent&Date)
+
+---
+
+<div align="center">
+
+**Built with 🧠 by [Vedant Jadhav](https://github.com/VedantJadhav701)**
+
+*A lightweight local open-source miniature of Claude Code CLI.*
+
+</div>