icdev 0.0.3__py3-none-any.whl

tools/dashboard/templates/writeguard.html

@@ -0,0 +1,277 @@
+{% extends "base.html" %}
+{% block title %}{{ app_name }} — WriteGuard{% endblock %}
+{% block content %}
+<h1>WriteGuard — AI Writing Assistant</h1>
+
+<div class="intro-panel">
+    <h2>Writing Quality Analysis</h2>
+    <p>Analyze text for grammar, readability, tone, and style compliance.
+       Paste text below and click Analyze for instant feedback.</p>
+</div>
+
+<!-- Stat Grid -->
+<div class="stat-grid">
+    <div class="stat-card">
+        <div class="label">Total Analyses</div>
+        <div class="value blue">{{ stats.total_analyses }}</div>
+    </div>
+    <div class="stat-card">
+        <div class="label">Avg Quality Score</div>
+        <div class="value {% if stats.avg_quality >= 70 %}green{% elif stats.avg_quality >= 50 %}orange{% else %}red{% endif %}">{{ stats.avg_quality }}</div>
+    </div>
+    <div class="stat-card">
+        <div class="label">Active Snippets</div>
+        <div class="value purple">{{ stats.active_snippets }}</div>
+    </div>
+    <div class="stat-card">
+        <div class="label">Style Guides</div>
+        <div class="value blue">{{ stats.active_guides }}</div>
+    </div>
+    <div class="stat-card">
+        <div class="label">Total Findings</div>
+        <div class="value orange">{{ stats.total_findings }}</div>
+    </div>
+</div>
+
+<!-- Analysis Panel -->
+<div class="card" style="margin-bottom: 16px;">
+    <div class="card-header">
+        <h2>Analyze Text</h2>
+        <div style="display: flex; gap: 8px; align-items: center;">
+            <select id="style-guide" style="padding: 6px 10px; border-radius: 6px; border: 1px solid #334155; background: #1e293b; color: #e2e8f0; font-size: 13px;">
+                <option value="">No style guide</option>
+                {% for g in guides %}
+                <option value="{{ g.id }}">{{ g.guide_name }} ({{ g.scope }})</option>
+                {% endfor %}
+            </select>
+            <button class="btn btn-primary" onclick="runAnalysis()">Analyze</button>
+            <button class="btn btn-success" onclick="runRewrite()" id="btn-rewrite" disabled>Rewrite</button>
+        </div>
+    </div>
+    <textarea id="input-text" rows="8" placeholder="Paste your text here for analysis..."
+              style="width: 100%; padding: 12px; border-radius: 6px; border: 1px solid #334155;
+                     background: #0f172a; color: #e2e8f0; font-size: 14px; font-family: inherit;
+                     resize: vertical; box-sizing: border-box;"></textarea>
+    <div id="analysis-status" style="display:none; padding: 8px 0; font-size: 14px;"></div>
+</div>
+
+<!-- Results Panel (hidden until analysis runs) -->
+<div id="results-panel" style="display: none;">
+    <!-- Scores -->
+    <div class="stat-grid" id="result-scores"></div>
+
+    <!-- Findings -->
+    <div class="card" id="findings-card">
+        <h2>Findings</h2>
+        <div id="findings-list"></div>
+    </div>
+</div>
+
+<!-- Rewrite Output (hidden until rewrite runs) -->
+<div id="rewrite-panel" class="card" style="display: none;">
+    <h2>Rewritten Text</h2>
+    <pre id="rewrite-output" style="white-space: pre-wrap; color: #e2e8f0; font-size: 14px; line-height: 1.6;"></pre>
+</div>
+
+<!-- Recent Analyses -->
+<div class="card">
+    <h2>Recent Analyses</h2>
+    {% if recent %}
+    <div class="table-container">
+    <table>
+        <thead>
+            <tr>
+                <th>Document</th>
+                <th>Quality</th>
+                <th>Grade Level</th>
+                <th>Grammar Errors</th>
+                <th>Findings</th>
+                <th>Mode</th>
+                <th>Duration</th>
+                <th>Time</th>
+            </tr>
+        </thead>
+        <tbody>
+            {% for r in recent %}
+            <tr>
+                <td>{{ r.document_name or r.id[:12] }}</td>
+                <td>
+                    {% if r.overall_quality_score >= 70 %}
+                    <span class="badge badge-green">{{ r.overall_quality_score|round(1) }}</span>
+                    {% elif r.overall_quality_score >= 50 %}
+                    <span class="badge badge-orange">{{ r.overall_quality_score|round(1) }}</span>
+                    {% else %}
+                    <span class="badge badge-red">{{ r.overall_quality_score|round(1) }}</span>
+                    {% endif %}
+                </td>
+                <td>{{ r.readability_grade_level|round(1) }}</td>
+                <td>{{ r.grammar_error_count }}</td>
+                <td>{{ r.findings_count }}</td>
+                <td><span class="badge badge-blue">{{ r.mode }}</span></td>
+                <td>{{ r.analysis_duration_ms }}ms</td>
+                <td>{{ r.created_at[:16] if r.created_at else '—' }}</td>
+            </tr>
+            {% endfor %}
+        </tbody>
+    </table>
+    </div>
+    {% else %}
+    <div class="empty">No analyses yet. Paste text above and click Analyze to get started.</div>
+    {% endif %}
+</div>
+
+<!-- Active Style Guides -->
+{% if guides %}
+<div class="card">
+    <h2>Active Style Guides</h2>
+    <div class="table-container">
+    <table>
+        <thead>
+            <tr>
+                <th>Name</th>
+                <th>Scope</th>
+                <th>Scope ID</th>
+                <th>Version</th>
+                <th>Created</th>
+            </tr>
+        </thead>
+        <tbody>
+            {% for g in guides %}
+            <tr>
+                <td><strong>{{ g.guide_name }}</strong></td>
+                <td><span class="badge badge-blue">{{ g.scope }}</span></td>
+                <td>{{ g.scope_id }}</td>
+                <td>v{{ g.version }}</td>
+                <td>{{ g.created_at[:16] if g.created_at else '—' }}</td>
+            </tr>
+            {% endfor %}
+        </tbody>
+    </table>
+    </div>
+</div>
+{% endif %}
+
+<script>
+let lastFindings = [];
+
+async function runAnalysis() {
+    const text = document.getElementById('input-text').value.trim();
+    if (!text) return;
+
+    const status = document.getElementById('analysis-status');
+    status.style.display = 'block';
+    status.style.color = '#3b82f6';
+    status.textContent = 'Analyzing text...';
+
+    const guideId = document.getElementById('style-guide').value || null;
+
+    try {
+        const resp = await fetch('/api/writeguard/analyze', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({text: text, style_guide_id: guideId, skip_llm: true})
+        });
+        const data = await resp.json();
+
+        if (data.status === 'ok') {
+            status.style.color = '#22c55e';
+            status.textContent = 'Analysis complete.';
+            displayResults(data);
+            lastFindings = data.findings || [];
+            document.getElementById('btn-rewrite').disabled = false;
+        } else {
+            status.style.color = '#ef4444';
+            status.textContent = 'Error: ' + (data.message || 'Analysis failed');
+        }
+    } catch (e) {
+        status.style.color = '#ef4444';
+        status.textContent = 'Network error: ' + e.message;
+    }
+}
+
+function displayResults(data) {
+    const panel = document.getElementById('results-panel');
+    panel.style.display = 'block';
+
+    // Score cards
+    const scores = document.getElementById('result-scores');
+    const quality = data.overall_quality_score || 0;
+    const grade = data.readability_grade_level || 0;
+    const grammar = data.grammar_error_count || 0;
+    const passive = data.passive_voice_pct || 0;
+    const findings = (data.findings || []).length;
+
+    scores.innerHTML = `
+        <div class="stat-card">
+            <div class="label">Quality Score</div>
+            <div class="value ${quality >= 70 ? 'green' : quality >= 50 ? 'orange' : 'red'}">${quality.toFixed(1)}</div>
+        </div>
+        <div class="stat-card">
+            <div class="label">Grade Level</div>
+            <div class="value blue">${grade.toFixed(1)}</div>
+        </div>
+        <div class="stat-card">
+            <div class="label">Grammar Errors</div>
+            <div class="value ${grammar === 0 ? 'green' : 'orange'}">${grammar}</div>
+        </div>
+        <div class="stat-card">
+            <div class="label">Passive Voice</div>
+            <div class="value ${passive <= 20 ? 'green' : 'orange'}">${passive.toFixed(0)}%</div>
+        </div>
+        <div class="stat-card">
+            <div class="label">Findings</div>
+            <div class="value ${findings === 0 ? 'green' : 'orange'}">${findings}</div>
+        </div>
+    `;
+
+    // Findings list
+    const list = document.getElementById('findings-list');
+    if (!data.findings || data.findings.length === 0) {
+        list.innerHTML = '<div class="empty">No findings — text looks good!</div>';
+    } else {
+        list.innerHTML = data.findings.map(f => {
+            const sevColor = {critical:'red',high:'orange',medium:'orange',low:'blue',info:'gray'}[f.severity] || 'gray';
+            return `<div style="padding: 8px 0; border-bottom: 1px solid #1e293b;">
+                <span class="badge badge-${sevColor}">${f.severity}</span>
+                <span class="badge badge-blue" style="margin-left: 4px;">${f.category}</span>
+                <span style="margin-left: 8px; color: #e2e8f0;">${f.message}</span>
+                ${f.suggestion ? `<div style="margin-top: 4px; color: #94a3b8; font-size: 13px;">Suggestion: ${f.suggestion}</div>` : ''}
+            </div>`;
+        }).join('');
+    }
+}
+
+async function runRewrite() {
+    const text = document.getElementById('input-text').value.trim();
+    if (!text) return;
+
+    const status = document.getElementById('analysis-status');
+    status.style.display = 'block';
+    status.style.color = '#3b82f6';
+    status.textContent = 'Rewriting text with AI...';
+
+    try {
+        const resp = await fetch('/api/writeguard/rewrite', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({text: text, findings: lastFindings, style: 'government'})
+        });
+        const data = await resp.json();
+
+        if (data.status === 'ok') {
+            status.style.color = '#22c55e';
+            status.textContent = 'Rewrite complete.';
+            const panel = document.getElementById('rewrite-panel');
+            panel.style.display = 'block';
+            document.getElementById('rewrite-output').textContent = data.rewritten_text || data.text || 'No output.';
+        } else {
+            status.style.color = '#ef4444';
+            status.textContent = 'Rewrite error: ' + (data.message || 'Failed');
+        }
+    } catch (e) {
+        status.style.color = '#ef4444';
+        status.textContent = 'Network error: ' + e.message;
+    }
+}
+</script>
+{% endblock %}

tools/databridge/__init__.py

@@ -0,0 +1,5 @@
+# CUI // SP-CTI
+"""DataBridge — Universal Data & Storage Connector for ICDEV (D-DB-1)."""
+
+__version__ = "1.0.0"
+__module_slug__ = "databridge"

tools/databridge/agent/__init__.py

@@ -0,0 +1,2 @@
+# CUI // SP-CTI
+"""DataBridge On-Prem Agent package."""

tools/databridge/agent/daemon.py

@@ -0,0 +1,227 @@
+# CUI // SP-CTI
+"""DataBridge On-Prem Agent Daemon (D-DB-10).
+
+Lightweight Python daemon that runs on customer's network. Communicates with
+ICDEV cloud relay via outbound WebSocket only (firewall-friendly, no inbound ports).
+
+Receives sync requests, executes locally using installed connectors,
+returns Arrow IPC results over WebSocket.
+"""
+
+import json
+import logging
+import os
+import signal
+import sqlite3
+import sys
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger("databridge.agent.daemon")
+
+DB_PATH = Path(__file__).resolve().parent.parent.parent.parent / "data" / "icdev.db"
+
+
+def _get_conn(db_path: Optional[str] = None) -> sqlite3.Connection:
+    p = db_path or str(DB_PATH)
+    conn = sqlite3.connect(p)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    return conn
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class AgentDaemon:
+    """On-prem DataBridge agent daemon.
+
+    Lifecycle: register -> connect (WebSocket) -> heartbeat loop -> handle requests
+    """
+
+    def __init__(
+        self,
+        agent_name: str = "",
+        relay_url: str = "wss://relay.icdev.example.com/ws/agent",
+        tenant_id: str = "default",
+        db_path: Optional[str] = None,
+    ):
+        self.agent_id = f"db-agent-{uuid.uuid4().hex[:12]}"
+        self.agent_name = agent_name or f"agent-{self.agent_id[-8:]}"
+        self.relay_url = relay_url
+        self.tenant_id = tenant_id
+        self.db_path = db_path
+        self._running = False
+        self._ws: Any = None
+
+    def register(self) -> Dict[str, Any]:
+        """Register agent in db_agents table."""
+        conn = _get_conn(self.db_path)
+        now = _now_iso()
+        try:
+            # Discover local connectors
+            from tools.databridge.registry import list_registered_connectors
+            connectors = list_registered_connectors()
+            connector_names = [c["name"] for c in connectors if "error" not in c]
+
+            conn.execute(
+                """INSERT OR REPLACE INTO db_agents
+                   (id, agent_name, status, relay_url, capabilities,
+                    last_heartbeat, tenant_id, created_at, updated_at)
+                   VALUES (?, ?, 'registered', ?, ?, ?, ?, ?, ?)""",
+                (
+                    self.agent_id, self.agent_name, self.relay_url,
+                    json.dumps({"connectors": connector_names}),
+                    now, self.tenant_id, now, now,
+                ),
+            )
+            conn.commit()
+            return {
+                "status": "ok",
+                "agent_id": self.agent_id,
+                "connectors": connector_names,
+            }
+        finally:
+            conn.close()
+
+    def heartbeat(self) -> None:
+        """Update heartbeat timestamp."""
+        conn = _get_conn(self.db_path)
+        try:
+            conn.execute(
+                "UPDATE db_agents SET last_heartbeat = ?, status = 'connected', updated_at = ? WHERE id = ?",
+                (_now_iso(), _now_iso(), self.agent_id),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    def handle_request(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle an incoming sync request from the relay."""
+        action = message.get("action", "")
+        logger.info("Handling request: %s", action)
+
+        if action == "sync_read":
+            from tools.databridge.sync_engine import sync_read
+            return sync_read(
+                connection_id=message.get("connection_id", ""),
+                table_name=message.get("table_name", ""),
+                query=message.get("query", ""),
+                limit=message.get("limit"),
+                db_path=self.db_path,
+            )
+        elif action == "sync_write":
+            from tools.databridge.sync_engine import sync_write
+            return sync_write(
+                connection_id=message.get("connection_id", ""),
+                table_name=message.get("table_name", ""),
+                data=message.get("data"),
+                db_path=self.db_path,
+            )
+        elif action == "test_connection":
+            from tools.databridge.connection_manager import test_connection
+            return test_connection(
+                connection_id=message.get("connection_id", ""),
+                db_path=self.db_path,
+            )
+        elif action == "list_tables":
+            from tools.databridge.registry import get_connector_instance
+            connector = get_connector_instance(message.get("connector_name", ""))
+            if connector:
+                return {"status": "ok", "tables": connector.list_tables()}
+            return {"status": "error", "message": "Connector not found"}
+        elif action == "health_check":
+            return {"status": "ok", "agent_id": self.agent_id}
+        else:
+            return {"status": "error", "message": f"Unknown action: {action}"}
+
+    def start(self, heartbeat_interval: int = 60) -> None:
+        """Start the agent daemon (blocking).
+
+        In production, this connects to the relay WebSocket.
+        For local testing, runs a heartbeat-only loop.
+        """
+        self._running = True
+        self.register()
+        logger.info("Agent %s started. Relay: %s", self.agent_id, self.relay_url)
+
+        # Signal handling
+        def _shutdown(signum, frame):
+            logger.info("Shutting down agent %s", self.agent_id)
+            self._running = False
+
+        signal.signal(signal.SIGINT, _shutdown)
+        signal.signal(signal.SIGTERM, _shutdown)
+
+        # Try WebSocket connection
+        try:
+            from tools.databridge.agent.ws_relay import connect_relay
+            self._ws = connect_relay(
+                self.relay_url,
+                self.agent_id,
+                self.handle_request,
+            )
+        except (ImportError, Exception) as exc:
+            logger.warning("WebSocket not available: %s. Running heartbeat only.", exc)
+
+        # Heartbeat loop
+        while self._running:
+            try:
+                self.heartbeat()
+            except Exception as exc:
+                logger.error("Heartbeat failed: %s", exc)
+            time.sleep(heartbeat_interval)
+
+        # Cleanup
+        conn = _get_conn(self.db_path)
+        try:
+            conn.execute(
+                "UPDATE db_agents SET status = 'disconnected', updated_at = ? WHERE id = ?",
+                (_now_iso(), self.agent_id),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    def stop(self) -> None:
+        self._running = False
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="DataBridge On-Prem Agent")
+    parser.add_argument("--name", type=str, default="", help="Agent name")
+    parser.add_argument("--relay-url", type=str, default="wss://relay.icdev.example.com/ws/agent")
+    parser.add_argument("--tenant-id", type=str, default="default")
+    parser.add_argument("--heartbeat-interval", type=int, default=60)
+    parser.add_argument("--db-path", type=str, default=None)
+    parser.add_argument("--register-only", action="store_true", help="Register and exit")
+    parser.add_argument("--json", action="store_true", help="Output in JSON format")
+
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO)
+    daemon = AgentDaemon(
+        agent_name=args.name,
+        relay_url=args.relay_url,
+        tenant_id=args.tenant_id,
+        db_path=args.db_path,
+    )
+
+    if args.register_only:
+        result = daemon.register()
+        print(json.dumps(result, indent=2))
+    elif args.json:
+        print(json.dumps({"status": "ready", "agent_name": daemon.agent_name,
+                          "relay_url": daemon.relay_url, "tenant_id": daemon.tenant_id}))
+    else:
+        daemon.start(heartbeat_interval=args.heartbeat_interval)

tools/databridge/agent/tunnel.py

@@ -0,0 +1,101 @@
+# CUI // SP-CTI
+"""DataBridge SSH Tunnel for On-Prem Agent (D-DB-10).
+
+Provides SSH tunnel for database connections that require direct TCP access.
+Used when WebSocket relay is insufficient (e.g., direct PostgreSQL connections).
+"""
+
+import logging
+import subprocess
+import time
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger("databridge.agent.tunnel")
+
+
+class SSHTunnel:
+    """SSH tunnel manager for on-prem database access.
+
+    Creates an SSH tunnel: local_port -> ssh_host -> remote_host:remote_port
+    """
+
+    def __init__(
+        self,
+        ssh_host: str,
+        ssh_user: str,
+        ssh_key_path: str = "",
+        remote_host: str = "localhost",
+        remote_port: int = 5432,
+        local_port: int = 0,
+    ):
+        self.ssh_host = ssh_host
+        self.ssh_user = ssh_user
+        self.ssh_key_path = ssh_key_path
+        self.remote_host = remote_host
+        self.remote_port = remote_port
+        self.local_port = local_port or self._find_free_port()
+        self._process: Optional[subprocess.Popen] = None
+
+    def _find_free_port(self) -> int:
+        import socket
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            return s.getsockname()[1]
+
+    def open(self) -> Dict[str, Any]:
+        """Open SSH tunnel."""
+        cmd = [
+            "ssh", "-N", "-L",
+            f"{self.local_port}:{self.remote_host}:{self.remote_port}",
+            f"{self.ssh_user}@{self.ssh_host}",
+            "-o", "StrictHostKeyChecking=no",
+            "-o", "ServerAliveInterval=30",
+        ]
+        if self.ssh_key_path:
+            cmd.extend(["-i", self.ssh_key_path])
+
+        try:
+            self._process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            time.sleep(2)  # Wait for tunnel to establish
+            if self._process.poll() is not None:
+                stderr = self._process.stderr.read().decode() if self._process.stderr else ""
+                return {"status": "error", "message": f"Tunnel failed: {stderr}"}
+
+            logger.info(
+                "SSH tunnel open: localhost:%d -> %s:%d via %s",
+                self.local_port, self.remote_host, self.remote_port, self.ssh_host,
+            )
+            return {
+                "status": "ok",
+                "local_port": self.local_port,
+                "remote": f"{self.remote_host}:{self.remote_port}",
+                "via": self.ssh_host,
+            }
+        except FileNotFoundError:
+            return {"status": "error", "message": "ssh command not found"}
+        except Exception as exc:
+            return {"status": "error", "message": str(exc)}
+
+    def close(self) -> None:
+        """Close SSH tunnel."""
+        if self._process:
+            self._process.terminate()
+            self._process.wait(timeout=5)
+            self._process = None
+            logger.info("SSH tunnel closed")
+
+    @property
+    def is_open(self) -> bool:
+        return self._process is not None and self._process.poll() is None
+
+    def get_local_url(self, db_type: str = "postgresql", database: str = "") -> str:
+        """Get connection URL through the tunnel."""
+        if db_type == "postgresql":
+            return f"postgresql://localhost:{self.local_port}/{database}"
+        elif db_type == "mysql":
+            return f"mysql://localhost:{self.local_port}/{database}"
+        return f"localhost:{self.local_port}"