@scemoon/cdh 1.0.3 → 1.0.5

package/ai-dlc-skill/workflows/ai-dlc.yaml

@@ -35,11 +35,11 @@ phases:
       - UND-001..006: Understand rules
       - Human review and approval
     artifacts:
-      - requirements.md
-      - openspec/changes/{id}/spec-delta.md
+      - aidlc/requirements.md
+      - aidlc/openspec/changes/{id}/spec-delta.md
       - apps/{component}/features/{domain}/{feature}.feature
-      - features/cross-stack/{domain}/{feature}.feature
-      - contracts/api|events/{name}.{yaml,graphql}
+      - aidlc/features/cross-stack/{domain}/{feature}.feature
+      - aidlc/contracts/api|events/{name}.{yaml,graphql}
 
   - name: plan
     label: "② Plan — 规划"
@@ -57,9 +57,9 @@ phases:
       - PLN-001..004: Plan rules
       - Human review and approval
     artifacts:
-      - openspec/changes/{id}/design.md
-      - openspec/changes/{id}/task-list.md
-      - openspec/changes/{id}/contract-diff.md
+      - aidlc/openspec/changes/{id}/design.md
+      - aidlc/openspec/changes/{id}/task-list.md
+      - aidlc/openspec/changes/{id}/contract-diff.md
 
   - name: verify
     label: "③ Verify — 验证"
@@ -81,10 +81,10 @@ phases:
       - apps/{component}/tests/{unit,integration,e2e}/test_{feature}.py
       - apps/{component}/features/steps/test_{feature}_steps.py
       - apps/{component}/src/{module}/{feature}.py
-      - tests/contract/test_{contract}.py
-      - tests/cross-stack/test_{flow}.py
-      - packages/shared/
-      - openspec/changes/{id}/contract-diff.md
+      - aidlc/tests/contract/test_{contract}.py
+      - aidlc/tests/cross-stack/test_{flow}.py
+      - aidlc/packages/shared/
+      - aidlc/openspec/changes/{id}/contract-diff.md
 
   - name: deliver
     label: "④ Deliver — 交付"
@@ -105,6 +105,6 @@ phases:
       - STACK_URL / BACKEND_URL
       - Per-component e2e report
       - Cross-stack e2e report
-      - openspec/changes/{id}/contract-diff.md
+      - aidlc/openspec/changes/{id}/contract-diff.md
       - Stack BVT report
       - Deploy log

package/ai-dlc-skill/workflows/deployment.yaml

@@ -107,7 +107,7 @@ stages:
         requires: [deploy_stack]
         when: affects contains tta
       - name: e2e_cross_stack
-        command: pytest tests/cross-stack/ --stack-url ${STACK_URL}
+        command: pytest aidlc/tests/cross-stack/ --stack-url ${STACK_URL}
         requires: [e2e_backend, e2e_web, e2e_native, e2e_desktop, e2e_wxa, e2e_mya, e2e_tta]
         when: affects contains >= 2 components
 
@@ -119,7 +119,7 @@ stages:
       - name: smoke
         command: smoke-test ${STACK_URL}
       - name: cross_stack
-        command: pytest tests/cross-stack/ --stack-url ${STACK_URL}
+        command: pytest aidlc/tests/cross-stack/ --stack-url ${STACK_URL}
 
   - name: production
     description: Stack production deploy with stack BVT
@@ -132,7 +132,7 @@ stages:
           - per_component_e2e_reports
           - cross_stack_e2e_report
           - staging_smoke_report
-          - openspec/changes/{id}/contract-diff.md
+          - aidlc/openspec/changes/{id}/contract-diff.md
       - name: deploy_stack
         command: deploy_stack --env production
       - name: bvt
@@ -142,7 +142,7 @@ stages:
         command: curl -f ${PRODUCTION_URL}/health
         timeout: 30s
       - name: archive_contract_diff
-        command: cp openspec/changes/{id}/contract-diff.md deploy-artifacts/
+        command: cp aidlc/openspec/changes/{id}/contract-diff.md aidlc/deploy-artifacts/
 
 rollback:
   triggers:

package/cdh/cdh_mcp_injector.py

@@ -0,0 +1,115 @@
+"""cdh platform MCP injector — injects platform MCPs into engines.
+
+Strategies (per engine capability):
+- env var: Set CDH_SHARED_MCP with JSON-serialized platform MCP configs
+- CLI args: Inject via engine-specific CLI flags (--mcp-server name=url)
+- config file: Write a temp config that the engine reads at startup
+
+Name conflict: engine private MCPs win over cdh platform MCPs.
+Engines that don't support injection get a silent fallback (INFO log).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+logger = logging.getLogger("cdh.mcp.injector")
+
+CDH_SHARED_MCP_ENV = "CDH_SHARED_MCP"
+
+
+class CdhMcpInjector:
+    SUPPORTED_ENGINES = {"onecode", "opencode"}
+
+    def __init__(self, platform_mcps_dir: Path | None = None):
+        from cdh.cdh_mcp_manager import CDH_PLATFORM_MCPS_DIR
+
+        self.platform_mcps_dir = platform_mcps_dir or CDH_PLATFORM_MCPS_DIR
+
+    def inject_env(self) -> None:
+        """Set CDH_SHARED_MCP env var with platform MCP configs."""
+        config_path = self.platform_mcps_dir / "mcps.yaml"
+        if not config_path.exists():
+            return
+        try:
+            data = yaml.safe_load(config_path.read_text()) or {}
+            os.environ[CDH_SHARED_MCP_ENV] = json.dumps(data)
+            logger.debug("Set %s with %d MCP servers", CDH_SHARED_MCP_ENV, len(data))
+        except Exception as e:
+            logger.warning("Failed to inject platform MCPs via env: %s", e)
+
+    def clear_env(self) -> None:
+        os.environ.pop(CDH_SHARED_MCP_ENV, None)
+
+    def get_shared_mcp_config(self) -> dict[str, dict]:
+        raw = os.environ.get(CDH_SHARED_MCP_ENV, "")
+        if not raw:
+            return {}
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError:
+            logger.warning("Invalid %s value, ignoring", CDH_SHARED_MCP_ENV)
+            return {}
+
+    def inject_for_engine(
+        self,
+        engine_name: str,
+        engine_mcps_path: Path | None = None,
+    ) -> Optional[str]:
+        """Inject platform MCPs for a specific engine.
+
+        Returns an info/warning message, or None if no injection needed.
+
+        For supported engines: sets CDH_SHARED_MCP env var.
+        For unsupported engines: logs a silent INFO fallback.
+        """
+        platform_config = self._load_platform_config()
+        if not platform_config:
+            return None
+
+        if engine_name not in self.SUPPORTED_ENGINES:
+            logger.info(
+                "Engine '%s' does not support cdh platform MCP injection. "
+                "Platform MCPs available via %s env var.",
+                engine_name,
+                CDH_SHARED_MCP_ENV,
+            )
+            return None
+
+        # Merge with engine private (engine wins)
+        merged = dict(platform_config)
+        if engine_mcps_path and engine_mcps_path.exists():
+            try:
+                engine_data = yaml.safe_load(engine_mcps_path.read_text()) or {}
+                engine_data = {
+                    k: v for k, v in engine_data.items() if isinstance(v, dict)
+                }
+            except Exception:
+                engine_data = {}
+            merged.update(engine_data)
+
+        os.environ[CDH_SHARED_MCP_ENV] = json.dumps(merged)
+        logger.debug(
+            "Injected %d platform MCPs + %d engine MCPs via %s for '%s'",
+            len(platform_config),
+            len(engine_data) if engine_mcps_path and engine_mcps_path.exists() else 0,
+            CDH_SHARED_MCP_ENV,
+            engine_name,
+        )
+        return f"{len(platform_config)} platform MCP(s) injected for '{engine_name}'"
+
+    def _load_platform_config(self) -> dict[str, dict]:
+        config_path = self.platform_mcps_dir / "mcps.yaml"
+        if not config_path.exists():
+            return {}
+        try:
+            data = yaml.safe_load(config_path.read_text()) or {}
+            return {k: v for k, v in data.items() if isinstance(v, dict)}
+        except Exception:
+            return {}

package/cdh/cdh_mcp_loader.py

@@ -0,0 +1,67 @@
+"""cdh platform MCP loader — merges platform MCPs with engine-private MCPs.
+
+Discovery order:
+1. Read engine-private MCPs from engine's own config (e.g. ~/.onecode/mcps/mcps.yaml)
+2. Read cdh platform MCPs from ~/.cdh/mcps/mcps.yaml
+3. Merge: engine private wins on name conflict
+4. Return merged list for injection
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import yaml
+
+from cdh.cdh_mcp_manager import CDH_PLATFORM_MCPS_DIR
+
+logger = logging.getLogger("cdh.mcp.loader")
+
+
+class CdhMcpLoader:
+    def __init__(self, platform_mcps_dir: Path | None = None):
+        self.platform_mcps_dir = platform_mcps_dir or CDH_PLATFORM_MCPS_DIR
+        self._cache: dict[str, dict] | None = None
+
+    def load_platform(self) -> dict[str, dict]:
+        config_path = self.platform_mcps_dir / "mcps.yaml"
+        if not config_path.exists():
+            return {}
+        try:
+            data = yaml.safe_load(config_path.read_text()) or {}
+            return {k: v for k, v in data.items() if isinstance(v, dict)}
+        except Exception:
+            logger.warning("Failed to load platform MCP config from %s", config_path)
+            return {}
+
+    def get_merged(
+        self, engine_mcps_path: Path | None = None
+    ) -> list[dict]:
+        platform = self.load_platform()
+
+        if engine_mcps_path and engine_mcps_path.exists():
+            try:
+                engine_data = yaml.safe_load(engine_mcps_path.read_text()) or {}
+                engine_data = {k: v for k, v in engine_data.items() if isinstance(v, dict)}
+            except Exception:
+                engine_data = {}
+        else:
+            engine_data = {}
+
+        merged = dict(platform)
+        merged.update(engine_data)
+
+        return [
+            {"name": name, **cfg, "source": "engine" if name in engine_data else "platform"}
+            for name, cfg in merged.items()
+        ]
+
+    def get_platform_only(self) -> list[dict]:
+        return [
+            {"name": name, **cfg, "source": "platform"}
+            for name, cfg in self.load_platform().items()
+        ]
+
+    def invalidate_cache(self) -> None:
+        self._cache = None

package/cdh/cdh_mcp_manager.py

@@ -0,0 +1,73 @@
+"""cdh platform MCP manager — operates ~/.cdh/mcps/.
+
+This is the cdh platform equivalent of onecode.mcp.manager.MCPManager,
+but operates strictly on ~/.cdh/mcps/ (cdh platform shared MCP pool).
+Engines (onecode/opencode/claude) read platform MCPs via env var
+injection at launch time (see cdh_mcp_injector.py).
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+logger = logging.getLogger("cdh.mcp")
+
+CDH_PLATFORM_MCPS_DIR = Path.home() / ".cdh" / "mcps"
+
+
+class CdhMcpManager:
+    def __init__(self, mcps_dir: Path | None = None):
+        self.mcps_dir = mcps_dir or CDH_PLATFORM_MCPS_DIR
+        self.mcps_dir.mkdir(parents=True, exist_ok=True)
+        self.config_path = self.mcps_dir / "mcps.yaml"
+        self._data: dict[str, dict] = {}
+        if self.config_path.exists():
+            try:
+                self._data = yaml.safe_load(self.config_path.read_text()) or {}
+            except Exception:
+                self._data = {}
+
+    def add(self, name: str, url: str, transport: str = "sse") -> None:
+        self._data[name] = {"url": url, "transport": transport, "enabled": True}
+        self._save()
+
+    def add_stdio(self, name: str, command: str, args: list[str] | None = None) -> None:
+        self._data[name] = {
+            "command": command,
+            "args": args or [],
+            "transport": "stdio",
+            "enabled": True,
+        }
+        self._save()
+
+    def list(self) -> list[dict]:
+        return [{"name": name, **cfg} for name, cfg in self._data.items()]
+
+    def get(self, name: str) -> Optional[dict]:
+        return self._data.get(name)
+
+    def enable(self, name: str, enabled: bool = True) -> Optional[str]:
+        if name not in self._data:
+            return f"MCP server '{name}' not found"
+        self._data[name]["enabled"] = enabled
+        self._save()
+        return None
+
+    def remove(self, name: str) -> Optional[str]:
+        if name not in self._data:
+            return f"MCP server '{name}' not found"
+        del self._data[name]
+        self._save()
+        return None
+
+    def to_dict(self) -> dict[str, dict]:
+        return dict(self._data)
+
+    def _save(self) -> None:
+        self.config_path.write_text(
+            yaml.dump(self._data, default_flow_style=False), encoding="utf-8"
+        )

package/cdh/cdh_session_aggregator.py

@@ -0,0 +1,258 @@
+"""cdh platform session aggregator — cross-engine session registry.
+
+Maintains a session registry at ~/.cdh/sessions/sessions.db (SQLite).
+Provides a cross-engine view across all registered engines.
+Engines register sessions via the aggregator API.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+logger = logging.getLogger("cdh.session")
+
+CDH_SESSIONS_DIR = Path.home() / ".cdh" / "sessions"
+
+
+class CdhSessionAggregator:
+    def __init__(self, sessions_dir: Path | None = None):
+        self.sessions_dir = sessions_dir or CDH_SESSIONS_DIR
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        self.db_path = self.sessions_dir / "sessions.db"
+        self._init_db()
+
+    def _init_db(self) -> None:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS sessions (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    engine TEXT NOT NULL,
+                    engine_session_id TEXT NOT NULL,
+                    project_name TEXT DEFAULT '',
+                    agent TEXT NOT NULL,
+                    title TEXT NOT NULL,
+                    protocol TEXT DEFAULT 'acp',
+                    prompt_count INTEGER DEFAULT 0,
+                    created_at TEXT NOT NULL,
+                    last_used TEXT NOT NULL,
+                    meta_json TEXT DEFAULT '{}',
+                    UNIQUE(engine, engine_session_id)
+                )
+                """
+            )
+            conn.commit()
+            conn.close()
+        except sqlite3.Error as e:
+            logger.error("Failed to init session db: %s", e)
+
+    def register(
+        self,
+        engine: str,
+        engine_session_id: str,
+        agent: str,
+        title: str,
+        project_name: str = "",
+        protocol: str = "acp",
+        meta: dict[str, Any] | None = None,
+    ) -> Optional[int]:
+        now = datetime.now(timezone.utc).isoformat()
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO sessions
+                    (engine, engine_session_id, project_name, agent, title, protocol,
+                     prompt_count, created_at, last_used, meta_json)
+                VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?)
+                """,
+                (
+                    engine,
+                    engine_session_id,
+                    project_name,
+                    agent,
+                    title,
+                    protocol,
+                    now,
+                    now,
+                    json.dumps(meta or {}),
+                ),
+            )
+            conn.commit()
+            cursor = conn.execute("SELECT last_insert_rowid()")
+            row_id = cursor.fetchone()[0]
+            conn.close()
+            return row_id
+        except sqlite3.Error as e:
+            logger.error("Failed to register session: %s", e)
+            return None
+
+    def update_last_used(self, engine: str, engine_session_id: str) -> bool:
+        now = datetime.now(timezone.utc).isoformat()
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.execute(
+                "UPDATE sessions SET last_used = ? WHERE engine = ? AND engine_session_id = ?",
+                (now, engine, engine_session_id),
+            )
+            conn.commit()
+            conn.close()
+            return True
+        except sqlite3.Error:
+            return False
+
+    def increment_prompt_count(self, engine: str, engine_session_id: str) -> bool:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.execute(
+                "UPDATE sessions SET prompt_count = prompt_count + 1 WHERE engine = ? AND engine_session_id = ?",
+                (engine, engine_session_id),
+            )
+            conn.commit()
+            conn.close()
+            return True
+        except sqlite3.Error:
+            return False
+
+    def get(self, session_id: int) -> Optional[dict]:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.row_factory = sqlite3.Row
+            cursor = conn.execute("SELECT * FROM sessions WHERE id = ?", (session_id,))
+            row = cursor.fetchone()
+            conn.close()
+            return dict(row) if row else None
+        except sqlite3.Error:
+            return None
+
+    def get_by_engine_id(self, engine: str, engine_session_id: str) -> Optional[dict]:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.row_factory = sqlite3.Row
+            cursor = conn.execute(
+                "SELECT * FROM sessions WHERE engine = ? AND engine_session_id = ?",
+                (engine, engine_session_id),
+            )
+            row = cursor.fetchone()
+            conn.close()
+            return dict(row) if row else None
+        except sqlite3.Error:
+            return None
+
+    def get_recent(self, max_results: int = 100) -> list[dict]:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.row_factory = sqlite3.Row
+            cursor = conn.execute(
+                "SELECT * FROM sessions ORDER BY last_used DESC LIMIT ?",
+                (max_results,),
+            )
+            rows = cursor.fetchall()
+            conn.close()
+            return [dict(r) for r in rows]
+        except sqlite3.Error:
+            return []
+
+    def get_by_engine(self, engine: str, max_results: int = 100) -> list[dict]:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.row_factory = sqlite3.Row
+            cursor = conn.execute(
+                "SELECT * FROM sessions WHERE engine = ? ORDER BY last_used DESC LIMIT ?",
+                (engine, max_results),
+            )
+            rows = cursor.fetchall()
+            conn.close()
+            return [dict(r) for r in rows]
+        except sqlite3.Error:
+            return []
+
+    def get_by_project(self, project_name: str, max_results: int = 100) -> list[dict]:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.row_factory = sqlite3.Row
+            cursor = conn.execute(
+                "SELECT * FROM sessions WHERE project_name = ? ORDER BY last_used DESC LIMIT ?",
+                (project_name, max_results),
+            )
+            rows = cursor.fetchall()
+            conn.close()
+            return [dict(r) for r in rows]
+        except sqlite3.Error:
+            return []
+
+    def delete(self, session_id: int) -> bool:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            conn.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+            conn.commit()
+            conn.close()
+            return True
+        except sqlite3.Error:
+            return False
+
+    def count(self) -> int:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            cursor = conn.execute("SELECT COUNT(*) FROM sessions")
+            count = cursor.fetchone()[0]
+            conn.close()
+            return count
+        except sqlite3.Error:
+            return 0
+
+    def list_engines(self) -> list[str]:
+        try:
+            conn = sqlite3.connect(str(self.db_path))
+            cursor = conn.execute("SELECT DISTINCT engine FROM sessions ORDER BY engine")
+            rows = cursor.fetchall()
+            conn.close()
+            return [r[0] for r in rows]
+        except sqlite3.Error:
+            return []
+
+    def import_from_tui_db(self, tui_db_path: Path) -> int:
+        """Import sessions from a tui.db into the aggregator.
+
+        Returns the number of sessions imported.
+        """
+        if not tui_db_path.exists():
+            logger.info("No tui.db found at %s", tui_db_path)
+            return 0
+
+        imported = 0
+        try:
+            tui_conn = sqlite3.connect(str(tui_db_path))
+            tui_conn.row_factory = sqlite3.Row
+            cursor = tui_conn.execute(
+                "SELECT * FROM sessions ORDER BY id"
+            )
+            rows = cursor.fetchall()
+            tui_conn.close()
+
+            for row in rows:
+                sess = dict(row)
+                engine = sess.get("agent_identity", "tui").lower()
+                engine_session_id = sess.get("agent_session_id", str(sess["id"]))
+                if self.get_by_engine_id(engine, engine_session_id) is None:
+                    self.register(
+                        engine=engine,
+                        engine_session_id=engine_session_id,
+                        agent=sess.get("agent", engine),
+                        title=sess.get("title", f"Session {sess['id']}"),
+                        protocol=sess.get("protocol", "acp"),
+                        meta={"imported_from": str(tui_db_path), "original_id": sess["id"]},
+                    )
+                    imported += 1
+
+            logger.info("Imported %d sessions from %s", imported, tui_db_path)
+        except sqlite3.Error as e:
+            logger.error("Failed to import from tui.db: %s", e)
+
+        return imported