oortmem 0.2.0__tar.gz

oortmem-0.2.0/.gitignore

@@ -0,0 +1,17 @@
+node_modules/
+dist/
+.DS_Store
+*.log
+.env
+.env.*
+.worktrees/
+.superpowers/
+.output
+.tanstack
+.wrangler
+.dev.vars
+.nitro
+dist-ssr
+.npmrc
+__pycache__/
+*.egg-info/

oortmem-0.2.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.5
+Name: oortmem
+Version: 0.2.0
+Summary: Open-source memory for AI agents. Runs the Oort CLI (Node 22.15 or newer) from Python.
+Project-URL: Homepage, https://oortcloud.dev
+Project-URL: Source, https://github.com/oortmem/oort
+Project-URL: Documentation, https://oortcloud.dev/docs
+Author: Oort
+License-Expression: Apache-2.0
+Keywords: agents,ai,claude,llm,mcp,memory
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# oortmem
+
+Open-source memory for AI agents. Old facts are closed out, not overwritten, and every recall can explain why it was picked.
+
+This package installs the `oort` command for Python users. Oort itself is written in TypeScript and published on npm, so it needs **Node.js 22.15 or newer**. The launcher runs an `oort` you already have, or the matching npm release through `npx`. Arguments and exit codes pass straight through.
+
+```sh
+pipx install oortmem
+oort setup
+oort recall "where does the user live"
+```
+
+Without Node, `oort` tells you how to install it. You can also skip Python entirely with `npm install -g oortmem`.
+
+- Docs: https://oortcloud.dev/docs
+- Source: https://github.com/oortmem/oort
+- License: Apache 2.0

oortmem-0.2.0/README.md

@@ -0,0 +1,17 @@
+# oortmem
+
+Open-source memory for AI agents. Old facts are closed out, not overwritten, and every recall can explain why it was picked.
+
+This package installs the `oort` command for Python users. Oort itself is written in TypeScript and published on npm, so it needs **Node.js 22.15 or newer**. The launcher runs an `oort` you already have, or the matching npm release through `npx`. Arguments and exit codes pass straight through.
+
+```sh
+pipx install oortmem
+oort setup
+oort recall "where does the user live"
+```
+
+Without Node, `oort` tells you how to install it. You can also skip Python entirely with `npm install -g oortmem`.
+
+- Docs: https://oortcloud.dev/docs
+- Source: https://github.com/oortmem/oort
+- License: Apache 2.0

oortmem-0.2.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["hatchling==1.32.4"]
+build-backend = "hatchling.build"
+
+[project]
+name = "oortmem"
+version = "0.2.0"
+description = "Open-source memory for AI agents. Runs the Oort CLI (Node 22.15 or newer) from Python."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.9"
+authors = [{ name = "Oort" }]
+keywords = ["ai", "agents", "memory", "mcp", "claude", "llm"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://oortcloud.dev"
+Source = "https://github.com/oortmem/oort"
+Documentation = "https://oortcloud.dev/docs"
+
+[project.scripts]
+oort = "oortmem.cli:main"
+oortmem = "oortmem.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/oortmem"]

oortmem-0.2.0/src/oortmem/__init__.py

@@ -0,0 +1,3 @@
+"""Oort: open-source memory for AI agents. This package launches the Oort CLI from Python."""
+
+__version__ = "0.2.0"

oortmem-0.2.0/src/oortmem/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

oortmem-0.2.0/src/oortmem/cli.py

@@ -0,0 +1,108 @@
+"""Run the Oort CLI from Python.
+
+Oort is written in TypeScript and ships on npm as `oortmem`; it needs Node 22.15 or newer.
+This launcher runs an `oort` command that is already installed. Otherwise it runs the
+matching npm release through npx. Arguments, stdin, stdout and the exit code pass through
+unchanged.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from typing import Callable, Iterable, Optional, Sequence
+
+from . import __version__
+
+MIN_NODE = (22, 15)
+NPM_SPEC = f"oortmem@{__version__}"
+# Set on the child so a launcher that finds itself (or another copy of itself) on PATH
+# skips the PATH lookup instead of starting itself forever.
+GUARD = "OORTMEM_PY_LAUNCHER"
+
+HELP = f"""oort needs Node.js {MIN_NODE[0]}.{MIN_NODE[1]} or newer, and none was found.
+
+Install Node from https://nodejs.org, then run this command again. Or install the CLI
+directly with npm:
+
+    npm install -g oortmem
+
+Docs: https://oortcloud.dev/docs
+"""
+
+
+def node_version(node: str) -> Optional[tuple[int, int]]:
+    """The (major, minor) of `node --version`, or None when it cannot be run or read."""
+    try:
+        out = subprocess.run(
+            [node, "--version"], capture_output=True, text=True, timeout=10, check=False
+        ).stdout
+    except (OSError, subprocess.SubprocessError):
+        return None
+    m = re.match(r"v?(\d+)\.(\d+)", out.strip())
+    return (int(m.group(1)), int(m.group(2))) if m else None
+
+
+def path_candidates(name: str, path: Optional[str]) -> Iterable[str]:
+    """Every executable called `name` on PATH, in PATH order."""
+    seen = set()
+    for d in (path or "").split(os.pathsep):
+        if not d:
+            continue
+        found = shutil.which(name, path=d)
+        if found and found not in seen:
+            seen.add(found)
+            yield found
+
+
+def same_file(a: str, b: Optional[str]) -> bool:
+    if not b:
+        return False
+    try:
+        return os.path.samefile(a, b)
+    except OSError:
+        return False
+
+
+def resolve(
+    env: Optional[dict] = None,
+    self_path: Optional[str] = None,
+    candidates: Callable[[str, Optional[str]], Iterable[str]] = path_candidates,
+    which: Callable[[str], Optional[str]] = shutil.which,
+    version: Callable[[str], Optional[tuple[int, int]]] = node_version,
+) -> Optional[list[str]]:
+    """The command to run: an installed `oort`, else npx with the pinned release, else None."""
+    env = os.environ if env is None else env
+    if not env.get(GUARD):
+        for oort in candidates("oort", env.get("PATH")):
+            if not same_file(oort, self_path):
+                return [oort]
+    node, npx = which("node"), which("npx")
+    if node and npx:
+        v = version(node)
+        if v is not None and v >= MIN_NODE:
+            return [npx, "--yes", NPM_SPEC]
+    return None
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if args == ["--launcher-version"]:
+        print(f"oortmem (Python launcher) {__version__}, runs {NPM_SPEC}")
+        return 0
+    self_path = shutil.which(sys.argv[0]) or sys.argv[0]
+    cmd = resolve(self_path=self_path)
+    if cmd is None:
+        sys.stderr.write(HELP)
+        return 1
+    try:
+        return subprocess.call(cmd + args, env={**os.environ, GUARD: "1"})
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

oortmem-0.2.0/tests/test_cli.py

@@ -0,0 +1,108 @@
+import os
+import stat
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from oortmem import __version__, cli  # noqa: E402
+
+
+def none(_name):
+    return None
+
+
+class Resolve(unittest.TestCase):
+    def test_prefers_an_installed_oort(self):
+        cmd = cli.resolve(
+            env={"PATH": "/x"},
+            candidates=lambda n, p: ["/usr/local/bin/oort"],
+            which=none,
+        )
+        self.assertEqual(cmd, ["/usr/local/bin/oort"])
+
+    def test_falls_back_to_npx_with_the_pinned_release(self):
+        which = {"node": "/n/node", "npx": "/n/npx"}.get
+        cmd = cli.resolve(env={}, candidates=lambda n, p: [], which=which, version=lambda _: (22, 15))
+        self.assertEqual(cmd, ["/n/npx", "--yes", f"oortmem@{__version__}"])
+
+    def test_old_node_is_not_used(self):
+        which = {"node": "/n/node", "npx": "/n/npx"}.get
+        cmd = cli.resolve(env={}, candidates=lambda n, p: [], which=which, version=lambda _: (22, 14))
+        self.assertIsNone(cmd)
+
+    def test_unreadable_node_version_is_not_used(self):
+        which = {"node": "/n/node", "npx": "/n/npx"}.get
+        cmd = cli.resolve(env={}, candidates=lambda n, p: [], which=which, version=lambda _: None)
+        self.assertIsNone(cmd)
+
+    def test_nothing_installed(self):
+        self.assertIsNone(cli.resolve(env={}, candidates=lambda n, p: [], which=none))
+
+    def test_guard_skips_path_lookup(self):
+        def boom(n, p):
+            raise AssertionError("PATH must not be searched under the guard")
+
+        cmd = cli.resolve(env={cli.GUARD: "1"}, candidates=boom, which=none)
+        self.assertIsNone(cmd)
+
+
+class NeverRunsItself(unittest.TestCase):
+    """The Python `oort` script must skip itself on PATH and use the real CLI after it."""
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        root = Path(self.tmp.name)
+        self.first, self.second = root / "a", root / "b"
+        self.first.mkdir()
+        self.second.mkdir()
+        self.me = self._exe(self.first / "oort")
+        self.real = self._exe(self.second / "oort")
+        self.path = os.pathsep.join([str(self.first), str(self.second)])
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _exe(self, p):
+        p.write_text("#!/bin/sh\nexit 0\n")
+        p.chmod(p.stat().st_mode | stat.S_IXUSR)
+        return p
+
+    @unittest.skipIf(os.name == "nt", "POSIX shell scripts")
+    def test_skips_itself_and_finds_the_next(self):
+        cmd = cli.resolve(env={"PATH": self.path}, self_path=str(self.me), which=none)
+        self.assertEqual(cmd, [str(self.real)])
+
+    @unittest.skipIf(os.name == "nt", "POSIX shell scripts")
+    def test_only_itself_on_path_falls_through(self):
+        cmd = cli.resolve(env={"PATH": str(self.first)}, self_path=str(self.me), which=none)
+        self.assertIsNone(cmd)
+
+
+class Main(unittest.TestCase):
+    def test_launcher_version(self):
+        out = subprocess.run(
+            [sys.executable, "-m", "oortmem", "--launcher-version"],
+            capture_output=True,
+            text=True,
+            env={**os.environ, "PYTHONPATH": str(Path(cli.__file__).parents[1])},
+        )
+        self.assertEqual(out.returncode, 0)
+        self.assertIn(f"oortmem@{__version__}", out.stdout)
+
+    def test_no_node_prints_help_and_exits_1(self):
+        out = subprocess.run(
+            [sys.executable, "-m", "oortmem", "setup"],
+            capture_output=True,
+            text=True,
+            env={"PATH": "", "PYTHONPATH": str(Path(cli.__file__).parents[1])},
+        )
+        self.assertEqual(out.returncode, 1)
+        self.assertIn("npm install -g oortmem", out.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()