marvisx-cli 0.1.0__py3-none-any.whl

core/api/services/project_paths.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import os
+import time as _t
+from pathlib import Path
+
+# Workspace root: override via MARVIS_WORKSPACE_ROOT, else default to ~/workspace
+# (prod runs as the service user whose HOME holds the workspace, so the default
+# preserves the historical hardcoded path behavior).
+WORKSPACE_ROOT = os.environ.get("MARVIS_WORKSPACE_ROOT", str(Path.home() / "workspace"))
+
+
+def resolve_project_path(project_slug: str | None) -> str:
+    """Resolve a project slug to its repo or metadata path.
+
+    Falls back to the MarvisX workspace when the slug is missing or unknown.
+    Always returns an absolute, expanded path suitable for Claude JSONL lookup.
+    """
+    if not project_slug:
+        return WORKSPACE_ROOT
+
+    from core.api.routers.projects import _INDEX_TTL, _build_project_index, _index_built_at, _project_index
+
+    if _t.monotonic() - _index_built_at > _INDEX_TTL:
+        _build_project_index()
+
+    entry = _project_index.get(project_slug)
+    if entry and entry.repo_path:
+        return os.path.abspath(str(entry.repo_path))
+    if entry:
+        return os.path.abspath(str(entry.metadata_path.resolve()))
+    return WORKSPACE_ROOT
+
+
+def resolve_project_access_paths(project_slug: str | None) -> tuple[str, ...]:
+    """Return repo and metadata paths for a project slug.
+
+    Session launch now happens from the shared workspace for every provider, but
+    selected projects still need to be reachable via provider-specific extra
+    directory flags where supported.
+    """
+    if not project_slug:
+        return ()
+
+    from core.api.routers.projects import _INDEX_TTL, _build_project_index, _index_built_at, _project_index
+
+    if _t.monotonic() - _index_built_at > _INDEX_TTL:
+        _build_project_index()
+
+    entry = _project_index.get(project_slug)
+    if not entry:
+        return ()
+
+    paths: list[str] = []
+    if entry.repo_path:
+        paths.append(os.path.abspath(str(entry.repo_path)))
+
+    metadata_path = os.path.abspath(str(entry.metadata_path.resolve()))
+    if metadata_path not in paths:
+        paths.append(metadata_path)
+
+    return tuple(paths)
+
+
+def candidate_project_paths(project_slug: str | None) -> tuple[str, ...]:
+    """Return the preferred lookup path plus the legacy workspace fallback."""
+    primary = resolve_project_path(project_slug)
+    if primary == WORKSPACE_ROOT:
+        return (primary,)
+    return (primary, WORKSPACE_ROOT)

core/api/services/project_status_updates.py

@@ -0,0 +1,265 @@
+# v1.0.0 - 2026-04-22 - Feed-style status updates for /projects/detail single-pager v2
+"""Project status updates feed (PR #9).
+
+Builds a chronological feed of mixed entries for a project:
+  - Persisted rows from `project_status_updates` (kind = manual | auto_* | ai_*)
+  - Derived on-the-fly entries from recent handoffs + git commits (non-persisted)
+
+The goal is to give /projects/detail a "what happened lately" stream without
+forcing every handoff/commit to be materialized in the DB. Rows are returned
+newest-first, capped at `limit`.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+import aiosqlite
+
+from core.api.models import StatusUpdateFeedItem
+
+logger = logging.getLogger(__name__)
+
+MAX_RECENT_HANDOFFS = 5
+MAX_RECENT_COMMITS = 5
+# Frontmatter/title regex for handoff summaries.
+_FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
+_SUMMARY_KEY_RE = re.compile(r"^summary:\s*(.+?)(?:\n|$)", re.MULTILINE)
+_TITLE_H1_RE = re.compile(r"^#\s+(.+?)$", re.MULTILINE)
+
+
+def _parse_handoff_meta(path: Path) -> tuple[str | None, str]:
+    """Extract (summary, session) from a handoff .md file.
+
+    Returns a brief summary (from `summary:` frontmatter field, first H1, or
+    first non-empty body line) and a session id if any. All I/O is bounded
+    to ~8 KB to stay snappy.
+    """
+    try:
+        content = path.read_text(encoding="utf-8", errors="ignore")[:8192]
+    except Exception as exc:  # noqa: BLE001 — don't blow up the feed on a broken file
+        logger.debug("Failed to read handoff %s: %s", path, exc)
+        return None, ""
+
+    session = ""
+    summary: str | None = None
+
+    fm_match = _FRONTMATTER_RE.match(content)
+    if fm_match:
+        fm_body = fm_match.group(1)
+        sum_match = _SUMMARY_KEY_RE.search(fm_body)
+        if sum_match:
+            summary = sum_match.group(1).strip().strip('"').strip("'")
+        sess_match = re.search(r"^session:\s*(.+?)$", fm_body, re.MULTILINE)
+        if sess_match:
+            session = sess_match.group(1).strip().strip('"').strip("'")
+        after_fm = content[fm_match.end():]
+    else:
+        after_fm = content
+
+    if not summary:
+        h1 = _TITLE_H1_RE.search(after_fm)
+        if h1:
+            summary = h1.group(1).strip()
+
+    if not summary:
+        # Fallback: first non-empty, non-heading line
+        for line in after_fm.splitlines():
+            line = line.strip()
+            if line and not line.startswith("#") and not line.startswith("```"):
+                summary = line[:280]
+                break
+
+    return summary, session
+
+
+def _derive_from_handoffs(slug: str, metadata_path: Path | None) -> list[StatusUpdateFeedItem]:
+    """Scan `{metadata_path}/memory/handoff-*.md` for the 5 most recent files."""
+    if metadata_path is None:
+        return []
+    memory_dir = metadata_path / "memory"
+    if not memory_dir.exists() or not memory_dir.is_dir():
+        return []
+    try:
+        candidates = sorted(
+            memory_dir.glob("handoff-*.md"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )[:MAX_RECENT_HANDOFFS]
+    except OSError as exc:
+        logger.debug("handoff scan failed for %s: %s", slug, exc)
+        return []
+
+    items: list[StatusUpdateFeedItem] = []
+    for path in candidates:
+        summary, session = _parse_handoff_meta(path)
+        try:
+            mtime = datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc)
+        except OSError:
+            continue
+        content_md = summary or f"Handoff: {path.name}"
+        if session:
+            content_md = f"**Sessione {session}** · {content_md}"
+        items.append(
+            StatusUpdateFeedItem(
+                id=f"handoff:{path.name}",
+                kind="auto_handoff",
+                author="handoff",
+                author_display=path.name,
+                content_md=content_md,
+                ref_id=str(path.relative_to(metadata_path) if metadata_path in path.parents else path.name),
+                created_at=mtime.isoformat(),
+                derived=True,
+            )
+        )
+    return items
+
+
+async def _derive_from_commits(slug: str, repo_path: Path | None) -> list[StatusUpdateFeedItem]:
+    """Run `git log -n 5 --format=...` against `repo_path`. Returns empty list when
+    repo_path is None, not a git dir, or git is unavailable."""
+    if repo_path is None or not (repo_path / ".git").exists():
+        return []
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git",
+            "log",
+            f"-n{MAX_RECENT_COMMITS}",
+            "--format=%H%x1f%s%x1f%an%x1f%aI",
+            "--no-merges",
+            cwd=str(repo_path),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        try:
+            stdout_b, _stderr_b = await asyncio.wait_for(proc.communicate(), timeout=3.0)
+        except asyncio.TimeoutError:
+            proc.kill()
+            await proc.wait()
+            return []
+    except FileNotFoundError:
+        return []
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("git log failed for %s at %s: %s", slug, repo_path, exc)
+        return []
+
+    out = stdout_b.decode("utf-8", errors="replace").strip()
+    if not out:
+        return []
+
+    items: list[StatusUpdateFeedItem] = []
+    for line in out.splitlines():
+        parts = line.split("\x1f")
+        if len(parts) != 4:
+            continue
+        sha, subject, author, iso_date = parts
+        items.append(
+            StatusUpdateFeedItem(
+                id=f"commit:{sha[:7]}",
+                kind="auto_commit",
+                author="git",
+                author_display=author or "unknown",
+                content_md=subject.strip() or "(no commit message)",
+                ref_id=sha,
+                created_at=iso_date,
+                derived=True,
+            )
+        )
+    return items
+
+
+def _row_to_feed_item(row: aiosqlite.Row) -> StatusUpdateFeedItem:
+    kind = row["kind"] if "kind" in row.keys() and row["kind"] else "manual"
+    author = row["created_by"]
+    # Prefer stored content_md when present, fall back to composing from the
+    # legacy structured fields (what_done / blockers / next_steps) so rows
+    # created via /api/v1/status-updates still show up in the feed.
+    raw_content = row["content_md"] if "content_md" in row.keys() else None
+    if raw_content:
+        content_md = raw_content
+    else:
+        chunks: list[str] = []
+        if row["status"]:
+            chunks.append(f"**Status:** {row['status']}")
+        if row["what_done"]:
+            chunks.append(f"**Done:** {row['what_done']}")
+        if row["blockers"]:
+            chunks.append(f"**Blockers:** {row['blockers']}")
+        if row["next_steps"]:
+            chunks.append(f"**Next:** {row['next_steps']}")
+        content_md = "\n\n".join(chunks) if chunks else "(empty update)"
+    author_display = row["author_display"] if "author_display" in row.keys() else None
+    ref_id = row["ref_id"] if "ref_id" in row.keys() else None
+    return StatusUpdateFeedItem(
+        id=str(row["id"]),
+        kind=kind,
+        author=author,
+        author_display=author_display,
+        content_md=content_md,
+        ref_id=ref_id,
+        created_at=row["created_at"],
+        derived=False,
+    )
+
+
+async def list_feed(
+    db: aiosqlite.Connection,
+    slug: str,
+    metadata_path: Path | None,
+    repo_path: Path | None,
+    limit: int = 20,
+) -> tuple[list[StatusUpdateFeedItem], int]:
+    """Combine stored updates + derived entries into a chronological feed."""
+    # Persisted rows (cap at limit just in case — typical project has <50)
+    cursor = await db.execute(
+        "SELECT id, project, status, what_done, blockers, next_steps, "
+        "created_by, created_at, updated_at, kind, content_md, ref_id, author_display "
+        "FROM project_status_updates WHERE project = ? ORDER BY created_at DESC LIMIT ?",
+        (slug, limit),
+    )
+    db_rows = [_row_to_feed_item(r) async for r in cursor]
+
+    # Derived entries, concurrent
+    derived_handoffs = _derive_from_handoffs(slug, metadata_path)
+    derived_commits = await _derive_from_commits(slug, repo_path)
+
+    all_items = db_rows + derived_handoffs + derived_commits
+    # Sort newest-first by ISO timestamp (lexicographic sort works for ISO 8601)
+    all_items.sort(key=lambda item: item.created_at, reverse=True)
+
+    total_derived = len(derived_handoffs) + len(derived_commits)
+    return all_items[:limit], len(db_rows) + total_derived
+
+
+async def create_manual_update(
+    db: aiosqlite.Connection,
+    slug: str,
+    content_md: str,
+    author: str,
+    author_display: str | None,
+) -> StatusUpdateFeedItem:
+    """Insert a manual feed entry. Callers must have already enforced RBAC."""
+    now = datetime.now(timezone.utc).isoformat()
+    # Legacy `status` column is NOT NULL, pick 'active' as a neutral default for
+    # feed-mode entries (UI surfaces the kind/author, not the status badge).
+    cursor = await db.execute(
+        "INSERT INTO project_status_updates "
+        "(project, status, kind, content_md, created_by, author_display, created_at) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?)",
+        (slug, "active", "manual", content_md, author, author_display, now),
+    )
+    await db.commit()
+    new_id = cursor.lastrowid
+    return StatusUpdateFeedItem(
+        id=str(new_id),
+        kind="manual",
+        author=author,
+        author_display=author_display,
+        content_md=content_md,
+        ref_id=None,
+        created_at=now,
+        derived=False,
+    )

core/api/services/providers.py

@@ -0,0 +1,276 @@
+# v1.4.0 - 2026-04-02 - Add model-aware launch commands and OpenCode runtime overrides
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shlex
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from core.api.config import settings
+
+ProviderName = Literal["claude", "gemini", "codex", "opencode"]
+
+
+@dataclass(frozen=True, slots=True)
+class KeystrokeStep:
+    key: str
+    delay_after: float = 0.3
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderConfig:
+    name: str
+    binary: str
+    cli_flags: str
+    process_names: tuple[str, ...]
+    exit_sequence: tuple[KeystrokeStep, ...]
+    submit_with_double_enter: bool = False
+    source_bashrc: bool = False
+    launcher_path: str | None = None
+
+
+_API_ROOT = Path(__file__).resolve().parents[1]
+_OPENCODE_LAUNCHER = str(_API_ROOT / "bin" / "opencode-launch.sh")
+_OPENCODE_TUI_CONFIGS = {
+    "dark": str(_API_ROOT / "opencode-runtime" / "tui.dark.json"),
+    "light": str(_API_ROOT / "opencode-runtime" / "tui.light.json"),
+}
+
+
+PROVIDERS: dict[str, ProviderConfig] = {
+    "claude": ProviderConfig(
+        name="Claude Code",
+        binary="claude",
+        cli_flags="--dangerously-skip-permissions",
+        process_names=("claude", "node"),
+        exit_sequence=(
+            KeystrokeStep("C-c", 1.0),
+            KeystrokeStep("C-u", 0.3),
+            KeystrokeStep("/exit", 0.5),
+            KeystrokeStep("Escape", 0.3),
+            KeystrokeStep("Enter", 2.0),
+        ),
+        submit_with_double_enter=True,
+    ),
+    "gemini": ProviderConfig(
+        name="Gemini CLI",
+        binary="gemini",
+        cli_flags="--yolo",
+        process_names=("gemini",),
+        exit_sequence=(
+            KeystrokeStep("C-c", 0.5),
+            KeystrokeStep("/exit", 1.0),
+            KeystrokeStep("Enter", 1.0),
+        ),
+    ),
+    "codex": ProviderConfig(
+        name="Codex CLI",
+        binary="codex",
+        cli_flags="--dangerously-bypass-approvals-and-sandbox",
+        process_names=("codex", "node"),
+        exit_sequence=(
+            KeystrokeStep("C-c", 0.5),
+            KeystrokeStep("/exit", 1.0),
+            KeystrokeStep("Enter", 1.0),
+        ),
+    ),
+    "opencode": ProviderConfig(
+        name="OpenCode",
+        binary="opencode",
+        cli_flags="",
+        process_names=("opencode", "node"),
+        exit_sequence=(
+            KeystrokeStep("C-c", 0.5),
+            KeystrokeStep("/exit", 0.5),
+            KeystrokeStep("Enter", 1.0),
+        ),
+        submit_with_double_enter=True,
+        launcher_path=_OPENCODE_LAUNCHER,
+    ),
+}
+
+# All known process names across all providers (for quick status checks in list endpoints)
+ALL_KNOWN_PROCESS_NAMES = tuple(
+    sorted({pn for cfg in PROVIDERS.values() for pn in cfg.process_names})
+)
+
+def _runtime_home() -> str:
+    return settings.effective_runtime_home
+
+
+def _runtime_bashrc() -> str:
+    return os.path.join(_runtime_home(), ".bashrc")
+
+
+def _runtime_path_prefix() -> str:
+    home = _runtime_home()
+    return ":".join(
+        (
+            os.path.join(home, ".local", "bin"),
+            os.path.join(home, "bin"),
+            os.path.join(home, ".npm-global", "bin"),
+            os.path.join(home, ".opencode", "bin"),
+        )
+    )
+
+
+def _opencode_state_root() -> str:
+    return os.path.join(
+        _runtime_home(), ".local", "state", "opencode-marvisx-console"
+    )
+
+
+def _provider_invocation(config: ProviderConfig) -> str:
+    return " ".join(part for part in (config.binary, config.cli_flags) if part)
+
+
+def get_provider(name: str | None) -> ProviderConfig:
+    """Get provider config. None defaults to Claude (backward compat).
+    Raises ValueError for unknown provider names."""
+    if name is None:
+        return PROVIDERS["claude"]
+    try:
+        return PROVIDERS[name]
+    except KeyError:
+        raise ValueError(
+            f"Unknown provider: {name!r}. Available: {', '.join(PROVIDERS)}"
+        )
+
+
+def _model_flag(config: ProviderConfig, model: str | None) -> str:
+    if not model:
+        return ""
+    if config.binary == "codex":
+        return f"-m {shlex.quote(model)}"
+    return f"--model {shlex.quote(model)}"
+
+
+def _opencode_invocation(
+    config: ProviderConfig,
+    safe_dir: str,
+    model: str | None,
+    opencode_config: dict[str, object] | None,
+    opencode_tui_config: str | None = None,
+    opencode_state_dir: str | None = None,
+    extra_cli_args: tuple[str, ...] | None = None,
+) -> str:
+    parts: list[str] = []
+    if opencode_config:
+        config_json = json.dumps(opencode_config, separators=(",", ":"))
+        parts.append(f"OPENCODE_CONFIG_CONTENT={shlex.quote(config_json)}")
+    if opencode_tui_config:
+        parts.append(f"OPENCODE_TUI_CONFIG={shlex.quote(opencode_tui_config)}")
+    if opencode_state_dir:
+        parts.append(f"OPENCODE_STATE_DIR={shlex.quote(opencode_state_dir)}")
+    parts.append(shlex.quote(config.launcher_path or config.binary))
+    parts.append(safe_dir)
+    model_flag = _model_flag(config, model)
+    if model_flag:
+        parts.append(model_flag)
+    if extra_cli_args:
+        parts.extend(extra_cli_args)
+    return " ".join(parts)
+
+
+def _codex_invocation(
+    config: ProviderConfig,
+    safe_dir: str,
+    model: str | None,
+    extra_cli_args: tuple[str, ...] | None = None,
+) -> str:
+    parts = [config.binary]
+    if config.cli_flags:
+        parts.append(config.cli_flags)
+    model_flag = _model_flag(config, model)
+    if model_flag:
+        parts.append(model_flag)
+    if extra_cli_args:
+        parts.extend(extra_cli_args)
+    parts.append(f"-C {safe_dir}")
+    return " ".join(parts)
+
+
+def _direct_invocation(
+    config: ProviderConfig,
+    model: str | None,
+    extra_cli_args: tuple[str, ...] | None = None,
+) -> str:
+    parts = [config.binary]
+    if config.cli_flags:
+        parts.append(config.cli_flags)
+    model_flag = _model_flag(config, model)
+    if model_flag:
+        parts.append(model_flag)
+    if extra_cli_args:
+        parts.extend(extra_cli_args)
+    return " ".join(parts)
+
+
+def build_start_command(
+    config: ProviderConfig,
+    directory: str,
+    *,
+    model: str | None = None,
+    opencode_config: dict[str, object] | None = None,
+    opencode_theme_mode: Literal["light", "dark"] | None = None,
+    session_name: str | None = None,
+    extra_cli_args: tuple[str, ...] | None = None,
+) -> str:
+    """Build shell command to start CLI in given directory.
+
+    The systemd API service and tmux sessions do not always preserve the interactive
+    shell environment. Force HOME/PATH so provider CLIs can find their auth/config.
+    """
+    expanded = os.path.expanduser(directory)
+    safe_dir = shlex.quote(expanded)
+    env_prefix = (
+        f"export HOME={shlex.quote(_runtime_home())} "
+        f"XDG_CONFIG_HOME={shlex.quote(os.path.join(_runtime_home(), '.config'))} "
+        f"PATH={shlex.quote(_runtime_path_prefix())}:$PATH"
+    )
+    if config.launcher_path:
+        invocation = _opencode_invocation(
+            config,
+            safe_dir,
+            model,
+            opencode_config,
+            opencode_tui_config=_OPENCODE_TUI_CONFIGS.get(opencode_theme_mode)
+            if opencode_theme_mode
+            else None,
+            opencode_state_dir=os.path.join(_opencode_state_root(), session_name)
+            if session_name
+            else None,
+            extra_cli_args=extra_cli_args,
+        )
+        return f"{env_prefix} && {invocation}"
+    if config.binary == "codex":
+        invocation = _codex_invocation(
+            config, safe_dir, model, extra_cli_args=extra_cli_args
+        )
+        return f"{env_prefix} && {invocation}"
+    invocation = _direct_invocation(config, model, extra_cli_args=extra_cli_args)
+    if config.source_bashrc:
+        shell_bootstrap = shlex.quote(
+            f"source {shlex.quote(_runtime_bashrc())} >/dev/null 2>&1; "
+            f"cd {safe_dir} && {invocation}"
+        )
+        return f"{env_prefix} && bash -ic {shell_bootstrap}"
+    return f"{env_prefix} && cd {safe_dir} && {invocation}"
+
+
+async def is_binary_available(config: ProviderConfig) -> bool:
+    """Check if the provider's CLI binary is installed and in PATH."""
+    env = os.environ.copy()
+    env["PATH"] = f"{_runtime_path_prefix()}:{env.get('PATH', '')}"
+    proc = await asyncio.create_subprocess_exec(
+        "which",
+        config.binary,
+        env=env,
+        stdout=asyncio.subprocess.DEVNULL,
+        stderr=asyncio.subprocess.DEVNULL,
+    )
+    await proc.communicate()
+    return proc.returncode == 0