pylumbergh 0.0.2__tar.gz

pylumbergh-0.0.2/.gitignore

@@ -0,0 +1,50 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+venv/
+.uv/
+*.egg-info/
+.eggs/
+
+# Node
+node_modules/
+dist/
+dev-dist/
+.npm
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Build outputs
+build/
+*.tsbuildinfo
+
+# uv
+uv.lock
+
+# Playwright
+.playwright/
+.playwright-cli/
+
+# Lumbergh package build artifacts
+backend/lumbergh/frontend_dist/
+!backend/lumbergh/frontend_dist/.gitkeep

pylumbergh-0.0.2/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: pylumbergh
+Version: 0.0.2
+Summary: Tmux session supervisor backend
+Requires-Python: >=3.11
+Requires-Dist: fastapi
+Requires-Dist: gitpython>=3.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: libtmux
+Requires-Dist: python-multipart
+Requires-Dist: tinydb
+Requires-Dist: uvicorn[standard]

pylumbergh-0.0.2/assets/tmux.conf

@@ -0,0 +1,43 @@
+# Change prefix from Ctrl-b to Ctrl-a
+unbind C-b
+set-option -g prefix C-a
+bind-key C-a send-prefix
+
+# Start windows and panes at 1, not 0
+set -g base-index 1
+setw -g pane-base-index 1
+
+# Reload config with Ctrl-a r
+bind r source-file ~/.tmux.conf \; display "Reloaded!"
+
+# Status bar at top
+set -g status-position top
+
+# Minimal status bar styling
+set -g status-style "bg=#282828,fg=#928374"
+set -g status-left "#[fg=#a89984,bold] #S "
+set -g status-left-length 20
+set -g status-right ""
+set -g window-status-format " #I:#W "
+set -g window-status-current-format "#[fg=#ebdbb2,bg=#504945,bold] #I:#W "
+set -g window-status-separator ""
+
+# Rename window with F2
+bind F2 command-prompt -I "#W" "rename-window '%%'"
+
+# Move windows left/right with Ctrl-Shift-Left/Right
+bind -n C-S-Left swap-window -t -1\; select-window -t -1
+bind -n C-S-Right swap-window -t +1\; select-window -t +1
+
+# Auto renumber windows when one is closed
+set -g renumber-windows on
+
+# Mobile/xterm.js scroll support
+set -g mouse on
+
+# Prevent copy-mode from exiting on mouse/touch release
+unbind -T copy-mode MouseDragEnd1Pane
+unbind -T copy-mode-vi MouseDragEnd1Pane
+
+# Allow scrolling in alternate screen apps (like Claude Code)
+set -ga terminal-overrides ',xterm*:smcup@:rmcup@'

pylumbergh-0.0.2/lumbergh/__init__.py

@@ -0,0 +1 @@
+"""Lumbergh - AI Session Supervisor."""

pylumbergh-0.0.2/lumbergh/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running with `python -m lumbergh`."""
+
+from lumbergh.cli import run
+
+run()

pylumbergh-0.0.2/lumbergh/_version.py

@@ -0,0 +1 @@
+__version__ = "0.0.2"

pylumbergh-0.0.2/lumbergh/ai/__init__.py

@@ -0,0 +1,14 @@
+"""
+AI module for Lumbergh.
+
+Provides provider-agnostic AI completions with support for:
+- Ollama (local)
+- OpenAI
+- Anthropic
+- OpenAI-compatible endpoints
+"""
+
+from lumbergh.ai.prompts import DEFAULT_COMMIT_MESSAGE_PROMPT, get_ai_prompt
+from lumbergh.ai.providers import AIProvider, get_provider
+
+__all__ = ["DEFAULT_COMMIT_MESSAGE_PROMPT", "AIProvider", "get_ai_prompt", "get_provider"]

pylumbergh-0.0.2/lumbergh/ai/prompts.py

@@ -0,0 +1,191 @@
+"""
+AI prompt template management.
+
+Stores and retrieves AI system prompts with support for:
+- Global default prompts
+- Per-project overrides
+"""
+
+from pathlib import Path
+
+from lumbergh.db_utils import (
+    get_global_db,
+    get_project_db,
+    get_single_document_items,
+    save_single_document_items,
+)
+
+# Default prompt for commit message generation
+DEFAULT_COMMIT_MESSAGE_PROMPT = """Generate a git commit message following the Conventional Commits specification.
+
+FORMAT:
+<type>(<scope>): <description>
+
+[optional body]
+
+TYPES (pick one):
+- feat: new feature or capability
+- fix: bug fix
+- refactor: code change that neither fixes a bug nor adds a feature
+- docs: documentation only
+- test: adding or updating tests
+- chore: maintenance tasks (deps, config, build)
+- style: formatting, whitespace (no logic change)
+- perf: performance improvement
+
+RULES:
+- Subject line MUST be under 50 characters (hard limit)
+- Use imperative mood: "add" not "added" or "adds"
+- Scope is optional but helpful (e.g., api, ui, auth)
+- No period at end of subject line
+- Body is optional; use for complex changes to explain WHY
+
+EXAMPLES:
+- feat(ai): add commit message generation
+- fix: prevent crash on empty diff
+- refactor(providers): extract base class for AI providers
+- chore: update dependencies
+
+{{#if user_messages}}
+User instructions that led to these changes:
+{{user_messages}}
+{{/if}}
+
+{{#if file_summary}}
+Files changed:
+{{file_summary}}
+{{/if}}
+
+Diff:
+```
+{{git_diff}}
+```
+
+Respond with ONLY the commit message. No markdown, no explanation."""
+
+# Prompt for summarizing a todo into a short status
+STATUS_SUMMARY_PROMPT = """Summarize this task in 2-3 words maximum.
+Examples: "fixing auth", "adding tests", "refactoring API"
+Task: {text}"""
+
+# Table name for AI prompts
+AI_PROMPTS_TABLE = "ai_prompts"
+
+
+def get_default_ai_prompts() -> list[dict]:
+    """Return the built-in default AI prompts."""
+    return [
+        {
+            "id": "commit_message",
+            "task": "commit_message",
+            "name": "Default Commit Message",
+            "template": DEFAULT_COMMIT_MESSAGE_PROMPT,
+            "isDefault": True,
+        }
+    ]
+
+
+def get_global_ai_prompts() -> list[dict]:
+    """Get AI prompts from global config, with defaults merged in."""
+    db = get_global_db()
+    table = db.table(AI_PROMPTS_TABLE)
+    stored = get_single_document_items(table)
+
+    # Merge with defaults - stored prompts override defaults by task
+    defaults = get_default_ai_prompts()
+    stored_tasks = {p["task"] for p in stored}
+
+    # Add defaults for any tasks not in stored
+    result = list(stored)
+    result.extend(default for default in defaults if default["task"] not in stored_tasks)
+
+    return result
+
+
+def save_global_ai_prompts(prompts: list[dict]) -> list[dict]:
+    """Save AI prompts to global config."""
+    db = get_global_db()
+    table = db.table(AI_PROMPTS_TABLE)
+    return save_single_document_items(table, prompts)
+
+
+def get_project_ai_prompts(project_path: Path) -> list[dict]:
+    """Get AI prompts for a specific project (overrides only)."""
+    db = get_project_db(project_path)
+    table = db.table(AI_PROMPTS_TABLE)
+    return get_single_document_items(table)
+
+
+def save_project_ai_prompts(project_path: Path, prompts: list[dict]) -> list[dict]:
+    """Save AI prompts for a specific project."""
+    db = get_project_db(project_path)
+    table = db.table(AI_PROMPTS_TABLE)
+    return save_single_document_items(table, prompts)
+
+
+def get_ai_prompt(task: str, project_path: Path | None = None) -> str | None:
+    """
+    Get the AI prompt template for a specific task.
+
+    Resolution order:
+    1. Project-specific override (if project_path provided)
+    2. Global custom prompt
+    3. Built-in default
+
+    Args:
+        task: The task identifier (e.g., "commit_message")
+        project_path: Optional project path for project-specific overrides
+
+    Returns:
+        The prompt template string, or None if not found
+    """
+    # Check project-specific first
+    if project_path:
+        project_prompts = get_project_ai_prompts(project_path)
+        for prompt in project_prompts:
+            if prompt.get("task") == task:
+                return prompt.get("template")
+
+    # Check global prompts (includes defaults)
+    global_prompts = get_global_ai_prompts()
+    for prompt in global_prompts:
+        if prompt.get("task") == task:
+            return prompt.get("template")
+
+    return None
+
+
+def render_prompt(template: str, variables: dict) -> str:
+    """
+    Simple template rendering with {{variable}} syntax.
+
+    Also supports {{#if variable}}...{{/if}} blocks.
+
+    Args:
+        template: The template string with {{variable}} placeholders
+        variables: Dict of variable names to values
+
+    Returns:
+        The rendered prompt string
+    """
+    result = template
+
+    # Handle {{#if var}}...{{/if}} blocks
+    import re
+
+    if_pattern = re.compile(r"\{\{#if\s+(\w+)\}\}(.*?)\{\{/if\}\}", re.DOTALL)
+
+    def replace_if(match):
+        var_name = match.group(1)
+        content = match.group(2)
+        if variables.get(var_name):
+            return content
+        return ""
+
+    result = if_pattern.sub(replace_if, result)
+
+    # Handle simple {{variable}} substitutions
+    for key, value in variables.items():
+        result = result.replace(f"{{{{{key}}}}}", str(value))
+
+    return result

pylumbergh-0.0.2/lumbergh/ai/providers.py

@@ -0,0 +1,246 @@
+"""
+AI provider abstraction layer.
+
+Supports multiple AI backends with a unified interface.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+import httpx
+
+
+class AIProvider(ABC):
+    """Abstract base class for AI providers."""
+
+    @abstractmethod
+    async def complete(self, prompt: str) -> str:
+        """Generate a completion for the given prompt."""
+        ...
+
+    @abstractmethod
+    async def health_check(self) -> bool:
+        """Check if the provider is available."""
+        ...
+
+
+class OllamaProvider(AIProvider):
+    """Ollama local LLM provider."""
+
+    def __init__(self, base_url: str = "http://localhost:11434", model: str = "llama3.2"):
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+
+    async def complete(self, prompt: str) -> str:
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(
+                f"{self.base_url}/api/generate",
+                json={
+                    "model": self.model,
+                    "prompt": prompt,
+                    "stream": False,
+                },
+            )
+            response.raise_for_status()
+            return response.json()["response"]
+
+    async def health_check(self) -> bool:
+        try:
+            async with httpx.AsyncClient(timeout=5.0) as client:
+                response = await client.get(f"{self.base_url}/api/tags")
+                return response.status_code == 200
+        except Exception:
+            return False
+
+    async def list_models(self) -> list[dict[str, Any]]:
+        """List available models from Ollama."""
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(f"{self.base_url}/api/tags")
+            response.raise_for_status()
+            data = response.json()
+            return [
+                {
+                    "name": m["name"],
+                    "size": m.get("size", 0),
+                    "parameter_size": m.get("details", {}).get("parameter_size", ""),
+                }
+                for m in data.get("models", [])
+            ]
+
+
+class OpenAIProvider(AIProvider):
+    """OpenAI API provider."""
+
+    def __init__(self, api_key: str, model: str = "gpt-4o"):
+        self.api_key = api_key
+        self.model = model
+        self.base_url = "https://api.openai.com/v1"
+
+    async def complete(self, prompt: str) -> str:
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            response = await client.post(
+                f"{self.base_url}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": self.model,
+                    "messages": [{"role": "user", "content": prompt}],
+                },
+            )
+            response.raise_for_status()
+            return response.json()["choices"][0]["message"]["content"]
+
+    async def health_check(self) -> bool:
+        try:
+            async with httpx.AsyncClient(timeout=5.0) as client:
+                response = await client.get(
+                    f"{self.base_url}/models",
+                    headers={"Authorization": f"Bearer {self.api_key}"},
+                )
+                return response.status_code == 200
+        except Exception:
+            return False
+
+
+class AnthropicProvider(AIProvider):
+    """Anthropic Claude API provider."""
+
+    def __init__(self, api_key: str, model: str = "claude-sonnet-4-20250514"):
+        self.api_key = api_key
+        self.model = model
+        self.base_url = "https://api.anthropic.com/v1"
+
+    async def complete(self, prompt: str) -> str:
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            response = await client.post(
+                f"{self.base_url}/messages",
+                headers={
+                    "x-api-key": self.api_key,
+                    "anthropic-version": "2023-06-01",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": self.model,
+                    "max_tokens": 1024,
+                    "messages": [{"role": "user", "content": prompt}],
+                },
+            )
+            response.raise_for_status()
+            return response.json()["content"][0]["text"]
+
+    async def health_check(self) -> bool:
+        # Anthropic doesn't have a simple health endpoint, so just check if key exists
+        return bool(self.api_key)
+
+
+class GoogleAIProvider(AIProvider):
+    """Google AI (Gemini) API provider."""
+
+    def __init__(self, api_key: str, model: str = "gemini-3-flash-preview"):
+        self.api_key = api_key
+        self.model = model
+        self.base_url = "https://generativelanguage.googleapis.com/v1beta"
+
+    async def complete(self, prompt: str) -> str:
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(
+                f"{self.base_url}/models/{self.model}:generateContent",
+                headers={
+                    "x-goog-api-key": self.api_key,
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "contents": [{"parts": [{"text": prompt}]}],
+                    "generationConfig": {"thinkingConfig": {"thinkingLevel": "minimal"}},
+                },
+            )
+            response.raise_for_status()
+            return response.json()["candidates"][0]["content"]["parts"][0]["text"]
+
+    async def health_check(self) -> bool:
+        # Google AI doesn't have a simple health endpoint, so just check if key exists
+        return bool(self.api_key)
+
+
+class OpenAICompatibleProvider(AIProvider):
+    """OpenAI-compatible API provider (e.g., local vLLM, text-generation-inference)."""
+
+    def __init__(self, base_url: str, api_key: str = "", model: str = "default"):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+
+    async def complete(self, prompt: str) -> str:
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(
+                f"{self.base_url}/chat/completions",
+                headers=headers,
+                json={
+                    "model": self.model,
+                    "messages": [{"role": "user", "content": prompt}],
+                },
+            )
+            response.raise_for_status()
+            return response.json()["choices"][0]["message"]["content"]
+
+    async def health_check(self) -> bool:
+        try:
+            headers = {}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+            async with httpx.AsyncClient(timeout=5.0) as client:
+                response = await client.get(f"{self.base_url}/models", headers=headers)
+                return response.status_code == 200
+        except Exception:
+            return False
+
+
+def get_provider(ai_settings: dict) -> AIProvider:
+    """
+    Factory function to get the appropriate AI provider based on settings.
+
+    Args:
+        ai_settings: The 'ai' section of the settings dict, containing:
+            - provider: str (ollama, openai, anthropic, openai_compatible)
+            - providers: dict with provider-specific settings
+
+    Returns:
+        An AIProvider instance
+    """
+    provider_name = ai_settings.get("provider", "ollama")
+    providers_config = ai_settings.get("providers", {})
+    config = providers_config.get(provider_name, {})
+
+    if provider_name == "ollama":
+        return OllamaProvider(
+            base_url=config.get("baseUrl", "http://localhost:11434"),
+            model=config.get("model", "llama3.2"),
+        )
+    if provider_name == "openai":
+        return OpenAIProvider(
+            api_key=config.get("apiKey", ""),
+            model=config.get("model", "gpt-4o"),
+        )
+    if provider_name == "anthropic":
+        return AnthropicProvider(
+            api_key=config.get("apiKey", ""),
+            model=config.get("model", "claude-sonnet-4-20250514"),
+        )
+    if provider_name == "google":
+        return GoogleAIProvider(
+            api_key=config.get("apiKey", ""),
+            model=config.get("model", "gemini-3-flash-preview"),
+        )
+    if provider_name == "openai_compatible":
+        return OpenAICompatibleProvider(
+            base_url=config.get("baseUrl", ""),
+            api_key=config.get("apiKey", ""),
+            model=config.get("model", "default"),
+        )
+    raise ValueError(f"Unknown AI provider: {provider_name}")

pylumbergh-0.0.2/lumbergh/cli.py

@@ -0,0 +1,23 @@
+"""CLI entry point for Lumbergh."""
+
+import argparse
+
+from lumbergh._version import __version__
+
+
+def run():
+    """Run the Lumbergh server."""
+    parser = argparse.ArgumentParser(description="Lumbergh - AI Session Supervisor")
+    parser.add_argument("--version", action="version", version=f"lumbergh {__version__}")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
+    parser.add_argument("--port", "-p", type=int, default=8420, help="Port to bind to")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload for development")
+    args = parser.parse_args()
+
+    import uvicorn
+
+    uvicorn.run("lumbergh.main:app", host=args.host, port=args.port, reload=args.reload)
+
+
+if __name__ == "__main__":
+    run()

pylumbergh-0.0.2/lumbergh/constants.py

@@ -0,0 +1,51 @@
+"""
+Shared constants for the Lumbergh backend.
+"""
+
+from pathlib import Path
+
+# Configuration directories
+CONFIG_DIR = Path.home() / ".config" / "lumbergh"
+PROJECTS_DIR = CONFIG_DIR / "projects"
+SESSIONS_DATA_DIR = CONFIG_DIR / "session_data"
+SHARED_DIR = CONFIG_DIR / "shared"
+
+# Ensure directories exist
+CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+PROJECTS_DIR.mkdir(parents=True, exist_ok=True)
+SESSIONS_DATA_DIR.mkdir(parents=True, exist_ok=True)
+SHARED_DIR.mkdir(parents=True, exist_ok=True)
+
+# Git status code mapping
+GIT_STATUS_MAP = {
+    "M": "modified",
+    "A": "added",
+    "D": "deleted",
+    "R": "renamed",
+    "C": "copied",
+    "U": "unmerged",
+    "?": "untracked",
+}
+
+# File extension to language mapping for syntax highlighting
+EXT_TO_LANGUAGE = {
+    ".py": "python",
+    ".js": "javascript",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".jsx": "jsx",
+    ".json": "json",
+    ".md": "markdown",
+    ".sh": "bash",
+    ".css": "css",
+    ".html": "html",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+}
+
+# Directories to ignore when listing/searching files
+IGNORE_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", "dist", "build"}
+
+# Additional directories to skip when searching for git repos
+REPO_SEARCH_SKIP_DIRS = IGNORE_DIRS | {".cache", ".tox", ".nox"}