code-context-control 2.28.0__py3-none-any.whl

cli/tools/validate.py

@@ -0,0 +1,310 @@
+"""c3_validate — Deterministic syntax validation using native language parsers."""
+
+import asyncio
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+async def _deep_type_check(full: Path, ext: str, timeout: int = 15) -> list[str]:
+    """Run pyright (Python) or tsc (TypeScript) if available. Returns advisory type-warning strings."""
+    warnings: list[str] = []
+
+    def _popen_no_window() -> dict:
+        kw: dict = {}
+        if sys.platform == "win32":
+            kw["creationflags"] = subprocess.CREATE_NO_WINDOW
+        return kw
+
+    if ext == ".py":
+        exe = shutil.which("pyright")
+        if not exe:
+            return []
+        try:
+            proc = await asyncio.to_thread(
+                subprocess.run,
+                [exe, "--outputjson", str(full)],
+                capture_output=True, text=True, timeout=timeout,
+                stdin=subprocess.DEVNULL,
+                **_popen_no_window(),
+            )
+            try:
+                data = __import__("json").loads(proc.stdout)
+                diags = data.get("generalDiagnostics", [])
+                errors = [d for d in diags if d.get("severity") == "error"]
+                warns  = [d for d in diags if d.get("severity") == "warning"]
+                if errors or warns:
+                    parts = []
+                    if errors:
+                        parts.append(f"{len(errors)} type error(s)")
+                    if warns:
+                        parts.append(f"{len(warns)} warning(s)")
+                    warnings.append(f"pyright: {', '.join(parts)}")
+                    for d in errors[:3]:
+                        ln = (d.get("range") or {}).get("start", {}).get("line", "?")
+                        warnings.append(f"  L{ln}: {d.get('message', '')[:80]}")
+            except Exception:
+                # Fallback: count error lines from plain text output
+                lines = (proc.stdout + proc.stderr).splitlines()
+                errs = [l for l in lines if " - error:" in l or " error " in l.lower()]
+                if errs:
+                    warnings.append(f"pyright: {len(errs)} issue(s) — run pyright {full.name} for details")
+        except (subprocess.TimeoutExpired, Exception):
+            pass
+
+    elif ext in (".ts", ".tsx"):
+        exe = shutil.which("tsc")
+        if not exe:
+            exe = shutil.which("npx")
+            tsc_args = [exe, "tsc", "--noEmit", "--strict", str(full)] if exe else []
+        else:
+            tsc_args = [exe, "--noEmit", "--strict", str(full)]
+        if not tsc_args:
+            return []
+        try:
+            proc = await asyncio.to_thread(
+                subprocess.run,
+                tsc_args,
+                capture_output=True, text=True, timeout=timeout,
+                stdin=subprocess.DEVNULL, cwd=str(full.parent),
+                **_popen_no_window(),
+            )
+            output = proc.stdout + proc.stderr
+            # tsc output: "file.ts(10,5): error TS2304: Cannot find..."
+            errs = re.findall(r"error TS\d+:", output)
+            warns = re.findall(r"warning TS\d+:", output)
+            if errs or warns:
+                parts = []
+                if errs:
+                    parts.append(f"{len(errs)} type error(s)")
+                if warns:
+                    parts.append(f"{len(warns)} warning(s)")
+                warnings.append(f"tsc: {', '.join(parts)}")
+                for line in output.splitlines()[:3]:
+                    if "error TS" in line:
+                        warnings.append(f"  {line.strip()[:100]}")
+        except (subprocess.TimeoutExpired, Exception):
+            pass
+
+    return warnings
+
+
+async def handle_validate(file_path: str, svc, finalize) -> str:
+    # Support comma-separated paths for batch validation
+    paths = [p.strip() for p in file_path.split(",") if p.strip()]
+
+    if len(paths) == 1:
+        return await _validate_single(paths[0], svc, finalize)
+
+    # Batch: validate all files in parallel
+    cfg = (svc.hybrid_config or {}).get("agent_workflows", {})
+    max_files = max(1, int(cfg.get("batch_validate_max_files", 10)))
+    paths = paths[:max_files]
+
+    tasks = [_validate_one(p, svc) for p in paths]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    pass_count = 0
+    fail_count = 0
+    skip_count = 0
+    lines = []
+    for fp, res in zip(paths, results):
+        if isinstance(res, Exception):
+            lines.append(f"? {fp} — ERROR: {res}")
+            skip_count += 1
+            continue
+        status_word, detail = res
+        if status_word == "PASS":
+            lines.append(f"\u2713 {fp} \u2014 {detail}")
+            pass_count += 1
+        elif status_word == "FAIL":
+            lines.append(f"\u2717 {fp} \u2014 {detail}")
+            fail_count += 1
+        else:
+            lines.append(f"? {fp} \u2014 {detail}")
+            skip_count += 1
+
+    body = "\n".join(lines)
+    summary = f"{len(paths)} files: {pass_count} pass, {fail_count} fail"
+    if skip_count:
+        summary += f", {skip_count} skip"
+    return finalize("c3_validate", {"file_path": file_path, "batch": True}, body, summary)
+
+
+async def _validate_one(file_path: str, svc) -> tuple:
+    """Validate a single file and return (status_word, detail_line)."""
+    full = Path(svc.project_path) / file_path
+    if not full.exists():
+        full = Path(file_path)
+    if not full.exists():
+        return ("SKIP", f"NOT_FOUND: {file_path}")
+
+    ext = full.suffix.lower()
+    lang = ext.lstrip('.').upper() if ext else 'unknown'
+    hybrid_cfg = svc.hybrid_config or {}
+    timeout_seconds = max(1, int(hybrid_cfg.get("validate_timeout_seconds", 35) or 35))
+
+    # Resolve relative path once (used for cache get/put)
+    try:
+        rel = str(full.resolve().relative_to(Path(svc.project_path).resolve()))
+    except Exception:
+        rel = file_path
+
+    # Try cached result first
+    vcache = getattr(svc, "validation_cache", None)
+    cached_hit = False
+    result = None
+    if vcache:
+        try:
+            cached = vcache.get(rel)
+            if cached is not None:
+                result = cached
+                cached_hit = True
+        except Exception:
+            pass
+
+    if not cached_hit:
+        try:
+            content = await asyncio.to_thread(full.read_text, encoding="utf-8", errors="replace")
+        except Exception as e:
+            return ("SKIP", f"READ_ERROR {lang}: {e}")
+
+        from services.parser import check_syntax_native_with_timeout
+
+        try:
+            result = await asyncio.to_thread(
+                check_syntax_native_with_timeout, content, ext, timeout_seconds,
+            )
+        except Exception:
+            result = {"status": "checker_failed", "checker": "native", "errors": [],
+                      "detail": "Validation failed unexpectedly."}
+
+        if vcache:
+            try:
+                st = os.stat(str(full))
+                vcache.put(rel, result, st.st_mtime, st.st_size)
+            except Exception:
+                pass
+
+    outcome = result.get("status", "checker_failed")
+    checker = result.get("checker", "native")
+    errors = result.get("errors", []) or []
+    detail_text = result.get("detail", "")
+    cache_tag = " [cached]" if cached_hit else ""
+
+    if outcome == "clean":
+        return ("PASS", f"PASS {lang}")
+    elif outcome == "syntax_error":
+        err_lines = "; ".join(f"L{e['line']}: {e['text']}" for e in errors[:3])
+        more = f" (+{len(errors) - 3} more)" if len(errors) > 3 else ""
+        return ("FAIL", f"FAIL {lang}: {err_lines}{more}")
+    elif outcome == "checker_unavailable":
+        return ("SKIP", f"SKIP {lang}: {checker} not found{cache_tag}")
+    elif outcome == "checker_timeout":
+        return ("SKIP", f"TIMEOUT {lang}: exceeded {timeout_seconds}s{cache_tag}")
+    elif outcome == "unsupported":
+        return ("SKIP", f"SKIP {lang}: unsupported type{cache_tag}")
+    else:
+        return ("SKIP", f"ERROR {lang}: {detail_text}{cache_tag}")
+
+
+async def _validate_single(file_path: str, svc, finalize) -> str:
+    """Original single-file validation path."""
+    full = Path(svc.project_path) / file_path
+    if not full.exists():
+        full = Path(file_path)
+    if not full.exists():
+        return f"Error: File not found: {file_path}"
+
+    ext = full.suffix.lower()
+    lang = ext.lstrip('.').upper() if ext else 'unknown'
+    hybrid_cfg = svc.hybrid_config or {}
+    timeout_seconds = max(1, int(hybrid_cfg.get("validate_timeout_seconds", 35) or 35))
+
+    # Try cached result first (populated by background watcher).
+    cached_hit = False
+    vcache = getattr(svc, "validation_cache", None)
+    if vcache:
+        try:
+            rel = str(full.resolve().relative_to(Path(svc.project_path).resolve()))
+            cached = vcache.get(rel)
+            if cached is not None:
+                result = cached
+                cached_hit = True
+        except Exception:
+            pass
+
+    if not cached_hit:
+        try:
+            content = await asyncio.to_thread(full.read_text, encoding="utf-8", errors="replace")
+        except Exception as e:
+            return f"Error: Could not read {file_path}: {e}"
+
+        from services.parser import check_syntax_native_with_timeout
+
+        try:
+            result = await asyncio.to_thread(
+                check_syntax_native_with_timeout, content, ext, timeout_seconds,
+            )
+        except Exception:
+            result = {"status": "checker_failed", "checker": "native", "errors": [],
+                      "detail": "Validation failed unexpectedly."}
+
+        # Store result in cache for future calls.
+        if vcache:
+            try:
+                rel = str(full.resolve().relative_to(Path(svc.project_path).resolve()))
+                st = os.stat(str(full))
+                vcache.put(rel, result, st.st_mtime, st.st_size)
+            except Exception:
+                pass
+
+    checker = result.get("checker", "native")
+    detail = result.get("detail", "")
+    errors = result.get("errors", []) or []
+    outcome = result.get("status", "checker_failed")
+
+    cache_tag = " [cached]" if cached_hit else ""
+
+    if outcome == "clean":
+        # LSP-inspired deep type check (advisory, never blocks PASS)
+        type_warns = await _deep_type_check(full, ext)
+        if type_warns:
+            status = f"PASS {lang} [type-warnings]\n" + "\n".join(type_warns)
+        else:
+            status = f"PASS {lang}"
+        summary = "pass"
+    elif outcome == "syntax_error":
+        status = f"FAIL {lang}:\n"
+        for err in errors[:10]:
+            status += f"- L{err['line']}, Col {err['column']}: {err['text']}\n"
+        if len(errors) > 10:
+            status += f"- ... and {len(errors) - 10} more errors.\n"
+        if detail:
+            status += f"[detail] {detail}"
+        summary = f"validated syntax_error via {checker}"
+    elif outcome == "checker_unavailable":
+        status = f"SKIP {lang}: {checker} not found on PATH — install it to enable validation. [checker:{checker}]"
+        if detail:
+            status += f"\n[detail] {detail}"
+        summary = f"validated checker_unavailable via {checker}"
+    elif outcome == "checker_timeout":
+        status = f"TIMEOUT {lang}: validation exceeded {timeout_seconds}s. [checker:{checker}]"
+        if detail:
+            status += f"\n[detail] {detail}"
+        summary = f"validated checker_timeout via {checker}"
+    elif outcome == "unsupported":
+        status = f"SKIP {lang}: unsupported file type for native validation. [checker:{checker}]"
+        if detail:
+            status += f"\n[detail] {detail}"
+        summary = f"validated unsupported via {checker}"
+    else:
+        status = f"ERROR {lang}: validator failed. [checker:{checker}]"
+        if detail:
+            status += f"\n[detail] {detail}"
+        summary = f"validated checker_failed via {checker}"
+
+    return finalize("c3_validate", {"file_path": file_path}, status, summary)

cli/ui/api.js

@@ -0,0 +1,36 @@
+// ─── API Client ───────────────────────────
+const API = window.location.origin;
+const parseApiResponse = async (r) => {
+  const ct = (r.headers.get('content-type') || '').toLowerCase();
+  let json = null;
+  let text = '';
+  if (ct.includes('application/json')) {
+    try { json = await r.json(); } catch { json = null; }
+  } else {
+    try { text = await r.text(); } catch { text = ''; }
+    if (text) {
+      try { json = JSON.parse(text); } catch { json = null; }
+    }
+  }
+  if (!r.ok) {
+    const msg = (json && (json.error || json.message)) || text || `HTTP ${r.status}`;
+    const err = new Error(msg);
+    err.status = r.status;
+    err.payload = json;
+    throw err;
+  }
+  if (json !== null) return json;
+  return {};
+};
+const api = {
+  get: async (path) => parseApiResponse(await fetch(`${API}${path}`)),
+  post: async (path, body) => parseApiResponse(await fetch(`${API}${path}`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })),
+  put: async (path, body) => parseApiResponse(await fetch(`${API}${path}`, {
+    method: 'PUT', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })),
+  del: async (path) => parseApiResponse(await fetch(`${API}${path}`, { method: 'DELETE' })),
+};

cli/ui/app.js

@@ -0,0 +1,207 @@
+// ─── Main App ─────────────────────────────
+const BUILD_TIME = "2026-04-10 UI-v2";
+const { useState, useEffect, useCallback, useRef } = React;
+
+const tabs = [
+  { id: "dashboard", label: "Dashboard", icon: "gauge" },
+  { id: "chat", label: "Chat", icon: "messageSquare" },
+  { id: "sessions", label: "Sessions", icon: "clock" },
+  { id: "memory", label: "Memory", icon: "bookmark" },
+  { id: "edits", label: "Edits", icon: "edit" },
+  { id: "instructions", label: "Instructions", icon: "fileText" },
+  { id: "settings", label: "Settings", icon: "settings" },
+];
+
+function App() {
+  const [tab, setTab] = useState("dashboard");
+  const [stats, setStats] = useState({});
+  const [connected, setConnected] = useState(false);
+  const [loading, setLoading] = useState(true);
+  const [health, setHealth] = useState(null);
+  const [healthChecking, setHealthChecking] = useState(false);
+  const [notifications, setNotifications] = useState([]);
+  const [registry, setRegistry] = useState([]);
+
+  // Sidebar state
+  const [sidebarPinned, setSidebarPinned] = useState(() => {
+    try { return localStorage.getItem("c3-sidebar-pinned") === "true"; } catch { return true; }
+  });
+  const [sidebarHover, setSidebarHover] = useState(false);
+  const sidebarOpen = sidebarPinned || sidebarHover;
+
+  const toggleSidebarPin = () => {
+    const next = !sidebarPinned;
+    setSidebarPinned(next);
+    try { localStorage.setItem("c3-sidebar-pinned", String(next)); } catch { }
+  };
+
+  // Theme toggle
+  const [darkMode, setDarkMode] = useState(true);
+  T = darkMode ? DARK : LIGHT;
+  // Sync data-theme for CSS-based theming (code blocks, markdown)
+  React.useEffect(() => {
+    document.body.dataset.theme = darkMode ? 'dark' : 'light';
+    const dEl = document.getElementById('hljs-theme-dark');
+    const lEl = document.getElementById('hljs-theme-light');
+    if (dEl) dEl.disabled = !darkMode;
+    if (lEl) lEl.disabled = darkMode;
+  }, [darkMode]);
+
+  // Data loading
+  const loadHealth = useCallback(async () => {
+    setHealthChecking(true);
+    try { const h = await api.get('/api/health'); setHealth(h); } catch { }
+    setHealthChecking(false);
+  }, []);
+
+  const loadNotifications = useCallback(async () => {
+    try { const n = await api.get('/api/notifications'); setNotifications(Array.isArray(n) ? n : []); } catch { }
+  }, []);
+
+  const loadRegistry = useCallback(async () => {
+    try { const r = await api.get('/api/registry'); setRegistry(Array.isArray(r) ? r : []); } catch { }
+  }, []);
+
+  const ackNotification = async (id) => {
+    try { await api.post('/api/notifications/ack', { id }); } catch { }
+    loadNotifications();
+  };
+
+  const ackAllNotifications = async () => {
+    try { await api.post('/api/notifications/ack-all'); } catch { }
+    setNotifications([]);
+  };
+
+  // Single consolidated poll
+  useEffect(() => {
+    const load = async () => {
+      try {
+        const [s] = await Promise.all([api.get('/api/stats')]);
+        setStats(s);
+        setConnected(true);
+      } catch { setConnected(false); }
+      setLoading(false);
+    };
+    load();
+    loadHealth();
+    loadNotifications();
+    loadRegistry();
+    const iv = setInterval(() => {
+      load();
+      loadNotifications();
+    }, 15000);
+    const hv = setInterval(loadHealth, 30000);
+    const rv = setInterval(loadRegistry, 30000);
+    return () => { clearInterval(iv); clearInterval(hv); clearInterval(rv); };
+  }, [loadNotifications, loadHealth, loadRegistry]);
+
+  const renderPanel = () => {
+    // Use display:none instead of unmounting to preserve state
+    return (
+      <>
+        <div style={{ display: tab === "dashboard" ? "block" : "none", height: "100%" }}>
+          <Dashboard stats={stats} loading={loading} notifications={notifications}
+            ackNotification={ackNotification} ackAllNotifications={ackAllNotifications} />
+        </div>
+        <div style={{ display: tab === "chat" ? "flex" : "none", height: "100%", flexDirection: "column" }}>
+          <ChatPanel />
+        </div>
+        <div style={{ display: tab === "sessions" ? "block" : "none", height: "100%" }}>
+          <SessionsPanel />
+        </div>
+        <div style={{ display: tab === "memory" ? "block" : "none", height: "100%" }}>
+          <Memory />
+        </div>
+        <div style={{ display: tab === "edits" ? "block" : "none", height: "100%" }}>
+          <EditsPanel />
+        </div>
+        <div style={{ display: tab === "instructions" ? "block" : "none", height: "100%" }}>
+          <Instructions />
+        </div>
+        <div style={{ display: tab === "settings" ? "block" : "none", height: "100%" }}>
+          <SettingsPanel stats={stats} />
+        </div>
+      </>
+    );
+  };
+
+  return (
+    <div style={{ display: "flex", height: "100vh", width: "100vw", background: T.bg, overflow: "hidden" }}>
+      <Sidebar
+        tab={tab} setTab={setTab} tabs={tabs}
+        sidebarOpen={sidebarOpen} sidebarPinned={sidebarPinned}
+        toggleSidebarPin={toggleSidebarPin} setSidebarHover={setSidebarHover}
+        connected={connected} health={health} healthChecking={healthChecking}
+        loadHealth={loadHealth} registry={registry}
+      />
+
+      {/* Main content */}
+      <div style={{ flex: 1, display: "flex", flexDirection: "column", overflow: "hidden" }}>
+        {/* Top bar */}
+        <div style={{
+          padding: "10px 20px", borderBottom: `1px solid ${T.border}`,
+          display: "flex", alignItems: "center", justifyContent: "space-between",
+          background: T.surface, flexShrink: 0
+        }}>
+          <div style={{ display: "flex", alignItems: "center", gap: 8 }}>
+            <I name={tabs.find(t => t.id === tab)?.icon || "gauge"} size={16} color={T.accent} />
+            <span style={{ fontSize: 14, fontWeight: 600, color: T.text }}>
+              {tabs.find(t => t.id === tab)?.label}
+            </span>
+          </div>
+          <div style={{ display: "flex", alignItems: "center", gap: 8 }}>
+            {notifications.length > 0 && (
+              <Badge color={T.warn}>{notifications.length} alerts</Badge>
+            )}
+            <button onClick={async () => {
+                try { const h = await api.get('/api/hub/info'); window.location.href = h.url; }
+                catch { window.location.href = 'http://localhost:3330'; }
+              }} title="Back to Projects Hub"
+              style={{
+                height: 28, padding: "0 10px", borderRadius: 6, border: `1px solid ${T.warn}40`,
+                background: `${T.warn}12`, color: T.warn, cursor: "pointer",
+                display: "flex", alignItems: "center", gap: 4, fontSize: 11,
+                fontFamily: "'JetBrains Mono', monospace", fontWeight: 600
+              }}>
+              Hub
+            </button>
+            <a href="/nano" title="Switch to Nano view"
+              style={{
+                height: 28, padding: "0 10px", borderRadius: 6, border: `1px solid ${T.accent}40`,
+                background: `${T.accent}12`, color: T.accent, textDecoration: "none",
+                display: "flex", alignItems: "center", gap: 4, fontSize: 11,
+                fontFamily: "'JetBrains Mono', monospace", fontWeight: 600
+              }}>
+              Nano
+            </a>
+            <a href="/edits" title="Edit Ledger — version timeline"
+              style={{
+                height: 28, padding: "0 10px", borderRadius: 6, border: `1px solid ${T.purple}40`,
+                background: `${T.purple}12`, color: T.purple, textDecoration: "none",
+                display: "flex", alignItems: "center", gap: 4, fontSize: 11,
+                fontFamily: "'JetBrains Mono', monospace", fontWeight: 600
+              }}>
+              Ledger
+            </a>
+            <button onClick={() => setDarkMode(!darkMode)} title="Toggle theme"
+              style={{
+                width: 28, height: 28, borderRadius: 6, border: `1px solid ${T.border}`,
+                background: "transparent", cursor: "pointer", display: "flex",
+                alignItems: "center", justifyContent: "center"
+              }}>
+              <I name={darkMode ? "sun" : "moon"} size={13} color={T.textMuted} />
+            </button>
+            <span className="mono" style={{ fontSize: 9, color: T.textDim }}>{BUILD_TIME}</span>
+          </div>
+        </div>
+
+        {/* Content area */}
+        <div style={{ flex: 1, overflow: "auto", padding: 20 }}>
+          {renderPanel()}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+ReactDOM.render(<App />, document.getElementById("root"));