helix-memory 4.0.1__py3-none-any.whl

helix/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("helix-memory")

helix/cli/__init__.py

@@ -0,0 +1,19 @@
+from .app import app
+from .commands import (
+    cmd_forget,
+    cmd_install,
+    cmd_list,
+    cmd_recall,
+    cmd_remember,
+    cmd_uninstall,
+)
+
+__all__ = [
+    "app",
+    "cmd_forget",
+    "cmd_install",
+    "cmd_list",
+    "cmd_recall",
+    "cmd_remember",
+    "cmd_uninstall",
+]

helix/cli/app.py

@@ -0,0 +1,21 @@
+import typer
+
+from helix.cli.commands import COMMANDS
+from helix.core import Brain
+
+app = typer.Typer()
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context) -> None:
+    Brain().initialize()
+    if ctx.invoked_subcommand is None:
+        typer.echo("Helix — global convention memory. Run `helix --help` for commands.")
+
+
+for name, command in COMMANDS.items():
+    app.command(name)(command)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app()

helix/cli/commands.py

@@ -0,0 +1,136 @@
+import shutil
+from collections.abc import Callable
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from helix.core import Brain, Scope, detect_snippet_blocks, install, uninstall
+from helix.core.installer import clients as all_clients
+from helix.core.installer import detect_installed_clients
+from helix.utils import parse_csv
+
+from .prompts import pick, pick_many
+
+
+def cmd_remember(
+    name: Annotated[str, typer.Argument(help="Convention name (kebab-case).")],
+    body: Annotated[str, typer.Argument(help="Convention body text.")],
+    tags: Annotated[str | None, typer.Option(help="Comma-separated tags.")] = None,
+    applies_to: Annotated[
+        str | None, typer.Option(help="Comma-separated stacks/scopes.")
+    ] = None,
+) -> None:
+    path = Brain().remember(
+        name=name,
+        body=body,
+        tags=parse_csv(tags),
+        applies_to=parse_csv(applies_to),
+    )
+    typer.echo(f"Saved as {path.name}")
+
+
+def cmd_list(
+    tags: Annotated[
+        str | None, typer.Option(help="Filter by comma-separated tags.")
+    ] = None,
+) -> None:
+    lines = Brain().list_conventions(tags=parse_csv(tags))
+    if not lines:
+        typer.echo("No conventions found.")
+        return
+    for line in lines:
+        typer.echo(line)
+
+
+def cmd_recall(
+    query: Annotated[str, typer.Argument(help="Substring to search for.")],
+    tags: Annotated[
+        str | None, typer.Option(help="Filter by comma-separated tags.")
+    ] = None,
+) -> None:
+    results: list[str] = Brain().recall(query=query, tags=parse_csv(tags))
+    if not results:
+        typer.echo("No matches found.")
+        return
+    for line in results:
+        typer.echo(line)
+
+
+def cmd_forget(
+    name: Annotated[str, typer.Argument(help="Convention name to remove.")],
+) -> None:
+    if Brain().forget(name):
+        typer.echo(f"Removed {name}")
+    else:
+        typer.echo(f"Convention '{name}' not found.", err=True)
+        raise typer.Exit(1)
+
+
+def cmd_install() -> None:
+    detected = detect_installed_clients()
+    available = detected or all_clients()
+    if not detected:
+        typer.echo("No client config directories found; showing all known clients.")
+
+    typer.echo("Pick client(s):")
+    selected = [available[i] for i in pick_many("Clients", [c.name for c in available])]
+
+    project_root = Path.cwd()
+    typer.echo("Pick a scope:")
+    scope = (Scope.GLOBAL, Scope.PROJECT)[
+        pick("Scope", ["global (per-user config dir)", "project (this repo)"])
+    ]
+
+    written: set[Path] = set()
+    for client in selected:
+        path = client.path_for(scope, project_root)
+        if path in written:  # pragma: no cover
+            typer.echo(f"Skipped {client.name}: {path} already written this run")
+            continue
+        install(client, scope, project_root)
+        written.add(path)
+        typer.echo(f"Wrote helix block to {path} ({client.name})")
+
+    if not shutil.which("helix"):  # pragma: no cover
+        typer.echo(
+            "\nWarning: 'helix' is not on PATH. The installed snippet tells agents "
+            "to run `helix list`, which will fail until the CLI is installed on "
+            "PATH (e.g. `pipx install helix` or `uv tool install helix`).",
+            err=True,
+        )
+
+
+def cmd_uninstall() -> None:
+    project_root = Path.cwd()
+    installed = detect_snippet_blocks(project_root)
+    if not installed:
+        typer.echo("No helix blocks found.")
+        return
+
+    typer.echo("Pick block(s) to remove:")
+    labels = [
+        f"{block.client.name} [{block.scope}] — {block.path}" for block in installed
+    ]
+    selected = [installed[i] for i in pick_many("Blocks", labels)]
+
+    removed_any = False
+    for block in selected:
+        if uninstall(block.client, block.scope, project_root):
+            typer.echo(f"Removed helix block from {block.path}")
+            removed_any = True
+        else:
+            typer.echo(f"Nothing to remove from {block.path}", err=True)
+
+    if not removed_any:
+        raise typer.Exit(1)
+
+
+COMMANDS: dict[str, Callable[..., None]] = {
+    "forget": cmd_forget,
+    "install": cmd_install,
+    "list": cmd_list,
+    "recall": cmd_recall,
+    "remember": cmd_remember,
+    "uninstall": cmd_uninstall,
+}

helix/cli/prompts.py

@@ -0,0 +1,33 @@
+"""Interactive selection helpers for CLI commands."""
+
+import typer
+
+
+def pick(prompt: str, options: list[str]) -> int:  # pragma: no cover
+    """Prompt for a single choice and return its zero-based index."""
+    for index, label in enumerate(options, 1):
+        typer.echo(f"  {index}) {label}")
+    choice = typer.prompt(prompt, type=int, default=1)
+    if not 1 <= choice <= len(options):
+        typer.echo("Invalid choice.", err=True)
+        raise typer.Exit(1)
+    return int(choice) - 1
+
+
+def pick_many(prompt: str, options: list[str]) -> list[int]:  # pragma: no cover
+    """Prompt for one or more choices and return their zero-based indices."""
+    for index, label in enumerate(options, 1):
+        typer.echo(f"  {index}) {label}")
+    raw = typer.prompt(f"{prompt} (comma-separated, or 'all')", default="all")
+    if raw.strip().lower() == "all":
+        return list(range(len(options)))
+    chosen: list[int] = []
+    for raw_part in raw.split(","):
+        part = raw_part.strip()
+        if not part.isdigit() or not 1 <= int(part) <= len(options):
+            typer.echo(f"Invalid choice: {part!r}", err=True)
+            raise typer.Exit(1)
+        index = int(part) - 1
+        if index not in chosen:
+            chosen.append(index)
+    return chosen

helix/core/__init__.py

@@ -0,0 +1,35 @@
+# pylint: disable=duplicate-code
+from .conventions import Brain, Convention
+from .installer import (
+    BLOCK_PATTERN,
+    END_MARKER,
+    SNIPPET,
+    START_MARKER,
+    Client,
+    Scope,
+    SnippetBlock,
+    clients,
+    detect_installed_clients,
+    detect_snippet_blocks,
+    install,
+    uninstall,
+)
+from .settings import Settings
+
+__all__ = [
+    "BLOCK_PATTERN",
+    "END_MARKER",
+    "SNIPPET",
+    "START_MARKER",
+    "Brain",
+    "Client",
+    "Convention",
+    "Scope",
+    "Settings",
+    "SnippetBlock",
+    "clients",
+    "detect_installed_clients",
+    "detect_snippet_blocks",
+    "install",
+    "uninstall",
+]

helix/core/conventions/__init__.py

@@ -0,0 +1,7 @@
+from helix.core.conventions.brain import Brain
+from helix.core.conventions.convention import Convention
+
+__all__ = [
+    "Brain",
+    "Convention",
+]

helix/core/conventions/brain.py

@@ -0,0 +1,127 @@
+from pathlib import Path
+
+from helix.core.settings import Settings
+
+from .convention import Convention
+
+
+class Brain:
+    @property
+    def index(self) -> Path:
+        return Settings.HELIX_INDEX
+
+    @property
+    def conventions(self) -> Path:
+        return Settings.HELIX_CONVENTIONS
+
+    @property
+    def is_initialized(self) -> bool:
+        return self.index.exists()
+
+    @property
+    def content(self) -> str:
+        return self.index.read_text()
+
+    @property
+    def index_lines(self) -> list[str]:
+        return self.content.splitlines(keepends=True)
+
+    def initialize(self) -> None:
+        self.conventions.mkdir(parents=True, exist_ok=True)
+        if not self.is_initialized:
+            self.index.write_text("# Helix Convention Index\n\n")
+
+    def remember(
+        self,
+        *,
+        name: str,
+        body: str,
+        tags: list[str],
+        applies_to: list[str] | None = None,
+    ) -> Path:
+        convention = Convention(
+            name=name, body=body, tags=tags, applies_to=applies_to or []
+        )
+        convention.file_path.write_text(convention.to_markdown())
+        self._add_convention_to_index(convention)
+
+        return convention.file_path
+
+    def index_line_for(self, name: str) -> str | None:
+        return next(
+            (line for line in self.index_lines if line.startswith(f"- [{name}](")),
+            None,
+        )
+
+    def convention_for(self, name: str) -> Convention | None:
+        path = self.conventions / f"{name}.md"
+        if not path.exists():
+            return None
+        try:
+            return Convention.from_markdown(path.read_text())
+        except ValueError:
+            return None
+
+    def _add_convention_to_index(self, convention: Convention) -> None:
+        lines = [
+            line
+            for line in self.index_lines
+            if not line.startswith(f"- [{convention.name}](")
+        ]
+        content = "".join(lines).rstrip("\n") + "\n"
+        content += convention.index_line() + "\n"
+        self.index.write_text(content)
+
+    def list_conventions(self, tags: list[str] | None = None) -> list[str]:
+        if not self.is_initialized:
+            return []
+        lines = [line for line in self.index_lines if line.startswith("- [")]
+        if not tags:
+            return lines
+
+        return self._filter_index_lines_by_tags(lines, tags)
+
+    @staticmethod
+    def _filter_index_lines_by_tags(lines: list[str], tags: list[str]) -> list[str]:
+        tags_set = set(tags)
+        return [
+            line for line in lines if Convention.tags_from_index_line(line) & tags_set
+        ]
+
+    def recall(self, query: str, tags: list[str] | None = None) -> list[str]:
+        lines = [
+            f"{path}:{line_number}:{line}"
+            for path in self.conventions.glob("*.md")
+            for line_number, line in enumerate(path.read_text().splitlines(), 1)
+            if query.lower() in line.lower()
+        ]
+
+        if not tags:
+            return lines
+
+        tags_set = set(tags)
+        allowed_names = {
+            convention.name
+            for convention in self._load_conventions()
+            if tags_set & set(convention.tags)
+        }
+        return [line for line in lines if any(name in line for name in allowed_names)]
+
+    def _load_conventions(self) -> list[Convention]:
+        conventions = []
+        for path in self.conventions.glob("*.md"):
+            try:
+                conventions.append(Convention.from_markdown(path.read_text()))
+            except ValueError:
+                pass
+        return conventions
+
+    def forget(self, name: str) -> bool:
+        file_path = self.conventions / f"{name}.md"
+        if not file_path.exists():
+            return False
+        file_path.unlink()
+        existing_line = self.index_line_for(name)
+        if existing_line:
+            self.index.write_text(self.content.replace(existing_line, ""))
+        return True

helix/core/conventions/convention.py

@@ -0,0 +1,53 @@
+import re
+from pathlib import Path
+from typing import Self
+
+import frontmatter
+from pydantic import BaseModel, ConfigDict, Field
+
+from helix.core.settings import Settings
+
+CONVENTION_REGEX = r"\[([^\]]*)\] —"
+
+
+class Convention(BaseModel):
+    name: str
+    body: str
+    tags: list[str] = Field(default_factory=list)
+    applies_to: list[str] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="ignore")
+
+    @property
+    def file_path(self) -> Path:
+        return Settings.HELIX_CONVENTIONS / f"{self.name}.md"
+
+    def to_markdown(self) -> str:
+        post = frontmatter.Post(
+            self.body,
+            name=self.name,
+            tags=self.tags,
+            applies_to=self.applies_to,
+        )
+        return str(frontmatter.dumps(post)) + "\n"
+
+    @classmethod
+    def from_markdown(cls, text: str) -> Self:
+        post = frontmatter.loads(text)
+        if not post.metadata.get("name"):
+            raise ValueError("Invalid convention file: missing 'name' field")
+        return cls.model_validate({"body": post.content, **post.metadata})
+
+    def index_line(self) -> str:
+        first_line = self.body.strip().splitlines()[0] if self.body.strip() else ""
+        if len(first_line) > 80:
+            first_line = first_line[:77] + "..."
+        tags_string = ",".join(self.tags)
+        return f"- [{self.name}](conventions/{self.name}.md) [{tags_string}] — {first_line}"
+
+    @staticmethod
+    def tags_from_index_line(line: str) -> set[str]:
+        match = re.search(CONVENTION_REGEX, line)
+        if not match:
+            return set()
+        return {tag.strip() for tag in match.group(1).split(",") if tag.strip()}

helix/core/installer/__init__.py

@@ -0,0 +1,30 @@
+# pylint: disable=duplicate-code
+from helix.core.installer.models import Client, Scope, SnippetBlock
+from helix.core.installer.operations import (
+    clients,
+    detect_installed_clients,
+    detect_snippet_blocks,
+    install,
+    uninstall,
+)
+from helix.core.installer.snippet import (
+    BLOCK_PATTERN,
+    END_MARKER,
+    SNIPPET,
+    START_MARKER,
+)
+
+__all__ = [
+    "BLOCK_PATTERN",
+    "END_MARKER",
+    "SNIPPET",
+    "START_MARKER",
+    "Client",
+    "Scope",
+    "SnippetBlock",
+    "clients",
+    "detect_installed_clients",
+    "detect_snippet_blocks",
+    "install",
+    "uninstall",
+]

helix/core/installer/models.py

@@ -0,0 +1,35 @@
+from enum import StrEnum
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+
+class Scope(StrEnum):
+    GLOBAL = "global"
+    PROJECT = "project"
+
+
+class Client(BaseModel):
+    key: str = Field(description="Stable identifier for the client (e.g. 'claude').")
+    name: str = Field(description="Human-readable client name shown in CLI prompts.")
+    global_path: Path = Field(
+        description="Absolute path to the client's per-user (global) config file."
+    )
+    project_relative_path: Path = Field(
+        description="Config file path relative to a project root, for project scope."
+    )
+
+    def path_for(self, scope: Scope, project_root: Path) -> Path:
+        if scope == Scope.GLOBAL:
+            return self.global_path
+        return project_root / self.project_relative_path
+
+
+class SnippetBlock(BaseModel):
+    client: Client = Field(description="The client whose config file holds the block.")
+    scope: Scope = Field(
+        description="Whether the block was found in global or project scope."
+    )
+    path: Path = Field(
+        description="Resolved config file where the helix block was detected."
+    )

helix/core/installer/operations.py

@@ -0,0 +1,114 @@
+from pathlib import Path
+
+from helix.core.settings import Settings
+
+from .models import Client, Scope, SnippetBlock
+from .snippet import BLOCK_PATTERN, END_MARKER, SNIPPET, START_MARKER
+
+
+def clients() -> list[Client]:
+    home = Settings.HOME_DIRECTORY
+    return [
+        Client(
+            key="claude",
+            name="Claude Code",
+            global_path=home / ".claude" / "CLAUDE.md",
+            project_relative_path=Path("CLAUDE.md"),
+        ),
+        Client(
+            key="cursor",
+            name="Cursor",
+            global_path=home / ".cursor" / "rules" / "helix.mdc",
+            project_relative_path=Path(".cursor") / "rules" / "helix.mdc",
+        ),
+        Client(
+            key="codex",
+            name="Codex CLI",
+            global_path=home / ".codex" / "AGENTS.md",
+            project_relative_path=Path("AGENTS.md"),
+        ),
+        Client(
+            key="opencode",
+            name="Opencode",
+            global_path=home / ".config" / "opencode" / "AGENTS.md",
+            project_relative_path=Path("AGENTS.md"),
+        ),
+    ]
+
+
+def detect_installed_clients() -> list[Client]:
+    return [client for client in clients() if client.global_path.parent.exists()]
+
+
+def detect_snippet_blocks(project_root: Path) -> list[SnippetBlock]:
+    blocks: list[SnippetBlock] = []
+    for client in clients():
+        for scope in Scope:
+            path = client.path_for(scope, project_root)
+            if not path.exists():
+                continue
+
+            if START_MARKER not in path.read_text():
+                continue
+
+            config_block = SnippetBlock(client=client, scope=scope, path=path)
+            blocks.append(config_block)
+    return blocks
+
+
+def _insert_snippet_block(existing: str, block: str) -> str:
+    """Return ``existing`` with the Helix snippet block inserted or refreshed.
+
+    If a snippet block is already present, it is replaced in place
+    so reinstalling updates the snippet rather than duplicating it.
+
+    If there is other content but no existing block, the
+    block is appended after a blank-line separator.
+
+    Otherwise the block becomes the entire content.
+    """
+    if BLOCK_PATTERN.search(existing):
+        return BLOCK_PATTERN.sub(block.rstrip("\n"), existing)
+    if existing.strip():
+        return existing.rstrip("\n") + "\n\n" + block
+    return block
+
+
+def install(client: Client, scope: Scope, project_root: Path) -> Path:
+    """Write (or refresh) the Helix snippet block in the client's config file.
+
+    Creates the file and parent directories if needed, and returns the path
+    that was written.
+    """
+    path = client.path_for(scope, project_root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    existing = path.read_text() if path.exists() else ""
+    block = f"{START_MARKER}\n{SNIPPET}{END_MARKER}\n"
+    new_text = _insert_snippet_block(existing, block)
+    path.write_text(new_text)
+
+    return path
+
+
+def uninstall(client: Client, scope: Scope, project_root: Path) -> bool:
+    """Remove the Helix snippet block from the client's config file.
+
+    Deletes the file if nothing else remains. Returns ``True`` if a block was
+    removed, or ``False`` if the file or block was not present.
+    """
+    path = client.path_for(scope, project_root)
+    if not path.exists():
+        return False
+
+    text = path.read_text()
+    if START_MARKER not in text:
+        return False
+
+    remaining = BLOCK_PATTERN.sub("", text).strip("\n")
+    if not remaining:
+        path.unlink()
+        return True
+
+    path.write_text(remaining + "\n")
+    return True

helix/core/installer/snippet.py

@@ -0,0 +1,18 @@
+import re
+
+START_MARKER = "<!-- helix:start -->"
+END_MARKER = "<!-- helix:end -->"
+
+SNIPPET = (
+    "## Helix — Global Conventions\n"
+    "\n"
+    "If the `helix` CLI is available on PATH, run `helix list` at the start of "
+    "every session and treat the output as global coding conventions that apply "
+    "across projects. Use `helix recall <query>` to load the full text of any "
+    "convention that looks relevant.\n"
+)
+
+BLOCK_PATTERN = re.compile(
+    re.escape(START_MARKER) + r".*?" + re.escape(END_MARKER),
+    re.DOTALL,
+)

helix/core/settings.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class AppSettings(BaseSettings):
+    HOME_DIRECTORY: Path = Field(default=Path.home())
+
+    @property
+    def HELIX_BRAIN(self) -> Path:
+        return self.HOME_DIRECTORY / ".dev_brain"
+
+    @property
+    def HELIX_CONVENTIONS(self) -> Path:
+        return self.HELIX_BRAIN / "conventions"
+
+    @property
+    def HELIX_INDEX(self) -> Path:
+        return self.HELIX_BRAIN / "INDEX.md"
+
+
+Settings = AppSettings()

helix/utils/__init__.py

@@ -0,0 +1,3 @@
+from .parsing import parse_csv
+
+__all__ = ["parse_csv"]

helix/utils/parsing.py

@@ -0,0 +1,4 @@
+def parse_csv(value: str | None) -> list[str]:
+    if not value:
+        return []
+    return [item.strip() for item in value.split(",")]

helix_memory-4.0.1.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: helix-memory
+Version: 4.0.1
+Summary: A lightweight, multi-client memory layer that persists cross-project coding conventions
+Author-email: Matias Gimenez <matiasgimenez.dev@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: pydantic-settings>=2.14.1
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: python-frontmatter>=1.1.0
+Requires-Dist: typer>=0.25.1
+Description-Content-Type: text/markdown
+
+# Helix
+
+Global convention memory for AI coding agents — persist your coding preferences once, surface them in every Claude Code, Cursor, or MCP-compatible session.
+
+## Install
+
+```bash
+# With uv (recommended)
+uv tool install helix-memory
+
+# Or with pip
+pip install helix-memory
+```
+
+## Quick start
+
+```bash
+# 1. Hook Helix into your agent (Claude Code, Cursor, …).
+helix install
+
+# 2. Save your first convention.
+helix remember pydantic-validation \
+  "Prefer Pydantic v2 for any external-boundary validation." \
+  --tags python,validation
+```
+
+From there, your next agent session will see the conventions automatically.
+
+## CLI
+
+```bash
+helix remember <name> "<body>" --tags <comma,separated>
+helix list [--tags <tag>]
+helix recall "<query>" [--tags <tag>]
+helix forget <name>
+helix install   # wire Helix into your agent
+helix uninstall # remove the integration
+helix serve     # start the MCP server
+```
+
+## MCP server
+
+`helix serve` exposes four tools to any MCP-compatible client: `remember`, `recall`, `list_conventions`, `forget`.
+
+Add to your client's MCP config (e.g. `~/.claude/claude_desktop_config.json`):
+
+```json
+{
+	"mcpServers": {
+		"helix": {
+			"command": "helix",
+			"args": ["serve"]
+		}
+	}
+}
+```
+
+## License
+
+MIT

helix_memory-4.0.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+helix/__init__.py,sha256=5g2kqKvprvMTvEJlJb5hCmx3gPH-GNXGaAQi2wUSmp4,78
+helix/cli/__init__.py,sha256=zraDVOm11vw3MjqGS_VVugBKCwG3vbn2s1yGtSWvYpA,285
+helix/cli/app.py,sha256=lF7hPodHgrG2me5Ex8HeA9YZT5mjeVD73fmn9e23pWE,473
+helix/cli/commands.py,sha256=OJwo-Nn9C1mGBMdwpRShyvzrnCBL2fG3qLTSMPkMT1w,4220
+helix/cli/prompts.py,sha256=iDBwni87NYsUgt3Z2urK2dLhLN9M3l6xFQhMlJMaLf0,1275
+helix/core/__init__.py,sha256=a_ongXXQoRWpTQFc3iPVnNKv7uB_ng4IrV7VHGHCCUw,630
+helix/core/settings.py,sha256=i5SVBCqAM9ARUYZ1eCiUGD68O9_rReLNcFBXzB_Nvi0,511
+helix/core/conventions/__init__.py,sha256=CKyUUGf1X3CpJuf_PWx9SUBCx9jmk-NAGOud0hIiBok,150
+helix/core/conventions/brain.py,sha256=P-Ei9wIlSYkgQTDcdxbZlrTFPY_R1rJDVndcjJJMD4s,3929
+helix/core/conventions/convention.py,sha256=M6zmbjw3zi7AxBg2UJB3SAUYSTQ9JZrMSFr0IbT0SDM,1667
+helix/core/installer/__init__.py,sha256=iMC2xycD9CfD1XmP5e0D29NHjYhDxfqz9am2pS2o2xw,602
+helix/core/installer/models.py,sha256=onqU7KaX-bP3wwfYxGWePk7nR9vDda9FbvW72RPKRnk,1145
+helix/core/installer/operations.py,sha256=N26kV2kqTMyTGyE4BPNl8VcWk2cbbLHxWCVqXHD7634,3580
+helix/core/installer/snippet.py,sha256=o0ACtehFPdJA-J2mxbnmJpraN8c6dpPE-3MdmsOcvaU,538
+helix/utils/__init__.py,sha256=9BnbE-Egv-kDjwRLLZJAgR5bfeMRxb0CPbIOj-Z2U5s,56
+helix/utils/parsing.py,sha256=xleJFLV96sLxznFqI6lVj-aPadscX966BK3EGXg1JpA,138
+helix_memory-4.0.1.dist-info/METADATA,sha256=k1NFTJ22FBSs4gColM7berG8cdEO9Pg5rZP_36RLiWw,1709
+helix_memory-4.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+helix_memory-4.0.1.dist-info/entry_points.txt,sha256=eNgBVu2lbzlXnYzKBtj167gLyI9_B6buR9-5udLzyG0,44
+helix_memory-4.0.1.dist-info/licenses/LICENSE,sha256=yY8ZbpGnAb7AQA9D-zSLN6X78WcUvXA34GRr8urUbKY,1073
+helix_memory-4.0.1.dist-info/RECORD,,

helix_memory-4.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

helix_memory-4.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+helix = helix.cli.app:app

helix_memory-4.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matías Giménez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.