raise-cli 3.0.0a1__tar.gz → 3.0.0a2__tar.gz

{raise_cli-3.0.0a1 → raise_cli-3.0.0a2}/.gitignore

@@ -6,7 +6,6 @@
 
 # Claude Code local settings (user-specific)
 .claude/settings.local.json
-CLAUDE.local.md
 .claude/worktrees/
 .claude/projects/
 
@@ -24,7 +23,7 @@ daemon.yaml
 .raise/cache/
 .raise/confluence-pages.yaml
 .raise/backlog/
-.raise/artifacts/
+# .raise/artifacts/ — tracked (story-design YAMLs are versioned artifacts)
 
 # Pipeline state (environment-specific, PAT-E-594)
 .rai-state/
@@ -46,6 +45,10 @@ dev/output/
 # RaiSE sync state (per-instance JIRA mappings, not shared)
 .raise/rai/sync/
 
+# Per-session env context written by Rai skills, read by CC hooks + MCP tool
+# Namespaced by CC session_id (RAISE-1982) — isolates concurrent CC sessions.
+.raise/rai/sessions/
+
 # Temporary files
 req.txt
 *.tmp
@@ -141,3 +144,20 @@ dev/transcripts/
 # Prevent symlink artifacts from being tracked at root
 /es/
 work/research/
+
+# Ephemeral debug artifacts (Playwright MCP snapshots, root-level screenshots)
+.playwright-mcp/
+.claude/scheduled_tasks.lock
+/issue-*.png
+/panel-*.png
+/s7-*.png
+/app-actions-menu.yml
+/issue-layout.yml
+/layout-editor.yml
+/menu-open.yml
+/raise-*.yml
+
+# Per-developer docker compose override (e.g., expose postgres:5432 for e2e).
+# See dev/sops/raise-server-local.md § Running e2e tests locally.
+/docker-compose.override.yaml
+/docker-compose.override.yml

{raise_cli-3.0.0a1 → raise_cli-3.0.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raise-cli
-Version: 3.0.0a1
+Version: 3.0.0a2
 Summary: RaiSE CLI - Reliable AI Software Engineering governance framework
 Project-URL: Homepage, https://raiseframework.ai
 Project-URL: Documentation, https://docs.raiseframework.ai
@@ -20,12 +20,13 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: logfire-api>=4.0
+Requires-Dist: mcp<2,>=1.26
 Requires-Dist: networkx>=3.6.1
 Requires-Dist: pydantic-settings>=2.2.0
 Requires-Dist: pydantic>=2.6.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml>=6.0.1
-Requires-Dist: raise-core
+Requires-Dist: raise-core>=3.0.0a2
 Requires-Dist: rich>=13.7.0
 Requires-Dist: tree-sitter-javascript>=0.25.0
 Requires-Dist: tree-sitter-language-pack>=0.13.0
@@ -38,12 +39,11 @@ Provides-Extra: atlassian
 Requires-Dist: atlassian-python-api>=3.41.0; extra == 'atlassian'
 Provides-Extra: confluence
 Requires-Dist: atlassian-python-api>=3.41.0; extra == 'confluence'
+Requires-Dist: markdown>=3.6; extra == 'confluence'
 Provides-Extra: csharp
 Requires-Dist: tree-sitter-c-sharp>=0.23.1; extra == 'csharp'
 Provides-Extra: jira
 Requires-Dist: atlassian-python-api>=3.41.0; extra == 'jira'
-Provides-Extra: mcp
-Requires-Dist: mcp<2,>=1.26; extra == 'mcp'
 Provides-Extra: observability
 Requires-Dist: logfire>=4.0; extra == 'observability'
 Requires-Dist: opentelemetry-api>=1.20; extra == 'observability'
@@ -76,11 +76,8 @@ Optional integrations:
 # Jira + Confluence adapters
 pip install "raise-cli[jira,confluence]"
 
-# MCP server support
-pip install "raise-cli[mcp]"
-
 # All extras
-pip install "raise-cli[jira,confluence,mcp,csharp,observability]"
+pip install "raise-cli[jira,confluence,csharp,observability]"
 ```
 
 Requires Python 3.12 or 3.13.

{raise_cli-3.0.0a1 → raise_cli-3.0.0a2}/README.md

@@ -24,11 +24,8 @@ Optional integrations:
 # Jira + Confluence adapters
 pip install "raise-cli[jira,confluence]"
 
-# MCP server support
-pip install "raise-cli[mcp]"
-
 # All extras
-pip install "raise-cli[jira,confluence,mcp,csharp,observability]"
+pip install "raise-cli[jira,confluence,csharp,observability]"
 ```
 
 Requires Python 3.12 or 3.13.

{raise_cli-3.0.0a1 → raise_cli-3.0.0a2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "raise-cli"
-version = "3.0.0a1"
+version = "3.0.0a2"
 description = "RaiSE CLI - Reliable AI Software Engineering governance framework"
 authors = [
     {name = "Emilio Osorio", email = "emilio@humansys.ai"}
@@ -21,7 +21,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "raise-core",
+    "raise-core>=3.0.0a2",
     "typer>=0.12.0",
     "rich>=13.7.0",
     "pydantic>=2.6.0",
@@ -37,12 +37,10 @@ dependencies = [
     "tree-sitter-language-pack>=0.13.0",
     "logfire-api>=4.0",
     "httpx>=0.27.0",
+    "mcp>=1.26,<2",
 ]
 
 [project.optional-dependencies]
-mcp = [
-    "mcp>=1.26,<2",
-]
 observability = [
     "logfire>=4.0",
     "opentelemetry-api>=1.20",
@@ -56,6 +54,7 @@ atlassian = [
 ]
 confluence = [
     "atlassian-python-api>=3.41.0",
+    "markdown>=3.6",
 ]
 jira = [
     "atlassian-python-api>=3.41.0",
@@ -84,7 +83,7 @@ glossary = "raise_cli.governance.parsers.glossary:GlossaryParser"
 [project.entry-points."rai.hooks"]
 telemetry = "raise_cli.hooks.builtin.telemetry:TelemetryHook"
 gate-bridge = "raise_cli.hooks.builtin.gate_bridge:GateBridgeHook"
-memory-sync = "raise_cli.hooks.builtin.memory:MemoryMdSyncHook"
+work-events = "raise_cli.work_events.emitter:ServerEmitHook"
 
 [project.entry-points."rai.gates"]
 tests = "raise_cli.gates.builtin.tests:TestGate"

raise_cli-3.0.0a2/src/raise_cli/_cc_session.py

@@ -0,0 +1,30 @@
+"""Discover CC session_id via CLAUDE_CODE_SSE_PORT matching (RAISE-1986)."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+_SESSIONS_DIR = Path(".raise") / "rai" / "sessions"
+
+
+def discover_cc_session_id() -> str | None:
+    """Match $CLAUDE_CODE_SSE_PORT to a session dir's cc.port file.
+
+    Works from any subprocess spawned by CC (MCP server, CLI, skill bash)
+    because CC exports CLAUDE_CODE_SSE_PORT to every subprocess it spawns,
+    while vars written to $CLAUDE_ENV_FILE remain shell-local.
+    """
+    port = os.environ.get("CLAUDE_CODE_SSE_PORT", "").strip()
+    if not port:
+        return None
+    sessions_dir = Path.cwd() / _SESSIONS_DIR
+    if not sessions_dir.exists():
+        return None
+    for sess_dir in sessions_dir.iterdir():
+        if not sess_dir.is_dir():
+            continue
+        port_file = sess_dir / "cc.port"
+        if port_file.exists() and port_file.read_text().strip() == port:
+            return sess_dir.name
+    return None

raise_cli-3.0.0a2/src/raise_cli/adapters/composite_docs.py

@@ -0,0 +1,180 @@
+"""Composite documentation target — delegates to multiple targets.
+
+Publishes to ALL targets (e.g. filesystem + Confluence). Reads (get_page,
+search, health) delegate to the remote target (last in list — typically Confluence).
+
+Filesystem is first for durability: local copy always saved.
+Result prefers last successful publish (remote URL over local path).
+If remote fails, returns success with warning (local copy is the guarantee).
+
+S1700.6 — Retrofit with PendingOpsLog:
+- On remote failure with filesystem success, append pending op (queue for replay).
+- Before each publish, attempt best-effort flush of existing pending ops.
+- `pending_ops=None` preserves pre-S1700.6 behavior (backward compat).
+
+RAISE-1051 (S1051.7) | RAISE-1795 (S1700.6)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from raise_cli.adapters.models.docs import PageContent, PageSummary, PublishResult
+from raise_cli.adapters.models.health import AdapterHealth
+from raise_cli.adapters.pending_ops import PendingOpsLog
+
+logger = logging.getLogger(__name__)
+
+
+class CompositeDocTarget:
+    """Delegates to multiple DocumentationTargets.
+
+    - publish: calls all targets; returns last successful result (remote preferred)
+    - get_page / search / health: delegate to remote (last) target
+    - Filesystem first for durability, Confluence last for the URL
+    - Optional pending_ops queues failed remote publishes for later replay (S1700.6)
+    """
+
+    def __init__(
+        self,
+        targets: list[Any],
+        pending_ops: PendingOpsLog | None = None,
+    ) -> None:
+        self._targets = targets
+        self._remote = targets[-1]  # last target = remote (Confluence)
+        self._pending_ops = pending_ops
+
+    def can_publish(self, doc_type: str, metadata: dict[str, Any]) -> bool:
+        """True if any wrapped target can publish."""
+        return any(t.can_publish(doc_type, metadata) for t in self._targets)
+
+    def publish(
+        self, doc_type: str, content: str, metadata: dict[str, Any]
+    ) -> PublishResult:
+        """Publish to all accepting targets. Return best result.
+
+        Prefers last successful result (remote URL). If remote fails but
+        local succeeded, returns success with sync-pending warning.
+
+        When `pending_ops` is configured (S1700.6):
+        - Before publishing, attempt best-effort flush of queued ops.
+        - On remote failure with filesystem success, append a pending op.
+        """
+        # S1700.6: best-effort flush of pending ops (non-blocking)
+        self._flush_pending()
+
+        results, failures, fs_result, remote_failed = self._publish_to_targets(
+            doc_type, content, metadata
+        )
+
+        # S1700.6: queue pending op when filesystem (canonical) succeeded but remote failed
+        if (
+            self._pending_ops is not None
+            and remote_failed
+            and fs_result is not None
+            and fs_result.success
+        ):
+            self._pending_ops.append(
+                op="publish",
+                key=str(metadata.get("key") or metadata.get("title") or doc_type),
+                args={"doc_type": doc_type, "content": content, "metadata": metadata},
+            )
+
+        return self._reduce_results(results, failures)
+
+    def _publish_to_targets(
+        self, doc_type: str, content: str, metadata: dict[str, Any]
+    ) -> tuple[list[PublishResult], list[str], PublishResult | None, bool]:
+        """Publish to each accepting target, tracking results, failures, and remote status."""
+        results: list[PublishResult] = []
+        failures: list[str] = []
+        fs_result: PublishResult | None = None
+        remote_failed = False
+        last_idx = len(self._targets) - 1
+
+        for idx, target in enumerate(self._targets):
+            if not target.can_publish(doc_type, metadata):
+                continue
+            try:
+                result: PublishResult = target.publish(doc_type, content, metadata)
+                results.append(result)
+                if idx == 0:
+                    fs_result = result
+                if not result.success:
+                    failures.append(result.message)
+                    if idx == last_idx:
+                        remote_failed = True
+            except Exception as exc:
+                logger.warning(
+                    "Composite publish failed on %s: %s",
+                    type(target).__name__,
+                    exc,
+                )
+                failures.append(str(exc))
+                if idx == last_idx:
+                    remote_failed = True
+
+        return results, failures, fs_result, remote_failed
+
+    @staticmethod
+    def _reduce_results(
+        results: list[PublishResult], failures: list[str]
+    ) -> PublishResult:
+        """Reduce per-target results into a single PublishResult."""
+        if not results:
+            return PublishResult(
+                success=False, message="No target accepted this doc_type"
+            )
+        successful = [r for r in results if r.success]
+        if not successful:
+            return results[0]
+        best = successful[-1]  # last success = remote if available
+        if failures:
+            return PublishResult(
+                success=True,
+                url=best.url,
+                message=f"{best.message} (sync pending: {'; '.join(failures)})",
+            )
+        return best
+
+    def _flush_pending(self) -> None:
+        """Attempt to replay pending ops against remote. Best-effort, never raises."""
+        if self._pending_ops is None:
+            return
+        try:
+            for op in list(self._pending_ops.iter()):
+                args = op.args
+                doc_type = str(args.get("doc_type", ""))
+                content = str(args.get("content", ""))
+                metadata: dict[str, Any] = args.get("metadata") or {}
+                try:
+                    replay_result = self._remote.publish(doc_type, content, metadata)
+                    if (
+                        isinstance(replay_result, PublishResult)
+                        and replay_result.success
+                    ):
+                        self._pending_ops.mark_done(op.id)
+                    else:
+                        logger.info(
+                            "Pending op %s replay returned failure; keeping in queue",
+                            op.id,
+                        )
+                except Exception as exc:  # noqa: BLE001 — replay failure = keep queued
+                    logger.warning(
+                        "Pending op %s replay raised: %s", op.id, exc, exc_info=True
+                    )
+        except Exception:  # noqa: BLE001 — flush errors never block new publish
+            logger.exception("Pending ops flush failed")
+
+    def get_page(self, identifier: str) -> PageContent:
+        """Delegate to remote (last) target."""
+        return self._remote.get_page(identifier)
+
+    def search(self, query: str, limit: int = 10) -> list[PageSummary]:
+        """Delegate to remote (last) target."""
+        return self._remote.search(query, limit=limit)
+
+    def health(self) -> AdapterHealth:
+        """Delegate to remote (last) target."""
+        return self._remote.health()