chronicle-dev 0.1.0__tar.gz

chronicle_dev-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+dist/
+*.tsbuildinfo
+.env
+.lore/.extraction-cache.json
+.lore/capture.log

chronicle_dev-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: chronicle-dev
+Version: 0.1.0
+Summary: AI-native development memory — markdown RAG for every AI coding tool
+Project-URL: Homepage, https://github.com/ypollak2/chronicle
+Project-URL: Repository, https://github.com/ypollak2/chronicle
+Project-URL: Issues, https://github.com/ypollak2/chronicle/issues
+License: MIT
+Keywords: ai,claude,codex,cursor,developer-tools,llm,rag
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# chronicle-dev (Python)
+
+> AI-native development memory — markdown RAG for every AI coding tool
+
+This is the Python wrapper for [Chronicle](https://github.com/ypollak2/chronicle).
+It delegates all work to the Node.js CLI (`chronicle-dev` on npm).
+
+## Requirements
+
+- Python ≥ 3.9
+- Node.js ≥ 20 ([install](https://nodejs.org))
+
+## Install
+
+```bash
+pip install chronicle-dev
+```
+
+## Usage
+
+Identical to the npm version:
+
+```bash
+chronicle init                    # scan last 6 months of git history
+chronicle inject | claude         # pipe context into Claude
+chronicle inject | codex          # or Codex, Gemini CLI, Aider...
+chronicle hooks install           # passive capture on every commit
+chronicle deepen --depth=1year    # scan further back
+```
+
+## How it works
+
+`pip install chronicle-dev` installs a `chronicle` entry point that:
+1. Checks Node ≥ 20 is available
+2. Delegates to `chronicle` (if globally installed) or `npx chronicle-dev`
+
+The Node package is the source of truth. This wrapper exists so Python developers
+can install Chronicle without switching to npm.
+
+## Full docs
+
+See [github.com/ypollak2/chronicle](https://github.com/ypollak2/chronicle)

chronicle_dev-0.1.0/README.md

@@ -0,0 +1,42 @@
+# chronicle-dev (Python)
+
+> AI-native development memory — markdown RAG for every AI coding tool
+
+This is the Python wrapper for [Chronicle](https://github.com/ypollak2/chronicle).
+It delegates all work to the Node.js CLI (`chronicle-dev` on npm).
+
+## Requirements
+
+- Python ≥ 3.9
+- Node.js ≥ 20 ([install](https://nodejs.org))
+
+## Install
+
+```bash
+pip install chronicle-dev
+```
+
+## Usage
+
+Identical to the npm version:
+
+```bash
+chronicle init                    # scan last 6 months of git history
+chronicle inject | claude         # pipe context into Claude
+chronicle inject | codex          # or Codex, Gemini CLI, Aider...
+chronicle hooks install           # passive capture on every commit
+chronicle deepen --depth=1year    # scan further back
+```
+
+## How it works
+
+`pip install chronicle-dev` installs a `chronicle` entry point that:
+1. Checks Node ≥ 20 is available
+2. Delegates to `chronicle` (if globally installed) or `npx chronicle-dev`
+
+The Node package is the source of truth. This wrapper exists so Python developers
+can install Chronicle without switching to npm.
+
+## Full docs
+
+See [github.com/ypollak2/chronicle](https://github.com/ypollak2/chronicle)

chronicle_dev-0.1.0/chronicle/__init__.py

@@ -0,0 +1,12 @@
+"""
+Chronicle — AI-native development memory.
+
+This package is a thin wrapper around the Node.js chronicle-dev CLI.
+For the full API, use the CLI directly or via subprocess.
+
+Example:
+    import subprocess
+    result = subprocess.run(["chronicle", "inject"], capture_output=True, text=True)
+    context = result.stdout
+"""
+__version__ = "0.1.0"

chronicle_dev-0.1.0/chronicle/_cli.py

@@ -0,0 +1,64 @@
+"""
+Subprocess wrapper — delegates all work to the Node binary (chronicle-dev).
+Requires Node ≥ 20 on PATH. The Node package is the source of truth.
+"""
+import shutil
+import subprocess
+import sys
+
+
+def _node_available() -> bool:
+    node = shutil.which("node")
+    if not node:
+        return False
+    try:
+        out = subprocess.check_output(["node", "--version"], text=True).strip()
+        major = int(out.lstrip("v").split(".")[0])
+        return major >= 20
+    except Exception:
+        return False
+
+
+def _chronicle_binary() -> list[str]:
+    """Return the command list that invokes the Node chronicle CLI.
+
+    Never calls 'chronicle' directly — that would call this Python wrapper
+    recursively. Always delegates to the Node package via npm/npx.
+    """
+    # If the user has `npm install -g chronicle-dev`, the Node binary lands
+    # at a path like /usr/local/bin/chronicle — but so does this Python script.
+    # We disambiguate by checking for the npm global bin explicitly.
+    npm = shutil.which("npm")
+    if npm:
+        try:
+            prefix = subprocess.check_output(
+                [npm, "root", "-g"], text=True, stderr=subprocess.DEVNULL
+            ).strip()
+            # npm global bin is one level up from global node_modules
+            import os
+            global_bin = os.path.join(os.path.dirname(prefix), "bin", "chronicle")
+            # Only use it if it's a Node script (not this Python script)
+            if os.path.exists(global_bin):
+                with open(global_bin) as f:
+                    first_line = f.readline()
+                if "node" in first_line and "python" not in first_line:
+                    return [global_bin]
+        except Exception:
+            pass
+
+    # Fallback: npx installs on-demand from npm registry
+    return ["npx", "--yes", "chronicle-dev"]
+
+
+def main() -> None:
+    if not _node_available():
+        print(
+            "Chronicle requires Node.js ≥ 20.\n"
+            "Install it from https://nodejs.org or via `brew install node`.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    cmd = _chronicle_binary() + sys.argv[1:]
+    result = subprocess.run(cmd)
+    sys.exit(result.returncode)

chronicle_dev-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "chronicle-dev"
+version = "0.1.0"
+description = "AI-native development memory — markdown RAG for every AI coding tool"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+keywords = ["ai", "llm", "rag", "developer-tools", "claude", "codex", "cursor"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+# No runtime dependencies — Node does all the work
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[project.scripts]
+chronicle = "chronicle._cli:main"
+
+[project.urls]
+Homepage = "https://github.com/ypollak2/chronicle"
+Repository = "https://github.com/ypollak2/chronicle"
+Issues = "https://github.com/ypollak2/chronicle/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["chronicle"]

chronicle_dev-0.1.0/tests/test_cli.py

@@ -0,0 +1,58 @@
+"""Tests for the Chronicle Python wrapper."""
+import subprocess
+import sys
+from unittest.mock import patch, MagicMock
+import pytest
+
+
+def test_node_available_when_node_on_path():
+    """Node must be detectable via shutil.which."""
+    import shutil
+    assert shutil.which("node") is not None, "Node not found — required for Chronicle"
+
+
+def test_node_version_is_20_plus():
+    """Node version must be >= 20."""
+    result = subprocess.run(["node", "--version"], capture_output=True, text=True)
+    assert result.returncode == 0
+    version_str = result.stdout.strip().lstrip("v")
+    major = int(version_str.split(".")[0])
+    assert major >= 20, f"Node {version_str} < 20"
+
+
+def test_main_exits_nonzero_without_node(monkeypatch):
+    """main() exits with code 1 when Node is not available."""
+    from chronicle._cli import _node_available
+    with patch("chronicle._cli._node_available", return_value=False):
+        with pytest.raises(SystemExit) as exc:
+            from chronicle._cli import main
+            main()
+        assert exc.value.code == 1
+
+
+def test_chronicle_binary_prefers_node_global():
+    """_chronicle_binary returns a list starting with a string."""
+    from chronicle._cli import _chronicle_binary
+    cmd = _chronicle_binary()
+    assert isinstance(cmd, list)
+    assert len(cmd) >= 1
+    assert isinstance(cmd[0], str)
+
+
+def test_chronicle_binary_fallback_is_npx():
+    """Falls back to npx when no global Node binary found."""
+    import shutil
+    with patch("shutil.which", return_value=None):
+        from importlib import reload
+        import chronicle._cli as cli_module
+        # Simulate npm not found → must fall back to npx
+        with patch("subprocess.check_output", side_effect=Exception("no npm")):
+            cmd = cli_module._chronicle_binary()
+            assert cmd[0] in ("npx", "chronicle"), f"Unexpected fallback: {cmd}"
+
+
+def test_package_version_defined():
+    """Package version must be defined."""
+    import chronicle
+    assert hasattr(chronicle, "__version__")
+    assert chronicle.__version__ == "0.1.0"