sessionmemory 0.2.0__py3-none-any.whl

sessionmemory/lib/registry.py

@@ -0,0 +1,269 @@
+"""The map from a checkout on disk to a project slug in the vault.
+
+Remotes are the primary key because they survive a repository being moved or cloned
+again, which a filesystem path does not. Normalization strips everything that varies
+between equivalent spellings of one URL: scheme, credentials, port, trailing `.git`,
+and case. The port strip is anchored to the host segment (before the first `/`) so a
+path that happens to contain a colon followed by digits is never mistaken for one.
+"""
+
+from __future__ import annotations
+
+import re
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import tomli_w
+
+from sessionmemory.lib import atomic, ids
+from sessionmemory.lib.paths import SYSTEM_DIR
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+REGISTRY_FILE = "registry.toml"
+
+_SCHEME = re.compile(r"^[a-z][a-z0-9+.-]*://", re.IGNORECASE)
+_SCP_LIKE = re.compile(r"^(?:[^@/]+@)?([^:/]+):(.+)$")
+_CREDENTIALS = re.compile(r"^[^@/]+@")
+_PORT = re.compile(r":\d+$")
+
+
+class RegistryError(ValueError):
+    """Raised when registry.toml cannot be read, whether from a syntax error or a malformed shape.
+
+    A single exception for both failure modes lets callers report a hand-edited file's
+    problems to the user without risking that a genuine bug elsewhere (which would
+    raise some other exception type) gets misreported as "your file is broken".
+    """
+
+
+@dataclass(frozen=True)
+class Project:
+    """One registered project."""
+
+    slug: str
+    remotes: tuple[str, ...]
+    root: str
+
+
+def normalize_remote(url: str) -> str:
+    """Reduce a git remote URL to a stable comparison key.
+
+    Args:
+        url (str): A remote URL in any of git's supported spellings.
+
+    Returns:
+        str: The normalized `host/path` key, lowercased and without a `.git` suffix.
+    """
+    candidate = url.strip()
+
+    if _SCHEME.match(candidate):
+        candidate = _SCHEME.sub("", candidate, count=1)
+    else:
+        scp = _SCP_LIKE.match(candidate)
+        if scp:
+            candidate = f"{scp.group(1)}/{scp.group(2)}"
+
+    candidate = _CREDENTIALS.sub("", candidate, count=1)
+
+    # Strip a port only from the host segment, so a path that happens to
+    # contain ":digits" past the first slash is never mistaken for one.
+    host, sep, rest = candidate.partition("/")
+    host = _PORT.sub("", host, count=1)
+    candidate = f"{host}{sep}{rest}"
+
+    candidate = candidate.removesuffix(".git").strip("/")
+
+    return candidate.lower()
+
+
+def _string_tuple(entry: dict[str, object], key: str, slug: str) -> tuple[str, ...]:
+    """Read an optional list-of-strings field from a raw registry entry.
+
+    Args:
+        entry (dict[str, object]): The raw table for one registry entry.
+        key (str): The field name to read.
+        slug (str): The entry's project slug, for error messages.
+
+    Returns:
+        tuple[str, ...]: The field's values, or an empty tuple when absent.
+
+    Raises:
+        RegistryError: If the field is present but is not a list of strings.
+    """
+    value = entry.get(key, [])
+    if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
+        msg = f"registry entry {slug!r} has a malformed {key!r} field"
+        raise RegistryError(msg)
+    return tuple(value)
+
+
+def load(vault: Path) -> dict[str, Project]:
+    """Read the registry.
+
+    Args:
+        vault (Path): The vault root.
+
+    Returns:
+        dict[str, Project]: Projects keyed by slug. Empty when the file is absent.
+
+    Raises:
+        RegistryError: If the file is not valid TOML, the top-level `projects` table
+            is malformed, a registry entry is not a table, or one of its fields has
+            the wrong type.
+    """
+    path = vault / SYSTEM_DIR / REGISTRY_FILE
+    if not path.is_file():
+        return {}
+
+    try:
+        raw = tomllib.loads(path.read_text(encoding="utf-8"))
+    except tomllib.TOMLDecodeError as error:
+        msg = f"registry is not valid TOML: {error}"
+        raise RegistryError(msg) from error
+
+    raw_projects = raw.get("projects", {})
+    if not isinstance(raw_projects, dict):
+        msg = f"registry 'projects' must be a table, got {type(raw_projects).__name__}"
+        raise RegistryError(msg)
+
+    projects: dict[str, Project] = {}
+    for slug, entry in raw_projects.items():
+        if not isinstance(entry, dict):
+            msg = f"registry entry {slug!r} must be a table, got {type(entry).__name__}"
+            raise RegistryError(msg)
+
+        try:
+            slug_shaped = slug == ids.slugify(slug)
+        except ValueError:
+            slug_shaped = False
+        if not slug_shaped:
+            # A slug names a directory under projects/, so one that survives no
+            # slugification, or slugifies to something else, could otherwise walk
+            # a project's files outside the vault.
+            msg = f"registry entry {slug!r} is not a valid project slug"
+            raise RegistryError(msg)
+
+        root = entry.get("root", "")
+        if not isinstance(root, str):
+            msg = f"registry entry {slug!r} has a malformed 'root' field"
+            raise RegistryError(msg)
+
+        projects[slug] = Project(
+            slug=slug,
+            remotes=_string_tuple(entry, "remotes", slug),
+            root=root,
+        )
+    return projects
+
+
+def save(vault: Path, projects: Mapping[str, Project]) -> None:
+    """Write the registry, replacing whatever was there.
+
+    The write is atomic. A slug is permanent once notes carry it, and this file is the
+    only record of which slug a project's existing notes were filed under, so a write
+    interrupted partway through has to leave the previous mapping intact.
+
+    Args:
+        vault (Path): The vault root.
+        projects (Mapping[str, Project]): Projects keyed by slug.
+    """
+    path = vault / SYSTEM_DIR / REGISTRY_FILE
+
+    document = {
+        "projects": {
+            slug: {
+                "remotes": list(project.remotes),
+                "root": project.root,
+            }
+            for slug, project in sorted(projects.items())
+        }
+    }
+    atomic.write_text(path, tomli_w.dumps(document))
+
+
+def find_by_remote(projects: Mapping[str, Project], remotes: Iterable[str]) -> Project | None:
+    """Return the project sharing any remote with `remotes`.
+
+    Args:
+        projects (Mapping[str, Project]): The loaded registry.
+        remotes (Iterable[str]): Normalized remote keys from the current checkout.
+
+    Returns:
+        Project | None: The matching project, or None.
+    """
+    wanted = set(remotes)
+    for project in projects.values():
+        if wanted & set(project.remotes):
+            return project
+    return None
+
+
+def find_by_root(projects: Mapping[str, Project], root: str) -> Project | None:
+    """Return the project whose recorded repository root equals `root`.
+
+    Both sides are resolved before comparison, so a symlinked path (`/tmp` on macOS,
+    for instance) matches a registry entry regardless of which spelling either side
+    happens to use. A stored root that is not absolute is skipped rather than resolved,
+    since resolving it would measure it from wherever the process happens to be running,
+    which would make the answer depend on the caller's working directory.
+
+    Args:
+        projects (Mapping[str, Project]): The loaded registry.
+        root (str): An absolute repository root.
+
+    Returns:
+        Project | None: The matching project, or None.
+    """
+    if not root:
+        return None
+
+    target = Path(root).resolve()
+    for project in projects.values():
+        if not project.root or not Path(project.root).is_absolute():
+            continue
+        if Path(project.root).resolve() == target:
+            return project
+    return None
+
+
+def find_by_path_prefix(projects: Mapping[str, Project], path: str) -> Project | None:
+    """Return the registered project containing `path`, preferring the deepest root.
+
+    This is what resolves a directory anywhere inside a project whose root is the only
+    key it has, such as a project that is not a git repository. It is a broad key, and
+    `resolve` documents the narrow conditions under which it applies one. Both sides are
+    resolved before comparison for the same reason `find_by_root` does it, and a stored
+    root that is not absolute is skipped rather than resolved, since resolving it would
+    measure it from wherever the process happens to be running. The deepest matching root
+    wins, so a project nested inside another resolves as the inner one. Ties, which only a
+    hand-edited registry can produce, break on slug order to keep the answer stable across
+    runs.
+
+    Args:
+        projects (Mapping[str, Project]): The loaded registry.
+        path (str): An absolute directory.
+
+    Returns:
+        Project | None: The innermost project containing `path`, or None.
+    """
+    if not path:
+        return None
+
+    target = Path(path).resolve()
+    best: Project | None = None
+    best_depth = -1
+    for project in sorted(projects.values(), key=lambda candidate: candidate.slug):
+        if not project.root or not Path(project.root).is_absolute():
+            continue
+        root = Path(project.root).resolve()
+        if not target.is_relative_to(root):
+            continue
+        depth = len(root.parts)
+        if depth > best_depth:
+            best = project
+            best_depth = depth
+    return best

sessionmemory/lib/resolve.py

@@ -0,0 +1,75 @@
+"""Answer "which project am I in".
+
+Three keys are tried in order and the first hit wins: the normalized git remote, the
+repository root, then a longest-prefix match of `cwd` against every registered root.
+
+The third key applies only where git has positively ruled out a repository. A git
+repository is its own project boundary, so an unregistered one is unregistered rather
+than absorbed by whichever directory happens to contain it. Letting the path walk run
+inside a repository would file a fresh checkout's notes under its parent directory's
+project with nothing reported, and a slug is permanent once notes carry it. The same
+reasoning bars the walk when git could not answer, since an unanswered question is not
+an answer of "no repository", and when the repository is bare, since it has no working
+tree for a working directory to belong to.
+
+A worktree always resolves to its parent project, because the repository root comes from
+`--git-common-dir`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from sessionmemory.lib import registry
+from sessionmemory.lib.gitinfo import git_context
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Resolution:
+    """Which project a working directory belongs to."""
+
+    slug: str | None
+    registered: bool
+    repo_root: Path | None
+    is_worktree: bool
+
+
+def resolve(vault: Path, cwd: Path) -> Resolution:
+    """Map a working directory to a registered project.
+
+    Args:
+        vault (Path): The vault root.
+        cwd (Path): The directory to resolve.
+
+    Returns:
+        Resolution: The match, or an unregistered result carrying what git did know.
+    """
+    context = git_context(cwd)
+    projects = registry.load(vault)
+
+    found = registry.find_by_remote(projects, context.remotes)
+
+    if found is None and context.repo_root is not None:
+        found = registry.find_by_root(projects, str(context.repo_root))
+
+    if found is None and context.repo_root is None and context.git_answered and not context.is_bare:
+        found = registry.find_by_path_prefix(projects, str(cwd.resolve()))
+
+    if found is None:
+        return Resolution(
+            slug=None,
+            registered=False,
+            repo_root=context.repo_root,
+            is_worktree=context.is_worktree,
+        )
+
+    return Resolution(
+        slug=found.slug,
+        registered=True,
+        repo_root=context.repo_root,
+        is_worktree=context.is_worktree,
+    )

sessionmemory-0.2.0.dist-info/METADATA

@@ -0,0 +1,250 @@
+Metadata-Version: 2.3
+Name: sessionmemory
+Version: 0.2.0
+Summary: Durable memory for coding agents, one folder of searchable pages per project.
+Author: Nathaniel Landau
+Author-email: Nathaniel Landau <github@natelandau.com>
+Requires-Dist: fastembed>=0.8.0
+Requires-Dist: nclutils>=3.4.4
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: sqlite-vec>=0.1.9
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: typer>=0.27.2
+Requires-Python: >=3.13, <3.15
+Description-Content-Type: text/markdown
+
+# sessionmemory
+
+Durable memory for coding agents, one folder of searchable pages per project.
+
+An agent starts every session knowing nothing about the last one. Yesterday's session
+worked around a trap, rejected the obvious approach for a reason, and found the one flag
+that makes a library behave. All of it ends with the session, and the next one works it
+out again from nothing. `sessionmemory` keeps what a project learned and hands it back
+when the next session starts. Each project keeps its own memory, and no page is ever
+shared between projects.
+
+| Part                       | What it is                                                                     |
+| -------------------------- | ------------------------------------------------------------------------------ |
+| The vault                  | Your knowledge as markdown pages, one folder per project                       |
+| The `sessionmemory` plugin | Claude Code hooks that feed a session at its start and record it at its end    |
+| The `sessionmemory` CLI    | Searches pages by meaning and creates them. Everything else is a file you edit |
+
+The pages follow the memoryfield format by Cal Paterson, described in
+[his article](https://calpaterson.com/memoryfields.html) and defined in
+[the memoryfield spec](https://github.com/calpaterson/memoryfield-spec). Each project's
+`learnings/` folder is one field in that format: a flat directory of markdown pages beside one
+vector index file. You can export that folder, share it, or read it with any tool that
+speaks the format.
+
+## Requirements
+
+- Python 3.13 or 3.14
+- [uv](https://docs.astral.sh/uv/)
+- git. The vault is a git repository, and a project is registered by its git remote.
+- Claude Code, to run the plugin. The CLI works on its own without it.
+
+The first search downloads the `nomic-embed-text-v1.5` embedding model, about 520MB, and
+caches it under `~/.cache/sessionmemory/models`. Nothing else touches the network.
+
+## Install the CLI
+
+Clone the repository and install its dependencies. Keep the clone: it is the source the
+plugin installs from, and it is where you pull updates.
+
+```bash
+git clone https://github.com/natelandau/sessionmemory ~/repos/sessionmemory
+cd ~/repos/sessionmemory
+uv sync
+```
+
+To put a `sessionmemory` command on your `PATH`, install the package as a tool:
+
+```bash
+uv tool install .
+```
+
+Without that step, run the CLI as `uv run sessionmemory` from the clone, or through the
+`bin/sessionmemory` shim, which works from any directory.
+
+## Create a vault
+
+The vault is its own directory. Make it a git repository of its own, so your pages and
+this code do not share a history.
+
+```bash
+mkdir -p ~/repos/my-vault
+cd ~/repos/my-vault
+git init
+export SESSIONMEMORY_VAULT=~/repos/my-vault
+sessionmemory init
+```
+
+Put the `export` in your shell profile, and give it an absolute path. Every directory the
+CLI prints is built from that value.
+
+`sessionmemory init` writes the three files a vault needs. A marker in `_system/vault.toml`
+identifies the directory as a vault. A `.gitignore` keeps the derived index out of your
+history. A README explains the layout to whoever opens the vault later. `sessionmemory init`
+never overwrites a file, so you can run it again safely.
+
+Until a directory holds that marker, every command refuses to touch it. The refusal
+protects you. If `SESSIONMEMORY_VAULT` points at your home directory by mistake, the
+first page written scatters a `projects/` tree into it.
+
+Nothing commits the vault on a timer. The plugin commits it when a session starts and
+again when a session ends, so a page reaches git within the session that wrote it.
+Pushing that history to a remote stays yours to do.
+
+> **Note:** To bring an existing directory of notes under the CLI, run
+> `sessionmemory init --force ~/repos/my-vault` once. `--force` means only that the
+> directory already has contents. Nothing existing is overwritten.
+
+## Register a project
+
+A project gets memory when its repository is registered. Registration is the only
+decision, and it happens once, from inside the repository:
+
+```bash
+cd ~/repos/invoice-api
+sessionmemory project --register --cwd .
+```
+
+```
+✓ registered 'invoice-api'
+  └─ root: ~/repos/invoice-api
+```
+
+`--register` reads the git remote and the repository root, and derives the slug from
+them. There is nothing else to choose: no tags, no scope, no note type. The slug is
+permanent once pages carry it, so an unregistered directory is told to run this command
+rather than registered for you.
+
+## Search and write pages
+
+The CLI does two things. It finds pages by meaning, and it creates pages. Reading and
+editing a page is a job for your editor or your agent's own tools.
+
+```bash
+sessionmemory search "why does the same stripe event arrive twice" --limit 2 --cwd .
+```
+
+```
+~/repos/my-vault/projects/invoice-api/learnings/stripe-retries-a-webhook-for-72-hours-so-the-handler-must-be-idempotent.md
+  Stripe retries a webhook for 72 hours, so the handler must be idempotent
+  Stripe redelivers an unacknowledged webhook for up to 72 hours, so the handler records the event id and ignores a repeat.
+
+~/repos/my-vault/projects/invoice-api/learnings/the-nightly-reconciliation-job-must-start-after-the-02-00-bank-feed.md
+  The nightly reconciliation job must start after the 02:00 bank feed
+  The bank feed lands at 02:00 UTC; a reconciliation run before it reports every open invoice as unpaid.
+```
+
+A result is a path, a title, and a summary. A paraphrase finds the page, because search
+ranks by meaning and not by words in common. A query that nothing answers returns no
+results rather than the nearest pages. Pass `--read` to print every hit in full.
+
+```bash
+sessionmemory new learning \
+  --title "Stripe retries a webhook for 72 hours, so the handler must be idempotent" \
+  --summary "Stripe redelivers an unacknowledged webhook for up to 72 hours, so the handler records the event id and ignores a repeat." \
+  --cwd .
+```
+
+```
+✓ created stripe-retries-a-webhook-for-72-hours-so-the-handler-must-be-idempotent.md
+  └─ ~/repos/my-vault/projects/invoice-api/learnings/stripe-retries-a-webhook-for-72-hours-so-the-handler-must-be-idempotent.md
+```
+
+The vault path is shortened to `~` here; the command prints absolute paths.
+
+The command writes the frontmatter and prints the path. Write the body into that file,
+or pass it with `--body-file`. The title is what every future session sees at its start,
+and the summary is what a search result shows. Both state the fact and not the topic.
+
+## Install the Claude Code plugin
+
+Add the clone as a marketplace, then install the plugin from it:
+
+```
+/plugin marketplace add ~/repos/sessionmemory
+/plugin install sessionmemory@sessionmemory
+```
+
+The GitHub shorthand `natelandau/sessionmemory` works as a marketplace source too.
+Either way, Claude Code copies the plugin into its own cache and runs the hooks from that
+copy, not from your clone. After you pull changes into the clone, run
+`/plugin update sessionmemory@sessionmemory` to refresh the copy.
+
+A hook does not start from an interactive shell. A session launched from a GUI or an IDE
+cannot see a root exported in `.zshrc`, so record the vault root in
+`~/.claude/sessionmemory.toml` as well:
+
+```toml
+[vault]
+root = "~/repos/my-vault"
+```
+
+From then on, a session that starts in a registered repository receives that project's
+memory. A session that ends or compacts hands its transcript to a background pass, which
+records what was worth keeping.
+
+## What a session sees
+
+`sessionmemory inject` prints the block a session starts with. This is the block for a
+project holding four learnings, one spec, one plan, and two open backlog items:
+
+```
+## Using this vault
+
+Durable memory for this project lives in a vault of markdown pages. Below is the
+list of what it already knows; each title is one `sessionmemory search` away.
+
+  - A title below matches what you are doing: `sessionmemory search "<words>"` returns
+    the page's path, and you Read it. Search before assuming nothing was written down.
+  - Past sessions: `sessionmemory search "<words>" --logs`. Open work: read `backlog.md`
+    in the project's vault folder (`sessionmemory project --json` prints every path).
+  - Something worth keeping past this session: `sessionmemory new learning --title "..."
+    --summary "..." --cwd .` creates the page and prints the path to write prose into.
+    Keep a page under 8KB; more detail is another page.
+  - Specs and plans: `sessionmemory new spec|plan --title "..." --cwd .` creates the file.
+    Edit `backlog.md`, specs, and plans directly; the CLI only creates pages.
+
+## What this project knows
+
+  - Invoice numbers come from a Postgres sequence, never from max(id) plus one
+  - pytest-asyncio needs asyncio_mode = auto or every async test is skipped
+  - Stripe retries a webhook for 72 hours, so the handler must be idempotent
+  - The nightly reconciliation job must start after the 02:00 bank feed
+
+## Open work
+
+  2 open backlog items
+  spec: Export invoices as UBL 2.1 XML
+  plan: Move PDF rendering to a worker queue
+```
+
+A page body never enters that block, so its cost grows with the number of pages and not
+with their length. The titles say what exists. `sessionmemory search` returns what they say.
+
+## Documentation
+
+| Page                                     | What it covers                                               |
+| ---------------------------------------- | ------------------------------------------------------------ |
+| [Concepts](docs/concepts.md)             | Pages, fields, the index, and the layout of a vault          |
+| [CLI reference](docs/cli.md)             | Every command, its options, and its output                   |
+| [The Claude Code plugin](docs/plugin.md) | The hooks, the sweep, every setting, and the slash commands  |
+| [Vault health](docs/vault-health.md)     | What `sessionmemory doctor` reports, and what to do about it |
+
+## Development
+
+```bash
+uv sync                  # install dependencies
+uv run duty lint         # ruff, ty, typos, yamllint, shellcheck, prek
+uv run duty test         # pytest with coverage
+```
+
+`CLAUDE.md` records the conventions this project holds itself to.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

sessionmemory-0.2.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+sessionmemory/__init__.py,sha256=lZ5NrhvNUTYw1L7hV1Shym8B7sRAjC82U-W7N1UCXxc,26
+sessionmemory/cli.py,sha256=AjhwVYRtLu8DKhdrdyzQ2KovAfirfTpkhDefpYNMVco,2215
+sessionmemory/commands/__init__.py,sha256=Zgb48cR6suqCxLYng_XewSdeDg_l2Siv3FPk4F1zKL8,35
+sessionmemory/commands/_common.py,sha256=8_tH03x-wWoOyH5bZxR1P3SIEnLZsXtGQ1NTHxqwm-s,7410
+sessionmemory/commands/delete.py,sha256=0zNYhrPHQ785ruWlkyqBJW5TJr3ne9TKj4bKNfFHY3Q,2644
+sessionmemory/commands/doctor.py,sha256=drrdiNQsYp0EfRhSWlbY6OfiDyNRYVkTgHUB4yfINIA,1008
+sessionmemory/commands/export.py,sha256=QKG4mDc-8Tqcrx7b190MIlU0JGZ5o45smPQzkDVgL8I,1886
+sessionmemory/commands/init.py,sha256=HcCfQKpQTA1Z5qFTjrN_l5ZZWNIfHaH5uNKmDOjb5pk,3057
+sessionmemory/commands/inject.py,sha256=FrGuPWADg-2DEI675ZaJFU8bBxbVbvKtAcVDCZ8Hy5I,989
+sessionmemory/commands/log.py,sha256=koYZm0mJ2GGcDj5qlqpJUfw1H095b3RHDMF9BC9UkKQ,2062
+sessionmemory/commands/new.py,sha256=--UZhCi3FSK9kNNYWt4ax4ELUbArJbqNIv5-dFaq5g8,3106
+sessionmemory/commands/project.py,sha256=Hvy-fwupZm6iAcEaDzdqS5tCE7XPAViEKpR6rJmYsEI,11232
+sessionmemory/commands/reindex.py,sha256=jf8Ftp9TBfZrMmz_bRVcsXgZWj1GQgM3WVx7AapSmlU,1483
+sessionmemory/commands/search.py,sha256=7mp1Hb8X_zr05Qp_1plpgox8Ut-rQSA7EGqkCMpTVYI,2757
+sessionmemory/lib/__init__.py,sha256=IBmOlf3iTUn0K5FixO7tFYFcj0Som-1Kr2P0qIn9tDw,34
+sessionmemory/lib/atomic.py,sha256=BEwmZOfCWgKHmlLj7TT9H9u1g_itpLo5ptq7HYY9U4M,2707
+sessionmemory/lib/bootstrap.py,sha256=tENxX0QskhA3E79C9IwYgJU8iPvga8UHqgfXUCkhxr0,4847
+sessionmemory/lib/config.py,sha256=sqJn2lmCy3HeKuVijINIMqx9tVZ_8G1D92REFy41y-Y,3088
+sessionmemory/lib/doctor.py,sha256=gYc0-qsGAhLM44os3fxbT1vKCXFh00pnH-m6EtC4Ruk,6634
+sessionmemory/lib/embed.py,sha256=V3fcSg2VUxVKuK0efH75EuE1lMQQBK7uA5LDzkbWHnE,4392
+sessionmemory/lib/export.py,sha256=wIYglaUM7zlPllDf3r5hwk_-YawmrtdwiObYvtP0JkQ,864
+sessionmemory/lib/field.py,sha256=iRPc70VNrhmwjPdxL73UThKFSDiaGMUUzLvQs31zSuk,5828
+sessionmemory/lib/fieldindex.py,sha256=yRrMQEWWu3wtwEsKKQMb3QI0Xs37-4whtdAXV7vVVtQ,7166
+sessionmemory/lib/frontmatter.py,sha256=-9PFyLu1hboNMlBu525iWGuAvRwj0BvaEWCVcqBCNBk,5524
+sessionmemory/lib/gitinfo.py,sha256=FzIavwIQzgd6aXlIbu5zQz488LuD5IUns0cXOR02HZc,7152
+sessionmemory/lib/ids.py,sha256=3HBUw9vwFa9B0h5ktAbFzw7wCKMP5-h_J3Ys_heLW_E,3561
+sessionmemory/lib/inject.py,sha256=YcjEeD29hNLqn8qpNjIC6NQfvzRjdgu0KZsJNS-v5dw,3634
+sessionmemory/lib/log.py,sha256=32zNrSvtEtEln1gSJYwRW2ZOfAg7uQGXmL53Y6z55jA,2190
+sessionmemory/lib/paths.py,sha256=xdct1Vp-K2LVxzWxzsNrfkMSZqV_I8_OtHzkfll5zpE,2400
+sessionmemory/lib/registry.py,sha256=itOfFGSqSliJWsZhC3zEpPEBTH_hP83dvMKXjFIZjjY,9427
+sessionmemory/lib/resolve.py,sha256=LEbRQGaB7TIdL6xDrmMVLIU6v7RDInIAxaPexXi7bfY,2501
+sessionmemory-0.2.0.dist-info/WHEEL,sha256=y6e-a5KI2W-qDAJKfh9Xr81bin8NgUdfWgz3VSXXpe4,80
+sessionmemory-0.2.0.dist-info/entry_points.txt,sha256=Y-AoMbxG6rKjzZlclFrAE1hXi-oh4cE4iQ6CgzQQezI,58
+sessionmemory-0.2.0.dist-info/METADATA,sha256=eXCnzbIS1LqbD6kPHR8-KNWucqWZsPGsT8jIRkRx250,10696
+sessionmemory-0.2.0.dist-info/RECORD,,

sessionmemory-0.2.0.dist-info/WHEEL

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

sessionmemory-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+sessionmemory = sessionmemory.cli:main
+