librarian-code 0.1.0__tar.gz → 0.2.0__tar.gz

librarian_code-0.2.0/.mimocode/plans/1782009063038-gentle-garden.md

@@ -0,0 +1,88 @@
+# Plan: Librarian Feature Roadmap
+
+## Goal
+Add high-impact features to differentiate Librarian from basic CLI coding agents.
+
+---
+
+## P0 — Must Have (Core UX)
+
+### 1. Streaming Output
+Show LLM tokens as they arrive instead of waiting for full response.
+- **Why**: Eliminates "hung" perception during 10s+ generation
+- **Complexity**: Medium
+- **Files**: `adapter/base.py`, `adapter/groq_adapter.py`, `adapter/openrouter_adapter.py`, `commands/ask.py`, `commands/do.py`
+
+### 2. Diff Preview Before Execute
+Show syntax-highlighted file diffs before user confirms changes.
+- **Why**: Safety — users approve exact changes, not blind JSON plans
+- **Complexity**: Low
+- **Files**: `commands/do.py`, `actions/file_ops.py`, `utils/ui.py`
+
+### 3. Multi-Turn Conversation
+Maintain session context across consecutive `ask`/`do` calls.
+- **Why**: Essential for iterative coding; current stateless design forces re-retrieval each turn
+- **Complexity**: Medium
+- **Files**: `orchestrator/core.py`, `commands/ask.py`, `commands/do.py`, new `memory/session.py`
+
+---
+
+## P1 — Should Have (Quality & Precision)
+
+### 4. File Targeting (`--file`)
+Scope retrieval to specific files or directories.
+- **Why**: Precision reduces irrelevant context; faster, cheaper, more accurate
+- **Complexity**: Low
+- **Files**: `commands/ask.py`, `commands/do.py`, `memory/retriever.py`
+
+### 5. Post-Change Test/Lint
+Auto-run tests/lint after `do` executes changes.
+- **Why**: Catches regressions immediately; differentiator vs basic agents
+- **Complexity**: Medium
+- **Files**: `commands/do.py`, new `actions/verify.py`, `utils/config.py`
+
+### 6. Git CLI Command
+`librarian commit`, `librarian push`, `librarian diff`
+- **Why**: Wire existing `shell_ops.py` helpers into first-class commands
+- **Complexity**: Low
+- **Files**: `cli.py`, new `commands/git.py`, `actions/shell_ops.py`
+
+### 7. Capsule Feedback Loop
+Feed undo/approve signals back into retrieval ranking.
+- **Why**: Memory improves over time; currently capsules decay but never inform search
+- **Complexity**: Medium
+- **Files**: `memory/capsule.py`, `memory/retriever.py`, `orchestrator/core.py`
+
+---
+
+## P2 — Nice to Have (Extensibility)
+
+### 8. Custom Skills
+User-defined skill files loaded per-project.
+- **Why**: Power users tailor agent behavior to their stack
+- **Complexity**: Medium
+- **Files**: `skills/loader.py`, `orchestrator/core.py`
+
+### 9. Interactive REPL
+`librarian repl` with persistent session.
+- **Why**: Exploratory workflows; reduces startup cost per query
+- **Complexity**: High
+- **Files**: New `commands/repl.py`, `cli.py`, all commands
+
+### 10. TOML/YAML Config
+`librarian.toml` replacing raw `.env`.
+- **Why**: Structured config with defaults, per-project overrides
+- **Complexity**: Low
+- **Files**: `utils/config.py`, `cli.py`
+
+---
+
+## Implementation Order
+
+Start P0 (streaming → diff preview → multi-turn), then P1, then P2.
+
+## Verification
+
+1. `python -m pytest tests/` — all existing tests pass
+2. Manual test each new command
+3. `python -m build && twine check dist/*` — package builds clean

{librarian_code-0.1.0 → librarian_code-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: librarian-code
-Version: 0.1.0
+Version: 0.2.0
 Summary: A local-first CLI coding agent with persistent project memory
 Project-URL: Homepage, https://github.com/Humble-Librarian/Librarian-Code
 Project-URL: Repository, https://github.com/Humble-Librarian/Librarian-Code

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/__init__.py

@@ -1,3 +1,3 @@
 """Librarian — a CLI coding agent with persistent project memory."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

librarian_code-0.2.0/librarian/actions/verify.py

@@ -0,0 +1,40 @@
+import subprocess
+from pathlib import Path
+from librarian.actions.shell_ops import run_command
+
+
+def run_tests() -> tuple[bool, str]:
+    if Path("pyproject.toml").exists():
+        code, out, err = run_command("python -m pytest tests/ -v --tb=short -q")
+        return code == 0, out + err
+    if Path("package.json").exists():
+        code, out, err = run_command("npm test")
+        return code == 0, out + err
+    return True, "no test runner detected"
+
+
+def run_lint() -> tuple[bool, str]:
+    if Path("pyproject.toml").exists():
+        code, out, err = run_command("python -m ruff check .")
+        if code != 0 and "No module named 'ruff'" in err:
+            return True, "ruff not installed"
+        return code == 0, out + err
+    if Path("package.json").exists():
+        code, out, err = run_command("npm run lint")
+        return code == 0, out + err
+    return True, "no linter detected"
+
+
+def verify_changes() -> tuple[bool, str]:
+    lint_ok, lint_out = run_lint()
+    tests_ok, tests_out = run_tests()
+
+    parts = []
+    if not lint_ok:
+        parts.append(f"lint failed:\n{lint_out}")
+    if not tests_ok:
+        parts.append(f"tests failed:\n{tests_out}")
+
+    if parts:
+        return False, "\n\n".join(parts)
+    return True, "all checks passed"

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/adapter/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from typing import Iterator
 
 
 class LLMAdapter(ABC):
@@ -6,6 +7,10 @@ class LLMAdapter(ABC):
     def complete(self, system: str, prompt: str) -> str:
         pass
 
+    @abstractmethod
+    def complete_stream(self, system: str, prompt: str) -> Iterator[str]:
+        yield ""
+
     @abstractmethod
     def is_available(self) -> bool:
         pass

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/adapter/groq_adapter.py

@@ -1,3 +1,4 @@
+from typing import Iterator
 from groq import Groq, RateLimitError as GroqRateLimitError, APIConnectionError
 from librarian.adapter.base import LLMAdapter
 from librarian.exceptions import RateLimitError, ProviderUnavailableError
@@ -30,6 +31,28 @@ class GroqAdapter(LLMAdapter):
         except APIConnectionError:
             raise ProviderUnavailableError("Cannot connect to Groq")
 
+    def complete_stream(self, system: str, prompt: str) -> Iterator[str]:
+        if not self.client:
+            raise ProviderUnavailableError("GROQ_API_KEY not set")
+        try:
+            stream = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": prompt},
+                ],
+                temperature=0.2,
+                max_tokens=4096,
+                stream=True,
+            )
+            for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    yield chunk.choices[0].delta.content
+        except GroqRateLimitError:
+            raise RateLimitError("Groq rate limit exceeded")
+        except APIConnectionError:
+            raise ProviderUnavailableError("Cannot connect to Groq")
+
     def is_available(self) -> bool:
         if not self.client:
             return False

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/adapter/openrouter_adapter.py

@@ -1,3 +1,5 @@
+import json
+from typing import Iterator
 import httpx
 from librarian.adapter.base import LLMAdapter
 from librarian.exceptions import RateLimitError, ProviderUnavailableError
@@ -46,6 +48,42 @@ class OpenRouterAdapter(LLMAdapter):
         except httpx.TimeoutException:
             raise ProviderUnavailableError("OpenRouter request timed out")
 
+    def complete_stream(self, system: str, prompt: str) -> Iterator[str]:
+        if not self.api_key:
+            raise ProviderUnavailableError("OPENROUTER_API_KEY not set")
+        headers = {**HEADERS, "Authorization": f"Bearer {self.api_key}"}
+        payload = {
+            "model": MODEL,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": prompt},
+            ],
+            "temperature": 0.2,
+            "max_tokens": 4096,
+            "stream": True,
+        }
+        try:
+            with httpx.Client(timeout=60) as client:
+                with client.stream("POST", ENDPOINT, headers=headers, json=payload) as resp:
+                    if resp.status_code == 429:
+                        raise RateLimitError("OpenRouter rate limit exceeded")
+                    resp.raise_for_status()
+                    for line in resp.iter_lines():
+                        if line.startswith("data: "):
+                            data_str = line[6:]
+                            if data_str.strip() == "[DONE]":
+                                break
+                            try:
+                                data = json.loads(data_str)
+                                if data.get("choices") and data["choices"][0].get("delta", {}).get("content"):
+                                    yield data["choices"][0]["delta"]["content"]
+                            except json.JSONDecodeError:
+                                continue
+        except httpx.ConnectError:
+            raise ProviderUnavailableError("Cannot connect to OpenRouter")
+        except httpx.TimeoutException:
+            raise ProviderUnavailableError("OpenRouter request timed out")
+
     def is_available(self) -> bool:
         if not self.api_key:
             return False

librarian_code-0.2.0/librarian/cli.py

@@ -0,0 +1,74 @@
+import typer
+from librarian.commands import init, ask, do, why, undo, status
+from librarian.commands import git_cmd
+from librarian.commands import repl
+from librarian.skills.loader import add_skill, list_skills
+from librarian.utils.ui import print_banner, print_muted, print_warning, print_panel, console, INDIGO
+
+app = typer.Typer(
+    name="librarian",
+    help="A CLI coding agent with persistent project memory.",
+    add_completion=False,
+)
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    if ctx.invoked_subcommand is None:
+        print_banner()
+
+
+app.command(name="init")(init.run)
+app.command(name="ask")(ask.run)
+app.command(name="do")(do.run)
+app.command(name="why")(why.run)
+app.command(name="undo")(undo.run)
+app.command(name="status")(status.run)
+app.command(name="repl")(repl.run)
+
+git_app = typer.Typer(help="git operations")
+git_app.command(name="commit")(git_cmd.commit)
+git_app.command(name="push")(git_cmd.push)
+git_app.command(name="diff")(git_cmd.diff)
+git_app.command(name="status")(git_cmd.status)
+app.add_typer(git_app, name="git")
+
+
+def _skill_add(name: str, file: str = None):
+    from pathlib import Path
+    if file:
+        content = Path(file).read_text(encoding="utf-8")
+    else:
+        console.print(f"[bold {INDIGO}]enter skill conventions (Ctrl+D to finish):[/bold {INDIGO}]")
+        lines = []
+        try:
+            while True:
+                lines.append(input())
+        except EOFError:
+            pass
+        content = "\n".join(lines)
+    add_skill(name, content)
+    print_muted(f"  skill '{name}' added")
+
+
+def _skill_list():
+    skills = list_skills()
+    if not skills:
+        print_muted("  no skills found")
+        return
+    from rich.table import Table
+    table = Table(show_header=True, header_style=f"bold {INDIGO}")
+    table.add_column("name")
+    table.add_column("source")
+    for s in skills:
+        table.add_row(s["name"], s["source"])
+    console.print(table)
+
+
+skill_app = typer.Typer(help="manage custom skills")
+skill_app.command(name="add")(_skill_add)
+skill_app.command(name="list")(_skill_list)
+app.add_typer(skill_app, name="skill")
+
+if __name__ == "__main__":
+    app()

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/commands/ask.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from typing import Optional
 from librarian.utils.ui import print_header, print_warning, print_panel, print_muted
 from librarian.utils.token_tracker import tracker
 from librarian.orchestrator.core import ask as ask_llm
@@ -18,7 +19,7 @@ def _check_api_keys():
     return True
 
 
-def run(task: str):
+def run(task: str, file: Optional[str] = None):
     if not Path(".librarian").exists():
         print_header("librarian ask")
         print_warning("project not initialised — run 'librarian init' first")
@@ -30,13 +31,13 @@ def run(task: str):
     print_header("librarian ask")
 
     try:
-        chunks = retrieve(task, n_results=5)
+        chunks = retrieve(task, n_results=5, file_filter=file)
         sources = []
         for c in chunks:
             meta = c["metadata"]
             sources.append(f"{meta['file_path']}:{meta.get('start_line', '?')}-{meta.get('end_line', '?')}")
 
-        response, provider, tokens = ask_llm(task)
+        response, provider, tokens = ask_llm(task, file_filter=file)
         tracker.add(provider, tokens)
         print_panel(response, title="answer")
         if sources:

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/commands/do.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from librarian.utils.ui import (
     print_header, print_warning, print_success, print_muted,
     print_panel, confirm_action, console, INDIGO, WARNING, SUCCESS,
+    print_diff,
 )
 from librarian.utils.token_tracker import tracker
 from librarian.orchestrator.core import read_librarian_md, build_system_prompt
@@ -14,6 +15,7 @@ from librarian.memory import capsule, decision_log
 from librarian.actions.file_ops import read_file, write_file, edit_file
 from librarian.actions.shell_ops import run_command
 from librarian.actions.safety import classify_action, RiskLevel
+from librarian.actions.verify import verify_changes
 from librarian.skills.loader import build_skill_context
 
 DO_SYSTEM_PROMPT = """You are Librarian, a CLI coding agent. Respond ONLY with a JSON plan.
@@ -96,6 +98,28 @@ def _show_plan(plan: dict, task: str):
     console.print(table)
 
 
+def _preview_action(action: dict):
+    action_type = action.get("type")
+    if action_type == "edit_file":
+        path = Path(action["file"])
+        if path.exists():
+            content = read_file(action["file"])
+            if action["old_code"] in content:
+                new_content = content.replace(action["old_code"], action["new_code"], 1)
+                print_diff(action["file"], content, new_content)
+    elif action_type == "create_file":
+        path = Path(action["file"])
+        if path.exists():
+            old_content = read_file(action["file"])
+            print_diff(action["file"], old_content, action.get("content", ""))
+        else:
+            console.print(f"\n[bold {INDIGO}]new file:[/bold {INDIGO}] {action['file']}")
+            from rich.syntax import Syntax
+            content = action.get("content", "")
+            syntax = Syntax(content, Path(action["file"]).suffix.lstrip(".") or "text", theme="monokai")
+            console.print(Panel(syntax, border_style=INDIGO, padding=(0, 1)))
+
+
 def _execute_action(action: dict) -> dict:
     action_type = action.get("type")
     if action_type == "edit_file":
@@ -155,7 +179,7 @@ def _check_api_keys():
     return True
 
 
-def run(task: str):
+def run(task: str, file: str = None):
     if not Path(".librarian").exists():
         print_header("librarian do")
         print_warning("project not initialised — run 'librarian init' first")
@@ -166,7 +190,7 @@ def run(task: str):
 
     print_header("librarian do")
 
-    chunks = retrieve(task, n_results=7)
+    chunks = retrieve(task, n_results=7, file_filter=file)
     conventions = read_librarian_md()
     skill_ctx = build_skill_context()
 
@@ -192,6 +216,10 @@ def run(task: str):
 
     _show_plan(plan, task)
 
+    print_muted("\n  preview of changes:")
+    for action in plan.get("actions", []):
+        _preview_action(action)
+
     if not confirm_action("proceed with execution?"):
         print_muted("  cancelled")
         return
@@ -216,6 +244,14 @@ def run(task: str):
         except Exception as e:
             print_warning(f"failed: {action.get('description', '?')} — {e}")
 
+    if results and files_changed:
+        print_muted("\n  verifying changes...")
+        ok, msg = verify_changes()
+        if not ok:
+            print_warning(f"verification failed:\n{msg}")
+        else:
+            print_success("all checks passed")
+
     decision_log.append({
         "command": "do",
         "task": task,

librarian_code-0.2.0/librarian/commands/git_cmd.py

@@ -0,0 +1,98 @@
+from pathlib import Path
+from typing import Optional
+from librarian.utils.ui import print_header, print_warning, print_success, print_muted, print_panel
+from librarian.actions.shell_ops import run_command, git_stage, git_commit, git_push
+from librarian.actions.safety import classify_action, RiskLevel
+
+
+def _check_api_keys():
+    return True
+
+
+def commit(message: str, files: Optional[list[str]] = None):
+    if not Path(".git").exists():
+        print_header("librarian commit")
+        print_warning("not a git repository")
+        return
+
+    print_header("librarian commit")
+
+    if files:
+        git_stage(files)
+    else:
+        code, out, err = run_command("git add -A")
+        if code != 0:
+            print_warning(f"git add failed: {err}")
+            return
+
+    try:
+        git_commit(message)
+        print_success(f"committed: {message}")
+    except Exception as e:
+        print_warning(f"commit failed: {e}")
+
+
+def push():
+    if not Path(".git").exists():
+        print_header("librarian push")
+        print_warning("not a git repository")
+        return
+
+    print_header("librarian push")
+
+    code, out, err = run_command("git status --short")
+    if out.strip():
+        print_warning("uncommitted changes — commit first")
+        print_muted(out)
+        return
+
+    try:
+        git_push()
+        print_success("pushed to remote")
+    except Exception as e:
+        print_warning(f"push failed: {e}")
+
+
+def diff(file: Optional[str] = None):
+    if not Path(".git").exists():
+        print_header("librarian diff")
+        print_warning("not a git repository")
+        return
+
+    print_header("librarian diff")
+
+    cmd = "git diff"
+    if file:
+        cmd += f" -- {file}"
+
+    code, out, err = run_command(cmd)
+    if code != 0:
+        print_warning(f"git diff failed: {err}")
+        return
+
+    if not out.strip():
+        print_muted("  no changes")
+        return
+
+    from rich.syntax import Syntax
+    from rich.panel import Panel
+    from librarian.utils.ui import console, INDIGO
+
+    syntax = Syntax(out, "diff", theme="monokai")
+    console.print(Panel(syntax, title="diff", border_style=INDIGO, padding=(0, 1)))
+
+
+def status():
+    if not Path(".git").exists():
+        print_header("librarian status")
+        print_warning("not a git repository")
+        return
+
+    print_header("librarian git status")
+
+    code, out, err = run_command("git status")
+    if code != 0:
+        print_warning(f"git status failed: {err}")
+        return
+
+    print_panel(out, title="git status")

librarian_code-0.2.0/librarian/commands/repl.py

@@ -0,0 +1,70 @@
+from pathlib import Path
+from librarian.utils.ui import print_header, print_warning, print_muted, print_panel, console, INDIGO, MUTED
+from librarian.utils.token_tracker import tracker
+from librarian.orchestrator.core import ask as ask_llm
+from librarian.memory.retriever import retrieve
+from librarian.memory import session
+
+
+def _check_api_keys():
+    from librarian.utils.config import GROQ_API_KEY, OPENROUTER_API_KEY
+    if not GROQ_API_KEY and not OPENROUTER_API_KEY:
+        print_warning("no API keys found")
+        print_muted("  set at least one API key in .env file:")
+        print_muted("")
+        print_muted("  GROQ_API_KEY=gsk_...        (free at console.groq.com)")
+        print_muted("  OPENROUTER_API_KEY=sk-or-... (free at openrouter.ai)")
+        print_muted("")
+        return False
+    return True
+
+
+def run():
+    if not Path(".librarian").exists():
+        print_header("librarian repl")
+        print_warning("project not initialised — run 'librarian init' first")
+        return
+
+    if not _check_api_keys():
+        return
+
+    print_header("librarian repl")
+    print_muted("  type 'exit' or 'quit' to leave, 'clear' to reset history")
+    print_muted("")
+
+    while True:
+        try:
+            user_input = console.input(f"[bold {INDIGO}]you>[/bold {INDIGO}] ")
+        except (EOFError, KeyboardInterrupt):
+            print_muted("\n  bye!")
+            break
+
+        user_input = user_input.strip()
+        if not user_input:
+            continue
+
+        if user_input.lower() in ("exit", "quit", "q"):
+            print_muted("  bye!")
+            break
+
+        if user_input.lower() == "clear":
+            session.clear_history()
+            print_muted("  history cleared")
+            continue
+
+        try:
+            chunks = retrieve(user_input, n_results=5)
+            sources = []
+            for c in chunks:
+                meta = c["metadata"]
+                sources.append(f"{meta['file_path']}:{meta.get('start_line', '?')}-{meta.get('end_line', '?')}")
+
+            response, provider, tokens = ask_llm(user_input)
+            tracker.add(provider, tokens)
+
+            print_panel(response, title="answer")
+            if sources:
+                print_muted(f"  sources   {', '.join(sources[:3])}")
+            print_muted(f"  tokens    {tokens}  provider  {provider}")
+        except Exception as e:
+            print_warning(f"error: {e}")

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/memory/capsule.py

@@ -92,3 +92,12 @@ def _archive_low_confidence():
 
 def get_all() -> list[dict]:
     return _load()
+
+
+def get_file_confidence(file_path: str) -> float:
+    capsules = _load()
+    relevant = [c for c in capsules if c.get("file") == file_path]
+    if not relevant:
+        return 1.0
+    avg = sum(c["confidence"] for c in relevant) / len(relevant)
+    return max(avg, 0.1)

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/memory/retriever.py

@@ -3,6 +3,7 @@ import chromadb
 from sentence_transformers import SentenceTransformer
 from librarian.utils.config import CHROMA_PERSIST_DIR, EMBED_MODEL
 from librarian.memory.indexer import _sanitize_collection_name
+from librarian.memory import capsule
 
 _model = None
 _client = None
@@ -22,7 +23,7 @@ def _get_client():
     return _client
 
 
-def retrieve(query: str, n_results: int = 5) -> list[dict]:
+def retrieve(query: str, n_results: int = 5, file_filter: str = None) -> list[dict]:
     model = _get_model()
     client = _get_client()
     project_name = _sanitize_collection_name(os.path.basename(os.getcwd()))
@@ -33,10 +34,16 @@ def retrieve(query: str, n_results: int = 5) -> list[dict]:
         return []
 
     query_embedding = model.encode([query]).tolist()
+
+    where_filter = None
+    if file_filter:
+        where_filter = {"file_path": {"$contains": file_filter}}
+
     results = collection.query(
         query_embeddings=query_embedding,
         n_results=n_results,
         include=["documents", "metadatas", "distances"],
+        where=where_filter,
     )
 
     if not results.get("documents") or not results["documents"][0]:
@@ -50,10 +57,12 @@ def retrieve(query: str, n_results: int = 5) -> list[dict]:
     ):
         if dist > 2.5:
             continue
+        file_conf = capsule.get_file_confidence(meta.get("file_path", ""))
+        adjusted_dist = dist / file_conf
         chunks.append({
             "content": doc,
             "metadata": meta,
-            "distance": dist,
+            "distance": adjusted_dist,
         })
 
     if chunks and sum(c["distance"] for c in chunks) / len(chunks) > 2.0:

librarian_code-0.2.0/librarian/memory/session.py

@@ -0,0 +1,48 @@
+import json
+from pathlib import Path
+from datetime import datetime, timezone
+
+SESSION_FILE = ".librarian/session.json"
+
+
+def _load() -> dict:
+    path = Path(SESSION_FILE)
+    if not path.exists():
+        return {"history": [], "created_at": datetime.now(timezone.utc).isoformat()}
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _save(session: dict):
+    Path(SESSION_FILE).write_text(json.dumps(session, indent=2), encoding="utf-8")
+
+
+def add_message(role: str, content: str):
+    session = _load()
+    session["history"].append({
+        "role": role,
+        "content": content,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    })
+    if len(session["history"]) > 20:
+        session["history"] = session["history"][-20:]
+    _save(session)
+
+
+def get_history(max_messages: int = 10) -> list[dict]:
+    session = _load()
+    return session["history"][-max_messages:]
+
+
+def clear_history():
+    _save({"history": [], "created_at": datetime.now(timezone.utc).isoformat()})
+
+
+def format_history(max_messages: int = 10) -> str:
+    history = get_history(max_messages)
+    if not history:
+        return ""
+    parts = []
+    for msg in history:
+        role = "user" if msg["role"] == "user" else "assistant"
+        parts.append(f"[{role}]: {msg['content'][:500]}")
+    return "\n\n".join(parts)

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/orchestrator/core.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 from librarian.orchestrator.router import get_response
 from librarian.memory.retriever import retrieve
+from librarian.memory import session
 from librarian.skills.loader import build_skill_context
 
 
@@ -29,12 +30,12 @@ def read_librarian_md() -> str:
     return "No project conventions file found."
 
 
-def ask(question: str) -> tuple[str, str, int]:
+def ask(question: str, file_filter: str = None) -> tuple[str, str, int]:
     conventions = read_librarian_md()
     skill_ctx = build_skill_context()
     system = build_system_prompt(conventions, skill_ctx)
 
-    chunks = retrieve(question, n_results=5)
+    chunks = retrieve(question, n_results=5, file_filter=file_filter)
     context = ""
     if chunks:
         parts = []
@@ -43,5 +44,16 @@ def ask(question: str) -> tuple[str, str, int]:
             parts.append(f"--- {meta['file_path']}:{meta.get('start_line', '?')}-{meta.get('end_line', '?')} ---\n{c['content']}")
         context = "\n\n".join(parts)
 
-    prompt = f"Relevant code context:\n{context}\n\nQuestion: {question}" if context else question
-    return get_response(system, prompt)
+    history = session.format_history(max_messages=6)
+    prompt_parts = []
+    if context:
+        prompt_parts.append(f"Relevant code context:\n{context}")
+    if history:
+        prompt_parts.append(f"Previous conversation:\n{history}")
+    prompt_parts.append(f"Question: {question}")
+    prompt = "\n\n".join(prompt_parts)
+
+    session.add_message("user", question)
+    response, provider, tokens = get_response(system, prompt)
+    session.add_message("assistant", response)
+    return response, provider, tokens

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/orchestrator/router.py

@@ -1,3 +1,4 @@
+from typing import Iterator
 from librarian.adapter.groq_adapter import GroqAdapter
 from librarian.adapter.openrouter_adapter import OpenRouterAdapter
 from librarian.exceptions import RateLimitError, ProviderUnavailableError
@@ -15,3 +16,15 @@ def get_response(system: str, prompt: str) -> tuple[str, str, int]:
         log_warning(f"{e} — switching to OpenRouter")
         response = fallback.complete(system, prompt)
         return response, "openrouter", fallback.tokens_used
+
+
+def get_response_stream(system: str, prompt: str) -> tuple[Iterator[str], str]:
+    primary = GroqAdapter()
+    fallback = OpenRouterAdapter()
+
+    try:
+        _ = primary.complete_stream(system, prompt)
+        return primary.complete_stream(system, prompt), "groq"
+    except (RateLimitError, ProviderUnavailableError) as e:
+        log_warning(f"{e} — switching to OpenRouter")
+        return fallback.complete_stream(system, prompt), "openrouter"

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/skills/loader.py

@@ -6,6 +6,7 @@ import functools
 from pathlib import Path
 
 SKILLS_DIR = Path(__file__).parent / "bundled"
+CUSTOM_SKILLS_DIR = Path(".librarian/skills")
 
 
 @functools.lru_cache(maxsize=1)
@@ -82,6 +83,12 @@ def _detect_project_type() -> list[str]:
 
 
 def load_skill(skill_name: str) -> str | None:
+    custom_dir = CUSTOM_SKILLS_DIR / skill_name
+    if custom_dir.exists():
+        conventions_file = custom_dir / "conventions.md"
+        if conventions_file.exists():
+            return conventions_file.read_text(encoding="utf-8")
+
     skill_dir = SKILLS_DIR / skill_name
     if not skill_dir.exists():
         return None
@@ -91,6 +98,32 @@ def load_skill(skill_name: str) -> str | None:
     return None
 
 
+def add_skill(skill_name: str, content: str):
+    CUSTOM_SKILLS_DIR.mkdir(parents=True, exist_ok=True)
+    skill_dir = CUSTOM_SKILLS_DIR / skill_name
+    skill_dir.mkdir(exist_ok=True)
+    (skill_dir / "conventions.md").write_text(content, encoding="utf-8")
+
+
+def list_skills() -> list[dict]:
+    skills = []
+
+    for skill_dir in SKILLS_DIR.iterdir():
+        if skill_dir.is_dir():
+            conventions = skill_dir / "conventions.md"
+            if conventions.exists():
+                skills.append({"name": skill_dir.name, "source": "bundled"})
+
+    if CUSTOM_SKILLS_DIR.exists():
+        for skill_dir in CUSTOM_SKILLS_DIR.iterdir():
+            if skill_dir.is_dir():
+                conventions = skill_dir / "conventions.md"
+                if conventions.exists():
+                    skills.append({"name": skill_dir.name, "source": "custom"})
+
+    return skills
+
+
 def get_relevant_skills() -> list[str]:
     return _detect_project_type()
 

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/utils/config.py

@@ -13,3 +13,14 @@ GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
 CHROMA_PERSIST_DIR = os.getenv("CHROMA_PERSIST_DIR", ".librarian/memory")
 EMBED_MODEL = os.getenv("EMBED_MODEL", "all-MiniLM-L6-v2")
+
+
+def _load_toml_defaults():
+    try:
+        from librarian.utils.toml_config import get_config_value
+        return get_config_value("model", EMBED_MODEL)
+    except Exception:
+        return EMBED_MODEL
+
+
+EMBED_MODEL = _load_toml_defaults()

librarian_code-0.2.0/librarian/utils/toml_config.py

@@ -0,0 +1,36 @@
+import os
+import tomllib
+from pathlib import Path
+
+CONFIG_FILE = "librarian.toml"
+
+DEFAULTS = {
+    "model": "all-MiniLM-L6-v2",
+    "max_results": 5,
+    "distance_threshold": 2.5,
+    "auto_verify": True,
+    "max_history": 20,
+}
+
+
+def load_config() -> dict:
+    config = dict(DEFAULTS)
+
+    config_path = Path(CONFIG_FILE)
+    if config_path.exists():
+        with open(config_path, "rb") as f:
+            user_config = tomllib.load(f)
+        if "librarian" in user_config:
+            config.update(user_config["librarian"])
+
+    if os.getenv("GROQ_API_KEY"):
+        config["provider"] = "groq"
+    elif os.getenv("OPENROUTER_API_KEY"):
+        config["provider"] = "openrouter"
+
+    return config
+
+
+def get_config_value(key: str, default=None):
+    config = load_config()
+    return config.get(key, default)

{librarian_code-0.1.0 → librarian_code-0.2.0}/librarian/utils/ui.py

@@ -95,3 +95,32 @@ def spinner(description: str):
         TextColumn(f"[{MUTED}]{description}[/{MUTED}]"),
         transient=True,
     )
+
+
+def print_stream(iterator, style: str = ""):
+    from rich.live import Live
+    from rich.text import Text
+
+    text = Text("", style=style)
+    with Live(text, console=console, refresh_per_second=10) as live:
+        for token in iterator:
+            text.append(token)
+            live.refresh()
+    return str(text)
+
+
+def print_diff(file_path: str, old_content: str, new_content: str):
+    from rich.syntax import Syntax
+    import difflib
+
+    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/{file_path}", tofile=f"b/{file_path}"))
+
+    if not diff:
+        return
+
+    diff_text = "".join(diff)
+    console.print(f"\n[bold {INDIGO}]diff:[/bold {INDIGO}] {file_path}")
+    syntax = Syntax(diff_text, "diff", theme="monokai", line_numbers=False)
+    console.print(Panel(syntax, border_style=INDIGO, padding=(0, 1)))

{librarian_code-0.1.0 → librarian_code-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "librarian-code"
-version = "0.1.0"
+version = "0.2.0"
 description = "A local-first CLI coding agent with persistent project memory"
 readme = "README.md"
 license = "MIT"

librarian_code-0.1.0/.mimocode/plans/1782009063038-gentle-garden.md

@@ -1,95 +0,0 @@
-# Plan: Publish to PyPI for `pip install -g librarian-code`
-
-## Goal
-Make the package installable globally via `pip install -g librarian-code`.
-
----
-
-## Phase 1: Fix Package Metadata
-
-### 1. Update `pyproject.toml`
-Add missing fields: `readme`, `license`, `authors`, `classifiers`, `urls`, and build artifacts for bundled skills.
-
-### 2. Add `__version__` to `librarian/__init__.py`
-```python
-__version__ = "0.1.0"
-```
-
-### 3. Fix `README.md`
-Remove `.env.example` reference (file doesn't exist).
-
----
-
-## Phase 2: Set Up PyPI Account
-
-1. Go to https://pypi.org/account/register/
-2. Create account (use a dedicated email)
-3. Verify email
-
-### Generate API Token
-1. Go to https://pypi.org/manage/account/token/
-2. Click "Add API token"
-3. Name: `librarian-code-publish`
-4. Scope: "Entire account" (or project-specific after first upload)
-5. Copy token — **it won't be shown again**
-
-### Store Token Locally
-```bash
-pip install twine
-# Create ~/.pypirc (Windows: %USERPROFILE%\.pypirc)
-```
-
-Contents:
-```ini
-[pypi]
-username = __token__
-password = pypi-YOUR_TOKEN_HERE
-```
-
----
-
-## Phase 3: Build & Publish
-
-```bash
-# 1. Install build tools
-pip install build twine
-
-# 2. Clean old builds
-rm -rf dist/ build/ *.egg-info
-
-# 3. Build
-python -m build
-
-# 4. Verify package contents
-twine check dist/*
-
-# 5. Upload to PyPI
-twine upload dist/*
-```
-
----
-
-## Phase 4: Verify
-
-```bash
-# Test install from PyPI
-pip install -g librarian-code
-
-# Should work
-librarian --version
-librarian --help
-```
-
----
-
-## Files to Modify
-- `pyproject.toml`
-- `librarian/__init__.py`
-- `README.md`
-
-## Verification
-1. `python -m build` — produces `.whl` + `.tar.gz`
-2. `twine check dist/*` — passes
-3. `pip install dist/*.whl` — installs correctly
-4. `librarian --version` — prints `0.1.0`
-5. Bundled skills `.md` files included in wheel

librarian_code-0.1.0/librarian/cli.py

@@ -1,26 +0,0 @@
-import typer
-from librarian.commands import init, ask, do, why, undo, status
-from librarian.utils.ui import print_banner, print_muted, print_warning
-
-app = typer.Typer(
-    name="librarian",
-    help="A CLI coding agent with persistent project memory.",
-    add_completion=False,
-)
-
-
-@app.callback(invoke_without_command=True)
-def main(ctx: typer.Context):
-    if ctx.invoked_subcommand is None:
-        print_banner()
-
-
-app.command(name="init")(init.run)
-app.command(name="ask")(ask.run)
-app.command(name="do")(do.run)
-app.command(name="why")(why.run)
-app.command(name="undo")(undo.run)
-app.command(name="status")(status.run)
-
-if __name__ == "__main__":
-    app()