mnemo-dev 0.1.0__py3-none-any.whl

mnemo/retrieval.py

@@ -0,0 +1,31 @@
+"""Semantic retrieval orchestration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .chunking import Chunk
+from .vector_index import LocalVectorIndex
+
+_INDICES: dict[str, LocalVectorIndex] = {}
+
+
+def get_index(repo_root: Path) -> LocalVectorIndex:
+    key = str(repo_root.resolve())
+    if key not in _INDICES:
+        _INDICES[key] = LocalVectorIndex(repo_root)
+    return _INDICES[key]
+
+
+def index_chunks(repo_root: Path, namespace: str, chunks: list[Chunk]) -> None:
+    get_index(repo_root).upsert(namespace, chunks)
+
+
+def semantic_query(
+    repo_root: Path,
+    namespace: str,
+    query: str,
+    limit: int = 10,
+    filters: dict[str, str] | None = None,
+) -> list[dict]:
+    return get_index(repo_root).query(namespace, query, limit=limit, filters=filters)

mnemo/sprint/__init__.py

@@ -0,0 +1,102 @@
+"""Sprint/task context - store and recall task-specific context."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from ..storage import Collections, get_storage
+
+
+def _load_tasks(repo_root: Path) -> list[dict]:
+    data = get_storage(repo_root).read_collection(Collections.TASKS)
+    return data if isinstance(data, list) else []
+
+
+def _save_tasks(repo_root: Path, tasks: list[dict]) -> None:
+    get_storage(repo_root).write_collection(Collections.TASKS, tasks)
+
+
+def set_current_task(
+    repo_root: Path,
+    task_id: str,
+    description: str = "",
+    files: list[str] | None = None,
+    notes: str = "",
+) -> dict:
+    """Set the current task/ticket being worked on."""
+    tasks = _load_tasks(repo_root)
+
+    for task in tasks:
+        if task["task_id"] == task_id:
+            task["last_active"] = time.time()
+            if description:
+                task["description"] = description
+            if files:
+                task["files"] = sorted(set(task.get("files", []) + files))
+            if notes:
+                task["notes"] = task.get("notes", "") + "\n" + notes
+            task["status"] = "active"
+            _save_tasks(repo_root, tasks)
+            return task
+
+    entry = {
+        "task_id": task_id,
+        "description": description,
+        "files": files or [],
+        "notes": notes,
+        "status": "active",
+        "created": time.time(),
+        "last_active": time.time(),
+    }
+    tasks.append(entry)
+    _save_tasks(repo_root, tasks)
+    return entry
+
+
+def complete_task(repo_root: Path, task_id: str, summary: str = "") -> str:
+    """Mark a task as complete with an optional summary."""
+    tasks = _load_tasks(repo_root)
+    for task in tasks:
+        if task["task_id"] == task_id:
+            task["status"] = "completed"
+            task["completed_at"] = time.time()
+            if summary:
+                task["summary"] = summary
+            _save_tasks(repo_root, tasks)
+            return f"Task {task_id} marked complete."
+    return f"Task {task_id} not found."
+
+
+def get_current_task(repo_root: Path) -> str:
+    """Get the currently active task context."""
+    tasks = _load_tasks(repo_root)
+    active = [task for task in tasks if task.get("status") == "active"]
+
+    if not active:
+        return "No active task. Use mnemo_task to set one."
+
+    lines = ["# Active Tasks\n"]
+    for task in active:
+        lines.append(f"## {task['task_id']}")
+        if task.get("description"):
+            lines.append(task["description"])
+        if task.get("files"):
+            lines.append(f"**Files:** {', '.join(task['files'])}")
+        if task.get("notes"):
+            lines.append(f"**Notes:** {task['notes']}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def format_tasks(repo_root: Path) -> str:
+    """Format all tasks as markdown."""
+    tasks = _load_tasks(repo_root)
+    if not tasks:
+        return "No tasks stored."
+
+    lines = ["# Task History\n"]
+    for task in tasks[-20:]:
+        status = "done" if task.get("status") == "completed" else "active"
+        lines.append(f"- {status}: **{task['task_id']}** - {task.get('description', '')[:80]}")
+    return "\n".join(lines)

mnemo/storage.py

@@ -0,0 +1,215 @@
+"""Storage abstraction for Mnemo collections."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Protocol
+
+from .config import CONTEXT_FILE, DECISIONS_FILE, MEMORY_FILE, mnemo_path
+
+
+class Collections:
+    """Logical storage collection names."""
+
+    MEMORY = "memory"
+    DECISIONS = "decisions"
+    CONTEXT = "context"
+    HASHES = "hashes"
+    ERRORS = "errors"
+    INCIDENTS = "incidents"
+    REVIEWS = "reviews"
+    TASKS = "tasks"
+    REPO_MAP = "repo_map"
+    KNOWLEDGE = "knowledge"
+
+
+class StorageAdapter(Protocol):
+    """Synchronous storage contract used by local Mnemo tools."""
+
+    def get(self, collection: str, key: str) -> dict[str, Any] | None:
+        """Return a single item by key."""
+
+    def put(self, collection: str, key: str, value: dict[str, Any]) -> None:
+        """Create or replace a single item."""
+
+    def list(self, collection: str) -> list[dict[str, Any]]:
+        """Return all items in a collection."""
+
+    def query(self, collection: str, filters: dict[str, Any]) -> list[dict[str, Any]]:
+        """Return items matching exact filter values."""
+
+    def delete(self, collection: str, key: str) -> None:
+        """Delete a single item by key."""
+
+    def search(self, collection: str, query: str, k: int = 10) -> list[dict[str, Any]]:
+        """Return keyword matches for a collection."""
+
+    def read_collection(self, collection: str) -> list[dict[str, Any]] | dict[str, Any]:
+        """Read a collection in its native persisted shape."""
+
+    def write_collection(self, collection: str, data: list[dict[str, Any]] | dict[str, Any]) -> None:
+        """Write a collection in its native persisted shape."""
+
+
+COLLECTION_FILES = {
+    Collections.MEMORY: MEMORY_FILE,
+    Collections.DECISIONS: DECISIONS_FILE,
+    Collections.CONTEXT: CONTEXT_FILE,
+    Collections.HASHES: "hashes.json",
+    Collections.ERRORS: "errors.json",
+    Collections.INCIDENTS: "incidents.json",
+    Collections.REVIEWS: "reviews.json",
+    Collections.TASKS: "tasks.json",
+    Collections.REPO_MAP: "repo_map.json",
+}
+
+LIST_COLLECTIONS = {
+    Collections.MEMORY,
+    Collections.DECISIONS,
+    Collections.ERRORS,
+    Collections.INCIDENTS,
+    Collections.REVIEWS,
+    Collections.TASKS,
+}
+
+
+class JSONFileAdapter:
+    """Local JSON-file storage backend preserving the current `.mnemo` layout."""
+
+    def __init__(self, repo_root: Path):
+        self.repo_root = repo_root
+        self.base_path = mnemo_path(repo_root)
+        self.base_path.mkdir(parents=True, exist_ok=True)
+
+    def collection_path(self, collection: str) -> Path:
+        filename = COLLECTION_FILES.get(collection, f"{collection}.json")
+        return self.base_path / filename
+
+    def get(self, collection: str, key: str) -> dict[str, Any] | None:
+        data = self._load(collection)
+        if isinstance(data, dict):
+            value = data.get(key)
+            if isinstance(value, dict):
+                return value
+            if value is not None:
+                return {"key": key, "value": value}
+            return None
+
+        for item in data:
+            if self._item_key(item) == key:
+                return item
+        return None
+
+    def put(self, collection: str, key: str, value: dict[str, Any]) -> None:
+        if collection in LIST_COLLECTIONS:
+            items = self._load_list(collection)
+            replacement = dict(value)
+            if "id" not in replacement and key and "task_id" not in replacement:
+                replacement["id"] = key
+
+            for index, item in enumerate(items):
+                if self._item_key(item) == key:
+                    items[index] = replacement
+                    self.replace_all(collection, items)
+                    return
+
+            items.append(replacement)
+            self.replace_all(collection, items)
+            return
+
+        data = self._load_dict(collection)
+        data[key] = value
+        self._save(collection, data)
+
+    def list(self, collection: str) -> list[dict[str, Any]]:
+        data = self._load(collection)
+        if isinstance(data, list):
+            return [item for item in data if isinstance(item, dict)]
+        return [
+            {"key": key, **value} if isinstance(value, dict) else {"key": key, "value": value}
+            for key, value in data.items()
+        ]
+
+    def query(self, collection: str, filters: dict[str, Any]) -> list[dict[str, Any]]:
+        if not filters:
+            return self.list(collection)
+        return [
+            item
+            for item in self.list(collection)
+            if all(item.get(field) == expected for field, expected in filters.items())
+        ]
+
+    def delete(self, collection: str, key: str) -> None:
+        if collection in LIST_COLLECTIONS:
+            items = [item for item in self._load_list(collection) if self._item_key(item) != key]
+            self.replace_all(collection, items)
+            return
+
+        data = self._load_dict(collection)
+        data.pop(key, None)
+        self._save(collection, data)
+
+    def search(self, collection: str, query: str, k: int = 10) -> list[dict[str, Any]]:
+        terms = [term for term in query.lower().split() if term]
+        if not terms:
+            return self.list(collection)[:k]
+
+        scored: list[tuple[int, dict[str, Any]]] = []
+        for item in self.list(collection):
+            text = json.dumps(item, sort_keys=True).lower()
+            score = sum(1 for term in terms if term in text)
+            if score:
+                scored.append((score, item))
+
+        scored.sort(key=lambda match: match[0], reverse=True)
+        return [item for _, item in scored[:k]]
+
+    def replace_all(self, collection: str, items: list[dict[str, Any]]) -> None:
+        """Replace a list collection in one write."""
+        self._save(collection, items)
+
+    def read_collection(self, collection: str) -> list[dict[str, Any]] | dict[str, Any]:
+        """Read a collection in its native persisted shape."""
+        return self._load(collection)
+
+    def write_collection(self, collection: str, data: list[dict[str, Any]] | dict[str, Any]) -> None:
+        """Write a collection in its native persisted shape."""
+        self._save(collection, data)
+
+    def _load(self, collection: str) -> list[dict[str, Any]] | dict[str, Any]:
+        path = self.collection_path(collection)
+        if not path.exists():
+            return [] if collection in LIST_COLLECTIONS else {}
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return [] if collection in LIST_COLLECTIONS else {}
+        if collection in LIST_COLLECTIONS:
+            return data if isinstance(data, list) else []
+        return data if isinstance(data, dict) else {}
+
+    def _load_list(self, collection: str) -> list[dict[str, Any]]:
+        data = self._load(collection)
+        return data if isinstance(data, list) else []
+
+    def _load_dict(self, collection: str) -> dict[str, Any]:
+        data = self._load(collection)
+        return data if isinstance(data, dict) else {}
+
+    def _save(self, collection: str, data: Any) -> None:
+        path = self.collection_path(collection)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+
+    @staticmethod
+    def _item_key(item: dict[str, Any]) -> str:
+        for field in ("id", "task_id", "key"):
+            if field in item:
+                return str(item[field])
+        return ""
+
+
+def get_storage(repo_root: Path) -> StorageAdapter:
+    """Return the default local storage adapter."""
+    return JSONFileAdapter(repo_root)

mnemo/team_graph/__init__.py

@@ -0,0 +1,96 @@
+"""Team Knowledge Graph — who knows what, based on git history."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from collections import defaultdict
+
+from ..config import IGNORE_DIRS
+
+
+def _should_ignore(path: str) -> bool:
+    return any(part in IGNORE_DIRS for part in path.split("/"))
+
+
+def build_team_graph(repo_root: Path) -> dict[str, dict]:
+    """Build expertise map from git history."""
+    try:
+        from git import Repo
+        repo = Repo(repo_root)
+    except Exception:
+        return {}
+
+    # author → {service: commit_count}
+    expertise: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+    # file → last author
+    last_touch: dict[str, str] = {}
+
+    try:
+        for commit in repo.iter_commits(max_count=500, no_merges=True):
+            author = commit.author.name
+            for file_path in commit.stats.files:
+                if _should_ignore(file_path):
+                    continue
+                parts = file_path.split("/")
+                service = parts[0] if len(parts) > 1 else "root"
+                expertise[author][service] += 1
+                if file_path not in last_touch:
+                    last_touch[file_path] = author
+    except Exception:
+        pass
+
+    return {
+        "expertise": dict(expertise),
+        "last_touch": last_touch,
+    }
+
+
+def get_experts(repo_root: Path, query: str = "") -> str:
+    """Find who has expertise in a specific area."""
+    graph = build_team_graph(repo_root)
+    if not graph:
+        return "No git history available for team analysis."
+
+    expertise = graph.get("expertise", {})
+    query_lower = query.lower()
+
+    lines = []
+    if query:
+        lines.append(f"# Experts for '{query}'\n")
+        # Find authors with most commits in matching services
+        scores: list[tuple[str, int]] = []
+        for author, services in expertise.items():
+            score = sum(count for svc, count in services.items() if query_lower in svc.lower())
+            if score > 0:
+                scores.append((author, score))
+        scores.sort(key=lambda x: -x[1])
+        if scores:
+            for author, count in scores[:10]:
+                lines.append(f"- **{author}** — {count} commits")
+        else:
+            lines.append(f"No experts found for '{query}'.")
+    else:
+        lines.append("# Team Knowledge Map\n")
+        for author in sorted(expertise.keys()):
+            services = expertise[author]
+            top = sorted(services.items(), key=lambda x: -x[1])[:3]
+            areas = ", ".join(f"{svc} ({count})" for svc, count in top)
+            lines.append(f"- **{author}** — {areas}")
+
+    return "\n".join(lines)
+
+
+def who_last_touched(repo_root: Path, filepath: str) -> str:
+    """Find who last modified a file."""
+    graph = build_team_graph(repo_root)
+    last_touch = graph.get("last_touch", {})
+
+    matches = [(f, author) for f, author in last_touch.items() if filepath.lower() in f.lower()]
+
+    if not matches:
+        return f"No git history for '{filepath}'."
+
+    lines = [f"# Last touched: '{filepath}'\n"]
+    for f, author in matches[:10]:
+        lines.append(f"- **{f}** → {author}")
+    return "\n".join(lines)

mnemo/test_intel/__init__.py

@@ -0,0 +1,111 @@
+"""Test Intelligence — map tests to source code, know what to run/update."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from ..config import IGNORE_DIRS
+
+
+def _should_ignore(path: Path) -> bool:
+    return any(part in IGNORE_DIRS for part in path.parts)
+
+
+def build_test_map(repo_root: Path) -> dict[str, list[str]]:
+    """Map source files to their test files based on naming conventions and imports."""
+    test_files: list[Path] = []
+    source_files: list[Path] = []
+
+    for cs_file in repo_root.rglob("*.cs"):
+        if _should_ignore(cs_file):
+            continue
+        rel = str(cs_file.relative_to(repo_root))
+        if "Test" in rel:
+            test_files.append(cs_file)
+        else:
+            source_files.append(cs_file)
+
+    # Map: source_file → [test_files]
+    test_map: dict[str, list[str]] = {}
+
+    for source in source_files:
+        source_name = source.stem  # e.g. "AuthorizationService"
+        source_rel = str(source.relative_to(repo_root))
+        matching_tests = []
+
+        for test in test_files:
+            test_name = test.stem
+            # Convention: FooTests.cs tests Foo.cs
+            if source_name in test_name:
+                matching_tests.append(str(test.relative_to(repo_root)))
+                continue
+
+            # Check if test imports/uses the source class
+            try:
+                content = test.read_text(errors="replace")
+                if source_name in content:
+                    matching_tests.append(str(test.relative_to(repo_root)))
+            except (OSError, PermissionError):
+                continue
+
+        if matching_tests:
+            test_map[source_rel] = matching_tests
+
+    return test_map
+
+
+def get_tests_for_file(repo_root: Path, filepath: str) -> str:
+    """Get all tests that cover a specific file."""
+    test_map = build_test_map(repo_root)
+    query = filepath.lower()
+
+    matches = []
+    for source, tests in test_map.items():
+        if query in source.lower():
+            matches.append((source, tests))
+
+    if not matches:
+        return f"No tests found for '{filepath}'."
+
+    lines = [f"# Tests for '{filepath}'\n"]
+    for source, tests in matches:
+        lines.append(f"## {source}")
+        for t in tests:
+            lines.append(f"- {t}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def get_coverage_summary(repo_root: Path) -> str:
+    """Get a summary of test coverage by service."""
+    test_map = build_test_map(repo_root)
+
+    # Group by service
+    by_service: dict[str, dict] = {}
+    for source, tests in test_map.items():
+        parts = source.split("/")
+        svc = parts[0] if len(parts) > 1 else "root"
+        if svc not in by_service:
+            by_service[svc] = {"covered": 0, "tests": 0}
+        by_service[svc]["covered"] += 1
+        by_service[svc]["tests"] += len(tests)
+
+    # Count total source files per service
+    total_by_service: dict[str, int] = {}
+    for cs_file in repo_root.rglob("*.cs"):
+        if _should_ignore(cs_file) or "Test" in str(cs_file):
+            continue
+        parts = cs_file.relative_to(repo_root).parts
+        svc = parts[0] if len(parts) > 1 else "root"
+        total_by_service[svc] = total_by_service.get(svc, 0) + 1
+
+    lines = ["# Test Coverage Summary\n"]
+    for svc in sorted(set(list(by_service.keys()) + list(total_by_service.keys()))):
+        total = total_by_service.get(svc, 0)
+        covered = by_service.get(svc, {}).get("covered", 0)
+        tests = by_service.get(svc, {}).get("tests", 0)
+        pct = f"{covered/total*100:.0f}%" if total > 0 else "0%"
+        lines.append(f"- **{svc}**: {covered}/{total} files covered ({pct}), {tests} test files")
+
+    return "\n".join(lines)