craft-code 0.1.0__py3-none-any.whl

code_craft/AGENTS.md

@@ -0,0 +1,35 @@
+# Project: Code Craft
+
+## Overview
+A Claude Code-like AI coding assistant built with LangChain Deep Agents.
+
+## Tech Stack
+- Python 3.11+
+- LangChain Deep Agents framework
+- LangGraph for orchestration
+- Rich for terminal UI
+
+## Project Structure
+```
+code_craft/
+  __init__.py       — package metadata
+  agent.py          — core agent factory (build_agent)
+  cli.py            — interactive CLI entry point
+  config.py         — AgentConfig dataclass
+  interrupt_handler.py — human-in-the-loop approval UI
+  prompts.py        — system prompts for agent and subagents
+  tools.py          — custom tools (git, delete, test runner)
+skills/
+  testing/SKILL.md
+  code_review/SKILL.md
+```
+
+## Commands
+- Run: `code-craft` or `python -m code_craft.cli`
+- Test: `pytest`
+- Lint: `ruff check .`
+
+## Conventions
+- Use type hints on public functions
+- Keep modules focused — one responsibility per file
+- Use Rich for all terminal output

code_craft/__init__.py

@@ -0,0 +1,3 @@
+"""Deep Coding Agent — A Claude Code-like AI coding assistant built with Deep Agents."""
+
+__version__ = "0.1.0"

code_craft/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running with: python -m code_craft"""
+
+from .cli import main
+
+main()

code_craft/agent.py

@@ -0,0 +1,140 @@
+"""Core agent factory — builds the deep coding agent with all capabilities."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from deepagents import create_deep_agent
+from deepagents.backends import (
+    CompositeBackend,
+    LocalShellBackend,
+    StateBackend,
+    StoreBackend,
+)
+from deepagents.backends.utils import create_file_data
+from langchain.chat_models import init_chat_model
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.store.memory import InMemoryStore
+
+from .config import AgentConfig
+from .prompts import CODE_REVIEW_PROMPT, CODING_SYSTEM_PROMPT, RESEARCH_PROMPT
+from .tools import CUSTOM_TOOLS
+
+
+def _load_agents_md(config: AgentConfig, store: InMemoryStore) -> None:
+    """Load AGENTS.md into the store if it exists on disk."""
+    agents_md_file = config.agents_md_file
+    if agents_md_file.exists():
+        content = agents_md_file.read_text()
+        store.put(
+            namespace=("filesystem",),
+            key="/AGENTS.md",
+            value=create_file_data(content),
+        )
+
+
+def _build_memory_prompt(config: AgentConfig) -> str:
+    """Append project root and persistent memory instructions to the system prompt."""
+    return CODING_SYSTEM_PROMPT + f"""
+
+## Working directory
+Your project root is: `{config.resolved_root}`
+In the virtual filesystem exposed by your tools, this maps to `/`.
+**Always start file exploration from `/`** — never explore system paths like /usr, /bin, /etc.
+When using `ls`, `read_file`, `write_file`, or `edit_file` without an explicit path, default to `/`.
+
+## Persistent memory
+You have access to persistent memory at {config.memories_dir}:
+- {config.memories_dir}project_context.md — tech stack, architecture, conventions
+- {config.memories_dir}user_preferences.md — coding style preferences
+- {config.memories_dir}known_issues.md — recurring bugs or gotchas
+
+Read these at session start. Update them when you learn something new about the project.
+"""
+
+
+def _build_subagents(subagent_model: str) -> list[dict]:
+    """Define specialized subagents the main agent can delegate to."""
+    return [
+        {
+            "name": "code-reviewer",
+            "description": (
+                "Performs in-depth code review: checks for bugs, security issues, "
+                "performance problems, and style violations."
+            ),
+            "system_prompt": CODE_REVIEW_PROMPT,
+            "model": subagent_model,
+            "tools": [],
+        },
+        {
+            "name": "researcher",
+            "description": (
+                "Researches APIs, libraries, and documentation to answer "
+                "technical questions."
+            ),
+            "system_prompt": RESEARCH_PROMPT,
+            "model": subagent_model,
+            "tools": [],
+        },
+    ]
+
+
+def _make_backend(config: AgentConfig):
+    """Build a composite backend: local filesystem + persistent memory store."""
+
+    def factory(runtime):
+        return CompositeBackend(
+            default=LocalShellBackend(
+                root_dir=str(config.resolved_root),
+                env={**os.environ, "PWD": str(config.resolved_root)},
+            ),
+            routes={
+                config.memories_dir: StoreBackend(runtime),
+            },
+        )
+
+    return factory
+
+
+def build_agent(config: AgentConfig | None = None):
+    """Build and return the fully configured deep coding agent.
+
+    Returns:
+        (agent, checkpointer, store) tuple for use in the CLI or programmatically.
+    """
+    if config is None:
+        config = AgentConfig()
+
+    checkpointer = MemorySaver()
+    store = InMemoryStore()
+
+    # Pre-load AGENTS.md into the store
+    _load_agents_md(config, store)
+
+    model = init_chat_model(
+        model=config.model,
+        max_retries=config.max_retries,
+        timeout=config.timeout,
+    )
+
+    system_prompt = _build_memory_prompt(config)
+
+    # Resolve skills directory relative to the project root, not the shell's CWD
+    skills_dir = (config.resolved_root / config.skills_dir).resolve()
+    skills = [str(skills_dir)] if skills_dir.exists() else []
+
+    agent = create_deep_agent(
+        model=model,
+        system_prompt=system_prompt,
+        backend=_make_backend(config),
+        tools=CUSTOM_TOOLS,
+        subagents=_build_subagents(config.subagent_model),
+        skills=skills,
+        interrupt_on=config.interrupt_tools,
+        memory=["/AGENTS.md"],
+        store=store,
+        checkpointer=checkpointer,
+    )
+
+    return agent, checkpointer, store

code_craft/auth.py

@@ -0,0 +1,146 @@
+"""First-run API key setup — checks env, checks ~/.config, prompts once if missing."""
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+from rich.console import Console
+from rich.rule import Rule
+
+console = Console()
+
+# Where we persist credentials between sessions (never stored in the project dir)
+_CONFIG_DIR = Path.home() / ".config" / "deep-coding-agent"
+_CREDENTIALS_FILE = _CONFIG_DIR / "credentials"
+
+# Credential keys written to / read from the file
+_CRED_KEY = "OPENROUTER_API_KEY"
+_PERSISTED_KEYS = ("OPENROUTER_API_KEY", "MODEL", "SUBAGENT_MODEL")
+
+
+def _load_saved_credentials() -> dict[str, str]:
+    """Read saved credentials from ~/.config/deep-coding-agent/credentials."""
+    result: dict[str, str] = {}
+    if _CREDENTIALS_FILE.exists():
+        for line in _CREDENTIALS_FILE.read_text().splitlines():
+            line = line.strip()
+            for key in _PERSISTED_KEYS:
+                if line.startswith(f"{key}="):
+                    result[key] = line.split("=", 1)[1].strip()
+    return result
+
+
+def _load_saved_key() -> str | None:
+    """Read a previously saved API key from ~/.config/deep-coding-agent/credentials."""
+    return _load_saved_credentials().get(_CRED_KEY)
+
+
+def _save_key(api_key: str) -> None:
+    """Persist the API key (and current model settings) to ~/.config/deep-coding-agent/credentials."""
+    _CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    lines = [f"{_CRED_KEY}={api_key}"]
+    for key in ("MODEL", "SUBAGENT_MODEL"):
+        value = os.environ.get(key)
+        if value:
+            lines.append(f"{key}={value}")
+    _CREDENTIALS_FILE.write_text("\n".join(lines) + "\n")
+    _CREDENTIALS_FILE.chmod(0o600)  # owner read/write only
+
+
+def _prompt_for_key() -> str:
+    """Interactively ask the user for their OpenRouter API key."""
+    console.print()
+    console.print(Rule("[bold yellow]Welcome to Deep Coding Agent[/bold yellow]"))
+    console.print()
+    console.print("  To get started, you need an [bold]OpenRouter API key[/bold].")
+    console.print(
+        "  Get one at: [link=https://openrouter.ai/settings/keys]"
+        "https://openrouter.ai/settings/keys[/link]"
+    )
+    console.print()
+
+    while True:
+        try:
+            key = console.input("  [bold]Enter your OpenRouter API key:[/bold] ").strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print()
+            console.print("[dim]Setup cancelled.[/dim]")
+            raise SystemExit(0)
+
+        if not key:
+            console.print("  [yellow]API key cannot be empty. Try again.[/yellow]")
+            continue
+
+        if not key.startswith("sk-or-"):
+            console.print(
+                "  [yellow]That doesn't look like an OpenRouter key "
+                "(should start with 'sk-or-'). Try again.[/yellow]"
+            )
+            continue
+
+        break
+
+    # Ask whether to save for future sessions
+    console.print()
+    try:
+        save = console.input(
+            "  Save key to [dim]~/.config/deep-coding-agent/credentials[/dim]"
+            " for future sessions? [bold][Y/n][/bold]: "
+        ).strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        save = "n"
+
+    if save in ("", "y", "yes"):
+        _save_key(key)
+        console.print("  [green]✓ Key saved.[/green]")
+    else:
+        console.print("  [dim]Key will be used for this session only.[/dim]")
+
+    console.print()
+    return key
+
+
+def ensure_api_key() -> None:
+    """Guarantee OPENROUTER_API_KEY (and model settings) are in the environment.
+
+    Resolution order:
+      1. Already set in the shell environment  →  use it, done
+      2. Saved in ~/.config/deep-coding-agent/credentials  →  load it, done
+      3. Neither found  →  prompt once, optionally save, inject into env
+    """
+    # 2. Load any previously saved credentials (API key + model settings)
+    saved = _load_saved_credentials()
+    for key, value in saved.items():
+        if not os.environ.get(key):
+            os.environ[key] = value
+
+    # 1. API key already set (shell export, CI secret, or just loaded above)
+    if os.environ.get(_CRED_KEY):
+        return
+
+    # 3. First run — prompt the user
+    key = _prompt_for_key()
+    os.environ[_CRED_KEY] = key
+
+
+def logout() -> None:
+    """Remove saved credentials from ~/.config/deep-coding-agent/credentials."""
+    if not _CREDENTIALS_FILE.exists():
+        console.print("[dim]No saved credentials found — nothing to remove.[/dim]")
+        return
+
+    _CREDENTIALS_FILE.unlink()
+    console.print("[green]✓ Credentials removed.[/green]")
+    console.print(f"[dim]Deleted: {_CREDENTIALS_FILE}[/dim]")
+
+
+def purge_config() -> None:
+    """Remove the entire ~/.config/deep-coding-agent directory."""
+    if not _CONFIG_DIR.exists():
+        console.print("[dim]No config directory found — nothing to remove.[/dim]")
+        return
+
+    shutil.rmtree(_CONFIG_DIR)
+    console.print(f"[green]✓ Config directory removed: {_CONFIG_DIR}[/green]")

code_craft/cli.py

@@ -0,0 +1,254 @@
+"""Interactive CLI for the deep coding agent — the main entry point."""
+
+from __future__ import annotations
+
+import sys
+import uuid
+from pathlib import Path
+
+from langgraph.types import Command
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.rule import Rule
+
+from .agent import build_agent
+from .auth import ensure_api_key, logout, purge_config
+from .config import AgentConfig
+from .interrupt_handler import collect_decisions
+
+from prompt_toolkit import prompt as pt_prompt
+from prompt_toolkit.formatted_text import HTML
+
+console = Console()
+
+BANNER = r"""
+[bold cyan]╔══════════════════════════════════════════╗
+║       Code-Craft Coding Agent v0.1.0     ║
+╚══════════════════════════════════════════╝[/bold cyan]
+
+Type your request, or use these commands:
+  [green]/help[/green]    — show this help
+  [green]/new[/green]     — start a new thread
+  [green]/logout[/green]  — remove saved API key
+  [green]/quit[/green]    — exit
+
+"""
+
+
+def _trust_check(project_root: Path) -> bool:
+    """Show a Claude Code-style trust prompt before granting filesystem access.
+
+    Returns True if the user trusts the folder, False to abort.
+    """
+    console.print()
+    console.print(Rule("[bold yellow]Accessing workspace[/bold yellow]"))
+    console.print()
+    console.print(f"  [bold]{project_root}[/bold]")
+    console.print()
+    console.print(
+        "  Quick safety check: Is this a project you created or one you trust?\n"
+        "  (Like your own code, a well-known open source project, or work from\n"
+        "  your team.) If not, take a moment to review what's in this folder first."
+    )
+    console.print()
+    console.print("  [dim]The agent will be able to read, edit, and execute files here.[/dim]")
+    console.print()
+
+    options = [
+        ("1", "Yes, I trust this folder", True),
+        ("2", "No, exit",                 False),
+    ]
+
+    for key, label, _ in options:
+        console.print(f"  [bold cyan]>[/bold cyan] [bold]{key}.[/bold] {label}")
+
+    console.print()
+
+    while True:
+        try:
+            choice = console.input("  Enter number to confirm (or Ctrl+C to cancel): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print()
+            return False
+
+        if choice == "1":
+            console.print()
+            return True
+        elif choice == "2":
+            console.print()
+            return False
+        else:
+            console.print("  [yellow]Please enter 1 or 2.[/yellow]")
+
+
+def _tool_call_detail(name: str, args: dict) -> str:
+    """Brief inline detail for a tool call."""
+    if name in ("read_file", "edit_file", "write_file", "delete_file"):
+        return f"  [dim]{args.get('file_path', '')}[/dim]"
+    if name == "execute":
+        cmd = args.get("command", "")
+        if len(cmd) > 80:
+            cmd = cmd[:80] + "..."
+        return f"  [dim]{cmd}[/dim]"
+    if name == "run_tests":
+        return f"  [dim]{args.get('command', 'pytest')}[/dim]"
+    return ""
+
+
+def _display_stream_chunk(chunk: dict) -> None:
+    """Display a single stream update chunk — shows tool calls as they happen."""
+    if not isinstance(chunk, dict):
+        return
+    for node_name, output in chunk.items():
+        if node_name == "__interrupt__":
+            continue
+        if not isinstance(output, dict):
+            continue
+        messages = output.get("messages", [])
+        if not isinstance(messages, list):
+            continue
+        for msg in messages:
+            if hasattr(msg, "tool_calls") and msg.tool_calls:
+                for tc in msg.tool_calls:
+                    name = tc["name"]
+                    detail = _tool_call_detail(name, tc.get("args", {}))
+                    console.print(f"  [bold cyan]→ {name}[/bold cyan]{detail}")
+
+
+def _has_interrupts(state) -> bool:
+    """Check whether a LangGraph state snapshot has pending interrupts."""
+    return bool(state.tasks and any(t.interrupts for t in state.tasks))
+
+
+def _get_interrupt_value(state) -> dict:
+    """Extract the first interrupt value from a state snapshot."""
+    for task in state.tasks:
+        for interrupt in task.interrupts:
+            return interrupt.value
+    return {}
+
+
+def _print_response(content: str) -> None:
+    """Render the agent's response as markdown."""
+    console.print()
+    console.print(Markdown(content))
+    console.print()
+
+
+def main():
+    """Run the interactive coding agent CLI."""
+    import sys
+
+    # Handle top-level subcommands before anything else
+    if len(sys.argv) > 1:
+        subcmd = sys.argv[1].lower()
+        if subcmd == "logout":
+            logout()
+            sys.exit(0)
+        elif subcmd == "uninstall":
+            purge_config()
+            console.print()
+            console.print("  To fully uninstall the package, run:")
+            console.print("  [bold]pip uninstall code-craft[/bold]")
+            console.print("  [dim]or, if installed with uv:[/dim]")
+            console.print("  [bold]uv pip uninstall code-craft[/bold]")
+            sys.exit(0)
+        elif subcmd in ("--help", "-h", "help"):
+            console.print(BANNER)
+            sys.exit(0)
+
+    # Ensure API key is available before anything else — prompts once if missing
+    ensure_api_key()
+
+    config = AgentConfig()
+
+    console.print(BANNER)
+
+    # --- Trust gate: must pass before the agent is built or any files touched ---
+    if not _trust_check(config.resolved_root):
+        console.print("[dim]Exiting. No files were accessed.[/dim]")
+        sys.exit(0)
+
+    console.print(f"[dim]Model: {config.model}[/dim]")
+    console.print(f"[dim]Project root: {config.resolved_root}[/dim]")
+    console.print()
+
+    try:
+        agent, checkpointer, store = build_agent(config)
+    except Exception as e:
+        console.print(f"[red]Failed to build agent: {e}[/red]")
+        sys.exit(1)
+
+    thread_id = str(uuid.uuid4())
+    lang_config = {"configurable": {"thread_id": thread_id}}
+
+    console.print(f"[dim]Thread: {thread_id[:8]}...[/dim]")
+
+    while True:
+        try:
+            console.rule()
+            user_input = pt_prompt(HTML("<ansigreen><b>&gt;</b></ansigreen> ")).strip()
+            console.rule()
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[dim]Goodbye![/dim]")
+            break
+
+        if not user_input:
+            continue
+
+        # Handle commands
+        if user_input.startswith("/"):
+            cmd = user_input.lower()
+            if cmd in ("/quit", "/exit", "/q"):
+                console.print("[dim]Goodbye![/dim]")
+                break
+            elif cmd == "/new":
+                thread_id = str(uuid.uuid4())
+                lang_config = {"configurable": {"thread_id": thread_id}}
+                console.print(f"[dim]New thread: {thread_id[:8]}...[/dim]")
+                continue
+            elif cmd == "/help":
+                console.print(BANNER)
+                continue
+            elif cmd == "/logout":
+                logout()
+                continue
+            else:
+                console.print(f"[yellow]Unknown command: {user_input}[/yellow]")
+                continue
+
+        # Stream agent execution with real-time step display
+        try:
+            input_data = {"messages": [{"role": "user", "content": user_input}]}
+
+            for chunk in agent.stream(input_data, lang_config, stream_mode="updates"):
+                _display_stream_chunk(chunk)
+
+            # Handle interrupts (approval loop)
+            state = agent.get_state(lang_config)
+            while _has_interrupts(state):
+                decisions = collect_decisions(_get_interrupt_value(state))
+                for chunk in agent.stream(
+                    Command(resume={"decisions": decisions}),
+                    lang_config,
+                    stream_mode="updates",
+                ):
+                    _display_stream_chunk(chunk)
+                state = agent.get_state(lang_config)
+
+            # Print the final response
+            messages = state.values.get("messages", [])
+            if messages:
+                last_msg = messages[-1]
+                content = getattr(last_msg, "content", str(last_msg))
+                if content:
+                    _print_response(content)
+
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Interrupted.[/yellow]")
+        except Exception as e:
+            console.print(f"\n[red]Error: {e}[/red]")
+
+
+if __name__ == "__main__":
+    main()

code_craft/config.py

@@ -0,0 +1,62 @@
+"""Configuration for the coding agent."""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Directory containing this file — used to locate bundled package data
+_PACKAGE_DIR = Path(__file__).parent
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for the deep coding agent."""
+
+    # Model settings
+    # Supports provider:model format — e.g. anthropic:claude-sonnet-4-6
+    # or openrouter:anthropic/claude-sonnet-4-6 (requires langchain-openrouter)
+    # Uses field(default_factory=...) so env vars are read at instantiation time,
+    # after ensure_api_key() has loaded credentials into the environment.
+    model: str = field(default_factory=lambda: os.getenv("MODEL", "openrouter:anthropic/claude-sonnet-4-6"))
+    # Subagent model defaults to main model if unset — set to a cheaper model to save credits
+    subagent_model: str = field(
+        default_factory=lambda: os.getenv("SUBAGENT_MODEL", "") or os.getenv("MODEL", "openrouter:anthropic/claude-sonnet-4-6")
+    )
+    max_retries: int = 3
+    timeout: int = 120_000  # milliseconds (120 seconds)
+
+    # Project settings
+    project_root: str = os.getenv("PROJECT_ROOT", ".")
+
+    # Agent limits
+    model_call_limit: int = 50
+    tool_call_limit: int = 100
+
+    # Human-in-the-loop: which tools require approval
+    interrupt_tools: dict = field(default_factory=lambda: {
+        "execute": True,
+        "write_file": {"allowed_decisions": ["approve", "reject"]},
+        "edit_file": True,
+    })
+
+    # Paths — skills_dir defaults to the bundled package skills, so they work
+    # whether the package is installed via pip or run from source.
+    agents_md_path: str = "AGENTS.md"
+    memories_dir: str = "/memories/"
+    skills_dir: str = str(_PACKAGE_DIR / "skills")
+
+    @property
+    def resolved_root(self) -> Path:
+        return Path(self.project_root).resolve()
+
+    @property
+    def agents_md_file(self) -> Path:
+        """AGENTS.md: prefer the project's own file, fall back to bundled template."""
+        project_file = self.resolved_root / self.agents_md_path
+        if project_file.exists():
+            return project_file
+        return _PACKAGE_DIR / "AGENTS.md"

code_craft/interrupt_handler.py

@@ -0,0 +1,131 @@
+"""Human-in-the-loop interrupt handling for tool approval."""
+
+from __future__ import annotations
+
+import difflib
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+console = Console()
+
+
+def _format_action(action: dict) -> Panel:
+    """Format a tool call action as a rich panel for display."""
+    name = action.get("name", "unknown")
+    args = action.get("args", {})
+
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    for key, value in args.items():
+        display_value = str(value)
+        if len(display_value) > 200:
+            display_value = display_value[:200] + "..."
+        table.add_row(f"[bold]{key}[/bold]", display_value)
+
+    return Panel(table, title=f"[bold yellow]{name}[/bold yellow]", border_style="yellow")
+
+
+def _print_edit_diff(action: dict) -> None:
+    """Print an edit_file action as a colored unified diff between horizontal rules."""
+    args = action.get("args", {})
+    old_string = args.get("old_string")
+    new_string = args.get("new_string")
+    file_path = args.get("file_path", "unknown file")
+
+    if old_string is None or new_string is None:
+        console.print(_format_action(action))
+        return
+
+    old_lines = old_string.splitlines(keepends=True)
+    new_lines = new_string.splitlines(keepends=True)
+    diff = list(difflib.unified_diff(old_lines, new_lines, fromfile=file_path, tofile=file_path))
+
+    console.rule(f"[bold yellow]edit_file[/bold yellow] → {file_path}")
+
+    text = Text()
+    for line in diff:
+        stripped = line.rstrip("\n")
+        if line.startswith("---") or line.startswith("+++"):
+            text.append(stripped + "\n", style="bold")
+        elif line.startswith("@@"):
+            text.append(stripped + "\n", style="dim cyan")
+        elif line.startswith("-"):
+            text.append(stripped + "\n", style="red strike")
+        elif line.startswith("+"):
+            text.append(stripped + "\n", style="green")
+        else:
+            text.append(stripped + "\n")
+
+    # Remove trailing newline for cleaner display
+    if text.plain.endswith("\n"):
+        text.right_crop(1)
+
+    console.print(text)
+    console.rule()
+
+
+def collect_decisions(interrupt_value: dict) -> list[dict]:
+    """Display pending actions and collect user approve/edit/reject decisions.
+
+    Args:
+        interrupt_value: The interrupt value dict with action_requests and review_configs.
+
+    Returns:
+        List of decision dicts (one per action).
+    """
+    action_requests = interrupt_value.get("action_requests", [])
+    review_configs = interrupt_value.get("review_configs", [])
+
+    decisions = []
+    for i, action in enumerate(action_requests):
+        console.print()
+        if action.get("name") == "edit_file":
+            _print_edit_diff(action)
+        else:
+            console.print(_format_action(action))
+
+        # Determine allowed decisions
+        allowed = ["approve", "edit", "reject"]
+        if i < len(review_configs):
+            rc = review_configs[i]
+            if isinstance(rc, dict) and "allowed_decisions" in rc:
+                allowed = rc["allowed_decisions"]
+
+        prompt_parts = []
+        if "approve" in allowed:
+            prompt_parts.append("[green]a[/green]pprove")
+        if "edit" in allowed:
+            prompt_parts.append("[yellow]e[/yellow]dit")
+        if "reject" in allowed:
+            prompt_parts.append("[red]r[/red]eject")
+
+        prompt = " / ".join(prompt_parts) + "? "
+        console.rule()
+        choice = console.input(prompt).strip().lower()
+        console.rule()
+
+        if choice in ("a", "approve"):
+            decisions.append({"type": "approve"})
+        elif choice in ("r", "reject"):
+            decisions.append({"type": "reject"})
+        elif choice in ("e", "edit") and "edit" in allowed:
+            console.print("[dim]Enter edited arguments as key=value pairs (blank line to finish):[/dim]")
+            new_args = dict(action.get("args", {}))
+            while True:
+                line = console.input("  > ").strip()
+                if not line:
+                    break
+                if "=" in line:
+                    key, _, value = line.partition("=")
+                    new_args[key.strip()] = value.strip()
+            decisions.append({
+                "type": "edit",
+                "edited_action": {"name": action["name"], "args": new_args},
+            })
+        else:
+            console.print("[red]Invalid choice, defaulting to reject.[/red]")
+            decisions.append({"type": "reject"})
+
+    return decisions

code_craft/prompts.py

@@ -0,0 +1,60 @@
+"""System prompts for the coding agent."""
+
+CODING_SYSTEM_PROMPT = """\
+You are an expert AI coding assistant. Your job is to help developers
+write, debug, refactor, and understand code in their project directory.
+
+## Your capabilities
+- Read, write, and edit files in the project directory
+- Execute shell commands (tests, linters, build tools, git, etc.)
+- Plan complex multi-step changes using your todo list
+- Delegate deep research or isolated subtasks to subagents
+
+## Your workflow
+1. Always read relevant files before making changes
+2. Write a plan using write_todos before multi-step changes
+3. Make targeted, minimal changes — don't over-refactor
+4. Run tests after changes to verify correctness
+5. Report what you did and why
+
+## Safety rules
+- Never delete files without explicit user permission
+- Always show diffs or summaries of your changes
+- Ask before running commands that modify external state (git push, deploy, etc.)
+- Never commit secrets, credentials, or API keys
+- Prefer editing existing files over creating new ones
+
+## Shell commands
+- Always use non-interactive flags to prevent commands from hanging on prompts:
+  - npx: use `npx --yes` (e.g. `npx --yes create-react-app my-app`)
+  - apt: use `apt-get -y`
+  - pip: use `pip install --no-input`
+  - npm init: use `npm init -y`
+- Commands run without a terminal, so interactive prompts will hang forever
+
+## Style
+- Be concise. Lead with the answer or action.
+- When showing code changes, highlight what changed and why.
+- If a task is ambiguous, ask one clarifying question before proceeding.
+"""
+
+CODE_REVIEW_PROMPT = """\
+You are an expert code reviewer. Analyze the provided code for:
+- Bugs and logic errors
+- Security vulnerabilities (injection, XSS, auth flaws)
+- Performance issues (N+1 queries, unnecessary allocations)
+- Style and convention violations
+- Missing error handling or edge cases
+- Missing tests
+
+Return a structured review with severity levels: critical, warning, info.
+Be specific — reference line numbers and suggest fixes.
+"""
+
+RESEARCH_PROMPT = """\
+You are a technical researcher. When asked a question:
+1. Search for authoritative documentation and examples
+2. Verify information across multiple sources
+3. Provide concise, accurate answers with source references
+4. Include code examples when relevant
+"""

code_craft/skills/code-review/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: code-review
+description: Use when asked to review code, check for bugs, security issues, or audit a file.
+---
+
+# Code Review Skill
+
+Use this when asked to review code, check for issues, or audit a file.
+
+## Workflow
+1. Read the file(s) to review
+2. Analyze for bugs, security issues, performance, and style
+3. Categorize findings by severity: critical, warning, info
+4. Suggest specific fixes with code snippets
+5. Summarize the overall health of the code
+
+## Focus Areas
+- **Security**: injection, XSS, auth flaws, hardcoded secrets
+- **Bugs**: off-by-one, null refs, race conditions, logic errors
+- **Performance**: N+1 queries, unnecessary allocations, blocking I/O
+- **Style**: naming, structure, dead code, missing types

code_craft/skills/testing/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: testing
+description: Use when asked to write, run, or debug tests for any module or function.
+---
+
+# Testing Skill
+
+Use this when asked to write, run, or debug tests.
+
+## Workflow
+1. Read the source file being tested
+2. Identify all public functions/methods and their edge cases
+3. Write unit tests using the project's test framework (default: pytest)
+4. Run the tests to verify they pass
+5. Fix any failures and re-run until green
+
+## Conventions
+- Test file path: `tests/test_<module>.py`
+- Use fixtures for shared setup
+- Mock external dependencies (network, DB) but not internal logic
+- Each test should be independent and deterministic
+- Name tests: `test_<function>_<scenario>_<expected>`

code_craft/tools.py

@@ -0,0 +1,59 @@
+"""Custom tools that extend the built-in Deep Agents toolset."""
+
+import os
+import subprocess
+
+from langchain_core.tools import tool
+
+
+@tool
+def delete_file(path: str) -> str:
+    """Permanently delete a file. Use with caution — this cannot be undone."""
+    if not os.path.exists(path):
+        return f"Error: {path} does not exist"
+    os.remove(path)
+    return f"Deleted {path}"
+
+
+@tool
+def git_status() -> str:
+    """Show the current git status of the project."""
+    result = subprocess.run(
+        ["git", "status", "--short"],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    if result.returncode != 0:
+        return f"Error: {result.stderr}"
+    return result.stdout or "Working tree clean"
+
+
+@tool
+def git_diff(path: str = "") -> str:
+    """Show git diff for staged and unstaged changes. Optionally filter by path."""
+    cmd = ["git", "diff"]
+    if path:
+        cmd.append(path)
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+    if result.returncode != 0:
+        return f"Error: {result.stderr}"
+    return result.stdout or "No changes"
+
+
+@tool
+def run_tests(command: str = "pytest") -> str:
+    """Run the project's test suite. Defaults to pytest."""
+    result = subprocess.run(
+        command.split(),
+        capture_output=True,
+        text=True,
+        timeout=300,
+    )
+    output = result.stdout
+    if result.stderr:
+        output += f"\nSTDERR:\n{result.stderr}"
+    return output
+
+
+CUSTOM_TOOLS = [delete_file, git_status, git_diff, run_tests]

craft_code-0.1.0.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: craft-code
+Version: 0.1.0
+Summary: A Claude Code-like AI coding assistant built with LangChain Deep Agents
+Project-URL: Homepage, https://github.com/shubhamagarwal/code-craft
+Project-URL: Repository, https://github.com/shubhamagarwal/code-craft
+Project-URL: Bug Tracker, https://github.com/shubhamagarwal/code-craft/issues
+Author: Shubham Agarwal
+License: MIT
+License-File: LICENSE
+Keywords: agent,ai,claude,coding-assistant,langchain,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.11
+Requires-Dist: deepagents>=0.4.0
+Requires-Dist: langchain-anthropic>=0.3.0
+Requires-Dist: langchain-openrouter>=0.1.0
+Requires-Dist: langgraph-checkpoint>=2.0.0
+Requires-Dist: langgraph>=0.3.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: openrouter
+Requires-Dist: langchain-openrouter>=0.1.0; extra == 'openrouter'
+Provides-Extra: sandbox
+Requires-Dist: langchain-daytona>=0.1.0; extra == 'sandbox'
+Description-Content-Type: text/markdown
+
+# Code Craft
+
+A Claude Code-like AI coding assistant built with [LangChain Deep Agents](https://docs.langchain.com/oss/python/deepagents/overview).
+
+## Features
+
+- **File system access** — reads, writes, and edits project files
+- **Shell execution** — runs commands (tests, linters, build tools)
+- **Agentic planning** — breaks tasks into steps with `write_todos`
+- **Human-in-the-loop** — asks approval before destructive operations
+- **Persistent memory** — remembers project context across sessions
+- **Subagent delegation** — spawns code-reviewer and researcher subagents
+- **Skill system** — lazy-loaded workflows for testing, code review, etc.
+
+## Quick Start
+
+```bash
+# 1. Clone and install
+cd code-craft
+uv venv && source .venv/bin/activate
+uv pip install -e .
+
+# 2. Set your API key
+cp .env.example .env
+# Edit .env and add your ANTHROPIC_API_KEY
+
+# 3. Run
+coding-agent
+```
+
+## Usage
+
+```bash
+# Interactive CLI
+coding-agent
+
+# Or run directly
+python -m code_craft
+```
+
+Inside the CLI:
+- Type your coding request
+- The agent will ask for approval before file writes and shell commands
+- Use `/new` to start a fresh thread, `/quit` to exit
+
+## Programmatic Usage
+
+```python
+from code_craft.agent import build_agent
+from code_craft.config import AgentConfig
+
+config = AgentConfig(project_root="/path/to/your/project")
+agent, checkpointer, store = build_agent(config)
+```
+
+## Configuration
+
+Set these in `.env` or as environment variables:
+
+| Variable | Default | Description |
+|---|---|---|
+| `ANTHROPIC_API_KEY` | (required) | Your Anthropic API key |
+| `MODEL` | `anthropic:claude-sonnet-4-6` | Model to use |
+| `PROJECT_ROOT` | `.` | Root directory for file operations |
+
+## Architecture
+
+```
+code_craft/
+  agent.py              — Agent factory with backends, subagents, skills
+  cli.py                — Interactive Rich-powered CLI
+  config.py             — AgentConfig dataclass
+  interrupt_handler.py  — Human-in-the-loop approval UI
+  prompts.py            — System prompts
+  tools.py              — Custom tools (git, delete, tests)
+skills/
+  testing/SKILL.md      — Test writing workflow
+  code_review/SKILL.md  — Code review workflow
+AGENTS.md               — Project context for the agent
+```

craft_code-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+code_craft/AGENTS.md,sha256=bgE40QDX_gKzRSaLf_q96oN-eQo6UUEe8w9DOA4arQ0,943
+code_craft/__init__.py,sha256=1jM6UvGpiKPOPQCN6DQ6_vCtU-Mc4YCJ3PH9-UUzSHc,114
+code_craft/__main__.py,sha256=hhH1lYKvDczHUHWNp0ohEIDBS0FxAwQcEsPXvlc-Z0o,78
+code_craft/agent.py,sha256=Duf5Z99XmE_aG4nCjx1uo1d-72W-2IuDMmb0R81cJI0,4526
+code_craft/auth.py,sha256=3VIlBQEP6n1RNWg4vkVV5mPftSfPOfCibK9syya_pUA,4989
+code_craft/cli.py,sha256=bZMjhvnpXC9s-rn4qfhzTFVXGt0qW20pWF2PGnJrJKQ,8640
+code_craft/config.py,sha256=AAHX-KxzOZvnWTpWW7PaVCbqcuK1F8eOWoI3YCvnDnA,2236
+code_craft/interrupt_handler.py,sha256=PgoNZsrVkyeZgU2dTVF7SQqxhiaSRnjO_ta3Tg4D-bQ,4590
+code_craft/prompts.py,sha256=P6vGLBOFisFH2x60gOAIYKz1xAWi0r24gkZ5lsFKksg,2318
+code_craft/tools.py,sha256=BXQgWG43ybhwZjAFcLNvSvRM7vE3s0AM7C8g3WcNQeo,1541
+code_craft/skills/code-review/SKILL.md,sha256=ECoyTN7mlzd--hHcTrL7dQFsPZSkYMPiYrVp1KfQCGQ,736
+code_craft/skills/testing/SKILL.md,sha256=r-fvtOCAxqLlZtUmxePxYqI_u2XWgGxPc2WuM6QDJPE,705
+craft_code-0.1.0.dist-info/METADATA,sha256=Z9BiOjAmNy4hmsW53gyW2rpZ8YzlaP2pAzuQJuOzwZ0,3962
+craft_code-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+craft_code-0.1.0.dist-info/entry_points.txt,sha256=DGyWYFa6PvKo8Cg9PWtAX32cKQVO_V3lmeSlz0O35YM,51
+craft_code-0.1.0.dist-info/licenses/LICENSE,sha256=0noz4EH8s_K8GHRQJmSKl7UY56UVxBy4pbawpT6Bo-0,1072
+craft_code-0.1.0.dist-info/RECORD,,

craft_code-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

craft_code-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+code-craft = code_craft.cli:main

craft_code-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shubham Agarwal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.