mimry 0.1.0__py3-none-any.whl

mimry/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

mimry/adapters.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Literal
+
+AdapterStatus = Literal["active", "planned"]
+AdapterKind = Literal["code", "document", "data", "media", "project"]
+
+
+@dataclass(frozen=True)
+class AdapterInfo:
+    name: str
+    status: AdapterStatus
+    kind: AdapterKind
+    extensions: tuple[str, ...]
+    parser: str
+    emits: tuple[str, ...]
+    agent_use: str
+    notes: str
+
+    def to_dict(self) -> dict[str, object]:
+        data = asdict(self)
+        data["extensions"] = list(self.extensions)
+        data["emits"] = list(self.emits)
+        return data
+
+
+BUILTIN_ADAPTERS: tuple[AdapterInfo, ...] = (
+    AdapterInfo(
+        name="python-ast",
+        status="active",
+        kind="code",
+        extensions=(".py",),
+        parser="stdlib ast",
+        emits=("files", "symbols", "imports", "defines_edges", "line_ranges"),
+        agent_use="Find Python services, tests, functions, classes, imports, and edit locations without reading every file.",
+        notes="Currently extracts FunctionDef, AsyncFunctionDef, ClassDef, imports, line_start, line_end.",
+    ),
+    AdapterInfo(
+        name="typescript-ast",
+        status="active",
+        kind="code",
+        extensions=(".js", ".jsx", ".ts", ".tsx"),
+        parser="tree-sitter-language-pack",
+        emits=(
+            "files",
+            "symbols",
+            "imports",
+            "exports",
+            "defines_edges",
+            "component_edges",
+            "call_edges",
+            "jsx_elements",
+            "line_ranges",
+        ),
+        agent_use="Frontend agents can find React/TypeScript components, functions, classes, methods, imports, JSX usage, call relationships, and edit locations without reading every TSX file.",
+        notes="Extracts functions, classes, methods, variable/arrow components, JSX element references, import/export hints (ES and CommonJS require), and line ranges. Call sites resolve to symbol-to-symbol call edges. Module-scope caller attribution is exact; a call on a `const x = f()` line is still attributed to the local binding.",
+    ),
+    AdapterInfo(
+        name="config-manifest",
+        status="active",
+        kind="data",
+        extensions=(
+            "package.json",
+            "pyproject.toml",
+            "tsconfig.json",
+            "vite.config.*",
+            "next.config.*",
+            "app.json",
+            "app.config.*",
+            ".env.example",
+            "CLAUDE.md",
+            "AGENTS.md",
+            "README.md",
+        ),
+        parser="manifest-specific safe metadata parsers",
+        emits=("commands", "package_manager", "frameworks", "entrypoints", "env_names", "agent_rules"),
+        agent_use="Gives coding agents exact commands, package managers, frameworks, env variable names, and repo rules before edits without exposing secret values.",
+        notes="Operating-context adapter layered alongside the graph; does not replace code graph extraction.",
+    ),
+    AdapterInfo(
+        name="nextjs-app-router",
+        status="active",
+        kind="project",
+        extensions=("page.tsx", "layout.tsx", "route.ts", "loading.tsx", "error.tsx", "not-found.tsx"),
+        parser="safe filesystem router detector + TypeScript AST facts",
+        emits=("routes", "layouts", "api_routes", "dynamic_segments", "verification_hints"),
+        agent_use="Maps Next.js App Router pages, layouts, loading/error/not-found surfaces, dynamic segments, and API route files for web agents.",
+        notes="Does not execute Next.js or read env values; emits route facts into file metadata for ranking/context packs.",
+    ),
+    AdapterInfo(
+        name="fastapi",
+        status="active",
+        kind="project",
+        extensions=(".py",),
+        parser="Python AST FastAPI/APIRouter decorator detector",
+        emits=("api_routes", "http_methods", "endpoint_symbols", "route_edges"),
+        agent_use="Lets backend agents find FastAPI endpoints, methods, paths, and endpoint functions without broad Python spelunking.",
+        notes="Detects literal @app/@router HTTP method paths only; no app execution or dependency resolution.",
+    ),
+    AdapterInfo(
+        name="react-native-expo",
+        status="active",
+        kind="project",
+        extensions=("app.json", "app.config.*", ".tsx", ".ts"),
+        parser="Expo config + Expo Router filesystem detector",
+        emits=("mobile_surfaces", "expo_routes", "screens", "native_config_hints", "app_config_edges"),
+        agent_use="Surfaces Expo Router routes, screen/component files, and native iOS/Android config hints without simulator access.",
+        notes="Safe manifest/filesystem parsing only; does not run Expo, Metro, xcodebuild, adb, or simulators.",
+    ),
+    AdapterInfo(
+        name="sql-schema",
+        status="active",
+        kind="data",
+        extensions=(".sql", ".py"),
+        parser="conservative CREATE TABLE regex over text/Python string literals",
+        emits=("tables", "columns", "schema_symbols", "migration_hints"),
+        agent_use="Finds straightforward SQL/SQLite tables and columns while keeping migrations as schema evidence instead of runtime edit targets.",
+        notes="Read-only text parsing; never executes migrations, opens databases, or performs writes.",
+    ),
+    AdapterInfo(
+        name="markdown-docs",
+        status="active",
+        kind="document",
+        extensions=(".md", ".mdx"),
+        parser="Markdown heading/frontmatter/link/wiki-link parser",
+        emits=("headings", "frontmatter", "doc_links", "wiki_links", "doc_relationship_hints"),
+        agent_use="Turns docs, plans, specs, and Obsidian-style notes into structured context without overpowering code-edit queries.",
+        notes="Extracts headings, title/type/tags frontmatter, markdown links, and [[wiki links]]; stores no full document body.",
+    ),
+    AdapterInfo(
+        name="generic-text",
+        status="active",
+        kind="document",
+        extensions=("*",),
+        parser="safe text metadata and content hints",
+        emits=("files", "metadata", "content_hints"),
+        agent_use="Fallback coverage for docs, configs, unknown text files, and ranking hints.",
+        notes="Does not store full text by default; sensitive files are skipped by scanner policy.",
+    ),
+)
+
+PLANNED_ADAPTERS: tuple[AdapterInfo, ...] = (
+    AdapterInfo(
+        name="js-ts-regex",
+        status="planned",
+        kind="code",
+        extensions=(".ts", ".tsx", ".js", ".jsx"),
+        parser="regex import/export scanner",
+        emits=("files", "imports", "exports", "defines_edges"),
+        agent_use="Fallback path if tree-sitter is unavailable in a constrained environment.",
+        notes="Kept as fallback; active adapter is now typescript-ast.",
+    ),
+    AdapterInfo(
+        name="sql-alembic",
+        status="planned",
+        kind="data",
+        extensions=(".sql", ".py"),
+        parser="Alembic migration lineage detector layered on sql-schema",
+        emits=("migration_edges", "schema_versions", "upgrade_downgrade_symbols"),
+        agent_use="Adds richer migration lineage and DB edit gates after the active read-only schema facts are enough.",
+        notes="Planned follow-up; active sql-schema already detects straightforward tables and columns safely.",
+    ),
+    AdapterInfo(
+        name="swift-ios",
+        status="planned",
+        kind="code",
+        extensions=(".swift", ".xcodeproj", ".pbxproj"),
+        parser="SwiftSyntax or pragmatic Swift/Xcode parser",
+        emits=("targets", "entitlements", "app_groups", "native_symbols", "extension_edges"),
+        agent_use="Needed for Maggy iOS share extension and App Group work.",
+        notes="Later, but important for mobile native boundaries.",
+    ),
+)
+
+
+def list_adapters(include_planned: bool = True) -> list[dict[str, object]]:
+    adapters = list(BUILTIN_ADAPTERS)
+    if include_planned:
+        adapters += list(PLANNED_ADAPTERS)
+    return [a.to_dict() for a in adapters]
+
+
+def adapter_for_extension(extension: str) -> AdapterInfo:
+    ext = extension.lower()
+    for adapter in BUILTIN_ADAPTERS:
+        if ext in adapter.extensions:
+            return adapter
+    return BUILTIN_ADAPTERS[-1]

mimry/agent_integration.py

@@ -0,0 +1,231 @@
+"""Isolated real-client integration smoke for MIMRY's MCP server."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from fastmcp import Client
+from fastmcp.client.transports import StdioTransport
+
+REQUIRED_TOOLS = {
+    "mimry_context",
+    "mimry_find",
+    "mimry_init",
+    "mimry_preflight",
+    "mimry_status",
+}
+_ENV_ALLOWLIST = ("PATH", "LANG", "LC_ALL", "LC_CTYPE", "TMPDIR", "SSL_CERT_FILE", "SSL_CERT_DIR", "SYSTEMROOT")
+
+
+def _run(command: list[str], *, cwd: Path, env: dict[str, str], timeout: int = 45) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        text=True,
+        capture_output=True,
+        timeout=timeout,
+        check=False,
+    )
+
+
+def _require_ok(result: subprocess.CompletedProcess[str], label: str) -> str:
+    if result.returncode:
+        detail = (result.stderr or result.stdout).strip()
+        raise RuntimeError(f"{label} failed ({result.returncode}): {detail}")
+    return result.stdout.strip()
+
+
+def _client_env(sandbox: Path, *, client: str) -> dict[str, str]:
+    """Build a fail-closed client environment without operator credentials."""
+    env = {name: os.environ[name] for name in _ENV_ALLOWLIST if os.environ.get(name)}
+    home = sandbox / f"{client}-home"
+    config = sandbox / f"{client}-config"
+    cache = sandbox / f"{client}-cache"
+    data = sandbox / f"{client}-data"
+    appdata = home / "AppData" / "Roaming"
+    localappdata = home / "AppData" / "Local"
+    for path in (home, config, cache, data, appdata, localappdata):
+        path.mkdir(parents=True, exist_ok=True)
+    env.update(
+        {
+            "HOME": str(home),
+            # Windows resolves Path.home() from USERPROFILE (then HOMEDRIVE+HOMEPATH)
+            # and ignores HOME entirely. Without these the server subprocess raises
+            # "Could not determine home directory" at startup and the client just
+            # waits out its timeout with no diagnosable error. Point them at the same
+            # sandbox home so isolation is unchanged.
+            "USERPROFILE": str(home),
+            "HOMEDRIVE": home.drive,
+            "HOMEPATH": str(home)[len(home.drive) :],
+            "XDG_CONFIG_HOME": str(config),
+            "XDG_CACHE_HOME": str(cache),
+            "XDG_DATA_HOME": str(data),
+            "APPDATA": str(appdata),
+            "LOCALAPPDATA": str(localappdata),
+            "FASTMCP_HOME": str(sandbox / f"{client}-fastmcp"),
+            "MIMRY_CACHE_HOME": str(sandbox / "mimry-cache"),
+            "NO_COLOR": "1",
+        }
+    )
+    if client == "claude":
+        env["CLAUDE_CONFIG_DIR"] = str(config)
+    elif client == "codex":
+        env["CODEX_HOME"] = str(config)
+    return env
+
+
+async def _protocol_smoke(repo: Path, cache: Path, server_command: list[str]) -> dict[str, Any]:
+    env = _client_env(cache.parent, client="protocol")
+    env["MIMRY_CACHE_HOME"] = str(cache)
+    transport = StdioTransport(server_command[0], server_command[1:], cwd=str(repo), env=env)
+    async with Client(transport, timeout=30) as client:
+        tools = await client.list_tools()
+        tool_names = {tool.name for tool in tools}
+        missing = sorted(REQUIRED_TOOLS - tool_names)
+        if missing:
+            raise RuntimeError(f"MCP protocol is missing required tools: {', '.join(missing)}")
+
+        init = (await client.call_tool("mimry_init", {"root": str(repo), "skip_graph": True})).data
+        if init.get("returncode") != 0:
+            raise RuntimeError(f"mimry_init failed over MCP: {init}")
+
+        preflight = (
+            await client.call_tool(
+                "mimry_preflight",
+                {"query": "locate daily agent entrypoint", "root": str(repo)},
+            )
+        ).data
+        if preflight.get("returncode") != 0 or preflight.get("index_state") != "current":
+            raise RuntimeError(f"mimry_preflight failed over MCP: {preflight}")
+
+        found = (
+            await client.call_tool(
+                "mimry_find",
+                {"query": "daily agent entrypoint", "root": str(repo), "limit": 3},
+            )
+        ).data
+        paths = [row.get("path") for row in found.get("results", [])]
+        if "src/entrypoint.py" not in paths:
+            raise RuntimeError(f"mimry_find did not return the fixture source: {paths}")
+
+        context = (
+            await client.call_tool(
+                "mimry_context",
+                {"query": "daily agent entrypoint", "root": str(repo)},
+            )
+        ).data
+        context_path = Path(context.get("output", ""))
+        if not context_path.is_file() or "## Source of Truth Reminder" not in context_path.read_text(encoding="utf-8"):
+            raise RuntimeError("mimry_context did not write an evidence-grade context pack")
+
+    return {
+        "state": "PASS",
+        "transport": "stdio",
+        "tools": len(tool_names),
+        "required_tools": sorted(REQUIRED_TOOLS),
+        "find_paths": paths,
+        "context": str(context_path.relative_to(repo)),
+    }
+
+
+def _claude_smoke(sandbox: Path, repo: Path, server_command: list[str]) -> dict[str, Any]:
+    binary = shutil.which("claude")
+    if not binary:
+        return {"state": "UNVERIFIED", "blocker": "claude binary not found"}
+
+    env = _client_env(sandbox, client="claude")
+    add = _run([binary, "mcp", "add", "--scope", "user", "mimry-smoke", "--", *server_command], cwd=repo, env=env)
+    _require_ok(add, "Claude Code MCP registration")
+    get = _run([binary, "mcp", "get", "mimry-smoke"], cwd=repo, env=env)
+    output = _require_ok(get, "Claude Code MCP health check")
+    if "Connected" not in output or server_command[0] not in output:
+        raise RuntimeError(f"Claude Code did not report the isolated MIMRY server connected: {output}")
+    return {
+        "state": "PASS",
+        "version": _require_ok(_run([binary, "--version"], cwd=repo, env=env), "Claude Code version"),
+        "health": "Connected",
+        "config_home": "temporary isolated sandbox",
+    }
+
+
+def _codex_smoke(sandbox: Path, repo: Path, server_command: list[str]) -> dict[str, Any]:
+    binary = shutil.which("codex")
+    if not binary:
+        return {"state": "UNVERIFIED", "blocker": "codex binary not found"}
+
+    env = _client_env(sandbox, client="codex")
+    add = _run([binary, "mcp", "add", "mimry-smoke", "--", *server_command], cwd=repo, env=env)
+    _require_ok(add, "Codex MCP registration")
+    get = _run([binary, "mcp", "get", "mimry-smoke", "--json"], cwd=repo, env=env)
+    payload = json.loads(_require_ok(get, "Codex MCP config readback"))
+    transport = payload.get("transport", {})
+    if not payload.get("enabled") or transport.get("type") != "stdio" or transport.get("command") != server_command[0]:
+        raise RuntimeError(f"Codex MCP registration readback mismatch: {payload}")
+    return {
+        "state": "PASS",
+        "version": _require_ok(_run([binary, "--version"], cwd=repo, env=env), "Codex version"),
+        "transport": "stdio",
+        "config_readback": "matched",
+        "config_home": "temporary isolated sandbox",
+    }
+
+
+def _herdr_status() -> dict[str, Any]:
+    binary = shutil.which("herdr")
+    blocker = (
+        "Herdr runtime detected, but pane-only round-trip proof requires an active isolated pane harness."
+        if binary
+        else "Herdr runtime not detected; pane-only integration was not simulated."
+    )
+    return {"state": "UNVERIFIED", "detected": bool(binary), "blocker": blocker}
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Safely smoke MIMRY through real MCP, Claude Code, and Codex clients.")
+    parser.add_argument("--json-output", type=Path, help="Optional path for the machine-readable report.")
+    args = parser.parse_args(argv)
+
+    with tempfile.TemporaryDirectory(prefix="mimry-agent-integration-") as raw_sandbox:
+        sandbox = Path(raw_sandbox)
+        repo = sandbox / "repo"
+        source = repo / "src" / "entrypoint.py"
+        source.parent.mkdir(parents=True)
+        source.write_text("def daily_agent_entrypoint():\n    return 'ready'\n", encoding="utf-8")
+        (repo / "README.md").write_text("# Integration fixture\n", encoding="utf-8")
+        server_command = [sys.executable, "-m", "mimry.mcp_server"]
+
+        try:
+            report = {
+                "schema_version": 1,
+                "sandbox": "temporary and deleted after run",
+                "mcp_protocol": asyncio.run(_protocol_smoke(repo, sandbox / "cache", server_command)),
+                "claude_code": _claude_smoke(sandbox, repo, server_command),
+                "codex": _codex_smoke(sandbox, repo, server_command),
+                "herdr": _herdr_status(),
+            }
+        except Exception as exc:
+            report = {"schema_version": 1, "state": "FAIL", "error": str(exc)}
+            code = 1
+        else:
+            code = 0
+
+    rendered = json.dumps(report, indent=2, sort_keys=True)
+    print(rendered)
+    if args.json_output:
+        args.json_output.parent.mkdir(parents=True, exist_ok=True)
+        args.json_output.write_text(rendered + "\n", encoding="utf-8")
+    return code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())