mnemo-dev 0.1.0__py3-none-any.whl

mnemo/__init__.py

@@ -0,0 +1,3 @@
+"""Mnemo – Persistent memory and repo map for Amazon Q chats."""
+
+__version__ = "0.1.0"

mnemo/analyzers/__init__.py

@@ -0,0 +1,108 @@
+"""Roslyn analyzer bridge — uses .NET SDK when available for richer C# analysis."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+_ANALYZER_DIR = Path(__file__).parent.parent.parent / "analyzers" / "roslyn"
+
+
+def dotnet_available() -> bool:
+    """Check if .NET SDK is installed."""
+    return shutil.which("dotnet") is not None
+
+
+def _find_solution_or_project(repo_root: Path) -> Path | None:
+    """Find .sln or .csproj in the repo."""
+    slns = list(repo_root.glob("*.sln"))
+    if slns:
+        return slns[0]
+    csprojs = list(repo_root.rglob("*.csproj"))
+    if csprojs:
+        return repo_root
+    return None
+
+
+def roslyn_available(repo_root: Path) -> bool:
+    """Check if Roslyn analysis is possible for this repo."""
+    if not dotnet_available():
+        return False
+    return _find_solution_or_project(repo_root) is not None
+
+
+def run_roslyn_analyzer(repo_root: Path) -> list[dict[str, Any]] | None:
+    """Run the Roslyn analyzer and return parsed results."""
+    if not dotnet_available():
+        return None
+
+    target = _find_solution_or_project(repo_root)
+    if target is None:
+        return None
+
+    try:
+        result = subprocess.run(
+            ["dotnet", "run", "--project", str(_ANALYZER_DIR), "--", str(target)],
+            capture_output=True,
+            text=True,
+            timeout=120,
+            cwd=str(repo_root),
+        )
+        if result.returncode != 0:
+            return None
+        # stdout may have warnings before JSON — find the JSON array
+        stdout = result.stdout.strip()
+        json_start = stdout.find("[")
+        if json_start == -1:
+            return None
+        return json.loads(stdout[json_start:])
+    except (subprocess.TimeoutExpired, json.JSONDecodeError, OSError):
+        return None
+
+
+def roslyn_to_mnemo_format(roslyn_results: list[dict[str, Any]], repo_root: Path) -> dict[str, dict[str, Any]]:
+    """Convert Roslyn JSON output to the same format tree-sitter extractors return.
+
+    Returns: {relative_file_path: {"imports": [...], "classes": [...], "functions": [...]}}
+    """
+    output: dict[str, dict[str, Any]] = {}
+
+    for file_entry in roslyn_results:
+        filepath = file_entry.get("file", "")
+        if not filepath:
+            continue
+
+        # Make path relative to repo root
+        try:
+            rel = str(Path(filepath).relative_to(repo_root))
+        except ValueError:
+            rel = filepath
+
+        info: dict[str, Any] = {}
+
+        imports = file_entry.get("imports", [])
+        if imports:
+            info["imports"] = imports
+
+        classes = file_entry.get("classes", [])
+        if classes:
+            info["classes"] = []
+            for cls in classes:
+                entry: dict[str, Any] = {"name": cls["name"]}
+                if cls.get("implements"):
+                    entry["implements"] = cls["implements"]
+                if cls.get("methods"):
+                    entry["methods"] = cls["methods"]
+                info["classes"].append(entry)
+
+        functions = file_entry.get("functions", [])
+        if functions:
+            info["functions"] = functions
+
+        if info:
+            output[rel] = info
+
+    return output

mnemo/api_discovery/__init__.py

@@ -0,0 +1,248 @@
+"""API Discovery — parse OpenAPI/Swagger specs and service endpoints."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from ..chunking import api_endpoint_chunk
+from ..config import IGNORE_DIRS, mnemo_path
+from ..retrieval import index_chunks, semantic_query
+
+
+def _should_ignore(path: Path) -> bool:
+    return any(part in IGNORE_DIRS for part in path.parts)
+
+
+def _find_openapi_specs(repo_root: Path) -> list[Path]:
+    """Find OpenAPI/Swagger spec files."""
+    specs = []
+    patterns = ["swagger.json", "openapi.json", "swagger.yaml", "openapi.yaml"]
+    
+    for pattern in patterns:
+        for f in repo_root.rglob(pattern):
+            if not _should_ignore(f):
+                specs.append(f)
+
+    # Also check for specs in common locations
+    for candidate in [
+        repo_root / "docs" / "api",
+        repo_root / "api",
+        repo_root / "specs",
+    ]:
+        if candidate.exists():
+            for f in candidate.rglob("*.json"):
+                try:
+                    data = json.loads(f.read_text())
+                    if "openapi" in data or "swagger" in data:
+                        specs.append(f)
+                except (json.JSONDecodeError, OSError):
+                    pass
+
+    return specs
+
+
+def _parse_openapi(spec_path: Path) -> dict[str, Any] | None:
+    """Parse an OpenAPI spec into a compact summary."""
+    try:
+        content = spec_path.read_text()
+        if spec_path.suffix in (".yaml", ".yml"):
+            try:
+                import yaml
+                data = yaml.safe_load(content)
+            except ImportError:
+                return None
+        else:
+            data = json.loads(content)
+    except (json.JSONDecodeError, OSError):
+        return None
+
+    if not data or not isinstance(data, dict):
+        return None
+
+    info = data.get("info", {})
+    paths = data.get("paths", {})
+
+    endpoints = []
+    for path, methods in paths.items():
+        for method, details in methods.items():
+            if method in ("get", "post", "put", "delete", "patch"):
+                endpoint = {
+                    "method": method.upper(),
+                    "path": path,
+                    "summary": details.get("summary", details.get("operationId", "")),
+                }
+                # Get request body schema name
+                req_body = details.get("requestBody", {})
+                if req_body:
+                    content_types = req_body.get("content", {})
+                    for ct, schema_info in content_types.items():
+                        ref = schema_info.get("schema", {}).get("$ref", "")
+                        if ref:
+                            endpoint["request_schema"] = ref.split("/")[-1]
+                        break
+
+                # Get response schema
+                responses = details.get("responses", {})
+                for code, resp in responses.items():
+                    if code.startswith("2"):
+                        resp_content = resp.get("content", {})
+                        for ct, schema_info in resp_content.items():
+                            ref = schema_info.get("schema", {}).get("$ref", "")
+                            if ref:
+                                endpoint["response_schema"] = ref.split("/")[-1]
+                            break
+                        break
+
+                endpoints.append(endpoint)
+
+    return {
+        "title": info.get("title", spec_path.stem),
+        "version": info.get("version", ""),
+        "base_url": (data.get("servers", [{}])[0].get("url", "") if data.get("servers") else ""),
+        "endpoints": endpoints,
+    }
+
+
+def _detect_endpoints_from_controllers(repo_root: Path) -> list[dict[str, Any]]:
+    """Detect API endpoints from controller attributes in .NET code."""
+    import re
+    endpoints = []
+
+    for cs_file in repo_root.rglob("*Controller.cs"):
+        if _should_ignore(cs_file):
+            continue
+        try:
+            content = cs_file.read_text(errors="replace")
+        except (OSError, PermissionError):
+            continue
+
+        # Skip test files
+        if "Tests" in str(cs_file):
+            continue
+
+        service = cs_file.relative_to(repo_root).parts[0]
+
+        # Get route prefix from class
+        class_route = ""
+        route_match = re.search(r'\[Route\("([^"]+)"\)\]', content)
+        if route_match:
+            class_route = route_match.group(1)
+
+        # Find HTTP method attributes (flexible whitespace matching)
+        for match in re.finditer(
+            r'\[(Http(Get|Post|Put|Delete|Patch))(?:\("([^"]*)"\))?\]\s*(?:\[.*?\]\s*)*public\s+(?:async\s+)?\S+\s+(\w+)',
+            content, re.DOTALL
+        ):
+            method = match.group(2).upper()
+            route = match.group(3) or ""
+            func_name = match.group(4)
+            full_path = f"/{class_route}/{route}".replace("//", "/").rstrip("/")
+            full_path = re.sub(r'\[controller\]', cs_file.stem.replace('Controller', '').lower(), full_path)
+            endpoints.append({
+                "service": service,
+                "method": method,
+                "path": full_path,
+                "handler": func_name,
+            })
+
+    return endpoints
+
+
+def discover_apis(repo_root: Path) -> str:
+    """Discover all APIs in the repo and return as markdown."""
+    lines = ["# API Discovery\n"]
+
+    endpoint_chunks = []
+
+    # Try OpenAPI specs first
+    specs = _find_openapi_specs(repo_root)
+    if specs:
+        lines.append("## OpenAPI Specifications")
+        for spec_path in specs:
+            parsed = _parse_openapi(spec_path)
+            if parsed:
+                lines.append(f"\n### {parsed['title']} (v{parsed['version']})")
+                if parsed['base_url']:
+                    lines.append(f"Base URL: `{parsed['base_url']}`")
+                lines.append("")
+                for ep in parsed["endpoints"]:
+                    req = f" ← {ep['request_schema']}" if ep.get("request_schema") else ""
+                    resp = f" → {ep['response_schema']}" if ep.get("response_schema") else ""
+                    lines.append(f"- `{ep['method']} {ep['path']}` {ep['summary']}{req}{resp}")
+                    endpoint_chunks.append(
+                        api_endpoint_chunk(
+                            path=str(spec_path.relative_to(repo_root)),
+                            method=ep["method"],
+                            endpoint=ep["path"],
+                            summary=ep.get("summary", ""),
+                        )
+                    )
+                lines.append("")
+
+    # Detect from controllers
+    controller_endpoints = _detect_endpoints_from_controllers(repo_root)
+    if controller_endpoints:
+        lines.append("## Controller Endpoints")
+        # Group by service
+        by_service: dict[str, list] = {}
+        for ep in controller_endpoints:
+            svc = ep["service"]
+            if svc not in by_service:
+                by_service[svc] = []
+            by_service[svc].append(ep)
+
+        for svc in sorted(by_service.keys()):
+            lines.append(f"\n### {svc}")
+            for ep in by_service[svc]:
+                lines.append(f"- `{ep['method']} {ep['path']}` → {ep['handler']}()")
+                endpoint_chunks.append(
+                    api_endpoint_chunk(
+                        path=f"{svc}/controller",
+                        method=ep["method"],
+                        endpoint=ep["path"],
+                        summary=f"Handler: {ep['handler']}",
+                        service=svc,
+                    )
+                )
+        lines.append("")
+
+    if endpoint_chunks:
+        index_chunks(repo_root, "api", endpoint_chunks)
+
+    if len(lines) <= 2:
+        return "No APIs discovered. Add OpenAPI specs or check controller annotations."
+
+    return "\n".join(lines)
+
+
+def search_api(repo_root: Path, query: str) -> str:
+    """Search for a specific API endpoint or schema."""
+    full_report = discover_apis(repo_root)
+    semantic_results = semantic_query(repo_root, "api", query, limit=8)
+    if semantic_results:
+        lines = [f"# API Search: '{query}'\n", "## Semantic Matches"]
+        for result in semantic_results:
+            meta = result.get("metadata", {})
+            lines.append(f"- `{meta.get('symbol', '')}` ({meta.get('path', '')})")
+            lines.append(f"  {result.get('content', '')[:240]}")
+        return "\n".join(lines)
+    query_lower = query.lower()
+
+    # Filter lines that match
+    lines = full_report.splitlines()
+    results = []
+    current_section = ""
+    for line in lines:
+        if line.startswith("#"):
+            current_section = line
+        if query_lower in line.lower():
+            if current_section and current_section not in results:
+                results.append(current_section)
+            results.append(line)
+
+    if not results:
+        return f"No API endpoints matching '{query}'. Run full discovery with mnemo_discover_apis."
+
+    return "\n".join(results)

mnemo/chunking.py

@@ -0,0 +1,136 @@
+"""Chunk schema and builders for semantic indexing."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Chunk:
+    """Canonical chunk used for local semantic retrieval."""
+
+    id: str
+    chunk_type: str
+    path: str
+    language: str
+    symbol: str
+    content: str
+    hash: str
+    metadata: dict[str, Any]
+
+
+def _hash(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8", errors="replace")).hexdigest()[:16]
+
+
+def _chunk_id(chunk_type: str, path: str, symbol: str) -> str:
+    raw = f"{chunk_type}:{path}:{symbol}"
+    return hashlib.sha256(raw.encode("utf-8", errors="replace")).hexdigest()[:24]
+
+
+def make_code_chunks(path: str, language: str, info: dict[str, Any]) -> list[Chunk]:
+    """Build code chunks from parsed file info."""
+    chunks: list[Chunk] = []
+
+    for cls in info.get("classes", []):
+        name = str(cls.get("name", "UnknownClass"))
+        methods = cls.get("methods", [])
+        methods_text = "\n".join(f"- {method}" for method in methods)
+        content = f"class {name}\n{methods_text}".strip()
+        chunks.append(
+            Chunk(
+                id=_chunk_id("code", path, f"class:{name}"),
+                chunk_type="code",
+                path=path,
+                language=language,
+                symbol=name,
+                content=content,
+                hash=_hash(content),
+                metadata={"kind": "class", "method_count": len(methods)},
+            )
+        )
+
+    seen_ids: set[str] = set()
+    for fn in info.get("functions", []):
+        text = str(fn)
+        symbol = text.split("(")[0].replace("def ", "").strip()
+        chunk_id = _chunk_id("code", path, f"function:{symbol}:{_hash(text)}")
+        if chunk_id in seen_ids:
+            continue
+        seen_ids.add(chunk_id)
+        chunks.append(
+            Chunk(
+                id=chunk_id,
+                chunk_type="code",
+                path=path,
+                language=language,
+                symbol=symbol or "function",
+                content=text,
+                hash=_hash(text),
+                metadata={"kind": "function"},
+            )
+        )
+    return chunks
+
+
+def markdown_heading_chunks(base_dir: Path, file_path: Path) -> list[Chunk]:
+    """Split a markdown file into heading-based chunks."""
+    try:
+        content = file_path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+
+    rel_path = str(file_path.relative_to(base_dir))
+    lines = content.splitlines()
+    sections: list[tuple[str, list[str]]] = []
+    current_heading = "Document"
+    current_lines: list[str] = []
+
+    for line in lines:
+        if line.startswith("#"):
+            if current_lines:
+                sections.append((current_heading, current_lines))
+            current_heading = line.lstrip("#").strip() or "Section"
+            current_lines = [line]
+        else:
+            current_lines.append(line)
+    if current_lines:
+        sections.append((current_heading, current_lines))
+
+    chunks: list[Chunk] = []
+    for heading, body_lines in sections:
+        text = "\n".join(body_lines).strip()
+        if not text:
+            continue
+        chunks.append(
+            Chunk(
+                id=_chunk_id("knowledge", rel_path, heading),
+                chunk_type="knowledge",
+                path=rel_path,
+                language="markdown",
+                symbol=heading,
+                content=text,
+                hash=_hash(text),
+                metadata={"kind": "heading"},
+            )
+        )
+    return chunks
+
+
+def api_endpoint_chunk(path: str, method: str, endpoint: str, summary: str, service: str = "") -> Chunk:
+    """Build a chunk from an API endpoint."""
+    symbol = f"{method.upper()} {endpoint}"
+    content = f"{symbol}\n{summary}".strip()
+    return Chunk(
+        id=_chunk_id("api", path, symbol),
+        chunk_type="api",
+        path=path,
+        language="http",
+        symbol=symbol,
+        content=content,
+        hash=_hash(content),
+        metadata={"kind": "endpoint", "service": service},
+    )

mnemo/cli.py

@@ -0,0 +1,186 @@
+"""Mnemo CLI - persistent memory for AI coding chats."""
+
+from pathlib import Path
+
+import click
+
+from .clients import CLIENT_CHOICES, DEFAULT_CLIENT
+
+
+@click.group()
+def cli():
+    """Mnemo - persistent memory and repo map for AI coding assistants."""
+    pass
+
+
+@cli.command()
+@click.option(
+    "--client",
+    "-c",
+    default=DEFAULT_CLIENT,
+    type=click.Choice(CLIENT_CHOICES),
+    show_default=True,
+    help="AI client to configure.",
+)
+@click.argument("path", default=".", type=click.Path(exists=True))
+def init(path: str, client: str):
+    """Initialize .mnemo/ in the current repo."""
+    from .init import init as do_init
+
+    result = do_init(Path(path).resolve(), client=client)
+    click.echo(result)
+
+
+@cli.command()
+@click.argument("path", default=".", type=click.Path(exists=True))
+def map(path: str):
+    """Regenerate the repo map."""
+    from .config import mnemo_path
+    from .repo_map import save_repo_map
+
+    repo_root = Path(path).resolve()
+    if not mnemo_path(repo_root).exists():
+        click.echo("Not initialized. Run `mnemo init` first.")
+        return
+    save_repo_map(repo_root)
+    click.echo("Repo map updated.")
+
+
+@cli.command()
+@click.argument("content")
+@click.option("--category", "-c", default="general")
+@click.argument("path", default=".", type=click.Path(exists=True))
+def remember(content: str, category: str, path: str):
+    """Store a memory entry. Example: mnemo remember 'uses FastAPI'"""
+    from .memory import add_memory
+
+    entry = add_memory(Path(path).resolve(), content, category)
+    click.echo(f"Remembered #{entry['id']}: {content}")
+
+
+@cli.command()
+@click.argument("path", default=".", type=click.Path(exists=True))
+def recall(path: str):
+    """Show all stored memory."""
+    from .memory import recall as do_recall
+
+    data = do_recall(Path(path).resolve())
+    if not data:
+        click.echo("No memory found. Run `mnemo init` first.")
+        return
+    click.echo(data)
+
+
+@cli.command()
+@click.option(
+    "--client",
+    "-c",
+    default="all",
+    type=click.Choice(CLIENT_CHOICES),
+    show_default=True,
+    help="AI client setup to inspect.",
+)
+@click.argument("path", default=".", type=click.Path(exists=True))
+def doctor(path: str, client: str):
+    """Diagnose Mnemo installation and client setup."""
+    from .doctor import doctor as run_doctor
+
+    click.echo(run_doctor(Path(path).resolve(), client=client))
+
+
+@cli.command()
+@click.argument("path", default=".", type=click.Path(exists=True))
+@click.confirmation_option(prompt="This will delete all Mnemo memory. Are you sure?")
+def reset(path: str):
+    """Wipe all Mnemo data and start fresh. Run: mnemo reset"""
+    import shutil
+
+    from .config import mnemo_path
+    from .clients import CLIENTS, context_path
+
+    repo_root = Path(path).resolve()
+    base = mnemo_path(repo_root)
+
+    # Remove .mnemo/ data
+    if base.exists():
+        shutil.rmtree(base)
+        click.echo(".mnemo/ deleted.")
+    else:
+        click.echo("Nothing to reset - .mnemo/ not found.")
+        return
+
+    # Remove client context files
+    for target in CLIENTS.values():
+        ctx = context_path(repo_root, target)
+        if ctx and ctx.exists():
+            ctx.unlink()
+            click.echo(f"Removed {ctx.relative_to(repo_root)}")
+
+    click.echo("Run `mnemo init` to start fresh.")
+
+
+@cli.command()
+@click.argument("path", default=".", type=click.Path(exists=True))
+def status(path: str):
+    """Quick check: is Mnemo initialized and MCP server responding?"""
+    from .config import mnemo_path
+    from .clients import find_mnemo_mcp_command
+    from .doctor import _check_mcp_alive
+
+    repo_root = Path(path).resolve()
+    base = mnemo_path(repo_root)
+
+    if not base.exists():
+        click.echo("❌ Not initialized. Run: mnemo init")
+        return
+
+    command = find_mnemo_mcp_command()
+    alive = _check_mcp_alive(command)
+
+    if alive:
+        click.echo("✅ Mnemo active — MCP server responding")
+    else:
+        click.echo("⚠️  Mnemo initialized but MCP server not responding — restart your IDE")
+
+
+@cli.command()
+@click.argument("target", required=False)
+@click.option("--discover", "-d", type=click.Path(exists=True), help="Auto-discover all repos under a directory.")
+@click.option("--init", "auto_init", is_flag=True, help="Auto-initialize discovered repos that haven't been set up.")
+@click.argument("path", default=".", type=click.Path(exists=True))
+def link(target: str | None, discover: str | None, auto_init: bool, path: str):
+    """Link a sibling repo for cross-repo queries. Use --discover to auto-find repos."""
+    from .workspace import link_repo, discover_repos
+
+    repo_root = Path(path).resolve()
+    if discover:
+        result = discover_repos(repo_root, Path(discover), auto_init=auto_init)
+    elif target:
+        result = link_repo(repo_root, Path(target))
+    else:
+        click.echo("Provide a repo path or use --discover <dir>")
+        return
+    click.echo(result)
+
+
+@cli.command()
+@click.argument("name")
+@click.argument("path", default=".", type=click.Path(exists=True))
+def unlink(name: str, path: str):
+    """Remove a linked repo."""
+    from .workspace import unlink_repo
+
+    click.echo(unlink_repo(Path(path).resolve(), name))
+
+
+@cli.command()
+@click.argument("path", default=".", type=click.Path(exists=True))
+def links(path: str):
+    """Show all linked repos and their status."""
+    from .workspace import format_links
+
+    click.echo(format_links(Path(path).resolve()))
+
+
+if __name__ == "__main__":
+    cli()