delimit-cli 3.15.2 → 3.15.4

package/gateway/ai/notify.py

@@ -37,7 +37,37 @@ INBOX_ROUTING_FILE = Path.home() / ".delimit" / "inbox_routing.jsonl"
 IMAP_HOST = "mail.spacemail.com"
 IMAP_PORT = 993
 IMAP_USER = "pro@delimit.ai"
-FORWARD_TO = os.environ.get("DELIMIT_FORWARD_TO", "")
+def _resolve_forward_to():
+    """Resolve forward email from env or secrets broker."""
+    # 1. Environment variable (highest priority)
+    val = os.environ.get("DELIMIT_FORWARD_TO", "")
+    if val:
+        return val
+    # 2. DELIMIT_SMTP_TO env var
+    val = os.environ.get("DELIMIT_SMTP_TO", "")
+    if val:
+        return val
+    # 3. Read from secrets broker config
+    try:
+        import json as _json
+        from pathlib import Path as _Path
+        # Check smtp-all.json for configured accounts
+        smtp_all = _Path.home() / ".delimit" / "secrets" / "smtp-all.json"
+        if smtp_all.exists():
+            data = _json.loads(smtp_all.read_text())
+            # The forward target is typically stored separately
+            # Check for a dedicated forward-to secret
+            fwd_file = _Path.home() / ".delimit" / "secrets" / "forward-to.json"
+            if fwd_file.exists():
+                fwd_data = _json.loads(fwd_file.read_text())
+                val = fwd_data.get("value", fwd_data.get("email", ""))
+                if val:
+                    return val
+    except Exception:
+        pass
+    return ""
+
+FORWARD_TO = _resolve_forward_to()
 
 # Domains/senders whose emails require owner action
 OWNER_ACTION_DOMAINS = {

package/gateway/ai/project_config.py

@@ -0,0 +1,173 @@
+"""delimit.yml — committable project configuration (STR-049).
+
+A single YAML file that teams commit to their repo. Defines:
+- Context directories (what the AI should know about)
+- Preferred models per task type
+- Policy preset
+- Playbook references
+- Governance mode (advisory/guarded/enforce)
+
+Focus group: "My AI setup on my laptop should match my teammate's."
+"""
+
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+try:
+    import yaml as _yaml
+except ImportError:
+    _yaml = None
+
+
+DEFAULT_CONFIG = {
+    "version": 1,
+    "governance": {
+        "mode": "advisory",
+        "preset": "default",
+    },
+    "context": {
+        "include": ["src/", "lib/", "app/"],
+        "exclude": ["node_modules/", ".git/", "dist/", "__pycache__/"],
+    },
+    "models": {
+        "default": "auto",
+        "tasks": {
+            "refactoring": "claude-opus",
+            "testing": "claude-sonnet",
+            "documentation": "gemini-flash",
+            "debugging": "auto",
+        },
+    },
+    "playbooks": [],
+    "team": {
+        "shared_memory": True,
+        "shared_ledger": True,
+        "require_approval_for": ["deploy", "publish"],
+    },
+}
+
+CONFIG_FILENAMES = ["delimit.yml", "delimit.yaml", ".delimit.yml", ".delimit.yaml"]
+
+
+def find_project_config(project_path: str = ".") -> Optional[Path]:
+    """Find delimit.yml in the project directory or parents."""
+    p = Path(project_path).resolve()
+    for _ in range(10):  # Max 10 parent dirs
+        for name in CONFIG_FILENAMES:
+            candidate = p / name
+            if candidate.exists():
+                return candidate
+        parent = p.parent
+        if parent == p:
+            break
+        p = parent
+    return None
+
+
+def load_project_config(project_path: str = ".") -> Dict[str, Any]:
+    """Load project config from delimit.yml or return defaults."""
+    config_file = find_project_config(project_path)
+
+    if not config_file:
+        return {
+            "status": "no_config",
+            "config": DEFAULT_CONFIG,
+            "source": "defaults",
+            "message": "No delimit.yml found. Using defaults. Run delimit_project_init to create one.",
+        }
+
+    try:
+        content = config_file.read_text()
+        if _yaml:
+            config = _yaml.safe_load(content)
+        else:
+            config = json.loads(content)
+
+        # Merge with defaults for missing keys
+        merged = {**DEFAULT_CONFIG}
+        if isinstance(config, dict):
+            for key in config:
+                if key in merged and isinstance(merged[key], dict) and isinstance(config[key], dict):
+                    merged[key] = {**merged[key], **config[key]}
+                else:
+                    merged[key] = config[key]
+
+        return {
+            "status": "loaded",
+            "config": merged,
+            "source": str(config_file),
+            "message": f"Loaded from {config_file.name}",
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "config": DEFAULT_CONFIG,
+            "source": str(config_file),
+            "error": str(e),
+            "message": f"Error loading {config_file.name}: {e}. Using defaults.",
+        }
+
+
+def init_project_config(
+    project_path: str = ".",
+    mode: str = "advisory",
+    preset: str = "default",
+) -> Dict[str, Any]:
+    """Create a delimit.yml in the project root."""
+    p = Path(project_path).resolve()
+
+    # Check if already exists
+    existing = find_project_config(project_path)
+    if existing:
+        return {
+            "status": "exists",
+            "path": str(existing),
+            "message": f"Config already exists at {existing}",
+        }
+
+    config = dict(DEFAULT_CONFIG)
+    config["governance"]["mode"] = mode
+    config["governance"]["preset"] = preset
+
+    # Auto-detect context dirs
+    detected_dirs = []
+    for d in ["src", "lib", "app", "api", "server", "client", "packages"]:
+        if (p / d).exists():
+            detected_dirs.append(f"{d}/")
+    if detected_dirs:
+        config["context"]["include"] = detected_dirs
+
+    config_path = p / "delimit.yml"
+
+    if _yaml:
+        content = _yaml.dump(config, default_flow_style=False, sort_keys=False)
+    else:
+        content = json.dumps(config, indent=2)
+
+    config_path.write_text(content)
+
+    return {
+        "status": "created",
+        "path": str(config_path),
+        "config": config,
+        "message": f"Created delimit.yml with {mode} mode, {preset} preset",
+    }
+
+
+def get_model_for_task(task_type: str, project_path: str = ".") -> Dict[str, Any]:
+    """Get the recommended model for a specific task type."""
+    result = load_project_config(project_path)
+    config = result.get("config", DEFAULT_CONFIG)
+
+    models = config.get("models", {})
+    tasks = models.get("tasks", {})
+
+    model = tasks.get(task_type, models.get("default", "auto"))
+
+    return {
+        "task": task_type,
+        "model": model,
+        "source": result.get("source", "defaults"),
+    }

package/gateway/ai/server.py

@@ -3631,6 +3631,42 @@ STANDARD_WORKFLOWS = [
 ]
 
 
+@mcp.tool()
+def delimit_project_config(action: str = "load", project_path: str = ".",
+                            mode: str = "advisory", preset: str = "default",
+                            task_type: str = "") -> Dict[str, Any]:
+    """Manage delimit.yml project configuration.
+
+    A committable YAML file that defines AI governance for your repo.
+    Your teammates get the same AI setup when they clone.
+
+    Actions:
+      load: Read current project config (or defaults if no delimit.yml)
+      init: Create a delimit.yml in your project root
+      model: Get recommended model for a task type
+
+    Args:
+        action: "load", "init", or "model".
+        project_path: Project root directory.
+        mode: Governance mode for init (advisory/guarded/enforce).
+        preset: Policy preset for init (strict/default/relaxed).
+        task_type: Task type for model lookup (refactoring/testing/docs/debugging).
+    """
+    from ai.project_config import load_project_config, init_project_config, get_model_for_task
+
+    if action == "init":
+        return _with_next_steps("project_config", _safe_call(
+            init_project_config, project_path=project_path, mode=mode, preset=preset,
+        ))
+    if action == "model":
+        return _with_next_steps("project_config", _safe_call(
+            get_model_for_task, task_type=task_type, project_path=project_path,
+        ))
+    return _with_next_steps("project_config", _safe_call(
+        load_project_config, project_path=project_path,
+    ))
+
+
 @mcp.tool()
 def delimit_playbook(action: str = "list", name: str = "", prompt: str = "",
                       description: str = "", variables: str = "",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "delimit-cli",
   "mcpName": "io.github.delimit-ai/delimit-mcp-server",
-  "version": "3.15.2",
+  "version": "3.15.4",
   "description": "Unify Claude Code, Codex, Cursor, and Gemini CLI with persistent context, governance, and multi-model debate.",
   "main": "index.js",
   "files": [