projectmemory-cli 0.1.0__py3-none-any.whl

projectmemory_cli/git.py

@@ -0,0 +1,124 @@
+"""Local Git repository helpers.
+
+Reads local git state using subprocess — no GitHub API calls.
+"""
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import NamedTuple
+
+
+class GitCommit(NamedTuple):
+    sha: str
+    short_sha: str
+    message: str
+    author: str
+    date: str
+
+
+def _run(*args: str, cwd: Path | None = None) -> str:
+    """Run a git command and return stdout, or '' on error."""
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            capture_output=True,
+            text=True,
+            cwd=cwd,
+            timeout=5,
+        )
+        return result.stdout.strip() if result.returncode == 0 else ""
+    except Exception:
+        return ""
+
+
+def is_git_repo(path: Path | None = None) -> bool:
+    return bool(_run("rev-parse", "--git-dir", cwd=path))
+
+
+def get_repo_root(path: Path | None = None) -> Path | None:
+    root = _run("rev-parse", "--show-toplevel", cwd=path)
+    return Path(root) if root else None
+
+
+def get_remote_url(path: Path | None = None, remote: str = "origin") -> str:
+    """Return the remote URL for the given remote name."""
+    return _run("remote", "get-url", remote, cwd=path)
+
+
+def normalize_github_repo(url: str) -> str:
+    """Extract 'owner/repo' from a GitHub remote URL."""
+    url = url.strip()
+    if not url:
+        return ""
+    # Strip .git suffix
+    if url.endswith(".git"):
+        url = url[:-4]
+    # SSH: git@github.com:owner/repo
+    if "github.com:" in url:
+        return url.split("github.com:", 1)[1].lower().strip("/")
+    # HTTPS: https://github.com/owner/repo
+    if "github.com" in url:
+        parts = url.split("github.com/", 1)
+        if len(parts) > 1:
+            return "/".join(parts[1].strip("/").split("/")[:2]).lower()
+    return ""
+
+
+def get_github_repo_name(path: Path | None = None) -> str:
+    """Return 'owner/repo' if the local remote is a GitHub repo, else ''."""
+    url = get_remote_url(path)
+    return normalize_github_repo(url)
+
+
+def get_recent_commits(path: Path | None = None, limit: int = 10) -> list[GitCommit]:
+    """Return the most recent local commits."""
+    fmt = "%H|||%h|||%s|||%an|||%ci"
+    output = _run("log", f"--pretty=format:{fmt}", f"-{limit}", cwd=path)
+    commits = []
+    for line in output.splitlines():
+        parts = line.split("|||", 4)
+        if len(parts) == 5:
+            commits.append(GitCommit(
+                sha=parts[0],
+                short_sha=parts[1],
+                message=parts[2],
+                author=parts[3],
+                date=parts[4],
+            ))
+    return commits
+
+
+def get_head_sha(path: Path | None = None) -> str:
+    return _run("rev-parse", "HEAD", cwd=path)
+
+
+def resolve_sha(ref: str, path: Path | None = None) -> str:
+    """Resolve a ref (HEAD, sha, branch) to a full SHA."""
+    return _run("rev-parse", ref, cwd=path)
+
+
+def get_commit_info(sha: str, path: Path | None = None) -> GitCommit | None:
+    """Get info for a specific commit SHA."""
+    fmt = "%H|||%h|||%s|||%an|||%ci"
+    output = _run("show", "-s", f"--pretty=format:{fmt}", sha, cwd=path)
+    if not output:
+        return None
+    parts = output.splitlines()[0].split("|||", 4)
+    if len(parts) == 5:
+        return GitCommit(
+            sha=parts[0],
+            short_sha=parts[1],
+            message=parts[2],
+            author=parts[3],
+            date=parts[4],
+        )
+    return None
+
+
+def get_current_branch(path: Path | None = None) -> str:
+    return _run("branch", "--show-current", cwd=path) or _run("rev-parse", "--abbrev-ref", "HEAD", cwd=path)
+
+
+def get_short_head_sha(path: Path | None = None) -> str:
+    return _run("rev-parse", "--short", "HEAD", cwd=path)

projectmemory_cli/main.py

@@ -0,0 +1,4 @@
+"""CLI entry point — registers all command groups on the Typer app."""
+from projectmemory_cli.app import app  # noqa: F401 — re-export for entry point
+
+__all__ = ["app"]

projectmemory_cli/models/__init__.py

@@ -0,0 +1 @@
+"""Pydantic models for API responses."""

projectmemory_cli/models/api.py

@@ -0,0 +1,226 @@
+"""Pydantic models for all API response shapes."""
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Optional
+
+from pydantic import BaseModel, field_validator
+
+
+# ---------------------------------------------------------------------------
+# Auth
+# ---------------------------------------------------------------------------
+
+class UserInfo(BaseModel):
+    id: int
+    email: str
+    name: str = ""
+    plan: str = "free"
+    email_verified: bool = True
+    email_verification_required: bool = False
+    limits: dict[str, Any] = {}
+    usage: dict[str, Any] = {}
+
+
+# ---------------------------------------------------------------------------
+# Sessions
+# ---------------------------------------------------------------------------
+
+class ActiveSession(BaseModel):
+    id: int
+    project: int
+    project_name: str = ""
+    started_at: str
+    updated_at: str
+    duration_seconds: int = 0
+    source: str = "cli"
+
+
+class SessionInfo(BaseModel):
+    id: int
+    project: int
+    project_name: str = ""
+    started_at: str
+    ended_at: Optional[str] = None
+    finalized_at: Optional[str] = None
+    is_active: bool
+    session_date: str
+    progress: str = ""
+    note: str = ""
+    duration_minutes: Optional[int] = None
+    mood: str = ""
+    source: str = "web"
+
+
+# ---------------------------------------------------------------------------
+# Memory
+# ---------------------------------------------------------------------------
+
+class NextActionLinkedSource(BaseModel):
+    type: str  # "task" | "issue"
+    id: int
+    title: str
+    status: str
+
+
+class NextAction(BaseModel):
+    title: str = ""
+    description: str = ""
+    source_type: str = "manual"
+    linked_source: Optional[NextActionLinkedSource] = None
+
+
+class MemoryField(BaseModel):
+    title: str = ""
+    description: str = ""
+
+
+class Memory(BaseModel):
+    next_action: NextAction = NextAction()
+    current_status: MemoryField = MemoryField()
+    important_context: MemoryField = MemoryField()
+
+
+# ---------------------------------------------------------------------------
+# GitHub
+# ---------------------------------------------------------------------------
+
+class GitHubRepo(BaseModel):
+    id: int
+    owner: str
+    name: str
+    full_name: str
+    private: bool = False
+    default_branch: str = "main"
+
+
+class GitHubInfo(BaseModel):
+    connected: bool = False
+    repository: Optional[GitHubRepo] = None
+    last_synced_at: Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# Projects
+# ---------------------------------------------------------------------------
+
+class ProjectCounts(BaseModel):
+    open_tasks: int = 0
+    completed_tasks: int = 0
+    snoozed_tasks: int = 0
+    open_issues: int = 0
+    resolved_issues: int = 0
+    notes: int = 0
+    sessions: int = 0
+
+
+class ProjectSummary(BaseModel):
+    id: int
+    name: str
+    description: str = ""
+    status: str = "active"
+    is_starred: bool = False
+    created_at: str
+    updated_at: str
+    last_updated_at: Optional[str] = None
+    last_memory_updated_at: Optional[str] = None
+    web_url: str = ""
+    active_session: Optional[ActiveSession] = None
+    has_active_session: bool = False
+    next_action: NextAction = NextAction()
+    github: GitHubInfo = GitHubInfo()
+    counts: ProjectCounts = ProjectCounts()
+
+    @field_validator("counts", mode="before")
+    @classmethod
+    def coerce_counts(cls, v: Any) -> Any:
+        if isinstance(v, dict):
+            return v
+        return {}
+
+
+class ProjectContext(BaseModel):
+    project: ProjectSummary
+    memory: Memory
+    open_tasks: list[dict[str, Any]] = []
+    open_issues: list[dict[str, Any]] = []
+    latest_session: Optional[dict[str, Any]] = None
+    active_session: Optional[ActiveSession] = None
+    github: GitHubInfo = GitHubInfo()
+    counts: ProjectCounts = ProjectCounts()
+
+    @field_validator("counts", mode="before")
+    @classmethod
+    def coerce_counts(cls, v: Any) -> Any:
+        if isinstance(v, dict):
+            return v
+        return {}
+
+
+# ---------------------------------------------------------------------------
+# Tasks
+# ---------------------------------------------------------------------------
+
+class Task(BaseModel):
+    id: int
+    project: int
+    project_name: str = ""
+    title: str
+    description: str = ""
+    priority: str = "medium"
+    due_date: Optional[str] = None
+    is_completed: bool = False
+    is_snoozed: bool = False
+    snoozed_until: Optional[str] = None
+    snoozed_is_someday: bool = False
+    is_next_action: bool = False
+    created_at: str
+    updated_at: str
+    completed_at: Optional[str] = None
+    has_linked_commits: bool = False
+    linked_commit_count: int = 0
+    github_issue: Optional[dict[str, Any]] = None
+    github_commits: list[dict[str, Any]] = []
+
+
+class TaskCounts(BaseModel):
+    open: int = 0
+    completed: int = 0
+    snoozed: int = 0
+    total: int = 0
+
+
+# ---------------------------------------------------------------------------
+# Notes
+# ---------------------------------------------------------------------------
+
+class Note(BaseModel):
+    id: int
+    project: int
+    project_name: str = ""
+    title: str = ""
+    content: str
+    created_at: str
+    updated_at: str
+
+
+# ---------------------------------------------------------------------------
+# Issues
+# ---------------------------------------------------------------------------
+
+class Issue(BaseModel):
+    id: int
+    description: str
+    is_resolved: bool = False
+    resolution_notes: str = ""
+    is_next_action: bool = False
+    created_at: str
+    updated_at: str
+    resolved_at: Optional[str] = None
+    github_issue: Optional[dict[str, Any]] = None
+
+
+class IssueCounts(BaseModel):
+    open: int = 0
+    resolved: int = 0
+    total: int = 0

projectmemory_cli/output.py

@@ -0,0 +1,227 @@
+"""Rich-based terminal output helpers.
+
+Supports --json, --plain, --quiet, --no-color, --debug modes.
+Automatically disables decorative formatting when output is piped.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich import box
+
+# Module-level console — colour disabled if not a tty or NO_COLOR is set
+_is_tty = sys.stdout.isatty()
+
+console = Console(
+    highlight=False,
+    markup=True,
+    emoji=True,
+)
+err_console = Console(stderr=True, highlight=False)
+
+# Runtime flags (set by command callbacks)
+_json_mode: bool = False
+_plain_mode: bool = False
+_quiet_mode: bool = False
+_debug_mode: bool = False
+
+
+def configure(*, json_mode: bool | None = None, plain_mode: bool | None = None,
+              quiet_mode: bool | None = None, debug_mode: bool | None = None,
+              no_color: bool | None = None) -> None:
+    global _json_mode, _plain_mode, _quiet_mode, _debug_mode
+    if json_mode is not None:
+        _json_mode = json_mode
+    if plain_mode is not None:
+        _plain_mode = plain_mode
+    if quiet_mode is not None:
+        _quiet_mode = quiet_mode
+    if debug_mode is not None:
+        _debug_mode = debug_mode
+    if no_color is True or not _is_tty:
+        console._markup = False  # type: ignore[attr-defined]
+
+
+# ---------------------------------------------------------------------------
+# Print helpers
+# ---------------------------------------------------------------------------
+
+def print_json(data: Any) -> None:
+    console.print_json(json.dumps(data, default=str))
+
+
+def info(msg: str) -> None:
+    if not _quiet_mode:
+        if _plain_mode:
+            print(msg)
+        else:
+            console.print(msg)
+
+
+def success(msg: str) -> None:
+    if _plain_mode:
+        print(msg)
+    else:
+        console.print(f"[bold green]✓[/bold green] {msg}")
+
+
+def warn(msg: str) -> None:
+    if _plain_mode:
+        print(f"WARNING: {msg}", file=sys.stderr)
+    else:
+        err_console.print(f"[bold yellow]⚠[/bold yellow]  {msg}")
+
+
+def error(msg: str) -> None:
+    if _plain_mode:
+        print(f"Error: {msg}", file=sys.stderr)
+    else:
+        err_console.print(f"[bold red]✗[/bold red]  {msg}")
+
+
+def hint(msg: str) -> None:
+    if not _quiet_mode:
+        if _plain_mode:
+            print(f"  {msg}")
+        else:
+            console.print(f"[dim]  {msg}[/dim]")
+
+
+def blank() -> None:
+    if not _quiet_mode:
+        console.print()
+
+
+def rule(title: str = "") -> None:
+    if not _quiet_mode and not _plain_mode:
+        console.rule(title, style="dim")
+
+
+def header(title: str) -> None:
+    if _quiet_mode:
+        return
+    if _plain_mode:
+        print(f"\n{title.upper()}")
+        print("-" * len(title))
+    else:
+        console.print(f"\n[bold cyan]{title.upper()}[/bold cyan]")
+
+
+def panel(title: str, content: str, style: str = "cyan") -> None:
+    if _plain_mode:
+        print(f"\n{title.upper()}\n{content}")
+    else:
+        console.print(Panel(content, title=f"[bold]{title}[/bold]", border_style=style, expand=False))
+
+
+def project_banner(name: str) -> None:
+    if _quiet_mode:
+        return
+    if _plain_mode:
+        print(f"\nPROJECT: {name.upper()}\n")
+    else:
+        console.print(
+            Panel(
+                f"[bold white]{name.upper()}[/bold white]",
+                border_style="bright_cyan",
+                expand=False,
+                padding=(0, 2),
+            )
+        )
+
+
+def kv(label: str, value: str, label_style: str = "dim") -> None:
+    if not _quiet_mode:
+        if _plain_mode:
+            print(f"{label}: {value}")
+        else:
+            console.print(f"[{label_style}]{label}:[/{label_style}] {value}")
+
+
+def section(title: str, items: list[str], empty_msg: str = "(none)") -> None:
+    if _quiet_mode:
+        return
+    header(title)
+    if not items:
+        hint(empty_msg)
+    else:
+        for item in items:
+            if _plain_mode:
+                print(f"  {item}")
+            else:
+                console.print(f"  {item}")
+
+
+def table(headers: list[str], rows: list[list[str]], title: str = "") -> None:
+    if _plain_mode:
+        if title:
+            print(f"\n{title}")
+        print("  ".join(headers))
+        for row in rows:
+            print("  ".join(str(c) for c in row))
+        return
+    t = Table(
+        title=title or None,
+        box=box.SIMPLE_HEAD,
+        show_header=True,
+        header_style="bold cyan",
+        border_style="dim",
+    )
+    for h in headers:
+        t.add_column(h)
+    for row in rows:
+        t.add_row(*[str(c) for c in row])
+    console.print(t)
+
+
+def debug(msg: str) -> None:
+    if _debug_mode:
+        err_console.print(f"[dim magenta][DEBUG][/dim magenta] {msg}")
+
+
+# ---------------------------------------------------------------------------
+# Duration formatting
+# ---------------------------------------------------------------------------
+
+def format_duration(seconds: int) -> str:
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes = seconds // 60
+    if minutes < 60:
+        return f"{minutes}m"
+    hours = minutes // 60
+    mins = minutes % 60
+    if mins:
+        return f"{hours}h {mins}m"
+    return f"{hours}h"
+
+
+def format_ago(dt_str: str | None) -> str:
+    """Convert ISO datetime string to 'Xh Ym ago' text."""
+    if not dt_str:
+        return "unknown"
+    try:
+        from datetime import datetime, timezone
+        dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
+        diff = datetime.now(timezone.utc) - dt
+        secs = int(diff.total_seconds())
+        if secs < 60:
+            return "just now"
+        if secs < 3600:
+            return f"{secs // 60}m ago"
+        if secs < 86400:
+            h = secs // 3600
+            m = (secs % 3600) // 60
+            return f"{h}h {m}m ago" if m else f"{h}h ago"
+        days = secs // 86400
+        if days == 1:
+            return "yesterday"
+        return f"{days} days ago"
+    except Exception:
+        return dt_str or "unknown"