delimit-cli 4.1.16 → 4.1.18

package/README.md

@@ -30,9 +30,9 @@ Works across any configuration — from a single model on a budget to an enterpr
 ## Try it in 2 minutes
 
 ```bash
-npx delimit-cli demo     # See governance in action — no setup needed
-npx delimit-cli init     # Set up governance for your project
-npx delimit-cli setup    # Configure your AI assistants
+npx delimit-cli scan              # Instant health grade for your API spec
+npx delimit-cli demo              # See governance in action — no setup needed
+npx delimit-cli setup && source ~/.bashrc  # Configure AI assistants + activate
 ```
 
 No API keys. No account. No config files.
@@ -142,6 +142,7 @@ That's it. Delimit auto-fetches the base branch spec, diffs it, and posts a PR c
 ## CLI commands
 
 ```bash
+npx delimit-cli scan                             # Instant spec health grade + recommendations
 npx delimit-cli quickstart                       # Clone demo project + guided walkthrough
 npx delimit-cli try                              # Zero-risk demo — saves governance report
 npx delimit-cli demo                             # Self-contained governance demo

package/bin/delimit-os.sh

@@ -0,0 +1,105 @@
+#!/bin/bash
+# Delimit OS — the AI developer operating system
+# Type 'delimit' to launch the TUI, or 'delimit <command>' for CLI tools
+#
+# Usage:
+#   delimit              → Launch TUI (interactive terminal dashboard)
+#   delimit --quick      → Quick status (non-interactive)
+#   delimit think        → Trigger deliberation
+#   delimit build        → Start autonomous build loop
+#   delimit ask <query>  → Ask the swarm
+#   delimit lint <spec>  → Lint an API spec
+#   delimit init         → Initialize governance in current repo
+#   delimit setup        → Configure AI assistants
+
+set -e
+
+DELIMIT_HOME="${DELIMIT_HOME:-$HOME/.delimit}"
+GATEWAY="$DELIMIT_HOME/server/ai"
+
+# If no args, launch TUI (interactive if terminal, quick if piped)
+if [ $# -eq 0 ]; then
+    if [ -f "$GATEWAY/tui.py" ]; then
+        if [ -t 1 ] && [ -t 0 ]; then
+            cd "$DELIMIT_HOME/server" && exec python3 -m ai.tui
+        else
+            cd "$DELIMIT_HOME/server" && exec python3 -m ai.tui --quick
+        fi
+    else
+        # Fallback to npm CLI
+        exec delimit-cli "$@"
+    fi
+fi
+
+# Route commands
+case "$1" in
+    --quick|-q)
+        if [ -f "$GATEWAY/tui.py" ]; then
+            cd "$DELIMIT_HOME/server" && exec python3 -m ai.tui --quick
+        else
+            exec delimit-cli status
+        fi
+        ;;
+    think|deliberate)
+        shift
+        QUESTION="${*:-What should we build next based on the current ledger and signals?}"
+        echo "[Delimit OS] Triggering deliberation..."
+        cd "$DELIMIT_HOME/server" && python3 -c "
+from ai.deliberation import deliberate
+import json
+result = deliberate('''$QUESTION''', mode='dialogue', max_rounds=3)
+if 'error' in result:
+    print(f'Error: {result[\"error\"]}')
+elif result.get('mode') == 'single_model_reflection':
+    print(f'Model: {result.get(\"model\", \"?\")}')
+    print(f'\\nAdvocate:\\n{result.get(\"advocate\", \"\")[:500]}')
+    print(f'\\nCritic:\\n{result.get(\"critic\", \"\")[:500]}')
+    print(f'\\nSynthesis:\\n{result.get(\"synthesis\", \"\")}')
+else:
+    print(f'Verdict: {result.get(\"final_verdict\", \"no consensus\")[:500]}')
+    print(f'Rounds: {result.get(\"rounds\", 0)}')
+" 2>&1
+        ;;
+    build|loop)
+        shift
+        echo "[Delimit OS] Starting autonomous build loop..."
+        echo "Checking ledger for next task..."
+        cd "$DELIMIT_HOME/server" && python3 -c "
+from ai.ledger_manager import get_context
+import json
+result = get_context()
+items = result.get('next_up', [])
+if items:
+    print(f'Next up: {items[0].get(\"id\", \"?\")} [{items[0].get(\"priority\", \"?\")}] {items[0].get(\"title\", \"?\")[:60]}')
+    print(f'Total open: {result.get(\"open_items\", 0)}')
+else:
+    print('Ledger is clear — nothing to build.')
+" 2>&1
+        ;;
+    ask)
+        shift
+        QUERY="$*"
+        if [ -z "$QUERY" ]; then
+            echo "Usage: delimit ask <question>"
+            exit 1
+        fi
+        echo "[Delimit OS] Checking context..."
+        cd "$DELIMIT_HOME/server" && python3 -c "
+from ai.ledger_manager import get_context
+import json
+result = get_context()
+print(json.dumps(result, indent=2)[:2000])
+" 2>&1
+        ;;
+    status)
+        if [ -f "$GATEWAY/tui.py" ]; then
+            cd "$GATEWAY/.." && exec python3 -m ai.tui --quick
+        else
+            exec delimit-cli status
+        fi
+        ;;
+    *)
+        # Pass through to delimit-cli for all other commands
+        exec delimit-cli "$@"
+        ;;
+esac

package/bin/delimit-setup.js

@@ -800,11 +800,19 @@ exit 127
                 await logp(`  ${green('✓')} Governance shims updated`);
             } else {
                 log(`  ${green('✓')} Governance wrapping enabled`);
+            }
+
+            // Check if shims are already in current PATH
+            const currentPath = process.env.PATH || '';
+            if (!currentPath.includes('.delimit/shims')) {
+                // Can't modify parent shell, but try exec $SHELL -l to reload
                 log('');
-                log(`  ${bold('To activate now, run:')}`);
-                log(`  ${green('source ~/.bashrc')}`);
+                log(`  ${yellow('!')} Run this to activate the banner now:`);
+                log(`  ${green(`export PATH="${shimsDir}:$PATH"`)}`);
                 log('');
-                log(`  ${dim('Or restart your terminal. The banner appears before each AI session.')}`);
+                log(`  ${dim('Or just open a new terminal. Future sessions load it automatically.')}`);
+            } else {
+                log(`  ${green('✓')} Shim active in current shell`);
             }
         } else {
             log(`  ${dim('  Skipped. Enable later: delimit shims enable')}`);
@@ -1170,6 +1178,44 @@ exit 127
     log('');
     log(`  ${bold('Keep Building.')}`);
     log('');
+
+    // Show governance banner preview
+    const shimFile = path.join(DELIMIT_HOME, 'shims', 'claude');
+    if (fs.existsSync(shimFile)) {
+        log(dim('  --- Governance Banner Preview ---'));
+        try {
+            // Run the shim with DELIMIT_WRAPPED=true so it exits after banner
+            // We simulate the banner directly instead
+            const toolCount = (() => {
+                try {
+                    const srv = fs.readFileSync(path.join(DELIMIT_HOME, 'server', 'ai', 'server.py'), 'utf-8');
+                    return (srv.match(/@mcp\.tool/g) || []).length + (srv.match(/mcp\.tool\(\)\(/g) || []).length;
+                } catch { return 0; }
+            })();
+            const version = require('../package.json').version;
+            const purple = '\x1b[35m', magenta = '\x1b[91m', orange = '\x1b[33m';
+            const bold2 = '\x1b[1m', dim2 = '\x1b[2m', reset = '\x1b[0m', green2 = '\x1b[32m';
+            console.log('');
+            console.log(`  ${purple}${bold2}    ____  ________    ______  _____________${reset}`);
+            console.log(`  ${purple}${bold2}   / __ \\/ ____/ /   /  _/  |/  /  _/_  __/${reset}`);
+            console.log(`  ${magenta}${bold2}  / / / / __/ / /    / // /|_/ // /  / /   ${reset}`);
+            console.log(`  ${magenta}${bold2} / /_/ / /___/ /____/ // /  / // /  / /    ${reset}`);
+            console.log(`  ${orange}${bold2}/_____/_____/_____/___/_/  /_/___/ /_/     ${reset}`);
+            console.log(`  ${dim2}v${version}${reset}`);
+            console.log('');
+            console.log(`  ${purple}${bold2}[Delimit]${reset} ${dim2}Executing governance check...${reset}`);
+            console.log(`  ${purple}${bold2}[Delimit]${reset} ${orange}Mode: advisory${reset}`);
+            console.log(`  ${purple}${bold2}[Delimit]${reset} ${dim2}MCP server: ${toolCount} tools${reset}`);
+            console.log(`  ${magenta}${bold2}[Delimit]${reset} ${magenta}═══════════════════════════════════════════${reset}`);
+            console.log(`  ${magenta}${bold2}[Delimit]${reset} ${purple}<${magenta}/${orange}>${reset} ${bold2}GOVERNANCE ACTIVE: CLAUDE${reset}`);
+            console.log(`  ${magenta}${bold2}[Delimit]${reset} ${magenta}═══════════════════════════════════════════${reset}`);
+            console.log(`  ${green2}${bold2}[Delimit]${reset} ${green2}✓ Allowed${reset}`);
+            console.log('');
+            log(dim('  This banner appears before each AI session.'));
+            log(dim('  If you don\'t see it, run: source ~/.bashrc'));
+        } catch {}
+        log('');
+    }
 }
 
 // LED-213: Import canonical template from shared module

package/gateway/ai/ledger_propose.py

@@ -0,0 +1,240 @@
+"""Ledger Propose — AI-driven item generation from signals.
+
+Analyzes repo state, sensing signals, completed work, and venture priorities
+to propose 3-5 new ledger items with rationale. Runs at end of build loops
+when the queue is empty, or on-demand.
+
+Works across all AI models via MCP — no model-specific code.
+"""
+
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+SIGNALS_DIR = Path.home() / ".delimit" / "signals"
+PROPOSALS_DIR = Path.home() / ".delimit" / "proposals"
+
+
+def _gather_context(venture: str = "") -> Dict[str, Any]:
+    """Collect context from multiple sources for proposal generation."""
+    context = {
+        "timestamp": time.time(),
+        "venture": venture or "all",
+        "sources": {},
+    }
+
+    # 1. Recent ledger completions (what just shipped)
+    ledger_path = Path.home() / ".delimit" / "ledger.jsonl"
+    if ledger_path.exists():
+        recent_done = []
+        for line in ledger_path.read_text().strip().split("\n")[-100:]:
+            try:
+                item = json.loads(line)
+                if item.get("status") == "done":
+                    recent_done.append({
+                        "id": item.get("id", ""),
+                        "title": item.get("title", ""),
+                        "venture": item.get("venture", ""),
+                    })
+            except json.JSONDecodeError:
+                continue
+        context["sources"]["completed_work"] = recent_done[-10:]
+
+    # 2. Open items (what's already tracked)
+    open_items = []
+    if ledger_path.exists():
+        for line in ledger_path.read_text().strip().split("\n"):
+            try:
+                item = json.loads(line)
+                if item.get("status") == "open":
+                    open_items.append(item.get("title", ""))
+            except json.JSONDecodeError:
+                continue
+    context["sources"]["open_items_count"] = len(open_items)
+    context["sources"]["open_item_titles"] = open_items[:20]
+
+    # 3. Sensing signals (GitHub issues, Reddit, migrations)
+    signals_file = Path.home() / ".delimit" / "signals" / "recent.jsonl"
+    if signals_file.exists():
+        signals = []
+        for line in signals_file.read_text().strip().split("\n")[-20:]:
+            try:
+                sig = json.loads(line)
+                signals.append({
+                    "type": sig.get("type", ""),
+                    "title": sig.get("title", ""),
+                    "source": sig.get("source", ""),
+                    "relevance": sig.get("relevance", 0),
+                })
+            except json.JSONDecodeError:
+                continue
+        context["sources"]["signals"] = signals
+
+    # 4. Git recent activity
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["git", "log", "--oneline", "-10"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if result.returncode == 0:
+            context["sources"]["recent_commits"] = result.stdout.strip().split("\n")
+    except Exception:
+        pass
+
+    # 5. Swarm state
+    swarm_registry = Path.home() / ".delimit" / "swarm" / "agent_registry.json"
+    if swarm_registry.exists():
+        try:
+            reg = json.loads(swarm_registry.read_text())
+            context["sources"]["swarm_agents"] = len(reg.get("agents", {}))
+        except json.JSONDecodeError:
+            pass
+
+    return context
+
+
+def propose_items(
+    venture: str = "",
+    focus: str = "",
+    max_items: int = 5,
+) -> Dict[str, Any]:
+    """Generate proposed ledger items based on current context.
+
+    Analyzes completed work, open items, sensing signals, and repo state
+    to suggest what to work on next. Returns structured proposals that
+    can be added to the ledger with delimit_ledger_add.
+
+    This is the AI's "what should I do next?" engine. Works with any model.
+
+    Args:
+        venture: Focus proposals on a specific venture.
+        focus: Optional focus area (e.g., "outreach", "engineering", "security").
+        max_items: Maximum number of proposals to generate.
+    """
+    context = _gather_context(venture)
+
+    # Build proposal prompt from context
+    proposals = []
+    open_titles = set(context["sources"].get("open_item_titles", []))
+
+    # Strategy 1: Follow-through on completed work
+    for done in context["sources"].get("completed_work", []):
+        title = done.get("title", "")
+        if venture and done.get("venture", "") != venture:
+            continue
+        # Suggest follow-up actions
+        if "deploy" in title.lower() or "publish" in title.lower():
+            follow_up = f"Verify deployment: {title}"
+            if follow_up not in open_titles:
+                proposals.append({
+                    "title": follow_up,
+                    "rationale": f"Follow-through: '{title}' was shipped but may need verification",
+                    "priority": "P1",
+                    "type": "task",
+                    "source": "ledger_propose:follow_through",
+                })
+        if "outreach" in title.lower() or "issue" in title.lower():
+            follow_up = f"Monitor engagement: {title}"
+            if follow_up not in open_titles:
+                proposals.append({
+                    "title": follow_up,
+                    "rationale": f"Outreach needs monitoring for responses and engagement",
+                    "priority": "P1",
+                    "type": "task",
+                    "source": "ledger_propose:follow_through",
+                })
+
+    # Strategy 2: Act on unprocessed signals
+    for sig in context["sources"].get("signals", []):
+        sig_title = sig.get("title", "")
+        if sig_title and sig_title not in open_titles:
+            proposals.append({
+                "title": f"Evaluate signal: {sig_title[:80]}",
+                "rationale": f"Unprocessed {sig.get('type', 'signal')} from {sig.get('source', 'unknown')}",
+                "priority": "P1",
+                "type": "strategy",
+                "source": "ledger_propose:signal",
+            })
+
+    # Strategy 3: Detect gaps
+    has_tests = any("test" in t.lower() for t in open_titles)
+    has_docs = any("doc" in t.lower() or "readme" in t.lower() for t in open_titles)
+    has_security = any("security" in t.lower() or "audit" in t.lower() for t in open_titles)
+
+    if not has_tests and focus != "outreach":
+        proposals.append({
+            "title": f"Run test coverage analysis{f' for {venture}' if venture else ''}",
+            "rationale": "No test-related items in queue — ensure coverage hasn't regressed",
+            "priority": "P1",
+            "type": "task",
+            "source": "ledger_propose:gap_detection",
+        })
+
+    if not has_security and focus != "outreach":
+        proposals.append({
+            "title": f"Security audit{f' for {venture}' if venture else ''}",
+            "rationale": "No security items in queue — periodic audits prevent surprises",
+            "priority": "P2",
+            "type": "task",
+            "source": "ledger_propose:gap_detection",
+        })
+
+    if not has_docs:
+        proposals.append({
+            "title": f"Documentation freshness check{f' for {venture}' if venture else ''}",
+            "rationale": "No doc items in queue — ensure README/CHANGELOG reflect current state",
+            "priority": "P2",
+            "type": "task",
+            "source": "ledger_propose:gap_detection",
+        })
+
+    # Apply focus filter
+    if focus:
+        focus_lower = focus.lower()
+        proposals = [p for p in proposals if focus_lower in p.get("title", "").lower()
+                     or focus_lower in p.get("rationale", "").lower()
+                     or focus_lower in p.get("type", "").lower()]
+
+    # Deduplicate and limit
+    seen = set()
+    unique = []
+    for p in proposals:
+        key = p["title"][:50]
+        if key not in seen:
+            seen.add(key)
+            unique.append(p)
+    proposals = unique[:max_items]
+
+    # Save proposals for audit trail
+    PROPOSALS_DIR.mkdir(parents=True, exist_ok=True)
+    proposal_file = PROPOSALS_DIR / f"proposal_{int(time.time())}.json"
+    proposal_file.write_text(json.dumps({
+        "proposals": proposals,
+        "context_summary": {
+            "completed_work": len(context["sources"].get("completed_work", [])),
+            "open_items": context["sources"].get("open_items_count", 0),
+            "signals": len(context["sources"].get("signals", [])),
+            "swarm_agents": context["sources"].get("swarm_agents", 0),
+        },
+        "venture": venture,
+        "focus": focus,
+        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+    }, indent=2))
+
+    return {
+        "status": "ok",
+        "proposals": proposals,
+        "total": len(proposals),
+        "venture": venture or "all",
+        "focus": focus or "none",
+        "context": {
+            "completed_work_analyzed": len(context["sources"].get("completed_work", [])),
+            "open_items": context["sources"].get("open_items_count", 0),
+            "signals_analyzed": len(context["sources"].get("signals", [])),
+        },
+        "message": f"Generated {len(proposals)} proposal(s). "
+                   "Use delimit_ledger_add to add approved items.",
+    }

package/gateway/ai/reddit_proxy.py

@@ -0,0 +1,106 @@
+import json
+import logging
+import os
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("delimit.ai.reddit_proxy")
+
+def _get_proxy_config() -> Dict[str, str]:
+    """Load proxy config from private secrets or environment."""
+    config = {"proxy_url": ""}
+    
+    # 1. Check environment variable
+    env_url = os.environ.get("DELIMIT_REDDIT_PROXY")
+    if env_url:
+        config["proxy_url"] = env_url
+        return config
+
+    # 2. Check private secrets file
+    secrets_path = Path.home() / ".delimit" / "secrets" / "reddit-proxy.json"
+    if secrets_path.exists():
+        try:
+            secrets = json.loads(secrets_path.read_text())
+            config["proxy_url"] = secrets.get("proxy_url", "")
+        except Exception as e:
+            logger.debug(f"Failed to load reddit-proxy secrets: {e}")
+            
+    return config
+
+def fetch_subreddit(subreddit: str, sort: str = "new", limit: int = 10) -> List[Dict[str, Any]]:
+    """
+    Fetch posts from a single subreddit with fallback chain.
+    Returns standardized post dicts.
+    """
+    reddit_url = f"https://www.reddit.com/r/{subreddit}/{sort}.json?limit={limit}&raw_json=1"
+    
+    # 1. Try Local Proxy (Residential IP)
+    proxy_cfg = _get_proxy_config()
+    proxy_url = proxy_cfg.get("proxy_url")
+    if proxy_url:
+        try:
+            fetch_url = f"{proxy_url}?url={urllib.parse.quote(reddit_url, safe='')}"
+            req = urllib.request.Request(fetch_url, headers={"User-Agent": "Delimit/1.0"})
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                body = json.loads(resp.read().decode())
+                children = body.get("data", {}).get("children", [])
+                return [c.get("data", {}) for c in children if c.get("data")]
+        except Exception as e:
+            logger.debug(f"Local proxy failed for r/{subreddit}: {e}")
+
+    # 2. Fallback: PullPush API (Public Archive)
+    try:
+        pp_url = f"https://api.pullpush.io/reddit/search/submission/?subreddit={subreddit}&size={limit}&sort=desc"
+        req = urllib.request.Request(pp_url, headers={"User-Agent": "Delimit/1.0"})
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            body = json.loads(resp.read().decode())
+            return body.get("data", [])
+    except Exception as e:
+        logger.debug(f"PullPush fallback failed for r/{subreddit}: {e}")
+
+    # 3. Fallback: Direct (Often blocked on servers)
+    try:
+        req = urllib.request.Request(reddit_url, headers={"User-Agent": "Mozilla/5.0 (Delimit)"})
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            body = json.loads(resp.read().decode())
+            children = body.get("data", {}).get("children", [])
+            return [c.get("data", {}) for c in children if c.get("data")]
+    except Exception as e:
+        logger.warning(f"Direct fetch failed for r/{subreddit}: {e}")
+
+    return []
+
+def fetch_thread(thread_id: str) -> Optional[Dict[str, Any]]:
+    """
+    Fetch a single Reddit thread by ID with fallback chain.
+    """
+    reddit_url = f"https://www.reddit.com/comments/{thread_id}.json?raw_json=1"
+    
+    # 1. Try Local Proxy
+    proxy_cfg = _get_proxy_config()
+    proxy_url = proxy_cfg.get("proxy_url")
+    if proxy_url:
+        try:
+            fetch_url = f"{proxy_url}?url={urllib.parse.quote(reddit_url, safe='')}"
+            req = urllib.request.Request(fetch_url, headers={"User-Agent": "Delimit/1.0"})
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                data = json.loads(resp.read().decode())
+                if isinstance(data, list) and len(data) > 0:
+                    return data[0].get("data", {}).get("children", [{}])[0].get("data", {})
+        except Exception as e:
+            logger.debug(f"Local proxy failed for thread {thread_id}: {e}")
+
+    # 2. Fallback: PullPush
+    try:
+        pp_url = f"https://api.pullpush.io/reddit/search/submission/?ids={thread_id}"
+        req = urllib.request.Request(pp_url, headers={"User-Agent": "Delimit/1.0"})
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            body = json.loads(resp.read().decode())
+            data = body.get("data", [])
+            return data[0] if data else None
+    except Exception as e:
+        logger.debug(f"PullPush fallback failed for thread {thread_id}: {e}")
+
+    return None