luna-intelligence 1.0.0__tar.gz

luna_intelligence-1.0.0/.gitignore

@@ -0,0 +1,11 @@
+node_modules/
+.next/
+.env.local
+.env.*.local
+*.log
+.DS_Store
+.vscode/
+.idea/
+dist/
+build/
+.turbo/

luna_intelligence-1.0.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: luna-intelligence
+Version: 1.0.0
+Summary: LUNA — Developer activity intelligence. Monitor projects, enforce focus, generate AI session journals.
+License: MIT
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.28.0
+Description-Content-Type: text/markdown
+
+# luna-intelligence
+
+LUNA — Developer activity intelligence. Monitor projects, enforce focus, generate AI session journals.
+
+## Install
+
+```bash
+pip install luna-intelligence
+```
+
+## Requirements
+
+- Python 3.8+
+- LUNA daemon running locally (default: `http://localhost:3030`)
+- `luna` CLI on PATH
+
+## Usage
+
+### Python API
+
+```python
+from luna import LunaClient
+
+client = LunaClient()
+
+# Query activity
+events = client.events(limit=20)
+stats  = client.stats()
+
+# Get directive
+action = client.next_action()
+print(action.type)       # FOCUS | FINISH | EXECUTE
+print(action.message)
+print(action.directive)  # list of imperative steps
+
+# Set intent
+client.set_intent("Finish LUNA v8 journal engine")
+
+# Generate journal
+path = client.journal()  # triggers AI summary of last 6 hours
+```
+
+### CLI
+
+```bash
+luna-py status
+luna-py next
+luna-py events --limit 50
+luna-py stats
+luna-py intent "Ship CADMUS to Isaac"
+luna-py journal
+```

luna_intelligence-1.0.0/README.md

@@ -0,0 +1,52 @@
+# luna-intelligence
+
+LUNA — Developer activity intelligence. Monitor projects, enforce focus, generate AI session journals.
+
+## Install
+
+```bash
+pip install luna-intelligence
+```
+
+## Requirements
+
+- Python 3.8+
+- LUNA daemon running locally (default: `http://localhost:3030`)
+- `luna` CLI on PATH
+
+## Usage
+
+### Python API
+
+```python
+from luna import LunaClient
+
+client = LunaClient()
+
+# Query activity
+events = client.events(limit=20)
+stats  = client.stats()
+
+# Get directive
+action = client.next_action()
+print(action.type)       # FOCUS | FINISH | EXECUTE
+print(action.message)
+print(action.directive)  # list of imperative steps
+
+# Set intent
+client.set_intent("Finish LUNA v8 journal engine")
+
+# Generate journal
+path = client.journal()  # triggers AI summary of last 6 hours
+```
+
+### CLI
+
+```bash
+luna-py status
+luna-py next
+luna-py events --limit 50
+luna-py stats
+luna-py intent "Ship CADMUS to Isaac"
+luna-py journal
+```

luna_intelligence-1.0.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "luna-intelligence"
+version = "1.0.0"
+description = "LUNA — Developer activity intelligence. Monitor projects, enforce focus, generate AI session journals."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.scripts]
+luna-py = "luna.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/luna"]

luna_intelligence-1.0.0/src/luna/__init__.py

@@ -0,0 +1,7 @@
+"""LUNA Intelligence — Python SDK"""
+
+from .client import LunaClient
+from .models import Event, Project, Stats, NextAction
+
+__all__ = ["LunaClient", "Event", "Project", "Stats", "NextAction"]
+__version__ = "1.0.0"

luna_intelligence-1.0.0/src/luna/cli.py

@@ -0,0 +1,71 @@
+"""luna-py CLI — thin wrapper exposing LUNA commands from Python."""
+
+import argparse
+import json
+import sys
+
+from .client import LunaClient
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="luna-py",
+        description="LUNA Intelligence — Python CLI",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("status", help="Current project and intent")
+    sub.add_parser("next", help="Get LUNA directive (FOCUS / FINISH / EXECUTE)")
+    sub.add_parser("journal", help="Generate AI session journal")
+    sub.add_parser("stats", help="Per-project event counts (last hour)")
+
+    events_p = sub.add_parser("events", help="Recent activity events")
+    events_p.add_argument("--limit", type=int, default=20)
+
+    intent_p = sub.add_parser("intent", help="Set focus intent")
+    intent_p.add_argument("text", help="Intent text")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    client = LunaClient()
+
+    if args.command == "status":
+        s = client.status()
+        print(f"\nProject:       {s.get('project', 'none')}")
+        print(f"Last Activity: {s.get('last_activity', 'none')}")
+        print(f"Intent:        {s.get('intent', 'none')}\n")
+
+    elif args.command == "next":
+        action = client.next_action()
+        print(f"\n[{action.type}] {action.message}")
+        if action.directive:
+            print("\nDO THIS:")
+            for d in action.directive:
+                print(f"  → {d}")
+        if action.suggestion:
+            print("\nContext:")
+            for s in action.suggestion:
+                print(f"  - {s}")
+        print()
+
+    elif args.command == "journal":
+        path = client.journal()
+        print(f"Journal: {path}")
+
+    elif args.command == "stats":
+        stats = client.stats()
+        for s in stats:
+            print(f"  {s.project:<40} {s.count} events")
+
+    elif args.command == "events":
+        events = client.events(limit=args.limit)
+        for e in events:
+            print(f"  {e.time.strftime('%H:%M:%S')}  {e.project:<30}  {e.type}:{e.action}  {e.target}")
+
+    elif args.command == "intent":
+        client.set_intent(args.text)
+        print(f"Intent set: {args.text}")

luna_intelligence-1.0.0/src/luna/client.py

@@ -0,0 +1,206 @@
+"""
+LunaClient — connects to the LUNA daemon API (default: http://localhost:3030).
+
+LUNA must be running locally (managed by pm2). This client wraps the REST
+endpoints exposed by LUNA's Express server and also exposes the CLI commands
+via subprocess for journal generation and directives.
+
+Usage:
+    from luna import LunaClient
+
+    client = LunaClient()
+    events = client.events(limit=10)
+    action = client.next_action()
+    client.log_event(project="my-repo", type="file", action="modified", target="src/main.py")
+"""
+
+import subprocess
+import json
+from typing import List, Optional
+
+try:
+    import requests
+    _has_requests = True
+except ImportError:
+    _has_requests = False
+
+from .models import Event, Project, Stats, NextAction
+
+
+class LunaClient:
+    """
+    Python interface to a running LUNA daemon.
+
+    Args:
+        host: LUNA API host (default: localhost)
+        port: LUNA API port (default: 3030)
+        luna_bin: Path to the `luna` CLI binary (default: "luna" on PATH)
+    """
+
+    def __init__(
+        self,
+        host: str = "localhost",
+        port: int = 3030,
+        luna_bin: str = "luna",
+    ):
+        self.base_url = f"http://{host}:{port}"
+        self.luna_bin = luna_bin
+
+        if not _has_requests:
+            raise ImportError(
+                "The 'requests' package is required. Install it with: pip install requests"
+            )
+
+    # ── REST API ──────────────────────────────────────────────────────────────
+
+    def events(self, limit: int = 50) -> List[Event]:
+        """Return the most recent activity events logged by LUNA."""
+        resp = requests.get(f"{self.base_url}/events", params={"limit": limit})
+        resp.raise_for_status()
+        return [Event(**e) for e in resp.json()]
+
+    def stats(self) -> List[Stats]:
+        """Return per-project event counts for the last hour."""
+        resp = requests.get(f"{self.base_url}/stats")
+        resp.raise_for_status()
+        return [Stats(**s) for s in resp.json()]
+
+    def log_event(
+        self,
+        project: str,
+        type: str,
+        action: str,
+        target: str,
+        metadata: Optional[dict] = None,
+    ) -> None:
+        """Push a custom event into LUNA's activity log."""
+        payload = {
+            "project": project,
+            "type": type,
+            "action": action,
+            "target": target,
+            "timestamp": _now_ms(),
+            "metadata": json.dumps(metadata) if metadata else None,
+        }
+        resp = requests.post(f"{self.base_url}/event", json=payload)
+        resp.raise_for_status()
+
+    # ── CLI commands (subprocess) ─────────────────────────────────────────────
+
+    def next_action(self) -> NextAction:
+        """
+        Get LUNA's current directive: FOCUS / FINISH / EXECUTE.
+        Parses the luna CLI output — returns a structured NextAction.
+        """
+        raw = self._run_cli("next")
+        return _parse_next_action(raw)
+
+    def status(self) -> dict:
+        """Return current project, last activity, and intent as a dict."""
+        raw = self._run_cli("status")
+        return _parse_status(raw)
+
+    def journal(self) -> str:
+        """
+        Trigger AI journal generation for the last 6 hours of activity.
+        Returns the path to the generated markdown file.
+        """
+        raw = self._run_cli("journal")
+        for line in raw.splitlines():
+            if "Journal created:" in line:
+                return line.split("Journal created:")[-1].strip()
+        return raw.strip()
+
+    def set_intent(self, text: str) -> None:
+        """Set the current focus intent."""
+        self._run_cli("intent", text)
+
+    def projects(self) -> List[dict]:
+        """Return raw project rows from LUNA's database."""
+        raw = self._run_cli_json("projects")
+        return raw if isinstance(raw, list) else []
+
+    # ── Internal ──────────────────────────────────────────────────────────────
+
+    def _run_cli(self, *args: str) -> str:
+        result = subprocess.run(
+            [self.luna_bin, *args],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0 and result.stderr:
+            raise RuntimeError(f"LUNA CLI error: {result.stderr.strip()}")
+        return result.stdout
+
+    def _run_cli_json(self, *args: str) -> object:
+        """Run CLI command and attempt JSON parse of output."""
+        raw = self._run_cli(*args)
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError:
+            return raw
+
+
+# ── Parsers ───────────────────────────────────────────────────────────────────
+
+def _parse_next_action(raw: str) -> NextAction:
+    lines = [l.strip() for l in raw.splitlines() if l.strip()]
+    action_type = "EXECUTE"
+    message_lines = []
+    directives = []
+    suggestions = []
+    in_directive = False
+    in_suggestion = False
+
+    for line in lines:
+        if line.startswith("→"):
+            directives.append(line.lstrip("→").strip())
+            in_directive = True
+            in_suggestion = False
+        elif line.startswith("-"):
+            suggestions.append(line.lstrip("-").strip())
+            in_suggestion = True
+            in_directive = False
+        elif line in ("DO THIS:", "Context:"):
+            in_directive = line == "DO THIS:"
+            in_suggestion = line == "Context:"
+        elif "FOCUS" in line:
+            action_type = "FOCUS"
+        elif "FINISH" in line:
+            action_type = "FINISH"
+        elif not in_directive and not in_suggestion and line not in ("🧠 LUNA DIRECTIVE",):
+            message_lines.append(line)
+
+    # Infer type from message if not caught above
+    message = " ".join(message_lines).strip()
+    if "split across" in message:
+        action_type = "FOCUS"
+    elif "unfinished" in message.lower():
+        action_type = "FINISH"
+    elif "focused" in message.lower():
+        action_type = "EXECUTE"
+
+    return NextAction(
+        type=action_type,
+        message=message,
+        directive=directives,
+        suggestion=suggestions,
+    )
+
+
+def _parse_status(raw: str) -> dict:
+    result = {}
+    for line in raw.splitlines():
+        line = line.strip()
+        if line.startswith("Project:"):
+            result["project"] = line.split(":", 1)[1].strip()
+        elif line.startswith("Last Activity:"):
+            result["last_activity"] = line.split(":", 1)[1].strip()
+        elif line.startswith("Intent:"):
+            result["intent"] = line.split(":", 1)[1].strip()
+    return result
+
+
+def _now_ms() -> int:
+    import time
+    return int(time.time() * 1000)

luna_intelligence-1.0.0/src/luna/models.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import List, Optional
+
+
+@dataclass
+class Event:
+    id: int
+    type: str
+    action: str
+    target: str
+    project: str
+    timestamp: int
+    metadata: Optional[str] = None
+
+    @property
+    def time(self) -> datetime:
+        return datetime.fromtimestamp(self.timestamp / 1000)
+
+
+@dataclass
+class Project:
+    id: int
+    name: str
+    path: str
+    status: str  # active | stale | archive
+    last_active: int
+
+    @property
+    def last_active_time(self) -> datetime:
+        return datetime.fromtimestamp(self.last_active / 1000)
+
+
+@dataclass
+class Stats:
+    project: str
+    count: int
+
+
+@dataclass
+class NextAction:
+    type: str         # FOCUS | FINISH | EXECUTE
+    message: str
+    directive: List[str] = field(default_factory=list)
+    suggestion: List[str] = field(default_factory=list)