lore-solo 0.1.0__py3-none-any.whl

lore/__init__.py

@@ -0,0 +1,3 @@
+"""Lore engine: personas, skills, and a codebase map for one developer."""
+
+__version__ = "0.1.0"

lore/__main__.py

@@ -0,0 +1,43 @@
+"""`lore-solo install`, `setup`, `connect`, and `mcp`."""
+
+from __future__ import annotations
+
+import sys
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args or args[0] in {"-h", "--help"}:
+        print("usage: lore-solo install|setup|connect|mcp", file=sys.stderr)
+        return 0
+    command, rest = args[0], args[1:]
+    if command == "install":
+        from lore.install_cmd import run as run_install
+
+        run_install(rest)
+        return 0
+    if command == "setup":
+        from lore.setup_cmd import run as run_setup
+
+        run_setup(rest)
+        return 0
+    if command == "connect":
+        from lore.connect import register_agents
+
+        result = register_agents()
+        for path in result["written"]:
+            print(path)
+        for skipped in result["skipped"]:
+            print(f"skipped {skipped}", file=sys.stderr)
+        return 0 if result["written"] else 1
+    if command == "mcp":
+        from lore.mcp import run as run_mcp
+
+        run_mcp(rest)
+        return 0
+    print(f"unknown command {command!r}; use install, setup, connect, or mcp", file=sys.stderr)
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

lore/connect.py

@@ -0,0 +1,232 @@
+"""MCP entry for Lore, and the editor configs the connect command writes.
+
+The command is a local process. The editor starts it with the open project as
+its working directory.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+from pathlib import Path
+
+
+def invocation() -> tuple[str, list[str]]:
+    """The program an editor should start, and the arguments that select MCP."""
+    explicit = os.environ.get("LORE_COMMAND", "").strip()
+    if explicit:
+        return explicit, ["mcp"]
+    installed = _installed_command()
+    if installed is not None:
+        return str(installed), ["mcp"]
+    for name in ("lore-solo", "lore"):
+        found = shutil.which(name)
+        if found:
+            return found, ["mcp"]
+    return "uvx", ["lore-solo", "mcp"]
+
+
+def lore_command() -> str:
+    """The program editors should start."""
+    return invocation()[0]
+
+
+def _installed_command() -> Path | None:
+    bin_dir = Path.home() / ".lore" / "bin"
+    for name in ("lore-solo", "lore"):
+        base = bin_dir / name
+        if os.name == "nt":
+            windows = base.with_suffix(".exe")
+            if windows.is_file():
+                return windows
+        if base.is_file():
+            return base
+    return None
+
+
+def mcp_args() -> list[str]:
+    return invocation()[1]
+
+
+def mcp_entry(
+    kind: str,
+    command: str | None = None,
+    client: str = "",
+    args: list[str] | None = None,
+) -> dict[str, object]:
+    chosen, chosen_args = invocation()
+    if command is not None:
+        chosen = command
+    if args is not None:
+        chosen_args = args
+    elif command is not None:
+        chosen_args = ["mcp"]
+    entry: dict[str, object] = {"command": chosen, "args": chosen_args}
+    if kind == "vscode":
+        entry["type"] = "stdio"
+    name = client.strip()
+    if name:
+        entry["env"] = {"LORE_CLIENT": name}
+    return entry
+
+
+def install_command() -> str:
+    launcher = os.environ.get("LORE_LAUNCHER", "").strip()
+    if launcher:
+        return f"{launcher} connect"
+    return "uvx lore-solo connect"
+
+
+def windows_command(command: str) -> str:
+    if command.startswith("uvx "):
+        return command
+    suffix = " connect"
+    if command.endswith(suffix):
+        script = command[: -len(suffix)]
+        if script.endswith(".ps1"):
+            return command
+        return f"{script}.ps1 connect"
+    return "scripts/lore-solo.ps1 connect"
+
+
+def agent_prompt(command: str | None = None) -> str:
+    chosen = command or install_command()
+    windows = windows_command(chosen)
+    if windows == chosen:
+        steps = f"On macOS, Linux, or Windows, run:\n\n{chosen}\n\n"
+    else:
+        steps = (
+            "On macOS or Linux, run this in the shell:\n\n"
+            f"{chosen}\n\n"
+            "On Windows, run this in PowerShell:\n\n"
+            f"{windows}\n\n"
+        )
+    return (
+        "Register Lore with the editors on this computer. "
+        f"{steps}"
+        "When it finishes, confirm Lore is registered with the editors it found. "
+        "A project that already has a .lore directory keeps using that directory."
+    )
+
+
+def host_system(value: str | None = None) -> str:
+    raw = (value or os.environ.get("LORE_HOST_OS") or platform.system()).lower()
+    if raw.startswith("darwin") or raw == "macos":
+        return "darwin"
+    if raw.startswith("win"):
+        return "windows"
+    return "linux"
+
+
+def _write_json(path: Path, key: str, entry: dict[str, object]) -> None:
+    data: dict[str, object] = {}
+    if path.is_file():
+        raw = path.read_text(encoding="utf-8").strip()
+        if raw:
+            loaded = json.loads(raw)
+            if not isinstance(loaded, dict):
+                raise ValueError(f"{path} is not a JSON object.")
+            data = loaded
+        backup = path.with_name(path.name + ".lore.bak")
+        if not backup.exists():
+            shutil.copyfile(path, backup)
+    servers = data.get(key)
+    if not isinstance(servers, dict):
+        servers = {}
+    servers["lore"] = entry
+    data[key] = servers
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+
+
+def _strip_toml_section(text: str, heading: str) -> str:
+    kept: list[str] = []
+    skipping = False
+    blanks: list[str] = []
+    for line in text.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("["):
+            skipping = stripped == heading or stripped.startswith(heading + " ")
+        if skipping:
+            continue
+        if stripped == "":
+            blanks.append(line)
+            continue
+        kept.extend(blanks)
+        blanks = []
+        kept.append(line)
+    return "\n".join(kept).rstrip()
+
+
+def _write_codex(path: Path, command: str, client: str = "", args: list[str] | None = None) -> None:
+    existing = path.read_text(encoding="utf-8") if path.is_file() else ""
+    if path.is_file():
+        backup = path.with_name(path.name + ".lore.bak")
+        if not backup.exists():
+            shutil.copyfile(path, backup)
+    kept = _strip_toml_section(existing, "[mcp_servers.lore]")
+    rendered = ", ".join(json.dumps(part) for part in (args if args is not None else mcp_args()))
+    env = ""
+    if client.strip():
+        env = f"env = {{ LORE_CLIENT = {json.dumps(client.strip())} }}\n"
+    block = f"[mcp_servers.lore]\ncommand = {json.dumps(command)}\nargs = [{rendered}]\n{env}"
+    body = f"{kept}\n\n{block}" if kept else block
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(body if body.endswith("\n") else body + "\n", encoding="utf-8")
+
+
+def _targets(home: Path, system: str) -> list[tuple[str, Path, str, str]]:
+    """(label, file, container key, editor). An editor is included when its folder exists."""
+    if system == "darwin":
+        desktop = home / "Library" / "Application Support" / "Claude"
+        vscode = home / "Library" / "Application Support" / "Code" / "User"
+    elif system == "windows":
+        desktop = home / "AppData" / "Roaming" / "Claude"
+        vscode = home / "AppData" / "Roaming" / "Code" / "User"
+    else:
+        desktop = home / ".config" / "Claude"
+        vscode = home / ".config" / "Code" / "User"
+    rows: list[tuple[str, Path, str, str]] = []
+    cursor = home / ".cursor"
+    if cursor.is_dir() or (cursor / "mcp.json").exists():
+        rows.append(("Cursor", cursor / "mcp.json", "mcpServers", "cursor"))
+    claude = home / ".claude.json"
+    if claude.exists() or (home / ".claude").is_dir():
+        rows.append(("Claude Code", claude, "mcpServers", "other"))
+    if desktop.is_dir():
+        rows.append(("Claude Desktop", desktop / "claude_desktop_config.json", "mcpServers", "other"))
+    if (home / ".codex").is_dir():
+        rows.append(("Codex", home / ".codex" / "config.toml", "", "codex"))
+    if vscode.is_dir():
+        rows.append(("VS Code", vscode / "mcp.json", "servers", "vscode"))
+    gemini = home / ".gemini" / "config"
+    if gemini.is_dir():
+        rows.append(("Antigravity", gemini / "mcp_config.json", "mcpServers", "other"))
+    return rows
+
+
+def register_agents(
+    home: Path | None = None,
+    system: str | None = None,
+) -> dict[str, list[str]]:
+    """Write Lore into each detected editor. Other servers in those files stay."""
+    if home is None:
+        raw = os.environ.get("LORE_HOST_HOME", "")
+        home = Path(raw) if raw else Path.home()
+    host = host_system(system)
+    command, args = invocation()
+    written: list[str] = []
+    skipped: list[str] = []
+    for label, path, key, editor in _targets(home, host):
+        try:
+            if editor == "codex":
+                _write_codex(path, command, client=label, args=args)
+            else:
+                _write_json(path, key, mcp_entry(editor, command, client=label, args=args))
+        except (OSError, ValueError, json.JSONDecodeError):
+            skipped.append(f"{label}: {path}")
+            continue
+        written.append(str(path))
+    return {"written": written, "skipped": skipped}

lore/core/__init__.py

@@ -0,0 +1 @@
+"""File-backed knowledge. No network and no database."""

lore/core/budget.py

@@ -0,0 +1,40 @@
+"""Count tokens for the 800-token answer cap.
+
+The count is cl100k_base when the tiktoken encoder is installed. That is the
+same encoding the previous Go engine used. If the encoder cannot be loaded,
+the count is one token per three UTF-8 bytes, rounded up. Tests pin both
+behaviors by name.
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Protocol
+
+
+class _Encoder(Protocol):
+    def encode(self, text: str) -> list[int]: ...
+
+
+@lru_cache(maxsize=1)
+def _encoder() -> _Encoder | None:
+    try:
+        import tiktoken
+    except ImportError:
+        return None
+    try:
+        return tiktoken.get_encoding("cl100k_base")
+    except (OSError, ValueError, RuntimeError):
+        return None
+
+
+def count_tokens(text: str) -> int:
+    encoder = _encoder()
+    if encoder is not None:
+        return len(encoder.encode(text))
+    return _bytes_fallback(text)
+
+
+def _bytes_fallback(text: str) -> int:
+    """One token per three UTF-8 bytes, rounded up. Used only if tiktoken is missing."""
+    return (len(text.encode("utf-8")) + 2) // 3

lore/core/codebases.py

@@ -0,0 +1,101 @@
+"""Codebases the person has asked Lore to map."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+from lore.core.personas import file_slug
+
+
+def _file(project: Path) -> Path:
+    return project / ".lore" / "codebases.json"
+
+
+def list_codebases(project: Path) -> list[dict[str, str]]:
+    path = _file(project)
+    if not path.is_file():
+        return []
+    try:
+        loaded = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return []
+    if not isinstance(loaded, list):
+        return []
+    rows: list[dict[str, str]] = []
+    for item in loaded:
+        if not isinstance(item, dict):
+            continue
+        ident = str(item.get("id", "")).strip()
+        name = str(item.get("name", "")).strip()
+        folder = str(item.get("path", "")).strip()
+        if ident and name and folder:
+            rows.append({"id": ident, "name": name, "path": folder})
+    return rows
+
+
+def get_codebase(project: Path, ident: str) -> dict[str, str]:
+    for row in list_codebases(project):
+        if row["id"] == ident:
+            return row
+    raise FileNotFoundError(ident)
+
+
+def add_codebase(project: Path, name: str, folder: Path) -> dict[str, str]:
+    title = name.strip()
+    if not title:
+        raise ValueError("A codebase needs a name.")
+    if not folder.is_dir():
+        raise ValueError("That path is not a folder.")
+    rows = list_codebases(project)
+    slug = file_slug(title)
+    taken = {row["id"] for row in rows}
+    ident = slug
+    number = 2
+    while ident in taken:
+        ident = f"{slug}-{number}"
+        number += 1
+    row = {"id": ident, "name": title, "path": str(folder.resolve())}
+    rows.append(row)
+    _write(project, rows)
+    return row
+
+
+def rename_codebase(project: Path, ident: str, name: str) -> dict[str, str]:
+    title = name.strip()
+    if not title:
+        raise ValueError("A codebase needs a name.")
+    rows = list_codebases(project)
+    for row in rows:
+        if row["id"] == ident:
+            row["name"] = title
+            _write(project, rows)
+            return row
+    raise FileNotFoundError(ident)
+
+
+def delete_codebase(project: Path, ident: str) -> dict[str, str]:
+    rows = list_codebases(project)
+    kept = [row for row in rows if row["id"] != ident]
+    if len(kept) == len(rows):
+        raise FileNotFoundError(ident)
+    removed = next(row for row in rows if row["id"] == ident)
+    _write(project, kept)
+    return removed
+
+
+def remove_map(folder: Path) -> None:
+    """Delete the map files Lore wrote. Source files stay."""
+    graph = folder / "graphify-out"
+    if graph.is_dir():
+        shutil.rmtree(graph)
+    status = folder / ".lore" / "graph-status.json"
+    if status.is_file():
+        status.unlink()
+
+
+def _write(project: Path, rows: list[dict[str, str]]) -> None:
+    path = _file(project)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(rows, indent=2) + "\n", encoding="utf-8")

lore/core/config.py

@@ -0,0 +1,39 @@
+"""Read `.lore/lore.config.yaml`. Missing keys use the solo defaults."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+DEFAULT_TOKEN_BUDGET = 800
+DEFAULT_MAX_ITEMS = 8
+
+
+def save_config(lore_dir: Path, token_budget: int, max_items: int) -> dict[str, int]:
+    if token_budget < 1 or max_items < 1:
+        raise ValueError("token_budget and max_items must be at least 1")
+    path = lore_dir / "lore.config.yaml"
+    loaded: dict[str, Any] = {}
+    if path.is_file():
+        raw = yaml.safe_load(path.read_text(encoding="utf-8"))
+        if isinstance(raw, dict):
+            loaded = raw
+    loaded["token_budget"] = int(token_budget)
+    loaded["max_items"] = int(max_items)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.safe_dump(loaded, sort_keys=False), encoding="utf-8")
+    return {"token_budget": int(token_budget), "max_items": int(max_items)}
+
+
+def load_config(lore_dir: Path) -> dict[str, int]:
+    path = lore_dir / "lore.config.yaml"
+    loaded: dict[str, Any] = {}
+    if path.is_file():
+        raw = yaml.safe_load(path.read_text(encoding="utf-8"))
+        if isinstance(raw, dict):
+            loaded = raw
+    budget = loaded.get("token_budget", DEFAULT_TOKEN_BUDGET)
+    items = loaded.get("max_items", DEFAULT_MAX_ITEMS)
+    return {"token_budget": int(budget), "max_items": int(items)}